wip

Author: DashieTM

.direnv/flake-profile

@@ -1 +1 @@
-flake-profile-4-link
+flake-profile-5-link

.direnv/flake-profile-4-link

@@ -12,8 +12,15 @@ dbus-crossroads = "0.5.2"
 pulse = { version = "2.28.2", package = "libpulse-binding" }
 once_cell = "1.20.2"
 libloading = "0.8.6"
-gtk = { version = "0.9.5", package = "gtk4", features = ["v4_12"] }
+gtk = { version = "0.9.6", package = "gtk4", features = ["v4_16"] }
 serial_test = "3.2.0"
 toml = "0.8.19"
 xdg = "2.5.2"
 zbus = "5.3.1"
+iced = { version = "0.13.1", features = [
+	"advanced",
+	"canvas",
+	"image",
+	"svg",
+	"tokio",
+] }

Cargo.toml

@@ -7,39 +7,50 @@
       url = "github:hercules-ci/flake-parts";
       inputs.nixpkgs-lib.follows = "nixpkgs";
     };
+    rust-overlay.url = "github:oxalica/rust-overlay";
   };
 
-  outputs =
-    inputs@{ self, flake-parts, ... }:
-    flake-parts.lib.mkFlake { inherit inputs; } {
+  outputs = inputs @ {
+    self,
+    flake-parts,
+    ...
+  }:
+    flake-parts.lib.mkFlake {inherit inputs;} {
       systems = [
         "x86_64-linux"
         "aarch64-linux"
       ];
 
-      perSystem =
-        {
-          pkgs,
-          system,
-          ...
-        }:
-        {
-          _module.args.pkgs = import self.inputs.nixpkgs {
-            inherit system;
-          };
-          devShells.default = pkgs.mkShell {
-            nativeBuildInputs = [
-              pkgs.pkg-config
-              pkgs.dbus
-            ];
+      perSystem = {
+        pkgs,
+        system,
+        ...
+      }: {
+        _module.args.pkgs = import self.inputs.nixpkgs {
+          inherit system;
+          overlays = [
+            (
+              import
+              inputs.rust-overlay
+            )
+          ];
+        };
+        devShells.default = pkgs.mkShell {
+          nativeBuildInputs = [
+            pkgs.pkg-config
+            pkgs.dbus
+          ];
 
-            buildInputs = [
-              pkgs.dbus
-              pkgs.gtk4
-              pkgs.libadwaita
-              pkgs.pulseaudio
-            ];
-          };
+          buildInputs = [
+            pkgs.dbus
+            pkgs.libadwaita
+            pkgs.pulseaudio
+            (pkgs.rust-bin.selectLatestNightlyWith
+              (toolchain: toolchain.default))
+            pkgs.rust-analyzer
+            pkgs.clippy
+          ];
         };
+      };
     };
 }

flake.lock

@@ -1,6 +1,5 @@
 #![feature(trait_upcasting)]
 #![feature(string_remove_matches)]
-#![feature(unsized_fn_params)]
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]
 use std::{

flake.nix

@@ -0,0 +1,66 @@
+use std::any::TypeId;
+use std::fmt::Debug;
+
+use iced::advanced::graphics::futures::MaybeSend;
+
+// Taken from https://doc.rust-lang.org/stable/src/core/any.rs.html
+// adjusted to fit ReSet
+pub trait ReSetAny: 'static + MaybeSend + Debug + Send + Sync {
+    fn type_id(&self) -> TypeId;
+}
+
+impl<T: 'static + ?Sized + Debug + MaybeSend + Send + Sync> ReSetAny for T {
+    fn type_id(&self) -> TypeId {
+        TypeId::of::<T>()
+    }
+}
+
+impl dyn ReSetAny {
+    #[inline]
+    pub fn is<T: ReSetAny>(&self) -> bool {
+        // Get `TypeId` of the type this function is instantiated with.
+        let t = TypeId::of::<T>();
+        // Get `TypeId` of the type in the trait object (`self`).
+        let concrete = self.type_id();
+        // Compare both `TypeId`s on equality.
+        t == concrete
+    }
+
+    #[inline]
+    pub fn downcast_ref<T: ReSetAny>(&self) -> Option<&T> {
+        if self.is::<T>() {
+            // SAFETY: just checked whether we are pointing to the correct type, and we can rely on
+            // that check for memory safety because we have implemented Any for all types; no other
+            // impls can exist as they would conflict with our impl.
+            unsafe { Some(self.downcast_ref_unchecked()) }
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    pub fn downcast_mut<T: ReSetAny>(&mut self) -> Option<&mut T> {
+        if self.is::<T>() {
+            // SAFETY: just checked whether we are pointing to the correct type, and we can rely on
+            // that check for memory safety because we have implemented Any for all types; no other
+            // impls can exist as they would conflict with our impl.
+            unsafe { Some(self.downcast_mut_unchecked()) }
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    pub unsafe fn downcast_mut_unchecked<T: ReSetAny>(&mut self) -> &mut T {
+        debug_assert!(self.is::<T>());
+        // SAFETY: caller guarantees that T is the correct type
+        unsafe { &mut *(self as *mut dyn ReSetAny as *mut T) }
+    }
+
+    #[inline]
+    pub unsafe fn downcast_ref_unchecked<T: ReSetAny>(&self) -> &T {
+        debug_assert!(self.is::<T>());
+        // SAFETY: caller guarantees that T is the correct type
+        unsafe { &*(self as *const dyn ReSetAny as *const T) }
+    }
+}

src/lib.rs

@@ -0,0 +1,23 @@
+use std::fmt;
+
+pub type ReSetError = Box<dyn TReSetError>;
+
+pub trait TReSetError: fmt::Debug + fmt::Display + Send + Sync + 'static {}
+
+pub fn create_error(err: impl TReSetError) -> ReSetError {
+    Box::new(err)
+}
+
+impl TReSetError for zbus::Error {}
+impl From<zbus::Error> for ReSetError {
+    fn from(value: zbus::Error) -> Self {
+        create_error(value)
+    }
+}
+
+impl TReSetError for String {}
+impl From<String> for ReSetError {
+    fn from(value: String) -> Self {
+        create_error(value)
+    }
+}

src/utils/any.rs

@@ -0,0 +1,46 @@
+use super::any::ReSetAny;
+
+pub enum EntryButtonLevel {
+    TopLevel,
+    SubLevel,
+}
+
+pub struct EntryButton {
+    pub title: &'static str,
+    pub icon: Option<String>,
+    pub msg: Box<&'static dyn ReSetAny>,
+    pub level: EntryButtonLevel,
+}
+
+impl EntryButton {
+    pub fn top_level(
+        title: &'static str,
+        icon: Option<impl Into<String>>,
+        msg: impl Into<Box<&'static dyn ReSetAny>>,
+    ) -> Self {
+        Self {
+            title,
+            icon: icon.map(|icon| icon.into()),
+            msg: msg.into(),
+            level: EntryButtonLevel::TopLevel,
+        }
+    }
+
+    pub fn sub_level(
+        title: &'static str,
+        icon: Option<impl Into<String>>,
+        msg: impl Into<Box<&'static dyn ReSetAny>>,
+    ) -> Self {
+        Self {
+            title,
+            icon: icon.map(|icon| icon.into()),
+            msg: msg.into(),
+            level: EntryButtonLevel::SubLevel,
+        }
+    }
+}
+
+pub struct EntryCategory {
+    pub main_entry: EntryButton,
+    pub sub_entries: Vec<EntryButton>,
+}

src/utils/error.rs

@@ -1,7 +1,10 @@
+pub mod any;
 pub mod config;
 pub mod dbus_utils;
+pub mod error;
 pub mod flags;
 pub mod gtk;
+pub mod iced_sidebar;
 pub mod macros;
 pub mod plugin;
 pub mod plugin_setup;