1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
//! Process window events
use std::fs::File;
use std::io::Write;
use std::sync::{Arc, mpsc};
use serde_json as json;
use glutin;
use config::Config;
use display::OnResize;
use input;
use sync::FairMutex;
use term::{Term, SizeInfo};
use window::Window;
/// The event processor
pub struct Processor<N> {
notifier: N,
input_processor: input::Processor,
terminal: Arc<FairMutex<Term>>,
resize_tx: mpsc::Sender<(u32, u32)>,
ref_test: bool,
}
/// Notify that the terminal was resized
///
/// Currently this just forwards the notice to the input processor.
impl<N> OnResize for Processor<N> {
fn on_resize(&mut self, size: &SizeInfo) {
self.input_processor.resize(size);
}
}
impl<N: input::Notify> Processor<N> {
/// Create a new event processor
///
/// Takes a writer which is expected to be hooked up to the write end of a
/// pty.
pub fn new(
notifier: N,
terminal: Arc<FairMutex<Term>>,
resize_tx: mpsc::Sender<(u32, u32)>,
config: &Config,
ref_test: bool,
) -> Processor<N> {
let input_processor = {
let terminal = terminal.lock();
input::Processor::new(config, terminal.size_info())
};
Processor {
notifier: notifier,
terminal: terminal,
input_processor: input_processor,
resize_tx: resize_tx,
ref_test: ref_test,
}
}
fn handle_event(&mut self, event: glutin::Event, wakeup_request: &mut bool) {
match event {
glutin::Event::Closed => {
if self.ref_test {
// dump grid state
let terminal = self.terminal.lock();
let grid = terminal.grid();
let serialized_grid = json::to_string(&grid)
.expect("serialize grid");
let serialized_size = json::to_string(terminal.size_info())
.expect("serialize size");
File::create("./grid.json")
.and_then(|mut f| f.write_all(serialized_grid.as_bytes()))
.expect("write grid.json");
File::create("./size.json")
.and_then(|mut f| f.write_all(serialized_size.as_bytes()))
.expect("write size.json");
}
// FIXME
panic!("window closed");
},
glutin::Event::Resized(w, h) => {
self.resize_tx.send((w, h)).expect("send new size");
// Previously, this marked the terminal state as "dirty", but
// now the wakeup_request controls whether a display update is
// triggered.
*wakeup_request = true;
},
glutin::Event::KeyboardInput(state, _code, key, mods, string) => {
// Acquire term lock
let terminal = self.terminal.lock();
let processor = &mut self.input_processor;
let notifier = &mut self.notifier;
processor.process_key(state, key, mods, notifier, *terminal.mode(), string);
},
glutin::Event::MouseInput(state, button) => {
let terminal = self.terminal.lock();
let processor = &mut self.input_processor;
let notifier = &mut self.notifier;
processor.mouse_input(state, button, notifier, &terminal);
},
glutin::Event::MouseMoved(x, y) => {
if x > 0 && y > 0 {
self.input_processor.mouse_moved(x as u32, y as u32);
}
},
glutin::Event::Focused(true) => {
let mut terminal = self.terminal.lock();
terminal.dirty = true;
},
glutin::Event::MouseWheel(scroll_delta, touch_phase) => {
let terminal = self.terminal.lock();
let processor = &mut self.input_processor;
let notifier = &mut self.notifier;
processor.on_mouse_wheel(
notifier,
scroll_delta,
touch_phase,
&terminal
);
},
glutin::Event::Awakened => {
*wakeup_request = true;
},
_ => (),
}
}
/// Process at least one event and handle any additional queued events.
pub fn process_events(&mut self, window: &Window) -> bool {
let mut wakeup_request = false;
for event in window.wait_events() {
self.handle_event(event, &mut wakeup_request);
break;
}
for event in window.poll_events() {
self.handle_event(event, &mut wakeup_request);
}
wakeup_request
}
pub fn update_config(&mut self, config: &Config) {
self.input_processor.update_config(config);
}
}
|
