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
127
128
129
130
131
132
133
134
135
136

use cocoa::base::id;
use cocoa::foundation::{NSPoint, NSRect, NSSize};
use objc::declare::ClassDecl;
use objc::runtime::Class;
use objc::runtime::Object;
use objc::runtime::Sel;
use std::mem;
use std::os::raw::c_void;
use super::view;
use super::view::{Size, View, ViewParams};
use super::ObjCObject;

pub const ORIENTATION_HORIZONTAL: u8 = 0;
pub const ORIENTATION_VERTICAL: u8 = 1;

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

pub struct ViewBox(id);

fn declare() -> &'static Class {
    let super_cls = &*view::CLS;
    let mut decl = ClassDecl::new("SquareViewBox", super_cls).unwrap();

    unsafe {
        decl.add_ivar::<u8>("__square_view_box_orientation");
        decl.add_method(sel!(layout), layout as extern "C" fn(&Object, Sel));
    }

    decl.register()
}

extern "C" fn layout(ptr: &Object, _: Sel) {
    unsafe {
        let subviews: id = msg_send![ptr, subviews];
        let count: usize = msg_send![subviews, count];
        let orientation: u8 = *(*ptr).get_ivar("__square_view_box_orientation");

        let frame_size: NSSize = msg_send![ptr, frameSize];

        let mut number_of_unspec = 0.0;
        let mut total_accounted_for_size: f64 = 0.0;

        for i in 0..count {
            let subview: id = msg_send![subviews, objectAtIndex: i];

            // TODO: Getting parameters should be easier
            let params = (*subview).get_ivar::<*mut c_void>("__square_view_params");
            let params: &Box<ViewParams> = mem::transmute(params);

            if orientation == ORIENTATION_VERTICAL {
                match params.height {
                    Size::Unspecified => {
                        number_of_unspec += 1.0;
                    }

                    Size::Absolute(v) => {
                        total_accounted_for_size += v;
                    }
                }
            } else if orientation == ORIENTATION_HORIZONTAL {
                match params.width {
                    Size::Unspecified => {
                        number_of_unspec += 1.0;
                    }

                    Size::Absolute(v) => {
                        total_accounted_for_size += v;
                    }
                }
            }
        }

        let mut y = 0.0;

        for i in 0..count {
            let subview: id = msg_send![subviews, objectAtIndex: i];

            // TODO: Getting parameters should be easier
            let params = (*subview).get_ivar::<*mut c_void>("__square_view_params");
            let params: &Box<ViewParams> = mem::transmute(params);

            // TODO: Use a balanced formula to ensure we cover the parent view completely

            let sv_width = match params.width {
                Size::Absolute(w) => w,
                Size::Unspecified => {
                    if orientation == ORIENTATION_HORIZONTAL {
                        (frame_size.width - total_accounted_for_size) / number_of_unspec
                    } else {
                        frame_size.width
                    }
                }
            };

            let sv_height = match params.height {
                Size::Absolute(h) => h,
                Size::Unspecified => {
                    if orientation == ORIENTATION_VERTICAL {
                        (frame_size.height - total_accounted_for_size) / number_of_unspec
                    } else {
                        frame_size.height
                    }
                }
            };

            let origin = NSPoint::new(0.0, y);
            let frame = NSRect::new(origin, NSSize::new(sv_width, sv_height));

            msg_send![subview, setFrame: frame];

            y += frame.size.height;
        }
    }
}

impl ViewBox {
    pub fn new(orientation: u8) -> Self {
        let ptr: id = unsafe { msg_send![*CLS, new] };

        unsafe {
            (*ptr).set_ivar("__square_view_box_orientation", orientation);
        }

        ViewBox(ptr)
    }
}

impl ObjCObject for ViewBox {
    fn handle(&self) -> id {
        self.0
    }
}

impl View for ViewBox {}