Feature/drag to reorder applets

cosmic-panel-bin/src/main.rs

@@ -40,6 +40,11 @@ pub enum PanelCalloopMsg {
     RestartSpace(CosmicPanelConfig, WlOutput),
     MinimizeRect { output: String, applet_info: MinimizeApplet },
     UpdateToplevel(ext_foreign_toplevel_handle_v1::ExtForeignToplevelHandleV1),
+    ReorderPlugins {
+        panel_name: String,
+        plugins_wings: Option<(Vec<String>, Vec<String>)>,
+        plugins_center: Option<Vec<String>>,
+    },
 }
 
 /// Access glibc malloc tunables.
@@ -186,6 +191,16 @@ fn main() -> Result<()> {
                     PanelCalloopMsg::MinimizeRect { output, applet_info } => {
                         minimize::set_rectangles(state, output, applet_info)
                     },
+                    PanelCalloopMsg::ReorderPlugins { panel_name, plugins_wings, plugins_center } => {
+                        for entry in &mut state.space.config.config_list {
+                            if entry.name == panel_name {
+                                entry.plugins_wings = plugins_wings;
+                                entry.plugins_center = plugins_center;
+                                break;
+                            }
+                        }
+                        let _ = state.space.config.write_entries();
+                    },
                 },
                 calloop::channel::Event::Closed => {},
             };

cosmic-panel-bin/src/space/layout.rs

@@ -16,7 +16,7 @@ use crate::space::Alignment;
 use crate::xdg_shell_wrapper::space::Visibility;
 
 use super::PanelSpace;
-use super::panel_space::{ClientShrinkSize, PanelClient};
+use super::panel_space::{ClientShrinkSize, DragSection, PanelClient};
 use crate::xdg_shell_wrapper::space::WrapperSpace;
 use anyhow::bail;
 use cosmic::widget::Id;
@@ -26,7 +26,7 @@ use sctk::shell::WaylandSurface;
 use smithay::desktop::space::SpaceElement;
 use smithay::desktop::{Space, Window};
 use smithay::reexports::wayland_server::Resource;
-use smithay::utils::{IsAlive, Physical, Rectangle, Size};
+use smithay::utils::{IsAlive, Logical, Physical, Point, Rectangle, Size};
 use smithay::wayland::compositor::with_states;
 use smithay::wayland::fractional_scale::with_fractional_scale;
 use smithay::wayland::seat::WaylandFocus;
@@ -194,6 +194,60 @@ impl PanelSpace {
         let mut windows_center = map_clients(&self.clients_center);
         let mut windows_right = map_clients(&self.clients_right);
 
+        if let Some(drag) = self.drag_state.as_ref().filter(|d| d.is_active) {
+            let drag_name = drag.applet_name.clone();
+            let preview_section = drag.preview_section;
+            let preview_index = drag.preview_index;
+
+            let drag_client_id = self
+                .clients_left
+                .lock()
+                .unwrap()
+                .iter()
+                .chain(self.clients_center.lock().unwrap().iter())
+                .chain(self.clients_right.lock().unwrap().iter())
+                .find(|c| c.name == drag_name)
+                .and_then(|c| c.client.as_ref())
+                .map(|c| c.id());
+
+            if let Some(drag_client_id) = drag_client_id {
+                let dragged = if let Some(pos) = windows_left.iter().position(|(_, w, ..)| {
+                    w.toplevel()
+                        .and_then(|t| t.wl_surface().client())
+                        .is_some_and(|c| c.id() == drag_client_id)
+                }) {
+                    Some(windows_left.remove(pos))
+                } else if let Some(pos) = windows_center.iter().position(|(_, w, ..)| {
+                    w.toplevel()
+                        .and_then(|t| t.wl_surface().client())
+                        .is_some_and(|c| c.id() == drag_client_id)
+                }) {
+                    Some(windows_center.remove(pos))
+                } else if let Some(pos) = windows_right.iter().position(|(_, w, ..)| {
+                    w.toplevel()
+                        .and_then(|t| t.wl_surface().client())
+                        .is_some_and(|c| c.id() == drag_client_id)
+                }) {
+                    Some(windows_right.remove(pos))
+                } else {
+                    None
+                };
+
+                if let Some(dragged_window) = dragged {
+                    let target_list = match preview_section {
+                        DragSection::Left => &mut windows_left,
+                        DragSection::Center => &mut windows_center,
+                        DragSection::Right => &mut windows_right,
+                    };
+                    let insert_idx = preview_index.min(target_list.len());
+                    target_list.insert(insert_idx, dragged_window);
+                    for (j, (i, ..)) in target_list.iter_mut().enumerate() {
+                        *i = j;
+                    }
+                }
+            }
+        }
+
         let is_dock = !self.config.expand_to_edges()
             || self.animate_state.as_ref().is_some_and(|a| !(a.cur.expanded > 0.5));
 
@@ -213,6 +267,64 @@ impl PanelSpace {
             right_overflow_button,
             center_overflow_button,
         );
+
+        let anim_info = self.drag_state.as_ref().and_then(|drag| {
+            if drag.is_active && drag.anim_t < 1.0 && !drag.prev_positions.is_empty() {
+                Some((drag.anim_t, drag.prev_positions.clone()))
+            } else {
+                None
+            }
+        });
+        if let Some((raw_t, prev_positions)) = anim_info {
+            // ease-out-cubic
+            let t = 1.0_f32 - (1.0_f32 - raw_t).powi(3);
+            let is_h = self.config.is_horizontal();
+            let client_to_name: Vec<(_, String)> = {
+                let l = self.clients_left.lock().unwrap();
+                let c = self.clients_center.lock().unwrap();
+                let r = self.clients_right.lock().unwrap();
+                l.iter()
+                    .chain(c.iter())
+                    .chain(r.iter())
+                    .filter_map(|pc| pc.client.as_ref().map(|wc| (wc.id(), pc.name.clone())))
+                    .collect()
+            };
+            let updates: Vec<(CosmicMappedInternal, Point<i32, Logical>)> = self
+                .space
+                .elements()
+                .filter_map(|elem| {
+                    if let CosmicMappedInternal::Window(w) = elem {
+                        let client_id = w
+                            .toplevel()
+                            .and_then(|t| t.wl_surface().client())
+                            .map(|c| c.id())?;
+                        let (_, name) =
+                            client_to_name.iter().find(|(id, _)| *id == client_id)?;
+                        let &prev_major = prev_positions.get(name)?;
+                        let geo = self.space.element_geometry(elem)?;
+                        let cur_major = if is_h { geo.loc.x } else { geo.loc.y };
+                        let lerped = (prev_major as f32 * (1.0 - t)
+                            + cur_major as f32 * t)
+                            .round() as i32;
+                        if lerped == cur_major {
+                            return None;
+                        }
+                        let new_loc = if is_h {
+                            Point::from((lerped, geo.loc.y))
+                        } else {
+                            Point::from((geo.loc.x, lerped))
+                        };
+                        Some((elem.clone(), new_loc))
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+            for (elem, loc) in updates {
+                self.space.map_element(elem, loc, false);
+            }
+        }
+
         if let Err(e) = res.as_ref() {
             info!("Requires relayout: {:?}", e);
         }