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

tiling: Fix misaligned positioning

Browse source
This commit is contained in:
Victoria Brekenfeld 2023-05-22 16:55:29 +02:00
parent 9be6c85459
commit 0d1894e08f
2 changed files with 96 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1837,37 +1837,47 @@ where
) )
.into_iter() .into_iter()
.flat_map(|element| match element { .flat_map(|element| match element {
CosmicMappedRenderElement::Stack(elem) => Some( CosmicMappedRenderElement::Stack(elem) => {
CosmicMappedRenderElement::TiledStack(RelocateRenderElement::from_element( Some(CosmicMappedRenderElement::TiledStack({
RescaleRenderElement::from_element( let cropped = CropRenderElement::from_element(
CropRenderElement::from_element( elem,
elem, output_scale,
output_scale, crop_rect.to_physical_precise_round(output_scale),
crop_rect.to_physical_precise_round(output_scale), )?;
)?, let rescaled = RescaleRenderElement::from_element(
cropped,
original_location, original_location,
scale, scale,
), );
geo.loc.to_physical_precise_round(output_scale), let relocated = RelocateRenderElement::from_element(
Relocate::Absolute, rescaled,
)), (geo.loc - original_geo.loc)
), .to_physical_precise_round(output_scale),
Relocate::Relative,
);
relocated
}))
}
CosmicMappedRenderElement::Window(elem) => { CosmicMappedRenderElement::Window(elem) => {
Some(CosmicMappedRenderElement::TiledWindow( Some(CosmicMappedRenderElement::TiledWindow({
RelocateRenderElement::from_element( let cropped = CropRenderElement::from_element(
RescaleRenderElement::from_element( elem,
CropRenderElement::from_element( output_scale,
elem, crop_rect.to_physical_precise_round(output_scale),
output_scale, )?;
crop_rect.to_physical_precise_round(output_scale), let rescaled = RescaleRenderElement::from_element(
)?, cropped,
(0, 0).into(), original_location,
scale, scale,
), );
geo.loc.to_physical_precise_round(output_scale), let relocated = RelocateRenderElement::from_element(
Relocate::Absolute, rescaled,
), (geo.loc - original_geo.loc)
)) .to_physical_precise_round(output_scale),
Relocate::Relative,
);
relocated
}))
} }
x => Some(x), x => Some(x),
}) })
@ -2001,57 +2011,64 @@ where
(new_geo, percentage) (new_geo, percentage)
}; };
let original_location = original_geo.loc.to_physical_precise_round(output_scale) let original_location = (original_geo.loc - mapped.geometry().loc)
- mapped .to_physical_precise_round(output_scale);
.geometry()
.loc let mut elements =
.to_physical_precise_round(output_scale); AsRenderElements::<R>::render_elements::<CosmicMappedRenderElement<R>>(
let mut elements = AsRenderElements::<R>::render_elements::< mapped,
CosmicMappedRenderElement<R>, renderer,
>( original_location,
mapped, Scale::from(output_scale),
renderer, alpha,
original_location, )
Scale::from(output_scale), .into_iter()
alpha, .flat_map(|element| match element {
) CosmicMappedRenderElement::Stack(elem) => {
.into_iter() Some(CosmicMappedRenderElement::TiledStack({
.flat_map(|element| match element { let cropped = CropRenderElement::from_element(
CosmicMappedRenderElement::Stack(elem) => Some(
CosmicMappedRenderElement::TiledStack(RelocateRenderElement::from_element(
RescaleRenderElement::from_element(
CropRenderElement::from_element(
elem, elem,
output_scale, output_scale,
crop_rect.to_physical_precise_round(output_scale), crop_rect.to_physical_precise_round(output_scale),
)?, )?;
original_location, let rescaled = RescaleRenderElement::from_element(
scale, cropped,
), original_location,
geo.loc.to_physical_precise_round(output_scale),
Relocate::Absolute,
)),
),
CosmicMappedRenderElement::Window(elem) => {
Some(CosmicMappedRenderElement::TiledWindow(
RelocateRenderElement::from_element(
RescaleRenderElement::from_element(
CropRenderElement::from_element(
elem,
output_scale,
crop_rect.to_physical_precise_round(output_scale),
)?,
(0, 0).into(),
scale, scale,
), );
geo.loc.to_physical_precise_round(output_scale), let relocated = RelocateRenderElement::from_element(
Relocate::Absolute, rescaled,
), (geo.loc - original_geo.loc)
)) .to_physical_precise_round(output_scale),
} Relocate::Relative,
x => Some(x), );
}) relocated
.collect::<Vec<_>>(); }))
}
CosmicMappedRenderElement::Window(elem) => {
Some(CosmicMappedRenderElement::TiledWindow({
let cropped = CropRenderElement::from_element(
elem,
output_scale,
crop_rect.to_physical_precise_round(output_scale),
)?;
let rescaled = RescaleRenderElement::from_element(
cropped,
original_location,
scale,
);
let relocated = RelocateRenderElement::from_element(
rescaled,
(geo.loc - original_geo.loc)
.to_physical_precise_round(output_scale),
Relocate::Relative,
);
relocated
}))
}
x => Some(x),
})
.collect::<Vec<_>>();
if focused == Some(mapped) { if focused == Some(mapped) {
if indicator_thickness > 0 { if indicator_thickness > 0 {

18
src/shell/workspace.rs
View file

@ -42,10 +42,7 @@ use smithay::{
input::{pointer::GrabStartData as PointerGrabStartData, Seat}, input::{pointer::GrabStartData as PointerGrabStartData, Seat},
output::Output, output::Output,
reexports::wayland_server::protocol::wl_surface::WlSurface, reexports::wayland_server::protocol::wl_surface::WlSurface,
utils::{ utils::{Buffer as BufferCoords, IsAlive, Logical, Physical, Point, Rectangle, Scale, Size},
Buffer as BufferCoords, IsAlive, Logical, Physical, Point, Rectangle, Scale, Size,
Transform,
},
wayland::{seat::WaylandFocus, shell::wlr_layer::Layer}, wayland::{seat::WaylandFocus, shell::wlr_layer::Layer},
xwayland::X11Surface, xwayland::X11Surface,
}; };
@ -686,7 +683,7 @@ impl Workspace {
Id::new(), Id::new(),
renderer renderer
.glow_renderer_mut() .glow_renderer_mut()
.import_memory(&[0, 0, 0, 255], Fourcc::Argb8888, (1, 1).into(), false) .import_memory(&[0, 0, 0, 255], Fourcc::Abgr8888, (1, 1).into(), false)
.unwrap(), .unwrap(),
); );
renderer renderer
@ -711,17 +708,10 @@ impl Workspace {
tex, tex,
1, 1,
smithay::utils::Transform::Normal, smithay::utils::Transform::Normal,
Some(alpha as f32), Some(alpha.min(0.8) as f32),
Some(Rectangle::from_loc_and_size((0., 0.), (1., 1.))), Some(Rectangle::from_loc_and_size((0., 0.), (1., 1.))),
Some(output.geometry().size), Some(output.geometry().size),
if alpha >= 1.0 { None,
Some(vec![Rectangle::from_loc_and_size(
(0, 0),
output.geometry().size.to_buffer(1, Transform::Normal),
)])
} else {
None
},
) )
.into(), .into(),
) )