950 lines
35 KiB
Rust
950 lines
35 KiB
Rust
|
use std::{
|
||
|
|
cell::RefCell,
|
||
|
|
sync::{
|
||
|
|
atomic::{AtomicBool, Ordering},
|
||
|
|
Arc, Mutex,
|
||
|
|
},
|
||
|
|
};
|
||
|
|
|
||
|
|
use anyhow::Context;
|
||
|
|
use calloop::LoopHandle;
|
||
|
|
use cosmic::{
|
||
|
|
iced::Background,
|
||
|
|
iced_core::{alignment::Horizontal, Length, Rectangle as IcedRectangle},
|
||
|
|
iced_widget::{self, horizontal_rule, text::Appearance as TextAppearance, Column, Row},
|
||
|
|
theme,
|
||
|
|
widget::{button, horizontal_space, icon::from_name, text},
|
||
|
|
Apply as _, Command,
|
||
|
|
};
|
||
|
|
use smithay::{
|
||
|
|
backend::{
|
||
|
|
allocator::Fourcc,
|
||
|
|
input::ButtonState,
|
||
|
|
renderer::{
|
||
|
|
damage::OutputDamageTracker,
|
||
|
|
element::{
|
||
|
|
memory::MemoryRenderBufferRenderElement, surface::WaylandSurfaceRenderElement,
|
||
|
|
AsRenderElements,
|
||
|
|
},
|
||
|
|
gles::GlesRenderbuffer,
|
||
|
|
ExportMem, ImportAll, ImportMem, Offscreen, Renderer,
|
||
|
|
},
|
||
|
|
},
|
||
|
|
desktop::{space::SpaceElement, utils::bbox_from_surface_tree},
|
||
|
|
input::{
|
||
|
|
pointer::{
|
||
|
|
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
|
||
|
|
GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
|
||
|
|
GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent,
|
||
|
|
GrabStartData as PointerGrabStartData, MotionEvent, PointerGrab, PointerInnerHandle,
|
||
|
|
PointerTarget, RelativeMotionEvent,
|
||
|
|
},
|
||
|
|
Seat,
|
||
|
|
},
|
||
|
|
output::Output,
|
||
|
|
utils::{Logical, Point, Scale, Size, Transform},
|
||
|
|
wayland::seat::WaylandFocus,
|
||
|
|
};
|
||
|
|
use tracing::warn;
|
||
|
|
|
||
|
|
use crate::{
|
||
|
|
backend::kms::source_node_for_surface,
|
||
|
|
config::{Action, StaticConfig},
|
||
|
|
fl,
|
||
|
|
shell::{
|
||
|
|
element::{CosmicMapped, CosmicSurface},
|
||
|
|
focus::target::PointerFocusTarget,
|
||
|
|
grabs::ReleaseMode,
|
||
|
|
Shell,
|
||
|
|
},
|
||
|
|
state::{BackendData, Common, State},
|
||
|
|
utils::{
|
||
|
|
iced::{IcedElement, Program},
|
||
|
|
prelude::{Global, PointGlobalExt, PointLocalExt, SeatExt},
|
||
|
|
},
|
||
|
|
};
|
||
|
|
|
||
|
|
use super::ResizeEdge;
|
||
|
|
|
||
|
|
mod item;
|
||
|
|
|
||
|
|
pub struct MenuGrabState {
|
||
|
|
elements: Arc<Mutex<Vec<Element>>>,
|
||
|
|
}
|
||
|
|
pub type SeatMenuGrabState = RefCell<Option<MenuGrabState>>;
|
||
|
|
|
||
|
|
impl MenuGrabState {
|
||
|
|
pub fn render<I, R>(&self, renderer: &mut R, output: &Output) -> Vec<I>
|
||
|
|
where
|
||
|
|
R: Renderer + ImportMem,
|
||
|
|
<R as Renderer>::TextureId: 'static,
|
||
|
|
I: From<MemoryRenderBufferRenderElement<R>>,
|
||
|
|
{
|
||
|
|
let scale = output.current_scale().fractional_scale();
|
||
|
|
self.elements
|
||
|
|
.lock()
|
||
|
|
.unwrap()
|
||
|
|
.iter()
|
||
|
|
.flat_map(|elem| {
|
||
|
|
elem.iced.render_elements(
|
||
|
|
renderer,
|
||
|
|
elem.position
|
||
|
|
.to_local(output)
|
||
|
|
.as_logical()
|
||
|
|
.to_physical_precise_round(scale),
|
||
|
|
scale.into(),
|
||
|
|
1.0,
|
||
|
|
)
|
||
|
|
})
|
||
|
|
.collect()
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn set_theme(&self, theme: cosmic::Theme) {
|
||
|
|
for element in &*self.elements.lock().unwrap() {
|
||
|
|
element.iced.set_theme(theme.clone())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#[derive(Clone)]
|
||
|
|
pub enum Item {
|
||
|
|
Separator,
|
||
|
|
Submenu {
|
||
|
|
title: String,
|
||
|
|
items: Vec<Item>,
|
||
|
|
},
|
||
|
|
Entry {
|
||
|
|
title: String,
|
||
|
|
shortcut: Option<String>,
|
||
|
|
on_press: Arc<Box<dyn Fn(&LoopHandle<'_, State>) + Send + Sync>>,
|
||
|
|
toggled: bool,
|
||
|
|
submenu: bool,
|
||
|
|
disabled: bool,
|
||
|
|
},
|
||
|
|
}
|
||
|
|
|
||
|
|
impl Item {
|
||
|
|
pub fn new<S: Into<String>, F: Fn(&LoopHandle<'_, State>) + Send + Sync + 'static>(
|
||
|
|
title: S,
|
||
|
|
on_press: F,
|
||
|
|
) -> Item {
|
||
|
|
Item::Entry {
|
||
|
|
title: title.into(),
|
||
|
|
shortcut: None,
|
||
|
|
on_press: Arc::new(Box::new(on_press)),
|
||
|
|
toggled: false,
|
||
|
|
submenu: false,
|
||
|
|
disabled: false,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn new_submenu<S: Into<String>>(title: S, items: Vec<Item>) -> Item {
|
||
|
|
Item::Submenu {
|
||
|
|
title: title.into(),
|
||
|
|
items,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn shortcut(mut self, shortcut: impl Into<Option<String>>) -> Self {
|
||
|
|
if let Item::Entry {
|
||
|
|
shortcut: ref mut s,
|
||
|
|
..
|
||
|
|
} = self
|
||
|
|
{
|
||
|
|
*s = shortcut.into();
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn toggled(mut self, toggled: bool) -> Self {
|
||
|
|
if let Item::Entry {
|
||
|
|
toggled: ref mut t, ..
|
||
|
|
} = self
|
||
|
|
{
|
||
|
|
*t = toggled;
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn disabled(mut self, disabled: bool) -> Self {
|
||
|
|
if let Item::Entry {
|
||
|
|
disabled: ref mut d,
|
||
|
|
..
|
||
|
|
} = self
|
||
|
|
{
|
||
|
|
*d = disabled;
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub struct ContextMenu {
|
||
|
|
items: Vec<Item>,
|
||
|
|
selected: AtomicBool,
|
||
|
|
row_width: Mutex<Option<f32>>,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl ContextMenu {
|
||
|
|
pub fn new(items: Vec<Item>) -> ContextMenu {
|
||
|
|
ContextMenu {
|
||
|
|
items,
|
||
|
|
selected: AtomicBool::new(false),
|
||
|
|
row_width: Mutex::new(None),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#[derive(Debug, Clone)]
|
||
|
|
pub enum Message {
|
||
|
|
ItemEntered(usize, IcedRectangle<f32>),
|
||
|
|
ItemPressed(usize),
|
||
|
|
ItemLeft(usize, IcedRectangle<f32>),
|
||
|
|
}
|
||
|
|
|
||
|
|
impl item::CursorEvents for Message {
|
||
|
|
fn cursor_entered(idx: usize, bounds: IcedRectangle<f32>) -> Self {
|
||
|
|
Message::ItemEntered(idx, bounds)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn cursor_left(idx: usize, bounds: IcedRectangle<f32>) -> Self {
|
||
|
|
Message::ItemLeft(idx, bounds)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl Program for ContextMenu {
|
||
|
|
type Message = Message;
|
||
|
|
|
||
|
|
fn update(
|
||
|
|
&mut self,
|
||
|
|
message: Self::Message,
|
||
|
|
loop_handle: &LoopHandle<'static, crate::state::State>,
|
||
|
|
) -> Command<Self::Message> {
|
||
|
|
match message {
|
||
|
|
Message::ItemPressed(idx) => {
|
||
|
|
if let Some(Item::Entry { on_press, .. }) = self.items.get_mut(idx) {
|
||
|
|
(on_press)(loop_handle);
|
||
|
|
self.selected.store(true, Ordering::SeqCst);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Message::ItemEntered(idx, bounds) => {
|
||
|
|
if let Some(Item::Submenu { items, .. }) = self.items.get_mut(idx) {
|
||
|
|
let items = items.clone();
|
||
|
|
let _ = loop_handle.insert_idle(move |state| {
|
||
|
|
let seat = state.common.last_active_seat();
|
||
|
|
let grab_state = seat
|
||
|
|
.user_data()
|
||
|
|
.get::<SeatMenuGrabState>()
|
||
|
|
.unwrap()
|
||
|
|
.borrow_mut();
|
||
|
|
|
||
|
|
if let Some(grab_state) = &*grab_state {
|
||
|
|
let mut elements = grab_state.elements.lock().unwrap();
|
||
|
|
let mut position = elements.last().unwrap().position;
|
||
|
|
position.x += bounds.width.ceil() as i32;
|
||
|
|
position.y += bounds.y.ceil() as i32;
|
||
|
|
|
||
|
|
let element = IcedElement::new(
|
||
|
|
ContextMenu::new(items),
|
||
|
|
Size::default(),
|
||
|
|
state.common.event_loop_handle.clone(),
|
||
|
|
state.common.theme.clone(),
|
||
|
|
);
|
||
|
|
let min_size = element.minimum_size();
|
||
|
|
element.with_program(|p| {
|
||
|
|
*p.row_width.lock().unwrap() = Some(min_size.w as f32);
|
||
|
|
});
|
||
|
|
element.resize(min_size);
|
||
|
|
element.output_enter(&seat.active_output(), element.bbox());
|
||
|
|
|
||
|
|
elements.push(Element {
|
||
|
|
iced: element,
|
||
|
|
position,
|
||
|
|
pointer_entered: false,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Message::ItemLeft(idx, _) => {
|
||
|
|
if let Some(Item::Submenu { .. }) = self.items.get_mut(idx) {
|
||
|
|
let _ = loop_handle.insert_idle(|state| {
|
||
|
|
let seat = state.common.last_active_seat();
|
||
|
|
let grab_state = seat
|
||
|
|
.user_data()
|
||
|
|
.get::<SeatMenuGrabState>()
|
||
|
|
.unwrap()
|
||
|
|
.borrow_mut();
|
||
|
|
|
||
|
|
if let Some(grab_state) = &*grab_state {
|
||
|
|
let mut elements = grab_state.elements.lock().unwrap();
|
||
|
|
elements.pop();
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
Command::none()
|
||
|
|
}
|
||
|
|
|
||
|
|
fn view(&self) -> crate::utils::iced::Element<'_, Self::Message> {
|
||
|
|
let width = self
|
||
|
|
.row_width
|
||
|
|
.lock()
|
||
|
|
.unwrap()
|
||
|
|
.map(|size| Length::Fixed(size))
|
||
|
|
.unwrap_or(Length::Shrink);
|
||
|
|
let mode = match width {
|
||
|
|
Length::Shrink => Length::Shrink,
|
||
|
|
_ => Length::Fill,
|
||
|
|
};
|
||
|
|
|
||
|
|
Column::with_children(
|
||
|
|
self.items
|
||
|
|
.iter()
|
||
|
|
.enumerate()
|
||
|
|
.map(|(idx, item)| match item {
|
||
|
|
Item::Separator => horizontal_rule(1)
|
||
|
|
.style(theme::Rule::LightDivider)
|
||
|
|
.width(Length::Shrink)
|
||
|
|
.into(),
|
||
|
|
Item::Submenu { title, .. } => Row::with_children(vec![
|
||
|
|
horizontal_space(16).into(),
|
||
|
|
text(title).width(mode).into(),
|
||
|
|
from_name("go-next-symbolic")
|
||
|
|
.size(16)
|
||
|
|
.prefer_svg(true)
|
||
|
|
.icon()
|
||
|
|
.into(),
|
||
|
|
])
|
||
|
|
.spacing(8)
|
||
|
|
.width(width)
|
||
|
|
.padding([8, 24])
|
||
|
|
.apply(|row| item::SubmenuItem::new(row, idx))
|
||
|
|
.style(theme::Button::MenuItem)
|
||
|
|
.into(),
|
||
|
|
Item::Entry {
|
||
|
|
title,
|
||
|
|
shortcut,
|
||
|
|
toggled,
|
||
|
|
disabled,
|
||
|
|
..
|
||
|
|
} => {
|
||
|
|
let mut components = vec![
|
||
|
|
if *toggled {
|
||
|
|
from_name("object-select-symbolic")
|
||
|
|
.size(16)
|
||
|
|
.prefer_svg(true)
|
||
|
|
.icon()
|
||
|
|
.style(theme::Svg::custom(|theme| {
|
||
|
|
iced_widget::svg::Appearance {
|
||
|
|
color: Some(theme.cosmic().accent.base.into()),
|
||
|
|
}
|
||
|
|
}))
|
||
|
|
.into()
|
||
|
|
} else {
|
||
|
|
horizontal_space(16).into()
|
||
|
|
},
|
||
|
|
text(title).width(mode).into(),
|
||
|
|
];
|
||
|
|
if let Some(shortcut) = shortcut.as_ref() {
|
||
|
|
components.push(
|
||
|
|
text(shortcut)
|
||
|
|
.line_height(20.)
|
||
|
|
.size(14)
|
||
|
|
.horizontal_alignment(Horizontal::Right)
|
||
|
|
.width(Length::Shrink)
|
||
|
|
.style(theme::Text::Custom(|theme| {
|
||
|
|
let mut color = theme.cosmic().background.component.on;
|
||
|
|
color.alpha *= 0.75;
|
||
|
|
TextAppearance {
|
||
|
|
color: Some(color.into()),
|
||
|
|
}
|
||
|
|
}))
|
||
|
|
.into(),
|
||
|
|
);
|
||
|
|
}
|
||
|
|
components.push(horizontal_space(16).into());
|
||
|
|
|
||
|
|
Row::with_children(components)
|
||
|
|
.spacing(8)
|
||
|
|
.width(mode)
|
||
|
|
.apply(button)
|
||
|
|
.width(width)
|
||
|
|
.padding([8, 24])
|
||
|
|
.on_press_maybe((!disabled).then_some(Message::ItemPressed(idx)))
|
||
|
|
.style(theme::Button::MenuItem)
|
||
|
|
.into()
|
||
|
|
}
|
||
|
|
})
|
||
|
|
.collect(),
|
||
|
|
)
|
||
|
|
.width(Length::Shrink)
|
||
|
|
.apply(iced_widget::container)
|
||
|
|
.padding(1)
|
||
|
|
.style(theme::Container::custom(|theme| {
|
||
|
|
let cosmic = theme.cosmic();
|
||
|
|
let component = &cosmic.background.component;
|
||
|
|
iced_widget::container::Appearance {
|
||
|
|
icon_color: Some(cosmic.accent.base.into()),
|
||
|
|
text_color: Some(component.on.into()),
|
||
|
|
background: Some(Background::Color(component.base.into())),
|
||
|
|
border_radius: 8.0.into(),
|
||
|
|
border_width: 1.0,
|
||
|
|
border_color: component.divider.into(),
|
||
|
|
}
|
||
|
|
}))
|
||
|
|
.width(Length::Shrink)
|
||
|
|
.into()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub struct Element {
|
||
|
|
iced: IcedElement<ContextMenu>,
|
||
|
|
position: Point<i32, Global>,
|
||
|
|
pointer_entered: bool,
|
||
|
|
}
|
||
|
|
|
||
|
|
pub struct MenuGrab {
|
||
|
|
elements: Arc<Mutex<Vec<Element>>>,
|
||
|
|
start_data: PointerGrabStartData<State>,
|
||
|
|
seat: Seat<State>,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl PointerGrab<State> for MenuGrab {
|
||
|
|
fn motion(
|
||
|
|
&mut self,
|
||
|
|
state: &mut State,
|
||
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
||
|
|
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
|
||
|
|
event: &MotionEvent,
|
||
|
|
) {
|
||
|
|
{
|
||
|
|
let mut guard = self.elements.lock().unwrap();
|
||
|
|
let elements = &mut *guard;
|
||
|
|
if let Some(i) = elements.iter().position(|elem| {
|
||
|
|
let mut bbox = elem.iced.bbox();
|
||
|
|
bbox.loc = elem.position.as_logical();
|
||
|
|
|
||
|
|
bbox.contains(event.location.to_i32_round())
|
||
|
|
}) {
|
||
|
|
let element = &mut elements[i];
|
||
|
|
|
||
|
|
let new_event = MotionEvent {
|
||
|
|
location: event.location - element.position.as_logical().to_f64(),
|
||
|
|
serial: event.serial,
|
||
|
|
time: event.time,
|
||
|
|
};
|
||
|
|
if !element.pointer_entered {
|
||
|
|
PointerTarget::enter(&element.iced, &self.seat, state, &new_event);
|
||
|
|
element.pointer_entered = true;
|
||
|
|
} else {
|
||
|
|
element.iced.motion(&self.seat, state, &new_event);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
elements.iter_mut().for_each(|element| {
|
||
|
|
if element.pointer_entered {
|
||
|
|
PointerTarget::leave(
|
||
|
|
&element.iced,
|
||
|
|
&self.seat,
|
||
|
|
state,
|
||
|
|
event.serial,
|
||
|
|
event.time,
|
||
|
|
);
|
||
|
|
element.pointer_entered = false;
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
handle.motion(state, None, event);
|
||
|
|
}
|
||
|
|
|
||
|
|
fn relative_motion(
|
||
|
|
&mut self,
|
||
|
|
state: &mut State,
|
||
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
||
|
|
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
|
||
|
|
event: &RelativeMotionEvent,
|
||
|
|
) {
|
||
|
|
// While the grab is active, no client has pointer focus
|
||
|
|
handle.relative_motion(state, None, event);
|
||
|
|
}
|
||
|
|
|
||
|
|
fn button(
|
||
|
|
&mut self,
|
||
|
|
state: &mut State,
|
||
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
||
|
|
event: &ButtonEvent,
|
||
|
|
) {
|
||
|
|
let any_entered = self
|
||
|
|
.elements
|
||
|
|
.lock()
|
||
|
|
.unwrap()
|
||
|
|
.iter()
|
||
|
|
.any(|elem| elem.pointer_entered);
|
||
|
|
if !any_entered {
|
||
|
|
if event.state == ButtonState::Pressed {
|
||
|
|
handle.unset_grab(state, event.serial, event.time, true);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
let selected = {
|
||
|
|
let elements = self.elements.lock().unwrap();
|
||
|
|
let mut selected = false;
|
||
|
|
for element in elements.iter().filter(|elem| elem.pointer_entered) {
|
||
|
|
element.iced.button(&self.seat, state, event);
|
||
|
|
selected = true;
|
||
|
|
}
|
||
|
|
selected
|
||
|
|
};
|
||
|
|
if selected && event.state == ButtonState::Released {
|
||
|
|
handle.unset_grab(state, event.serial, event.time, true);
|
||
|
|
} else {
|
||
|
|
handle.button(state, event);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn axis(
|
||
|
|
&mut self,
|
||
|
|
state: &mut State,
|
||
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
||
|
|
details: AxisFrame,
|
||
|
|
) {
|
||
|
|
handle.axis(state, details);
|
||
|
|
}
|
||
|
|
|
||
|
|
fn frame(&mut self, data: &mut State, handle: &mut PointerInnerHandle<'_, State>) {
|
||
|
|
handle.frame(data)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn gesture_swipe_begin(
|
||
|
|
&mut self,
|
||
|
|
data: &mut State,
|
||
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
||
|
|
event: &GestureSwipeBeginEvent,
|
||
|
|
) {
|
||
|
|
handle.gesture_swipe_begin(data, event)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn gesture_swipe_update(
|
||
|
|
&mut self,
|
||
|
|
data: &mut State,
|
||
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
||
|
|
event: &GestureSwipeUpdateEvent,
|
||
|
|
) {
|
||
|
|
handle.gesture_swipe_update(data, event)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn gesture_swipe_end(
|
||
|
|
&mut self,
|
||
|
|
data: &mut State,
|
||
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
||
|
|
event: &GestureSwipeEndEvent,
|
||
|
|
) {
|
||
|
|
handle.gesture_swipe_end(data, event)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn gesture_pinch_begin(
|
||
|
|
&mut self,
|
||
|
|
data: &mut State,
|
||
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
||
|
|
event: &GesturePinchBeginEvent,
|
||
|
|
) {
|
||
|
|
handle.gesture_pinch_begin(data, event)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn gesture_pinch_update(
|
||
|
|
&mut self,
|
||
|
|
data: &mut State,
|
||
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
||
|
|
event: &GesturePinchUpdateEvent,
|
||
|
|
) {
|
||
|
|
handle.gesture_pinch_update(data, event)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn gesture_pinch_end(
|
||
|
|
&mut self,
|
||
|
|
data: &mut State,
|
||
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
||
|
|
event: &GesturePinchEndEvent,
|
||
|
|
) {
|
||
|
|
handle.gesture_pinch_end(data, event)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn gesture_hold_begin(
|
||
|
|
&mut self,
|
||
|
|
data: &mut State,
|
||
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
||
|
|
event: &GestureHoldBeginEvent,
|
||
|
|
) {
|
||
|
|
handle.gesture_hold_begin(data, event)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn gesture_hold_end(
|
||
|
|
&mut self,
|
||
|
|
data: &mut State,
|
||
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
||
|
|
event: &GestureHoldEndEvent,
|
||
|
|
) {
|
||
|
|
handle.gesture_hold_end(data, event)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn start_data(&self) -> &PointerGrabStartData<State> {
|
||
|
|
&self.start_data
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl MenuGrab {
|
||
|
|
pub fn new(
|
||
|
|
start_data: PointerGrabStartData<State>,
|
||
|
|
seat: &Seat<State>,
|
||
|
|
items: impl Iterator<Item = Item>,
|
||
|
|
position: Point<i32, Global>,
|
||
|
|
handle: LoopHandle<'static, crate::state::State>,
|
||
|
|
theme: cosmic::Theme,
|
||
|
|
) -> MenuGrab {
|
||
|
|
let items = items.collect::<Vec<_>>();
|
||
|
|
let element = IcedElement::new(ContextMenu::new(items), Size::default(), handle, theme);
|
||
|
|
let min_size = element.minimum_size();
|
||
|
|
element.with_program(|p| {
|
||
|
|
*p.row_width.lock().unwrap() = Some(min_size.w as f32);
|
||
|
|
});
|
||
|
|
element.resize(min_size);
|
||
|
|
|
||
|
|
element.output_enter(&seat.active_output(), element.bbox());
|
||
|
|
|
||
|
|
let elements = Arc::new(Mutex::new(vec![Element {
|
||
|
|
iced: element,
|
||
|
|
position,
|
||
|
|
pointer_entered: false,
|
||
|
|
}]));
|
||
|
|
|
||
|
|
let grab_state = MenuGrabState {
|
||
|
|
elements: elements.clone(),
|
||
|
|
};
|
||
|
|
|
||
|
|
*seat
|
||
|
|
.user_data()
|
||
|
|
.get::<SeatMenuGrabState>()
|
||
|
|
.unwrap()
|
||
|
|
.borrow_mut() = Some(grab_state);
|
||
|
|
|
||
|
|
MenuGrab {
|
||
|
|
elements,
|
||
|
|
start_data,
|
||
|
|
seat: seat.clone(),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl Drop for MenuGrab {
|
||
|
|
fn drop(&mut self) {
|
||
|
|
self.seat
|
||
|
|
.user_data()
|
||
|
|
.get::<SeatMenuGrabState>()
|
||
|
|
.unwrap()
|
||
|
|
.borrow_mut()
|
||
|
|
.take();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn window_items(
|
||
|
|
window: &CosmicMapped,
|
||
|
|
is_tiled: bool,
|
||
|
|
is_stacked: bool,
|
||
|
|
tiling_enabled: bool,
|
||
|
|
possible_resizes: ResizeEdge,
|
||
|
|
config: &StaticConfig,
|
||
|
|
) -> impl Iterator<Item = Item> {
|
||
|
|
//let is_always_on_top = false; // TODO check window (potentially shell?)
|
||
|
|
//let is_always_on_visible_ws = false; // TODO check window (potentially shell?)
|
||
|
|
|
||
|
|
let maximize_clone = window.clone();
|
||
|
|
let tile_clone = window.clone();
|
||
|
|
let move_prev_clone = window.clone();
|
||
|
|
let move_next_clone = window.clone();
|
||
|
|
let move_clone = window.clone();
|
||
|
|
let resize_top_clone = window.clone();
|
||
|
|
let resize_left_clone = window.clone();
|
||
|
|
let resize_right_clone = window.clone();
|
||
|
|
let resize_bottom_clone = window.clone();
|
||
|
|
let unstack_clone = window.clone();
|
||
|
|
let screenshot_clone = window.clone();
|
||
|
|
let stack_clone = window.clone();
|
||
|
|
let close_clone = window.clone();
|
||
|
|
|
||
|
|
vec![
|
||
|
|
is_stacked.then_some(Item::new(fl!("window-menu-unstack"), move |handle| {
|
||
|
|
let unstack_clone = unstack_clone.clone();
|
||
|
|
let _ = handle.insert_idle(move |state| {
|
||
|
|
let seat = state.common.last_active_seat().clone();
|
||
|
|
let Some(ws) = state.common.shell.space_for_mut(&unstack_clone) else { return };
|
||
|
|
if let Some(new_focus) = ws.toggle_stacking(&unstack_clone) {
|
||
|
|
Common::set_focus(state, Some(&new_focus), &seat, None);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
})
|
||
|
|
.shortcut(config.get_shortcut_for_action(&Action::ToggleStacking))),
|
||
|
|
is_stacked.then_some(Item::Separator),
|
||
|
|
//Some(Item::new(fl!("window-menu-minimize"), |handle| {})),
|
||
|
|
Some(Item::new(fl!("window-menu-maximize"), move |handle| {
|
||
|
|
let maximize_clone = maximize_clone.clone();
|
||
|
|
let _ = handle.insert_idle(move |state| {
|
||
|
|
if let Some(space) = state.common.shell.space_for_mut(&maximize_clone) {
|
||
|
|
if maximize_clone.is_maximized(false) {
|
||
|
|
space.unmaximize_request(&maximize_clone.active_window());
|
||
|
|
} else {
|
||
|
|
space.maximize_request(&maximize_clone.active_window());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
})
|
||
|
|
.shortcut(config.get_shortcut_for_action(&Action::Maximize))
|
||
|
|
.toggled(window.is_maximized(false))),
|
||
|
|
tiling_enabled.then_some(Item::new(fl!("window-menu-tiled"), move |handle| {
|
||
|
|
let tile_clone = tile_clone.clone();
|
||
|
|
let _ = handle.insert_idle(move |state| {
|
||
|
|
let seat = state.common.last_active_seat().clone();
|
||
|
|
if let Some(ws) = state.common.shell.space_for_mut(&tile_clone) {
|
||
|
|
ws.toggle_floating_window(&seat, &tile_clone);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
})
|
||
|
|
.shortcut(config.get_shortcut_for_action(&Action::ToggleWindowFloating))
|
||
|
|
.toggled(!is_tiled)),
|
||
|
|
Some(Item::Separator),
|
||
|
|
// TODO: Where to save?
|
||
|
|
Some(Item::new(fl!("window-menu-screenshot"), move |handle| {
|
||
|
|
let screenshot_clone = screenshot_clone.clone();
|
||
|
|
let _ = handle.insert_idle(move |state| {
|
||
|
|
fn render_window<R>(
|
||
|
|
renderer: &mut R,
|
||
|
|
window: &CosmicSurface,
|
||
|
|
offset: &time::UtcOffset,
|
||
|
|
) -> anyhow::Result<()>
|
||
|
|
where
|
||
|
|
R: Renderer
|
||
|
|
+ ImportAll
|
||
|
|
+ Offscreen<GlesRenderbuffer>
|
||
|
|
+ ExportMem,
|
||
|
|
<R as Renderer>::TextureId: 'static,
|
||
|
|
<R as Renderer>::Error: Send + Sync + 'static,
|
||
|
|
{
|
||
|
|
let bbox = bbox_from_surface_tree(&window.wl_surface().unwrap(), (0, 0));
|
||
|
|
let elements = AsRenderElements::<R>::render_elements::<WaylandSurfaceRenderElement<R>>(
|
||
|
|
window,
|
||
|
|
renderer,
|
||
|
|
(-bbox.loc.x, -bbox.loc.y).into(),
|
||
|
|
Scale::from(1.0),
|
||
|
|
1.0,
|
||
|
|
);
|
||
|
|
|
||
|
|
// TODO: 10-bit
|
||
|
|
let format = Fourcc::Abgr8888;
|
||
|
|
let render_buffer =
|
||
|
|
Offscreen::<GlesRenderbuffer>::create_buffer(renderer, format, bbox.size.to_buffer(1, Transform::Normal))?;
|
||
|
|
renderer.bind(render_buffer)?;
|
||
|
|
let mut output_damage_tracker = OutputDamageTracker::new(bbox.size.to_physical(1), 1.0, Transform::Normal);
|
||
|
|
output_damage_tracker.render_output(renderer, 0, &elements, [0.0, 0.0, 0.0, 0.0]).map_err(|err| match err {
|
||
|
|
smithay::backend::renderer::damage::Error::Rendering(err) => err,
|
||
|
|
smithay::backend::renderer::damage::Error::OutputNoMode(_) => unreachable!(),
|
||
|
|
})?;
|
||
|
|
let mapping = renderer.copy_framebuffer(bbox.to_buffer(1, Transform::Normal, &bbox.size), format)?;
|
||
|
|
let gl_data = renderer.map_texture(&mapping)?;
|
||
|
|
|
||
|
|
if let Ok(Some(path)) = xdg_user::pictures() {
|
||
|
|
let local_timestamp = time::OffsetDateTime::now_utc().to_offset(*offset);
|
||
|
|
let mut title = window.title();
|
||
|
|
title.truncate(227); // 255 - time - png
|
||
|
|
let name = sanitize_filename::sanitize(format!("{}_{}.png",
|
||
|
|
title,
|
||
|
|
local_timestamp.format(time::macros::format_description!("[year]-[month]-[day]_[hour]:[minute]:[second]_[subsecond digits:4]")).unwrap(),
|
||
|
|
));
|
||
|
|
let file = std::fs::File::create(path.join(name))?;
|
||
|
|
|
||
|
|
let ref mut writer = std::io::BufWriter::new(file);
|
||
|
|
let mut encoder = png::Encoder::new(writer, bbox.size.w as u32, bbox.size.h as u32);
|
||
|
|
encoder.set_color(png::ColorType::Rgba);
|
||
|
|
encoder.set_depth(png::BitDepth::Eight);
|
||
|
|
encoder.set_source_gamma(png::ScaledFloat::new(1.0 / 2.2)); // 1.0 / 2.2, unscaled, but rounded
|
||
|
|
let source_chromaticities = png::SourceChromaticities::new( // Using unscaled instantiation here
|
||
|
|
(0.31270, 0.32900),
|
||
|
|
(0.64000, 0.33000),
|
||
|
|
(0.30000, 0.60000),
|
||
|
|
(0.15000, 0.06000)
|
||
|
|
);
|
||
|
|
encoder.set_source_chromaticities(source_chromaticities);
|
||
|
|
let mut writer = encoder.write_header()?;
|
||
|
|
writer.write_image_data(&gl_data)?;
|
||
|
|
}
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
if let Some(surface) = screenshot_clone.active_window().wl_surface() {
|
||
|
|
let res = match &mut state.backend {
|
||
|
|
BackendData::Kms(kms) => {
|
||
|
|
let node = source_node_for_surface(&surface, &state.common.display_handle)
|
||
|
|
.unwrap_or(kms.primary);
|
||
|
|
kms
|
||
|
|
.api
|
||
|
|
.single_renderer(&node)
|
||
|
|
.with_context(|| "Failed to get renderer for screenshot")
|
||
|
|
.and_then(|mut multirenderer| render_window(&mut multirenderer, &screenshot_clone.active_window(), &state.common.local_offset))
|
||
|
|
},
|
||
|
|
BackendData::Winit(winit) => {
|
||
|
|
render_window(winit.backend.renderer(), &screenshot_clone.active_window(), &state.common.local_offset)
|
||
|
|
},
|
||
|
|
BackendData::X11(x11) => {
|
||
|
|
render_window(&mut x11.renderer, &screenshot_clone.active_window(), &state.common.local_offset)
|
||
|
|
},
|
||
|
|
BackendData::Unset => unreachable!(),
|
||
|
|
};
|
||
|
|
if let Err(err) = res {
|
||
|
|
warn!(?err, "Failed to take screenshot")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
})),
|
||
|
|
Some(Item::Separator),
|
||
|
|
Some(Item::new(fl!("window-menu-move"), move |handle| {
|
||
|
|
let move_clone = move_clone.clone();
|
||
|
|
let _ = handle.insert_idle(move |state| {
|
||
|
|
if let Some(surface) = move_clone.wl_surface() {
|
||
|
|
let seat = state.common.last_active_seat().clone();
|
||
|
|
Shell::move_request(state, &surface, &seat, None, ReleaseMode::Click);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
})),
|
||
|
|
Some(Item::new_submenu(fl!("window-menu-resize"), vec![
|
||
|
|
Item::new(fl!("window-menu-resize-edge-top"), move |handle| {
|
||
|
|
let resize_clone = resize_top_clone.clone();
|
||
|
|
let _ = handle.insert_idle(move |state| {
|
||
|
|
let seat = state.common.last_active_seat().clone();
|
||
|
|
Shell::menu_resize_request(state, &resize_clone, &seat, ResizeEdge::TOP);
|
||
|
|
});
|
||
|
|
}).disabled(!possible_resizes.contains(ResizeEdge::TOP)),
|
||
|
|
Item::new(fl!("window-menu-resize-edge-left"), move |handle| {
|
||
|
|
let resize_clone = resize_left_clone.clone();
|
||
|
|
let _ = handle.insert_idle(move |state| {
|
||
|
|
let seat = state.common.last_active_seat().clone();
|
||
|
|
Shell::menu_resize_request(state, &resize_clone, &seat, ResizeEdge::LEFT);
|
||
|
|
});
|
||
|
|
}).disabled(!possible_resizes.contains(ResizeEdge::LEFT)),
|
||
|
|
Item::new(fl!("window-menu-resize-edge-right"), move |handle| {
|
||
|
|
let resize_clone = resize_right_clone.clone();
|
||
|
|
let _ = handle.insert_idle(move |state| {
|
||
|
|
let seat = state.common.last_active_seat().clone();
|
||
|
|
Shell::menu_resize_request(state, &resize_clone, &seat, ResizeEdge::RIGHT);
|
||
|
|
});
|
||
|
|
}).disabled(!possible_resizes.contains(ResizeEdge::RIGHT)),
|
||
|
|
Item::new(fl!("window-menu-resize-edge-bottom"), move |handle| {
|
||
|
|
let resize_clone = resize_bottom_clone.clone();
|
||
|
|
let _ = handle.insert_idle(move |state| {
|
||
|
|
let seat = state.common.last_active_seat().clone();
|
||
|
|
Shell::menu_resize_request(state, &resize_clone, &seat, ResizeEdge::BOTTOM);
|
||
|
|
});
|
||
|
|
}).disabled(!possible_resizes.contains(ResizeEdge::BOTTOM)),
|
||
|
|
])),
|
||
|
|
Some(Item::new(fl!("window-menu-move-prev-workspace"), move |handle| {
|
||
|
|
let move_prev_clone = move_prev_clone.clone();
|
||
|
|
let _ = handle.insert_idle(move |state| {
|
||
|
|
let seat = state.common.last_active_seat().clone();
|
||
|
|
let (current_handle, output) = {
|
||
|
|
let Some(ws) = state.common.shell.space_for(&move_prev_clone) else { return };
|
||
|
|
(ws.handle, ws.output.clone())
|
||
|
|
};
|
||
|
|
let maybe_handle = state
|
||
|
|
.common
|
||
|
|
.shell
|
||
|
|
.workspaces
|
||
|
|
.spaces_for_output(&output)
|
||
|
|
.enumerate()
|
||
|
|
.find_map(|(i, space)| (space.handle == current_handle).then_some(i))
|
||
|
|
.and_then(|i| i.checked_sub(1))
|
||
|
|
.and_then(|i| {
|
||
|
|
state
|
||
|
|
.common
|
||
|
|
.shell
|
||
|
|
.workspaces
|
||
|
|
.get(i, &output)
|
||
|
|
.map(|s| s.handle)
|
||
|
|
});
|
||
|
|
if let Some(prev_handle) = maybe_handle
|
||
|
|
{
|
||
|
|
Shell::move_window(
|
||
|
|
state,
|
||
|
|
&seat,
|
||
|
|
&move_prev_clone,
|
||
|
|
¤t_handle,
|
||
|
|
&prev_handle,
|
||
|
|
true,
|
||
|
|
None,
|
||
|
|
);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
})
|
||
|
|
.shortcut(config.get_shortcut_for_action(&Action::MoveToPreviousWorkspace))),
|
||
|
|
Some(Item::new(fl!("window-menu-move-next-workspace"), move |handle| {
|
||
|
|
let move_next_clone = move_next_clone.clone();
|
||
|
|
let _ = handle.insert_idle(move |state| {
|
||
|
|
let seat = state.common.last_active_seat().clone();
|
||
|
|
let (current_handle, output) = {
|
||
|
|
let Some(ws) = state.common.shell.space_for(&move_next_clone) else { return };
|
||
|
|
(ws.handle, ws.output.clone())
|
||
|
|
};
|
||
|
|
let maybe_handle = state
|
||
|
|
.common
|
||
|
|
.shell
|
||
|
|
.workspaces
|
||
|
|
.spaces_for_output(&output)
|
||
|
|
.skip_while(|space| space.handle != current_handle)
|
||
|
|
.skip(1)
|
||
|
|
.next()
|
||
|
|
.map(|space| space.handle);
|
||
|
|
if let Some(next_handle) = maybe_handle
|
||
|
|
{
|
||
|
|
Shell::move_window(
|
||
|
|
state,
|
||
|
|
&seat,
|
||
|
|
&move_next_clone,
|
||
|
|
¤t_handle,
|
||
|
|
&next_handle,
|
||
|
|
true,
|
||
|
|
None,
|
||
|
|
);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
})
|
||
|
|
.shortcut(config.get_shortcut_for_action(&Action::MoveToNextWorkspace))),
|
||
|
|
(!is_stacked).then_some(Item::new(fl!("window-menu-stack"), move |handle| {
|
||
|
|
let stack_clone = stack_clone.clone();
|
||
|
|
let _ = handle.insert_idle(move |state| {
|
||
|
|
let seat = state.common.last_active_seat().clone();
|
||
|
|
let Some(ws) = state.common.shell.space_for_mut(&stack_clone) else { return };
|
||
|
|
if let Some(new_focus) = ws.toggle_stacking(&stack_clone) {
|
||
|
|
Common::set_focus(state, Some(&new_focus), &seat, None);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
})
|
||
|
|
.shortcut(config.get_shortcut_for_action(&Action::ToggleStacking))),
|
||
|
|
Some(Item::Separator),
|
||
|
|
//Some(Item::new(fl!("window-menu-always-on-top"), |handle| {}).toggled(is_always_on_top)),
|
||
|
|
//Some(Item::new(fl!("window-menu-always-on-visible-ws"), |handle| {})
|
||
|
|
// .toggled(is_always_on_visible_ws)),
|
||
|
|
//Some(Item::Separator),
|
||
|
|
if is_stacked {
|
||
|
|
Some(Item::new(fl!("window-menu-close-all"), move |_handle| {
|
||
|
|
for (window, _) in close_clone.windows() {
|
||
|
|
window.close();
|
||
|
|
}
|
||
|
|
}))
|
||
|
|
} else {
|
||
|
|
Some(Item::new(fl!("window-menu-close"), move |_handle| {
|
||
|
|
close_clone.send_close();
|
||
|
|
})
|
||
|
|
.shortcut(config.get_shortcut_for_action(&Action::Close)))
|
||
|
|
},
|
||
|
|
].into_iter().flatten()
|
||
|
|
}
|