Initial WIP code

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "cosmic-panel"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+cascade = "1"
+gdk4-x11 = "0.2"
+gtk4 = "0.2"
+toml = "0.5"
+x11 = { version = "2", features = ["xlib"] }
+zbus = "1"

rust-toolchain

@@ -0,0 +1 @@
+1.51.0

src/main.rs

@@ -0,0 +1,33 @@
+use gtk4::{gdk, glib, prelude::*};
+
+mod window;
+mod x;
+
+fn main() {
+    gtk4::init().unwrap();
+
+    let display = gdk::Display::default().unwrap();
+    let monitors = display.monitors().unwrap();
+
+    for i in 0..monitors.n_items() {
+        let monitor = monitors
+            .item(i)
+            .unwrap()
+            .downcast::<gdk::Monitor>()
+            .unwrap();
+        window::window(monitor);
+    }
+
+    monitors.connect_items_changed(|monitors, position, _removed, added| {
+        for i in position..position + added {
+            let monitor = monitors
+                .item(i)
+                .unwrap()
+                .downcast::<gdk::Monitor>()
+                .unwrap();
+            window::window(monitor);
+        }
+    });
+
+    glib::MainLoop::new(None, false).run();
+}

src/window.rs

@@ -0,0 +1,94 @@
+use cascade::cascade;
+use glib::clone;
+use gtk4::{gdk, glib, prelude::*};
+
+use crate::x;
+
+pub fn window(monitor: gdk::Monitor) -> gtk4::Window {
+    let box_ = cascade! {
+        gtk4::CenterBox::new();
+        ..set_start_widget(Some(&cascade! {
+            gtk4::Box::new(gtk4::Orientation::Horizontal, 0);
+            ..append(&gtk4::Button::with_label("Workspaces"));
+            ..append(&gtk4::Button::with_label("Applications"));
+        }));
+        ..set_center_widget(Some(&cascade! {
+            gtk4::MenuButton::new();
+            ..set_label("Jan 1 00:00 AM");
+            ..set_popover(Some(&cascade! {
+                gtk4::Popover::new();
+                ..set_child(Some(&cascade! {
+                    gtk4::Calendar::new();
+                }));
+            }));
+        }));
+    };
+
+    let window = cascade! {
+        gtk4::Window::new();
+        ..set_decorated(false);
+        //..set_keep_above(true);
+        //..stick();
+        ..set_child(Some(&box_));
+        ..connect_realize(|window| {
+        });
+        ..show();
+    };
+
+    if let Some((display, surface)) = x::get_window_x11(&window) {
+        unsafe {
+            surface.set_skip_pager_hint(true);
+            surface.set_skip_taskbar_hint(true);
+            x::change_property(
+                &display,
+                &surface,
+                "_NET_WM_STATE",
+                x::PropMode::Append,
+                &[
+                    x::Atom::new(&display, "_NET_WM_STATE_ABOVE").unwrap(),
+                    x::Atom::new(&display, "_NET_WM_STATE_STICKY").unwrap(),
+                ],
+            ); // XXX not working?
+            x::change_property(
+                &display,
+                &surface,
+                "_NET_WM_ALLOWED_ACTIONS",
+                x::PropMode::Replace,
+                &[
+                    x::Atom::new(&display, "_NET_WM_ACTION_CHANGE_DESKTOP").unwrap(),
+                    x::Atom::new(&display, "_NET_WM_ACTION_ABOVE").unwrap(),
+                    x::Atom::new(&display, "_NET_WM_ACTION_BELOW").unwrap(),
+                ],
+            );
+            x::change_property(
+                &display,
+                &surface,
+                "_NET_WM_STRUT",
+                x::PropMode::Replace,
+                &[0, 0, 32 as x::c_ulong, 0],
+            );
+            x::change_property(
+                &display,
+                &surface,
+                "_NET_WM_WINDOW_TYPE",
+                x::PropMode::Replace,
+                &[x::Atom::new(&display, "_NET_WM_WINDOW_TYPE_DOCK").unwrap()],
+            );
+        }
+    }
+
+    let gdk::Rectangle {
+        x,
+        y,
+        width,
+        height,
+    } = monitor.geometry();
+    window.set_size_request(width, 0);
+    monitor.connect_geometry_notify(clone!(@strong window => move |monitor| {
+        let gdk::Rectangle { x, y, width, height } = monitor.geometry();
+        window.set_size_request(width, 0);
+    }));
+    monitor.connect_invalidate(clone!(@strong window => move |_| window.close()));
+
+    window
+}

