Struct SpellLock 

pub struct SpellLock { /* private fields */ }

SpellLock is a struct which represents a window lock. It can be run and initialised on a custom lockscreen implementation with slint.

Remember, with great power comes great responsibility. The struct doen't implement pointer events so you would need to make sure that your lock screen has a text input field and it is in focus on startup. Also spell doesn't add any restrictions on what you can have in your lockscreen so that is a bonus

Know limitations include the abscence to verify from fingerprints and unideal issues on multi-monitor setup. You can add the path of binary of your lock in your compositor config and idle manager config to use the program. It will be linked to spell-cli directly in coming releases.

Example

Here is a minimal example.

use std::{env, error::Error, time::Duration};

use slint::ComponentHandle;
use spell_framework::{
    layer_properties::{TimeoutAction, Timer},
    wayland_adapter::{run_lock, SpellLock, SpellSlintLock},
};
slint::include_modules!();

fn main() -> Result<(), Box<dyn Error>> {
    let (mut lock, event_loop, event_queue, handle) = SpellLock::invoke_lock_spell();
    let lock_ui = LockScreen::new().unwrap();
    let looop_handle = event_loop.handle().clone();
    SpellSlintLock::build(&mut lock, handle);
    lock_ui.on_check_pass({
        let lock_handle = lock_ui.as_weak();
        move |string_val| {
            // let lock_handle_a = lock_handle.clone();
            let lock_handle_a = lock_handle.clone().unwrap();
            looop_handle
                .insert_source(
                    Timer::from_duration(Duration::from_secs(5)),
                    move |_, _, app_data| {
                        if app_data.unlock(None, string_val.as_str()).is_err() {
                            lock_handle_a.set_lock_error(true);
                        }
                        TimeoutAction::Drop
                    },
                )
                .unwrap();
        }
    });

    run_lock(lock, event_loop, event_queue)
}

Implementations

impl SpellLock

