477 lines
14 KiB
Rust
477 lines
14 KiB
Rust
|
use std::{
|
||
|
|
fmt,
|
||
|
|
sync::{mpsc::Receiver, Arc, Mutex},
|
||
|
|
};
|
||
|
|
|
||
|
|
use cosmic::iced_native::{
|
||
|
|
command::Action,
|
||
|
|
event::Event,
|
||
|
|
keyboard::{Event as KeyboardEvent, Modifiers as IcedModifiers},
|
||
|
|
mouse::{Button as MouseButton, Event as MouseEvent, ScrollDelta},
|
||
|
|
program::{Program, State},
|
||
|
|
renderer::Style,
|
||
|
|
window::{Event as WindowEvent, Id},
|
||
|
|
Debug, Point as IcedPoint, Size as IcedSize,
|
||
|
|
};
|
||
|
|
pub use cosmic::Renderer as IcedRenderer;
|
||
|
|
use cosmic::Theme;
|
||
|
|
use iced_swbuf::{native::*, Backend};
|
||
|
|
|
||
|
|
use smithay::{
|
||
|
|
backend::{
|
||
|
|
input::{ButtonState, KeyState},
|
||
|
|
renderer::{
|
||
|
|
element::{
|
||
|
|
memory::{MemoryRenderBuffer, MemoryRenderBufferRenderElement},
|
||
|
|
AsRenderElements,
|
||
|
|
},
|
||
|
|
ImportMem, Renderer,
|
||
|
|
},
|
||
|
|
},
|
||
|
|
desktop::space::{RenderZindex, SpaceElement},
|
||
|
|
input::{
|
||
|
|
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
|
||
|
|
pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget},
|
||
|
|
Seat,
|
||
|
|
},
|
||
|
|
output::Output,
|
||
|
|
reexports::calloop::RegistrationToken,
|
||
|
|
reexports::calloop::{self, futures::Scheduler, LoopHandle},
|
||
|
|
utils::{IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size, Transform},
|
||
|
|
};
|
||
|
|
|
||
|
|
#[derive(Debug)]
|
||
|
|
pub struct IcedElement<P: Program<Renderer = IcedRenderer> + Send + 'static>(
|
||
|
|
Arc<Mutex<IcedElementInternal<P>>>,
|
||
|
|
);
|
||
|
|
|
||
|
|
// SAFETY: We cannot really be sure about `iced_native::program::State` sadly,
|
||
|
|
// but the rest should be fine.
|
||
|
|
unsafe impl<P: Program<Renderer = IcedRenderer> + Send + 'static> Send for IcedElementInternal<P> {}
|
||
|
|
|
||
|
|
impl<P: Program<Renderer = IcedRenderer> + Send + 'static> Clone for IcedElement<P> {
|
||
|
|
fn clone(&self) -> Self {
|
||
|
|
IcedElement(self.0.clone())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<P: Program<Renderer = IcedRenderer> + Send + 'static> PartialEq for IcedElement<P> {
|
||
|
|
fn eq(&self, other: &Self) -> bool {
|
||
|
|
Arc::ptr_eq(&self.0, &other.0)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
struct IcedElementInternal<P: Program<Renderer = IcedRenderer> + Send + 'static> {
|
||
|
|
// draw buffer
|
||
|
|
memory: MemoryRenderBuffer,
|
||
|
|
needs_redraw: bool,
|
||
|
|
|
||
|
|
// state
|
||
|
|
size: Size<i32, Logical>,
|
||
|
|
cursor_pos: Option<Point<f64, Logical>>,
|
||
|
|
|
||
|
|
// iced
|
||
|
|
theme: Theme,
|
||
|
|
renderer: IcedRenderer,
|
||
|
|
state: State<P>,
|
||
|
|
debug: Debug,
|
||
|
|
|
||
|
|
// futures
|
||
|
|
handle: LoopHandle<'static, crate::state::Data>,
|
||
|
|
scheduler: Scheduler<<P as Program>::Message>,
|
||
|
|
executor_token: Option<RegistrationToken>,
|
||
|
|
rx: Receiver<<P as Program>::Message>,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<P: Program<Renderer = IcedRenderer> + Send + 'static> fmt::Debug for IcedElementInternal<P> {
|
||
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||
|
|
f.debug_struct("IcedElementInternal")
|
||
|
|
.field("memory", &self.memory)
|
||
|
|
.field("needs_redraw", &self.needs_redraw)
|
||
|
|
.field("size", &self.size)
|
||
|
|
.field("cursor_pos", &self.cursor_pos)
|
||
|
|
.field("theme", &self.theme)
|
||
|
|
.finish_non_exhaustive()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<P: Program<Renderer = IcedRenderer> + Send + 'static> Drop for IcedElementInternal<P> {
|
||
|
|
fn drop(&mut self) {
|
||
|
|
self.handle.remove(self.executor_token.take().unwrap());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<P: Program<Renderer = IcedRenderer> + Send + 'static> IcedElement<P> {
|
||
|
|
pub fn new(
|
||
|
|
program: P,
|
||
|
|
size: impl Into<Size<i32, Logical>>,
|
||
|
|
scale: i32,
|
||
|
|
handle: LoopHandle<'static, crate::state::Data>,
|
||
|
|
) -> calloop::error::Result<IcedElement<P>> {
|
||
|
|
let size = size.into();
|
||
|
|
let buffer_size = size.to_buffer(scale, Transform::Normal);
|
||
|
|
|
||
|
|
let mut renderer = IcedRenderer::new(Backend::new());
|
||
|
|
let mut debug = Debug::new();
|
||
|
|
|
||
|
|
let state = State::new(
|
||
|
|
program,
|
||
|
|
IcedSize::new(size.w as f32, size.h as f32),
|
||
|
|
&mut renderer,
|
||
|
|
&mut debug,
|
||
|
|
);
|
||
|
|
|
||
|
|
let (executor, scheduler) = calloop::futures::executor()?;
|
||
|
|
let (tx, rx) = std::sync::mpsc::channel();
|
||
|
|
let executor_token = handle.insert_source(executor, |message, _, _| {
|
||
|
|
tx.send(message);
|
||
|
|
})?;
|
||
|
|
|
||
|
|
let mut internal = IcedElementInternal {
|
||
|
|
memory: MemoryRenderBuffer::new(buffer_size, scale, Transform::Normal, None),
|
||
|
|
needs_redraw: true,
|
||
|
|
size,
|
||
|
|
cursor_pos: None,
|
||
|
|
theme: Theme::Dark, // TODO
|
||
|
|
renderer,
|
||
|
|
state,
|
||
|
|
debug,
|
||
|
|
handle,
|
||
|
|
scheduler,
|
||
|
|
executor_token: Some(executor_token),
|
||
|
|
rx,
|
||
|
|
};
|
||
|
|
let _ = internal.update(true);
|
||
|
|
|
||
|
|
Ok(IcedElement(Arc::new(Mutex::new(internal))))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<P: Program<Renderer = IcedRenderer> + Send + 'static> IcedElementInternal<P> {
|
||
|
|
fn update(&mut self, mut force: bool) -> Vec<Action<<P as Program>::Message>> {
|
||
|
|
let cursor_pos = self.cursor_pos.unwrap_or(Point::from((-1.0, -1.0)));
|
||
|
|
|
||
|
|
while let Ok(message) = self.rx.try_recv() {
|
||
|
|
self.state.queue_message(message);
|
||
|
|
force = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if !force {
|
||
|
|
return Vec::new();
|
||
|
|
}
|
||
|
|
|
||
|
|
let actions = self
|
||
|
|
.state
|
||
|
|
.update(
|
||
|
|
IcedSize::new(self.size.w as f32, self.size.h as f32),
|
||
|
|
IcedPoint::new(cursor_pos.x as f32, cursor_pos.y as f32),
|
||
|
|
&mut self.renderer,
|
||
|
|
&self.theme,
|
||
|
|
&Style {
|
||
|
|
text_color: self.theme.palette().text,
|
||
|
|
},
|
||
|
|
&mut cosmic::iced_native::clipboard::Null,
|
||
|
|
&mut self.debug,
|
||
|
|
)
|
||
|
|
.1
|
||
|
|
.map(|command| command.actions());
|
||
|
|
|
||
|
|
if actions.is_some() {
|
||
|
|
self.needs_redraw = true;
|
||
|
|
}
|
||
|
|
let actions = actions.unwrap_or_default();
|
||
|
|
actions
|
||
|
|
.into_iter()
|
||
|
|
.filter_map(|action| {
|
||
|
|
if let Action::Future(future) = action {
|
||
|
|
let _ = self.scheduler.schedule(future);
|
||
|
|
None
|
||
|
|
} else {
|
||
|
|
Some(action)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
.collect::<Vec<_>>()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<P: Program<Renderer = IcedRenderer> + Send + 'static> PointerTarget<crate::state::State>
|
||
|
|
for IcedElement<P>
|
||
|
|
{
|
||
|
|
fn enter(
|
||
|
|
&self,
|
||
|
|
_seat: &Seat<crate::state::State>,
|
||
|
|
_data: &mut crate::state::State,
|
||
|
|
event: &MotionEvent,
|
||
|
|
) {
|
||
|
|
let mut internal = self.0.lock().unwrap();
|
||
|
|
internal
|
||
|
|
.state
|
||
|
|
.queue_event(Event::Mouse(MouseEvent::CursorEntered));
|
||
|
|
let position = IcedPoint::new(event.location.x as f32, event.location.y as f32);
|
||
|
|
internal
|
||
|
|
.state
|
||
|
|
.queue_event(Event::Mouse(MouseEvent::CursorMoved { position }));
|
||
|
|
internal.cursor_pos = Some(event.location);
|
||
|
|
let _ = internal.update(true); // TODO
|
||
|
|
}
|
||
|
|
|
||
|
|
fn motion(
|
||
|
|
&self,
|
||
|
|
_seat: &Seat<crate::state::State>,
|
||
|
|
_data: &mut crate::state::State,
|
||
|
|
event: &MotionEvent,
|
||
|
|
) {
|
||
|
|
let mut internal = self.0.lock().unwrap();
|
||
|
|
let position = IcedPoint::new(event.location.x as f32, event.location.y as f32);
|
||
|
|
internal
|
||
|
|
.state
|
||
|
|
.queue_event(Event::Mouse(MouseEvent::CursorMoved { position }));
|
||
|
|
internal.cursor_pos = Some(event.location);
|
||
|
|
let _ = internal.update(true); // TODO
|
||
|
|
}
|
||
|
|
|
||
|
|
fn button(
|
||
|
|
&self,
|
||
|
|
_seat: &Seat<crate::state::State>,
|
||
|
|
_data: &mut crate::state::State,
|
||
|
|
event: &ButtonEvent,
|
||
|
|
) {
|
||
|
|
let mut internal = self.0.lock().unwrap();
|
||
|
|
let button = match event.button {
|
||
|
|
0x110 => MouseButton::Left,
|
||
|
|
0x111 => MouseButton::Right,
|
||
|
|
0x112 => MouseButton::Middle,
|
||
|
|
x => MouseButton::Other(x as u8),
|
||
|
|
};
|
||
|
|
internal.state.queue_event(Event::Mouse(match event.state {
|
||
|
|
ButtonState::Pressed => MouseEvent::ButtonPressed(button),
|
||
|
|
ButtonState::Released => MouseEvent::ButtonReleased(button),
|
||
|
|
}));
|
||
|
|
let _ = internal.update(true); // TODO
|
||
|
|
}
|
||
|
|
|
||
|
|
fn axis(
|
||
|
|
&self,
|
||
|
|
_seat: &Seat<crate::state::State>,
|
||
|
|
_data: &mut crate::state::State,
|
||
|
|
frame: AxisFrame,
|
||
|
|
) {
|
||
|
|
let mut internal = self.0.lock().unwrap();
|
||
|
|
internal
|
||
|
|
.state
|
||
|
|
.queue_event(Event::Mouse(MouseEvent::WheelScrolled {
|
||
|
|
delta: if let Some(discrete) = frame.discrete {
|
||
|
|
ScrollDelta::Lines {
|
||
|
|
x: discrete.0 as f32,
|
||
|
|
y: discrete.1 as f32,
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
ScrollDelta::Pixels {
|
||
|
|
x: frame.axis.0 as f32,
|
||
|
|
y: frame.axis.1 as f32,
|
||
|
|
}
|
||
|
|
},
|
||
|
|
}));
|
||
|
|
let _ = internal.update(true); // TODO
|
||
|
|
}
|
||
|
|
|
||
|
|
fn leave(
|
||
|
|
&self,
|
||
|
|
_seat: &Seat<crate::state::State>,
|
||
|
|
_data: &mut crate::state::State,
|
||
|
|
_serial: Serial,
|
||
|
|
_time: u32,
|
||
|
|
) {
|
||
|
|
let mut internal = self.0.lock().unwrap();
|
||
|
|
internal
|
||
|
|
.state
|
||
|
|
.queue_event(Event::Mouse(MouseEvent::CursorLeft));
|
||
|
|
let _ = internal.update(true); // TODO
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<P: Program<Renderer = IcedRenderer> + Send + 'static> KeyboardTarget<crate::state::State>
|
||
|
|
for IcedElement<P>
|
||
|
|
{
|
||
|
|
fn enter(
|
||
|
|
&self,
|
||
|
|
_seat: &Seat<crate::state::State>,
|
||
|
|
_data: &mut crate::state::State,
|
||
|
|
_keys: Vec<KeysymHandle<'_>>,
|
||
|
|
_serial: Serial,
|
||
|
|
) {
|
||
|
|
// TODO convert keys
|
||
|
|
}
|
||
|
|
|
||
|
|
fn leave(
|
||
|
|
&self,
|
||
|
|
_seat: &Seat<crate::state::State>,
|
||
|
|
_data: &mut crate::state::State,
|
||
|
|
_serial: Serial,
|
||
|
|
) {
|
||
|
|
// TODO remove all held keys
|
||
|
|
}
|
||
|
|
|
||
|
|
fn key(
|
||
|
|
&self,
|
||
|
|
_seat: &Seat<crate::state::State>,
|
||
|
|
_data: &mut crate::state::State,
|
||
|
|
_key: KeysymHandle<'_>,
|
||
|
|
_state: KeyState,
|
||
|
|
_serial: Serial,
|
||
|
|
_time: u32,
|
||
|
|
) {
|
||
|
|
// TODO convert keys
|
||
|
|
}
|
||
|
|
|
||
|
|
fn modifiers(
|
||
|
|
&self,
|
||
|
|
_seat: &Seat<crate::state::State>,
|
||
|
|
_data: &mut crate::state::State,
|
||
|
|
modifiers: ModifiersState,
|
||
|
|
_serial: Serial,
|
||
|
|
) {
|
||
|
|
let mut internal = self.0.lock().unwrap();
|
||
|
|
let mut mods = IcedModifiers::empty();
|
||
|
|
if modifiers.shift {
|
||
|
|
mods.insert(IcedModifiers::SHIFT);
|
||
|
|
}
|
||
|
|
if modifiers.alt {
|
||
|
|
mods.insert(IcedModifiers::ALT);
|
||
|
|
}
|
||
|
|
if modifiers.ctrl {
|
||
|
|
mods.insert(IcedModifiers::CTRL);
|
||
|
|
}
|
||
|
|
if modifiers.logo {
|
||
|
|
mods.insert(IcedModifiers::LOGO);
|
||
|
|
}
|
||
|
|
internal
|
||
|
|
.state
|
||
|
|
.queue_event(Event::Keyboard(KeyboardEvent::ModifiersChanged(mods)));
|
||
|
|
let _ = internal.update(true); // TODO
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<P: Program<Renderer = IcedRenderer> + Send + 'static> IsAlive for IcedElement<P> {
|
||
|
|
fn alive(&self) -> bool {
|
||
|
|
true
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<P: Program<Renderer = IcedRenderer> + Send + 'static> SpaceElement for IcedElement<P> {
|
||
|
|
fn bbox(&self) -> Rectangle<i32, Logical> {
|
||
|
|
Rectangle::from_loc_and_size((0, 0), self.0.lock().unwrap().size)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn is_in_input_region(&self, _point: &Point<f64, Logical>) -> bool {
|
||
|
|
true
|
||
|
|
}
|
||
|
|
|
||
|
|
fn set_activate(&self, activated: bool) {
|
||
|
|
let mut internal = self.0.lock().unwrap();
|
||
|
|
internal.state.queue_event(Event::Window(
|
||
|
|
Id::MAIN,
|
||
|
|
if activated {
|
||
|
|
WindowEvent::Focused
|
||
|
|
} else {
|
||
|
|
WindowEvent::Unfocused
|
||
|
|
},
|
||
|
|
));
|
||
|
|
let _ = internal.update(true); // TODO
|
||
|
|
}
|
||
|
|
|
||
|
|
fn output_enter(&self, _output: &Output, _overlap: Rectangle<i32, Logical>) {
|
||
|
|
// TODO: Update scale, once supported to the highest one
|
||
|
|
}
|
||
|
|
|
||
|
|
fn output_leave(&self, _output: &Output) {
|
||
|
|
// TODO: Update scale, once supported to the highest one
|
||
|
|
}
|
||
|
|
|
||
|
|
fn z_index(&self) -> u8 {
|
||
|
|
// meh, user-provided?
|
||
|
|
RenderZindex::Shell as u8
|
||
|
|
}
|
||
|
|
|
||
|
|
fn refresh(&self) {}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<P, R> AsRenderElements<R> for IcedElement<P>
|
||
|
|
where
|
||
|
|
P: Program<Renderer = IcedRenderer> + Send + 'static,
|
||
|
|
R: Renderer + ImportMem,
|
||
|
|
<R as Renderer>::TextureId: 'static,
|
||
|
|
{
|
||
|
|
type RenderElement = MemoryRenderBufferRenderElement<R>;
|
||
|
|
|
||
|
|
fn render_elements<C: From<Self::RenderElement>>(
|
||
|
|
&self,
|
||
|
|
renderer: &mut R,
|
||
|
|
location: Point<i32, Physical>,
|
||
|
|
_scale: Scale<f64>,
|
||
|
|
) -> Vec<C> {
|
||
|
|
let mut internal = self.0.lock().unwrap();
|
||
|
|
|
||
|
|
let _ = internal.update(false); // TODO
|
||
|
|
|
||
|
|
// makes partial borrows easier
|
||
|
|
let internal_ref = &mut *internal;
|
||
|
|
if internal_ref.needs_redraw {
|
||
|
|
let renderer = &mut internal_ref.renderer;
|
||
|
|
let size = internal_ref.size;
|
||
|
|
internal_ref
|
||
|
|
.memory
|
||
|
|
.render()
|
||
|
|
.draw(move |buf| {
|
||
|
|
let mut target = raqote::DrawTarget::from_backing(
|
||
|
|
size.w,
|
||
|
|
size.h,
|
||
|
|
bytemuck::cast_slice_mut::<_, u32>(buf),
|
||
|
|
);
|
||
|
|
|
||
|
|
target.clear(raqote::SolidSource::from_unpremultiplied_argb(0, 0, 0, 0));
|
||
|
|
|
||
|
|
let draw_options = raqote::DrawOptions {
|
||
|
|
// Default to antialiasing off for now
|
||
|
|
antialias: raqote::AntialiasMode::None,
|
||
|
|
..Default::default()
|
||
|
|
};
|
||
|
|
|
||
|
|
// Having at least one clip fixes some font rendering issues
|
||
|
|
target.push_clip_rect(raqote::IntRect::new(
|
||
|
|
raqote::IntPoint::new(0, 0),
|
||
|
|
raqote::IntPoint::new(size.w, size.h),
|
||
|
|
));
|
||
|
|
|
||
|
|
renderer.with_primitives(|backend, primitives| {
|
||
|
|
for primitive in primitives.iter() {
|
||
|
|
draw_primitive(&mut target, &draw_options, backend, primitive);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
target.pop_clip();
|
||
|
|
|
||
|
|
Result::<_, ()>::Ok(vec![Rectangle::from_loc_and_size(
|
||
|
|
(0, 0),
|
||
|
|
size.to_buffer(1, Transform::Normal),
|
||
|
|
)])
|
||
|
|
})
|
||
|
|
.unwrap();
|
||
|
|
internal_ref.needs_redraw = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
let Ok(buffer) = MemoryRenderBufferRenderElement::from_buffer(
|
||
|
|
renderer,
|
||
|
|
location.to_f64(),
|
||
|
|
&internal.memory,
|
||
|
|
None,
|
||
|
|
None,
|
||
|
|
None,
|
||
|
|
slog_scope::logger(),
|
||
|
|
) else {
|
||
|
|
return Vec::new()
|
||
|
|
};
|
||
|
|
vec![C::from(buffer)]
|
||
|
|
}
|
||
|
|
}
|