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

deps: Update smithay

Browse source
This commit is contained in:
Victoria Brekenfeld 2023-01-03 19:17:51 +01:00
parent ec647597f1
commit 8a2e1e5c89
10 changed files with 334 additions and 316 deletions
Download patch file Download diff file Expand all files Collapse all files

142
Cargo.lock generated
View file

@ -352,7 +352,7 @@ dependencies = [
"smithay-egui", "smithay-egui",
"thiserror", "thiserror",
"wayland-backend", "wayland-backend",
"wayland-scanner 0.30.0-beta.15", "wayland-scanner 0.30.0",
"xcursor", "xcursor",
"xdg", "xdg",
"xkbcommon 0.4.1", "xkbcommon 0.4.1",
@ -365,8 +365,8 @@ source = "git+https://github.com/pop-os/cosmic-protocols?branch=main#a3e0aa740a3
dependencies = [ dependencies = [
"bitflags", "bitflags",
"wayland-backend", "wayland-backend",
"wayland-protocols 0.30.0-beta.15", "wayland-protocols 0.30.0",
"wayland-scanner 0.30.0-beta.15", "wayland-scanner 0.30.0",
"wayland-server", "wayland-server",
] ]
@ -650,6 +650,70 @@ dependencies = [
"bytemuck", "bytemuck",
] ]
[[package]]
name = "encoding"
version = "0.2.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6b0d943856b990d12d3b55b359144ff341533e516d94098b1d3fc1ac666d36ec"
dependencies = [
"encoding-index-japanese",
"encoding-index-korean",
"encoding-index-simpchinese",
"encoding-index-singlebyte",
"encoding-index-tradchinese",
]
[[package]]
name = "encoding-index-japanese"
version = "1.20141219.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "04e8b2ff42e9a05335dbf8b5c6f7567e5591d0d916ccef4e0b1710d32a0d0c91"
dependencies = [
"encoding_index_tests",
]
[[package]]
name = "encoding-index-korean"
version = "1.20141219.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4dc33fb8e6bcba213fe2f14275f0963fd16f0a02c878e3095ecfdf5bee529d81"
dependencies = [
"encoding_index_tests",
]
[[package]]
name = "encoding-index-simpchinese"
version = "1.20141219.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d87a7194909b9118fc707194baa434a4e3b0fb6a5a757c73c3adb07aa25031f7"
dependencies = [
"encoding_index_tests",
]
[[package]]
name = "encoding-index-singlebyte"
version = "1.20141219.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3351d5acffb224af9ca265f435b859c7c01537c0849754d3db3fdf2bfe2ae84a"
dependencies = [
"encoding_index_tests",
]
[[package]]
name = "encoding-index-tradchinese"
version = "1.20141219.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fd0e20d5688ce3cab59eb3ef3a2083a5c77bf496cb798dc6fcdb75f323890c18"
dependencies = [
"encoding_index_tests",
]
[[package]]
name = "encoding_index_tests"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a246d82be1c9d791c5dfde9a2bd045fc3cbba3fa2b11ad558f27d01712f00569"
[[package]] [[package]]
name = "epaint" name = "epaint"
version = "0.19.0" version = "0.19.0"
@ -1309,6 +1373,19 @@ dependencies = [
"memoffset 0.6.5", "memoffset 0.6.5",
] ]
[[package]]
name = "nix"
version = "0.26.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "46a58d1d356c6597d08cde02c2f09d785b09e28711837b1ed667dc652c08a694"
dependencies = [
"bitflags",
"cfg-if",
"libc",
"memoffset 0.7.1",
"static_assertions",
]
[[package]] [[package]]
name = "nohash-hasher" name = "nohash-hasher"
version = "0.2.0" version = "0.2.0"
@ -1925,7 +2002,7 @@ checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
[[package]] [[package]]
name = "smithay" name = "smithay"
version = "0.3.0" version = "0.3.0"
source = "git+https://github.com/pop-os/smithay?rev=51368f56bc#51368f56bc459c7dc5b9eff0385cd0bc49db53b2" source = "git+https://github.com/pop-os/smithay?rev=2a05d8cd64#2a05d8cd648bc9689491ff5a996fd7713f23aa77"
dependencies = [ dependencies = [
"appendlist", "appendlist",
"bitflags", "bitflags",
@ -1936,6 +2013,7 @@ dependencies = [
"drm", "drm",
"drm-ffi", "drm-ffi",
"drm-fourcc", "drm-fourcc",
"encoding",
"gbm", "gbm",
"gl_generator", "gl_generator",
"glow", "glow",
@ -1950,6 +2028,7 @@ dependencies = [
"pkg-config", "pkg-config",
"rand", "rand",
"scan_fmt", "scan_fmt",
"scopeguard",
"slog", "slog",
"slog-stdlog", "slog-stdlog",
"tempfile", "tempfile",
@ -1957,7 +2036,7 @@ dependencies = [
"udev", "udev",
"wayland-backend", "wayland-backend",
"wayland-egl", "wayland-egl",
"wayland-protocols 0.30.0-beta.15", "wayland-protocols 0.30.0",
"wayland-protocols-misc", "wayland-protocols-misc",
"wayland-protocols-wlr", "wayland-protocols-wlr",
"wayland-server", "wayland-server",
@ -2007,6 +2086,12 @@ version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "27207bb65232eda1f588cf46db2fee75c0808d557f6b3cf19a75f5d6d7c94df1" checksum = "27207bb65232eda1f588cf46db2fee75c0808d557f6b3cf19a75f5d6d7c94df1"
[[package]]
name = "static_assertions"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
[[package]] [[package]]
name = "strsim" name = "strsim"
version = "0.10.0" version = "0.10.0"
@ -2362,14 +2447,14 @@ checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
[[package]] [[package]]
name = "wayland-backend" name = "wayland-backend"
version = "0.1.0-beta.15" version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5fd01ec68102e595371e585da12bb7d2785b93639a1b3a9f99f1030634c526ac" checksum = "fb23bfea266c92bb051ea36cce0eb1a52b743dc1c5f168021947eda79764656d"
dependencies = [ dependencies = [
"cc", "cc",
"downcast-rs", "downcast-rs",
"io-lifetimes", "io-lifetimes",
"nix 0.25.0", "nix 0.26.1",
"scoped-tls", "scoped-tls",
"smallvec", "smallvec",
"wayland-sys 0.30.1", "wayland-sys 0.30.1",
@ -2416,11 +2501,10 @@ dependencies = [
[[package]] [[package]]
name = "wayland-egl" name = "wayland-egl"
version = "0.30.0-beta.15" version = "0.30.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7bee5cad71e703c1cda119cd614ef8c8f1c6c5d04927c33f3485bdf22bef00db" checksum = "1187695fe81c3153c3163f9d2953149f638c5d7dbc6fe988914ca3f4961e28ed"
dependencies = [ dependencies = [
"thiserror",
"wayland-backend", "wayland-backend",
"wayland-sys 0.30.1", "wayland-sys 0.30.1",
] ]
@ -2439,39 +2523,39 @@ dependencies = [
[[package]] [[package]]
name = "wayland-protocols" name = "wayland-protocols"
version = "0.30.0-beta.15" version = "0.30.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "89c142821785f87f5c0c14d29b37b05b458a76f88f5b86d24e7be259e5659f48" checksum = "7fefbeb8a360abe67ab7c2efe1d297a1a50ee011f5460791bc18870c26bb84e2"
dependencies = [ dependencies = [
"bitflags", "bitflags",
"wayland-backend", "wayland-backend",
"wayland-scanner 0.30.0-beta.15", "wayland-scanner 0.30.0",
"wayland-server", "wayland-server",
] ]
[[package]] [[package]]
name = "wayland-protocols-misc" name = "wayland-protocols-misc"
version = "0.1.0-beta.15" version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ba9acd1d036b489da5036c257fe0b8bb815a202a35e6e7455f1262e2b6af0fc6" checksum = "897d4e99645e1ed9245e9e6b5efa78828d2b23b661016d63d55251243d812f8b"
dependencies = [ dependencies = [
"bitflags", "bitflags",
"wayland-backend", "wayland-backend",
"wayland-protocols 0.30.0-beta.15", "wayland-protocols 0.30.0",
"wayland-scanner 0.30.0-beta.15", "wayland-scanner 0.30.0",
"wayland-server", "wayland-server",
] ]
[[package]] [[package]]
name = "wayland-protocols-wlr" name = "wayland-protocols-wlr"
version = "0.1.0-beta.15" version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3fb9e3d2d11e195572835a6a447ed98a5201f461f32ebcf3e8d3ec9a0502cfd" checksum = "fce991093320e4a6a525876e6b629ab24da25f9baef0c2e0080ad173ec89588a"
dependencies = [ dependencies = [
"bitflags", "bitflags",
"wayland-backend", "wayland-backend",
"wayland-protocols 0.30.0-beta.15", "wayland-protocols 0.30.0",
"wayland-scanner 0.30.0-beta.15", "wayland-scanner 0.30.0",
"wayland-server", "wayland-server",
] ]
@ -2488,29 +2572,27 @@ dependencies = [
[[package]] [[package]]
name = "wayland-scanner" name = "wayland-scanner"
version = "0.30.0-beta.15" version = "0.30.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "528e351affadac21fa63ac149e68747a43500bd93d742c42b5b22473890fbfbb" checksum = "4834c14b3edf1d9986c83ca79b1e7e3afbe9874c7c144702f6467063259ce45d"
dependencies = [ dependencies = [
"proc-macro2", "proc-macro2",
"quick-xml", "quick-xml",
"quote", "quote",
"syn",
] ]
[[package]] [[package]]
name = "wayland-server" name = "wayland-server"
version = "0.30.0-beta.15" version = "0.30.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee9869ba2ca46e6689ef235a44ef1c452d7d7a89a3bc076411acf524ddf73bfa" checksum = "9062def387c1b1d80e366d8243c2b3bd6d9e4f343032a3e5da8d4aa03866cf89"
dependencies = [ dependencies = [
"bitflags", "bitflags",
"downcast-rs", "downcast-rs",
"io-lifetimes", "io-lifetimes",
"nix 0.25.0", "nix 0.26.1",
"thiserror",
"wayland-backend", "wayland-backend",
"wayland-scanner 0.30.0-beta.15", "wayland-scanner 0.30.0",
] ]
[[package]] [[package]]

8
Cargo.toml
View file

@ -32,8 +32,8 @@ indexmap = "1.8.0"
xdg = "^2.1" xdg = "^2.1"
ron = "0.7" ron = "0.7"
libsystemd = "0.5" libsystemd = "0.5"
wayland-backend = "=0.1.0-beta.15" wayland-backend = "0.1.0"
wayland-scanner = "=0.30.0-beta.15" wayland-scanner = "0.30.0"
cosmic-protocols = { git = "https://github.com/pop-os/cosmic-protocols", branch = "main", default-features = false, features = ["server"] } cosmic-protocols = { git = "https://github.com/pop-os/cosmic-protocols", branch = "main", default-features = false, features = ["server"] }
[dependencies.smithay] [dependencies.smithay]
@ -41,7 +41,7 @@ version = "0.3"
git = "https://github.com/Smithay/smithay.git" git = "https://github.com/Smithay/smithay.git"
rev = "2de946cf9e" rev = "2de946cf9e"
default-features = false default-features = false
features = ["backend_drm", "backend_gbm", "backend_egl", "backend_libinput", "backend_session_libseat", "backend_udev", "backend_winit", "backend_x11", "desktop", "use_system_lib", "renderer_glow", "renderer_multi", "wayland_frontend", "slog-stdlog"] features = ["backend_drm", "backend_gbm", "backend_egl", "backend_libinput", "backend_session_libseat", "backend_udev", "backend_winit", "backend_x11", "desktop", "use_system_lib", "renderer_glow", "renderer_multi", "wayland_frontend", "slog-stdlog", "xwayland"]
[dependencies.smithay-egui] [dependencies.smithay-egui]
git = "https://github.com/Smithay/smithay-egui.git" git = "https://github.com/Smithay/smithay-egui.git"
@ -64,4 +64,4 @@ debug = true
lto = "fat" lto = "fat"
[patch."https://github.com/Smithay/smithay.git"] [patch."https://github.com/Smithay/smithay.git"]
smithay = { git = "https://github.com/pop-os/smithay", rev = "51368f56bc" } smithay = { git = "https://github.com/pop-os/smithay", rev = "2a05d8cd64" }

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

@ -28,7 +28,7 @@ use smithay::{
glow::GlowRenderer, glow::GlowRenderer,
multigpu::{egl::EglGlesBackend, GpuManager}, multigpu::{egl::EglGlesBackend, GpuManager},
}, },
session::{auto::AutoSession, Session, Signal}, session::{libseat::LibSeatSession, Event as SessionEvent, Session},
udev::{all_gpus, primary_gpu, UdevBackend, UdevEvent}, udev::{all_gpus, primary_gpu, UdevBackend, UdevEvent},
}, },
desktop::utils::OutputPresentationFeedback, desktop::utils::OutputPresentationFeedback,
@ -45,10 +45,7 @@ use smithay::{
wayland_protocols::wp::presentation_time::server::wp_presentation_feedback, wayland_protocols::wp::presentation_time::server::wp_presentation_feedback,
wayland_server::{protocol::wl_surface::WlSurface, DisplayHandle, Resource}, wayland_server::{protocol::wl_surface::WlSurface, DisplayHandle, Resource},
}, },
utils::{ utils::{DeviceFd, Size, Transform},
signaling::{Linkable, SignalToken, Signaler},
DeviceFd, Size, Transform,
},
wayland::dmabuf::DmabufGlobal, wayland::dmabuf::DmabufGlobal,
}; };
@ -72,9 +69,7 @@ pub struct KmsState {
devices: HashMap<DrmNode, Device>, devices: HashMap<DrmNode, Device>,
pub api: GpuManager<EglGlesBackend<GlowRenderer>>, pub api: GpuManager<EglGlesBackend<GlowRenderer>>,
pub primary: DrmNode, pub primary: DrmNode,
session: AutoSession, session: LibSeatSession,
signaler: Signaler<Signal>,
_restart_token: SignalToken,
_tokens: Vec<RegistrationToken>, _tokens: Vec<RegistrationToken>,
} }
@ -107,17 +102,15 @@ pub fn init_backend(
event_loop: &mut EventLoop<'static, Data>, event_loop: &mut EventLoop<'static, Data>,
state: &mut State, state: &mut State,
) -> Result<()> { ) -> Result<()> {
let (session, notifier) = AutoSession::new(None).context("Failed to acquire session")?; let (session, notifier) = LibSeatSession::new(None).context("Failed to acquire session")?;
let signaler = notifier.signaler();
let udev_backend = UdevBackend::new(session.seat(), None)?; let udev_backend = UdevBackend::new(session.seat(), None)?;
let mut libinput_context = let mut libinput_context =
Libinput::new_with_udev::<LibinputSessionInterface<AutoSession>>(session.clone().into()); Libinput::new_with_udev::<LibinputSessionInterface<LibSeatSession>>(session.clone().into());
libinput_context libinput_context
.udev_assign_seat(&session.seat()) .udev_assign_seat(&session.seat())
.map_err(|_| anyhow::anyhow!("Failed to assign seat to libinput"))?; .map_err(|_| anyhow::anyhow!("Failed to assign seat to libinput"))?;
let mut libinput_backend = LibinputInputBackend::new(libinput_context, None); let libinput_backend = LibinputInputBackend::new(libinput_context.clone(), None);
libinput_backend.link(signaler.clone());
let libinput_event_source = event_loop let libinput_event_source = event_loop
.handle() .handle()
@ -143,12 +136,6 @@ pub fn init_backend(
}) })
.map_err(|err| err.error) .map_err(|err| err.error)
.context("Failed to initialize libinput event source")?; .context("Failed to initialize libinput event source")?;
let session_event_source = event_loop
.handle()
.insert_source(notifier, |(), &mut (), _state| {})
.map_err(|err| err.error)
.context("Failed to initialize session event source")?;
let api = GpuManager::new(EglGlesBackend::<GlowRenderer>::default(), None) let api = GpuManager::new(EglGlesBackend::<GlowRenderer>::default(), None)
.context("Failed to initialize renderers")?; .context("Failed to initialize renderers")?;
@ -209,85 +196,98 @@ pub fn init_backend(
let handle = event_loop.handle(); let handle = event_loop.handle();
let loop_signal = state.common.event_loop_signal.clone(); let loop_signal = state.common.event_loop_signal.clone();
let dispatcher = udev_dispatcher.clone(); let dispatcher = udev_dispatcher.clone();
let _restart_token = signaler.register(move |signal| { let session_event_source = event_loop
if let Signal::ActivateSession = signal { .handle()
let dispatcher = dispatcher.clone(); .insert_source(notifier, move |event, &mut (), data| match event {
handle.insert_idle(move |data| { SessionEvent::ActivateSession => {
for (dev, path) in dispatcher.as_source_ref().device_list() { if let Err(err) = libinput_context.resume() {
let drm_node = match DrmNode::from_dev_id(dev) { slog_scope::error!("Failed to resume libinput context: {:?}", err);
Ok(node) => node,
Err(err) => {
slog_scope::error!(
"Failed to read drm device {}: {}",
path.display(),
err
);
continue;
}
};
if data.state.backend.kms().devices.contains_key(&drm_node) {
if let Err(err) = data.state.device_changed(dev) {
slog_scope::error!(
"Failed to update drm device {}: {}",
path.display(),
err
);
}
} else {
if let Err(err) =
data.state
.device_added(dev, path.into(), &data.display.handle())
{
slog_scope::error!(
"Failed to add drm device {}: {}",
path.display(),
err
);
}
}
} }
let dispatcher = dispatcher.clone();
let seats = data.state.common.seats().cloned().collect::<Vec<_>>(); handle.insert_idle(move |data| {
data.state.common.config.read_outputs( for (dev, path) in dispatcher.as_source_ref().device_list() {
&mut data.state.common.output_configuration_state, let drm_node = match DrmNode::from_dev_id(dev) {
&mut data.state.backend, Ok(node) => node,
&mut data.state.common.shell, Err(err) => {
seats.into_iter(), slog_scope::error!(
&data.state.common.event_loop_handle, "Failed to read drm device {}: {}",
); path.display(),
for surface in data err
.state );
.backend continue;
.kms() }
.devices };
.values_mut() if data.state.backend.kms().devices.contains_key(&drm_node) {
.flat_map(|d| d.surfaces.values_mut()) if let Err(err) = data.state.device_changed(dev) {
{ slog_scope::error!(
surface.pending = false; "Failed to update drm device {}: {}",
} path.display(),
for output in data.state.common.shell.outputs() { err
let sessions = output.pending_buffers().collect::<Vec<_>>(); );
if let Err(err) = data.state.backend.kms().schedule_render( }
&data.state.common.event_loop_handle,
output,
None,
if !sessions.is_empty() {
Some(sessions)
} else { } else {
None if let Err(err) =
}, data.state
) { .device_added(dev, path.into(), &data.display.handle())
slog_scope::crit!( {
"Error scheduling event loop for output {}: {:?}", slog_scope::error!(
output.name(), "Failed to add drm device {}: {}",
err path.display(),
); err
);
}
}
} }
let seats = data.state.common.seats().cloned().collect::<Vec<_>>();
data.state.common.config.read_outputs(
&mut data.state.common.output_configuration_state,
&mut data.state.backend,
&mut data.state.common.shell,
seats.into_iter(),
&data.state.common.event_loop_handle,
);
for surface in data
.state
.backend
.kms()
.devices
.values_mut()
.flat_map(|d| d.surfaces.values_mut())
{
surface.pending = false;
}
for output in data.state.common.shell.outputs() {
let sessions = output.pending_buffers().collect::<Vec<_>>();
if let Err(err) = data.state.backend.kms().schedule_render(
&data.state.common.event_loop_handle,
output,
None,
if !sessions.is_empty() {
Some(sessions)
} else {
None
},
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
output.name(),
err
);
}
}
});
loop_signal.wakeup();
}
SessionEvent::PauseSession => {
libinput_context.suspend();
for device in data.state.backend.kms().devices.values() {
device.drm.as_source_ref().pause();
} }
}); }
loop_signal.wakeup(); })
} .map_err(|err| err.error)
}); .context("Failed to initialize session event source")?;
state.backend = BackendData::Kms(KmsState { state.backend = BackendData::Kms(KmsState {
api, api,
@ -298,8 +298,6 @@ pub fn init_backend(
], ],
primary, primary,
session, session,
signaler,
_restart_token,
devices: HashMap::new(), devices: HashMap::new(),
}); });
@ -337,7 +335,7 @@ impl State {
}, },
None, None,
); );
let mut drm = DrmDevice::new(fd.clone(), false, None) let drm = DrmDevice::new(fd.clone(), false, None)
.with_context(|| format!("Failed to initialize drm device for: {}", path.display()))?; .with_context(|| format!("Failed to initialize drm device for: {}", path.display()))?;
let drm_node = DrmNode::from_dev_id(dev)?; let drm_node = DrmNode::from_dev_id(dev)?;
let supports_atomic = drm.is_atomic(); let supports_atomic = drm.is_atomic();
@ -369,7 +367,6 @@ impl State {
})?; })?;
let formats = egl_context.dmabuf_render_formats().clone(); let formats = egl_context.dmabuf_render_formats().clone();
drm.link(self.backend.kms().signaler.clone());
let dispatcher = let dispatcher =
Dispatcher::new(drm, move |event, metadata, data: &mut Data| match event { Dispatcher::new(drm, move |event, metadata, data: &mut Data| match event {
DrmEvent::VBlank(crtc) => { DrmEvent::VBlank(crtc) => {
@ -943,9 +940,8 @@ impl KmsState {
surface.vrr = drm_helpers::set_vrr(drm, *crtc, conn, output_config.vrr) surface.vrr = drm_helpers::set_vrr(drm, *crtc, conn, output_config.vrr)
.unwrap_or(false); .unwrap_or(false);
surface.refresh_rate = drm_helpers::calculate_refresh_rate(*mode); surface.refresh_rate = drm_helpers::calculate_refresh_rate(*mode);
let mut drm_surface = drm.create_surface(*crtc, *mode, &[conn])?;
drm_surface.link(self.signaler.clone());
let drm_surface = drm.create_surface(*crtc, *mode, &[conn])?;
let target = GbmBufferedSurface::new( let target = GbmBufferedSurface::new(
drm_surface, drm_surface,
device.allocator.clone(), device.allocator.clone(),

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

@ -13,7 +13,7 @@ use smithay::{
ImportAll, Renderer, ImportAll, Renderer,
}, },
}, },
desktop::{space::SpaceElement, Kind, PopupManager, Window, WindowSurfaceType}, desktop::{space::SpaceElement, PopupManager, Window, WindowSurfaceType},
input::{ input::{
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState}, keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget}, pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget},
@ -252,16 +252,13 @@ impl CosmicMapped {
CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())), CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())),
_ => unreachable!(), _ => unreachable!(),
} { } {
match window.toplevel() { window.toplevel().with_pending_state(|state| {
Kind::Xdg(xdg) => xdg.with_pending_state(|state| { if resizing {
if resizing { state.states.set(XdgState::Resizing);
state.states.set(XdgState::Resizing); } else {
} else { state.states.unset(XdgState::Resizing);
state.states.unset(XdgState::Resizing); }
} });
}),
// Kind::X11?
};
} }
} }
@ -272,37 +269,31 @@ impl CosmicMapped {
_ => unreachable!(), _ => unreachable!(),
}; };
match window.toplevel() { let xdg = window.toplevel();
Kind::Xdg(xdg) => { xdg.current_state().states.contains(XdgState::Resizing)
xdg.current_state().states.contains(XdgState::Resizing) || xdg.with_pending_state(|states| states.states.contains(XdgState::Resizing))
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Resizing))
} // Kind::X11?
}
} }
pub fn set_tiled(&self, tiled: bool) { pub fn set_tiled(&self, tiled: bool) {
for toplevel in match &self.element { for xdg in match &self.element {
// we use the tiled state of stack windows anyway to get rid of decorations // we use the tiled state of stack windows anyway to get rid of decorations
CosmicMappedInternal::Stack(_) => None, CosmicMappedInternal::Stack(_) => None,
CosmicMappedInternal::Window(w) => Some(w.window.toplevel()), CosmicMappedInternal::Window(w) => Some(w.window.toplevel()),
_ => unreachable!(), _ => unreachable!(),
} { } {
match toplevel { xdg.with_pending_state(|state| {
Kind::Xdg(xdg) => xdg.with_pending_state(|state| { if tiled {
if tiled { state.states.set(XdgState::TiledLeft);
state.states.set(XdgState::TiledLeft); state.states.set(XdgState::TiledRight);
state.states.set(XdgState::TiledRight); state.states.set(XdgState::TiledTop);
state.states.set(XdgState::TiledTop); state.states.set(XdgState::TiledBottom);
state.states.set(XdgState::TiledBottom); } else {
} else { state.states.unset(XdgState::TiledLeft);
state.states.unset(XdgState::TiledLeft); state.states.unset(XdgState::TiledRight);
state.states.unset(XdgState::TiledRight); state.states.unset(XdgState::TiledTop);
state.states.unset(XdgState::TiledTop); state.states.unset(XdgState::TiledBottom);
state.states.unset(XdgState::TiledBottom); }
} });
}),
// Kind::X11?
};
} }
} }
@ -313,10 +304,11 @@ impl CosmicMapped {
_ => unreachable!(), _ => unreachable!(),
}; };
match window.toplevel() { window
Kind::Xdg(xdg) => xdg.current_state().states.contains(XdgState::TiledLeft), .toplevel()
// Kind::X11? .current_state()
} .states
.contains(XdgState::TiledLeft)
} }
pub fn set_fullscreen(&self, fullscreen: bool) { pub fn set_fullscreen(&self, fullscreen: bool) {
@ -327,16 +319,13 @@ impl CosmicMapped {
CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())), CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())),
_ => unreachable!(), _ => unreachable!(),
} { } {
match window.toplevel() { window.toplevel().with_pending_state(|state| {
Kind::Xdg(xdg) => xdg.with_pending_state(|state| { if fullscreen {
if fullscreen { state.states.set(XdgState::Fullscreen);
state.states.set(XdgState::Fullscreen); } else {
} else { state.states.unset(XdgState::Fullscreen);
state.states.unset(XdgState::Fullscreen); }
} });
}),
// Kind::X11?
};
} }
} }
@ -347,12 +336,9 @@ impl CosmicMapped {
_ => unreachable!(), _ => unreachable!(),
}; };
match window.toplevel() { let xdg = window.toplevel();
Kind::Xdg(xdg) => { xdg.current_state().states.contains(XdgState::Fullscreen)
xdg.current_state().states.contains(XdgState::Fullscreen) || xdg.with_pending_state(|states| states.states.contains(XdgState::Fullscreen))
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Fullscreen))
} // Kind::X11?
}
} }
pub fn set_maximized(&self, maximized: bool) { pub fn set_maximized(&self, maximized: bool) {
@ -363,16 +349,13 @@ impl CosmicMapped {
CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())), CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())),
_ => unreachable!(), _ => unreachable!(),
} { } {
match window.toplevel() { window.toplevel().with_pending_state(|state| {
Kind::Xdg(xdg) => xdg.with_pending_state(|state| { if maximized {
if maximized { state.states.set(XdgState::Maximized);
state.states.set(XdgState::Maximized); } else {
} else { state.states.unset(XdgState::Maximized);
state.states.unset(XdgState::Maximized); }
} });
}),
// Kind::X11?
};
} }
} }
@ -383,12 +366,9 @@ impl CosmicMapped {
_ => unreachable!(), _ => unreachable!(),
}; };
match window.toplevel() { let xdg = window.toplevel();
Kind::Xdg(xdg) => { xdg.current_state().states.contains(XdgState::Maximized)
xdg.current_state().states.contains(XdgState::Maximized) || xdg.with_pending_state(|states| states.states.contains(XdgState::Maximized))
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Maximized))
} // Kind::X11?
}
} }
pub fn set_activated(&self, activated: bool) { pub fn set_activated(&self, activated: bool) {
@ -399,16 +379,13 @@ impl CosmicMapped {
CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())), CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())),
_ => unreachable!(), _ => unreachable!(),
} { } {
match window.toplevel() { window.toplevel().with_pending_state(|state| {
Kind::Xdg(xdg) => xdg.with_pending_state(|state| { if activated {
if activated { state.states.set(XdgState::Activated);
state.states.set(XdgState::Activated); } else {
} else { state.states.unset(XdgState::Activated);
state.states.unset(XdgState::Activated); }
} });
}),
// Kind::X11?
};
} }
} }
@ -419,12 +396,9 @@ impl CosmicMapped {
_ => unreachable!(), _ => unreachable!(),
}; };
match window.toplevel() { let xdg = window.toplevel();
Kind::Xdg(xdg) => { xdg.current_state().states.contains(XdgState::Activated)
xdg.current_state().states.contains(XdgState::Activated) || xdg.with_pending_state(|states| states.states.contains(XdgState::Activated))
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Activated))
} // Kind::X11?
}
} }
pub fn set_size(&self, size: Size<i32, Logical>) { pub fn set_size(&self, size: Size<i32, Logical>) {
@ -536,10 +510,7 @@ impl CosmicMapped {
CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())), CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())),
_ => unreachable!(), _ => unreachable!(),
} { } {
match window.toplevel() { window.toplevel().send_configure();
Kind::Xdg(xdg) => xdg.send_configure(),
// Kind::X11?
};
} }
} }
@ -550,10 +521,7 @@ impl CosmicMapped {
_ => unreachable!(), _ => unreachable!(),
}; };
match window.toplevel() { window.toplevel().send_close();
Kind::Xdg(xdg) => xdg.send_close(),
// Kind::X11?
};
} }
#[cfg(feature = "debug")] #[cfg(feature = "debug")]

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

