abletk-cairo/src/lib.rs

@@ -22,6 +22,7 @@ pub struct Renderer {
 
 impl Renderer {
     pub fn new(handle: XlibHandle) -> Self {
+        println!("{:#?}", handle);
         let (width, height) = unsafe {
             let mut root = mem::zeroed();
             let mut x = mem::zeroed();
@@ -164,10 +165,27 @@ impl Renderer {
     }
 
     pub fn size(&self) -> (u32, u32) {
-        unsafe {(
+        unsafe {
-            cairo_xlib_surface_get_width(self.surface).try_into().unwrap(),
+            let mut root = mem::zeroed();
-            cairo_xlib_surface_get_height(self.surface).try_into().unwrap(),
+            let mut x = mem::zeroed();
-        )}
+            let mut y = mem::zeroed();
+            let mut width = mem::zeroed();
+            let mut height = mem::zeroed();
+            let mut border_width = mem::zeroed();
+            let mut depth = mem::zeroed();
+            assert_ne!(XGetGeometry(
+                self.handle.display as _,
+                self.handle.window.try_into().unwrap(),
+                &mut root,
+                &mut x,
+                &mut y,
+                &mut width,
+                &mut height,
+                &mut border_width,
+                &mut depth,
+            ), 0);
+            (width, height)
+        }
     }
 
     fn text_extents(&self, text: &str) -> TextExtents {

abletk-common/src/lib.rs

@@ -62,6 +62,7 @@ impl Renderer {
     }
 
     pub fn draw_text<S: AsRef<str>>(&self, text: S) {
+        eprintln!("drawing text at ({}, {})", self.x, self.y);
         self.renderer.draw_text(
             text.as_ref(),
             Rect::new(

abletk-direct2d/src/lib.rs

@@ -39,7 +39,7 @@ impl Renderer {
                 .unwrap()
         };
 
-        let mut renderer = Self {
+        Self {
             handle,
             factory,
             dw_factory,
@@ -48,12 +48,12 @@ impl Renderer {
             stroke_style,
             system_fonts,
             text_format,
-        };
+        }
-        renderer.setup_target();
-        renderer
     }
 
     pub fn begin_draw(&mut self) {
+        self.setup_target();
+
         unsafe { self.target.as_ref().unwrap().BeginDraw() }
     }
 

src/application.rs

@@ -9,7 +9,7 @@
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
-use winit::event::{Event, WindowEvent as WinitWindowEvent, ElementState};
+use winit::event::{Event, WindowEvent as WinitWindowEvent};
 use winit::event_loop::EventLoop;
 use winit::window::WindowId;
 use crate::context::Context;
@@ -104,42 +104,17 @@ impl Application {
                     self.windows.remove(&window_id);
 
                     if self.windows.is_empty() {
-                        emit_app_event!(self, ApplicationEvent::AllWindowsDestroyed);
+                        emit_app_event!(self, ApplicationEvent::AllWindowsClosed);
                     }
                 }
-
                 Event::WindowEvent {
                     window_id,
                     event: WinitWindowEvent::Resized(size)
                 } => self.windows.get_mut(&window_id).unwrap().resized(size),
-
-                Event::WindowEvent {
-                    window_id,
-                    event: WinitWindowEvent::CursorMoved {
-                        position,
-                        ..
-                    },
-                } => self.windows.get_mut(&window_id).unwrap().cursor_moved(position),
-
-                Event::WindowEvent {
-                    window_id,
-                    event: WinitWindowEvent::MouseInput {
-                        state,
-                        button,
-                        ..
-                    },
-                } => match state {
-                    ElementState::Pressed => self.windows
-                        .get_mut(&window_id).unwrap().mouse_pressed(button),
-                    ElementState::Released => self.windows
-                        .get_mut(&window_id).unwrap().mouse_released(button),
-                }
-
                 Event::MainEventsCleared => {
                     // determine if state changed and request redraw if needed
                     // rinse and repeat for every window
                 }
-
                 Event::RedrawRequested(window_id) =>
                     self.windows.get_mut(&window_id).unwrap().render(),
 

src/event/application.rs

@@ -9,5 +9,5 @@
 #[non_exhaustive]
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum Event {
-    AllWindowsDestroyed,
+    AllWindowsClosed,
 }

src/event/window.rs

@@ -10,5 +10,4 @@
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum Event {
     Closed,
-    Resized,
 }

src/layout/position.rs

@@ -18,10 +18,6 @@ impl Position {
     pub fn new(x: u32, y: u32, width: u32, height: u32) -> Self {
         Position { x, y, width, height }
     }
-
-    pub fn contains(&self, x: u32, y: u32) -> bool {
-        x >= self.x && y >= self.y && x < self.x + self.width && y < self.y + self.height
-    }
     
     pub fn x(&self) -> u32 {
         self.x

src/lib.rs

@@ -24,7 +24,7 @@ pub mod prelude {
     pub use crate::event::window::Event as WindowEvent;
     pub use crate::platform::Platform;
     pub use crate::widget::Column;
-    pub use crate::widget::Padded;
+    pub use crate::widget::IntoPadded;
     pub use crate::widget::Label;
     pub use crate::widget::Row;
     pub use crate::widget::Padding;

src/main.rs

@@ -20,10 +20,10 @@ fn launch() -> _ {
                 .add(Column::new()
                     .add(Label::new("World!"))
                     .add(Label::new("AbleTK!")))
-                .add(Label::new("this is a label!")
+                .add(Label::new("this is a label! jjjjyyy")
                     .bg_color(rgb!(0xFF0000FF)))
                 .padding_left(10))
-        .on_event(WindowEvent::Resized, |_, window| {
+        .on_event(WindowEvent::Closed, |_, window| {
-            println!("window resized: {:?}", window.size())
+            window.set_title("CLOSING!")
         }))
 }

src/plugin.rs

@@ -25,7 +25,7 @@ pub struct QuitPlugin;
 
 impl Plugin for QuitPlugin {
     fn apply(&self, app: Application) -> Application {
-        app.on_event(Event::AllWindowsDestroyed, |ctx| {
+        app.on_event(Event::AllWindowsClosed, |ctx| {
             if Platform::target() != Platform::MacOS {
                 ctx.quit()
             }

src/widget/column.rs

@@ -6,9 +6,8 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use crate::{layout::position::Position, widget::Widget, window::Window};
+use crate::{layout::position::Position, widget::Widget};
 use abletk_common::Renderer;
-use winit::event::MouseButton;
 
 pub struct Column {
     widgets: Vec<Box<dyn Widget>>,
@@ -44,78 +43,6 @@ impl Widget for Column {
 
         Position::new(0, 0, width, height)
     }
-
-    fn mouse_pressed(&mut self,
-        renderer: &mut Renderer,
-        window: &mut Window,
-        button: MouseButton,
-        x: u32,
-        y: u32,
-    ) {
-        let mut pos = Position::new(0, 0, 0, 0);
-        for widget in &mut self.widgets {
-            let widget_pos = widget.position(renderer);
-            pos = Position::new(
-                widget_pos.x(),
-                pos.y() + widget_pos.y(),
-                widget_pos.width(),
-                widget_pos.height(),
-            );
-
-            if pos.contains(x, y) {
-                widget.mouse_pressed(
-                    renderer,
-                    window,
-                    button,
-                    x - pos.x(),
-                    y - pos.y(),
-                );
-            }
-
-            pos = Position::new(
-                pos.x(),
-                pos.y() + widget_pos.height(),
-                pos.width(),
-                pos.height(),
-            )
-        }
-    }
-
-    fn mouse_released(&mut self,
-        renderer: &mut Renderer,
-        window: &mut Window,
-        button: MouseButton,
-        x: u32,
-        y: u32,
-    ) {
-        let mut pos = Position::new(0, 0, 0, 0);
-        for widget in &mut self.widgets {
-            let widget_pos = widget.position(renderer);
-            pos = Position::new(
-                widget_pos.x(),
-                pos.y() + widget_pos.y(),
-                widget_pos.width(),
-                widget_pos.height(),
-            );
-
-            if pos.contains(x, y) {
-                widget.mouse_released(
-                    renderer,
-                    window,
-                    button,
-                    x - pos.x(),
-                    y - pos.y(),
-                );
-            }
-
-            pos = Position::new(
-                pos.x(),
-                pos.y() + widget_pos.height(),
-                pos.width(),
-                pos.height(),
-            )
-        }
-    }
 }
 
 impl Column {

src/widget/label.rs

@@ -7,8 +7,7 @@
  */
 
 use abletk_common::{Renderer, brush::Brush, color::Color, rgb};
-use winit::event::MouseButton;
+use crate::{widget::Widget, layout::position::Position};
-use crate::{widget::Widget, layout::position::Position, window::Window};
 
 pub struct Label {
     text: String,
@@ -29,26 +28,6 @@ impl Widget for Label {
         let (width, height) = renderer.get_text_size(&self.text);
         Position::new(0, 0, width, height)
     }
-
-    fn mouse_pressed(&mut self,
-        renderer: &mut Renderer,
-        window: &mut Window,
-        button: MouseButton,
-        x: u32,
-        y: u32,
-    ) {
-        eprintln!("Label::mouse_pressed {} {x}, {y}", self.text);
-    }
-
-    fn mouse_released(&mut self,
-        renderer: &mut Renderer,
-        window: &mut Window,
-        button: MouseButton,
-        x: u32,
-        y: u32,
-    ) {
-        eprintln!("Label::mouse_released {} {x}, {y}", self.text);
-    }
 }
 
 impl Label {

src/widget/mod.rs

@@ -16,29 +16,11 @@ pub use column::*;
 pub use label::*;
 pub use padding::*;
 pub use row::*;
-use winit::event::MouseButton;
 
-use crate::{layout::position::Position, window::Window};
+use crate::layout::position::Position;
 
 pub trait Widget {
     fn draw(&self, renderer: &mut Renderer);
-
     // fixme: don't pass renderer
     fn position(&self, renderer: &mut Renderer) -> Position;
-
-    fn mouse_pressed(&mut self,
-        renderer: &mut Renderer,
-        window: &mut Window,
-        button: MouseButton,
-        x: u32,
-        y: u32,
-    );
-
-    fn mouse_released(&mut self,
-        renderer: &mut Renderer,
-        window: &mut Window,
-        button: MouseButton,
-        x: u32,
-        y: u32,
-    );
 }

src/widget/padding.rs

@@ -6,9 +6,8 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use crate::{layout::position::Position, widget::Widget, window::Window};
+use crate::{layout::position::Position, widget::Widget};
 use abletk_common::Renderer;
-use winit::event::MouseButton;
 
 pub struct Padding<W: Widget> {
     widget: W,
@@ -33,32 +32,6 @@ impl<W: Widget> Widget for Padding<W> {
             pos.height() + self.bottom,
         )
     }
-
-    fn mouse_pressed(&mut self,
-        renderer: &mut Renderer,
-        window: &mut Window,
-        button: MouseButton,
-        x: u32,
-        y: u32,
-    ) {
-        let pos = self.position(renderer);
-        if pos.contains(x, y) {
-            self.widget.mouse_pressed(renderer, window, button, x - pos.x(), y - pos.y());
-        }
-    }
-
-    fn mouse_released(&mut self,
-        renderer: &mut Renderer,
-        window: &mut Window,
-        button: MouseButton,
-        x: u32,
-        y: u32,
-    ) {
-        let pos = self.position(renderer);
-        if pos.contains(x, y) {
-            self.widget.mouse_released(renderer, window, button, x - pos.x(), y - pos.y());
-        }
-    }
 }
 
 impl<W: Widget> Padding<W> {
@@ -79,7 +52,7 @@ impl<W: Widget> Padding<W> {
     }
 }
 
-pub trait Padded<W: Widget> {
+pub trait IntoPadded<W: Widget> {
     fn padding(self, left: u32, right: u32, top: u32, bottom: u32) -> Padding<W>;
     fn padding_x(self, left: u32, right: u32) -> Padding<W>;
     fn padding_y(self, top: u32, bottom: u32) -> Padding<W>;
@@ -90,7 +63,7 @@ pub trait Padded<W: Widget> {
     fn padding_all(self, padding: u32) -> Padding<W>;
 }
 
-impl<W: Widget> Padded<W> for W {
+impl<W: Widget> IntoPadded<W> for W {
     fn padding(self, left: u32, right: u32, top: u32, bottom: u32) -> Padding<W> {
         Padding::new(left, right, top, bottom, self)
     }

src/widget/row.rs

@@ -6,9 +6,8 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use crate::{layout::position::Position, widget::Widget, window::Window};
+use crate::{layout::position::Position, widget::Widget};
 use abletk_common::Renderer;
-use winit::event::MouseButton;
 
 pub struct Row {
     widgets: Vec<Box<dyn Widget>>,
@@ -44,78 +43,6 @@ impl Widget for Row {
 
         Position::new(0, 0, width, height)
     }
-
-    fn mouse_pressed(&mut self,
-        renderer: &mut Renderer,
-        window: &mut Window,
-        button: MouseButton,
-        x: u32,
-        y: u32,
-    ) {
-        let mut pos = Position::new(0, 0, 0, 0);
-        for widget in &mut self.widgets {
-            let widget_pos = widget.position(renderer);
-            pos = Position::new(
-                widget_pos.x() + pos.x(),
-                widget_pos.y(),
-                widget_pos.width(),
-                widget_pos.height(),
-            );
-
-            if pos.contains(x, y) {
-                widget.mouse_pressed(
-                    renderer,
-                    window,
-                    button,
-                    x - pos.x(),
-                    y - pos.y(),
-                );
-            }
-
-            pos = Position::new(
-                pos.x() + widget_pos.width(),
-                pos.y(),
-                pos.width(),
-                pos.height(),
-            );
-        }
-    }
-
-    fn mouse_released(&mut self,
-        renderer: &mut Renderer,
-        window: &mut Window,
-        button: MouseButton,
-        x: u32,
-        y: u32,
-    ) {
-        let mut pos = Position::new(0, 0, 0, 0);
-        for widget in &mut self.widgets {
-            let widget_pos = widget.position(renderer);
-            pos = Position::new(
-                widget_pos.x() + pos.x(),
-                widget_pos.y(),
-                widget_pos.width(),
-                widget_pos.height(),
-            );
-
-            if pos.contains(x, y) {
-                widget.mouse_released(
-                    renderer,
-                    window,
-                    button,
-                    x - pos.x(),
-                    y - pos.y(),
-                );
-            }
-
-            pos = Position::new(
-                pos.x() + widget_pos.width(),
-                pos.y(),
-                pos.width(),
-                pos.height(),
-            );
-        }
-    }
 }
 
 impl Row {

src/window.rs

@@ -12,7 +12,7 @@ use std::rc::Rc;
 use raw_window_handle::HasRawWindowHandle;
 use winit::{
     event_loop::EventLoopWindowTarget,
-    window::{Window as WinitWindow, WindowBuilder as WinitWindowBuilder}, dpi::PhysicalPosition, event::MouseButton,
+    window::{Window as WinitWindow, WindowBuilder as WinitWindowBuilder},
 };
 use winit::dpi::PhysicalSize;
 use winit::error::OsError;
@@ -26,11 +26,10 @@ use crate::widget::Widget;
 pub struct Window {
     window: WinitWindow,
     events: HashMap<Event, Vec<fn(&mut Context, &mut Window)>>,
-    root: Option<Box<dyn Widget>>,
+    root: Box<dyn Widget>,
     ctx: Rc<RefCell<Context>>,
-    renderer: Option<Renderer>,
+    renderer: Renderer,
     background: Color,
-    cursor_pos: (u32, u32),
 }
 
 impl Window {
@@ -59,13 +58,12 @@ impl Window {
             .build(event_loop)?;
 
         Ok(Self {
-            renderer: Some(Renderer::new(window.raw_window_handle())),
+            renderer: Renderer::new(window.raw_window_handle()),
             window,
             background,
             events,
-            root: Some(root),
+            root,
             ctx,
-            cursor_pos: (0, 0),
         })
     }
 
@@ -74,14 +72,19 @@ impl Window {
     }
 
     pub(crate) fn render(&mut self) {
-        let root = self.root.as_ref().unwrap();
+        let position = self.root.position(&mut self.renderer);
-        let renderer = self.renderer.as_mut().unwrap();
+        eprintln!("Rendering window with id {:?}", self.id());
-        let position = root.position(renderer);
+        eprintln!("Root widget position: {position:?}");
-        renderer.begin_draw();
+
-        renderer.clear(self.background);
+        self.renderer.begin_draw();
-        renderer.position_at(position.x(), position.y());
+        self.renderer.clear(self.background);
-        root.draw(renderer);
+        self.renderer.position_at(position.x(), position.y());
-        renderer.end_draw()
+        self.root.draw(&mut self.renderer);
+        self.renderer.end_draw()
+    }
+
+    pub fn set_always_on_top(&self, value: bool) {
+        self.window.set_always_on_top(value)
     }
 
     pub fn focus(&self) {
@@ -92,19 +95,10 @@ impl Window {
         self.window.request_redraw()
     }
 
-    pub fn set_always_on_top(&self, value: bool) {
-        self.window.set_always_on_top(value)
-    }
-
     pub fn set_title<S: AsRef<str> + Into<String>>(&mut self, title: S) {
         self.window.set_title(title.as_ref())
     }
 
-    pub fn size(&self) -> (u32, u32) {
-        let size = self.window.inner_size();
-        (size.width, size.height)
-    }
-
     pub(crate) fn emit_event(&mut self, event: Event) {
         if let Some(handlers) = self.events.get(&event) {
             let ctx = self.ctx.clone();
@@ -113,61 +107,12 @@ impl Window {
         }
     }
 
-    pub(crate) fn cursor_moved(&mut self, pos: PhysicalPosition<f64>) {
-        self.cursor_pos = (pos.x as u32, pos.y as u32)
-    }
-
     pub(crate) fn id(&self) -> WindowId {
         self.window.id()
     }
 
-    pub(crate) fn mouse_pressed(&mut self, button: MouseButton) {
-        if self.root
-            .as_ref()
-            .unwrap()
-            .position(self.renderer.as_mut().unwrap())
-            .contains(self.cursor_pos.0, self.cursor_pos.1)
-        {
-            let mut root = self.root.take().unwrap();
-            let mut renderer = self.renderer.take().unwrap();
-            root.mouse_pressed(
-                &mut renderer,
-                self,
-                button,
-                self.cursor_pos.0,
-                self.cursor_pos.1,
-            );
-
-            self.root = Some(root);
-            self.renderer = Some(renderer);
-        }
-    }
-
-    pub(crate) fn mouse_released(&mut self, button: MouseButton) {
-        if self.root
-            .as_ref()
-            .unwrap()
-            .position(self.renderer.as_mut().unwrap())
-            .contains(self.cursor_pos.0, self.cursor_pos.1)
-        {
-            let mut root = self.root.take().unwrap();
-            let mut renderer = self.renderer.take().unwrap();
-            root.mouse_released(
-                &mut renderer,
-                self,
-                button,
-                self.cursor_pos.0,
-                self.cursor_pos.1,
-            );
-
-            self.root = Some(root);
-            self.renderer = Some(renderer);
-        }
-    }
-
     pub(crate) fn resized(&mut self, size: PhysicalSize<u32>) {
-        self.renderer.as_mut().unwrap().resized(size.width, size.height);
+        self.renderer.resized(size.width, size.height)
-        self.emit_event(Event::Resized)
     }
 }