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

Update to latest Smithay version

Browse source
This commit is contained in:
Ian Douglas Scott 2024-06-18 19:23:16 -07:00 • committed by Victoria Brekenfeld
parent c91d3fe77b
commit f2342f56c1
17 changed files with 228 additions and 123 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Cargo.lock generated
View file

@ -4581,7 +4581,7 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
[[package]] [[package]]
name = "smithay" name = "smithay"
version = "0.3.0" version = "0.3.0"
source = "git+https://github.com/smithay//smithay?rev=24e36e9#24e36e97a1844d575a1586d3cddcc94d96c2044d" source = "git+https://github.com/smithay//smithay?rev=b4f8120#b4f8120be0fb9b7f038d041efa7f6549e26cd2bc"
dependencies = [ dependencies = [
"appendlist", "appendlist",
"ash", "ash",

2
Cargo.toml
View file

@ -118,4 +118,4 @@ inherits = "release"
lto = "fat" lto = "fat"
[patch."https://github.com/Smithay/smithay.git"] [patch."https://github.com/Smithay/smithay.git"]
smithay = {git = "https://github.com/smithay//smithay", rev = "24e36e9"} smithay = {git = "https://github.com/smithay//smithay", rev = "b4f8120"}

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

@ -189,21 +189,22 @@ impl RenderElement<GlowRenderer> for CosmicElement<GlowRenderer> {
src: Rectangle<f64, BufferCoords>, src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>, dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>], damage: &[Rectangle<i32, Physical>],
opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), <GlowRenderer as Renderer>::Error> { ) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self { match self {
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage), CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage), CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
CosmicElement::Dnd(elem) => elem.draw(frame, src, dst, damage), CosmicElement::Dnd(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage), CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
CosmicElement::AdditionalDamage(elem) => { CosmicElement::AdditionalDamage(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage) RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
} }
CosmicElement::Mirror(elem) => { CosmicElement::Mirror(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage) RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
} }
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
CosmicElement::Egui(elem) => { CosmicElement::Egui(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage) RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
} }
} }
} }
@ -229,20 +230,33 @@ impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicElement<GlMultiRenderer<'a
src: Rectangle<f64, BufferCoords>, src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>, dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>], damage: &[Rectangle<i32, Physical>],
opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), GlMultiError> { ) -> Result<(), GlMultiError> {
match self { match self {
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage), CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage), CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
CosmicElement::Dnd(elem) => elem.draw(frame, src, dst, damage), CosmicElement::Dnd(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage), CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
CosmicElement::AdditionalDamage(elem) => { CosmicElement::AdditionalDamage(elem) => RenderElement::<GlMultiRenderer<'a>>::draw(
RenderElement::<GlMultiRenderer<'a>>::draw(elem, frame, src, dst, damage) elem,
} frame,
src,
dst,
damage,
opaque_regions,
),
CosmicElement::Mirror(elem) => { CosmicElement::Mirror(elem) => {
let elem = { let elem = {
let glow_frame = frame.glow_frame_mut(); let glow_frame = frame.glow_frame_mut();
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage) RenderElement::<GlowRenderer>::draw(
.map_err(|err| GlMultiError::Render(err)) elem,
glow_frame,
src,
dst,
damage,
opaque_regions,
)
.map_err(|err| GlMultiError::Render(err))
}; };
elem elem
} }
@ -250,8 +264,15 @@ impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicElement<GlMultiRenderer<'a
CosmicElement::Egui(elem) => { CosmicElement::Egui(elem) => {
let elem = { let elem = {
let glow_frame = frame.glow_frame_mut(); let glow_frame = frame.glow_frame_mut();
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage) RenderElement::<GlowRenderer>::draw(
.map_err(|err| GlMultiError::Render(err)) elem,
glow_frame,
src,
dst,
damage,
opaque_regions,
)
.map_err(|err| GlMultiError::Render(err))
}; };
elem elem
} }
@ -439,6 +460,7 @@ impl<R: Renderer> RenderElement<R> for DamageElement {
_src: Rectangle<f64, BufferCoords>, _src: Rectangle<f64, BufferCoords>,
_dst: Rectangle<i32, Physical>, _dst: Rectangle<i32, Physical>,
_damage: &[Rectangle<i32, Physical>], _damage: &[Rectangle<i32, Physical>],
_opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), <R as Renderer>::Error> { ) -> Result<(), <R as Renderer>::Error> {
Ok(()) Ok(())
} }

