inkreas.ing
old school music tracker
better event pushing
+20
-10
src/app.rs
+20
-10
src/app.rs
···
157
157
}
158
158
}
159
159
160
+
pub struct EventQueue<'a>(&'a mut VecDeque<GlobalEvent>);
161
+
162
+
impl EventQueue<'_> {
163
+
pub fn push(&mut self, event: GlobalEvent) {
164
+
self.0.push_back(event);
165
+
}
166
+
}
167
+
160
168
pub struct App {
161
169
window_gpu: Option<(Arc<Window>, RenderBackend)>,
162
170
draw_buffer: DrawBuffer,
···
255
263
let (window, render_backend) = window_gpu.as_mut().unwrap();
256
264
// don't want the window to be mut
257
265
let window = window.as_ref();
266
+
// limit the pages and widgets to only push events and not read or pop
267
+
let event_queue = &mut EventQueue(event_queue);
258
268
259
269
match event {
260
270
WindowEvent::CloseRequested => Self::close_requested(event_queue),
···
326
336
} else {
327
337
if event.state.is_pressed() && event.logical_key == Key::Named(NamedKey::Escape)
328
338
{
329
-
event_queue.push_back(GlobalEvent::OpenDialog(Box::new(|| {
339
+
event_queue.push(GlobalEvent::OpenDialog(Box::new(|| {
330
340
Box::new(PageMenu::main())
331
341
})));
332
342
}
···
350
360
351
361
/// i may need to add the ability for events to add events to the event queue, but that should be possible
352
362
fn user_event(&mut self, event_loop: &ActiveEventLoop, event: GlobalEvent) {
363
+
let event_queue = &mut EventQueue(&mut self.event_queue);
353
364
match event {
354
365
GlobalEvent::OpenDialog(dialog) => {
355
366
self.dialog_manager.open_dialog(dialog());
356
367
_ = self.try_request_redraw();
357
368
}
358
-
GlobalEvent::Page(c) => {
359
-
match self.ui_pages.process_page_event(c, &mut self.event_queue) {
360
-
PageResponse::RequestRedraw => _ = self.try_request_redraw(),
361
-
PageResponse::None => (),
362
-
}
363
-
}
369
+
GlobalEvent::Page(c) => match self.ui_pages.process_page_event(c, event_queue) {
370
+
PageResponse::RequestRedraw => _ = self.try_request_redraw(),
371
+
PageResponse::None => (),
372
+
},
364
373
GlobalEvent::Header(header_event) => {
365
374
self.header.process_event(header_event);
366
375
_ = self.try_request_redraw();
···
371
380
_ = self.try_request_redraw();
372
381
}
373
382
GlobalEvent::CloseApp => event_loop.exit(),
374
-
GlobalEvent::CloseRequested => Self::close_requested(&mut self.event_queue),
383
+
GlobalEvent::CloseRequested => Self::close_requested(event_queue),
375
384
GlobalEvent::ConstRedraw => {
376
385
self.ui_pages.request_draw_const();
377
386
_ = self.try_request_redraw();
···
433
442
}
434
443
}
435
444
436
-
fn close_requested(events: &mut VecDeque<GlobalEvent>) {
437
-
events.push_back(GlobalEvent::OpenDialog(Box::new(|| {
445
+
// TODO: should this be its own function?? or is there something better
446
+
fn close_requested(events: &mut EventQueue<'_>) {
447
+
events.push(GlobalEvent::OpenDialog(Box::new(|| {
438
448
Box::new(ConfirmDialog::new(
439
449
"Close Torque Tracker?",
440
450
|| Some(GlobalEvent::CloseApp),
+2
-4
src/ui/dialog.rs
+2
-4
src/ui/dialog.rs
···
2
2
pub mod page_menu;
3
3
pub mod slider_dialog;
4
4
5
-
use std::collections::VecDeque;
6
-
7
5
use winit::event::{KeyEvent, Modifiers};
8
6
9
-
use crate::{app::GlobalEvent, draw_buffer::DrawBuffer};
7
+
use crate::{app::EventQueue, draw_buffer::DrawBuffer};
10
8
11
9
pub enum DialogResponse {
12
10
RequestRedraw,
···
24
22
&mut self,
25
23
key_event: &KeyEvent,
26
24
modifiers: &Modifiers,
27
-
events: &mut VecDeque<GlobalEvent>,
25
+
events: &mut EventQueue<'_>,
28
26
) -> DialogResponse;
29
27
}
30
28
+2
-2
src/ui/dialog/confirm.rs
+2
-2
src/ui/dialog/confirm.rs
···
86
86
&mut self,
87
87
key_event: &winit::event::KeyEvent,
88
88
modifiers: &winit::event::Modifiers,
89
-
events: &mut std::collections::VecDeque<GlobalEvent>,
89
+
events: &mut crate::app::EventQueue<'_>,
90
90
) -> DialogResponse {
91
91
if key_event.logical_key == Key::Named(NamedKey::Escape) && modifiers.state().is_empty() {
92
92
return DialogResponse::Close;
···
96
96
self.widgets.process_input(key_event, modifiers, events);
97
97
if let Some(global_option) = extra {
98
98
if let Some(global) = global_option {
99
-
events.push_back(global);
99
+
events.push(global);
100
100
}
101
101
// if there is a response i also want to close myself
102
102
return DialogResponse::Close;
+4
-4
src/ui/dialog/slider_dialog.rs
+4
-4
src/ui/dialog/slider_dialog.rs
···
1
-
use std::{collections::VecDeque, ops::RangeInclusive};
1
+
use std::ops::RangeInclusive;
2
2
3
3
use winit::{
4
4
event::{KeyEvent, Modifiers},
···
6
6
};
7
7
8
8
use crate::{
9
-
app::GlobalEvent,
9
+
app::{EventQueue, GlobalEvent},
10
10
coordinates::{CharPosition, CharRect},
11
11
draw_buffer::DrawBuffer,
12
12
ui::widgets::{NextWidget, StandardResponse, Widget, text_in::TextIn},
···
33
33
&mut self,
34
34
key_event: &KeyEvent,
35
35
modifiers: &Modifiers,
36
-
events: &mut VecDeque<GlobalEvent>,
36
+
events: &mut EventQueue<'_>,
37
37
) -> DialogResponse {
38
38
if key_event.state.is_pressed() {
39
39
if key_event.logical_key == Key::Named(NamedKey::Escape) {
···
42
42
if let Ok(num) = self.text.get_str().parse::<i16>()
43
43
&& self.range.contains(&num)
44
44
{
45
-
events.push_back((self.return_event)(num));
45
+
events.push((self.return_event)(num));
46
46
}
47
47
return DialogResponse::Close;
48
48
}
+6
-7
src/ui/pages.rs
+6
-7
src/ui/pages.rs
···
4
4
mod sample_list;
5
5
mod song_directory_config_page;
6
6
7
-
use std::collections::VecDeque;
8
-
9
7
use help_page::HelpPage;
10
8
use order_list::{OrderListPage, OrderListPageEvent};
11
9
use pattern::{PatternPage, PatternPageEvent};
···
18
16
};
19
17
20
18
use crate::{
21
-
app::GlobalEvent,
19
+
app::{EventQueue, GlobalEvent},
22
20
coordinates::{CharPosition, CharRect, WINDOW_SIZE_CHARS},
23
21
draw_buffer::DrawBuffer,
24
22
ui::pages::sample_list::SampleListEvent,
···
32
30
&mut self,
33
31
modifiers: &Modifiers,
34
32
key_event: &KeyEvent,
35
-
events: &mut VecDeque<GlobalEvent>,
33
+
// please give me reborrowing for custom structs rustc :3
34
+
events: &mut EventQueue<'_>,
36
35
) -> PageResponse;
37
36
}
38
37
···
82
81
&mut self,
83
82
key_event: &winit::event::KeyEvent,
84
83
modifiers: &winit::event::Modifiers,
85
-
events: &mut std::collections::VecDeque<crate::app::GlobalEvent>,
84
+
events: &mut crate::app::EventQueue<'_>,
86
85
) -> WidgetResponse<$response> {
87
86
self.get_widget_mut(self.selected).process_input(modifiers, key_event, events)
88
87
}
···
255
254
&mut self,
256
255
modifiers: &Modifiers,
257
256
key_event: &KeyEvent,
258
-
events: &mut VecDeque<GlobalEvent>,
257
+
events: &mut EventQueue<'_>,
259
258
) -> PageResponse {
260
259
if key_event.state.is_pressed() && modifiers.state().is_empty() {
261
260
if key_event.logical_key == Key::Named(NamedKey::F1) {
···
289
288
pub fn process_page_event(
290
289
&mut self,
291
290
event: PageEvent,
292
-
events: &mut VecDeque<GlobalEvent>,
291
+
events: &mut EventQueue<'_>,
293
292
) -> PageResponse {
294
293
let page = event.get_page();
295
294
let response = match event {
+2
-4
src/ui/pages/help_page.rs
+2
-4
src/ui/pages/help_page.rs
···
1
-
use std::collections::VecDeque;
2
-
3
-
use crate::{app::GlobalEvent, coordinates::CharRect, draw_buffer::DrawBuffer};
1
+
use crate::{app::EventQueue, coordinates::CharRect, draw_buffer::DrawBuffer};
4
2
5
3
use super::{Page, PageResponse};
6
4
···
17
15
&mut self,
18
16
_modifiers: &winit::event::Modifiers,
19
17
_key_event: &winit::event::KeyEvent,
20
-
_events: &mut VecDeque<GlobalEvent>,
18
+
_events: &mut EventQueue<'_>,
21
19
) -> PageResponse {
22
20
PageResponse::None
23
21
}
+8
-13
src/ui/pages/order_list.rs
+8
-13
src/ui/pages/order_list.rs
···
1
-
use std::collections::VecDeque;
2
1
use std::str::from_utf8;
3
2
use std::{array, io::Write};
4
3
···
7
6
use torque_tracker_engine::{file::impulse_format::header::PatternOrder, project::song::Song};
8
7
use winit::keyboard::{Key, ModifiersState, NamedKey};
9
8
10
-
use crate::app::{GlobalEvent, send_song_op};
9
+
use crate::app::{EventQueue, GlobalEvent, send_song_op};
11
10
use crate::ui::header::HeaderEvent;
12
11
use crate::ui::widgets::{NextWidget, StandardResponse, Widget};
13
12
use crate::{
···
160
159
self.mode
161
160
}
162
161
163
-
fn send_order_position(&self, events: &mut VecDeque<GlobalEvent>) {
164
-
events.push_back(GlobalEvent::Header(HeaderEvent::SetOrder(
162
+
fn send_order_position(&self, events: &mut EventQueue<'_>) {
163
+
events.push(GlobalEvent::Header(HeaderEvent::SetOrder(
165
164
self.order_cursor.order,
166
165
)));
167
166
}
168
167
169
-
fn send_order_len(&self, events: &mut VecDeque<GlobalEvent>) {
168
+
fn send_order_len(&self, events: &mut EventQueue<'_>) {
170
169
let order_len = self
171
170
.pattern_order
172
171
.iter()
173
172
.take_while(|o| **o != PatternOrder::EndOfSong)
174
173
.count();
175
-
events.push_back(GlobalEvent::Header(HeaderEvent::SetOrderLen(
174
+
events.push(GlobalEvent::Header(HeaderEvent::SetOrderLen(
176
175
u16::try_from(order_len).unwrap(),
177
176
)));
178
177
}
179
178
180
-
fn order_cursor_up(&mut self, count: u16, events: &mut VecDeque<GlobalEvent>) -> PageResponse {
179
+
fn order_cursor_up(&mut self, count: u16, events: &mut EventQueue<'_>) -> PageResponse {
181
180
debug_assert!(count != 0, "why would you do this");
182
181
if self.order_cursor.order == 0 {
183
182
return PageResponse::None;
···
189
188
PageResponse::RequestRedraw
190
189
}
191
190
192
-
fn order_cursor_down(
193
-
&mut self,
194
-
count: u16,
195
-
events: &mut VecDeque<GlobalEvent>,
196
-
) -> PageResponse {
191
+
fn order_cursor_down(&mut self, count: u16, events: &mut EventQueue<'_>) -> PageResponse {
197
192
debug_assert!(count != 0, "why would you do this");
198
193
if self.order_cursor.order == 255 {
199
194
return PageResponse::None;
···
369
364
&mut self,
370
365
modifiers: &winit::event::Modifiers,
371
366
key_event: &winit::event::KeyEvent,
372
-
events: &mut std::collections::VecDeque<crate::app::GlobalEvent>,
367
+
events: &mut EventQueue<'_>,
373
368
) -> PageResponse {
374
369
match self.cursor {
375
370
Cursor::Order => {
+11
-15
src/ui/pages/pattern.rs
+11
-15
src/ui/pages/pattern.rs
···
1
-
use std::{collections::VecDeque, io::Write, str::from_utf8};
1
+
use std::{io::Write, str::from_utf8};
2
2
3
3
use torque_tracker_engine::project::{
4
4
event_command::NoteCommand,
···
12
12
};
13
13
14
14
use crate::{
15
-
app::{EXECUTOR, GlobalEvent, SONG_MANAGER, send_song_op},
15
+
app::{EXECUTOR, EventQueue, GlobalEvent, SONG_MANAGER, send_song_op},
16
16
coordinates::{CharPosition, CharRect},
17
17
ui::header::HeaderEvent,
18
18
};
···
143
143
pub fn process_event(
144
144
&mut self,
145
145
event: PatternPageEvent,
146
-
events: &mut VecDeque<GlobalEvent>,
146
+
events: &mut EventQueue<'_>,
147
147
) -> PageResponse {
148
148
match event {
149
149
PatternPageEvent::Loaded(pattern, idx) => {
150
150
self.pattern = pattern;
151
151
self.pattern_index = idx;
152
-
events.push_back(GlobalEvent::Header(HeaderEvent::SetPattern(idx)));
153
-
events.push_back(GlobalEvent::Header(HeaderEvent::SetMaxCursorRow(
152
+
events.push(GlobalEvent::Header(HeaderEvent::SetPattern(idx)));
153
+
events.push(GlobalEvent::Header(HeaderEvent::SetMaxCursorRow(
154
154
self.pattern.row_count(),
155
155
)));
156
156
PageResponse::RequestRedraw
···
183
183
}
184
184
185
185
/// returns true if the position was changed
186
-
fn set_cursor(
187
-
&mut self,
188
-
mut pos: InPatternPosition,
189
-
events: &mut VecDeque<GlobalEvent>,
190
-
) -> bool {
186
+
fn set_cursor(&mut self, mut pos: InPatternPosition, events: &mut EventQueue<'_>) -> bool {
191
187
if pos.row >= self.pattern.row_count() {
192
188
pos.row = self.pattern.row_count() - 1;
193
189
}
···
200
196
}
201
197
202
198
if pos.row != self.cursor_position.0.row {
203
-
events.push_back(GlobalEvent::Header(HeaderEvent::SetCursorRow(pos.row)));
199
+
events.push(GlobalEvent::Header(HeaderEvent::SetCursorRow(pos.row)));
204
200
}
205
201
206
202
self.cursor_position.0 = pos;
···
224
220
}
225
221
226
222
/// returns true if the cursor was changed
227
-
fn cursor_next_row(&mut self, events: &mut VecDeque<GlobalEvent>) -> bool {
223
+
fn cursor_next_row(&mut self, events: &mut EventQueue<'_>) -> bool {
228
224
let mut pos = self.cursor_position.0;
229
225
pos.row = pos.row.saturating_add(1);
230
226
self.set_cursor(pos, events)
···
264
260
send_song_op(op);
265
261
}
266
262
267
-
pub fn set_sample(&mut self, sample: u8, events: &mut VecDeque<GlobalEvent>) {
263
+
pub fn set_sample(&mut self, sample: u8, events: &mut EventQueue<'_>) {
268
264
self.selected_sample_instr = sample;
269
-
events.push_back(GlobalEvent::Page(super::PageEvent::SampleList(
265
+
events.push(GlobalEvent::Page(super::PageEvent::SampleList(
270
266
super::sample_list::SampleListEvent::SelectSample(sample),
271
267
)));
272
268
}
···
466
462
&mut self,
467
463
modifiers: &winit::event::Modifiers,
468
464
key_event: &winit::event::KeyEvent,
469
-
events: &mut VecDeque<GlobalEvent>,
465
+
events: &mut EventQueue<'_>,
470
466
) -> PageResponse {
471
467
if !key_event.state.is_pressed() {
472
468
return PageResponse::None;
+7
-8
src/ui/pages/sample_list.rs
+7
-8
src/ui/pages/sample_list.rs
···
1
1
use std::{
2
-
collections::VecDeque,
3
2
io::{Cursor, Write},
4
3
iter::zip,
5
4
num::NonZero,
···
16
15
use winit::keyboard::{Key, NamedKey};
17
16
18
17
use crate::{
19
-
app::{EXECUTOR, GlobalEvent, SONG_OP_SEND},
18
+
app::{EXECUTOR, EventQueue, GlobalEvent, SONG_OP_SEND},
20
19
coordinates::{CharPosition, CharRect},
21
20
draw_buffer::DrawBuffer,
22
21
ui::{
···
52
51
pub fn process_event(
53
52
&mut self,
54
53
event: SampleListEvent,
55
-
events: &mut VecDeque<GlobalEvent>,
54
+
events: &mut EventQueue<'_>,
56
55
) -> PageResponse {
57
56
match event {
58
57
// this event is from the pattern page, so i don't have to send it there
···
82
81
};
83
82
}
84
83
85
-
fn send_to_header(&self, events: &mut VecDeque<GlobalEvent>) {
84
+
fn send_to_header(&self, events: &mut EventQueue<'_>) {
86
85
let name: Box<str> = self.samples[usize::from(self.selected)]
87
86
.as_ref()
88
87
.map(|(n, _)| Box::from(n.as_str()))
89
88
.unwrap_or(Box::from(""));
90
-
events.push_back(GlobalEvent::Header(HeaderEvent::SetSample(
89
+
events.push(GlobalEvent::Header(HeaderEvent::SetSample(
91
90
self.selected,
92
91
name,
93
92
)));
94
93
}
95
94
96
-
fn send_to_pattern(&self, events: &mut VecDeque<GlobalEvent>) {
97
-
events.push_back(GlobalEvent::Page(PageEvent::Pattern(
95
+
fn send_to_pattern(&self, events: &mut EventQueue<'_>) {
96
+
events.push(GlobalEvent::Page(PageEvent::Pattern(
98
97
PatternPageEvent::SetSampleInstr(self.selected),
99
98
)));
100
99
}
···
140
139
&mut self,
141
140
modifiers: &winit::event::Modifiers,
142
141
key_event: &winit::event::KeyEvent,
143
-
events: &mut VecDeque<crate::app::GlobalEvent>,
142
+
events: &mut EventQueue<'_>,
144
143
) -> PageResponse {
145
144
if !key_event.state.is_pressed() {
146
145
return PageResponse::None;
+3
-3
src/ui/pages/song_directory_config_page.rs
+3
-3
src/ui/pages/song_directory_config_page.rs
···
1
-
use std::{collections::VecDeque, num::NonZero};
1
+
use std::num::NonZero;
2
2
3
3
use torque_tracker_engine::project::song::SongOperation;
4
4
5
5
use crate::{
6
-
app::{GlobalEvent, send_song_op},
6
+
app::{EventQueue, GlobalEvent, send_song_op},
7
7
coordinates::{CharPosition, CharRect},
8
8
draw_buffer::DrawBuffer,
9
9
ui::widgets::{NextWidget, StandardResponse, WidgetResponse, slider::Slider, text_in::TextIn},
···
145
145
&mut self,
146
146
modifiers: &winit::event::Modifiers,
147
147
key_event: &winit::event::KeyEvent,
148
-
events: &mut VecDeque<GlobalEvent>,
148
+
events: &mut EventQueue<'_>,
149
149
) -> PageResponse {
150
150
match self
151
151
.widgets
+2
-4
src/ui/widgets.rs
+2
-4
src/ui/widgets.rs
···
5
5
pub mod toggle;
6
6
pub mod toggle_button;
7
7
8
-
use std::collections::VecDeque;
9
-
10
8
use winit::{
11
9
event::{KeyEvent, Modifiers},
12
10
keyboard::{Key, ModifiersState, NamedKey},
13
11
};
14
12
15
-
use crate::{app::GlobalEvent, draw_buffer::DrawBuffer};
13
+
use crate::{app::EventQueue, draw_buffer::DrawBuffer};
16
14
17
15
pub(crate) trait Widget {
18
16
type Response;
···
22
20
&mut self,
23
21
modifiers: &Modifiers,
24
22
key_event: &KeyEvent,
25
-
events: &mut VecDeque<GlobalEvent>,
23
+
events: &mut EventQueue<'_>,
26
24
) -> WidgetResponse<Self::Response>;
27
25
}
28
26
+3
-4
src/ui/widgets/slider.rs
+3
-4
src/ui/widgets/slider.rs
···
1
1
use std::{
2
-
collections::VecDeque,
3
2
fmt::Debug,
4
3
ops::{AddAssign, Deref, SubAssign},
5
4
};
···
7
6
use winit::keyboard::{Key, NamedKey};
8
7
9
8
use crate::{
10
-
app::GlobalEvent,
9
+
app::{EventQueue, GlobalEvent},
11
10
coordinates::{CharPosition, CharRect, FONT_SIZE, PixelRect, WINDOW_SIZE_CHARS},
12
11
draw_buffer::DrawBuffer,
13
12
ui::dialog::slider_dialog::SliderDialog,
···
176
175
&mut self,
177
176
modifiers: &winit::event::Modifiers,
178
177
key_event: &winit::event::KeyEvent,
179
-
event: &mut VecDeque<GlobalEvent>,
178
+
event: &mut EventQueue<'_>,
180
179
) -> WidgetResponse<R> {
181
180
if !key_event.state.is_pressed() {
182
181
return WidgetResponse::default();
···
235
234
if let Some(first_char) = chars.next() {
236
235
if first_char.is_ascii_digit() {
237
236
let dialog = SliderDialog::new(first_char, MIN..=MAX, self.dialog_return);
238
-
event.push_back(GlobalEvent::OpenDialog(Box::new(|| Box::new(dialog))));
237
+
event.push(GlobalEvent::OpenDialog(Box::new(|| Box::new(dialog))));
239
238
return WidgetResponse::default();
240
239
}
241
240
}
+2
-4
src/ui/widgets/text_in.rs
+2
-4
src/ui/widgets/text_in.rs
···
1
-
use std::collections::VecDeque;
2
-
3
1
use ascii::{AsciiChar, AsciiString};
4
2
use font8x8::UnicodeFonts;
5
3
use winit::keyboard::{Key, NamedKey};
6
4
7
5
use crate::{
8
-
app::GlobalEvent,
6
+
app::EventQueue,
9
7
coordinates::{CharPosition, WINDOW_SIZE},
10
8
draw_buffer::DrawBuffer,
11
9
};
···
50
48
&mut self,
51
49
modifiers: &winit::event::Modifiers,
52
50
key_event: &winit::event::KeyEvent,
53
-
_: &mut VecDeque<GlobalEvent>,
51
+
_: &mut EventQueue<'_>,
54
52
) -> WidgetResponse<R> {
55
53
if !key_event.state.is_pressed() {
56
54
return WidgetResponse::default();
+2
-4
src/ui/widgets/text_in_scroll.rs
+2
-4
src/ui/widgets/text_in_scroll.rs
···
1
-
use std::collections::VecDeque;
2
-
3
1
use ascii::{AsciiChar, AsciiString};
4
2
use font8x8::UnicodeFonts;
5
3
use winit::keyboard::{Key, NamedKey};
6
4
7
5
use crate::{
8
-
app::GlobalEvent,
6
+
app::EventQueue,
9
7
coordinates::{CharPosition, WINDOW_SIZE},
10
8
draw_buffer::DrawBuffer,
11
9
ui::widgets::StandardResponse,
···
56
54
&mut self,
57
55
modifiers: &winit::event::Modifiers,
58
56
key_event: &winit::event::KeyEvent,
59
-
_event: &mut VecDeque<GlobalEvent>,
57
+
_: &mut EventQueue<'_>,
60
58
) -> WidgetResponse<R> {
61
59
if !key_event.state.is_pressed() {
62
60
return WidgetResponse::default();
+2
-4
src/ui/widgets/toggle.rs
+2
-4
src/ui/widgets/toggle.rs
···
1
-
use std::collections::VecDeque;
2
-
3
1
use winit::keyboard::{Key, NamedKey};
4
2
5
3
use crate::{
6
-
app::GlobalEvent,
4
+
app::EventQueue,
7
5
coordinates::{CharPosition, CharRect, WINDOW_SIZE},
8
6
draw_buffer::DrawBuffer,
9
7
};
···
43
41
&mut self,
44
42
modifiers: &winit::event::Modifiers,
45
43
key_event: &winit::event::KeyEvent,
46
-
_events: &mut VecDeque<GlobalEvent>,
44
+
_: &mut EventQueue<'_>,
47
45
) -> WidgetResponse<R> {
48
46
if key_event.logical_key == Key::Named(NamedKey::Space)
49
47
&& modifiers.state().is_empty()