leyoda/cosmic-comp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into weblate-pop-os-cosmic-comp

Browse source
This commit is contained in:
Victoria Brekenfeld 2026-07-13 17:19:34 +02:00 • committed by GitHub
commit 80a440fcb0
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
62 changed files with 5391 additions and 2852 deletions
Download patch file Download diff file Expand all files Collapse all files

757
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

9
Cargo.toml
View file

@ -4,7 +4,7 @@ edition = "2024"
license = "GPL-3.0-only"
name = "cosmic-comp"
version = "1.0.0"
rust-version = "1.90"
rust-version = "1.93"
[workspace]
members = ["cosmic-comp-config"]
@ -28,7 +28,7 @@ cosmic-settings-config = { git = "https://github.com/pop-os/cosmic-settings-daem
cosmic-settings-daemon-config = { git = "https://github.com/pop-os/cosmic-settings-daemon", features = [
"greeter",
] }
cosmic-text = { git = "https://github.com/pop-os/cosmic-text.git", features = [
cosmic-text = { version = "0.19", features = [
"shape-run-cache",
] }
libdisplay-info = "0.3.0"
@ -40,6 +40,7 @@ i18n-embed = { version = "0.16", features = [
] }
i18n-embed-fl = "0.10"
iced_tiny_skia = { git = "https://github.com/pop-os/libcosmic" }
iced_graphics = { git = "https://github.com/pop-os/libcosmic/", features = ["geometry"] }
indexmap = "2.13"
keyframe = "1.1.1"
libcosmic = { git = "https://github.com/pop-os/libcosmic", default-features = false }
@ -83,6 +84,7 @@ logind-zbus = { version = "5.3.2", optional = true }
futures-executor = { version = "0.3.32" }
futures-util = "0.3.32"
cgmath = "0.18.0"
smallvec = "1.15.2"
[dependencies.id_tree]
branch = "feature/copy_clone"
@ -140,7 +142,6 @@ lto = "fat"
[patch."https://github.com/pop-os/cosmic-protocols"]
cosmic-protocols = { git = "https://github.com/pop-os//cosmic-protocols", branch = "main" }
cosmic-client-toolkit = { git = "https://github.com/pop-os//cosmic-protocols", branch = "main" }
[patch.crates-io]
smithay = { git = "https://github.com/smithay/smithay.git", rev = "85f83ab" }
smithay = { git = "https://github.com/smithay/smithay.git", rev = "efeb597" }

24
examples/customized-window-decorations.rs
View file

@ -23,7 +23,7 @@ struct Circle {
color: Color,
}
impl<Message, Theme, Renderer: cosmic::iced_renderer::geometry::Renderer>
impl<Message, Theme, Renderer: iced_graphics::geometry::Renderer>
canvas::Program<Message, Theme, Renderer> for Circle
{
type State = ();
@ -50,17 +50,17 @@ impl<Internal, Message: std::clone::Clone + 'static, Lower: Decorations<Internal
{
fn view(&self, window: &Internal) -> cosmic::Element<'_, Message> {
let orig = self.lower.view(window);
widget::row()
.push(
widget::column()
.push(canvas(Circle {
radius: (self.height as f32 / 2.) * 0.8,
color: Color::from_rgba(1.0, 0.0, 0.0, 1.0),
}))
.width(self.height as f32),
)
.push(orig)
.into()
widget::row([
widget::column([canvas(Circle {
radius: (self.height as f32 / 2.) * 0.8,
color: Color::from_rgba(1.0, 0.0, 0.0, 1.0),
})
.into()])
.width(self.height as f32)
.into(),
orig,
])
.into()
}
}

2
rust-toolchain.toml
View file

@ -1,3 +1,3 @@
[toolchain]
channel = "1.90"
channel = "1.93"
components = [ "rust-src" ]

7
src/backend/kms/device.rs
View file

@ -96,7 +96,6 @@ pub struct Device {
pub inner: InnerDevice,
pub drm: GbmDrmOutputManager,
supports_atomic: bool,
pub texture_formats: FormatSet,
event_token: Option<RegistrationToken>,
pub socket: Option<Socket>,
@ -711,7 +710,6 @@ impl Device {
let (drm, notifier) = DrmDevice::new(fd.clone(), false)
.with_context(|| format!("Failed to initialize drm device for: {}", path.display()))?;
let dev_node = DrmNode::from_dev_id(dev)?;
let supports_atomic = drm.is_atomic();
let gbm = GbmDevice::new(fd)
.with_context(|| format!("Failed to initialize GBM device for {}", path.display()))?;
@ -831,7 +829,6 @@ impl Device {
active_clients,
},
supports_atomic,
texture_formats,
event_token: Some(token),
socket,
@ -840,8 +837,7 @@ impl Device {
pub fn enumerate_surfaces(&mut self) -> Result<OutputChanges> {
// enumerate our outputs
let config =
drm_helpers::display_configuration(self.drm.device_mut(), self.supports_atomic)?;
let config = drm_helpers::display_configuration(self.drm.device_mut())?;
let surfaces = self
.inner
@ -947,6 +943,7 @@ impl LockedDevice<'_> {
output,
CursorMode::All,
None,
None,
)
.with_context(|| "Failed to render outputs")?,
None => Vec::new(),

97
src/backend/kms/drm_helpers.rs
View file

@ -3,6 +3,7 @@
use anyhow::{Context, Result, anyhow};
use libdisplay_info::{edid::DisplayDescriptorTag, info::Info};
use smithay::{
backend::drm::DrmDevice,
reexports::drm::control::{
AtomicCommitFlags, Device as ControlDevice, Mode, ModeFlags, PlaneType, ResourceHandle,
atomic::AtomicModeReq,
@ -16,8 +17,7 @@ use smithay::{
use std::{collections::HashMap, ops::Range};
pub fn display_configuration(
device: &mut impl ControlDevice,
supports_atomic: bool,
device: &mut DrmDevice,
) -> Result<HashMap<connector::Handle, Option<crtc::Handle>>> {
let res_handles = device.resource_handles()?;
let connectors = res_handles.connectors();
@ -73,28 +73,10 @@ pub fn display_configuration(
}
// And then cleanup
if supports_atomic {
if device.is_atomic() {
let mut req = AtomicModeReq::new();
let plane_handles = device.plane_handles()?;
for conn in connectors
.iter()
.flat_map(|conn| device.get_connector(*conn, false).ok())
.filter(|conn| {
if let Some(enc) = conn.current_encoder()
&& let Ok(enc) = device.get_encoder(enc)
&& let Some(crtc) = enc.crtc()
{
return cleanup.contains(&crtc);
}
false
})
.map(|info| info.handle())
{
let crtc_id = get_prop(device, conn, "CRTC_ID")?;
req.add_property(conn, crtc_id, property::Value::CRTC(None));
}
// We cannot just shortcut and use the legacy api for all cleanups because of this.
// (Technically a device does not need to be atomic for planes to be used, but nobody does this otherwise.)
for plane in plane_handles {
@ -108,7 +90,7 @@ pub fn display_configuration(
_ => false,
},
)?;
if cleanup.contains(&crtc) || !is_primary {
if !is_primary && !cleanup.contains(&crtc) {
let crtc_id = get_prop(device, plane, "CRTC_ID")?;
let fb_id = get_prop(device, plane, "FB_ID")?;
req.add_property(plane, crtc_id, property::Value::CRTC(None));
@ -116,27 +98,76 @@ pub fn display_configuration(
}
}
}
for crtc in cleanup {
let mode_id = get_prop(device, crtc, "MODE_ID")?;
let active = get_prop(device, crtc, "ACTIVE")?;
req.add_property(crtc, active, property::Value::Boolean(false));
req.add_property(crtc, mode_id, property::Value::Unknown(0));
}
device.atomic_commit(AtomicCommitFlags::ALLOW_MODESET, req)?;
} else {
for crtc in res_handles.crtcs() {
#[allow(deprecated)]
let _ = device.set_cursor(*crtc, Option::<&DumbBuffer>::None);
}
for crtc in cleanup {
}
disable_crtcs(device, &cleanup)?;
Ok(map)
}
/// Disables the given CRTCs and detaches their connectors/planes.
pub fn disable_crtcs(device: &mut DrmDevice, crtcs: &[crtc::Handle]) -> Result<()> {
if crtcs.is_empty() {
return Ok(());
}
let res_handles = device.resource_handles()?;
if device.is_atomic() {
let mut req = AtomicModeReq::new();
for conn in res_handles
.connectors()
.iter()
.flat_map(|conn| device.get_connector(*conn, false).ok())
.filter(|conn| {
if let Some(enc) = conn.current_encoder()
&& let Ok(enc) = device.get_encoder(enc)
&& let Some(crtc) = enc.crtc()
{
return crtcs.contains(&crtc);
}
false
})
.map(|info| info.handle())
{
let crtc_id = get_prop(device, conn, "CRTC_ID")?;
req.add_property(conn, crtc_id, property::Value::CRTC(None));
}
for plane in device.plane_handles()? {
let info = device.get_plane(plane)?;
if let Some(crtc) = info.crtc()
&& crtcs.contains(&crtc)
{
let crtc_id = get_prop(device, plane, "CRTC_ID")?;
let fb_id = get_prop(device, plane, "FB_ID")?;
req.add_property(plane, crtc_id, property::Value::CRTC(None));
req.add_property(plane, fb_id, property::Value::Framebuffer(None));
}
}
for crtc in crtcs {
let mode_id = get_prop(device, *crtc, "MODE_ID")?;
let active = get_prop(device, *crtc, "ACTIVE")?;
req.add_property(*crtc, active, property::Value::Boolean(false));
req.add_property(*crtc, mode_id, property::Value::Unknown(0));
}
device.atomic_commit(AtomicCommitFlags::ALLOW_MODESET, req)?;
} else {
for crtc in crtcs {
// null commit (necessary to trigger removal on the kernel side with the legacy api.)
let _ = device.set_crtc(crtc, None, (0, 0), &[], None);
let _ = device.set_crtc(*crtc, None, (0, 0), &[], None);
}
}
Ok(map)
Ok(())
}
pub fn interface_name(device: &impl ControlDevice, connector: connector::Handle) -> Result<String> {

25
src/backend/kms/mod.rs
View file

@ -852,11 +852,23 @@ impl KmsGuard<'_> {
// first drop old surfaces
if !test_only {
for output in outputs.iter().filter(|o| !o.is_enabled()) {
device
.inner
.surfaces
.retain(|_, surface| surface.output != *output);
let mut disabled_crtcs = Vec::new();
device.inner.surfaces.retain(|crtc, surface| {
if outputs
.iter()
.any(|o| !o.is_enabled() && surface.output == *o)
{
disabled_crtcs.push(*crtc);
false
} else {
true
}
});
if let Err(err) =
drm_helpers::disable_crtcs(device.drm.device_mut(), &disabled_crtcs)
{
warn!("Failed to disable crtcs for disabled outputs: {err}");
}
}
@ -966,6 +978,7 @@ impl KmsGuard<'_> {
output,
CursorMode::All,
None,
None,
)
.with_context(|| "Failed to render outputs")?;
@ -1076,6 +1089,7 @@ impl KmsGuard<'_> {
output,
CursorMode::All,
None,
None,
)
.with_context(|| "Failed to render outputs")?;
@ -1120,6 +1134,7 @@ impl KmsGuard<'_> {
output,
CursorMode::All,
None,
None,
)
.with_context(|| "Failed to render outputs")?;

72
src/backend/kms/render/gles.rs
View file

@ -1,21 +1,29 @@
// SPDX-License-Identifier: GPL-3.0-only
use smithay::backend::{
SwapBuffersError,
allocator::{
Allocator,
dmabuf::{AnyError, Dmabuf, DmabufAllocator},
gbm::GbmAllocator,
},
drm::{CreateDrmNodeError, DrmNode},
renderer::{
RendererSuper,
gles::{GlesError, GlesRenderer},
glow::GlowRenderer,
multigpu::{ApiDevice, Error as MultiError, GraphicsApi},
use clap_lex::OsStrExt;
use rustix::path::Arg;
use smithay::{
backend::{
SwapBuffersError,
allocator::{
Allocator,
dmabuf::{AnyError, Dmabuf, DmabufAllocator},
gbm::GbmAllocator,
},
drm::{CreateDrmNodeError, DrmNode},
renderer::{
gles::{GlesError, GlesRenderer, ffi},
glow::GlowRenderer,
multigpu::{ApiDevice, GraphicsApi},
},
},
reexports::drm::control::Device,
};
use std::{
borrow::{Borrow, BorrowMut},
cell::Cell,
ffi::{CStr, c_char},
};
use std::{borrow::Borrow, cell::Cell};
use std::{
collections::HashMap,
fmt,
@ -23,8 +31,6 @@ use std::{
sync::atomic::{AtomicBool, Ordering},
};
use crate::backend::render::element::FromGlesError;
/// Errors raised by the [`GbmGlesBackend`]
#[derive(Debug, thiserror::Error)]
pub enum Error {
@ -98,7 +104,7 @@ impl<A: AsFd + Clone + Send + 'static> GbmGlowBackend<A> {
}
}
impl<A: AsFd + Clone + 'static> GraphicsApi for GbmGlowBackend<A> {
impl<A: AsFd + Device + Clone + 'static> GraphicsApi for GbmGlowBackend<A> {
type Device = GbmGlowDevice;
type Error = Error;
@ -123,11 +129,29 @@ impl<A: AsFd + Clone + 'static> GraphicsApi for GbmGlowBackend<A> {
.any(|renderer| renderer.node.dev_id() == node.dev_id())
})
.flat_map(|(node, (allocator, renderer))| {
let renderer = renderer.replace(None)?;
let mut renderer = renderer.replace(None)?;
let is_intel = allocator
.as_ref()
.get_driver()
.is_ok_and(|drv| drv.name().contains("i915"));
let intel_export_quirk = is_intel
&& BorrowMut::<GlesRenderer>::borrow_mut(&mut renderer)
.with_context(|gl| unsafe {
CStr::from_ptr(gl.GetString(ffi::RENDERER) as *const c_char)
})
.is_ok_and(|name| {
name.as_str().is_ok_and(|name| {
name.contains("TGL")
|| name.contains("MTL")
|| name.contains("ARL")
|| name.contains("LNL")
})
});
Some(GbmGlowDevice {
node: *node,
renderer,
intel_export_quirk,
allocator: Box::new(DmabufAllocator(allocator.clone())),
})
})
@ -150,6 +174,7 @@ impl<A: AsFd + Clone + 'static> GraphicsApi for GbmGlowBackend<A> {
pub struct GbmGlowDevice {
node: DrmNode,
renderer: GlowRenderer,
intel_export_quirk: bool,
allocator: Box<dyn Allocator<Buffer = Dmabuf, Error = AnyError>>,
}
@ -180,15 +205,8 @@ impl ApiDevice for GbmGlowDevice {
fn can_do_cross_device_imports(&self) -> bool {
!Borrow::<GlesRenderer>::borrow(&self.renderer).is_software()
}
}
impl<T: GraphicsApi, A: AsFd + Clone + 'static> FromGlesError for MultiError<GbmGlowBackend<A>, T>
where
T::Error: 'static,
<<T::Device as ApiDevice>::Renderer as RendererSuper>::Error: 'static,
{
#[inline]
fn from_gles_error(err: GlesError) -> MultiError<GbmGlowBackend<A>, T> {
MultiError::Render(err)
fn should_do_cross_device_exports(&self) -> bool {
!self.intel_export_quirk
}
}

1
src/backend/kms/surface/mod.rs
View file

@ -1068,6 +1068,7 @@ impl SurfaceThreadState {
None,
#[cfg(feature = "debug")]
Some((&self.egui, &self.timings)),
Some(self.target_node),
)
.map_err(|err| {
anyhow::format_err!("Failed to accumulate elements for rendering: {:?}", err)

130
src/backend/render/cursor.rs
View file

@ -1,6 +1,13 @@
// SPDX-License-Identifier: GPL-3.0-only
use crate::{utils::prelude::*, wayland::handlers::compositor::FRAME_TIME_FILTER};
use crate::{
backend::render::{
element::AsGlowRenderer,
wayland::{SurfaceRenderElement, push_render_elements_from_surface_tree},
},
utils::prelude::*,
wayland::handlers::compositor::FRAME_TIME_FILTER,
};
use smithay::{
backend::{
allocator::Fourcc,
@ -9,10 +16,10 @@ use smithay::{
element::{
Kind,
memory::{MemoryRenderBuffer, MemoryRenderBufferRenderElement},
surface::{WaylandSurfaceRenderElement, render_elements_from_surface_tree},
},
},
},
desktop::utils::bbox_from_surface_tree,
input::{
Seat,
pointer::{CursorIcon, CursorImageAttributes, CursorImageStatus},
@ -114,24 +121,63 @@ enum Error {
NoDefaultCursor,
#[error("Error opening xcursor file: {0}")]
File(#[from] std::io::Error),
#[error("Failed to parse XCursor file")]
Parse,
}
fn cursor_aliases(name: &str) -> &[&str] {
match name {
"default" => &["default", "left_ptr", "arrow"],
"pointer" => &["pointer", "hand2", "hand"],
"text" => &["text", "xterm"],
"wait" => &["wait", "watch"],
"progress" => &["progress", "left_ptr_watch"],
"ew-resize" => &["ew-resize", "h_double_arrow", "sb_h_double_arrow"],
"ns-resize" => &["ns-resize", "v_double_arrow", "sb_v_double_arrow"],
"nw-resize" => &["nw-resize", "top_left_corner"],
"ne-resize" => &["ne-resize", "top_right_corner"],
"sw-resize" => &["sw-resize", "bottom_left_corner"],
"se-resize" => &["se-resize", "bottom_right_corner"],
"w-resize" => &["w-resize", "left_side"],
"e-resize" => &["e-resize", "right_side"],
"n-resize" => &["n-resize", "top_side"],
"s-resize" => &["s-resize", "bottom_side"],
"move" => &["move", "fleur"],
"not-allowed" => &["not-allowed", "crossed_circle"],
"crosshair" => &["crosshair", "cross"],
"help" => &["help", "question_arrow", "left_ptr_help"],
_ => &[],
}
}
fn load_icon(theme: &CursorTheme, shape: CursorIcon) -> Result<Vec<Image>, Error> {
let icon_path = theme
.load_icon(&shape.to_string())
.ok_or(Error::NoDefaultCursor)?;
let mut cursor_file = std::fs::File::open(&icon_path)?;
let mut cursor_data = Vec::new();
cursor_file.read_to_end(&mut cursor_data)?;
parse_xcursor(&cursor_data).ok_or(Error::Parse)
let shape_name = shape.to_string();
for name in cursor_aliases(&shape_name)
.iter()
.copied()
.chain(std::iter::once(shape_name.as_str()))
{
if let Some(icon_path) = theme.load_icon(name) {
let mut cursor_file = std::fs::File::open(&icon_path)?;
let mut cursor_data = Vec::new();
cursor_file.read_to_end(&mut cursor_data)?;
if let Some(images) = parse_xcursor(&cursor_data) {
return Ok(images);
}
}
}
Err(Error::NoDefaultCursor)
}
render_elements! {
pub CursorRenderElement<R> where R: ImportAll + ImportMem;
pub CursorRenderElement<R> where R: ImportAll + ImportMem + AsGlowRenderer, R::TextureId: Send;
Static=MemoryRenderBufferRenderElement<R>,
Surface=WaylandSurfaceRenderElement<R>,
Surface=SurfaceRenderElement<R>,
}
pub fn draw_surface_cursor<R>(
@ -139,9 +185,10 @@ pub fn draw_surface_cursor<R>(
surface: &wl_surface::WlSurface,
location: Point<f64, Logical>,
scale: impl Into<Scale<f64>>,
) -> Vec<(CursorRenderElement<R>, Point<i32, Physical>)>
where
R: Renderer + ImportAll,
blur_strength: usize,
push: &mut dyn FnMut(CursorRenderElement<R>, Point<i32, Physical>),
) where
R: Renderer + ImportAll + AsGlowRenderer,
R::TextureId: Clone + 'static,
{
let scale = scale.into();
@ -156,17 +203,21 @@ where
.to_physical_precise_round(scale)
});
render_elements_from_surface_tree(
push_render_elements_from_surface_tree(
renderer,
surface,
location.to_physical(scale).to_i32_round(),
bbox_from_surface_tree(surface, location.to_i32_round()).to_f64(),
scale,
1.0,
false,
[0; 4],
None,
blur_strength,
Kind::Cursor,
)
.into_iter()
.map(|elem| (elem, h))
.collect()
&mut |elem| push(elem.into(), h),
None,
);
}
#[profiling::function]
@ -175,9 +226,10 @@ pub fn draw_dnd_icon<R>(
surface: &wl_surface::WlSurface,
location: Point<f64, Logical>,
scale: impl Into<Scale<f64>>,
) -> Vec<WaylandSurfaceRenderElement<R>>
where
R: Renderer + ImportAll,
blur_strength: usize,
push: &mut dyn FnMut(SurfaceRenderElement<R>),
) where
R: Renderer + ImportAll + AsGlowRenderer,
R::TextureId: Clone + 'static,
{
if get_role(surface) != Some("dnd_icon") {
@ -187,14 +239,21 @@ where
);
}
let scale = scale.into();
render_elements_from_surface_tree(
push_render_elements_from_surface_tree(
renderer,
surface,
location.to_physical(scale).to_i32_round(),
bbox_from_surface_tree(surface, location.to_i32_round()).to_f64(),
scale,
1.0,
false,
[0; 4],
None,
blur_strength,
FRAME_TIME_FILTER,
)
push,
None,
);
}
pub type CursorState = Mutex<CursorStateInner>;
@ -277,10 +336,11 @@ pub fn draw_cursor<R>(
scale: Scale<f64>,
buffer_scale: f64,
time: Time<Monotonic>,
blur_strength: usize,
draw_default: bool,
) -> Vec<(CursorRenderElement<R>, Point<i32, Physical>)>
where
R: Renderer + ImportMem + ImportAll,
push: &mut dyn FnMut(CursorRenderElement<R>, Point<i32, Physical>),
) where
R: Renderer + ImportMem + ImportAll + AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
{
// draw the cursor as relevant
@ -291,7 +351,7 @@ where
let state = &mut *state_ref;
if state.hidden {
return Vec::new();
return;
}
let named_cursor = state.current_cursor.or(match cursor_status {
@ -300,7 +360,7 @@ where
});
if let Some(current_cursor) = named_cursor {
if !draw_default && current_cursor == CursorIcon::Default {
return Vec::new();
return;
}
let integer_scale = (scale.x.max(scale.y) * buffer_scale).ceil() as u32;
@ -337,7 +397,7 @@ where
);
state.current_image = Some(frame);
return vec![(
push(
CursorRenderElement::Static(
MemoryRenderBufferRenderElement::from_buffer(
renderer,
@ -351,11 +411,9 @@ where
.expect("Failed to import cursor bitmap"),
),
hotspot.to_physical_precise_round(scale),
)];
);
} else if let CursorImageStatus::Surface(ref wl_surface) = cursor_status {
return draw_surface_cursor(renderer, wl_surface, location, scale);
} else {
Vec::new()
draw_surface_cursor(renderer, wl_surface, location, scale, blur_strength, push);
}
}

114
src/backend/render/element.rs
View file

@ -1,20 +1,27 @@
use crate::shell::{CosmicMappedRenderElement, WorkspaceRenderElement};
use crate::{
backend::{
kms::render::gles::GbmGlowBackend,
render::{GlMultiError, wayland::SurfaceRenderElement},
},
shell::{CosmicMappedRenderElement, WorkspaceRenderElement},
utils::iced::IcedRenderElement,
};
#[cfg(feature = "debug")]
use smithay::backend::renderer::element::texture::TextureRenderElement;
use smithay::{
backend::{
allocator::dmabuf::Dmabuf,
drm::DrmDeviceFd,
renderer::{
Bind, Blit, ExportMem, ImportAll, ImportMem, Offscreen, Renderer,
Bind, Blit, ContextId, ExportMem, ImportAll, ImportMem, Offscreen, Renderer,
element::{
Element, Id, Kind, RenderElement, UnderlyingStorage,
memory::MemoryRenderBufferRenderElement,
surface::WaylandSurfaceRenderElement,
utils::{CropRenderElement, Relocate, RelocateRenderElement, RescaleRenderElement},
},
gles::{GlesError, GlesRenderbuffer, GlesTexture, element::TextureShaderElement},
glow::{GlowFrame, GlowRenderer},
multigpu::MultiTexture,
utils::{CommitCounter, DamageSet, OpaqueRegions},
},
},
@ -28,19 +35,20 @@ use super::{GlMultiRenderer, cursor::CursorRenderElement};
pub enum CosmicElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
Workspace(
RelocateRenderElement<CropRenderElement<RescaleRenderElement<WorkspaceRenderElement<R>>>>,
),
Cursor(RescaleRenderElement<RelocateRenderElement<CursorRenderElement<R>>>),
Dnd(WaylandSurfaceRenderElement<R>),
Dnd(SurfaceRenderElement<R>),
MoveGrab(RescaleRenderElement<CosmicMappedRenderElement<R>>),
Postprocess(
CropRenderElement<RelocateRenderElement<RescaleRenderElement<TextureShaderElement>>>,
),
Zoom(MemoryRenderBufferRenderElement<R>),
Zoom(IcedRenderElement<R>),
Damage(DamageElement),
#[cfg(feature = "debug")]
Egui(TextureRenderElement<GlesTexture>),
}
@ -48,7 +56,7 @@ where
impl<R> Element for CosmicElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn id(&self) -> &Id {
@ -59,6 +67,7 @@ where
CosmicElement::MoveGrab(elem) => elem.id(),
CosmicElement::Postprocess(elem) => elem.id(),
CosmicElement::Zoom(elem) => elem.id(),
CosmicElement::Damage(elem) => elem.id(),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.id(),
}
@ -72,6 +81,7 @@ where
CosmicElement::MoveGrab(elem) => elem.current_commit(),
CosmicElement::Postprocess(elem) => elem.current_commit(),
CosmicElement::Zoom(elem) => elem.current_commit(),
CosmicElement::Damage(elem) => elem.current_commit(),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.current_commit(),
}
@ -85,6 +95,7 @@ where
CosmicElement::MoveGrab(elem) => elem.src(),
CosmicElement::Postprocess(elem) => elem.src(),
CosmicElement::Zoom(elem) => elem.src(),
CosmicElement::Damage(elem) => elem.src(),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.src(),
}
@ -98,6 +109,7 @@ where
CosmicElement::MoveGrab(elem) => elem.geometry(scale),
CosmicElement::Postprocess(elem) => elem.geometry(scale),
CosmicElement::Zoom(elem) => elem.geometry(scale),
CosmicElement::Damage(elem) => elem.geometry(scale),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.geometry(scale),
}
@ -111,6 +123,7 @@ where
CosmicElement::MoveGrab(elem) => elem.location(scale),
CosmicElement::Postprocess(elem) => elem.location(scale),
CosmicElement::Zoom(elem) => elem.location(scale),
CosmicElement::Damage(elem) => elem.location(scale),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.location(scale),
}
@ -124,6 +137,7 @@ where
CosmicElement::MoveGrab(elem) => elem.transform(),
CosmicElement::Postprocess(elem) => elem.transform(),
CosmicElement::Zoom(elem) => elem.transform(),
CosmicElement::Damage(elem) => elem.transform(),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.transform(),
}
@ -141,6 +155,7 @@ where
CosmicElement::MoveGrab(elem) => elem.damage_since(scale, commit),
CosmicElement::Postprocess(elem) => elem.damage_since(scale, commit),
CosmicElement::Zoom(elem) => elem.damage_since(scale, commit),
CosmicElement::Damage(elem) => elem.damage_since(scale, commit),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.damage_since(scale, commit),
}
@ -154,6 +169,7 @@ where
CosmicElement::MoveGrab(elem) => elem.opaque_regions(scale),
CosmicElement::Postprocess(elem) => elem.opaque_regions(scale),
CosmicElement::Zoom(elem) => elem.opaque_regions(scale),
CosmicElement::Damage(elem) => elem.opaque_regions(scale),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.opaque_regions(scale),
}
@ -167,6 +183,7 @@ where
CosmicElement::MoveGrab(elem) => elem.alpha(),
CosmicElement::Postprocess(elem) => elem.alpha(),
CosmicElement::Zoom(elem) => elem.alpha(),
CosmicElement::Damage(elem) => elem.alpha(),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.alpha(),
}
@ -180,6 +197,7 @@ where
CosmicElement::MoveGrab(elem) => elem.kind(),
CosmicElement::Postprocess(elem) => elem.kind(),
CosmicElement::Zoom(elem) => elem.kind(),
CosmicElement::Damage(elem) => elem.kind(),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.kind(),
}
@ -193,6 +211,7 @@ where
CosmicElement::MoveGrab(elem) => elem.is_framebuffer_effect(),
CosmicElement::Postprocess(elem) => elem.is_framebuffer_effect(),
CosmicElement::Zoom(elem) => elem.is_framebuffer_effect(),
CosmicElement::Damage(elem) => elem.is_framebuffer_effect(),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.is_framebuffer_effect(),
}
@ -202,8 +221,7 @@ where
impl<R> RenderElement<R> for CosmicElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::Error: FromGlesError,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn draw(
@ -237,9 +255,12 @@ where
opaque_regions,
cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
CosmicElement::Zoom(elem) => elem.draw(frame, src, dst, damage, opaque_regions, cache),
CosmicElement::Damage(elem) => {
RenderElement::<R>::draw(elem, frame, src, dst, damage, opaque_regions, cache)
}
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
let glow_frame = R::glow_frame_mut(frame);
@ -252,7 +273,7 @@ where
opaque_regions,
cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
}
}
@ -268,6 +289,7 @@ where
elem.underlying_storage(glow_renderer)
}
CosmicElement::Zoom(elem) => elem.underlying_storage(renderer),
CosmicElement::Damage(elem) => elem.underlying_storage(renderer),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
let glow_renderer = renderer.glow_renderer_mut();
@ -293,16 +315,19 @@ where
RenderElement::<GlowRenderer>::capture_framebuffer(
elem, glow_frame, src, dst, cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
CosmicElement::Zoom(elem) => elem.capture_framebuffer(frame, src, dst, cache),
CosmicElement::Damage(elem) => {
RenderElement::<R>::capture_framebuffer(elem, frame, src, dst, cache)
}
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
let glow_frame = R::glow_frame_mut(frame);
RenderElement::<GlowRenderer>::capture_framebuffer(
elem, glow_frame, src, dst, cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
}
}
@ -312,7 +337,7 @@ impl<R> From<CropRenderElement<RescaleRenderElement<WorkspaceRenderElement<R>>>>
for CosmicElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: CropRenderElement<RescaleRenderElement<WorkspaceRenderElement<R>>>) -> Self {
@ -324,22 +349,33 @@ where
}
}
impl<R> From<MemoryRenderBufferRenderElement<R>> for CosmicElement<R>
impl<R> From<IcedRenderElement<R>> for CosmicElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(value: MemoryRenderBufferRenderElement<R>) -> Self {
fn from(value: IcedRenderElement<R>) -> Self {
Self::Zoom(value)
}
}
impl<R> From<DamageElement> for CosmicElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(value: DamageElement) -> Self {
Self::Damage(value)
}
}
#[cfg(feature = "debug")]
impl<R> From<TextureRenderElement<GlesTexture>> for CosmicElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: TextureRenderElement<GlesTexture>) -> Self {
@ -365,6 +401,12 @@ pub trait AsGlowRenderer:
fn glow_frame_mut<'a, 'frame, 'buffer>(
frame: &'a mut Self::Frame<'frame, 'buffer>,
) -> &'a mut GlowFrame<'frame, 'buffer>;
fn tex_from_gl(context: &ContextId<GlesTexture>, texture: GlesTexture) -> Self::TextureId;
fn tex_to_gl(
context: &ContextId<GlesTexture>,
texture: &Self::TextureId,
) -> Option<GlesTexture>;
fn from_gles_error(err: GlesError) -> Self::Error;
}
impl AsGlowRenderer for GlowRenderer {
@ -384,6 +426,18 @@ impl AsGlowRenderer for GlowRenderer {
) -> &'a mut GlowFrame<'frame, 'buffer> {
frame
}
fn tex_from_gl(_context: &ContextId<GlesTexture>, texture: GlesTexture) -> Self::TextureId {
texture
}
fn tex_to_gl(
_context: &ContextId<GlesTexture>,
texture: &Self::TextureId,
) -> Option<GlesTexture> {
Some(texture.clone())
}
fn from_gles_error(err: GlesError) -> Self::Error {
err
}
}
impl AsGlowRenderer for GlMultiRenderer<'_> {
@ -403,6 +457,18 @@ impl AsGlowRenderer for GlMultiRenderer<'_> {
) -> &'b mut GlowFrame<'frame, 'buffer> {
frame.as_mut()
}
fn tex_from_gl(context: &ContextId<GlesTexture>, texture: GlesTexture) -> Self::TextureId {
MultiTexture::from_native_texture::<GbmGlowBackend<DrmDeviceFd>>(context, texture).unwrap()
}
fn tex_to_gl(
context: &ContextId<GlesTexture>,
texture: &Self::TextureId,
) -> Option<GlesTexture> {
texture.get::<GbmGlowBackend<DrmDeviceFd>>(context)
}
fn from_gles_error(err: GlesError) -> Self::Error {
GlMultiError::Render(err)
}
}
pub struct DamageElement {
@ -458,13 +524,3 @@ impl<R: Renderer> RenderElement<R> for DamageElement {
Ok(())
}
}
pub trait FromGlesError {
fn from_gles_error(err: GlesError) -> Self;
}
impl FromGlesError for GlesError {
fn from_gles_error(err: GlesError) -> Self {
err
}
}

461
src/backend/render/mod.rs
View file

@ -15,14 +15,19 @@ use crate::{
backend::{
kms::render::gles::GbmGlowBackend,
render::{
clipped_surface::{CLIPPING_SHADER, ClippingShader},
element::DamageElement,
shadow::{SHADOW_SHADER, ShadowShader},
wayland::{
SurfaceRenderElement,
blur_effect::BlurShaders,
clipped_surface::{CLIPPING_SHADER, ClippingShader},
push_render_elements_from_surface_tree,
},
},
},
config::ScreenFilter,
shell::{
CosmicMappedRenderElement, OverviewMode, SeatExt, Trigger, WorkspaceDelta,
CosmicMappedRenderElement, OutputId, OverviewMode, SeatExt, Trigger, WorkspaceDelta,
WorkspaceRenderElement,
element::CosmicMappedKey,
focus::{FocusTarget, Stage, render_input_order, target::WindowGroup},
@ -34,6 +39,7 @@ use crate::{
wayland::{
handlers::{
compositor::FRAME_TIME_FILTER,
corner_radius::{pad_rect, surface_corners, surface_padding},
data_device::get_dnd_icon,
image_copy_capture::{FrameHolder, SessionData, render_session},
},
@ -42,17 +48,15 @@ use crate::{
};
use cosmic::Theme;
use element::FromGlesError;
use smithay::{
backend::{
allocator::Fourcc,
drm::{DrmDeviceFd, DrmNode},
renderer::{
Color32F, ImportAll, Offscreen, Renderer, Texture, TextureFilter,
Color32F, Offscreen, Texture, TextureFilter,
damage::{Error as RenderError, OutputDamageTracker, RenderOutputResult},
element::{
Element, Id, Kind, RenderElement, WeakId,
surface::{WaylandSurfaceRenderElement, render_elements_from_surface_tree},
Element, Id, Kind, NamespacedElement, RenderElement, WeakId,
texture::{TextureRenderBuffer, TextureRenderElement},
utils::{
ConstrainAlign, ConstrainScaleBehavior, CropRenderElement, Relocate,
@ -69,22 +73,23 @@ use smithay::{
sync::SyncPoint,
},
},
desktop::utils::bbox_from_surface_tree,
input::Seat,
output::{Output, OutputModeSource, OutputNoMode},
utils::{
IsAlive, Logical, Monotonic, Physical, Point, Rectangle, Scale, Size, Time, Transform,
},
wayland::{dmabuf::get_dmabuf, session_lock::LockSurface},
wayland::{compositor::with_states, dmabuf::get_dmabuf, session_lock::LockSurface},
};
#[cfg(feature = "debug")]
use smithay_egui::EguiState;
pub mod animations;
pub mod clipped_surface;
pub mod cursor;
pub mod element;
pub mod shadow;
pub mod wayland;
use self::element::{AsGlowRenderer, CosmicElement};
use super::kms::Timings;
@ -422,6 +427,7 @@ pub fn init_shaders(renderer: &mut GlesRenderer) -> Result<(), GlesError> {
UniformName::new("geo_size", UniformType::_2f),
UniformName::new("corner_radius", UniformType::_4f),
UniformName::new("input_to_geo", UniformType::Matrix3x3),
UniformName::new("noise", UniformType::_1f),
],
)?;
let shadow_shader = renderer.compile_custom_pixel_shader(
@ -437,6 +443,7 @@ pub fn init_shaders(renderer: &mut GlesRenderer) -> Result<(), GlesError> {
UniformName::new("window_corner_radius", UniformType::_4f),
],
)?;
let blur_shaders = BlurShaders::compile(renderer)?;
let egl_context = renderer.egl_context();
egl_context
@ -454,6 +461,7 @@ pub fn init_shaders(renderer: &mut GlesRenderer) -> Result<(), GlesError> {
egl_context
.user_data()
.insert_if_missing(|| ShadowShader(shadow_shader));
egl_context.user_data().insert_if_missing(|| blur_shaders);
Ok(())
}
@ -471,12 +479,14 @@ pub fn cursor_elements<'a, 'frame, R>(
seats: impl Iterator<Item = &'a Seat<State>>,
zoom_state: Option<&ZoomState>,
theme: &Theme,
blur_strength: usize,
now: Time<Monotonic>,
output: &Output,
mode: CursorMode,
exclude_dnd_icon: bool,
) -> Vec<CosmicElement<R>>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
@ -490,7 +500,6 @@ where
)
})
.unwrap_or_else(|| ((0., 0.).into(), 1.));
let mut elements = Vec::new();
for seat in seats {
let pointer = match seat.get_pointer() {
@ -500,19 +509,17 @@ where
let location = pointer.current_location() - output.current_location().to_f64();
if mode != CursorMode::None {
elements.extend(
cursor::draw_cursor(
renderer,
seat,
location,
scale.into(),
zoom_scale,
now,
mode != CursorMode::NotDefault,
)
.into_iter()
.map(|(elem, hotspot)| {
CosmicElement::Cursor(RescaleRenderElement::from_element(
cursor::draw_cursor(
renderer,
seat,
location,
scale.into(),
zoom_scale,
now,
blur_strength,
mode != CursorMode::NotDefault,
&mut |elem, hotspot| {
push(CosmicElement::Cursor(RescaleRenderElement::from_element(
RelocateRenderElement::from_element(
elem,
Point::from((-hotspot.x, -hotspot.y)),
@ -523,63 +530,55 @@ where
.to_physical(output.current_scale().fractional_scale())
.to_i32_round(),
zoom_scale,
))
}),
)))
},
);
}
if !exclude_dnd_icon && let Some(dnd_icon) = get_dnd_icon(seat) {
elements.extend(
cursor::draw_dnd_icon(
renderer,
&dnd_icon.surface,
(location + dnd_icon.offset.to_f64()).to_i32_round(),
scale,
)
.into_iter()
.map(CosmicElement::Dnd),
cursor::draw_dnd_icon(
renderer,
&dnd_icon.surface,
(location + dnd_icon.offset.to_f64()).to_i32_round(),
scale,
blur_strength,
&mut |elem| push(CosmicElement::Dnd(elem)),
);
}
let theme = theme.cosmic();
if let Some(grab_elements) = seat
if let Some(grab_state) = seat
.user_data()
.get::<SeatMoveGrabState>()
.unwrap()
.lock()
.unwrap()
.as_ref()
.map(|state| state.render::<CosmicMappedRenderElement<R>, R>(renderer, output, theme))
{
elements.extend(grab_elements.into_iter().map(|elem| {
CosmicElement::MoveGrab(RescaleRenderElement::from_element(
grab_state.render(renderer, output, theme, scanout_node, &mut |elem| {
push(CosmicElement::MoveGrab(RescaleRenderElement::from_element(
elem,
focal_point
.as_logical()
.to_physical(output.current_scale().fractional_scale())
.to_i32_round(),
zoom_scale,
))
}));
)));
})
}
if let Some((grab_elements, should_scale)) = seat
if let Some(grab_state) = seat
.user_data()
.get::<SeatMenuGrabState>()
.unwrap()
.lock()
.unwrap()
.as_ref()
.map(|state| {
(
state.render::<CosmicMappedRenderElement<R>, R>(renderer, output),
!state.is_in_screen_space(),
)
})
{
elements.extend(grab_elements.into_iter().map(|elem| {
CosmicElement::MoveGrab(RescaleRenderElement::from_element(
elem,
let should_scale = !grab_state.is_in_screen_space();
grab_state.render(renderer, output, &mut |elem| {
push(CosmicElement::MoveGrab(RescaleRenderElement::from_element(
elem.into(),
if should_scale {
focal_point
.as_logical()
@ -589,12 +588,10 @@ where
Point::from((0, 0))
},
if should_scale { zoom_scale } else { 1.0 },
))
}));
)));
})
}
}
elements
}
#[cfg(not(feature = "debug"))]
@ -615,11 +612,11 @@ pub fn output_elements<R>(
output: &Output,
cursor_mode: CursorMode,
_fps: Option<(&EguiState, &Timings)>,
scanout_node: Option<DrmNode>,
) -> Result<Vec<CosmicElement<R>>, RenderError<R::Error>>
where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
{
@ -646,7 +643,7 @@ where
),
scale,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
.map_err(RenderError::Rendering)?
.into(),
]
@ -690,6 +687,7 @@ where
workspace,
cursor_mode,
element_filter,
scanout_node,
)?;
#[cfg(feature = "debug")]
@ -713,15 +711,15 @@ pub fn workspace_elements<R>(
current: (WorkspaceHandle, usize),
cursor_mode: CursorMode,
element_filter: ElementFilter,
scanout_node: Option<DrmNode>,
) -> Result<Vec<CosmicElement<R>>, RenderError<R::Error>>
where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
{
let mut elements = Vec::new();
let mut elements = Vec::<CosmicElement<R>>::new();
let shell_ref = shell.read();
let seats = shell_ref.seats.iter().cloned().collect::<Vec<_>>();
@ -729,21 +727,25 @@ where
return Ok(Vec::new());
}
let theme = shell_ref.theme().clone();
let blur_strength = (theme.cosmic().frosted as u8 + 1) as usize;
let scale = output.current_scale().fractional_scale();
// we don't want to hold a shell lock across `cursor_elements`,
// that is prone to deadlock with the main-thread on some grabs.
std::mem::drop(shell_ref);
elements.extend(cursor_elements(
cursor_elements(
renderer,
seats.iter(),
zoom_level,
&theme,
blur_strength,
now,
output,
cursor_mode,
element_filter == ElementFilter::ExcludeWorkspaceOverview,
));
scanout_node,
&mut |elem| elements.push(elem),
);
let shell = shell.read();
let overview = shell.overview_mode();
@ -819,72 +821,132 @@ where
render_input_order::<()>(&shell, output, previous, current, element_filter, |stage| {
match stage {
Stage::ZoomUI => {
elements.extend(ZoomState::render(renderer, output));
ZoomState::render(renderer, output, &mut |elem| {
elements.push(CosmicElement::Zoom(elem))
});
}
Stage::SessionLock(lock_surface) => {
elements.extend(
session_lock_elements(renderer, output, lock_surface)
.into_iter()
.map(Into::into)
.flat_map(crop_to_output)
.map(Into::into),
);
session_lock_elements(renderer, output, lock_surface, blur_strength, &mut |elem| {
elements.extend(crop_to_output(elem.into()).map(Into::into))
})
}
Stage::LayerPopup {
popup, location, ..
popup,
location,
workspace_idx,
..
} => {
elements.extend(
render_elements_from_surface_tree::<_, WorkspaceRenderElement<_>>(
renderer,
popup.wl_surface(),
location
.to_local(output)
.as_logical()
.to_physical_precise_round(scale),
Scale::from(scale),
1.0,
FRAME_TIME_FILTER,
)
.into_iter()
.flat_map(crop_to_output)
.map(Into::into),
);
let mut geometry = popup.geometry().as_global();
geometry.loc += location;
let radii = with_states(popup.wl_surface(), |states| {
surface_corners(states, geometry.size.as_logical())
})
.unwrap_or([0; 4]);
let namespace = output
.user_data()
.get::<OutputId>()
.map(|id| id.namespace_for_workspace(workspace_idx))
.unwrap_or(workspace_idx);
push_render_elements_from_surface_tree(
renderer,
popup.wl_surface(),
location
.to_local(output)
.as_logical()
.to_physical_precise_round(scale),
geometry.to_local(output).as_logical().to_f64(),
Scale::from(scale),
1.0,
false,
radii,
None,
blur_strength,
FRAME_TIME_FILTER,
&mut |elem| {
elements.extend(
crop_to_output(NamespacedElement::new(elem, namespace).into())
.map(Into::into),
)
},
None,
)
}
Stage::LayerSurface { layer, location } => {
elements.extend(
render_elements_from_surface_tree::<_, WorkspaceRenderElement<_>>(
renderer,
layer.wl_surface(),
location
.to_local(output)
.as_logical()
.to_physical_precise_round(scale),
Scale::from(scale),
1.0,
FRAME_TIME_FILTER,
)
.into_iter()
.flat_map(crop_to_output)
.map(Into::into),
Stage::LayerSurface {
layer,
location,
workspace_idx,
} => {
let mut geometry = layer.geometry().as_global();
geometry.loc += location;
let geometry = geometry.to_local(output).as_logical();
let padded = with_states(layer.wl_surface(), |states| {
surface_padding(states, geometry.size)
.and_then(|padding| pad_rect(geometry, &padding))
})
.unwrap_or(geometry);
let radii = with_states(layer.wl_surface(), |states| {
surface_corners(states, padded.size)
})
.unwrap_or([0; 4]);
let namespace = output
.user_data()
.get::<OutputId>()
.map(|id| id.namespace_for_workspace(workspace_idx))
.unwrap_or(workspace_idx);
push_render_elements_from_surface_tree(
renderer,
layer.wl_surface(),
location
.to_local(output)
.as_logical()
.to_physical_precise_round(scale),
geometry.to_f64(),
Scale::from(scale),
1.0,
false,
radii,
padded.to_f64(),
blur_strength,
FRAME_TIME_FILTER,
&mut |elem| {
elements.extend(
crop_to_output(NamespacedElement::new(elem, namespace).into())
.map(Into::into),
)
},
None,
);
}
Stage::OverrideRedirect { surface, location } => {
elements.extend(surface.wl_surface().into_iter().flat_map(|surface| {
render_elements_from_surface_tree::<_, WorkspaceRenderElement<_>>(
if let Some(wl_surface) = surface.wl_surface() {
let mut geometry = surface.geometry().as_global();
geometry.loc += location;
push_render_elements_from_surface_tree(
renderer,
&surface,
&wl_surface,
location
.to_local(output)
.as_logical()
.to_physical_precise_round(scale),
geometry.to_local(output).as_logical().to_f64(),
Scale::from(scale),
1.0,
false,
[0; 4],
None,
blur_strength,
FRAME_TIME_FILTER,
)
.into_iter()
.flat_map(crop_to_output)
.map(Into::into)
}));
&mut |elem| elements.extend(crop_to_output(elem.into()).map(Into::into)),
None,
);
}
}
Stage::StickyPopups(layout) => {
let alpha = match &overview.0 {
@ -905,14 +967,11 @@ where
OverviewMode::None => 1.0,
};
elements.extend(
layout
.render_popups(renderer, alpha)
.into_iter()
.map(Into::into)
.flat_map(crop_to_output)
.map(Into::into),
);
layout.render_popups(renderer, alpha, scanout_node, &mut |elem| {
if let Some(elem) = crop_to_output(elem.into()) {
elements.push(elem.into())
}
});
}
Stage::Sticky(layout) => {
let alpha = match &overview.0 {
@ -937,79 +996,66 @@ where
.then_some(last_active_seat)
.map(|seat| workspace.focus_stack.get(seat));
elements.extend(
layout
.render(
renderer,
current_focus.as_ref().and_then(|stack| {
stack.last().and_then(|t| match t {
FocusTarget::Window(w) => Some(w),
_ => None,
})
}),
resize_indicator.clone(),
active_hint,
alpha,
theme.cosmic(),
)
.into_iter()
.map(Into::into)
.flat_map(crop_to_output)
.map(Into::into),
)
layout.render(
renderer,
current_focus.as_ref().and_then(|stack| {
stack.last().and_then(|t| match t {
FocusTarget::Window(w) => Some(w),
_ => None,
})
}),
resize_indicator.clone(),
active_hint,
alpha,
theme.cosmic(),
scanout_node,
&mut |elem| {
if let Some(elem) = crop_to_output(elem.into()) {
elements.push(elem.into())
}
},
);
}
Stage::WorkspacePopups { workspace, offset } => {
elements.extend(
match workspace.render_popups(
renderer,
last_active_seat,
!move_active && is_active_space,
overview.clone(),
theme.cosmic(),
) {
Ok(elements) => {
elements
.into_iter()
.flat_map(crop_to_output)
.map(|element| {
CosmicElement::Workspace(RelocateRenderElement::from_element(
element,
offset.to_physical_precise_round(scale),
Relocate::Relative,
))
})
}
Err(_) => {
return ControlFlow::Break(Err(OutputNoMode));
workspace.render_popups(
renderer,
last_active_seat,
!move_active && is_active_space,
overview.clone(),
theme.cosmic(),
scanout_node,
&mut |elem| {
if let Some(elem) = crop_to_output(elem) {
elements.push(CosmicElement::Workspace(
RelocateRenderElement::from_element(
elem,
offset.to_physical_precise_round(scale),
Relocate::Relative,
),
));
}
},
);
}
Stage::Workspace { workspace, offset } => {
elements.extend(
match workspace.render(
renderer,
last_active_seat,
!move_active && is_active_space,
overview.clone(),
resize_indicator.clone(),
active_hint,
theme.cosmic(),
) {
Ok(elements) => {
elements
.into_iter()
.flat_map(crop_to_output)
.map(|element| {
CosmicElement::Workspace(RelocateRenderElement::from_element(
element,
offset.to_physical_precise_round(scale),
Relocate::Relative,
))
})
}
Err(_) => {
return ControlFlow::Break(Err(OutputNoMode));
workspace.render(
renderer,
last_active_seat,
!move_active && is_active_space,
overview.clone(),
resize_indicator.clone(),
active_hint,
theme.cosmic(),
scanout_node,
&mut |elem| {
if let Some(elem) = crop_to_output(elem) {
elements.push(CosmicElement::Workspace(
RelocateRenderElement::from_element(
elem,
offset.to_physical_precise_round(scale),
Relocate::Relative,
),
));
}
},
);
@ -1026,23 +1072,29 @@ fn session_lock_elements<R>(
renderer: &mut R,
output: &Output,
lock_surface: Option<&LockSurface>,
) -> Vec<WaylandSurfaceRenderElement<R>>
where
R: Renderer + ImportAll,
blur_strength: usize,
push: &mut dyn FnMut(SurfaceRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Clone + 'static,
{
if let Some(surface) = lock_surface {
let scale = Scale::from(output.current_scale().fractional_scale());
render_elements_from_surface_tree(
push_render_elements_from_surface_tree(
renderer,
surface.wl_surface(),
(0, 0),
bbox_from_surface_tree(surface.wl_surface(), (0, 0)).to_f64(),
scale,
1.0,
false,
[0; 4],
None,
blur_strength,
FRAME_TIME_FILTER,
push,
None,
)
} else {
Vec::new()
}
}
@ -1190,7 +1242,6 @@ pub fn render_output<'d, R>(
where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
@ -1495,12 +1546,23 @@ pub fn render_workspace<'d, R>(
where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
{
let elements: Vec<CosmicElement<R>> = workspace_elements(
let mut elements: Vec<CosmicElement<R>> = if let Some(additional_damage) = additional_damage {
let output_geo = output.geometry().to_local(output).as_logical();
additional_damage
.into_iter()
.filter_map(|rect| rect.intersection(output_geo))
.map(DamageElement::new)
.map(CosmicElement::from)
.collect()
} else {
Vec::new()
};
elements.extend(workspace_elements(
gpu,
renderer,
shell,
@ -1511,17 +1573,8 @@ where
current,
cursor_mode,
element_filter,
)?;
if let Some(additional_damage) = additional_damage {
let output_geo = output.geometry().to_local(output).as_logical();
let additional_damage_elements: Vec<_> = additional_damage
.into_iter()
.filter_map(|rect| rect.intersection(output_geo))
.map(DamageElement::new)
.collect();
damage_tracker.damage_output(age, &additional_damage_elements)?;
}
None,
)?);
let res = damage_tracker.render_output(
renderer,

30
src/backend/render/shaders/blur_downsample.frag Normal file
View file

@ -0,0 +1,30 @@
#version 100
//_DEFINES_
precision highp float;
varying vec2 v_coords;
uniform sampler2D tex;
uniform vec2 half_pixel;
uniform float offset;
uniform float alpha;
#if defined(DEBUG_FLAGS)
uniform float tint;
#endif
void main() {
vec4 sum = texture2D(tex, v_coords) * 4.0;
sum += texture2D(tex, v_coords - half_pixel * offset);
sum += texture2D(tex, v_coords + half_pixel * offset);
sum += texture2D(tex, v_coords + vec2(half_pixel.x, -half_pixel.y) * offset);
sum += texture2D(tex, v_coords - vec2(half_pixel.x, -half_pixel.y) * offset);
if (sum.a == 0.0) {
gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
} else {
gl_FragColor = sum / sum.a;
}
}

31
src/backend/render/shaders/blur_upsample.frag Normal file
View file

@ -0,0 +1,31 @@
#version 100
precision highp float;
varying vec2 v_coords;
uniform sampler2D tex;
uniform vec2 half_pixel;
uniform float offset;
uniform float alpha;
#if defined(DEBUG_FLAGS)
uniform float tint;
#endif
void main() {
vec4 sum = texture2D(tex, v_coords + vec2(-half_pixel.x * 2.0, 0.0) * offset);
sum += texture2D(tex, v_coords + vec2(-half_pixel.x, half_pixel.y) * offset) * 2.0;
sum += texture2D(tex, v_coords + vec2(0.0, half_pixel.y * 2.0) * offset);
sum += texture2D(tex, v_coords + vec2(half_pixel.x, half_pixel.y) * offset) * 2.0;
sum += texture2D(tex, v_coords + vec2(half_pixel.x * 2.0, 0.0) * offset);
sum += texture2D(tex, v_coords + vec2(half_pixel.x, -half_pixel.y) * offset) * 2.0;
sum += texture2D(tex, v_coords + vec2(0.0, -half_pixel.y * 2.0) * offset);
sum += texture2D(tex, v_coords + vec2(-half_pixel.x, -half_pixel.y) * offset) * 2.0;
if (sum.a == 0.0) {
gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
} else {
gl_FragColor = sum / sum.a;
}
}

32
src/backend/render/shaders/clipped_surface.frag
View file

@ -25,6 +25,7 @@ uniform float tint;
uniform vec2 geo_size;
uniform vec4 corner_radius;
uniform mat3 input_to_geo;
uniform float noise;
float rounding_alpha(vec2 coords, vec2 size) {
vec2 center;
@ -51,15 +52,26 @@ float rounding_alpha(vec2 coords, vec2 size) {
return 1.0 - smoothstep(radius - half_px, radius + half_px, dist);
}
void main() {
vec3 coords_geo = input_to_geo * vec3(v_coords, 1.0);
float hash(vec2 p) {
vec3 p3 = fract(vec3(p.xyx) * 727.727);
p3 += dot(p3, p3.xyz + 33.33);
return fract((p3.x + p3.y) * p3.z);
}
void main() {
if (alpha <= 0.0) {
discard;
}
// Sample the texture.
vec4 color = texture2D(tex, v_coords);
#if defined(NO_ALPHA)
color = vec4(color.rgb, 1.0);
#endif
if (color.a <= 0.0) {
discard;
}
vec3 coords_geo = input_to_geo * vec3(v_coords, 1.0);
if (coords_geo.x < 0.0 || 1.0 < coords_geo.x || coords_geo.y < 0.0 || 1.0 < coords_geo.y) {
// Clip outside geometry.
color = vec4(0.0);
@ -68,8 +80,20 @@ void main() {
color = color * rounding_alpha(coords_geo.xy * geo_size, geo_size);
}
if (color.a <= 0.0) {
discard;
}
if (noise > 0.0) {
// Add noise fx
// This can be used to achieve a glass look
float noiseHash = hash(v_coords);
float noiseAmount = (mod(noiseHash, 1.0) - 0.5);
color.rgb += noiseAmount * noise;
}
// Apply final alpha and tint.
color = color * alpha;
color *= alpha;
#if defined(DEBUG_FLAGS)
if (tint == 1.0)

707
src/backend/render/wayland/blur_effect.rs Normal file
View file

@ -0,0 +1,707 @@
use std::{
borrow::{Borrow, BorrowMut},
sync::{LazyLock, Mutex},
};
use cgmath::{Matrix3, SquareMatrix, Vector2};
use smithay::{
backend::{
allocator::Fourcc,
renderer::{
Bind, BlitFrame, Color32F, ContextId, Frame, FrameContext, ImportAll, Offscreen,
Renderer, Texture, TextureFilter,
element::{Element, Id, Kind, RenderElement},
gles::{
GlesError, GlesFrame, GlesRenderer, GlesTexProgram, GlesTexture, Uniform,
UniformName, UniformType, UniformValue, ffi,
},
sync::SyncPoint,
utils::{CommitCounter, DamageSet},
},
},
utils::{
Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform, user_data::UserDataMap,
},
wayland::compositor::SurfaceData,
};
use tracing::trace;
use crate::{
backend::render::{element::AsGlowRenderer, wayland::clipped_surface::ClippingShader},
wayland::handlers::background_effect::ComputedBlurRegionCachedState,
};
pub static BLUR_DOWNSAMPLE_SHADER: &str = include_str!("../shaders/blur_downsample.frag");
pub static BLUR_UPSAMPLE_SHADER: &str = include_str!("../shaders/blur_upsample.frag");
const NOISE: f32 = 0.03;
const MAX_STEPS: usize = 15;
#[derive(Debug, Clone, Copy, PartialEq)]
struct BlurParameters {
passes: usize,
offset: f64,
extended_radius: i32,
}
static BLUR_PARAMS: LazyLock<Vec<BlurParameters>> = LazyLock::new(|| {
let mut params = Vec::new();
let mut remaining_steps = MAX_STEPS as isize;
let offsets = [
// min offset, max offset, extended radius to avoid artifacts
(1.0, 2.0, 10),
(2.0, 3.0, 20),
(2.0, 5.0, 50),
(3.0, 8.0, 150),
];
let sum = offsets.iter().map(|(min, max, _)| *max - *min).sum::<f64>();
for (i, (min, max, extended_radius)) in offsets.into_iter().enumerate() {
let mut iter_num = f64::ceil((max - min) / sum * (MAX_STEPS as f64)) as usize;
remaining_steps -= iter_num as isize;
if remaining_steps < 0 {
iter_num = iter_num.saturating_add_signed(remaining_steps);
}
let diff = max - min;
for j in 1..=iter_num {
params.push(BlurParameters {
passes: i + 1,
offset: min + (diff / iter_num as f64) * j as f64,
extended_radius,
});
}
}
trace!("Computed blur values: {:#?}", &params);
params
});
#[derive(Debug, Clone)]
pub struct BlurShaders {
down: GlesTexProgram,
up: GlesTexProgram,
}
impl BlurShaders {
pub fn compile(renderer: &mut GlesRenderer) -> Result<BlurShaders, GlesError> {
let up = renderer.compile_custom_texture_shader(
BLUR_UPSAMPLE_SHADER,
&[
UniformName::new("half_pixel", UniformType::_2f),
UniformName::new("offset", UniformType::_1f),
],
)?;
let down = renderer.compile_custom_texture_shader(
BLUR_DOWNSAMPLE_SHADER,
&[
UniformName::new("half_pixel", UniformType::_2f),
UniformName::new("offset", UniformType::_1f),
],
)?;
Ok(BlurShaders { up, down })
}
pub fn get<R: AsGlowRenderer>(renderer: &R) -> Self {
Borrow::<GlesRenderer>::borrow(renderer.glow_renderer())
.egl_context()
.user_data()
.get::<BlurShaders>()
.expect("Custom Shaders not initialized")
.clone()
}
}
type BlurTexture<T> = Mutex<Option<T>>;
#[derive(Debug)]
pub struct BlurState {
pub id: Id,
pub renderer_id: Option<ContextId<GlesTexture>>,
pub src: Size<f64, Buffer>,
pub offset: f64,
pub passes: usize,
pub region: Vec<Rectangle<i32, Logical>>,
pub commit: CommitCounter,
}
unsafe impl Send for BlurState {}
unsafe impl Sync for BlurState {}
impl Default for BlurState {
fn default() -> Self {
BlurState {
id: Id::new(),
renderer_id: None,
src: Size::new(0., 0.),
offset: 0.,
passes: 0,
region: Vec::new(),
commit: CommitCounter::default(),
}
}
}
pub struct BlurElement {
id: Id,
commit: CommitCounter,
src: Size<f64, Buffer>,
extended_offset: Point<f64, Logical>,
geometry: Rectangle<f64, Logical>,
scaling_shaders: BlurShaders,
render_shader: GlesTexProgram,
region: Vec<Rectangle<i32, Logical>>,
offset: f64,
passes: usize,
uniforms: Vec<Uniform<'static>>,
}
impl BlurElement {
pub fn from_state<R: ImportAll + AsGlowRenderer>(
renderer: &mut R,
state: &mut BlurState,
geometry: Rectangle<f64, Logical>,
output_scale: f64,
radii: [u8; 4],
strength: usize,
) -> Result<Option<Self>, R::Error> {
let region = vec![Rectangle::from_size(geometry.size.to_i32_round())];
Self::internal(
renderer,
state,
geometry,
&region,
output_scale,
radii,
strength,
)
}
pub fn from_surface<R: ImportAll + AsGlowRenderer>(
renderer: &mut R,
states: &SurfaceData,
geometry: Rectangle<f64, Logical>,
output_scale: f64,
radii: [u8; 4],
strength: usize,
) -> Result<Option<Self>, R::Error> {
let mut blur_region_state = states.cached_state.get::<ComputedBlurRegionCachedState>();
let Some(region) = blur_region_state.current().blur_region.as_ref() else {
return Ok(None);
};
let state = states
.data_map
.get_or_insert_threadsafe::<Mutex<BlurState>, _>(Default::default);
Self::internal(
renderer,
&mut state.lock().unwrap(),
geometry,
region,
output_scale,
radii,
strength,
)
}
pub fn internal<R: ImportAll + AsGlowRenderer>(
renderer: &mut R,
state: &mut BlurState,
geometry: Rectangle<f64, Logical>,
region: &Vec<Rectangle<i32, Logical>>,
output_scale: f64,
radii: [u8; 4],
strength: usize,
) -> Result<Option<Self>, R::Error> {
if strength == 0 || geometry.size.w == 0. || geometry.size.h == 0. {
return Ok(None);
}
let geo = geometry.to_physical_precise_round(output_scale);
let mut extended_geo = geo;
let radius = BLUR_PARAMS[(strength + 2).min(MAX_STEPS - 1)].extended_radius as f64;
extended_geo.loc -= Point::<f64, Physical>::new(radius, radius);
extended_geo.size += Size::<f64, Physical>::new(radius, radius).upscale(2.);
// compute input_to_geo so that it crops the extended capture radius
let geo_scale = {
let Scale { x, y } = geo.size / extended_geo.size;
Matrix3::from_nonuniform_scale(x as f32, y as f32)
.invert()
.unwrap()
};
let geo_translation = {
let offset = geo.loc - extended_geo.loc;
Matrix3::from_translation(-Vector2::new(
(offset.x / extended_geo.size.w) as f32,
(offset.y / extended_geo.size.h) as f32,
))
};
let input_to_geo = geo_scale * geo_translation;
let uniforms = vec![
Uniform::new("geo_size", (geometry.size.w as f32, geometry.size.h as f32)),
Uniform::new(
"corner_radius",
[
radii[3] as f32,
radii[1] as f32,
radii[0] as f32,
radii[2] as f32,
],
),
Uniform::new(
"input_to_geo",
UniformValue::Matrix3x3 {
matrices: vec![*AsRef::<[f32; 9]>::as_ref(&input_to_geo)],
transpose: false,
},
),
Uniform::new("noise", UniformValue::_1f(NOISE)),
];
let geometry = extended_geo.to_logical(output_scale);
let extended_offset = Point::<f64, Physical>::new(radius, radius).to_logical(output_scale);
let renderer_id = renderer.glow_renderer().context_id();
let src = geometry.size.to_buffer(output_scale, Transform::Normal);
let params = &BLUR_PARAMS[strength.min(MAX_STEPS - 1)];
let dirty = !(state
.renderer_id
.as_ref()
.is_some_and(|id| id == &renderer_id)
&& state.offset == params.offset
&& state.passes == params.passes
&& &state.region == region
&& state.src == src);
state.renderer_id = Some(renderer_id);
state.offset = params.offset;
state.passes = params.passes;
state.region = region.clone();
state.src = src;
if dirty {
state.commit.increment();
}
Ok(Some(BlurElement {
id: state.id.clone(),
commit: state.commit,
src,
geometry,
extended_offset,
scaling_shaders: BlurShaders::get(renderer),
render_shader: ClippingShader::get(renderer),
offset: state.offset,
passes: state.passes,
region: region
.iter()
.cloned()
.map(|mut rect| {
rect.loc += extended_offset.to_i32_round();
rect
})
.collect(),
uniforms,
}))
}
}
impl Element for BlurElement {
fn id(&self) -> &Id {
&self.id
}
fn current_commit(&self) -> CommitCounter {
self.commit
}
fn src(&self) -> Rectangle<f64, Buffer> {
Rectangle::from_size(self.src)
}
fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
self.geometry.to_physical_precise_round(scale)
}
fn transform(&self) -> Transform {
Transform::Normal
}
fn damage_since(
&self,
scale: Scale<f64>,
commit: Option<CommitCounter>,
) -> DamageSet<i32, Physical> {
if self.commit.distance(commit).is_none_or(|d| d > 0) {
DamageSet::from_slice(&[Rectangle::new(
self.extended_offset.to_physical_precise_round(scale),
self.geometry.size.to_physical_precise_round(scale)
- self
.extended_offset
.to_size()
.upscale(2.)
.to_physical_precise_round(scale),
)])
} else {
DamageSet::default()
}
}
fn alpha(&self) -> f32 {
1.0
}
fn kind(&self) -> Kind {
Kind::default()
}
fn is_framebuffer_effect(&self) -> bool {
true
}
}
impl<R: Renderer + AsGlowRenderer> RenderElement<R> for BlurElement
where
R::TextureId: Send + 'static,
{
fn capture_framebuffer(
&self,
frame: &mut <R>::Frame<'_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
cache: &UserDataMap,
) -> Result<(), <R>::Error> {
let transform = frame.transformation();
let tex_size = self.src.to_i32_round();
let glow_frame = <R as AsGlowRenderer>::glow_frame_mut(frame);
let gles_frame = BorrowMut::<GlesFrame<'_, '_>>::borrow_mut(glow_frame);
let mut renderer = gles_frame.renderer();
let texture_ref = cache.get_or_insert_threadsafe(BlurTexture::<R::TextureId>::default);
let mut texture_entry = texture_ref.lock().unwrap();
if texture_entry.as_ref().is_some_and(|tex| {
tex.size() != tex_size
|| R::tex_to_gl(
&renderer.as_ref().context_id(),
texture_entry.as_ref().unwrap(),
)
.is_none()
}) {
texture_entry.take();
}
if texture_entry.is_none() {
let gl_texture = renderer
.as_mut()
.create_buffer(Fourcc::Abgr8888, tex_size)
.map_err(R::from_gles_error)?;
*texture_entry = Some(R::tex_from_gl(&renderer.as_ref().context_id(), gl_texture));
}
let mut texture = R::tex_to_gl(
&renderer.as_ref().context_id(),
texture_entry.as_ref().unwrap(),
)
.unwrap();
let mut off_texture = renderer
.as_mut()
.create_buffer(Fourcc::Abgr8888, tex_size)
.map_err(R::from_gles_error)?;
std::mem::drop(renderer);
let sync = blit_from_active_fb(gles_frame, src, dst, transform, &mut texture)
.map_err(R::from_gles_error)?;
gles_frame.wait(&sync).map_err(R::from_gles_error)?;
let mut textures = [&mut texture, &mut off_texture];
render_blur(
gles_frame.renderer().as_mut(),
&self.scaling_shaders,
&mut textures,
self.offset,
self.passes,
)
.map_err(R::from_gles_error)?;
Ok(())
}
fn draw(
&self,
frame: &mut R::Frame<'_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
opaque_regions: &[Rectangle<i32, Physical>],
cache: Option<&UserDataMap>,
) -> Result<(), R::Error> {
let src_to_geo = self.geometry.size / self.src;
let src_log = src
.upscale(src_to_geo)
.to_logical(1., Transform::Normal, &Size::default());
let scale = dst.size.to_f64() / src_log.size;
let damage = self
.region
.iter()
.flat_map(|rect| {
let mut rect = rect.to_f64().intersection(src_log)?;
rect.loc -= src_log.loc;
Some(rect.to_physical_precise_round(scale))
})
.flat_map(|rect| damage.iter().flat_map(move |r| r.intersection(rect)))
.collect::<Vec<_>>();
let cache = cache.expect("Framebuffer element without cache?");
let Some(texture) = cache.get::<BlurTexture<R::TextureId>>() else {
return Err(R::from_gles_error(GlesError::BlitError));
};
let texture_ref = texture.lock().unwrap();
if let Some(tex) = texture_ref.as_ref() {
BorrowMut::<GlesFrame>::borrow_mut(<R as AsGlowRenderer>::glow_frame_mut(frame))
.override_default_tex_program(self.render_shader.clone(), self.uniforms.clone());
frame.render_texture_from_to(
tex,
src,
dst,
&damage,
opaque_regions,
Transform::Normal,
1.0,
)?;
BorrowMut::<GlesFrame>::borrow_mut(<R as AsGlowRenderer>::glow_frame_mut(frame))
.clear_tex_program_override();
}
Ok(())
}
}
fn blit_from_active_fb(
frame: &mut GlesFrame<'_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
transform: Transform,
to_texture: &mut GlesTexture,
) -> Result<SyncPoint, GlesError> {
let tex_size = to_texture.size();
let tex_size_phys = tex_size.to_logical(1, Transform::Normal).to_physical(1);
let fb_size = frame.output_size();
let mut renderer = frame.renderer();
let mut fb = renderer.as_mut().bind(to_texture)?;
let sync = {
let mut subframe = renderer
.as_mut()
.render(&mut fb, tex_size_phys, Transform::Normal)?;
subframe.clear(
Color32F::TRANSPARENT,
&[Rectangle::from_size(tex_size_phys)],
)?;
subframe.finish()?
};
if transform != Transform::Normal {
// We need to copy to a temporary texture to do an actual
// render pass with `render_texture_from_to` to do the rotation.
// dst is in screen space, but we just want to do a 1:1 copy in
// buffer space from dst of the current fb, so we need to undo any
// transforms for the blit.
let dst_phys = transform.transform_rect_in(dst, &fb_size);
let dst_buffer = dst_phys
.to_logical(1)
.to_buffer(1, Transform::Normal, &Size::default());
let mut tmp_texture = renderer
.as_mut()
.create_buffer(Fourcc::Abgr8888, dst_buffer.size)?;
let mut fb_tmp = renderer.as_mut().bind(&mut tmp_texture)?;
std::mem::drop(renderer);
frame.wait(&sync)?;
let sync = frame.blit_to(
&mut fb_tmp,
dst_phys,
Rectangle::from_size(dst_phys.size),
TextureFilter::Linear,
)?;
frame.wait(&sync)?;
std::mem::drop(fb_tmp);
// now we bind the target texture with `Transform::Normal`
// and render the temporary texture with inverse transform
// into src.
let mut renderer = frame.renderer();
let mut frame = renderer
.as_mut()
.render(&mut fb, tex_size_phys, Transform::Normal)?;
frame.wait(&sync)?;
Frame::render_texture_from_to(
&mut frame,
&tmp_texture,
Rectangle::from_size(dst_buffer.size.to_f64()),
src.to_logical(1., Transform::Normal, &Size::default())
.to_physical(1.)
.to_i32_round(),
&[Rectangle::from_size(dst.size)],
&[Rectangle::from_size(dst.size)],
transform.invert(),
1.0,
)?;
std::mem::drop(tmp_texture);
frame.finish()
} else {
std::mem::drop(renderer);
frame.wait(&sync)?;
frame.blit_to(
&mut fb,
dst,
src.to_logical(1., Transform::Normal, &Size::default())
.to_physical(1.)
.to_i32_round(),
TextureFilter::Linear,
)
}
}
fn render_blur(
renderer: &mut GlesRenderer,
shaders: &BlurShaders,
textures: &mut [&mut GlesTexture; 2],
offset: f64,
passes: usize,
) -> Result<(), GlesError> {
for i in 0..passes {
let tex_size = textures[0].size();
let [src_tex, target_tex] = textures;
let mut fb = renderer.bind(*target_tex)?;
let adjusted_tex_size = tex_size.downscale(1 << i);
let target_tex_size = tex_size
.downscale(1 << (i + 1))
.to_logical(1, Transform::Normal)
.to_physical(1);
let half_pixel = [
0.5 / (adjusted_tex_size.w as f32),
0.5 / (adjusted_tex_size.h as f32),
];
let mut frame = renderer.render(
&mut fb,
tex_size.to_logical(1, Transform::Normal).to_physical(1),
Transform::Normal,
)?;
frame.clear(
Color32F::new(0., 0., 0., 0.),
&[Rectangle::from_size(
tex_size.to_logical(1, Transform::Normal).to_physical(1),
)],
)?;
frame.with_context(|gl| unsafe {
gl.TexParameteri(
ffi::TEXTURE_2D,
ffi::TEXTURE_WRAP_S,
ffi::CLAMP_TO_EDGE as i32,
);
gl.TexParameteri(
ffi::TEXTURE_2D,
ffi::TEXTURE_WRAP_T,
ffi::CLAMP_TO_EDGE as i32,
);
})?;
frame.render_texture_from_to(
src_tex,
Rectangle::from_size(adjusted_tex_size.to_f64()),
Rectangle::from_size(target_tex_size),
&[Rectangle::from_size(target_tex_size)],
&[Rectangle::from_size(target_tex_size)],
Transform::Normal,
1.0,
Some(&shaders.down),
&[
Uniform::new("half_pixel", half_pixel),
Uniform::new("offset", (offset / (1 << i) as f64) as f32),
],
)?;
frame.with_context(|gl| unsafe {
gl.TexParameteri(ffi::TEXTURE_2D, ffi::TEXTURE_WRAP_S, ffi::REPEAT as i32);
gl.TexParameteri(ffi::TEXTURE_2D, ffi::TEXTURE_WRAP_T, ffi::REPEAT as i32);
})?;
let sync = frame.finish()?;
std::mem::drop(fb);
renderer.wait(&sync)?;
textures.swap(0, 1);
}
for i in 0..passes {
let tex_size = textures[0].size();
let [src_tex, target_tex] = textures;
let mut fb = renderer.bind(*target_tex)?;
let adjusted_tex_size = tex_size.downscale(1 << (passes - i));
let target_tex_size = tex_size
.downscale(1 << (passes - i - 1))
.to_logical(1, Transform::Normal)
.to_physical(1);
let half_pixel = [
0.5 / (adjusted_tex_size.w as f32),
0.5 / (adjusted_tex_size.h as f32),
];
let mut frame = renderer.render(
&mut fb,
tex_size.to_logical(1, Transform::Normal).to_physical(1),
Transform::Normal,
)?;
frame.clear(
Color32F::new(0., 0., 0., 0.),
&[Rectangle::from_size(
tex_size.to_logical(1, Transform::Normal).to_physical(1),
)],
)?;
frame.with_context(|gl| unsafe {
gl.TexParameteri(
ffi::TEXTURE_2D,
ffi::TEXTURE_WRAP_S,
ffi::CLAMP_TO_EDGE as i32,
);
gl.TexParameteri(
ffi::TEXTURE_2D,
ffi::TEXTURE_WRAP_T,
ffi::CLAMP_TO_EDGE as i32,
);
})?;
frame.render_texture_from_to(
src_tex,
Rectangle::from_size(adjusted_tex_size.to_f64()),
Rectangle::from_size(target_tex_size),
&[Rectangle::from_size(target_tex_size)],
&[Rectangle::from_size(target_tex_size)],
Transform::Normal,
1.0,
Some(&shaders.up),
&[
Uniform::new("half_pixel", half_pixel),
Uniform::new("offset", (offset / (1 << (passes - i)) as f64) as f32),
],
)?;
frame.with_context(|gl| unsafe {
gl.TexParameteri(ffi::TEXTURE_2D, ffi::TEXTURE_WRAP_S, ffi::REPEAT as i32);
gl.TexParameteri(ffi::TEXTURE_2D, ffi::TEXTURE_WRAP_T, ffi::REPEAT as i32);
})?;
let sync = frame.finish()?;
std::mem::drop(fb);
renderer.wait(&sync)?;
textures.swap(0, 1);
}
// textures always end up the right way around with `self.texture` containing our final render,
// since we render PASSES * 2 (downscale and upscale), so the number of swaps is always even.
Ok(())
}

17
src/backend/render/clipped_surface.rs → src/backend/render/wayland/clipped_surface.rs
View file

@ -6,7 +6,7 @@ use cgmath::{Matrix3, Vector2};
use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
use smithay::{
backend::renderer::{
ImportAll, ImportMem, Renderer,
ImportAll, Renderer,
element::{
Element, Id, Kind, RenderElement, UnderlyingStorage,
surface::WaylandSurfaceRenderElement,
@ -19,7 +19,7 @@ use smithay::{
use crate::backend::render::element::AsGlowRenderer;
pub static CLIPPING_SHADER: &str = include_str!("./shaders/clipped_surface.frag");
pub static CLIPPING_SHADER: &str = include_str!("../shaders/clipped_surface.frag");
pub struct ClippingShader(pub GlesTexProgram);
impl ClippingShader {
@ -35,10 +35,7 @@ impl ClippingShader {
}
#[derive(Debug)]
pub struct ClippedSurfaceRenderElement<R>
where
R: Renderer + ImportAll + ImportMem,
{
pub struct ClippedSurfaceRenderElement<R: Renderer> {
inner: WaylandSurfaceRenderElement<R>,
program: GlesTexProgram,
radius: [u8; 4],
@ -48,7 +45,7 @@ where
impl<R> ClippedSurfaceRenderElement<R>
where
R: Renderer + ImportAll + ImportMem,
R: Renderer + ImportAll,
{
pub fn new(
renderer: &mut R,
@ -114,6 +111,7 @@ where
transpose: false,
},
),
Uniform::new("noise", UniformValue::_1f(0.0)),
];
Self {
@ -174,7 +172,8 @@ where
impl<R> Element for ClippedSurfaceRenderElement<R>
where
R: Renderer + ImportAll + ImportMem,
R: Renderer + ImportAll + AsGlowRenderer,
R::TextureId: 'static,
{
fn id(&self) -> &Id {
self.inner.id()
@ -247,7 +246,7 @@ where
impl<R> RenderElement<R> for ClippedSurfaceRenderElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
R: AsGlowRenderer + Renderer + ImportAll,
R::TextureId: 'static,
{
fn draw(

145
src/backend/render/wayland/mod.rs Normal file
View file

@ -0,0 +1,145 @@
use smithay::{
backend::renderer::{
ImportAll, Renderer,
element::surface::{KindEvaluation, WaylandSurfaceRenderElement},
utils::RendererSurfaceStateUserData,
},
reexports::wayland_server::protocol::wl_surface,
render_elements,
utils::{Logical, Physical, Point, Rectangle, Scale},
wayland::compositor::{self, TraversalAction},
};
use tracing::warn;
use crate::backend::render::{
element::AsGlowRenderer,
wayland::{blur_effect::BlurElement, clipped_surface::ClippedSurfaceRenderElement},
};
pub mod blur_effect;
pub mod clipped_surface;
render_elements! {
pub SurfaceRenderElement<R> where R: AsGlowRenderer + ImportAll, R::TextureId: Send;
Blur=BlurElement,
Clipped=ClippedSurfaceRenderElement<R>,
Wayland=WaylandSurfaceRenderElement<R>,
}
pub fn push_render_elements_from_surface_tree<R>(
renderer: &mut R,
main_surface: &wl_surface::WlSurface,
location: impl Into<Point<i32, Physical>>,
geometry: impl Into<Rectangle<f64, Logical>>,
scale: impl Into<Scale<f64>>,
alpha: f32,
should_clip: bool,
radii: [u8; 4],
blur_geometry: impl Into<Option<Rectangle<f64, Logical>>>,
blur_strength: usize,
kind: impl Into<KindEvaluation>,
push_above: &mut dyn FnMut(SurfaceRenderElement<R>),
mut push_below: Option<&mut dyn FnMut(SurfaceRenderElement<R>)>,
) where
R: Renderer + ImportAll + AsGlowRenderer,
R::TextureId: Clone + 'static,
{
let location = location.into().to_f64();
let geometry = geometry.into();
let blur_geometry = blur_geometry.into();
let scale = scale.into();
let kind = kind.into();
let mut passed_main = false;
compositor::with_surface_tree_downward(
main_surface,
location,
|_, states, location| {
let mut location = *location;
let data = states.data_map.get::<RendererSurfaceStateUserData>();
if let Some(data) = data {
if let Some(view) = data.lock().unwrap().view() {
location += view.offset.to_f64().to_physical(scale);
TraversalAction::DoChildren(location)
} else {
TraversalAction::SkipChildren
}
} else {
TraversalAction::SkipChildren
}
},
|surface, states, location| {
let mut location = *location;
let kind = kind.eval(states);
let data = states.data_map.get::<RendererSurfaceStateUserData>();
let mut blur = Ok(None);
if let Some(data) = data {
let has_view = if let Some(view) = data.lock().unwrap().view() {
location += view.offset.to_f64().to_physical(scale);
true
} else {
false
};
if has_view {
match WaylandSurfaceRenderElement::from_surface(
renderer, surface, states, location, alpha, kind,
) {
Ok(Some(surface)) => {
let blur_geo = blur_geometry.unwrap_or(geometry);
blur = BlurElement::from_surface(
renderer,
states,
blur_geo,
scale.x,
radii,
blur_strength,
);
let elem: SurfaceRenderElement<R> = if radii.iter().any(|r| *r != 0)
&& should_clip
&& ClippedSurfaceRenderElement::will_clip(
&surface, scale, geometry, radii,
) {
ClippedSurfaceRenderElement::new(
renderer, surface, scale, geometry, radii,
)
.into()
} else {
surface.into()
};
if let Some(push_below) = push_below.as_mut()
&& passed_main
{
push_below(elem);
} else {
push_above(elem);
}
}
Ok(None) => {} // surface is not mapped
Err(err) => {
warn!("Failed to import surface: {}", err);
}
};
}
}
if surface == main_surface {
passed_main = true;
}
if let Ok(Some(elem)) = blur {
if let Some(push_below) = push_below.as_mut()
&& passed_main
{
push_below(elem.into());
} else {
push_above(elem.into());
}
}
},
|_, _, _| true,
);
}

2
src/backend/winit.rs
View file

@ -26,7 +26,7 @@ use smithay::{
calloop::{EventLoop, ping},
wayland_protocols::wp::presentation_time::server::wp_presentation_feedback,
wayland_server::DisplayHandle,
winit::platform::pump_events::PumpStatus,
winit::event_loop::pump_events::PumpStatus,
},
utils::Transform,
wayland::{dmabuf::DmabufFeedbackBuilder, presentation::Refresh},

21
src/input/mod.rs
View file

@ -35,14 +35,15 @@ use calloop::{
use cosmic_comp_config::{NumlockState, workspace::WorkspaceLayout};
use cosmic_settings_config::shortcuts;
use cosmic_settings_config::shortcuts::action::{Direction, ResizeDirection};
#[cfg(feature = "systemd")]
use smithay::backend::input::{Switch, SwitchState, SwitchToggleEvent};
use smithay::{
backend::input::{
AbsolutePositionEvent, Axis, AxisRelativeDirection, AxisSource, Device, DeviceCapability,
GestureBeginEvent, GestureEndEvent, GesturePinchUpdateEvent as _,
GestureSwipeUpdateEvent as _, InputBackend, InputEvent, KeyState, KeyboardKeyEvent,
PointerAxisEvent, ProximityState, Switch, SwitchState, SwitchToggleEvent,
TabletToolButtonEvent, TabletToolEvent, TabletToolProximityEvent, TabletToolTipEvent,
TabletToolTipState, TouchEvent,
PointerAxisEvent, ProximityState, TabletToolButtonEvent, TabletToolEvent,
TabletToolProximityEvent, TabletToolTipEvent, TabletToolTipState, TouchEvent,
},
desktop::{PopupKeyboardGrab, WindowSurfaceType, utils::under_from_surface_tree},
input::{
@ -74,7 +75,7 @@ use smithay::{
tablet_manager::{TabletDescriptor, TabletSeatTrait},
},
};
use tracing::{error, trace, warn};
use tracing::{error, trace};
use xkbcommon::xkb::{Keycode, Keysym};
use std::{
@ -1599,6 +1600,7 @@ impl State {
}
}
InputEvent::Special(_) => {}
#[allow(unused_variables)]
InputEvent::SwitchToggle { event } => {
#[cfg(feature = "logind")]
if event.switch() == Some(Switch::Lid) && self.common.inhibit_lid_fd.is_some() {
@ -1620,7 +1622,7 @@ impl State {
if let Err(err) = self.refresh_output_config() {
if !closed {
warn!(?err, "Failed to re-enable internal connector");
tracing::warn!(?err, "Failed to re-enable internal connector");
if let Some(output) = output {
use cosmic_comp_config::output::comp::OutputState;
@ -2132,6 +2134,7 @@ impl State {
layer,
popup,
location,
..
} => {
if layer.can_receive_keyboard_focus() {
let surface = popup.wl_surface();
@ -2149,7 +2152,9 @@ impl State {
}
}
}
Stage::LayerSurface { layer, location } => {
Stage::LayerSurface {
layer, location, ..
} => {
if under_from_surface_tree(
layer.wl_surface(),
global_pos.as_logical(),
@ -2301,7 +2306,9 @@ impl State {
))));
}
}
Stage::LayerSurface { layer, location } => {
Stage::LayerSurface {
layer, location, ..
} => {
let surface = layer.wl_surface();
if let Some((surface, surface_loc)) = under_from_surface_tree(
surface,

5
src/lib.rs
View file

@ -26,7 +26,9 @@ use std::{
time::{Duration, Instant},
};
use tracing::{error, info, warn};
use wayland::protocols::overlap_notify::OverlapNotifyState;
use wayland::protocols::{
keyboard_layout::KeyboardLayoutState, overlap_notify::OverlapNotifyState,
};
use crate::wayland::handlers::compositor::client_compositor_state;
@ -331,5 +333,6 @@ fn refresh(state: &mut State) {
state::Common::refresh_focus(state);
OverlapNotifyState::refresh(state);
state.common.update_x11_stacking_order();
KeyboardLayoutState::refresh(state);
state.last_refresh = LastRefresh::At(Instant::now());
}

139
src/shell/element/mod.rs
View file

@ -1,18 +1,21 @@
use crate::{
backend::render::element::{AsGlowRenderer, FromGlesError},
backend::render::element::AsGlowRenderer,
state::State,
utils::{iced::IcedElementInternal, prelude::*},
utils::{
iced::{IcedElementInternal, IcedRenderElement},
prelude::*,
},
};
use calloop::LoopHandle;
use cosmic_comp_config::AppearanceConfig;
use id_tree::NodeId;
use smithay::{
backend::{
drm::DrmNode,
input::KeyState,
renderer::{
element::{
Element, Kind, RenderElement, UnderlyingStorage,
memory::MemoryRenderBufferRenderElement,
utils::{CropRenderElement, RelocateRenderElement, RescaleRenderElement},
},
gles::element::PixelShaderElement,
@ -124,9 +127,9 @@ impl fmt::Debug for CosmicMapped {
}
}
#[derive(Clone)]
#[derive(Clone, Debug)]
pub struct CosmicMappedKey(CosmicMappedKeyInner);
#[derive(Clone)]
#[derive(Clone, Debug)]
enum CosmicMappedKeyInner {
Window(Weak<Mutex<IcedElementInternal<CosmicWindowInternal>>>),
Stack(Weak<Mutex<IcedElementInternal<CosmicStackInternal>>>),
@ -165,6 +168,20 @@ impl PartialEq for CosmicMappedKey {
}
impl Eq for CosmicMappedKey {}
impl PartialEq<CosmicMappedKey> for CosmicMapped {
fn eq(&self, other: &CosmicMappedKey) -> bool {
match (&self.element, &other.0) {
(CosmicMappedInternal::Window(window), CosmicMappedKeyInner::Window(weak)) => {
Arc::as_ptr(&window.0.0) == weak.as_ptr()
}
(CosmicMappedInternal::Stack(stack), CosmicMappedKeyInner::Stack(weak)) => {
Arc::as_ptr(&stack.0.0) == weak.as_ptr()
}
_ => false,
}
}
}
impl PartialEq for CosmicMapped {
fn eq(&self, other: &Self) -> bool {
self.element == other.element
@ -583,33 +600,38 @@ impl CosmicMapped {
}
}
pub fn popup_render_elements<R, C>(
pub fn push_popup_render_elements<R>(
&self,
renderer: &mut R,
location: smithay::utils::Point<i32, smithay::utils::Physical>,
scale: smithay::utils::Scale<f64>,
alpha: f32,
) -> Vec<C>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicMappedRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
C: From<CosmicMappedRenderElement<R>>,
{
match &self.element {
CosmicMappedInternal::Stack(s) => s
.popup_render_elements::<R, CosmicMappedRenderElement<R>>(
renderer, location, scale, alpha,
),
CosmicMappedInternal::Window(w) => w
.popup_render_elements::<R, CosmicMappedRenderElement<R>>(
renderer, location, scale, alpha,
),
CosmicMappedInternal::Stack(s) => s.push_popup_render_elements(
renderer,
location,
scale,
alpha,
scanout_node,
&mut |elem| push(elem.into()),
),
CosmicMappedInternal::Window(w) => w.push_popup_render_elements(
renderer,
location,
scale,
alpha,
scanout_node,
&mut |elem| push(elem.into()),
),
_ => unreachable!(),
}
.into_iter()
.map(C::from)
.collect()
}
pub fn shadow_render_element<R, C>(
@ -656,7 +678,7 @@ impl CosmicMapped {
}
}
pub fn render_elements<R, C>(
pub fn push_render_elements<R>(
&self,
renderer: &mut R,
location: smithay::utils::Point<i32, smithay::utils::Physical>,
@ -664,15 +686,16 @@ impl CosmicMapped {
scale: smithay::utils::Scale<f64>,
alpha: f32,
scanout_override: Option<bool>,
) -> Vec<C>
where
scanout_node: Option<DrmNode>,
push_above: &mut dyn FnMut(CosmicMappedRenderElement<R>),
push_below: &mut dyn FnMut(CosmicMappedRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
C: From<CosmicMappedRenderElement<R>>,
{
#[cfg(feature = "debug")]
let mut elements = if let Some(debug) = self.debug.lock().unwrap().as_mut() {
if let Some(debug) = self.debug.lock().unwrap().as_mut() {
let window = self.active_window();
let window_geo = window.geometry();
let (min_size, max_size, size) = (
@ -833,41 +856,38 @@ impl CosmicMapped {
scale.x,
0.8,
) {
Ok(element) => vec![CosmicMappedRenderElement::from(element)],
Ok(element) => push_above(element.into()),
Err(err) => {
debug!(?err, "Error rendering debug overlay.");
Vec::new()
}
}
} else {
Vec::new()
};
#[cfg(not(feature = "debug"))]
let mut elements = Vec::new();
#[cfg_attr(not(feature = "debug"), allow(unused_mut))]
elements.extend(match &self.element {
CosmicMappedInternal::Stack(s) => s.render_elements::<R, CosmicMappedRenderElement<R>>(
match &self.element {
CosmicMappedInternal::Stack(s) => s.push_render_elements(
renderer,
location,
max_size,
scale,
alpha,
scanout_override,
scanout_node,
&mut |elem| push_above(elem.into()),
&mut |elem| push_below(elem.into()),
),
CosmicMappedInternal::Window(w) => w.push_render_elements(
renderer,
location,
max_size,
scale,
alpha,
scanout_override,
scanout_node,
&mut |elem| push_above(elem.into()),
&mut |elem| push_below(elem.into()),
),
CosmicMappedInternal::Window(w) => w
.render_elements::<R, CosmicMappedRenderElement<R>>(
renderer,
location,
max_size,
scale,
alpha,
scanout_override,
),
_ => unreachable!(),
});
elements.into_iter().map(C::from).collect()
}
}
pub(crate) fn update_theme(&self, theme: cosmic::Theme) {
@ -1109,7 +1129,7 @@ where
GrabbedWindow(RescaleRenderElement<self::window::CosmicWindowRenderElement<R>>),
FocusIndicator(PixelShaderElement),
Overlay(PixelShaderElement),
StackHoverIndicator(MemoryRenderBufferRenderElement<R>),
StackHoverIndicator(IcedRenderElement<R>),
#[cfg(feature = "debug")]
Egui(TextureRenderElement<GlesTexture>),
}
@ -1117,7 +1137,7 @@ where
impl<R> Element for CosmicMappedRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
{
fn id(&self) -> &smithay::backend::renderer::element::Id {
match self {
@ -1338,8 +1358,7 @@ where
impl<R> RenderElement<R> for CosmicMappedRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::Error: FromGlesError,
R::TextureId: Send + 'static,
{
fn draw(
&self,
@ -1372,7 +1391,7 @@ where
opaque_regions,
cache,
)
.map_err(FromGlesError::from_gles_error),
.map_err(R::from_gles_error),
CosmicMappedRenderElement::MovingStack(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions, cache)
}
@ -1394,7 +1413,7 @@ where
opaque_regions,
cache,
)
.map_err(FromGlesError::from_gles_error),
.map_err(R::from_gles_error),
CosmicMappedRenderElement::Overlay(elem) => RenderElement::<GlowRenderer>::draw(
elem,
R::glow_frame_mut(frame),
@ -1404,7 +1423,7 @@ where
opaque_regions,
cache,
)
.map_err(FromGlesError::from_gles_error),
.map_err(R::from_gles_error),
CosmicMappedRenderElement::StackHoverIndicator(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions, cache)
}
@ -1420,7 +1439,7 @@ where
opaque_regions,
cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
}
}
@ -1483,7 +1502,7 @@ where
dst,
cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
CosmicMappedRenderElement::MovingStack(elem) => {
elem.capture_framebuffer(frame, src, dst, cache)
@ -1505,7 +1524,7 @@ where
dst,
cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
CosmicMappedRenderElement::Overlay(elem) => {
RenderElement::<GlowRenderer>::capture_framebuffer(
@ -1515,7 +1534,7 @@ where
dst,
cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
CosmicMappedRenderElement::StackHoverIndicator(elem) => {
elem.capture_framebuffer(frame, src, dst, cache)
@ -1526,7 +1545,7 @@ where
RenderElement::<GlowRenderer>::capture_framebuffer(
elem, glow_frame, src, dst, cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
}
}
@ -1564,13 +1583,13 @@ where
}
}
impl<R> From<MemoryRenderBufferRenderElement<R>> for CosmicMappedRenderElement<R>
impl<R> From<IcedRenderElement<R>> for CosmicMappedRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: MemoryRenderBufferRenderElement<R>) -> Self {
fn from(elem: IcedRenderElement<R>) -> Self {
CosmicMappedRenderElement::StackHoverIndicator(elem)
}
}

450
src/shell/element/resize_indicator.rs
View file

@ -1,10 +1,11 @@
use std::sync::Mutex;
use std::sync::{Arc, Mutex};
use crate::{
backend::render::element::AsGlowRenderer,
config::Config,
fl,
shell::grabs::ResizeEdge,
utils::iced::{IcedElement, Program},
utils::iced::{IcedElement, IcedRenderElement, Program},
};
use calloop::LoopHandle;
@ -12,175 +13,330 @@ use cosmic::{
Apply,
iced::{
Alignment,
widget::{column, container, row, space},
core::{Background, Border, Color, Length},
widget::{container, row, space},
},
iced_core::{Background, Border, Color, Length},
theme,
widget::{icon::from_name, text},
};
use cosmic_settings_config::shortcuts::action::{Action, ResizeDirection};
use smithay::utils::Size;
use smithay::{
backend::renderer::ImportMem,
desktop::space::SpaceElement,
output::Output,
utils::{Logical, Physical, Point, Rectangle, Scale, Size},
};
pub type ResizeIndicator = IcedElement<ResizeIndicatorInternal>;
#[derive(Debug, Clone)]
pub struct ResizeIndicator {
edges: ResizeEdge,
direction: Arc<Mutex<ResizeDirection>>,
size: Size<i32, Logical>,
pub fn resize_indicator(
direction: ResizeDirection,
config: &Config,
evlh: LoopHandle<'static, crate::state::State>,
theme: cosmic::Theme,
) -> ResizeIndicator {
ResizeIndicator::new(
ResizeIndicatorInternal {
edges: Mutex::new(ResizeEdge::all()),
direction,
shortcut1: config
.shortcuts
.iter()
.find_map(|(pattern, action)| {
(*action == Action::Resizing(ResizeDirection::Outwards)).then_some(pattern)
})
.map(|pattern| format!("{}: ", pattern.to_string()))
.unwrap_or_else(|| crate::fl!("unknown-keybinding")),
shortcut2: config
.shortcuts
.iter()
.find_map(|(pattern, action)| {
(*action == Action::Resizing(ResizeDirection::Inwards)).then_some(pattern)
})
.map(|pattern| format!("{}: ", pattern.to_string()))
.unwrap_or_else(|| crate::fl!("unknown-keybinding")),
},
Size::from((1, 1)),
evlh,
theme,
)
center_elem: IcedElement<ResizeIndicatorInternal>,
left_elem: IcedElement<ResizeIndicatorArrow>,
top_elem: IcedElement<ResizeIndicatorArrow>,
right_elem: IcedElement<ResizeIndicatorArrow>,
down_elem: IcedElement<ResizeIndicatorArrow>,
}
const ARROW_SIZE: i32 = 36;
impl ResizeIndicator {
pub fn new(
direction: ResizeDirection,
config: &Config,
evlh: LoopHandle<'static, crate::state::State>,
mut theme: cosmic::Theme,
) -> ResizeIndicator {
theme.transparent = theme.cosmic().frosted_system_interface;
let direction = Arc::new(Mutex::new(direction));
ResizeIndicator {
edges: ResizeEdge::all(),
direction: direction.clone(),
size: Size::default(),
center_elem: IcedElement::new(
ResizeIndicatorInternal {
shortcut1: config
.shortcuts
.iter()
.find_map(|(pattern, action)| {
(*action == Action::Resizing(ResizeDirection::Outwards))
.then_some(pattern)
})
.map(|pattern| format!("{}: ", pattern.to_string()))
.unwrap_or_else(|| crate::fl!("unknown-keybinding")),
shortcut2: config
.shortcuts
.iter()
.find_map(|(pattern, action)| {
(*action == Action::Resizing(ResizeDirection::Inwards))
.then_some(pattern)
})
.map(|pattern| format!("{}: ", pattern.to_string()))
.unwrap_or_else(|| crate::fl!("unknown-keybinding")),
},
Size::from((1, 1)),
evlh.clone(),
theme.clone(),
),
left_elem: IcedElement::new(
ResizeIndicatorArrow {
direction: direction.clone(),
icon_outwards: "go-previous-symbolic",
icon_inwards: "go-next-symbolic",
},
Size::from((ARROW_SIZE, ARROW_SIZE)),
evlh.clone(),
theme.clone(),
),
top_elem: IcedElement::new(
ResizeIndicatorArrow {
direction: direction.clone(),
icon_outwards: "go-up-symbolic",
icon_inwards: "go-down-symbolic",
},
Size::from((ARROW_SIZE, ARROW_SIZE)),
evlh.clone(),
theme.clone(),
),
right_elem: IcedElement::new(
ResizeIndicatorArrow {
direction: direction.clone(),
icon_outwards: "go-next-symbolic",
icon_inwards: "go-previous-symbolic",
},
Size::from((ARROW_SIZE, ARROW_SIZE)),
evlh.clone(),
theme.clone(),
),
down_elem: IcedElement::new(
ResizeIndicatorArrow {
direction,
icon_outwards: "go-down-symbolic",
icon_inwards: "go-up-symbolic",
},
Size::from((ARROW_SIZE, ARROW_SIZE)),
evlh.clone(),
theme.clone(),
),
}
}
pub fn resize(&mut self, size: Size<i32, Logical>) {
let minimum = self.center_elem.minimum_size();
let new_size = Size::<i32, Logical>::new(size.w.min(minimum.w), size.h.min(minimum.h));
self.center_elem.resize(new_size);
self.size = size;
}
pub fn push_render_elements<R>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
push_above: &mut dyn FnMut(IcedRenderElement<R>),
mut push_below: Option<&mut dyn FnMut(IcedRenderElement<R>)>,
) where
R: AsGlowRenderer + ImportMem,
R::TextureId: Send + Clone + 'static,
{
let elem_size = self.center_elem.current_size();
let center_location = Point::new(
self.size.w.saturating_sub(elem_size.w) / 2,
self.size.h.saturating_sub(elem_size.h) / 2,
);
let left_location = Point::new(0, self.size.h.saturating_sub(ARROW_SIZE) / 2);
let top_location = Point::new(self.size.w.saturating_sub(ARROW_SIZE) / 2, 0);
let right_location = Point::new(
self.size.w.saturating_sub(ARROW_SIZE),
self.size.h.saturating_sub(ARROW_SIZE) / 2,
);
let down_location = Point::new(
self.size.w.saturating_sub(ARROW_SIZE) / 2,
self.size.h.saturating_sub(ARROW_SIZE),
);
let radii = self
.center_elem
.with_theme(|theme| theme.cosmic().radius_s())
.map(|x| x.round() as u8);
self.center_elem.push_render_elements(
renderer,
location + center_location.to_physical_precise_round(scale),
scale,
alpha,
radii,
push_above,
if let Some(push_below) = push_below.as_mut() {
Some(&mut **push_below)
} else {
None
},
);
let mut render = move |elem: &IcedElement<ResizeIndicatorArrow>,
loc: Point<i32, Logical>| {
elem.push_render_elements(
renderer,
location + loc.to_physical_precise_round(scale),
scale,
alpha,
radii,
push_above,
if let Some(push_below) = push_below.as_mut() {
Some(&mut **push_below)
} else {
None
},
);
};
if self.edges.contains(ResizeEdge::LEFT) {
render(&self.left_elem, left_location);
}
if self.edges.contains(ResizeEdge::TOP) {
render(&self.top_elem, top_location);
}
if self.edges.contains(ResizeEdge::RIGHT) {
render(&self.right_elem, right_location);
}
if self.edges.contains(ResizeEdge::BOTTOM) {
render(&self.down_elem, down_location);
}
}
pub fn set_edges(&mut self, edges: ResizeEdge) {
self.edges = edges;
}
pub fn set_direction(&self, direction: ResizeDirection) {
let mut dir_ref = self.direction.lock().unwrap();
if *dir_ref != direction {
*dir_ref = direction;
self.left_elem.force_redraw();
self.top_elem.force_redraw();
self.right_elem.force_redraw();
self.down_elem.force_redraw();
}
}
pub fn output_enter(&self, output: &Output) {
self.center_elem
.output_enter(output, Rectangle::default() /*unused*/);
self.left_elem
.output_enter(output, Rectangle::default() /*unused*/);
self.top_elem
.output_enter(output, Rectangle::default() /*unused*/);
self.right_elem
.output_enter(output, Rectangle::default() /*unused*/);
self.down_elem
.output_enter(output, Rectangle::default() /*unused*/);
}
pub fn output_leave(&self, output: &Output) {
self.center_elem.output_leave(output);
self.left_elem.output_leave(output);
self.top_elem.output_leave(output);
self.right_elem.output_leave(output);
self.down_elem.output_leave(output);
}
}
pub struct ResizeIndicatorInternal {
pub edges: Mutex<ResizeEdge>,
pub direction: ResizeDirection,
pub shortcut1: String,
pub shortcut2: String,
shortcut1: String,
shortcut2: String,
}
impl Program for ResizeIndicatorInternal {
type Message = ();
fn view(&self) -> cosmic::Element<'_, Self::Message> {
let edges = self.edges.lock().unwrap();
let icon_container_style = || {
theme::Container::custom(|theme| container::Style {
row(vec![
text::heading(&self.shortcut1).into(),
text::body(fl!("grow-window")).into(),
space::horizontal().width(40).into(),
text::heading(&self.shortcut2).into(),
text::body(fl!("shrink-window")).into(),
])
.apply(container)
.align_x(Alignment::Center)
.align_y(Alignment::Center)
.padding(16)
.apply(container)
.class(theme::Container::custom(|theme| {
let mut background = theme.cosmic().accent_color();
if theme.transparent {
background.alpha = theme
.cosmic()
.alpha_map
.blurred_alpha(theme.cosmic().frosted);
}
container::Style {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent.on)),
text_color: Some(Color::from(theme.cosmic().accent.on)),
background: Some(Background::Color(theme.cosmic().accent_color().into())),
background: Some(Background::Color(background.into())),
border: Border {
radius: 18.0.into(),
radius: theme.cosmic().radius_s().into(),
width: 0.0,
color: Color::TRANSPARENT,
},
shadow: Default::default(),
})
};
column(vec![
if edges.contains(ResizeEdge::TOP) {
from_name(if self.direction == ResizeDirection::Outwards {
"go-up-symbolic"
} else {
"go-down-symbolic"
})
.size(20)
.prefer_svg(true)
.apply(container)
.padding(8)
.class(icon_container_style())
.width(Length::Shrink)
.apply(container)
.center_x(Length::Fill)
.into()
} else {
space::vertical().height(36).into()
},
row(vec![
if edges.contains(ResizeEdge::LEFT) {
from_name(if self.direction == ResizeDirection::Outwards {
"go-previous-symbolic"
} else {
"go-next-symbolic"
})
.size(20)
.prefer_svg(true)
.apply(container)
.padding(8)
.class(icon_container_style())
.width(Length::Shrink)
.apply(container)
.center_y(Length::Fill)
.into()
} else {
space::horizontal().width(36).into()
},
row(vec![
text::heading(&self.shortcut1).into(),
text::body(fl!("grow-window")).into(),
space::horizontal().width(40).into(),
text::heading(&self.shortcut2).into(),
text::body(fl!("shrink-window")).into(),
])
.apply(container)
.align_x(Alignment::Center)
.align_y(Alignment::Center)
.padding(16)
.apply(container)
.class(icon_container_style())
.width(Length::Shrink)
.height(Length::Shrink)
.apply(container)
.center_x(Length::Fill)
.center_y(Length::Fill)
.into(),
if edges.contains(ResizeEdge::RIGHT) {
from_name(if self.direction == ResizeDirection::Outwards {
"go-next-symbolic"
} else {
"go-previous-symbolic"
})
.size(20)
.prefer_svg(true)
.apply(container)
.padding(8)
.class(icon_container_style())
.height(Length::Shrink)
.apply(container)
.center_y(Length::Fill)
.into()
} else {
space::horizontal().width(36).into()
},
])
.width(Length::Fill)
.height(Length::Fill)
.into(),
if edges.contains(ResizeEdge::BOTTOM) {
from_name(if self.direction == ResizeDirection::Outwards {
"go-down-symbolic"
} else {
"go-up-symbolic"
})
.size(20)
.prefer_svg(true)
.apply(container)
.padding(8)
.class(icon_container_style())
.width(Length::Shrink)
.apply(container)
.center_x(Length::Fill)
.into()
} else {
space::vertical().height(36).into()
},
])
}
}))
.width(Length::Shrink)
.height(Length::Shrink)
.into()
}
}
pub struct ResizeIndicatorArrow {
direction: Arc<Mutex<ResizeDirection>>,
icon_outwards: &'static str,
icon_inwards: &'static str,
}
impl Program for ResizeIndicatorArrow {
type Message = ();
fn view(&self) -> cosmic::Element<'_, Self::Message> {
from_name(
if *self.direction.lock().unwrap() == ResizeDirection::Outwards {
self.icon_outwards
} else {
self.icon_inwards
},
)
.size(20)
.prefer_svg(true)
.apply(container)
.padding(8)
.class(theme::Container::custom(|theme| {
let mut background = theme.cosmic().accent_color();
if theme.transparent {
background.alpha = theme
.cosmic()
.alpha_map
.blurred_alpha(theme.cosmic().frosted);
}
container::Style {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent.on)),
text_color: Some(Color::from(theme.cosmic().accent.on)),
background: Some(Background::Color(background.into())),
border: Border {
radius: theme.cosmic().radius_s().into(),
width: 0.0,
color: Color::TRANSPARENT,
},
shadow: Default::default(),
}
}))
.width(Length::Shrink)
.into()
}
}

291
src/shell/element/stack.rs
View file

@ -4,11 +4,8 @@ use super::{
};
use crate::{
backend::render::{
IndicatorShader, Key, Usage,
clipped_surface::ClippedSurfaceRenderElement,
cursor::CursorState,
element::{AsGlowRenderer, FromGlesError},
shadow::ShadowShader,
IndicatorShader, Key, Usage, cursor::CursorState, element::AsGlowRenderer,
shadow::ShadowShader, wayland::SurfaceRenderElement,
},
hooks::{Decorations, HOOKS},
shell::{
@ -19,17 +16,20 @@ use crate::{
},
state::State,
utils::{
iced::{IcedElement, Program},
iced::{IcedElement, IcedRenderElement, Program},
prelude::*,
},
};
use calloop::LoopHandle;
use cosmic::{
Apply, Element as CosmicElement, Theme,
iced::{Alignment, id::Id, widget as iced_widget},
iced_core::{Background, Border, Color, Length, border::Radius},
iced_runtime::Task,
iced_widget::scrollable::AbsoluteOffset,
iced::{
Alignment,
core::{Background, Border, Color, Length, border::Radius},
id::Id,
runtime::Task,
widget::{self as iced_widget, scrollable::AbsoluteOffset},
},
theme, widget as cosmic_widget,
};
use cosmic_comp_config::AppearanceConfig;
@ -37,14 +37,11 @@ use cosmic_settings_config::shortcuts;
use shortcuts::action::{Direction, FocusDirection};
use smithay::{
backend::{
drm::DrmNode,
input::KeyState,
renderer::{
ImportAll, ImportMem, Renderer,
element::{
AsRenderElements, Element, Id as RendererId, Kind, RenderElement,
UnderlyingStorage, memory::MemoryRenderBufferRenderElement,
surface::WaylandSurfaceRenderElement,
},
element::{Element, Id as RendererId, Kind, RenderElement, UnderlyingStorage},
gles::element::PixelShaderElement,
glow::GlowRenderer,
utils::{CommitCounter, DamageSet, OpaqueRegions},
@ -61,8 +58,8 @@ use smithay::{
PointerTarget, RelativeMotionEvent,
},
touch::{
DownEvent, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent, TouchTarget,
UpEvent,
DownEvent, FrameMarker, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent,
TouchTarget, UpEvent,
},
},
output::Output,
@ -79,7 +76,7 @@ use std::{
hash::Hash,
sync::{
Arc, LazyLock, Mutex,
atomic::{AtomicBool, AtomicU8, AtomicUsize, Ordering},
atomic::{AtomicBool, AtomicU8, AtomicU32, AtomicUsize, Ordering},
},
};
@ -114,6 +111,7 @@ pub struct CosmicStackInternal {
scroll_to_focus: AtomicBool,
previous_keyboard: AtomicUsize,
pointer_entered: AtomicU8,
touch_serial: AtomicU32,
reenter: AtomicBool,
potential_drag: Mutex<Option<usize>>,
override_alive: AtomicBool,
@ -148,9 +146,10 @@ impl CosmicStack {
pub fn new<I: Into<CosmicSurface>>(
windows: impl Iterator<Item = I>,
handle: LoopHandle<'static, crate::state::State>,
theme: cosmic::Theme,
mut theme: cosmic::Theme,
appearance: AppearanceConfig,
) -> CosmicStack {
theme.transparent = theme.cosmic().frosted_windows;
let windows = windows.map(Into::into).collect::<Vec<_>>();
assert!(!windows.is_empty());
@ -171,6 +170,7 @@ impl CosmicStack {
scroll_to_focus: AtomicBool::new(false),
previous_keyboard: AtomicUsize::new(0),
pointer_entered: AtomicU8::new(0),
touch_serial: AtomicU32::new(0),
reenter: AtomicBool::new(false),
potential_drag: Mutex::new(None),
override_alive: AtomicBool::new(true),
@ -646,30 +646,38 @@ impl CosmicStack {
self.0.loop_handle()
}
pub fn popup_render_elements<R, C>(
pub fn push_popup_render_elements<R>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
) -> Vec<C>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicStackRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
C: From<CosmicStackRenderElement<R>>,
{
let window_loc = location + Point::from((0, (TAB_HEIGHT as f64 * scale.y) as i32));
self.0.with_program(|p| {
let windows = p.windows.lock().unwrap();
let active = p.active.load(Ordering::SeqCst);
let theme = p.theme.lock().unwrap();
let frosted = if theme.cosmic().frosted_windows {
(theme.cosmic().frosted as u8 + 1) as usize
} else {
0
};
windows[active]
.popup_render_elements::<R, CosmicStackRenderElement<R>>(
renderer, window_loc, scale, alpha,
)
.into_iter()
.map(C::from)
.collect()
windows[active].push_popup_render_elements(
renderer,
window_loc,
scale,
alpha,
scanout_node,
frosted,
&mut |elem| push(elem.into()),
)
})
}
@ -740,7 +748,7 @@ impl CosmicStack {
})
}
pub fn render_elements<R, C>(
pub fn push_render_elements<R>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
@ -748,17 +756,18 @@ impl CosmicStack {
scale: Scale<f64>,
alpha: f32,
scanout_override: Option<bool>,
) -> Vec<C>
where
scanout_node: Option<DrmNode>,
push_above: &mut dyn FnMut(CosmicStackRenderElement<R>),
push_below: &mut dyn FnMut(CosmicStackRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
C: From<CosmicStackRenderElement<R>>,
{
if !self
.0
.with_program(|p| p.override_alive.load(Ordering::Acquire))
{
return Vec::new();
return;
}
let geometry = self
@ -767,27 +776,36 @@ impl CosmicStack {
.to_physical_precise_round(scale);
let stack_loc = location + geometry.loc;
let window_loc = location + Point::from((0, (TAB_HEIGHT as f64 * scale.y) as i32));
let mut elements = AsRenderElements::<R>::render_elements::<CosmicStackRenderElement<R>>(
&self.0, renderer, stack_loc, scale, alpha,
);
elements.extend(self.0.with_program(|p| {
let frosted = self.0.with_program(|p| {
let theme = p.theme.lock().unwrap();
if theme.cosmic().frosted_windows {
(theme.cosmic().frosted as u8 + 1) as usize
} else {
0
}
});
let radii = self.0.with_program(|p| {
let windows = p.windows.lock().unwrap();
let active = p.active.load(Ordering::SeqCst);
let theme = p.theme.lock().unwrap();
let appearance = p.appearance_conf.lock().unwrap();
let theme = p.theme.lock().unwrap();
let tiled = p.tiled.load(Ordering::Acquire);
let maximized = windows[active].is_maximized(false);
let round = (appearance.clip_tiled_windows || !tiled) && !maximized;
let radii = round.then(|| {
round.then(|| {
theme
.cosmic()
.radius_s()
.map(|x| if x < 4.0 { x } else { x + 4.0 })
.map(|x| x.round() as u8)
});
})
});
self.0.with_program(|p| {
let windows = p.windows.lock().unwrap();
let active = p.active.load(Ordering::SeqCst);
let theme = p.theme.lock().unwrap();
let maximized = windows[active].is_maximized(false);
let mut geo = SpaceElement::geometry(&windows[active]).to_f64();
geo.loc += location.to_f64().to_logical(scale);
@ -799,53 +817,49 @@ impl CosmicStack {
let window_key =
CosmicMappedKey(CosmicMappedKeyInner::Stack(Arc::downgrade(&self.0.0)));
let border = (!maximized).then(|| {
if !maximized {
let (r, g, b, a) = theme.cosmic().bg_divider().into_components();
CosmicStackRenderElement::Border(IndicatorShader::element(
push_above(CosmicStackRenderElement::Border(IndicatorShader::element(
renderer,
Key::Window(Usage::Border, window_key.clone()),
geo.to_i32_round().as_local(),
1,
radii.unwrap_or([0, 0, 0, 0]),
radii.unwrap_or([0; 4]),
a * alpha,
scale.x,
[r, g, b],
))
});
)));
};
border.into_iter().chain(
windows[active]
.render_elements::<R, WaylandSurfaceRenderElement<R>>(
renderer,
window_loc,
scale,
alpha,
scanout_override,
)
.into_iter()
.map(move |elem| {
let radii = radii.map(|[a, _, c, _]| [a, 0, c, 0]);
if radii.is_some_and(|radii| {
ClippedSurfaceRenderElement::will_clip(&elem, scale, geo, radii)
}) {
CosmicStackRenderElement::Clipped(ClippedSurfaceRenderElement::new(
renderer,
elem,
scale,
geo,
radii.unwrap(),
))
} else {
CosmicStackRenderElement::Window(elem)
}
}),
)
}));
let radii = radii.map(|[a, _, c, _]| [a, 0, c, 0]);
windows[active].push_render_elements(
renderer,
window_loc,
scale,
alpha,
scanout_override,
scanout_node,
radii.is_some(),
radii.unwrap_or([0; 4]),
frosted,
&mut |elem| push_above(elem.into()),
Some(&mut |elem| push_below(elem.into())),
);
});
elements.into_iter().map(C::from).collect()
self.0.push_render_elements(
renderer,
stack_loc,
scale,
alpha,
radii.map(|[_, b, _, d]| [0, b, 0, d]).unwrap_or([0; 4]),
&mut |elem| push_above(elem.into()),
Some(&mut |elem| push_below(elem.into())),
);
}
pub(crate) fn set_theme(&self, theme: cosmic::Theme) {
pub(crate) fn set_theme(&self, mut theme: cosmic::Theme) {
theme.transparent = theme.cosmic().frosted_windows;
self.0.with_program(|p| {
*p.theme.lock().unwrap() = theme.clone();
});
@ -1354,16 +1368,29 @@ impl Decorations<CosmicStackInternal, Message> for DefaultDecorations {
.class(theme::Container::custom(move |theme| {
let cosmic_theme = theme.cosmic();
let background = if group_focused {
let mut background = if group_focused {
cosmic_theme.accent_color()
} else {
cosmic_theme.primary_container_color()
};
if cosmic_theme.frosted_windows {
background.alpha = cosmic_theme.alpha_map.blurred_alpha(cosmic_theme.frosted);
}
iced_widget::container::Style {
snap: true,
icon_color: Some(cosmic_theme.background.on.into()),
text_color: Some(cosmic_theme.background.on.into()),
icon_color: Some(
cosmic_theme
.background(cosmic_theme.frosted_windows)
.on
.into(),
),
text_color: Some(
cosmic_theme
.background(cosmic_theme.frosted_windows)
.on
.into(),
),
background: Some(Background::Color(background.into())),
border: Border {
radius,
@ -1815,93 +1842,92 @@ impl PointerTarget<State> for CosmicStack {
}
impl TouchTarget<State> for CosmicStack {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent, seq: Serial) {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent) {
let mut event = event.clone();
let active_window_geo = self.0.with_program(|p| {
p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)].geometry()
});
event.location -= active_window_geo.loc.to_f64();
TouchTarget::down(&self.0, seat, data, &event, seq)
self.0
.with_program(|p| p.touch_serial.store(event.serial.into(), Ordering::Release));
TouchTarget::down(&self.0, seat, data, &event)
}
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent, seq: Serial) {
TouchTarget::up(&self.0, seat, data, event, seq)
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent) {
TouchTarget::up(&self.0, seat, data, event)
}
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent, seq: Serial) {
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent) {
let mut event = event.clone();
let active_window_geo = self.0.with_program(|p| {
p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)].geometry()
});
event.location -= active_window_geo.loc.to_f64();
TouchTarget::motion(&self.0, seat, data, &event, seq);
TouchTarget::motion(&self.0, seat, data, &event);
if event.location.y < 0.0
|| event.location.y > TAB_HEIGHT as f64
|| event.location.x < 64.0
|| event.location.x > (active_window_geo.size.w as f64 - 64.0)
{
self.start_drag(data, seat, seq);
self.start_drag(
data,
seat,
self.0
.with_program(|p| p.touch_serial.load(Ordering::Acquire))
.into(),
);
}
}
fn frame(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
TouchTarget::frame(&self.0, seat, data, seq)
fn frame(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
TouchTarget::frame(&self.0, seat, data, frame)
}
fn cancel(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
TouchTarget::cancel(&self.0, seat, data, seq)
fn cancel(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
TouchTarget::cancel(&self.0, seat, data, frame)
}
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent, seq: Serial) {
TouchTarget::shape(&self.0, seat, data, event, seq)
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent) {
TouchTarget::shape(&self.0, seat, data, event)
}
fn orientation(
&self,
_seat: &Seat<State>,
_data: &mut State,
_event: &OrientationEvent,
_seq: Serial,
) {
fn orientation(&self, seat: &Seat<State>, data: &mut State, event: &OrientationEvent) {
TouchTarget::orientation(&self.0, seat, data, event)
}
fn last_frame(&self, seat: &Seat<State>, data: &mut State) -> Option<FrameMarker> {
TouchTarget::last_frame(&self.0, seat, data)
}
}
pub enum CosmicStackRenderElement<R: Renderer + ImportAll + ImportMem> {
Header(MemoryRenderBufferRenderElement<R>),
Header(IcedRenderElement<R>),
Shadow(PixelShaderElement),
Border(PixelShaderElement),
Window(WaylandSurfaceRenderElement<R>),
Clipped(ClippedSurfaceRenderElement<R>),
Window(SurfaceRenderElement<R>),
}
impl<R: Renderer + ImportAll + ImportMem> From<MemoryRenderBufferRenderElement<R>>
impl<R: Renderer + ImportAll + ImportMem> From<IcedRenderElement<R>>
for CosmicStackRenderElement<R>
{
fn from(value: MemoryRenderBufferRenderElement<R>) -> Self {
fn from(value: IcedRenderElement<R>) -> Self {
Self::Header(value)
}
}
impl<R: Renderer + ImportAll + ImportMem> From<WaylandSurfaceRenderElement<R>>
impl<R: Renderer + ImportAll + ImportMem> From<SurfaceRenderElement<R>>
for CosmicStackRenderElement<R>
{
fn from(value: WaylandSurfaceRenderElement<R>) -> Self {
fn from(value: SurfaceRenderElement<R>) -> Self {
Self::Window(value)
}
}
impl<R: Renderer + ImportAll + ImportMem> From<ClippedSurfaceRenderElement<R>>
for CosmicStackRenderElement<R>
{
fn from(value: ClippedSurfaceRenderElement<R>) -> Self {
Self::Clipped(value)
}
}
impl<R> Element for CosmicStackRenderElement<R>
where
R: Renderer + ImportAll + ImportMem,
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
R::TextureId: Send + 'static,
{
fn id(&self) -> &RendererId {
match self {
@ -1909,7 +1935,6 @@ where
CosmicStackRenderElement::Shadow(elem) => elem.id(),
CosmicStackRenderElement::Border(elem) => elem.id(),
CosmicStackRenderElement::Window(elem) => elem.id(),
CosmicStackRenderElement::Clipped(elem) => elem.id(),
}
}
@ -1919,7 +1944,6 @@ where
CosmicStackRenderElement::Shadow(elem) => elem.current_commit(),
CosmicStackRenderElement::Border(elem) => elem.current_commit(),
CosmicStackRenderElement::Window(elem) => elem.current_commit(),
CosmicStackRenderElement::Clipped(elem) => elem.current_commit(),
}
}
@ -1929,7 +1953,6 @@ where
CosmicStackRenderElement::Shadow(elem) => elem.src(),
CosmicStackRenderElement::Border(elem) => elem.src(),
CosmicStackRenderElement::Window(elem) => elem.src(),
CosmicStackRenderElement::Clipped(elem) => elem.src(),
}
}
@ -1939,7 +1962,6 @@ where
CosmicStackRenderElement::Shadow(elem) => elem.geometry(scale),
CosmicStackRenderElement::Border(elem) => elem.geometry(scale),
CosmicStackRenderElement::Window(elem) => elem.geometry(scale),
CosmicStackRenderElement::Clipped(elem) => elem.geometry(scale),
}
}
@ -1949,7 +1971,6 @@ where
CosmicStackRenderElement::Shadow(elem) => elem.location(scale),
CosmicStackRenderElement::Border(elem) => elem.location(scale),
CosmicStackRenderElement::Window(elem) => elem.location(scale),
CosmicStackRenderElement::Clipped(elem) => elem.location(scale),
}
}
@ -1959,7 +1980,6 @@ where
CosmicStackRenderElement::Shadow(elem) => elem.transform(),
CosmicStackRenderElement::Border(elem) => elem.transform(),
CosmicStackRenderElement::Window(elem) => elem.transform(),
CosmicStackRenderElement::Clipped(elem) => elem.transform(),
}
}
@ -1973,7 +1993,6 @@ where
CosmicStackRenderElement::Shadow(elem) => elem.damage_since(scale, commit),
CosmicStackRenderElement::Border(elem) => elem.damage_since(scale, commit),
CosmicStackRenderElement::Window(elem) => elem.damage_since(scale, commit),
CosmicStackRenderElement::Clipped(elem) => elem.damage_since(scale, commit),
}
}
@ -1983,7 +2002,6 @@ where
CosmicStackRenderElement::Shadow(elem) => elem.opaque_regions(scale),
CosmicStackRenderElement::Border(elem) => elem.opaque_regions(scale),
CosmicStackRenderElement::Window(elem) => elem.opaque_regions(scale),
CosmicStackRenderElement::Clipped(elem) => elem.opaque_regions(scale),
}
}
@ -1993,7 +2011,6 @@ where
CosmicStackRenderElement::Shadow(elem) => elem.alpha(),
CosmicStackRenderElement::Border(elem) => elem.alpha(),
CosmicStackRenderElement::Window(elem) => elem.alpha(),
CosmicStackRenderElement::Clipped(elem) => elem.alpha(),
}
}
@ -2003,7 +2020,6 @@ where
CosmicStackRenderElement::Shadow(elem) => elem.kind(),
CosmicStackRenderElement::Border(elem) => elem.kind(),
CosmicStackRenderElement::Window(elem) => elem.kind(),
CosmicStackRenderElement::Clipped(elem) => elem.kind(),
}
}
@ -2013,7 +2029,6 @@ where
CosmicStackRenderElement::Shadow(elem) => elem.is_framebuffer_effect(),
CosmicStackRenderElement::Border(elem) => elem.is_framebuffer_effect(),
CosmicStackRenderElement::Window(elem) => elem.is_framebuffer_effect(),
CosmicStackRenderElement::Clipped(elem) => elem.is_framebuffer_effect(),
}
}
}
@ -2021,12 +2036,11 @@ where
impl<R> RenderElement<R> for CosmicStackRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::Error: FromGlesError,
R::TextureId: Send + 'static,
{
fn draw(
&self,
frame: &mut <R>::Frame<'_, '_>,
frame: &mut R::Frame<'_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
@ -2047,14 +2061,11 @@ where
opaque_regions,
cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
CosmicStackRenderElement::Window(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions, cache)
}
CosmicStackRenderElement::Clipped(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions, cache)
}
}
}
@ -2065,7 +2076,6 @@ where
elem.underlying_storage(renderer.glow_renderer_mut())
}
CosmicStackRenderElement::Window(elem) => elem.underlying_storage(renderer),
CosmicStackRenderElement::Clipped(elem) => elem.underlying_storage(renderer),
}
}
@ -2088,14 +2098,11 @@ where
dst,
cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
CosmicStackRenderElement::Window(elem) => {
elem.capture_framebuffer(frame, src, dst, cache)
}
CosmicStackRenderElement::Clipped(elem) => {
elem.capture_framebuffer(frame, src, dst, cache)
}
}
}
}

55
src/shell/element/stack/tab.rs
View file

@ -3,16 +3,15 @@ use cosmic::{
font::Font,
iced::{
Background,
widget::{self, container::draw_background, rule::FillMode},
core::{
Border, Clipboard, Color, Length, Rectangle, Shell, Size, alignment, event,
layout::{Layout, Limits, Node},
mouse, overlay, renderer,
text::{Ellipsize, EllipsizeHeightLimit, Shaping, Wrapping},
widget::{Id, Widget, operation::Operation, tree::Tree},
},
widget::{self, container::draw_background, rule::FillMode, scrollable::AbsoluteOffset},
},
iced_core::{
Border, Clipboard, Color, Length, Rectangle, Shell, Size, alignment, event,
layout::{Layout, Limits, Node},
mouse, overlay, renderer,
text::{Ellipsize, EllipsizeHeightLimit, Shaping, Wrapping},
widget::{Id, Widget, operation::Operation, tree::Tree},
},
iced_widget::scrollable::AbsoluteOffset,
theme,
widget::{Icon, icon::from_name, text},
};
@ -64,9 +63,20 @@ impl From<TabBackgroundTheme> for theme::Container<'_> {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent_text_color())),
text_color: Some(Color::from(theme.cosmic().accent_text_color())),
background: Some(Background::Color(
theme.cosmic().primary.component.selected.into(),
)),
background: Some(Background::Color({
let mut color = theme
.cosmic()
.primary(theme.cosmic().frosted_windows)
.component
.selected;
if theme.cosmic().frosted_windows {
color.alpha = theme
.cosmic()
.alpha_map
.blurred_alpha(theme.cosmic().frosted);
}
color.into()
})),
border: Border {
radius: 0.0.into(),
width: 0.0,
@ -80,9 +90,20 @@ impl From<TabBackgroundTheme> for theme::Container<'_> {
snap: true,
icon_color: None,
text_color: None,
background: Some(Background::Color(
theme.cosmic().primary.component.base.into(),
)),
background: Some(Background::Color({
let mut color = theme
.cosmic()
.primary(theme.cosmic().frosted_windows)
.component
.base;
if theme.cosmic().frosted_windows {
color.alpha = theme
.cosmic()
.alpha_map
.blurred_alpha(theme.cosmic().frosted);
}
color.into()
})),
border: Border {
radius: 0.0.into(),
width: 0.0,
@ -289,8 +310,8 @@ where
.min_height(size.height)
.width(size.width)
.height(size.height);
cosmic::iced_core::layout::flex::resolve(
cosmic::iced_core::layout::flex::Axis::Horizontal,
cosmic::iced::core::layout::flex::resolve(
cosmic::iced::core::layout::flex::Axis::Horizontal,
renderer,
&limits,
Length::Fill,

44
src/shell/element/stack/tabs.rs
View file

@ -1,24 +1,30 @@
use super::tab::{MIN_ACTIVE_TAB_WIDTH, Tab, TabBackgroundTheme, TabMessage, TabRuleTheme};
use cosmic::{
Apply,
iced::{Element, id::Id, widget},
iced_core::{
Background, Border, Clipboard, Color, Length, Point, Rectangle, Renderer, Shell, Size,
Vector, event,
layout::{Layout, Limits, Node},
mouse, overlay, renderer,
widget::{
Widget,
operation::{
Operation, Scrollable,
scrollable::{AbsoluteOffset, RelativeOffset},
iced::{
Element,
core::{
Background, Border, Clipboard, Color, Length, Point, Rectangle, Renderer, Shell, Size,
Vector, event,
layout::{Layout, Limits, Node},
mouse, overlay, renderer,
widget::{
Widget,
operation::{
Operation, Scrollable,
scrollable::{AbsoluteOffset, RelativeOffset},
},
tree::{self, Tree},
},
tree::{self, Tree},
},
id::Id,
widget::{
self,
container::{Catalog, draw_background},
},
},
iced_widget::container::draw_background,
theme,
widget::{container::Catalog, icon::from_name},
widget::icon::from_name,
};
use keyframe::{
ease,
@ -379,8 +385,8 @@ where
>= MIN_ACTIVE_TAB_WIDTH
{
// just use a flex layout
cosmic::iced_core::layout::flex::resolve(
cosmic::iced_core::layout::flex::Axis::Horizontal,
cosmic::iced::core::layout::flex::resolve(
cosmic::iced::core::layout::flex::Axis::Horizontal,
renderer,
&limits,
self.width,
@ -513,13 +519,11 @@ where
let background_style = Catalog::style(
theme,
&theme::Container::custom(|theme| widget::container::Style {
&theme::Container::custom(|_theme| widget::container::Style {
snap: true,
icon_color: None,
text_color: None,
background: Some(Background::Color(
theme.cosmic().primary_container_color().into(),
)),
background: Some(Background::Color(Color::TRANSPARENT)),
border: Border {
radius: 0.0.into(),
width: 0.0,

112
src/shell/element/stack_hover.rs
View file

@ -1,6 +1,7 @@
use crate::{
backend::render::element::AsGlowRenderer,
fl,
utils::iced::{IcedElement, Program},
utils::iced::{IcedElement, IcedRenderElement, Program},
};
use calloop::LoopHandle;
@ -8,22 +9,78 @@ use cosmic::{
Apply,
iced::{
Alignment,
core::{Background, Border, Color, Length},
widget::{container, row},
},
iced_core::{Background, Border, Color, Length},
theme,
widget::{icon::from_name, space, text},
};
use smithay::utils::{Logical, Size};
use smithay::{
backend::renderer::ImportMem,
desktop::space::SpaceElement,
output::Output,
utils::{Logical, Physical, Point, Rectangle, Scale, Size},
};
pub type StackHover = IcedElement<StackHoverInternal>;
#[derive(Debug)]
pub struct StackHover {
location: Point<i32, Logical>,
elem: IcedElement<StackHoverInternal>,
}
pub fn stack_hover(
evlh: LoopHandle<'static, crate::state::State>,
size: Size<i32, Logical>,
theme: cosmic::Theme,
) -> StackHover {
StackHover::new(StackHoverInternal, size, evlh, theme)
impl StackHover {
pub fn new(
evlh: LoopHandle<'static, crate::state::State>,
size: Size<i32, Logical>,
mut theme: cosmic::Theme,
) -> StackHover {
theme.transparent = theme.cosmic().frosted_system_interface;
let elem = IcedElement::new(StackHoverInternal, size, evlh, theme);
let minimum = elem.minimum_size();
let new_size = Size::<i32, Logical>::new(size.w.min(minimum.w), size.h.min(minimum.h));
let location = Point::new(
size.w.saturating_sub(new_size.w) / 2,
size.h.saturating_sub(new_size.h) / 2,
);
elem.resize(new_size);
StackHover { location, elem }
}
pub fn push_render_elements<R>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
push_above: &mut dyn FnMut(IcedRenderElement<R>),
push_below: Option<&mut dyn FnMut(IcedRenderElement<R>)>,
) where
R: AsGlowRenderer + ImportMem,
R::TextureId: Send + Clone + 'static,
{
self.elem.push_render_elements(
renderer,
location + self.location.to_physical_precise_round(scale),
scale,
alpha,
self.elem
.with_theme(|theme| theme.cosmic().radius_s())
.map(|x| x.round() as u8),
push_above,
push_below,
);
}
pub fn output_enter(&self, output: &Output) {
self.elem
.output_enter(output, Rectangle::default() /*unused*/);
}
pub fn output_leave(&self, output: &Output) {
self.elem.output_leave(output);
}
}
pub struct StackHoverInternal;
@ -47,23 +104,30 @@ impl Program for StackHoverInternal {
.align_y(Alignment::Center)
.padding(16)
.apply(container)
.class(theme::Container::custom(|theme| container::Style {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent.on)),
text_color: Some(Color::from(theme.cosmic().accent.on)),
background: Some(Background::Color(theme.cosmic().accent_color().into())),
border: Border {
radius: 18.0.into(),
width: 0.0,
color: Color::TRANSPARENT,
},
shadow: Default::default(),
.class(theme::Container::custom(|theme| {
let mut background = theme.cosmic().accent_color();
if theme.transparent {
background.alpha = theme
.cosmic()
.alpha_map
.blurred_alpha(theme.cosmic().frosted);
}
container::Style {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent.on)),
text_color: Some(Color::from(theme.cosmic().accent.on)),
background: Some(Background::Color(background.into())),
border: Border {
radius: theme.cosmic().radius_s().into(),
width: 0.0,
color: Color::TRANSPARENT,
},
shadow: Default::default(),
}
}))
.width(Length::Shrink)
.height(Length::Shrink)
.apply(container)
.center_x(Length::Fill)
.center_y(Length::Fill)
.into()
}
}

209
src/shell/element/surface.rs
View file

@ -1,8 +1,10 @@
use crate::{
shell::focus::target::PointerFocusTarget,
wayland::{
handlers::compositor::frame_time_filter_fn, protocols::corner_radius::CacheableCorners,
backend::render::{
element::AsGlowRenderer,
wayland::{SurfaceRenderElement, push_render_elements_from_surface_tree},
},
shell::focus::target::PointerFocusTarget,
wayland::handlers::{compositor::frame_time_filter_fn, corner_radius::surface_corners},
};
use std::{
borrow::Cow,
@ -14,11 +16,12 @@ use std::{
};
use smithay::{
backend::renderer::{
ImportAll, Renderer,
element::{
AsRenderElements, Kind, RenderElementStates,
surface::{WaylandSurfaceRenderElement, render_elements_from_surface_tree},
backend::{
drm::DrmNode,
renderer::{
ImportAll, Renderer,
element::{Kind, RenderElementStates, surface::KindEvaluation},
utils::RendererSurfaceStateUserData,
},
},
desktop::{
@ -49,6 +52,7 @@ use smithay::{
SubsurfaceCachedState, SurfaceData, TraversalAction, get_parent, with_states,
with_surface_tree_downward,
},
dmabuf::get_dmabuf,
seat::WaylandFocus,
shell::xdg::{
SurfaceCachedState, ToplevelCachedState, ToplevelSurface, XdgToplevelSurfaceData,
@ -67,6 +71,49 @@ use crate::{
},
};
/// The [`DrmNode`] the surface's currently committed buffer was allocated on, if it is a dmabuf.
fn buffer_node(data: &SurfaceData) -> Option<DrmNode> {
let surface_state = data.data_map.get::<RendererSurfaceStateUserData>()?;
let surface_state = surface_state.lock().unwrap();
surface_state
.buffer()
.and_then(|buffer| get_dmabuf(buffer).ok())
.and_then(|dmabuf| dmabuf.node())
}
/// Build the [`KindEvaluation`] for a window's surface tree.
///
/// `scanout_node`, when set, is the scan-out target [`DrmNode`] of the output currently being
/// rendered: only buffers allocated on that node may be promoted to overlay scan-out candidates.
/// It is `None` for render passes that never scan out to a plane (e.g. screen-copy).
fn scanout_kind_eval(
scanout_override: Option<bool>,
scanout_node: Option<DrmNode>,
) -> KindEvaluation {
match (scanout_override, scanout_node) {
// Forced off.
(Some(false), _) => Kind::Unspecified.into(),
// No node restriction: preserve the previous behaviour exactly.
(Some(true), None) => Kind::ScanoutCandidate.into(),
(None, None) => FRAME_TIME_FILTER,
// Node restriction in effect: only buffers on the scan-out node may be candidates.
(Some(true), Some(node)) => KindEvaluation::Closure(Box::new(move |data| {
if buffer_node(data) == Some(node) {
Kind::ScanoutCandidate
} else {
Kind::Unspecified
}
})),
(None, Some(node)) => KindEvaluation::Closure(Box::new(move |data| {
if buffer_node(data) == Some(node) {
frame_time_filter_fn(data)
} else {
Kind::Unspecified
}
})),
}
}
#[derive(Debug, Clone, PartialEq, Hash, Eq)]
pub struct CosmicSurface(pub Window);
@ -144,22 +191,7 @@ impl CosmicSurface {
pub fn corner_radius(&self, geometry_size: Size<i32, Logical>) -> Option<[u8; 4]> {
self.wl_surface().and_then(|surface| {
with_states(&surface, |states| {
let mut guard = states.cached_state.get::<CacheableCorners>();
// guard against corner radius being too large, potentially disconnecting the outline
let half_min_dim =
u8::try_from(geometry_size.w.min(geometry_size.h) / 2).unwrap_or(u8::MAX);
let corners = guard.current().0?;
Some([
corners.bottom_right.min(half_min_dim),
corners.top_right.min(half_min_dim),
corners.bottom_left.min(half_min_dim),
corners.top_left.min(half_min_dim),
])
})
with_states(&surface, |states| surface_corners(states, geometry_size))
})
}
@ -810,97 +842,112 @@ impl CosmicSurface {
self.0.user_data()
}
pub fn popup_render_elements<R, C>(
pub fn push_popup_render_elements<R>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
) -> Vec<C>
where
R: Renderer + ImportAll,
scanout_node: Option<DrmNode>,
blur_strength: usize,
push: &mut dyn FnMut(SurfaceRenderElement<R>),
) where
R: Renderer + ImportAll + AsGlowRenderer,
R::TextureId: Clone + 'static,
C: From<WaylandSurfaceRenderElement<R>>,
{
match self.0.underlying_surface() {
WindowSurface::Wayland(toplevel) => {
let surface = toplevel.wl_surface();
PopupManager::popups_for_surface(surface)
.flat_map(move |(popup, popup_offset)| {
let offset = (self.0.geometry().loc + popup_offset - popup.geometry().loc)
.to_physical_precise_round(scale);
render_elements_from_surface_tree(
renderer,
popup.wl_surface(),
location + offset,
scale,
alpha,
FRAME_TIME_FILTER,
)
for (popup, popup_offset) in PopupManager::popups_for_surface(surface) {
let offset = (self.0.geometry().loc + popup_offset - popup.geometry().loc)
.to_physical_precise_round(scale);
let mut geometry = popup.geometry().to_f64();
geometry.loc += location.to_f64().to_logical(scale) + popup_offset.to_f64();
let radii = with_states(popup.wl_surface(), |states| {
surface_corners(states, geometry.size.to_i32_round())
})
.collect()
.unwrap_or([0; 4]);
push_render_elements_from_surface_tree(
renderer,
popup.wl_surface(),
location + offset,
geometry,
scale,
alpha,
false,
radii,
None,
blur_strength,
scanout_kind_eval(None, scanout_node),
push,
None,
)
}
}
WindowSurface::X11(_) => Vec::new(),
WindowSurface::X11(_) => {}
}
}
pub fn render_elements<R, C>(
pub fn push_render_elements<R>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
scanout_override: Option<bool>,
) -> Vec<C>
where
R: Renderer + ImportAll,
scanout_node: Option<DrmNode>,
should_clip: bool,
radii: [u8; 4],
blur_strength: usize,
push_above: &mut dyn FnMut(SurfaceRenderElement<R>),
push_below: Option<&mut dyn FnMut(SurfaceRenderElement<R>)>,
) where
R: Renderer + ImportAll + AsGlowRenderer,
R::TextureId: Clone + 'static,
C: From<WaylandSurfaceRenderElement<R>>,
{
let mut geometry = self.0.geometry().to_f64();
geometry.loc += location.to_f64().to_logical(scale);
match self.0.underlying_surface() {
WindowSurface::Wayland(toplevel) => {
let surface = toplevel.wl_surface();
render_elements_from_surface_tree(
push_render_elements_from_surface_tree(
renderer,
surface,
location,
geometry,
scale,
alpha,
scanout_override
.map(|val| {
if val {
Kind::ScanoutCandidate
} else {
Kind::Unspecified
}
.into()
})
.unwrap_or(FRAME_TIME_FILTER),
should_clip,
radii,
None,
blur_strength,
scanout_kind_eval(scanout_override, scanout_node),
push_above,
push_below,
)
}
WindowSurface::X11(surface) => {
let Some(surface) = surface.wl_surface() else {
return Vec::new();
return;
};
render_elements_from_surface_tree(
push_render_elements_from_surface_tree(
renderer,
&surface,
location,
geometry,
scale,
alpha,
scanout_override
.map(|val| {
if val {
Kind::ScanoutCandidate
} else {
Kind::Unspecified
}
.into()
})
.unwrap_or(FRAME_TIME_FILTER),
should_clip,
radii,
None,
blur_strength,
scanout_kind_eval(scanout_override, scanout_node),
push_above,
push_below,
)
}
}
@ -1044,24 +1091,6 @@ impl X11Relatable for CosmicSurface {
}
}
impl<R> AsRenderElements<R> for CosmicSurface
where
R: Renderer + ImportAll,
R::TextureId: Clone + 'static,
{
type RenderElement = WaylandSurfaceRenderElement<R>;
fn render_elements<C: From<Self::RenderElement>>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
) -> Vec<C> {
self.0.render_elements(renderer, location, scale, alpha)
}
}
fn with_toplevel_state<T, F: FnOnce(Option<&smithay::wayland::shell::xdg::ToplevelState>) -> T>(
toplevel: &ToplevelSurface,
pending: bool,

118
src/shell/element/swap_indicator.rs
View file

@ -1,25 +1,88 @@
use crate::{
backend::render::element::AsGlowRenderer,
fl,
utils::iced::{IcedElement, Program},
utils::iced::{IcedElement, IcedRenderElement, Program},
};
use calloop::LoopHandle;
use cosmic::{
Apply,
iced::widget::{container, row, space},
iced_core::{Alignment, Background, Border, Color, Length},
iced::{
core::{Alignment, Background, Border, Color, Length},
widget::{container, row, space},
},
theme,
widget::{icon::from_name, text},
};
use smithay::utils::Size;
use smithay::{
backend::renderer::ImportMem,
desktop::space::SpaceElement,
output::Output,
utils::{Logical, Physical, Point, Rectangle, Scale, Size},
};
pub type SwapIndicator = IcedElement<SwapIndicatorInternal>;
#[derive(Debug, Clone)]
pub struct SwapIndicator {
location: Point<i32, Logical>,
elem: IcedElement<SwapIndicatorInternal>,
}
pub fn swap_indicator(
evlh: LoopHandle<'static, crate::state::State>,
theme: cosmic::Theme,
) -> SwapIndicator {
SwapIndicator::new(SwapIndicatorInternal, Size::from((1, 1)), evlh, theme)
impl SwapIndicator {
pub fn new(
evlh: LoopHandle<'static, crate::state::State>,
mut theme: cosmic::Theme,
) -> SwapIndicator {
theme.transparent = theme.cosmic().frosted_system_interface;
SwapIndicator {
location: Point::default(),
elem: IcedElement::new(SwapIndicatorInternal, Size::from((1, 1)), evlh, theme),
}
}
pub fn resize(&mut self, size: Size<i32, Logical>) {
let minimum = self.elem.minimum_size();
let new_size = Size::<i32, Logical>::new(size.w.min(minimum.w), size.h.min(minimum.h));
let location = Point::new(
size.w.saturating_sub(new_size.w) / 2,
size.h.saturating_sub(new_size.h) / 2,
);
self.elem.resize(new_size);
self.location = location;
}
pub fn push_render_elements<R>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
push_above: &mut dyn FnMut(IcedRenderElement<R>),
push_below: Option<&mut dyn FnMut(IcedRenderElement<R>)>,
) where
R: AsGlowRenderer + ImportMem,
R::TextureId: Send + Clone + 'static,
{
self.elem.push_render_elements(
renderer,
location + self.location.to_physical_precise_round(scale),
scale,
alpha,
self.elem
.with_theme(|theme| theme.cosmic().radius_s())
.map(|x| x.round() as u8),
push_above,
push_below,
);
}
pub fn output_enter(&self, output: &Output) {
self.elem
.output_enter(output, Rectangle::default() /*unused*/);
}
pub fn output_leave(&self, output: &Output) {
self.elem.output_leave(output);
}
}
pub struct SwapIndicatorInternal;
@ -43,23 +106,30 @@ impl Program for SwapIndicatorInternal {
.align_y(Alignment::Center)
.padding(16)
.apply(container)
.class(theme::Container::custom(|theme| container::Style {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent.on)),
text_color: Some(Color::from(theme.cosmic().accent.on)),
background: Some(Background::Color(theme.cosmic().accent_color().into())),
border: Border {
radius: 18.0.into(),
width: 0.0,
color: Color::TRANSPARENT,
},
shadow: Default::default(),
.class(theme::Container::custom(|theme| {
let mut background = theme.cosmic().accent_color();
if theme.transparent {
background.alpha = theme
.cosmic()
.alpha_map
.blurred_alpha(theme.cosmic().frosted);
}
container::Style {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent.on)),
text_color: Some(Color::from(theme.cosmic().accent.on)),
background: Some(Background::Color(background.into())),
border: Border {
radius: theme.cosmic().radius_s().into(),
width: 0.0,
color: Color::TRANSPARENT,
},
shadow: Default::default(),
}
}))
.width(Length::Shrink)
.height(Length::Shrink)
.apply(container)
.center_x(Length::Fill)
.center_y(Length::Fill)
.into()
}
}

231
src/shell/element/window.rs
View file

@ -1,10 +1,7 @@
use crate::{
backend::render::{
IndicatorShader, Key, Usage,
clipped_surface::ClippedSurfaceRenderElement,
cursor::CursorState,
element::{AsGlowRenderer, FromGlesError},
shadow::ShadowShader,
IndicatorShader, Key, Usage, cursor::CursorState, element::AsGlowRenderer,
shadow::ShadowShader, wayland::SurfaceRenderElement,
},
hooks::{Decorations, HOOKS},
shell::{
@ -14,7 +11,7 @@ use crate::{
},
state::State,
utils::{
iced::{IcedElement, Program},
iced::{IcedElement, IcedRenderElement, Program},
prelude::*,
},
};
@ -23,14 +20,11 @@ use cosmic::iced::{Color, Task};
use cosmic_comp_config::AppearanceConfig;
use smithay::{
backend::{
drm::DrmNode,
input::KeyState,
renderer::{
ImportAll, ImportMem, Renderer,
element::{
AsRenderElements, Element, Id as RendererId, Kind, RenderElement,
UnderlyingStorage, memory::MemoryRenderBufferRenderElement,
surface::WaylandSurfaceRenderElement,
},
element::{Element, Id as RendererId, Kind, RenderElement, UnderlyingStorage},
gles::element::PixelShaderElement,
glow::GlowRenderer,
utils::{CommitCounter, DamageSet, OpaqueRegions},
@ -47,8 +41,8 @@ use smithay::{
GestureSwipeUpdateEvent, MotionEvent, PointerTarget, RelativeMotionEvent,
},
touch::{
DownEvent, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent, TouchTarget,
UpEvent,
DownEvent, FrameMarker, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent,
TouchTarget, UpEvent,
},
},
output::Output,
@ -196,12 +190,13 @@ impl CosmicWindow {
pub fn new(
window: impl Into<CosmicSurface>,
handle: LoopHandle<'static, crate::state::State>,
theme: cosmic::Theme,
mut theme: cosmic::Theme,
appearance: AppearanceConfig,
) -> CosmicWindow {
let window = window.into();
let width = window.geometry().size.w;
let last_title = window.title();
theme.transparent = theme.cosmic().frosted_windows;
if appearance.clip_floating_windows {
window.set_tiled(true);
@ -351,17 +346,17 @@ impl CosmicWindow {
self.0.loop_handle()
}
pub fn popup_render_elements<R, C>(
pub fn push_popup_render_elements<R>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
) -> Vec<C>
where
R: Renderer + ImportAll + ImportMem,
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicWindowRenderElement<R>),
) where
R: Renderer + AsGlowRenderer + ImportAll + ImportMem,
R::TextureId: Send + Clone + 'static,
C: From<CosmicWindowRenderElement<R>>,
{
let has_ssd = self.0.with_program(|p| p.has_ssd(false));
@ -372,13 +367,22 @@ impl CosmicWindow {
};
self.0.with_program(|p| {
p.window
.popup_render_elements::<R, CosmicWindowRenderElement<R>>(
renderer, window_loc, scale, alpha,
)
.into_iter()
.map(C::from)
.collect()
let theme = p.theme.lock().unwrap();
let frosted = if theme.cosmic().frosted_windows {
(theme.cosmic().frosted as u8 + 1) as usize
} else {
0
};
p.window.push_popup_render_elements(
renderer,
window_loc,
scale,
alpha,
scanout_node,
frosted,
&mut |elem| push(elem.into()),
)
})
}
@ -462,7 +466,7 @@ impl CosmicWindow {
})
}
pub fn render_elements<R, C>(
pub fn push_render_elements<R>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
@ -470,11 +474,12 @@ impl CosmicWindow {
scale: Scale<f64>,
alpha: f32,
scanout_override: Option<bool>,
) -> Vec<C>
where
scanout_node: Option<DrmNode>,
push_above: &mut dyn FnMut(CosmicWindowRenderElement<R>),
push_below: &mut dyn FnMut(CosmicWindowRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
C: From<CosmicWindowRenderElement<R>>,
{
let (has_ssd, is_tiled, is_maximized, mut radii, appearance) = self.0.with_program(|p| {
(
@ -511,8 +516,6 @@ impl CosmicWindow {
location
};
let mut elements = Vec::new();
let (mut geo, bg_divider) = self.0.with_program(|p| {
(
SpaceElement::geometry(&p.window).to_f64(),
@ -542,55 +545,57 @@ impl CosmicWindow {
scale.x,
[r, g, b],
));
elements.push(elem);
push_above(elem);
}
let window_elements = self.0.with_program(|p| {
p.window
.render_elements::<R, WaylandSurfaceRenderElement<R>>(
renderer,
window_loc,
scale,
alpha,
scanout_override,
)
});
if window_elements.is_empty() {
return Vec::new();
}
elements.extend(window_elements.into_iter().map(|elem| {
self.0.with_program(|p| {
let mut radii = radii;
if has_ssd {
radii[1] = 0;
radii[3] = 0;
}
if radii.iter().any(|x| *x != 0)
&& clip
&& ClippedSurfaceRenderElement::will_clip(&elem, scale, geo, radii)
{
CosmicWindowRenderElement::Clipped(ClippedSurfaceRenderElement::new(
renderer, elem, scale, geo, radii,
))
let theme = p.theme.lock().unwrap();
let frosted = if theme.cosmic().frosted_windows {
(theme.cosmic().frosted as u8 + 1) as usize
} else {
CosmicWindowRenderElement::Window(elem)
}
}));
0
};
p.window.push_render_elements(
renderer,
window_loc,
scale,
alpha,
scanout_override,
scanout_node,
clip,
radii,
frosted,
&mut |elem| push_above(elem.into()),
Some(&mut |elem| push_below(elem.into())),
);
});
if has_ssd {
radii[0] = 0;
radii[2] = 0;
let ssd_loc = location
+ self
.0
.with_program(|p| p.window.geometry().loc)
.to_physical_precise_round(scale);
elements.extend(AsRenderElements::<R>::render_elements::<
CosmicWindowRenderElement<R>,
>(&self.0, renderer, ssd_loc, scale, alpha))
.with_program(|p| p.window.geometry().loc.to_physical_precise_round(scale));
self.0.push_render_elements(
renderer,
ssd_loc,
scale,
alpha,
radii,
&mut |elem| push_above(elem.into()),
Some(&mut |elem| push_below(elem.into())),
);
}
elements.into_iter().map(C::from).collect()
}
pub(crate) fn set_theme(&self, theme: cosmic::Theme) {
pub(crate) fn set_theme(&self, mut theme: cosmic::Theme) {
theme.transparent = theme.cosmic().frosted_windows;
self.0.with_program(|p| {
*p.theme.lock().unwrap() = theme.clone();
});
@ -826,7 +831,11 @@ impl Program for CosmicWindowInternal {
fn background_color(&self, theme: &cosmic::Theme) -> Color {
if self.window.is_maximized(false) {
theme.cosmic().background.base.into()
theme
.cosmic()
.background(theme.cosmic().frosted_windows)
.base
.into()
} else {
Color::TRANSPARENT
}
@ -1190,43 +1199,42 @@ impl PointerTarget<State> for CosmicWindow {
}
impl TouchTarget<State> for CosmicWindow {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent, seq: Serial) {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent) {
let mut event = event.clone();
self.0.with_program(|p| {
event.location -= p.window.geometry().loc.to_f64();
});
TouchTarget::down(&self.0, seat, data, &event, seq)
TouchTarget::down(&self.0, seat, data, &event)
}
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent, seq: Serial) {
TouchTarget::up(&self.0, seat, data, event, seq)
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent) {
TouchTarget::up(&self.0, seat, data, event)
}
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent, seq: Serial) {
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent) {
let mut event = event.clone();
event.location -= self.0.with_program(|p| p.window.geometry().loc.to_f64());
TouchTarget::motion(&self.0, seat, data, &event, seq)
TouchTarget::motion(&self.0, seat, data, &event)
}
fn frame(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
TouchTarget::frame(&self.0, seat, data, seq)
fn frame(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
TouchTarget::frame(&self.0, seat, data, frame)
}
fn cancel(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
TouchTarget::cancel(&self.0, seat, data, seq)
fn cancel(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
TouchTarget::cancel(&self.0, seat, data, frame)
}
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent, seq: Serial) {
TouchTarget::shape(&self.0, seat, data, event, seq)
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent) {
TouchTarget::shape(&self.0, seat, data, event)
}
fn orientation(
&self,
_seat: &Seat<State>,
_data: &mut State,
_event: &OrientationEvent,
_seq: Serial,
) {
fn orientation(&self, seat: &Seat<State>, data: &mut State, event: &OrientationEvent) {
TouchTarget::orientation(&self.0, seat, data, event)
}
fn last_frame(&self, seat: &Seat<State>, data: &mut State) -> Option<FrameMarker> {
TouchTarget::last_frame(&self.0, seat, data)
}
}
@ -1244,41 +1252,33 @@ impl WaylandFocus for CosmicWindow {
}
}
pub enum CosmicWindowRenderElement<R: Renderer + ImportAll + ImportMem> {
Header(MemoryRenderBufferRenderElement<R>),
pub enum CosmicWindowRenderElement<R: AsGlowRenderer + ImportAll + ImportMem> {
Header(IcedRenderElement<R>),
Shadow(PixelShaderElement),
Border(PixelShaderElement),
Window(WaylandSurfaceRenderElement<R>),
Clipped(ClippedSurfaceRenderElement<R>),
Window(SurfaceRenderElement<R>),
}
impl<R: Renderer + ImportAll + ImportMem> From<MemoryRenderBufferRenderElement<R>>
impl<R: AsGlowRenderer + ImportAll + ImportMem> From<IcedRenderElement<R>>
for CosmicWindowRenderElement<R>
{
fn from(value: MemoryRenderBufferRenderElement<R>) -> Self {
fn from(value: IcedRenderElement<R>) -> Self {
Self::Header(value)
}
}
impl<R: Renderer + ImportAll + ImportMem> From<WaylandSurfaceRenderElement<R>>
impl<R: AsGlowRenderer + ImportAll + ImportMem> From<SurfaceRenderElement<R>>
for CosmicWindowRenderElement<R>
{
fn from(value: WaylandSurfaceRenderElement<R>) -> Self {
fn from(value: SurfaceRenderElement<R>) -> Self {
Self::Window(value)
}
}
impl<R: Renderer + ImportAll + ImportMem> From<ClippedSurfaceRenderElement<R>>
for CosmicWindowRenderElement<R>
{
fn from(value: ClippedSurfaceRenderElement<R>) -> Self {
Self::Clipped(value)
}
}
impl<R> Element for CosmicWindowRenderElement<R>
where
R: Renderer + ImportAll + ImportMem,
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
R::TextureId: Send + 'static,
{
fn id(&self) -> &RendererId {
match self {
@ -1286,7 +1286,6 @@ where
CosmicWindowRenderElement::Shadow(elem) => elem.id(),
CosmicWindowRenderElement::Border(elem) => elem.id(),
CosmicWindowRenderElement::Window(elem) => elem.id(),
CosmicWindowRenderElement::Clipped(elem) => elem.id(),
}
}
@ -1296,7 +1295,6 @@ where
CosmicWindowRenderElement::Shadow(elem) => elem.current_commit(),
CosmicWindowRenderElement::Border(elem) => elem.current_commit(),
CosmicWindowRenderElement::Window(elem) => elem.current_commit(),
CosmicWindowRenderElement::Clipped(elem) => elem.current_commit(),
}
}
@ -1306,7 +1304,6 @@ where
CosmicWindowRenderElement::Shadow(elem) => elem.src(),
CosmicWindowRenderElement::Border(elem) => elem.src(),
CosmicWindowRenderElement::Window(elem) => elem.src(),
CosmicWindowRenderElement::Clipped(elem) => elem.src(),
}
}
@ -1316,7 +1313,6 @@ where
CosmicWindowRenderElement::Shadow(elem) => elem.geometry(scale),
CosmicWindowRenderElement::Border(elem) => elem.geometry(scale),
CosmicWindowRenderElement::Window(elem) => elem.geometry(scale),
CosmicWindowRenderElement::Clipped(elem) => elem.geometry(scale),
}
}
@ -1326,7 +1322,6 @@ where
CosmicWindowRenderElement::Shadow(elem) => elem.location(scale),
CosmicWindowRenderElement::Border(elem) => elem.location(scale),
CosmicWindowRenderElement::Window(elem) => elem.location(scale),
CosmicWindowRenderElement::Clipped(elem) => elem.location(scale),
}
}
@ -1336,7 +1331,6 @@ where
CosmicWindowRenderElement::Shadow(elem) => elem.transform(),
CosmicWindowRenderElement::Border(elem) => elem.transform(),
CosmicWindowRenderElement::Window(elem) => elem.transform(),
CosmicWindowRenderElement::Clipped(elem) => elem.transform(),
}
}
@ -1350,7 +1344,6 @@ where
CosmicWindowRenderElement::Shadow(elem) => elem.damage_since(scale, commit),
CosmicWindowRenderElement::Border(elem) => elem.damage_since(scale, commit),
CosmicWindowRenderElement::Window(elem) => elem.damage_since(scale, commit),
CosmicWindowRenderElement::Clipped(elem) => elem.damage_since(scale, commit),
}
}
@ -1360,7 +1353,6 @@ where
CosmicWindowRenderElement::Shadow(elem) => elem.opaque_regions(scale),
CosmicWindowRenderElement::Border(elem) => elem.opaque_regions(scale),
CosmicWindowRenderElement::Window(elem) => elem.opaque_regions(scale),
CosmicWindowRenderElement::Clipped(elem) => elem.opaque_regions(scale),
}
}
@ -1370,7 +1362,6 @@ where
CosmicWindowRenderElement::Shadow(elem) => elem.alpha(),
CosmicWindowRenderElement::Border(elem) => elem.alpha(),
CosmicWindowRenderElement::Window(elem) => elem.alpha(),
CosmicWindowRenderElement::Clipped(elem) => elem.alpha(),
}
}
@ -1380,7 +1371,6 @@ where
CosmicWindowRenderElement::Shadow(elem) => elem.kind(),
CosmicWindowRenderElement::Border(elem) => elem.kind(),
CosmicWindowRenderElement::Window(elem) => elem.kind(),
CosmicWindowRenderElement::Clipped(elem) => elem.kind(),
}
}
@ -1390,7 +1380,6 @@ where
CosmicWindowRenderElement::Shadow(elem) => elem.is_framebuffer_effect(),
CosmicWindowRenderElement::Border(elem) => elem.is_framebuffer_effect(),
CosmicWindowRenderElement::Window(elem) => elem.is_framebuffer_effect(),
CosmicWindowRenderElement::Clipped(elem) => elem.is_framebuffer_effect(),
}
}
}
@ -1398,8 +1387,7 @@ where
impl<R> RenderElement<R> for CosmicWindowRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::Error: FromGlesError,
R::TextureId: Send + 'static,
{
fn draw(
&self,
@ -1424,14 +1412,11 @@ where
opaque_regions,
cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
CosmicWindowRenderElement::Window(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions, cache)
}
CosmicWindowRenderElement::Clipped(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions, cache)
}
}
}
@ -1442,7 +1427,6 @@ where
elem.underlying_storage(renderer.glow_renderer_mut())
}
CosmicWindowRenderElement::Window(elem) => elem.underlying_storage(renderer),
CosmicWindowRenderElement::Clipped(elem) => elem.underlying_storage(renderer),
}
}
@ -1465,14 +1449,11 @@ where
dst,
cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
CosmicWindowRenderElement::Window(elem) => {
elem.capture_framebuffer(frame, src, dst, cache)
}
CosmicWindowRenderElement::Clipped(elem) => {
elem.capture_framebuffer(frame, src, dst, cache)
}
}
}
}

58
src/shell/focus/order.rs
View file

@ -32,10 +32,12 @@ pub enum Stage<'a> {
layer: LayerSurface,
popup: &'a PopupKind,
location: Point<i32, Global>,
workspace_idx: usize,
},
LayerSurface {
layer: LayerSurface,
location: Point<i32, Global>,
workspace_idx: usize,
},
OverrideRedirect {
surface: &'a X11Surface,
@ -95,10 +97,15 @@ fn render_input_order_internal<R: 'static>(
layer,
popup: &popup,
location,
workspace_idx: current.1,
})?;
}
for (layer, location) in layer_surfaces(output, Layer::Overlay, element_filter) {
callback(Stage::LayerSurface { layer, location })?;
callback(Stage::LayerSurface {
layer,
location,
workspace_idx: current.1,
})?;
}
// calculate a bunch of stuff for workspace transitions
@ -187,7 +194,7 @@ fn render_input_order_internal<R: 'static>(
});
(
Some((previous, has_fullscreen, offset)),
Some((previous, previous_idx, has_fullscreen, offset)),
Point::<i32, Logical>::from(match (layout, forward) {
(WorkspaceLayout::Vertical, true) => (0, output_size.h + offset.y),
(WorkspaceLayout::Vertical, false) => (0, -(output_size.h - offset.y)),
@ -206,6 +213,7 @@ fn render_input_order_internal<R: 'static>(
layer,
popup: &popup,
location,
workspace_idx: current.1,
})?;
}
}
@ -236,7 +244,7 @@ fn render_input_order_internal<R: 'static>(
if element_filter != ElementFilter::LayerShellOnly {
// previous workspace popups
if let Some((previous_handle, _, offset)) = previous.as_ref() {
if let Some((previous_handle, _, _, offset)) = previous.as_ref() {
let Some(workspace) = shell.workspaces.space_for_handle(previous_handle) else {
return ControlFlow::Break(Err(OutputNoMode));
};
@ -265,11 +273,12 @@ fn render_input_order_internal<R: 'static>(
layer,
popup: &popup,
location,
workspace_idx: current.1,
})?;
}
}
if let Some((_, has_fullscreen, offset)) = previous.as_ref()
if let Some((_, idx, has_fullscreen, offset)) = previous.as_ref()
&& !has_fullscreen
{
// previous bottom layer popups
@ -278,6 +287,7 @@ fn render_input_order_internal<R: 'static>(
layer,
popup: &popup,
location: location + offset.as_global(),
workspace_idx: **idx,
})?;
}
}
@ -289,11 +299,12 @@ fn render_input_order_internal<R: 'static>(
layer,
popup: &popup,
location,
workspace_idx: current.1,
})?;
}
}
if let Some((_, has_fullscreen, offset)) = previous.as_ref()
if let Some((_, idx, has_fullscreen, offset)) = previous.as_ref()
&& !has_fullscreen
{
// previous background layer popups
@ -302,6 +313,7 @@ fn render_input_order_internal<R: 'static>(
layer,
popup: &popup,
location: location + offset.as_global(),
workspace_idx: **idx,
})?;
}
}
@ -309,7 +321,11 @@ fn render_input_order_internal<R: 'static>(
if !has_focused_fullscreen {
// top-layer shell
for (layer, location) in layer_surfaces(output, Layer::Top, element_filter) {
callback(Stage::LayerSurface { layer, location })?;
callback(Stage::LayerSurface {
layer,
location,
workspace_idx: current.1,
})?;
}
}
@ -326,7 +342,7 @@ fn render_input_order_internal<R: 'static>(
})?;
// previous workspace windows
if let Some((previous_handle, _, offset)) = previous.as_ref() {
if let Some((previous_handle, _, _, offset)) = previous.as_ref() {
let Some(workspace) = shell.workspaces.space_for_handle(previous_handle) else {
return ControlFlow::Break(Err(OutputNoMode));
};
@ -341,17 +357,25 @@ fn render_input_order_internal<R: 'static>(
// bottom layer
for (layer, mut location) in layer_surfaces(output, Layer::Bottom, element_filter) {
location += current_offset.as_global();
callback(Stage::LayerSurface { layer, location })?;
callback(Stage::LayerSurface {
layer,
location,
workspace_idx: current.1,
})?;
}
}
if let Some((_, has_fullscreen, offset)) = previous.as_ref()
if let Some((_, idx, has_fullscreen, offset)) = previous.as_ref()
&& !has_fullscreen
{
// previous bottom layer
for (layer, mut location) in layer_surfaces(output, Layer::Bottom, element_filter) {
location += offset.as_global();
callback(Stage::LayerSurface { layer, location })?;
callback(Stage::LayerSurface {
layer,
location,
workspace_idx: **idx,
})?;
}
}
@ -359,17 +383,25 @@ fn render_input_order_internal<R: 'static>(
// background layer
for (layer, mut location) in layer_surfaces(output, Layer::Background, element_filter) {
location += current_offset.as_global();
callback(Stage::LayerSurface { layer, location })?;
callback(Stage::LayerSurface {
layer,
location,
workspace_idx: current.1,
})?;
}
}
if let Some((_, has_fullscreen, offset)) = previous.as_ref()
if let Some((_, idx, has_fullscreen, offset)) = previous.as_ref()
&& !has_fullscreen
{
// previous background layer
for (layer, mut location) in layer_surfaces(output, Layer::Background, element_filter) {
location += offset.as_global();
callback(Stage::LayerSurface { layer, location })?;
callback(Stage::LayerSurface {
layer,
location,
workspace_idx: **idx,
})?;
}
}

43
src/shell/focus/target.rs
View file

@ -29,8 +29,8 @@ use smithay::{
MotionEvent as PointerMotionEvent, PointerTarget, RelativeMotionEvent,
},
touch::{
DownEvent, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent, TouchTarget,
UpEvent,
DownEvent, FrameMarker, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent,
TouchTarget, UpEvent,
},
},
reexports::wayland_server::{
@ -498,39 +498,36 @@ impl PointerTarget<State> for PointerFocusTarget {
}
impl TouchTarget<State> for PointerFocusTarget {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent, seq: Serial) {
self.inner_touch_target().down(seat, data, event, seq);
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent) {
self.inner_touch_target().down(seat, data, event);
}
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent, seq: Serial) {
self.inner_touch_target().up(seat, data, event, seq);
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent) {
self.inner_touch_target().up(seat, data, event);
}
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent, seq: Serial) {
self.inner_touch_target().motion(seat, data, event, seq);
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent) {
self.inner_touch_target().motion(seat, data, event);
}
fn frame(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
self.inner_touch_target().frame(seat, data, seq);
fn frame(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
self.inner_touch_target().frame(seat, data, frame);
}
fn cancel(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
self.inner_touch_target().cancel(seat, data, seq);
fn cancel(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
self.inner_touch_target().cancel(seat, data, frame);
}
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent, seq: Serial) {
self.inner_touch_target().shape(seat, data, event, seq);
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent) {
self.inner_touch_target().shape(seat, data, event);
}
fn orientation(
&self,
seat: &Seat<State>,
data: &mut State,
event: &OrientationEvent,
seq: Serial,
) {
self.inner_touch_target()
.orientation(seat, data, event, seq);
fn orientation(&self, seat: &Seat<State>, data: &mut State, event: &OrientationEvent) {
self.inner_touch_target().orientation(seat, data, event);
}
fn last_frame(&self, seat: &Seat<State>, data: &mut State) -> Option<FrameMarker> {
self.inner_touch_target().last_frame(seat, data)
}
}

30
src/shell/grabs/delay.rs
View file

@ -202,19 +202,12 @@ impl<G: TouchGrab<State>> TouchGrab<State> for DelayGrab<G> {
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(<State as SeatHandler>::TouchFocus, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
handle.down(data, focus, event, seq);
handle.down(data, focus, event);
}
fn up(
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &UpEvent,
seq: Serial,
) {
handle.up(data, event, seq);
fn up(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, event: &UpEvent) {
handle.up(data, event);
if event.slot == TouchGrab::start_data(self).slot {
handle.unset_grab(self, data);
@ -227,9 +220,8 @@ impl<G: TouchGrab<State>> TouchGrab<State> for DelayGrab<G> {
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(<State as SeatHandler>::TouchFocus, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {
handle.motion(data, focus, event, seq);
handle.motion(data, focus, event);
let distance = self.start_data.distance(event.location);
if distance >= 1.
@ -245,12 +237,12 @@ impl<G: TouchGrab<State>> TouchGrab<State> for DelayGrab<G> {
}
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
handle.frame(data, seq)
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.frame(data)
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
handle.cancel(data, seq);
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.cancel(data);
handle.unset_grab(self, data);
}
@ -259,9 +251,8 @@ impl<G: TouchGrab<State>> TouchGrab<State> for DelayGrab<G> {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &ShapeEvent,
seq: Serial,
) {
handle.shape(data, event, seq)
handle.shape(data, event)
}
fn orientation(
@ -269,9 +260,8 @@ impl<G: TouchGrab<State>> TouchGrab<State> for DelayGrab<G> {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &OrientationEvent,
seq: Serial,
) {
handle.orientation(data, event, seq);
handle.orientation(data, event);
}
fn start_data(&self) -> &TouchGrabStartData<State> {

33
src/shell/grabs/menu/item.rs
View file

@ -1,10 +1,12 @@
use cosmic::{
iced::Element,
iced_core::{
Background, Border, Clipboard, Color, Event, Layout, Length, Rectangle,
Renderer as IcedRenderer, Shell, Size, layout, mouse, overlay,
renderer::{Quad, Style},
widget::{Id, Tree, Widget, tree},
iced::{
Alignment, Element,
core::{
Background, Border, Clipboard, Color, Event, Layout, Length, Rectangle,
Renderer as IcedRenderer, Shell, Size, layout, mouse, overlay,
renderer::{Quad, Style},
widget::{Id, Tree, Widget, tree},
},
},
widget::button::Catalog,
};
@ -73,11 +75,26 @@ where
viewport: &Rectangle,
) {
let widget_state = state.state.downcast_ref::<State>();
let styling = if widget_state.cursor_over {
let mut styling = if widget_state.cursor_over {
theme.hovered(true, false, &self.styling)
} else {
theme.active(true, false, &self.styling)
};
if matches!(self.styling, cosmic::theme::Button::MenuItem) {
match theme.list_item_position {
Some((Alignment::Start, _)) => {
styling.border_radius =
styling.border_radius.bottom(theme.cosmic().radius_0()[3]);
}
Some((Alignment::End, _)) => {
styling.border_radius = styling.border_radius.top(theme.cosmic().radius_0()[0]);
}
Some((Alignment::Center, _)) => {}
None => {
styling.border_radius = theme.cosmic().radius_0().into();
}
};
}
renderer.fill_quad(
Quad {
@ -85,7 +102,7 @@ where
bounds: layout.bounds(),
border: Border {
radius: styling.border_radius,
width: styling.border_width,
width: 0.,
color: styling.border_color,
},
shadow: Default::default(),

132
src/shell/grabs/menu/mod.rs
View file

@ -9,19 +9,18 @@ use std::{
use calloop::LoopHandle;
use cosmic::{
Apply as _, Task,
iced::{Alignment, Background},
iced_core::{Border, Length, Rectangle as IcedRectangle, alignment::Horizontal},
iced_widget::{self, Column, Row, text::Style as TextStyle},
iced::{
Alignment, Background,
core::{Border, Length, Rectangle as IcedRectangle, alignment::Horizontal},
widget::{self as iced_widget, Row, text::Style as TextStyle},
},
theme,
widget::{button, divider, icon::from_name, space, text},
widget::{button, divider, icon::from_name, menu::menu_column::MenuColumn, space, text},
};
use smithay::{
backend::{
input::{ButtonState, TouchSlot},
renderer::{
ImportMem, Renderer,
element::{AsRenderElements, memory::MemoryRenderBufferRenderElement},
},
renderer::ImportMem,
},
desktop::space::SpaceElement,
input::{
@ -43,10 +42,11 @@ use smithay::{
};
use crate::{
backend::render::element::AsGlowRenderer,
shell::{SeatExt, focus::target::PointerFocusTarget},
state::State,
utils::{
iced::{IcedElement, Program},
iced::{IcedElement, IcedRenderElement, Program},
prelude::*,
},
};
@ -65,29 +65,32 @@ pub struct MenuGrabState {
pub type SeatMenuGrabState = Mutex<Option<MenuGrabState>>;
impl MenuGrabState {
pub fn render<I, R>(&self, renderer: &mut R, output: &Output) -> Vec<I>
where
R: Renderer + ImportMem,
pub fn render<R>(
&self,
renderer: &mut R,
output: &Output,
push: &mut dyn FnMut(IcedRenderElement<R>),
) where
R: AsGlowRenderer + ImportMem,
R::TextureId: Send + Clone + 'static,
I: From<MemoryRenderBufferRenderElement<R>>,
{
let scale = output.current_scale().fractional_scale();
self.elements
.lock()
.unwrap()
.iter()
.flat_map(|elem| {
elem.iced.render_elements(
renderer,
elem.position
.to_local(output)
.as_logical()
.to_physical_precise_round(scale),
scale.into(),
1.0,
)
})
.collect()
for elem in self.elements.lock().unwrap().iter() {
elem.iced.push_render_elements(
renderer,
elem.position
.to_local(output)
.as_logical()
.to_physical_precise_round(scale),
scale.into(),
1.0,
elem.iced
.with_theme(|theme| theme.cosmic().radius_s())
.map(|x| x.round() as u8),
push,
None,
)
}
}
pub fn is_in_screen_space(&self) -> bool {
@ -276,11 +279,13 @@ impl Program for ContextMenu {
let mut elements = grab_state.elements.lock().unwrap();
let position = elements.last().unwrap().position;
let mut theme = state.common.theme.clone();
theme.transparent = theme.cosmic().frosted_system_interface;
let element = IcedElement::new(
ContextMenu::new(items),
Size::default(),
state.common.event_loop_handle.clone(),
state.common.theme.clone(),
theme,
);
let min_size = element.minimum_size();
@ -295,7 +300,7 @@ impl Program for ContextMenu {
Rectangle::new(
position
+ Point::from((
bounds.width.ceil() as i32,
bounds.width.floor() as i32,
bounds.y.ceil() as i32,
)),
min_size.as_global(),
@ -304,7 +309,7 @@ impl Program for ContextMenu {
Rectangle::new(
position
+ Point::from((
bounds.width.ceil() as i32,
bounds.width.floor() as i32,
bounds.y.ceil() as i32 + bounds.height.ceil() as i32
- min_size.h,
)),
@ -312,14 +317,15 @@ impl Program for ContextMenu {
),
// to the left -> down
Rectangle::new(
position + Point::from((-min_size.w, bounds.y.ceil() as i32)),
position
+ Point::from((-min_size.w + 1, bounds.y.ceil() as i32)),
min_size.as_global(),
),
// to the left -> up
Rectangle::new(
position
+ Point::from((
-min_size.w,
-min_size.w + 1,
bounds.y.ceil() as i32 + bounds.height.ceil() as i32
- min_size.h,
)),
@ -385,9 +391,11 @@ impl Program for ContextMenu {
_ => Length::Fill,
};
Column::with_children(self.items.iter().enumerate().map(|(idx, item)| {
MenuColumn::with_children(self.items.iter().enumerate().map(|(idx, item)| {
match item {
Item::Separator => divider::horizontal::light().into(),
Item::Separator => divider::horizontal::light()
.class(theme::Rule::Default)
.into(),
Item::Submenu { title, .. } => Row::with_children(vec![
space::horizontal().width(16).into(),
text::body(title).width(mode).into(),
@ -428,10 +436,11 @@ impl Program for ContextMenu {
.width(mode)
.class(if *disabled {
theme::Text::Custom(|theme| {
let mut color = theme.cosmic().background.component.on;
let mut color = theme.cosmic().background(false).component.on;
color.alpha *= 0.5;
TextStyle {
color: Some(color.into()),
..Default::default()
}
})
} else {
@ -446,10 +455,11 @@ impl Program for ContextMenu {
.align_x(Horizontal::Right)
.width(Length::Shrink)
.class(theme::Text::Custom(|theme| {
let mut color = theme.cosmic().background.component.on;
let mut color = theme.cosmic().background(false).component.on;
color.alpha *= 0.75;
TextStyle {
color: Some(color.into()),
..Default::default()
}
}))
.into(),
@ -474,7 +484,7 @@ impl Program for ContextMenu {
.padding(1)
.class(theme::Container::custom(|theme| {
let cosmic = theme.cosmic();
let component = &cosmic.background.component;
let component = &cosmic.background(theme.cosmic().frosted_windows).component;
iced_widget::container::Style {
snap: true,
icon_color: Some(cosmic.accent.base.into()),
@ -554,8 +564,11 @@ impl PointerGrab<State> for MenuGrab {
PointerTarget::motion(&element.iced, &self.seat, state, &new_event);
}
} else {
elements.iter_mut().for_each(|element| {
if element.pointer_entered {
elements
.iter_mut()
.filter(|element| element.pointer_entered)
.skip(1)
.for_each(|element| {
PointerTarget::leave(
&element.iced,
&self.seat,
@ -564,8 +577,7 @@ impl PointerGrab<State> for MenuGrab {
event.time,
);
element.pointer_entered = false;
}
})
})
}
}
handle.motion(state, None, event);
@ -718,7 +730,6 @@ impl TouchGrab<State> for MenuGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
{
let mut guard = self.elements.lock().unwrap();
@ -753,21 +764,15 @@ impl TouchGrab<State> for MenuGrab {
time: event.time,
};
if element.touch_entered.is_none() {
TouchTarget::down(&element.iced, &self.seat, data, &new_event, seq);
TouchTarget::down(&element.iced, &self.seat, data, &new_event);
element.touch_entered = Some(event.slot);
}
}
}
handle.down(data, None, event, seq);
handle.down(data, None, event);
}
fn up(
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &UpEvent,
seq: Serial,
) {
fn up(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, event: &UpEvent) {
{
let elements = self.elements.lock().unwrap();
for element in elements.iter().filter(|elem| {
@ -775,7 +780,7 @@ impl TouchGrab<State> for MenuGrab {
.as_ref()
.is_some_and(|slot| *slot == event.slot)
}) {
TouchTarget::up(&element.iced, &self.seat, data, event, seq);
TouchTarget::up(&element.iced, &self.seat, data, event);
}
}
handle.unset_grab(self, data);
@ -787,7 +792,6 @@ impl TouchGrab<State> for MenuGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {
{
let elements = self.elements.lock().unwrap();
@ -796,24 +800,24 @@ impl TouchGrab<State> for MenuGrab {
.as_ref()
.is_some_and(|slot| *slot == event.slot)
}) {
TouchTarget::motion(&element.iced, &self.seat, data, event, seq);
TouchTarget::motion(&element.iced, &self.seat, data, event);
}
}
handle.motion(data, None, event, seq);
handle.motion(data, None, event);
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
handle.frame(data, seq);
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.frame(data);
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
{
let mut elements = self.elements.lock().unwrap();
for element in elements.iter_mut() {
let _ = element.touch_entered.take();
}
}
handle.cancel(data, seq);
handle.cancel(data);
}
fn shape(
@ -821,9 +825,8 @@ impl TouchGrab<State> for MenuGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &smithay::input::touch::ShapeEvent,
seq: Serial,
) {
handle.shape(data, event, seq);
handle.shape(data, event);
}
fn orientation(
@ -831,9 +834,8 @@ impl TouchGrab<State> for MenuGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &smithay::input::touch::OrientationEvent,
seq: Serial,
) {
handle.orientation(data, event, seq);
handle.orientation(data, event);
}
fn start_data(&self) -> &TouchGrabStartData<State> {

88
src/shell/grabs/mod.rs
View file

@ -387,24 +387,17 @@ impl TouchGrab<State> for ResizeGrab {
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::down(grab, data, handle, focus, event, seq),
ResizeGrab::Tiling(grab) => TouchGrab::down(grab, data, handle, focus, event, seq),
ResizeGrab::Floating(grab) => TouchGrab::down(grab, data, handle, focus, event),
ResizeGrab::Tiling(grab) => TouchGrab::down(grab, data, handle, focus, event),
}
}
fn up(
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &UpEvent,
seq: Serial,
) {
fn up(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, event: &UpEvent) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::up(grab, data, handle, event, seq),
ResizeGrab::Tiling(grab) => TouchGrab::up(grab, data, handle, event, seq),
ResizeGrab::Floating(grab) => TouchGrab::up(grab, data, handle, event),
ResizeGrab::Tiling(grab) => TouchGrab::up(grab, data, handle, event),
}
}
@ -414,25 +407,24 @@ impl TouchGrab<State> for ResizeGrab {
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::motion(grab, data, handle, focus, event, seq),
ResizeGrab::Tiling(grab) => TouchGrab::motion(grab, data, handle, focus, event, seq),
ResizeGrab::Floating(grab) => TouchGrab::motion(grab, data, handle, focus, event),
ResizeGrab::Tiling(grab) => TouchGrab::motion(grab, data, handle, focus, event),
}
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::frame(grab, data, handle, seq),
ResizeGrab::Tiling(grab) => TouchGrab::frame(grab, data, handle, seq),
ResizeGrab::Floating(grab) => TouchGrab::frame(grab, data, handle),
ResizeGrab::Tiling(grab) => TouchGrab::frame(grab, data, handle),
}
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::cancel(grab, data, handle, seq),
ResizeGrab::Tiling(grab) => TouchGrab::cancel(grab, data, handle, seq),
ResizeGrab::Floating(grab) => TouchGrab::cancel(grab, data, handle),
ResizeGrab::Tiling(grab) => TouchGrab::cancel(grab, data, handle),
}
}
@ -441,11 +433,10 @@ impl TouchGrab<State> for ResizeGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &ShapeEvent,
seq: Serial,
) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::shape(grab, data, handle, event, seq),
ResizeGrab::Tiling(grab) => TouchGrab::shape(grab, data, handle, event, seq),
ResizeGrab::Floating(grab) => TouchGrab::shape(grab, data, handle, event),
ResizeGrab::Tiling(grab) => TouchGrab::shape(grab, data, handle, event),
}
}
@ -454,11 +445,10 @@ impl TouchGrab<State> for ResizeGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &OrientationEvent,
seq: Serial,
) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::orientation(grab, data, handle, event, seq),
ResizeGrab::Tiling(grab) => TouchGrab::orientation(grab, data, handle, event, seq),
ResizeGrab::Floating(grab) => TouchGrab::orientation(grab, data, handle, event),
ResizeGrab::Tiling(grab) => TouchGrab::orientation(grab, data, handle, event),
}
}
@ -729,24 +719,17 @@ impl TouchGrab<State> for MoveGrab {
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
match self {
MoveGrab::Move(grab) => TouchGrab::down(grab, data, handle, focus, event, seq),
MoveGrab::Delayed(grab) => TouchGrab::down(grab, data, handle, focus, event, seq),
MoveGrab::Move(grab) => TouchGrab::down(grab, data, handle, focus, event),
MoveGrab::Delayed(grab) => TouchGrab::down(grab, data, handle, focus, event),
}
}
fn up(
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &UpEvent,
seq: Serial,
) {
fn up(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, event: &UpEvent) {
match self {
MoveGrab::Move(grab) => TouchGrab::up(grab, data, handle, event, seq),
MoveGrab::Delayed(grab) => TouchGrab::up(grab, data, handle, event, seq),
MoveGrab::Move(grab) => TouchGrab::up(grab, data, handle, event),
MoveGrab::Delayed(grab) => TouchGrab::up(grab, data, handle, event),
}
}
@ -756,25 +739,24 @@ impl TouchGrab<State> for MoveGrab {
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {
match self {
MoveGrab::Move(grab) => TouchGrab::motion(grab, data, handle, focus, event, seq),
MoveGrab::Delayed(grab) => TouchGrab::motion(grab, data, handle, focus, event, seq),
MoveGrab::Move(grab) => TouchGrab::motion(grab, data, handle, focus, event),
MoveGrab::Delayed(grab) => TouchGrab::motion(grab, data, handle, focus, event),
}
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
match self {
MoveGrab::Move(grab) => TouchGrab::frame(grab, data, handle, seq),
MoveGrab::Delayed(grab) => TouchGrab::frame(grab, data, handle, seq),
MoveGrab::Move(grab) => TouchGrab::frame(grab, data, handle),
MoveGrab::Delayed(grab) => TouchGrab::frame(grab, data, handle),
}
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
match self {
MoveGrab::Move(grab) => TouchGrab::cancel(grab, data, handle, seq),
MoveGrab::Delayed(grab) => TouchGrab::cancel(grab, data, handle, seq),
MoveGrab::Move(grab) => TouchGrab::cancel(grab, data, handle),
MoveGrab::Delayed(grab) => TouchGrab::cancel(grab, data, handle),
}
}
@ -783,11 +765,10 @@ impl TouchGrab<State> for MoveGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &ShapeEvent,
seq: Serial,
) {
match self {
MoveGrab::Move(grab) => TouchGrab::shape(grab, data, handle, event, seq),
MoveGrab::Delayed(grab) => TouchGrab::shape(grab, data, handle, event, seq),
MoveGrab::Move(grab) => TouchGrab::shape(grab, data, handle, event),
MoveGrab::Delayed(grab) => TouchGrab::shape(grab, data, handle, event),
}
}
@ -796,11 +777,10 @@ impl TouchGrab<State> for MoveGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &OrientationEvent,
seq: Serial,
) {
match self {
MoveGrab::Move(grab) => TouchGrab::orientation(grab, data, handle, event, seq),
MoveGrab::Delayed(grab) => TouchGrab::orientation(grab, data, handle, event, seq),
MoveGrab::Move(grab) => TouchGrab::orientation(grab, data, handle, event),
MoveGrab::Delayed(grab) => TouchGrab::orientation(grab, data, handle, event),
}
}

279
src/shell/grabs/moving.rs
View file

@ -6,10 +6,7 @@ use crate::{
},
shell::{
CosmicMapped, CosmicSurface, Direction, ManagedLayer,
element::{
CosmicMappedRenderElement,
stack_hover::{StackHover, stack_hover},
},
element::{CosmicMappedRenderElement, stack_hover::StackHover},
focus::target::{KeyboardFocusTarget, PointerFocusTarget},
layout::floating::TiledCorners,
},
@ -19,12 +16,14 @@ use crate::{
use calloop::LoopHandle;
use cosmic::theme::CosmicTheme;
use smallvec::SmallVec;
use smithay::{
backend::{
drm::DrmNode,
input::ButtonState,
renderer::{
ImportAll, ImportMem, Renderer,
element::{AsRenderElements, RenderElement, utils::RescaleRenderElement},
ImportAll, ImportMem,
element::{RenderElement, utils::RescaleRenderElement},
},
},
desktop::{WindowSurfaceType, layer_map_for_output, space::SpaceElement},
@ -40,7 +39,7 @@ use smithay::{
touch::{self, GrabStartData as TouchGrabStartData, TouchGrab, TouchInnerHandle},
},
output::Output,
utils::{IsAlive, Logical, Point, Rectangle, SERIAL_COUNTER, Scale, Serial},
utils::{IsAlive, Logical, Point, Rectangle, SERIAL_COUNTER, Scale},
};
use std::{
collections::HashSet,
@ -68,12 +67,17 @@ pub struct MoveGrabState {
impl MoveGrabState {
#[profiling::function]
pub fn render<I, R>(&self, renderer: &mut R, output: &Output, theme: &CosmicTheme) -> Vec<I>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
pub fn render<R>(
&self,
renderer: &mut R,
output: &Output,
theme: &CosmicTheme,
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicMappedRenderElement<R>),
) where
R: AsGlowRenderer + ImportAll + ImportMem,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
I: From<CosmicMappedRenderElement<R>>,
{
let scale = if self.previous == ManagedLayer::Tiling {
0.6 + ((1.0
@ -98,7 +102,7 @@ impl MoveGrabState {
.intersection(window_geo)
.is_none()
{
return Vec::new();
return;
}
let output_scale: Scale<f64> = output.current_scale().fractional_scale().into();
@ -108,13 +112,33 @@ impl MoveGrabState {
+ self.window_offset
- scaling_offset;
for (indicator, location) in self.stacking_indicator.iter() {
indicator.push_render_elements(
renderer,
location.to_physical_precise_round(output_scale),
output_scale,
1.0,
&mut |elem| push(elem.into()),
None,
);
}
self.window.push_popup_render_elements::<R>(
renderer,
(render_location - self.window.geometry().loc).to_physical_precise_round(output_scale),
output_scale,
alpha,
scanout_node,
push,
);
let active_window_hint = crate::theme::active_window_hint(theme);
let radius = self
.element()
.corner_radius(window_geo.size, self.indicator_thickness);
let focus_element = if self.indicator_thickness > 0 {
Some(CosmicMappedRenderElement::from(
if self.indicator_thickness > 0 {
push(
IndicatorShader::focus_element(
renderer,
Key::Window(Usage::MoveGrabIndicator, self.window.key()),
@ -137,12 +161,57 @@ impl MoveGrabState {
active_window_hint.green,
active_window_hint.blue,
],
),
))
} else {
None
)
.into(),
)
}
let map_window_element = |elem| match elem {
CosmicMappedRenderElement::Stack(stack) => {
CosmicMappedRenderElement::GrabbedStack(RescaleRenderElement::from_element(
stack,
render_location
.to_physical_precise_round(output.current_scale().fractional_scale()),
scale,
))
}
CosmicMappedRenderElement::Window(window) => {
CosmicMappedRenderElement::GrabbedWindow(RescaleRenderElement::from_element(
window,
render_location
.to_physical_precise_round(output.current_scale().fractional_scale()),
scale,
))
}
x => x,
};
let mut lower_elements = SmallVec::<[CosmicMappedRenderElement<R>; 4]>::new_const();
self.window.push_render_elements(
renderer,
(render_location - self.window.geometry().loc).to_physical_precise_round(output_scale),
None,
output_scale,
alpha,
Some(false),
scanout_node,
&mut |elem| push(map_window_element(elem)),
&mut |elem| lower_elements.push(map_window_element(elem)),
);
if let Some(shadow_element) = self.window.shadow_render_element(
renderer,
(render_location - self.window.geometry().loc).to_physical_precise_round(output_scale),
None,
output_scale,
scale,
alpha,
) {
push(shadow_element);
}
for elem in lower_elements.into_iter() {
push(elem);
}
let non_exclusive_geometry = {
let layers = layer_map_for_output(output);
layers.non_exclusive_zone()
@ -151,117 +220,46 @@ impl MoveGrabState {
let gaps = (theme.gaps.0 as i32, theme.gaps.1 as i32);
let thickness = self.indicator_thickness.max(1);
let snapping_indicator = match &self.snapping_zone {
Some(t) if &self.cursor_output == output => {
let base_color = theme.palette.neutral_9;
let overlay_geometry = t.overlay_geometry(non_exclusive_geometry, gaps);
vec![
CosmicMappedRenderElement::from(IndicatorShader::element(
renderer,
Key::Window(Usage::SnappingIndicator, self.window.key()),
overlay_geometry,
thickness,
[
theme.radius_s()[0] as u8,
theme.radius_s()[1] as u8,
theme.radius_s()[2] as u8,
theme.radius_s()[3] as u8,
],
1.0,
output_scale.x,
[
active_window_hint.red,
active_window_hint.green,
active_window_hint.blue,
],
)),
CosmicMappedRenderElement::from(BackdropShader::element(
renderer,
Key::Window(Usage::SnappingIndicator, self.window.key()),
t.overlay_geometry(non_exclusive_geometry, gaps),
theme.radius_s()[0], // TODO: Fix once shaders support 4 corner radii customization
0.4,
[base_color.red, base_color.green, base_color.blue],
)),
]
}
_ => vec![],
};
if let Some(t) = &self.snapping_zone
&& &self.cursor_output == output
{
let base_color = theme.palette.neutral_9;
let overlay_geometry = t.overlay_geometry(non_exclusive_geometry, gaps);
let w_elements = self
.window
.render_elements::<R, CosmicMappedRenderElement<R>>(
renderer,
(render_location - self.window.geometry().loc)
.to_physical_precise_round(output_scale),
None,
output_scale,
alpha,
Some(false),
);
let p_elements = self
.window
.popup_render_elements::<R, CosmicMappedRenderElement<R>>(
renderer,
(render_location - self.window.geometry().loc)
.to_physical_precise_round(output_scale),
output_scale,
alpha,
);
let shadow_element = self.window.shadow_render_element(
renderer,
(render_location - self.window.geometry().loc).to_physical_precise_round(output_scale),
None,
output_scale,
scale,
alpha,
);
self.stacking_indicator
.iter()
.flat_map(|(indicator, location)| {
indicator.render_elements(
push(
IndicatorShader::element(
renderer,
location.to_physical_precise_round(output_scale),
output_scale,
Key::Window(Usage::SnappingIndicator, self.window.key()),
overlay_geometry,
thickness,
[
theme.radius_s()[0] as u8,
theme.radius_s()[1] as u8,
theme.radius_s()[2] as u8,
theme.radius_s()[3] as u8,
],
1.0,
output_scale.x,
[
active_window_hint.red,
active_window_hint.green,
active_window_hint.blue,
],
)
})
.chain(p_elements)
.chain(focus_element)
.chain(
w_elements
.into_iter()
.chain(shadow_element)
.map(|elem| match elem {
CosmicMappedRenderElement::Stack(stack) => {
CosmicMappedRenderElement::GrabbedStack(
RescaleRenderElement::from_element(
stack,
render_location.to_physical_precise_round(
output.current_scale().fractional_scale(),
),
scale,
),
)
}
CosmicMappedRenderElement::Window(window) => {
CosmicMappedRenderElement::GrabbedWindow(
RescaleRenderElement::from_element(
window,
render_location.to_physical_precise_round(
output.current_scale().fractional_scale(),
),
scale,
),
)
}
x => x,
}),
.into(),
);
push(
BackdropShader::element(
renderer,
Key::Window(Usage::SnappingIndicator, self.window.key()),
t.overlay_geometry(non_exclusive_geometry, gaps),
theme.radius_s()[0], // TODO: Fix once shaders support 4 corner radii customization
0.4,
[base_color.red, base_color.green, base_color.blue],
)
.into(),
)
.chain(snapping_indicator)
.map(I::from)
.collect()
}
}
pub fn element(&self) -> CosmicMapped {
@ -441,7 +439,7 @@ impl MoveGrab {
if let Some(indicator) =
grab_state.stacking_indicator.as_ref().map(|x| &x.0)
{
indicator.output_enter(output, overlap);
indicator.output_enter(output);
}
}
} else if self.window_outputs.remove(output) {
@ -455,16 +453,14 @@ impl MoveGrab {
let indicator_location = shell.stacking_indicator(&current_output, self.previous);
if indicator_location.is_some() != grab_state.stacking_indicator.is_some() {
grab_state.stacking_indicator = indicator_location.map(|geo| {
let element = stack_hover(
let size = geo.size.as_logical();
let element = StackHover::new(
state.common.event_loop_handle.clone(),
geo.size.as_logical(),
size,
state.common.theme.clone(),
);
for output in &self.window_outputs {
element.output_enter(
output,
Rectangle::from_size(output.geometry().size.as_logical()),
);
element.output_enter(output);
}
(element, geo.loc.as_logical())
});
@ -652,9 +648,8 @@ impl TouchGrab<State> for MoveGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &touch::DownEvent,
seq: Serial,
) {
handle.down(data, None, event, seq)
handle.down(data, None, event)
}
fn up(
@ -662,13 +657,12 @@ impl TouchGrab<State> for MoveGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &touch::UpEvent,
seq: Serial,
) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot {
handle.unset_grab(self, data);
}
handle.up(data, event, seq);
handle.up(data, event);
}
fn motion(
@ -677,20 +671,19 @@ impl TouchGrab<State> for MoveGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &touch::MotionEvent,
seq: Serial,
) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot {
self.update_location(data, event.location);
}
handle.motion(data, None, event, seq);
handle.motion(data, None, event);
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
handle.frame(data, seq)
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.frame(data)
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, _seq: Serial) {
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.unset_grab(self, data);
}
@ -699,9 +692,8 @@ impl TouchGrab<State> for MoveGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &touch::ShapeEvent,
seq: Serial,
) {
handle.shape(data, event, seq)
handle.shape(data, event)
}
fn orientation(
@ -709,9 +701,8 @@ impl TouchGrab<State> for MoveGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &touch::OrientationEvent,
seq: Serial,
) {
handle.orientation(data, event, seq)
handle.orientation(data, event)
}
fn start_data(&self) -> &TouchGrabStartData<State> {

30
src/shell/layout/floating/grabs/resize.rs
View file

@ -29,7 +29,7 @@ use smithay::{
},
},
output::Output,
utils::{IsAlive, Logical, Point, Rectangle, Serial, Size},
utils::{IsAlive, Logical, Point, Rectangle, Size},
};
use tracing::debug;
@ -330,23 +330,16 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
handle.down(data, None, event, seq)
handle.down(data, None, event)
}
fn up(
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &UpEvent,
seq: Serial,
) {
fn up(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, event: &UpEvent) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot {
handle.unset_grab(self, data);
}
handle.up(data, event, seq);
handle.up(data, event);
}
fn motion(
@ -355,7 +348,6 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot
&& self.update_location(event.location.as_global())
@ -363,14 +355,14 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
handle.unset_grab(self, data);
}
handle.motion(data, None, event, seq);
handle.motion(data, None, event);
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
handle.frame(data, seq)
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.frame(data)
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, _seq: Serial) {
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.unset_grab(self, data);
}
@ -379,9 +371,8 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &ShapeEvent,
seq: Serial,
) {
handle.shape(data, event, seq)
handle.shape(data, event)
}
fn orientation(
@ -389,9 +380,8 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &OrientationEvent,
seq: Serial,
) {
handle.orientation(data, event, seq)
handle.orientation(data, event)
}
fn start_data(&self) -> &TouchGrabStartData<State> {

281
src/shell/layout/floating/mod.rs
View file

@ -9,10 +9,14 @@ use std::{
use cosmic_comp_config::AppearanceConfig;
use cosmic_settings_config::shortcuts::action::ResizeDirection;
use keyframe::{ease, functions::EaseInOutCubic};
use smallvec::SmallVec;
use smithay::{
backend::renderer::element::{
AsRenderElements, RenderElement,
utils::{Relocate, RelocateRenderElement, RescaleRenderElement},
backend::{
drm::DrmNode,
renderer::element::{
RenderElement,
utils::{Relocate, RelocateRenderElement, RescaleRenderElement},
},
},
desktop::{PopupKind, Space, WindowSurfaceType, layer_map_for_output, space::SpaceElement},
input::Seat,
@ -1439,8 +1443,9 @@ impl FloatingLayout {
&self,
renderer: &mut R,
alpha: f32,
) -> Vec<CosmicMappedRenderElement<R>>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicMappedRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
@ -1450,8 +1455,6 @@ impl FloatingLayout {
let output = self.space.outputs().next().unwrap();
let output_scale = output.current_scale().fractional_scale();
let mut elements = Vec::default();
for elem in self
.animations
.iter()
@ -1466,19 +1469,17 @@ impl FloatingLayout {
.unwrap_or_else(|| (self.space.element_geometry(elem).unwrap().as_local(), alpha));
let render_location = geometry.loc - elem.geometry().loc.as_local();
elements.extend(
elem.popup_render_elements(
renderer,
render_location
.as_logical()
.to_physical_precise_round(output_scale),
output_scale.into(),
alpha,
),
elem.push_popup_render_elements(
renderer,
render_location
.as_logical()
.to_physical_precise_round(output_scale),
output_scale.into(),
alpha,
scanout_node,
push,
);
}
elements
}
#[profiling::function]
@ -1490,8 +1491,9 @@ impl FloatingLayout {
indicator_thickness: u8,
alpha: f32,
theme: &cosmic::theme::CosmicTheme,
) -> Vec<CosmicMappedRenderElement<R>>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicMappedRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
@ -1504,8 +1506,7 @@ impl FloatingLayout {
layers.non_exclusive_zone()
};
let output_scale = output.current_scale().fractional_scale();
let mut elements = Vec::default();
let mut lower_elements = SmallVec::<[_; 4]>::new_const();
for elem in self
.animations
@ -1519,32 +1520,52 @@ impl FloatingLayout {
.get(elem)
.map(|anim| (*anim.previous_geometry(), alpha * anim.alpha()))
.unwrap_or_else(|| (self.space.element_geometry(elem).unwrap().as_local(), alpha));
let render_location = geometry.loc - elem.geometry().loc.as_local();
let mut window_elements = elem.render_elements(
renderer,
render_location
.as_logical()
.to_physical_precise_round(output_scale),
None,
output_scale.into(),
alpha,
None,
);
window_elements.extend(
elem.shadow_render_element(
renderer,
render_location
.as_logical()
.to_physical_precise_round(output_scale),
None,
output_scale.into(),
1.,
alpha,
),
);
if let Some(anim) = self.animations.get(elem) {
if focused == Some(elem) && !elem.is_maximized(false) {
let active_window_hint = crate::theme::active_window_hint(theme);
let radius = elem.corner_radius(geometry.size.as_logical(), indicator_thickness);
if let Some((mode, resize)) = resize_indicator.as_mut() {
let mut resize_geometry = geometry;
resize_geometry.loc -= (18, 18).into();
resize_geometry.size += (36, 36).into();
resize.resize(resize_geometry.size.as_logical());
resize.output_enter(output);
resize.push_render_elements(
renderer,
resize_geometry
.loc
.as_logical()
.to_physical_precise_round(output_scale),
output_scale.into(),
alpha * mode.alpha().unwrap_or(1.0),
&mut |elem| push(CosmicMappedRenderElement::Window(elem.into())),
None,
);
}
if indicator_thickness > 0 {
let element = IndicatorShader::focus_element(
renderer,
Key::Window(Usage::FocusIndicator, elem.key()),
geometry,
indicator_thickness,
radius,
alpha,
output_scale,
[
active_window_hint.red,
active_window_hint.green,
active_window_hint.blue,
],
);
push(element.into());
}
}
let maybe_map = if let Some(anim) = self.animations.get(elem) {
let original_geo = anim.previous_geometry();
geometry = anim.geometry(
output_geometry,
@ -1562,103 +1583,89 @@ impl FloatingLayout {
y: geometry.size.h as f64 / buffer_size.h as f64,
};
window_elements = window_elements
.into_iter()
.map(|element| match element {
CosmicMappedRenderElement::Stack(elem) => {
CosmicMappedRenderElement::MovingStack({
let rescaled = RescaleRenderElement::from_element(
elem,
original_geo
.loc
.as_logical()
.to_physical_precise_round(output_scale),
scale,
);
Some(move |element| match element {
CosmicMappedRenderElement::Stack(elem) => {
CosmicMappedRenderElement::MovingStack({
let rescaled = RescaleRenderElement::from_element(
elem,
original_geo
.loc
.as_logical()
.to_physical_precise_round(output_scale),
scale,
);
RelocateRenderElement::from_element(
rescaled,
(geometry.loc - original_geo.loc)
.as_logical()
.to_physical_precise_round(output_scale),
Relocate::Relative,
)
})
}
CosmicMappedRenderElement::Window(elem) => {
CosmicMappedRenderElement::MovingWindow({
let rescaled = RescaleRenderElement::from_element(
elem,
original_geo
.loc
.as_logical()
.to_physical_precise_round(output_scale),
scale,
);
RelocateRenderElement::from_element(
rescaled,
(geometry.loc - original_geo.loc)
.as_logical()
.to_physical_precise_round(output_scale),
Relocate::Relative,
)
})
}
CosmicMappedRenderElement::Window(elem) => {
CosmicMappedRenderElement::MovingWindow({
let rescaled = RescaleRenderElement::from_element(
elem,
original_geo
.loc
.as_logical()
.to_physical_precise_round(output_scale),
scale,
);
RelocateRenderElement::from_element(
rescaled,
(geometry.loc - original_geo.loc)
.as_logical()
.to_physical_precise_round(output_scale),
Relocate::Relative,
)
})
}
x => x,
})
.collect();
}
if focused == Some(elem) && !elem.is_maximized(false) {
if let Some((mode, resize)) = resize_indicator.as_mut() {
let mut resize_geometry = geometry;
resize_geometry.loc -= (18, 18).into();
resize_geometry.size += (36, 36).into();
resize.resize(resize_geometry.size.as_logical());
resize.output_enter(output, Rectangle::default() /* unused */);
window_elements = resize
.render_elements::<CosmicWindowRenderElement<R>>(
renderer,
resize_geometry
.loc
.as_logical()
.to_physical_precise_round(output_scale),
output_scale.into(),
alpha * mode.alpha().unwrap_or(1.0),
)
.into_iter()
.map(CosmicMappedRenderElement::Window)
.chain(window_elements.into_iter())
.collect();
RelocateRenderElement::from_element(
rescaled,
(geometry.loc - original_geo.loc)
.as_logical()
.to_physical_precise_round(output_scale),
Relocate::Relative,
)
})
}
x => x,
})
} else {
None
};
let map_anim = |elem| {
if let Some(map) = maybe_map {
map(elem)
} else {
elem
}
};
let active_window_hint = crate::theme::active_window_hint(theme);
let radius = elem.corner_radius(geometry.size.as_logical(), indicator_thickness);
if indicator_thickness > 0 {
let element = IndicatorShader::focus_element(
renderer,
Key::Window(Usage::FocusIndicator, elem.key()),
geometry,
indicator_thickness,
radius,
alpha,
output_scale,
[
active_window_hint.red,
active_window_hint.green,
active_window_hint.blue,
],
);
window_elements.insert(0, element.into());
}
elem.push_render_elements(
renderer,
render_location
.as_logical()
.to_physical_precise_round(output_scale),
None,
output_scale.into(),
alpha,
None,
scanout_node,
&mut |elem| push(map_anim(elem)),
&mut |elem| lower_elements.push(map_anim(elem)),
);
if let Some(shadow_element) = elem.shadow_render_element(
renderer,
render_location
.as_logical()
.to_physical_precise_round(output_scale),
None,
output_scale.into(),
1.,
alpha,
) {
push(map_anim(shadow_element));
}
for elem in lower_elements.drain(..) {
push(elem);
}
elements.extend(window_elements);
}
elements
}
pub fn snap_to_corner(&self, mapped: &CosmicMapped, corners: &TiledCorners) {

2
src/shell/layout/mod.rs
View file

@ -32,7 +32,7 @@ pub fn is_dialog(window: &CosmicSurface) -> bool {
}
WindowSurface::X11(surface) => {
if surface.is_override_redirect()
|| surface.is_popup()
|| surface.is_modal()
|| !matches!(
surface.window_type(),
None | Some(WmWindowType::Normal) | Some(WmWindowType::Utility)

64
src/shell/layout/tiling/grabs/resize.rs
View file

@ -22,12 +22,13 @@ use smithay::{
PointerTarget, RelativeMotionEvent,
},
touch::{
DownEvent, GrabStartData as TouchGrabStartData, MotionEvent as TouchMotionEvent,
OrientationEvent, ShapeEvent, TouchGrab, TouchInnerHandle, TouchTarget, UpEvent,
DownEvent, FrameMarker, GrabStartData as TouchGrabStartData,
MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent, TouchGrab,
TouchInnerHandle, TouchTarget, UpEvent,
},
},
output::WeakOutput,
utils::{IsAlive, Logical, Point, Serial},
utils::{IsAlive, Logical, Point},
};
use super::super::{Data, TilingLayout};
@ -126,7 +127,7 @@ impl PointerTarget<State> for ResizeForkTarget {
}
impl TouchTarget<State> for ResizeForkTarget {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent, _seq: Serial) {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent) {
let seat = seat.clone();
let node = self.node.clone();
let output = self.output.clone();
@ -157,25 +158,14 @@ impl TouchTarget<State> for ResizeForkTarget {
});
}
fn up(&self, _seat: &Seat<State>, _data: &mut State, _event: &UpEvent, _seq: Serial) {}
fn motion(
&self,
_seat: &Seat<State>,
_data: &mut State,
_event: &TouchMotionEvent,
_seq: Serial,
) {
}
fn frame(&self, _seat: &Seat<State>, _data: &mut State, _seq: Serial) {}
fn cancel(&self, _seat: &Seat<State>, _data: &mut State, _seq: Serial) {}
fn shape(&self, _seat: &Seat<State>, _data: &mut State, _event: &ShapeEvent, _seq: Serial) {}
fn orientation(
&self,
_seat: &Seat<State>,
_data: &mut State,
_event: &OrientationEvent,
_seq: Serial,
) {
fn up(&self, _seat: &Seat<State>, _data: &mut State, _event: &UpEvent) {}
fn motion(&self, _seat: &Seat<State>, _data: &mut State, _event: &TouchMotionEvent) {}
fn frame(&self, _seat: &Seat<State>, _data: &mut State, _frame: FrameMarker) {}
fn cancel(&self, _seat: &Seat<State>, _data: &mut State, _frame: FrameMarker) {}
fn shape(&self, _seat: &Seat<State>, _data: &mut State, _event: &ShapeEvent) {}
fn orientation(&self, _seat: &Seat<State>, _data: &mut State, _event: &OrientationEvent) {}
fn last_frame(&self, _seat: &Seat<State>, _data: &mut State) -> Option<FrameMarker> {
None
}
}
@ -508,23 +498,16 @@ impl TouchGrab<State> for ResizeForkGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
handle.down(data, None, event, seq)
handle.down(data, None, event)
}
fn up(
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &UpEvent,
seq: Serial,
) {
fn up(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, event: &UpEvent) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot {
handle.unset_grab(self, data);
}
handle.up(data, event, seq);
handle.up(data, event);
}
fn motion(
@ -533,7 +516,6 @@ impl TouchGrab<State> for ResizeForkGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot
&& self.update_location(data, event.location, false)
@ -541,14 +523,14 @@ impl TouchGrab<State> for ResizeForkGrab {
handle.unset_grab(self, data);
}
handle.motion(data, None, event, seq);
handle.motion(data, None, event);
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
handle.frame(data, seq)
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.frame(data)
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, _seq: Serial) {
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.unset_grab(self, data);
}
@ -557,9 +539,8 @@ impl TouchGrab<State> for ResizeForkGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &ShapeEvent,
seq: Serial,
) {
handle.shape(data, event, seq)
handle.shape(data, event)
}
fn start_data(&self) -> &TouchGrabStartData<State> {
@ -574,9 +555,8 @@ impl TouchGrab<State> for ResizeForkGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &OrientationEvent,
seq: Serial,
) {
handle.orientation(data, event, seq)
handle.orientation(data, event)
}
fn unset(&mut self, data: &mut State) {

596
src/shell/layout/tiling/mod.rs
View file

@ -6,8 +6,7 @@ use crate::{
element::AsGlowRenderer,
},
shell::{
CosmicSurface, Direction, FocusResult, MoveResult, OutputNotMapped, OverviewMode,
ResizeMode, Trigger,
CosmicSurface, Direction, FocusResult, MoveResult, OverviewMode, ResizeMode, Trigger,
element::{
CosmicMapped, CosmicMappedRenderElement, CosmicStack, CosmicWindow,
resize_indicator::ResizeIndicator,
@ -45,16 +44,20 @@ use keyframe::{
ease,
functions::{EaseInOutCubic, Linear},
};
use smallvec::SmallVec;
use smithay::{
backend::renderer::{
element::{
AsRenderElements, Id, RenderElement,
utils::{
ConstrainAlign, ConstrainScaleBehavior, RescaleRenderElement,
constrain_render_elements,
backend::{
drm::DrmNode,
renderer::{
element::{
Id, RenderElement,
utils::{
ConstrainAlign, ConstrainScaleBehavior, RescaleRenderElement,
constrain_render_elements,
},
},
glow::GlowRenderer,
},
glow::GlowRenderer,
},
desktop::{PopupKind, WindowSurfaceType, layer_map_for_output, space::SpaceElement},
input::Seat,
@ -1874,8 +1877,8 @@ impl TilingLayout {
if let Some(id) = id {
return match tree.get(&id).unwrap().data() {
Data::Mapped { mapped, .. } => {
if mapped.is_stack() {
mapped.stack_ref().unwrap().focus_stack();
if let Some(stack) = mapped.stack_ref() {
stack.focus_stack();
}
FocusResult::Some(mapped.clone().into())
}
@ -1983,11 +1986,11 @@ impl TilingLayout {
}))
}
Data::Mapped { mapped, .. } => {
if mapped.is_stack()
if let Some(stack) = mapped.stack_ref()
&& desc.stack_window.is_none()
&& replacement_id == &desc.node
{
mapped.stack_ref().unwrap().focus_stack();
stack.focus_stack();
}
FocusResult::Some(KeyboardFocusTarget::Element(mapped.clone()))
}
@ -2059,7 +2062,7 @@ impl TilingLayout {
});
}
Data::Mapped { mapped, .. } => {
if mapped.is_stack()
if let Some(stack) = mapped.stack_ref()
&& swap_desc
.as_ref()
.map(|desc| {
@ -2068,7 +2071,7 @@ impl TilingLayout {
})
.unwrap_or(false)
{
mapped.stack_ref().unwrap().focus_stack();
stack.focus_stack();
}
return FocusResult::Some(mapped.clone().into());
}
@ -3421,8 +3424,8 @@ impl TilingLayout {
None,
None,
self.theme.cosmic(),
)
.0;
&mut |_| {},
);
let mut result = None;
let mut lookup = Some(root.clone());
@ -4007,8 +4010,9 @@ impl TilingLayout {
resize_indicator: Option<(ResizeMode, ResizeIndicator)>,
indicator_thickness: u8,
theme: &cosmic::theme::CosmicTheme,
) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicMappedRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
@ -4048,8 +4052,6 @@ impl TilingLayout {
};
let draw_groups = overview.0.alpha();
let mut elements = Vec::default();
let is_overview = !matches!(overview.0, OverviewMode::None);
let is_mouse_tiling = (matches!(overview.0.trigger(), Some(Trigger::Pointer(_))))
.then(|| self.last_overview_hover.as_ref().map(|(_, zone)| zone));
@ -4061,7 +4063,7 @@ impl TilingLayout {
// all gone windows and fade them out
let old_geometries = if let Some(reference_tree) = reference_tree.as_ref() {
let (geometries, _) = if let Some(transition) = draw_groups {
let geometries = if let Some(transition) = draw_groups {
Some(geometries_for_groupview(
reference_tree,
&mut *renderer,
@ -4076,14 +4078,14 @@ impl TilingLayout {
swap_desc.clone(),
overview.1.as_ref().and_then(|(_, tree)| *tree),
theme,
&mut |_elem| {},
))
} else {
None
}
.unzip();
};
// all old windows we want to fade out
elements.extend(render_old_tree_windows(
render_old_tree_windows(
reference_tree,
target_tree,
renderer,
@ -4093,14 +4095,17 @@ impl TilingLayout {
indicator_thickness,
swap_desc.is_some(),
theme,
));
scanout_node,
push,
);
geometries
} else {
None
};
let (geometries, group_elements) = if let Some(transition) = draw_groups {
let mut group_elements = SmallVec::<[_; 4]>::new_const();
let geometries = if let Some(transition) = draw_groups {
Some(geometries_for_groupview(
target_tree,
&mut *renderer,
@ -4114,14 +4119,14 @@ impl TilingLayout {
swap_desc.clone(),
overview.1.as_ref().and_then(|(_, tree)| *tree),
theme,
&mut |elem| group_elements.push(elem),
))
} else {
None
}
.unzip();
};
// all alive windows
elements.extend(render_new_tree_windows(
render_new_tree_windows(
target_tree,
reference_tree,
renderer,
@ -4149,14 +4154,14 @@ impl TilingLayout {
&self.swapping_stack_surface_id,
&self.backdrop_id,
theme,
));
scanout_node,
push,
);
// tiling hints
if let Some(group_elements) = group_elements {
elements.extend(group_elements);
for elem in group_elements.into_iter() {
push(elem);
}
Ok(elements)
}
#[profiling::function]
@ -4167,8 +4172,9 @@ impl TilingLayout {
non_exclusive_zone: Rectangle<i32, Local>,
overview: (OverviewMode, Option<(SwapIndicator, Option<&Tree<Data>>)>),
theme: &cosmic::theme::CosmicTheme,
) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicMappedRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
@ -4200,8 +4206,6 @@ impl TilingLayout {
};
let draw_groups = overview.0.alpha();
let mut elements = Vec::default();
let is_mouse_tiling = (matches!(overview.0.trigger(), Some(Trigger::Pointer(_))))
.then(|| self.last_overview_hover.as_ref().map(|(_, zone)| zone));
let swap_desc = if let Some(Trigger::KeyboardSwap(_, desc)) = overview.0.trigger() {
@ -4212,7 +4216,7 @@ impl TilingLayout {
// all gone windows and fade them out
let old_geometries = if let Some(reference_tree) = reference_tree.as_ref() {
let (geometries, _) = if let Some(transition) = draw_groups {
let geometries = if let Some(transition) = draw_groups {
Some(geometries_for_groupview(
reference_tree,
&mut *renderer,
@ -4227,14 +4231,14 @@ impl TilingLayout {
swap_desc.clone(),
overview.1.as_ref().and_then(|(_, tree)| *tree),
theme,
&mut |_| {},
))
} else {
None
}
.unzip();
};
// all old windows we want to fade out
elements.extend(render_old_tree_popups(
render_old_tree_popups(
reference_tree,
target_tree,
renderer,
@ -4242,14 +4246,16 @@ impl TilingLayout {
output_scale,
percentage,
swap_desc.is_some(),
));
scanout_node,
push,
);
geometries
} else {
None
};
let (geometries, _) = if let Some(transition) = draw_groups {
let geometries = if let Some(transition) = draw_groups {
Some(geometries_for_groupview(
target_tree,
&mut *renderer,
@ -4263,14 +4269,14 @@ impl TilingLayout {
swap_desc.clone(),
overview.1.as_ref().and_then(|(_, tree)| *tree),
theme,
&mut |_| {},
))
} else {
None
}
.unzip();
};
// all alive windows
elements.extend(render_new_tree_popups(
render_new_tree_popups(
target_tree,
reference_tree,
renderer,
@ -4281,9 +4287,9 @@ impl TilingLayout {
percentage,
overview,
swap_desc.clone(),
));
Ok(elements)
scanout_node,
push,
);
}
fn gaps(&self) -> (i32, i32) {
@ -4338,10 +4344,8 @@ fn geometries_for_groupview<'a, R>(
swap_desc: Option<NodeDesc>,
swap_tree: Option<&Tree<Data>>,
_theme: &cosmic::theme::CosmicTheme,
) -> (
HashMap<NodeId, Rectangle<i32, Local>>,
Vec<CosmicMappedRenderElement<R>>,
)
push: &mut dyn FnMut(CosmicMappedRenderElement<R>),
) -> HashMap<NodeId, Rectangle<i32, Local>>
where
R: AsGlowRenderer + 'a,
R::TextureId: 'static,
@ -4364,11 +4368,18 @@ where
// push bogos value, that will get ignored anyway
stack.push((Rectangle::from_size((320, 240).into()), 0));
}
if root.is_some() {
let has_root = root.is_some();
if has_root {
stack.push((non_exclusive_zone, 0));
}
let mut elements = Vec::new();
let mut push = |elem| {
if has_root {
push(elem)
}
};
let mut geometries: HashMap<NodeId, Rectangle<i32, Local>> = HashMap::new();
let alpha = alpha * transition;
@ -4523,7 +4534,7 @@ where
if let Some(renderer) = renderer.as_mut() {
if (render_potential_group || render_active_child) && Some(&node_id) != root
{
elements.push(
push(
IndicatorShader::element(
*renderer,
Key::Group(Arc::downgrade(alive)),
@ -4541,7 +4552,7 @@ where
&& pill_indicator.is_some()
&& Some(&node_id) != root
{
elements.push(
push(
IndicatorShader::element(
*renderer,
Key::Group(Arc::downgrade(alive)),
@ -4605,7 +4616,7 @@ where
};
if draw_outline {
elements.push(
push(
IndicatorShader::element(
*renderer,
Key::Group(Arc::downgrade(alive)),
@ -4666,7 +4677,7 @@ where
};
if let Some(renderer) = renderer.as_mut() {
elements.push(
push(
BackdropShader::element(
*renderer,
backdrop_id.clone(),
@ -4684,7 +4695,7 @@ where
if matches!(swap_desc, Some(ref desc) if desc.node == node_id) {
if let Some(renderer) = renderer.as_mut() {
elements.push(
push(
BackdropShader::element(
*renderer,
Key::Group(Arc::downgrade(alive)),
@ -4769,7 +4780,7 @@ where
.unwrap_or(false)
{
if let Some(renderer) = renderer.as_mut() {
elements.push(
push(
BackdropShader::element(
*renderer,
backdrop_id.clone(),
@ -4811,7 +4822,7 @@ where
.unwrap_or(false)
{
if let Some(renderer) = renderer.as_mut() {
elements.push(
push(
BackdropShader::element(
*renderer,
backdrop_id.clone(),
@ -4842,7 +4853,7 @@ where
if let Some(renderer) = renderer.as_mut() {
if render_potential_group {
elements.push(
push(
IndicatorShader::element(
*renderer,
Key::Window(Usage::PotentialGroupIndicator, mapped.key()),
@ -4882,7 +4893,7 @@ where
geo.loc += (WINDOW_BACKDROP_BORDER, WINDOW_BACKDROP_BORDER).into();
geo.size -=
(WINDOW_BACKDROP_BORDER * 2, WINDOW_BACKDROP_BORDER * 2).into();
elements.push(
push(
BackdropShader::element(
*renderer,
Key::Window(Usage::OverviewBackdrop, mapped.key()),
@ -4939,7 +4950,7 @@ where
if let Some(renderer) = renderer.as_mut() {
geo.loc += (WINDOW_BACKDROP_BORDER, WINDOW_BACKDROP_BORDER).into();
geo.size -= (WINDOW_BACKDROP_BORDER * 2, WINDOW_BACKDROP_BORDER * 2).into();
elements.push(
push(
BackdropShader::element(
*renderer,
id.clone(),
@ -4958,11 +4969,7 @@ where
}
}
if root.is_none() {
elements.clear();
}
(geometries, elements)
geometries
}
fn render_old_tree_popups<R>(
@ -4973,16 +4980,15 @@ fn render_old_tree_popups<R>(
output_scale: f64,
percentage: f32,
is_swap_mode: bool,
) -> Vec<CosmicMappedRenderElement<R>>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicMappedRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>,
{
let mut elements = Vec::default();
render_old_tree(
reference_tree,
target_tree,
@ -4991,19 +4997,16 @@ where
percentage,
is_swap_mode,
|mapped, elem_geometry, geo, alpha, _| {
elements.extend(
mapped.popup_render_elements::<R, CosmicMappedRenderElement<R>>(
renderer,
geo.loc.as_logical().to_physical_precise_round(output_scale)
- elem_geometry.loc,
Scale::from(output_scale),
alpha,
),
);
mapped.push_popup_render_elements(
renderer,
geo.loc.as_logical().to_physical_precise_round(output_scale) - elem_geometry.loc,
Scale::from(output_scale),
alpha,
scanout_node,
push,
)
},
);
elements
)
}
fn render_old_tree_windows<R>(
@ -5016,8 +5019,9 @@ fn render_old_tree_windows<R>(
indicator_thickness: u8,
is_swap_mode: bool,
theme: &cosmic::theme::CosmicTheme,
) -> Vec<CosmicMappedRenderElement<R>>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicMappedRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
@ -5025,8 +5029,35 @@ where
CosmicStackRenderElement<R>: RenderElement<R>,
{
let window_hint = crate::theme::active_window_hint(theme);
let mut elements = Vec::default();
let mut shadow_elements = Vec::default();
let mut lower_elements = Vec::default();
let mut shadow_elements = SmallVec::<[_; 4]>::new_const();
let window_map =
|elem, geo: Rectangle<i32, Local>, elem_geometry: Rectangle<i32, Physical>| match elem {
CosmicMappedRenderElement::Stack(elem) => constrain_render_elements(
std::iter::once(elem),
geo.loc.as_logical().to_physical_precise_round(output_scale) - elem_geometry.loc,
geo.as_logical().to_physical_precise_round(output_scale),
elem_geometry,
ConstrainScaleBehavior::Stretch,
ConstrainAlign::CENTER,
output_scale,
)
.next()
.map(CosmicMappedRenderElement::TiledStack),
CosmicMappedRenderElement::Window(elem) => constrain_render_elements(
std::iter::once(elem),
geo.loc.as_logical().to_physical_precise_round(output_scale) - elem_geometry.loc,
geo.as_logical().to_physical_precise_round(output_scale),
elem_geometry,
ConstrainScaleBehavior::Stretch,
ConstrainAlign::CENTER,
output_scale,
)
.next()
.map(CosmicMappedRenderElement::TiledWindow),
x => Some(x),
};
render_old_tree(
reference_tree,
@ -5036,56 +5067,9 @@ where
percentage,
is_swap_mode,
|mapped, elem_geometry, geo, alpha, is_minimizing| {
shadow_elements.extend(mapped.shadow_render_element(
renderer,
geo.loc.as_logical().to_physical_precise_round(output_scale) - elem_geometry.loc,
Some(geo.size.as_logical()),
Scale::from(output_scale),
1.,
alpha,
));
let window_elements = mapped.render_elements::<R, CosmicMappedRenderElement<R>>(
renderer,
geo.loc.as_logical().to_physical_precise_round(output_scale) - elem_geometry.loc,
Some(geo.size.as_logical()),
Scale::from(output_scale),
alpha,
None,
);
elements.extend(window_elements.into_iter().flat_map(|element| {
match element {
CosmicMappedRenderElement::Stack(elem) => constrain_render_elements(
std::iter::once(elem),
geo.loc.as_logical().to_physical_precise_round(output_scale)
- elem_geometry.loc,
geo.as_logical().to_physical_precise_round(output_scale),
elem_geometry,
ConstrainScaleBehavior::Stretch,
ConstrainAlign::CENTER,
output_scale,
)
.next()
.map(CosmicMappedRenderElement::TiledStack),
CosmicMappedRenderElement::Window(elem) => constrain_render_elements(
std::iter::once(elem),
geo.loc.as_logical().to_physical_precise_round(output_scale)
- elem_geometry.loc,
geo.as_logical().to_physical_precise_round(output_scale),
elem_geometry,
ConstrainScaleBehavior::Stretch,
ConstrainAlign::CENTER,
output_scale,
)
.next()
.map(CosmicMappedRenderElement::TiledWindow),
x => Some(x),
}
}));
let radius = mapped.corner_radius(geo.size.as_logical(), indicator_thickness);
if is_minimizing && indicator_thickness > 0 {
elements.push(CosmicMappedRenderElement::FocusIndicator(
push(CosmicMappedRenderElement::FocusIndicator(
IndicatorShader::focus_element(
renderer,
Key::Window(Usage::FocusIndicator, mapped.clone().key()),
@ -5098,10 +5082,44 @@ where
),
));
}
mapped.push_render_elements(
renderer,
geo.loc.as_logical().to_physical_precise_round(output_scale) - elem_geometry.loc,
Some(geo.size.as_logical()),
Scale::from(output_scale),
alpha,
None,
scanout_node,
&mut |elem| {
if let Some(elem) = window_map(elem, geo, elem_geometry) {
push(elem);
}
},
&mut |elem| {
if let Some(elem) = window_map(elem, geo, elem_geometry) {
lower_elements.push(elem);
}
},
);
shadow_elements.extend(mapped.shadow_render_element(
renderer,
geo.loc.as_logical().to_physical_precise_round(output_scale) - elem_geometry.loc,
Some(geo.size.as_logical()),
Scale::from(output_scale),
1.,
alpha,
));
},
);
shadow_elements.into_iter().chain(elements).collect()
for elem in shadow_elements {
push(elem);
}
for elem in lower_elements {
push(elem);
}
}
fn render_old_tree(
@ -5196,15 +5214,15 @@ fn render_new_tree_popups<R>(
percentage: f32,
overview: (OverviewMode, Option<(SwapIndicator, Option<&Tree<Data>>)>),
swap_desc: Option<NodeDesc>,
) -> Vec<CosmicMappedRenderElement<R>>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicMappedRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>,
{
let mut popup_elements = Vec::new();
let output_scale = output.current_scale().fractional_scale();
let is_active_output = seat
@ -5227,20 +5245,18 @@ where
if let Data::Mapped { mapped, .. } = data {
let elem_geometry = mapped.geometry().to_physical_precise_round(output_scale);
popup_elements.extend(
mapped.popup_render_elements::<R, CosmicMappedRenderElement<R>>(
renderer,
geo.loc.as_logical().to_physical_precise_round(output_scale)
- elem_geometry.loc,
Scale::from(output_scale),
alpha,
),
mapped.push_popup_render_elements(
renderer,
geo.loc.as_logical().to_physical_precise_round(output_scale)
- elem_geometry.loc,
Scale::from(output_scale),
alpha,
scanout_node,
push,
);
}
},
);
popup_elements
}
fn render_new_tree_windows<R>(
@ -5262,8 +5278,9 @@ fn render_new_tree_windows<R>(
swapping_stack_surface_id: &Id,
backdrop_id: &Id,
theme: &cosmic::theme::CosmicTheme,
) -> Vec<CosmicMappedRenderElement<R>>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(CosmicMappedRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
@ -5303,19 +5320,22 @@ where
.map(|seat| &seat.active_output() == output)
.unwrap_or(false);
let mut animating_window_elements = Vec::new();
let mut window_elements = Vec::new();
let mut animating_window_upper_elements = Vec::new();
let mut animating_window_lower_elements = Vec::new();
let mut animating_shadow_elements = SmallVec::<[CosmicMappedRenderElement<R>; 4]>::new_const();
let mut window_upper_elements = Vec::new();
let mut window_lower_elements = Vec::new();
let mut shadow_elements = SmallVec::<[CosmicMappedRenderElement<R>; 4]>::new_const();
let mut group_backdrop = None;
let mut indicators = Vec::new();
let mut resize_elements = None;
let mut swap_elements = Vec::new();
let mut shadow_elements = Vec::new();
let mut indicators = SmallVec::<[CosmicMappedRenderElement<R>; 2]>::new_const();
let mut resize_elements = SmallVec::<[CosmicMappedRenderElement<R>; 10]>::new_const();
let mut swap_elements = SmallVec::<[CosmicMappedRenderElement<R>; 4]>::new_const();
let output_geo = output.geometry();
let output_scale = output.current_scale().fractional_scale();
let (swap_indicator, swap_tree) = overview.1.unzip();
let (mut swap_indicator, swap_tree) = overview.1.unzip();
let swap_desc = swap_desc.filter(|_| is_active_output);
let swap_tree = swap_tree.flatten().filter(|_| is_active_output);
let window_hint = crate::theme::active_window_hint(theme);
@ -5323,7 +5343,7 @@ where
// render placeholder, if we are swapping to an empty workspace
if target_tree.root_node_id().is_none() && swap_desc.is_some() {
window_elements.push(
window_upper_elements.push(
BackdropShader::element(
renderer,
backdrop_id.clone(),
@ -5378,31 +5398,36 @@ where
let render_loc =
(swap_geo.loc.as_logical() - window_geo.loc).to_physical_precise_round(output_scale);
swap_elements.extend(
AsRenderElements::render_elements::<CosmicWindowRenderElement<R>>(
&window,
renderer,
render_loc,
output_scale.into(),
1.0,
)
.into_iter()
.map(|window| {
CosmicMappedRenderElement::GrabbedWindow(RescaleRenderElement::from_element(
window,
swap_geo
.loc
.as_logical()
.to_physical_precise_round(output_scale),
ease(
Linear,
1.0,
swap_factor(window_geo.size),
transition.unwrap_or(1.0),
window.push_render_elements(
renderer,
render_loc,
output_scale.into(),
1.0,
None,
scanout_node,
false,
[0, 0, 0, 0],
// TODO
0,
&mut |elem| {
swap_elements.push(CosmicMappedRenderElement::GrabbedWindow(
RescaleRenderElement::from_element(
elem.into(),
swap_geo
.loc
.as_logical()
.to_physical_precise_round(output_scale),
ease(
Linear,
1.0,
swap_factor(window_geo.size),
transition.unwrap_or(1.0),
),
),
))
}),
)
));
},
None,
);
}
// render actual tree nodes
@ -5514,19 +5539,18 @@ where
.unwrap_or(false)
})
.unwrap_or(false))
&& let Some(swap) = swap_indicator.as_ref()
&& let Some(swap) = swap_indicator.as_mut()
{
swap.resize(geo.size.as_logical());
swap.output_enter(output, output_geo.as_logical());
swap_elements.extend(
swap.render_elements::<CosmicWindowRenderElement<R>>(
renderer,
geo.loc.as_logical().to_physical_precise_round(output_scale),
output_scale.into(),
alpha * overview.0.alpha().unwrap_or(1.0),
)
.into_iter()
.map(CosmicMappedRenderElement::from),
let size = geo.size.as_logical();
swap.resize(size);
swap.output_enter(output);
swap.push_render_elements(
renderer,
geo.loc.as_logical().to_physical_precise_round(output_scale),
output_scale.into(),
alpha * overview.0.alpha().unwrap_or(1.0),
&mut |elem| swap_elements.push(elem.into()),
None,
);
}
}
@ -5537,32 +5561,20 @@ where
geo.size += (36, 36).into();
resize.resize(geo.size.as_logical());
resize.output_enter(output, output_geo.as_logical());
resize.output_enter(output);
let possible_edges =
TilingLayout::possible_resizes(target_tree, node_id.clone());
if !possible_edges.is_empty() {
if resize.with_program(|internal| {
let mut edges = internal.edges.lock().unwrap();
if *edges != possible_edges {
*edges = possible_edges;
true
} else {
false
}
}) {
resize.force_update();
}
resize_elements = Some(
resize
.render_elements::<CosmicWindowRenderElement<R>>(
renderer,
geo.loc.as_logical().to_physical_precise_round(output_scale),
output_scale.into(),
alpha * mode.alpha().unwrap_or(1.0),
)
.into_iter()
.map(CosmicMappedRenderElement::from)
.collect::<Vec<_>>(),
resize.set_edges(possible_edges);
resize.push_render_elements(
renderer,
geo.loc.as_logical().to_physical_precise_round(output_scale),
output_scale.into(),
alpha * mode.alpha().unwrap_or(1.0),
&mut |elem| {
resize_elements.push(elem.into());
},
None,
);
}
}
@ -5588,51 +5600,6 @@ where
scale.x.min(scale.y),
alpha,
);
let mut elements = mapped.render_elements::<R, CosmicMappedRenderElement<R>>(
renderer,
//original_location,
geo.loc.as_logical().to_physical_precise_round(output_scale)
- elem_geometry.loc,
max_size,
Scale::from(output_scale),
alpha,
None,
);
if swap_desc
.as_ref()
.filter(|swap_desc| swap_desc.node == node_id)
.and_then(|swap_desc| swap_desc.stack_window.as_ref())
.zip(focused.as_ref())
.map(|(stack_window, focused_id)| {
target_tree
.get(focused_id)
.ok()
.map(|focused| match focused.data() {
Data::Mapped { mapped, .. } => mapped
.stack_ref()
.map(|stack| &stack.active() == stack_window)
.unwrap_or(false),
_ => false,
})
.unwrap_or(false)
})
.unwrap_or(false)
{
let mut active_geo = mapped.active_window_geometry().as_local();
active_geo.loc += geo.loc - mapped.geometry().loc.as_local();
elements.insert(
0,
CosmicMappedRenderElement::Overlay(BackdropShader::element(
renderer,
Key::Window(Usage::Overlay, mapped.key()),
active_geo,
0.0,
0.3,
group_color,
)),
)
}
let (behavior, align) = if is_overview {
(ConstrainScaleBehavior::Fit, ConstrainAlign::CENTER)
@ -5642,7 +5609,7 @@ where
(ConstrainScaleBehavior::CutOff, ConstrainAlign::TOP_LEFT)
};
let elements = elements.into_iter().flat_map(|element| match element {
let map_elem = |element| match element {
CosmicMappedRenderElement::Stack(elem) => constrain_render_elements(
std::iter::once(elem),
geo.loc.as_logical().to_physical_precise_round(output_scale)
@ -5680,7 +5647,66 @@ where
.next()
.map(CosmicMappedRenderElement::TiledOverlay),
x => Some(x),
});
};
let mut upper_elements = SmallVec::<[CosmicMappedRenderElement<R>; 4]>::new_const();
let mut lower_elements = SmallVec::<[CosmicMappedRenderElement<R>; 4]>::new_const();
mapped.push_render_elements(
renderer,
//original_location,
geo.loc.as_logical().to_physical_precise_round(output_scale)
- elem_geometry.loc,
max_size,
Scale::from(output_scale),
alpha,
None,
scanout_node,
&mut |elem| {
if let Some(elem) = map_elem(elem) {
upper_elements.push(elem)
}
},
&mut |elem| {
if let Some(elem) = map_elem(elem) {
lower_elements.push(elem)
}
},
);
if swap_desc
.as_ref()
.filter(|swap_desc| swap_desc.node == node_id)
.and_then(|swap_desc| swap_desc.stack_window.as_ref())
.zip(focused.as_ref())
.map(|(stack_window, focused_id)| {
target_tree
.get(focused_id)
.ok()
.map(|focused| match focused.data() {
Data::Mapped { mapped, .. } => mapped
.stack_ref()
.map(|stack| &stack.active() == stack_window)
.unwrap_or(false),
_ => false,
})
.unwrap_or(false)
})
.unwrap_or(false)
{
let mut active_geo = mapped.active_window_geometry().as_local();
active_geo.loc += geo.loc - mapped.geometry().loc.as_local();
upper_elements.insert(
0,
CosmicMappedRenderElement::Overlay(BackdropShader::element(
renderer,
Key::Window(Usage::Overlay, mapped.key()),
active_geo,
0.0,
0.3,
group_color,
)),
)
}
if swap_desc
.as_ref()
@ -5693,30 +5719,36 @@ where
})
.unwrap_or(false)
{
swap_elements.extend(upper_elements);
swap_elements.extend(shadow_element);
swap_elements.extend(elements);
swap_elements.extend(lower_elements);
} else if animating {
animating_window_upper_elements.extend(upper_elements);
animating_shadow_elements.extend(shadow_element);
animating_window_lower_elements.extend(lower_elements);
} else {
window_upper_elements.extend(upper_elements);
shadow_elements.extend(shadow_element);
if animating {
animating_window_elements.extend(elements);
} else {
window_elements.extend(elements);
}
window_lower_elements.extend(lower_elements);
}
}
},
);
resize_elements
for elem in resize_elements
.into_iter()
.flatten()
.chain(swap_elements)
.chain(indicators)
.chain(window_elements)
.chain(animating_window_elements)
.chain(window_upper_elements)
.chain(shadow_elements)
.chain(window_lower_elements)
.chain(animating_window_upper_elements)
.chain(animating_shadow_elements)
.chain(animating_window_lower_elements)
.chain(group_backdrop.into_iter().map(Into::into))
.collect()
{
push(elem);
}
}
fn render_new_tree(

163
src/shell/mod.rs
View file

@ -12,7 +12,11 @@ use std::{
use wayland_backend::server::ClientId;
use crate::{
shell::{focus::FocusTarget, grabs::fullscreen_items, layout::tiling::PlaceholderType},
shell::{
element::CosmicStack, focus::FocusTarget, grabs::fullscreen_items,
layout::tiling::PlaceholderType,
},
utils,
wayland::{
handlers::data_device::{self, get_dnd_icon},
protocols::workspace::{State as WState, WorkspaceCapabilities},
@ -99,9 +103,8 @@ use self::zoom::{OutputZoomState, ZoomState};
use self::{
element::{
CosmicWindow, MaximizedState,
resize_indicator::{ResizeIndicator, resize_indicator},
swap_indicator::{SwapIndicator, swap_indicator},
CosmicWindow, MaximizedState, resize_indicator::ResizeIndicator,
swap_indicator::SwapIndicator,
},
focus::target::{KeyboardFocusTarget, PointerFocusTarget},
grabs::{
@ -1508,6 +1511,21 @@ impl Workspaces {
#[derive(Debug)]
pub struct InvalidWorkspaceIndex;
utils::id_gen!(next_output_id, OUTPUT_ID, OUTPUT_IDS);
pub struct OutputId(usize);
impl OutputId {
pub fn namespace_for_workspace(&self, idx: usize) -> usize {
self.0 | (idx << 32)
}
}
impl Drop for OutputId {
fn drop(&mut self) {
OUTPUT_IDS.lock().unwrap().remove(&self.0);
}
}
impl Common {
pub fn add_output(&mut self, output: &Output) {
let mut shell = self.shell.write();
@ -1515,6 +1533,10 @@ impl Common {
.workspaces
.add_output(output, &mut self.workspace_state.update());
output
.user_data()
.insert_if_missing_threadsafe(|| OutputId(next_output_id()));
if let Some(state) = shell.zoom_state.as_ref() {
output.user_data().insert_if_missing_threadsafe(|| {
Mutex::new(OutputZoomState::new(
@ -2288,7 +2310,7 @@ impl Shell {
OverviewMode::Started(_, _) | OverviewMode::Active(_)
) {
if matches!(trigger, Trigger::KeyboardSwap(_, _)) {
self.swap_indicator = Some(swap_indicator(evlh, self.theme.clone()));
self.swap_indicator = Some(SwapIndicator::new(evlh, self.theme.clone()));
}
self.overview_mode = OverviewMode::Started(trigger, Instant::now());
}
@ -2341,7 +2363,7 @@ impl Shell {
} else {
self.resize_mode = ResizeMode::Started(pattern, Instant::now(), direction);
}
self.resize_indicator = Some(resize_indicator(
self.resize_indicator = Some(ResizeIndicator::new(
direction,
config,
evlh,
@ -2468,6 +2490,12 @@ impl Shell {
increment: zoom_config.increment,
movement: zoom_config.view_moves,
});
self.update_focal_point(
seat,
seat.get_pointer().unwrap().current_location().as_global(),
zoom_config.view_moves,
);
}
pub fn update_focal_point(
@ -2592,15 +2620,36 @@ impl Shell {
pub fn remap_unfullscreened_window(
&mut self,
surface: CosmicSurface,
state: Option<FullscreenRestoreState>,
mut state: Option<FullscreenRestoreState>,
loop_handle: &LoopHandle<'static, State>,
) -> CosmicMapped {
let window = CosmicMapped::from(CosmicWindow::new(
surface,
loop_handle.clone(),
self.theme.clone(),
self.appearance_conf,
));
if let Some(FullscreenRestoreState::Stack { state: stack_state }) = &state {
if let Some(mapped) = self.mapped().find(|m| **m == stack_state.stack)
&& let Some(stack) = mapped.stack_ref()
{
let idx = stack_state.idx.min(stack.len());
stack.add_window(surface, Some(idx), None);
return mapped.clone();
} else {
state = None;
}
}
let window = if state.as_ref().is_some_and(|s| s.was_stack()) {
CosmicMapped::from(CosmicStack::new(
std::iter::once(surface),
loop_handle.clone(),
self.theme.clone(),
self.appearance_conf,
))
} else {
CosmicMapped::from(CosmicWindow::new(
surface,
loop_handle.clone(),
self.theme.clone(),
self.appearance_conf,
))
};
if let Some(FullscreenRestoreState::Sticky { output, state, .. }) = &state {
let output = output
@ -2637,7 +2686,9 @@ impl Shell {
workspace
}
None => self.workspaces.active_mut(&seat.active_output()).unwrap(),
Some(FullscreenRestoreState::Sticky { .. }) => unreachable!(),
Some(FullscreenRestoreState::Sticky { .. } | FullscreenRestoreState::Stack { .. }) => {
unreachable!()
}
};
let fullscreen_geometry = workspace.output.geometry().to_local(&workspace.output);
@ -2752,7 +2803,9 @@ impl Shell {
}
}
}
Some(FullscreenRestoreState::Sticky { .. }) => unreachable!(),
Some(FullscreenRestoreState::Sticky { .. } | FullscreenRestoreState::Stack { .. }) => {
unreachable!()
}
}
window
@ -2856,10 +2909,12 @@ impl Shell {
let maybe_focused = workspace.focus_stack.get(&seat).iter().next().cloned();
if let Some(FocusTarget::Window(focused)) = maybe_focused
&& (focused.is_stack() && !is_dialog && !should_be_maximized)
&& let Some(stack) = focused.stack_ref()
&& !is_dialog
&& !should_be_maximized
&& !(workspace.is_tiled(&focused.active_window()) && floating_exception)
{
focused.stack_ref().unwrap().add_window(window, None, None);
stack.add_window(window, None, None);
if was_activated {
workspace_state.add_workspace_state(&workspace_handle, WState::Urgent);
}
@ -2985,8 +3040,8 @@ impl Shell {
.map(|idx| (idx, m.clone()))
});
let surface = if let Some((idx, mapped)) = sticky_res {
if mapped.is_stack() {
mapped.stack_ref().unwrap().remove_idx(idx)
if let Some(stack) = mapped.stack_ref() {
stack.remove_idx(idx)
} else {
set.sticky_layer.unmap(&mapped, None);
Some(mapped.active_window())
@ -2996,20 +3051,13 @@ impl Shell {
.iter()
.position(|w| w.windows().any(|s| &s == surface))
{
if set
if let Some(stack) = set
.minimized_windows
.get(idx)
.get_mut(idx)
.unwrap()
.mapped()
.is_some_and(CosmicMapped::is_stack)
.mapped_mut()
.and_then(|m| m.stack_ref())
{
let window = set
.minimized_windows
.get_mut(idx)
.unwrap()
.mapped_mut()
.unwrap();
let stack = window.stack_ref().unwrap();
let idx = stack.surfaces().position(|s| &s == surface);
idx.and_then(|idx| stack.remove_idx(idx))
} else {
@ -3240,7 +3288,7 @@ impl Shell {
toplevel_enter_workspace(window, to);
// we can't restore to a given position
if let WorkspaceRestoreData::Tiling(Some(state)) = &mut window_state {
if let WorkspaceRestoreData::Tiling(state) = &mut window_state {
state.state.take();
}
// update fullscreen state to restore to the new workspace
@ -3256,6 +3304,7 @@ impl Shell {
state: None,
was_maximized: previous.was_maximized(),
},
was_stack: previous.was_stack(),
};
} else if let FullscreenRestoreState::Tiling { workspace, .. }
| FullscreenRestoreState::Floating { workspace, .. } = previous
@ -3267,7 +3316,7 @@ impl Shell {
if is_minimized {
let to_workspace = self.workspaces.space_for_handle_mut(to).unwrap(); // checked above
let minimized_window = match window_state {
WorkspaceRestoreData::Floating(Some(previous)) => {
WorkspaceRestoreData::Floating(previous) => {
let window = CosmicMapped::from(CosmicWindow::new(
window.clone(),
evlh.clone(),
@ -3277,7 +3326,7 @@ impl Shell {
window.set_minimized(true);
MinimizedWindow::Floating { window, previous }
}
WorkspaceRestoreData::Tiling(Some(previous)) => {
WorkspaceRestoreData::Tiling(previous) => {
let window = CosmicMapped::from(CosmicWindow::new(
window.clone(),
evlh.clone(),
@ -3344,7 +3393,7 @@ impl Shell {
self.appearance_conf,
));
let position = match window_state {
WorkspaceRestoreData::Floating(Some(data)) => Some(
WorkspaceRestoreData::Floating(data) => Some(
data.position_relative(to_workspace.output.geometry().size.as_logical()),
),
_ => None,
@ -3444,7 +3493,7 @@ impl Shell {
let to_workspace = self.workspaces.space_for_handle_mut(to).unwrap(); // checked above
if !to_workspace.tiling_enabled {
let (position, was_maximized, was_snapped) = match &window_state {
WorkspaceRestoreData::Floating(Some(data)) => (
WorkspaceRestoreData::Floating(data) => (
Some(data.position_relative(to_workspace.output.geometry().size.as_logical())),
data.was_maximized,
data.was_snapped,
@ -3644,6 +3693,8 @@ impl Shell {
return None;
};
let mut theme = self.theme.clone();
theme.transparent = theme.cosmic().frosted_windows;
let grab = MenuGrab::new(
GrabStartData::Pointer(start_data),
seat,
@ -3652,7 +3703,7 @@ impl Shell {
MenuAlignment::CORNER,
None,
evlh.clone(),
self.theme.clone(),
theme,
);
Some((grab, Focus::Keep))
@ -4796,14 +4847,19 @@ impl Shell {
{
let mut from = set.sticky_layer.element_geometry(&mapped).unwrap();
let mut was_maximized = false;
window = if mapped
.stack_ref()
.map(|stack| stack.len() > 1)
.unwrap_or(false)
let mut restore_state = None;
let was_stack = mapped.is_stack();
window = if let Some(stack) = mapped.stack_ref()
&& stack.len() > 1
{
let stack = mapped.stack_ref().unwrap();
let surface = stack.surfaces().find(|s| s == surface).unwrap();
stack.remove_window(&surface);
let idx = stack.surfaces().position(|s| &s == surface)?;
let surface = stack.remove_idx(idx)?;
restore_state = Some(FullscreenRestoreState::Stack {
state: StackRestoreData {
stack: mapped.key(),
idx,
},
});
surface
} else {
// Must be set before `map_internal`/`unmap` below, as both may call
@ -4836,7 +4892,7 @@ impl Shell {
workspace.map_fullscreen(
&window,
&seat,
Some(FullscreenRestoreState::Sticky {
Some(restore_state.unwrap_or(FullscreenRestoreState::Sticky {
output: old_output,
state: FloatingRestoreData {
geometry: from,
@ -4844,7 +4900,8 @@ impl Shell {
was_maximized,
was_snapped: None,
},
}),
was_stack,
})),
Some(from),
);
} else if let Some(workspace) = self.space_for_mut(&mapped) {
@ -4875,17 +4932,22 @@ impl Shell {
&seat,
match state {
WorkspaceRestoreData::Floating(floating_state) => {
floating_state.map(|state| FullscreenRestoreState::Floating {
Some(FullscreenRestoreState::Floating {
workspace: handle,
state,
state: floating_state,
was_stack: mapped.is_stack(),
})
}
WorkspaceRestoreData::Tiling(tiling_state) => {
tiling_state.map(|state| FullscreenRestoreState::Tiling {
Some(FullscreenRestoreState::Tiling {
workspace: handle,
state,
state: tiling_state,
was_stack: mapped.is_stack(),
})
}
WorkspaceRestoreData::Stack(stack_state) => {
Some(FullscreenRestoreState::Stack { state: stack_state })
}
WorkspaceRestoreData::Fullscreen(_) => unreachable!(),
},
Some(from),
@ -5003,13 +5065,14 @@ impl Shell {
let map = smithay::desktop::layer_map_for_output(output);
for layer_surface in map.layers() {
let namespace = self.workspaces.active_num(output).1;
layer_surface.take_presentation_feedback(
&mut output_presentation_feedback,
surface_primary_scanout_output,
|surface, _| {
surface_presentation_feedback_flags_from_states(
surface,
None,
Some(namespace),
render_element_states,
)
},

418
src/shell/workspace.rs
View file

@ -1,11 +1,9 @@
use crate::backend::render::wayland::SurfaceRenderElement;
use crate::shell::focus::FocusTarget;
use crate::shell::layout::tiling::RestoreTilingState;
use crate::wayland::handlers::xdg_activation::ActivationContext;
use crate::{
backend::render::{
BackdropShader,
element::{AsGlowRenderer, FromGlesError},
},
backend::render::{BackdropShader, element::AsGlowRenderer},
shell::{
ANIMATION_DURATION, OverviewMode, SeatMoveGrabState,
layout::{
@ -31,14 +29,15 @@ use cosmic_protocols::workspace::v2::server::zcosmic_workspace_handle_v2::Tiling
use id_tree::Tree;
use indexmap::IndexSet;
use keyframe::{ease, functions::EaseInOutCubic};
use smithay::backend::renderer::element::Kind;
use smallvec::SmallVec;
use smithay::backend::drm::DrmNode;
use smithay::backend::renderer::element::{Kind, NamespacedElement};
use smithay::output::WeakOutput;
use smithay::utils::user_data::UserDataMap;
use smithay::{
backend::renderer::{
element::{
Element, Id, RenderElement, surface::WaylandSurfaceRenderElement,
texture::TextureRenderElement, utils::RescaleRenderElement,
Element, Id, RenderElement, texture::TextureRenderElement, utils::RescaleRenderElement,
},
gles::GlesTexture,
glow::GlowRenderer,
@ -61,7 +60,7 @@ use wayland_backend::server::ClientId;
use super::{
CosmicMappedRenderElement, CosmicSurface, ResizeDirection, ResizeMode,
element::{
CosmicMapped, MaximizedState, resize_indicator::ResizeIndicator,
CosmicMapped, CosmicMappedKey, MaximizedState, resize_indicator::ResizeIndicator,
stack::CosmicStackRenderElement, swap_indicator::SwapIndicator,
window::CosmicWindowRenderElement,
},
@ -253,14 +252,20 @@ pub enum FullscreenRestoreState {
Tiling {
workspace: WorkspaceHandle,
state: TilingRestoreData,
was_stack: bool,
},
Floating {
workspace: WorkspaceHandle,
state: FloatingRestoreData,
was_stack: bool,
},
Sticky {
output: WeakOutput,
state: FloatingRestoreData,
was_stack: bool,
},
Stack {
state: StackRestoreData,
},
}
@ -270,6 +275,18 @@ impl FullscreenRestoreState {
FullscreenRestoreState::Floating { state, .. }
| FullscreenRestoreState::Sticky { state, .. } => state.was_maximized,
FullscreenRestoreState::Tiling { state, .. } => state.was_maximized,
FullscreenRestoreState::Stack { .. } => false,
}
}
// Surface was previously a single-window stack
pub fn was_stack(&self) -> bool {
match self {
FullscreenRestoreState::Floating { was_stack, .. }
| FullscreenRestoreState::Sticky { was_stack, .. } => *was_stack,
FullscreenRestoreState::Tiling { was_stack, .. } => *was_stack,
// Stack wasn't removed; surface was removed from the stack
FullscreenRestoreState::Stack { .. } => false,
}
}
}
@ -277,18 +294,9 @@ impl FullscreenRestoreState {
#[derive(Debug, Clone)]
pub enum WorkspaceRestoreData {
Fullscreen(Option<FullscreenRestoreData>),
Tiling(Option<TilingRestoreData>),
Floating(Option<FloatingRestoreData>),
}
impl From<ManagedLayer> for WorkspaceRestoreData {
fn from(value: ManagedLayer) -> Self {
match value {
ManagedLayer::Floating | ManagedLayer::Sticky => WorkspaceRestoreData::Floating(None),
ManagedLayer::Tiling => WorkspaceRestoreData::Tiling(None),
ManagedLayer::Fullscreen => WorkspaceRestoreData::Fullscreen(None),
}
}
Tiling(TilingRestoreData),
Floating(FloatingRestoreData),
Stack(StackRestoreData),
}
#[derive(Debug, Clone)]
@ -320,6 +328,12 @@ pub struct TilingRestoreData {
pub was_maximized: bool,
}
#[derive(Debug, Clone)]
pub struct StackRestoreData {
pub stack: CosmicMappedKey,
pub idx: usize,
}
#[derive(Debug, Clone)]
pub struct FullscreenRestoreData {
pub previous_state: FullscreenRestoreState,
@ -641,32 +655,30 @@ impl Workspace {
mapped.set_minimized(false);
return Some(match state {
MinimizedWindow::Floating { previous, .. } => {
WorkspaceRestoreData::Floating(Some(previous))
}
MinimizedWindow::Tiling { previous, .. } => {
WorkspaceRestoreData::Tiling(Some(previous))
WorkspaceRestoreData::Floating(previous)
}
MinimizedWindow::Tiling { previous, .. } => WorkspaceRestoreData::Tiling(previous),
MinimizedWindow::Fullscreen { .. } => unreachable!(),
});
}
if let Ok(state) = self.tiling_layer.unmap(mapped, None) {
return Some(WorkspaceRestoreData::Tiling(Some(TilingRestoreData {
return Some(WorkspaceRestoreData::Tiling(TilingRestoreData {
state,
was_maximized: was_maximized.is_some(),
})));
}));
}
let was_snapped = *mapped.floating_tiled.lock().unwrap();
// unmaximize_request might have triggered a `floating_layer.refresh()`,
// which may have already removed a non-alive surface.
if let Some(floating_geometry) = self.floating_layer.unmap(mapped, None).or(was_maximized) {
return Some(WorkspaceRestoreData::Floating(Some(FloatingRestoreData {
return Some(WorkspaceRestoreData::Floating(FloatingRestoreData {
geometry: floating_geometry,
output_size: self.output.geometry().size.as_logical(),
was_maximized: was_maximized.is_some(),
was_snapped,
})));
}));
};
None
@ -712,19 +724,17 @@ impl Workspace {
}
let mapped = self.element_for_surface(surface)?;
let maybe_stack = mapped.stack_ref().filter(|s| s.len() > 1);
if let Some(stack) = maybe_stack
if let Some(stack) = mapped.stack_ref()
&& stack.len() > 1
{
let idx = stack.surfaces().position(|s| &s == surface);
let layer = if self.is_tiled(surface) {
ManagedLayer::Tiling
} else {
ManagedLayer::Floating
};
return idx
.and_then(|idx| stack.remove_idx(idx))
.map(|s| (s, layer.into()));
let idx = stack.surfaces().position(|s| &s == surface)?;
return Some((
stack.remove_idx(idx)?,
WorkspaceRestoreData::Stack(StackRestoreData {
stack: mapped.key(),
idx,
}),
));
}
// we know mapped is no stack with more than one element now,
@ -1612,8 +1622,9 @@ impl Workspace {
resize_indicator: Option<(ResizeMode, ResizeIndicator)>,
indicator_thickness: u8,
theme: &CosmicTheme,
) -> Result<Vec<WorkspaceRenderElement<R>>, OutputNotMapped>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(WorkspaceRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
@ -1621,108 +1632,109 @@ impl Workspace {
CosmicStackRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
{
let mut elements = Vec::default();
let output_scale = self.output.current_scale().fractional_scale();
let zone = {
let layer_map = layer_map_for_output(&self.output);
layer_map.non_exclusive_zone().as_local()
};
let focused = self.focus_stack.get(last_active_seat).last().cloned();
let fullscreen_focused = matches!(focused, Some(FocusTarget::Fullscreen(_)));
let render_fullscreen = |fullscreen: &FullscreenSurface,
renderer: &mut R,
output_scale: f64|
-> Vec<WorkspaceRenderElement<R>> {
let fullscreen_geo = self.fullscreen_geometry_for(fullscreen);
let previous_geo = fullscreen
.previous_geometry
.as_ref()
.unwrap_or(&fullscreen_geo);
let mut fullscreen_elements = SmallVec::<[WorkspaceRenderElement<R>; 2]>::new_const();
let mut render_fullscreen =
|fullscreen: &FullscreenSurface, renderer: &mut R, output_scale: f64| {
let fullscreen_geo = self.fullscreen_geometry_for(fullscreen);
let previous_geo = fullscreen
.previous_geometry
.as_ref()
.unwrap_or(&fullscreen_geo);
let (target_geo, alpha) = match (fullscreen.start_at, fullscreen.ended_at) {
(Some(started), _) => {
let duration = Instant::now().duration_since(started).as_secs_f64()
/ FULLSCREEN_ANIMATION_DURATION.as_secs_f64();
(
ease(
EaseInOutCubic,
EaseRectangle(*previous_geo),
EaseRectangle(fullscreen_geo),
duration,
let (target_geo, alpha) = match (fullscreen.start_at, fullscreen.ended_at) {
(Some(started), _) => {
let duration = Instant::now().duration_since(started).as_secs_f64()
/ FULLSCREEN_ANIMATION_DURATION.as_secs_f64();
(
ease(
EaseInOutCubic,
EaseRectangle(*previous_geo),
EaseRectangle(fullscreen_geo),
duration,
)
.0,
ease(EaseInOutCubic, 0.0, 1.0, duration),
)
.0,
ease(EaseInOutCubic, 0.0, 1.0, duration),
)
}
(_, Some(ended)) => {
let duration = Instant::now().duration_since(ended).as_secs_f64()
/ FULLSCREEN_ANIMATION_DURATION.as_secs_f64();
(
ease(
EaseInOutCubic,
EaseRectangle(fullscreen_geo),
EaseRectangle(*previous_geo),
duration,
}
(_, Some(ended)) => {
let duration = Instant::now().duration_since(ended).as_secs_f64()
/ FULLSCREEN_ANIMATION_DURATION.as_secs_f64();
(
ease(
EaseInOutCubic,
EaseRectangle(fullscreen_geo),
EaseRectangle(*previous_geo),
duration,
)
.0,
ease(EaseInOutCubic, 1.0, 0.0, duration),
)
.0,
ease(EaseInOutCubic, 1.0, 0.0, duration),
)
}
(None, None) => (fullscreen_geo, 1.0),
};
}
(None, None) => (fullscreen_geo, 1.0),
};
let render_loc = target_geo
.loc
.as_logical()
.to_physical_precise_round(output_scale);
let render_loc = target_geo
.loc
.as_logical()
.to_physical_precise_round(output_scale);
// Only rescale geometry when animating
let animation_rescale = |elem| {
if fullscreen.is_animating() {
let fullscreen_geo = fullscreen.surface.0.geometry();
let scale = Scale {
x: target_geo.size.w as f64 / fullscreen_geo.size.w as f64,
y: target_geo.size.h as f64 / fullscreen_geo.size.h as f64,
};
let fullscreen_geo = fullscreen.surface.0.geometry();
let scale = Scale {
x: target_geo.size.w as f64 / fullscreen_geo.size.w as f64,
y: target_geo.size.h as f64 / fullscreen_geo.size.h as f64,
};
RescaleRenderElement::from_element(elem, render_loc, scale).into()
} else {
Into::<WorkspaceRenderElement<_>>::into(elem)
}
};
// Only rescale geometry when animating
let animation_rescale = |elem| {
if fullscreen.is_animating() {
RescaleRenderElement::from_element(elem, render_loc, scale).into()
} else {
Into::<WorkspaceRenderElement<_>>::into(elem)
}
};
fullscreen
.surface
.render_elements::<R, CosmicWindowRenderElement<R>>(
let mut fullscreen_push = |elem: SurfaceRenderElement<R>| {
if fullscreen_focused {
push(animation_rescale(elem.into()))
} else {
fullscreen_elements.push(animation_rescale(elem.into()))
}
};
fullscreen.surface.push_render_elements(
renderer,
render_loc,
output_scale.into(),
alpha,
Some(true),
)
.into_iter()
.map(animation_rescale)
.collect::<Vec<_>>()
};
scanout_node,
false,
[0, 0, 0, 0],
0,
&mut fullscreen_push,
None,
);
};
let top_fullscreen = self.get_fullscreen(last_active_seat);
let mut fullscreen_elements: Vec<WorkspaceRenderElement<R>> = Vec::new();
if let Some(fs) = top_fullscreen {
fullscreen_elements.extend(render_fullscreen(fs, renderer, output_scale));
render_fullscreen(fs, renderer, output_scale)
}
// Also render any animating (entering/exiting) fullscreens
for fs in self.fullscreen_surfaces.iter().filter(|f| f.is_animating()) {
if top_fullscreen.is_none_or(|top| top.surface != fs.surface) {
fullscreen_elements.extend(render_fullscreen(fs, renderer, output_scale));
render_fullscreen(fs, renderer, output_scale);
};
}
if matches!(focused, Some(FocusTarget::Fullscreen(_))) {
elements.append(&mut fullscreen_elements);
}
let any_fullscreen_animating = self
.fullscreen_surfaces
.iter()
@ -1753,28 +1765,21 @@ impl Workspace {
OverviewMode::None => 1.0,
};
elements.extend(
self.floating_layer
.render::<R>(
renderer,
render_focus
.then(|| {
focused.as_ref().and_then(|target| {
if let FocusTarget::Window(mapped) = target {
Some(mapped)
} else {
None
}
})
})
.flatten(),
resize_indicator.clone(),
indicator_thickness,
alpha,
theme,
)
.into_iter()
.map(WorkspaceRenderElement::from),
self.floating_layer.render(
renderer,
focused.as_ref().and_then(|target| {
if let FocusTarget::Window(mapped) = target {
Some(mapped)
} else {
None
}
}),
resize_indicator.clone(),
indicator_thickness,
alpha,
theme,
scanout_node,
&mut |elem| push(elem.into()),
);
let alpha = match &overview.0 {
@ -1791,23 +1796,20 @@ impl Workspace {
};
//tiling surfaces
elements.extend(
self.tiling_layer
.render::<R>(
renderer,
render_focus.then_some(last_active_seat),
zone,
overview,
resize_indicator,
indicator_thickness,
theme,
)?
.into_iter()
.map(WorkspaceRenderElement::from),
self.tiling_layer.render(
renderer,
render_focus.then_some(last_active_seat),
zone,
overview,
resize_indicator,
indicator_thickness,
theme,
scanout_node,
&mut |elem| push(elem.into()),
);
if let Some(alpha) = alpha {
elements.push(
push(
Into::<CosmicMappedRenderElement<R>>::into(BackdropShader::element(
renderer,
self.backdrop_id.clone(),
@ -1821,11 +1823,9 @@ impl Workspace {
}
}
if !matches!(focused, Some(FocusTarget::Fullscreen(_))) {
elements.extend(fullscreen_elements.into_iter());
for elem in fullscreen_elements {
push(elem);
}
Ok(elements)
}
#[profiling::function]
@ -1836,8 +1836,9 @@ impl Workspace {
render_focus: bool,
overview: (OverviewMode, Option<(SwapIndicator, Option<&Tree<Data>>)>),
theme: &CosmicTheme,
) -> Result<Vec<WorkspaceRenderElement<R>>, OutputNotMapped>
where
scanout_node: Option<DrmNode>,
push: &mut dyn FnMut(WorkspaceRenderElement<R>),
) where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
@ -1845,8 +1846,6 @@ impl Workspace {
CosmicStackRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
{
let mut elements = Vec::default();
let output_scale = self.output.current_scale().fractional_scale();
let zone = {
let layer_map = layer_map_for_output(&self.output);
@ -1901,17 +1900,14 @@ impl Workspace {
.as_logical()
.to_physical_precise_round(output_scale);
elements.extend(
fullscreen
.surface
.popup_render_elements::<R, CosmicWindowRenderElement<R>>(
renderer,
render_loc,
output_scale.into(),
alpha,
)
.into_iter()
.map(Into::into),
fullscreen.surface.push_popup_render_elements(
renderer,
render_loc,
output_scale.into(),
alpha,
scanout_node,
0,
&mut |elem| push(WorkspaceRenderElement::FullscreenPopup(elem.into())),
);
}
@ -1945,29 +1941,20 @@ impl Workspace {
OverviewMode::None => 1.0,
};
elements.extend(
self.floating_layer
.render_popups::<R>(renderer, alpha)
.into_iter()
.map(WorkspaceRenderElement::from),
);
self.floating_layer
.render_popups(renderer, alpha, scanout_node, &mut |elem| push(elem.into()));
//tiling surfaces
elements.extend(
self.tiling_layer
.render_popups::<R>(
renderer,
render_focus.then_some(last_active_seat),
zone,
overview,
theme,
)?
.into_iter()
.map(WorkspaceRenderElement::from),
self.tiling_layer.render_popups(
renderer,
render_focus.then_some(last_active_seat),
zone,
overview,
theme,
scanout_node,
&mut |elem| push(elem.into()),
);
}
Ok(elements)
}
}
@ -1986,9 +1973,10 @@ pub struct OutputNotMapped;
pub enum WorkspaceRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
{
OverrideRedirect(WaylandSurfaceRenderElement<R>),
OverrideRedirect(SurfaceRenderElement<R>),
LowerLayerShell(NamespacedElement<SurfaceRenderElement<R>>),
Fullscreen(RescaleRenderElement<CosmicWindowRenderElement<R>>),
FullscreenPopup(CosmicWindowRenderElement<R>),
Window(CosmicMappedRenderElement<R>),
@ -1998,11 +1986,12 @@ where
impl<R> Element for WorkspaceRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
{
fn id(&self) -> &smithay::backend::renderer::element::Id {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.id(),
WorkspaceRenderElement::LowerLayerShell(elem) => elem.id(),
WorkspaceRenderElement::Fullscreen(elem) => elem.id(),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.id(),
WorkspaceRenderElement::Window(elem) => elem.id(),
@ -2013,6 +2002,7 @@ where
fn current_commit(&self) -> smithay::backend::renderer::utils::CommitCounter {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.current_commit(),
WorkspaceRenderElement::LowerLayerShell(elem) => elem.current_commit(),
WorkspaceRenderElement::Fullscreen(elem) => elem.current_commit(),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.current_commit(),
WorkspaceRenderElement::Window(elem) => elem.current_commit(),
@ -2023,6 +2013,7 @@ where
fn src(&self) -> Rectangle<f64, smithay::utils::Buffer> {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.src(),
WorkspaceRenderElement::LowerLayerShell(elem) => elem.src(),
WorkspaceRenderElement::Fullscreen(elem) => elem.src(),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.src(),
WorkspaceRenderElement::Window(elem) => elem.src(),
@ -2033,6 +2024,7 @@ where
fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, smithay::utils::Physical> {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.geometry(scale),
WorkspaceRenderElement::LowerLayerShell(elem) => elem.geometry(scale),
WorkspaceRenderElement::Fullscreen(elem) => elem.geometry(scale),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.geometry(scale),
WorkspaceRenderElement::Window(elem) => elem.geometry(scale),
@ -2043,6 +2035,7 @@ where
fn location(&self, scale: Scale<f64>) -> Point<i32, smithay::utils::Physical> {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.location(scale),
WorkspaceRenderElement::LowerLayerShell(elem) => elem.location(scale),
WorkspaceRenderElement::Fullscreen(elem) => elem.location(scale),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.location(scale),
WorkspaceRenderElement::Window(elem) => elem.location(scale),
@ -2053,6 +2046,7 @@ where
fn transform(&self) -> smithay::utils::Transform {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.transform(),
WorkspaceRenderElement::LowerLayerShell(elem) => elem.transform(),
WorkspaceRenderElement::Fullscreen(elem) => elem.transform(),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.transform(),
WorkspaceRenderElement::Window(elem) => elem.transform(),
@ -2067,6 +2061,7 @@ where
) -> DamageSet<i32, smithay::utils::Physical> {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.damage_since(scale, commit),
WorkspaceRenderElement::LowerLayerShell(elem) => elem.damage_since(scale, commit),
WorkspaceRenderElement::Fullscreen(elem) => elem.damage_since(scale, commit),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.damage_since(scale, commit),
WorkspaceRenderElement::Window(elem) => elem.damage_since(scale, commit),
@ -2077,6 +2072,7 @@ where
fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, smithay::utils::Physical> {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.opaque_regions(scale),
WorkspaceRenderElement::LowerLayerShell(elem) => elem.opaque_regions(scale),
WorkspaceRenderElement::Fullscreen(elem) => elem.opaque_regions(scale),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.opaque_regions(scale),
WorkspaceRenderElement::Window(elem) => elem.opaque_regions(scale),
@ -2087,6 +2083,7 @@ where
fn alpha(&self) -> f32 {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.alpha(),
WorkspaceRenderElement::LowerLayerShell(elem) => elem.alpha(),
WorkspaceRenderElement::Fullscreen(elem) => elem.alpha(),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.alpha(),
WorkspaceRenderElement::Window(elem) => elem.alpha(),
@ -2097,6 +2094,7 @@ where
fn kind(&self) -> Kind {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.kind(),
WorkspaceRenderElement::LowerLayerShell(elem) => elem.kind(),
WorkspaceRenderElement::Fullscreen(elem) => elem.kind(),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.kind(),
WorkspaceRenderElement::Window(elem) => elem.kind(),
@ -2107,6 +2105,7 @@ where
fn is_framebuffer_effect(&self) -> bool {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.is_framebuffer_effect(),
WorkspaceRenderElement::LowerLayerShell(elem) => elem.is_framebuffer_effect(),
WorkspaceRenderElement::Fullscreen(elem) => elem.is_framebuffer_effect(),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.is_framebuffer_effect(),
WorkspaceRenderElement::Window(elem) => elem.is_framebuffer_effect(),
@ -2118,8 +2117,7 @@ where
impl<R> RenderElement<R> for WorkspaceRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::Error: FromGlesError,
R::TextureId: Send + 'static,
{
fn draw(
&self,
@ -2134,6 +2132,9 @@ where
WorkspaceRenderElement::OverrideRedirect(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions, cache)
}
WorkspaceRenderElement::LowerLayerShell(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions, cache)
}
WorkspaceRenderElement::Fullscreen(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions, cache)
}
@ -2152,7 +2153,7 @@ where
opaque_regions,
cache,
)
.map_err(FromGlesError::from_gles_error),
.map_err(R::from_gles_error),
}
}
@ -2162,6 +2163,7 @@ where
) -> Option<smithay::backend::renderer::element::UnderlyingStorage<'_>> {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.underlying_storage(renderer),
WorkspaceRenderElement::LowerLayerShell(elem) => elem.underlying_storage(renderer),
WorkspaceRenderElement::Fullscreen(elem) => elem.underlying_storage(renderer),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.underlying_storage(renderer),
WorkspaceRenderElement::Window(elem) => elem.underlying_storage(renderer),
@ -2182,6 +2184,9 @@ where
WorkspaceRenderElement::OverrideRedirect(elem) => {
elem.capture_framebuffer(frame, src, dst, cache)
}
WorkspaceRenderElement::LowerLayerShell(elem) => {
elem.capture_framebuffer(frame, src, dst, cache)
}
WorkspaceRenderElement::Fullscreen(elem) => {
elem.capture_framebuffer(frame, src, dst, cache)
}
@ -2199,7 +2204,7 @@ where
dst,
cache,
)
.map_err(FromGlesError::from_gles_error)
.map_err(R::from_gles_error)
}
}
}
@ -2208,7 +2213,7 @@ where
impl<R> From<RescaleRenderElement<CosmicWindowRenderElement<R>>> for WorkspaceRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: RescaleRenderElement<CosmicWindowRenderElement<R>>) -> Self {
@ -2219,7 +2224,7 @@ where
impl<R> From<CosmicWindowRenderElement<R>> for WorkspaceRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: CosmicWindowRenderElement<R>) -> Self {
@ -2227,21 +2232,32 @@ where
}
}
impl<R> From<WaylandSurfaceRenderElement<R>> for WorkspaceRenderElement<R>
impl<R> From<SurfaceRenderElement<R>> for WorkspaceRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: WaylandSurfaceRenderElement<R>) -> Self {
fn from(elem: SurfaceRenderElement<R>) -> Self {
WorkspaceRenderElement::OverrideRedirect(elem)
}
}
impl<R> From<NamespacedElement<SurfaceRenderElement<R>>> for WorkspaceRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: NamespacedElement<SurfaceRenderElement<R>>) -> Self {
WorkspaceRenderElement::LowerLayerShell(elem)
}
}
impl<R> From<CosmicMappedRenderElement<R>> for WorkspaceRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: CosmicMappedRenderElement<R>) -> Self {
@ -2252,7 +2268,7 @@ where
impl<R> From<TextureRenderElement<GlesTexture>> for WorkspaceRenderElement<R>
where
R: AsGlowRenderer,
R::TextureId: 'static,
R::TextureId: Send + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: TextureRenderElement<GlesTexture>) -> Self {

289
src/shell/zoom.rs
View file

@ -3,15 +3,15 @@ use std::{sync::Mutex, time::Instant};
use calloop::LoopHandle;
use cosmic::{
Apply,
iced::{Alignment, Background, Border, Length, alignment::Vertical},
iced_widget, theme,
iced::{Alignment, Background, Border, Length, alignment::Vertical, widget as iced_widget},
theme,
widget::{self, icon::Named},
};
use cosmic_comp_config::ZoomMovement;
use cosmic_config::ConfigSet;
use keyframe::{ease, functions::Linear};
use smithay::{
backend::renderer::{ImportMem, Renderer, element::AsRenderElements},
backend::renderer::ImportMem,
desktop::space::SpaceElement,
input::{
Seat,
@ -22,19 +22,20 @@ use smithay::{
MotionEvent as PointerMotionEvent, PointerTarget, RelativeMotionEvent,
},
touch::{
DownEvent, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent, TouchTarget,
UpEvent,
DownEvent, FrameMarker, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent,
TouchTarget, UpEvent,
},
},
output::Output,
utils::{IsAlive, Point, Rectangle, Serial, Size},
utils::{FrameExtents, IsAlive, Point, Rectangle, Serial, Size},
};
use tracing::error;
use crate::{
backend::render::element::AsGlowRenderer,
state::State,
utils::{
iced::{IcedElement, Program},
iced::{IcedElement, IcedRenderElement, Program},
prelude::*,
tween::EasePoint,
},
@ -71,45 +72,17 @@ impl OutputZoomState {
increment: u32,
movement: ZoomMovement,
loop_handle: LoopHandle<'static, State>,
theme: cosmic::Theme,
mut theme: cosmic::Theme,
) -> OutputZoomState {
theme.transparent = theme.cosmic().frosted_system_interface;
let cursor_position = seat.get_pointer().unwrap().current_location().as_global();
let focal_point = cursor_position.to_local(output);
let output_geometry = output.geometry().to_f64();
let focal_point = if output_geometry.contains(cursor_position) {
match movement {
ZoomMovement::Continuously | ZoomMovement::OnEdge => {
cursor_position.to_local(output)
}
ZoomMovement::Centered => {
let mut zoomed_output_geometry = output.geometry().to_f64().downscale(level);
zoomed_output_geometry.loc =
cursor_position - zoomed_output_geometry.size.downscale(2.).to_point();
let mut focal_point = zoomed_output_geometry
.loc
.to_local(output)
.upscale(level)
.to_global(output);
focal_point.x = focal_point.x.clamp(
output_geometry.loc.x,
(output_geometry.loc.x + output_geometry.size.w).next_down(),
);
focal_point.y = focal_point.y.clamp(
output_geometry.loc.y,
(output_geometry.loc.y + output_geometry.size.h).next_down(),
);
focal_point.to_local(output)
}
}
} else {
(output_geometry.size.w / 2., output_geometry.size.h / 2.).into()
};
let program = ZoomProgram::new(level, movement, increment);
let element = IcedElement::new(program, Size::default(), loop_handle, theme);
let mut size = element.minimum_size();
size.w = (size.w + 32/*TODO: figure out why iced is calculating too little*/)
.min(output_geometry.size.w.round() as i32);
size.w = size.w.min(output_geometry.size.w.round() as i32);
element.set_activate(true);
element.resize(size);
element.output_enter(output, Rectangle::new(Point::from((0, 0)), size));
@ -192,10 +165,13 @@ impl OutputZoomState {
});
}
fn render<R, C>(&mut self, renderer: &mut R, output: &Output) -> Vec<C>
where
C: From<<IcedElement<ZoomProgram> as AsRenderElements<R>>::RenderElement>,
R: Renderer + ImportMem,
fn render<R>(
&mut self,
renderer: &mut R,
output: &Output,
push: &mut dyn FnMut(IcedRenderElement<R>),
) where
R: AsGlowRenderer + ImportMem,
R::TextureId: Send + Clone + 'static,
{
let size = self.element.current_size().to_f64();
@ -208,8 +184,17 @@ impl OutputZoomState {
.to_physical(scale.fractional_scale())
.to_i32_round();
self.element
.render_elements(renderer, location, scale.fractional_scale().into(), 1.0)
self.element.push_render_elements(
renderer,
location,
scale.fractional_scale().into(),
1.0,
self.element
.with_theme(|theme| theme.cosmic().radius_s())
.map(|x| x.round() as u8),
push,
None,
)
}
}
@ -256,93 +241,101 @@ impl ZoomState {
&mut self,
output: &Output,
cursor_position: Point<f64, Global>,
original_position: Point<f64, Global>,
_original_position: Point<f64, Global>,
movement: ZoomMovement,
) {
let cursor_position = cursor_position.to_i32_round();
let original_position = original_position.to_i32_round();
let output_geometry = output.geometry();
let mut zoomed_output_geometry = output.zoomed_geometry().unwrap();
let output_geometry = output.geometry().to_f64().to_local(output);
let zoomed_output_geometry = output.zoomed_geometry().unwrap().to_f64().to_local(output);
let output_state = output.user_data().get::<Mutex<OutputZoomState>>().unwrap();
let mut output_state_ref = output_state.lock().unwrap();
// animate movement type changes
if self.movement != movement {
let level = output_state_ref.current_level();
let is_level_change = output_state_ref
.previous_level
.is_some_and(|prev| prev.0 != level);
// animate level and movement type changes
if is_level_change || self.movement != movement {
output_state_ref.previous_point = Some((output_state_ref.focal_point, Instant::now()));
self.movement = movement;
}
let cursor_position = cursor_position.to_local(output);
match movement {
ZoomMovement::Continuously => output_state_ref.focal_point = cursor_position.to_f64(),
ZoomMovement::OnEdge => {
if !zoomed_output_geometry
.overlaps_or_touches(Rectangle::new(original_position, Size::from((16, 16))))
{
zoomed_output_geometry.loc = cursor_position.to_global(output)
- zoomed_output_geometry.size.downscale(2).to_point();
let mut focal_point = zoomed_output_geometry
.loc
.to_local(output)
.upscale(
output_geometry.size.w
/ (output_geometry.size.w - zoomed_output_geometry.size.w),
)
.to_global(output);
focal_point.x = focal_point.x.clamp(
output_geometry.loc.x,
output_geometry.loc.x + output_geometry.size.w - 1,
);
focal_point.y = focal_point.y.clamp(
output_geometry.loc.y,
output_geometry.loc.y + output_geometry.size.h - 1,
);
output_state_ref.previous_point =
Some((output_state_ref.focal_point, Instant::now()));
output_state_ref.focal_point = focal_point.to_local(output).to_f64();
} else if !zoomed_output_geometry.contains(cursor_position.to_global(output)) {
let mut diff = output_state_ref.focal_point.to_global(output)
+ (cursor_position.to_global(output) - original_position)
.to_f64()
.upscale(output_state_ref.level);
diff.x = diff.x.clamp(
output_geometry.loc.x as f64,
((output_geometry.loc.x + output_geometry.size.w) as f64).next_down(),
);
diff.y = diff.y.clamp(
output_geometry.loc.y as f64,
((output_geometry.loc.y + output_geometry.size.h) as f64).next_down(),
);
diff -= output_state_ref.focal_point.to_global(output);
output_state_ref.focal_point += diff.as_logical().as_local();
}
ZoomMovement::Continuously => {
// Focal point is the cursor position
output_state_ref.focal_point = cursor_position;
}
ZoomMovement::Centered => {
zoomed_output_geometry.loc = cursor_position.to_global(output)
- zoomed_output_geometry.size.downscale(2).to_point();
ZoomMovement::OnEdge => {
if is_level_change {
// Ensure the cursor doesn't disappear off screen
output_state_ref.focal_point = cursor_position;
return;
}
let mut focal_point = zoomed_output_geometry
.loc
.to_local(output)
.upscale(
output_geometry
.size
.w
.checked_div(output_geometry.size.w - zoomed_output_geometry.size.w)
.unwrap_or(1),
)
.to_global(output);
// Compute small margin relative to zoomed output to keep cursor within
// (can be user-configurable in the future)
let margin_size = zoomed_output_geometry.size.h * 0.02;
let margins = FrameExtents::new(margin_size, margin_size, margin_size, margin_size);
let inner_rect = zoomed_output_geometry - margins;
if inner_rect.contains(cursor_position) {
// Do not move if cursor within margins
return;
}
// Compute dx and dy to move the zoomed output based on cursor distance outside margin(s)
let dx = if cursor_position.x < inner_rect.loc.x {
cursor_position.x - inner_rect.loc.x
} else if cursor_position.x > inner_rect.loc.x + inner_rect.size.w {
cursor_position.x - (inner_rect.loc.x + inner_rect.size.w)
} else {
0.0
};
let dy = if cursor_position.y < inner_rect.loc.y {
cursor_position.y - inner_rect.loc.y
} else if cursor_position.y > inner_rect.loc.y + inner_rect.size.h {
cursor_position.y - (inner_rect.loc.y + inner_rect.size.h)
} else {
0.0
};
let mut focal_point = output_state_ref.focal_point + Point::new(dx, dy);
// Clamp the final focal point to output geometry
focal_point.x = focal_point.x.clamp(
output_geometry.loc.x,
output_geometry.loc.x + output_geometry.size.w - 1,
output_geometry.loc.x + output_geometry.size.w - 1.0,
);
focal_point.y = focal_point.y.clamp(
output_geometry.loc.y,
output_geometry.loc.y + output_geometry.size.h - 1,
output_geometry.loc.y + output_geometry.size.h - 1.0,
);
output_state_ref.focal_point = focal_point.to_local(output).to_f64();
output_state_ref.focal_point = focal_point;
}
ZoomMovement::Centered => {
let center = (output_geometry.size / 2.).to_point();
if level == 1.0 {
// Prevent focal point jumping to top-left corner (0, 0) on zoom out
output_state_ref.focal_point = center;
return;
}
// Compute translation to keep cursor at center of screen
let mut tx = center.x - cursor_position.x * level;
let mut ty = center.y - cursor_position.y * level;
// Clamp translation to keep viewport within screen bounds
tx = tx.clamp(output_geometry.size.w * (1.0 - level), 0.0);
ty = ty.clamp(output_geometry.size.h * (1.0 - level), 0.0);
// Convert translation back to focal point: T = F * (1 - level)
output_state_ref.focal_point =
Point::from((tx / (1.0 - level), ty / (1.0 - level)));
}
}
}
@ -389,14 +382,13 @@ impl ZoomState {
None
}
pub fn render<R, C>(renderer: &mut R, output: &Output) -> Vec<C>
pub fn render<R>(renderer: &mut R, output: &Output, push: &mut dyn FnMut(IcedRenderElement<R>))
where
C: From<<IcedElement<ZoomProgram> as AsRenderElements<R>>::RenderElement>,
R: Renderer + ImportMem,
R: AsGlowRenderer + ImportMem,
R::TextureId: Send + Clone + 'static,
{
let output_state = output.user_data().get::<Mutex<OutputZoomState>>().unwrap();
output_state.lock().unwrap().render(renderer, output)
output_state.lock().unwrap().render(renderer, output, push)
}
}
@ -512,7 +504,7 @@ impl Program for ZoomProgram {
.padding(8)
.class(theme::Container::custom(|theme| {
let cosmic = theme.cosmic();
let component = &cosmic.background.component;
let component = &cosmic.background(theme.transparent).component;
iced_widget::container::Style {
snap: true,
icon_color: Some(component.on.into()),
@ -588,6 +580,8 @@ impl Program for ZoomProgram {
let level = output_state_ref.level;
std::mem::drop(output_state_ref);
let mut theme = state.common.theme.clone();
theme.transparent = theme.cosmic().frosted_system_interface;
let grab = MenuGrab::new(
start_data,
&seat,
@ -700,7 +694,7 @@ impl Program for ZoomProgram {
),
Some(level.min(4.)),
state.common.event_loop_handle.clone(),
state.common.theme.clone(),
theme,
);
std::mem::drop(shell);
@ -753,6 +747,8 @@ impl Program for ZoomProgram {
let level = output_state_ref.level;
std::mem::drop(output_state_ref);
let mut theme = state.common.theme.clone();
theme.transparent = theme.cosmic().frosted_system_interface;
let grab = MenuGrab::new(
start_data,
&seat,
@ -785,7 +781,7 @@ impl Program for ZoomProgram {
MenuAlignment::PREFER_CENTERED,
Some(level.min(4.)),
state.common.event_loop_handle.clone(),
state.common.theme.clone(),
theme,
);
std::mem::drop(shell);
@ -1036,58 +1032,59 @@ impl PointerTarget<State> for ZoomFocusTarget {
}
impl TouchTarget<State> for ZoomFocusTarget {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent, seq: Serial) {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::down(elem, seat, data, event, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::down(elem, seat, data, event, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::down(elem, seat, data, event),
ZoomFocusTarget::Menu(elem) => TouchTarget::down(elem, seat, data, event),
}
}
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent, seq: Serial) {
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::up(elem, seat, data, event, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::up(elem, seat, data, event, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::up(elem, seat, data, event),
ZoomFocusTarget::Menu(elem) => TouchTarget::up(elem, seat, data, event),
}
}
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent, seq: Serial) {
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::motion(elem, seat, data, event, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::motion(elem, seat, data, event, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::motion(elem, seat, data, event),
ZoomFocusTarget::Menu(elem) => TouchTarget::motion(elem, seat, data, event),
}
}
fn frame(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
fn frame(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::frame(elem, seat, data, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::frame(elem, seat, data, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::frame(elem, seat, data, frame),
ZoomFocusTarget::Menu(elem) => TouchTarget::frame(elem, seat, data, frame),
}
}
fn cancel(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
fn cancel(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::cancel(elem, seat, data, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::cancel(elem, seat, data, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::cancel(elem, seat, data, frame),
ZoomFocusTarget::Menu(elem) => TouchTarget::cancel(elem, seat, data, frame),
}
}
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent, seq: Serial) {
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::shape(elem, seat, data, event, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::shape(elem, seat, data, event, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::shape(elem, seat, data, event),
ZoomFocusTarget::Menu(elem) => TouchTarget::shape(elem, seat, data, event),
}
}
fn orientation(
&self,
seat: &Seat<State>,
data: &mut State,
event: &OrientationEvent,
seq: Serial,
) {
fn orientation(&self, seat: &Seat<State>, data: &mut State, event: &OrientationEvent) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::orientation(elem, seat, data, event, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::orientation(elem, seat, data, event, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::orientation(elem, seat, data, event),
ZoomFocusTarget::Menu(elem) => TouchTarget::orientation(elem, seat, data, event),
}
}
fn last_frame(&self, seat: &Seat<State>, data: &mut State) -> Option<FrameMarker> {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::last_frame(elem, seat, data),
ZoomFocusTarget::Menu(elem) => TouchTarget::last_frame(elem, seat, data),
}
}
}

59
src/state.rs
View file

@ -19,6 +19,7 @@ use crate::{
corner_radius::CornerRadiusState,
drm::WlDrmState,
image_capture_source::CosmicImageCaptureSourceState,
keyboard_layout::KeyboardLayoutState,
output_configuration::OutputConfigurationState,
output_power::OutputPowerState,
overlap_notify::OverlapNotifyState,
@ -72,6 +73,7 @@ use smithay::{
utils::{Clock, Monotonic, Point},
wayland::{
alpha_modifier::AlphaModifierState,
background_effect::BackgroundEffectState,
compositor::{CompositorClientState, CompositorState, SurfaceData},
cursor_shape::CursorShapeManagerState,
dmabuf::{DmabufFeedback, DmabufGlobal, DmabufState},
@ -279,6 +281,8 @@ pub struct Common {
pub overlap_notify_state: OverlapNotifyState,
pub a11y_state: A11yState,
pub dbus_state: DBusState,
pub keyboard_layout_state: KeyboardLayoutState,
pub background_effect_state: BackgroundEffectState,
// shell-related wayland state
pub xdg_shell_state: XdgShellState,
@ -682,6 +686,9 @@ impl State {
AlphaModifierState::new::<Self>(dh);
SinglePixelBufferState::new::<Self>(dh);
FixesState::new::<Self>(dh);
let keyboard_layout_state = KeyboardLayoutState::new::<State, _>(&dh, client_not_sandboxed);
let background_effect_state = BackgroundEffectState::new::<Self>(dh);
let idle_notifier_state = IdleNotifierState::<Self>::new(dh, handle.clone());
let idle_inhibit_manager_state = IdleInhibitManagerState::new::<State>(dh);
@ -786,12 +793,14 @@ impl State {
xdg_activation_state,
xdg_foreign_state,
workspace_state,
background_effect_state,
a11y_state,
xwayland_scale: None,
xwayland_state: None,
xwayland_shell_state,
pointer_focus_state: None,
dbus_state,
keyboard_layout_state,
#[cfg(feature = "logind")]
inhibit_lid_fd: None,
@ -930,19 +939,22 @@ impl Common {
render_element_states: &RenderElementStates,
) {
let shell = self.shell.read();
let processor = |surface: &WlSurface, states: &SurfaceData| {
let primary_scanout_output = update_surface_primary_scanout_output(
surface,
output,
states,
None,
render_element_states,
primary_scanout_output_compare,
);
if let Some(output) = primary_scanout_output {
with_fractional_scale(states, |fraction_scale| {
fraction_scale.set_preferred_scale(output.current_scale().fractional_scale());
});
let processor = |namespace: Option<usize>| {
move |surface: &WlSurface, states: &SurfaceData| {
let primary_scanout_output = update_surface_primary_scanout_output(
surface,
output,
states,
namespace,
render_element_states,
primary_scanout_output_compare,
);
if let Some(output) = primary_scanout_output {
with_fractional_scale(states, |fraction_scale| {
fraction_scale
.set_preferred_scale(output.current_scale().fractional_scale());
});
}
}
};
@ -950,7 +962,7 @@ impl Common {
if let Some(session_lock) = shell.session_lock.as_ref()
&& let Some(lock_surface) = session_lock.surfaces.get(output)
{
with_surfaces_surface_tree(lock_surface.wl_surface(), processor)
with_surfaces_surface_tree(lock_surface.wl_surface(), processor(None))
}
for seat in shell
@ -962,7 +974,7 @@ impl Common {
// cursor ...
if let CursorImageStatus::Surface(wl_surface) = cursor_status {
with_surfaces_surface_tree(&wl_surface, processor);
with_surfaces_surface_tree(&wl_surface, processor(None));
}
// grabs
@ -970,12 +982,12 @@ impl Common {
&& let Some(grab_state) = move_grab.lock().unwrap().as_ref()
{
for (window, _) in grab_state.element().windows() {
window.with_surfaces(processor);
window.with_surfaces(processor(None));
}
}
if let Some(icon) = get_dnd_icon(seat) {
with_surfaces_surface_tree(&icon.surface, processor);
with_surfaces_surface_tree(&icon.surface, processor(None));
}
}
@ -983,7 +995,7 @@ impl Common {
for set in shell.workspaces.sets.values() {
set.sticky_layer.mapped().for_each(|mapped| {
for (window, _) in mapped.windows() {
window.with_surfaces(processor);
window.with_surfaces(processor(None));
}
});
}
@ -991,16 +1003,16 @@ impl Common {
// normal windows
for space in shell.workspaces.spaces() {
if let Some(fs) = space.get_fullscreen(shell.seats.last_active()) {
fs.surface.with_surfaces(processor);
fs.surface.with_surfaces(processor(None));
}
space.mapped().for_each(|mapped| {
for (window, _) in mapped.windows() {
window.with_surfaces(processor);
window.with_surfaces(processor(None));
}
});
space.minimized_windows.iter().for_each(|m| {
for window in m.windows() {
window.with_surfaces(processor);
window.with_surfaces(processor(None));
}
})
}
@ -1008,15 +1020,16 @@ impl Common {
// OR windows
shell.override_redirect_windows.iter().for_each(|or| {
if let Some(wl_surface) = or.wl_surface() {
with_surfaces_surface_tree(&wl_surface, processor);
with_surfaces_surface_tree(&wl_surface, processor(None));
}
});
// layer surfaces
for o in shell.outputs() {
let namespace = shell.workspaces.active_num(o).1;
let map = smithay::desktop::layer_map_for_output(o);
for layer_surface in map.layers() {
layer_surface.with_surfaces(processor);
layer_surface.with_surfaces(processor(Some(namespace)));
}
}
}

132
src/utils/iced/mod.rs
View file

@ -12,15 +12,15 @@ use cosmic::{
iced::{
Limits, Point as IcedPoint, Size as IcedSize, Task,
advanced::{graphics::text::font_system, widget::Tree},
core::{Color, Length, Pixels, clipboard::Null as NullClipboard, id::Id, renderer::Style},
event::Event,
futures::{FutureExt, StreamExt},
keyboard::{Event as KeyboardEvent, Modifiers as IcedModifiers},
mouse::{Button as MouseButton, Cursor, Event as MouseEvent, ScrollDelta},
runtime::{Action, task::into_stream},
touch::{Event as TouchEvent, Finger},
window::Event as WindowEvent,
},
iced_core::{Color, Length, Pixels, clipboard::Null as NullClipboard, id::Id, renderer::Style},
iced_runtime::{Action, task::into_stream},
};
use iced_tiny_skia::{
Layer,
@ -33,9 +33,9 @@ use smithay::{
allocator::Fourcc,
input::{ButtonState, KeyState},
renderer::{
ImportMem, Renderer,
ImportMem,
element::{
AsRenderElements, Kind,
Kind,
memory::{MemoryRenderBuffer, MemoryRenderBufferRenderElement},
},
},
@ -51,20 +51,26 @@ use smithay::{
PointerTarget, RelativeMotionEvent,
},
touch::{
DownEvent, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent, TouchTarget,
UpEvent,
DownEvent, FrameMarker, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent,
TouchTarget, UpEvent,
},
},
output::Output,
reexports::calloop::RegistrationToken,
reexports::calloop::{self, LoopHandle, futures::Scheduler},
reexports::calloop::{self, LoopHandle, RegistrationToken, futures::Scheduler},
render_elements,
utils::{
Buffer as BufferCoords, IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size,
Transform,
},
};
use crate::utils::iced::state::State;
use crate::{
backend::render::{
element::AsGlowRenderer,
wayland::blur_effect::{BlurElement, BlurState},
},
utils::iced::state::State,
};
static ID: LazyLock<Id> = LazyLock::new(|| Id::new("Program"));
@ -174,12 +180,15 @@ pub(crate) struct IcedElementInternal<P: Program + Send + 'static> {
outputs: HashSet<Output>,
buffers: HashMap<OrderedFloat<f64>, (MemoryRenderBuffer, Option<(Vec<Layer>, Color)>)>,
pending_realloc: bool,
blur: BlurState,
// state
size: Size<i32, Logical>,
last_seat: Arc<Mutex<Option<(Seat<crate::state::State>, Serial)>>>,
cursor_pos: Option<Point<f64, Logical>>,
touch_map: HashMap<Finger, IcedPoint>,
last_touch_frame: Option<FrameMarker>,
last_touch_serial: Option<Serial>,
// iced
theme: Theme,
@ -224,10 +233,13 @@ impl<P: Program + Send + Clone + 'static> Clone for IcedElementInternal<P> {
outputs: self.outputs.clone(),
buffers: self.buffers.clone(),
pending_realloc: self.pending_realloc,
blur: BlurState::default(),
size: self.size,
last_seat: self.last_seat.clone(),
cursor_pos: self.cursor_pos,
touch_map: self.touch_map.clone(),
last_touch_frame: None,
last_touch_serial: None,
theme: self.theme.clone(),
renderer,
state,
@ -253,6 +265,8 @@ impl<P: Program + Send + 'static> fmt::Debug for IcedElementInternal<P> {
.field("last_seat", &self.last_seat)
.field("cursor_pos", &self.cursor_pos)
.field("touch_map", &self.touch_map)
.field("last_touch_frame", &self.last_touch_frame)
.field("last_touch_serial", &self.last_touch_serial)
.field("theme", &"...")
.field("renderer", &"...")
.field("state", &"...")
@ -305,10 +319,13 @@ impl<P: Program + Send + 'static> IcedElement<P> {
outputs: HashSet::new(),
buffers: HashMap::new(),
pending_realloc: false,
blur: BlurState::default(),
size,
cursor_pos: None,
last_seat,
touch_map: HashMap::new(),
last_touch_frame: None,
last_touch_serial: None,
theme,
renderer,
state,
@ -335,7 +352,6 @@ impl<P: Program + Send + 'static> IcedElement<P> {
let node = element
.as_widget_mut()
.layout(
// TODO Avoid creating a new tree here?
&mut tree,
&internal.renderer,
&Limits::new(IcedSize::ZERO, IcedSize::INFINITE)
@ -379,6 +395,11 @@ impl<P: Program + Send + 'static> IcedElement<P> {
self.0.lock().unwrap().update(true);
}
pub fn with_theme<R: 'static>(&self, f: impl FnOnce(&Theme) -> R) -> R {
let guard = self.0.lock().unwrap();
f(&guard.theme)
}
pub fn set_theme(&self, theme: cosmic::Theme) {
let mut guard = self.0.lock().unwrap();
guard.theme = theme.clone();
@ -633,7 +654,6 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
event: &DownEvent,
seq: Serial,
) {
let mut internal = self.0.lock().unwrap();
let id = Finger(i32::from(event.slot) as u64);
@ -644,7 +664,8 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
.queue_event(Event::Touch(TouchEvent::FingerPressed { id, position }));
internal.touch_map.insert(id, position);
internal.cursor_pos = Some(event_location);
*internal.last_seat.lock().unwrap() = Some((seat.clone(), seq));
internal.last_touch_serial = Some(event.serial);
*internal.last_seat.lock().unwrap() = Some((seat.clone(), event.serial));
internal.update(false);
}
@ -653,12 +674,12 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
event: &UpEvent,
seq: Serial,
) {
let mut internal = self.0.lock().unwrap();
let id = Finger(i32::from(event.slot) as u64);
if let Some(position) = internal.touch_map.remove(&id) {
*internal.last_seat.lock().unwrap() = Some((seat.clone(), seq));
*internal.last_seat.lock().unwrap() =
Some((seat.clone(), internal.last_touch_serial.unwrap()));
internal
.state
.queue_event(Event::Touch(TouchEvent::FingerLifted { id, position }));
@ -671,13 +692,13 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
event: &TouchMotionEvent,
seq: Serial,
) {
let mut internal = self.0.lock().unwrap();
let id = Finger(i32::from(event.slot) as u64);
let event_location = event.location.downscale(internal.additional_scale);
let position = IcedPoint::new(event_location.x as f32, event_location.y as f32);
*internal.last_seat.lock().unwrap() = Some((seat.clone(), seq));
*internal.last_seat.lock().unwrap() =
Some((seat.clone(), internal.last_touch_serial.unwrap()));
internal
.state
.queue_event(Event::Touch(TouchEvent::FingerMoved { id, position }));
@ -690,17 +711,19 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
&self,
_seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
_seq: Serial,
frame: FrameMarker,
) {
self.0.lock().unwrap().last_touch_frame = Some(frame);
}
fn cancel(
&self,
_seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
_seq: Serial,
frame: FrameMarker,
) {
let mut internal = self.0.lock().unwrap();
internal.last_touch_frame = Some(frame);
for (id, position) in std::mem::take(&mut internal.touch_map) {
internal
.state
@ -714,7 +737,6 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
_seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
_event: &ShapeEvent,
_seq: Serial,
) {
}
@ -723,9 +745,16 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
_seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
_event: &OrientationEvent,
_seq: Serial,
) {
}
fn last_frame(
&self,
_seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
) -> Option<FrameMarker> {
self.0.lock().unwrap().last_touch_frame
}
}
impl<P: Program + Send + 'static> KeyboardTarget<crate::state::State> for IcedElement<P> {
@ -895,21 +924,20 @@ impl<P: Program + Send + 'static> SpaceElement for IcedElement<P> {
}
}
impl<P, R> AsRenderElements<R> for IcedElement<P>
where
P: Program + Send + 'static,
R: Renderer + ImportMem,
R::TextureId: Send + Clone + 'static,
{
type RenderElement = MemoryRenderBufferRenderElement<R>;
fn render_elements<C: From<Self::RenderElement>>(
impl<P: Program + Send + 'static> IcedElement<P> {
pub fn push_render_elements<R>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
mut scale: Scale<f64>,
alpha: f32,
) -> Vec<C> {
mut radii: [u8; 4],
push_above: &mut dyn FnMut(IcedRenderElement<R>),
push_below: Option<&mut dyn FnMut(IcedRenderElement<R>)>,
) where
R: AsGlowRenderer + ImportMem,
R::TextureId: Send + Clone + 'static,
{
let mut internal = self.0.lock().unwrap();
// makes partial borrows easier
let internal_ref = &mut *internal;
@ -1040,11 +1068,51 @@ where
Kind::Unspecified,
) {
Ok(buffer) => {
return vec![C::from(buffer)];
push_above(buffer.into());
}
Err(err) => tracing::warn!("What? {:?}", err),
}
if internal_ref.theme.transparent {
for radius in radii.iter_mut() {
*radius = ((*radius as f64) * internal_ref.additional_scale).round() as u8;
}
match BlurElement::from_state(
renderer,
&mut internal_ref.blur,
Rectangle::new(
location
.to_f64()
.to_logical(scale)
.upscale(internal_ref.additional_scale),
internal_ref
.size
.to_f64()
.upscale(internal_ref.additional_scale)
.to_i32_round(),
),
scale.x,
radii,
(internal_ref.theme.cosmic().frosted as u8 + 1) as usize,
) {
Ok(Some(elem)) => {
if let Some(push_below) = push_below {
push_below(elem.into())
} else {
push_above(elem.into())
}
}
Ok(None) => {}
Err(err) => tracing::warn!("Blur elem error: {:?}", err),
}
}
}
Vec::new()
}
}
render_elements! {
pub IcedRenderElement<R> where R: ImportMem + AsGlowRenderer, R::TextureId: Send;
UI=MemoryRenderBufferRenderElement<R>,
Blur=BlurElement,
}

24
src/utils/iced/state.rs
View file

@ -1,12 +1,16 @@
use super::IcedProgram as Program;
use cosmic::iced::core::event::{self, Event};
use cosmic::iced::core::mouse;
use cosmic::iced::core::renderer;
use cosmic::iced::core::widget::operation::{self, Operation};
use cosmic::iced::core::{Clipboard, Size};
use cosmic::iced_core;
use cosmic::iced_runtime::Task;
use cosmic::iced_runtime::user_interface::{self, UserInterface};
use cosmic::iced::{
core::{
self as iced_core, Clipboard, Size,
event::{self, Event},
mouse, renderer,
widget::operation::{self, Operation},
},
runtime::{
Task,
user_interface::{self, UserInterface},
},
};
/// The execution state of a [`Program`]. It leverages caching, event
/// processing, and rendering primitive storage.
@ -128,7 +132,7 @@ where
messages.append(&mut self.queued_messages);
let task = if messages.is_empty() {
if let cosmic::iced_runtime::user_interface::State::Updated {
if let cosmic::iced::runtime::user_interface::State::Updated {
mouse_interaction, ..
} = state
{
@ -154,7 +158,7 @@ where
let mut user_interface =
build_user_interface(id, &mut self.program, temp_cache, renderer, bounds);
if let cosmic::iced_runtime::user_interface::State::Updated {
if let cosmic::iced::runtime::user_interface::State::Updated {
mouse_interaction, ..
} = state
{

16
src/utils/quirks.rs
View file

@ -1,6 +1,9 @@
// SPDX-License-Identifier: GPL-3.0-only
use smithay::{desktop::layer_map_for_output, output::Output};
use smithay::{
backend::renderer::utils::with_renderer_surface_state, desktop::layer_map_for_output,
output::Output,
};
/// Layer shell namespace used by `cosmic-workspaces`
// TODO: Avoid special case, or add protocol to expose required behavior
@ -10,5 +13,14 @@ pub const WORKSPACE_OVERVIEW_NAMESPACE: &str = "cosmic-workspace-overview";
pub fn workspace_overview_is_open(output: &Output) -> bool {
layer_map_for_output(output)
.layers()
.any(|s| s.namespace() == WORKSPACE_OVERVIEW_NAMESPACE)
.filter(|s| s.namespace() == WORKSPACE_OVERVIEW_NAMESPACE)
// Only consider the overview open once it has committed a buffer. The
// surface is inserted into the layer map on its initial (bufferless)
// commit, so checking for the namespace alone hides all toplevels for a
// frame before the overview has anything to draw, briefly flashing the
// bare wallpaper.
.any(|s| {
with_renderer_surface_state(s.wl_surface(), |state| state.buffer().is_some())
.unwrap_or(false)
})
}

21
src/utils/screenshot.rs
View file

@ -3,9 +3,7 @@ use smithay::{
backend::{
allocator::Fourcc,
renderer::{
ExportMem, ImportAll, Offscreen, Renderer,
damage::OutputDamageTracker,
element::{AsRenderElements, surface::WaylandSurfaceRenderElement},
ExportMem, ImportAll, Offscreen, Renderer, damage::OutputDamageTracker,
gles::GlesRenderbuffer,
},
},
@ -16,7 +14,7 @@ use smithay::{
use tracing::warn;
use crate::{
backend::render::RendererRef,
backend::render::{RendererRef, element::AsGlowRenderer},
shell::element::CosmicSurface,
state::{State, advertised_node_for_surface},
};
@ -24,17 +22,24 @@ use crate::{
pub fn screenshot_window(state: &mut State, surface: &CosmicSurface) {
fn render_window<R>(renderer: &mut R, window: &CosmicSurface) -> anyhow::Result<()>
where
R: Renderer + ImportAll + Offscreen<GlesRenderbuffer> + ExportMem,
R::TextureId: Clone + 'static,
R: Renderer + ImportAll + Offscreen<GlesRenderbuffer> + ExportMem + AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: Send + Sync + 'static,
{
let bbox = bbox_from_surface_tree(&window.wl_surface().unwrap(), (0, 0));
let elements = AsRenderElements::<R>::render_elements::<WaylandSurfaceRenderElement<R>>(
window,
let mut elements = Vec::new();
window.push_render_elements(
renderer,
(-bbox.loc.x, -bbox.loc.y).into(),
Scale::from(1.0),
1.0,
None,
None,
false,
[0; 4],
0,
&mut |elem| elements.push(elem),
None,
);
// TODO: 10-bit

59
src/wayland/handlers/background_effect.rs Normal file
View file

@ -0,0 +1,59 @@
use smithay::{
reexports::wayland_server::{DisplayHandle, protocol::wl_surface::WlSurface},
utils::{Logical, Rectangle},
wayland::{
background_effect::{Capability, ExtBackgroundEffectHandler},
compositor::{Cacheable, RectangleKind, RegionAttributes, with_states},
},
};
use crate::state::State;
#[derive(Debug, Clone, Default)]
pub struct ComputedBlurRegionCachedState {
/// Region of the surface that will have its background blurred.
pub blur_region: Option<Vec<Rectangle<i32, Logical>>>,
}
impl Cacheable for ComputedBlurRegionCachedState {
fn commit(&mut self, _dh: &DisplayHandle) -> Self {
self.clone()
}
fn merge_into(self, into: &mut Self, _dh: &DisplayHandle) {
*into = self;
}
}
impl ExtBackgroundEffectHandler for State {
fn capabilities(&self) -> Capability {
Capability::Blur
}
fn set_blur_region(&mut self, surface: WlSurface, region: RegionAttributes) {
with_states(&surface, |states| {
let mut blur_state = states.cached_state.get::<ComputedBlurRegionCachedState>();
blur_state.pending().blur_region = Some({
let (added, subtracted) = region
.rects
.iter()
.cloned()
.partition::<Vec<_>, _>(|(op, _)| matches!(op, RectangleKind::Add));
let added = added.into_iter().map(|(_, rect)| rect).collect::<Vec<_>>();
Rectangle::subtract_rects_many_in_place(
added,
subtracted.into_iter().map(|(_, rect)| rect),
)
})
})
}
fn unset_blur_region(&mut self, surface: WlSurface) {
with_states(&surface, |states| {
let mut blur_state = states.cached_state.get::<ComputedBlurRegionCachedState>();
blur_state.pending().blur_region.take();
})
}
}

3
src/wayland/handlers/compositor.rs
View file

@ -314,8 +314,7 @@ impl CompositorHandler for State {
.then(|| state.element())
});
if let Some(window) = moved_window {
if window.is_stack() {
let stack = window.stack_ref().unwrap();
if let Some(stack) = window.stack_ref() {
if let Some(i) = stack.surfaces().position(|s| {
s.wl_surface()
.as_deref()

108
src/wayland/handlers/corner_radius.rs
View file

@ -1,7 +1,9 @@
use cosmic_protocols::corner_radius::v1::server::cosmic_corner_radius_toplevel_v1;
use smithay::utils::{Logical, Rectangle, Size};
use smithay::wayland::compositor::SurfaceData;
use crate::wayland::protocols::corner_radius::{
CornerRadiusData, CornerRadiusHandler, CornerRadiusState, delegate_corner_radius,
CacheableCorners, CacheablePadding, CornerRadiusData, CornerRadiusHandler, CornerRadiusState,
CornerRadiusSurface, delegate_corner_radius,
};
use crate::state::State;
@ -11,21 +13,25 @@ impl CornerRadiusHandler for State {
&mut self.common.corner_radius_state
}
fn set_corner_radius(
&mut self,
_: &cosmic_corner_radius_toplevel_v1::CosmicCornerRadiusToplevelV1,
data: &CornerRadiusData,
) {
fn set_corner_radius(&mut self, data: &CornerRadiusData) {
if force_redraw(self, data).is_none() {
tracing::warn!("Failed to force redraw for corner radius change.");
}
}
fn unset_corner_radius(
&mut self,
_: &cosmic_corner_radius_toplevel_v1::CosmicCornerRadiusToplevelV1,
data: &CornerRadiusData,
) {
fn unset_corner_radius(&mut self, data: &CornerRadiusData) {
if force_redraw(self, data).is_none() {
tracing::warn!("Failed to force redraw for corner radius reset.");
}
}
fn set_padding(&mut self, data: &CornerRadiusData) {
if force_redraw(self, data).is_none() {
tracing::warn!("Failed to force redraw for corner radius change.");
}
}
fn unset_padding(&mut self, data: &CornerRadiusData) {
if force_redraw(self, data).is_none() {
tracing::warn!("Failed to force redraw for corner radius reset.");
}
@ -34,16 +40,82 @@ impl CornerRadiusHandler for State {
fn force_redraw(state: &mut State, data: &CornerRadiusData) -> Option<()> {
let guard = data.lock().unwrap();
let shell = state.common.shell.read();
let toplevel = guard.toplevel.upgrade().ok()?;
let surface = state.common.xdg_shell_state.get_toplevel(&toplevel)?;
let guard = state.common.shell.read();
let output = guard.visible_output_for_surface(surface.wl_surface())?;
let output = match &guard.surface {
CornerRadiusSurface::Toplevel(toplevel) => {
let toplevel = toplevel.upgrade().ok()?;
let surface = state.common.xdg_shell_state.get_toplevel(&toplevel)?;
shell.visible_output_for_surface(surface.wl_surface())?
}
CornerRadiusSurface::Popup(popup) => {
let popup = popup.upgrade().ok()?;
let surface = state.common.xdg_shell_state.get_popup(&popup)?;
shell.visible_output_for_surface(surface.wl_surface())?
}
CornerRadiusSurface::Layer(layer) => {
let layer = layer.upgrade().ok()?;
let surface = state
.common
.layer_shell_state
.layer_surfaces()
.find(|l| l.shell_surface() == &layer)?;
shell.visible_output_for_surface(surface.wl_surface())?
}
};
state.backend.schedule_render(output);
Some(())
}
pub fn surface_corners(states: &SurfaceData, size: Size<i32, Logical>) -> Option<[u8; 4]> {
let mut guard = states.cached_state.get::<CacheableCorners>();
// guard against corner radius being too large, potentially disconnecting the outline
let half_min_dim = u8::try_from(size.w.min(size.h) / 2).unwrap_or(u8::MAX);
let corners = guard.current().0?;
Some([
u8::try_from(corners.top_left)
.unwrap_or(u8::MAX)
.min(half_min_dim),
u8::try_from(corners.top_right)
.unwrap_or(u8::MAX)
.min(half_min_dim),
u8::try_from(corners.bottom_right)
.unwrap_or(u8::MAX)
.min(half_min_dim),
u8::try_from(corners.bottom_left)
.unwrap_or(u8::MAX)
.min(half_min_dim),
])
}
pub fn surface_padding(states: &SurfaceData, size: Size<i32, Logical>) -> Option<[i32; 4]> {
let mut guard = states.cached_state.get::<CacheablePadding>();
let padding = guard.current().0?;
// guard against padding being too large
Some([
padding.top.min(size.h / 2),
padding.right.min(size.w / 2),
padding.bottom.min(size.h / 2),
padding.left.min(size.w / 2),
])
}
pub fn pad_rect(
mut rect: Rectangle<i32, Logical>,
padding: &[i32; 4],
) -> Option<Rectangle<i32, Logical>> {
rect.size.h = rect.size.h.checked_sub(padding[0])?;
rect.loc.x += padding[3];
rect.size.w = rect.size.w.checked_sub(padding[1])?;
rect.size.h = rect.size.h.checked_sub(padding[2])?;
rect.size.w = rect.size.w.checked_sub(padding[3])?;
rect.loc.y += padding[0];
Some(rect)
}
delegate_corner_radius!(State);

123
src/wayland/handlers/image_copy_capture/render.rs
View file

@ -9,8 +9,7 @@ use smithay::{
buffer_dimensions, buffer_type,
damage::{Error as DTError, OutputDamageTracker, RenderOutputResult},
element::{
AsRenderElements, RenderElement,
surface::WaylandSurfaceRenderElement,
RenderElement,
utils::{Relocate, RelocateRenderElement},
},
gles::{GlesError, GlesRenderbuffer},
@ -40,9 +39,11 @@ use tracing::warn;
use crate::{
backend::render::{
CursorMode, ElementFilter, RendererRef, cursor,
element::{AsGlowRenderer, CosmicElement, DamageElement, FromGlesError},
CursorMode, ElementFilter, RendererRef,
cursor::{self, CursorRenderElement},
element::{AsGlowRenderer, CosmicElement, DamageElement},
render_workspace,
wayland::SurfaceRenderElement,
},
shell::{CosmicMappedRenderElement, CosmicSurface, WorkspaceRenderElement},
state::{Common, KmsNodes, State},
@ -105,8 +106,7 @@ pub fn submit_buffer<R>(
mut sync: SyncPoint,
) -> Result<Option<PendingImageCopyData>, R::Error>
where
R: ExportMem,
R::Error: FromGlesError,
R: ExportMem + AsGlowRenderer,
{
let Some(damage) = damage else {
frame.success(
@ -164,7 +164,7 @@ where
Ok(())
})
.map_err(|err| R::Error::from_gles_error(GlesError::BufferAccessError(err)))
.map_err(|err| R::from_gles_error(GlesError::BufferAccessError(err)))
.and_then(|x| x)
{
frame.fail(CaptureFailureReason::Unknown);
@ -194,7 +194,6 @@ pub fn render_session<F, R>(
) -> Result<Option<PendingImageCopyData>, DTError<R::Error>>
where
R: AsGlowRenderer,
R::Error: FromGlesError,
F: for<'d> FnOnce(
&WlBuffer,
&mut R,
@ -321,7 +320,6 @@ pub fn render_workspace_to_buffer(
where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
@ -504,9 +502,10 @@ pub fn render_workspace_to_buffer(
}
smithay::render_elements! {
pub WindowCaptureElement<R> where R: ImportAll + ImportMem;
WaylandElement=WaylandSurfaceRenderElement<R>,
pub WindowCaptureElement<R> where R: ImportAll + ImportMem + AsGlowRenderer, R::TextureId: Send;
WaylandElement=SurfaceRenderElement<R>,
CursorElement=RelocateRenderElement<cursor::CursorRenderElement<R>>,
DamageElement=DamageElement,
}
pub fn render_window_to_buffer(
@ -554,11 +553,10 @@ pub fn render_window_to_buffer(
where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
let additional_damage_elements: Vec<_> = additional_damage
let mut elements: Vec<_> = additional_damage
.into_iter()
.filter_map(|rect| {
let logical_rect = rect.to_logical(
@ -569,10 +567,11 @@ pub fn render_window_to_buffer(
logical_rect.intersection(Rectangle::from_size(geometry.size))
})
.map(DamageElement::new)
.map(WindowCaptureElement::<R>::from)
.collect();
dt.damage_output(age, &additional_damage_elements)?;
let shell = common.shell.read();
let blur_strength = 9; // TODO
let seat = shell.seats.last_active().clone();
let pointer = seat.get_pointer().unwrap();
let pointer_loc = pointer.current_location().to_i32_round().as_global();
@ -591,56 +590,65 @@ pub fn render_window_to_buffer(
};
std::mem::drop(shell);
let mut elements = Vec::new();
if let Some(location) = location {
if draw_cursor {
elements.extend(
cursor::draw_cursor(
renderer,
&seat,
location,
1.0.into(),
1.0,
common.clock.now(),
true,
)
.into_iter()
.map(|(elem, hotspot)| {
WindowCaptureElement::CursorElement(RelocateRenderElement::from_element(
elem,
Point::from((-hotspot.x, -hotspot.y)),
Relocate::Relative,
))
}),
cursor::draw_cursor(
renderer,
&seat,
location,
1.0.into(),
1.0,
common.clock.now(),
blur_strength,
true,
&mut |elem, hotspot| {
elements.push(WindowCaptureElement::CursorElement(
RelocateRenderElement::from_element(
elem,
Point::from((-hotspot.x, -hotspot.y)),
Relocate::Relative,
),
));
},
);
}
// TODO cosmic-workspaces wants to omit, but metadata cursor capture in portal should
// still include dnd surface in window capture buffer?
if draw_cursor && let Some(dnd_icon) = get_dnd_icon(&seat) {
elements.extend(
cursor::draw_dnd_icon(
renderer,
&dnd_icon.surface,
(location + dnd_icon.offset.to_f64()).to_i32_round(),
1.0,
)
.into_iter()
.map(WindowCaptureElement::from),
cursor::draw_dnd_icon(
renderer,
&dnd_icon.surface,
(location + dnd_icon.offset.to_f64()).to_i32_round(),
1.0,
blur_strength,
&mut |elem| {
elements.push(
RelocateRenderElement::from_element(
CursorRenderElement::Surface(elem),
Point::new(0, 0),
Relocate::Relative,
)
.into(),
)
},
);
}
}
elements.extend(AsRenderElements::<R>::render_elements::<
WindowCaptureElement<R>,
>(
toplevel,
toplevel.push_render_elements(
renderer,
(-geometry.loc.x, -geometry.loc.y).into(),
Scale::from(1.0),
1.0,
));
None,
None,
false,
[0; 4],
blur_strength,
&mut |elem| elements.push(elem.into()),
None,
);
if let Ok(dmabuf) = get_dmabuf(buffer) {
let mut dmabuf_clone = dmabuf.clone();
@ -793,33 +801,34 @@ pub fn render_cursor_to_buffer(
where
R: AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
let additional_damage_elements: Vec<_> = additional_damage
let mut elements: Vec<_> = additional_damage
.into_iter()
.filter_map(|rect| {
let logical_rect = rect.to_logical(1, Transform::Normal, &Size::from((64, 64)));
logical_rect.intersection(Rectangle::from_size((64, 64).into()))
})
.map(DamageElement::new)
.map(WindowCaptureElement::from)
.collect();
dt.damage_output(age, &additional_damage_elements)?;
let elements = cursor::draw_cursor(
cursor::draw_cursor(
renderer,
seat,
Point::from((0.0, 0.0)),
1.0.into(),
1.0,
common.clock.now(),
0,
true,
)
.into_iter()
.map(|(elem, _)| RelocateRenderElement::from_element(elem, (0, 0), Relocate::Relative))
.map(WindowCaptureElement::from)
.collect::<Vec<_>>();
&mut |elem, _| {
elements.push(
RelocateRenderElement::from_element(elem, (0, 0), Relocate::Relative).into(),
)
},
);
if let Ok(dmabuf) = get_dmabuf(buffer) {
let mut dmabuf_clone = dmabuf.clone();

10
src/wayland/handlers/keyboard_layout.rs Normal file
View file

@ -0,0 +1,10 @@
// SPDX-License-Identifier: GPL-3.0-only
use crate::state::State;
use crate::wayland::protocols::keyboard_layout::{KeyboardLayoutHandler, KeyboardLayoutState};
impl KeyboardLayoutHandler for State {
fn keyboard_layout_state(&mut self) -> &mut KeyboardLayoutState {
&mut self.common.keyboard_layout_state
}
}

2
src/wayland/handlers/mod.rs
View file

@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
pub mod a11y;
pub mod background_effect;
pub mod buffer;
pub mod compositor;
pub mod corner_radius;
@ -18,6 +19,7 @@ pub mod idle_notify;
pub mod image_capture_source;
pub mod image_copy_capture;
pub mod input_method;
pub mod keyboard_layout;
pub mod keyboard_shortcuts_inhibit;
pub mod layer_shell;
pub mod output;

6
src/wayland/handlers/toplevel_management.rs
View file

@ -111,8 +111,10 @@ impl ToplevelManagementHandler for State {
std::mem::drop(shell);
// move pointer to window if it’s on a different monitor/output
let switching_output = seat.active_output() != *output;
if switching_output && let Some(new_pos) = new_pos {
if seat.active_output() != *output
&& self.common.config.cosmic_conf.cursor_follows_focus
&& let Some(new_pos) = new_pos
{
seat.set_active_output(output);
if let Some(ptr) = seat.get_pointer() {
let serial = SERIAL_COUNTER.next_serial();

647
src/wayland/protocols/corner_radius.rs
View file

@ -1,12 +1,21 @@
use cosmic_protocols::corner_radius::v1::server::cosmic_corner_radius_layer_v1::{
self, CosmicCornerRadiusLayerV1,
};
use cosmic_protocols::corner_radius::v1::server::cosmic_corner_radius_toplevel_v1::CosmicCornerRadiusToplevelV1;
use cosmic_protocols::corner_radius::v1::server::{
cosmic_corner_radius_manager_v1, cosmic_corner_radius_toplevel_v1,
};
use smithay::utils::HookId;
use smithay::desktop::utils::bbox_from_surface_tree;
use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_popup::XdgPopup;
use smithay::reexports::wayland_protocols_wlr::layer_shell::v1::server::zwlr_layer_surface_v1::ZwlrLayerSurfaceV1;
use smithay::reexports::wayland_server::New;
use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
use smithay::utils::{HookId, Logical, Point, Rectangle};
use smithay::wayland::compositor::Cacheable;
use smithay::wayland::compositor::add_pre_commit_hook;
use smithay::wayland::compositor::with_states;
use smithay::wayland::shell::xdg::SurfaceCachedState;
use smithay::wayland::shell::wlr_layer::WlrLayerShellHandler;
use smithay::wayland::shell::xdg::{SurfaceCachedState, XdgShellSurfaceUserData};
use smithay::{
reexports::{
wayland_protocols::xdg::shell::server::xdg_toplevel::XdgToplevel,
@ -18,6 +27,7 @@ use std::sync::Mutex;
use wayland_backend::server::GlobalId;
type ToplevelHookId = Mutex<Option<(HookId, Weak<CosmicCornerRadiusToplevelV1>)>>;
type LayerHookId = Mutex<Option<(HookId, Weak<CosmicCornerRadiusLayerV1>)>>;
#[derive(Debug)]
pub struct CornerRadiusState {
@ -33,12 +43,13 @@ impl CornerRadiusState {
+ Dispatch<
cosmic_corner_radius_toplevel_v1::CosmicCornerRadiusToplevelV1,
CornerRadiusData,
> + CornerRadiusHandler
> + Dispatch<cosmic_corner_radius_layer_v1::CosmicCornerRadiusLayerV1, CornerRadiusData>
+ CornerRadiusHandler
+ 'static,
{
let global = dh
.create_global::<D, cosmic_corner_radius_manager_v1::CosmicCornerRadiusManagerV1, _>(
1,
2,
(),
);
CornerRadiusState {
@ -52,18 +63,12 @@ impl CornerRadiusState {
}
}
pub trait CornerRadiusHandler: XdgShellHandler {
pub trait CornerRadiusHandler: XdgShellHandler + WlrLayerShellHandler {
fn corner_radius_state(&mut self) -> &mut CornerRadiusState;
fn set_corner_radius(
&mut self,
toplevel: &cosmic_corner_radius_toplevel_v1::CosmicCornerRadiusToplevelV1,
data: &CornerRadiusData,
);
fn unset_corner_radius(
&mut self,
toplevel: &cosmic_corner_radius_toplevel_v1::CosmicCornerRadiusToplevelV1,
data: &CornerRadiusData,
);
fn set_corner_radius(&mut self, data: &CornerRadiusData);
fn unset_corner_radius(&mut self, data: &CornerRadiusData);
fn set_padding(&mut self, data: &CornerRadiusData);
fn unset_padding(&mut self, data: &CornerRadiusData);
}
impl<D> GlobalDispatch<cosmic_corner_radius_manager_v1::CosmicCornerRadiusManagerV1, (), D>
@ -72,6 +77,7 @@ where
D: GlobalDispatch<cosmic_corner_radius_manager_v1::CosmicCornerRadiusManagerV1, ()>
+ Dispatch<cosmic_corner_radius_manager_v1::CosmicCornerRadiusManagerV1, ()>
+ Dispatch<cosmic_corner_radius_toplevel_v1::CosmicCornerRadiusToplevelV1, CornerRadiusData>
+ Dispatch<cosmic_corner_radius_layer_v1::CosmicCornerRadiusLayerV1, CornerRadiusData>
+ CornerRadiusHandler
+ 'static,
{
@ -96,6 +102,7 @@ where
D: GlobalDispatch<cosmic_corner_radius_manager_v1::CosmicCornerRadiusManagerV1, ()>
+ Dispatch<cosmic_corner_radius_manager_v1::CosmicCornerRadiusManagerV1, ()>
+ Dispatch<cosmic_corner_radius_toplevel_v1::CosmicCornerRadiusToplevelV1, CornerRadiusData>
+ Dispatch<cosmic_corner_radius_layer_v1::CosmicCornerRadiusLayerV1, CornerRadiusData>
+ CornerRadiusHandler
+ 'static,
{
@ -115,6 +122,71 @@ where
}
cosmic_corner_radius_manager_v1::Request::GetCornerRadius { id, toplevel } => {
if let Some(surface) = state.xdg_shell_state().get_toplevel(&toplevel) {
new_xdg(
surface.wl_surface(),
CornerRadiusSurface::Toplevel(surface.xdg_toplevel().downgrade()),
resource,
data_init,
id,
)
} // TODO: can this fail?
}
cosmic_corner_radius_manager_v1::Request::GetCornerRadiusSurface { id, surface } => {
if let Some(toplevel) =
state
.xdg_shell_state()
.toplevel_surfaces()
.iter()
.find(|toplevel| {
toplevel
.xdg_toplevel()
.data::<XdgShellSurfaceUserData>()
.unwrap()
.xdg_surface()
== &surface
})
{
new_xdg(
toplevel.wl_surface(),
CornerRadiusSurface::Toplevel(toplevel.xdg_toplevel().downgrade()),
resource,
data_init,
id,
)
} else if let Some(popup) =
state
.xdg_shell_state()
.popup_surfaces()
.iter()
.find(|popup| {
popup
.xdg_popup()
.data::<XdgShellSurfaceUserData>()
.unwrap()
.xdg_surface()
== &surface
})
{
new_xdg(
popup.wl_surface(),
CornerRadiusSurface::Popup(popup.xdg_popup().downgrade()),
resource,
data_init,
id,
)
} else {
resource.post_error(
cosmic_corner_radius_manager_v1::Error::NoRole as u32,
"xdg_surface has no known role object".to_string(),
);
}
}
cosmic_corner_radius_manager_v1::Request::GetCornerRadiusLayer { id, layer } => {
if let Some(surface) = state
.shell_state()
.layer_surfaces()
.find(|surface| surface.shell_surface() == &layer)
{
let radius_exists = with_states(surface.wl_surface(), |surface_data| {
let hook_id = surface_data
.data_map
@ -124,63 +196,33 @@ where
});
if radius_exists.unwrap_or_default() {
resource.post_error(
cosmic_corner_radius_manager_v1::Error::CornerRadiusExists as u32,
format!("{resource:?} CosmicCornerRadiusToplevelV1 object already exists for the surface"),
);
cosmic_corner_radius_manager_v1::Error::CornerRadiusExists as u32,
format!(
"{resource:?} CosmicCornerRadiusToplevelV1 object already exists for the surface"
),
);
}
let data = Mutex::new(CornerRadiusInternal {
toplevel: toplevel.downgrade(),
surface: CornerRadiusSurface::Layer(layer.downgrade()),
corners: None,
padding: None,
});
let obj = data_init.init(id, data);
let obj_downgrade = obj.downgrade();
let needs_hook = radius_exists.is_none();
if needs_hook {
let hook_id = add_pre_commit_hook::<D, _>(
surface.wl_surface(),
move |_, _dh, surface| {
let corner_radii_too_big = with_states(surface, |surface_data| {
let corners = *surface_data
.cached_state
.get::<CacheableCorners>()
.pending();
surface_data
.cached_state
.get::<SurfaceCachedState>()
.pending()
.geometry
.zip(corners.0.as_ref())
.is_some_and(|(geo, corners)| {
let half_min_dim =
u8::try_from(geo.size.w.min(geo.size.h) / 2)
.unwrap_or(u8::MAX);
corners.top_right > half_min_dim
|| corners.top_left > half_min_dim
|| corners.bottom_right > half_min_dim
|| corners.bottom_left > half_min_dim
})
});
if corner_radii_too_big {
obj.post_error(
cosmic_corner_radius_toplevel_v1::Error::RadiusTooLarge
as u32,
format!("{obj:?} corner radius too large"),
);
}
},
);
let hook_id =
add_pre_commit_hook::<D, _>(surface.wl_surface(), layer_radius_hook);
with_states(surface.wl_surface(), |surface_data| {
let hook_ids = surface_data
.data_map
.get_or_insert_threadsafe(|| ToplevelHookId::new(None));
.get_or_insert_threadsafe(|| LayerHookId::new(None));
let mut guard = hook_ids.lock().unwrap();
*guard = Some((hook_id, obj_downgrade));
});
}
}
} // TODO: can this fail?
}
_ => unimplemented!(),
}
@ -197,6 +239,55 @@ where
}
}
fn new_xdg<D>(
wl_surface: &WlSurface,
surface: CornerRadiusSurface,
resource: &cosmic_corner_radius_manager_v1::CosmicCornerRadiusManagerV1,
data_init: &mut smithay::reexports::wayland_server::DataInit<'_, D>,
id: New<cosmic_corner_radius_toplevel_v1::CosmicCornerRadiusToplevelV1>,
) where
D: GlobalDispatch<cosmic_corner_radius_manager_v1::CosmicCornerRadiusManagerV1, ()>
+ Dispatch<cosmic_corner_radius_manager_v1::CosmicCornerRadiusManagerV1, ()>
+ Dispatch<cosmic_corner_radius_toplevel_v1::CosmicCornerRadiusToplevelV1, CornerRadiusData>
+ CornerRadiusHandler
+ 'static,
{
let radius_exists = with_states(wl_surface, |surface_data| {
let hook_id = surface_data
.data_map
.get_or_insert_threadsafe(|| ToplevelHookId::new(None));
let guard = hook_id.lock().unwrap();
guard.as_ref().map(|(_, t)| t.upgrade().is_ok())
});
if radius_exists.unwrap_or_default() {
resource.post_error(
cosmic_corner_radius_manager_v1::Error::CornerRadiusExists as u32,
format!(
"{resource:?} CosmicCornerRadiusToplevelV1 object already exists for the surface"
),
);
}
let data = Mutex::new(CornerRadiusInternal {
surface,
corners: None,
padding: None,
});
let obj = data_init.init(id, data);
let obj_downgrade = obj.downgrade();
let needs_hook = radius_exists.is_none();
if needs_hook {
let hook_id = add_pre_commit_hook::<D, _>(wl_surface, xdg_radius_hook);
with_states(wl_surface, |surface_data| {
let hook_ids = surface_data
.data_map
.get_or_insert_threadsafe(|| ToplevelHookId::new(None));
let mut guard = hook_ids.lock().unwrap();
*guard = Some((hook_id, obj_downgrade));
});
}
}
impl<D>
Dispatch<cosmic_corner_radius_toplevel_v1::CosmicCornerRadiusToplevelV1, CornerRadiusData, D>
for CornerRadiusState
@ -221,30 +312,35 @@ where
let mut guard = data.lock().unwrap();
guard.corners = None;
let Ok(toplevel) = guard.toplevel.upgrade() else {
let Some(wl_surface) = (match &guard.surface {
CornerRadiusSurface::Toplevel(toplevel) => toplevel
.upgrade()
.ok()
.and_then(|toplevel| state.xdg_shell_state().get_toplevel(&toplevel))
.map(|toplevel| toplevel.wl_surface().clone()),
CornerRadiusSurface::Popup(popup) => popup
.upgrade()
.ok()
.and_then(|popup| state.xdg_shell_state().get_popup(&popup))
.map(|popup| popup.wl_surface().clone()),
CornerRadiusSurface::Layer(_) => unreachable!(),
}) else {
return;
};
if let Some(surface) = state.xdg_shell_state().get_toplevel(&toplevel) {
with_states(surface.wl_surface(), |surface_data| {
if let Some(hook_ids_mutex) = surface_data.data_map.get::<ToplevelHookId>()
{
let mut hook_id = hook_ids_mutex.lock().unwrap();
*hook_id = None;
}
});
}
with_states(&wl_surface, |surface_data| {
if let Some(hook_ids_mutex) = surface_data.data_map.get::<ToplevelHookId>() {
let mut hook_id = hook_ids_mutex.lock().unwrap();
*hook_id = None;
}
if let Some(surface) = state.xdg_shell_state().get_toplevel(&toplevel) {
with_states(surface.wl_surface(), |s| {
let mut cached = s.cached_state.get::<CacheableCorners>();
let pending = cached.pending();
*pending = CacheableCorners(None);
});
}
let mut cached = surface_data.cached_state.get::<CacheableCorners>();
let pending = cached.pending();
*pending = CacheableCorners(None);
});
drop(guard);
state.unset_corner_radius(resource, data);
state.unset_corner_radius(data);
}
cosmic_corner_radius_toplevel_v1::Request::SetRadius {
top_left,
@ -254,66 +350,388 @@ where
} => {
let mut guard = data.lock().unwrap();
guard.set_corner_radius(top_left, top_right, bottom_right, bottom_left);
let Ok(toplevel) = guard.toplevel.upgrade() else {
let Some(wl_surface) = (match &guard.surface {
CornerRadiusSurface::Toplevel(toplevel) => toplevel
.upgrade()
.ok()
.and_then(|toplevel| state.xdg_shell_state().get_toplevel(&toplevel))
.map(|toplevel| toplevel.wl_surface().clone()),
CornerRadiusSurface::Popup(popup) => popup
.upgrade()
.ok()
.and_then(|popup| state.xdg_shell_state().get_popup(&popup))
.map(|popup| popup.wl_surface().clone()),
CornerRadiusSurface::Layer(_) => unreachable!(),
}) else {
resource.post_error(
cosmic_corner_radius_toplevel_v1::Error::ToplevelDestroyed as u32,
format!("{:?} No toplevel found", resource),
);
return;
};
if let Some(surface) = state.xdg_shell_state().get_toplevel(&toplevel) {
with_states(surface.wl_surface(), |s| {
let mut cached = s.cached_state.get::<CacheableCorners>();
let pending = cached.pending();
*pending = CacheableCorners(guard.corners);
});
}
with_states(&wl_surface, |s| {
let mut cached = s.cached_state.get::<CacheableCorners>();
let pending = cached.pending();
*pending = CacheableCorners(guard.corners);
});
drop(guard);
state.set_corner_radius(resource, data);
state.set_corner_radius(data);
}
cosmic_corner_radius_toplevel_v1::Request::UnsetRadius => {
let mut guard = data.lock().unwrap();
guard.corners = None;
let Ok(toplevel) = guard.toplevel.upgrade() else {
let Some(wl_surface) = (match &guard.surface {
CornerRadiusSurface::Toplevel(toplevel) => toplevel
.upgrade()
.ok()
.and_then(|toplevel| state.xdg_shell_state().get_toplevel(&toplevel))
.map(|toplevel| toplevel.wl_surface().clone()),
CornerRadiusSurface::Popup(popup) => popup
.upgrade()
.ok()
.and_then(|popup| state.xdg_shell_state().get_popup(&popup))
.map(|popup| popup.wl_surface().clone()),
CornerRadiusSurface::Layer(_) => unreachable!(),
}) else {
resource.post_error(
cosmic_corner_radius_toplevel_v1::Error::ToplevelDestroyed as u32,
format!("{:?} No toplevel found", resource),
);
return;
};
if let Some(surface) = state.xdg_shell_state().get_toplevel(&toplevel) {
with_states(surface.wl_surface(), |s| {
let mut cached = s.cached_state.get::<CacheableCorners>();
let pending = cached.pending();
*pending = CacheableCorners(None);
});
}
with_states(&wl_surface, |s| {
let mut cached = s.cached_state.get::<CacheableCorners>();
let pending = cached.pending();
*pending = CacheableCorners(None);
});
drop(guard);
state.unset_corner_radius(resource, data);
state.unset_corner_radius(data);
}
_ => unimplemented!(),
}
}
}
impl<D> Dispatch<cosmic_corner_radius_layer_v1::CosmicCornerRadiusLayerV1, CornerRadiusData, D>
for CornerRadiusState
where
D: GlobalDispatch<cosmic_corner_radius_manager_v1::CosmicCornerRadiusManagerV1, ()>
+ Dispatch<cosmic_corner_radius_manager_v1::CosmicCornerRadiusManagerV1, ()>
+ Dispatch<cosmic_corner_radius_layer_v1::CosmicCornerRadiusLayerV1, CornerRadiusData>
+ CornerRadiusHandler
+ 'static,
{
fn request(
state: &mut D,
_client: &Client,
resource: &cosmic_corner_radius_layer_v1::CosmicCornerRadiusLayerV1,
request: <cosmic_corner_radius_layer_v1::CosmicCornerRadiusLayerV1 as Resource>::Request,
data: &CornerRadiusData,
_dhandle: &DisplayHandle,
_data_init: &mut smithay::reexports::wayland_server::DataInit<'_, D>,
) {
match request {
cosmic_corner_radius_layer_v1::Request::Destroy => {
let mut guard = data.lock().unwrap();
guard.corners = None;
let CornerRadiusSurface::Layer(layer_surface) = &guard.surface else {
unreachable!("corner_radius_layer without layer shell?");
};
let Some(layer_surface) = layer_surface.upgrade().ok().and_then(|layer| {
state
.shell_state()
.layer_surfaces()
.find(|s| s.shell_surface() == &layer)
}) else {
resource.post_error(
cosmic_corner_radius_layer_v1::Error::LayerDestroyed as u32,
format!("{:?} No layer found", resource),
);
return;
};
with_states(layer_surface.wl_surface(), |surface_data| {
if let Some(hook_ids_mutex) = surface_data.data_map.get::<LayerHookId>() {
let mut hook_id = hook_ids_mutex.lock().unwrap();
*hook_id = None;
}
let mut cached = surface_data.cached_state.get::<CacheableCorners>();
let pending = cached.pending();
*pending = CacheableCorners(None);
let mut cached = surface_data.cached_state.get::<CacheablePadding>();
let pending = cached.pending();
*pending = CacheablePadding(None);
});
drop(guard);
state.unset_corner_radius(data);
state.unset_padding(data);
}
cosmic_corner_radius_layer_v1::Request::SetRadius {
top_left,
top_right,
bottom_right,
bottom_left,
} => {
let mut guard = data.lock().unwrap();
guard.set_corner_radius(top_left, top_right, bottom_right, bottom_left);
let CornerRadiusSurface::Layer(layer_surface) = &guard.surface else {
unreachable!("corner_radius_layer without layer shell?");
};
let Some(layer_surface) = layer_surface.upgrade().ok().and_then(|layer| {
state
.shell_state()
.layer_surfaces()
.find(|s| s.shell_surface() == &layer)
}) else {
resource.post_error(
cosmic_corner_radius_layer_v1::Error::LayerDestroyed as u32,
format!("{:?} No layer found", resource),
);
return;
};
with_states(layer_surface.wl_surface(), |s| {
let mut cached = s.cached_state.get::<CacheableCorners>();
let pending = cached.pending();
*pending = CacheableCorners(guard.corners);
});
drop(guard);
state.set_corner_radius(data);
}
cosmic_corner_radius_layer_v1::Request::UnsetRadius => {
let mut guard = data.lock().unwrap();
guard.corners = None;
let CornerRadiusSurface::Layer(layer_surface) = &guard.surface else {
unreachable!("corner_radius_layer without layer shell?");
};
let Some(layer_surface) = layer_surface.upgrade().ok().and_then(|layer| {
state
.shell_state()
.layer_surfaces()
.find(|s| s.shell_surface() == &layer)
}) else {
resource.post_error(
cosmic_corner_radius_layer_v1::Error::LayerDestroyed as u32,
format!("{:?} No layer found", resource),
);
return;
};
with_states(layer_surface.wl_surface(), |s| {
let mut cached = s.cached_state.get::<CacheableCorners>();
let pending = cached.pending();
*pending = CacheableCorners(None);
});
drop(guard);
state.unset_corner_radius(data);
}
cosmic_corner_radius_layer_v1::Request::SetPadding {
top,
right,
bottom,
left,
} => {
let mut guard = data.lock().unwrap();
guard.set_padding(top, right, bottom, left);
let CornerRadiusSurface::Layer(layer_surface) = &guard.surface else {
unreachable!("corner_radius_layer without layer shell?");
};
let Some(layer_surface) = layer_surface.upgrade().ok().and_then(|layer| {
state
.shell_state()
.layer_surfaces()
.find(|s| s.shell_surface() == &layer)
}) else {
resource.post_error(
cosmic_corner_radius_layer_v1::Error::LayerDestroyed as u32,
format!("{:?} No layer found", resource),
);
return;
};
with_states(layer_surface.wl_surface(), |s| {
let mut cached = s.cached_state.get::<CacheablePadding>();
let pending = cached.pending();
*pending = CacheablePadding(guard.padding);
});
drop(guard);
state.set_padding(data);
}
cosmic_corner_radius_layer_v1::Request::UnsetPadding => {
let mut guard = data.lock().unwrap();
guard.corners = None;
let CornerRadiusSurface::Layer(layer_surface) = &guard.surface else {
unreachable!("corner_radius_layer without layer shell?");
};
let Some(layer_surface) = layer_surface.upgrade().ok().and_then(|layer| {
state
.shell_state()
.layer_surfaces()
.find(|s| s.shell_surface() == &layer)
}) else {
resource.post_error(
cosmic_corner_radius_layer_v1::Error::LayerDestroyed as u32,
format!("{:?} No layer found", resource),
);
return;
};
with_states(layer_surface.wl_surface(), |s| {
let mut cached = s.cached_state.get::<CacheablePadding>();
let pending = cached.pending();
*pending = CacheablePadding(None);
});
drop(guard);
state.unset_padding(data);
}
_ => unimplemented!(),
}
}
}
fn xdg_radius_hook<D: 'static>(_state: &mut D, _dh: &DisplayHandle, surface: &WlSurface) {
with_states(surface, |surface_data| {
let corners = *surface_data
.cached_state
.get::<CacheableCorners>()
.pending();
if surface_data
.cached_state
.get::<SurfaceCachedState>()
.pending()
.geometry
.zip(corners.0.as_ref())
.is_some_and(|(geo, corners)| {
let half_min_dim = (geo.size.w.min(geo.size.h) / 2) as u32;
corners.top_right > half_min_dim
|| corners.top_left > half_min_dim
|| corners.bottom_right > half_min_dim
|| corners.bottom_left > half_min_dim
})
&& let Some(hook) = surface_data.data_map.get::<ToplevelHookId>()
{
let hook_ref = hook.lock().unwrap();
if let Some((_, obj)) = hook_ref.as_ref()
&& let Ok(obj) = obj.upgrade()
{
obj.post_error(
cosmic_corner_radius_toplevel_v1::Error::RadiusTooLarge as u32,
format!("{obj:?} corner radius too large"),
);
}
}
});
}
fn pad_rect(
mut rect: Rectangle<i32, Logical>,
padding: &Padding,
) -> Option<Rectangle<i32, Logical>> {
rect.size.h = rect.size.h.checked_sub(padding.top)?;
rect.loc.x += padding.left;
rect.size.w = rect.size.w.checked_sub(padding.left)?;
rect.loc.y += padding.top;
rect.size.h = rect.size.h.checked_sub(padding.bottom)?;
rect.size.w = rect.size.w.checked_sub(padding.right)?;
Some(rect)
}
fn layer_radius_hook<D: 'static>(_state: &mut D, _dh: &DisplayHandle, surface: &WlSurface) {
let bbox = bbox_from_surface_tree(surface, Point::default());
with_states(surface, |surface_data| {
let corners = *surface_data
.cached_state
.get::<CacheableCorners>()
.pending();
let padding = *surface_data
.cached_state
.get::<CacheablePadding>()
.pending();
let empty = Padding::default();
let Some(padded_box) = pad_rect(bbox, padding.0.as_ref().unwrap_or(&empty)) else {
if let Some(hook) = surface_data.data_map.get::<LayerHookId>() {
let hook_ref = hook.lock().unwrap();
if let Some((_, obj)) = hook_ref.as_ref()
&& let Ok(obj) = obj.upgrade()
{
obj.post_error(
cosmic_corner_radius_layer_v1::Error::PaddingTooLarge as u32,
format!("{obj:?} padding too large"),
);
}
}
return;
};
if corners.0.as_ref().is_some_and(|corners| {
let half_min_dim = (padded_box.size.w.min(padded_box.size.h) / 2) as u32;
corners.top_right > half_min_dim
|| corners.top_left > half_min_dim
|| corners.bottom_right > half_min_dim
|| corners.bottom_left > half_min_dim
}) && let Some(hook) = surface_data.data_map.get::<LayerHookId>()
{
let hook_ref = hook.lock().unwrap();
if let Some((_, obj)) = hook_ref.as_ref()
&& let Ok(obj) = obj.upgrade()
{
obj.post_error(
cosmic_corner_radius_layer_v1::Error::RadiusTooLarge as u32,
format!("{obj:?} corner radius too large"),
);
}
}
});
}
pub type CornerRadiusData = Mutex<CornerRadiusInternal>;
#[derive(Debug)]
pub enum CornerRadiusSurface {
Toplevel(Weak<XdgToplevel>),
Popup(Weak<XdgPopup>),
Layer(Weak<ZwlrLayerSurfaceV1>),
}
#[derive(Debug)]
pub struct CornerRadiusInternal {
pub toplevel: Weak<XdgToplevel>,
pub surface: CornerRadiusSurface,
pub corners: Option<Corners>,
pub padding: Option<Padding>,
}
#[derive(Debug, Copy, Clone)]
pub struct Corners {
pub top_left: u8,
pub top_right: u8,
pub bottom_right: u8,
pub bottom_left: u8,
pub top_left: u32,
pub top_right: u32,
pub bottom_right: u32,
pub bottom_left: u32,
}
#[derive(Debug, Copy, Clone, Default)]
pub struct Padding {
pub top: i32,
pub right: i32,
pub bottom: i32,
pub left: i32,
}
#[derive(Default, Debug, Copy, Clone)]
@ -328,6 +746,18 @@ impl Cacheable for CacheableCorners {
}
}
#[derive(Default, Debug, Copy, Clone)]
pub struct CacheablePadding(pub Option<Padding>);
impl Cacheable for CacheablePadding {
fn commit(&mut self, _dh: &DisplayHandle) -> Self {
*self
}
fn merge_into(self, into: &mut Self, _dh: &DisplayHandle) {
*into = self;
}
}
impl CornerRadiusInternal {
fn set_corner_radius(
&mut self,
@ -337,13 +767,23 @@ impl CornerRadiusInternal {
bottom_left: u32,
) {
let corners = Corners {
top_left: top_left.clamp(u8::MIN as u32, u8::MAX as u32) as u8,
top_right: top_right.clamp(u8::MIN as u32, u8::MAX as u32) as u8,
bottom_right: bottom_right.clamp(u8::MIN as u32, u8::MAX as u32) as u8,
bottom_left: bottom_left.clamp(u8::MIN as u32, u8::MAX as u32) as u8,
top_left,
top_right,
bottom_right,
bottom_left,
};
self.corners = Some(corners);
}
fn set_padding(&mut self, top: i32, right: i32, bottom: i32, left: i32) {
let padding = Padding {
top,
right,
bottom,
left,
};
self.padding = Some(padding);
}
}
macro_rules! delegate_corner_radius {
@ -357,6 +797,9 @@ macro_rules! delegate_corner_radius {
smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
cosmic_protocols::corner_radius::v1::server::cosmic_corner_radius_toplevel_v1::CosmicCornerRadiusToplevelV1: CornerRadiusData
] => $crate::wayland::protocols::corner_radius::CornerRadiusState);
smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
cosmic_protocols::corner_radius::v1::server::cosmic_corner_radius_layer_v1::CosmicCornerRadiusLayerV1: CornerRadiusData
] => $crate::wayland::protocols::corner_radius::CornerRadiusState);
};
}
pub(crate) use delegate_corner_radius;

2
src/wayland/protocols/drm.rs
View file

@ -180,7 +180,7 @@ where
Modifier::Invalid,
DmabufFlags::empty(),
);
dma.add_plane(name, 0, offset0 as u32, stride0 as u32);
dma.add_plane(name, offset0 as u32, stride0 as u32);
match dma.build() {
Some(dmabuf) => {
match state.dmabuf_imported(&data.dmabuf_global, dmabuf.clone()) {

185
src/wayland/protocols/keyboard_layout.rs Normal file
View file

@ -0,0 +1,185 @@
// SPDX-License-Identifier: GPL-3.0-only
use cosmic_protocols::keyboard_layout::v1::server::{
zcosmic_keyboard_layout_manager_v1::{self, ZcosmicKeyboardLayoutManagerV1},
zcosmic_keyboard_layout_v1::{self, ZcosmicKeyboardLayoutV1},
};
use smithay::{
input::{
SeatHandler,
keyboard::{KeyboardHandle, Layout},
},
reexports::wayland_server::{
Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,
},
wayland::{Dispatch2, GlobalDispatch2},
};
use std::mem;
use wayland_backend::server::{ClientId, GlobalId};
pub trait KeyboardLayoutHandler {
fn keyboard_layout_state(&mut self) -> &mut KeyboardLayoutState;
}
#[derive(Debug)]
pub struct KeyboardLayoutState {
pub global: GlobalId,
keyboard_layouts: Vec<(ZcosmicKeyboardLayoutV1, Option<Layout>)>,
}
impl KeyboardLayoutState {
pub fn new<D, F>(dh: &DisplayHandle, client_filter: F) -> Self
where
D: GlobalDispatch<ZcosmicKeyboardLayoutManagerV1, LayoutGlobalData> + 'static,
F: for<'a> Fn(&'a Client) -> bool + Send + Sync + 'static,
{
let global = dh.create_global::<D, ZcosmicKeyboardLayoutManagerV1, _>(
1,
LayoutGlobalData {
filter: Box::new(client_filter),
},
);
KeyboardLayoutState {
global,
keyboard_layouts: Vec::new(),
}
}
pub fn refresh<D>(state: &mut D)
where
D: SeatHandler + KeyboardLayoutHandler + 'static,
{
let mut keyboard_layouts = mem::take(&mut state.keyboard_layout_state().keyboard_layouts);
for (keyboard_layout, last_layout) in &mut keyboard_layouts {
if let Some(data) = keyboard_layout.data::<LayoutUserData<D>>() {
if let Some(handle) = &data.handle {
let active_layout = handle.with_xkb_state(state, |context| {
context.xkb().lock().unwrap().active_layout()
});
if *last_layout != Some(active_layout) {
keyboard_layout.group(active_layout.0);
*last_layout = Some(active_layout);
}
}
}
}
state.keyboard_layout_state().keyboard_layouts = keyboard_layouts;
}
}
pub struct LayoutGlobalData {
filter: Box<dyn for<'a> Fn(&'a Client) -> bool + Send + Sync>,
}
struct LayoutManagerData;
impl<D> GlobalDispatch2<ZcosmicKeyboardLayoutManagerV1, D> for LayoutGlobalData
where
D: Dispatch<ZcosmicKeyboardLayoutManagerV1, LayoutManagerData> + 'static,
{
fn bind(
&self,
_state: &mut D,
_handle: &DisplayHandle,
_client: &Client,
resource: New<ZcosmicKeyboardLayoutManagerV1>,
data_init: &mut DataInit<'_, D>,
) {
data_init.init(resource, LayoutManagerData);
}
fn can_view(&self, client: &Client) -> bool {
(self.filter)(client)
}
}
impl<D> Dispatch2<ZcosmicKeyboardLayoutManagerV1, D> for LayoutManagerData
where
D: Dispatch<ZcosmicKeyboardLayoutV1, LayoutUserData<D>>,
D: 'static,
D: SeatHandler,
D: KeyboardLayoutHandler,
{
fn request(
&self,
state: &mut D,
_client: &Client,
_resource: &ZcosmicKeyboardLayoutManagerV1,
request: zcosmic_keyboard_layout_manager_v1::Request,
_dhandle: &DisplayHandle,
data_init: &mut DataInit<'_, D>,
) {
match request {
zcosmic_keyboard_layout_manager_v1::Request::GetKeyboardLayout {
keyboard_layout,
keyboard,
} => {
let handle = KeyboardHandle::<D>::from_resource(&keyboard);
let active_layout = handle.as_ref().map(|handle| {
handle.with_xkb_state(state, |context| {
context.xkb().lock().unwrap().active_layout()
})
});
let keyboard_layout = data_init.init(keyboard_layout, LayoutUserData { handle });
if let Some(layout) = active_layout {
keyboard_layout.group(layout.0);
}
state
.keyboard_layout_state()
.keyboard_layouts
.push((keyboard_layout, active_layout));
}
zcosmic_keyboard_layout_manager_v1::Request::Destroy => {}
_ => unreachable!(),
}
}
}
#[doc(hidden)]
struct LayoutUserData<D: SeatHandler> {
handle: Option<KeyboardHandle<D>>,
}
impl<D> Dispatch2<ZcosmicKeyboardLayoutV1, D> for LayoutUserData<D>
where
D: 'static,
D: SeatHandler,
D: KeyboardLayoutHandler,
{
fn request(
&self,
state: &mut D,
_client: &Client,
_resource: &ZcosmicKeyboardLayoutV1,
request: zcosmic_keyboard_layout_v1::Request,
_dhandle: &DisplayHandle,
_data_init: &mut DataInit<'_, D>,
) {
match request {
zcosmic_keyboard_layout_v1::Request::SetGroup { group } => {
if let Some(handle) = self.handle.as_ref() {
handle.with_xkb_state(state, |mut context| {
context.set_layout(Layout(group));
});
}
}
zcosmic_keyboard_layout_v1::Request::Destroy => {}
_ => unreachable!(),
}
}
fn destroyed(
&self,
state: &mut D,
_client: ClientId,
keyboard_layout: &ZcosmicKeyboardLayoutV1,
) {
let keyboard_layouts = &mut state.keyboard_layout_state().keyboard_layouts;
if let Some(idx) = keyboard_layouts
.iter()
.position(|(x, _)| x == keyboard_layout)
{
keyboard_layouts.remove(idx);
}
}
}

1
src/wayland/protocols/mod.rs
View file

@ -4,6 +4,7 @@ pub mod a11y;
pub mod corner_radius;
pub mod drm;
pub mod image_capture_source;
pub mod keyboard_layout;
pub mod output_configuration;
pub mod output_power;
pub mod overlap_notify;

1
src/xwayland.rs
View file

@ -115,6 +115,7 @@ impl State {
&self.common.display_handle,
None,
std::iter::empty::<(OsString, OsString)>(),
std::iter::empty::<OsString>(),
true,
Stdio::null(),
Stdio::null(),