24
src/input/mod.rs
View file

@ -528,7 +528,7 @@ impl State {
Some(constraint) if constraint.is_active() => { Some(constraint) if constraint.is_active() => {
// Constraint does not apply if not within region // Constraint does not apply if not within region
if !constraint.region().map_or(true, |x| { if !constraint.region().map_or(true, |x| {
x.contains(ptr.current_location().to_i32_round() - *surface_loc) x.contains((ptr.current_location() - *surface_loc).to_i32_round())
}) { }) {
return; return;
} }
@ -621,7 +621,7 @@ impl State {
} }
if let Some(region) = confine_region { if let Some(region) = confine_region {
if !region if !region
.contains(position.as_logical().to_i32_round() - *surface_loc) .contains((position.as_logical() - *surface_loc).to_i32_round())
{ {
ptr.frame(self); ptr.frame(self);
return; return;
@ -653,7 +653,7 @@ impl State {
PointerConstraint::Confined(confined) => confined.region(), PointerConstraint::Confined(confined) => confined.region(),
}; };
let point = let point =
ptr.current_location().to_i32_round() - surface_location; (ptr.current_location() - surface_location).to_i32_round();
if region.map_or(true, |region| region.contains(point)) { if region.map_or(true, |region| region.contains(point)) {
constraint.activate(); constraint.activate();
} }
@ -2501,7 +2501,7 @@ impl State {
global_pos: Point<f64, Global>, global_pos: Point<f64, Global>,
output: &Output, output: &Output,
shell: &mut Shell, shell: &mut Shell,
) -> Option<(PointerFocusTarget, Point<i32, Global>)> { ) -> Option<(PointerFocusTarget, Point<f64, Global>)> {
let session_lock = shell.session_lock.as_ref(); let session_lock = shell.session_lock.as_ref();
let relative_pos = global_pos.to_local(output); let relative_pos = global_pos.to_local(output);
let output_geo = output.geometry(); let output_geo = output.geometry();
@ -2513,7 +2513,7 @@ impl State {
surface: surface.wl_surface().clone(), surface: surface.wl_surface().clone(),
toplevel: None, toplevel: None,
}, },
output_geo.loc, output_geo.loc.to_f64(),
) )
}); });
} }
@ -2531,7 +2531,7 @@ impl State {
surface: wl_surface, surface: wl_surface,
toplevel: None, toplevel: None,
}, },
output_geo.loc + layer_loc.as_global() + surface_loc.as_global(), (output_geo.loc + layer_loc.as_global() + surface_loc.as_global()).to_f64(),
)); ));
} }
} }
@ -2545,7 +2545,7 @@ impl State {
}) })
.and_then(|or| { .and_then(|or| {
or.wl_surface() or.wl_surface()
.map(|surface| (surface, X11Surface::geometry(or).loc.as_global())) .map(|surface| (surface, X11Surface::geometry(or).loc.as_global().to_f64()))
}) })
{ {
return Some(( return Some((
@ -2557,7 +2557,7 @@ impl State {
)); ));
} }
PointerFocusTarget::under_surface(window, relative_pos.as_logical()) PointerFocusTarget::under_surface(window, relative_pos.as_logical())
.map(|(target, surface_loc)| (target, output_geo.loc + surface_loc.as_global())) .map(|(target, surface_loc)| (target, (output_geo.loc + surface_loc.as_global()).to_f64()))
} else { } else {
{ {
let layers = layer_map_for_output(output); let layers = layer_map_for_output(output);
@ -2575,7 +2575,8 @@ impl State {
surface: wl_surface, surface: wl_surface,
toplevel: None, toplevel: None,
}, },
output_geo.loc + layer_loc.as_global() + surface_loc.as_global(), (output_geo.loc + layer_loc.as_global() + surface_loc.as_global())
.to_f64(),
)); ));
} }
} }
@ -2590,7 +2591,7 @@ impl State {
}) })
.and_then(|or| { .and_then(|or| {
or.wl_surface() or.wl_surface()
.map(|surface| (surface, X11Surface::geometry(or).loc.as_global())) .map(|surface| (surface, X11Surface::geometry(or).loc.as_global().to_f64()))
}) })
{ {
return Some(( return Some((
@ -2620,7 +2621,8 @@ impl State {
surface: wl_surface, surface: wl_surface,
toplevel: None, toplevel: None,
}, },
output_geo.loc + layer_loc.as_global() + surface_loc.as_global(), (output_geo.loc + layer_loc.as_global() + surface_loc.as_global())
.to_f64(),
)); ));
} }
} }

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

