Simplify Hide

Author: Nercury

lesson-24-x/src/interface.rs

@@ -61,6 +61,7 @@ impl ControlInfo {
 }
 
 pub struct Interface {
+    tree: Tree,
     fill: Leaf<controls::Fill>,
     events: Events,
     controls: HashMap<Ix, ControlInfo>,
@@ -71,7 +72,7 @@ pub struct Interface {
 }
 
 impl Interface {
-    pub fn new(gl: &gl::Gl, resources: &resources::Resources, size: ElementSize) -> Result<Interface, failure::Error> {
+    pub fn new(gl: &gl::Gl, resources: &resources::Resources, size: BoxSize) -> Result<Interface, failure::Error> {
         let tree = Tree::new();
 
         let events = tree.events();
@@ -80,6 +81,7 @@ impl Interface {
         fill.resize(size);
 
         Ok(Interface {
+            tree,
             fill,
             events,
             controls: HashMap::new(),
@@ -89,7 +91,7 @@ impl Interface {
         })
     }
 
-    pub fn resize(&mut self, size: ElementSize) {
+    pub fn resize(&mut self, size: BoxSize) {
         self.fill.resize(size);
     }
 
@@ -123,7 +125,8 @@ impl Interface {
         }
     }
 
-    pub fn update(&mut self, _delta: f32) {
+    pub fn update(&mut self, delta: f32) {
+        self.tree.update(delta);
         self.process_events()
     }
 

lesson-24-x/src/main.rs

@@ -78,7 +78,8 @@ fn run() -> Result<(), failure::Error> {
     viewport.set_used(&gl);
     color_buffer.set_clear_color(&gl, na::Vector3::new(0.3, 0.3, 0.5));
 
-    let mut iface = Interface::new(&gl, &resources, ui::ElementSize::Fixed { w: viewport.w, h: viewport.h })?;
+    let mut iface_auto_size = false;
+    let mut iface = Interface::new(&gl, &resources, ui::BoxSize::Fixed { w: viewport.w, h: viewport.h })?;
 
     // main loop
 
@@ -92,15 +93,32 @@ fn run() -> Result<(), failure::Error> {
                 break 'main;
             }
 
+            use sdl2::event::Event;
+            use sdl2::keyboard::Scancode;
+
             match event {
-                sdl2::event::Event::Window {
+                Event::Window {
                     win_event: sdl2::event::WindowEvent::Resized(_w, _h),
                     ..
                 } => {
                     let (hdpi_w, hdpi_h) = window.drawable_size();
                     viewport.update_size(hdpi_w as i32, hdpi_h as i32);
                     viewport.set_used(&gl);
-                    iface.resize(ui::ElementSize::Fixed { w: hdpi_w as i32, h: hdpi_h as i32 });
+                    if iface_auto_size {
+                        iface.resize(ui::BoxSize::Auto );
+                    } else {
+                        iface.resize(ui::BoxSize::Fixed { w: viewport.w, h: viewport.h });
+                    }
+                },
+                Event::KeyDown {
+                    scancode: Some(Scancode::L), ..
+                } => {
+                    iface_auto_size = !iface_auto_size;
+                    if iface_auto_size {
+                        iface.resize(ui::BoxSize::Auto );
+                    } else {
+                        iface.resize(ui::BoxSize::Fixed { w: viewport.w, h: viewport.h });
+                    }
                 },
                 _ => (),
             };

lib/ui/src/lib.rs

@@ -10,28 +10,69 @@ pub mod controls {
     pub struct Text;
 
     impl Element for Text {
-        fn inflate(&mut self, mut base: Base) {
-            base.enable_update(true);
+        fn inflate(&mut self, _base: Base) {
+
         }
 
-        fn resize(&mut self, mut _base: Base, size: ElementSize) -> Option<ResolvedSize> {
+        fn resize(&mut self, mut _base: Base, size: BoxSize) -> Option<ResolvedSize> {
             match size {
-                ElementSize::Auto => Some(ResolvedSize { w: 100, h: 60 }),
-                ElementSize::Fixed { w, h } => Some(ResolvedSize { w, h }),
+                BoxSize::Hidden => None,
+                BoxSize::Auto => Some(ResolvedSize { w: 100, h: 60 }),
+                BoxSize::Fixed { w, h } => Some(ResolvedSize { w, h }),
             }
         }
+
+        fn update(&mut self, mut _base: Base, _delta: f32) {
+            println!("update Text");
+        }
     }
 
-    pub struct Button;
+    pub struct Button {
+        margin: i32,
+        step: i32,
+        delta_acc: f32,
+        last_size: Option<BoxSize>,
+    }
+
+    impl Button {
+        pub fn new() -> Button {
+            Button {
+                margin:10,
+                step: 1,
+                delta_acc: 0.0,
+                last_size: None,
+            }
+        }
+    }
 
     impl Element for Button {
         fn inflate(&mut self, mut base: Base) {
             base.add(Text);
             base.add(Text);
+            base.enable_update(true);
         }
 
-        fn resize(&mut self, mut base: Base, size: ElementSize) -> Option<ResolvedSize> {
-            base.layout_vertical(size, 5)
+        fn resize(&mut self, mut base: Base, size: BoxSize) -> Option<ResolvedSize> {
+            self.last_size = Some(size);
+            base.layout_vertical(size, self.margin)
+        }
+
+        fn update(&mut self, mut base: Base, delta: f32) {
+            self.delta_acc += delta;
+            if self.delta_acc > 0.05 {
+                self.margin += self.step;
+                if self.margin > 20 || self.margin < 1 {
+                    self.step = -self.step;
+                }
+
+                if let Some(BoxSize::Fixed { w, h }) = self.last_size {
+                    base.layout_vertical(BoxSize::Fixed { w: w, h: h }, self.margin);
+                } else {
+                    base.layout_vertical(BoxSize::Auto, self.margin);
+                }
+
+                self.delta_acc = 0.0;
+            }
         }
     }
 
@@ -50,17 +91,18 @@ pub mod controls {
     impl Element for Fill {
         fn inflate(&mut self, mut base: Base) {
             base.add(Text);
-            base.add(Button);
+            base.add(Button::new());
         }
 
-        fn resize(&mut self, mut base: Base, size: ElementSize) -> Option<ResolvedSize> {
+        fn resize(&mut self, mut base: Base, size: BoxSize) -> Option<ResolvedSize> {
             base.layout_vertical(size, 5)
         }
     }
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum ElementSize {
+pub enum BoxSize {
+    Hidden,
     Auto,
     Fixed { w: i32, h: i32 }
 }
@@ -81,7 +123,8 @@ pub enum Effect {
 pub trait Element {
 
     fn inflate(&mut self, _base: Base) {}
-    fn resize(&mut self, _base: Base, _size: ElementSize) -> Option<ResolvedSize>;
+    fn resize(&mut self, _base: Base, _size: BoxSize) -> Option<ResolvedSize>;
+    fn update(&mut self, _base: Base, _delta: f32) {}
 
 }