Overhaul dependencies and features

Cargo.toml

@@ -10,18 +10,23 @@ author.workspace = true
 repository.workspace = true
 keywords.workspace = true
 categories.workspace = true
+rust-version = "1.75.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [package.metadata.nix]
 build = true
 
 [profile.release]
-opt-level = "z"
+opt-level = 3
 strip = true
 lto = true
 
 [workspace]
-members = ["hyprland-macros"]
+members = [
+    "examples/almost_everything",
+    "examples/almost_everything_async",
+    "hyprland-macros",
+]
 
 [workspace.package]
 version = "0.3.13"
@@ -33,27 +38,48 @@ authors = ["yavko <[email protected]>"]
 
 [dependencies]
 hyprland-macros = { path = "hyprland-macros", version = "0.3.4" }
-serde = {version = "1", features = ["derive"]}
+serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 serde_repr = "0.1"
-hex = "0.4"
-tokio = { version = "1", features = ["full"], optional = true }
-async-net = { version = "2", optional = true }
-async-std = { version = "1", optional = true }
-futures-lite = { version = "2", optional = true }
-lazy_static = "1.4"
-regex = "1.10"
-async-trait = "0.1"
-num-traits = "0.2"
-doc-comment = "0.3"
-paste = "1"
-strum = { version = "0.26", features = ["derive"] }
-derive_more = "0.99"
-futures = "0.3"
+tokio = { version = "1", features = [
+    "io-std",
+    "io-util",
+    "net",
+], optional = true }
+async-net = { version = "2.0", optional = true }
+async-std = { version = "1.12", optional = true }
+futures-lite = { version = "2.3", optional = true, default-features = false }
+regex = { version = "1.10", default-features = false, features = [
+    "std",
+    "perf",
+    "unicode",
+] }
+num-traits = "0.2.18"
+paste = "1.0.14"
+derive_more = { version = "0.99", default-features = false, features = [
+    "display",
+    "constructor",
+] }
+once_cell = "1.19"
+parking_lot = { version = "0.12", optional = true }
+ahash = { version = "0.8", features = [
+    "std",
+    "no-rng",
+    "serde",
+], optional = true, default-features = false }
 
 [features]
-default = ["listener", "dispatch", "data", "keyword", "config", "ctl", "tokio"]
-async-net = ["dep:async-net", "dep:futures-lite"]
+default = [
+    "listener",
+    "dispatch",
+    "data",
+    "keyword",
+    "config",
+    "ctl",
+    "tokio",
+    "ahash",
+]
+async-lite = ["dep:async-net", "dep:futures-lite"]
 async-std = ["dep:async-std", "dep:futures-lite"]
 tokio = ["dep:tokio"]
 dispatch = []
@@ -63,3 +89,6 @@ keyword = []
 config = ["dispatch", "keyword"]
 listener = ["data", "dispatch"]
 silent = []
+parking_lot = ["dep:parking_lot", "once_cell/parking_lot", "tokio?/parking_lot"]
+ahash = ["dep:ahash"]
+unsafe-impl = []

examples/almost_everything/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "almost_everything"
+edition = "2021"
+version.workspace = true
+license.workspace = true
+repository.workspace = true
+keywords.workspace = true
+categories.workspace = true
+authors.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+hyprland = { version = "0.3.13", path = "../..", default-features = false, features = ["config", "ctl", "data", "dispatch", "keyword", "listener", "async-lite"] }

examples/almost_everything.rs → examples/almost_everything/src/main.rs

