Wired Notification Daemon

You can start Wired by adding it to your desktop environment's autostart script, or by using systemd as a user service. To use systemd, copy the wired.service file from the repository root to /usr/local/lib/systemd/user/wired.service (or your distro's equivalent).

# Autostart method
/path/to/wired &

# systemd method
$ systemctl enable --now --user wired.service

Use the provided installer.sh script with sudo permissions to install the necessary dependencies.

$ cd wired-notify
$ chmod +x installer.sh
$ sudo ./installer.sh

Wired supports Nix Flakes. You can run it directly, install it to your user profile, or integrate it into your own Flake or NixOS configuration.

# Run directly from the repository
nix run 'github:Toqozz/wired-notify'

# Install to user profile (systemd service will not be available)
nix profile install 'github:Toqozz/wired-notify'

On Arch Linux, you can install Wired using an AUR helper like yay. You can choose between the stable version or the -git version which tracks the master branch.

# Install stable version
$ yay -S wired

# Install master branch version
$ yay -S wired-git

If using standalone Home-Manager, you can use the provided Wired overlay and module to enable the service and provide a configuration file (e.g., wired.ron).

{
  # ...
  outputs = { self, nixpkgs, home-manager, wired, ... }: {
    homeConfigurations.alice = let
      system = "x86_64-linux";
    in home-manager.lib.homeManagerConfiguration {
      pkgs = import nixpkgs {
        inherit system;
        overlays = [ wired.overlays.default ];
      };

      modules = [
        wired.homeManagerModules.default
        ({ ... }: {
          services.wired = {
            enable = true;
            config = ./wired.ron;
          };
        })
      ];
    };
  };
}

To build Wired manually, ensure you have the following dependencies installed: rust, dbus, cairo, pango, glib2, x11, xss. Then use cargo build --release.

$ git clone https://github.com/Toqozz/wired-notify.git
$ cd wired-notify
$ cargo build --release
$ ./target/release/wired

To install Wired for all users in a NixOS configuration, add the Wired input and include its package in your environment.systemPackages.

{
  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
    wired.url = "github:Toqozz/wired-notify";
  };
  outputs = { self, nixpkgs, wired }: let
    std = nixpkgs.lib;
    system = "x86_64-linux";
  in {
    nixosConfigurations.alice = std.nixosSystem {
      inherit system;
      modules = [
        ./configuration.nix
        {
          environment.systemPackages = [ wired.packages.${system}.wired ];
        }
      ];
    };
  };
}

Wired is available in official NetBSD repositories via pkgin, or can be built from source using make.

# Using pkgin
$ pkgin install wired-notify

# Building from source
$ cd /usr/pkgsrc/x11/wired-notify
$ make install

The Hook struct determines how a LayoutBlock is positioned relative to its parent and itself using AnchorPosition.

• parent_anchor: The point on the parent's rectangle used for alignment.
• self_anchor: The point on the block's own rectangle used for alignment.

Positioning is calculated by finding the difference between the parent anchor and the self anchor, then applying the block's offset.

The Message enum represents the two types of events received from the DBus notification interface:

• Notify(Notification): A new notification has been sent.
• Close(u32): A notification with the specified ID should be closed.

// Example of handling messages
while let Ok(msg) = receiver.recv() {
    match msg {
        Message::Notify(notification) => {
            println!("New notification: {}", notification.summary);
        }
        Message::Close(id) => {
            println!("Closing notification: {}", id);
        }
    }
}

To start receiving notifications via the DBus session bus, call init_dbus_thread(). This function registers the org.freedesktop.Notifications name on the session bus and spawns a background thread to process incoming DBus messages. It returns a JoinHandle for the background thread and a Receiver<Message> which you can use to consume incoming notification events.

let (handle, receiver) = init_dbus_thread();
// Use receiver to listen for Message variants (Notify or Close)