Re-add checkbox, combobox and pixmap functionality to iui

Author: masche842

iui/Cargo.toml

@@ -46,4 +46,4 @@ maintenance = { status = "actively-developed" }
 bitflags = "0.7"
 libc = "0.2"
 failure = "0.1.1"
-ui-sys = "0.1.1"
+ui-sys = { version = "0.1.2", path = "../ui-sys" }

iui/src/controls/area.rs

@@ -0,0 +1,257 @@
+//! Provides a way to allocate an area in the window for custom drawing.
+
+use controls::Control;
+use ui::UI;
+use draw;
+use libc::c_int;
+use std::mem;
+use ui_sys::{self, uiArea, uiAreaDrawParams, uiAreaHandler, uiAreaKeyEvent, uiAreaMouseEvent,
+             uiControl};
+pub use ui_sys::uiExtKey as ExtKey;
+
+pub trait AreaHandler {
+    fn draw(&mut self, _area: &Area, _area_draw_params: &AreaDrawParams) {}
+    fn mouse_event(&mut self, _area: &Area, _area_mouse_event: &AreaMouseEvent) {}
+    fn mouse_crossed(&mut self, _area: &Area, _left: bool) {}
+    fn drag_broken(&mut self, _area: &Area) {}
+    fn key_event(&mut self, _area: &Area, _area_key_event: &AreaKeyEvent) -> bool {
+        true
+    }
+}
+
+#[repr(C)]
+struct RustAreaHandler {
+    ui_area_handler: uiAreaHandler,
+    trait_object: Box<AreaHandler>,
+}
+
+impl RustAreaHandler {
+    fn new(_ctx: &UI, trait_object: Box<AreaHandler>) -> Box<RustAreaHandler> {
+        return Box::new(RustAreaHandler {
+            ui_area_handler: uiAreaHandler {
+                Draw: draw,
+                MouseEvent: mouse_event,
+                MouseCrossed: mouse_crossed,
+                DragBroken: drag_broken,
+                KeyEvent: key_event,
+            },
+            trait_object: trait_object,
+        });
+
+        extern "C" fn draw(
+            ui_area_handler: *mut uiAreaHandler,
+            ui_area: *mut uiArea,
+            ui_area_draw_params: *mut uiAreaDrawParams,
+        ) {
+            unsafe {
+                let area = Area::from_ui_area(ui_area);
+                let area_draw_params =
+                    AreaDrawParams::from_ui_area_draw_params(&*ui_area_draw_params);
+                (*(ui_area_handler as *mut RustAreaHandler))
+                    .trait_object
+                    .draw(&area, &area_draw_params);
+                mem::forget(area_draw_params);
+                mem::forget(area);
+            }
+        }
+
+        extern "C" fn mouse_event(
+            ui_area_handler: *mut uiAreaHandler,
+            ui_area: *mut uiArea,
+            ui_area_mouse_event: *mut uiAreaMouseEvent,
+        ) {
+            unsafe {
+                let area = Area::from_ui_area(ui_area);
+                let area_mouse_event =
+                    AreaMouseEvent::from_ui_area_mouse_event(&*ui_area_mouse_event);
+                (*(ui_area_handler as *mut RustAreaHandler))
+                    .trait_object
+                    .mouse_event(&area, &area_mouse_event);
+                mem::forget(area_mouse_event);
+                mem::forget(area);
+            }
+        }
+
+        extern "C" fn mouse_crossed(
+            ui_area_handler: *mut uiAreaHandler,
+            ui_area: *mut uiArea,
+            left: c_int,
+        ) {
+            unsafe {
+                let area = Area::from_ui_area(ui_area);
+                (*(ui_area_handler as *mut RustAreaHandler))
+                    .trait_object
+                    .mouse_crossed(&area, left != 0);
+                mem::forget(area);
+            }
+        }
+
+        extern "C" fn drag_broken(ui_area_handler: *mut uiAreaHandler, ui_area: *mut uiArea) {
+            unsafe {
+                let area = Area::from_ui_area(ui_area);
+                (*(ui_area_handler as *mut RustAreaHandler))
+                    .trait_object
+                    .drag_broken(&area);
+                mem::forget(area);
+            }
+        }
+
+        extern "C" fn key_event(
+            ui_area_handler: *mut uiAreaHandler,
+            ui_area: *mut uiArea,
+            ui_area_key_event: *mut uiAreaKeyEvent,
+        ) -> c_int {
+            unsafe {
+                let area = Area::from_ui_area(ui_area);
+                let area_key_event = AreaKeyEvent::from_ui_area_key_event(&*ui_area_key_event);
+                let result = (*(ui_area_handler as *mut RustAreaHandler))
+                    .trait_object
+                    .key_event(&area, &area_key_event);
+                mem::forget(area_key_event);
+                mem::forget(area);
+                result as c_int
+            }
+        }
+    }
+}
+
+define_control!{
+    /// A control which takes up space on which the application can draw custom content.
+    rust_type: Area,
+    sys_type: uiArea
+}
+
+impl Area {
+    pub fn new(ctx: &UI, area_handler: Box<AreaHandler>) -> Area {
+        unsafe {
+            let mut rust_area_handler = RustAreaHandler::new(ctx, area_handler);
+            let area = Area::from_raw(ui_sys::uiNewArea(
+                &mut *rust_area_handler as *mut RustAreaHandler as *mut uiAreaHandler,
+            ));
+            mem::forget(rust_area_handler);
+            area
+        }
+    }
+
+    pub fn new_scrolling(ctx: &UI, area_handler: Box<AreaHandler>, width: i64, height: i64) -> Area {
+        unsafe {
+            let mut rust_area_handler = RustAreaHandler::new(ctx, area_handler);
+            let area = Area::from_raw(ui_sys::uiNewScrollingArea(
+                &mut *rust_area_handler as *mut RustAreaHandler as *mut uiAreaHandler,
+                width,
+                height,
+            ));
+            mem::forget(rust_area_handler);
+            area
+        }
+    }
+
+    pub unsafe fn from_ui_area(ui_area: *mut uiArea) -> Area {
+        Area { uiArea: ui_area }
+    }
+
+    pub fn set_size(&self, _ctx: &UI, width: i64, height: i64) {
+        unsafe { ui_sys::uiAreaSetSize(self.uiArea, width, height) }
+    }
+
+    pub fn queue_redraw_all(&self, _ctx: &UI) {
+        unsafe { ui_sys::uiAreaQueueRedrawAll(self.uiArea) }
+    }
+
+    pub fn scroll_to(&self, _ctx: &UI, x: f64, y: f64, width: f64, height: f64) {
+        unsafe { ui_sys::uiAreaScrollTo(self.uiArea, x, y, width, height) }
+    }
+}
+
+pub struct AreaDrawParams {
+    pub context: draw::Context,
+
+    pub area_width: f64,
+    pub area_height: f64,
+
+    pub clip_x: f64,
+    pub clip_y: f64,
+    pub clip_width: f64,
+    pub clip_height: f64,
+}
+
+impl AreaDrawParams {
+    // TODO: check if UI is initialized?
+    unsafe fn from_ui_area_draw_params(ui_area_draw_params: &uiAreaDrawParams) -> AreaDrawParams {
+        AreaDrawParams {
+            context: draw::Context::from_ui_draw_context(ui_area_draw_params.Context),
+            area_width: ui_area_draw_params.AreaWidth,
+            area_height: ui_area_draw_params.AreaHeight,
+            clip_x: ui_area_draw_params.ClipX,
+            clip_y: ui_area_draw_params.ClipY,
+            clip_width: ui_area_draw_params.ClipWidth,
+            clip_height: ui_area_draw_params.ClipHeight,
+        }
+    }
+}
+
+bitflags! {
+    pub flags Modifiers: u8 {
+        const MODIFIER_CTRL = 1 << 0,
+        const MODIFIER_ALT = 1 << 1,
+        const MODIFIER_SHIFT = 1 << 2,
+        const MODIFIER_SUPER = 1 << 3,
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct AreaMouseEvent {
+    pub x: f64,
+    pub y: f64,
+
+    pub area_width: f64,
+    pub area_height: f64,
+
+    pub down: i32,
+    pub up: i32,
+
+    pub count: i32,
+
+    pub modifiers: Modifiers,
+
+    pub held_1_to_64: u64,
+}
+
+impl AreaMouseEvent {
+    // TODO: check if UI is initialized?
+    pub fn from_ui_area_mouse_event(ui_area_mouse_event: &uiAreaMouseEvent) -> AreaMouseEvent {
+        AreaMouseEvent {
+            x: ui_area_mouse_event.X,
+            y: ui_area_mouse_event.Y,
+            area_width: ui_area_mouse_event.AreaWidth,
+            area_height: ui_area_mouse_event.AreaHeight,
+            down: ui_area_mouse_event.Down,
+            up: ui_area_mouse_event.Up,
+            count: ui_area_mouse_event.Count,
+            modifiers: Modifiers::from_bits(ui_area_mouse_event.Modifiers as u8).unwrap(),
+            held_1_to_64: ui_area_mouse_event.Held1To64,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct AreaKeyEvent {
+    pub key: u8,
+    pub ext_key: ExtKey,
+    pub modifier: Modifiers,
+    pub modifiers: Modifiers,
+    pub up: bool,
+}
+
+impl AreaKeyEvent {
+    // TODO: check if UI is initialized?
+    pub fn from_ui_area_key_event(ui_area_key_event: &uiAreaKeyEvent) -> AreaKeyEvent {
+        AreaKeyEvent {
+            key: ui_area_key_event.Key as u8,
+            ext_key: ui_area_key_event.ExtKey,
+            modifier: Modifiers::from_bits(ui_area_key_event.Modifier as u8).unwrap(),
+            modifiers: Modifiers::from_bits(ui_area_key_event.Modifiers as u8).unwrap(),
+            up: ui_area_key_event.Up != 0,
+        }
+    }
+}

iui/src/controls/entry.rs

@@ -4,7 +4,8 @@ use std::mem;
 use std::ffi::{CStr, CString};
 use std::i64;
 use libc::c_void;
-use ui_sys::{self, uiControl, uiSpinbox, uiSlider, uiEntry, uiMultilineEntry};
+use ui_sys::{self, uiControl, uiSpinbox, uiSlider, uiEntry, uiMultilineEntry, uiCombobox,
+    uiCheckbox};
 use super::Control;
 use ui::UI;
 
@@ -22,13 +23,13 @@ pub trait TextEntry {
 
 define_control!{
     /// Numerical entry control which allows users to set any value in a range by typing or incrementing/decrementing.
-    rust_type: Spinbox, 
+    rust_type: Spinbox,
     sys_type: uiSpinbox
 }
 
-define_control!{ 
+define_control!{
     /// Numerical entry which allows users to select a value by picking a location along a line.
-    rust_type: Slider, 
+    rust_type: Slider,
     sys_type: uiSlider
 }
 
@@ -192,3 +193,90 @@ impl TextEntry for MultilineEntry {
         }
     }
 }
+
+define_control! {
+    /// A control which allows the user to select any one of its options, from a list shown only when selected.
+    rust_type: Combobox,
+    sys_type: uiCombobox
+}
+
+impl Combobox {
+    /// Create a new Combobox
+    pub fn new(_ctx: &UI) -> Self {
+        unsafe { Combobox::from_raw(ui_sys::uiNewCombobox()) }
+    }
+
+    /// Adds a new option to the combination box.
+    pub fn append(&self, _ctx: &UI, name: &str) {
+        unsafe {
+            let c_string = CString::new(name.as_bytes().to_vec()).unwrap();
+            ui_sys::uiComboboxAppend(self.uiCombobox, c_string.as_ptr())
+        }
+    }
+
+    pub fn set_selected(&mut self, _ctx: &UI, value: i64) {
+        unsafe { ui_sys::uiComboboxSetSelected(self.uiCombobox, value) }
+    }
+
+    pub fn on_selected<F: FnMut(i64)>(&mut self, _ctx: &UI, callback: F) {
+        unsafe {
+            let mut data: Box<Box<FnMut(i64)>> = Box::new(Box::new(callback));
+            ui_sys::uiComboboxOnSelected(
+                self.uiCombobox,
+                c_callback,
+                &mut *data as *mut Box<FnMut(i64)> as *mut c_void,
+            );
+            mem::forget(data);
+        }
+
+        extern "C" fn c_callback(combobox: *mut uiCombobox, data: *mut c_void) {
+            unsafe {
+                let val = ui_sys::uiComboboxSelected(combobox);
+                // let combobox = Combobox::from_ui_control(combobox);
+                mem::transmute::<*mut c_void, &mut Box<FnMut(i64)>>(data)(val);
+                // mem::forget(combobox);
+            }
+        }
+    }
+}
+
+define_control! {
+    /// A control which allows the user to select any one of its options, from a list shown only when selected.
+    rust_type: Checkbox,
+    sys_type: uiCheckbox
+}
+
+impl Checkbox {
+    // Create a new Checkbox which can produce values from `min` to `max`.
+    pub fn new(_ctx: &UI, text: &str) -> Self {
+        let c_string = CString::new(text.as_bytes().to_vec()).unwrap();
+        unsafe { Checkbox::from_raw(ui_sys::uiNewCheckbox(c_string.as_ptr())) }
+    }
+
+    pub fn checked(&self, _ctx: &UI) -> bool {
+        unsafe { ui_sys::uiCheckboxChecked(self.uiCheckbox) != 0 }
+    }
+
+    pub fn set_checked(&mut self, _ctx: &UI, checked: bool) {
+        unsafe { ui_sys::uiCheckboxSetChecked(self.uiCheckbox, checked as i32) }
+    }
+
+    pub fn on_toggled<F: FnMut(bool)>(&mut self, _ctx: &UI, callback: F) {
+        unsafe {
+            let mut data: Box<Box<FnMut(bool)>> = Box::new(Box::new(callback));
+            ui_sys::uiCheckboxOnToggled(
+                self.uiCheckbox,
+                c_callback,
+                &mut *data as *mut Box<FnMut(bool)> as *mut c_void,
+            );
+            mem::forget(data);
+        }
+
+        extern "C" fn c_callback(checkbox: *mut uiCheckbox, data: *mut c_void) {
+            unsafe {
+                let val = ui_sys::uiCheckboxChecked(checkbox) != 0;
+                mem::transmute::<*mut c_void, &mut Box<FnMut(bool)>>(data)(val);
+            }
+        }
+    }
+}