square 0.0.1

Native UI toolkit for creating cross-platform graphical user interfaces in Rust.
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

use cocoa::appkit::NSRectFill;
use cocoa::base::{class, id};
use cocoa::foundation::NSRect;
use objc::declare::ClassDecl;
use objc::runtime::BOOL;
use objc::runtime::YES;
use objc::runtime::{Class, Object, Sel};
use std::mem;
use std::os::raw::c_void;
use super::ObjCObject;
use super::super::color::Color;

#[derive(Debug)]
pub(crate) enum Size {
    Unspecified,
    Absolute(f64),
    // 0.0 .. 1.0 (%)
    // Relative(f64),
}

impl Default for Size {
    fn default() -> Self {
        Size::Unspecified
    }
}

lazy_static! {
    pub(crate) static ref CLS: &'static Class = declare();
}

// TODO: Store natively instead of using this struct
#[derive(Default)]
pub(crate) struct ViewParams {
    pub(crate) width: Size,
    pub(crate) height: Size,
    background_color: Option<Color>,
}

fn declare() -> &'static Class {
    let super_cls = Class::get("NSView").unwrap();
    let mut decl = ClassDecl::new("SquareView", super_cls).unwrap();

    unsafe {
        decl.add_ivar::<*mut c_void>("__square_view_params");
        decl.add_method(sel!(init), init as extern "C" fn(&Object, Sel) -> id);

        decl.add_method(
            sel!(drawRect:),
            draw_rect as extern "C" fn(&Object, Sel, NSRect),
        );

        decl.add_method(
            sel!(isFlipped),
            is_flipped as extern "C" fn(&Object, Sel) -> BOOL,
        );
    }

    decl.register()
}

extern "C" fn init(ptr: &Object, _: Sel) -> id {
    let super_cls = Class::get("NSView").unwrap();
    let ptr: id = unsafe { msg_send![super(ptr, super_cls), init] };

    unsafe {
        let params = Box::<ViewParams>::default();

        (*ptr).set_ivar::<*mut c_void>("__square_view_params", Box::into_raw(params) as *mut c_void);
    }

    ptr
}

extern "C" fn is_flipped(_: &Object, _: Sel) -> BOOL {
    YES
}

pub(crate) extern "C" fn draw_rect(ptr: &Object, _: Sel, dirty_rect: NSRect) {
    unsafe {
        // TODO: Getting parameters should be easier
        let params = (*ptr).get_ivar::<*mut c_void>("__square_view_params");
        let params: &Box<ViewParams> = mem::transmute(params);

        if let Some(Color { r, g, b, a }) = params.background_color {
            let color: id = msg_send![class("NSColor"), colorWithSRGBRed:r green:g blue:b alpha:a];
            msg_send![color, setFill];

            NSRectFill(dirty_rect);
        }
    }
}

pub trait View: ObjCObject {
    fn set_height(&mut self, h: f64) {
        unsafe {
            // TODO: Getting parameters should be easier
            let ptr = self.handle();
            let params = (*ptr).get_mut_ivar::<*mut c_void>("__square_view_params");
            let params: &mut Box<ViewParams> = mem::transmute(params);

            params.height = Size::Absolute(h);
        }
    }

    fn set_width(&mut self, w: f64) {
        unsafe {
            // TODO: Getting parameters should be easier
            let ptr = self.handle();
            let params = (*ptr).get_mut_ivar::<*mut c_void>("__square_view_params");
            let params: &mut Box<ViewParams> = mem::transmute(params);

            params.width = Size::Absolute(w);
        }
    }

    fn set_background_color<C: Into<Color>>(&mut self, color: C) {
        unsafe {
            // TODO: Getting parameters should be easier
            let ptr = self.handle();
            let params = (*ptr).get_mut_ivar::<*mut c_void>("__square_view_params");
            let params: &mut Box<ViewParams> = mem::transmute(params);

            params.background_color = Some(color.into());
        }
    }
}