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

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),
}
}