argui-platform 0.2.0

Native platform integrations for Argui applications
Documentation 
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

#![cfg(all(feature = "file-picker", not(target_arch = "wasm32")))]
use argui_platform::file_picker::*;
use std::sync::{Arc, Mutex};

struct Recorder(Arc<Mutex<Option<FileDialog>>>);
impl FileDialogBackend for Recorder {
    fn open(&self, dialog: FileDialog) -> FileDialogFuture {
        *self.0.lock().unwrap() = Some(dialog);
        Box::pin(async { Ok(None) })
    }
}

#[test]
fn options_reach_the_provider_and_empty_results_are_not_fake_selections() {
    for mode in [
        FilePickerMode::File,
        FilePickerMode::Files,
        FilePickerMode::Folder,
        FilePickerMode::Folders,
        FilePickerMode::Save,
    ] {
        assert!(mode.supported());
        let dialog = FileDialog::new(mode)
            .title("Select a document")
            .directory(std::env::temp_dir())
            .file_name("notes.md")
            .filter(FileFilter::new("Documents", ["md", "tar.gz"]))
            .filter(FileFilter::new("Any file", ["*"]));
        let recorded = Arc::new(Mutex::new(None));
        assert!(
            pollster::block_on(dialog.open_with(&Recorder(recorded.clone())))
                .unwrap()
                .is_none()
        );
        let sent = recorded.lock().unwrap().take().unwrap();
        assert_eq!(sent.mode, mode);
        assert_eq!(sent.title, "Select a document");
        assert_eq!(sent.file_name.as_deref(), Some("notes.md"));
        assert_eq!(sent.directory, Some(std::env::temp_dir()));
        assert_eq!(sent.filters[0].extensions, ["md", "tar.gz"]);
        assert!(format!("{sent:?}").contains("Documents"));
    }
    let default = FileDialog::default();
    assert_eq!(default.mode, FilePickerMode::File);
    assert!(default.validate().is_ok());
}

#[test]
fn invalid_options_are_rejected_before_opening_any_native_window() {
    let mut invalid = vec![FileDialog::default().title("a\0b")];
    for name in ["", ".", "..", "folder/name", "folder\\name", "a\0b"] {
        invalid.push(FileDialog::default().file_name(name));
    }
    for filter in [
        FileFilter::new("", ["txt"]),
        FileFilter::new("a\0b", ["txt"]),
        FileFilter::new("Files", [] as [&str; 0]),
    ] {
        invalid.push(FileDialog::default().filter(filter));
    }
    for extension in [
        "", ".txt", "a b", "*.rs", "a?", "a/b", "a\\b", "a;b", "a,b", "a\0b",
    ] {
        invalid.push(FileDialog::default().filter(FileFilter::new("Files", [extension])));
    }
    invalid.push(FileDialog::default().directory("bad\0path"));
    let recorded = Arc::new(Mutex::new(None));
    for dialog in invalid {
        let error =
            pollster::block_on(dialog.clone().open_with(&Recorder(recorded.clone()))).unwrap_err();
        assert!(matches!(error, FileDialogError::InvalidOptions(_)));
        assert!(!error.to_string().is_empty());
        assert!(pollster::block_on(dialog.open()).is_err());
    }
    assert!(recorded.lock().unwrap().is_none());
    assert!(
        FileDialogError::UnsupportedMode(FilePickerMode::Folder)
            .to_string()
            .contains("Folder")
    );
    assert_eq!(
        FileDialogError::Unavailable("service missing".into()).to_string(),
        "service missing"
    );
}

#[test]
fn parent_owner_is_retained_by_the_request() {
    use winit::raw_window_handle::{
        DisplayHandle, HandleError, HasDisplayHandle, HasWindowHandle, WindowHandle,
    };
    struct UnavailableParent;
    impl HasWindowHandle for UnavailableParent {
        fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
            Err(HandleError::Unavailable)
        }
    }
    impl HasDisplayHandle for UnavailableParent {
        fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
            Err(HandleError::Unavailable)
        }
    }
    let parent = Arc::new(UnavailableParent);
    let weak = Arc::downgrade(&parent);
    let dialog = FileDialog::default().parent(parent);
    assert!(weak.upgrade().is_some());
    assert!(matches!(
        pollster::block_on(dialog.open()),
        Err(FileDialogError::Unavailable(_))
    ));
    assert!(weak.upgrade().is_none());
}