src/x.rs

@@ -0,0 +1,137 @@
+use gdk4_x11::x11::xlib;
+use glib::translate::ToGlibPtr;
+use gtk4::{glib, prelude::*};
+use std::{
+    ffi::{CString, NulError},
+    os::raw::c_int,
+};
+
+pub use std::os::raw::{c_uchar, c_ulong, c_ushort};
+
+pub fn get_window_x11(
+    window: &gtk4::Window,
+) -> Option<(gdk4_x11::X11Display, gdk4_x11::X11Surface)> {
+    let surface = window.surface()?.downcast::<gdk4_x11::X11Surface>().ok()?;
+    let display = surface.display()?.downcast::<gdk4_x11::X11Display>().ok()?;
+    Some((display, surface))
+}
+
+#[repr(transparent)]
+pub struct Atom(xlib::Atom);
+
+impl Atom {
+    pub fn new(display: &gdk4_x11::X11Display, prop: &str) -> Result<Self, NulError> {
+        unsafe {
+            let prop = CString::new(prop)?;
+            Ok(Self(gdk4_x11::ffi::gdk_x11_get_xatom_by_name_for_display(
+                display.to_glib_none().0,
+                prop.as_ptr(),
+            )))
+        }
+    }
+}
+
+pub unsafe trait XElement {
+    const TYPE: xlib::Atom;
+    const SIZE: c_int;
+}
+
+unsafe impl XElement for c_uchar {
+    const TYPE: xlib::Atom = xlib::XA_CARDINAL;
+    const SIZE: c_int = 8;
+}
+
+unsafe impl XElement for c_ushort {
+    const TYPE: xlib::Atom = xlib::XA_CARDINAL;
+    const SIZE: c_int = 16;
+}
+
+unsafe impl XElement for c_ulong {
+    const TYPE: xlib::Atom = xlib::XA_CARDINAL;
+    const SIZE: c_int = 32;
+}
+
+unsafe impl XElement for Atom {
+    const TYPE: xlib::Atom = xlib::XA_ATOM;
+    const SIZE: c_int = 32;
+}
+
+pub unsafe trait XProp {
+    const TYPE: xlib::Atom;
+    const SIZE: c_int;
+
+    fn ptr(&self) -> *const u8;
+
+    fn nelements(&self) -> c_int;
+}
+
+unsafe impl<T: XElement, const LEN: usize> XProp for &[T; LEN] {
+    const TYPE: xlib::Atom = T::TYPE;
+    const SIZE: c_int = T::SIZE;
+
+    fn ptr(&self) -> *const u8 {
+        self.as_ptr() as _
+    }
+
+    fn nelements(&self) -> c_int {
+        LEN as c_int
+    }
+}
+
+unsafe impl<T: XElement> XProp for &[T] {
+    const TYPE: xlib::Atom = T::TYPE;
+    const SIZE: c_int = T::SIZE;
+
+    fn ptr(&self) -> *const u8 {
+        self.as_ptr() as _
+    }
+
+    fn nelements(&self) -> c_int {
+        self.len() as c_int
+    }
+}
+
+unsafe impl XProp for &str {
+    const TYPE: xlib::Atom = xlib::XA_STRING;
+    const SIZE: c_int = 8;
+
+    fn ptr(&self) -> *const u8 {
+        self.as_ptr()
+    }
+
+    fn nelements(&self) -> c_int {
+        self.len() as c_int
+    }
+}
+
+#[allow(dead_code)]
+pub enum PropMode {
+    Replace,
+    Prepend,
+    Append,
+}
+
+pub unsafe fn change_property<T: XProp>(
+    display: &gdk4_x11::X11Display,
+    surface: &gdk4_x11::X11Surface,
+    prop: &str,
+    mode: PropMode,
+    value: T,
+) {
+    // TODO check error return value
+    let mode = match mode {
+        PropMode::Replace => xlib::PropModeReplace,
+        PropMode::Prepend => xlib::PropModePrepend,
+        PropMode::Append => xlib::PropModeAppend,
+    };
+    xlib::XChangeProperty(
+        display.xdisplay(),
+        surface.xid(),
+        Atom::new(display, prop).unwrap().0,
+        T::TYPE,
+        T::SIZE,
+        mode,
+        value.ptr(),
+        value.nelements(),
+    );
+}