objective-rust 0.1.1

Seamlessly bind Rust and Objective-C code.
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
143

//! Makes a window on macOS with AppKit. This doesn't process any events.

use {
    core::ptr::NonNull,
    objective_rust::{objrs, ObjcBool},
};

fn main() {
    let shared = NonNull::new(NSApplication::shared()).unwrap();
    let ns_app = unsafe { NSApplication::from_raw(shared) };

    let window = NonNull::new(NSWindow::alloc()).unwrap();
    let mut window = unsafe { NSWindow::from_raw(window) };
    let mut style_mask = NSWindowStyleMask::default();
    style_mask.closable().resizable().titled();
    window.init(
        NSRect {
            origin: NSPoint { x: 0.0, y: 0.0 },
            size: NSSize {
                width: 600.0,
                height: 400.0,
            },
        },
        style_mask,
        2,
        false.into(),
    );
    window.make_key(std::ptr::null_mut());

    ns_app.run();

    unreachable!()
}

#[objrs]
mod ffi {
    use super::*;

    extern "objc" {
        type NSApplication;

        #[selector = "sharedApplication"]
        fn shared() -> *mut Self;
        fn run(&self);
    }
    extern "Objective-C" {
        type NSWindow;

        fn alloc() -> *mut Self;

        #[selector = "initWithContentRect:styleMask:backing:defer:"]
        fn init(
            &mut self,
            content_rect: NSRect,
            style_mask: NSWindowStyleMask,
            backing_store: u64,
            defer: ObjcBool,
        );

        #[selector = "makeKeyAndOrderFront:"]
        fn make_key(&mut self, sender: *mut ());
    }

    #[repr(objc)]
    pub struct NSThing {}

    #[repr(C)]
    pub struct NSPoint {
        pub x: f64,
        pub y: f64,
    }
    #[repr(C)]
    pub struct NSSize {
        pub width: f64,
        pub height: f64,
    }
    #[repr(C)]
    pub struct NSRect {
        pub origin: NSPoint,
        pub size: NSSize,
    }

    #[derive(Default)]
    #[repr(transparent)]
    pub struct NSWindowStyleMask(u64);

    #[allow(dead_code)] // Every non-deprecated style mask is listed here, for completeness' sake.
    impl NSWindowStyleMask {
        pub fn borderless(&mut self) -> &mut Self {
            self.0 = 0;
            self
        }
        pub fn titled(&mut self) -> &mut Self {
            self.0 |= 1 << 0;
            self
        }
        pub fn closable(&mut self) -> &mut Self {
            self.0 |= 1 << 1;
            self
        }
        pub fn miniaturizable(&mut self) -> &mut Self {
            self.0 |= 1 << 2;
            self
        }
        pub fn resizable(&mut self) -> &mut Self {
            self.0 |= 1 << 3;
            self
        }
        pub fn unified_title_and_toolbar(&mut self) -> &mut Self {
            self.0 |= 1 << 12;
            self
        }
        pub fn fullscreen(&mut self) -> &mut Self {
            self.0 |= 1 << 14;
            self
        }
        pub fn full_size_content_view(&mut self) -> &mut Self {
            self.0 |= 1 << 15;
            self
        }
        pub fn utility(&mut self) -> &mut Self {
            self.0 |= 1 << 4;
            self
        }
        pub fn doc_modal(&mut self) -> &mut Self {
            self.0 |= 1 << 6;
            self
        }
        pub fn non_activating_panel(&mut self) -> &mut Self {
            self.0 |= 1 << 7;
            self
        }
        pub fn hud_window(&mut self) -> &mut Self {
            self.0 |= 1 << 13;
            self
        }
    }

    // Without this, Rust won't link to AppKit and AppKit classes won't get loaded.
    #[link(name = "AppKit", kind = "framework")]
    extern "C" {}
}
use ffi::*;