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

floating: Maximize animation

Browse source
This commit is contained in:
Victoria Brekenfeld 2024-01-05 20:38:13 +00:00 • committed by Victoria Brekenfeld
parent b46b92611c
commit 61a3aa8d79
3 changed files with 154 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -29,14 +29,14 @@ use crate::{
resize_indicator::ResizeIndicator, resize_indicator::ResizeIndicator,
stack::{CosmicStackRenderElement, MoveResult as StackMoveResult, TAB_HEIGHT}, stack::{CosmicStackRenderElement, MoveResult as StackMoveResult, TAB_HEIGHT},
window::CosmicWindowRenderElement, window::CosmicWindowRenderElement,
CosmicMapped, CosmicMappedRenderElement, CosmicWindow, CosmicMapped, CosmicMappedRenderElement, CosmicWindow, MaximizedState,
}, },
focus::{ focus::{
target::{KeyboardFocusTarget, PointerFocusTarget}, target::{KeyboardFocusTarget, PointerFocusTarget},
FocusStackMut, FocusStackMut,
}, },
grabs::{ReleaseMode, ResizeEdge}, grabs::{ReleaseMode, ResizeEdge},
CosmicSurface, Direction, MoveResult, ResizeDirection, ResizeMode, CosmicSurface, Direction, ManagedLayer, MoveResult, ResizeDirection, ResizeMode,
}, },
state::State, state::State,
utils::{prelude::*, tween::EaseRectangle}, utils::{prelude::*, tween::EaseRectangle},
@ -163,7 +163,12 @@ impl FloatingLayout {
let tiled_state = mapped.floating_tiled.lock().unwrap().clone(); let tiled_state = mapped.floating_tiled.lock().unwrap().clone();
if let Some(tiled_state) = tiled_state { if let Some(tiled_state) = tiled_state {
let geometry = tiled_state.relative_geometry(output_geometry); let geometry = tiled_state.relative_geometry(output_geometry);
self.map_internal(mapped, Some(geometry.loc), Some(geometry.size.as_logical())); self.map_internal(
mapped,
Some(geometry.loc),
Some(geometry.size.as_logical()),
None,
);
} else { } else {
let geometry = self.space.element_geometry(&mapped).unwrap(); let geometry = self.space.element_geometry(&mapped).unwrap();
let new_loc = ( let new_loc = (
@ -176,7 +181,7 @@ impl FloatingLayout {
* output_geometry.size.h * output_geometry.size.h
+ output_geometry.loc.y, + output_geometry.loc.y,
); );
self.map_internal(mapped, Some(Point::from(new_loc)), None); self.map_internal(mapped, Some(Point::from(new_loc)), None, None);
} }
} }
@ -191,10 +196,14 @@ impl FloatingLayout {
let mapped = mapped.into(); let mapped = mapped.into();
let position = position.into(); let position = position.into();
self.map_internal(mapped, position, None) self.map_internal(mapped, position, None, None)
} }
pub fn map_maximized(&mut self, mapped: CosmicMapped) { pub fn map_maximized(
&mut self,
mapped: CosmicMapped,
previous_geometry: Rectangle<i32, Local>,
) {
let output = self.space.outputs().next().unwrap().clone(); let output = self.space.outputs().next().unwrap().clone();
let layers = layer_map_for_output(&output); let layers = layer_map_for_output(&output);
let geometry = layers.non_exclusive_zone().as_local(); let geometry = layers.non_exclusive_zone().as_local();
@ -211,6 +220,15 @@ impl FloatingLayout {
mapped.moved_since_mapped.store(true, Ordering::SeqCst); mapped.moved_since_mapped.store(true, Ordering::SeqCst);
self.tiling_animations
.insert(mapped.clone(), (Instant::now(), previous_geometry));
if mapped.floating_tiled.lock().unwrap().take().is_some() {
if let Some(mut state) = mapped.maximized_state.lock().unwrap().as_mut() {
if let Some(real_old_geo) = mapped.last_geometry.lock().unwrap().clone() {
state.original_geometry = real_old_geo;
}
};
}
self.space self.space
.map_element(mapped, geometry.loc.as_logical(), true); .map_element(mapped, geometry.loc.as_logical(), true);
} }
@ -220,7 +238,9 @@ impl FloatingLayout {
mapped: CosmicMapped, mapped: CosmicMapped,
position: Option<Point<i32, Local>>, position: Option<Point<i32, Local>>,
size: Option<Size<i32, Logical>>, size: Option<Size<i32, Logical>>,
prev: Option<Rectangle<i32, Local>>,
) { ) {
let already_mapped = self.space.element_geometry(&mapped).map(RectExt::as_local);
let mut win_geo = mapped.geometry().as_local(); let mut win_geo = mapped.geometry().as_local();
let output = self.space.outputs().next().unwrap().clone(); let output = self.space.outputs().next().unwrap().clone();
@ -412,6 +432,11 @@ impl FloatingLayout {
mapped mapped
.set_geometry(Rectangle::from_loc_and_size(position, win_geo.size).to_global(&output)); .set_geometry(Rectangle::from_loc_and_size(position, win_geo.size).to_global(&output));
mapped.configure(); mapped.configure();
if let Some(previous_geo) = prev.or(already_mapped) {
self.tiling_animations
.insert(mapped.clone(), (Instant::now(), previous_geo));
}
self.space.map_element(mapped, position.as_logical(), false); self.space.map_element(mapped, position.as_logical(), false);
} }
@ -442,6 +467,8 @@ impl FloatingLayout {
} }
} }
let _ = self.tiling_animations.remove(window);
let was_unmaped = self.space.elements().any(|e| e == window); let was_unmaped = self.space.elements().any(|e| e == window);
self.space.unmap_elem(&window); self.space.unmap_elem(&window);
if was_unmaped { if was_unmaped {
@ -465,7 +492,7 @@ impl FloatingLayout {
} }
(mapped, geo.loc) (mapped, geo.loc)
} else { } else {
self.map_internal(window.clone(), Some(position), None); self.map_internal(window.clone(), Some(position), None, None);
(window, position) (window, position)
} }
} }
@ -627,7 +654,12 @@ impl FloatingLayout {
// if it is just a window // if it is just a window
self.space.unmap_elem(&mapped); self.space.unmap_elem(&mapped);
mapped.convert_to_stack((&output, mapped.bbox()), self.theme.clone()); mapped.convert_to_stack((&output, mapped.bbox()), self.theme.clone());
self.map_internal(mapped.clone(), Some(location.as_local()), Some(geo.size)); self.map_internal(
mapped.clone(),
Some(location.as_local()),
Some(geo.size),
None,
);
Some(KeyboardFocusTarget::Element(mapped)) Some(KeyboardFocusTarget::Element(mapped))
} else { } else {
// if we have a stack // if we have a stack
@ -680,6 +712,7 @@ impl FloatingLayout {
&mut self, &mut self,
direction: Direction, direction: Direction,
seat: &Seat<State>, seat: &Seat<State>,
layer: ManagedLayer,
theme: cosmic::Theme, theme: cosmic::Theme,
) -> MoveResult { ) -> MoveResult {
let Some(target) = seat.get_keyboard().unwrap().current_focus() else { let Some(target) = seat.get_keyboard().unwrap().current_focus() else {
@ -725,7 +758,7 @@ impl FloatingLayout {
}) })
.then_some(pos); .then_some(pos);
self.map_internal(mapped.clone(), position.map(PointExt::as_local), None); self.map_internal(mapped.clone(), position.map(PointExt::as_local), None, None);
MoveResult::ShiftFocus(KeyboardFocusTarget::Element(mapped)) MoveResult::ShiftFocus(KeyboardFocusTarget::Element(mapped))
} }
StackMoveResult::Default => { StackMoveResult::Default => {
@ -803,12 +836,16 @@ impl FloatingLayout {
| (Direction::Down, Some(TiledCorners::Top)) | (Direction::Down, Some(TiledCorners::Top))
| (Direction::Left, Some(TiledCorners::Right)) | (Direction::Left, Some(TiledCorners::Right))
| (Direction::Right, Some(TiledCorners::Left)) => { | (Direction::Right, Some(TiledCorners::Left)) => {
self.tiling_animations
.insert(focused.clone(), (Instant::now(), start_rectangle));
*tiled_state = None;
std::mem::drop(tiled_state); std::mem::drop(tiled_state);
self.map_maximized(focused.clone()); let mut maximized_state = focused.maximized_state.lock().unwrap();
*maximized_state = Some(MaximizedState {
original_geometry: start_rectangle,
original_layer: layer,
});
std::mem::drop(maximized_state);
self.map_maximized(focused.clone(), start_rectangle);
return MoveResult::Done; return MoveResult::Done;
} }
@ -842,19 +879,29 @@ impl FloatingLayout {
focused.set_tiled(true); // TODO: More fine grained? focused.set_tiled(true); // TODO: More fine grained?
focused.set_maximized(false); focused.set_maximized(false);
if tiled_state.is_none() && focused.is_maximized(false) { if tiled_state.is_none() {
*focused.last_geometry.lock().unwrap() = let last_geometry = focused
self.space.element_geometry(focused).map(RectExt::as_local); .maximized_state
.lock()
.unwrap()
.take()
.map(|state| state.original_geometry)
.or_else(|| self.space.element_geometry(focused).map(RectExt::as_local));
*focused.last_geometry.lock().unwrap() = last_geometry;
} }
self.tiling_animations
.insert(focused.clone(), (Instant::now(), start_rectangle));
*tiled_state = Some(new_state); *tiled_state = Some(new_state);
std::mem::drop(tiled_state); std::mem::drop(tiled_state);
focused.moved_since_mapped.store(true, Ordering::SeqCst); focused.moved_since_mapped.store(true, Ordering::SeqCst);
let focused = focused.clone(); let focused = focused.clone();
self.map_internal(focused, Some(new_pos), Some(new_size.as_logical())); self.map_internal(
focused,
Some(new_pos),
Some(new_size.as_logical()),
Some(start_rectangle),
);
MoveResult::Done MoveResult::Done
} }
@ -889,7 +936,7 @@ impl FloatingLayout {
{ {
// TODO what about windows leaving to the top with no headerbar to drag? can that happen? (Probably if the user is moving outputs down) // TODO what about windows leaving to the top with no headerbar to drag? can that happen? (Probably if the user is moving outputs down)
*element.last_geometry.lock().unwrap() = None; *element.last_geometry.lock().unwrap() = None;
self.map_internal(element, None, None); self.map_internal(element, None, None, None);
} }
} }
@ -913,7 +960,7 @@ impl FloatingLayout {
.unwrap() .unwrap()
.loc .loc
.as_local(); .as_local();
self.map_internal(element.clone(), Some(elem_loc), None); self.map_internal(element.clone(), Some(elem_loc), None, None);
} }
self.refresh(); //fixup any out of bounds elements self.refresh(); //fixup any out of bounds elements
} }
@ -968,7 +1015,7 @@ impl FloatingLayout {
); );
if let Some((start, original_geo)) = self.tiling_animations.get(elem) { if let Some((start, original_geo)) = self.tiling_animations.get(elem) {
if let Some(target_rect) = elem let target_rect = elem
.floating_tiled .floating_tiled
.lock() .lock()
.unwrap() .unwrap()
@ -978,72 +1025,72 @@ impl FloatingLayout {
elem.is_maximized(true) elem.is_maximized(true)
.then_some(output_geometry.as_local()) .then_some(output_geometry.as_local())
}) })
{ .unwrap_or_else(|| self.space.element_geometry(elem).unwrap().as_local());
geometry = ease(
EaseInOutCubic,
EaseRectangle(original_geo.clone()),
EaseRectangle(target_rect),
Instant::now()
.duration_since(*start)
.min(ANIMATION_DURATION)
.as_millis() as f32
/ ANIMATION_DURATION.as_millis() as f32,
)
.unwrap();
let buffer_size = elem.geometry().size; geometry = ease(
let scale = Scale { EaseInOutCubic,
x: geometry.size.w as f64 / buffer_size.w as f64, EaseRectangle(original_geo.clone()),
y: geometry.size.h as f64 / buffer_size.h as f64, EaseRectangle(target_rect),
}; Instant::now()
.duration_since(*start)
.min(ANIMATION_DURATION)
.as_millis() as f32
/ ANIMATION_DURATION.as_millis() as f32,
)
.unwrap();
w_elements = w_elements let buffer_size = elem.geometry().size;
.into_iter() let scale = Scale {
.map(|element| match element { x: geometry.size.w as f64 / buffer_size.w as f64,
CosmicMappedRenderElement::Stack(elem) => { y: geometry.size.h as f64 / buffer_size.h as f64,
CosmicMappedRenderElement::MovingStack({ };
let rescaled = RescaleRenderElement::from_element(
elem, w_elements = w_elements
original_geo .into_iter()
.loc .map(|element| match element {
.as_logical() CosmicMappedRenderElement::Stack(elem) => {
.to_physical_precise_round(output_scale), CosmicMappedRenderElement::MovingStack({
scale, let rescaled = RescaleRenderElement::from_element(
); elem,
let relocated = RelocateRenderElement::from_element( original_geo
rescaled, .loc
(geometry.loc - original_geo.loc) .as_logical()
.as_logical() .to_physical_precise_round(output_scale),
.to_physical_precise_round(output_scale), scale,
Relocate::Relative, );
); let relocated = RelocateRenderElement::from_element(
relocated rescaled,
}) (geometry.loc - original_geo.loc)
} .as_logical()
CosmicMappedRenderElement::Window(elem) => { .to_physical_precise_round(output_scale),
CosmicMappedRenderElement::MovingWindow({ Relocate::Relative,
let rescaled = RescaleRenderElement::from_element( );
elem, relocated
original_geo })
.loc }
.as_logical() CosmicMappedRenderElement::Window(elem) => {
.to_physical_precise_round(output_scale), CosmicMappedRenderElement::MovingWindow({
scale, let rescaled = RescaleRenderElement::from_element(
); elem,
let relocated = RelocateRenderElement::from_element( original_geo
rescaled, .loc
(geometry.loc - original_geo.loc) .as_logical()
.as_logical() .to_physical_precise_round(output_scale),
.to_physical_precise_round(output_scale), scale,
Relocate::Relative, );
); let relocated = RelocateRenderElement::from_element(
relocated rescaled,
}) (geometry.loc - original_geo.loc)
} .as_logical()
x => x, .to_physical_precise_round(output_scale),
}) Relocate::Relative,
.collect(); );
} relocated
})
}
x => x,
})
.collect();
} }
if focused == Some(elem) && !elem.is_maximized(false) { if focused == Some(elem) && !elem.is_maximized(false) {

24
src/shell/mod.rs
View file

@ -2324,6 +2324,7 @@ impl Shell {
mapped.clone(), mapped.clone(),
Some(state.original_geometry.loc), Some(state.original_geometry.loc),
Some(new_size), Some(new_size),
None,
); );
let ratio = pos.to_local(&output).x / output.geometry().size.w as f64; let ratio = pos.to_local(&output).x / output.geometry().size.w as f64;
@ -2531,6 +2532,16 @@ impl Shell {
}; };
let fullscreen = workspace.fullscreen.as_ref().map(|f| f.surface.clone()); let fullscreen = workspace.fullscreen.as_ref().map(|f| f.surface.clone());
if last
.maximized_state
.lock()
.unwrap()
.as_ref()
.is_some_and(|state| state.original_layer == ManagedLayer::Tiling)
{
self.unmaximize_request(&last);
}
if let Some(surface) = fullscreen { if let Some(surface) = fullscreen {
MoveResult::MoveFurther(KeyboardFocusTarget::Fullscreen(surface)) MoveResult::MoveFurther(KeyboardFocusTarget::Fullscreen(surface))
} else if let Some(set) = self } else if let Some(set) = self
@ -2539,14 +2550,18 @@ impl Shell {
.values_mut() .values_mut()
.find(|set| set.sticky_layer.mapped().any(|m| m == &last)) .find(|set| set.sticky_layer.mapped().any(|m| m == &last))
{ {
set.sticky_layer set.sticky_layer.move_current_element(
.move_current_element(direction, seat, self.theme.clone()) direction,
seat,
ManagedLayer::Sticky,
self.theme.clone(),
)
} else { } else {
let theme = self.theme.clone(); let theme = self.theme.clone();
let workspace = self.active_space_mut(&output); let workspace = self.active_space_mut(&output);
workspace workspace
.floating_layer .floating_layer
.move_current_element(direction, seat, theme) .move_current_element(direction, seat, ManagedLayer::Floating, theme)
.or_else(|| workspace.tiling_layer.move_current_node(direction, seat)) .or_else(|| workspace.tiling_layer.move_current_node(direction, seat))
} }
} }
@ -2662,7 +2677,7 @@ impl Shell {
original_layer, original_layer,
}); });
std::mem::drop(state); std::mem::drop(state);
floating_layer.map_maximized(mapped.clone()); floating_layer.map_maximized(mapped.clone(), original_geometry);
} }
} }
@ -2681,6 +2696,7 @@ impl Shell {
mapped.clone(), mapped.clone(),
Some(state.original_geometry.loc), Some(state.original_geometry.loc),
Some(state.original_geometry.size.as_logical()), Some(state.original_geometry.size.as_logical()),
None,
); );
Some(state.original_geometry.size.as_logical()) Some(state.original_geometry.size.as_logical())
} else { } else {

1
src/shell/workspace.rs
View file

@ -462,6 +462,7 @@ impl Workspace {
elem.clone(), elem.clone(),
Some(state.original_geometry.loc), Some(state.original_geometry.loc),
Some(state.original_geometry.size.as_logical()), Some(state.original_geometry.size.as_logical()),
None,
); );
Some(state.original_geometry.size.as_logical()) Some(state.original_geometry.size.as_logical())
} }