winit-gtk 0.1.0

Cross-platform window creation library.
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
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

use objc2::foundation::{MainThreadMarker, NSArray, NSInteger, NSObject, NSUInteger};
use objc2::rc::{Id, Shared};
use objc2::runtime::Object;
use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
use objc2::{Encode, Encoding};

use super::{NSAppearance, NSEvent, NSMenu, NSResponder, NSWindow};

extern_class!(
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub(crate) struct NSApplication;

    unsafe impl ClassType for NSApplication {
        #[inherits(NSObject)]
        type Super = NSResponder;
    }
);

pub(crate) fn NSApp() -> Id<NSApplication, Shared> {
    // TODO: Only allow access from main thread
    NSApplication::shared(unsafe { MainThreadMarker::new_unchecked() })
}

extern_methods!(
    unsafe impl NSApplication {
        /// This can only be called on the main thread since it may initialize
        /// the application and since it's parameters may be changed by the main
        /// thread at any time (hence it is only safe to access on the main thread).
        pub fn shared(_mtm: MainThreadMarker) -> Id<Self, Shared> {
            let app: Option<_> = unsafe { msg_send_id![Self::class(), sharedApplication] };
            // SAFETY: `sharedApplication` always initializes the app if it isn't already
            unsafe { app.unwrap_unchecked() }
        }

        pub fn currentEvent(&self) -> Option<Id<NSEvent, Shared>> {
            unsafe { msg_send_id![self, currentEvent] }
        }

        #[sel(postEvent:atStart:)]
        pub fn postEvent_atStart(&self, event: &NSEvent, front_of_queue: bool);

        #[sel(presentationOptions)]
        pub fn presentationOptions(&self) -> NSApplicationPresentationOptions;

        pub fn windows(&self) -> Id<NSArray<NSWindow, Shared>, Shared> {
            unsafe { msg_send_id![self, windows] }
        }

        pub fn keyWindow(&self) -> Option<Id<NSWindow, Shared>> {
            unsafe { msg_send_id![self, keyWindow] }
        }

        // TODO: NSApplicationDelegate
        #[sel(setDelegate:)]
        pub fn setDelegate(&self, delegate: &Object);

        #[sel(setPresentationOptions:)]
        pub fn setPresentationOptions(&self, options: NSApplicationPresentationOptions);

        #[sel(hide:)]
        pub fn hide(&self, sender: Option<&Object>);

        #[sel(orderFrontCharacterPalette:)]
        #[allow(dead_code)]
        pub fn orderFrontCharacterPalette(&self, sender: Option<&Object>);

        #[sel(hideOtherApplications:)]
        pub fn hideOtherApplications(&self, sender: Option<&Object>);

        #[sel(stop:)]
        pub fn stop(&self, sender: Option<&Object>);

        #[sel(activateIgnoringOtherApps:)]
        pub fn activateIgnoringOtherApps(&self, ignore: bool);

        #[sel(requestUserAttention:)]
        pub fn requestUserAttention(&self, type_: NSRequestUserAttentionType) -> NSInteger;

        #[sel(setActivationPolicy:)]
        pub fn setActivationPolicy(&self, policy: NSApplicationActivationPolicy) -> bool;

        #[sel(setMainMenu:)]
        pub fn setMainMenu(&self, menu: &NSMenu);

        pub fn effectiveAppearance(&self) -> Id<NSAppearance, Shared> {
            unsafe { msg_send_id![self, effectiveAppearance] }
        }

        #[sel(setAppearance:)]
        pub fn setAppearance(&self, appearance: Option<&NSAppearance>);

        #[sel(run)]
        pub unsafe fn run(&self);
    }
);

#[allow(dead_code)]
#[repr(isize)] // NSInteger
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum NSApplicationActivationPolicy {
    NSApplicationActivationPolicyRegular = 0,
    NSApplicationActivationPolicyAccessory = 1,
    NSApplicationActivationPolicyProhibited = 2,
    NSApplicationActivationPolicyERROR = -1,
}

unsafe impl Encode for NSApplicationActivationPolicy {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

bitflags! {
    pub struct NSApplicationPresentationOptions: NSUInteger {
        const NSApplicationPresentationDefault = 0;
        const NSApplicationPresentationAutoHideDock = 1 << 0;
        const NSApplicationPresentationHideDock = 1 << 1;
        const NSApplicationPresentationAutoHideMenuBar = 1 << 2;
        const NSApplicationPresentationHideMenuBar = 1 << 3;
        const NSApplicationPresentationDisableAppleMenu = 1 << 4;
        const NSApplicationPresentationDisableProcessSwitching = 1 << 5;
        const NSApplicationPresentationDisableForceQuit = 1 << 6;
        const NSApplicationPresentationDisableSessionTermination = 1 << 7;
        const NSApplicationPresentationDisableHideApplication = 1 << 8;
        const NSApplicationPresentationDisableMenuBarTransparency = 1 << 9;
        const NSApplicationPresentationFullScreen = 1 << 10;
        const NSApplicationPresentationAutoHideToolbar = 1 << 11;
    }
}

unsafe impl Encode for NSApplicationPresentationOptions {
    const ENCODING: Encoding = NSUInteger::ENCODING;
}

#[repr(usize)] // NSUInteger
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum NSRequestUserAttentionType {
    NSCriticalRequest = 0,
    NSInformationalRequest = 10,
}

unsafe impl Encode for NSRequestUserAttentionType {
    const ENCODING: Encoding = NSUInteger::ENCODING;
}