@ -10,7 +10,7 @@ use smithay::{
ImportAll, Renderer, ImportAll, Renderer,
}, },
}, },
desktop::{space::SpaceElement, Kind, Window}, desktop::{space::SpaceElement, Window},
input::{ input::{
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState}, keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget}, pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget},
@ -95,9 +95,9 @@ impl CosmicStack {
.into(); .into();
for window in self.windows.lock().unwrap().iter() { for window in self.windows.lock().unwrap().iter() {
match window.toplevel() { window
Kind::Xdg(xdg) => xdg.with_pending_state(|state| state.size = Some(surface_size)), .toplevel()
}; .with_pending_state(|state| state.size = Some(surface_size));
} }
} }

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

@ -9,7 +9,7 @@ use smithay::{
ImportAll, Renderer, ImportAll, Renderer,
}, },
}, },
desktop::{space::SpaceElement, Kind, Window}, desktop::{space::SpaceElement, Window},
input::{ input::{
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState}, keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget}, pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget},
@ -72,18 +72,16 @@ impl CosmicWindow {
.unwrap_or(0), .unwrap_or(0),
) )
.into(); .into();
match self.window.toplevel() { self.window
Kind::Xdg(xdg) => xdg.with_pending_state(|state| state.size = Some(surface_size)), .toplevel()
}; .with_pending_state(|state| state.size = Some(surface_size));
} }
} }
impl From<Window> for CosmicWindow { impl From<Window> for CosmicWindow {
fn from(window: Window) -> Self { fn from(window: Window) -> Self {
let is_ssd = matches!( let is_ssd = matches!(
match window.toplevel() { window.toplevel().current_state().decoration_mode,
Kind::Xdg(xdg) => xdg.current_state().decoration_mode,
},
Some(DecorationMode::ServerSide) Some(DecorationMode::ServerSide)
); );
CosmicWindow { CosmicWindow {
@ -100,7 +98,7 @@ impl From<ToplevelSurface> for CosmicWindow {
Some(DecorationMode::ServerSide) Some(DecorationMode::ServerSide)
); );
CosmicWindow { CosmicWindow {
window: Window::new(Kind::Xdg(surf)), window: Window::new(surf),
header: Arc::new(Mutex::new(is_ssd.then_some(HeaderBar::default()))), header: Arc::new(Mutex::new(is_ssd.then_some(HeaderBar::default()))),
} }
} }

78
src/shell/workspace.rs
View file

@ -21,7 +21,7 @@ use smithay::{
element::{surface::WaylandSurfaceRenderElement, AsRenderElements, Element, RenderElement}, element::{surface::WaylandSurfaceRenderElement, AsRenderElements, Element, RenderElement},
ImportAll, Renderer, ImportAll, Renderer,
}, },
desktop::{layer_map_for_output, space::SpaceElement, Kind, LayerSurface, Window}, desktop::{layer_map_for_output, space::SpaceElement, LayerSurface, Window},
input::{pointer::GrabStartData as PointerGrabStartData, Seat}, input::{pointer::GrabStartData as PointerGrabStartData, Seat},
output::Output, output::Output,
reexports::{ reexports::{
@ -197,13 +197,10 @@ impl Workspace {
self.floating_layer.maximize_request(window); self.floating_layer.maximize_request(window);
#[allow(irrefutable_let_patterns)] window.toplevel().with_pending_state(|state| {
if let Kind::Xdg(xdg) = &window.toplevel() { state.states.set(xdg_toplevel::State::Maximized);
xdg.with_pending_state(|state| { state.states.unset(xdg_toplevel::State::Fullscreen);
state.states.set(xdg_toplevel::State::Maximized); });
state.states.unset(xdg_toplevel::State::Fullscreen);
});
}
self.set_fullscreen(window, output) self.set_fullscreen(window, output)
} }
@ -219,13 +216,10 @@ impl Workspace {
return; return;
} }
#[allow(irrefutable_let_patterns)] window.toplevel().with_pending_state(|state| {
if let Kind::Xdg(xdg) = &window.toplevel() { state.states.set(xdg_toplevel::State::Fullscreen);
xdg.with_pending_state(|state| { state.states.unset(xdg_toplevel::State::Maximized);
state.states.set(xdg_toplevel::State::Fullscreen); });
state.states.unset(xdg_toplevel::State::Maximized);
});
}
self.set_fullscreen(window, output) self.set_fullscreen(window, output)
} }
@ -238,38 +232,33 @@ impl Workspace {
mapped.set_active(window); mapped.set_active(window);
} }
#[allow(irrefutable_let_patterns)] let xdg = window.toplevel();
if let Kind::Xdg(xdg) = &window.toplevel() { xdg.with_pending_state(|state| {
xdg.with_pending_state(|state| { state.size = Some(
state.size = Some( output
output .current_mode()
.current_mode() .map(|m| m.size)
.map(|m| m.size) .unwrap_or((0, 0).into())
.unwrap_or((0, 0).into()) .to_f64()
.to_f64() .to_logical(output.current_scale().fractional_scale())
.to_logical(output.current_scale().fractional_scale()) .to_i32_round(),
.to_i32_round(), );
); });
}); xdg.send_configure();
xdg.send_configure();
}
self.fullscreen.insert(output.clone(), window.clone()); self.fullscreen.insert(output.clone(), window.clone());
} }
pub fn unfullscreen_request(&mut self, window: &Window) { pub fn unfullscreen_request(&mut self, window: &Window) {
if self.fullscreen.values().any(|w| w == window) { if self.fullscreen.values().any(|w| w == window) {
#[allow(irrefutable_let_patterns)] let xdg = window.toplevel();
if let Kind::Xdg(xdg) = &window.toplevel() { xdg.with_pending_state(|state| {
xdg.with_pending_state(|state| { state.states.unset(xdg_toplevel::State::Fullscreen);
state.states.unset(xdg_toplevel::State::Fullscreen); state.states.unset(xdg_toplevel::State::Maximized);
state.states.unset(xdg_toplevel::State::Maximized); state.size = None;
state.size = None; });
}); self.floating_layer.refresh();
self.floating_layer.refresh(); self.tiling_layer.refresh();
self.tiling_layer.refresh(); xdg.send_configure();
xdg.send_configure();
}
self.fullscreen.retain(|_, w| w != window); self.fullscreen.retain(|_, w| w != window);
} }
} }
@ -331,10 +320,7 @@ impl Workspace {
if mapped.is_fullscreen() || mapped.is_maximized() { if mapped.is_fullscreen() || mapped.is_maximized() {
// If surface is maximized then unmaximize it // If surface is maximized then unmaximize it
self.unmaximize_request(window); self.unmaximize_request(window);
let new_size = match window.toplevel() { let new_size = window.toplevel().with_pending_state(|state| state.size);
Kind::Xdg(toplevel) => toplevel.with_pending_state(|state| state.size),
//_ => unreachable!(), // TODO x11
};
let ratio = pos.x / output.geometry().size.w as f64; let ratio = pos.x / output.geometry().size.w as f64;
initial_window_location = new_size initial_window_location = new_size

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

@ -4,7 +4,7 @@ use crate::{state::BackendData, utils::prelude::*, wayland::protocols::screencop
use smithay::{ use smithay::{
backend::renderer::utils::{on_commit_buffer_handler, with_renderer_surface_state}, backend::renderer::utils::{on_commit_buffer_handler, with_renderer_surface_state},
delegate_compositor, delegate_compositor,
desktop::{layer_map_for_output, Kind, LayerSurface, PopupKind, WindowSurfaceType}, desktop::{layer_map_for_output, LayerSurface, PopupKind, WindowSurfaceType},
reexports::wayland_server::protocol::wl_surface::WlSurface, reexports::wayland_server::protocol::wl_surface::WlSurface,
wayland::{ wayland::{
compositor::{with_states, CompositorHandler, CompositorState}, compositor::{with_states, CompositorHandler, CompositorState},
@ -116,19 +116,14 @@ impl CompositorHandler for State {
.find(|(window, _)| window.toplevel().wl_surface() == surface) .find(|(window, _)| window.toplevel().wl_surface() == surface)
.cloned() .cloned()
{ {
match window.toplevel() { let toplevel = window.toplevel();
Kind::Xdg(toplevel) => { if self.toplevel_ensure_initial_configure(&toplevel)
if self.toplevel_ensure_initial_configure(&toplevel) && with_renderer_surface_state(&surface, |state| state.wl_buffer().is_some())
&& with_renderer_surface_state(&surface, |state| { {
state.wl_buffer().is_some() let output = seat.active_output();
}) Shell::map_window(self, &window, &output);
{ } else {
let output = seat.active_output(); return;
Shell::map_window(self, &window, &output);
} else {
return;
}
}
} }
} }

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

@ -1,10 +1,6 @@
// SPDX-License-Identifier: GPL-3.0-only // SPDX-License-Identifier: GPL-3.0-only
use smithay::{ use smithay::{desktop::Window, input::Seat, reexports::wayland_server::DisplayHandle};
desktop::{Kind, Window},
input::Seat,
reexports::wayland_server::DisplayHandle,
};
use crate::{ use crate::{
utils::prelude::*, utils::prelude::*,
@ -52,10 +48,7 @@ impl ToplevelManagementHandler for State {
} }
fn close(&mut self, _dh: &DisplayHandle, window: &Window) { fn close(&mut self, _dh: &DisplayHandle, window: &Window) {
#[allow(irrefutable_let_patterns)] window.toplevel().send_close();
if let Kind::Xdg(xdg) = &window.toplevel() {
xdg.send_close();
}
} }
} }

14
src/wayland/handlers/xdg_shell/mod.rs
View file

@ -4,7 +4,7 @@ use crate::{utils::prelude::*, wayland::protocols::screencopy::SessionType};
use smithay::{ use smithay::{
delegate_xdg_shell, delegate_xdg_shell,
desktop::{ desktop::{
find_popup_root_surface, Kind, PopupGrab, PopupKeyboardGrab, PopupKind, PopupPointerGrab, find_popup_root_surface, PopupGrab, PopupKeyboardGrab, PopupKind, PopupPointerGrab,
PopupUngrabStrategy, Window, PopupUngrabStrategy, Window,
}, },
input::{ input::{
@ -39,7 +39,7 @@ impl XdgShellHandler for State {
fn new_toplevel(&mut self, surface: ToplevelSurface) { fn new_toplevel(&mut self, surface: ToplevelSurface) {
let seat = self.common.last_active_seat().clone(); let seat = self.common.last_active_seat().clone();
let window = Window::new(Kind::Xdg(surface)); let window = Window::new(surface);
self.common.shell.toplevel_info_state.new_toplevel(&window); self.common.shell.toplevel_info_state.new_toplevel(&window);
self.common.shell.pending_windows.push((window, seat)); self.common.shell.pending_windows.push((window, seat));
// We will position the window after the first commit, when we know its size hints // We will position the window after the first commit, when we know its size hints
@ -149,7 +149,7 @@ impl XdgShellHandler for State {
let output = seat.active_output(); let output = seat.active_output();
let (window, _) = mapped let (window, _) = mapped
.windows() .windows()
.find(|(w, _)| matches!(w.toplevel(), Kind::Xdg(s) if s == &surface)) .find(|(w, _)| w.toplevel() == &surface)
.unwrap(); .unwrap();
if let Some(grab) = if let Some(grab) =
workspace.move_request(&window, &seat, &output, serial, start_data) workspace.move_request(&window, &seat, &output, serial, start_data)
@ -213,7 +213,7 @@ impl XdgShellHandler for State {
if let Some(workspace) = self.common.shell.space_for_mut(&mapped) { if let Some(workspace) = self.common.shell.space_for_mut(&mapped) {
let (window, _) = mapped let (window, _) = mapped
.windows() .windows()
.find(|(w, _)| matches!(w.toplevel(), Kind::Xdg(s) if s == &surface)) .find(|(w, _)| w.toplevel() == &surface)
.unwrap(); .unwrap();
workspace.maximize_request(&window, &output) workspace.maximize_request(&window, &output)
} }
@ -230,7 +230,7 @@ impl XdgShellHandler for State {
if let Some(workspace) = self.common.shell.space_for_mut(&mapped) { if let Some(workspace) = self.common.shell.space_for_mut(&mapped) {
let (window, _) = mapped let (window, _) = mapped
.windows() .windows()
.find(|(w, _)| matches!(w.toplevel(), Kind::Xdg(s) if s == &surface)) .find(|(w, _)| w.toplevel() == &surface)
.unwrap(); .unwrap();
workspace.unmaximize_request(&window) workspace.unmaximize_request(&window)
} }
@ -255,7 +255,7 @@ impl XdgShellHandler for State {
if let Some(workspace) = self.common.shell.space_for_mut(&mapped) { if let Some(workspace) = self.common.shell.space_for_mut(&mapped) {
let (window, _) = mapped let (window, _) = mapped
.windows() .windows()
.find(|(w, _)| matches!(w.toplevel(), Kind::Xdg(s) if s == &surface)) .find(|(w, _)| w.toplevel() == &surface)
.unwrap(); .unwrap();
workspace.fullscreen_request(&window, &output) workspace.fullscreen_request(&window, &output)
} }
@ -272,7 +272,7 @@ impl XdgShellHandler for State {
if let Some(workspace) = self.common.shell.space_for_mut(&mapped) { if let Some(workspace) = self.common.shell.space_for_mut(&mapped) {
let (window, _) = mapped let (window, _) = mapped
.windows() .windows()
.find(|(w, _)| matches!(w.toplevel(), Kind::Xdg(s) if s == &surface)) .find(|(w, _)| w.toplevel() == &surface)
.unwrap(); .unwrap();
workspace.unfullscreen_request(&window) workspace.unfullscreen_request(&window)
} }