294 lines
9.8 KiB
Rust
294 lines
9.8 KiB
Rust
use cosmic::Element;
|
|
use cosmic::app::{Core, Settings, Task};
|
|
use cosmic::iced::event::{self, PlatformSpecific, wayland};
|
|
use cosmic::iced::keyboard::{self, Key, key::Named};
|
|
use cosmic::iced::platform_specific::{
|
|
runtime::wayland::layer_surface::{IcedOutput, SctkLayerSurfaceSettings},
|
|
shell::commands::layer_surface::{Anchor, KeyboardInteractivity, Layer},
|
|
};
|
|
use cosmic::iced::{Event, Length, Subscription, window};
|
|
use cosmic::widget::{button, column, container, text};
|
|
use ferese_protocols::effects::v1::client::{
|
|
ferese_effects_manager_v1::FereseEffectsManagerV1,
|
|
ferese_surface_effects_v1::{self, FereseSurfaceEffectsV1},
|
|
};
|
|
use std::time::Duration;
|
|
use wayland_client::{
|
|
Connection, Dispatch, EventQueue, Proxy, QueueHandle, delegate_noop,
|
|
globals::{GlobalListContents, registry_queue_init},
|
|
protocol::{wl_registry, wl_surface},
|
|
};
|
|
|
|
const APP_ID: &str = "dev.ferese.ShellSpike";
|
|
const BAR_HEIGHT: u32 = 48;
|
|
|
|
fn main() -> cosmic::iced::Result {
|
|
let settings = Settings::default()
|
|
.no_main_window(true)
|
|
.client_decorations(false)
|
|
.transparent(true)
|
|
.is_daemon(true);
|
|
|
|
cosmic::app::run::<ShellSpike>(settings, ())
|
|
}
|
|
|
|
struct ShellSpike {
|
|
core: Core,
|
|
surface_id: window::Id,
|
|
configured: bool,
|
|
focused: bool,
|
|
outputs: usize,
|
|
exit_after: Option<Duration>,
|
|
effects: Option<EffectsBinding>,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
enum Message {
|
|
Event(Event, window::Id),
|
|
Exit,
|
|
}
|
|
|
|
impl cosmic::Application for ShellSpike {
|
|
type Executor = cosmic::executor::Default;
|
|
type Flags = ();
|
|
type Message = Message;
|
|
|
|
const APP_ID: &'static str = APP_ID;
|
|
|
|
fn core(&self) -> &Core {
|
|
&self.core
|
|
}
|
|
|
|
fn core_mut(&mut self) -> &mut Core {
|
|
&mut self.core
|
|
}
|
|
|
|
fn init(core: Core, _flags: Self::Flags) -> (Self, Task<Self::Message>) {
|
|
let surface_id = window::Id::unique();
|
|
let force_focus = std::env::var_os("FERESE_SHELL_SPIKE_EXCLUSIVE_FOCUS").is_some();
|
|
let app = Self {
|
|
core,
|
|
surface_id,
|
|
configured: false,
|
|
focused: false,
|
|
outputs: 0,
|
|
exit_after: std::env::var("FERESE_SHELL_SPIKE_EXIT_AFTER_MS")
|
|
.ok()
|
|
.and_then(|value| value.parse().ok())
|
|
.map(Duration::from_millis),
|
|
effects: None,
|
|
};
|
|
let action = cosmic::surface::action::app_layer_shell::<Self>(
|
|
|_| Default::default(),
|
|
move |_| SctkLayerSurfaceSettings {
|
|
id: surface_id,
|
|
layer: Layer::Top,
|
|
keyboard_interactivity: if force_focus {
|
|
KeyboardInteractivity::Exclusive
|
|
} else {
|
|
KeyboardInteractivity::OnDemand
|
|
},
|
|
anchor: Anchor::TOP | Anchor::LEFT | Anchor::RIGHT,
|
|
output: IcedOutput::Active,
|
|
namespace: "ferese-shell-spike".to_owned(),
|
|
size: Some((None, Some(BAR_HEIGHT))),
|
|
exclusive_zone: BAR_HEIGHT as i32,
|
|
..Default::default()
|
|
},
|
|
Some(Box::new(Self::view_layer)),
|
|
);
|
|
|
|
println!(
|
|
"PASS startup requested active-output layer surface focus={}",
|
|
if force_focus {
|
|
"exclusive"
|
|
} else {
|
|
"on-demand"
|
|
}
|
|
);
|
|
|
|
(app, cosmic::task::message(cosmic::Action::Surface(action)))
|
|
}
|
|
|
|
fn subscription(&self) -> Subscription<Self::Message> {
|
|
let events = event::listen_with(|event, _status, id| Some(Message::Event(event, id)));
|
|
let mut subscriptions = vec![events];
|
|
if let Some(delay) = self.exit_after {
|
|
subscriptions.push(cosmic::iced::time::every(delay).map(|_| Message::Exit));
|
|
}
|
|
Subscription::batch(subscriptions)
|
|
}
|
|
|
|
fn update(&mut self, message: Self::Message) -> Task<Self::Message> {
|
|
match message {
|
|
Message::Event(event, id) => self.handle_event(event, id),
|
|
Message::Exit => {
|
|
println!("PASS clean shutdown requested");
|
|
cosmic::iced::exit()
|
|
}
|
|
}
|
|
}
|
|
|
|
fn view(&self) -> Element<'_, Self::Message> {
|
|
text("").into()
|
|
}
|
|
|
|
fn view_window(&self, _id: window::Id) -> Element<'_, Self::Message> {
|
|
text("").into()
|
|
}
|
|
}
|
|
|
|
impl ShellSpike {
|
|
fn handle_event(&mut self, event: Event, id: window::Id) -> Task<Message> {
|
|
match event {
|
|
Event::Window(window::Event::Opened { size, .. }) if id == self.surface_id => {
|
|
self.configured = true;
|
|
println!(
|
|
"PASS configure surface={} size={}x{}",
|
|
id, size.width, size.height
|
|
);
|
|
}
|
|
Event::Window(window::Event::Resized(size)) if id == self.surface_id => {
|
|
println!(
|
|
"PASS reconfigure surface={} size={}x{}",
|
|
id, size.width, size.height
|
|
);
|
|
}
|
|
Event::Window(window::Event::Focused) if id == self.surface_id => {
|
|
self.focused = true;
|
|
println!("PASS keyboard focus acquired surface={id}");
|
|
}
|
|
Event::Window(window::Event::Unfocused) if id == self.surface_id => {
|
|
self.focused = false;
|
|
println!("PASS keyboard focus released surface={id}");
|
|
}
|
|
Event::Window(window::Event::Closed) if id == self.surface_id => {
|
|
println!("PASS compositor closed layer surface={id}");
|
|
return cosmic::iced::exit();
|
|
}
|
|
Event::Keyboard(keyboard::Event::KeyPressed {
|
|
key: Key::Named(Named::Escape),
|
|
..
|
|
}) if id == self.surface_id => return cosmic::task::message(Message::Exit),
|
|
Event::PlatformSpecific(PlatformSpecific::Wayland(wayland::Event::Output(
|
|
output_event,
|
|
output,
|
|
))) => match output_event {
|
|
wayland::OutputEvent::Created(info) => {
|
|
self.outputs += 1;
|
|
println!(
|
|
"PASS output discovered output={output:?} info={info:?} count={}",
|
|
self.outputs,
|
|
);
|
|
}
|
|
wayland::OutputEvent::InfoUpdate(info) => {
|
|
println!("PASS output updated output={output:?} info={info:?}");
|
|
}
|
|
wayland::OutputEvent::Removed => {
|
|
self.outputs = self.outputs.saturating_sub(1);
|
|
println!(
|
|
"PASS output removed output={output:?} count={}",
|
|
self.outputs,
|
|
);
|
|
}
|
|
},
|
|
Event::PlatformSpecific(PlatformSpecific::Wayland(wayland::Event::Frame(
|
|
_,
|
|
surface,
|
|
frame_id,
|
|
))) if frame_id == self.surface_id => self.attach_effects(&surface),
|
|
Event::PlatformSpecific(PlatformSpecific::Wayland(wayland::Event::Layer(
|
|
layer_event,
|
|
surface,
|
|
layer_id,
|
|
))) if layer_id == self.surface_id => {
|
|
self.attach_effects(&surface);
|
|
println!(
|
|
"PASS layer event={layer_event:?} surface={surface:?} configured={} focused={}",
|
|
self.configured, self.focused
|
|
);
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
Task::none()
|
|
}
|
|
|
|
fn attach_effects(&mut self, surface: &wl_surface::WlSurface) {
|
|
if self.effects.is_some() {
|
|
return;
|
|
}
|
|
|
|
match EffectsBinding::attach(surface) {
|
|
Ok(binding) => {
|
|
self.effects = Some(binding);
|
|
println!("PASS ferese-effects-v1 attached role=panel");
|
|
}
|
|
Err(error) => eprintln!("FAIL ferese-effects-v1 attachment: {error}"),
|
|
}
|
|
}
|
|
|
|
fn view_layer(&self) -> Element<'_, cosmic::Action<Message>> {
|
|
let status = format!(
|
|
"Ferese shell spike | configured: {} | focused: {} | outputs: {}",
|
|
self.configured, self.focused, self.outputs
|
|
);
|
|
let content = column![
|
|
text(status),
|
|
button::standard("Exit spike").on_press(cosmic::Action::App(Message::Exit))
|
|
]
|
|
.spacing(4)
|
|
.padding([4, 16]);
|
|
|
|
container(content)
|
|
.width(Length::Fill)
|
|
.height(Length::Fill)
|
|
.into()
|
|
}
|
|
}
|
|
|
|
struct EffectsBinding {
|
|
_manager: FereseEffectsManagerV1,
|
|
_surface: FereseSurfaceEffectsV1,
|
|
_queue: EventQueue<EffectsState>,
|
|
}
|
|
|
|
impl EffectsBinding {
|
|
fn attach(surface: &wl_surface::WlSurface) -> Result<Self, Box<dyn std::error::Error>> {
|
|
let backend = surface
|
|
.backend()
|
|
.upgrade()
|
|
.ok_or("libcosmic Wayland connection is no longer alive")?;
|
|
let connection = Connection::from_backend(backend);
|
|
let (globals, queue) = registry_queue_init::<EffectsState>(&connection)?;
|
|
let qh = queue.handle();
|
|
let manager = globals.bind::<FereseEffectsManagerV1, _, _>(&qh, 1..=1, ())?;
|
|
let effects = manager.get_surface_effects(surface, &qh, ());
|
|
effects.set_role(ferese_surface_effects_v1::Role::Panel);
|
|
connection.flush()?;
|
|
|
|
Ok(Self {
|
|
_manager: manager,
|
|
_surface: effects,
|
|
_queue: queue,
|
|
})
|
|
}
|
|
}
|
|
|
|
struct EffectsState;
|
|
|
|
impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for EffectsState {
|
|
fn event(
|
|
_state: &mut Self,
|
|
_registry: &wl_registry::WlRegistry,
|
|
_event: wl_registry::Event,
|
|
_data: &GlobalListContents,
|
|
_connection: &Connection,
|
|
_qh: &QueueHandle<Self>,
|
|
) {
|
|
}
|
|
}
|
|
|
|
delegate_noop!(EffectsState: ignore FereseEffectsManagerV1);
|
|
delegate_noop!(EffectsState: ignore FereseSurfaceEffectsV1);
|