Use EGUI as windows sidebar

[chrisheib]

Working on this as a kind of system status monitor alike of 8gadgets or SidebarDiagnostics.
I couldn't find anything on how to get an rust gui app running with this, so I came up with this, adopting the C# WpfAppBar.
Haven't dabbled much in windows api calling, so I'm proud i got this far and wanted to share, in the case others searched for this.
Using the windows crate, building off of the custom_window_frame example.

My goal is to build something resembling the left status bar. So far I got the right one running.

Open questions: Is there a more reliable way to get the window handle from the egui context then trough the active_window crate?

Cargo.toml:

[dependencies]
active-win-pos-rs = "0.7.1"
eframe = "0.21.3"
lazy_static = "1.4.0"
windows = { version = "0.44.0", features = ["Win32_UI_Shell", "Win32_Foundation", "Win32_Graphics_Dwm"] }

main.rs

mod sidebar;

// Right Screen, Right side
pub const SIZE: egui::Vec2 = egui::Vec2 {
    x: 150.0,
    y: 1032.0,
};
pub const POS: egui::Pos2 = egui::Pos2 {
    x: 4330.0,
    y: 148.0,
};
pub const EDGE: u32 = windows::Win32::UI::Shell::ABE_RIGHT;

...

fn main() -> Result<(), eframe::Error> {

    ...

    eframe::run_native(
        "Sidebar", // unused title
        options,
        Box::new(|_cc| Box::<MyApp>::default()),
    )?;

    dispose_sidebar();

    Ok(())
}

...

#[derive(Default)]
struct MyApp {
    firstupdate: bool,
    create_frame: u64,
    framecount: u64,
}

impl eframe::App for MyApp {
    fn clear_color(&self, _visuals: &egui::Visuals) -> [f32; 4] {
        egui::Rgba::TRANSPARENT.to_array() // Make sure we don't paint anything behind the rounded corners
    }

    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
        self.framecount += 1;

        if frame.info().window_info.position != Some(POS) {
            frame.set_window_pos(POS);
        }

        if !self.firstupdate && self.framecount > 1 {
            self.firstupdate = true;
            self.create_frame = self.framecount;
            sidebar::setup_sidebar();
            frame.set_window_pos(POS);
        }
    }
}

sidebar.rs

use std::{mem, ops::DerefMut, os::raw::c_void, sync::RwLock};

use lazy_static::lazy_static;
use windows::Win32::{
    Foundation::{HWND, LPARAM, RECT},
    Graphics::Dwm::{
        DwmSetWindowAttribute, DWMNCRENDERINGPOLICY, DWMNCRP_ENABLED, DWMWA_DISALLOW_PEEK,
        DWMWA_EXCLUDED_FROM_PEEK,
    },
    UI::Shell::{
        SHAppBarMessage, ABE_LEFT, ABM_NEW, ABM_QUERYPOS, ABM_REMOVE, ABM_SETPOS, APPBARDATA,
    },
};

use crate::{EDGE, POS, SIZE};

lazy_static! {
    static ref STATIC_HWND: RwLock<isize> = 0.into();
}

pub(crate) fn setup_sidebar() {
    let active_window = active_win_pos_rs::get_active_window().expect("Active window should exist");
    println!("active window: {active_window:#?}");
    let handle = active_window
        .window_id
        .replace("HWND(", "")
        .replace(')', "")
        .parse::<isize>()
        .expect("handle should be valid isize");

    *STATIC_HWND.write().unwrap().deref_mut() = handle;

    let hwnd = HWND(handle);

    let rect = RECT {
        left: POS.x as i32,
        top: 0,
        right: POS.x as i32 + SIZE.x as i32,
        bottom: i32::MAX,
    };

    let lparam = LPARAM(0);

    let mut appbardata = APPBARDATA {
        cbSize: mem::size_of::<APPBARDATA>() as u32,
        hWnd: hwnd,
        uCallbackMessage: 0,
        uEdge: EDGE,
        rc: rect,
        lParam: lparam,
    };

    let mut dwmncrp_enabled_orig = DWMNCRP_ENABLED;
    let dwmncrp_enabled: *mut c_void = &mut dwmncrp_enabled_orig as *mut _ as *mut c_void;

    unsafe {
        let abd_ptr = &mut appbardata as *mut APPBARDATA;
        dbg!(SHAppBarMessage(ABM_NEW, abd_ptr));
        DwmSetWindowAttribute(
            hwnd,
            DWMWA_EXCLUDED_FROM_PEEK,
            dwmncrp_enabled,
            mem::size_of::<DWMNCRENDERINGPOLICY>() as u32,
        )
        .expect("DWMWA_EXCLUDED_FROM_PEEK should work");
        DwmSetWindowAttribute(
            hwnd,
            DWMWA_DISALLOW_PEEK,
            dwmncrp_enabled,
            mem::size_of::<DWMNCRENDERINGPOLICY>() as u32,
        )
        .expect("DWMWA_EXCLUDED_FROM_PEEK should work");
        dbg!(SHAppBarMessage(ABM_QUERYPOS, abd_ptr));
        dbg!(SHAppBarMessage(ABM_SETPOS, abd_ptr));
    }
}

pub fn dispose_sidebar() {
    let hwnd = HWND(*STATIC_HWND.read().unwrap());

    let rect = RECT {
        left: 0,
        top: 0,
        right: 150,
        bottom: 10000,
    };

    let lparam = LPARAM(0);

    let mut appbardata = APPBARDATA {
        cbSize: mem::size_of::<APPBARDATA>() as u32,
        hWnd: hwnd,
        uCallbackMessage: 0,
        uEdge: ABE_LEFT,
        rc: rect,
        lParam: lparam,
    };

    unsafe {
        let abd_ptr = &mut appbardata as *mut APPBARDATA;
        dbg!(SHAppBarMessage(ABM_REMOVE, abd_ptr));
    }
}