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]]
name = "smithay"
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 = [
"appendlist",
"ash",

2
Cargo.toml
View file

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

24
src/input/mod.rs
View file

@ -528,7 +528,7 @@ impl State {
Some(constraint) if constraint.is_active() => {
// Constraint does not apply if not within region
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;
}
@ -621,7 +621,7 @@ impl State {
}
if let Some(region) = confine_region {
if !region
.contains(position.as_logical().to_i32_round() - *surface_loc)
.contains((position.as_logical() - *surface_loc).to_i32_round())
{
ptr.frame(self);
return;
@ -653,7 +653,7 @@ impl State {
PointerConstraint::Confined(confined) => confined.region(),
};
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)) {
constraint.activate();
}
@ -2501,7 +2501,7 @@ impl State {
global_pos: Point<f64, Global>,
output: &Output,
shell: &mut Shell,
) -> Option<(PointerFocusTarget, Point<i32, Global>)> {
) -> Option<(PointerFocusTarget, Point<f64, Global>)> {
let session_lock = shell.session_lock.as_ref();
let relative_pos = global_pos.to_local(output);
let output_geo = output.geometry();
@ -2513,7 +2513,7 @@ impl State {
surface: surface.wl_surface().clone(),
toplevel: None,
},
output_geo.loc,
output_geo.loc.to_f64(),
)
});
}
@ -2531,7 +2531,7 @@ impl State {
surface: wl_surface,
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| {
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((
@ -2557,7 +2557,7 @@ impl State {
));
}
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 {
{
let layers = layer_map_for_output(output);
@ -2575,7 +2575,8 @@ impl State {
surface: wl_surface,
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| {
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((
@ -2620,7 +2621,8 @@ impl State {
surface: wl_surface,
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(
&self,
relative_pos: Point<f64, Logical>,
) -> Option<(PointerFocusTarget, Point<i32, Logical>)> {
) -> Option<(PointerFocusTarget, Point<f64, Logical>)> {
match &self.element {
CosmicMappedInternal::Stack(stack) => stack.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>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
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, src, dst, damage)
CosmicMappedRenderElement::Stack(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::Window(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
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) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::Overlay(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::StackHoverIndicator(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
}
#[cfg(feature = "debug")]
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>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), GlMultiError> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
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::Stack(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) => {
RenderElement::<GlowRenderer>::draw(elem, frame.glow_frame_mut(), src, dst, damage)
.map_err(|err| GlMultiError::Render(err))
CosmicMappedRenderElement::Window(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
CosmicMappedRenderElement::Overlay(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame.glow_frame_mut(), src, dst, damage)
.map_err(|err| GlMultiError::Render(err))
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.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) => {
elem.draw(frame, src, dst, damage)
elem.draw(frame, src, dst, damage, opaque_regions)
}
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => {
let glow_frame = frame.glow_frame_mut();
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage)
.map_err(|err| GlMultiError::Render(err))
RenderElement::<GlowRenderer>::draw(
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(
&self,
mut relative_pos: Point<f64, Logical>,
) -> Option<(PointerFocusTarget, Point<i32, Logical>)> {
) -> Option<(PointerFocusTarget, Point<f64, Logical>)> {
self.0.with_program(|p| {
let mut stack_ui = None;
let geo = p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)].geometry();
@ -435,14 +435,14 @@ impl CosmicStack {
{
stack_ui = Some((
PointerFocusTarget::StackUI(self.clone()),
Point::from((0, 0)),
Point::from((0., 0.)),
));
}
if point_i32.y - geo.loc.y < TAB_HEIGHT {
stack_ui = Some((
PointerFocusTarget::StackUI(self.clone()),
Point::from((0, 0)),
Point::from((0., 0.)),
));
}
@ -458,7 +458,7 @@ impl CosmicStack {
surface,
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)

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

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

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

@ -473,7 +473,7 @@ impl PointerGrab<State> for MenuGrab {
&mut self,
state: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &MotionEvent,
) {
{
@ -520,7 +520,7 @@ impl PointerGrab<State> for MenuGrab {
&mut self,
state: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &RelativeMotionEvent,
) {
// 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 {
pub fn focus(&self) -> Option<&(PointerFocusTarget, Point<i32, Logical>)> {
pub fn focus(&self) -> Option<&(PointerFocusTarget, Point<f64, Logical>)> {
match self {
Self::Touch(touch) => touch.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 {
Self::Touch(touch) => touch.focus = focus,
Self::Pointer(pointer) => pointer.focus = focus,
@ -167,7 +167,7 @@ impl PointerGrab<State> for ResizeGrab {
&mut self,
data: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &MotionEvent,
) {
match self {
@ -180,7 +180,7 @@ impl PointerGrab<State> for ResizeGrab {
&mut self,
data: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &RelativeMotionEvent,
) {
match self {
@ -336,7 +336,7 @@ impl TouchGrab<State> for ResizeGrab {
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
@ -363,7 +363,7 @@ impl TouchGrab<State> for ResizeGrab {
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {

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

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

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

@ -730,7 +730,7 @@ impl FloatingLayout {
pub fn surface_under(
&mut self,
location: Point<f64, Local>,
) -> Option<(PointerFocusTarget, Point<i32, Local>)> {
) -> Option<(PointerFocusTarget, Point<f64, Local>)> {
let res = self
.space
.element_under(location.as_logical())
@ -753,7 +753,7 @@ impl FloatingLayout {
element
.focus_under(point.as_logical())
.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,
data: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &MotionEvent,
) {
// While the grab is active, no client has pointer focus
@ -351,7 +351,7 @@ impl PointerGrab<State> for ResizeForkGrab {
&mut self,
state: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &RelativeMotionEvent,
) {
// While the grab is active, no client has pointer focus
@ -479,7 +479,7 @@ impl TouchGrab<State> for ResizeForkGrab {
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
@ -504,7 +504,7 @@ impl TouchGrab<State> for ResizeForkGrab {
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {

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

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

8
src/shell/mod.rs
View file

@ -2001,7 +2001,7 @@ impl Shell {
&mut self,
location: Point<f64, Global>,
output: &Output,
) -> Option<(PointerFocusTarget, Point<i32, Global>)> {
) -> Option<(PointerFocusTarget, Point<f64, Global>)> {
let overview = self.overview_mode.clone();
self.workspaces.sets.get_mut(output).and_then(|set| {
set.sticky_layer
@ -2659,7 +2659,7 @@ impl Shell {
edge: ResizeEdge,
) -> Option<(
(
Option<(PointerFocusTarget, Point<i32, Logical>)>,
Option<(PointerFocusTarget, Point<f64, Logical>)>,
Point<i32, Global>,
),
(ResizeGrab, Focus),
@ -2715,7 +2715,7 @@ impl Shell {
let element_offset = (new_loc - geometry.loc).as_logical();
let focus = mapped
.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_focus(focus.clone());
@ -3185,7 +3185,7 @@ pub fn check_grab_preconditions(
} else {
GrabStartData::Pointer(pointer.grab_start_data().unwrap_or_else(|| {
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,
location: pointer.current_location(),
}

49
src/shell/workspace.rs
View file

@ -475,7 +475,7 @@ impl Workspace {
&mut self,
location: Point<f64, Global>,
overview: OverviewMode,
) -> Option<(PointerFocusTarget, Point<i32, Global>)> {
) -> Option<(PointerFocusTarget, Point<f64, Global>)> {
let location = location.to_local(&self.output);
self.floating_layer
.surface_under(location)
@ -1360,14 +1360,23 @@ impl RenderElement<GlowRenderer> for WorkspaceRenderElement<GlowRenderer> {
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, smithay::utils::Physical>],
opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), GlesError> {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.draw(frame, src, dst, damage),
WorkspaceRenderElement::Fullscreen(elem) => elem.draw(frame, src, dst, damage),
WorkspaceRenderElement::FullscreenPopup(elem) => elem.draw(frame, src, dst, damage),
WorkspaceRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
WorkspaceRenderElement::OverrideRedirect(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
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, 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>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, smithay::utils::Physical>],
opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), GlMultiError> {
match self {
WorkspaceRenderElement::OverrideRedirect(elem) => elem.draw(frame, src, dst, damage),
WorkspaceRenderElement::Fullscreen(elem) => elem.draw(frame, src, dst, damage),
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::OverrideRedirect(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions)
}
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;
@ -134,7 +134,6 @@ impl CompositorHandler for State {
}
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)
on_commit_buffer_handler::<Self>(surface);