Struct EventListener

pub struct EventListener { /* private fields */ }

This struct is used for adding event handlers and executing them on events

The Event Listener

This struct holds what you need to create a event listener

Usage

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new(); // creates a new listener
// add a event handler which will be ran when this event happens
listener.add_workspace_change_handler(|data| println!("{:#?}", data));
listener.start_listener(); // or `.start_listener_async().await` if async

Implementations

impl EventListener

pub fn new() -> EventListener

This method creates a new EventListener instance

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();

pub async fn start_listener_async(&mut self) -> Result<(), HyprError>

This method starts the event listener (async)

This should be ran after all of your handlers are defined

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_workspace_change_handler(|id| println!("changed workspace to {id:?}"));
listener.start_listener_async().await;

pub fn start_listener(&mut self) -> Result<(), HyprError>

This method starts the event listener (blocking)

This should be ran after all of your handlers are defined

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_workspace_change_handler(&|id| println!("changed workspace to {id:?}"));
listener.start_listener();

impl EventListener

pub fn add_workspace_changed_handler( &mut self, f: impl Fn(WorkspaceEventData) + 'static, )

This method adds an event which executes when“on workspace change“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_workspace_changed_handler(|id| println!("changed workspace to: {id:#?}"));
listener.start_listener();

impl EventListener

pub fn add_workspace_added_handler( &mut self, f: impl Fn(WorkspaceEventData) + 'static, )

This method adds an event which executes when“a workspace is created“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_workspace_added_handler(|id| println!("workspace was added: {id:#?}"));
listener.start_listener();

impl EventListener

pub fn add_workspace_deleted_handler( &mut self, f: impl Fn(WorkspaceEventData) + 'static, )

This method adds an event which executes when“a workspace is destroyed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_workspace_deleted_handler(|data| println!("a workspace was destroyed: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_workspace_moved_handler( &mut self, f: impl Fn(WorkspaceMovedEventData) + 'static, )

This method adds an event which executes when“a workspace is moved“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_workspace_moved_handler(|id| println!("workspace was moved: {id:#?}"));
listener.start_listener();

impl EventListener

pub fn add_workspace_renamed_handler( &mut self, f: impl Fn(NonSpecialWorkspaceEventData) + 'static, )

This method adds an event which executes when“a workspace is renamed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_workspace_renamed_handler(|id| println!("workspace was renamed: {id:#?}"));
listener.start_listener();

impl EventListener

pub fn add_active_monitor_changed_handler( &mut self, f: impl Fn(MonitorEventData) + 'static, )

This method adds an event which executes when“the active monitor is changed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_active_monitor_changed_handler(|data| println!("Active monitor changed to: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_active_window_changed_handler( &mut self, f: impl Fn(Option<WindowEventData>) + 'static, )

This method adds an event which executes when“the active window is changed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_active_window_changed_handler(|data| println!("Active window changed: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_fullscreen_state_changed_handler( &mut self, f: impl Fn(bool) + 'static, )

This method adds an event which executes when“the fullscreen state is changed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_fullscreen_state_changed_handler(|state| println!("Fullscreen is on: {state:#?}"));
listener.start_listener();

impl EventListener

pub fn add_monitor_added_handler( &mut self, f: impl Fn(MonitorAddedEventData) + 'static, )

This method adds an event which executes when“a new monitor is added“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_monitor_added_handler(|data| println!("Monitor added: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_monitor_removed_handler(&mut self, f: impl Fn(String) + 'static)

This method adds an event which executes when“a monitor is removed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_monitor_removed_handler(|data| println!("Monitor removed: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_window_opened_handler( &mut self, f: impl Fn(WindowOpenEvent) + 'static, )

This method adds an event which executes when“a window is opened“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_window_opened_handler(|data| println!("Window opened: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_window_closed_handler(&mut self, f: impl Fn(Address) + 'static)

This method adds an event which executes when“a window is closed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_window_closed_handler(|data| println!("Window closed: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_window_moved_handler( &mut self, f: impl Fn(WindowMoveEvent) + 'static, )

This method adds an event which executes when“a window is moved“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_window_moved_handler(|data| println!("Window moved: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_special_removed_handler(&mut self, f: impl Fn(String) + 'static)

This method adds an event which executes when“a monitor’s special workspace is removed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_special_removed_handler(|monitor| println!("Special Workspace removed: {monitor:#?}"));
listener.start_listener();

impl EventListener

pub fn add_changed_special_handler( &mut self, f: impl Fn(ChangedSpecialEventData) + 'static, )

This method adds an event which executes when“a monitor’s special workspace is changed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_changed_special_handler(|data| println!("Special Workspace changed: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_layout_changed_handler(&mut self, f: impl Fn(LayoutEvent) + 'static)

This method adds an event which executes when“the keyboard layout is changed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_layout_changed_handler(|data| println!("Layout changed: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_sub_map_changed_handler(&mut self, f: impl Fn(String) + 'static)

This method adds an event which executes when“the submap is changed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_sub_map_changed_handler(|data| println!("Submap changed: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_layer_opened_handler(&mut self, f: impl Fn(String) + 'static)

This method adds an event which executes when“a new layer is opened“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_layer_opened_handler(|data| println!("Layer opened: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_layer_closed_handler(&mut self, f: impl Fn(String) + 'static)

This method adds an event which executes when“a layer is closed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_layer_closed_handler(|data| println!("Layer closed: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_float_state_changed_handler( &mut self, f: impl Fn(WindowFloatEventData) + 'static, )

This method adds an event which executes when“the float state of a window is changed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_float_state_changed_handler(|data| println!("Float state changed: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_urgent_state_changed_handler( &mut self, f: impl Fn(Address) + 'static, )

This method adds an event which executes when“the urgent state of a window is changed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_urgent_state_changed_handler(|data| println!("urgent state changed: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_window_title_changed_handler( &mut self, f: impl Fn(WindowTitleEventData) + 'static, )

This method adds an event which executes when“a window title is changed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_window_title_changed_handler(|data| println!("A window title changed: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_screencast_handler( &mut self, f: impl Fn(ScreencastEventData) + 'static, )

This method adds an event which executes when“the screencast state of a window is changed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_screencast_handler(|data| println!("screencast state changed: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_config_reloaded_handler(&mut self, f: impl Fn() + 'static)

This method adds an event which executes when“the configuration of Hyprland is reloaded“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_config_reloaded_handler(|_empty| println!("config reloaded: {_empty:#?}"));
listener.start_listener();

impl EventListener

pub fn add_ignore_group_lock_state_changed_handler( &mut self, f: impl Fn(bool) + 'static, )

This method adds an event which executes when“the state of ignore group lock is toggled“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_ignore_group_lock_state_changed_handler(|data| println!("ignore group lock toggled to: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_lock_groups_state_changed_handler( &mut self, f: impl Fn(bool) + 'static, )

This method adds an event which executes when“the state of lock groups is toggled“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_lock_groups_state_changed_handler(|data| println!("lock group state toggled to: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_window_pinned_handler( &mut self, f: impl Fn(WindowPinEventData) + 'static, )

This method adds an event which executes when“the pinned state of a window is changed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_window_pinned_handler(|state| println!("window pin was set to: {state:#?}"));
listener.start_listener();

impl EventListener

pub fn add_group_toggled_handler( &mut self, f: impl Fn(GroupToggledEventData) + 'static, )

This method adds an event which executes when“a group was toggled“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_group_toggled_handler(|data| println!("the group toggle state was set to: {data:#?}"));
listener.start_listener();

impl EventListener

pub fn add_window_moved_into_group_handler( &mut self, f: impl Fn(Address) + 'static, )

This method adds an event which executes when“a window was moved into a group“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_window_moved_into_group_handler(|addr| println!("a window was moved into a group with the address of: {addr:#?}"));
listener.start_listener();

impl EventListener

pub fn add_window_moved_out_of_group_handler( &mut self, f: impl Fn(Address) + 'static, )

This method adds an event which executes when“a window was moved out of a group“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_window_moved_out_of_group_handler(|addr| println!("a window was moved out of a group with the address of: {addr:#?}"));
listener.start_listener();

impl EventListener

pub fn add_unknown_handler(&mut self, f: impl Fn(UnknownEventData) + 'static)

This method adds an event which executes when“the state of some unknown event changed“

use hyprland::event_listener::EventListener;
let mut listener = EventListener::new();
listener.add_unknown_handler(|value| println!("unknown state changed to: {value:#?}"));
listener.start_listener();

Trait Implementations

impl Default for EventListener

fn default() -> EventListener

Returns the “default value” for a type.