-
-
Notifications
You must be signed in to change notification settings - Fork 805
/
ui.rs
437 lines (366 loc) · 12.4 KB
/
ui.rs
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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
use crate::backend::navigator::OwnedFuture;
use crate::events::{KeyCode, MouseButton, PlayerEvent, TextControlCode};
pub use crate::loader::Error as DialogLoaderError;
use chrono::{DateTime, TimeDelta, Utc};
use downcast_rs::Downcast;
use fluent_templates::loader::langid;
pub use fluent_templates::LanguageIdentifier;
use std::borrow::Cow;
use std::collections::HashSet;
use url::Url;
pub type FullscreenError = Cow<'static, str>;
pub static US_ENGLISH: LanguageIdentifier = langid!("en-US");
pub enum FontDefinition<'a> {
/// A singular DefineFont tag extracted from a swf.
SwfTag(swf::Font<'a>, &'static swf::Encoding),
/// A font contained in an external file, such as a ttf.
FontFile {
name: String,
is_bold: bool,
is_italic: bool,
data: Vec<u8>,
index: u32,
},
}
/// A filter specifying a category that can be selected from a file chooser dialog
pub struct FileFilter {
/// The description of the category
pub description: String,
/// A semicolon ';' delimited list of acceptable windows file extensions that can be selected
/// in this category, with a */wildcard before each extension
pub extensions: String,
/// A semicolon ';' delimited list of acceptable MacOs file extensions that can be selected in
/// this category, with a */wildcard before each extension
/// Note that a list of file filters will either all have Some(_) mac_type or all will have None
pub mac_type: Option<String>,
}
/// A result of a file selection
pub trait FileDialogResult: Downcast {
/// Was the file selection canceled by the user
fn is_cancelled(&self) -> bool;
fn creation_time(&self) -> Option<DateTime<Utc>>;
fn modification_time(&self) -> Option<DateTime<Utc>>;
fn file_name(&self) -> Option<String>;
fn size(&self) -> Option<u64>;
fn file_type(&self) -> Option<String>;
fn creator(&self) -> Option<String> {
None
}
fn contents(&self) -> &[u8];
/// Write the given data to the chosen file and refresh any internal metadata.
/// Any future calls to other functions (such as [FileDialogResult::size]) will reflect
/// the state at the time of the last refresh
fn write_and_refresh(&mut self, data: &[u8]);
}
impl_downcast!(FileDialogResult);
/// Future representing a file selection in process
pub type DialogResultFuture = OwnedFuture<Box<dyn FileDialogResult>, DialogLoaderError>;
pub trait UiBackend: Downcast {
fn mouse_visible(&self) -> bool;
fn set_mouse_visible(&mut self, visible: bool);
/// Changes the mouse cursor image.
fn set_mouse_cursor(&mut self, cursor: MouseCursor);
/// Get the clipboard content
fn clipboard_content(&mut self) -> String;
/// Check if the clipboard is available and not empty
fn clipboard_available(&mut self) -> bool {
!self.clipboard_content().is_empty()
}
/// Sets the clipboard to the given content.
fn set_clipboard_content(&mut self, content: String);
fn set_fullscreen(&mut self, is_full: bool) -> Result<(), FullscreenError>;
/// Displays a message about an error during root movie download.
/// In particular, on web this can be a CORS error, which we can sidestep
/// by providing a direct .swf link instead.
fn display_root_movie_download_failed_message(&self, _invalid_swf: bool);
// Unused, but kept in case we need it later.
fn message(&self, message: &str);
fn open_virtual_keyboard(&self);
fn close_virtual_keyboard(&self);
fn language(&self) -> LanguageIdentifier;
fn display_unsupported_video(&self, url: Url);
/// Called when a previously unknown device font is requested by a movie.
/// The backend is requested to call `register` with any fonts that match the given name.
///
/// You may call `register` any amount of times with any amount of found device fonts.
/// If you do not call `register` with any fonts that match the request,
/// then the font will simply be marked as not found - this may or may not fall back to another font.
fn load_device_font(
&self,
name: &str,
is_bold: bool,
is_italic: bool,
register: &mut dyn FnMut(FontDefinition),
);
/// Displays a file selection dialog, returning None if the dialog cannot be displayed
/// (e.g because it is already open)
/// * `filters` represents a list of filters to the possible file types that can be selected
fn display_file_open_dialog(&mut self, filters: Vec<FileFilter>) -> Option<DialogResultFuture>;
/// Display a dialog allowing a user to select a destination to save a file to
///
/// * `file_name` is a suggestion for the file name to save the file as
/// * `title` is a title that should be displayed in the dialog
fn display_file_save_dialog(
&mut self,
file_name: String,
title: String,
) -> Option<DialogResultFuture>;
/// Mark that any previously open dialog has been closed
fn close_file_dialog(&mut self);
}
impl_downcast!(UiBackend);
/// A mouse cursor icon displayed by the Flash Player.
/// Communicated from the core to the UI backend via `UiBackend::set_mouse_cursor`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum MouseCursor {
/// The default arrow icon.
/// Equivalent to AS3 `MouseCursor.ARROW`.
Arrow,
/// The hand icon indicating a button or link.
/// Equivalent to AS3 `MouseCursor.BUTTON`.
Hand,
/// The text I-beam.
/// Equivalent to AS3 `MouseCursor.IBEAM`.
IBeam,
/// The grabby-dragging hand icon.
/// Equivalent to AS3 `MouseCursor.HAND`.
Grab,
}
struct ClickEventData {
x: f64,
y: f64,
time: DateTime<Utc>,
index: usize,
}
impl ClickEventData {
fn distance_squared_to(&self, x: f64, y: f64) -> f64 {
let dx = x - self.x;
let dy = y - self.y;
dx * dx + dy * dy
}
}
pub struct InputManager {
keys_down: HashSet<KeyCode>,
keys_toggled: HashSet<KeyCode>,
last_key: KeyCode,
last_char: Option<char>,
last_text_control: Option<TextControlCode>,
last_click: Option<ClickEventData>,
}
impl InputManager {
pub fn new() -> Self {
Self {
keys_down: HashSet::new(),
keys_toggled: HashSet::new(),
last_key: KeyCode::UNKNOWN,
last_char: None,
last_text_control: None,
last_click: None,
}
}
fn add_key(&mut self, key_code: KeyCode) {
self.last_key = key_code;
if key_code != KeyCode::UNKNOWN {
self.keys_down.insert(key_code);
}
}
fn toggle_key(&mut self, key_code: KeyCode) {
if key_code == KeyCode::UNKNOWN || self.keys_down.contains(&key_code) {
return;
}
if self.keys_toggled.contains(&key_code) {
self.keys_toggled.remove(&key_code);
} else {
self.keys_toggled.insert(key_code);
}
}
fn remove_key(&mut self, key_code: KeyCode) {
self.last_key = key_code;
if key_code != KeyCode::UNKNOWN {
self.keys_down.remove(&key_code);
}
}
pub fn handle_event(&mut self, event: &PlayerEvent) {
match *event {
PlayerEvent::KeyDown { key_code, key_char } => {
self.last_char = key_char;
self.toggle_key(key_code);
self.add_key(key_code);
}
PlayerEvent::KeyUp { key_code, key_char } => {
self.last_char = key_char;
self.remove_key(key_code);
self.last_text_control = None;
}
PlayerEvent::TextControl { code } => {
self.last_text_control = Some(code);
}
PlayerEvent::MouseDown {
x,
y,
button,
index,
} => {
self.toggle_key(button.into());
self.add_key(button.into());
self.update_last_click(x, y, index);
}
PlayerEvent::MouseUp { button, .. } => self.remove_key(button.into()),
_ => {}
}
}
fn update_last_click(&mut self, x: f64, y: f64, index: Option<usize>) {
let time = Utc::now();
let index = index.unwrap_or_else(|| {
let Some(last_click) = self.last_click.as_ref() else {
return 0;
};
// TODO Make this configurable as "double click delay" and "double click distance"
if (time - last_click.time).abs() < TimeDelta::milliseconds(500)
&& last_click.distance_squared_to(x, y) < 4.0
{
last_click.index + 1
} else {
0
}
});
self.last_click = Some(ClickEventData { x, y, time, index });
}
pub fn is_key_down(&self, key: KeyCode) -> bool {
self.keys_down.contains(&key)
}
pub fn is_key_toggled(&self, key: KeyCode) -> bool {
self.keys_toggled.contains(&key)
}
pub fn last_key_code(&self) -> KeyCode {
self.last_key
}
pub fn last_key_char(&self) -> Option<char> {
self.last_char
}
pub fn last_text_control(&self) -> Option<TextControlCode> {
self.last_text_control
}
pub fn last_click_index(&self) -> usize {
self.last_click
.as_ref()
.map(|lc| lc.index)
.unwrap_or_default()
}
pub fn is_mouse_down(&self, button: MouseButton) -> bool {
self.is_key_down(button.into())
}
pub fn get_mouse_down_buttons(&self) -> HashSet<MouseButton> {
let mut buttons = HashSet::new();
if self.is_mouse_down(MouseButton::Left) {
buttons.insert(MouseButton::Left);
}
if self.is_mouse_down(MouseButton::Middle) {
buttons.insert(MouseButton::Middle);
}
if self.is_mouse_down(MouseButton::Right) {
buttons.insert(MouseButton::Right);
}
buttons
}
}
impl Default for InputManager {
fn default() -> Self {
Self::new()
}
}
/// UiBackend that does nothing.
pub struct NullUiBackend {}
impl NullUiBackend {
pub fn new() -> Self {
Self {}
}
}
impl UiBackend for NullUiBackend {
fn mouse_visible(&self) -> bool {
true
}
fn set_mouse_visible(&mut self, _visible: bool) {}
fn set_mouse_cursor(&mut self, _cursor: MouseCursor) {}
fn clipboard_content(&mut self) -> String {
"".into()
}
fn set_clipboard_content(&mut self, _content: String) {}
fn set_fullscreen(&mut self, _is_full: bool) -> Result<(), FullscreenError> {
Ok(())
}
fn display_root_movie_download_failed_message(&self, _invalid_swf: bool) {}
fn message(&self, _message: &str) {}
fn display_unsupported_video(&self, _url: Url) {}
fn load_device_font(
&self,
_name: &str,
_is_bold: bool,
_is_italic: bool,
_register: &mut dyn FnMut(FontDefinition),
) {
}
fn open_virtual_keyboard(&self) {}
fn close_virtual_keyboard(&self) {}
fn language(&self) -> LanguageIdentifier {
US_ENGLISH.clone()
}
fn display_file_open_dialog(
&mut self,
_filters: Vec<FileFilter>,
) -> Option<DialogResultFuture> {
Some(Box::pin(async move {
let result: Result<Box<dyn FileDialogResult>, DialogLoaderError> =
Ok(Box::new(NullFileDialogResult::new()));
result
}))
}
fn close_file_dialog(&mut self) {}
fn display_file_save_dialog(
&mut self,
_file_name: String,
_domain: String,
) -> Option<DialogResultFuture> {
None
}
}
impl Default for NullUiBackend {
fn default() -> Self {
NullUiBackend::new()
}
}
pub struct NullFileDialogResult {}
impl NullFileDialogResult {
pub fn new() -> Self {
Self {}
}
}
impl Default for NullFileDialogResult {
fn default() -> Self {
NullFileDialogResult::new()
}
}
impl FileDialogResult for NullFileDialogResult {
fn is_cancelled(&self) -> bool {
true
}
fn creation_time(&self) -> Option<DateTime<Utc>> {
None
}
fn modification_time(&self) -> Option<DateTime<Utc>> {
None
}
fn file_name(&self) -> Option<String> {
None
}
fn size(&self) -> Option<u64> {
None
}
fn file_type(&self) -> Option<String> {
None
}
fn contents(&self) -> &[u8] {
&[]
}
fn write_and_refresh(&mut self, _data: &[u8]) {}
}