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

chore: update smithay + switch to tracing

Browse source
This commit is contained in:
Victoria Brekenfeld 2023-02-24 17:41:52 +01:00
parent 844ed552b9
commit 35de500c00
35 changed files with 622 additions and 754 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -55,6 +55,7 @@ use smithay::{
wayland::{dmabuf::DmabufGlobal, seat::WaylandFocus},
xwayland::XWaylandClientData,
};
use tracing::{debug, error, info, warn};
use std::{
cell::RefCell,
@ -112,15 +113,15 @@ pub fn init_backend(
event_loop: &mut EventLoop<'static, Data>,
state: &mut State,
) -> Result<()> {
let (session, notifier) = LibSeatSession::new(None).context("Failed to acquire session")?;
let (session, notifier) = LibSeatSession::new().context("Failed to acquire session")?;
let udev_backend = UdevBackend::new(session.seat(), None)?;
let udev_backend = UdevBackend::new(session.seat())?;
let mut libinput_context =
Libinput::new_with_udev::<LibinputSessionInterface<LibSeatSession>>(session.clone().into());
libinput_context
.udev_assign_seat(&session.seat())
.map_err(|_| anyhow::anyhow!("Failed to assign seat to libinput"))?;
let libinput_backend = LibinputInputBackend::new(libinput_context.clone(), None);
let libinput_backend = LibinputInputBackend::new(libinput_context.clone());
let libinput_event_source = event_loop
.handle()
@ -136,17 +137,17 @@ pub fn init_backend(
None,
None,
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
error!(
?err,
"Error scheduling event loop for output {}.",
output.name(),
err
);
}
}
})
.map_err(|err| err.error)
.context("Failed to initialize libinput event source")?;
let api = GpuManager::new(GbmGlesBackend::<GlowRenderer>::default(), None)
let api = GpuManager::new(GbmGlesBackend::<GlowRenderer>::default())
.context("Failed to initialize renderers")?;
// TODO get this info from system76-power, if available and setup a watcher
@ -173,7 +174,7 @@ pub fn init_backend(
panic!("Failed to initialize any GPU");
})
};
slog_scope::info!("Using {} as primary gpu for rendering", primary);
info!("Using {} as primary gpu for rendering.", primary);
let udev_dispatcher = Dispatcher::new(udev_backend, move |event, _, data: &mut Data| {
match match event {
@ -191,10 +192,10 @@ pub fn init_backend(
.with_context(|| format!("Failed to remove drm device: {}", device_id)),
} {
Ok(()) => {
slog_scope::debug!("Successfully handled udev event")
debug!("Successfully handled udev event.")
}
Err(err) => {
slog_scope::error!("Error while handling udev event: {}", err)
error!(?err, "Error while handling udev event.")
}
}
});
@ -211,7 +212,7 @@ pub fn init_backend(
.insert_source(notifier, move |event, &mut (), data| match event {
SessionEvent::ActivateSession => {
if let Err(err) = libinput_context.resume() {
slog_scope::error!("Failed to resume libinput context: {:?}", err);
error!(?err, "Failed to resume libinput context.");
}
for device in data.state.backend.kms().devices.values() {
device.drm.as_source_ref().activate();
@ -222,21 +223,13 @@ pub fn init_backend(
let drm_node = match DrmNode::from_dev_id(dev) {
Ok(node) => node,
Err(err) => {
slog_scope::error!(
"Failed to read drm device {}: {}",
path.display(),
err
);
error!(?err, "Failed to read drm device {}.", path.display(),);
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
);
error!(?err, "Failed to update drm device {}.", path.display(),);
}
} else {
if let Err(err) = data.state.device_added(
@ -245,11 +238,7 @@ pub fn init_backend(
&data.display.handle(),
true,
) {
slog_scope::error!(
"Failed to add drm device {}: {}",
path.display(),
err
);
error!(?err, "Failed to add drm device {}.", path.display(),);
}
}
}
@ -284,10 +273,10 @@ pub fn init_backend(
None
},
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
error!(
?err,
"Error scheduling event loop for output {}.",
output.name(),
err
);
}
}
@ -352,27 +341,24 @@ impl State {
return Ok(());
}
let fd = DrmDeviceFd::new(
unsafe {
DeviceFd::from_raw_fd(
self.backend
.kms()
.session
.open(
&path,
OFlag::O_RDWR | OFlag::O_CLOEXEC | OFlag::O_NOCTTY | OFlag::O_NONBLOCK,
let fd = DrmDeviceFd::new(unsafe {
DeviceFd::from_raw_fd(
self.backend
.kms()
.session
.open(
&path,
OFlag::O_RDWR | OFlag::O_CLOEXEC | OFlag::O_NOCTTY | OFlag::O_NONBLOCK,
)
.with_context(|| {
format!(
"Failed to optain file descriptor for drm device: {}",
path.display()
)
.with_context(|| {
format!(
"Failed to optain file descriptor for drm device: {}",
path.display()
)
})?,
)
},
None,
);
let drm = DrmDevice::new(fd.clone(), false, None)
})?,
)
});
let drm = DrmDevice::new(fd.clone(), false)
.with_context(|| format!("Failed to initialize drm device for: {}", path.display()))?;
let drm_node = DrmNode::from_dev_id(dev)?;
let supports_atomic = drm.is_atomic();
@ -380,7 +366,7 @@ impl State {
let gbm = GbmDevice::new(fd)
.with_context(|| format!("Failed to initialize GBM device for {}", path.display()))?;
let (render_node, formats) = {
let egl_display = EGLDisplay::new(gbm.clone(), None).with_context(|| {
let egl_display = EGLDisplay::new(gbm.clone()).with_context(|| {
format!("Failed to create EGLDisplay for device: {}", path.display())
})?;
let egl_device = EGLDevice::device_for_display(&egl_display).with_context(|| {
@ -391,7 +377,7 @@ impl State {
.ok()
.and_then(std::convert::identity)
.unwrap_or(drm_node);
let egl_context = EGLContext::new(&egl_display, None).with_context(|| {
let egl_context = EGLContext::new(&egl_display).with_context(|| {
format!(
"Failed to create EGLContext for device {:?}:{}",
egl_device,
@ -458,7 +444,7 @@ impl State {
})
}
Some(Err(err)) => {
slog_scope::warn!("Failed to submit frame: {}", err);
warn!(?err, "Failed to submit frame.");
None
}
_ => None, // got disabled
@ -487,12 +473,12 @@ impl State {
Some(repaint_delay),
scheduled_sessions,
) {
slog_scope::warn!("Failed to schedule render: {}", err);
warn!(?err, "Failed to schedule render.");
}
}
}
DrmEvent::Error(err) => {
slog_scope::warn!("Failed to read events of device {:?}: {}", dev, err);
warn!(?err, "Failed to read events of device {:?}.", dev);
}
});
let token = self
@ -504,10 +490,9 @@ impl State {
let socket = match self.create_socket(dh, render_node, formats.clone().into_iter()) {
Ok(socket) => Some(socket),
Err(err) => {
slog_scope::warn!(
"Failed to initialize hardware-acceleration for clients on {}: {}",
render_node,
err
warn!(
?err,
"Failed to initialize hardware-acceleration for clients on {}.", render_node,
);
None
}
@ -548,7 +533,7 @@ impl State {
let mut renderer = match backend.api.single_renderer(&render_node) {
Ok(renderer) => renderer,
Err(err) => {
slog_scope::warn!("Failed to initialize output: {}", err);
warn!(?err, "Failed to initialize output.");
continue;
}
};
@ -563,7 +548,7 @@ impl State {
.w;
wl_outputs.push(output);
}
Err(err) => slog_scope::warn!("Failed to initialize output: {}", err),
Err(err) => warn!(?err, "Failed to initialize output."),
};
}
backend.devices.insert(drm_node, device);
@ -589,7 +574,7 @@ impl State {
}
fn init_vulkan(&mut self, drm_node: DrmNode, render_node: DrmNode) {
if let Ok(instance) = Instance::new(Version::VERSION_1_2, None, None) {
if let Ok(instance) = Instance::new(Version::VERSION_1_2, None) {
if let Some(physical_device) =
PhysicalDevice::enumerate(&instance)
.ok()
@ -621,7 +606,7 @@ impl State {
.allocator = Box::new(DmabufAllocator(allocator));
}
Err(err) => {
slog_scope::warn!("Failed to create vulkan allocator: {}", err);
warn!(?err, "Failed to create vulkan allocator.");
}
}
}
@ -654,7 +639,7 @@ impl State {
let mut renderer = match backend.api.single_renderer(&device.render_node) {
Ok(renderer) => renderer,
Err(err) => {
slog_scope::warn!("Failed to initialize output: {}", err);
warn!(?err, "Failed to initialize output.");
continue;
}
};
@ -669,7 +654,7 @@ impl State {
.w;
outputs_added.push(output);
}
Err(err) => slog_scope::warn!("Failed to initialize output: {}", err),
Err(err) => warn!(?err, "Failed to initialize output."),
};
}
}
@ -826,7 +811,6 @@ impl Device {
.map(|info| info.model.clone())
.unwrap_or_else(|_| String::from("Unknown")),
},
None,
);
for mode in conn_info.modes() {
let refresh_rate = drm_helpers::calculate_refresh_rate(*mode);
@ -1059,7 +1043,6 @@ impl KmsState {
GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT,
),
device.formats.clone(),
None,
)
.with_context(|| {
format!(
@ -1094,10 +1077,10 @@ impl KmsState {
None
},
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
error!(
?err,
"Error scheduling event loop for output {}.",
output.name(),
err
);
}
}
@ -1135,7 +1118,7 @@ impl KmsState {
render,
surface,
) {
slog_scope::debug!("Early import failed: {}", err);
debug!(?err, "Early import failed.");
}
}
@ -1247,7 +1230,7 @@ impl KmsState {
}
Err(err) => {
if backend.session.is_active() {
slog_scope::error!("Error rendering: {:?}", err);
error!(?err, "Error rendering.");
return TimeoutAction::ToDuration(Duration::from_secs_f64(
(1000.0 / surface.refresh_rate as f64) - 0.003,
));

14
src/backend/kms/socket.rs
View file

@ -14,6 +14,7 @@ use smithay::{
xwayland::XWaylandClientData,
};
use std::sync::Arc;
use tracing::{info, warn};
use crate::{
state::{ClientState, Data},
@ -61,7 +62,7 @@ impl State {
let dmabuf_global = self
.common
.dmabuf_state
.create_global_with_filter::<State, _, _>(dh, formats.clone(), filter, None);
.create_global_with_filter::<State, _>(dh, formats.clone(), filter);
let drm_global_id = self
.common
@ -81,8 +82,9 @@ impl State {
);
// add a special socket for the gpu
let listener = ListeningSocketSource::with_name(&socket_name, None)
let listener = ListeningSocketSource::with_name(&socket_name)
.with_context(|| format!("Failed to bind socket to {}", socket_name))?;
let socket_name_clone = socket_name.clone();
let token = self
.common
.event_loop_handle
@ -91,12 +93,16 @@ impl State {
client_stream,
Arc::new(data.state.new_client_state_with_node(render_node)),
) {
slog_scope::warn!("Error adding wayland client ({}): {}", render_node, err);
warn!(
socket_name = socket_name_clone,
?err,
"Error adding wayland client."
);
}
})
.context("Failed to add gpu-wayland socket to the event loop")?;
slog_scope::info!("Added socket at {} for gpu {}", socket_name, render_node,);
info!(socket_name, ?render_node, "Added gpu-specific socket.");
Ok(Socket {
token,

5
src/backend/mod.rs
View file

@ -3,6 +3,7 @@
use crate::state::{Data, State};
use anyhow::{Context, Result};
use smithay::reexports::{calloop::EventLoop, wayland_server::DisplayHandle};
use tracing::{info, warn};
pub mod render;
@ -29,8 +30,8 @@ pub fn init_backend_auto(
match x11::init_backend(dh, event_loop, state) {
Ok(_) => Ok(()),
Err(err) => {
slog_scope::warn!("X11 Backend failed with error: {}", err);
slog_scope::info!("Falling back to winit backend.");
warn!(?err, "Initializing X11 Backend failed.");
info!("Falling back to winit backend.");
winit::init_backend(dh, event_loop, state)
}
}

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

@ -26,6 +26,7 @@ use std::{
sync::Mutex,
time::Duration,
};
use tracing::warn;
use xcursor::{
parser::{parse_xcursor, Image},
CursorTheme,
@ -51,9 +52,7 @@ impl Cursor {
let theme = CursorTheme::load(&name);
let icons = load_icon(&theme)
.map_err(|err| {
slog_scope::warn!("Unable to load xcursor: {}, using fallback cursor", err)
})
.map_err(|err| warn!(?err, "Unable to load xcursor, using fallback cursor"))
.unwrap_or_else(|_| {
vec![Image {
size: 32,
@ -160,7 +159,6 @@ where
surface,
position.to_physical_precise_round(scale),
scale,
slog_scope::logger(),
)
}
@ -175,7 +173,8 @@ where
<R as Renderer>::TextureId: 'static,
{
if get_role(&surface) != Some("dnd_icon") {
slog_scope::warn!(
warn!(
?surface,
"Trying to display as a dnd icon a surface that does not have the DndIcon role."
);
}
@ -185,7 +184,6 @@ where
surface,
location.into().to_physical_precise_round(scale),
scale,
slog_scope::logger(),
)
}

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

@ -127,23 +127,19 @@ impl RenderElement<GlowRenderer> for CosmicElement<GlowRenderer> {
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self {
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, log)
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
}
}
}
fn underlying_storage(
&self,
renderer: &GlowRenderer,
) -> Option<UnderlyingStorage<'_, GlowRenderer>> {
fn underlying_storage(&self, renderer: &mut GlowRenderer) -> Option<UnderlyingStorage> {
match self {
CosmicElement::Workspace(elem) => elem.underlying_storage(renderer),
CosmicElement::Cursor(elem) => elem.underlying_storage(renderer),
@ -161,17 +157,16 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>> for CosmicElement<GlMultiRen
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlMultiRenderer<'a, 'b> as Renderer>::Error> {
match self {
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
let elem = {
let glow_frame = frame.glow_frame_mut();
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage, log)
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage)
.map_err(|err| MultiError::Render(err))
};
elem
@ -181,15 +176,15 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>> for CosmicElement<GlMultiRen
fn underlying_storage(
&self,
renderer: &GlMultiRenderer<'a, 'b>,
) -> Option<UnderlyingStorage<'_, GlMultiRenderer<'a, 'b>>> {
renderer: &mut GlMultiRenderer<'a, 'b>,
) -> Option<UnderlyingStorage> {
match self {
CosmicElement::Workspace(elem) => elem.underlying_storage(renderer),
CosmicElement::Cursor(elem) => elem.underlying_storage(renderer),
CosmicElement::MoveGrab(elem) => elem.underlying_storage(renderer),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
let glow_renderer = renderer.glow_renderer();
let glow_renderer = renderer.glow_renderer_mut();
match elem.underlying_storage(glow_renderer) {
Some(UnderlyingStorage::Wayland(buffer)) => {
Some(UnderlyingStorage::Wayland(buffer))

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

@ -37,6 +37,7 @@ use smithay::{
utils::{Physical, Rectangle},
wayland::dmabuf::get_dmabuf,
};
use tracing::warn;
pub mod cursor;
use self::cursor::CursorRenderElement;
@ -268,7 +269,7 @@ where
}
renderer.bind(target).map_err(RenderError::Rendering)?;
let res = damage_tracker.render_output(renderer, age, &elements, CLEAR_COLOR, None);
let res = damage_tracker.render_output(renderer, age, &elements, CLEAR_COLOR);
if let Some(fps) = fps.as_mut() {
fps.render();
@ -284,7 +285,7 @@ where
params,
output.current_transform(),
|_node, buffer, renderer, dtr, age| {
let res = dtr.damage_output(age, &elements, slog_scope::logger())?;
let res = dtr.damage_output(age, &elements)?;
if let (Some(ref damage), _) = &res {
if let Ok(dmabuf) = get_dmabuf(buffer) {
@ -311,7 +312,7 @@ where
Ok(true) => {} // success
Ok(false) => state.still_pending(session.clone(), params.clone()),
Err(err) => {
slog_scope::warn!("Error rendering to screencopy session: {}", err);
warn!(?err, "Error rendering to screencopy session.");
session.failed(FailureReason::Unspec);
}
}

13
src/backend/winit.rs
View file

@ -27,6 +27,7 @@ use smithay::{
utils::Transform,
};
use std::cell::RefCell;
use tracing::{error, info, warn};
#[cfg(feature = "debug")]
use crate::state::Fps;
@ -145,7 +146,7 @@ pub fn init_backend(
state: &mut State,
) -> Result<()> {
let (mut backend, mut input) =
winit::init(None).map_err(|_| anyhow!("Failed to initilize winit backend"))?;
winit::init().map_err(|_| anyhow!("Failed to initilize winit backend"))?;
init_egl_client_side(dh, state, &mut backend)?;
@ -161,7 +162,7 @@ pub fn init_backend(
size: (size.physical_size.w as i32, size.physical_size.h as i32).into(),
refresh: 60_000,
};
let output = Output::new(name, props, None);
let output = Output::new(name, props);
output.add_mode(mode);
output.set_preferred(mode);
output.change_current_state(
@ -197,7 +198,7 @@ pub fn init_backend(
.winit()
.render_output(&mut data.state.common)
{
slog_scope::error!("Failed to render frame: {}", err);
error!(?err, "Failed to render frame.");
render_ping.ping();
}
})
@ -269,7 +270,7 @@ fn init_egl_client_side(
let bind_result = renderer.renderer().bind_wl_display(dh);
match bind_result {
Ok(_) => {
slog_scope::info!("EGL hardware-acceleration enabled");
info!("EGL hardware-acceleration enabled.");
let dmabuf_formats = renderer
.renderer()
.dmabuf_formats()
@ -278,9 +279,9 @@ fn init_egl_client_side(
state
.common
.dmabuf_state
.create_global::<State, _>(dh, dmabuf_formats, None);
.create_global::<State>(dh, dmabuf_formats);
}
Err(err) => slog_scope::warn!("Unable to initialize bind display to EGL: {}", err),
Err(err) => warn!(?err, "Unable to initialize bind display to EGL."),
};
Ok(())

37
src/backend/x11.rs
View file

@ -37,6 +37,7 @@ use smithay::{
utils::{DeviceFd, Transform},
};
use std::{cell::RefCell, os::unix::io::OwnedFd};
use tracing::{debug, error, info, warn};
#[cfg(feature = "debug")]
use crate::state::Fps;
@ -96,7 +97,7 @@ impl X11State {
size: (size.w as i32, size.h as i32).into(),
refresh: 60_000,
};
let output = Output::new(name, props, None);
let output = Output::new(name, props);
output.add_mode(mode);
output.set_preferred(mode);
output.change_current_state(
@ -126,7 +127,7 @@ impl X11State {
if let Err(err) =
surface.render_output(&mut x11_state.renderer, &mut data.state.common)
{
slog_scope::error!("Error rendering: {}", err);
error!(?err, "Error rendering.");
}
surface.dirty = false;
surface.pending = true;
@ -272,12 +273,12 @@ impl Surface {
}
fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
let instance = match Instance::new(Version::VERSION_1_2, None, None) {
let instance = match Instance::new(Version::VERSION_1_2, None) {
Ok(instance) => instance,
Err(err) => {
slog_scope::warn!(
"Failed to instanciate vulkan, falling back to gbm allocator: {}",
err
warn!(
?err,
"Failed to instanciate vulkan, falling back to gbm allocator.",
);
return None;
}
@ -286,7 +287,7 @@ fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
let devices = match PhysicalDevice::enumerate(&instance) {
Ok(devices) => devices,
Err(err) => {
slog_scope::debug!("No vulkan devices, falling back to gbm: {}", err);
debug!(?err, "No vulkan devices, falling back to gbm.");
return None;
}
};
@ -299,7 +300,7 @@ fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
phd.primary_node().unwrap() == Some(*node) || phd.render_node().unwrap() == Some(*node)
})
else {
slog_scope::debug!("No vulkan device for node {:?}, falling back to gbm", node);
debug!(?node, "No vulkan device for node, falling back to gbm.");
return None;
};
@ -308,10 +309,10 @@ fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
fn try_gbm_allocator(fd: OwnedFd) -> Option<Allocator> {
// Create the gbm device for buffer allocation.
let device = match GbmDevice::new(DrmDeviceFd::new(DeviceFd::from(fd), None)) {
let device = match GbmDevice::new(DrmDeviceFd::new(DeviceFd::from(fd))) {
Ok(gbm) => gbm,
Err(err) => {
slog_scope::error!("Failed to create GBM device: {}", err);
error!(?err, "Failed to create GBM device.");
return None;
}
};
@ -327,7 +328,7 @@ pub fn init_backend(
event_loop: &mut EventLoop<Data>,
state: &mut State,
) -> Result<()> {
let backend = X11Backend::new(None).with_context(|| "Failed to initilize X11 backend")?;
let backend = X11Backend::new().with_context(|| "Failed to initilize X11 backend")?;
let handle = backend.handle();
// Obtain the DRM node the X server uses for direct rendering.
@ -340,12 +341,12 @@ pub fn init_backend(
.find(|device| device.try_get_render_node().ok().flatten() == Some(drm_node))
.with_context(|| format!("Failed to find EGLDevice for node {}", drm_node))?;
// Initialize EGL
let egl = EGLDisplay::new(device, None).with_context(|| "Failed to create EGL display")?;
let egl = EGLDisplay::new(device).with_context(|| "Failed to create EGL display")?;
// Create the OpenGL context
let context = EGLContext::new(&egl, None).with_context(|| "Failed to create EGL context")?;
let context = EGLContext::new(&egl).with_context(|| "Failed to create EGL context")?;
// Create a renderer
let mut renderer = unsafe { GlowRenderer::new(context, None) }
.with_context(|| "Failed to initialize renderer")?;
let mut renderer =
unsafe { GlowRenderer::new(context) }.with_context(|| "Failed to initialize renderer")?;
init_egl_client_side(dh, state, &mut renderer)?;
@ -478,14 +479,14 @@ where
let bind_result = renderer.bind_wl_display(dh);
match bind_result {
Ok(_) => {
slog_scope::info!("EGL hardware-acceleration enabled");
info!("EGL hardware-acceleration enabled.");
let dmabuf_formats = renderer.dmabuf_formats().cloned().collect::<Vec<_>>();
state
.common
.dmabuf_state
.create_global::<State, _>(dh, dmabuf_formats, None);
.create_global::<State>(dh, dmabuf_formats);
}
Err(err) => slog_scope::warn!("Unable to initialize bind display to EGL: {}", err),
Err(err) => warn!(?err, "Unable to initialize bind display to EGL."),
};
Ok(())

131
src/config/mod.rs
View file

@ -21,6 +21,7 @@ pub use smithay::{
utils::{Logical, Physical, Point, Size, Transform},
};
use std::{cell::RefCell, collections::HashMap, fs::OpenOptions, path::PathBuf};
use tracing::{debug, error, info, warn};
mod types;
pub use self::types::*;
@ -207,9 +208,9 @@ impl Config {
locations.push(PathBuf::from("/etc/cosmic-comp.ron"));
for path in locations {
slog_scope::debug!("Trying config location: {}", path.display());
debug!("Trying config location: {}", path.display());
if path.exists() {
slog_scope::info!("Using config at {}", path.display());
info!("Using config at {}", path.display());
return ron::de::from_reader(OpenOptions::new().read(true).open(path).unwrap())
.expect("Malformed config file");
}
@ -243,9 +244,9 @@ impl Config {
match ron::de::from_reader(OpenOptions::new().read(true).open(path).unwrap()) {
Ok(config) => return config,
Err(err) => {
slog_scope::warn!("Failed to read output_config ({}), resetting..", err);
warn!(?err, "Failed to read output_config, resetting..");
if let Err(err) = std::fs::remove_file(path) {
slog_scope::error!("Failed to remove output_config {}", err);
error!(?err, "Failed to remove output_config.");
}
}
};
@ -263,9 +264,9 @@ impl Config {
match ron::de::from_reader(OpenOptions::new().read(true).open(path).unwrap()) {
Ok(config) => return config,
Err(err) => {
slog_scope::warn!("Failed to read input_config ({}), resetting..", err);
warn!(?err, "Failed to read input_config, resetting..");
if let Err(err) = std::fs::remove_file(path) {
slog_scope::error!("Failed to remove input_config {}", err);
error!(?err, "Failed to remove input_config.");
}
}
};
@ -324,10 +325,10 @@ impl Config {
seats.iter().cloned(),
loop_handle,
) {
slog_scope::warn!(
"Failed to set new config for output {}: {}",
warn!(
?err,
"Failed to set new config for output {}.",
output.name(),
err
);
reset = true;
break;
@ -359,11 +360,7 @@ impl Config {
seats.iter().cloned(),
loop_handle,
) {
slog_scope::error!(
"Failed to reset config for output {}: {}",
output.name(),
err
);
error!(?err, "Failed to reset config for output {}.", output.name());
} else {
if enabled {
output_state.enable_head(&output);
@ -385,10 +382,10 @@ impl Config {
seats.iter().cloned(),
loop_handle,
) {
slog_scope::warn!(
"Failed to set new config for output {}: {}",
warn!(
?err,
"Failed to set new config for output {}.",
output.name(),
err
);
} else {
if output
@ -456,158 +453,158 @@ impl Config {
DeviceState::DisabledOnExternalMouse => device
.config_send_events_set_mode(SendEventsMode::DISABLED_ON_EXTERNAL_MOUSE),
} {
slog_scope::warn!(
"Failed to apply mode {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply mode {:?} for device {:?}.",
config.state,
device.name(),
err
);
}
if let Some(accel) = config.acceleration.as_ref() {
if let Some(profile) = accel.profile {
if let Err(err) = device.config_accel_set_profile(profile) {
slog_scope::warn!(
"Failed to apply acceleration profile {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply acceleration profile {:?} for device {:?}.",
profile,
device.name(),
err
);
}
}
if let Err(err) = device.config_accel_set_speed(accel.speed) {
slog_scope::warn!(
"Failed to apply acceleration speed {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply acceleration speed {:?} for device {:?}.",
accel.speed,
device.name(),
err
);
}
}
if let Some(matrix) = config.calibration {
if let Err(err) = device.config_calibration_set_matrix(matrix) {
slog_scope::warn!(
"Failed to apply calibration matrix {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply calibration matrix {:?} for device {:?}.",
matrix,
device.name(),
err
);
}
}
if let Some(method) = config.click_method {
if let Err(err) = device.config_click_set_method(method) {
slog_scope::warn!(
"Failed to apply click method {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply click method {:?} for device {:?}.",
method,
device.name(),
err
);
}
}
if let Some(dwt) = config.disable_while_typing {
if let Err(err) = device.config_dwt_set_enabled(dwt) {
slog_scope::warn!(
"Failed to apply disable-while-typing {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply disable-while-typing {:?} for device {:?}.",
dwt,
device.name(),
err
);
}
}
if let Some(left) = config.left_handed {
if let Err(err) = device.config_left_handed_set(left) {
slog_scope::warn!(
"Failed to apply left-handed {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply left-handed {:?} for device {:?}.",
left,
device.name(),
err
);
}
}
if let Some(middle) = config.middle_button_emulation {
if let Err(err) = device.config_middle_emulation_set_enabled(middle) {
slog_scope::warn!(
"Failed to apply middle-button-emulation {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply middle-button-emulation {:?} for device {:?}.",
middle,
device.name(),
err
);
}
}
if let Some(angle) = config.rotation_angle {
if let Err(err) = device.config_rotation_set_angle(angle) {
slog_scope::warn!(
"Failed to apply rotation-angle {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply rotation-angle {:?} for device {:?}",
angle,
device.name(),
err
);
}
}
if let Some(scroll) = config.scroll_config.as_ref() {
if let Some(method) = scroll.method {
if let Err(err) = device.config_scroll_set_method(method) {
slog_scope::warn!(
"Failed to apply scroll method {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply scroll method {:?} for device {:?}.",
method,
device.name(),
err
);
}
}
if let Some(natural) = scroll.natural_scroll {
if let Err(err) = device.config_scroll_set_natural_scroll_enabled(natural) {
slog_scope::warn!(
"Failed to apply natural scrolling {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply natural scrolling {:?} for device {:?}.",
natural,
device.name(),
err
);
}
}
if let Some(button) = scroll.scroll_button {
if let Err(err) = device.config_scroll_set_button(button) {
slog_scope::warn!(
"Failed to apply scroll button {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply scroll button {:?} for device {:?}.",
button,
device.name(),
err
);
}
}
}
if let Some(tap) = config.tap_config.as_ref() {
if let Err(err) = device.config_tap_set_enabled(tap.enabled) {
slog_scope::warn!(
"Failed to apply tap-to-click {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply tap-to-click {:?} for device {:?}.",
tap.enabled,
device.name(),
err
);
}
if let Some(button_map) = tap.button_map {
if let Err(err) = device.config_tap_set_button_map(button_map) {
slog_scope::warn!(
"Failed to apply button map {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply button map {:?} for device {:?}.",
button_map,
device.name(),
err
);
}
}
if let Err(err) = device.config_tap_set_drag_enabled(tap.drag) {
slog_scope::warn!(
"Failed to apply tap-drag {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply tap-drag {:?} for device {:?}.",
tap.drag,
device.name(),
err
);
}
if let Err(err) = device.config_tap_set_drag_lock_enabled(tap.drag_lock) {
slog_scope::warn!(
"Failed to apply tap-drag-lock {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply tap-drag-lock {:?} for device {:?}.",
tap.drag_lock,
device.name(),
err
);
}
}
@ -717,12 +714,12 @@ impl<'a, T: Serialize> Drop for PersistenceGuard<'a, T> {
{
Ok(writer) => writer,
Err(err) => {
slog_scope::warn!("Failed to persist {}: {}", path.display(), err);
warn!(?err, "Failed to persist {}.", path.display());
return;
}
};
if let Err(err) = ron::ser::to_writer_pretty(writer, &self.1, Default::default()) {
slog_scope::warn!("Failed to persist {}: {}", path.display(), err);
warn!(?err, "Failed to persist {}", path.display());
}
}
}

3
src/config/types.rs
View file

@ -10,6 +10,7 @@ pub use smithay::{
reexports::input::{AccelProfile, ClickMethod, ScrollMethod, TapButtonMap},
utils::{Logical, Physical, Point, Size, Transform},
};
use tracing::warn;
use xkbcommon::xkb;
#[derive(Debug, Clone, Deserialize, Serialize)]
@ -247,7 +248,7 @@ where
&"One of the keysym names of xkbcommon.h without the 'KEY_' prefix",
)),
x => {
slog_scope::warn!(
warn!(
"Key-Binding '{}' only matched case insensitive for {:?}",
name,
xkb::keysym_get_name(x)

24
src/input/mod.rs
View file

@ -35,6 +35,9 @@ use smithay::{
},
xwayland::X11Surface,
};
#[cfg(not(feature = "debug"))]
use tracing::info;
use tracing::{error, trace, warn};
use std::{cell::RefCell, collections::HashMap};
use xkbcommon::xkb::KEY_XF86Switch_VT_12;
@ -117,7 +120,7 @@ pub fn add_seat(
config: &Config,
name: String,
) -> Seat<State> {
let mut seat = seat_state.new_wl_seat(dh, name, None);
let mut seat = seat_state.new_wl_seat(dh, name);
let userdata = seat.user_data();
userdata.insert_if_missing(SeatId::default);
userdata.insert_if_missing(Devices::default);
@ -137,9 +140,9 @@ pub fn add_seat(
// devices appear), we have to surrender to reality and just always expose a keyboard and pointer.
let conf = config.xkb_config();
if let Err(err) = seat.add_keyboard((&conf).into(), 200, 25) {
slog_scope::warn!(
"Failed to load provided xkb config: {}. Trying default...",
err
warn!(
?err,
"Failed to load provided xkb config. Trying default...",
);
seat.add_keyboard(XkbConfig::default(), 200, 25)
.expect("Failed to load xkb configuration files");
@ -204,7 +207,7 @@ impl State {
if devices.has_device(&device) {
let keycode = event.key_code();
let state = event.state();
slog_scope::trace!("key"; "keycode" => keycode, "state" => format!("{:?}", state));
trace!(?keycode, ?state, "key");
let serial = SERIAL_COUNTER.next_serial();
let time = Event::time_msec(&event);
@ -233,10 +236,7 @@ impl State {
+ 1)
as i32,
) {
slog_scope::error!(
"Failed switching virtual terminal: {}",
err
);
error!(?err, "Failed switching virtual terminal.");
}
userdata.get::<SupressedKeys>().unwrap().add(&handle);
return FilterResult::Intercept(None);
@ -574,7 +574,7 @@ impl State {
}
#[cfg(not(feature = "debug"))]
Action::Debug => {
slog_scope::info!("Debug overlay not included in this version")
info!("Debug overlay not included in this build.")
}
Action::Close => {
let current_output = seat.active_output();
@ -923,7 +923,7 @@ impl State {
Action::Spawn(command) => {
if let Err(err) = std::process::Command::new("/bin/sh")
.arg("-c")
.arg(command)
.arg(command.clone())
.env("WAYLAND_DISPLAY", &self.common.socket)
.env(
"DISPLAY",
@ -938,7 +938,7 @@ impl State {
.env_remove("COSMIC_SESSION_SOCK")
.spawn()
{
slog_scope::warn!("Failed to spawn: {}", err);
warn!(?err, "Failed to spawn \"{}\"", command);
}
}
}

87
src/logger/mod.rs
View file

@ -1,59 +1,60 @@
// SPDX-License-Identifier: GPL-3.0-only
use std::str::FromStr;
use anyhow::Result;
use slog::{Drain, Level};
pub struct LogState {
_guard: slog_scope::GlobalLoggerGuard,
}
use tracing::{debug, info, warn};
use tracing_journald as journald;
use tracing_subscriber::{filter::Directive, fmt, prelude::*, EnvFilter};
pub fn init_logger() -> Result<LogState> {
let decorator = slog_term::TermDecorator::new().stderr().build();
let term_drain = slog_term::CompactFormat::new(decorator)
.build()
.ignore_res();
let journald_drain = slog_journald::JournaldDrain.ignore_res();
let drain = slog::Duplicate::new(term_drain, journald_drain);
// usually we would not want to use a Mutex here, but this is usefull for a prototype,
// to make sure we do not miss any in-flight messages, when we crash.
let logger = slog::Logger::root(
std::sync::Mutex::new(drain.filter(|record| {
if record.module().starts_with("smithay") || record.module().starts_with("cosmic_comp")
{
return true;
}
if record.module().contains("cosmic_text") {
// cosmic-text is very chatty
return record.level().is_at_least(Level::Error);
}
if cfg!(debug_assertions) {
record.level().is_at_least(Level::Warning)
pub fn init_logger() -> Result<()> {
let filter = EnvFilter::try_from_default_env()
.unwrap_or_else(|_| {
EnvFilter::new(if cfg!(debug_assertions) {
"warning"
} else {
record.level().is_at_least(Level::Error)
}
}))
.fuse(),
slog::o!(),
);
"error"
})
})
.add_directive(Directive::from_str("cosmic_text=error").unwrap())
.add_directive(
Directive::from_str(&format!(
"smithay={level},cosmic_comp={level}",
level = if cfg!(debug_assertions) {
"debug"
} else {
"info"
}
))
.unwrap(),
);
let _guard = slog_scope::set_global_logger(logger);
slog_stdlog::init_with_level(if cfg!(debug_assertions) {
log::Level::Debug
} else {
log::Level::Info
})
.unwrap();
let fmt_layer = fmt::layer().compact();
match journald::layer() {
Ok(journald_layer) => tracing_subscriber::registry()
.with(fmt_layer)
.with(journald_layer)
.with(filter)
.init(),
Err(err) => {
tracing_subscriber::registry()
.with(fmt_layer)
.with(filter)
.init();
warn!(?err, "Failed to init journald logging.");
}
};
log_panics::init();
slog_scope::info!("Version: {}", std::env!("CARGO_PKG_VERSION"));
info!("Version: {}", std::env!("CARGO_PKG_VERSION"));
if cfg!(feature = "debug") {
slog_scope::debug!(
debug!(
"Debug build ({})",
std::option_env!("GIT_HASH").unwrap_or("Unknown")
);
}
Ok(LogState { _guard })
Ok(())
}

19
src/main.rs
View file

@ -10,6 +10,7 @@ use smithay::{
use anyhow::{Context, Result};
use std::{ffi::OsString, os::unix::prelude::AsRawFd, sync::Arc};
use tracing::{error, info, warn};
pub mod backend;
pub mod config;
@ -27,8 +28,8 @@ pub mod xwayland;
fn main() -> Result<()> {
// setup logger
let _log = logger::init_logger()?;
slog_scope::info!("Cosmic starting up!");
logger::init_logger()?;
info!("Cosmic starting up!");
// init event loop
let mut event_loop =
@ -56,7 +57,7 @@ fn main() -> Result<()> {
event_loop.run(None, &mut data, |data| {
// shall we shut down?
if data.state.common.shell.outputs().next().is_none() || data.state.common.should_stop {
slog_scope::info!("Shutting down");
info!("Shutting down");
data.state.common.event_loop_signal.stop();
data.state.common.event_loop_signal.wakeup();
return;
@ -82,9 +83,9 @@ fn init_wayland_display(
) -> Result<(Display<state::State>, OsString)> {
let mut display = Display::new().unwrap();
let source = ListeningSocketSource::new_auto(None).unwrap();
let source = ListeningSocketSource::new_auto().unwrap();
let socket_name = source.socket_name().to_os_string();
slog_scope::info!("Listening on {:?}", socket_name);
info!("Listening on {:?}", socket_name);
event_loop
.handle()
@ -97,7 +98,7 @@ fn init_wayland_display(
data.state.new_client_state()
}),
) {
slog_scope::warn!("Error adding wayland client: {}", err);
warn!(?err, "Error adding wayland client");
};
})
.with_context(|| "Failed to init the wayland socket source.")?;
@ -112,10 +113,10 @@ fn init_wayland_display(
move |_, _, data: &mut state::Data| match data.display.dispatch_clients(&mut data.state)
{
Ok(_) => Ok(PostAction::Continue),
Err(e) => {
slog_scope::error!("I/O error on the Wayland display: {}", e);
Err(err) => {
error!(?err, "I/O error on the Wayland display");
data.state.common.should_stop = true;
Err(e)
Err(err)
}
},
)

17
src/session.rs
View file

@ -17,6 +17,7 @@ use std::{
},
sync::Arc,
};
use tracing::{error, warn};
use crate::state::{Data, State};
@ -108,7 +109,7 @@ pub fn setup_socket(handle: LoopHandle<Data>, state: &State) -> Result<()> {
stream.buffer = vec![0; stream.size as usize];
},
Err(err) => {
slog_scope::warn!("Error reading from session socket: {}", err);
warn!(?err, "Error reading from session socket");
return Ok(PostAction::Remove);
}
}
@ -117,7 +118,7 @@ pub fn setup_socket(handle: LoopHandle<Data>, state: &State) -> Result<()> {
stream.read_bytes += match stream.stream.read(&mut stream.buffer) {
Ok(size) => size,
Err(err) => {
slog_scope::error!("Error reading from session socket: {}", err);
error!(?err, "Error reading from session socket");
return Ok(PostAction::Remove);
}
};
@ -137,22 +138,22 @@ pub fn setup_socket(handle: LoopHandle<Data>, state: &State) -> Result<()> {
for fd in fds.into_iter().take(received_count) {
let stream = unsafe { UnixStream::from_raw_fd(fd) };
if let Err(err) = data.display.handle().insert_client(stream, Arc::new(data.state.new_privileged_client_state())) {
slog_scope::warn!("Failed to add privileged client to display: {}", err);
warn!(?err, "Failed to add privileged client to display");
}
}
},
Err(err) => {
slog_scope::warn!("Failed to read file descriptors from session sock: {}", err);
warn!(?err, "Failed to read file descriptors from session sock");
}
}
},
Ok(Message::SetEnv { .. }) => slog_scope::warn!("Got SetEnv from session? What is this?"),
_ => slog_scope::warn!("Unknown session socket message, are you using incompatible cosmic-session and cosmic-comp versions?"),
Ok(Message::SetEnv { .. }) => warn!("Got SetEnv from session? What is this?"),
_ => warn!("Unknown session socket message, are you using incompatible cosmic-session and cosmic-comp versions?"),
};
Ok(PostAction::Continue)
},
Err(err) => {
slog_scope::warn!("Invalid message from session sock: {}", err);
warn!(?err, "Invalid message from session sock");
Ok(PostAction::Continue)
}
}
@ -162,7 +163,7 @@ pub fn setup_socket(handle: LoopHandle<Data>, state: &State) -> Result<()> {
},
).with_context(|| "Failed to init the cosmic session socket source")?;
} else {
slog_scope::error!("COSMIC_SESSION_SOCK is no valid RawFd: {}", fd_num);
error!(socket = fd_num, "COSMIC_SESSION_SOCK is no valid RawFd.");
}
};

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

@ -54,6 +54,8 @@ use egui::plot::{Corner, Legend, Plot, PlotPoints, Polygon};
use smithay::backend::renderer::{
element::texture::TextureRenderElement, gles2::Gles2Texture, multigpu::Error as MultiError,
};
#[cfg(feature = "debug")]
use tracing::debug;
use super::{focus::FocusDirection, layout::floating::ResizeState};
@ -750,14 +752,13 @@ impl RenderElement<GlowRenderer> for CosmicMappedRenderElement<GlowRenderer> {
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage, log),
CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage, log),
CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, log)
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
}
}
}
@ -781,15 +782,14 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>>
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlMultiRenderer<'a, 'b> as Renderer>::Error> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage, log),
CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage, log),
CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => {
let glow_frame = frame.glow_frame_mut();
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage, log)
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage)
.map_err(|err| MultiError::Render(err))
}
}
@ -804,7 +804,7 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>>
CosmicMappedRenderElement::Window(elem) => elem.underlying_storage(renderer),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => {
let glow_renderer = renderer.glow_renderer();
let glow_renderer = renderer.glow_renderer_mut();
match elem.underlying_storage(glow_renderer) {
Some(UnderlyingStorage::Wayland(buffer)) => {
Some(UnderlyingStorage::Wayland(buffer))
@ -1015,7 +1015,7 @@ where
) {
Ok(element) => vec![element.into()],
Err(err) => {
slog_scope::debug!("Error rendering debug overlay: {}", err);
debug!(?err, "Error rendering debug overlay.");
Vec::new()
}
}

9
src/shell/focus/mod.rs
View file

@ -12,6 +12,7 @@ use smithay::{
utils::{IsAlive, Serial, SERIAL_COUNTER},
};
use std::cell::RefCell;
use tracing::{debug, info};
use self::target::{KeyboardFocusTarget, WindowGroup};
@ -100,7 +101,7 @@ impl Shell {
if let Some(workspace) = state.common.shell.space_for_mut(mapped) {
let mut focus_stack = workspace.focus_stack.get_mut(active_seat);
if Some(mapped) != focus_stack.last() {
slog_scope::debug!("Focusing window: {:?}", mapped);
debug!(?mapped, "Focusing window.");
focus_stack.append(mapped);
// also remove popup grabs, if we are switching focus
if let Some(mut popup_grab) = active_seat
@ -202,7 +203,7 @@ impl Common {
{
continue; // Focus is valid
} else {
slog_scope::debug!("Wrong Window, focus fixup");
debug!("Wrong Window, focus fixup");
}
}
KeyboardFocusTarget::LayerSurface(layer) => {
@ -223,7 +224,7 @@ impl Common {
} // Focus is valid
};
} else {
slog_scope::debug!("Surface dead, focus fixup");
debug!("Surface dead, focus fixup");
}
} else {
continue;
@ -262,7 +263,7 @@ impl Common {
.map(KeyboardFocusTarget::from)
});
if let Some(keyboard) = seat.get_keyboard() {
slog_scope::info!("restoring focus to: {:?}", target.as_ref());
info!("Restoring focus to {:?}", target.as_ref());
keyboard.set_focus(state, target.clone(), SERIAL_COUNTER.next_serial());
ActiveFocus::set(&seat, target);
}

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

@ -24,19 +24,11 @@ use crate::{
mod grabs;
pub use self::grabs::*;
#[derive(Debug)]
#[derive(Debug, Default)]
pub struct FloatingLayout {
pub(in crate::shell) space: Space<CosmicMapped>,
}
impl Default for FloatingLayout {
fn default() -> Self {
FloatingLayout {
space: Space::new(None),
}
}
}
impl FloatingLayout {
pub fn new() -> FloatingLayout {
Default::default()

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

@ -31,6 +31,7 @@ use smithay::{
wayland::seat::WaylandFocus,
};
use std::{borrow::Borrow, collections::HashMap, hash::Hash, sync::Arc};
use tracing::debug;
mod grabs;
pub use self::grabs::*;
@ -420,7 +421,7 @@ impl TilingLayout {
});
// remove self
slog_scope::debug!("Remove window {:?}", mapped);
debug!(?mapped, "Remove window.");
let _ = tree.remove_node(node_id.clone(), RemoveBehavior::DropChildren);
// fixup parent node
@ -433,7 +434,7 @@ impl TilingLayout {
if group.len() > 2 {
group.remove_window(position);
} else {
slog_scope::debug!("Removing Group");
debug!("Removing Group");
let other_child =
tree.children_ids(&id).unwrap().cloned().next().unwrap();
let fork_pos = parent_parent_id.as_ref().and_then(|parent_id| {

9
src/shell/mod.rs
View file

@ -1,5 +1,6 @@
use serde::{Deserialize, Serialize};
use std::{cell::RefCell, collections::HashMap};
use tracing::warn;
use cosmic_protocols::workspace::v1::server::zcosmic_workspace_handle_v1::State as WState;
use smithay::{
@ -430,8 +431,8 @@ impl WorkspaceMode {
impl Shell {
pub fn new(config: &Config, dh: &DisplayHandle) -> Self {
// TODO: Privileged protocols
let layer_shell_state = WlrLayerShellState::new::<State, _>(dh, None);
let xdg_shell_state = XdgShellState::new::<State, _>(dh, None);
let layer_shell_state = WlrLayerShellState::new::<State>(dh);
let xdg_shell_state = XdgShellState::new::<State>(dh);
let toplevel_info_state = ToplevelInfoState::new(
dh,
//|client| client.get_data::<ClientState>().map_or(false, |s| s.privileged),
@ -461,7 +462,7 @@ impl Shell {
);
Shell {
popups: PopupManager::new(None),
popups: PopupManager::default(),
outputs: Vec::new(),
workspaces: mode,
tiling_enabled,
@ -1090,7 +1091,7 @@ impl Shell {
.find(|xwm| Some(xwm.id()) == surface.xwm_id())
{
if let Err(err) = xwm.update_stacking_order_downwards(workspace.mapped()) {
slog_scope::warn!("Failed to update Xwayland stacking order: {}", err);
warn!(?err, "Failed to update Xwayland stacking order.");
}
}
}

22
src/shell/workspace.rs
View file

@ -32,6 +32,7 @@ use smithay::{
xwayland::X11Surface,
};
use std::collections::HashMap;
use tracing::warn;
use super::{
element::CosmicMapped,
@ -498,10 +499,10 @@ impl Workspace {
if let Err(err) =
xwm.update_stacking_order_upwards(render_elements.iter().rev().map(|e| e.id()))
{
slog_scope::warn!(
"Failed to update Xwm ({:?}) stacking order: {}",
xwm.id(),
err
warn!(
wm_id = ?xwm.id(),
?err,
"Failed to update Xwm stacking order.",
);
}
}
@ -578,10 +579,10 @@ impl Workspace {
if let Err(err) =
xwm.update_stacking_order_upwards(render_elements.iter().rev().map(|e| e.id()))
{
slog_scope::warn!(
"Failed to update Xwm ({:?}) stacking order: {}",
xwm.id(),
err
warn!(
wm_id = ?xwm.id(),
?err,
"Failed to update Xwm stacking order.",
);
}
}
@ -711,11 +712,10 @@ where
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, smithay::utils::Physical>],
log: &slog::Logger,
) -> Result<(), <R as Renderer>::Error> {
match self {
WorkspaceRenderElement::Wayland(elem) => elem.draw(frame, src, dst, damage, log),
WorkspaceRenderElement::Window(elem) => elem.draw(frame, src, dst, damage, log),
WorkspaceRenderElement::Wayland(elem) => elem.draw(frame, src, dst, damage),
WorkspaceRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
}
}

22
src/state.rs
View file

@ -53,6 +53,7 @@ use smithay::{
viewporter::ViewporterState,
},
};
use tracing::error;
use std::{cell::RefCell, collections::HashMap, ffi::OsString, time::Duration};
use std::{collections::VecDeque, time::Instant};
@ -206,7 +207,7 @@ impl BackendData {
BackendData::X11(ref mut state) => state.schedule_render(output, screencopy),
BackendData::Kms(ref mut state) => {
if let Err(err) = state.schedule_render(loop_handle, output, None, screencopy) {
slog_scope::crit!("Failed to schedule event, are we shutting down? {:?}", err);
error!(?err, "Failed to schedule event, are we shutting down?");
}
}
_ => unreachable!("No backend was initialized"),
@ -223,29 +224,26 @@ impl State {
) -> State {
let clock = Clock::new().expect("Failed to initialize clock");
let config = Config::load();
let compositor_state = CompositorState::new::<Self, _>(dh, None);
let data_device_state = DataDeviceState::new::<Self, _>(dh, None);
let compositor_state = CompositorState::new::<Self>(dh);
let data_device_state = DataDeviceState::new::<Self>(dh);
let dmabuf_state = DmabufState::new();
let keyboard_shortcuts_inhibit_state = KeyboardShortcutsInhibitState::new::<Self>(dh);
let output_state = OutputManagerState::new_with_xdg_output::<Self>(dh);
let output_configuration_state = OutputConfigurationState::new(dh, |_| true);
let presentation_state = PresentationState::new::<Self>(dh, clock.id() as u32);
let primary_selection_state = PrimarySelectionState::new::<Self, _>(dh, None);
let primary_selection_state = PrimarySelectionState::new::<Self>(dh);
let screencopy_state = ScreencopyState::new::<Self, _, _>(
dh,
vec![CursorMode::Embedded, CursorMode::Hidden],
|_| true,
); // TODO: privileged
let shm_state = ShmState::new::<Self, _>(
dh,
vec![wl_shm::Format::Xbgr8888, wl_shm::Format::Abgr8888],
None,
);
let shm_state =
ShmState::new::<Self>(dh, vec![wl_shm::Format::Xbgr8888, wl_shm::Format::Abgr8888]);
let seat_state = SeatState::<Self>::new();
let viewporter_state = ViewporterState::new::<Self, _>(dh, None);
let viewporter_state = ViewporterState::new::<Self>(dh);
let wl_drm_state = WlDrmState;
let kde_decoration_state = KdeDecorationState::new::<Self, _>(&dh, Mode::Client, None);
let xdg_decoration_state = XdgDecorationState::new::<Self, _>(&dh, None);
let kde_decoration_state = KdeDecorationState::new::<Self>(&dh, Mode::Client);
let xdg_decoration_state = XdgDecorationState::new::<Self>(&dh);
let shell = Shell::new(&config, dh);

14
src/systemd.rs
View file

@ -3,6 +3,7 @@
use crate::state::State;
use libsystemd::daemon::{booted, notify, NotifyState};
use std::process::Command;
use tracing::{error, warn};
pub fn ready(state: &State) {
if booted() {
@ -22,18 +23,15 @@ pub fn ready(state: &State) {
.status()
{
Ok(x) if x.success() => {}
Ok(x) => slog_scope::warn!(
"Failed to import WAYLAND_DISPLAY/DISPLAY into systemd (exit code {:?})",
x.code()
),
Err(err) => slog_scope::error!(
"Failed to run systemctl although booted with systemd: {}",
err
Ok(x) => warn!(
exit_code = ?x.code(),
"Failed to import WAYLAND_DISPLAY/DISPLAY into systemd",
),
Err(err) => error!(?err, "Failed to run systemctl although booted with systemd",),
};
if let Err(err) = notify(false, &[NotifyState::Ready]) {
slog_scope::error!("Failed to notify systemd: {}", err);
error!(?err, "Failed to notify systemd");
}
}
}

1
src/utils/iced.rs
View file

@ -613,7 +613,6 @@ where
size.to_f64().to_logical(1.0, Transform::Normal),
)),
Some(internal_ref.size),
slog_scope::logger(),
) {
return vec![C::from(buffer)];
}

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

@ -128,9 +128,7 @@ impl CompositorHandler for State {
CosmicSurface::Wayland(ref wl_window) => {
let toplevel = wl_window.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.buffer().is_some())
{
let output = seat.active_output();
Shell::map_window(self, &window, &output);

7
src/wayland/handlers/data_device.rs
View file

@ -13,6 +13,7 @@ use smithay::{
xwayland::xwm::{SelectionType, XwmId},
};
use std::{cell::RefCell, os::unix::io::OwnedFd};
use tracing::warn;
pub struct DnDIcon {
surface: RefCell<Option<WlSurface>>,
@ -66,10 +67,10 @@ impl DataDeviceHandler for State {
Some(metadata.mime_types.clone()),
)
}) {
slog_scope::warn!("Failed to set Xwayland clipboard selection: {}", err);
warn!(?err, "Failed to set Xwayland clipboard selection.");
}
} else if let Err(err) = xwm.new_selection(SelectionType::Clipboard, None) {
slog_scope::warn!("Failed to clear Xwayland clipboard selection: {}", err);
warn!(?err, "Failed to clear Xwayland clipboard selection.");
}
}
}
@ -94,7 +95,7 @@ impl DataDeviceHandler for State {
fd,
self.common.event_loop_handle.clone(),
) {
slog_scope::warn!("Failed to send clipboard (X11 -> Wayland): {}", err);
warn!(?err, "Failed to send clipboard (X11 -> Wayland).");
}
}
}

13
src/wayland/handlers/output_configuration.rs
View file

@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
use smithay::output::Output;
use tracing::{error, warn};
use crate::{
config::OutputConfig,
@ -89,10 +90,10 @@ impl State {
seats.iter().cloned(),
&self.common.event_loop_handle,
) {
slog_scope::warn!(
"Failed to apply config to {}: {}. Resetting",
warn!(
?err,
"Failed to apply config to {}. Resetting",
output.name(),
err
);
for (output, backup) in backups {
{
@ -111,11 +112,7 @@ impl State {
seats.iter().cloned(),
&self.common.event_loop_handle,
) {
slog_scope::error!(
"Failed to reset output config for {}: {}",
output.name(),
err
);
error!(?err, "Failed to reset output config for {}.", output.name(),);
}
}
}

7
src/wayland/handlers/primary_selection.rs
View file

@ -5,6 +5,7 @@ use smithay::{
delegate_primary_selection,
wayland::primary_selection::{PrimarySelectionHandler, PrimarySelectionState, with_source_metadata}, xwayland::xwm::{XwmId, SelectionType}, reexports::wayland_protocols::wp::primary_selection::zv1::server::zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1,
};
use tracing::warn;
use std::os::unix::io::OwnedFd;
@ -22,10 +23,10 @@ impl PrimarySelectionHandler for State {
if let Ok(Err(err)) = with_source_metadata(source, |metadata| {
xwm.new_selection(SelectionType::Primary, Some(metadata.mime_types.clone()))
}) {
slog_scope::warn!("Failed to set Xwayland primary selection: {}", err);
warn!(?err, "Failed to set Xwayland primary selection");
}
} else if let Err(err) = xwm.new_selection(SelectionType::Primary, None) {
slog_scope::warn!("Failed to clear Xwayland primary selection: {}", err);
warn!(?err, "Failed to clear Xwayland primary selection");
}
}
}
@ -50,7 +51,7 @@ impl PrimarySelectionHandler for State {
fd,
self.common.event_loop_handle.clone(),
) {
slog_scope::warn!("Failed to send primary selection (X11 -> Wayland): {}", err);
warn!(?err, "Failed to send primary selection (X11 -> Wayland).");
}
}
}

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

@ -39,6 +39,7 @@ use smithay::{
},
xwayland::XWaylandClientData,
};
use tracing::warn;
use crate::{
backend::render::{
@ -250,7 +251,7 @@ impl ScreencopyHandler for State {
let buffer_size = match buffer_dimensions(&params.buffer) {
Some(size) => size.to_logical(1, Transform::Normal),
None => {
slog_scope::warn!("Error during screencopy session: Buffer has no size");
warn!("Error during screencopy session: Buffer has no size");
session.failed(FailureReason::InvalidBuffer);
return;
}
@ -260,7 +261,7 @@ impl ScreencopyHandler for State {
let mode = match output.current_mode() {
Some(mode) => mode,
None => {
slog_scope::warn!("Error during screencopy session: Output has no mode");
warn!("Error during screencopy session: Output has no mode");
session.failed(FailureReason::InvalidOutput);
return;
}
@ -268,7 +269,7 @@ impl ScreencopyHandler for State {
.size;
if buffer_size.to_physical(1) != mode {
slog_scope::warn!("Error during screencopy session: Buffer size doesn't match");
warn!("Error during screencopy session: Buffer size doesn't match");
session.failed(FailureReason::InvalidSize);
return;
}
@ -276,7 +277,7 @@ impl ScreencopyHandler for State {
SessionType::Window(window) => {
let geometry = window.geometry();
if buffer_size != geometry.size {
slog_scope::warn!("Error during screencopy session: Buffer size doesn't match");
warn!("Error during screencopy session: Buffer size doesn't match");
session.failed(FailureReason::InvalidSize);
return;
}
@ -288,7 +289,7 @@ impl ScreencopyHandler for State {
buffer_type(&params.buffer),
Some(BufferType::Shm) | Some(BufferType::Dma)
) {
slog_scope::warn!("Error during screencopy session: Buffer is neither shm or dma");
warn!("Error during screencopy session: Buffer is neither shm or dma");
session.failed(FailureReason::InvalidBuffer);
return;
}
@ -299,7 +300,7 @@ impl ScreencopyHandler for State {
})
.unwrap()
{
slog_scope::warn!("Error during screencopy session: Invalid shm buffer format");
warn!("Error during screencopy session: Invalid shm buffer format");
session.failed(FailureReason::InvalidBuffer);
return;
}
@ -368,8 +369,8 @@ impl ScreencopyHandler for State {
buffer.release();
}
Ok(true) => {} // success
Err((reason, error)) => {
slog_scope::warn!("Error during screencopy session: {}", error);
Err((reason, err)) => {
warn!(?err, "Error during screencopy session");
session.failed(reason);
}
}
@ -955,7 +956,7 @@ pub fn render_window_to_buffer(
.map_err(DamageTrackedRendererError::Rendering)?;
}
dtr.render_output(renderer, age, &elements, CLEAR_COLOR, None)
dtr.render_output(renderer, age, &elements, CLEAR_COLOR)
}
let node = node_from_params(&params, &mut state.backend, None);
@ -1134,7 +1135,7 @@ impl State {
Ok(false) => data.state.common.still_pending(session, params),
Ok(true) => {} // success
Err((reason, err)) => {
slog_scope::warn!("Screencopy session failed: {}", err);
warn!(?err, "Screencopy session failed");
session.failed(reason);
}
}
@ -1263,7 +1264,7 @@ pub fn schedule_offscreen_workspace_session(
}
Ok(true) => {}
Err((reason, err)) => {
slog_scope::warn!("Screencopy session failed: {}", err);
warn!(?err, "Screencopy session failed.");
session.failed(reason);
}
}

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

@ -22,6 +22,7 @@ use smithay::{
},
};
use std::cell::Cell;
use tracing::warn;
use super::screencopy::PendingScreencopyBuffers;
@ -125,9 +126,9 @@ impl XdgShellHandler for State {
self.common.shell.unconstrain_popup(&surface, &positioner);
surface.send_repositioned(token);
if let Err(err) = surface.send_configure() {
slog_scope::warn!(
"Client bug: Unable to re-configure repositioned popup: {}",
err
warn!(
?err,
"Client bug: Unable to re-configure repositioned popup.",
);
}
}

13
src/wayland/handlers/xdg_shell/popup.rs
View file

@ -24,6 +24,7 @@ use smithay::{
},
};
use std::sync::Mutex;
use tracing::{debug, warn};
impl Shell {
pub fn unconstrain_popup(&self, surface: &PopupSurface, positioner: &PositionerState) {
@ -86,9 +87,9 @@ pub fn update_reactive_popups<'a>(
{
unconstrain_xdg_popup(&surface, loc, rect);
if let Err(err) = surface.send_configure() {
slog_scope::warn!(
"Compositor bug: Unable to re-configure reactive popup: {}",
err
warn!(
?err,
"Compositor bug: Unable to re-configure reactive popup",
);
}
}
@ -103,7 +104,7 @@ fn unconstrain_xdg_popup_tile(surface: &PopupSurface, rect: Rectangle<i32, Logic
let offset = check_constrained(geometry, rect);
if offset.x != 0 || offset.y != 0 {
slog_scope::debug!("Unconstraining popup to tile: {:?}", surface);
debug!(?surface, "Unconstraining popup to tile.");
if !unconstrain_flip(&surface, rect) {
return unconstrain_slide(&surface, rect);
// don't try to resize for fitting to a tile
@ -123,7 +124,7 @@ fn unconstrain_xdg_popup(
let offset = check_constrained(geometry, relative);
if offset.x != 0 || offset.y != 0 {
slog_scope::debug!("Unconstraining popup: {:?}", surface);
debug!(?surface, "Unconstraining popup.");
if !unconstrain_flip(&surface, relative) {
if !unconstrain_slide(&surface, relative) {
unconstrain_resize(&surface, relative);
@ -143,7 +144,7 @@ fn unconstrain_layer_popup(surface: &PopupSurface, output: &Output, layer_surfac
let offset = check_constrained(geometry, relative);
if offset.x != 0 || offset.y != 0 {
slog_scope::debug!("Unconstraining popup: {:?}", surface);
debug!(?surface, "Unconstraining popup.");
if !unconstrain_flip(&surface, relative) {
if !unconstrain_slide(&surface, relative) {
unconstrain_resize(&surface, relative);

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

@ -34,6 +34,7 @@ use smithay::{
dmabuf::{DmabufGlobal, DmabufHandler, ImportError},
},
};
use tracing::trace;
use std::{convert::TryFrom, path::PathBuf, sync::Arc};
@ -44,7 +45,6 @@ pub struct DrmGlobalData {
filter: Box<dyn for<'a> Fn(&'a Client) -> bool + Send + Sync>,
formats: Arc<Vec<Fourcc>>,
device_path: PathBuf,
_logger: slog::Logger,
dmabuf_global: DmabufGlobal,
}
@ -165,9 +165,7 @@ where
Ok(_) => {
// import was successful
data_init.init(id, dmabuf);
slog_scope::trace!(
"Created a new validated dma wl_buffer via wl_drm."
);
trace!("Created a new validated dma wl_buffer via wl_drm.");
}
Err(ImportError::InvalidFormat) => {
@ -246,7 +244,6 @@ impl WlDrmState {
formats,
device_path,
dmabuf_global: dmabuf_global.clone(),
_logger: slog_scope::logger().new(slog::o!("cosmic_module" => "wayland_drm")),
};
display.create_global::<D, wl_drm::WlDrm, _>(2, data)

5
src/wayland/protocols/screencopy.rs
View file

@ -24,6 +24,7 @@ use smithay::{
},
utils::{user_data::UserDataMap, Buffer, IsAlive, Physical, Point, Rectangle, Size, Transform},
};
use tracing::warn;
use wayland_backend::{
protocol::WEnum,
server::{GlobalId, ObjectId},
@ -540,7 +541,7 @@ fn check_cursor(
match cursor.into_result() {
Ok(mode) => {
if !supported.contains(&mode) {
slog_scope::warn!("Client did send unsupported cursor mode: {:?}", mode);
warn!(?mode, "Client did send unsupported cursor mode");
resource.post_error(
zcosmic_screencopy_manager_v1::Error::InvalidCursorMode,
"Unsupported cursor mode",
@ -550,7 +551,7 @@ fn check_cursor(
Some(mode)
}
Err(err) => {
slog_scope::warn!("Client did send unknown cursor mode: {}", err);
warn!(?err, "Client did send unknown cursor mode");
resource.post_error(
zcosmic_screencopy_manager_v1::Error::InvalidCursorMode,
"Unknown cursor mode, wrong protocol version?",

38
src/xwayland.rs
View file

@ -27,6 +27,7 @@ use smithay::{
X11Surface, X11Wm, XWayland, XWaylandEvent, XwmHandler,
},
};
use tracing::{error, info, warn};
pub struct XWaylandState {
pub xwm: Option<X11Wm>,
@ -41,7 +42,7 @@ impl State {
return;
}
let (xwayland, source) = XWayland::new(None, &self.common.display_handle);
let (xwayland, source) = XWayland::new(&self.common.display_handle);
let token =
match self
.common
@ -58,11 +59,10 @@ impl State {
data.state.common.display_handle.clone(),
connection,
client,
None,
) {
Ok(wm) => wm,
Err(err) => {
slog_scope::error!("Failed to start Xwayland WM: {}", err);
error!(?err, "Failed to start Xwayland WM");
return;
}
};
@ -74,10 +74,10 @@ impl State {
Size::from((image.width as u16, image.height as u16)),
Point::from((image.xhot as u16, image.yhot as u16)),
) {
slog_scope::warn!(
"Failed to set default cursor for Xwayland WM ({:?}): {}",
wm.id(),
err
warn!(
id = ?wm.id(),
?err,
"Failed to set default cursor for Xwayland WM",
);
}
@ -95,7 +95,7 @@ impl State {
}) {
Ok(token) => token,
Err(err) => {
slog_scope::error!("Failed to listen for Xwayland: {}", err);
error!(?err, "Failed to listen for Xwayland");
return;
}
};
@ -122,7 +122,7 @@ impl State {
);
}
Err(err) => {
slog_scope::error!("Failed to start Xwayland: {}", err);
error!(?err, "Failed to start Xwayland.");
self.common.event_loop_handle.remove(token);
}
}
@ -146,11 +146,7 @@ impl XwmHandler for Data {
fn map_window_request(&mut self, _xwm: XwmId, window: X11Surface) {
if let Err(err) = window.set_mapped(true) {
slog_scope::warn!(
"Failed to send Xwayland Mapped-Event (for window {:?}): {}",
window,
err
);
warn!(?window, ?err, "Failed to send Xwayland Mapped-Event",);
}
let surface = CosmicSurface::X11(window.clone());
@ -471,17 +467,17 @@ impl XwmHandler for Data {
match selection {
SelectionType::Clipboard => {
if let Err(err) = request_data_device_client_selection(seat, mime_type, fd) {
slog_scope::error!(
"Failed to request current wayland clipboard for Xwayland: {}",
err
error!(
?err,
"Failed to request current wayland clipboard for Xwayland.",
);
}
}
SelectionType::Primary => {
if let Err(err) = request_primary_client_selection(seat, mime_type, fd) {
slog_scope::error!(
"Failed to request current wayland primary selection for Xwayland: {}",
err
error!(
?err,
"Failed to request current wayland primary selection for Xwayland.",
);
}
}
@ -493,7 +489,7 @@ impl XwmHandler for Data {
}
fn new_selection(&mut self, xwm: XwmId, selection: SelectionType, mime_types: Vec<String>) {
slog_scope::info!("Got Selection {:?} from X11: {:?}", selection, mime_types);
info!(?selection, ?mime_types, "Got Selection from Xwayland",);
if self.state.common.is_x_focused(xwm) {
let seat = self.state.common.last_active_seat();