fltk-accesskit 0.2.1

fltk accesskit adapter made to work with the fltk gui crate
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

#![allow(unused_imports)]
use accesskit::{ActionHandler, ActivationHandler, DeactivationHandler, Rect, TreeUpdate};
use std::cell::RefCell;
use std::rc::Rc;

#[cfg(target_os = "windows")]
use accesskit_windows::{SubclassingAdapter, HWND};

#[cfg(target_os = "macos")]
use accesskit_macos::SubclassingAdapter;

#[cfg(not(any(target_os = "windows", target_os = "macos")))]
use accesskit_unix::Adapter as UnixAdapter;

use fltk::prelude::WindowExt;
use fltk::window;

pub struct Adapter {
    #[cfg(not(any(target_os = "windows", target_os = "macos")))]
    adapter: Option<UnixAdapter>,
    #[cfg(any(target_os = "windows", target_os = "macos"))]
    adapter: Option<SubclassingAdapter>,
}

impl Adapter {
    pub fn new(
        _win: &window::Window,
        activation_handler: impl 'static + ActivationHandler + Send,
        action_handler: impl 'static + ActionHandler + Send,
        _deactivation_handler: impl 'static + DeactivationHandler + Send,
    ) -> Rc<RefCell<Self>> {
        let adapter;
        #[cfg(not(any(target_os = "windows", target_os = "macos")))]
        {
            adapter = UnixAdapter::new(activation_handler, action_handler, _deactivation_handler);
        }

        #[cfg(target_os = "windows")]
        {
            unsafe extern "system" {
                fn ShowWindow(w: *mut std::os::raw::c_void, v: i32) -> i32;
            }
            unsafe {
                ShowWindow(_win.raw_handle(), 0);
            }
            adapter = SubclassingAdapter::new(
                HWND(_win.raw_handle()),
                activation_handler,
                action_handler,
            );
            unsafe {
                ShowWindow(_win.raw_handle(), 1);
            }
        }

        #[cfg(target_os = "macos")]
        {
            adapter = {
                use std::os::raw;
                extern "C" {
                    pub fn cfltk_getContentView(xid: *mut raw::c_void) -> *mut raw::c_void;
                }
                let cv = unsafe { cfltk_getContentView(_win.raw_handle()) };
                unsafe { SubclassingAdapter::new(cv, activation_handler, action_handler) }
            };
        }
        Rc::new(RefCell::new(Self {
            adapter: Some(adapter),
        }))
    }

    #[cfg(not(any(target_os = "windows", target_os = "macos")))]
    pub fn set_root_window_bounds(&mut self, outer: Rect, inner: Rect) {
        if let Some(adapter) = &mut self.adapter {
            adapter.set_root_window_bounds(outer, inner);
        }
    }

    pub fn update_if_active(&mut self, updater: impl FnOnce() -> TreeUpdate) {
        #[cfg(not(any(target_os = "windows", target_os = "macos")))]
        {
            if let Some(adapter) = &mut self.adapter {
                adapter.update_if_active(updater);
            }
        }
        #[cfg(any(target_os = "macos", target_os = "windows"))]
        {
            if let Some(adapter) = &mut self.adapter {
                if let Some(events) = adapter.update_if_active(updater) {
                    events.raise();
                }
            }
        }
    }
}