pub fn invoke_lock_spell() -> (Self, EventLoop<'static, SpellLock>, EventQueue<SpellLock>)

pub fn unlock( &mut self, username: Option<&str>, password: &str, ) -> PamResult<()>

call this method to unlock Spelllock

Trait Implementations

impl CompositorHandler for SpellLock

fn scale_factor_changed( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _surface: &WlSurface, _new_factor: i32, )

The surface has either been moved into or out of an output and the output has a different scale factor.

fn transform_changed( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _surface: &WlSurface, _new_transform: Transform, )

The surface has either been moved into or out of an output and the output has different transform.

fn frame( &mut self, _conn: &Connection, qh: &QueueHandle<Self>, _surface: &WlSurface, _time: u32, )

A frame callback has been completed.

fn surface_enter( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _surface: &WlSurface, _output: &WlOutput, )

The surface has entered an output.

fn surface_leave( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _surface: &WlSurface, _output: &WlOutput, )

The surface has left an output.

impl Dispatch<ExtSessionLockManagerV1, GlobalData> for SpellLock

fn event( state: &mut Self, proxy: &ExtSessionLockManagerV1, event: <ExtSessionLockManagerV1 as Proxy>::Event, data: &GlobalData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<ExtSessionLockSurfaceV1, SessionLockSurfaceData> for SpellLock

fn event( state: &mut Self, proxy: &ExtSessionLockSurfaceV1, event: <ExtSessionLockSurfaceV1 as Proxy>::Event, data: &SessionLockSurfaceData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<ExtSessionLockV1, SessionLockData> for SpellLock

fn event( state: &mut Self, proxy: &ExtSessionLockV1, event: <ExtSessionLockV1 as Proxy>::Event, data: &SessionLockData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlCallback, WlSurface> for SpellLock

fn event( state: &mut Self, proxy: &WlCallback, event: <WlCallback as Proxy>::Event, data: &WlSurface, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlCompositor, GlobalData> for SpellLock

fn event( state: &mut Self, proxy: &WlCompositor, event: <WlCompositor as Proxy>::Event, data: &GlobalData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlKeyboard, KeyboardData<SpellLock>> for SpellLock

fn event( state: &mut Self, proxy: &WlKeyboard, event: <WlKeyboard as Proxy>::Event, data: &KeyboardData<SpellLock>, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlOutput, OutputData> for SpellLock

fn event( state: &mut Self, proxy: &WlOutput, event: <WlOutput as Proxy>::Event, data: &OutputData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlRegistry, GlobalListContents> for SpellLock

fn event( state: &mut Self, proxy: &WlRegistry, event: <WlRegistry as Proxy>::Event, data: &GlobalListContents, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlSeat, SeatData> for SpellLock

fn event( state: &mut Self, proxy: &WlSeat, event: <WlSeat as Proxy>::Event, data: &SeatData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlShm, GlobalData> for SpellLock

fn event( state: &mut Self, proxy: &WlShm, event: <WlShm as Proxy>::Event, data: &GlobalData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlSurface, SurfaceData> for SpellLock

fn event( state: &mut Self, proxy: &WlSurface, event: <WlSurface as Proxy>::Event, data: &SurfaceData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<ZxdgOutputManagerV1, GlobalData> for SpellLock

fn event( state: &mut Self, proxy: &ZxdgOutputManagerV1, event: <ZxdgOutputManagerV1 as Proxy>::Event, data: &GlobalData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<ZxdgOutputV1, OutputData> for SpellLock

fn event( state: &mut Self, proxy: &ZxdgOutputV1, event: <ZxdgOutputV1 as Proxy>::Event, data: &OutputData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl KeyboardHandler for SpellLock

fn enter( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _keyboard: &WlKeyboard, _surface: &WlSurface, _serial: u32, _raw: &[u32], _keysyms: &[Keysym], )

The keyboard has entered a surface.

fn leave( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _keyboard: &WlKeyboard, _surface: &WlSurface, _serial: u32, )

The keyboard has left a surface.

fn press_key( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _keyboard: &WlKeyboard, _serial: u32, event: KeyEvent, )

A key has been pressed on the keyboard.

fn release_key( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _keyboard: &WlKeyboard, _serial: u32, event: KeyEvent, )

A key has been released.

fn update_modifiers( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _keyboard: &WlKeyboard, _serial: u32, _modifiers: Modifiers, _raw_modifiers: RawModifiers, _layout: u32, )

Keyboard modifiers have been updated.

fn repeat_key( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _keyboard: &WlKeyboard, _serial: u32, _event: KeyEvent, )

A key has been previously pressed and is now repeating.

fn update_repeat_info( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _keyboard: &WlKeyboard, _info: RepeatInfo, )

The keyboard has updated the rate and delay between repeating key inputs.

fn update_keymap( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _keyboard: &WlKeyboard, _keymap: Keymap<'_>, )

Keyboard keymap has been updated.

impl OutputHandler for SpellLock

fn output_state(&mut self) -> &mut OutputState

fn new_output( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _output: WlOutput, )

A new output has been advertised.

fn update_output( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _output: WlOutput, )

An existing output has changed.

fn output_destroyed( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _output: WlOutput, )

An output is no longer advertised.

impl ProvidesRegistryState for SpellLock

fn registry(&mut self) -> &mut RegistryState

Returns a mutable reference to the registry state.

fn runtime_add_global( &mut self, conn: &Connection, qh: &QueueHandle<Self>, name: u32, interface: &str, version: u32, )

Called when a new global has been advertised by the compositor.

fn runtime_remove_global( &mut self, conn: &Connection, qh: &QueueHandle<Self>, name: u32, interface: &str, )

Called when a global has been destroyed by the compositor.

impl SeatHandler for SpellLock

fn seat_state(&mut self) -> &mut SeatState

fn new_seat(&mut self, _: &Connection, _: &QueueHandle<Self>, _: WlSeat)

A new seat has been created.

fn new_capability( &mut self, _conn: &Connection, qh: &QueueHandle<Self>, seat: WlSeat, capability: Capability, )

A new capability is available on the seat.

fn remove_capability( &mut self, _conn: &Connection, _: &QueueHandle<Self>, _: WlSeat, capability: Capability, )

A capability has been removed from the seat.

fn remove_seat(&mut self, _: &Connection, _: &QueueHandle<Self>, _: WlSeat)

A seat has been removed.

impl SessionLockHandler for SpellLock

fn locked( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _session_lock: SessionLock, )

The session lock is active, and the client may create lock surfaces.

fn finished( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _session_lock: SessionLock, )

Session lock is not active and should be destroyed.

fn configure( &mut self, _conn: &Connection, qh: &QueueHandle<Self>, _surface: SessionLockSurface, _configure: SessionLockSurfaceConfigure, _serial: u32, )

Compositor has requested size for surface.

impl ShmHandler for SpellLock

fn shm_state(&mut self) -> &mut Shm