AbleTK/abletk
1
1
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

click events! soon there will be buttons!

Browse source
This commit is contained in:
TheOddGarlic 2022-05-22 19:23:58 +03:00
parent dbf64e8b7f
commit 4a4b94ba2a
8 changed files with 315 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
src/application.rs
View file

@ -9,7 +9,7 @@
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use winit::event::{Event, WindowEvent as WinitWindowEvent};
use winit::event::{Event, WindowEvent as WinitWindowEvent, ElementState};
use winit::event_loop::EventLoop;
use winit::window::WindowId;
use crate::context::Context;
@ -107,14 +107,39 @@ impl Application {
emit_app_event!(self, ApplicationEvent::AllWindowsDestroyed);
}
}
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(),

4
src/layout/position.rs
View file

@ -19,6 +19,10 @@ impl Position {
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
}

75
src/widget/column.rs
View file

@ -6,8 +6,9 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
use crate::{layout::position::Position, widget::Widget};
use crate::{layout::position::Position, widget::Widget, window::Window};
use abletk_common::Renderer;
use winit::event::MouseButton;
pub struct Column {
widgets: Vec<Box<dyn Widget>>,
@ -43,6 +44,78 @@ 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 {

23
src/widget/label.rs
View file

@ -7,7 +7,8 @@
*/
use abletk_common::{Renderer, brush::Brush, color::Color, rgb};
use crate::{widget::Widget, layout::position::Position};
use winit::event::MouseButton;
use crate::{widget::Widget, layout::position::Position, window::Window};
pub struct Label {
text: String,
@ -28,6 +29,26 @@ 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 {

20
src/widget/mod.rs
View file

@ -16,11 +16,29 @@ pub use column::*;
pub use label::*;
pub use padding::*;
pub use row::*;
use winit::event::MouseButton;
use crate::layout::position::Position;
use crate::{layout::position::Position, window::Window};
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,
);
}

29
src/widget/padding.rs
View file

@ -6,8 +6,9 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
use crate::{layout::position::Position, widget::Widget};
use crate::{layout::position::Position, widget::Widget, window::Window};
use abletk_common::Renderer;
use winit::event::MouseButton;
pub struct Padding<W: Widget> {
widget: W,
@ -32,6 +33,32 @@ 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> {

75
src/widget/row.rs
View file

@ -6,8 +6,9 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
use crate::{layout::position::Position, widget::Widget};
use crate::{layout::position::Position, widget::Widget, window::Window};
use abletk_common::Renderer;
use winit::event::MouseButton;
pub struct Row {
widgets: Vec<Box<dyn Widget>>,
@ -43,6 +44,78 @@ 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 {

84
src/window.rs
View file

@ -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},
window::{Window as WinitWindow, WindowBuilder as WinitWindowBuilder}, dpi::PhysicalPosition, event::MouseButton,
};
use winit::dpi::PhysicalSize;
use winit::error::OsError;
@ -26,10 +26,11 @@ use crate::widget::Widget;
pub struct Window {
window: WinitWindow,
events: HashMap<Event, Vec<fn(&mut Context, &mut Window)>>,
root: Box<dyn Widget>,
root: Option<Box<dyn Widget>>,
ctx: Rc<RefCell<Context>>,
renderer: Renderer,
renderer: Option<Renderer>,
background: Color,
cursor_pos: (u32, u32),
}
impl Window {
@ -58,12 +59,13 @@ impl Window {
.build(event_loop)?;
Ok(Self {
renderer: Renderer::new(window.raw_window_handle()),
renderer: Some(Renderer::new(window.raw_window_handle())),
window,
background,
events,
root,
root: Some(root),
ctx,
cursor_pos: (0, 0),
})
}
@ -72,16 +74,14 @@ impl Window {
}
pub(crate) fn render(&mut self) {
let position = self.root.position(&mut self.renderer);
self.renderer.begin_draw();
self.renderer.clear(self.background);
self.renderer.position_at(position.x(), position.y());
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)
let root = self.root.as_ref().unwrap();
let renderer = self.renderer.as_mut().unwrap();
let position = root.position(renderer);
renderer.begin_draw();
renderer.clear(self.background);
renderer.position_at(position.x(), position.y());
root.draw(renderer);
renderer.end_draw()
}
pub fn focus(&self) {
@ -92,6 +92,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())
}
@ -109,12 +113,60 @@ 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.resized(size.width, size.height);
self.renderer.as_mut().unwrap().resized(size.width, size.height);
self.emit_event(Event::Resized)
}
}