style: consistent import format

.github/workflows/ci.yml

@@ -51,7 +51,7 @@ jobs:
                   key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
 
             - name: Check formatting
-              run: cargo fmt --all -- --check
+              run: cargo +nightly fmt --all -- --check
 
             - name: Run clippy
               run: cargo clippy --workspace --all-targets -- -D warnings

.rustfmt.toml

@@ -0,0 +1,2 @@
+imports_granularity = "Module"
+group_imports = "StdExternalCrate"

crates/adapters/src/errors.rs

@@ -1,14 +1,14 @@
-use layer_shika_domain::errors::DomainError;
-use slint::{PlatformError, platform::SetPlatformError};
-use smithay_client_toolkit::reexports::calloop;
 use std::error::Error;
 use std::result::Result as StdResult;
+
+use layer_shika_domain::errors::DomainError;
+use slint::PlatformError;
+use slint::platform::SetPlatformError;
+use smithay_client_toolkit::reexports::calloop;
 use thiserror::Error;
 use wayland_client::backend::WaylandError;
-use wayland_client::{
-    ConnectError, DispatchError,
-    globals::{BindError, GlobalError},
-};
+use wayland_client::globals::{BindError, GlobalError};
+use wayland_client::{ConnectError, DispatchError};
 
 pub type Result<T> = StdResult<T, LayerShikaError>;
 

crates/adapters/src/lib.rs

@@ -5,7 +5,6 @@ pub(crate) mod rendering;
 pub(crate) mod wayland;
 
 pub use rendering::femtovg::popup_window::PopupWindow;
