1use std::cell::{Ref, RefCell, RefMut};
2use std::ffi::c_void;
3use std::ptr::NonNull;
4use std::rc::Rc;
5use std::sync::Arc;
6
7use blade_graphics as gpu;
8use collections::HashMap;
9use futures::channel::oneshot::Receiver;
10
11use raw_window_handle as rwh;
12use wayland_backend::client::ObjectId;
13use wayland_client::WEnum;
14use wayland_client::{protocol::wl_surface, Proxy};
15use wayland_protocols::wp::fractional_scale::v1::client::wp_fractional_scale_v1;
16use wayland_protocols::wp::viewporter::client::wp_viewport;
17use wayland_protocols::xdg::decoration::zv1::client::zxdg_toplevel_decoration_v1;
18use wayland_protocols::xdg::shell::client::xdg_surface;
19use wayland_protocols::xdg::shell::client::xdg_toplevel::{self};
20use wayland_protocols_plasma::blur::client::org_kde_kwin_blur;
21
22use crate::platform::blade::{BladeRenderer, BladeSurfaceConfig};
23use crate::platform::linux::wayland::display::WaylandDisplay;
24use crate::platform::linux::wayland::serial::SerialKind;
25use crate::platform::{PlatformAtlas, PlatformInputHandler, PlatformWindow};
26use crate::scene::Scene;
27use crate::{
28 px, size, AnyWindowHandle, Bounds, Decorations, Globals, Modifiers, Output, Pixels,
29 PlatformDisplay, PlatformInput, Point, PromptLevel, ResizeEdge, Size, Tiling,
30 WaylandClientStatePtr, WindowAppearance, WindowBackgroundAppearance, WindowBounds,
31 WindowControls, WindowDecorations, WindowParams,
32};
33
34#[derive(Default)]
35pub(crate) struct Callbacks {
36 request_frame: Option<Box<dyn FnMut()>>,
37 input: Option<Box<dyn FnMut(crate::PlatformInput) -> crate::DispatchEventResult>>,
38 active_status_change: Option<Box<dyn FnMut(bool)>>,
39 resize: Option<Box<dyn FnMut(Size<Pixels>, f32)>>,
40 moved: Option<Box<dyn FnMut()>>,
41 should_close: Option<Box<dyn FnMut() -> bool>>,
42 close: Option<Box<dyn FnOnce()>>,
43 appearance_changed: Option<Box<dyn FnMut()>>,
44}
45
46struct RawWindow {
47 window: *mut c_void,
48 display: *mut c_void,
49}
50
51impl rwh::HasWindowHandle for RawWindow {
52 fn window_handle(&self) -> Result<rwh::WindowHandle<'_>, rwh::HandleError> {
53 let window = NonNull::new(self.window).unwrap();
54 let handle = rwh::WaylandWindowHandle::new(window);
55 Ok(unsafe { rwh::WindowHandle::borrow_raw(handle.into()) })
56 }
57}
58impl rwh::HasDisplayHandle for RawWindow {
59 fn display_handle(&self) -> Result<rwh::DisplayHandle<'_>, rwh::HandleError> {
60 let display = NonNull::new(self.display).unwrap();
61 let handle = rwh::WaylandDisplayHandle::new(display);
62 Ok(unsafe { rwh::DisplayHandle::borrow_raw(handle.into()) })
63 }
64}
65
66#[derive(Debug)]
67struct InProgressConfigure {
68 size: Option<Size<Pixels>>,
69 fullscreen: bool,
70 maximized: bool,
71 tiling: Tiling,
72}
73
74pub struct WaylandWindowState {
75 xdg_surface: xdg_surface::XdgSurface,
76 acknowledged_first_configure: bool,
77 pub surface: wl_surface::WlSurface,
78 decoration: Option<zxdg_toplevel_decoration_v1::ZxdgToplevelDecorationV1>,
79 appearance: WindowAppearance,
80 blur: Option<org_kde_kwin_blur::OrgKdeKwinBlur>,
81 toplevel: xdg_toplevel::XdgToplevel,
82 viewport: Option<wp_viewport::WpViewport>,
83 outputs: HashMap<ObjectId, Output>,
84 display: Option<(ObjectId, Output)>,
85 globals: Globals,
86 renderer: BladeRenderer,
87 bounds: Bounds<Pixels>,
88 scale: f32,
89 input_handler: Option<PlatformInputHandler>,
90 decorations: WindowDecorations,
91 background_appearance: WindowBackgroundAppearance,
92 fullscreen: bool,
93 maximized: bool,
94 tiling: Tiling,
95 window_bounds: Bounds<Pixels>,
96 client: WaylandClientStatePtr,
97 handle: AnyWindowHandle,
98 active: bool,
99 in_progress_configure: Option<InProgressConfigure>,
100 in_progress_window_controls: Option<WindowControls>,
101 window_controls: WindowControls,
102 inset: Option<Pixels>,
103 requested_inset: Option<Pixels>,
104}
105
106#[derive(Clone)]
107pub struct WaylandWindowStatePtr {
108 state: Rc<RefCell<WaylandWindowState>>,
109 callbacks: Rc<RefCell<Callbacks>>,
110}
111
112impl WaylandWindowState {
113 #[allow(clippy::too_many_arguments)]
114 pub(crate) fn new(
115 handle: AnyWindowHandle,
116 surface: wl_surface::WlSurface,
117 xdg_surface: xdg_surface::XdgSurface,
118 toplevel: xdg_toplevel::XdgToplevel,
119 decoration: Option<zxdg_toplevel_decoration_v1::ZxdgToplevelDecorationV1>,
120 appearance: WindowAppearance,
121 viewport: Option<wp_viewport::WpViewport>,
122 client: WaylandClientStatePtr,
123 globals: Globals,
124 options: WindowParams,
125 ) -> anyhow::Result<Self> {
126 let raw = RawWindow {
127 window: surface.id().as_ptr().cast::<c_void>(),
128 display: surface
129 .backend()
130 .upgrade()
131 .unwrap()
132 .display_ptr()
133 .cast::<c_void>(),
134 };
135 let gpu = Arc::new(
136 unsafe {
137 gpu::Context::init_windowed(
138 &raw,
139 gpu::ContextDesc {
140 validation: false,
141 capture: false,
142 overlay: false,
143 },
144 )
145 }
146 .map_err(|e| anyhow::anyhow!("{:?}", e))?,
147 );
148 let config = BladeSurfaceConfig {
149 size: gpu::Extent {
150 width: options.bounds.size.width.0 as u32,
151 height: options.bounds.size.height.0 as u32,
152 depth: 1,
153 },
154 transparent: true,
155 };
156
157 Ok(Self {
158 xdg_surface,
159 acknowledged_first_configure: false,
160 surface,
161 decoration,
162 blur: None,
163 toplevel,
164 viewport,
165 globals,
166 outputs: HashMap::default(),
167 display: None,
168 renderer: BladeRenderer::new(gpu, config),
169 bounds: options.bounds,
170 scale: 1.0,
171 input_handler: None,
172 decorations: WindowDecorations::Client,
173 background_appearance: WindowBackgroundAppearance::Opaque,
174 fullscreen: false,
175 maximized: false,
176 tiling: Tiling::default(),
177 window_bounds: options.bounds,
178 in_progress_configure: None,
179 client,
180 appearance,
181 handle,
182 active: false,
183 in_progress_window_controls: None,
184 // Assume that we can do anything, unless told otherwise
185 window_controls: WindowControls {
186 fullscreen: true,
187 maximize: true,
188 minimize: true,
189 window_menu: true,
190 },
191 inset: None,
192 requested_inset: None,
193 })
194 }
195
196 pub fn is_transparent(&self) -> bool {
197 self.decorations == WindowDecorations::Client
198 || self.background_appearance != WindowBackgroundAppearance::Opaque
199 }
200}
201
202pub(crate) struct WaylandWindow(pub WaylandWindowStatePtr);
203pub enum ImeInput {
204 InsertText(String),
205 SetMarkedText(String),
206 UnmarkText,
207 DeleteText,
208}
209
210impl Drop for WaylandWindow {
211 fn drop(&mut self) {
212 let mut state = self.0.state.borrow_mut();
213 let surface_id = state.surface.id();
214 let client = state.client.clone();
215
216 state.renderer.destroy();
217 if let Some(decoration) = &state.decoration {
218 decoration.destroy();
219 }
220 if let Some(blur) = &state.blur {
221 blur.release();
222 }
223 state.toplevel.destroy();
224 if let Some(viewport) = &state.viewport {
225 viewport.destroy();
226 }
227 state.xdg_surface.destroy();
228 state.surface.destroy();
229
230 let state_ptr = self.0.clone();
231 state
232 .globals
233 .executor
234 .spawn(async move {
235 state_ptr.close();
236 client.drop_window(&surface_id)
237 })
238 .detach();
239 drop(state);
240 }
241}
242
243impl WaylandWindow {
244 fn borrow(&self) -> Ref<WaylandWindowState> {
245 self.0.state.borrow()
246 }
247
248 fn borrow_mut(&self) -> RefMut<WaylandWindowState> {
249 self.0.state.borrow_mut()
250 }
251
252 pub fn new(
253 handle: AnyWindowHandle,
254 globals: Globals,
255 client: WaylandClientStatePtr,
256 params: WindowParams,
257 appearance: WindowAppearance,
258 ) -> anyhow::Result<(Self, ObjectId)> {
259 let surface = globals.compositor.create_surface(&globals.qh, ());
260 let xdg_surface = globals
261 .wm_base
262 .get_xdg_surface(&surface, &globals.qh, surface.id());
263 let toplevel = xdg_surface.get_toplevel(&globals.qh, surface.id());
264 toplevel.set_min_size(50, 50);
265
266 if let Some(fractional_scale_manager) = globals.fractional_scale_manager.as_ref() {
267 fractional_scale_manager.get_fractional_scale(&surface, &globals.qh, surface.id());
268 }
269
270 // Attempt to set up window decorations based on the requested configuration
271 let decoration = globals
272 .decoration_manager
273 .as_ref()
274 .map(|decoration_manager| {
275 decoration_manager.get_toplevel_decoration(&toplevel, &globals.qh, surface.id())
276 });
277
278 let viewport = globals
279 .viewporter
280 .as_ref()
281 .map(|viewporter| viewporter.get_viewport(&surface, &globals.qh, ()));
282
283 let this = Self(WaylandWindowStatePtr {
284 state: Rc::new(RefCell::new(WaylandWindowState::new(
285 handle,
286 surface.clone(),
287 xdg_surface,
288 toplevel,
289 decoration,
290 appearance,
291 viewport,
292 client,
293 globals,
294 params,
295 )?)),
296 callbacks: Rc::new(RefCell::new(Callbacks::default())),
297 });
298
299 // Kick things off
300 surface.commit();
301
302 Ok((this, surface.id()))
303 }
304}
305
306impl WaylandWindowStatePtr {
307 pub fn handle(&self) -> AnyWindowHandle {
308 self.state.borrow().handle
309 }
310
311 pub fn surface(&self) -> wl_surface::WlSurface {
312 self.state.borrow().surface.clone()
313 }
314
315 pub fn ptr_eq(&self, other: &Self) -> bool {
316 Rc::ptr_eq(&self.state, &other.state)
317 }
318
319 pub fn frame(&self, request_frame_callback: bool) {
320 if request_frame_callback {
321 let mut state = self.state.borrow_mut();
322 state.surface.frame(&state.globals.qh, state.surface.id());
323 drop(state);
324 }
325 let mut cb = self.callbacks.borrow_mut();
326 if let Some(fun) = cb.request_frame.as_mut() {
327 fun();
328 }
329 }
330
331 pub fn handle_xdg_surface_event(&self, event: xdg_surface::Event) {
332 match event {
333 xdg_surface::Event::Configure { serial } => {
334 {
335 let mut state = self.state.borrow_mut();
336 if let Some(window_controls) = state.in_progress_window_controls.take() {
337 state.window_controls = window_controls;
338
339 drop(state);
340 let mut callbacks = self.callbacks.borrow_mut();
341 if let Some(appearance_changed) = callbacks.appearance_changed.as_mut() {
342 appearance_changed();
343 }
344 }
345 }
346 {
347 let mut state = self.state.borrow_mut();
348
349 if let Some(mut configure) = state.in_progress_configure.take() {
350 let got_unmaximized = state.maximized && !configure.maximized;
351 state.fullscreen = configure.fullscreen;
352 state.maximized = configure.maximized;
353 state.tiling = configure.tiling;
354 if got_unmaximized {
355 configure.size = Some(state.window_bounds.size);
356 } else if !configure.maximized {
357 configure.size =
358 compute_outer_size(state.inset, configure.size, state.tiling);
359 }
360 if !configure.fullscreen && !configure.maximized {
361 if let Some(size) = configure.size {
362 state.window_bounds = Bounds {
363 origin: Point::default(),
364 size,
365 };
366 }
367 }
368 drop(state);
369 if let Some(size) = configure.size {
370 self.resize(size);
371 }
372 }
373 }
374 let mut state = self.state.borrow_mut();
375 state.xdg_surface.ack_configure(serial);
376 let request_frame_callback = !state.acknowledged_first_configure;
377 state.acknowledged_first_configure = true;
378
379 if request_frame_callback {
380 drop(state);
381 self.frame(true);
382 }
383 }
384 _ => {}
385 }
386 }
387
388 pub fn handle_toplevel_decoration_event(&self, event: zxdg_toplevel_decoration_v1::Event) {
389 match event {
390 zxdg_toplevel_decoration_v1::Event::Configure { mode } => match mode {
391 WEnum::Value(zxdg_toplevel_decoration_v1::Mode::ServerSide) => {
392 self.state.borrow_mut().decorations = WindowDecorations::Server;
393 if let Some(mut appearance_changed) =
394 self.callbacks.borrow_mut().appearance_changed.as_mut()
395 {
396 appearance_changed();
397 }
398 }
399 WEnum::Value(zxdg_toplevel_decoration_v1::Mode::ClientSide) => {
400 self.state.borrow_mut().decorations = WindowDecorations::Client;
401 // Update background to be transparent
402 if let Some(mut appearance_changed) =
403 self.callbacks.borrow_mut().appearance_changed.as_mut()
404 {
405 appearance_changed();
406 }
407 }
408 WEnum::Value(_) => {
409 log::warn!("Unknown decoration mode");
410 }
411 WEnum::Unknown(v) => {
412 log::warn!("Unknown decoration mode: {}", v);
413 }
414 },
415 _ => {}
416 }
417 }
418
419 pub fn handle_fractional_scale_event(&self, event: wp_fractional_scale_v1::Event) {
420 match event {
421 wp_fractional_scale_v1::Event::PreferredScale { scale } => {
422 self.rescale(scale as f32 / 120.0);
423 }
424 _ => {}
425 }
426 }
427
428 pub fn handle_toplevel_event(&self, event: xdg_toplevel::Event) -> bool {
429 match event {
430 xdg_toplevel::Event::Configure {
431 width,
432 height,
433 states,
434 } => {
435 let mut size = if width == 0 || height == 0 {
436 None
437 } else {
438 Some(size(px(width as f32), px(height as f32)))
439 };
440
441 let states = extract_states::<xdg_toplevel::State>(&states);
442
443 let mut tiling = Tiling::default();
444 let mut fullscreen = false;
445 let mut maximized = false;
446
447 for state in states {
448 match state {
449 xdg_toplevel::State::Maximized => {
450 maximized = true;
451 }
452 xdg_toplevel::State::Fullscreen => {
453 fullscreen = true;
454 }
455 xdg_toplevel::State::TiledTop => {
456 tiling.top = true;
457 }
458 xdg_toplevel::State::TiledLeft => {
459 tiling.left = true;
460 }
461 xdg_toplevel::State::TiledRight => {
462 tiling.right = true;
463 }
464 xdg_toplevel::State::TiledBottom => {
465 tiling.bottom = true;
466 }
467 _ => {
468 // noop
469 }
470 }
471 }
472
473 let mut state = self.state.borrow_mut();
474 state.in_progress_configure = Some(InProgressConfigure {
475 size,
476 fullscreen,
477 maximized,
478 tiling,
479 });
480
481 false
482 }
483 xdg_toplevel::Event::Close => {
484 let mut cb = self.callbacks.borrow_mut();
485 if let Some(mut should_close) = cb.should_close.take() {
486 let result = (should_close)();
487 cb.should_close = Some(should_close);
488 if result {
489 drop(cb);
490 self.close();
491 }
492 result
493 } else {
494 true
495 }
496 }
497 xdg_toplevel::Event::WmCapabilities { capabilities } => {
498 let mut window_controls = WindowControls::default();
499
500 let states = extract_states::<xdg_toplevel::WmCapabilities>(&capabilities);
501
502 for state in states {
503 match state {
504 xdg_toplevel::WmCapabilities::Maximize => {
505 window_controls.maximize = true;
506 }
507 xdg_toplevel::WmCapabilities::Minimize => {
508 window_controls.minimize = true;
509 }
510 xdg_toplevel::WmCapabilities::Fullscreen => {
511 window_controls.fullscreen = true;
512 }
513 xdg_toplevel::WmCapabilities::WindowMenu => {
514 window_controls.window_menu = true;
515 }
516 _ => {}
517 }
518 }
519
520 let mut state = self.state.borrow_mut();
521 state.in_progress_window_controls = Some(window_controls);
522 false
523 }
524 _ => false,
525 }
526 }
527
528 pub fn handle_surface_event(
529 &self,
530 event: wl_surface::Event,
531 outputs: HashMap<ObjectId, Output>,
532 ) {
533 let mut state = self.state.borrow_mut();
534
535 match event {
536 wl_surface::Event::Enter { output } => {
537 let id = output.id();
538
539 let Some(output) = outputs.get(&id) else {
540 return;
541 };
542
543 state.outputs.insert(id, output.clone());
544
545 let scale = primary_output_scale(&mut state);
546
547 // We use `PreferredBufferScale` instead to set the scale if it's available
548 if state.surface.version() < wl_surface::EVT_PREFERRED_BUFFER_SCALE_SINCE {
549 state.surface.set_buffer_scale(scale);
550 drop(state);
551 self.rescale(scale as f32);
552 }
553 }
554 wl_surface::Event::Leave { output } => {
555 state.outputs.remove(&output.id());
556
557 let scale = primary_output_scale(&mut state);
558
559 // We use `PreferredBufferScale` instead to set the scale if it's available
560 if state.surface.version() < wl_surface::EVT_PREFERRED_BUFFER_SCALE_SINCE {
561 state.surface.set_buffer_scale(scale);
562 drop(state);
563 self.rescale(scale as f32);
564 }
565 }
566 wl_surface::Event::PreferredBufferScale { factor } => {
567 // We use `WpFractionalScale` instead to set the scale if it's available
568 if state.globals.fractional_scale_manager.is_none() {
569 state.surface.set_buffer_scale(factor);
570 drop(state);
571 self.rescale(factor as f32);
572 }
573 }
574 _ => {}
575 }
576 }
577
578 pub fn handle_ime(&self, ime: ImeInput) {
579 let mut state = self.state.borrow_mut();
580 if let Some(mut input_handler) = state.input_handler.take() {
581 drop(state);
582 match ime {
583 ImeInput::InsertText(text) => {
584 input_handler.replace_text_in_range(None, &text);
585 }
586 ImeInput::SetMarkedText(text) => {
587 input_handler.replace_and_mark_text_in_range(None, &text, None);
588 }
589 ImeInput::UnmarkText => {
590 input_handler.unmark_text();
591 }
592 ImeInput::DeleteText => {
593 if let Some(marked) = input_handler.marked_text_range() {
594 input_handler.replace_text_in_range(Some(marked), "");
595 }
596 }
597 }
598 self.state.borrow_mut().input_handler = Some(input_handler);
599 }
600 }
601
602 pub fn get_ime_area(&self) -> Option<Bounds<Pixels>> {
603 let mut state = self.state.borrow_mut();
604 let mut bounds: Option<Bounds<Pixels>> = None;
605 if let Some(mut input_handler) = state.input_handler.take() {
606 drop(state);
607 if let Some(range) = input_handler.selected_text_range() {
608 bounds = input_handler.bounds_for_range(range);
609 }
610 self.state.borrow_mut().input_handler = Some(input_handler);
611 }
612 bounds
613 }
614
615 pub fn set_size_and_scale(&self, size: Option<Size<Pixels>>, scale: Option<f32>) {
616 let (size, scale) = {
617 let mut state = self.state.borrow_mut();
618 if size.map_or(true, |size| size == state.bounds.size)
619 && scale.map_or(true, |scale| scale == state.scale)
620 {
621 return;
622 }
623 if let Some(size) = size {
624 state.bounds.size = size;
625 }
626 if let Some(scale) = scale {
627 state.scale = scale;
628 }
629 let device_bounds = state.bounds.to_device_pixels(state.scale);
630 state.renderer.update_drawable_size(device_bounds.size);
631 (state.bounds.size, state.scale)
632 };
633
634 if let Some(ref mut fun) = self.callbacks.borrow_mut().resize {
635 fun(size, scale);
636 }
637
638 {
639 let state = self.state.borrow();
640 if let Some(viewport) = &state.viewport {
641 viewport.set_destination(size.width.0 as i32, size.height.0 as i32);
642 }
643 }
644 }
645
646 pub fn resize(&self, size: Size<Pixels>) {
647 self.set_size_and_scale(Some(size), None);
648 }
649
650 pub fn rescale(&self, scale: f32) {
651 self.set_size_and_scale(None, Some(scale));
652 }
653
654 pub fn close(&self) {
655 let mut callbacks = self.callbacks.borrow_mut();
656 if let Some(fun) = callbacks.close.take() {
657 fun()
658 }
659 }
660
661 pub fn handle_input(&self, input: PlatformInput) {
662 if let Some(ref mut fun) = self.callbacks.borrow_mut().input {
663 if !fun(input.clone()).propagate {
664 return;
665 }
666 }
667 if let PlatformInput::KeyDown(event) = input {
668 if let Some(ime_key) = &event.keystroke.ime_key {
669 let mut state = self.state.borrow_mut();
670 if let Some(mut input_handler) = state.input_handler.take() {
671 drop(state);
672 input_handler.replace_text_in_range(None, ime_key);
673 self.state.borrow_mut().input_handler = Some(input_handler);
674 }
675 }
676 }
677 }
678
679 pub fn set_focused(&self, focus: bool) {
680 self.state.borrow_mut().active = focus;
681 if let Some(ref mut fun) = self.callbacks.borrow_mut().active_status_change {
682 fun(focus);
683 }
684 }
685
686 pub fn set_appearance(&mut self, appearance: WindowAppearance) {
687 self.state.borrow_mut().appearance = appearance;
688
689 let mut callbacks = self.callbacks.borrow_mut();
690 if let Some(ref mut fun) = callbacks.appearance_changed {
691 (fun)()
692 }
693 }
694}
695
696fn extract_states<'a, S: TryFrom<u32> + 'a>(states: &'a [u8]) -> impl Iterator<Item = S> + 'a
697where
698 <S as TryFrom<u32>>::Error: 'a,
699{
700 states
701 .chunks_exact(4)
702 .flat_map(TryInto::<[u8; 4]>::try_into)
703 .map(u32::from_ne_bytes)
704 .flat_map(S::try_from)
705}
706
707fn primary_output_scale(state: &mut RefMut<WaylandWindowState>) -> i32 {
708 let mut scale = 1;
709 let mut current_output = state.display.take();
710 for (id, output) in state.outputs.iter() {
711 if let Some((_, output_data)) = ¤t_output {
712 if output.scale > output_data.scale {
713 current_output = Some((id.clone(), output.clone()));
714 }
715 } else {
716 current_output = Some((id.clone(), output.clone()));
717 }
718 scale = scale.max(output.scale);
719 }
720 state.display = current_output;
721 scale
722}
723
724impl rwh::HasWindowHandle for WaylandWindow {
725 fn window_handle(&self) -> Result<rwh::WindowHandle<'_>, rwh::HandleError> {
726 unimplemented!()
727 }
728}
729impl rwh::HasDisplayHandle for WaylandWindow {
730 fn display_handle(&self) -> Result<rwh::DisplayHandle<'_>, rwh::HandleError> {
731 unimplemented!()
732 }
733}
734
735impl PlatformWindow for WaylandWindow {
736 fn bounds(&self) -> Bounds<Pixels> {
737 self.borrow().bounds
738 }
739
740 fn is_maximized(&self) -> bool {
741 self.borrow().maximized
742 }
743
744 fn window_bounds(&self) -> WindowBounds {
745 let state = self.borrow();
746 if state.fullscreen {
747 WindowBounds::Fullscreen(state.window_bounds)
748 } else if state.maximized {
749 WindowBounds::Maximized(state.window_bounds)
750 } else {
751 drop(state);
752 WindowBounds::Windowed(self.bounds())
753 }
754 }
755
756 fn content_size(&self) -> Size<Pixels> {
757 self.borrow().bounds.size
758 }
759
760 fn scale_factor(&self) -> f32 {
761 self.borrow().scale
762 }
763
764 fn appearance(&self) -> WindowAppearance {
765 self.borrow().appearance
766 }
767
768 fn display(&self) -> Option<Rc<dyn PlatformDisplay>> {
769 let state = self.borrow();
770 state.display.as_ref().map(|(id, display)| {
771 Rc::new(WaylandDisplay {
772 id: id.clone(),
773 name: display.name.clone(),
774 bounds: display.bounds.to_pixels(state.scale),
775 }) as Rc<dyn PlatformDisplay>
776 })
777 }
778
779 fn mouse_position(&self) -> Point<Pixels> {
780 self.borrow()
781 .client
782 .get_client()
783 .borrow()
784 .mouse_location
785 .unwrap_or_default()
786 }
787
788 fn modifiers(&self) -> Modifiers {
789 self.borrow().client.get_client().borrow().modifiers
790 }
791
792 fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {
793 self.borrow_mut().input_handler = Some(input_handler);
794 }
795
796 fn take_input_handler(&mut self) -> Option<PlatformInputHandler> {
797 self.borrow_mut().input_handler.take()
798 }
799
800 fn prompt(
801 &self,
802 _level: PromptLevel,
803 _msg: &str,
804 _detail: Option<&str>,
805 _answers: &[&str],
806 ) -> Option<Receiver<usize>> {
807 None
808 }
809
810 fn activate(&self) {
811 log::info!("Wayland does not support this API");
812 }
813
814 fn is_active(&self) -> bool {
815 self.borrow().active
816 }
817
818 fn set_title(&mut self, title: &str) {
819 self.borrow().toplevel.set_title(title.to_string());
820 }
821
822 fn set_app_id(&mut self, app_id: &str) {
823 self.borrow().toplevel.set_app_id(app_id.to_owned());
824 }
825
826 fn set_background_appearance(&self, background_appearance: WindowBackgroundAppearance) {
827 let mut state = self.borrow_mut();
828 state.background_appearance = background_appearance;
829 update_window(state);
830 }
831
832 fn minimize(&self) {
833 self.borrow().toplevel.set_minimized();
834 }
835
836 fn zoom(&self) {
837 let state = self.borrow();
838 if !state.maximized {
839 state.toplevel.set_maximized();
840 } else {
841 state.toplevel.unset_maximized();
842 }
843 }
844
845 fn toggle_fullscreen(&self) {
846 let mut state = self.borrow_mut();
847 if !state.fullscreen {
848 state.toplevel.set_fullscreen(None);
849 } else {
850 state.toplevel.unset_fullscreen();
851 }
852 }
853
854 fn is_fullscreen(&self) -> bool {
855 self.borrow().fullscreen
856 }
857
858 fn on_request_frame(&self, callback: Box<dyn FnMut()>) {
859 self.0.callbacks.borrow_mut().request_frame = Some(callback);
860 }
861
862 fn on_input(&self, callback: Box<dyn FnMut(PlatformInput) -> crate::DispatchEventResult>) {
863 self.0.callbacks.borrow_mut().input = Some(callback);
864 }
865
866 fn on_active_status_change(&self, callback: Box<dyn FnMut(bool)>) {
867 self.0.callbacks.borrow_mut().active_status_change = Some(callback);
868 }
869
870 fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>) {
871 self.0.callbacks.borrow_mut().resize = Some(callback);
872 }
873
874 fn on_moved(&self, callback: Box<dyn FnMut()>) {
875 self.0.callbacks.borrow_mut().moved = Some(callback);
876 }
877
878 fn on_should_close(&self, callback: Box<dyn FnMut() -> bool>) {
879 self.0.callbacks.borrow_mut().should_close = Some(callback);
880 }
881
882 fn on_close(&self, callback: Box<dyn FnOnce()>) {
883 self.0.callbacks.borrow_mut().close = Some(callback);
884 }
885
886 fn on_appearance_changed(&self, callback: Box<dyn FnMut()>) {
887 self.0.callbacks.borrow_mut().appearance_changed = Some(callback);
888 }
889
890 fn draw(&self, scene: &Scene) {
891 let mut state = self.borrow_mut();
892 state.renderer.draw(scene);
893 }
894
895 fn completed_frame(&self) {
896 let mut state = self.borrow_mut();
897 if let Some(area) = state.requested_inset {
898 state.inset = Some(area);
899 }
900
901 let window_geometry = inset_by_tiling(
902 state.bounds.map_origin(|_| px(0.0)),
903 state.inset.unwrap_or(px(0.0)),
904 state.tiling,
905 )
906 .map(|v| v.0 as i32)
907 .map_size(|v| if v <= 0 { 1 } else { v });
908
909 state.xdg_surface.set_window_geometry(
910 window_geometry.origin.x,
911 window_geometry.origin.y,
912 window_geometry.size.width,
913 window_geometry.size.height,
914 );
915
916 state.surface.commit();
917 }
918
919 fn sprite_atlas(&self) -> Arc<dyn PlatformAtlas> {
920 let state = self.borrow();
921 state.renderer.sprite_atlas().clone()
922 }
923
924 fn show_window_menu(&self, position: Point<Pixels>) {
925 let state = self.borrow();
926 let serial = state.client.get_serial(SerialKind::MousePress);
927 state.toplevel.show_window_menu(
928 &state.globals.seat,
929 serial,
930 position.x.0 as i32,
931 position.y.0 as i32,
932 );
933 }
934
935 fn start_window_move(&self) {
936 let state = self.borrow();
937 let serial = state.client.get_serial(SerialKind::MousePress);
938 state.toplevel._move(&state.globals.seat, serial);
939 }
940
941 fn start_window_resize(&self, edge: crate::ResizeEdge) {
942 let state = self.borrow();
943 state.toplevel.resize(
944 &state.globals.seat,
945 state.client.get_serial(SerialKind::MousePress),
946 edge.to_xdg(),
947 )
948 }
949
950 fn window_decorations(&self) -> Decorations {
951 let state = self.borrow();
952 match state.decorations {
953 WindowDecorations::Server => Decorations::Server,
954 WindowDecorations::Client => Decorations::Client {
955 tiling: state.tiling,
956 },
957 }
958 }
959
960 fn request_decorations(&self, decorations: WindowDecorations) {
961 let mut state = self.borrow_mut();
962 state.decorations = decorations;
963 if let Some(decoration) = state.decoration.as_ref() {
964 decoration.set_mode(decorations.to_xdg());
965 update_window(state);
966 }
967 }
968
969 fn window_controls(&self) -> WindowControls {
970 self.borrow().window_controls
971 }
972
973 fn set_client_inset(&self, inset: Pixels) {
974 let mut state = self.borrow_mut();
975 if Some(inset) != state.inset {
976 state.requested_inset = Some(inset);
977 update_window(state);
978 }
979 }
980}
981
982fn update_window(mut state: RefMut<WaylandWindowState>) {
983 let opaque = !state.is_transparent();
984
985 state.renderer.update_transparency(!opaque);
986 let mut opaque_area = state.window_bounds.map(|v| v.0 as i32);
987 if let Some(inset) = state.inset {
988 opaque_area.inset(inset.0 as i32);
989 }
990
991 let region = state
992 .globals
993 .compositor
994 .create_region(&state.globals.qh, ());
995 region.add(
996 opaque_area.origin.x,
997 opaque_area.origin.y,
998 opaque_area.size.width,
999 opaque_area.size.height,
1000 );
1001
1002 // Note that rounded corners make this rectangle API hard to work with.
1003 // As this is common when using CSD, let's just disable this API.
1004 if state.background_appearance == WindowBackgroundAppearance::Opaque
1005 && state.decorations == WindowDecorations::Server
1006 {
1007 // Promise the compositor that this region of the window surface
1008 // contains no transparent pixels. This allows the compositor to
1009 // do skip whatever is behind the surface for better performance.
1010 state.surface.set_opaque_region(Some(®ion));
1011 } else {
1012 state.surface.set_opaque_region(None);
1013 }
1014
1015 if let Some(ref blur_manager) = state.globals.blur_manager {
1016 if state.background_appearance == WindowBackgroundAppearance::Blurred {
1017 if state.blur.is_none() {
1018 let blur = blur_manager.create(&state.surface, &state.globals.qh, ());
1019 blur.set_region(Some(®ion));
1020 state.blur = Some(blur);
1021 }
1022 state.blur.as_ref().unwrap().commit();
1023 } else {
1024 // It probably doesn't hurt to clear the blur for opaque windows
1025 blur_manager.unset(&state.surface);
1026 if let Some(b) = state.blur.take() {
1027 b.release()
1028 }
1029 }
1030 }
1031
1032 region.destroy();
1033}
1034
1035impl WindowDecorations {
1036 fn to_xdg(&self) -> zxdg_toplevel_decoration_v1::Mode {
1037 match self {
1038 WindowDecorations::Client => zxdg_toplevel_decoration_v1::Mode::ClientSide,
1039 WindowDecorations::Server => zxdg_toplevel_decoration_v1::Mode::ServerSide,
1040 }
1041 }
1042}
1043
1044impl ResizeEdge {
1045 fn to_xdg(&self) -> xdg_toplevel::ResizeEdge {
1046 match self {
1047 ResizeEdge::Top => xdg_toplevel::ResizeEdge::Top,
1048 ResizeEdge::TopRight => xdg_toplevel::ResizeEdge::TopRight,
1049 ResizeEdge::Right => xdg_toplevel::ResizeEdge::Right,
1050 ResizeEdge::BottomRight => xdg_toplevel::ResizeEdge::BottomRight,
1051 ResizeEdge::Bottom => xdg_toplevel::ResizeEdge::Bottom,
1052 ResizeEdge::BottomLeft => xdg_toplevel::ResizeEdge::BottomLeft,
1053 ResizeEdge::Left => xdg_toplevel::ResizeEdge::Left,
1054 ResizeEdge::TopLeft => xdg_toplevel::ResizeEdge::TopLeft,
1055 }
1056 }
1057}
1058
1059/// The configuration event is in terms of the window geometry, which we are constantly
1060/// updating to account for the client decorations. But that's not the area we want to render
1061/// to, due to our intrusize CSD. So, here we calculate the 'actual' size, by adding back in the insets
1062fn compute_outer_size(
1063 inset: Option<Pixels>,
1064 new_size: Option<Size<Pixels>>,
1065 tiling: Tiling,
1066) -> Option<Size<Pixels>> {
1067 let Some(inset) = inset else { return new_size };
1068
1069 new_size.map(|mut new_size| {
1070 if !tiling.top {
1071 new_size.height += inset;
1072 }
1073 if !tiling.bottom {
1074 new_size.height += inset;
1075 }
1076 if !tiling.left {
1077 new_size.width += inset;
1078 }
1079 if !tiling.right {
1080 new_size.width += inset;
1081 }
1082
1083 new_size
1084 })
1085}
1086
1087fn inset_by_tiling(mut bounds: Bounds<Pixels>, inset: Pixels, tiling: Tiling) -> Bounds<Pixels> {
1088 if !tiling.top {
1089 bounds.origin.y += inset;
1090 bounds.size.height -= inset;
1091 }
1092 if !tiling.bottom {
1093 bounds.size.height -= inset;
1094 }
1095 if !tiling.left {
1096 bounds.origin.x += inset;
1097 bounds.size.width -= inset;
1098 }
1099 if !tiling.right {
1100 bounds.size.width -= inset;
1101 }
1102
1103 bounds
1104}