@ -260,7 +260,7 @@ impl CosmicMapped {
pub fn focus_under( pub fn focus_under(
&self, &self,
relative_pos: Point<f64, Logical>, relative_pos: Point<f64, Logical>,
) -> Option<(PointerFocusTarget, Point<i32, Logical>)> { ) -> Option<(PointerFocusTarget, Point<f64, Logical>)> {
match &self.element { match &self.element {
CosmicMappedInternal::Stack(stack) => stack.focus_under(relative_pos), CosmicMappedInternal::Stack(stack) => stack.focus_under(relative_pos),
CosmicMappedInternal::Window(window) => window.focus_under(relative_pos), CosmicMappedInternal::Window(window) => window.focus_under(relative_pos),
@ -1219,31 +1219,48 @@ impl RenderElement<GlowRenderer> for CosmicMappedRenderElement<GlowRenderer> {
src: Rectangle<f64, BufferCoords>, src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>, dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>], damage: &[Rectangle<i32, Physical>],
opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), <GlowRenderer as Renderer>::Error> { ) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self { match self {
CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage), CosmicMappedRenderElement::Stack(elem) => {
CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage), elem.draw(frame, src, dst, damage, opaque_regions)
CosmicMappedRenderElement::TiledStack(elem) => elem.draw(frame, src, dst, damage), }
CosmicMappedRenderElement::TiledWindow(elem) => elem.draw(frame, src, dst, damage), CosmicMappedRenderElement::Window(elem) => {
CosmicMappedRenderElement::TiledOverlay(elem) => { elem.draw(frame, src, dst, damage, opaque_regions)
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage) }
CosmicMappedRenderElement::TiledStack(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::TiledWindow(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::TiledOverlay(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::MovingStack(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::MovingWindow(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::GrabbedStack(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::GrabbedWindow(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
} }
CosmicMappedRenderElement::MovingStack(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::MovingWindow(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::GrabbedStack(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::GrabbedWindow(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::FocusIndicator(elem) => { CosmicMappedRenderElement::FocusIndicator(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage) RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
} }
CosmicMappedRenderElement::Overlay(elem) => { CosmicMappedRenderElement::Overlay(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage) RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
} }
CosmicMappedRenderElement::StackHoverIndicator(elem) => { CosmicMappedRenderElement::StackHoverIndicator(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage) RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
} }
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => { CosmicMappedRenderElement::Egui(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage) RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
} }
} }
} }
@ -1277,36 +1294,75 @@ impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicMappedRenderElement<GlMult
src: Rectangle<f64, BufferCoords>, src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>, dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>], damage: &[Rectangle<i32, Physical>],
opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), GlMultiError> { ) -> Result<(), GlMultiError> {
match self { match self {
CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage), CosmicMappedRenderElement::Stack(elem) => {
CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage), elem.draw(frame, src, dst, damage, opaque_regions)
CosmicMappedRenderElement::TiledStack(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::TiledWindow(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::TiledOverlay(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame.glow_frame_mut(), src, dst, damage)
.map_err(|err| GlMultiError::Render(err))
} }
CosmicMappedRenderElement::MovingStack(elem) => elem.draw(frame, src, dst, damage), CosmicMappedRenderElement::Window(elem) => {
CosmicMappedRenderElement::MovingWindow(elem) => elem.draw(frame, src, dst, damage), elem.draw(frame, src, dst, damage, opaque_regions)
CosmicMappedRenderElement::GrabbedStack(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::GrabbedWindow(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::FocusIndicator(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame.glow_frame_mut(), src, dst, damage)
.map_err(|err| GlMultiError::Render(err))
} }
CosmicMappedRenderElement::Overlay(elem) => { CosmicMappedRenderElement::TiledStack(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame.glow_frame_mut(), src, dst, damage) elem.draw(frame, src, dst, damage, opaque_regions)
.map_err(|err| GlMultiError::Render(err))
} }
CosmicMappedRenderElement::TiledWindow(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::TiledOverlay(elem) => RenderElement::<GlowRenderer>::draw(
elem,
frame.glow_frame_mut(),
src,
dst,
damage,
opaque_regions,
)
.map_err(|err| GlMultiError::Render(err)),
CosmicMappedRenderElement::MovingStack(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::MovingWindow(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::GrabbedStack(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::GrabbedWindow(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::FocusIndicator(elem) => RenderElement::<GlowRenderer>::draw(
elem,
frame.glow_frame_mut(),
src,
dst,
damage,
opaque_regions,
)
.map_err(|err| GlMultiError::Render(err)),
CosmicMappedRenderElement::Overlay(elem) => RenderElement::<GlowRenderer>::draw(
elem,
frame.glow_frame_mut(),
src,
dst,
damage,
opaque_regions,
)
.map_err(|err| GlMultiError::Render(err)),
CosmicMappedRenderElement::StackHoverIndicator(elem) => { CosmicMappedRenderElement::StackHoverIndicator(elem) => {
elem.draw(frame, src, dst, damage) elem.draw(frame, src, dst, damage, opaque_regions)
} }
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => { CosmicMappedRenderElement::Egui(elem) => {
let glow_frame = frame.glow_frame_mut(); let glow_frame = frame.glow_frame_mut();
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage) RenderElement::<GlowRenderer>::draw(
.map_err(|err| GlMultiError::Render(err)) elem,
glow_frame,
src,
dst,
damage,
opaque_regions,
)
.map_err(|err| GlMultiError::Render(err))
} }
} }
} }

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

@ -420,7 +420,7 @@ impl CosmicStack {
pub fn focus_under( pub fn focus_under(
&self, &self,
mut relative_pos: Point<f64, Logical>, mut relative_pos: Point<f64, Logical>,
) -> Option<(PointerFocusTarget, Point<i32, Logical>)> { ) -> Option<(PointerFocusTarget, Point<f64, Logical>)> {
self.0.with_program(|p| { self.0.with_program(|p| {
let mut stack_ui = None; let mut stack_ui = None;
let geo = p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)].geometry(); let geo = p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)].geometry();
@ -435,14 +435,14 @@ impl CosmicStack {
{ {
stack_ui = Some(( stack_ui = Some((
PointerFocusTarget::StackUI(self.clone()), PointerFocusTarget::StackUI(self.clone()),
Point::from((0, 0)), Point::from((0., 0.)),
)); ));
} }
if point_i32.y - geo.loc.y < TAB_HEIGHT { if point_i32.y - geo.loc.y < TAB_HEIGHT {
stack_ui = Some(( stack_ui = Some((
PointerFocusTarget::StackUI(self.clone()), PointerFocusTarget::StackUI(self.clone()),
Point::from((0, 0)), Point::from((0., 0.)),
)); ));
} }
@ -458,7 +458,7 @@ impl CosmicStack {
surface, surface,
toplevel: Some(active_window.clone().into()), toplevel: Some(active_window.clone().into()),
}, },
surface_offset + Point::from((0, TAB_HEIGHT)), surface_offset.to_f64() + Point::from((0., TAB_HEIGHT as f64)),
) )
}) })
.or(stack_ui) .or(stack_ui)

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

@ -247,9 +247,9 @@ impl CosmicWindow {
pub fn focus_under( pub fn focus_under(
&self, &self,
mut relative_pos: Point<f64, Logical>, mut relative_pos: Point<f64, Logical>,
) -> Option<(PointerFocusTarget, Point<i32, Logical>)> { ) -> Option<(PointerFocusTarget, Point<f64, Logical>)> {
self.0.with_program(|p| { self.0.with_program(|p| {
let mut offset = Point::from((0, 0)); let mut offset = Point::from((0., 0.));
let mut window_ui = None; let mut window_ui = None;
if p.has_ssd(false) { if p.has_ssd(false) {
let geo = p.window.geometry(); let geo = p.window.geometry();
@ -264,19 +264,19 @@ impl CosmicWindow {
{ {
window_ui = Some(( window_ui = Some((
PointerFocusTarget::WindowUI(self.clone()), PointerFocusTarget::WindowUI(self.clone()),
Point::from((0, 0)), Point::from((0., 0.)),
)); ));
} }
if point_i32.y - geo.loc.y < SSD_HEIGHT { if point_i32.y - geo.loc.y < SSD_HEIGHT {
window_ui = Some(( window_ui = Some((
PointerFocusTarget::WindowUI(self.clone()), PointerFocusTarget::WindowUI(self.clone()),
Point::from((0, 0)), Point::from((0., 0.)),
)); ));
} }
relative_pos.y -= SSD_HEIGHT as f64; relative_pos.y -= SSD_HEIGHT as f64;
offset.y += SSD_HEIGHT; offset.y += SSD_HEIGHT as f64;
} }
p.window p.window
@ -288,7 +288,7 @@ impl CosmicWindow {
surface, surface,
toplevel: Some(p.window.clone().into()), toplevel: Some(p.window.clone().into()),
}, },
offset + surface_offset, (offset + surface_offset.to_f64()),
) )
}) })
.or(window_ui) .or(window_ui)

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

@ -473,7 +473,7 @@ impl PointerGrab<State> for MenuGrab {
&mut self, &mut self,
state: &mut State, state: &mut State,
handle: &mut PointerInnerHandle<'_, State>, handle: &mut PointerInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &MotionEvent, event: &MotionEvent,
) { ) {
{ {
@ -520,7 +520,7 @@ impl PointerGrab<State> for MenuGrab {
&mut self, &mut self,
state: &mut State, state: &mut State,
handle: &mut PointerInnerHandle<'_, State>, handle: &mut PointerInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &RelativeMotionEvent, event: &RelativeMotionEvent,
) { ) {
// While the grab is active, no client has pointer focus // While the grab is active, no client has pointer focus

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

@ -31,14 +31,14 @@ pub enum GrabStartData {
} }
impl GrabStartData { impl GrabStartData {
pub fn focus(&self) -> Option<&(PointerFocusTarget, Point<i32, Logical>)> { pub fn focus(&self) -> Option<&(PointerFocusTarget, Point<f64, Logical>)> {
match self { match self {
Self::Touch(touch) => touch.focus.as_ref(), Self::Touch(touch) => touch.focus.as_ref(),
Self::Pointer(pointer) => pointer.focus.as_ref(), Self::Pointer(pointer) => pointer.focus.as_ref(),
} }
} }
pub fn set_focus(&mut self, focus: Option<(PointerFocusTarget, Point<i32, Logical>)>) { pub fn set_focus(&mut self, focus: Option<(PointerFocusTarget, Point<f64, Logical>)>) {
match self { match self {
Self::Touch(touch) => touch.focus = focus, Self::Touch(touch) => touch.focus = focus,
Self::Pointer(pointer) => pointer.focus = focus, Self::Pointer(pointer) => pointer.focus = focus,
@ -167,7 +167,7 @@ impl PointerGrab<State> for ResizeGrab {
&mut self, &mut self,
data: &mut State, data: &mut State,
handle: &mut PointerInnerHandle<'_, State>, handle: &mut PointerInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &MotionEvent, event: &MotionEvent,
) { ) {
match self { match self {
@ -180,7 +180,7 @@ impl PointerGrab<State> for ResizeGrab {
&mut self, &mut self,
data: &mut State, data: &mut State,
handle: &mut PointerInnerHandle<'_, State>, handle: &mut PointerInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &RelativeMotionEvent, event: &RelativeMotionEvent,
) { ) {
match self { match self {
@ -336,7 +336,7 @@ impl TouchGrab<State> for ResizeGrab {
&mut self, &mut self,
data: &mut State, data: &mut State,
handle: &mut TouchInnerHandle<'_, State>, handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent, event: &DownEvent,
seq: Serial, seq: Serial,
) { ) {
@ -363,7 +363,7 @@ impl TouchGrab<State> for ResizeGrab {
&mut self, &mut self,
data: &mut State, data: &mut State,
handle: &mut TouchInnerHandle<'_, State>, handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent, event: &TouchMotionEvent,
seq: Serial, seq: Serial,
) { ) {

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

@ -445,7 +445,7 @@ impl PointerGrab<State> for MoveGrab {
&mut self, &mut self,
state: &mut State, state: &mut State,
handle: &mut PointerInnerHandle<'_, State>, handle: &mut PointerInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &MotionEvent, event: &MotionEvent,
) { ) {
self.update_location(state, event.location); self.update_location(state, event.location);
@ -461,7 +461,7 @@ impl PointerGrab<State> for MoveGrab {
&mut self, &mut self,
state: &mut State, state: &mut State,
handle: &mut PointerInnerHandle<'_, State>, handle: &mut PointerInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &RelativeMotionEvent, event: &RelativeMotionEvent,
) { ) {
// While the grab is active, no client has pointer focus // While the grab is active, no client has pointer focus
@ -589,7 +589,7 @@ impl TouchGrab<State> for MoveGrab {
&mut self, &mut self,
data: &mut State, data: &mut State,
handle: &mut TouchInnerHandle<'_, State>, handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &touch::DownEvent, event: &touch::DownEvent,
seq: Serial, seq: Serial,
) { ) {
@ -614,7 +614,7 @@ impl TouchGrab<State> for MoveGrab {
&mut self, &mut self,
data: &mut State, data: &mut State,
handle: &mut TouchInnerHandle<'_, State>, handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &touch::MotionEvent, event: &touch::MotionEvent,
seq: Serial, seq: Serial,
) { ) {
@ -858,7 +858,7 @@ impl Drop for MoveGrab {
state, state,
Some(( Some((
target, target,
position.as_logical() - window.geometry().loc + offset, position.as_logical().to_f64() - window.geometry().loc.to_f64() + offset,
)), )),
&MotionEvent { &MotionEvent {
location: pointer.current_location(), location: pointer.current_location(),

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

@ -137,7 +137,7 @@ impl PointerGrab<State> for ResizeSurfaceGrab {
&mut self, &mut self,
data: &mut State, data: &mut State,
handle: &mut PointerInnerHandle<'_, State>, handle: &mut PointerInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &MotionEvent, event: &MotionEvent,
) { ) {
// While the grab is active, no client has pointer focus // While the grab is active, no client has pointer focus
@ -152,7 +152,7 @@ impl PointerGrab<State> for ResizeSurfaceGrab {
&mut self, &mut self,
state: &mut State, state: &mut State,
handle: &mut PointerInnerHandle<'_, State>, handle: &mut PointerInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &RelativeMotionEvent, event: &RelativeMotionEvent,
) { ) {
// While the grab is active, no client has pointer focus // While the grab is active, no client has pointer focus
@ -282,7 +282,7 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
&mut self, &mut self,
data: &mut State, data: &mut State,
handle: &mut TouchInnerHandle<'_, State>, handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent, event: &DownEvent,
seq: Serial, seq: Serial,
) { ) {
@ -307,7 +307,7 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
&mut self, &mut self,
data: &mut State, data: &mut State,
handle: &mut TouchInnerHandle<'_, State>, handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent, event: &TouchMotionEvent,
seq: Serial, seq: Serial,
) { ) {

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

@ -730,7 +730,7 @@ impl FloatingLayout {
pub fn surface_under( pub fn surface_under(
&mut self, &mut self,
location: Point<f64, Local>, location: Point<f64, Local>,
) -> Option<(PointerFocusTarget, Point<i32, Local>)> { ) -> Option<(PointerFocusTarget, Point<f64, Local>)> {
let res = self let res = self
.space .space
.element_under(location.as_logical()) .element_under(location.as_logical())
@ -753,7 +753,7 @@ impl FloatingLayout {
element element
.focus_under(point.as_logical()) .focus_under(point.as_logical())
.map(|(surface, surface_offset)| { .map(|(surface, surface_offset)| {
(surface, space_offset + surface_offset.as_local()) (surface, space_offset.to_f64() + surface_offset.as_local())
}) })
}) })
} }

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

@ -336,7 +336,7 @@ impl PointerGrab<State> for ResizeForkGrab {
&mut self, &mut self,
data: &mut State, data: &mut State,
handle: &mut PointerInnerHandle<'_, State>, handle: &mut PointerInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &MotionEvent, event: &MotionEvent,
) { ) {
// While the grab is active, no client has pointer focus // While the grab is active, no client has pointer focus
@ -351,7 +351,7 @@ impl PointerGrab<State> for ResizeForkGrab {
&mut self, &mut self,
state: &mut State, state: &mut State,
handle: &mut PointerInnerHandle<'_, State>, handle: &mut PointerInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &RelativeMotionEvent, event: &RelativeMotionEvent,
) { ) {
// While the grab is active, no client has pointer focus // While the grab is active, no client has pointer focus
@ -479,7 +479,7 @@ impl TouchGrab<State> for ResizeForkGrab {
&mut self, &mut self,
data: &mut State, data: &mut State,
handle: &mut TouchInnerHandle<'_, State>, handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent, event: &DownEvent,
seq: Serial, seq: Serial,
) { ) {
@ -504,7 +504,7 @@ impl TouchGrab<State> for ResizeForkGrab {
&mut self, &mut self,
data: &mut State, data: &mut State,
handle: &mut TouchInnerHandle<'_, State>, handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>, _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent, event: &TouchMotionEvent,
seq: Serial, seq: Serial,
) { ) {

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

@ -3101,7 +3101,7 @@ impl TilingLayout {
&mut self, &mut self,
location_f64: Point<f64, Local>, location_f64: Point<f64, Local>,
overview: OverviewMode, overview: OverviewMode,
) -> Option<(PointerFocusTarget, Point<i32, Local>)> { ) -> Option<(PointerFocusTarget, Point<f64, Local>)> {
let gaps = self.gaps(); let gaps = self.gaps();
let last_overview_hover = &mut self.last_overview_hover; let last_overview_hover = &mut self.last_overview_hover;
let placeholder_id = &self.placeholder_id; let placeholder_id = &self.placeholder_id;
@ -3132,7 +3132,8 @@ impl TilingLayout {
) { ) {
return Some(( return Some((
target, target,
geo.loc - mapped.geometry().loc.as_local() + surface_offset.as_local(), geo.loc.to_f64() - mapped.geometry().loc.as_local().to_f64()
+ surface_offset.as_local(),
)); ));
} }
} }
@ -3179,7 +3180,8 @@ impl TilingLayout {
.map(|(surface, surface_offset)| { .map(|(surface, surface_offset)| {
( (
surface, surface,
last_geometry.loc - mapped.geometry().loc.as_local() last_geometry.loc.to_f64()
- mapped.geometry().loc.as_local().to_f64()
+ surface_offset.as_local(), + surface_offset.as_local(),
) )
}) })
@ -3211,7 +3213,7 @@ impl TilingLayout {
orientation, orientation,
} }
.into(), .into(),
last_geometry.loc (last_geometry.loc
+ tree + tree
.children(&id) .children(&id)
.unwrap() .unwrap()
@ -3221,7 +3223,8 @@ impl TilingLayout {
let geo = node.data().geometry(); let geo = node.data().geometry();
geo.loc + geo.size geo.loc + geo.size
}) })
.unwrap(), .unwrap())
.to_f64(),
)) ))
} }
_ => None, _ => None,

8
src/shell/mod.rs
View file

@ -2001,7 +2001,7 @@ impl Shell {
&mut self, &mut self,
location: Point<f64, Global>, location: Point<f64, Global>,
output: &Output, output: &Output,
) -> Option<(PointerFocusTarget, Point<i32, Global>)> { ) -> Option<(PointerFocusTarget, Point<f64, Global>)> {
let overview = self.overview_mode.clone(); let overview = self.overview_mode.clone();
self.workspaces.sets.get_mut(output).and_then(|set| { self.workspaces.sets.get_mut(output).and_then(|set| {
set.sticky_layer set.sticky_layer
@ -2659,7 +2659,7 @@ impl Shell {
edge: ResizeEdge, edge: ResizeEdge,
) -> Option<( ) -> Option<(
( (
Option<(PointerFocusTarget, Point<i32, Logical>)>, Option<(PointerFocusTarget, Point<f64, Logical>)>,
Point<i32, Global>, Point<i32, Global>,
), ),
(ResizeGrab, Focus), (ResizeGrab, Focus),
@ -2715,7 +2715,7 @@ impl Shell {
let element_offset = (new_loc - geometry.loc).as_logical(); let element_offset = (new_loc - geometry.loc).as_logical();
let focus = mapped let focus = mapped
.focus_under(element_offset.to_f64()) .focus_under(element_offset.to_f64())
.map(|(target, surface_offset)| (target, (surface_offset + element_offset))); .map(|(target, surface_offset)| (target, (surface_offset + element_offset.to_f64())));
start_data.set_location(new_loc.as_logical().to_f64()); start_data.set_location(new_loc.as_logical().to_f64());
start_data.set_focus(focus.clone()); start_data.set_focus(focus.clone());
@ -3185,7 +3185,7 @@ pub fn check_grab_preconditions(
} else { } else {
GrabStartData::Pointer(pointer.grab_start_data().unwrap_or_else(|| { GrabStartData::Pointer(pointer.grab_start_data().unwrap_or_else(|| {
PointerGrabStartData { PointerGrabStartData {
focus: pointer.current_focus().map(|f| (f, Point::from((0, 0)))), focus: pointer.current_focus().map(|f| (f, Point::from((0., 0.)))),
button: 0x110, button: 0x110,
location: pointer.current_location(), location: pointer.current_location(),
} }

49
src/shell/workspace.rs
View file

@ -475,7 +475,7 @@ impl Workspace {
&mut self, &mut self,
location: Point<f64, Global>, location: Point<f64, Global>,
overview: OverviewMode, overview: OverviewMode,
) -> Option<(PointerFocusTarget, Point<i32, Global>)> { ) -> Option<(PointerFocusTarget, Point<f64, Global>)> {
let location = location.to_local(&self.output); let location = location.to_local(&self.output);
self.floating_layer self.floating_layer
.surface_under(location) .surface_under(location)
@ -1360,14 +1360,23 @@ impl RenderElement<GlowRenderer> for WorkspaceRenderElement<GlowRenderer> {
src: Rectangle<f64, BufferCoords>, src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>, dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, smithay::utils::Physical>], damage: &[Rectangle<i32, smithay::utils::Physical>],
opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), GlesError> { ) -> Result<(), GlesError> {
match self { match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.draw(frame, src, dst, damage), WorkspaceRenderElement::OverrideRedirect(elem) => {
WorkspaceRenderElement::Fullscreen(elem) => elem.draw(frame, src, dst, damage), elem.draw(frame, src, dst, damage, opaque_regions)
WorkspaceRenderElement::FullscreenPopup(elem) => elem.draw(frame, src, dst, damage), }
WorkspaceRenderElement::Window(elem) => elem.draw(frame, src, dst, damage), WorkspaceRenderElement::Fullscreen(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
WorkspaceRenderElement::FullscreenPopup(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
WorkspaceRenderElement::Window(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
WorkspaceRenderElement::Backdrop(elem) => { WorkspaceRenderElement::Backdrop(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage) RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
} }
} }
} }
@ -1393,16 +1402,30 @@ impl<'a> RenderElement<GlMultiRenderer<'a>> for WorkspaceRenderElement<GlMultiRe
src: Rectangle<f64, BufferCoords>, src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>, dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, smithay::utils::Physical>], damage: &[Rectangle<i32, smithay::utils::Physical>],
opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), GlMultiError> { ) -> Result<(), GlMultiError> {
match self { match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.draw(frame, src, dst, damage), WorkspaceRenderElement::OverrideRedirect(elem) => {
WorkspaceRenderElement::Fullscreen(elem) => elem.draw(frame, src, dst, damage), elem.draw(frame, src, dst, damage, opaque_regions)
WorkspaceRenderElement::FullscreenPopup(elem) => elem.draw(frame, src, dst, damage),
WorkspaceRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
WorkspaceRenderElement::Backdrop(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame.glow_frame_mut(), src, dst, damage)
.map_err(GlMultiError::Render)
} }
WorkspaceRenderElement::Fullscreen(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
WorkspaceRenderElement::FullscreenPopup(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
WorkspaceRenderElement::Window(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
WorkspaceRenderElement::Backdrop(elem) => RenderElement::<GlowRenderer>::draw(
elem,
frame.glow_frame_mut(),
src,
dst,
damage,
opaque_regions,
)
.map_err(GlMultiError::Render),
} }
} }

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

@ -22,7 +22,7 @@ use smithay::{
}, },
}, },
}, },
xwayland::{X11Wm, XWaylandClientData}, xwayland::XWaylandClientData,
}; };
use std::sync::Mutex; use std::sync::Mutex;
@ -134,7 +134,6 @@ impl CompositorHandler for State {
} }
fn commit(&mut self, surface: &WlSurface) { fn commit(&mut self, surface: &WlSurface) {
X11Wm::commit_hook::<State>(self, surface);
// first load the buffer for various smithay helper functions (which also initializes the RendererSurfaceState) // first load the buffer for various smithay helper functions (which also initializes the RendererSurfaceState)
on_commit_buffer_handler::<Self>(surface); on_commit_buffer_handler::<Self>(surface);