-
 pub use wayland::config::{MultiSurfaceConfig, ShellSurfaceConfig, WaylandSurfaceConfig};
 pub use wayland::ops::WaylandSystemOps;
 pub use wayland::session_lock::{
@@ -28,15 +27,13 @@ pub(crate) mod logger {
 }
 
 pub mod platform {
-    pub use slint;
-    pub use slint_interpreter;
+    pub use {slint, slint_interpreter};
 
     pub mod calloop {
-        pub use smithay_client_toolkit::reexports::calloop::channel;
         pub use smithay_client_toolkit::reexports::calloop::generic::Generic;
         pub use smithay_client_toolkit::reexports::calloop::timer::{TimeoutAction, Timer};
         pub use smithay_client_toolkit::reexports::calloop::{
-            EventSource, InsertError, Interest, Mode, PostAction, RegistrationToken,
+            EventSource, InsertError, Interest, Mode, PostAction, RegistrationToken, channel,
         };
     }
 

crates/adapters/src/rendering/egl/context.rs

@@ -1,33 +1,28 @@
-use crate::{
-    errors::{EGLError, LayerShikaError, Result},
-    logger,
-};
-use glutin::{
-    api::egl::{
-        config::Config,
-        context::{NotCurrentContext, PossiblyCurrentContext},
-        display::Display,
-        surface::Surface,
-    },
-    config::ConfigTemplateBuilder,
-    context::ContextAttributesBuilder,
-    display::GetGlDisplay,
-    prelude::*,
-    surface::{SurfaceAttributesBuilder, WindowSurface},
-};
+use std::error::Error;
+use std::ffi::{self, CStr, c_void};
+use std::num::NonZeroU32;
+use std::ptr::NonNull;
+use std::result::Result as StdResult;
+
+use glutin::api::egl::config::Config;
+use glutin::api::egl::context::{NotCurrentContext, PossiblyCurrentContext};
+use glutin::api::egl::display::Display;
+use glutin::api::egl::surface::Surface;
+use glutin::config::ConfigTemplateBuilder;
+use glutin::context::ContextAttributesBuilder;
+use glutin::display::GetGlDisplay;
+use glutin::prelude::*;
+use glutin::surface::{SurfaceAttributesBuilder, WindowSurface};
 use raw_window_handle::{
     RawDisplayHandle, RawWindowHandle, WaylandDisplayHandle, WaylandWindowHandle,
 };
-use slint::{PhysicalSize, platform::femtovg_renderer::OpenGLInterface};
-use std::{
-    error::Error,
-    ffi::{self, CStr, c_void},
-    num::NonZeroU32,
-    ptr::NonNull,
-    result::Result as StdResult,
-};
+use slint::PhysicalSize;
+use slint::platform::femtovg_renderer::OpenGLInterface;
 use wayland_client::backend::ObjectId;
 
+use crate::errors::{EGLError, LayerShikaError, Result};
+use crate::logger;
+
 pub struct EGLContext {
     surface: Surface<WindowSurface>,
     context: PossiblyCurrentContext,

crates/adapters/src/rendering/egl/context_factory.rs

@@ -1,20 +1,23 @@
-use super::context::EGLContext;
-use super::render_context_manager::RenderContextManager;
-use crate::{
-    errors::{EGLError, LayerShikaError, Result},
-    logger,
-};
-use glutin::{
-    api::egl::{config::Config, display::Display, surface::Surface},
-    context::ContextAttributesBuilder,
-    prelude::*,
-    surface::{SurfaceAttributesBuilder, WindowSurface},
-};
+use std::ffi::c_void;
+use std::num::NonZeroU32;
+use std::ptr::NonNull;
+use std::rc::Rc;
+
+use glutin::api::egl::config::Config;
+use glutin::api::egl::display::Display;
+use glutin::api::egl::surface::Surface;
+use glutin::context::ContextAttributesBuilder;
+use glutin::prelude::*;
+use glutin::surface::{SurfaceAttributesBuilder, WindowSurface};
 use raw_window_handle::{RawWindowHandle, WaylandWindowHandle};
 use slint::PhysicalSize;
-use std::{ffi::c_void, num::NonZeroU32, ptr::NonNull, rc::Rc};
 use wayland_client::backend::ObjectId;
 
+use super::context::EGLContext;
+use super::render_context_manager::RenderContextManager;
+use crate::errors::{EGLError, LayerShikaError, Result};
+use crate::logger;
+
 pub struct RenderContextFactory {
     manager: Rc<RenderContextManager>,
 }

crates/adapters/src/rendering/egl/render_context_manager.rs

@@ -1,17 +1,19 @@
-use crate::{
-    errors::{EGLError, LayerShikaError, Result},
-    logger,
-};
-use glutin::{
-    api::egl::{config::Config, context::PossiblyCurrentContext, display::Display},
-    config::ConfigTemplateBuilder,
-    context::ContextAttributesBuilder,
-    prelude::*,
-};
+use std::ffi::c_void;
+use std::ptr::NonNull;
+use std::rc::Rc;
+
+use glutin::api::egl::config::Config;
+use glutin::api::egl::context::PossiblyCurrentContext;
+use glutin::api::egl::display::Display;
+use glutin::config::ConfigTemplateBuilder;
+use glutin::context::ContextAttributesBuilder;
+use glutin::prelude::*;
 use raw_window_handle::{RawDisplayHandle, WaylandDisplayHandle};
-use std::{ffi::c_void, ptr::NonNull, rc::Rc};
 use wayland_client::backend::ObjectId;
 
+use crate::errors::{EGLError, LayerShikaError, Result};
+use crate::logger;
+
 pub struct RenderContextManager {
     display: Display,
     config: Config,

crates/adapters/src/rendering/femtovg/main_window.rs

@@ -1,16 +1,15 @@
-use super::renderable_window::{RenderState, RenderableWindow};
-use crate::{
-    errors::{RenderingError, Result},
-    logger,
-};
 use core::ops::Deref;
-use slint::{
-    PhysicalSize, Window, WindowSize,
-    platform::{Renderer, WindowAdapter, WindowEvent, femtovg_renderer::FemtoVGRenderer},
-};
 use std::cell::Cell;
 use std::rc::{Rc, Weak};
 
+use slint::platform::femtovg_renderer::FemtoVGRenderer;
+use slint::platform::{Renderer, WindowAdapter, WindowEvent};
+use slint::{PhysicalSize, Window, WindowSize};
+
+use super::renderable_window::{RenderState, RenderableWindow};
+use crate::errors::{RenderingError, Result};
+use crate::logger;
+
 pub struct FemtoVGWindow {
     window: Window,
     renderer: FemtoVGRenderer,

crates/adapters/src/rendering/femtovg/popup_window.rs

@@ -1,17 +1,18 @@
+use core::ops::Deref;
+use std::cell::{Cell, OnceCell, RefCell};
+use std::rc::{Rc, Weak};
+
+use layer_shika_domain::dimensions::LogicalSize;
+use layer_shika_domain::value_objects::handle::PopupHandle;
+use slint::platform::femtovg_renderer::FemtoVGRenderer;
+use slint::platform::{Renderer, WindowAdapter, WindowEvent};
+use slint::{PhysicalSize, Window, WindowSize};
+use slint_interpreter::ComponentInstance;
+
 use super::renderable_window::{RenderState, RenderableWindow};
 use crate::errors::{RenderingError, Result};
 use crate::logger;
 use crate::wayland::surfaces::popup_manager::OnCloseCallback;
-use core::ops::Deref;
-use layer_shika_domain::dimensions::LogicalSize;
-use layer_shika_domain::value_objects::handle::PopupHandle;
-use slint::{
-    PhysicalSize, Window, WindowSize,
-    platform::{Renderer, WindowAdapter, WindowEvent, femtovg_renderer::FemtoVGRenderer},
-};
-use slint_interpreter::ComponentInstance;
-use std::cell::{Cell, OnceCell, RefCell};
-use std::rc::{Rc, Weak};
 
 /// Represents the rendering lifecycle state of a popup window
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

crates/adapters/src/rendering/femtovg/renderable_window.rs

@@ -1,10 +1,10 @@
-use crate::errors::Result;
-use slint::{
-    PhysicalSize, WindowSize,
-    platform::{WindowAdapter, WindowEvent},
-};
 use std::cell::Cell;
 
+use slint::platform::{WindowAdapter, WindowEvent};
+use slint::{PhysicalSize, WindowSize};
+
+use crate::errors::Result;
+
 pub enum RenderState {
     Clean,
     Dirty,

crates/adapters/src/rendering/slint_integration/platform.rs

@@ -1,11 +1,11 @@
-use slint::{
-    PlatformError,
-    platform::{Platform, WindowAdapter},
-};
 use std::cell::{OnceCell, RefCell};
 use std::rc::Rc;
 
-use crate::{logger, rendering::femtovg::main_window::FemtoVGWindow};
+use slint::PlatformError;
+use slint::platform::{Platform, WindowAdapter};
+
+use crate::logger;
+use crate::rendering::femtovg::main_window::FemtoVGWindow;
 
 type PopupCreator = dyn Fn() -> Result<Rc<dyn WindowAdapter>, PlatformError>;
 

crates/adapters/src/wayland/input/keyboard.rs

@@ -1,13 +1,13 @@
-use crate::wayland::surfaces::keyboard_state::{KeyboardState, keysym_to_text};
-use slint::{SharedString, platform::WindowEvent};
-use wayland_client::{
-    Proxy,
-    backend::ObjectId,
-    protocol::{wl_keyboard, wl_surface::WlSurface},
-};
+use slint::SharedString;
+use slint::platform::WindowEvent;
+use wayland_client::Proxy;
+use wayland_client::backend::ObjectId;
+use wayland_client::protocol::wl_keyboard;
+use wayland_client::protocol::wl_surface::WlSurface;
 use xkbcommon::xkb;
 
 use super::state::KeyboardInputState;
+use crate::wayland::surfaces::keyboard_state::{KeyboardState, keysym_to_text};
 
 pub trait KeyboardEventTarget {
     fn dispatch_event(&self, event: WindowEvent);

crates/adapters/src/wayland/input/pointer.rs

@@ -1,12 +1,12 @@
-use crate::wayland::surfaces::pointer_utils::wayland_button_to_slint;
-use slint::{LogicalPosition, platform::WindowEvent};
-use wayland_client::{
-    Proxy, WEnum,
-    backend::ObjectId,
-    protocol::{wl_pointer, wl_surface::WlSurface},
-};
+use slint::LogicalPosition;
+use slint::platform::WindowEvent;
+use wayland_client::backend::ObjectId;
+use wayland_client::protocol::wl_pointer;
+use wayland_client::protocol::wl_surface::WlSurface;
+use wayland_client::{Proxy, WEnum};
 
 use super::state::PointerInputState;
+use crate::wayland::surfaces::pointer_utils::wayland_button_to_slint;
 
 pub trait PointerEventTarget {
     fn to_logical_position(&self, surface_x: f64, surface_y: f64) -> LogicalPosition;

crates/adapters/src/wayland/ops.rs

@@ -1,14 +1,15 @@
+use std::rc::Rc;
+
+use layer_shika_domain::value_objects::lock_config::LockConfig;
+use layer_shika_domain::value_objects::lock_state::LockState;
+use layer_shika_domain::value_objects::output_handle::OutputHandle;
+use slint_interpreter::{CompilationResult, ComponentInstance, Value};
+use smithay_client_toolkit::reexports::calloop::LoopHandle;
+
 use crate::errors::Result;
 use crate::wayland::config::ShellSurfaceConfig;
 use crate::wayland::session_lock::{LockPropertyOperation, OutputFilter};
 use crate::wayland::surfaces::app_state::AppState;
-use layer_shika_domain::value_objects::lock_config::LockConfig;
-use layer_shika_domain::value_objects::lock_state::LockState;
-use layer_shika_domain::value_objects::output_handle::OutputHandle;
-use slint_interpreter::Value;
-use slint_interpreter::{CompilationResult, ComponentInstance};
-use smithay_client_toolkit::reexports::calloop::LoopHandle;
-use std::rc::Rc;
 
 type SessionLockCallback = Rc<dyn Fn(&[Value]) -> Value>;
 

crates/adapters/src/wayland/outputs.rs

@@ -1,8 +1,8 @@
-use layer_shika_domain::value_objects::output_handle::OutputHandle;
 use std::collections::HashMap;
-use wayland_client::backend::ObjectId;
 
+use layer_shika_domain::value_objects::output_handle::OutputHandle;
 pub(crate) use output_manager::{OutputManager, OutputManagerContext};
+use wayland_client::backend::ObjectId;
 pub(crate) mod output_manager;
 
 pub(crate) struct OutputMapping {

crates/adapters/src/wayland/session_lock/lock_context.rs

@@ -1,15 +1,17 @@
-use crate::rendering::egl::context_factory::RenderContextFactory;
-use crate::wayland::surfaces::app_state::AppState;
 use std::rc::Rc;
-use wayland_client::{
-    QueueHandle,
-    protocol::{wl_compositor::WlCompositor, wl_output::WlOutput, wl_seat::WlSeat},
-};
+
+use wayland_client::QueueHandle;
+use wayland_client::protocol::wl_compositor::WlCompositor;
+use wayland_client::protocol::wl_output::WlOutput;
+use wayland_client::protocol::wl_seat::WlSeat;
 use wayland_protocols::ext::session_lock::v1::client::ext_session_lock_manager_v1::ExtSessionLockManagerV1;
 use wayland_protocols::ext::session_lock::v1::client::ext_session_lock_v1::ExtSessionLockV1;
 use wayland_protocols::wp::fractional_scale::v1::client::wp_fractional_scale_manager_v1::WpFractionalScaleManagerV1;
 use wayland_protocols::wp::viewporter::client::wp_viewporter::WpViewporter;
 
+use crate::rendering::egl::context_factory::RenderContextFactory;
+use crate::wayland::surfaces::app_state::AppState;
+
 #[derive(Clone)]
 pub struct SessionLockContext {
     compositor: WlCompositor,

crates/adapters/src/wayland/session_lock/lock_surface.rs

@@ -1,10 +1,15 @@
-use crate::{logger, wayland::session_lock::lock_context::LockSurfaceParams};
 use std::rc::Rc;
-use wayland_client::{Proxy, backend::ObjectId, protocol::wl_surface::WlSurface};
+
+use wayland_client::Proxy;
+use wayland_client::backend::ObjectId;
+use wayland_client::protocol::wl_surface::WlSurface;
 use wayland_protocols::ext::session_lock::v1::client::ext_session_lock_surface_v1::ExtSessionLockSurfaceV1;
 use wayland_protocols::wp::fractional_scale::v1::client::wp_fractional_scale_v1::WpFractionalScaleV1;
 use wayland_protocols::wp::viewporter::client::wp_viewport::WpViewport;
 
+use crate::logger;
+use crate::wayland::session_lock::lock_context::LockSurfaceParams;
+
 pub struct LockSurface {
     surface: Rc<WlSurface>,
     session_surface: Rc<ExtSessionLockSurfaceV1>,

crates/adapters/src/wayland/session_lock/manager/callbacks.rs

@@ -1,8 +1,10 @@
-use crate::errors::{LayerShikaError, Result};
+use std::rc::Rc;
+
 use layer_shika_domain::value_objects::output_handle::OutputHandle;
 use layer_shika_domain::value_objects::output_info::OutputInfo;
 use slint_interpreter::{ComponentInstance, Value};
-use std::rc::Rc;
+
+use crate::errors::{LayerShikaError, Result};
 
 pub(crate) trait FilterContext {
     fn matches_filter(&self, filter: &dyn Fn(&Self) -> bool) -> bool {

crates/adapters/src/wayland/session_lock/manager/input_handling.rs

@@ -1,3 +1,11 @@
+use slint::LogicalPosition;
+use slint::platform::WindowEvent;
+use wayland_client::WEnum;
+use wayland_client::backend::ObjectId;
+use wayland_client::protocol::wl_surface::WlSurface;
+use wayland_client::protocol::{wl_keyboard, wl_pointer};
+
+use super::state::ActiveLockSurface;
 use crate::wayland::input::keyboard::{
     handle_keyboard_enter as shared_keyboard_enter, handle_keyboard_key as shared_keyboard_key,
     handle_keyboard_leave as shared_keyboard_leave,
@@ -14,14 +22,6 @@ use crate::wayland::input::{
     PointerInputState, PointerSurfaceResolver,
 };
 use crate::wayland::surfaces::keyboard_state::KeyboardState;
-use slint::{LogicalPosition, platform::WindowEvent};
-use wayland_client::{
-    WEnum,
-    backend::ObjectId,
-    protocol::{wl_keyboard, wl_pointer, wl_surface::WlSurface},
-};
-
-use super::state::ActiveLockSurface;
 
 pub(super) struct InputState {
     pub pointer: PointerInputState,

crates/adapters/src/wayland/session_lock/manager/lifecycle.rs

@@ -1,13 +1,14 @@
+use std::rc::Rc;
+
+use slint::platform::WindowAdapter;
+use slint::platform::femtovg_renderer::FemtoVGRenderer;
+use slint::{LogicalPosition, LogicalSize, WindowPosition, WindowSize};
+use wayland_client::backend::ObjectId;
+
 use crate::errors::{LayerShikaError, Result};
 use crate::rendering::femtovg::main_window::FemtoVGWindow;
 use crate::rendering::femtovg::renderable_window::RenderableWindow;
 use crate::wayland::session_lock::lock_context::SessionLockContext;
-use slint::{
-    LogicalPosition, LogicalSize, WindowPosition, WindowSize, platform::WindowAdapter,
-    platform::femtovg_renderer::FemtoVGRenderer,
-};
-use std::rc::Rc;
-use wayland_client::backend::ObjectId;
 
 pub(super) fn create_window(
     context: &SessionLockContext,

crates/adapters/src/wayland/session_lock/manager/mod.rs

@@ -4,36 +4,33 @@ pub mod lifecycle;
 pub mod rendering;
 pub mod state;
 
-use crate::rendering::slint_integration::platform::CustomSlintPlatform;
-use crate::wayland::rendering::RenderableSet;
-use crate::wayland::session_lock::lock_context::SessionLockContext;
-use crate::wayland::session_lock::lock_surface::LockSurface;
-use crate::wayland::surfaces::app_state::AppState;
-use crate::wayland::surfaces::keyboard_state::KeyboardState;
-use crate::{
-    errors::{LayerShikaError, Result},
-    logger,
-};
-use layer_shika_domain::prelude::OutputInfo;
-use layer_shika_domain::value_objects::lock_config::LockConfig;
-use layer_shika_domain::value_objects::lock_state::LockState;
-use slint_interpreter::{CompilationResult, ComponentDefinition, ComponentInstance};
 use std::rc::Rc;
-use wayland_client::{
-    Proxy, QueueHandle, WEnum,
-    backend::ObjectId,
-    protocol::{wl_keyboard, wl_output::WlOutput, wl_pointer, wl_surface::WlSurface},
-};
-use wayland_protocols::ext::session_lock::v1::client::ext_session_lock_v1::ExtSessionLockV1;
 
 pub use callbacks::{
     LockCallback, LockPropertyOperation, OutputFilter,
     create_lock_property_operation_with_output_filter,
 };
+use layer_shika_domain::prelude::OutputInfo;
+use layer_shika_domain::value_objects::lock_config::LockConfig;
+use layer_shika_domain::value_objects::lock_state::LockState;
+use slint_interpreter::{CompilationResult, ComponentDefinition, ComponentInstance};
 pub use state::{ActiveLockSurface, LockConfigureContext, LockSurfaceOutputContext};
+use wayland_client::backend::ObjectId;
+use wayland_client::protocol::wl_output::WlOutput;
+use wayland_client::protocol::wl_surface::WlSurface;
+use wayland_client::protocol::{wl_keyboard, wl_pointer};
+use wayland_client::{Proxy, QueueHandle, WEnum};
+use wayland_protocols::ext::session_lock::v1::client::ext_session_lock_v1::ExtSessionLockV1;
 
 use self::input_handling::InputState;
-use crate::wayland::session_lock::lock_context::LockSurfaceParams;
+use crate::errors::{LayerShikaError, Result};
+use crate::logger;
+use crate::rendering::slint_integration::platform::CustomSlintPlatform;
+use crate::wayland::rendering::RenderableSet;
+use crate::wayland::session_lock::lock_context::{LockSurfaceParams, SessionLockContext};
+use crate::wayland::session_lock::lock_surface::LockSurface;
+use crate::wayland::surfaces::app_state::AppState;
+use crate::wayland::surfaces::keyboard_state::KeyboardState;
 
 pub struct SessionLockManager {
     context: Rc<SessionLockContext>,

crates/adapters/src/wayland/session_lock/manager/rendering.rs

@@ -1,7 +1,7 @@
-use crate::errors::Result;
 use wayland_client::backend::ObjectId;
 
 use super::state::ActiveLockSurface;
+use crate::errors::Result;
 
 pub(super) fn render_frames(lock_surfaces: &[(ObjectId, ActiveLockSurface)]) -> Result<()> {
     for (_, surface) in lock_surfaces {

crates/adapters/src/wayland/session_lock/manager/state.rs

@@ -1,4 +1,15 @@
-use super::callbacks::{LockCallbackContext, LockCallbackExt, LockPropertyOperationExt};
+use std::rc::Rc;
+
+use layer_shika_domain::surface_dimensions::SurfaceDimensions;
+use layer_shika_domain::value_objects::output_handle::OutputHandle;
+use layer_shika_domain::value_objects::output_info::OutputInfo;
+use slint::platform::{WindowAdapter, WindowEvent};
+use slint::{LogicalPosition, LogicalSize, WindowSize};
+use slint_interpreter::{CompilationResult, ComponentDefinition};
+
+use super::callbacks::{
+    LockCallback, LockCallbackContext, LockCallbackExt, LockPropertyOperationExt,
+};
 use crate::errors::Result;
 use crate::logger;
 use crate::rendering::femtovg::main_window::FemtoVGWindow;
@@ -7,17 +18,6 @@ use crate::rendering::slint_integration::platform::CustomSlintPlatform;
 use crate::wayland::session_lock::lock_surface::LockSurface;
 use crate::wayland::surfaces::component_state::ComponentState;
 use crate::wayland::surfaces::display_metrics::DisplayMetrics;
-use layer_shika_domain::surface_dimensions::SurfaceDimensions;
-use layer_shika_domain::value_objects::output_handle::OutputHandle;
-use layer_shika_domain::value_objects::output_info::OutputInfo;
-use slint::{
-    LogicalPosition, LogicalSize, WindowSize,
-    platform::{WindowAdapter, WindowEvent},
-};
-use slint_interpreter::{CompilationResult, ComponentDefinition};
-use std::rc::Rc;
-
-use super::callbacks::LockCallback;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum LockScalingMode {

crates/adapters/src/wayland/surfaces/app_state.rs

@@ -1,3 +1,22 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::os::fd::BorrowedFd;
+use std::rc::Rc;
+
+use layer_shika_domain::entities::output_registry::OutputRegistry;
+use layer_shika_domain::value_objects::handle::SurfaceHandle;
+use layer_shika_domain::value_objects::lock_config::LockConfig;
+use layer_shika_domain::value_objects::lock_state::LockState;
+use layer_shika_domain::value_objects::output_handle::OutputHandle;
+use layer_shika_domain::value_objects::output_info::OutputInfo;
+use slint_interpreter::{CompilationResult, ComponentDefinition, Value};
+use wayland_client::Proxy;
+use wayland_client::backend::ObjectId;
+use wayland_client::protocol::wl_keyboard;
+use wayland_client::protocol::wl_output::WlOutput;
+use wayland_client::protocol::wl_surface::WlSurface;
+use xkbcommon::xkb;
+
 use super::event_context::SharedPointerSerial;
 use super::keyboard_state::KeyboardState;
 use super::surface_state::SurfaceState;
@@ -17,22 +36,6 @@ use crate::wayland::session_lock::manager::callbacks::{
 use crate::wayland::session_lock::{
     LockCallback, LockPropertyOperation, OutputFilter, SessionLockManager,
 };
-use layer_shika_domain::entities::output_registry::OutputRegistry;
-use layer_shika_domain::value_objects::handle::SurfaceHandle;
-use layer_shika_domain::value_objects::lock_config::LockConfig;
-use layer_shika_domain::value_objects::lock_state::LockState;
-use layer_shika_domain::value_objects::output_handle::OutputHandle;
-use layer_shika_domain::value_objects::output_info::OutputInfo;
-use slint_interpreter::{CompilationResult, ComponentDefinition, Value};
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::os::fd::BorrowedFd;
-use std::rc::Rc;
-use wayland_client::Proxy;
-use wayland_client::backend::ObjectId;
-use wayland_client::protocol::wl_keyboard;
-use wayland_client::protocol::{wl_output::WlOutput, wl_surface::WlSurface};
-use xkbcommon::xkb;
 
 pub type PerOutputSurface = SurfaceState;
 type SessionLockCallback = Rc<dyn Fn(&[Value]) -> Value>;

crates/adapters/src/wayland/surfaces/component_state.rs

@@ -1,8 +1,10 @@
-use crate::errors::{LayerShikaError, Result};
-use crate::rendering::femtovg::main_window::FemtoVGWindow;
+use std::rc::Rc;
+
 use slint::ComponentHandle;
 use slint_interpreter::{CompilationResult, ComponentDefinition, ComponentInstance};
-use std::rc::Rc;
+
+use crate::errors::{LayerShikaError, Result};
+use crate::rendering::femtovg::main_window::FemtoVGWindow;
 
 pub struct ComponentState {
     component_instance: ComponentInstance,

crates/adapters/src/wayland/surfaces/display_metrics.rs

@@ -1,4 +1,6 @@
-use crate::logger;
+use std::cell::RefCell;
+use std::rc::Rc;
+
 use layer_shika_domain::dimensions::{
     LogicalSize as DomainLogicalSize, PhysicalSize as DomainPhysicalSize,
     ScaleFactor as DomainScaleFactor,
@@ -6,8 +8,8 @@ use layer_shika_domain::dimensions::{
 use layer_shika_domain::errors::Result as DomainResult;
 use layer_shika_domain::surface_dimensions::SurfaceDimensions;
 use slint::PhysicalSize;
-use std::cell::RefCell;
-use std::rc::Rc;
+
+use crate::logger;
 
 pub struct DisplayMetrics {
     surface: SurfaceDimensions,

crates/adapters/src/wayland/surfaces/event_context.rs

@@ -1,17 +1,18 @@
+use std::cell::Cell;
+use std::rc::Rc;
+
+use slint::platform::{WindowAdapter, WindowEvent};
+use slint::{LogicalPosition, PhysicalSize};
+use wayland_client::Proxy;
+use wayland_client::backend::ObjectId;
+use wayland_client::protocol::wl_pointer;
+use wayland_client::protocol::wl_surface::WlSurface;
+use wayland_protocols::wp::fractional_scale::v1::client::wp_fractional_scale_v1::WpFractionalScaleV1;
+
 use crate::rendering::femtovg::main_window::FemtoVGWindow;
 use crate::wayland::input::PointerInputState;
 use crate::wayland::surfaces::display_metrics::SharedDisplayMetrics;
 use crate::wayland::surfaces::popup_manager::{ActiveWindow, PopupManager};
-use slint::platform::{WindowAdapter, WindowEvent};
-use slint::{LogicalPosition, PhysicalSize};
-use std::cell::Cell;
-use std::rc::Rc;
-use wayland_client::{
-    Proxy,
-    backend::ObjectId,
-    protocol::{wl_pointer, wl_surface::WlSurface},
-};
-use wayland_protocols::wp::fractional_scale::v1::client::wp_fractional_scale_v1::WpFractionalScaleV1;
 
 pub struct SharedPointerSerial {
     serial: Cell<u32>,

crates/adapters/src/wayland/surfaces/keyboard_state.rs

@@ -1,4 +1,5 @@
-use slint::{SharedString, platform::Key};
+use slint::SharedString;
+use slint::platform::Key;
 use xkbcommon::xkb;
 
 pub struct KeyboardState {

crates/composition/src/event_loop.rs

@@ -1,14 +1,16 @@
-use crate::{Error, Result};
+use std::cell::RefCell;
+use std::os::unix::io::AsFd;
+use std::rc::{Rc, Weak};
+use std::time::{Duration, Instant};
+
 use layer_shika_adapters::errors::EventLoopError;
 use layer_shika_adapters::platform::calloop::{
     EventSource, Generic, Interest, Mode, PostAction, RegistrationToken, TimeoutAction, Timer,
     channel,
 };
 use layer_shika_adapters::{AppState, WaylandSystemOps};
-use std::cell::RefCell;
-use std::os::unix::io::AsFd;
-use std::rc::{Rc, Weak};
-use std::time::{Duration, Instant};
+
+use crate::{Error, Result};
 
 pub trait FromAppState<'a> {
     fn from_app_state(app_state: &'a mut AppState) -> Self;

crates/composition/src/lib.rs

@@ -15,14 +15,14 @@ mod surface_registry;
 mod system;
 pub mod value_conversion;
 
-use layer_shika_adapters::errors::LayerShikaError;
-use layer_shika_domain::errors::DomainError;
 use std::result::Result as StdResult;
 
 pub use event_loop::{EventLoopHandle, ShellEventLoop};
 pub use layer_shika_adapters::PopupWindow;
+use layer_shika_adapters::errors::LayerShikaError;
 pub use layer_shika_adapters::platform::{slint, slint_interpreter};
 pub use layer_shika_domain::entities::output_registry::OutputRegistry;
+use layer_shika_domain::errors::DomainError;
 pub use layer_shika_domain::prelude::AnchorStrategy;
 pub use layer_shika_domain::value_objects::anchor::AnchorEdges;
 pub use layer_shika_domain::value_objects::handle::{Handle, PopupHandle, SurfaceHandle};
@@ -31,14 +31,16 @@ pub use layer_shika_domain::value_objects::layer::Layer;
 pub use layer_shika_domain::value_objects::output_handle::OutputHandle;
 pub use layer_shika_domain::value_objects::output_info::{OutputGeometry, OutputInfo};
 pub use layer_shika_domain::value_objects::output_policy::OutputPolicy;
-pub use layer_shika_domain::value_objects::surface_instance_id::SurfaceInstanceId;
-pub use layer_shika_domain::value_objects::{
-    output_target::OutputTarget,
-    popup_behavior::{ConstraintAdjustment, OutputMigrationPolicy, PopupBehavior},
-    popup_config::PopupConfig,
-    popup_position::{Alignment, AnchorPoint, Offset, PopupPosition},
-    popup_size::PopupSize,
+pub use layer_shika_domain::value_objects::output_target::OutputTarget;
+pub use layer_shika_domain::value_objects::popup_behavior::{
+    ConstraintAdjustment, OutputMigrationPolicy, PopupBehavior,
 };
+pub use layer_shika_domain::value_objects::popup_config::PopupConfig;
+pub use layer_shika_domain::value_objects::popup_position::{
+    Alignment, AnchorPoint, Offset, PopupPosition,
+};
+pub use layer_shika_domain::value_objects::popup_size::PopupSize;
+pub use layer_shika_domain::value_objects::surface_instance_id::SurfaceInstanceId;
 pub use layer_surface::{LayerSurfaceHandle, ShellSurfaceConfigHandler};
 pub use lock_selection::LockSelection;
 pub use popup::PopupShell;
@@ -46,21 +48,18 @@ pub use popup_builder::{Bound, PopupBuilder, Unbound};
 pub use selection::{PropertyError, Selection, SelectionResult};
 pub use selector::{Output, Selector, Surface, SurfaceInfo};
 pub use session_lock::{SessionLock, SessionLockBuilder};
+pub use shell::{
+    DEFAULT_COMPONENT_NAME, Shell, ShellBuilder, ShellEventContext, SurfaceConfigBuilder,
+};
+pub use shell_config::{CompiledUiSource, ShellConfig, SurfaceComponentConfig};
 pub use shell_runtime::{DEFAULT_SURFACE_NAME, ShellRuntime};
+pub use surface_registry::{SurfaceDefinition, SurfaceEntry, SurfaceMetadata, SurfaceRegistry};
 pub use system::{
     CallbackContext, EventDispatchContext, RuntimeSurfaceConfigBuilder, ShellControl,
     SurfaceControlHandle, SurfaceTarget,
 };
 pub use value_conversion::IntoValue;
 
-pub use shell::{
-    DEFAULT_COMPONENT_NAME, Shell, ShellBuilder, ShellEventContext, SurfaceConfigBuilder,
-};
-
-pub use surface_registry::{SurfaceDefinition, SurfaceEntry, SurfaceMetadata, SurfaceRegistry};
-
-pub use shell_config::{CompiledUiSource, ShellConfig, SurfaceComponentConfig};
-
 pub(crate) mod logger {
     #[cfg(all(feature = "log", feature = "tracing"))]
     compile_error!("Cannot use both logging backend at one time");
@@ -99,6 +98,13 @@ pub enum Error {
 }
 
 pub mod prelude {
+    pub use layer_shika_adapters::platform::wayland::Anchor;
+    pub use layer_shika_domain::prelude::{
+        LogicalPosition, LogicalRect, LogicalSize, Margins, PhysicalSize, ScaleFactor,
+        SurfaceConfig, SurfaceDimension, UiSource,
+    };
+
+    pub use crate::calloop::{Generic, Interest, Mode, PostAction, RegistrationToken, Timer};
     pub use crate::{
         AnchorEdges, AnchorStrategy, CompiledUiSource, DEFAULT_COMPONENT_NAME,
         DEFAULT_SURFACE_NAME, EventDispatchContext, EventLoopHandle, Handle, IntoValue,
@@ -109,17 +115,6 @@ pub mod prelude {
         ShellConfig, ShellControl, ShellEventContext, ShellEventLoop, ShellRuntime,
         ShellSurfaceConfigHandler, Surface, SurfaceComponentConfig, SurfaceConfigBuilder,
         SurfaceControlHandle, SurfaceDefinition, SurfaceEntry, SurfaceHandle, SurfaceInfo,
-        SurfaceMetadata, SurfaceRegistry,
+        SurfaceMetadata, SurfaceRegistry, slint, slint_interpreter,
     };
-
-    pub use crate::calloop::{Generic, Interest, Mode, PostAction, RegistrationToken, Timer};
-
-    pub use crate::{slint, slint_interpreter};
-
-    pub use layer_shika_domain::prelude::{
-        LogicalPosition, LogicalRect, LogicalSize, Margins, PhysicalSize, ScaleFactor,
-        SurfaceConfig, SurfaceDimension, UiSource,
-    };
-
-    pub use layer_shika_adapters::platform::wayland::Anchor;
 }

crates/composition/src/lock_selection.rs

@@ -1,12 +1,11 @@
 // TODO: Maybe refactor to reuse the layer shell selector
 
-use crate::{
-    Error, logger,
-    selector::{Selector, SurfaceInfo},
-    slint_interpreter::{ComponentInstance, Value},
-};
 use layer_shika_domain::errors::DomainError;
 
+use crate::selector::{Selector, SurfaceInfo};
+use crate::slint_interpreter::{ComponentInstance, Value};
+use crate::{Error, logger};
+
 /// A selection of session lock surfaces matching a selector
 ///
 /// Provides methods to interact with all matching lock surfaces at once.

crates/composition/src/popup/mod.rs

@@ -1,11 +1,12 @@
-use crate::popup_builder::{Bound, PopupBuilder};
-use crate::system::{PopupCommand, ShellCommand, ShellControl};
-use crate::{Error, Result};
 use layer_shika_adapters::platform::calloop::channel;
 use layer_shika_domain::errors::DomainError;
 use layer_shika_domain::value_objects::handle::PopupHandle;
 use layer_shika_domain::value_objects::popup_config::PopupConfig;
 
+use crate::popup_builder::{Bound, PopupBuilder};
+use crate::system::{PopupCommand, ShellCommand, ShellControl};
+use crate::{Error, Result};
+
 #[derive(Clone)]
 pub struct PopupShell {
     sender: channel::Sender<ShellCommand>,

crates/composition/src/popup_builder.rs

@@ -1,5 +1,3 @@
-use crate::Result;
-use crate::popup::PopupShell;
 use layer_shika_domain::dimensions::LogicalRect;
 use layer_shika_domain::value_objects::handle::PopupHandle;
 use layer_shika_domain::value_objects::output_target::OutputTarget;
@@ -10,6 +8,9 @@ use layer_shika_domain::value_objects::popup_position::{
 };
 use layer_shika_domain::value_objects::popup_size::PopupSize;
 
+use crate::Result;
+use crate::popup::PopupShell;
+
 /// Type state indicating the builder is not bound to a shell
 pub struct Unbound;
 

crates/composition/src/selection.rs

@@ -1,11 +1,9 @@
-use crate::{
-    Error, LayerSurfaceHandle, Shell, logger,
-    selector::{Selector, SurfaceInfo},
-    slint_interpreter::{ComponentInstance, Value},
-};
-use layer_shika_domain::{
-    errors::DomainError, value_objects::surface_instance_id::SurfaceInstanceId,
-};
+use layer_shika_domain::errors::DomainError;
+use layer_shika_domain::value_objects::surface_instance_id::SurfaceInstanceId;
+
+use crate::selector::{Selector, SurfaceInfo};
+use crate::slint_interpreter::{ComponentInstance, Value};
+use crate::{Error, LayerSurfaceHandle, Shell, logger};
 
 /// Result of a property operation on a single surface
 #[derive(Debug)]

crates/composition/src/selector.rs

@@ -1,8 +1,10 @@
-use crate::{OutputHandle, OutputInfo};
-use layer_shika_domain::value_objects::surface_instance_id::SurfaceInstanceId;
 use std::fmt::{Debug, Formatter, Result as FmtResult};
 use std::sync::Arc;
 
+use layer_shika_domain::value_objects::surface_instance_id::SurfaceInstanceId;
+
+use crate::{OutputHandle, OutputInfo};
+
 /// Runtime information about a surface instance
 #[derive(Debug, Clone)]
 pub struct SurfaceInfo {

crates/composition/src/session_lock.rs

@@ -1,9 +1,6 @@
-use crate::IntoValue;
-use crate::calloop::channel;
-use crate::logger;
-use crate::slint_interpreter::Value;
-use crate::system::{SessionLockCommand, ShellCommand};
-use crate::{Error, Result};
+use std::cell::RefCell;
+use std::rc::{Rc, Weak};
+
 use layer_shika_adapters::WaylandSystemOps;
 use layer_shika_domain::dimensions::ScaleFactor;
 use layer_shika_domain::errors::DomainError;
@@ -11,9 +8,11 @@ use layer_shika_domain::value_objects::lock_config::LockConfig;
 use layer_shika_domain::value_objects::lock_state::LockState;
 use layer_shika_domain::value_objects::margins::Margins;
 use layer_shika_domain::value_objects::output_policy::OutputPolicy;
-use std::cell::RefCell;
-use std::rc::Rc;
-use std::rc::Weak;
+
+use crate::calloop::channel;
+use crate::slint_interpreter::Value;
+use crate::system::{SessionLockCommand, ShellCommand};
+use crate::{Error, IntoValue, Result, logger};
 
 pub struct SessionLock {
     system: Weak<RefCell<dyn WaylandSystemOps>>,

crates/composition/src/shell.rs

@@ -1,15 +1,7 @@
-use crate::event_loop::{EventLoopHandle, FromAppState};
-use crate::layer_surface::LayerSurfaceHandle;
-use crate::session_lock::{SessionLock, SessionLockBuilder};
-use crate::shell_config::{CompiledUiSource, ShellConfig};
-use crate::shell_runtime::ShellRuntime;
-use crate::surface_registry::{SurfaceDefinition, SurfaceEntry, SurfaceRegistry};
-use crate::system::{
-    CallbackContext, EventDispatchContext, PopupCommand, SessionLockCommand, ShellCommand,
-    ShellControl, SurfaceCommand, SurfaceTarget,
-};
-use crate::value_conversion::IntoValue;
-use crate::{Error, Result, logger};
+use std::cell::RefCell;
+use std::path::{Path, PathBuf};
+use std::rc::{Rc, Weak};
+
 use layer_shika_adapters::errors::EventLoopError;
 use layer_shika_adapters::platform::calloop::channel;
 use layer_shika_adapters::platform::slint_interpreter::{
@@ -29,9 +21,19 @@ use layer_shika_domain::value_objects::output_handle::OutputHandle;
 use layer_shika_domain::value_objects::output_info::OutputInfo;
 use layer_shika_domain::value_objects::surface_instance_id::SurfaceInstanceId;
 use spin_on::spin_on;
-use std::cell::RefCell;
-use std::path::{Path, PathBuf};
-use std::rc::{Rc, Weak};
+
+use crate::event_loop::{EventLoopHandle, FromAppState};
+use crate::layer_surface::LayerSurfaceHandle;
+use crate::session_lock::{SessionLock, SessionLockBuilder};
+use crate::shell_config::{CompiledUiSource, ShellConfig};
+use crate::shell_runtime::ShellRuntime;
+use crate::surface_registry::{SurfaceDefinition, SurfaceEntry, SurfaceRegistry};
+use crate::system::{
+    CallbackContext, EventDispatchContext, PopupCommand, SessionLockCommand, ShellCommand,
+    ShellControl, SurfaceCommand, SurfaceTarget,
+};
+use crate::value_conversion::IntoValue;
+use crate::{Error, Result, logger};
 
 /// Default Slint component name used when none is specified
 pub const DEFAULT_COMPONENT_NAME: &str = "Main";

crates/composition/src/shell_config.rs

@@ -1,8 +1,9 @@
-use layer_shika_adapters::platform::slint_interpreter::CompilationResult;
-use layer_shika_domain::prelude::{SurfaceConfig, UiSource};
 use std::path::PathBuf;
 use std::rc::Rc;
 
+use layer_shika_adapters::platform::slint_interpreter::CompilationResult;
+use layer_shika_domain::prelude::{SurfaceConfig, UiSource};
+
 /// Source for Slint UI definition
 ///
 /// Specifies where to load the UI from: a `.slint` file, inline source code, or pre-compiled result.

crates/composition/src/surface_registry.rs

@@ -1,10 +1,12 @@
-use crate::Result;
+use std::collections::HashMap;
+use std::rc::Rc;
+
 use layer_shika_adapters::platform::slint_interpreter::ComponentInstance;
 use layer_shika_domain::config::SurfaceConfig;
 use layer_shika_domain::value_objects::handle::SurfaceHandle;
 use layer_shika_domain::value_objects::output_handle::OutputHandle;
-use std::collections::HashMap;
-use std::rc::Rc;
+
+use crate::Result;
 
 /// Definition of a surface including component name and configuration
 ///

crates/composition/src/system.rs

@@ -1,6 +1,6 @@
-use crate::event_loop::FromAppState;
-use crate::layer_surface::LayerSurfaceHandle;
-use crate::{Error, Result, logger};
+use std::cell::Cell;
+use std::rc::Rc;
+
 use layer_shika_adapters::platform::calloop::channel;
 use layer_shika_adapters::platform::slint::ComponentHandle;
 use layer_shika_adapters::platform::slint_interpreter::{
@@ -14,8 +14,7 @@ use layer_shika_domain::prelude::{
     AnchorEdges, KeyboardInteractivity, Layer, Margins, OutputPolicy, ScaleFactor,
 };
 use layer_shika_domain::value_objects::dimensions::{PopupDimensions, SurfaceDimension};
-use layer_shika_domain::value_objects::handle::PopupHandle;
-use layer_shika_domain::value_objects::handle::SurfaceHandle;
+use layer_shika_domain::value_objects::handle::{PopupHandle, SurfaceHandle};
 use layer_shika_domain::value_objects::lock_config::LockConfig;
 use layer_shika_domain::value_objects::output_handle::OutputHandle;
 use layer_shika_domain::value_objects::output_info::OutputInfo;
@@ -23,8 +22,10 @@ use layer_shika_domain::value_objects::popup_config::PopupConfig;
 use layer_shika_domain::value_objects::popup_position::PopupPosition;
 use layer_shika_domain::value_objects::popup_size::PopupSize;
 use layer_shika_domain::value_objects::surface_instance_id::SurfaceInstanceId;
-use std::cell::Cell;
-use std::rc::Rc;
+
+use crate::event_loop::FromAppState;
+use crate::layer_surface::LayerSurfaceHandle;
+use crate::{Error, Result, logger};
 
 pub enum PopupCommand {
     Show {

crates/domain/src/entities/output_registry.rs

@@ -1,7 +1,8 @@
+use std::collections::HashMap;
+
 use crate::value_objects::output_handle::OutputHandle;
 use crate::value_objects::output_info::OutputInfo;
 use crate::value_objects::output_policy::OutputPolicy;
-use std::collections::HashMap;
 
 #[derive(Clone)]
 pub struct OutputRegistry {

crates/domain/src/entities/popup_tree.rs

@@ -1,6 +1,7 @@
-use crate::value_objects::handle::PopupHandle;
 use std::collections::HashMap;
 
+use crate::value_objects::handle::PopupHandle;
+
 #[derive(Debug, Default, Clone)]
 pub struct PopupTree {
     root_popups: Vec<PopupHandle>,

crates/domain/src/errors.rs

@@ -1,5 +1,6 @@
 use std::error::Error;
 use std::result::Result as StdResult;
+
 use thiserror::Error as ThisError;
 
 pub type Result<T> = StdResult<T, DomainError>;

crates/domain/src/value_objects/handle.rs

@@ -1,6 +1,5 @@
 use std::fmt::{Debug, Formatter, Result as FmtResult};
-use std::hash::Hash;
-use std::hash::Hasher;
+use std::hash::{Hash, Hasher};
 use std::marker::PhantomData;
 use std::sync::atomic::{AtomicUsize, Ordering};
 

crates/domain/src/value_objects/output_policy.rs

@@ -1,7 +1,8 @@
-use crate::value_objects::output_info::OutputInfo;
 use std::fmt;
 use std::rc::Rc;
 
+use crate::value_objects::output_info::OutputInfo;
+
 type OutputFilter = Rc<dyn Fn(&OutputInfo) -> bool>;
 
 /// Determines which outputs (monitors) should display the surface

examples/multi-surface/src/main.rs

@@ -1,6 +1,7 @@
+use std::path::PathBuf;
+
 use layer_shika::prelude::*;
 use layer_shika::slint_interpreter::Value;
-use std::path::PathBuf;
 
 fn main() -> Result<()> {
     env_logger::builder()

examples/runtime-surface-config/src/main.rs

@@ -1,9 +1,10 @@
+use std::path::PathBuf;
+use std::rc::Rc;
+
 use layer_shika::calloop::channel::Sender;
 use layer_shika::prelude::*;
 use layer_shika::slint::SharedString;
 use layer_shika::slint_interpreter::Value;
-use std::path::PathBuf;
-use std::rc::Rc;
 
 #[derive(Debug)]
 enum UiUpdate {

examples/session-lock-selectors/src/main.rs

@@ -1,8 +1,9 @@
-use layer_shika::prelude::*;
-use layer_shika::slint_interpreter::Value;
 use std::path::PathBuf;
 use std::rc::Rc;
 
+use layer_shika::prelude::*;
+use layer_shika::slint_interpreter::Value;
+
 fn main() -> Result<()> {
     env_logger::builder()
         .filter_level(log::LevelFilter::Info)

examples/session-lock-standalone/src/main.rs

@@ -1,8 +1,9 @@
-use layer_shika::prelude::*;
-use layer_shika::slint_interpreter::Value;
 use std::path::PathBuf;
 use std::rc::Rc;
 
+use layer_shika::prelude::*;
+use layer_shika::slint_interpreter::Value;
+
 fn main() -> Result<()> {
     env_logger::builder()
         .filter_level(log::LevelFilter::Info)

examples/session-lock/src/main.rs

@@ -1,7 +1,8 @@
-use layer_shika::prelude::*;
 use std::path::PathBuf;
 use std::rc::Rc;
 
+use layer_shika::prelude::*;
+
 fn main() -> Result<()> {
     env_logger::builder()
         .filter_level(log::LevelFilter::Info)

examples/simple-bar/src/main.rs

@@ -1,6 +1,7 @@
-use layer_shika::prelude::*;
 use std::path::PathBuf;
 
+use layer_shika::prelude::*;
+
 fn main() -> Result<()> {
     env_logger::builder()
         .filter_level(log::LevelFilter::Info)

examples/simple-popup/src/main.rs

@@ -1,6 +1,7 @@
-use layer_shika::prelude::*;
 use std::path::PathBuf;
 
+use layer_shika::prelude::*;
+
 fn main() -> Result<()> {
     env_logger::builder()
         .filter_level(log::LevelFilter::Info)

src/lib.rs

@@ -131,29 +131,24 @@ pub mod shell;
 pub mod slint_integration;
 pub mod window;
 
+pub use event::{EventDispatchContext, EventLoopHandle, ShellEventLoop};
 pub use layer_shika_composition::{
     CallbackContext, Error, Handle, Result, SurfaceHandle, SurfaceInstanceId, SurfaceTarget,
 };
-
+pub use output::{OutputGeometry, OutputHandle, OutputInfo, OutputPolicy, OutputRegistry};
 pub use shell::{
     CompiledUiSource, DEFAULT_COMPONENT_NAME, DEFAULT_SURFACE_NAME, LayerSurfaceHandle, Output,
     Selection, Selector, Shell, ShellBuilder, ShellConfig, ShellControl, ShellEventContext,
     ShellRuntime, ShellSurfaceConfigHandler, Surface, SurfaceComponentConfig, SurfaceConfigBuilder,
     SurfaceDefinition, SurfaceInfo,
 };
-
+pub use slint_integration::{PopupWindow, slint, slint_interpreter};
 pub use window::{
     Alignment, AnchorEdges, AnchorPoint, AnchorStrategy, ConstraintAdjustment,
     KeyboardInteractivity, Layer, Offset, OutputTarget, PopupBehavior, PopupBuilder, PopupConfig,
     PopupHandle, PopupPosition, PopupShell, PopupSize,
 };
 
-pub use output::{OutputGeometry, OutputHandle, OutputInfo, OutputPolicy, OutputRegistry};
-
-pub use event::{EventDispatchContext, EventLoopHandle, ShellEventLoop};
-
-pub use slint_integration::{PopupWindow, slint, slint_interpreter};
-
 pub mod calloop {
     pub use layer_shika_composition::calloop::*;
 }

src/prelude.rs

@@ -8,32 +8,26 @@
 
 #![allow(clippy::pub_use)]
 
+pub use layer_shika_composition::prelude::{
+    Anchor, LogicalPosition, LogicalRect, LogicalSize, Margins, PhysicalSize, ScaleFactor,
+    SurfaceConfig, SurfaceDimension, UiSource,
+};
+
+pub use crate::event::{EventDispatchContext, EventLoopHandle, ShellEventLoop};
+pub use crate::output::{OutputGeometry, OutputHandle, OutputInfo, OutputPolicy, OutputRegistry};
 pub use crate::shell::{
     CompiledUiSource, DEFAULT_COMPONENT_NAME, DEFAULT_SURFACE_NAME, LayerSurfaceHandle, Output,
     Selection, Selector, Shell, ShellBuilder, ShellConfig, ShellControl, ShellEventContext,
     ShellRuntime, ShellSurfaceConfigHandler, Surface, SurfaceComponentConfig, SurfaceConfigBuilder,
     SurfaceDefinition, SurfaceInfo,
 };
-
+pub use crate::slint_integration::{PopupWindow, slint, slint_interpreter};
 pub use crate::window::{
     Alignment, AnchorEdges, AnchorPoint, AnchorStrategy, ConstraintAdjustment,
     KeyboardInteractivity, Layer, Offset, OutputTarget, PopupBehavior, PopupBuilder, PopupConfig,
     PopupHandle, PopupPosition, PopupShell, PopupSize,
 };
-
-pub use crate::output::{OutputGeometry, OutputHandle, OutputInfo, OutputPolicy, OutputRegistry};
-
-pub use crate::event::{EventDispatchContext, EventLoopHandle, ShellEventLoop};
-
-pub use crate::slint_integration::{PopupWindow, slint, slint_interpreter};
-
 pub use crate::{
     CallbackContext, Error, Handle, Result, SurfaceHandle, SurfaceInstanceId, SurfaceTarget,
+    calloop,
 };
-
-pub use layer_shika_composition::prelude::{
-    Anchor, LogicalPosition, LogicalRect, LogicalSize, Margins, PhysicalSize, ScaleFactor,
-    SurfaceConfig, SurfaceDimension, UiSource,
-};
-
-pub use crate::calloop;

src/slint_integration.rs

@@ -1,3 +1 @@
-pub use layer_shika_composition::{slint, slint_interpreter};
-
-pub use layer_shika_composition::PopupWindow;
+pub use layer_shika_composition::{PopupWindow, slint, slint_interpreter};