@@ -45,7 +45,7 @@ fn main() -> hyprland::Result<()> {
     println!("monitors: {monitors:#?},\nactive window: {win:#?},\nclients {clients:#?}\nworkspace: {work:#?}");
 
     // Create a event listener
-    let mut event_listener = EventListener::new();
+    let mut event_listener = EventListener::new()?;
 
     // Shows when active window changes
     event_listener.add_active_window_change_handler(|data, _| {

examples/almost_everything_async/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "almost_everything_async"
+edition = "2021"
+version.workspace = true
+license.workspace = true
+repository.workspace = true
+keywords.workspace = true
+categories.workspace = true
+authors.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+hyprland = { version = "0.3.13", path = "../.." }
+tokio = { version = "1", features = [
+    "macros",
+    "io-std",
+    "rt-multi-thread",
+    "time",
+] }

examples/almost_everything_async/src/main.rs

@@ -0,0 +1,108 @@
+use hyprland::data::{Animations, Client, Clients, Monitors, Workspace};
+use hyprland::event_listener::AsyncEventListener;
+use hyprland::keyword::*;
+use hyprland::prelude::*;
+//use hyprland::shared::WorkspaceType;
+use hyprland::{async_closure, dispatch::*};
+
+fn main() -> hyprland::Result<()> {
+    // It is always a good practice to configure your runtime to your specifications
+    tokio::runtime::Builder::new_multi_thread().enable_io().enable_time().worker_threads(1).build()?.block_on(async move {
+        // We can call dispatchers with the dispatch function!
+
+        // Here we are telling hyprland to open kitty using the dispatch macro!
+        hyprland::dispatch!(async; Exec, "kitty").await?;
+
+        // Here we are adding a keybinding to Hyprland using the bind macro!
+        hyprland::bind!(async; SUPER, Key, "i" => ToggleFloating, None).await?;
+
+        // Here we are moving the cursor to the top left corner! We can also just use the Dispatch
+        // struct!
+        Dispatch::call_async(DispatchType::MoveCursorToCorner(Corner::TopLeft)).await?;
+
+        let border_size = match Keyword::get_async("general:border_size").await?.value {
+            OptionValue::Int(i) => i,
+            _ => panic!("border size can only be a int"),
+        };
+        println!("{border_size}");
+
+        // Here we change a keyword, yes its a dispatcher don't complain
+        Keyword::set_async("general:border_size", border_size * 2).await?;
+        // get all monitors
+        let monitors = Monitors::get_async().await?;
+        // and the active window
+        let win = Client::get_active_async().await?;
+        // and all open windows
+        let clients = Clients::get_async().await?;
+        // and the active workspace
+        let work = Workspace::get_active_async().await?;
+        // and printing them all out!
+        println!("monitors: {monitors:#?},\nactive window: {win:#?},\nclients {clients:#?}\nworkspace:{work:#?}");
+        let animations = Animations::get_async().await?;
+        println!("{animations:#?}");
+        // Create a event listener
+        let mut event_listener = AsyncEventListener::new();
+
+        //This changes the workspace to 5 if the workspace is switched to 9
+        //this is a performance and mutable state test
+        // event_listener.add_workspace_change_handler(async_closure! {|id, state| {
+        //     if id == WorkspaceType::Regular('9'.to_string()) {
+        //         *state.workspace = '2'.to_string();
+        //     }
+        // }});
+        /*
+        event_listener.add_workspace_change_handler(|id, state| {
+            Box::pin(async move {
+                if id == WorkspaceType::Regular('9'.to_string()) {
+                    *state.workspace = '2'.to_string();
+                }
+            })
+        });
+
+        // This makes it so you can't turn on fullscreen lol
+        event_listener.add_fullscreen_state_change_handler(async_closure! {|fstate, state| {
+            if fstate {
+                *state.fullscreen = false;
+            }
+        }});
+        // Makes a monitor unfocusable
+        event_listener.add_active_monitor_change_handler(async_closure! {|data, state| {
+            let hyprland::event_listener::MonitorEventData{ monitor_name, .. } = data;
+
+            if monitor_name == *"DP-1".to_string() {
+                *state.monitor = "eDP-1".to_string()
+            }
+        }});
+        */
+        // add event, yes functions and closures both work!
+
+        event_listener.add_workspace_change_handler(
+            async_closure! { move |id| println!("workspace changed to {id:#?}")},
+        );
+        event_listener.add_active_window_change_handler(
+            async_closure! { move |data| println!("window changed to {data:#?}")},
+        );
+        // Waybar example
+        // event_listener.add_active_window_change_handler(|data| {
+        //     use hyprland::event_listener::WindowEventData;
+        //     let string = match data {
+        //         Some(WindowEventData(class, title)) => format!("{class}: {title}"),
+        //         None => "".to_string()
+        //     };
+        //     println!(r#"{{"text": "{string}", class: "what is this?"}}"#);
+        // });
+
+        // reset your border size back to normal
+        tokio::spawn(async move {
+            tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+            println!("Resetting border size!");
+            Keyword::set_async("general:border_size", border_size).await?;
+            Ok::<_, hyprland::shared::HyprError>(())
+        });
+
+        // and execute the function
+        // here we are using the blocking variant
+        // but there is a async version too
+        event_listener.start_listener_async().await
+    })
+}