PolytreeDE
/
alacritty
mirror of https://github.com/alacritty/alacritty.git
1
0
Fork 0
Code Releases Activity
alacritty/src/input.rs

394 lines
15 KiB
Rust
Raw Normal View History

Add license headers to source files
2016-06-30 03:56:12 +00:00
// Copyright 2016 Joe Wilm, The Alacritty Project Contributors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
//! Handle input from glutin
//!
//! Certain key combinations should send some escape sequence back to the pty.
//! In order to figure that out, state about which modifier keys are pressed
//! needs to be tracked. Additionally, we need a bit of a state machine to
//! determine what to do when a non-modifier key is pressed.
//!
//! TODO would be nice to generalize this so it could work with other windowing
//! APIs
//!
//! TODO handling xmodmap would be good
Use evented I/O for the pty This was largely an experiment to see whether writing and reading from a separate thread was causing terminal state corruption as described in https://github.com/jwilm/alacritty/issues/9. Although this doesn't seem to fix that particular issue. Keeping this because it generally seems more correct than reading/writing from separate locations.
2016-09-24 23:11:50 +00:00
use std::borrow::Cow;
Move WriteNotifier type into input module It's a generic impl of `input::Notify` for `Write` types; as such, it seems completely reasonable to include in the input module. Moving it also serves to declutter main.
2016-07-02 15:32:28 +00:00
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
use glutin::{ElementState, VirtualKeyCode};
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
use glutin::{Mods, mods};
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
use term::mode::{self, TermMode};
Refactor EventLoop into event_loop module This type and its implementations were seriously cluttering main.rs.
2016-09-26 02:49:44 +00:00
use event_loop;
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
/// Processes input from glutin.
///
/// An escape sequence may be emitted in case specific keys or key combinations
/// are activated.
///
/// TODO also need terminal state when processing input
#[derive(Default)]
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
pub struct Processor;
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
/// Types that are notified of escape sequences from the input::Processor.
pub trait Notify {
/// Notify that an escape sequence should be written to the pty
Use evented I/O for the pty This was largely an experiment to see whether writing and reading from a separate thread was causing terminal state corruption as described in https://github.com/jwilm/alacritty/issues/9. Although this doesn't seem to fix that particular issue. Keeping this because it generally seems more correct than reading/writing from separate locations.
2016-09-24 23:11:50 +00:00
///
/// TODO this needs to be able to error somehow
fn notify<B: Into<Cow<'static, [u8]>>>(&mut self, B);
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
}
Refactor EventLoop into event_loop module This type and its implementations were seriously cluttering main.rs.
2016-09-26 02:49:44 +00:00
pub struct LoopNotifier(pub ::mio::channel::Sender<event_loop::Msg>);
Use evented I/O for the pty This was largely an experiment to see whether writing and reading from a separate thread was causing terminal state corruption as described in https://github.com/jwilm/alacritty/issues/9. Although this doesn't seem to fix that particular issue. Keeping this because it generally seems more correct than reading/writing from separate locations.
2016-09-24 23:11:50 +00:00
impl Notify for LoopNotifier {
fn notify<B>(&mut self, bytes: B)
where B: Into<Cow<'static, [u8]>>
{
let bytes = bytes.into();
Refactor EventLoop into event_loop module This type and its implementations were seriously cluttering main.rs.
2016-09-26 02:49:44 +00:00
match self.0.send(event_loop::Msg::Input(bytes)) {
Use evented I/O for the pty This was largely an experiment to see whether writing and reading from a separate thread was causing terminal state corruption as described in https://github.com/jwilm/alacritty/issues/9. Although this doesn't seem to fix that particular issue. Keeping this because it generally seems more correct than reading/writing from separate locations.
2016-09-24 23:11:50 +00:00
Ok(_) => (),
Err(_) => panic!("expected send event loop msg"),
}
Move WriteNotifier type into input module It's a generic impl of `input::Notify` for `Write` types; as such, it seems completely reasonable to include in the input module. Moving it also serves to declutter main.
2016-07-02 15:32:28 +00:00
}
}
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
/// Describes a key combination that should emit a control sequence
///
/// The actual triggering key is omitted here since bindings are grouped by the trigger key.
#[derive(Debug)]
pub struct Binding {
/// Modifier keys required to activate binding
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
mods: Mods,
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
/// String to send to pty if mods and mode match
send: &'static str,
/// Terminal mode required to activate binding
mode: TermMode,
/// excluded terminal modes where the binding won't be activated
notmode: TermMode,
}
/// Bindings for the LEFT key.
static LEFT_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::SHIFT, send: "\x1b[1;2D", mode: mode::ANY, notmode: mode::NONE },
Binding { mods: mods::CONTROL, send: "\x1b[1;5D", mode: mode::ANY, notmode: mode::NONE },
Binding { mods: mods::ALT, send: "\x1b[1;3D", mode: mode::ANY, notmode: mode::NONE },
Binding { mods: mods::ANY, send: "\x1b[D", mode: mode::ANY, notmode: mode::APP_CURSOR },
Binding { mods: mods::ANY, send: "\x1bOD", mode: mode::APP_CURSOR, notmode: mode::NONE },
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
];
/// Bindings for the RIGHT key
static RIGHT_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::SHIFT, send: "\x1b[1;2C", mode: mode::ANY, notmode: mode::NONE },
Binding { mods: mods::CONTROL, send: "\x1b[1;5C", mode: mode::ANY, notmode: mode::NONE },
Binding { mods: mods::ALT, send: "\x1b[1;3C", mode: mode::ANY, notmode: mode::NONE },
Binding { mods: mods::ANY, send: "\x1b[C", mode: mode::ANY, notmode: mode::APP_CURSOR },
Binding { mods: mods::ANY, send: "\x1bOC", mode: mode::APP_CURSOR, notmode: mode::NONE },
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
];
/// Bindings for the UP key
static UP_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::SHIFT, send: "\x1b[1;2A", mode: mode::ANY, notmode: mode::NONE },
Binding { mods: mods::CONTROL, send: "\x1b[1;5A", mode: mode::ANY, notmode: mode::NONE },
Binding { mods: mods::ALT, send: "\x1b[1;3A", mode: mode::ANY, notmode: mode::NONE },
Binding { mods: mods::ANY, send: "\x1b[A", mode: mode::ANY, notmode: mode::APP_CURSOR },
Binding { mods: mods::ANY, send: "\x1bOA", mode: mode::APP_CURSOR, notmode: mode::NONE },
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
];
/// Bindings for the DOWN key
static DOWN_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::SHIFT, send: "\x1b[1;2B", mode: mode::ANY, notmode: mode::NONE },
Binding { mods: mods::CONTROL, send: "\x1b[1;5B", mode: mode::ANY, notmode: mode::NONE },
Binding { mods: mods::ALT, send: "\x1b[1;3B", mode: mode::ANY, notmode: mode::NONE },
Binding { mods: mods::ANY, send: "\x1b[B", mode: mode::ANY, notmode: mode::APP_CURSOR },
Binding { mods: mods::ANY, send: "\x1bOB", mode: mode::APP_CURSOR, notmode: mode::NONE },
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
];
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
/// Bindings for the F1 key
static F1_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1bOP", mode: mode::ANY, notmode: mode::NONE },
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
];
/// Bindings for the F2 key
static F2_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1bOQ", mode: mode::ANY, notmode: mode::NONE },
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
];
/// Bindings for the F3 key
static F3_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1bOR", mode: mode::ANY, notmode: mode::NONE },
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
];
/// Bindings for the F4 key
static F4_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1bOS", mode: mode::ANY, notmode: mode::NONE },
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
];
/// Bindings for the F5 key
static F5_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1b[15~", mode: mode::ANY, notmode: mode::NONE },
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
];
/// Bindings for the F6 key
static F6_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1b[17~", mode: mode::ANY, notmode: mode::NONE },
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
];
/// Bindings for the F7 key
static F7_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1b[18~", mode: mode::ANY, notmode: mode::NONE },
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
];
/// Bindings for the F8 key
static F8_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1b[19~", mode: mode::ANY, notmode: mode::NONE },
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
];
/// Bindings for the F9 key
static F9_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1b[20~", mode: mode::ANY, notmode: mode::NONE },
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
];
/// Bindings for the F10 key
static F10_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1b[21~", mode: mode::ANY, notmode: mode::NONE },
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
];
/// Bindings for the F11 key
static F11_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1b[23~", mode: mode::ANY, notmode: mode::NONE },
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
];
/// Bindings for the F11 key
static F12_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1b[24~", mode: mode::ANY, notmode: mode::NONE },
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
];
Fix Control-H bug Glutin sends both a received character and the key pressed event when a key is pressed. Because delete and backspace are mapped in reverse by terminal standards, we ignore the received character 0x07 and 0x7f values. However, this breaks Control-H since this normally sends 0x07 as well. The fix here adds handling for Control-H through the input tracking system.
2016-07-16 19:25:57 +00:00
/// Bindings for the H key
///
/// Control-H sends 0x08 normally, but we capture that in ReceivedCharacter
/// since DEL and BACKSPACE are inverted. This binding is a work around to that
/// capture.
static H_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::CONTROL, send: "\x08", mode: mode::ANY, notmode: mode::NONE },
Fix Control-H bug Glutin sends both a received character and the key pressed event when a key is pressed. Because delete and backspace are mapped in reverse by terminal standards, we ignore the received character 0x07 and 0x7f values. However, this breaks Control-H since this normally sends 0x07 as well. The fix here adds handling for Control-H through the input tracking system.
2016-07-16 19:25:57 +00:00
];
Correctly handle Backspace and Delete The default characters sent for this were incorrect. Delete now sends xterm-compatible escapes (dch1, kdch1), and Backspace sends the delete code 0x7f.
2016-07-04 16:24:51 +00:00
/// Bindings for the Backspace key
static BACKSPACE_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x7f", mode: mode::ANY, notmode: mode::NONE },
Correctly handle Backspace and Delete The default characters sent for this were incorrect. Delete now sends xterm-compatible escapes (dch1, kdch1), and Backspace sends the delete code 0x7f.
2016-07-04 16:24:51 +00:00
];
/// Bindings for the Delete key
static DELETE_BINDINGS: &'static [Binding] = &[
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
Binding { mods: mods::ANY, send: "\x1b[3~", mode: mode::APP_KEYPAD, notmode: mode::NONE },
Binding { mods: mods::ANY, send: "\x1b[P", mode: mode::ANY, notmode: mode::APP_KEYPAD },
Correctly handle Backspace and Delete The default characters sent for this were incorrect. Delete now sends xterm-compatible escapes (dch1, kdch1), and Backspace sends the delete code 0x7f.
2016-07-04 16:24:51 +00:00
];
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
// key mods escape appkey appcursor crlf
//
// notes: appkey = DECPAM (application keypad mode); not enabled is "normal keypad"
// appcursor = DECCKM (application cursor mode);
// crlf = LNM (Linefeed/new line); wtf is this
impl Processor {
pub fn new() -> Processor {
Default::default()
}
pub fn process<N>(&mut self,
state: ElementState,
key: Option<VirtualKeyCode>,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
mods: Mods,
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
notifier: &mut N,
mode: TermMode)
where N: Notify
{
if let Some(key) = key {
// Ignore release events
if state == ElementState::Released {
return;
}
let bindings = match key {
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
// Arrows
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
VirtualKeyCode::Left => LEFT_BINDINGS,
VirtualKeyCode::Up => UP_BINDINGS,
VirtualKeyCode::Down => DOWN_BINDINGS,
VirtualKeyCode::Right => RIGHT_BINDINGS,
Function keys send escape sequences This doesn't currently handle any of the modifiers, but it does mean applications like `htop` can be used.
2016-06-24 04:24:08 +00:00
// Function keys
VirtualKeyCode::F1 => F1_BINDINGS,
VirtualKeyCode::F2 => F2_BINDINGS,
VirtualKeyCode::F3 => F3_BINDINGS,
VirtualKeyCode::F4 => F4_BINDINGS,
VirtualKeyCode::F5 => F5_BINDINGS,
VirtualKeyCode::F6 => F6_BINDINGS,
VirtualKeyCode::F7 => F7_BINDINGS,
VirtualKeyCode::F8 => F8_BINDINGS,
VirtualKeyCode::F9 => F9_BINDINGS,
VirtualKeyCode::F10 => F10_BINDINGS,
VirtualKeyCode::F11 => F11_BINDINGS,
VirtualKeyCode::F12 => F12_BINDINGS,
Correctly handle Backspace and Delete The default characters sent for this were incorrect. Delete now sends xterm-compatible escapes (dch1, kdch1), and Backspace sends the delete code 0x7f.
2016-07-04 16:24:51 +00:00
VirtualKeyCode::Back => BACKSPACE_BINDINGS,
VirtualKeyCode::Delete => DELETE_BINDINGS,
Fix Control-H bug Glutin sends both a received character and the key pressed event when a key is pressed. Because delete and backspace are mapped in reverse by terminal standards, we ignore the received character 0x07 and 0x7f values. However, this breaks Control-H since this normally sends 0x07 as well. The fix here adds handling for Control-H through the input tracking system.
2016-07-16 19:25:57 +00:00
VirtualKeyCode::H => H_BINDINGS,
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
// Mode keys ignored now
VirtualKeyCode::LAlt | VirtualKeyCode::RAlt | VirtualKeyCode::LShift |
VirtualKeyCode::RShift | VirtualKeyCode::LControl | VirtualKeyCode::RControl |
VirtualKeyCode::LWin | VirtualKeyCode::RWin => return,
// All of the alphanumeric keys get passed through here as well, but there's no work
// to be done for them.
VirtualKeyCode::A | VirtualKeyCode::B | VirtualKeyCode::C | VirtualKeyCode::D |
Fix Control-H bug Glutin sends both a received character and the key pressed event when a key is pressed. Because delete and backspace are mapped in reverse by terminal standards, we ignore the received character 0x07 and 0x7f values. However, this breaks Control-H since this normally sends 0x07 as well. The fix here adds handling for Control-H through the input tracking system.
2016-07-16 19:25:57 +00:00
VirtualKeyCode::E | VirtualKeyCode::F | VirtualKeyCode::G |
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
VirtualKeyCode::I | VirtualKeyCode::J | VirtualKeyCode::K | VirtualKeyCode::L |
VirtualKeyCode::M | VirtualKeyCode::N | VirtualKeyCode::O | VirtualKeyCode::P |
VirtualKeyCode::Q | VirtualKeyCode::R | VirtualKeyCode::S | VirtualKeyCode::T |
VirtualKeyCode::U | VirtualKeyCode::V | VirtualKeyCode::W | VirtualKeyCode::X |
VirtualKeyCode::Y | VirtualKeyCode::Z => return,
VirtualKeyCode::Key1 | VirtualKeyCode::Key2 | VirtualKeyCode::Key3 |
VirtualKeyCode::Key4 | VirtualKeyCode::Key5 | VirtualKeyCode::Key6 |
VirtualKeyCode::Key7 | VirtualKeyCode::Key8 | VirtualKeyCode::Key9 |
VirtualKeyCode::Key0 => return,
// Log something by default
_ => {
println!("Unhandled key: {:?}; state: {:?}; mods: {:?}",
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
key, state, mods);
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
return;
},
};
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
self.process_bindings(bindings, mode, notifier, mods);
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
}
}
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
fn process_bindings<N>(&self,
bindings: &[Binding],
mode: TermMode,
notifier: &mut N,
mods: Mods)
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
where N: Notify
{
// Check each binding
for binding in bindings {
// TermMode positive
if binding.mode.is_all() || mode.intersects(binding.mode) {
// TermMode negative
if binding.notmode.is_empty() || !mode.intersects(binding.notmode) {
// Modifier keys
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
if binding.mods.is_all() || mods.intersects(binding.mods) {
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
// everything matches
Use evented I/O for the pty This was largely an experiment to see whether writing and reading from a separate thread was causing terminal state corruption as described in https://github.com/jwilm/alacritty/issues/9. Although this doesn't seem to fix that particular issue. Keeping this because it generally seems more correct than reading/writing from separate locations.
2016-09-24 23:11:50 +00:00
notifier.notify(binding.send.as_bytes());
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
break;
}
}
}
}
}
}
#[cfg(test)]
mod tests {
use term::mode::{self, TermMode};
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
use glutin::mods;
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
use super::Processor;
use super::Binding;
/// Receiver that keeps a copy of any strings it is notified with
#[derive(Default)]
struct Receiver {
pub got: Option<String>
}
impl super::Notify for Receiver {
fn notify(&mut self, s: &str) {
self.got = Some(String::from(s));
}
}
macro_rules! test_process_binding {
{
name: $name:ident,
binding: $binding:expr,
expect: $expect:expr,
mode: $mode:expr,
mods: $mods:expr
} => {
#[test]
fn $name() {
let bindings = &[$binding];
Fix tests Errors/warnings fixed.
2016-08-15 03:25:15 +00:00
let processor = Processor::new();
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
let mut receiver = Receiver::default();
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
processor.process_bindings(bindings, $mode, &mut receiver, $mods);
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
assert_eq!(receiver.got, $expect);
}
}
}
test_process_binding! {
name: process_binding_nomode_shiftmod_require_shift,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
binding: Binding { mods: mods::SHIFT, send: "\x1b[1;2D", mode: mode::ANY, notmode: mode::NONE },
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
expect: Some(String::from("\x1b[1;2D")),
mode: mode::NONE,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
mods: mods::SHIFT
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
}
test_process_binding! {
name: process_binding_nomode_nomod_require_shift,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
binding: Binding { mods: mods::SHIFT, send: "\x1b[1;2D", mode: mode::ANY, notmode: mode::NONE },
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
expect: None,
mode: mode::NONE,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
mods: mods::NONE
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
}
test_process_binding! {
name: process_binding_nomode_controlmod,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
binding: Binding { mods: mods::CONTROL, send: "\x1b[1;5D", mode: mode::ANY, notmode: mode::NONE },
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
expect: Some(String::from("\x1b[1;5D")),
mode: mode::NONE,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
mods: mods::CONTROL
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
}
test_process_binding! {
name: process_binding_nomode_nomod_require_not_appcursor,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
binding: Binding { mods: mods::ANY, send: "\x1b[D", mode: mode::ANY, notmode: mode::APP_CURSOR },
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
expect: Some(String::from("\x1b[D")),
mode: mode::NONE,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
mods: mods::NONE
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
}
test_process_binding! {
name: process_binding_appcursormode_nomod_require_appcursor,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
binding: Binding { mods: mods::ANY, send: "\x1bOD", mode: mode::APP_CURSOR, notmode: mode::NONE },
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
expect: Some(String::from("\x1bOD")),
mode: mode::APP_CURSOR,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
mods: mods::NONE
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
}
test_process_binding! {
name: process_binding_nomode_nomod_require_appcursor,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
binding: Binding { mods: mods::ANY, send: "\x1bOD", mode: mode::APP_CURSOR, notmode: mode::NONE },
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
expect: None,
mode: mode::NONE,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
mods: mods::NONE
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
}
Add test for input Added a test while debugging arrow keys, no reason to delete it.
2016-07-30 01:27:45 +00:00
test_process_binding! {
name: process_binding_appcursormode_appkeypadmode_nomod_require_appcursor,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
binding: Binding { mods: mods::ANY, send: "\x1bOD", mode: mode::APP_CURSOR, notmode: mode::NONE },
Add test for input Added a test while debugging arrow keys, no reason to delete it.
2016-07-30 01:27:45 +00:00
expect: Some(String::from("\x1bOD")),
mode: mode::APP_CURSOR | mode::APP_KEYPAD,
Input expects modifier keys from Glutin This is experimental on a separate branch of Glutin. It's intended to fix the problem of certain key events not being delivered on alt-tab and breaking the modifier state tracking.
2016-07-30 19:47:22 +00:00
mods: mods::NONE
Add test for input Added a test while debugging arrow keys, no reason to delete it.
2016-07-30 01:27:45 +00:00
}
Implement special input handling There's a number of keys/combinations that should emit escape sequences to the PTY when triggered. This commit adds a framework to support that. The input::Processor is a type which tracks state of modifier keys. When special keys (like arrow, function) are detected, the processor pulls up a list of candidate escapes to send, and picks the first one based on terminal mode and active modifier keys. The input::Processor is generic over the thing receiving the escape sequences, the input::Notify type. Included is a wrapper for `&mut io::Write` which implements input::Notify and is currently used to connect the processor to the PTY stream. This added handling of the APP_CURSOR mode which changes affects input processing.
2016-06-23 16:48:31 +00:00
}