diff --git a/src/cursor.rs b/src/cursor.rs index 9c3dd279..e4447700 100644 --- a/src/cursor.rs +++ b/src/cursor.rs @@ -61,29 +61,77 @@ pub trait Cursor { pub struct ServerCursors { pub default: ServerCursorTemplate, + pub context_menu: ServerCursorTemplate, + pub help: ServerCursorTemplate, pub pointer: ServerCursorTemplate, - pub resize_right: ServerCursorTemplate, - pub resize_left: ServerCursorTemplate, - pub resize_top: ServerCursorTemplate, - pub resize_bottom: ServerCursorTemplate, - pub resize_top_bottom: ServerCursorTemplate, - pub resize_left_right: ServerCursorTemplate, - pub resize_top_left: ServerCursorTemplate, - pub resize_top_right: ServerCursorTemplate, - pub resize_bottom_left: ServerCursorTemplate, - pub resize_bottom_right: ServerCursorTemplate, + pub progress: ServerCursorTemplate, + pub wait: ServerCursorTemplate, + pub cell: ServerCursorTemplate, + pub crosshair: ServerCursorTemplate, + pub text: ServerCursorTemplate, + pub vertical_text: ServerCursorTemplate, + pub alias: ServerCursorTemplate, + pub copy: ServerCursorTemplate, + pub r#move: ServerCursorTemplate, + pub no_drop: ServerCursorTemplate, + pub not_allowed: ServerCursorTemplate, + pub grab: ServerCursorTemplate, + pub grabbing: ServerCursorTemplate, + pub e_resize: ServerCursorTemplate, + pub n_resize: ServerCursorTemplate, + pub ne_resize: ServerCursorTemplate, + pub nw_resize: ServerCursorTemplate, + pub s_resize: ServerCursorTemplate, + pub se_resize: ServerCursorTemplate, + pub sw_resize: ServerCursorTemplate, + pub w_resize: ServerCursorTemplate, + pub ew_resize: ServerCursorTemplate, + pub ns_resize: ServerCursorTemplate, + pub nesw_resize: ServerCursorTemplate, + pub nwse_resize: ServerCursorTemplate, + pub col_resize: ServerCursorTemplate, + pub row_resize: ServerCursorTemplate, + pub all_scroll: ServerCursorTemplate, + pub zoom_in: ServerCursorTemplate, + pub zoom_out: ServerCursorTemplate, } #[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] pub enum KnownCursor { Default, + ContextMenu, + Help, Pointer, - ResizeLeftRight, - ResizeTopBottom, - ResizeTopLeft, - ResizeTopRight, - ResizeBottomLeft, - ResizeBottomRight, + Progress, + Wait, + Cell, + Crosshair, + Text, + VerticalText, + Alias, + Copy, + Move, + NoDrop, + NotAllowed, + Grab, + Grabbing, + EResize, + NResize, + NeResize, + NwResize, + SResize, + SeResize, + SwResize, + WResize, + EwResize, + NsResize, + NeswResize, + NwseResize, + ColResize, + RowResize, + AllScroll, + ZoomIn, + ZoomOut, } impl ServerCursors { @@ -99,21 +147,42 @@ impl ServerCursors { let theme = xcursor_theme.as_ref().map(|theme| BStr::new(theme.bytes())); let load = - |name: &str| ServerCursorTemplate::load(name, theme, &scales, &sizes, &paths, ctx); + |names: &[&str]| ServerCursorTemplate::load(names, theme, &scales, &sizes, &paths, ctx); Ok(Some(Self { - default: load("left_ptr")?, - pointer: load("hand2")?, - // default: load("left_ptr_watch")?, - resize_right: load("right_side")?, - resize_left: load("left_side")?, - resize_top: load("top_side")?, - resize_bottom: load("bottom_side")?, - resize_top_bottom: load("v_double_arrow")?, - resize_left_right: load("h_double_arrow")?, - resize_top_left: load("top_left_corner")?, - resize_top_right: load("top_right_corner")?, - resize_bottom_left: load("bottom_left_corner")?, - resize_bottom_right: load("bottom_right_corner")?, + default: load(&["default", "left_ptr"])?, + context_menu: load(&["context-menu"])?, + help: load(&["help"])?, + pointer: load(&["pointer", "hand2", "hand1"])?, + progress: load(&["progress"])?, + wait: load(&["wait", "watch"])?, + cell: load(&["cell"])?, + crosshair: load(&["crosshair"])?, + text: load(&["text", "xterm"])?, + vertical_text: load(&["vertical-text"])?, + alias: load(&["alias"])?, + copy: load(&["copy"])?, + r#move: load(&["move"])?, + no_drop: load(&["no-drop"])?, + not_allowed: load(&["not-allowed"])?, + grab: load(&["grab"])?, + grabbing: load(&["grabbing"])?, + e_resize: load(&["e-resize", "right_side"])?, + w_resize: load(&["w-resize", "left_side"])?, + n_resize: load(&["n-resize", "top_side"])?, + s_resize: load(&["s-resize", "bottom_side"])?, + ns_resize: load(&["ns-resize", "v_double_arrow"])?, + ew_resize: load(&["ew-resize", "h_double_arrow"])?, + nw_resize: load(&["nw-resize", "top_left_corner"])?, + ne_resize: load(&["ne-resize", "top_right_corner"])?, + sw_resize: load(&["sw-resize", "bottom_left_corner"])?, + se_resize: load(&["se-resize", "bottom_right_corner"])?, + nesw_resize: load(&["nesw-resize"])?, + nwse_resize: load(&["nwse-resize"])?, + col_resize: load(&["col-resize"])?, + row_resize: load(&["row-resize"])?, + all_scroll: load(&["all-scroll", "grabbing"])?, + zoom_in: load(&["zoom-in"])?, + zoom_out: load(&["zoom-out"])?, })) } } @@ -130,14 +199,14 @@ enum ServerCursorTemplateVariant { impl ServerCursorTemplate { fn load( - name: &str, + names: &[&str], theme: Option<&BStr>, scales: &[Scale], sizes: &[u32], paths: &[BString], ctx: &Rc, ) -> Result { - match open_cursor(name, theme, scales, sizes, paths) { + match open_cursor(names, theme, scales, sizes, paths) { Ok(cs) => { if cs.images.len() == 1 { let mut sizes = SmallMapMut::new(); @@ -178,7 +247,7 @@ impl ServerCursorTemplate { } } Err(e) => { - log::warn!("Could not load cursor {}: {}", name, ErrorFmt(e)); + log::warn!("Could not load cursor {:?}: {}", names, ErrorFmt(e)); let empty: [Cell; 4] = unsafe { MaybeUninit::zeroed().assume_init() }; let mut img_sizes = SmallMapMut::new(); for scale in scales { @@ -399,20 +468,31 @@ struct OpenCursorResult { } fn open_cursor( - name: &str, + names: &[&str], theme: Option<&BStr>, scales: &[Scale], sizes: &[u32], paths: &[BString], ) -> Result { - let name = name.as_bytes().as_bstr(); let mut file = None; - let mut themes_tested = AHashSet::new(); + let mut pairs_tested = AHashSet::new(); if let Some(theme) = theme { - file = open_cursor_file(&mut themes_tested, paths, theme, name); + for name in names { + let name = name.as_bytes().as_bstr(); + file = open_cursor_file(&mut pairs_tested, paths, theme, name); + if file.is_some() { + break; + } + } } if file.is_none() { - file = open_cursor_file(&mut themes_tested, paths, b"default".as_bstr(), name); + for name in names { + let name = name.as_bytes().as_bstr(); + file = open_cursor_file(&mut pairs_tested, paths, b"default".as_bstr(), name); + if file.is_some() { + break; + } + } } let file = match file { Some(f) => f, @@ -422,13 +502,13 @@ fn open_cursor( parser_cursor_file(&mut file, scales, sizes) } -fn open_cursor_file( - themes_tested: &mut AHashSet, +fn open_cursor_file<'a>( + pairs_tested: &mut AHashSet<(BString, &'a BStr)>, paths: &[BString], theme: &BStr, - name: &BStr, + name: &'a BStr, ) -> Option { - if !themes_tested.insert(theme.to_owned()) { + if !pairs_tested.insert((theme.to_owned(), name)) { return None; } if paths.is_empty() { @@ -453,7 +533,7 @@ fn open_cursor_file( } if let Some(parents) = parents { for parent in parents { - if let Some(file) = open_cursor_file(themes_tested, paths, parent.as_bstr(), name) { + if let Some(file) = open_cursor_file(pairs_tested, paths, parent.as_bstr(), name) { return Some(file); } } diff --git a/src/globals.rs b/src/globals.rs index bdfb0594..c894c631 100644 --- a/src/globals.rs +++ b/src/globals.rs @@ -20,6 +20,7 @@ use { wl_shm::WlShmGlobal, wl_subcompositor::WlSubcompositorGlobal, wl_surface::xwayland_shell_v1::XwaylandShellV1Global, + wp_cursor_shape_manager_v1::WpCursorShapeManagerV1Global, wp_fractional_scale_manager_v1::WpFractionalScaleManagerV1Global, wp_presentation::WpPresentationGlobal, wp_single_pixel_buffer_manager_v1::WpSinglePixelBufferManagerV1Global, @@ -158,6 +159,7 @@ impl Globals { add_singleton!(XwaylandShellV1Global); add_singleton!(WpTearingControlManagerV1Global); add_singleton!(WpSinglePixelBufferManagerV1Global); + add_singleton!(WpCursorShapeManagerV1Global); } pub fn add_backend_singletons(&self, backend: &Rc) { diff --git a/src/ifs.rs b/src/ifs.rs index 2418eddf..7159237a 100644 --- a/src/ifs.rs +++ b/src/ifs.rs @@ -27,6 +27,8 @@ pub mod wl_shm; pub mod wl_shm_pool; pub mod wl_subcompositor; pub mod wl_surface; +pub mod wp_cursor_shape_device_v1; +pub mod wp_cursor_shape_manager_v1; pub mod wp_fractional_scale_manager_v1; pub mod wp_presentation; pub mod wp_presentation_feedback; diff --git a/src/ifs/wl_seat.rs b/src/ifs/wl_seat.rs index d9dabe6e..7347a17c 100644 --- a/src/ifs/wl_seat.rs +++ b/src/ifs/wl_seat.rs @@ -784,13 +784,39 @@ impl WlSeatGlobal { }; let tpl = match cursor { KnownCursor::Default => &cursors.default, + KnownCursor::ContextMenu => &cursors.context_menu, + KnownCursor::Help => &cursors.help, KnownCursor::Pointer => &cursors.pointer, - KnownCursor::ResizeLeftRight => &cursors.resize_left_right, - KnownCursor::ResizeTopBottom => &cursors.resize_top_bottom, - KnownCursor::ResizeTopLeft => &cursors.resize_top_left, - KnownCursor::ResizeTopRight => &cursors.resize_top_right, - KnownCursor::ResizeBottomLeft => &cursors.resize_bottom_left, - KnownCursor::ResizeBottomRight => &cursors.resize_bottom_right, + KnownCursor::Progress => &cursors.progress, + KnownCursor::Wait => &cursors.wait, + KnownCursor::Cell => &cursors.cell, + KnownCursor::Crosshair => &cursors.crosshair, + KnownCursor::Text => &cursors.text, + KnownCursor::VerticalText => &cursors.vertical_text, + KnownCursor::Alias => &cursors.alias, + KnownCursor::Copy => &cursors.copy, + KnownCursor::Move => &cursors.r#move, + KnownCursor::NoDrop => &cursors.no_drop, + KnownCursor::NotAllowed => &cursors.not_allowed, + KnownCursor::Grab => &cursors.grab, + KnownCursor::Grabbing => &cursors.grabbing, + KnownCursor::EResize => &cursors.e_resize, + KnownCursor::NResize => &cursors.n_resize, + KnownCursor::NeResize => &cursors.ne_resize, + KnownCursor::NwResize => &cursors.nw_resize, + KnownCursor::SResize => &cursors.s_resize, + KnownCursor::SeResize => &cursors.se_resize, + KnownCursor::SwResize => &cursors.sw_resize, + KnownCursor::WResize => &cursors.w_resize, + KnownCursor::EwResize => &cursors.ew_resize, + KnownCursor::NsResize => &cursors.ns_resize, + KnownCursor::NeswResize => &cursors.nesw_resize, + KnownCursor::NwseResize => &cursors.nwse_resize, + KnownCursor::ColResize => &cursors.col_resize, + KnownCursor::RowResize => &cursors.row_resize, + KnownCursor::AllScroll => &cursors.all_scroll, + KnownCursor::ZoomIn => &cursors.zoom_in, + KnownCursor::ZoomOut => &cursors.zoom_out, }; self.set_cursor2(Some(tpl.instantiate(self.cursor_size.get()))); } diff --git a/src/ifs/wl_seat/wl_pointer.rs b/src/ifs/wl_seat/wl_pointer.rs index 4319b8df..e596777f 100644 --- a/src/ifs/wl_seat/wl_pointer.rs +++ b/src/ifs/wl_seat/wl_pointer.rs @@ -197,7 +197,7 @@ impl WlPointer { } }; if pointer_node.node_client_id() != Some(self.seat.client.id) { - log::warn!("ignoring wl_pointer.set_cursor (2)"); + // log::warn!("ignoring wl_pointer.set_cursor (2)"); return Ok(()); } // https://gitlab.freedesktop.org/wayland/wayland/-/issues/439 diff --git a/src/ifs/wp_cursor_shape_device_v1.rs b/src/ifs/wp_cursor_shape_device_v1.rs new file mode 100644 index 00000000..84a2b480 --- /dev/null +++ b/src/ifs/wp_cursor_shape_device_v1.rs @@ -0,0 +1,136 @@ +use { + crate::{ + client::{Client, ClientError}, + cursor::KnownCursor, + ifs::wl_seat::WlSeatGlobal, + leaks::Tracker, + object::Object, + utils::buffd::{MsgParser, MsgParserError}, + wire::{wp_cursor_shape_device_v1::*, WpCursorShapeDeviceV1Id}, + }, + std::rc::Rc, + thiserror::Error, +}; + +const DEFAULT: u32 = 1; +const CONTEXT_MENU: u32 = 2; +const HELP: u32 = 3; +const POINTER: u32 = 4; +const PROGRESS: u32 = 5; +const WAIT: u32 = 6; +const CELL: u32 = 7; +const CROSSHAIR: u32 = 8; +const TEXT: u32 = 9; +const VERTICAL_TEXT: u32 = 10; +const ALIAS: u32 = 11; +const COPY: u32 = 12; +const MOVE: u32 = 13; +const NO_DROP: u32 = 14; +const NOT_ALLOWED: u32 = 15; +const GRAB: u32 = 16; +const GRABBING: u32 = 17; +const E_RESIZE: u32 = 18; +const N_RESIZE: u32 = 19; +const NE_RESIZE: u32 = 20; +const NW_RESIZE: u32 = 21; +const S_RESIZE: u32 = 22; +const SE_RESIZE: u32 = 23; +const SW_RESIZE: u32 = 24; +const W_RESIZE: u32 = 25; +const EW_RESIZE: u32 = 26; +const NS_RESIZE: u32 = 27; +const NESW_RESIZE: u32 = 28; +const NWSE_RESIZE: u32 = 29; +const COL_RESIZE: u32 = 30; +const ROW_RESIZE: u32 = 31; +const ALL_SCROLL: u32 = 32; +const ZOOM_IN: u32 = 33; +const ZOOM_OUT: u32 = 34; + +pub struct WpCursorShapeDeviceV1 { + pub id: WpCursorShapeDeviceV1Id, + pub client: Rc, + pub seat: Rc, + pub tracker: Tracker, +} + +impl WpCursorShapeDeviceV1 { + fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), WpCursorShapeDeviceV1Error> { + let _req: Destroy = self.client.parse(self, parser)?; + self.client.remove_obj(self)?; + Ok(()) + } + + fn set_shape(&self, parser: MsgParser<'_, '_>) -> Result<(), WpCursorShapeDeviceV1Error> { + let req: SetShape = self.client.parse(self, parser)?; + let cursor = match req.shape { + DEFAULT => KnownCursor::Default, + CONTEXT_MENU => KnownCursor::ContextMenu, + HELP => KnownCursor::Help, + POINTER => KnownCursor::Pointer, + PROGRESS => KnownCursor::Progress, + WAIT => KnownCursor::Wait, + CELL => KnownCursor::Cell, + CROSSHAIR => KnownCursor::Crosshair, + TEXT => KnownCursor::Text, + VERTICAL_TEXT => KnownCursor::VerticalText, + ALIAS => KnownCursor::Alias, + COPY => KnownCursor::Copy, + MOVE => KnownCursor::Move, + NO_DROP => KnownCursor::NoDrop, + NOT_ALLOWED => KnownCursor::NotAllowed, + GRAB => KnownCursor::Grab, + GRABBING => KnownCursor::Grabbing, + E_RESIZE => KnownCursor::EResize, + N_RESIZE => KnownCursor::NResize, + NE_RESIZE => KnownCursor::NeResize, + NW_RESIZE => KnownCursor::NwResize, + S_RESIZE => KnownCursor::SResize, + SE_RESIZE => KnownCursor::SeResize, + SW_RESIZE => KnownCursor::SwResize, + W_RESIZE => KnownCursor::WResize, + EW_RESIZE => KnownCursor::EwResize, + NS_RESIZE => KnownCursor::NsResize, + NESW_RESIZE => KnownCursor::NeswResize, + NWSE_RESIZE => KnownCursor::NwseResize, + COL_RESIZE => KnownCursor::ColResize, + ROW_RESIZE => KnownCursor::RowResize, + ALL_SCROLL => KnownCursor::AllScroll, + ZOOM_IN => KnownCursor::ZoomIn, + ZOOM_OUT => KnownCursor::ZoomOut, + _ => return Err(WpCursorShapeDeviceV1Error::UnknownShape(req.shape)), + }; + let pointer_node = match self.seat.pointer_node() { + Some(n) => n, + _ => return Ok(()), + }; + if pointer_node.node_client_id() != Some(self.client.id) { + return Ok(()); + } + self.seat.set_known_cursor(cursor); + Ok(()) + } +} + +object_base! { + self = WpCursorShapeDeviceV1; + + DESTROY => destroy, + SET_SHAPE => set_shape, +} + +impl Object for WpCursorShapeDeviceV1 {} + +simple_add_obj!(WpCursorShapeDeviceV1); + +#[derive(Debug, Error)] +pub enum WpCursorShapeDeviceV1Error { + #[error(transparent)] + ClientError(Box), + #[error("Parsing failed")] + MsgParserError(#[source] Box), + #[error("Shape {0} is unknown")] + UnknownShape(u32), +} +efrom!(WpCursorShapeDeviceV1Error, ClientError); +efrom!(WpCursorShapeDeviceV1Error, MsgParserError); diff --git a/src/ifs/wp_cursor_shape_manager_v1.rs b/src/ifs/wp_cursor_shape_manager_v1.rs new file mode 100644 index 00000000..edc034d0 --- /dev/null +++ b/src/ifs/wp_cursor_shape_manager_v1.rs @@ -0,0 +1,119 @@ +use { + crate::{ + client::{Client, ClientError}, + globals::{Global, GlobalName}, + ifs::wp_cursor_shape_device_v1::WpCursorShapeDeviceV1, + leaks::Tracker, + object::Object, + utils::buffd::{MsgParser, MsgParserError}, + wire::{wp_cursor_shape_manager_v1::*, WpCursorShapeManagerV1Id}, + }, + std::rc::Rc, + thiserror::Error, +}; + +pub struct WpCursorShapeManagerV1Global { + pub name: GlobalName, +} + +impl WpCursorShapeManagerV1Global { + pub fn new(name: GlobalName) -> Self { + Self { name } + } + + fn bind_( + self: Rc, + id: WpCursorShapeManagerV1Id, + client: &Rc, + version: u32, + ) -> Result<(), WpCursorShapeManagerV1Error> { + let mgr = Rc::new(WpCursorShapeManagerV1 { + id, + client: client.clone(), + tracker: Default::default(), + version, + }); + track!(client, mgr); + client.add_client_obj(&mgr)?; + Ok(()) + } +} + +global_base!( + WpCursorShapeManagerV1Global, + WpCursorShapeManagerV1, + WpCursorShapeManagerV1Error +); + +simple_add_global!(WpCursorShapeManagerV1Global); + +impl Global for WpCursorShapeManagerV1Global { + fn singleton(&self) -> bool { + true + } + + fn version(&self) -> u32 { + 1 + } +} + +pub struct WpCursorShapeManagerV1 { + pub id: WpCursorShapeManagerV1Id, + pub client: Rc, + pub tracker: Tracker, + pub version: u32, +} + +impl WpCursorShapeManagerV1 { + fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), WpCursorShapeManagerV1Error> { + let _req: Destroy = self.client.parse(self, parser)?; + self.client.remove_obj(self)?; + Ok(()) + } + + fn get_pointer(&self, parser: MsgParser<'_, '_>) -> Result<(), WpCursorShapeManagerV1Error> { + let req: GetPointer = self.client.parse(self, parser)?; + let pointer = self.client.lookup(req.pointer)?; + let device = Rc::new(WpCursorShapeDeviceV1 { + id: req.cursor_shape_device, + client: self.client.clone(), + seat: pointer.seat.global.clone(), + tracker: Default::default(), + }); + track!(self.client, device); + self.client.add_client_obj(&device)?; + Ok(()) + } + + fn get_tablet_tool_v2( + &self, + parser: MsgParser<'_, '_>, + ) -> Result<(), WpCursorShapeManagerV1Error> { + let _req: GetTabletToolV2 = self.client.parse(self, parser)?; + Err(WpCursorShapeManagerV1Error::TabletToolNotSupported) + } +} + +object_base! { + self = WpCursorShapeManagerV1; + + DESTROY => destroy, + GET_POINTER => get_pointer, + GET_TABLET_TOOL_V2 => get_tablet_tool_v2, +} + +impl Object for WpCursorShapeManagerV1 {} + +simple_add_obj!(WpCursorShapeManagerV1); + +#[derive(Debug, Error)] +pub enum WpCursorShapeManagerV1Error { + #[error(transparent)] + ClientError(Box), + #[error("Parsing failed")] + MsgParserError(#[source] Box), + #[error("This compositor does not support tablet tools")] + TabletToolNotSupported, +} +efrom!(WpCursorShapeManagerV1Error, ClientError); +efrom!(WpCursorShapeManagerV1Error, MsgParserError); diff --git a/src/tree/container.rs b/src/tree/container.rs index eaff7a3c..41d517f2 100644 --- a/src/tree/container.rs +++ b/src/tree/container.rs @@ -577,7 +577,7 @@ impl ContainerNode { if y < title_height + 1 { KnownCursor::Default } else { - KnownCursor::ResizeLeftRight + KnownCursor::EwResize } } else { let mut cursor = KnownCursor::Default; @@ -585,7 +585,7 @@ impl ContainerNode { let body = child.body.get(); if body.y1() > y { if body.y1() - y > title_height + 1 { - cursor = KnownCursor::ResizeTopBottom + cursor = KnownCursor::NsResize } break; } diff --git a/src/tree/float.rs b/src/tree/float.rs index 525e6ff6..1f0e5b60 100644 --- a/src/tree/float.rs +++ b/src/tree/float.rs @@ -320,14 +320,14 @@ impl FloatNode { let op_type = OP_TYPES[id]; let new_cursor = match op_type { OpType::Move => KnownCursor::Default, - OpType::ResizeLeft => KnownCursor::ResizeLeftRight, - OpType::ResizeTop => KnownCursor::ResizeTopBottom, - OpType::ResizeRight => KnownCursor::ResizeLeftRight, - OpType::ResizeBottom => KnownCursor::ResizeTopBottom, - OpType::ResizeTopLeft => KnownCursor::ResizeTopLeft, - OpType::ResizeTopRight => KnownCursor::ResizeTopRight, - OpType::ResizeBottomLeft => KnownCursor::ResizeBottomLeft, - OpType::ResizeBottomRight => KnownCursor::ResizeBottomRight, + OpType::ResizeLeft => KnownCursor::EwResize, + OpType::ResizeTop => KnownCursor::NsResize, + OpType::ResizeRight => KnownCursor::EwResize, + OpType::ResizeBottom => KnownCursor::NsResize, + OpType::ResizeTopLeft => KnownCursor::NwResize, + OpType::ResizeTopRight => KnownCursor::NeResize, + OpType::ResizeBottomLeft => KnownCursor::SwResize, + OpType::ResizeBottomRight => KnownCursor::SeResize, }; seat_state.op_type = op_type; if new_cursor != mem::replace(&mut seat_state.cursor, new_cursor) { diff --git a/wire/wp_cursor_shape_device_v1.txt b/wire/wp_cursor_shape_device_v1.txt new file mode 100644 index 00000000..d840af08 --- /dev/null +++ b/wire/wp_cursor_shape_device_v1.txt @@ -0,0 +1,9 @@ +# requests + +msg destroy = 0 { +} + +msg set_shape = 1 { + serial: u32, + shape: u32, +} diff --git a/wire/wp_cursor_shape_manager_v1.txt b/wire/wp_cursor_shape_manager_v1.txt new file mode 100644 index 00000000..769da728 --- /dev/null +++ b/wire/wp_cursor_shape_manager_v1.txt @@ -0,0 +1,14 @@ +# requests + +msg destroy = 0 { +} + +msg get_pointer = 1 { + cursor_shape_device: id(wp_cursor_shape_device_v1), + pointer: id(wl_pointer), +} + +msg get_tablet_tool_v2 = 2 { + cursor_shape_device: id(wp_cursor_shape_device_v1), + tablet_tool: id(zwp_tablet_tool_v2), +} diff --git a/wire/zwp_tablet_tool_v2.txt b/wire/zwp_tablet_tool_v2.txt new file mode 100644 index 00000000..efdf60a6 --- /dev/null +++ b/wire/zwp_tablet_tool_v2.txt @@ -0,0 +1,4 @@ +# requests + +msg destroy = 1 { +}