waydeer
/
layer-shika
mirror of https://codeberg.org/dyrland/layer-shika.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor: minor refactor

WIP/draft
drendog 2024-08-14 23:24:41 +02:00
parent 0910670518
commit 3554b1684d
Signed by: dwenya
GPG Key ID: 8DD77074645332D0
8 changed files with 96 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/common.rs
View File

@ -6,13 +6,13 @@ pub struct LayerSize {
}
impl LayerSize {
pub fn new(width: u32, height: u32) -> Self {
pub const fn new(width: u32, height: u32) -> Self {
Self {
size: PhysicalSize::new(width, height),
}
}
pub fn physical_size(&self) -> PhysicalSize {
pub const fn physical_size(self) -> PhysicalSize {
self.size
}
}

2
src/lib.rs
View File

@ -2,4 +2,4 @@ mod common;
mod rendering;
mod windowing;
pub use windowing::WindowingSystemBuilder;
pub use windowing::WindowingSystemBuilder as LayerShika;

27
src/rendering/egl_context.rs
View File

@ -36,7 +36,7 @@ pub struct EGLContextBuilder {
#[allow(dead_code)]
impl EGLContextBuilder {
pub fn new() -> Self {
Default::default()
Self::default()
}
pub fn with_display_id(mut self, display_id: ObjectId) -> Self {
@ -49,17 +49,20 @@ impl EGLContextBuilder {
self
}
pub fn with_size(mut self, size: LayerSize) -> Self {
pub const fn with_size(mut self, size: LayerSize) -> Self {
self.size = Some(size);
self
}
pub fn with_config_template(mut self, config_template: ConfigTemplateBuilder) -> Self {
pub const fn with_config_template(mut self, config_template: ConfigTemplateBuilder) -> Self {
self.config_template = Some(config_template);
self
}
pub fn with_context_attributes(mut self, context_attributes: ContextAttributesBuilder) -> Self {
pub const fn with_context_attributes(
mut self,
context_attributes: ContextAttributesBuilder,
) -> Self {
self.context_attributes = Some(context_attributes);
self
}
@ -73,7 +76,7 @@ impl EGLContextBuilder {
.ok_or_else(|| anyhow!("Surface ID is required"))?;
let size = self.size.ok_or_else(|| anyhow!("Size is required"))?;
let display_handle = create_wayland_display_handle(display_id);
let display_handle = create_wayland_display_handle(&display_id);
let glutin_display = unsafe { Display::new(display_handle) }?;
let config_template = self.config_template.unwrap_or_default();
@ -84,7 +87,7 @@ impl EGLContextBuilder {
let context = create_context(&glutin_display, &config, context_attributes)?;
let surface_handle = create_surface_handle(surface_id);
let surface_handle = create_surface_handle(&surface_id);
let surface = create_surface(&glutin_display, &config, surface_handle, size)?;
let context = context
@ -108,9 +111,9 @@ impl EGLContext {
}
}
fn create_wayland_display_handle(display_id: ObjectId) -> RawDisplayHandle {
let display =
NonNull::new(display_id.as_ptr() as *mut c_void).expect("NonNull pointer creation failed");
fn create_wayland_display_handle(display_id: &ObjectId) -> RawDisplayHandle {
let display = NonNull::new(display_id.as_ptr().cast::<c_void>())
.expect("NonNull pointer creation failed");
let handle = WaylandDisplayHandle::new(display);
RawDisplayHandle::Wayland(handle)
}
@ -133,9 +136,9 @@ fn create_context(
.map_err(|e| anyhow!("Failed to create context: {}", e))
}
fn create_surface_handle(surface_id: ObjectId) -> RawWindowHandle {
let surface =
NonNull::new(surface_id.as_ptr() as *mut c_void).expect("NonNull pointer creation failed");
fn create_surface_handle(surface_id: &ObjectId) -> RawWindowHandle {
let surface = NonNull::new(surface_id.as_ptr().cast::<c_void>())
.expect("NonNull pointer creation failed");
let handle = WaylandWindowHandle::new(surface);
RawWindowHandle::Wayland(handle)
}

4
src/rendering/femtovg_window.rs
View File

@ -21,7 +21,7 @@ impl FemtoVGWindow {
Self {
window,
renderer,
is_dirty: Default::default(),
is_dirty: Cell::default(),
size: Cell::new(PhysicalSize::default()),
scale_factor: Cell::new(1.),
}
@ -31,7 +31,7 @@ impl FemtoVGWindow {
pub fn render_frame_if_dirty(&self) {
if self.is_dirty.get() {
match self.renderer.render() {
Ok(_) => {} //log::debug!("Frame rendered successfully"),
Ok(()) => {} //log::debug!("Frame rendered successfully"),
Err(e) => log::error!("Error rendering frame: {}", e),
}
self.is_dirty.set(false);

31
src/windowing/event_handler.rs
View File

@ -1,3 +1,4 @@
use super::state::WindowState;
use crate::impl_empty_dispatch;
use log::info;
use slint::platform::{PointerEventButton, WindowEvent};
@ -7,6 +8,7 @@ use smithay_client_toolkit::reexports::protocols_wlr::layer_shell::v1::client::{
};
use std::rc::Rc;
use std::{cell::RefCell, rc::Weak};
use wayland_client::WEnum;
use wayland_client::{
globals::GlobalListContents,
protocol::{
@ -17,12 +19,9 @@ use wayland_client::{
wl_seat::WlSeat,
wl_surface::WlSurface,
},
Connection, Dispatch, QueueHandle,
Connection, Dispatch, Proxy, QueueHandle,
};
use super::state::WindowState;
#[derive(Clone)]
pub struct WindowEventHandler {
state: Weak<RefCell<WindowState>>,
}
@ -36,7 +35,7 @@ impl WindowEventHandler {
self.state.upgrade().unwrap()
}
fn handle_pointer_enter(&mut self, surface_x: f64, surface_y: f64) {
fn handle_pointer_enter(&self, surface_x: f64, surface_y: f64) {
if let Some(state) = self.state.upgrade() {
state
.borrow()
@ -50,7 +49,7 @@ impl WindowEventHandler {
}
}
fn handle_pointer_leave(&mut self) {
fn handle_pointer_leave(&self) {
if let Some(state) = self.state.upgrade() {
if let Some(window) = state.borrow().window() {
window.dispatch_event(WindowEvent::PointerExited);
@ -58,7 +57,7 @@ impl WindowEventHandler {
}
}
fn handle_pointer_motion(&mut self, surface_x: f64, surface_y: f64) {
fn handle_pointer_motion(&self, surface_x: f64, surface_y: f64) {
if let Some(state) = self.state.upgrade() {
state
.borrow()
@ -72,15 +71,9 @@ impl WindowEventHandler {
}
}
fn handle_pointer_button(
&mut self,
button_state: wayland_client::WEnum<wl_pointer::ButtonState>,
) {
fn handle_pointer_button(&self, button_state: wayland_client::WEnum<wl_pointer::ButtonState>) {
if let Some(state) = self.state.upgrade() {
let is_press = matches!(
button_state,
wayland_client::WEnum::Value(wl_pointer::ButtonState::Pressed)
);
let is_press = matches!(button_state, WEnum::Value(wl_pointer::ButtonState::Pressed));
let current_position = state.borrow().current_pointer_position();
if let Some(window) = state.borrow().window() {
let event = if is_press {
@ -140,7 +133,7 @@ impl Dispatch<WlOutput, ()> for WindowEventHandler {
fn event(
state: &mut Self,
_proxy: &WlOutput,
event: <WlOutput as wayland_client::Proxy>::Event,
event: <WlOutput as Proxy>::Event,
_data: &(),
_conn: &Connection,
_qhandle: &QueueHandle<Self>,
@ -150,7 +143,9 @@ impl Dispatch<WlOutput, ()> for WindowEventHandler {
info!("WlOutput size changed to {}x{}", width, height);
if let Some(state) = state.state.upgrade() {
let state_borrow = state.borrow();
state_borrow.set_output_size(width as u32, height as u32);
let width = width.try_into().unwrap_or_default();
let height = height.try_into().unwrap_or_default();
state_borrow.set_output_size(width, height);
}
}
wl_output::Event::Description { ref description } => {
@ -186,7 +181,7 @@ impl Dispatch<WlPointer, ()> for WindowEventHandler {
fn event(
state: &mut Self,
_proxy: &WlPointer,
event: <WlPointer as wayland_client::Proxy>::Event,
event: <WlPointer as Proxy>::Event,
_data: &(),
_conn: &Connection,
_qhandle: &QueueHandle<Self>,

13
src/windowing/event_loop.rs
View File

@ -1,6 +1,6 @@
use anyhow::{anyhow, Result};
use log::{debug, error, info};
use smithay_client_toolkit::reexports::calloop::{self, EventLoop, Interest, Mode, PostAction};
use log::{debug, error};
use smithay_client_toolkit::reexports::calloop::{self, Interest, Mode, PostAction};
use std::cell::RefCell;
use std::rc::{Rc, Weak};
use wayland_client::{Connection, EventQueue};
@ -44,7 +44,7 @@ impl EventLoopHandler {
loop_handle
.insert_source(
calloop::generic::Generic::new(connection, Interest::READ, Mode::Level),
move |_, connection, _| {
move |_, connection, ()| {
let result: Result<PostAction, anyhow::Error> = (|| {
let wayland_queue = wayland_queue
.upgrade()
@ -75,13 +75,6 @@ impl EventLoopHandler {
Ok(())
}
pub fn run(&self, event_loop: &mut EventLoop<()>) -> Result<()> {
info!("Starting event loop");
event_loop
.run(None, &mut (), |_| {})
.map_err(|e| anyhow!("Failed to run event loop: {}", e))
}
fn handle_wayland_events(
connection: &Connection,
wayland_queue: &Rc<RefCell<EventQueue<WindowEventHandler>>>,

95
src/windowing/mod.rs
View File

@ -1,3 +1,11 @@
use self::{event_handler::WindowEventHandler, event_loop::EventLoopHandler, state::WindowState};
use crate::{
bind_globals,
common::LayerSize,
rendering::{
egl_context::EGLContext, femtovg_window::FemtoVGWindow, slint_platform::CustomSlintPlatform,
},
};
use anyhow::{Context, Result};
use log::{debug, info};
use slint::{platform::femtovg_renderer::FemtoVGRenderer, ComponentHandle, LogicalPosition};
@ -19,21 +27,11 @@ use wayland_client::{
Connection, EventQueue, Proxy, QueueHandle,
};
use crate::{
bind_globals,
common::LayerSize,
rendering::{
egl_context::EGLContext, femtovg_window::FemtoVGWindow, slint_platform::CustomSlintPlatform,
},
};
mod event_handler;
mod event_loop;
mod macros;
mod state;
use self::{event_handler::WindowEventHandler, event_loop::EventLoopHandler, state::WindowState};
pub struct WindowConfig {
height: u32,
layer: zwlr_layer_shell_v1::Layer,
@ -43,7 +41,7 @@ pub struct WindowConfig {
exclusive_zone: i32,
scale_factor: f32,
namespace: String,
component_definition: Option<Rc<ComponentDefinition>>,
component_definition: Option<ComponentDefinition>,
}
impl Default for WindowConfig {
@ -55,7 +53,7 @@ impl Default for WindowConfig {
anchor: Anchor::Top | Anchor::Left | Anchor::Right,
keyboard_interactivity: KeyboardInteractivity::OnDemand,
exclusive_zone: -1,
namespace: "layer-sheeka".to_string(),
namespace: "layer-shika".to_owned(),
scale_factor: 1.0,
component_definition: None,
}
@ -73,53 +71,69 @@ impl Default for WindowingSystemBuilder {
}
impl WindowingSystemBuilder {
#[must_use]
#[inline]
pub fn new() -> Self {
Self {
config: WindowConfig::default(),
}
}
pub fn with_height(mut self, height: u32) -> Self {
#[must_use]
pub const fn with_height(mut self, height: u32) -> Self {
self.config.height = height;
self
}
pub fn with_layer(mut self, layer: zwlr_layer_shell_v1::Layer) -> Self {
#[must_use]
#[inline]
pub const fn with_layer(mut self, layer: zwlr_layer_shell_v1::Layer) -> Self {
self.config.layer = layer;
self
}
pub fn with_margin(mut self, top: i32, right: i32, bottom: i32, left: i32) -> Self {
#[must_use]
#[inline]
pub const fn with_margin(mut self, top: i32, right: i32, bottom: i32, left: i32) -> Self {
self.config.margin = (top, right, bottom, left);
self
}
pub fn with_anchor(mut self, anchor: Anchor) -> Self {
#[must_use]
#[inline]
pub const fn with_anchor(mut self, anchor: Anchor) -> Self {
self.config.anchor = anchor;
self
}
pub fn with_keyboard_interactivity(mut self, interactivity: KeyboardInteractivity) -> Self {
#[must_use]
#[inline]
pub const fn with_keyboard_interactivity(
mut self,
interactivity: KeyboardInteractivity,
) -> Self {
self.config.keyboard_interactivity = interactivity;
self
}
pub fn with_exclusive_zone(mut self, zone: i32) -> Self {
#[must_use]
#[inline]
pub const fn with_exclusive_zone(mut self, zone: i32) -> Self {
self.config.exclusive_zone = zone;
self
}
#[must_use]
#[inline]
pub fn with_namespace(mut self, namespace: String) -> Self {
self.config.namespace = namespace;
self
}
pub fn with_scale_factor(mut self, scale_factor: f32) -> Self {
#[must_use]
#[inline]
pub const fn with_scale_factor(mut self, scale_factor: f32) -> Self {
self.config.scale_factor = scale_factor;
self
}
pub fn with_component_definition(mut self, component: Rc<ComponentDefinition>) -> Self {
#[must_use]
#[inline]
pub fn with_component_definition(mut self, component: ComponentDefinition) -> Self {
self.config.component_definition = Some(component);
self
}
@ -185,7 +199,8 @@ impl<'a> WindowingSystem<'a> {
system.wait_for_configure()?;
system.initialize_renderer_and_ui()?;
system.initialize_event_loop_handler()?;
system.initialize_event_loop_handler();
system.setup_event_sources()?;
Ok(system)
}
@ -253,14 +268,14 @@ impl<'a> WindowingSystem<'a> {
config.margin.2,
config.margin.3,
);
println!("Setting exclusive zone: {}", config.exclusive_zone);
layer_surface.set_exclusive_zone(config.exclusive_zone);
layer_surface.set_keyboard_interactivity(config.keyboard_interactivity);
layer_surface.set_size(1, config.height);
surface.commit();
}
fn wait_for_configure(&mut self) -> Result<()> {
fn wait_for_configure(&self) -> Result<()> {
info!("Waiting for surface to be configured...");
loop {
self.connection.flush()?;
@ -288,10 +303,10 @@ impl<'a> WindowingSystem<'a> {
.clone()
.ok_or_else(|| anyhow::anyhow!("Component definition not set"))?;
let (window, component_instance) =
self.initialize_slint_ui(renderer, component_definition)?;
self.initialize_slint_ui(renderer, &component_definition)?;
self.window = Some(window.clone());
self.state.borrow_mut().set_window(Rc::downgrade(&window));
self.state.borrow_mut().set_window(window);
self.component_instance = Some(component_instance);
Ok(())
@ -310,7 +325,7 @@ impl<'a> WindowingSystem<'a> {
.with_surface_id(surface.id())
.with_size(LayerSize::new(size.width, size.height))
.build()
.context("Failed to build EGL context")?;
.map_err(|e| anyhow::anyhow!("Failed to create EGL context: {:?}", e))?;
debug!("Creating FemtoVGRenderer");
FemtoVGRenderer::new(context).context("Failed to create FemtoVGRenderer")
@ -319,7 +334,7 @@ impl<'a> WindowingSystem<'a> {
fn initialize_slint_ui(
&self,
renderer: FemtoVGRenderer,
component_definition: Rc<ComponentDefinition>,
component_definition: &ComponentDefinition,
) -> Result<(Rc<FemtoVGWindow>, Rc<ComponentInstance>)> {
let femtovg_window = FemtoVGWindow::new(renderer);
let size = self.state.borrow().size();
@ -343,7 +358,7 @@ impl<'a> WindowingSystem<'a> {
Ok((femtovg_window, slint_component))
}
pub fn initialize_event_loop_handler(&mut self) -> Result<()> {
pub fn initialize_event_loop_handler(&mut self) {
let event_loop_handler = EventLoopHandler::new(
Rc::downgrade(self.window.as_ref().unwrap()),
Rc::downgrade(&self.event_queue),
@ -352,7 +367,6 @@ impl<'a> WindowingSystem<'a> {
);
self.event_loop_handler = Some(event_loop_handler);
Ok(())
}
pub fn setup_event_sources(&self) -> Result<()> {
@ -377,12 +391,9 @@ impl<'a> WindowingSystem<'a> {
window.render_frame_if_dirty();
}
let event_loop_handler = self
.event_loop_handler
.as_ref()
.ok_or_else(|| anyhow::anyhow!("EventLoopHandler not initialized"))?;
event_loop_handler.run(&mut self.event_loop)
self.event_loop
.run(None, &mut (), |()| {})
.map_err(|e| anyhow::anyhow!("Failed to run event loop: {}", e))
}
pub fn component_instance(&self) -> Option<Rc<ComponentInstance>> {
@ -397,7 +408,7 @@ impl<'a> WindowingSystem<'a> {
self.state.clone()
}
pub fn display(&self) -> &WlDisplay {
pub const fn display(&self) -> &WlDisplay {
&self.display
}
}

14
src/windowing/state.rs
View File

@ -1,4 +1,4 @@
use std::{cell::Cell, rc::Weak};
use std::cell::Cell;
use std::rc::Rc;
use log::info;
use slint::{LogicalPosition, PhysicalSize};
@ -14,7 +14,7 @@ pub struct WindowState {
size: Cell<PhysicalSize>,
output_size: Cell<PhysicalSize>,
pointer: Option<WlPointer>,
window: Option<Weak<FemtoVGWindow>>,
window: Option<Rc<FemtoVGWindow>>,
current_pointer_position: Cell<LogicalPosition>,
scale_factor: f32,
height: u32,
@ -54,7 +54,7 @@ impl WindowState {
}
if let Some(s) = self.surface.as_ref() {
s.commit()
s.commit();
}
}
@ -77,24 +77,24 @@ impl WindowState {
self.current_pointer_position.get()
}
pub fn window(&self) -> Option<Rc<FemtoVGWindow>> {
self.window.as_ref().and_then(|w| w.upgrade())
self.window.clone()
}
pub fn layer_surface(&self) -> Option<Rc<ZwlrLayerSurfaceV1>> {
self.layer_surface.clone()
}
pub fn surface(&self) -> Option<&WlSurface> {
pub const fn surface(&self) -> Option<&WlSurface> {
self.surface.as_ref()
}
pub fn height(&self) -> u32 {
pub const fn height(&self) -> u32 {
self.height
}
pub fn set_output_size(&self, width: u32, height: u32) {
self.output_size.set(PhysicalSize::new(width, height));
}
pub fn set_window(&mut self, window: Weak<FemtoVGWindow>) {
pub fn set_window(&mut self, window: Rc<FemtoVGWindow>) {
self.window = Some(window);
}