use crate::base::{self, BaseError, BaseEvent, GeEvent, Raw, Reply, WiredIn, WiredOut, Xid};
use crate::ext;
use crate::ffi::base::*;
use crate::ffi::ext::*;
use crate::lat1_str::{Lat1Str, Lat1String, Lat1StrF};
use crate::xfixes;
use crate::xproto;
use crate::render;
use crate::shape;
use crate::xproto::PropEl;
use bitflags::bitflags;
use libc::{self, iovec};
use std::convert::TryInto;
use std::hash::{Hash, Hasher};
use std::os::unix::io::RawFd;
pub const XNAME: &str = "XInputExtension";
pub const MAJOR_VERSION: u32 = 2;
pub const MINOR_VERSION: u32 = 3;
pub const VERSION_STRING: &str = "2.3";
pub(crate) static mut FFI_EXT: xcb_extension_t = xcb_extension_t {
name: "XInputExtension\0".as_ptr() as *const _,
global_id: 0,
};
pub fn prefetch_extension_data(conn: &base::Connection) {
unsafe {
xcb_prefetch_extension_data(conn.get_raw_conn(), &mut FFI_EXT as *mut _);
}
}
pub fn get_extension_data(conn: &base::Connection) -> std::option::Option<ext::ExtensionData> {
unsafe {
let reply = xcb_get_extension_data(conn.get_raw_conn(), &mut FFI_EXT as *mut _);
assert!(!reply.is_null(), "Could not fetch Input extension data");
let reply = xproto::QueryExtensionReply::from_raw(reply);
if !reply.present() {
std::mem::forget(reply);
return None;
}
let res = ext::ExtensionData{
ext: ext::Extension::Input,
major_opcode: reply.major_opcode(),
first_event: reply.first_event(),
first_error: reply.first_error(),
};
std::mem::forget(reply);
Some(res)
}
}
pub struct DeviceError {
raw: *mut xcb_generic_error_t,
}
impl base::Raw<xcb_generic_error_t> for DeviceError {
unsafe fn from_raw(raw: *mut xcb_generic_error_t) -> Self { DeviceError { raw } }
fn as_raw(&self) -> *mut xcb_generic_error_t {
self.raw
}
}
impl base::BaseError for DeviceError {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 0;
}
impl DeviceError {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
fn wire_len(&self) -> usize { 32 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn error_code(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
}
impl std::fmt::Debug for DeviceError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceError")
.field("response_type", &self.response_type())
.field("error_code", &self.error_code())
.field("sequence", &self.sequence())
.finish()
}
}
impl Drop for DeviceError {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for DeviceError {}
unsafe impl Sync for DeviceError {}
pub struct EventError {
raw: *mut xcb_generic_error_t,
}
impl base::Raw<xcb_generic_error_t> for EventError {
unsafe fn from_raw(raw: *mut xcb_generic_error_t) -> Self { EventError { raw } }
fn as_raw(&self) -> *mut xcb_generic_error_t {
self.raw
}
}
impl base::BaseError for EventError {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 1;
}
impl EventError {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
fn wire_len(&self) -> usize { 32 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn error_code(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
}
impl std::fmt::Debug for EventError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("EventError")
.field("response_type", &self.response_type())
.field("error_code", &self.error_code())
.field("sequence", &self.sequence())
.finish()
}
}
impl Drop for EventError {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for EventError {}
unsafe impl Sync for EventError {}
pub struct ModeError {
raw: *mut xcb_generic_error_t,
}
impl base::Raw<xcb_generic_error_t> for ModeError {
unsafe fn from_raw(raw: *mut xcb_generic_error_t) -> Self { ModeError { raw } }
fn as_raw(&self) -> *mut xcb_generic_error_t {
self.raw
}
}
impl base::BaseError for ModeError {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 2;
}
impl ModeError {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
fn wire_len(&self) -> usize { 32 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn error_code(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
}
impl std::fmt::Debug for ModeError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ModeError")
.field("response_type", &self.response_type())
.field("error_code", &self.error_code())
.field("sequence", &self.sequence())
.finish()
}
}
impl Drop for ModeError {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for ModeError {}
unsafe impl Sync for ModeError {}
pub struct DeviceBusyError {
raw: *mut xcb_generic_error_t,
}
impl base::Raw<xcb_generic_error_t> for DeviceBusyError {
unsafe fn from_raw(raw: *mut xcb_generic_error_t) -> Self { DeviceBusyError { raw } }
fn as_raw(&self) -> *mut xcb_generic_error_t {
self.raw
}
}
impl base::BaseError for DeviceBusyError {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 3;
}
impl DeviceBusyError {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
fn wire_len(&self) -> usize { 32 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn error_code(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
}
impl std::fmt::Debug for DeviceBusyError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceBusyError")
.field("response_type", &self.response_type())
.field("error_code", &self.error_code())
.field("sequence", &self.sequence())
.finish()
}
}
impl Drop for DeviceBusyError {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for DeviceBusyError {}
unsafe impl Sync for DeviceBusyError {}
pub struct ClassError {
raw: *mut xcb_generic_error_t,
}
impl base::Raw<xcb_generic_error_t> for ClassError {
unsafe fn from_raw(raw: *mut xcb_generic_error_t) -> Self { ClassError { raw } }
fn as_raw(&self) -> *mut xcb_generic_error_t {
self.raw
}
}
impl base::BaseError for ClassError {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 4;
}
impl ClassError {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
fn wire_len(&self) -> usize { 32 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn error_code(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
}
impl std::fmt::Debug for ClassError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ClassError")
.field("response_type", &self.response_type())
.field("error_code", &self.error_code())
.field("sequence", &self.sequence())
.finish()
}
}
impl Drop for ClassError {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for ClassError {}
unsafe impl Sync for ClassError {}
#[derive(Debug)]
pub enum Error {
Device(DeviceError),
Event(EventError),
Mode(ModeError),
DeviceBusy(DeviceBusyError),
Class(ClassError),
}
impl base::ResolveWireError for Error {
unsafe fn resolve_wire_error(first_error: u8, raw: *mut xcb_generic_error_t) -> Self {
debug_assert!(!raw.is_null());
let error_code = (*raw).error_code;
match error_code - first_error {
0 => Error::Device(DeviceError::from_raw(raw)),
1 => Error::Event(EventError::from_raw(raw)),
2 => Error::Mode(ModeError::from_raw(raw)),
3 => Error::DeviceBusy(DeviceBusyError::from_raw(raw)),
4 => Error::Class(ClassError::from_raw(raw)),
_ => unreachable!(
"Could not resolve xinput Error with error_code {} and first_error {}",
error_code, first_error
),
}
}
}
pub struct DeviceValuatorEvent {
raw: *mut xcb_generic_event_t,
}
impl base::Raw<xcb_generic_event_t> for DeviceValuatorEvent {
unsafe fn from_raw(raw: *mut xcb_generic_event_t) -> Self { DeviceValuatorEvent { raw } }
fn as_raw(&self) -> *mut xcb_generic_event_t {
self.raw
}
}
impl base::BaseEvent for DeviceValuatorEvent {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 0;
}
impl DeviceValuatorEvent {
pub fn new(event_base: u8,
device_id: u8,
device_state: u16,
num_valuators: u8,
first_valuator: u8,
valuators: [i32; 6],
) -> DeviceValuatorEvent {
unsafe {
let ptr = libc::malloc(32) as *mut u8;
let wire_buf = std::slice::from_raw_parts_mut(ptr, 32);
let mut wire_off = 0usize;
let response_type = event_base;
let sequence = 0u16;
wire_off += response_type.serialize(&mut wire_buf[wire_off ..]);
wire_off += device_id.serialize(&mut wire_buf[wire_off ..]);
wire_off += sequence.serialize(&mut wire_buf[wire_off ..]);
wire_off += device_state.serialize(&mut wire_buf[wire_off ..]);
wire_off += num_valuators.serialize(&mut wire_buf[wire_off ..]);
wire_off += first_valuator.serialize(&mut wire_buf[wire_off ..]);
std::slice::from_raw_parts_mut(ptr.add(wire_off) as *mut i32, 6usize)
.copy_from_slice(&valuators);
DeviceValuatorEvent::from_raw(ptr as *mut xcb_generic_event_t)
}
}
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn device_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device_state(&self) -> u16 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn num_valuators(&self) -> u8 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn first_valuator(&self) -> u8 {
unsafe {
let offset = 7usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn valuators(&self) -> &[i32; 6] {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const [i32; 6];
&*ptr
}
}
}
impl std::fmt::Debug for DeviceValuatorEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceValuatorEvent")
.field("response_type", &self.response_type())
.field("device_id", &self.device_id())
.field("sequence", &self.sequence())
.field("device_state", &self.device_state())
.field("num_valuators", &self.num_valuators())
.field("first_valuator", &self.first_valuator())
.field("valuators", &self.valuators())
.finish()
}
}
impl base::WiredOut for DeviceValuatorEvent {
fn wire_len(&self) -> usize {
32usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for DeviceValuatorEvent {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize {
32
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_generic_event_t;
std::ptr::copy(ptr as *const xcb_generic_event_t, raw, sz);
DeviceValuatorEvent { raw }
}
}
impl Drop for DeviceValuatorEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for DeviceValuatorEvent {}
unsafe impl Sync for DeviceValuatorEvent {}
pub struct DeviceKeyPressEvent {
raw: *mut xcb_generic_event_t,
}
impl base::Raw<xcb_generic_event_t> for DeviceKeyPressEvent {
unsafe fn from_raw(raw: *mut xcb_generic_event_t) -> Self { DeviceKeyPressEvent { raw } }
fn as_raw(&self) -> *mut xcb_generic_event_t {
self.raw
}
}
impl base::BaseEvent for DeviceKeyPressEvent {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 1;
}
impl DeviceKeyPressEvent {
pub fn new(event_base: u8,
detail: u8,
time: xproto::Timestamp,
root: xproto::Window,
event: xproto::Window,
child: xproto::Window,
root_x: i16,
root_y: i16,
event_x: i16,
event_y: i16,
state: xproto::KeyButMask,
same_screen: bool,
device_id: u8,
) -> DeviceKeyPressEvent {
unsafe {
let ptr = libc::malloc(32) as *mut u8;
let wire_buf = std::slice::from_raw_parts_mut(ptr, 32);
let mut wire_off = 0usize;
let response_type = 1u8 + event_base;
let sequence = 0u16;
wire_off += response_type.serialize(&mut wire_buf[wire_off ..]);
wire_off += detail.serialize(&mut wire_buf[wire_off ..]);
wire_off += sequence.serialize(&mut wire_buf[wire_off ..]);
wire_off += time.serialize(&mut wire_buf[wire_off ..]);
wire_off += root.serialize(&mut wire_buf[wire_off ..]);
wire_off += event.serialize(&mut wire_buf[wire_off ..]);
wire_off += child.serialize(&mut wire_buf[wire_off ..]);
wire_off += root_x.serialize(&mut wire_buf[wire_off ..]);
wire_off += root_y.serialize(&mut wire_buf[wire_off ..]);
wire_off += event_x.serialize(&mut wire_buf[wire_off ..]);
wire_off += event_y.serialize(&mut wire_buf[wire_off ..]);
wire_off += (state.bits() as u16).serialize(&mut wire_buf[wire_off ..]);
let same_screen: u8 = if same_screen { 1 } else { 0 };
wire_off += same_screen.serialize(&mut wire_buf[wire_off ..]);
device_id.serialize(&mut wire_buf[wire_off ..]);
DeviceKeyPressEvent::from_raw(ptr as *mut xcb_generic_event_t)
}
}
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn detail(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn root(&self) -> xproto::Window {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn event(&self) -> xproto::Window {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn child(&self) -> xproto::Window {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn root_x(&self) -> i16 {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const i16;
base::value_from_ptr(ptr)
}
}
pub fn root_y(&self) -> i16 {
unsafe {
let offset = 22usize;
let ptr = self.wire_ptr().add(offset) as *const i16;
base::value_from_ptr(ptr)
}
}
pub fn event_x(&self) -> i16 {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const i16;
base::value_from_ptr(ptr)
}
}
pub fn event_y(&self) -> i16 {
unsafe {
let offset = 26usize;
let ptr = self.wire_ptr().add(offset) as *const i16;
base::value_from_ptr(ptr)
}
}
pub fn state(&self) -> xproto::KeyButMask {
unsafe {
let offset = 28usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::KeyButMask>(val)
}
}
pub fn same_screen(&self) -> bool {
let val = unsafe { *(self.wire_ptr().add(30usize)) };
val != 0
}
pub fn device_id(&self) -> u8 {
unsafe {
let offset = 31usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
}
impl std::fmt::Debug for DeviceKeyPressEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceKeyPressEvent")
.field("response_type", &self.response_type())
.field("detail", &self.detail())
.field("sequence", &self.sequence())
.field("time", &self.time())
.field("root", &self.root())
.field("event", &self.event())
.field("child", &self.child())
.field("root_x", &self.root_x())
.field("root_y", &self.root_y())
.field("event_x", &self.event_x())
.field("event_y", &self.event_y())
.field("state", &self.state())
.field("same_screen", &self.same_screen())
.field("device_id", &self.device_id())
.finish()
}
}
impl base::WiredOut for DeviceKeyPressEvent {
fn wire_len(&self) -> usize {
32usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for DeviceKeyPressEvent {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize {
32
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_generic_event_t;
std::ptr::copy(ptr as *const xcb_generic_event_t, raw, sz);
DeviceKeyPressEvent { raw }
}
}
impl Drop for DeviceKeyPressEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for DeviceKeyPressEvent {}
unsafe impl Sync for DeviceKeyPressEvent {}
pub type DeviceKeyReleaseEvent = DeviceKeyPressEvent;
pub type DeviceButtonPressEvent = DeviceKeyPressEvent;
pub type DeviceButtonReleaseEvent = DeviceKeyPressEvent;
pub type DeviceMotionNotifyEvent = DeviceKeyPressEvent;
pub struct DeviceFocusInEvent {
raw: *mut xcb_generic_event_t,
}
impl base::Raw<xcb_generic_event_t> for DeviceFocusInEvent {
unsafe fn from_raw(raw: *mut xcb_generic_event_t) -> Self { DeviceFocusInEvent { raw } }
fn as_raw(&self) -> *mut xcb_generic_event_t {
self.raw
}
}
impl base::BaseEvent for DeviceFocusInEvent {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 6;
}
impl DeviceFocusInEvent {
pub fn new(event_base: u8,
detail: xproto::NotifyDetail,
time: xproto::Timestamp,
window: xproto::Window,
mode: xproto::NotifyMode,
device_id: u8,
) -> DeviceFocusInEvent {
unsafe {
let ptr = libc::malloc(32) as *mut u8;
let wire_buf = std::slice::from_raw_parts_mut(ptr, 32);
let mut wire_off = 0usize;
let response_type = 6u8 + event_base;
let sequence = 0u16;
wire_off += response_type.serialize(&mut wire_buf[wire_off ..]);
wire_off += (std::mem::transmute::<_, u32>(detail) as u8).serialize(&mut wire_buf[wire_off ..]);
wire_off += sequence.serialize(&mut wire_buf[wire_off ..]);
wire_off += time.serialize(&mut wire_buf[wire_off ..]);
wire_off += window.serialize(&mut wire_buf[wire_off ..]);
wire_off += (std::mem::transmute::<_, u32>(mode) as u8).serialize(&mut wire_buf[wire_off ..]);
device_id.serialize(&mut wire_buf[wire_off ..]);
DeviceFocusInEvent::from_raw(ptr as *mut xcb_generic_event_t)
}
}
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn detail(&self) -> xproto::NotifyDetail {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::NotifyDetail>(val)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn window(&self) -> xproto::Window {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn mode(&self) -> xproto::NotifyMode {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::NotifyMode>(val)
}
}
pub fn device_id(&self) -> u8 {
unsafe {
let offset = 13usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
}
impl std::fmt::Debug for DeviceFocusInEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceFocusInEvent")
.field("response_type", &self.response_type())
.field("detail", &self.detail())
.field("sequence", &self.sequence())
.field("time", &self.time())
.field("window", &self.window())
.field("mode", &self.mode())
.field("device_id", &self.device_id())
.field("pad", &18)
.finish()
}
}
impl base::WiredOut for DeviceFocusInEvent {
fn wire_len(&self) -> usize {
32usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for DeviceFocusInEvent {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize {
32
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_generic_event_t;
std::ptr::copy(ptr as *const xcb_generic_event_t, raw, sz);
DeviceFocusInEvent { raw }
}
}
impl Drop for DeviceFocusInEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for DeviceFocusInEvent {}
unsafe impl Sync for DeviceFocusInEvent {}
pub type DeviceFocusOutEvent = DeviceFocusInEvent;
pub type ProximityInEvent = DeviceKeyPressEvent;
pub type ProximityOutEvent = DeviceKeyPressEvent;
pub struct DeviceStateNotifyEvent {
raw: *mut xcb_generic_event_t,
}
impl base::Raw<xcb_generic_event_t> for DeviceStateNotifyEvent {
unsafe fn from_raw(raw: *mut xcb_generic_event_t) -> Self { DeviceStateNotifyEvent { raw } }
fn as_raw(&self) -> *mut xcb_generic_event_t {
self.raw
}
}
impl base::BaseEvent for DeviceStateNotifyEvent {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 10;
}
impl DeviceStateNotifyEvent {
pub fn new(event_base: u8,
device_id: u8,
time: xproto::Timestamp,
num_keys: u8,
num_buttons: u8,
num_valuators: u8,
classes_reported: ClassesReportedMask,
buttons: [u8; 4],
keys: [u8; 4],
valuators: [u32; 3],
) -> DeviceStateNotifyEvent {
unsafe {
let ptr = libc::malloc(32) as *mut u8;
let wire_buf = std::slice::from_raw_parts_mut(ptr, 32);
let mut wire_off = 0usize;
let response_type = 10u8 + event_base;
let sequence = 0u16;
wire_off += response_type.serialize(&mut wire_buf[wire_off ..]);
wire_off += device_id.serialize(&mut wire_buf[wire_off ..]);
wire_off += sequence.serialize(&mut wire_buf[wire_off ..]);
wire_off += time.serialize(&mut wire_buf[wire_off ..]);
wire_off += num_keys.serialize(&mut wire_buf[wire_off ..]);
wire_off += num_buttons.serialize(&mut wire_buf[wire_off ..]);
wire_off += num_valuators.serialize(&mut wire_buf[wire_off ..]);
wire_off += (classes_reported.bits() as u8).serialize(&mut wire_buf[wire_off ..]);
std::slice::from_raw_parts_mut(ptr.add(wire_off) as *mut u8, 4usize)
.copy_from_slice(&buttons);
wire_off += 4usize;
std::slice::from_raw_parts_mut(ptr.add(wire_off) as *mut u8, 4usize)
.copy_from_slice(&keys);
wire_off += 4usize;
std::slice::from_raw_parts_mut(ptr.add(wire_off) as *mut u32, 3usize)
.copy_from_slice(&valuators);
DeviceStateNotifyEvent::from_raw(ptr as *mut xcb_generic_event_t)
}
}
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn device_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn num_keys(&self) -> u8 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn num_buttons(&self) -> u8 {
unsafe {
let offset = 9usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn num_valuators(&self) -> u8 {
unsafe {
let offset = 10usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn classes_reported(&self) -> ClassesReportedMask {
unsafe {
let offset = 11usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, ClassesReportedMask>(val)
}
}
pub fn buttons(&self) -> &[u8; 4] {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const [u8; 4];
&*ptr
}
}
pub fn keys(&self) -> &[u8; 4] {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const [u8; 4];
&*ptr
}
}
pub fn valuators(&self) -> &[u32; 3] {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const [u32; 3];
&*ptr
}
}
}
impl std::fmt::Debug for DeviceStateNotifyEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceStateNotifyEvent")
.field("response_type", &self.response_type())
.field("device_id", &self.device_id())
.field("sequence", &self.sequence())
.field("time", &self.time())
.field("num_keys", &self.num_keys())
.field("num_buttons", &self.num_buttons())
.field("num_valuators", &self.num_valuators())
.field("classes_reported", &self.classes_reported())
.field("buttons", &self.buttons())
.field("keys", &self.keys())
.field("valuators", &self.valuators())
.finish()
}
}
impl base::WiredOut for DeviceStateNotifyEvent {
fn wire_len(&self) -> usize {
32usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for DeviceStateNotifyEvent {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize {
32
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_generic_event_t;
std::ptr::copy(ptr as *const xcb_generic_event_t, raw, sz);
DeviceStateNotifyEvent { raw }
}
}
impl Drop for DeviceStateNotifyEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for DeviceStateNotifyEvent {}
unsafe impl Sync for DeviceStateNotifyEvent {}
pub struct DeviceMappingNotifyEvent {
raw: *mut xcb_generic_event_t,
}
impl base::Raw<xcb_generic_event_t> for DeviceMappingNotifyEvent {
unsafe fn from_raw(raw: *mut xcb_generic_event_t) -> Self { DeviceMappingNotifyEvent { raw } }
fn as_raw(&self) -> *mut xcb_generic_event_t {
self.raw
}
}
impl base::BaseEvent for DeviceMappingNotifyEvent {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 11;
}
impl DeviceMappingNotifyEvent {
pub fn new(event_base: u8,
device_id: u8,
request: xproto::Mapping,
first_keycode: KeyCode,
count: u8,
time: xproto::Timestamp,
) -> DeviceMappingNotifyEvent {
unsafe {
let ptr = libc::malloc(32) as *mut u8;
let wire_buf = std::slice::from_raw_parts_mut(ptr, 32);
let mut wire_off = 0usize;
let response_type = 11u8 + event_base;
let sequence = 0u16;
wire_off += response_type.serialize(&mut wire_buf[wire_off ..]);
wire_off += device_id.serialize(&mut wire_buf[wire_off ..]);
wire_off += sequence.serialize(&mut wire_buf[wire_off ..]);
wire_off += (std::mem::transmute::<_, u32>(request) as u8).serialize(&mut wire_buf[wire_off ..]);
wire_off += first_keycode.serialize(&mut wire_buf[wire_off ..]);
wire_off += count.serialize(&mut wire_buf[wire_off ..]);
wire_off += 1usize;
time.serialize(&mut wire_buf[wire_off ..]);
DeviceMappingNotifyEvent::from_raw(ptr as *mut xcb_generic_event_t)
}
}
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn device_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn request(&self) -> xproto::Mapping {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::Mapping>(val)
}
}
pub fn first_keycode(&self) -> KeyCode {
unsafe {
let offset = 5usize;
let ptr = self.wire_ptr().add(offset) as *const KeyCode;
base::value_from_ptr(ptr)
}
}
pub fn count(&self) -> u8 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
}
impl std::fmt::Debug for DeviceMappingNotifyEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceMappingNotifyEvent")
.field("response_type", &self.response_type())
.field("device_id", &self.device_id())
.field("sequence", &self.sequence())
.field("request", &self.request())
.field("first_keycode", &self.first_keycode())
.field("count", &self.count())
.field("pad", &1)
.field("time", &self.time())
.field("pad", &20)
.finish()
}
}
impl base::WiredOut for DeviceMappingNotifyEvent {
fn wire_len(&self) -> usize {
32usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for DeviceMappingNotifyEvent {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize {
32
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_generic_event_t;
std::ptr::copy(ptr as *const xcb_generic_event_t, raw, sz);
DeviceMappingNotifyEvent { raw }
}
}
impl Drop for DeviceMappingNotifyEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for DeviceMappingNotifyEvent {}
unsafe impl Sync for DeviceMappingNotifyEvent {}
pub struct ChangeDeviceNotifyEvent {
raw: *mut xcb_generic_event_t,
}
impl base::Raw<xcb_generic_event_t> for ChangeDeviceNotifyEvent {
unsafe fn from_raw(raw: *mut xcb_generic_event_t) -> Self { ChangeDeviceNotifyEvent { raw } }
fn as_raw(&self) -> *mut xcb_generic_event_t {
self.raw
}
}
impl base::BaseEvent for ChangeDeviceNotifyEvent {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 12;
}
impl ChangeDeviceNotifyEvent {
pub fn new(event_base: u8,
device_id: u8,
time: xproto::Timestamp,
request: ChangeDevice,
) -> ChangeDeviceNotifyEvent {
unsafe {
let ptr = libc::malloc(32) as *mut u8;
let wire_buf = std::slice::from_raw_parts_mut(ptr, 32);
let mut wire_off = 0usize;
let response_type = 12u8 + event_base;
let sequence = 0u16;
wire_off += response_type.serialize(&mut wire_buf[wire_off ..]);
wire_off += device_id.serialize(&mut wire_buf[wire_off ..]);
wire_off += sequence.serialize(&mut wire_buf[wire_off ..]);
wire_off += time.serialize(&mut wire_buf[wire_off ..]);
(std::mem::transmute::<_, u32>(request) as u8).serialize(&mut wire_buf[wire_off ..]);
ChangeDeviceNotifyEvent::from_raw(ptr as *mut xcb_generic_event_t)
}
}
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn device_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn request(&self) -> ChangeDevice {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, ChangeDevice>(val)
}
}
}
impl std::fmt::Debug for ChangeDeviceNotifyEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ChangeDeviceNotifyEvent")
.field("response_type", &self.response_type())
.field("device_id", &self.device_id())
.field("sequence", &self.sequence())
.field("time", &self.time())
.field("request", &self.request())
.field("pad", &23)
.finish()
}
}
impl base::WiredOut for ChangeDeviceNotifyEvent {
fn wire_len(&self) -> usize {
32usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for ChangeDeviceNotifyEvent {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize {
32
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_generic_event_t;
std::ptr::copy(ptr as *const xcb_generic_event_t, raw, sz);
ChangeDeviceNotifyEvent { raw }
}
}
impl Drop for ChangeDeviceNotifyEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for ChangeDeviceNotifyEvent {}
unsafe impl Sync for ChangeDeviceNotifyEvent {}
pub struct DeviceKeyStateNotifyEvent {
raw: *mut xcb_generic_event_t,
}
impl base::Raw<xcb_generic_event_t> for DeviceKeyStateNotifyEvent {
unsafe fn from_raw(raw: *mut xcb_generic_event_t) -> Self { DeviceKeyStateNotifyEvent { raw } }
fn as_raw(&self) -> *mut xcb_generic_event_t {
self.raw
}
}
impl base::BaseEvent for DeviceKeyStateNotifyEvent {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 13;
}
impl DeviceKeyStateNotifyEvent {
pub fn new(event_base: u8,
device_id: u8,
keys: [u8; 28],
) -> DeviceKeyStateNotifyEvent {
unsafe {
let ptr = libc::malloc(32) as *mut u8;
let wire_buf = std::slice::from_raw_parts_mut(ptr, 32);
let mut wire_off = 0usize;
let response_type = 13u8 + event_base;
let sequence = 0u16;
wire_off += response_type.serialize(&mut wire_buf[wire_off ..]);
wire_off += device_id.serialize(&mut wire_buf[wire_off ..]);
wire_off += sequence.serialize(&mut wire_buf[wire_off ..]);
std::slice::from_raw_parts_mut(ptr.add(wire_off) as *mut u8, 28usize)
.copy_from_slice(&keys);
DeviceKeyStateNotifyEvent::from_raw(ptr as *mut xcb_generic_event_t)
}
}
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn device_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn keys(&self) -> &[u8; 28] {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const [u8; 28];
&*ptr
}
}
}
impl std::fmt::Debug for DeviceKeyStateNotifyEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceKeyStateNotifyEvent")
.field("response_type", &self.response_type())
.field("device_id", &self.device_id())
.field("sequence", &self.sequence())
.field("keys", &self.keys())
.finish()
}
}
impl base::WiredOut for DeviceKeyStateNotifyEvent {
fn wire_len(&self) -> usize {
32usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for DeviceKeyStateNotifyEvent {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize {
32
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_generic_event_t;
std::ptr::copy(ptr as *const xcb_generic_event_t, raw, sz);
DeviceKeyStateNotifyEvent { raw }
}
}
impl Drop for DeviceKeyStateNotifyEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for DeviceKeyStateNotifyEvent {}
unsafe impl Sync for DeviceKeyStateNotifyEvent {}
pub struct DeviceButtonStateNotifyEvent {
raw: *mut xcb_generic_event_t,
}
impl base::Raw<xcb_generic_event_t> for DeviceButtonStateNotifyEvent {
unsafe fn from_raw(raw: *mut xcb_generic_event_t) -> Self { DeviceButtonStateNotifyEvent { raw } }
fn as_raw(&self) -> *mut xcb_generic_event_t {
self.raw
}
}
impl base::BaseEvent for DeviceButtonStateNotifyEvent {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 14;
}
impl DeviceButtonStateNotifyEvent {
pub fn new(event_base: u8,
device_id: u8,
buttons: [u8; 28],
) -> DeviceButtonStateNotifyEvent {
unsafe {
let ptr = libc::malloc(32) as *mut u8;
let wire_buf = std::slice::from_raw_parts_mut(ptr, 32);
let mut wire_off = 0usize;
let response_type = 14u8 + event_base;
let sequence = 0u16;
wire_off += response_type.serialize(&mut wire_buf[wire_off ..]);
wire_off += device_id.serialize(&mut wire_buf[wire_off ..]);
wire_off += sequence.serialize(&mut wire_buf[wire_off ..]);
std::slice::from_raw_parts_mut(ptr.add(wire_off) as *mut u8, 28usize)
.copy_from_slice(&buttons);
DeviceButtonStateNotifyEvent::from_raw(ptr as *mut xcb_generic_event_t)
}
}
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn device_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn buttons(&self) -> &[u8; 28] {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const [u8; 28];
&*ptr
}
}
}
impl std::fmt::Debug for DeviceButtonStateNotifyEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceButtonStateNotifyEvent")
.field("response_type", &self.response_type())
.field("device_id", &self.device_id())
.field("sequence", &self.sequence())
.field("buttons", &self.buttons())
.finish()
}
}
impl base::WiredOut for DeviceButtonStateNotifyEvent {
fn wire_len(&self) -> usize {
32usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for DeviceButtonStateNotifyEvent {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize {
32
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_generic_event_t;
std::ptr::copy(ptr as *const xcb_generic_event_t, raw, sz);
DeviceButtonStateNotifyEvent { raw }
}
}
impl Drop for DeviceButtonStateNotifyEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for DeviceButtonStateNotifyEvent {}
unsafe impl Sync for DeviceButtonStateNotifyEvent {}
pub struct DevicePresenceNotifyEvent {
raw: *mut xcb_generic_event_t,
}
impl base::Raw<xcb_generic_event_t> for DevicePresenceNotifyEvent {
unsafe fn from_raw(raw: *mut xcb_generic_event_t) -> Self { DevicePresenceNotifyEvent { raw } }
fn as_raw(&self) -> *mut xcb_generic_event_t {
self.raw
}
}
impl base::BaseEvent for DevicePresenceNotifyEvent {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 15;
}
impl DevicePresenceNotifyEvent {
pub fn new(event_base: u8,
time: xproto::Timestamp,
devchange: DeviceChange,
device_id: u8,
control: u16,
) -> DevicePresenceNotifyEvent {
unsafe {
let ptr = libc::malloc(32) as *mut u8;
let wire_buf = std::slice::from_raw_parts_mut(ptr, 32);
let mut wire_off = 0usize;
let response_type = 15u8 + event_base;
let sequence = 0u16;
wire_off += response_type.serialize(&mut wire_buf[wire_off ..]);
wire_off += 1usize;
wire_off += sequence.serialize(&mut wire_buf[wire_off ..]);
wire_off += time.serialize(&mut wire_buf[wire_off ..]);
wire_off += (std::mem::transmute::<_, u32>(devchange) as u8).serialize(&mut wire_buf[wire_off ..]);
wire_off += device_id.serialize(&mut wire_buf[wire_off ..]);
control.serialize(&mut wire_buf[wire_off ..]);
DevicePresenceNotifyEvent::from_raw(ptr as *mut xcb_generic_event_t)
}
}
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn devchange(&self) -> DeviceChange {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceChange>(val)
}
}
pub fn device_id(&self) -> u8 {
unsafe {
let offset = 9usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn control(&self) -> u16 {
unsafe {
let offset = 10usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
}
impl std::fmt::Debug for DevicePresenceNotifyEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DevicePresenceNotifyEvent")
.field("response_type", &self.response_type())
.field("pad", &1)
.field("sequence", &self.sequence())
.field("time", &self.time())
.field("devchange", &self.devchange())
.field("device_id", &self.device_id())
.field("control", &self.control())
.field("pad", &20)
.finish()
}
}
impl base::WiredOut for DevicePresenceNotifyEvent {
fn wire_len(&self) -> usize {
32usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for DevicePresenceNotifyEvent {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize {
32
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_generic_event_t;
std::ptr::copy(ptr as *const xcb_generic_event_t, raw, sz);
DevicePresenceNotifyEvent { raw }
}
}
impl Drop for DevicePresenceNotifyEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for DevicePresenceNotifyEvent {}
unsafe impl Sync for DevicePresenceNotifyEvent {}
pub struct DevicePropertyNotifyEvent {
raw: *mut xcb_generic_event_t,
}
impl base::Raw<xcb_generic_event_t> for DevicePropertyNotifyEvent {
unsafe fn from_raw(raw: *mut xcb_generic_event_t) -> Self { DevicePropertyNotifyEvent { raw } }
fn as_raw(&self) -> *mut xcb_generic_event_t {
self.raw
}
}
impl base::BaseEvent for DevicePropertyNotifyEvent {
const EXTENSION: std::option::Option<ext::Extension> = Some(ext::Extension::Input);
const NUMBER: u32 = 16;
}
impl DevicePropertyNotifyEvent {
pub fn new(event_base: u8,
state: xproto::Property,
time: xproto::Timestamp,
property: xproto::Atom,
device_id: u8,
) -> DevicePropertyNotifyEvent {
unsafe {
let ptr = libc::malloc(32) as *mut u8;
let wire_buf = std::slice::from_raw_parts_mut(ptr, 32);
let mut wire_off = 0usize;
let response_type = 16u8 + event_base;
let sequence = 0u16;
wire_off += response_type.serialize(&mut wire_buf[wire_off ..]);
wire_off += (std::mem::transmute::<_, u32>(state) as u8).serialize(&mut wire_buf[wire_off ..]);
wire_off += sequence.serialize(&mut wire_buf[wire_off ..]);
wire_off += time.serialize(&mut wire_buf[wire_off ..]);
wire_off += property.serialize(&mut wire_buf[wire_off ..]);
wire_off += 19usize;
device_id.serialize(&mut wire_buf[wire_off ..]);
DevicePropertyNotifyEvent::from_raw(ptr as *mut xcb_generic_event_t)
}
}
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn state(&self) -> xproto::Property {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::Property>(val)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn property(&self) -> xproto::Atom {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Atom;
base::value_from_ptr(ptr)
}
}
pub fn device_id(&self) -> u8 {
unsafe {
let offset = 31usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
}
impl std::fmt::Debug for DevicePropertyNotifyEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DevicePropertyNotifyEvent")
.field("response_type", &self.response_type())
.field("state", &self.state())
.field("sequence", &self.sequence())
.field("time", &self.time())
.field("property", &self.property())
.field("pad", &19)
.field("device_id", &self.device_id())
.finish()
}
}
impl base::WiredOut for DevicePropertyNotifyEvent {
fn wire_len(&self) -> usize {
32usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for DevicePropertyNotifyEvent {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize {
32
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_generic_event_t;
std::ptr::copy(ptr as *const xcb_generic_event_t, raw, sz);
DevicePropertyNotifyEvent { raw }
}
}
impl Drop for DevicePropertyNotifyEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for DevicePropertyNotifyEvent {}
unsafe impl Sync for DevicePropertyNotifyEvent {}
pub struct DeviceChangedEvent {
raw: *mut xcb_ge_generic_event_t,
}
impl base::Raw<xcb_ge_generic_event_t> for DeviceChangedEvent {
unsafe fn from_raw(raw: *mut xcb_ge_generic_event_t) -> Self { DeviceChangedEvent { raw } }
fn as_raw(&self) -> *mut xcb_ge_generic_event_t {
self.raw
}
}
impl base::GeEvent for DeviceChangedEvent {
const EXTENSION: ext::Extension = ext::Extension::Input;
const NUMBER: u32 = 1;
}
impl DeviceChangedEvent {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn extension(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn event_type(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
fn num_classes(&self) -> u16 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 18usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn reason(&self) -> ChangeReason {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, ChangeReason>(val)
}
}
pub fn full_sequence(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn classes(&self) -> DeviceClassIterator {
unsafe {
let offset = 36usize;
DeviceClassIterator {
params: (),
rem: (self.num_classes() as usize),
ptr: self.wire_ptr().add(offset),
phantom: std::marker::PhantomData,
}
}
}
}
impl std::fmt::Debug for DeviceChangedEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceChangedEvent")
.field("response_type", &self.response_type())
.field("extension", &self.extension())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("event_type", &self.event_type())
.field("device", &self.device())
.field("time", &self.time())
.field("num_classes", &self.num_classes())
.field("source", &self.source())
.field("reason", &self.reason())
.field("pad", &11)
.field("full_sequence", &self.full_sequence())
.field("classes", &self.classes())
.finish()
}
}
impl base::WiredOut for DeviceChangedEvent {
fn wire_len(&self) -> usize {
32 + 4 * self.length() as usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for DeviceChangedEvent {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
32 + 4 * (*(ptr.add(4) as *const u32) as usize)
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_ge_generic_event_t;
std::ptr::copy(ptr as *const xcb_ge_generic_event_t, raw, sz);
DeviceChangedEvent { raw }
}
}
impl Drop for DeviceChangedEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for DeviceChangedEvent {}
unsafe impl Sync for DeviceChangedEvent {}
pub struct KeyPressEvent {
raw: *mut xcb_ge_generic_event_t,
}
impl base::Raw<xcb_ge_generic_event_t> for KeyPressEvent {
unsafe fn from_raw(raw: *mut xcb_ge_generic_event_t) -> Self { KeyPressEvent { raw } }
fn as_raw(&self) -> *mut xcb_ge_generic_event_t {
self.raw
}
}
impl base::GeEvent for KeyPressEvent {
const EXTENSION: ext::Extension = ext::Extension::Input;
const NUMBER: u32 = 2;
}
impl KeyPressEvent {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn extension(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn event_type(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn detail(&self) -> u32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn root(&self) -> xproto::Window {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn event(&self) -> xproto::Window {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn child(&self) -> xproto::Window {
unsafe {
let offset = 28usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn full_sequence(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn root_x(&self) -> Fp1616 {
unsafe {
let offset = 36usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn root_y(&self) -> Fp1616 {
unsafe {
let offset = 40usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn event_x(&self) -> Fp1616 {
unsafe {
let offset = 44usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn event_y(&self) -> Fp1616 {
unsafe {
let offset = 48usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
fn buttons_len(&self) -> u16 {
unsafe {
let offset = 52usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
fn valuators_len(&self) -> u16 {
unsafe {
let offset = 54usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 56usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn flags(&self) -> KeyEventFlags {
unsafe {
let offset = 60usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, KeyEventFlags>(val)
}
}
pub fn mods(&self) -> ModifierInfo {
unsafe {
let offset = 64usize;
let ptr = self.wire_ptr().add(offset) as *const ModifierInfo;
base::value_from_ptr(ptr)
}
}
pub fn group(&self) -> GroupInfo {
unsafe {
let offset = 80usize;
let ptr = self.wire_ptr().add(offset) as *const GroupInfo;
base::value_from_ptr(ptr)
}
}
pub fn button_mask(&self) -> &[u32] {
unsafe {
let offset = 84usize;
let len = (self.buttons_len() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn valuator_mask(&self) -> &[u32] {
unsafe {
let offset = (84usize + ((self.buttons_len() as usize) * 4usize));
let len = (self.valuators_len() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn axisvalues(&self) -> &[Fp3232] {
unsafe {
let offset = ((84usize + ((self.buttons_len() as usize) * 4usize)) + ((self.valuators_len() as usize) * 4usize));
let len = (self.valuator_mask().iter().map(|el| el.count_ones()).sum::<u32>() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl std::fmt::Debug for KeyPressEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("KeyPressEvent")
.field("response_type", &self.response_type())
.field("extension", &self.extension())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("event_type", &self.event_type())
.field("device", &self.device())
.field("time", &self.time())
.field("detail", &self.detail())
.field("root", &self.root())
.field("event", &self.event())
.field("child", &self.child())
.field("full_sequence", &self.full_sequence())
.field("root_x", &self.root_x())
.field("root_y", &self.root_y())
.field("event_x", &self.event_x())
.field("event_y", &self.event_y())
.field("buttons_len", &self.buttons_len())
.field("valuators_len", &self.valuators_len())
.field("source", &self.source())
.field("pad", &2)
.field("flags", &self.flags())
.field("mods", &self.mods())
.field("group", &self.group())
.field("button_mask", &self.button_mask())
.field("valuator_mask", &self.valuator_mask())
.field("axisvalues", &self.axisvalues())
.finish()
}
}
impl base::WiredOut for KeyPressEvent {
fn wire_len(&self) -> usize {
32 + 4 * self.length() as usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for KeyPressEvent {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
32 + 4 * (*(ptr.add(4) as *const u32) as usize)
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_ge_generic_event_t;
std::ptr::copy(ptr as *const xcb_ge_generic_event_t, raw, sz);
KeyPressEvent { raw }
}
}
impl Drop for KeyPressEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for KeyPressEvent {}
unsafe impl Sync for KeyPressEvent {}
pub type KeyReleaseEvent = KeyPressEvent;
pub struct ButtonPressEvent {
raw: *mut xcb_ge_generic_event_t,
}
impl base::Raw<xcb_ge_generic_event_t> for ButtonPressEvent {
unsafe fn from_raw(raw: *mut xcb_ge_generic_event_t) -> Self { ButtonPressEvent { raw } }
fn as_raw(&self) -> *mut xcb_ge_generic_event_t {
self.raw
}
}
impl base::GeEvent for ButtonPressEvent {
const EXTENSION: ext::Extension = ext::Extension::Input;
const NUMBER: u32 = 4;
}
impl ButtonPressEvent {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn extension(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn event_type(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn detail(&self) -> u32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn root(&self) -> xproto::Window {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn event(&self) -> xproto::Window {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn child(&self) -> xproto::Window {
unsafe {
let offset = 28usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn full_sequence(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn root_x(&self) -> Fp1616 {
unsafe {
let offset = 36usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn root_y(&self) -> Fp1616 {
unsafe {
let offset = 40usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn event_x(&self) -> Fp1616 {
unsafe {
let offset = 44usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn event_y(&self) -> Fp1616 {
unsafe {
let offset = 48usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
fn buttons_len(&self) -> u16 {
unsafe {
let offset = 52usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
fn valuators_len(&self) -> u16 {
unsafe {
let offset = 54usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 56usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn flags(&self) -> PointerEventFlags {
unsafe {
let offset = 60usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, PointerEventFlags>(val)
}
}
pub fn mods(&self) -> ModifierInfo {
unsafe {
let offset = 64usize;
let ptr = self.wire_ptr().add(offset) as *const ModifierInfo;
base::value_from_ptr(ptr)
}
}
pub fn group(&self) -> GroupInfo {
unsafe {
let offset = 80usize;
let ptr = self.wire_ptr().add(offset) as *const GroupInfo;
base::value_from_ptr(ptr)
}
}
pub fn button_mask(&self) -> &[u32] {
unsafe {
let offset = 84usize;
let len = (self.buttons_len() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn valuator_mask(&self) -> &[u32] {
unsafe {
let offset = (84usize + ((self.buttons_len() as usize) * 4usize));
let len = (self.valuators_len() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn axisvalues(&self) -> &[Fp3232] {
unsafe {
let offset = ((84usize + ((self.buttons_len() as usize) * 4usize)) + ((self.valuators_len() as usize) * 4usize));
let len = (self.valuator_mask().iter().map(|el| el.count_ones()).sum::<u32>() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl std::fmt::Debug for ButtonPressEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ButtonPressEvent")
.field("response_type", &self.response_type())
.field("extension", &self.extension())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("event_type", &self.event_type())
.field("device", &self.device())
.field("time", &self.time())
.field("detail", &self.detail())
.field("root", &self.root())
.field("event", &self.event())
.field("child", &self.child())
.field("full_sequence", &self.full_sequence())
.field("root_x", &self.root_x())
.field("root_y", &self.root_y())
.field("event_x", &self.event_x())
.field("event_y", &self.event_y())
.field("buttons_len", &self.buttons_len())
.field("valuators_len", &self.valuators_len())
.field("source", &self.source())
.field("pad", &2)
.field("flags", &self.flags())
.field("mods", &self.mods())
.field("group", &self.group())
.field("button_mask", &self.button_mask())
.field("valuator_mask", &self.valuator_mask())
.field("axisvalues", &self.axisvalues())
.finish()
}
}
impl base::WiredOut for ButtonPressEvent {
fn wire_len(&self) -> usize {
32 + 4 * self.length() as usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for ButtonPressEvent {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
32 + 4 * (*(ptr.add(4) as *const u32) as usize)
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_ge_generic_event_t;
std::ptr::copy(ptr as *const xcb_ge_generic_event_t, raw, sz);
ButtonPressEvent { raw }
}
}
impl Drop for ButtonPressEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for ButtonPressEvent {}
unsafe impl Sync for ButtonPressEvent {}
pub type ButtonReleaseEvent = ButtonPressEvent;
pub type MotionEvent = ButtonPressEvent;
pub struct EnterEvent {
raw: *mut xcb_ge_generic_event_t,
}
impl base::Raw<xcb_ge_generic_event_t> for EnterEvent {
unsafe fn from_raw(raw: *mut xcb_ge_generic_event_t) -> Self { EnterEvent { raw } }
fn as_raw(&self) -> *mut xcb_ge_generic_event_t {
self.raw
}
}
impl base::GeEvent for EnterEvent {
const EXTENSION: ext::Extension = ext::Extension::Input;
const NUMBER: u32 = 7;
}
impl EnterEvent {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn extension(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn event_type(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 16usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn mode(&self) -> NotifyMode {
unsafe {
let offset = 18usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, NotifyMode>(val)
}
}
pub fn detail(&self) -> NotifyDetail {
unsafe {
let offset = 19usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, NotifyDetail>(val)
}
}
pub fn root(&self) -> xproto::Window {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn event(&self) -> xproto::Window {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn child(&self) -> xproto::Window {
unsafe {
let offset = 28usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn full_sequence(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn root_x(&self) -> Fp1616 {
unsafe {
let offset = 36usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn root_y(&self) -> Fp1616 {
unsafe {
let offset = 40usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn event_x(&self) -> Fp1616 {
unsafe {
let offset = 44usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn event_y(&self) -> Fp1616 {
unsafe {
let offset = 48usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn same_screen(&self) -> bool {
let val = unsafe { *(self.wire_ptr().add(52usize)) };
val != 0
}
pub fn focus(&self) -> bool {
let val = unsafe { *(self.wire_ptr().add(53usize)) };
val != 0
}
fn buttons_len(&self) -> u16 {
unsafe {
let offset = 54usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn mods(&self) -> ModifierInfo {
unsafe {
let offset = 56usize;
let ptr = self.wire_ptr().add(offset) as *const ModifierInfo;
base::value_from_ptr(ptr)
}
}
pub fn group(&self) -> GroupInfo {
unsafe {
let offset = 72usize;
let ptr = self.wire_ptr().add(offset) as *const GroupInfo;
base::value_from_ptr(ptr)
}
}
pub fn buttons(&self) -> &[u32] {
unsafe {
let offset = 76usize;
let len = (self.buttons_len() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl std::fmt::Debug for EnterEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("EnterEvent")
.field("response_type", &self.response_type())
.field("extension", &self.extension())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("event_type", &self.event_type())
.field("device", &self.device())
.field("time", &self.time())
.field("source", &self.source())
.field("mode", &self.mode())
.field("detail", &self.detail())
.field("root", &self.root())
.field("event", &self.event())
.field("child", &self.child())
.field("full_sequence", &self.full_sequence())
.field("root_x", &self.root_x())
.field("root_y", &self.root_y())
.field("event_x", &self.event_x())
.field("event_y", &self.event_y())
.field("same_screen", &self.same_screen())
.field("focus", &self.focus())
.field("buttons_len", &self.buttons_len())
.field("mods", &self.mods())
.field("group", &self.group())
.field("buttons", &self.buttons())
.finish()
}
}
impl base::WiredOut for EnterEvent {
fn wire_len(&self) -> usize {
32 + 4 * self.length() as usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for EnterEvent {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
32 + 4 * (*(ptr.add(4) as *const u32) as usize)
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_ge_generic_event_t;
std::ptr::copy(ptr as *const xcb_ge_generic_event_t, raw, sz);
EnterEvent { raw }
}
}
impl Drop for EnterEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for EnterEvent {}
unsafe impl Sync for EnterEvent {}
pub type LeaveEvent = EnterEvent;
pub type FocusInEvent = EnterEvent;
pub type FocusOutEvent = EnterEvent;
pub struct HierarchyEvent {
raw: *mut xcb_ge_generic_event_t,
}
impl base::Raw<xcb_ge_generic_event_t> for HierarchyEvent {
unsafe fn from_raw(raw: *mut xcb_ge_generic_event_t) -> Self { HierarchyEvent { raw } }
fn as_raw(&self) -> *mut xcb_ge_generic_event_t {
self.raw
}
}
impl base::GeEvent for HierarchyEvent {
const EXTENSION: ext::Extension = ext::Extension::Input;
const NUMBER: u32 = 11;
}
impl HierarchyEvent {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn extension(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn event_type(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn flags(&self) -> HierarchyMask {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, HierarchyMask>(val)
}
}
fn num_infos(&self) -> u16 {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn full_sequence(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn infos(&self) -> &[HierarchyInfo] {
unsafe {
let offset = 36usize;
let len = (self.num_infos() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const HierarchyInfo;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl std::fmt::Debug for HierarchyEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("HierarchyEvent")
.field("response_type", &self.response_type())
.field("extension", &self.extension())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("event_type", &self.event_type())
.field("device", &self.device())
.field("time", &self.time())
.field("flags", &self.flags())
.field("num_infos", &self.num_infos())
.field("pad", &10)
.field("full_sequence", &self.full_sequence())
.field("infos", &self.infos())
.finish()
}
}
impl base::WiredOut for HierarchyEvent {
fn wire_len(&self) -> usize {
32 + 4 * self.length() as usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for HierarchyEvent {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
32 + 4 * (*(ptr.add(4) as *const u32) as usize)
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_ge_generic_event_t;
std::ptr::copy(ptr as *const xcb_ge_generic_event_t, raw, sz);
HierarchyEvent { raw }
}
}
impl Drop for HierarchyEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for HierarchyEvent {}
unsafe impl Sync for HierarchyEvent {}
pub struct PropertyEvent {
raw: *mut xcb_ge_generic_event_t,
}
impl base::Raw<xcb_ge_generic_event_t> for PropertyEvent {
unsafe fn from_raw(raw: *mut xcb_ge_generic_event_t) -> Self { PropertyEvent { raw } }
fn as_raw(&self) -> *mut xcb_ge_generic_event_t {
self.raw
}
}
impl base::GeEvent for PropertyEvent {
const EXTENSION: ext::Extension = ext::Extension::Input;
const NUMBER: u32 = 12;
}
impl PropertyEvent {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn extension(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn event_type(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn property(&self) -> xproto::Atom {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Atom;
base::value_from_ptr(ptr)
}
}
pub fn what(&self) -> PropertyFlag {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, PropertyFlag>(val)
}
}
pub fn full_sequence(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
}
impl std::fmt::Debug for PropertyEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PropertyEvent")
.field("response_type", &self.response_type())
.field("extension", &self.extension())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("event_type", &self.event_type())
.field("device", &self.device())
.field("time", &self.time())
.field("property", &self.property())
.field("what", &self.what())
.field("pad", &11)
.field("full_sequence", &self.full_sequence())
.finish()
}
}
impl base::WiredOut for PropertyEvent {
fn wire_len(&self) -> usize {
32 + 4 * self.length() as usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for PropertyEvent {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
32 + 4 * (*(ptr.add(4) as *const u32) as usize)
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_ge_generic_event_t;
std::ptr::copy(ptr as *const xcb_ge_generic_event_t, raw, sz);
PropertyEvent { raw }
}
}
impl Drop for PropertyEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for PropertyEvent {}
unsafe impl Sync for PropertyEvent {}
pub struct RawKeyPressEvent {
raw: *mut xcb_ge_generic_event_t,
}
impl base::Raw<xcb_ge_generic_event_t> for RawKeyPressEvent {
unsafe fn from_raw(raw: *mut xcb_ge_generic_event_t) -> Self { RawKeyPressEvent { raw } }
fn as_raw(&self) -> *mut xcb_ge_generic_event_t {
self.raw
}
}
impl base::GeEvent for RawKeyPressEvent {
const EXTENSION: ext::Extension = ext::Extension::Input;
const NUMBER: u32 = 13;
}
impl RawKeyPressEvent {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn extension(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn event_type(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn detail(&self) -> u32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 20usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
fn valuators_len(&self) -> u16 {
unsafe {
let offset = 22usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn flags(&self) -> KeyEventFlags {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, KeyEventFlags>(val)
}
}
pub fn full_sequence(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn valuator_mask(&self) -> &[u32] {
unsafe {
let offset = 36usize;
let len = (self.valuators_len() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn axisvalues(&self) -> &[Fp3232] {
unsafe {
let offset = (36usize + ((self.valuators_len() as usize) * 4usize));
let len = (self.valuator_mask().iter().map(|el| el.count_ones()).sum::<u32>() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn axisvalues_raw(&self) -> &[Fp3232] {
unsafe {
let offset = ((36usize + ((self.valuators_len() as usize) * 4usize)) + ((self.valuator_mask().iter().map(|el| el.count_ones()).sum::<u32>() as usize) * 8usize));
let len = (self.valuator_mask().iter().map(|el| el.count_ones()).sum::<u32>() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl std::fmt::Debug for RawKeyPressEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RawKeyPressEvent")
.field("response_type", &self.response_type())
.field("extension", &self.extension())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("event_type", &self.event_type())
.field("device", &self.device())
.field("time", &self.time())
.field("detail", &self.detail())
.field("source", &self.source())
.field("valuators_len", &self.valuators_len())
.field("flags", &self.flags())
.field("pad", &4)
.field("full_sequence", &self.full_sequence())
.field("valuator_mask", &self.valuator_mask())
.field("axisvalues", &self.axisvalues())
.field("axisvalues_raw", &self.axisvalues_raw())
.finish()
}
}
impl base::WiredOut for RawKeyPressEvent {
fn wire_len(&self) -> usize {
32 + 4 * self.length() as usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for RawKeyPressEvent {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
32 + 4 * (*(ptr.add(4) as *const u32) as usize)
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_ge_generic_event_t;
std::ptr::copy(ptr as *const xcb_ge_generic_event_t, raw, sz);
RawKeyPressEvent { raw }
}
}
impl Drop for RawKeyPressEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for RawKeyPressEvent {}
unsafe impl Sync for RawKeyPressEvent {}
pub type RawKeyReleaseEvent = RawKeyPressEvent;
pub struct RawButtonPressEvent {
raw: *mut xcb_ge_generic_event_t,
}
impl base::Raw<xcb_ge_generic_event_t> for RawButtonPressEvent {
unsafe fn from_raw(raw: *mut xcb_ge_generic_event_t) -> Self { RawButtonPressEvent { raw } }
fn as_raw(&self) -> *mut xcb_ge_generic_event_t {
self.raw
}
}
impl base::GeEvent for RawButtonPressEvent {
const EXTENSION: ext::Extension = ext::Extension::Input;
const NUMBER: u32 = 15;
}
impl RawButtonPressEvent {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn extension(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn event_type(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn detail(&self) -> u32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 20usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
fn valuators_len(&self) -> u16 {
unsafe {
let offset = 22usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn flags(&self) -> PointerEventFlags {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, PointerEventFlags>(val)
}
}
pub fn full_sequence(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn valuator_mask(&self) -> &[u32] {
unsafe {
let offset = 36usize;
let len = (self.valuators_len() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn axisvalues(&self) -> &[Fp3232] {
unsafe {
let offset = (36usize + ((self.valuators_len() as usize) * 4usize));
let len = (self.valuator_mask().iter().map(|el| el.count_ones()).sum::<u32>() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn axisvalues_raw(&self) -> &[Fp3232] {
unsafe {
let offset = ((36usize + ((self.valuators_len() as usize) * 4usize)) + ((self.valuator_mask().iter().map(|el| el.count_ones()).sum::<u32>() as usize) * 8usize));
let len = (self.valuator_mask().iter().map(|el| el.count_ones()).sum::<u32>() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl std::fmt::Debug for RawButtonPressEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RawButtonPressEvent")
.field("response_type", &self.response_type())
.field("extension", &self.extension())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("event_type", &self.event_type())
.field("device", &self.device())
.field("time", &self.time())
.field("detail", &self.detail())
.field("source", &self.source())
.field("valuators_len", &self.valuators_len())
.field("flags", &self.flags())
.field("pad", &4)
.field("full_sequence", &self.full_sequence())
.field("valuator_mask", &self.valuator_mask())
.field("axisvalues", &self.axisvalues())
.field("axisvalues_raw", &self.axisvalues_raw())
.finish()
}
}
impl base::WiredOut for RawButtonPressEvent {
fn wire_len(&self) -> usize {
32 + 4 * self.length() as usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for RawButtonPressEvent {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
32 + 4 * (*(ptr.add(4) as *const u32) as usize)
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_ge_generic_event_t;
std::ptr::copy(ptr as *const xcb_ge_generic_event_t, raw, sz);
RawButtonPressEvent { raw }
}
}
impl Drop for RawButtonPressEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for RawButtonPressEvent {}
unsafe impl Sync for RawButtonPressEvent {}
pub type RawButtonReleaseEvent = RawButtonPressEvent;
pub type RawMotionEvent = RawButtonPressEvent;
pub struct TouchBeginEvent {
raw: *mut xcb_ge_generic_event_t,
}
impl base::Raw<xcb_ge_generic_event_t> for TouchBeginEvent {
unsafe fn from_raw(raw: *mut xcb_ge_generic_event_t) -> Self { TouchBeginEvent { raw } }
fn as_raw(&self) -> *mut xcb_ge_generic_event_t {
self.raw
}
}
impl base::GeEvent for TouchBeginEvent {
const EXTENSION: ext::Extension = ext::Extension::Input;
const NUMBER: u32 = 18;
}
impl TouchBeginEvent {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn extension(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn event_type(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn detail(&self) -> u32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn root(&self) -> xproto::Window {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn event(&self) -> xproto::Window {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn child(&self) -> xproto::Window {
unsafe {
let offset = 28usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn full_sequence(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn root_x(&self) -> Fp1616 {
unsafe {
let offset = 36usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn root_y(&self) -> Fp1616 {
unsafe {
let offset = 40usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn event_x(&self) -> Fp1616 {
unsafe {
let offset = 44usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn event_y(&self) -> Fp1616 {
unsafe {
let offset = 48usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
fn buttons_len(&self) -> u16 {
unsafe {
let offset = 52usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
fn valuators_len(&self) -> u16 {
unsafe {
let offset = 54usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 56usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn flags(&self) -> TouchEventFlags {
unsafe {
let offset = 60usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, TouchEventFlags>(val)
}
}
pub fn mods(&self) -> ModifierInfo {
unsafe {
let offset = 64usize;
let ptr = self.wire_ptr().add(offset) as *const ModifierInfo;
base::value_from_ptr(ptr)
}
}
pub fn group(&self) -> GroupInfo {
unsafe {
let offset = 80usize;
let ptr = self.wire_ptr().add(offset) as *const GroupInfo;
base::value_from_ptr(ptr)
}
}
pub fn button_mask(&self) -> &[u32] {
unsafe {
let offset = 84usize;
let len = (self.buttons_len() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn valuator_mask(&self) -> &[u32] {
unsafe {
let offset = (84usize + ((self.buttons_len() as usize) * 4usize));
let len = (self.valuators_len() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn axisvalues(&self) -> &[Fp3232] {
unsafe {
let offset = ((84usize + ((self.buttons_len() as usize) * 4usize)) + ((self.valuators_len() as usize) * 4usize));
let len = (self.valuator_mask().iter().map(|el| el.count_ones()).sum::<u32>() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl std::fmt::Debug for TouchBeginEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("TouchBeginEvent")
.field("response_type", &self.response_type())
.field("extension", &self.extension())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("event_type", &self.event_type())
.field("device", &self.device())
.field("time", &self.time())
.field("detail", &self.detail())
.field("root", &self.root())
.field("event", &self.event())
.field("child", &self.child())
.field("full_sequence", &self.full_sequence())
.field("root_x", &self.root_x())
.field("root_y", &self.root_y())
.field("event_x", &self.event_x())
.field("event_y", &self.event_y())
.field("buttons_len", &self.buttons_len())
.field("valuators_len", &self.valuators_len())
.field("source", &self.source())
.field("pad", &2)
.field("flags", &self.flags())
.field("mods", &self.mods())
.field("group", &self.group())
.field("button_mask", &self.button_mask())
.field("valuator_mask", &self.valuator_mask())
.field("axisvalues", &self.axisvalues())
.finish()
}
}
impl base::WiredOut for TouchBeginEvent {
fn wire_len(&self) -> usize {
32 + 4 * self.length() as usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for TouchBeginEvent {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
32 + 4 * (*(ptr.add(4) as *const u32) as usize)
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_ge_generic_event_t;
std::ptr::copy(ptr as *const xcb_ge_generic_event_t, raw, sz);
TouchBeginEvent { raw }
}
}
impl Drop for TouchBeginEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for TouchBeginEvent {}
unsafe impl Sync for TouchBeginEvent {}
pub type TouchUpdateEvent = TouchBeginEvent;
pub type TouchEndEvent = TouchBeginEvent;
pub struct TouchOwnershipEvent {
raw: *mut xcb_ge_generic_event_t,
}
impl base::Raw<xcb_ge_generic_event_t> for TouchOwnershipEvent {
unsafe fn from_raw(raw: *mut xcb_ge_generic_event_t) -> Self { TouchOwnershipEvent { raw } }
fn as_raw(&self) -> *mut xcb_ge_generic_event_t {
self.raw
}
}
impl base::GeEvent for TouchOwnershipEvent {
const EXTENSION: ext::Extension = ext::Extension::Input;
const NUMBER: u32 = 21;
}
impl TouchOwnershipEvent {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn extension(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn event_type(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn touchid(&self) -> u32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn root(&self) -> xproto::Window {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn event(&self) -> xproto::Window {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn child(&self) -> xproto::Window {
unsafe {
let offset = 28usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn full_sequence(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 36usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn flags(&self) -> TouchOwnershipFlags {
unsafe {
let offset = 40usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, TouchOwnershipFlags>(val)
}
}
}
impl std::fmt::Debug for TouchOwnershipEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("TouchOwnershipEvent")
.field("response_type", &self.response_type())
.field("extension", &self.extension())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("event_type", &self.event_type())
.field("device", &self.device())
.field("time", &self.time())
.field("touchid", &self.touchid())
.field("root", &self.root())
.field("event", &self.event())
.field("child", &self.child())
.field("full_sequence", &self.full_sequence())
.field("source", &self.source())
.field("pad", &2)
.field("flags", &self.flags())
.field("pad", &8)
.finish()
}
}
impl base::WiredOut for TouchOwnershipEvent {
fn wire_len(&self) -> usize {
32 + 4 * self.length() as usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for TouchOwnershipEvent {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
32 + 4 * (*(ptr.add(4) as *const u32) as usize)
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_ge_generic_event_t;
std::ptr::copy(ptr as *const xcb_ge_generic_event_t, raw, sz);
TouchOwnershipEvent { raw }
}
}
impl Drop for TouchOwnershipEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for TouchOwnershipEvent {}
unsafe impl Sync for TouchOwnershipEvent {}
pub struct RawTouchBeginEvent {
raw: *mut xcb_ge_generic_event_t,
}
impl base::Raw<xcb_ge_generic_event_t> for RawTouchBeginEvent {
unsafe fn from_raw(raw: *mut xcb_ge_generic_event_t) -> Self { RawTouchBeginEvent { raw } }
fn as_raw(&self) -> *mut xcb_ge_generic_event_t {
self.raw
}
}
impl base::GeEvent for RawTouchBeginEvent {
const EXTENSION: ext::Extension = ext::Extension::Input;
const NUMBER: u32 = 22;
}
impl RawTouchBeginEvent {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn extension(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn event_type(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn detail(&self) -> u32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 20usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
fn valuators_len(&self) -> u16 {
unsafe {
let offset = 22usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn flags(&self) -> TouchEventFlags {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, TouchEventFlags>(val)
}
}
pub fn full_sequence(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn valuator_mask(&self) -> &[u32] {
unsafe {
let offset = 36usize;
let len = (self.valuators_len() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn axisvalues(&self) -> &[Fp3232] {
unsafe {
let offset = (36usize + ((self.valuators_len() as usize) * 4usize));
let len = (self.valuator_mask().iter().map(|el| el.count_ones()).sum::<u32>() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn axisvalues_raw(&self) -> &[Fp3232] {
unsafe {
let offset = ((36usize + ((self.valuators_len() as usize) * 4usize)) + ((self.valuator_mask().iter().map(|el| el.count_ones()).sum::<u32>() as usize) * 8usize));
let len = (self.valuator_mask().iter().map(|el| el.count_ones()).sum::<u32>() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl std::fmt::Debug for RawTouchBeginEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RawTouchBeginEvent")
.field("response_type", &self.response_type())
.field("extension", &self.extension())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("event_type", &self.event_type())
.field("device", &self.device())
.field("time", &self.time())
.field("detail", &self.detail())
.field("source", &self.source())
.field("valuators_len", &self.valuators_len())
.field("flags", &self.flags())
.field("pad", &4)
.field("full_sequence", &self.full_sequence())
.field("valuator_mask", &self.valuator_mask())
.field("axisvalues", &self.axisvalues())
.field("axisvalues_raw", &self.axisvalues_raw())
.finish()
}
}
impl base::WiredOut for RawTouchBeginEvent {
fn wire_len(&self) -> usize {
32 + 4 * self.length() as usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for RawTouchBeginEvent {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
32 + 4 * (*(ptr.add(4) as *const u32) as usize)
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_ge_generic_event_t;
std::ptr::copy(ptr as *const xcb_ge_generic_event_t, raw, sz);
RawTouchBeginEvent { raw }
}
}
impl Drop for RawTouchBeginEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for RawTouchBeginEvent {}
unsafe impl Sync for RawTouchBeginEvent {}
pub type RawTouchUpdateEvent = RawTouchBeginEvent;
pub type RawTouchEndEvent = RawTouchBeginEvent;
pub struct BarrierHitEvent {
raw: *mut xcb_ge_generic_event_t,
}
impl base::Raw<xcb_ge_generic_event_t> for BarrierHitEvent {
unsafe fn from_raw(raw: *mut xcb_ge_generic_event_t) -> Self { BarrierHitEvent { raw } }
fn as_raw(&self) -> *mut xcb_ge_generic_event_t {
self.raw
}
}
impl base::GeEvent for BarrierHitEvent {
const EXTENSION: ext::Extension = ext::Extension::Input;
const NUMBER: u32 = 25;
}
impl BarrierHitEvent {
fn wire_ptr(&self) -> *const u8 { self.raw as *const u8 }
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn extension(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn event_type(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn eventid(&self) -> u32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn root(&self) -> xproto::Window {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn event(&self) -> xproto::Window {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn barrier(&self) -> xfixes::Barrier {
unsafe {
let offset = 28usize;
let ptr = self.wire_ptr().add(offset) as *const xfixes::Barrier;
base::value_from_ptr(ptr)
}
}
pub fn full_sequence(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn dtime(&self) -> u32 {
unsafe {
let offset = 36usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn flags(&self) -> BarrierFlags {
unsafe {
let offset = 40usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, BarrierFlags>(val)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 44usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn root_x(&self) -> Fp1616 {
unsafe {
let offset = 48usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn root_y(&self) -> Fp1616 {
unsafe {
let offset = 52usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn dx(&self) -> Fp3232 {
unsafe {
let offset = 56usize;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
base::value_from_ptr(ptr)
}
}
pub fn dy(&self) -> Fp3232 {
unsafe {
let offset = 64usize;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
base::value_from_ptr(ptr)
}
}
}
impl std::fmt::Debug for BarrierHitEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BarrierHitEvent")
.field("response_type", &self.response_type())
.field("extension", &self.extension())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("event_type", &self.event_type())
.field("device", &self.device())
.field("time", &self.time())
.field("eventid", &self.eventid())
.field("root", &self.root())
.field("event", &self.event())
.field("barrier", &self.barrier())
.field("full_sequence", &self.full_sequence())
.field("dtime", &self.dtime())
.field("flags", &self.flags())
.field("source", &self.source())
.field("pad", &2)
.field("root_x", &self.root_x())
.field("root_y", &self.root_y())
.field("dx", &self.dx())
.field("dy", &self.dy())
.finish()
}
}
impl base::WiredOut for BarrierHitEvent {
fn wire_len(&self) -> usize {
32 + 4 * self.length() as usize
}
fn serialize(&self, wire_buf: &mut[u8]) -> usize {
debug_assert!(wire_buf.len() >= self.wire_len());
let raw_slice = unsafe { std::slice::from_raw_parts(self.raw as *const u8, self.wire_len()) };
wire_buf[0 .. self.wire_len()].copy_from_slice(raw_slice);
self.wire_len()
}
}
impl base::WiredIn for BarrierHitEvent {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
32 + 4 * (*(ptr.add(4) as *const u32) as usize)
}
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, ());
*offset += sz;
let raw = libc::malloc(sz) as *mut xcb_ge_generic_event_t;
std::ptr::copy(ptr as *const xcb_ge_generic_event_t, raw, sz);
BarrierHitEvent { raw }
}
}
impl Drop for BarrierHitEvent {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl Send for BarrierHitEvent {}
unsafe impl Sync for BarrierHitEvent {}
pub type BarrierLeaveEvent = BarrierHitEvent;
#[derive(Debug)]
pub enum Event {
DeviceValuator(DeviceValuatorEvent),
DeviceKeyPress(DeviceKeyPressEvent),
DeviceKeyRelease(DeviceKeyReleaseEvent),
DeviceButtonPress(DeviceButtonPressEvent),
DeviceButtonRelease(DeviceButtonReleaseEvent),
DeviceMotionNotify(DeviceMotionNotifyEvent),
DeviceFocusIn(DeviceFocusInEvent),
DeviceFocusOut(DeviceFocusOutEvent),
ProximityIn(ProximityInEvent),
ProximityOut(ProximityOutEvent),
DeviceStateNotify(DeviceStateNotifyEvent),
DeviceMappingNotify(DeviceMappingNotifyEvent),
ChangeDeviceNotify(ChangeDeviceNotifyEvent),
DeviceKeyStateNotify(DeviceKeyStateNotifyEvent),
DeviceButtonStateNotify(DeviceButtonStateNotifyEvent),
DevicePresenceNotify(DevicePresenceNotifyEvent),
DevicePropertyNotify(DevicePropertyNotifyEvent),
DeviceChanged(DeviceChangedEvent),
KeyPress(KeyPressEvent),
KeyRelease(KeyReleaseEvent),
ButtonPress(ButtonPressEvent),
ButtonRelease(ButtonReleaseEvent),
Motion(MotionEvent),
Enter(EnterEvent),
Leave(LeaveEvent),
FocusIn(FocusInEvent),
FocusOut(FocusOutEvent),
Hierarchy(HierarchyEvent),
Property(PropertyEvent),
RawKeyPress(RawKeyPressEvent),
RawKeyRelease(RawKeyReleaseEvent),
RawButtonPress(RawButtonPressEvent),
RawButtonRelease(RawButtonReleaseEvent),
RawMotion(RawMotionEvent),
TouchBegin(TouchBeginEvent),
TouchUpdate(TouchUpdateEvent),
TouchEnd(TouchEndEvent),
TouchOwnership(TouchOwnershipEvent),
RawTouchBegin(RawTouchBeginEvent),
RawTouchUpdate(RawTouchUpdateEvent),
RawTouchEnd(RawTouchEndEvent),
BarrierHit(BarrierHitEvent),
BarrierLeave(BarrierLeaveEvent),
}
impl Event {
pub fn as_raw(&self) -> *mut xcb_generic_event_t {
match self {
Self::DeviceValuator(e) => e.as_raw(),
Self::DeviceKeyPress(e) => e.as_raw(),
Self::DeviceKeyRelease(e) => e.as_raw(),
Self::DeviceButtonPress(e) => e.as_raw(),
Self::DeviceButtonRelease(e) => e.as_raw(),
Self::DeviceMotionNotify(e) => e.as_raw(),
Self::DeviceFocusIn(e) => e.as_raw(),
Self::DeviceFocusOut(e) => e.as_raw(),
Self::ProximityIn(e) => e.as_raw(),
Self::ProximityOut(e) => e.as_raw(),
Self::DeviceStateNotify(e) => e.as_raw(),
Self::DeviceMappingNotify(e) => e.as_raw(),
Self::ChangeDeviceNotify(e) => e.as_raw(),
Self::DeviceKeyStateNotify(e) => e.as_raw(),
Self::DeviceButtonStateNotify(e) => e.as_raw(),
Self::DevicePresenceNotify(e) => e.as_raw(),
Self::DevicePropertyNotify(e) => e.as_raw(),
Self::DeviceChanged(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::KeyPress(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::KeyRelease(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::ButtonPress(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::ButtonRelease(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::Motion(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::Enter(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::Leave(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::FocusIn(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::FocusOut(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::Hierarchy(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::Property(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::RawKeyPress(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::RawKeyRelease(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::RawButtonPress(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::RawButtonRelease(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::RawMotion(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::TouchBegin(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::TouchUpdate(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::TouchEnd(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::TouchOwnership(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::RawTouchBegin(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::RawTouchUpdate(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::RawTouchEnd(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::BarrierHit(e) => e.as_raw() as *mut xcb_generic_event_t,
Self::BarrierLeave(e) => e.as_raw() as *mut xcb_generic_event_t,
}
}
}
impl base::ResolveWireEvent for Event {
unsafe fn resolve_wire_event(first_event: u8, raw: *mut xcb_generic_event_t) -> std::option::Option<Self> {
debug_assert!(!raw.is_null());
let response_type = (*raw).response_type & 0x7F;
debug_assert!(response_type != 0, "This is not an event but an error!");
debug_assert!(response_type != XCB_GE_GENERIC, "This is a GE_GENERIC event!");
match response_type - first_event {
0 => Some(Event::DeviceValuator(DeviceValuatorEvent::from_raw(raw))),
1 => Some(Event::DeviceKeyPress(DeviceKeyPressEvent::from_raw(raw))),
2 => Some(Event::DeviceKeyRelease(DeviceKeyReleaseEvent::from_raw(raw))),
3 => Some(Event::DeviceButtonPress(DeviceButtonPressEvent::from_raw(raw))),
4 => Some(Event::DeviceButtonRelease(DeviceButtonReleaseEvent::from_raw(raw))),
5 => Some(Event::DeviceMotionNotify(DeviceMotionNotifyEvent::from_raw(raw))),
6 => Some(Event::DeviceFocusIn(DeviceFocusInEvent::from_raw(raw))),
7 => Some(Event::DeviceFocusOut(DeviceFocusOutEvent::from_raw(raw))),
8 => Some(Event::ProximityIn(ProximityInEvent::from_raw(raw))),
9 => Some(Event::ProximityOut(ProximityOutEvent::from_raw(raw))),
10 => Some(Event::DeviceStateNotify(DeviceStateNotifyEvent::from_raw(raw))),
11 => Some(Event::DeviceMappingNotify(DeviceMappingNotifyEvent::from_raw(raw))),
12 => Some(Event::ChangeDeviceNotify(ChangeDeviceNotifyEvent::from_raw(raw))),
13 => Some(Event::DeviceKeyStateNotify(DeviceKeyStateNotifyEvent::from_raw(raw))),
14 => Some(Event::DeviceButtonStateNotify(DeviceButtonStateNotifyEvent::from_raw(raw))),
15 => Some(Event::DevicePresenceNotify(DevicePresenceNotifyEvent::from_raw(raw))),
16 => Some(Event::DevicePropertyNotify(DevicePropertyNotifyEvent::from_raw(raw))),
_ => None,
}
}
}
impl base::ResolveWireGeEvent for Event {
unsafe fn resolve_wire_ge_event(raw: *mut xcb_ge_generic_event_t) -> Self{
debug_assert!(!raw.is_null());
debug_assert!(((*raw).response_type & 0x7F) == XCB_GE_GENERIC);
let event_type = (*raw).event_type;
match event_type {
1 => Event::DeviceChanged(DeviceChangedEvent::from_raw(raw)),
2 => Event::KeyPress(KeyPressEvent::from_raw(raw)),
3 => Event::KeyRelease(KeyReleaseEvent::from_raw(raw)),
4 => Event::ButtonPress(ButtonPressEvent::from_raw(raw)),
5 => Event::ButtonRelease(ButtonReleaseEvent::from_raw(raw)),
6 => Event::Motion(MotionEvent::from_raw(raw)),
7 => Event::Enter(EnterEvent::from_raw(raw)),
8 => Event::Leave(LeaveEvent::from_raw(raw)),
9 => Event::FocusIn(FocusInEvent::from_raw(raw)),
10 => Event::FocusOut(FocusOutEvent::from_raw(raw)),
11 => Event::Hierarchy(HierarchyEvent::from_raw(raw)),
12 => Event::Property(PropertyEvent::from_raw(raw)),
13 => Event::RawKeyPress(RawKeyPressEvent::from_raw(raw)),
14 => Event::RawKeyRelease(RawKeyReleaseEvent::from_raw(raw)),
15 => Event::RawButtonPress(RawButtonPressEvent::from_raw(raw)),
16 => Event::RawButtonRelease(RawButtonReleaseEvent::from_raw(raw)),
17 => Event::RawMotion(RawMotionEvent::from_raw(raw)),
18 => Event::TouchBegin(TouchBeginEvent::from_raw(raw)),
19 => Event::TouchUpdate(TouchUpdateEvent::from_raw(raw)),
20 => Event::TouchEnd(TouchEndEvent::from_raw(raw)),
21 => Event::TouchOwnership(TouchOwnershipEvent::from_raw(raw)),
22 => Event::RawTouchBegin(RawTouchBeginEvent::from_raw(raw)),
23 => Event::RawTouchUpdate(RawTouchUpdateEvent::from_raw(raw)),
24 => Event::RawTouchEnd(RawTouchEndEvent::from_raw(raw)),
25 => Event::BarrierHit(BarrierHitEvent::from_raw(raw)),
26 => Event::BarrierLeave(BarrierLeaveEvent::from_raw(raw)),
_ => panic!("Could not resolve GE event for xinput: {}", event_type),
}
}
}
pub type EventClass = u32;
pub type KeyCode = u8;
pub type Fp1616 = i32;
#[derive(Copy, Clone, Debug)]
#[repr(C)]
pub struct Fp3232 {
pub integral: i32,
pub frac: u32,
}
#[test]
fn test_sizeof_fp3232() {
assert_eq!(std::mem::size_of::<Fp3232>(), 8);
}
impl base::WiredOut for Fp3232 {
fn wire_len(&self) -> usize { 8 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let me = unsafe {
std::slice::from_raw_parts(self as *const Fp3232 as _, 8)
};
(&mut wire_buf[..me.len()]).copy_from_slice(me);
8
}
}
impl base::WiredIn for Fp3232 {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 8 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 8;
*(ptr as *const Fp3232)
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum DeviceUse {
IsXPointer = 0,
IsXKeyboard = 1,
IsXExtensionDevice = 2,
IsXExtensionKeyboard = 3,
IsXExtensionPointer = 4,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum InputClass {
Key = 0,
Button = 1,
Valuator = 2,
Feedback = 3,
Proximity = 4,
Focus = 5,
Other = 6,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum ValuatorMode {
Relative = 0,
Absolute = 1,
}
#[derive(Copy, Clone)]
pub struct DeviceInfo {
data: [u8; 8],
}
#[allow(unused_parens)]
impl DeviceInfo {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceInfo {
debug_assert_eq!(data.as_ref().len(), 8);
&*(data.as_ref() as *const [u8] as *const DeviceInfo)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
device_type: xproto::Atom,
device_id: u8,
num_class_info: u8,
device_use: DeviceUse,
) -> DeviceInfo {
unsafe {
let mut wire_buf = [0u8; 8];
let mut wire_off = 0usize;
wire_off += device_type.serialize(&mut wire_buf[wire_off .. ]);
wire_off += device_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += num_class_info.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (std::mem::transmute::<_, u32>(device_use) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += 1; DeviceInfo { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn device_type(&self) -> xproto::Atom {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Atom;
base::value_from_ptr(ptr)
}
}
pub fn device_id(&self) -> u8 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn num_class_info(&self) -> u8 {
unsafe {
let offset = 5usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn device_use(&self) -> DeviceUse {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceUse>(val)
}
}
}
#[test]
fn test_sizeof_device_info() {
assert_eq!(std::mem::size_of::<DeviceInfo>(), 8);
}
impl base::WiredOut for DeviceInfo {
fn wire_len(&self) -> usize { 8 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for DeviceInfo {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 8 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 8;
*(ptr as *const DeviceInfo)
}
}
impl std::fmt::Debug for DeviceInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceInfo")
.field("device_type", &self.device_type())
.field("device_id", &self.device_id())
.field("num_class_info", &self.num_class_info())
.field("device_use", &self.device_use())
.field("pad", &1)
.finish()
}
}
#[derive(Copy, Clone)]
pub struct KeyInfo {
data: [u8; 8],
}
#[allow(unused_parens)]
impl KeyInfo {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &KeyInfo {
debug_assert_eq!(data.as_ref().len(), 8);
&*(data.as_ref() as *const [u8] as *const KeyInfo)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: InputClass,
len: u8,
min_keycode: KeyCode,
max_keycode: KeyCode,
num_keys: u16,
) -> KeyInfo {
unsafe {
let mut wire_buf = [0u8; 8];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += min_keycode.serialize(&mut wire_buf[wire_off .. ]);
wire_off += max_keycode.serialize(&mut wire_buf[wire_off .. ]);
wire_off += num_keys.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 2; KeyInfo { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> InputClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, InputClass>(val)
}
}
pub fn len(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn min_keycode(&self) -> KeyCode {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const KeyCode;
base::value_from_ptr(ptr)
}
}
pub fn max_keycode(&self) -> KeyCode {
unsafe {
let offset = 3usize;
let ptr = self.wire_ptr().add(offset) as *const KeyCode;
base::value_from_ptr(ptr)
}
}
pub fn num_keys(&self) -> u16 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_key_info() {
assert_eq!(std::mem::size_of::<KeyInfo>(), 8);
}
impl base::WiredOut for KeyInfo {
fn wire_len(&self) -> usize { 8 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for KeyInfo {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 8 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 8;
*(ptr as *const KeyInfo)
}
}
impl std::fmt::Debug for KeyInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("KeyInfo")
.field("class_id", &self.class_id())
.field("len", &self.len())
.field("min_keycode", &self.min_keycode())
.field("max_keycode", &self.max_keycode())
.field("num_keys", &self.num_keys())
.field("pad", &2)
.finish()
}
}
#[derive(Copy, Clone)]
pub struct ButtonInfo {
data: [u8; 4],
}
#[allow(unused_parens)]
impl ButtonInfo {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &ButtonInfo {
debug_assert_eq!(data.as_ref().len(), 4);
&*(data.as_ref() as *const [u8] as *const ButtonInfo)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: InputClass,
len: u8,
num_buttons: u16,
) -> ButtonInfo {
unsafe {
let mut wire_buf = [0u8; 4];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += num_buttons.serialize(&mut wire_buf[wire_off .. ]);
ButtonInfo { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> InputClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, InputClass>(val)
}
}
pub fn len(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn num_buttons(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_button_info() {
assert_eq!(std::mem::size_of::<ButtonInfo>(), 4);
}
impl base::WiredOut for ButtonInfo {
fn wire_len(&self) -> usize { 4 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for ButtonInfo {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 4 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 4;
*(ptr as *const ButtonInfo)
}
}
impl std::fmt::Debug for ButtonInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ButtonInfo")
.field("class_id", &self.class_id())
.field("len", &self.len())
.field("num_buttons", &self.num_buttons())
.finish()
}
}
#[derive(Copy, Clone, Debug)]
#[repr(C)]
pub struct AxisInfo {
pub resolution: u32,
pub minimum: i32,
pub maximum: i32,
}
#[test]
fn test_sizeof_axis_info() {
assert_eq!(std::mem::size_of::<AxisInfo>(), 12);
}
impl base::WiredOut for AxisInfo {
fn wire_len(&self) -> usize { 12 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let me = unsafe {
std::slice::from_raw_parts(self as *const AxisInfo as _, 12)
};
(&mut wire_buf[..me.len()]).copy_from_slice(me);
12
}
}
impl base::WiredIn for AxisInfo {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 12 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 12;
*(ptr as *const AxisInfo)
}
}
pub struct ValuatorInfo {
data: [u8],
}
#[allow(unused_parens)]
impl ValuatorInfo {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &ValuatorInfo {
debug_assert_eq!(data.as_ref().len(), <&ValuatorInfo as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const ValuatorInfo)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn class_id(&self) -> InputClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, InputClass>(val)
}
}
pub fn len(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
fn axes_len(&self) -> u8 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn mode(&self) -> ValuatorMode {
unsafe {
let offset = 3usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, ValuatorMode>(val)
}
}
pub fn motion_size(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn axes(&self) -> &[AxisInfo] {
unsafe {
let offset = 8usize;
let len = (self.axes_len() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const AxisInfo;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::WiredOut for ValuatorInfo {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &ValuatorInfo {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
let axes_len = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 1usize;
sz += 4usize;
sz += ((axes_len as usize) * 12usize);
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
ValuatorInfo::from_data(data)
}
}
#[derive(Clone)]
pub struct ValuatorInfoBuf {
data: Vec<u8>,
}
impl ValuatorInfoBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> ValuatorInfoBuf {
debug_assert_eq!(<&ValuatorInfo>::compute_wire_len(data.as_ptr(), ()), data.len());
ValuatorInfoBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: InputClass,
len: u8,
mode: ValuatorMode,
motion_size: u32,
axes: &[AxisInfo],
) -> ValuatorInfoBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 1; wire_sz += 1; wire_sz += 1; wire_sz += 1; wire_sz += 4; wire_sz += axes.iter().map(|el| el.wire_len()).sum::<usize>();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (axes.len() as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += (std::mem::transmute::<_, u32>(mode) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += motion_size.serialize(&mut wire_buf[wire_off .. ]);
for el in axes {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
ValuatorInfoBuf { data: wire_buf }
}
}
}
impl base::WiredIn for ValuatorInfoBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&ValuatorInfo>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
ValuatorInfoBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for ValuatorInfoBuf {
type Target = ValuatorInfo;
fn deref(&self) -> &Self::Target {
unsafe { ValuatorInfo::from_data(&self.data) }
}
}
impl std::borrow::Borrow<ValuatorInfo> for ValuatorInfoBuf {
fn borrow(&self) -> &ValuatorInfo {
unsafe { ValuatorInfo::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for ValuatorInfo {
type Owned = ValuatorInfoBuf;
fn to_owned(&self) -> Self::Owned {
ValuatorInfoBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for ValuatorInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ValuatorInfo")
.field("class_id", &self.class_id())
.field("len", &self.len())
.field("axes_len", &self.axes_len())
.field("mode", &self.mode())
.field("motion_size", &self.motion_size())
.field("axes", &self.axes())
.finish()
}
}
impl std::fmt::Debug for ValuatorInfoBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ValuatorInfoBuf")
.field("class_id", &self.class_id())
.field("len", &self.len())
.field("axes_len", &self.axes_len())
.field("mode", &self.mode())
.field("motion_size", &self.motion_size())
.field("axes", &self.axes())
.finish()
}
}
#[derive(Clone)]
pub struct ValuatorInfoIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a ValuatorInfo>,
}
impl<'a> Iterator for ValuatorInfoIterator<'a> {
type Item = &'a ValuatorInfo;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&ValuatorInfo>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for ValuatorInfoIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone, Debug)]
pub struct InputInfoInfoParams {
pub class_id: usize,
}
#[derive(Clone, Debug)]
pub enum InputInfoInfo {
Key{
min_keycode: KeyCode,
max_keycode: KeyCode,
num_keys: u16,
},
Button(u16),
Valuator{
mode: ValuatorMode,
motion_size: u32,
axes: Vec<AxisInfo>,
},
}
impl InputInfoInfo {
pub(crate) fn get_enum(&self) -> InputClass {
match self {
InputInfoInfo::Key{..} => {
InputClass::Key
}
InputInfoInfo::Button{..} => {
InputClass::Button
}
InputInfoInfo::Valuator{..} => {
InputClass::Valuator
}
}
}
}
impl base::WiredOut for InputInfoInfo {
fn wire_len(&self) -> usize {
let mut sz = 0usize;
match self {
InputInfoInfo::Key{
..
} => {
sz += 1;
sz += 1;
sz += 2;
sz += 2;
}
InputInfoInfo::Button(
..
) => {
sz += 2;
}
InputInfoInfo::Valuator{
axes,
..
} => {
sz += 1;
sz += 1;
sz += 4;
for el in axes {
sz += el.wire_len();
}
}
}
sz
}
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let mut offset = 0usize;
match self {
InputInfoInfo::Key{
min_keycode,
max_keycode,
num_keys,
..
} => {
offset += min_keycode.serialize(&mut wire_buf[offset..]);
offset += max_keycode.serialize(&mut wire_buf[offset..]);
offset += num_keys.serialize(&mut wire_buf[offset..]);
offset += 2;
}
InputInfoInfo::Button(
num_buttons,
..
) => {
offset += num_buttons.serialize(&mut wire_buf[offset..]);
}
InputInfoInfo::Valuator{
mode,
motion_size,
axes,
..
} => {
offset += (axes.len() as u8).serialize(&mut wire_buf[offset..]);
offset += (unsafe { std::mem::transmute::<_, u32>(*mode) } as u8).serialize(&mut wire_buf[offset..]);
offset += motion_size.serialize(&mut wire_buf[offset..]);
for el in axes {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
}
offset
}
}
impl base::WiredIn for InputInfoInfo {
type Params = InputInfoInfoParams;
unsafe fn compute_wire_len(ptr: *const u8, params: Self::Params) -> usize {
let InputInfoInfoParams {
class_id,
} = params;
let expr = (class_id as usize);
if expr == (InputClass::Key as usize) {
let mut sz = 0usize;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 2usize;
return sz;
}
if expr == (InputClass::Button as usize) {
let mut sz = 0usize;
sz += 2usize;
return sz;
}
if expr == (InputClass::Valuator as usize) {
let mut sz = 0usize;
let axes_len = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 1usize;
sz += 4usize;
sz += ((axes_len as usize) * 12usize);
return sz;
}
unreachable!("could not match switch expression in xinput::InputInfoInfo::compute_wire_len")
}
#[allow(unused_assignments)]
unsafe fn unserialize(wire_data: *const u8, params: InputInfoInfoParams, out_offset: &mut usize) -> InputInfoInfo {
let InputInfoInfoParams{
class_id,
} = params;
let expr = (class_id as usize);
if expr == (InputClass::Key as usize) {
let mut offset = 0usize;
let min_keycode = *(wire_data.add(offset) as *const KeyCode);
offset += std::mem::size_of::<KeyCode>();
let max_keycode = *(wire_data.add(offset) as *const KeyCode);
offset += std::mem::size_of::<KeyCode>();
let num_keys = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
offset += 2; *out_offset += offset;
return InputInfoInfo::Key{
min_keycode,
max_keycode,
num_keys,
};
}
if expr == (InputClass::Button as usize) {
let mut offset = 0usize;
let num_buttons = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
*out_offset += offset;
return InputInfoInfo::Button(
num_buttons,
);
}
if expr == (InputClass::Valuator as usize) {
let mut offset = 0usize;
let axes_len = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
let mode = std::mem::transmute::<_, ValuatorMode>(*(wire_data.add(offset) as *const u8) as u32);
offset += 1;
let motion_size = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let axes = {
let ptr = wire_data.add(offset) as *const AxisInfo;
let len = (axes_len as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<AxisInfo>();
data.to_vec()
};
*out_offset += offset;
return InputInfoInfo::Valuator{
mode,
motion_size,
axes,
};
}
unreachable!("Could not match any expression for InputInfoInfo");
}
}
pub struct InputInfo {
data: [u8],
}
#[allow(unused_parens)]
impl InputInfo {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &InputInfo {
debug_assert_eq!(data.as_ref().len(), <&InputInfo as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const InputInfo)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn class_id(&self) -> InputClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, InputClass>(val)
}
}
pub fn len(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn info(&self) -> InputInfoInfo {
let class_id = self.class_id();
let params = InputInfoInfoParams {class_id: class_id as usize};
let mut offset = 2usize;
unsafe {
InputInfoInfo::unserialize(
self.wire_ptr().add(offset), params, &mut offset
)
}
}
}
impl base::WiredOut for InputInfo {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &InputInfo {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
let class_id = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 1usize;
sz += InputInfoInfo::compute_wire_len(ptr.add(sz), InputInfoInfoParams {class_id: class_id as usize});
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
InputInfo::from_data(data)
}
}
#[derive(Clone)]
pub struct InputInfoBuf {
data: Vec<u8>,
}
impl InputInfoBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> InputInfoBuf {
debug_assert_eq!(<&InputInfo>::compute_wire_len(data.as_ptr(), ()), data.len());
InputInfoBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
len: u8,
info: InputInfoInfo,
) -> InputInfoBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 1; wire_sz += 1; wire_sz += info.wire_len();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(info.get_enum()) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += info.serialize(&mut wire_buf[wire_off ..]);
InputInfoBuf { data: wire_buf }
}
}
}
impl base::WiredIn for InputInfoBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&InputInfo>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
InputInfoBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for InputInfoBuf {
type Target = InputInfo;
fn deref(&self) -> &Self::Target {
unsafe { InputInfo::from_data(&self.data) }
}
}
impl std::borrow::Borrow<InputInfo> for InputInfoBuf {
fn borrow(&self) -> &InputInfo {
unsafe { InputInfo::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for InputInfo {
type Owned = InputInfoBuf;
fn to_owned(&self) -> Self::Owned {
InputInfoBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for InputInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("InputInfo")
.field("class_id", &self.class_id())
.field("len", &self.len())
.field("info", &self.info())
.finish()
}
}
impl std::fmt::Debug for InputInfoBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("InputInfoBuf")
.field("class_id", &self.class_id())
.field("len", &self.len())
.field("info", &self.info())
.finish()
}
}
#[derive(Clone)]
pub struct InputInfoIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a InputInfo>,
}
impl<'a> Iterator for InputInfoIterator<'a> {
type Item = &'a InputInfo;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&InputInfo>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for InputInfoIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
pub struct DeviceName {
data: [u8],
}
#[allow(unused_parens)]
impl DeviceName {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceName {
debug_assert_eq!(data.as_ref().len(), <&DeviceName as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const DeviceName)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn len(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn string(&self) -> &Lat1Str {
unsafe {
let offset = 1usize;
let len = (self.len() as usize) as _;
let ptr = self.wire_ptr().add(offset);
let bytes = std::slice::from_raw_parts(ptr, len);
Lat1Str::from_bytes(bytes)
}
}
}
impl base::WiredOut for DeviceName {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &DeviceName {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
let len = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += (len as usize);
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceName::from_data(data)
}
}
#[derive(Clone)]
pub struct DeviceNameBuf {
data: Vec<u8>,
}
impl DeviceNameBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> DeviceNameBuf {
debug_assert_eq!(<&DeviceName>::compute_wire_len(data.as_ptr(), ()), data.len());
DeviceNameBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
string: &[u8],
) -> DeviceNameBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 1; wire_sz += string.len();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (string.len() as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_buf[wire_off .. wire_off + string.len()].copy_from_slice(string);
wire_off += string.len();
DeviceNameBuf { data: wire_buf }
}
}
}
impl base::WiredIn for DeviceNameBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&DeviceName>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceNameBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for DeviceNameBuf {
type Target = DeviceName;
fn deref(&self) -> &Self::Target {
unsafe { DeviceName::from_data(&self.data) }
}
}
impl std::borrow::Borrow<DeviceName> for DeviceNameBuf {
fn borrow(&self) -> &DeviceName {
unsafe { DeviceName::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for DeviceName {
type Owned = DeviceNameBuf;
fn to_owned(&self) -> Self::Owned {
DeviceNameBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for DeviceName {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceName")
.field("len", &self.len())
.field("string", &self.string())
.finish()
}
}
impl std::fmt::Debug for DeviceNameBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceNameBuf")
.field("len", &self.len())
.field("string", &self.string())
.finish()
}
}
#[derive(Clone)]
pub struct DeviceNameIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a DeviceName>,
}
impl<'a> Iterator for DeviceNameIterator<'a> {
type Item = &'a DeviceName;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&DeviceName>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for DeviceNameIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
pub type EventTypeBase = u8;
#[derive(Copy, Clone)]
pub struct InputClassInfo {
data: [u8; 2],
}
#[allow(unused_parens)]
impl InputClassInfo {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &InputClassInfo {
debug_assert_eq!(data.as_ref().len(), 2);
&*(data.as_ref() as *const [u8] as *const InputClassInfo)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: InputClass,
event_type_base: EventTypeBase,
) -> InputClassInfo {
unsafe {
let mut wire_buf = [0u8; 2];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += event_type_base.serialize(&mut wire_buf[wire_off .. ]);
InputClassInfo { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> InputClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, InputClass>(val)
}
}
pub fn event_type_base(&self) -> EventTypeBase {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const EventTypeBase;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_input_class_info() {
assert_eq!(std::mem::size_of::<InputClassInfo>(), 2);
}
impl base::WiredOut for InputClassInfo {
fn wire_len(&self) -> usize { 2 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for InputClassInfo {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 2 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 2;
*(ptr as *const InputClassInfo)
}
}
impl std::fmt::Debug for InputClassInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("InputClassInfo")
.field("class_id", &self.class_id())
.field("event_type_base", &self.event_type_base())
.finish()
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum PropagateMode {
AddToList = 0,
DeleteFromList = 1,
}
#[derive(Copy, Clone, Debug)]
pub struct DeviceTimeCoordParams {
pub num_axes: usize,
}
pub struct DeviceTimeCoord {
data: [u8],
}
#[allow(unused_parens)]
impl DeviceTimeCoord {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceTimeCoord {
&*(data.as_ref() as *const [u8] as *const DeviceTimeCoord)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn axisvalues(&self, num_axes: usize) -> &[i32] {
unsafe {
let offset = 4usize;
let len = num_axes;
let ptr = self.wire_ptr().add(offset) as *const i32;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::WiredOut for DeviceTimeCoord {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &DeviceTimeCoord {
type Params = DeviceTimeCoordParams;
unsafe fn compute_wire_len(ptr: *const u8, params: DeviceTimeCoordParams) -> usize {
let DeviceTimeCoordParams {
num_axes,
} = params;
let mut sz = 0;
sz += 4usize;
sz += (num_axes * 4usize);
sz
}
unsafe fn unserialize(ptr: *const u8, params: DeviceTimeCoordParams, offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceTimeCoord::from_data(data)
}
}
#[derive(Clone)]
pub struct DeviceTimeCoordBuf {
data: Vec<u8>,
}
impl DeviceTimeCoordBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> DeviceTimeCoordBuf {
DeviceTimeCoordBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
time: xproto::Timestamp,
axisvalues: &[i32],
) -> DeviceTimeCoordBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 4; wire_sz += axisvalues.iter().map(|el| el.wire_len()).sum::<usize>();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += time.serialize(&mut wire_buf[wire_off .. ]);
for el in axisvalues {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
DeviceTimeCoordBuf { data: wire_buf }
}
}
}
impl base::WiredIn for DeviceTimeCoordBuf {
type Params = DeviceTimeCoordParams;
unsafe fn compute_wire_len(ptr: *const u8, params: DeviceTimeCoordParams) -> usize {
<&DeviceTimeCoord>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: DeviceTimeCoordParams, offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceTimeCoordBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for DeviceTimeCoordBuf {
type Target = DeviceTimeCoord;
fn deref(&self) -> &Self::Target {
unsafe { DeviceTimeCoord::from_data(&self.data) }
}
}
impl std::borrow::Borrow<DeviceTimeCoord> for DeviceTimeCoordBuf {
fn borrow(&self) -> &DeviceTimeCoord {
unsafe { DeviceTimeCoord::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for DeviceTimeCoord {
type Owned = DeviceTimeCoordBuf;
fn to_owned(&self) -> Self::Owned {
DeviceTimeCoordBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for DeviceTimeCoord {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceTimeCoord")
.field("time", &self.time())
.finish()
}
}
impl std::fmt::Debug for DeviceTimeCoordBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceTimeCoordBuf")
.field("time", &self.time())
.finish()
}
}
#[derive(Clone)]
pub struct DeviceTimeCoordIterator<'a> {
pub(crate) params: DeviceTimeCoordParams,
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a DeviceTimeCoord>,
}
impl<'a> Iterator for DeviceTimeCoordIterator<'a> {
type Item = &'a DeviceTimeCoord;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&DeviceTimeCoord>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for DeviceTimeCoordIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum ModifierDevice {
UseXKeyboard = 255,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum DeviceInputMode {
AsyncThisDevice = 0,
SyncThisDevice = 1,
ReplayThisDevice = 2,
AsyncOtherDevices = 3,
AsyncAll = 4,
SyncAll = 5,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum FeedbackClass {
Keyboard = 0,
Pointer = 1,
String = 2,
Integer = 3,
Led = 4,
Bell = 5,
}
#[derive(Copy, Clone)]
pub struct KbdFeedbackState {
data: [u8; 52],
}
#[allow(unused_parens)]
impl KbdFeedbackState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &KbdFeedbackState {
debug_assert_eq!(data.as_ref().len(), 52);
&*(data.as_ref() as *const [u8] as *const KbdFeedbackState)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: FeedbackClass,
feedback_id: u8,
len: u16,
pitch: u16,
duration: u16,
led_mask: u32,
led_values: u32,
global_auto_repeat: bool,
click: u8,
percent: u8,
auto_repeats: &[u8; 32],
) -> KbdFeedbackState {
unsafe {
let mut wire_buf = [0u8; 52];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += pitch.serialize(&mut wire_buf[wire_off .. ]);
wire_off += duration.serialize(&mut wire_buf[wire_off .. ]);
wire_off += led_mask.serialize(&mut wire_buf[wire_off .. ]);
wire_off += led_values.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (if global_auto_repeat { 1u8 } else { 0u8 }).serialize(&mut wire_buf[wire_off .. ]);
wire_off += click.serialize(&mut wire_buf[wire_off .. ]);
wire_off += percent.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 1; for el in auto_repeats {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
KbdFeedbackState { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn pitch(&self) -> u16 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn duration(&self) -> u16 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn led_mask(&self) -> u32 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn led_values(&self) -> u32 {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn global_auto_repeat(&self) -> bool {
let val = unsafe { *(self.wire_ptr().add(16usize)) };
val != 0
}
pub fn click(&self) -> u8 {
unsafe {
let offset = 17usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn percent(&self) -> u8 {
unsafe {
let offset = 18usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn auto_repeats(&self) -> &[u8; 32] {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const [u8; 32];
&*ptr
}
}
}
#[test]
fn test_sizeof_kbd_feedback_state() {
assert_eq!(std::mem::size_of::<KbdFeedbackState>(), 52);
}
impl base::WiredOut for KbdFeedbackState {
fn wire_len(&self) -> usize { 52 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for KbdFeedbackState {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 52 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 52;
*(ptr as *const KbdFeedbackState)
}
}
impl std::fmt::Debug for KbdFeedbackState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("KbdFeedbackState")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("pitch", &self.pitch())
.field("duration", &self.duration())
.field("led_mask", &self.led_mask())
.field("led_values", &self.led_values())
.field("global_auto_repeat", &self.global_auto_repeat())
.field("click", &self.click())
.field("percent", &self.percent())
.field("pad", &1)
.field("auto_repeats", &self.auto_repeats())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct PtrFeedbackState {
data: [u8; 12],
}
#[allow(unused_parens)]
impl PtrFeedbackState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &PtrFeedbackState {
debug_assert_eq!(data.as_ref().len(), 12);
&*(data.as_ref() as *const [u8] as *const PtrFeedbackState)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: FeedbackClass,
feedback_id: u8,
len: u16,
accel_num: u16,
accel_denom: u16,
threshold: u16,
) -> PtrFeedbackState {
unsafe {
let mut wire_buf = [0u8; 12];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 2; wire_off += accel_num.serialize(&mut wire_buf[wire_off .. ]);
wire_off += accel_denom.serialize(&mut wire_buf[wire_off .. ]);
wire_off += threshold.serialize(&mut wire_buf[wire_off .. ]);
PtrFeedbackState { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn accel_num(&self) -> u16 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn accel_denom(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn threshold(&self) -> u16 {
unsafe {
let offset = 10usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_ptr_feedback_state() {
assert_eq!(std::mem::size_of::<PtrFeedbackState>(), 12);
}
impl base::WiredOut for PtrFeedbackState {
fn wire_len(&self) -> usize { 12 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for PtrFeedbackState {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 12 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 12;
*(ptr as *const PtrFeedbackState)
}
}
impl std::fmt::Debug for PtrFeedbackState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PtrFeedbackState")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("pad", &2)
.field("accel_num", &self.accel_num())
.field("accel_denom", &self.accel_denom())
.field("threshold", &self.threshold())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct IntegerFeedbackState {
data: [u8; 16],
}
#[allow(unused_parens)]
impl IntegerFeedbackState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &IntegerFeedbackState {
debug_assert_eq!(data.as_ref().len(), 16);
&*(data.as_ref() as *const [u8] as *const IntegerFeedbackState)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: FeedbackClass,
feedback_id: u8,
len: u16,
resolution: u32,
min_value: i32,
max_value: i32,
) -> IntegerFeedbackState {
unsafe {
let mut wire_buf = [0u8; 16];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += resolution.serialize(&mut wire_buf[wire_off .. ]);
wire_off += min_value.serialize(&mut wire_buf[wire_off .. ]);
wire_off += max_value.serialize(&mut wire_buf[wire_off .. ]);
IntegerFeedbackState { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn resolution(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn min_value(&self) -> i32 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
pub fn max_value(&self) -> i32 {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_integer_feedback_state() {
assert_eq!(std::mem::size_of::<IntegerFeedbackState>(), 16);
}
impl base::WiredOut for IntegerFeedbackState {
fn wire_len(&self) -> usize { 16 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for IntegerFeedbackState {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 16 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 16;
*(ptr as *const IntegerFeedbackState)
}
}
impl std::fmt::Debug for IntegerFeedbackState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("IntegerFeedbackState")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("resolution", &self.resolution())
.field("min_value", &self.min_value())
.field("max_value", &self.max_value())
.finish()
}
}
pub struct StringFeedbackState {
data: [u8],
}
#[allow(unused_parens)]
impl StringFeedbackState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &StringFeedbackState {
debug_assert_eq!(data.as_ref().len(), <&StringFeedbackState as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const StringFeedbackState)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn max_symbols(&self) -> u16 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
fn num_keysyms(&self) -> u16 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn keysyms(&self) -> &[xproto::Keysym] {
unsafe {
let offset = 8usize;
let len = (self.num_keysyms() as usize);
let ptr = self.wire_ptr().add(offset) as *const xproto::Keysym;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::WiredOut for StringFeedbackState {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &StringFeedbackState {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 2usize;
let num_keysyms = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += ((num_keysyms as usize) * 4usize);
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
StringFeedbackState::from_data(data)
}
}
#[derive(Clone)]
pub struct StringFeedbackStateBuf {
data: Vec<u8>,
}
impl StringFeedbackStateBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> StringFeedbackStateBuf {
debug_assert_eq!(<&StringFeedbackState>::compute_wire_len(data.as_ptr(), ()), data.len());
StringFeedbackStateBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: FeedbackClass,
feedback_id: u8,
len: u16,
max_symbols: u16,
keysyms: &[xproto::Keysym],
) -> StringFeedbackStateBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 1; wire_sz += 1; wire_sz += 2; wire_sz += 2; wire_sz += 2; wire_sz += keysyms.iter().map(|el| el.wire_len()).sum::<usize>();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += max_symbols.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (keysyms.len() as u16).serialize(&mut wire_buf[wire_off .. ]);
for el in keysyms {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
StringFeedbackStateBuf { data: wire_buf }
}
}
}
impl base::WiredIn for StringFeedbackStateBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&StringFeedbackState>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
StringFeedbackStateBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for StringFeedbackStateBuf {
type Target = StringFeedbackState;
fn deref(&self) -> &Self::Target {
unsafe { StringFeedbackState::from_data(&self.data) }
}
}
impl std::borrow::Borrow<StringFeedbackState> for StringFeedbackStateBuf {
fn borrow(&self) -> &StringFeedbackState {
unsafe { StringFeedbackState::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for StringFeedbackState {
type Owned = StringFeedbackStateBuf;
fn to_owned(&self) -> Self::Owned {
StringFeedbackStateBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for StringFeedbackState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("StringFeedbackState")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("max_symbols", &self.max_symbols())
.field("num_keysyms", &self.num_keysyms())
.field("keysyms", &self.keysyms())
.finish()
}
}
impl std::fmt::Debug for StringFeedbackStateBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("StringFeedbackStateBuf")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("max_symbols", &self.max_symbols())
.field("num_keysyms", &self.num_keysyms())
.field("keysyms", &self.keysyms())
.finish()
}
}
#[derive(Clone)]
pub struct StringFeedbackStateIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a StringFeedbackState>,
}
impl<'a> Iterator for StringFeedbackStateIterator<'a> {
type Item = &'a StringFeedbackState;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&StringFeedbackState>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for StringFeedbackStateIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone)]
pub struct BellFeedbackState {
data: [u8; 12],
}
#[allow(unused_parens)]
impl BellFeedbackState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &BellFeedbackState {
debug_assert_eq!(data.as_ref().len(), 12);
&*(data.as_ref() as *const [u8] as *const BellFeedbackState)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: FeedbackClass,
feedback_id: u8,
len: u16,
percent: u8,
pitch: u16,
duration: u16,
) -> BellFeedbackState {
unsafe {
let mut wire_buf = [0u8; 12];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += percent.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 3; wire_off += pitch.serialize(&mut wire_buf[wire_off .. ]);
wire_off += duration.serialize(&mut wire_buf[wire_off .. ]);
BellFeedbackState { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn percent(&self) -> u8 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn pitch(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn duration(&self) -> u16 {
unsafe {
let offset = 10usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_bell_feedback_state() {
assert_eq!(std::mem::size_of::<BellFeedbackState>(), 12);
}
impl base::WiredOut for BellFeedbackState {
fn wire_len(&self) -> usize { 12 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for BellFeedbackState {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 12 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 12;
*(ptr as *const BellFeedbackState)
}
}
impl std::fmt::Debug for BellFeedbackState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BellFeedbackState")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("percent", &self.percent())
.field("pad", &3)
.field("pitch", &self.pitch())
.field("duration", &self.duration())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct LedFeedbackState {
data: [u8; 12],
}
#[allow(unused_parens)]
impl LedFeedbackState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &LedFeedbackState {
debug_assert_eq!(data.as_ref().len(), 12);
&*(data.as_ref() as *const [u8] as *const LedFeedbackState)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: FeedbackClass,
feedback_id: u8,
len: u16,
led_mask: u32,
led_values: u32,
) -> LedFeedbackState {
unsafe {
let mut wire_buf = [0u8; 12];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += led_mask.serialize(&mut wire_buf[wire_off .. ]);
wire_off += led_values.serialize(&mut wire_buf[wire_off .. ]);
LedFeedbackState { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn led_mask(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn led_values(&self) -> u32 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_led_feedback_state() {
assert_eq!(std::mem::size_of::<LedFeedbackState>(), 12);
}
impl base::WiredOut for LedFeedbackState {
fn wire_len(&self) -> usize { 12 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for LedFeedbackState {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 12 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 12;
*(ptr as *const LedFeedbackState)
}
}
impl std::fmt::Debug for LedFeedbackState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("LedFeedbackState")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("led_mask", &self.led_mask())
.field("led_values", &self.led_values())
.finish()
}
}
#[derive(Copy, Clone, Debug)]
pub struct FeedbackStateDataParams {
pub class_id: usize,
}
#[derive(Clone, Debug)]
pub enum FeedbackStateData {
Keyboard{
pitch: u16,
duration: u16,
led_mask: u32,
led_values: u32,
global_auto_repeat: bool,
click: u8,
percent: u8,
auto_repeats: Vec<u8>,
},
Pointer{
accel_num: u16,
accel_denom: u16,
threshold: u16,
},
String{
max_symbols: u16,
keysyms: Vec<xproto::Keysym>,
},
Integer{
resolution: u32,
min_value: i32,
max_value: i32,
},
Led{
led_mask: u32,
led_values: u32,
},
Bell{
percent: u8,
pitch: u16,
duration: u16,
},
}
impl FeedbackStateData {
pub(crate) fn get_enum(&self) -> FeedbackClass {
match self {
FeedbackStateData::Keyboard{..} => {
FeedbackClass::Keyboard
}
FeedbackStateData::Pointer{..} => {
FeedbackClass::Pointer
}
FeedbackStateData::String{..} => {
FeedbackClass::String
}
FeedbackStateData::Integer{..} => {
FeedbackClass::Integer
}
FeedbackStateData::Led{..} => {
FeedbackClass::Led
}
FeedbackStateData::Bell{..} => {
FeedbackClass::Bell
}
}
}
}
impl base::WiredOut for FeedbackStateData {
fn wire_len(&self) -> usize {
let mut sz = 0usize;
match self {
FeedbackStateData::Keyboard{
..
} => {
sz += 2;
sz += 2;
sz += 4;
sz += 4;
sz += 1;
sz += 1;
sz += 1;
sz += 1;
sz += 32;
}
FeedbackStateData::Pointer{
..
} => {
sz += 2;
sz += 2;
sz += 2;
sz += 2;
}
FeedbackStateData::String{
keysyms,
..
} => {
sz += 2;
sz += 2;
for el in keysyms {
sz += el.wire_len();
}
}
FeedbackStateData::Integer{
..
} => {
sz += 4;
sz += 4;
sz += 4;
}
FeedbackStateData::Led{
..
} => {
sz += 4;
sz += 4;
}
FeedbackStateData::Bell{
..
} => {
sz += 1;
sz += 3;
sz += 2;
sz += 2;
}
}
sz
}
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let mut offset = 0usize;
match self {
FeedbackStateData::Keyboard{
pitch,
duration,
led_mask,
led_values,
global_auto_repeat,
click,
percent,
auto_repeats,
..
} => {
offset += pitch.serialize(&mut wire_buf[offset..]);
offset += duration.serialize(&mut wire_buf[offset..]);
offset += led_mask.serialize(&mut wire_buf[offset..]);
offset += led_values.serialize(&mut wire_buf[offset..]);
let global_auto_repeat: u8 = if *global_auto_repeat { 1 } else { 0 };
offset += global_auto_repeat.serialize(&mut wire_buf[offset..]);
offset += click.serialize(&mut wire_buf[offset..]);
offset += percent.serialize(&mut wire_buf[offset..]);
offset += 1;
for el in auto_repeats {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
FeedbackStateData::Pointer{
accel_num,
accel_denom,
threshold,
..
} => {
offset += 2;
offset += accel_num.serialize(&mut wire_buf[offset..]);
offset += accel_denom.serialize(&mut wire_buf[offset..]);
offset += threshold.serialize(&mut wire_buf[offset..]);
}
FeedbackStateData::String{
max_symbols,
keysyms,
..
} => {
offset += max_symbols.serialize(&mut wire_buf[offset..]);
offset += (keysyms.len() as u16).serialize(&mut wire_buf[offset..]);
for el in keysyms {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
FeedbackStateData::Integer{
resolution,
min_value,
max_value,
..
} => {
offset += resolution.serialize(&mut wire_buf[offset..]);
offset += min_value.serialize(&mut wire_buf[offset..]);
offset += max_value.serialize(&mut wire_buf[offset..]);
}
FeedbackStateData::Led{
led_mask,
led_values,
..
} => {
offset += led_mask.serialize(&mut wire_buf[offset..]);
offset += led_values.serialize(&mut wire_buf[offset..]);
}
FeedbackStateData::Bell{
percent,
pitch,
duration,
..
} => {
offset += percent.serialize(&mut wire_buf[offset..]);
offset += 3;
offset += pitch.serialize(&mut wire_buf[offset..]);
offset += duration.serialize(&mut wire_buf[offset..]);
}
}
offset
}
}
impl base::WiredIn for FeedbackStateData {
type Params = FeedbackStateDataParams;
unsafe fn compute_wire_len(ptr: *const u8, params: Self::Params) -> usize {
let FeedbackStateDataParams {
class_id,
} = params;
let expr = (class_id as usize);
if expr == (FeedbackClass::Keyboard as usize) {
let mut sz = 0usize;
sz += 2usize;
sz += 2usize;
sz += 4usize;
sz += 4usize;
sz += 1usize;
sz += 1usize;
sz += 1usize;
sz += 1usize;
sz += 32usize;
return sz;
}
if expr == (FeedbackClass::Pointer as usize) {
let mut sz = 0usize;
sz += 2usize;
sz += 2usize;
sz += 2usize;
sz += 2usize;
return sz;
}
if expr == (FeedbackClass::String as usize) {
let mut sz = 0usize;
sz += 2usize;
let num_keysyms = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += ((num_keysyms as usize) * 4usize);
return sz;
}
if expr == (FeedbackClass::Integer as usize) {
let mut sz = 0usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
return sz;
}
if expr == (FeedbackClass::Led as usize) {
let mut sz = 0usize;
sz += 4usize;
sz += 4usize;
return sz;
}
if expr == (FeedbackClass::Bell as usize) {
let mut sz = 0usize;
sz += 1usize;
sz += 3usize;
sz += 2usize;
sz += 2usize;
return sz;
}
unreachable!("could not match switch expression in xinput::FeedbackStateData::compute_wire_len")
}
#[allow(unused_assignments)]
unsafe fn unserialize(wire_data: *const u8, params: FeedbackStateDataParams, out_offset: &mut usize) -> FeedbackStateData {
let FeedbackStateDataParams{
class_id,
} = params;
let expr = (class_id as usize);
if expr == (FeedbackClass::Keyboard as usize) {
let mut offset = 0usize;
let pitch = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let duration = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let led_mask = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let led_values = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let global_auto_repeat = *(wire_data.add(offset) as *const u8) != 0;
offset += 1;
let click = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
let percent = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
offset += 1; let auto_repeats = {
let ptr = wire_data.add(offset) as *const u8;
let len = 32usize;
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u8>();
data.to_vec()
};
*out_offset += offset;
return FeedbackStateData::Keyboard{
pitch,
duration,
led_mask,
led_values,
global_auto_repeat,
click,
percent,
auto_repeats,
};
}
if expr == (FeedbackClass::Pointer as usize) {
let mut offset = 0usize;
offset += 2; let accel_num = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let accel_denom = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let threshold = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
*out_offset += offset;
return FeedbackStateData::Pointer{
accel_num,
accel_denom,
threshold,
};
}
if expr == (FeedbackClass::String as usize) {
let mut offset = 0usize;
let max_symbols = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let num_keysyms = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let keysyms = {
let ptr = wire_data.add(offset) as *const xproto::Keysym;
let len = (num_keysyms as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<xproto::Keysym>();
data.to_vec()
};
*out_offset += offset;
return FeedbackStateData::String{
max_symbols,
keysyms,
};
}
if expr == (FeedbackClass::Integer as usize) {
let mut offset = 0usize;
let resolution = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let min_value = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
let max_value = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
*out_offset += offset;
return FeedbackStateData::Integer{
resolution,
min_value,
max_value,
};
}
if expr == (FeedbackClass::Led as usize) {
let mut offset = 0usize;
let led_mask = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let led_values = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
*out_offset += offset;
return FeedbackStateData::Led{
led_mask,
led_values,
};
}
if expr == (FeedbackClass::Bell as usize) {
let mut offset = 0usize;
let percent = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
offset += 3; let pitch = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let duration = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
*out_offset += offset;
return FeedbackStateData::Bell{
percent,
pitch,
duration,
};
}
unreachable!("Could not match any expression for FeedbackStateData");
}
}
pub struct FeedbackState {
data: [u8],
}
#[allow(unused_parens)]
impl FeedbackState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &FeedbackState {
debug_assert_eq!(data.as_ref().len(), <&FeedbackState as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const FeedbackState)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn data(&self) -> FeedbackStateData {
let class_id = self.class_id();
let params = FeedbackStateDataParams {class_id: class_id as usize};
let mut offset = 4usize;
unsafe {
FeedbackStateData::unserialize(
self.wire_ptr().add(offset), params, &mut offset
)
}
}
}
impl base::WiredOut for FeedbackState {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &FeedbackState {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
let class_id = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += FeedbackStateData::compute_wire_len(ptr.add(sz), FeedbackStateDataParams {class_id: class_id as usize});
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
FeedbackState::from_data(data)
}
}
#[derive(Clone)]
pub struct FeedbackStateBuf {
data: Vec<u8>,
}
impl FeedbackStateBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> FeedbackStateBuf {
debug_assert_eq!(<&FeedbackState>::compute_wire_len(data.as_ptr(), ()), data.len());
FeedbackStateBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
feedback_id: u8,
len: u16,
data: FeedbackStateData,
) -> FeedbackStateBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 1; wire_sz += 1; wire_sz += 2; wire_sz += data.wire_len();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(data.get_enum()) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += data.serialize(&mut wire_buf[wire_off ..]);
FeedbackStateBuf { data: wire_buf }
}
}
}
impl base::WiredIn for FeedbackStateBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&FeedbackState>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
FeedbackStateBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for FeedbackStateBuf {
type Target = FeedbackState;
fn deref(&self) -> &Self::Target {
unsafe { FeedbackState::from_data(&self.data) }
}
}
impl std::borrow::Borrow<FeedbackState> for FeedbackStateBuf {
fn borrow(&self) -> &FeedbackState {
unsafe { FeedbackState::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for FeedbackState {
type Owned = FeedbackStateBuf;
fn to_owned(&self) -> Self::Owned {
FeedbackStateBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for FeedbackState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("FeedbackState")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("data", &self.data())
.finish()
}
}
impl std::fmt::Debug for FeedbackStateBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("FeedbackStateBuf")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("data", &self.data())
.finish()
}
}
#[derive(Clone)]
pub struct FeedbackStateIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a FeedbackState>,
}
impl<'a> Iterator for FeedbackStateIterator<'a> {
type Item = &'a FeedbackState;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&FeedbackState>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for FeedbackStateIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone)]
pub struct KbdFeedbackCtl {
data: [u8; 20],
}
#[allow(unused_parens)]
impl KbdFeedbackCtl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &KbdFeedbackCtl {
debug_assert_eq!(data.as_ref().len(), 20);
&*(data.as_ref() as *const [u8] as *const KbdFeedbackCtl)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: FeedbackClass,
feedback_id: u8,
len: u16,
key: KeyCode,
auto_repeat_mode: u8,
key_click_percent: i8,
bell_percent: i8,
bell_pitch: i16,
bell_duration: i16,
led_mask: u32,
led_values: u32,
) -> KbdFeedbackCtl {
unsafe {
let mut wire_buf = [0u8; 20];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += key.serialize(&mut wire_buf[wire_off .. ]);
wire_off += auto_repeat_mode.serialize(&mut wire_buf[wire_off .. ]);
wire_off += key_click_percent.serialize(&mut wire_buf[wire_off .. ]);
wire_off += bell_percent.serialize(&mut wire_buf[wire_off .. ]);
wire_off += bell_pitch.serialize(&mut wire_buf[wire_off .. ]);
wire_off += bell_duration.serialize(&mut wire_buf[wire_off .. ]);
wire_off += led_mask.serialize(&mut wire_buf[wire_off .. ]);
wire_off += led_values.serialize(&mut wire_buf[wire_off .. ]);
KbdFeedbackCtl { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn key(&self) -> KeyCode {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const KeyCode;
base::value_from_ptr(ptr)
}
}
pub fn auto_repeat_mode(&self) -> u8 {
unsafe {
let offset = 5usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn key_click_percent(&self) -> i8 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const i8;
base::value_from_ptr(ptr)
}
}
pub fn bell_percent(&self) -> i8 {
unsafe {
let offset = 7usize;
let ptr = self.wire_ptr().add(offset) as *const i8;
base::value_from_ptr(ptr)
}
}
pub fn bell_pitch(&self) -> i16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const i16;
base::value_from_ptr(ptr)
}
}
pub fn bell_duration(&self) -> i16 {
unsafe {
let offset = 10usize;
let ptr = self.wire_ptr().add(offset) as *const i16;
base::value_from_ptr(ptr)
}
}
pub fn led_mask(&self) -> u32 {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn led_values(&self) -> u32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_kbd_feedback_ctl() {
assert_eq!(std::mem::size_of::<KbdFeedbackCtl>(), 20);
}
impl base::WiredOut for KbdFeedbackCtl {
fn wire_len(&self) -> usize { 20 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for KbdFeedbackCtl {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 20 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 20;
*(ptr as *const KbdFeedbackCtl)
}
}
impl std::fmt::Debug for KbdFeedbackCtl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("KbdFeedbackCtl")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("key", &self.key())
.field("auto_repeat_mode", &self.auto_repeat_mode())
.field("key_click_percent", &self.key_click_percent())
.field("bell_percent", &self.bell_percent())
.field("bell_pitch", &self.bell_pitch())
.field("bell_duration", &self.bell_duration())
.field("led_mask", &self.led_mask())
.field("led_values", &self.led_values())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct PtrFeedbackCtl {
data: [u8; 12],
}
#[allow(unused_parens)]
impl PtrFeedbackCtl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &PtrFeedbackCtl {
debug_assert_eq!(data.as_ref().len(), 12);
&*(data.as_ref() as *const [u8] as *const PtrFeedbackCtl)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: FeedbackClass,
feedback_id: u8,
len: u16,
num: i16,
denom: i16,
threshold: i16,
) -> PtrFeedbackCtl {
unsafe {
let mut wire_buf = [0u8; 12];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 2; wire_off += num.serialize(&mut wire_buf[wire_off .. ]);
wire_off += denom.serialize(&mut wire_buf[wire_off .. ]);
wire_off += threshold.serialize(&mut wire_buf[wire_off .. ]);
PtrFeedbackCtl { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn num(&self) -> i16 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const i16;
base::value_from_ptr(ptr)
}
}
pub fn denom(&self) -> i16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const i16;
base::value_from_ptr(ptr)
}
}
pub fn threshold(&self) -> i16 {
unsafe {
let offset = 10usize;
let ptr = self.wire_ptr().add(offset) as *const i16;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_ptr_feedback_ctl() {
assert_eq!(std::mem::size_of::<PtrFeedbackCtl>(), 12);
}
impl base::WiredOut for PtrFeedbackCtl {
fn wire_len(&self) -> usize { 12 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for PtrFeedbackCtl {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 12 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 12;
*(ptr as *const PtrFeedbackCtl)
}
}
impl std::fmt::Debug for PtrFeedbackCtl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PtrFeedbackCtl")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("pad", &2)
.field("num", &self.num())
.field("denom", &self.denom())
.field("threshold", &self.threshold())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct IntegerFeedbackCtl {
data: [u8; 8],
}
#[allow(unused_parens)]
impl IntegerFeedbackCtl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &IntegerFeedbackCtl {
debug_assert_eq!(data.as_ref().len(), 8);
&*(data.as_ref() as *const [u8] as *const IntegerFeedbackCtl)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: FeedbackClass,
feedback_id: u8,
len: u16,
int_to_display: i32,
) -> IntegerFeedbackCtl {
unsafe {
let mut wire_buf = [0u8; 8];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += int_to_display.serialize(&mut wire_buf[wire_off .. ]);
IntegerFeedbackCtl { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn int_to_display(&self) -> i32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_integer_feedback_ctl() {
assert_eq!(std::mem::size_of::<IntegerFeedbackCtl>(), 8);
}
impl base::WiredOut for IntegerFeedbackCtl {
fn wire_len(&self) -> usize { 8 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for IntegerFeedbackCtl {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 8 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 8;
*(ptr as *const IntegerFeedbackCtl)
}
}
impl std::fmt::Debug for IntegerFeedbackCtl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("IntegerFeedbackCtl")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("int_to_display", &self.int_to_display())
.finish()
}
}
pub struct StringFeedbackCtl {
data: [u8],
}
#[allow(unused_parens)]
impl StringFeedbackCtl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &StringFeedbackCtl {
debug_assert_eq!(data.as_ref().len(), <&StringFeedbackCtl as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const StringFeedbackCtl)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
fn num_keysyms(&self) -> u16 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn keysyms(&self) -> &[xproto::Keysym] {
unsafe {
let offset = 8usize;
let len = (self.num_keysyms() as usize);
let ptr = self.wire_ptr().add(offset) as *const xproto::Keysym;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::WiredOut for StringFeedbackCtl {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &StringFeedbackCtl {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 2usize;
let num_keysyms = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += ((num_keysyms as usize) * 4usize);
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
StringFeedbackCtl::from_data(data)
}
}
#[derive(Clone)]
pub struct StringFeedbackCtlBuf {
data: Vec<u8>,
}
impl StringFeedbackCtlBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> StringFeedbackCtlBuf {
debug_assert_eq!(<&StringFeedbackCtl>::compute_wire_len(data.as_ptr(), ()), data.len());
StringFeedbackCtlBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: FeedbackClass,
feedback_id: u8,
len: u16,
keysyms: &[xproto::Keysym],
) -> StringFeedbackCtlBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 1; wire_sz += 1; wire_sz += 2; wire_sz += 2; wire_sz += 2; wire_sz += keysyms.iter().map(|el| el.wire_len()).sum::<usize>();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 2; wire_off += (keysyms.len() as u16).serialize(&mut wire_buf[wire_off .. ]);
for el in keysyms {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
StringFeedbackCtlBuf { data: wire_buf }
}
}
}
impl base::WiredIn for StringFeedbackCtlBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&StringFeedbackCtl>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
StringFeedbackCtlBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for StringFeedbackCtlBuf {
type Target = StringFeedbackCtl;
fn deref(&self) -> &Self::Target {
unsafe { StringFeedbackCtl::from_data(&self.data) }
}
}
impl std::borrow::Borrow<StringFeedbackCtl> for StringFeedbackCtlBuf {
fn borrow(&self) -> &StringFeedbackCtl {
unsafe { StringFeedbackCtl::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for StringFeedbackCtl {
type Owned = StringFeedbackCtlBuf;
fn to_owned(&self) -> Self::Owned {
StringFeedbackCtlBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for StringFeedbackCtl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("StringFeedbackCtl")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("pad", &2)
.field("num_keysyms", &self.num_keysyms())
.field("keysyms", &self.keysyms())
.finish()
}
}
impl std::fmt::Debug for StringFeedbackCtlBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("StringFeedbackCtlBuf")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("pad", &2)
.field("num_keysyms", &self.num_keysyms())
.field("keysyms", &self.keysyms())
.finish()
}
}
#[derive(Clone)]
pub struct StringFeedbackCtlIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a StringFeedbackCtl>,
}
impl<'a> Iterator for StringFeedbackCtlIterator<'a> {
type Item = &'a StringFeedbackCtl;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&StringFeedbackCtl>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for StringFeedbackCtlIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone)]
pub struct BellFeedbackCtl {
data: [u8; 12],
}
#[allow(unused_parens)]
impl BellFeedbackCtl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &BellFeedbackCtl {
debug_assert_eq!(data.as_ref().len(), 12);
&*(data.as_ref() as *const [u8] as *const BellFeedbackCtl)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: FeedbackClass,
feedback_id: u8,
len: u16,
percent: i8,
pitch: i16,
duration: i16,
) -> BellFeedbackCtl {
unsafe {
let mut wire_buf = [0u8; 12];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += percent.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 3; wire_off += pitch.serialize(&mut wire_buf[wire_off .. ]);
wire_off += duration.serialize(&mut wire_buf[wire_off .. ]);
BellFeedbackCtl { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn percent(&self) -> i8 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const i8;
base::value_from_ptr(ptr)
}
}
pub fn pitch(&self) -> i16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const i16;
base::value_from_ptr(ptr)
}
}
pub fn duration(&self) -> i16 {
unsafe {
let offset = 10usize;
let ptr = self.wire_ptr().add(offset) as *const i16;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_bell_feedback_ctl() {
assert_eq!(std::mem::size_of::<BellFeedbackCtl>(), 12);
}
impl base::WiredOut for BellFeedbackCtl {
fn wire_len(&self) -> usize { 12 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for BellFeedbackCtl {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 12 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 12;
*(ptr as *const BellFeedbackCtl)
}
}
impl std::fmt::Debug for BellFeedbackCtl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BellFeedbackCtl")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("percent", &self.percent())
.field("pad", &3)
.field("pitch", &self.pitch())
.field("duration", &self.duration())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct LedFeedbackCtl {
data: [u8; 12],
}
#[allow(unused_parens)]
impl LedFeedbackCtl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &LedFeedbackCtl {
debug_assert_eq!(data.as_ref().len(), 12);
&*(data.as_ref() as *const [u8] as *const LedFeedbackCtl)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: FeedbackClass,
feedback_id: u8,
len: u16,
led_mask: u32,
led_values: u32,
) -> LedFeedbackCtl {
unsafe {
let mut wire_buf = [0u8; 12];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += led_mask.serialize(&mut wire_buf[wire_off .. ]);
wire_off += led_values.serialize(&mut wire_buf[wire_off .. ]);
LedFeedbackCtl { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn led_mask(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn led_values(&self) -> u32 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_led_feedback_ctl() {
assert_eq!(std::mem::size_of::<LedFeedbackCtl>(), 12);
}
impl base::WiredOut for LedFeedbackCtl {
fn wire_len(&self) -> usize { 12 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for LedFeedbackCtl {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 12 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 12;
*(ptr as *const LedFeedbackCtl)
}
}
impl std::fmt::Debug for LedFeedbackCtl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("LedFeedbackCtl")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("led_mask", &self.led_mask())
.field("led_values", &self.led_values())
.finish()
}
}
#[derive(Copy, Clone, Debug)]
pub struct FeedbackCtlDataParams {
pub class_id: usize,
}
#[derive(Clone, Debug)]
pub enum FeedbackCtlData {
Keyboard{
key: KeyCode,
auto_repeat_mode: u8,
key_click_percent: i8,
bell_percent: i8,
bell_pitch: i16,
bell_duration: i16,
led_mask: u32,
led_values: u32,
},
Pointer{
num: i16,
denom: i16,
threshold: i16,
},
String{
keysyms: Vec<xproto::Keysym>,
},
Integer(i32),
Led{
led_mask: u32,
led_values: u32,
},
Bell{
percent: i8,
pitch: i16,
duration: i16,
},
}
impl FeedbackCtlData {
pub(crate) fn get_enum(&self) -> FeedbackClass {
match self {
FeedbackCtlData::Keyboard{..} => {
FeedbackClass::Keyboard
}
FeedbackCtlData::Pointer{..} => {
FeedbackClass::Pointer
}
FeedbackCtlData::String{..} => {
FeedbackClass::String
}
FeedbackCtlData::Integer{..} => {
FeedbackClass::Integer
}
FeedbackCtlData::Led{..} => {
FeedbackClass::Led
}
FeedbackCtlData::Bell{..} => {
FeedbackClass::Bell
}
}
}
}
impl base::WiredOut for FeedbackCtlData {
fn wire_len(&self) -> usize {
let mut sz = 0usize;
match self {
FeedbackCtlData::Keyboard{
..
} => {
sz += 1;
sz += 1;
sz += 1;
sz += 1;
sz += 2;
sz += 2;
sz += 4;
sz += 4;
}
FeedbackCtlData::Pointer{
..
} => {
sz += 2;
sz += 2;
sz += 2;
sz += 2;
}
FeedbackCtlData::String{
keysyms,
..
} => {
sz += 2;
sz += 2;
for el in keysyms {
sz += el.wire_len();
}
}
FeedbackCtlData::Integer(
..
) => {
sz += 4;
}
FeedbackCtlData::Led{
..
} => {
sz += 4;
sz += 4;
}
FeedbackCtlData::Bell{
..
} => {
sz += 1;
sz += 3;
sz += 2;
sz += 2;
}
}
sz
}
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let mut offset = 0usize;
match self {
FeedbackCtlData::Keyboard{
key,
auto_repeat_mode,
key_click_percent,
bell_percent,
bell_pitch,
bell_duration,
led_mask,
led_values,
..
} => {
offset += key.serialize(&mut wire_buf[offset..]);
offset += auto_repeat_mode.serialize(&mut wire_buf[offset..]);
offset += key_click_percent.serialize(&mut wire_buf[offset..]);
offset += bell_percent.serialize(&mut wire_buf[offset..]);
offset += bell_pitch.serialize(&mut wire_buf[offset..]);
offset += bell_duration.serialize(&mut wire_buf[offset..]);
offset += led_mask.serialize(&mut wire_buf[offset..]);
offset += led_values.serialize(&mut wire_buf[offset..]);
}
FeedbackCtlData::Pointer{
num,
denom,
threshold,
..
} => {
offset += 2;
offset += num.serialize(&mut wire_buf[offset..]);
offset += denom.serialize(&mut wire_buf[offset..]);
offset += threshold.serialize(&mut wire_buf[offset..]);
}
FeedbackCtlData::String{
keysyms,
..
} => {
offset += 2;
offset += (keysyms.len() as u16).serialize(&mut wire_buf[offset..]);
for el in keysyms {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
FeedbackCtlData::Integer(
int_to_display,
..
) => {
offset += int_to_display.serialize(&mut wire_buf[offset..]);
}
FeedbackCtlData::Led{
led_mask,
led_values,
..
} => {
offset += led_mask.serialize(&mut wire_buf[offset..]);
offset += led_values.serialize(&mut wire_buf[offset..]);
}
FeedbackCtlData::Bell{
percent,
pitch,
duration,
..
} => {
offset += percent.serialize(&mut wire_buf[offset..]);
offset += 3;
offset += pitch.serialize(&mut wire_buf[offset..]);
offset += duration.serialize(&mut wire_buf[offset..]);
}
}
offset
}
}
impl base::WiredIn for FeedbackCtlData {
type Params = FeedbackCtlDataParams;
unsafe fn compute_wire_len(ptr: *const u8, params: Self::Params) -> usize {
let FeedbackCtlDataParams {
class_id,
} = params;
let expr = (class_id as usize);
if expr == (FeedbackClass::Keyboard as usize) {
let mut sz = 0usize;
sz += 1usize;
sz += 1usize;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 2usize;
sz += 4usize;
sz += 4usize;
return sz;
}
if expr == (FeedbackClass::Pointer as usize) {
let mut sz = 0usize;
sz += 2usize;
sz += 2usize;
sz += 2usize;
sz += 2usize;
return sz;
}
if expr == (FeedbackClass::String as usize) {
let mut sz = 0usize;
sz += 2usize;
let num_keysyms = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += ((num_keysyms as usize) * 4usize);
return sz;
}
if expr == (FeedbackClass::Integer as usize) {
let mut sz = 0usize;
sz += 4usize;
return sz;
}
if expr == (FeedbackClass::Led as usize) {
let mut sz = 0usize;
sz += 4usize;
sz += 4usize;
return sz;
}
if expr == (FeedbackClass::Bell as usize) {
let mut sz = 0usize;
sz += 1usize;
sz += 3usize;
sz += 2usize;
sz += 2usize;
return sz;
}
unreachable!("could not match switch expression in xinput::FeedbackCtlData::compute_wire_len")
}
#[allow(unused_assignments)]
unsafe fn unserialize(wire_data: *const u8, params: FeedbackCtlDataParams, out_offset: &mut usize) -> FeedbackCtlData {
let FeedbackCtlDataParams{
class_id,
} = params;
let expr = (class_id as usize);
if expr == (FeedbackClass::Keyboard as usize) {
let mut offset = 0usize;
let key = *(wire_data.add(offset) as *const KeyCode);
offset += std::mem::size_of::<KeyCode>();
let auto_repeat_mode = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
let key_click_percent = *(wire_data.add(offset) as *const i8);
offset += std::mem::size_of::<i8>();
let bell_percent = *(wire_data.add(offset) as *const i8);
offset += std::mem::size_of::<i8>();
let bell_pitch = *(wire_data.add(offset) as *const i16);
offset += std::mem::size_of::<i16>();
let bell_duration = *(wire_data.add(offset) as *const i16);
offset += std::mem::size_of::<i16>();
let led_mask = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let led_values = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
*out_offset += offset;
return FeedbackCtlData::Keyboard{
key,
auto_repeat_mode,
key_click_percent,
bell_percent,
bell_pitch,
bell_duration,
led_mask,
led_values,
};
}
if expr == (FeedbackClass::Pointer as usize) {
let mut offset = 0usize;
offset += 2; let num = *(wire_data.add(offset) as *const i16);
offset += std::mem::size_of::<i16>();
let denom = *(wire_data.add(offset) as *const i16);
offset += std::mem::size_of::<i16>();
let threshold = *(wire_data.add(offset) as *const i16);
offset += std::mem::size_of::<i16>();
*out_offset += offset;
return FeedbackCtlData::Pointer{
num,
denom,
threshold,
};
}
if expr == (FeedbackClass::String as usize) {
let mut offset = 0usize;
offset += 2; let num_keysyms = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let keysyms = {
let ptr = wire_data.add(offset) as *const xproto::Keysym;
let len = (num_keysyms as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<xproto::Keysym>();
data.to_vec()
};
*out_offset += offset;
return FeedbackCtlData::String{
keysyms,
};
}
if expr == (FeedbackClass::Integer as usize) {
let mut offset = 0usize;
let int_to_display = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
*out_offset += offset;
return FeedbackCtlData::Integer(
int_to_display,
);
}
if expr == (FeedbackClass::Led as usize) {
let mut offset = 0usize;
let led_mask = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let led_values = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
*out_offset += offset;
return FeedbackCtlData::Led{
led_mask,
led_values,
};
}
if expr == (FeedbackClass::Bell as usize) {
let mut offset = 0usize;
let percent = *(wire_data.add(offset) as *const i8);
offset += std::mem::size_of::<i8>();
offset += 3; let pitch = *(wire_data.add(offset) as *const i16);
offset += std::mem::size_of::<i16>();
let duration = *(wire_data.add(offset) as *const i16);
offset += std::mem::size_of::<i16>();
*out_offset += offset;
return FeedbackCtlData::Bell{
percent,
pitch,
duration,
};
}
unreachable!("Could not match any expression for FeedbackCtlData");
}
}
pub struct FeedbackCtl {
data: [u8],
}
#[allow(unused_parens)]
impl FeedbackCtl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &FeedbackCtl {
debug_assert_eq!(data.as_ref().len(), <&FeedbackCtl as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const FeedbackCtl)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn class_id(&self) -> FeedbackClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, FeedbackClass>(val)
}
}
pub fn feedback_id(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn data(&self) -> FeedbackCtlData {
let class_id = self.class_id();
let params = FeedbackCtlDataParams {class_id: class_id as usize};
let mut offset = 4usize;
unsafe {
FeedbackCtlData::unserialize(
self.wire_ptr().add(offset), params, &mut offset
)
}
}
}
impl base::WiredOut for FeedbackCtl {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &FeedbackCtl {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
let class_id = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += FeedbackCtlData::compute_wire_len(ptr.add(sz), FeedbackCtlDataParams {class_id: class_id as usize});
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
FeedbackCtl::from_data(data)
}
}
#[derive(Clone)]
pub struct FeedbackCtlBuf {
data: Vec<u8>,
}
impl FeedbackCtlBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> FeedbackCtlBuf {
debug_assert_eq!(<&FeedbackCtl>::compute_wire_len(data.as_ptr(), ()), data.len());
FeedbackCtlBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
feedback_id: u8,
len: u16,
data: FeedbackCtlData,
) -> FeedbackCtlBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 1; wire_sz += 1; wire_sz += 2; wire_sz += data.wire_len();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(data.get_enum()) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += feedback_id.serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += data.serialize(&mut wire_buf[wire_off ..]);
FeedbackCtlBuf { data: wire_buf }
}
}
}
impl base::WiredIn for FeedbackCtlBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&FeedbackCtl>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
FeedbackCtlBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for FeedbackCtlBuf {
type Target = FeedbackCtl;
fn deref(&self) -> &Self::Target {
unsafe { FeedbackCtl::from_data(&self.data) }
}
}
impl std::borrow::Borrow<FeedbackCtl> for FeedbackCtlBuf {
fn borrow(&self) -> &FeedbackCtl {
unsafe { FeedbackCtl::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for FeedbackCtl {
type Owned = FeedbackCtlBuf;
fn to_owned(&self) -> Self::Owned {
FeedbackCtlBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for FeedbackCtl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("FeedbackCtl")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("data", &self.data())
.finish()
}
}
impl std::fmt::Debug for FeedbackCtlBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("FeedbackCtlBuf")
.field("class_id", &self.class_id())
.field("feedback_id", &self.feedback_id())
.field("len", &self.len())
.field("data", &self.data())
.finish()
}
}
#[derive(Clone)]
pub struct FeedbackCtlIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a FeedbackCtl>,
}
impl<'a> Iterator for FeedbackCtlIterator<'a> {
type Item = &'a FeedbackCtl;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&FeedbackCtl>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for FeedbackCtlIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
bitflags! {
pub struct ChangeFeedbackControlMask: u32 {
const KEY_CLICK_PERCENT = 0x00000001;
const PERCENT = 0x00000002;
const PITCH = 0x00000004;
const DURATION = 0x00000008;
const LED = 0x00000010;
const LED_MODE = 0x00000020;
const KEY = 0x00000040;
const AUTO_REPEAT_MODE = 0x00000080;
const STRING = 0x00000001;
const ACCEL_DENOM = 0x00000002;
const THRESHOLD = 0x00000004;
}
}
#[derive(Copy, Clone)]
pub struct KeyState {
data: [u8; 36],
}
#[allow(unused_parens)]
impl KeyState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &KeyState {
debug_assert_eq!(data.as_ref().len(), 36);
&*(data.as_ref() as *const [u8] as *const KeyState)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: InputClass,
len: u8,
num_keys: u8,
keys: &[u8; 32],
) -> KeyState {
unsafe {
let mut wire_buf = [0u8; 36];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += num_keys.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 1; for el in keys {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
KeyState { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> InputClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, InputClass>(val)
}
}
pub fn len(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn num_keys(&self) -> u8 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn keys(&self) -> &[u8; 32] {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const [u8; 32];
&*ptr
}
}
}
#[test]
fn test_sizeof_key_state() {
assert_eq!(std::mem::size_of::<KeyState>(), 36);
}
impl base::WiredOut for KeyState {
fn wire_len(&self) -> usize { 36 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for KeyState {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 36 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 36;
*(ptr as *const KeyState)
}
}
impl std::fmt::Debug for KeyState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("KeyState")
.field("class_id", &self.class_id())
.field("len", &self.len())
.field("num_keys", &self.num_keys())
.field("pad", &1)
.field("keys", &self.keys())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct ButtonState {
data: [u8; 36],
}
#[allow(unused_parens)]
impl ButtonState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &ButtonState {
debug_assert_eq!(data.as_ref().len(), 36);
&*(data.as_ref() as *const [u8] as *const ButtonState)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: InputClass,
len: u8,
num_buttons: u8,
buttons: &[u8; 32],
) -> ButtonState {
unsafe {
let mut wire_buf = [0u8; 36];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += num_buttons.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 1; for el in buttons {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
ButtonState { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn class_id(&self) -> InputClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, InputClass>(val)
}
}
pub fn len(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn num_buttons(&self) -> u8 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn buttons(&self) -> &[u8; 32] {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const [u8; 32];
&*ptr
}
}
}
#[test]
fn test_sizeof_button_state() {
assert_eq!(std::mem::size_of::<ButtonState>(), 36);
}
impl base::WiredOut for ButtonState {
fn wire_len(&self) -> usize { 36 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for ButtonState {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 36 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 36;
*(ptr as *const ButtonState)
}
}
impl std::fmt::Debug for ButtonState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ButtonState")
.field("class_id", &self.class_id())
.field("len", &self.len())
.field("num_buttons", &self.num_buttons())
.field("pad", &1)
.field("buttons", &self.buttons())
.finish()
}
}
bitflags! {
pub struct ValuatorStateModeMask: u32 {
const DEVICE_MODE_ABSOLUTE = 0x00000001;
const OUT_OF_PROXIMITY = 0x00000002;
}
}
pub struct ValuatorState {
data: [u8],
}
#[allow(unused_parens)]
impl ValuatorState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &ValuatorState {
debug_assert_eq!(data.as_ref().len(), <&ValuatorState as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const ValuatorState)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn class_id(&self) -> InputClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, InputClass>(val)
}
}
pub fn len(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
fn num_valuators(&self) -> u8 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn mode(&self) -> ValuatorStateModeMask {
unsafe {
let offset = 3usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, ValuatorStateModeMask>(val)
}
}
pub fn valuators(&self) -> &[i32] {
unsafe {
let offset = 4usize;
let len = (self.num_valuators() as usize);
let ptr = self.wire_ptr().add(offset) as *const i32;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::WiredOut for ValuatorState {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &ValuatorState {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
let num_valuators = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 1usize;
sz += ((num_valuators as usize) * 4usize);
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
ValuatorState::from_data(data)
}
}
#[derive(Clone)]
pub struct ValuatorStateBuf {
data: Vec<u8>,
}
impl ValuatorStateBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> ValuatorStateBuf {
debug_assert_eq!(<&ValuatorState>::compute_wire_len(data.as_ptr(), ()), data.len());
ValuatorStateBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
class_id: InputClass,
len: u8,
mode: ValuatorStateModeMask,
valuators: &[i32],
) -> ValuatorStateBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 1; wire_sz += 1; wire_sz += 1; wire_sz += 1; wire_sz += valuators.iter().map(|el| el.wire_len()).sum::<usize>();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(class_id) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (valuators.len() as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += (mode.bits() as u8).serialize(&mut wire_buf[wire_off .. ]);
for el in valuators {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
ValuatorStateBuf { data: wire_buf }
}
}
}
impl base::WiredIn for ValuatorStateBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&ValuatorState>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
ValuatorStateBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for ValuatorStateBuf {
type Target = ValuatorState;
fn deref(&self) -> &Self::Target {
unsafe { ValuatorState::from_data(&self.data) }
}
}
impl std::borrow::Borrow<ValuatorState> for ValuatorStateBuf {
fn borrow(&self) -> &ValuatorState {
unsafe { ValuatorState::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for ValuatorState {
type Owned = ValuatorStateBuf;
fn to_owned(&self) -> Self::Owned {
ValuatorStateBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for ValuatorState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ValuatorState")
.field("class_id", &self.class_id())
.field("len", &self.len())
.field("num_valuators", &self.num_valuators())
.field("mode", &self.mode())
.field("valuators", &self.valuators())
.finish()
}
}
impl std::fmt::Debug for ValuatorStateBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ValuatorStateBuf")
.field("class_id", &self.class_id())
.field("len", &self.len())
.field("num_valuators", &self.num_valuators())
.field("mode", &self.mode())
.field("valuators", &self.valuators())
.finish()
}
}
#[derive(Clone)]
pub struct ValuatorStateIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a ValuatorState>,
}
impl<'a> Iterator for ValuatorStateIterator<'a> {
type Item = &'a ValuatorState;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&ValuatorState>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for ValuatorStateIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone, Debug)]
pub struct InputStateDataParams {
pub class_id: usize,
}
#[derive(Clone, Debug)]
pub enum InputStateData {
Key{
num_keys: u8,
keys: Vec<u8>,
},
Button{
num_buttons: u8,
buttons: Vec<u8>,
},
Valuator{
mode: ValuatorStateModeMask,
valuators: Vec<i32>,
},
}
impl InputStateData {
pub(crate) fn get_enum(&self) -> InputClass {
match self {
InputStateData::Key{..} => {
InputClass::Key
}
InputStateData::Button{..} => {
InputClass::Button
}
InputStateData::Valuator{..} => {
InputClass::Valuator
}
}
}
}
impl base::WiredOut for InputStateData {
fn wire_len(&self) -> usize {
let mut sz = 0usize;
match self {
InputStateData::Key{
..
} => {
sz += 1;
sz += 1;
sz += 32;
}
InputStateData::Button{
..
} => {
sz += 1;
sz += 1;
sz += 32;
}
InputStateData::Valuator{
valuators,
..
} => {
sz += 1;
sz += 1;
for el in valuators {
sz += el.wire_len();
}
}
}
sz
}
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let mut offset = 0usize;
match self {
InputStateData::Key{
num_keys,
keys,
..
} => {
offset += num_keys.serialize(&mut wire_buf[offset..]);
offset += 1;
for el in keys {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
InputStateData::Button{
num_buttons,
buttons,
..
} => {
offset += num_buttons.serialize(&mut wire_buf[offset..]);
offset += 1;
for el in buttons {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
InputStateData::Valuator{
mode,
valuators,
..
} => {
offset += (valuators.len() as u8).serialize(&mut wire_buf[offset..]);
offset += (mode.bits() as u8).serialize(&mut wire_buf[offset..]);
for el in valuators {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
}
offset
}
}
impl base::WiredIn for InputStateData {
type Params = InputStateDataParams;
unsafe fn compute_wire_len(ptr: *const u8, params: Self::Params) -> usize {
let InputStateDataParams {
class_id,
} = params;
let expr = (class_id as usize);
if expr == (InputClass::Key as usize) {
let mut sz = 0usize;
sz += 1usize;
sz += 1usize;
sz += 32usize;
return sz;
}
if expr == (InputClass::Button as usize) {
let mut sz = 0usize;
sz += 1usize;
sz += 1usize;
sz += 32usize;
return sz;
}
if expr == (InputClass::Valuator as usize) {
let mut sz = 0usize;
let num_valuators = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 1usize;
sz += ((num_valuators as usize) * 4usize);
return sz;
}
unreachable!("could not match switch expression in xinput::InputStateData::compute_wire_len")
}
#[allow(unused_assignments)]
unsafe fn unserialize(wire_data: *const u8, params: InputStateDataParams, out_offset: &mut usize) -> InputStateData {
let InputStateDataParams{
class_id,
} = params;
let expr = (class_id as usize);
if expr == (InputClass::Key as usize) {
let mut offset = 0usize;
let num_keys = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
offset += 1; let keys = {
let ptr = wire_data.add(offset) as *const u8;
let len = 32usize;
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u8>();
data.to_vec()
};
*out_offset += offset;
return InputStateData::Key{
num_keys,
keys,
};
}
if expr == (InputClass::Button as usize) {
let mut offset = 0usize;
let num_buttons = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
offset += 1; let buttons = {
let ptr = wire_data.add(offset) as *const u8;
let len = 32usize;
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u8>();
data.to_vec()
};
*out_offset += offset;
return InputStateData::Button{
num_buttons,
buttons,
};
}
if expr == (InputClass::Valuator as usize) {
let mut offset = 0usize;
let num_valuators = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
let mode = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
let valuators = {
let ptr = wire_data.add(offset) as *const i32;
let len = (num_valuators as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<i32>();
data.to_vec()
};
*out_offset += offset;
return InputStateData::Valuator{
mode: ValuatorStateModeMask::from_bits(mode as u32).unwrap(),
valuators,
};
}
unreachable!("Could not match any expression for InputStateData");
}
}
pub struct InputState {
data: [u8],
}
#[allow(unused_parens)]
impl InputState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &InputState {
debug_assert_eq!(data.as_ref().len(), <&InputState as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const InputState)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn class_id(&self) -> InputClass {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, InputClass>(val)
}
}
pub fn len(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn data(&self) -> InputStateData {
let class_id = self.class_id();
let params = InputStateDataParams {class_id: class_id as usize};
let mut offset = 2usize;
unsafe {
InputStateData::unserialize(
self.wire_ptr().add(offset), params, &mut offset
)
}
}
}
impl base::WiredOut for InputState {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &InputState {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
let class_id = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 1usize;
sz += InputStateData::compute_wire_len(ptr.add(sz), InputStateDataParams {class_id: class_id as usize});
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
InputState::from_data(data)
}
}
#[derive(Clone)]
pub struct InputStateBuf {
data: Vec<u8>,
}
impl InputStateBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> InputStateBuf {
debug_assert_eq!(<&InputState>::compute_wire_len(data.as_ptr(), ()), data.len());
InputStateBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
len: u8,
data: InputStateData,
) -> InputStateBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 1; wire_sz += 1; wire_sz += data.wire_len();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(data.get_enum()) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += data.serialize(&mut wire_buf[wire_off ..]);
InputStateBuf { data: wire_buf }
}
}
}
impl base::WiredIn for InputStateBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&InputState>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
InputStateBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for InputStateBuf {
type Target = InputState;
fn deref(&self) -> &Self::Target {
unsafe { InputState::from_data(&self.data) }
}
}
impl std::borrow::Borrow<InputState> for InputStateBuf {
fn borrow(&self) -> &InputState {
unsafe { InputState::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for InputState {
type Owned = InputStateBuf;
fn to_owned(&self) -> Self::Owned {
InputStateBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for InputState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("InputState")
.field("class_id", &self.class_id())
.field("len", &self.len())
.field("data", &self.data())
.finish()
}
}
impl std::fmt::Debug for InputStateBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("InputStateBuf")
.field("class_id", &self.class_id())
.field("len", &self.len())
.field("data", &self.data())
.finish()
}
}
#[derive(Clone)]
pub struct InputStateIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a InputState>,
}
impl<'a> Iterator for InputStateIterator<'a> {
type Item = &'a InputState;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&InputState>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for InputStateIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum DeviceControl {
Resolution = 1,
AbsCalib = 2,
Core = 3,
Enable = 4,
AbsArea = 5,
}
pub struct DeviceResolutionState {
data: [u8],
}
#[allow(unused_parens)]
impl DeviceResolutionState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceResolutionState {
debug_assert_eq!(data.as_ref().len(), <&DeviceResolutionState as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const DeviceResolutionState)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn control_id(&self) -> DeviceControl {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceControl>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
fn num_valuators(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn resolution_values(&self) -> &[u32] {
unsafe {
let offset = 8usize;
let len = (self.num_valuators() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn resolution_min(&self) -> &[u32] {
unsafe {
let offset = (8usize + ((self.num_valuators() as usize) * 4usize));
let len = (self.num_valuators() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn resolution_max(&self) -> &[u32] {
unsafe {
let offset = ((8usize + ((self.num_valuators() as usize) * 4usize)) + ((self.num_valuators() as usize) * 4usize));
let len = (self.num_valuators() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::WiredOut for DeviceResolutionState {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &DeviceResolutionState {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 2usize;
sz += 2usize;
let num_valuators = *(ptr.add(sz) as *const u32);
sz += 4usize;
sz += ((num_valuators as usize) * 4usize);
sz += ((num_valuators as usize) * 4usize);
sz += ((num_valuators as usize) * 4usize);
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceResolutionState::from_data(data)
}
}
#[derive(Clone)]
pub struct DeviceResolutionStateBuf {
data: Vec<u8>,
}
impl DeviceResolutionStateBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> DeviceResolutionStateBuf {
debug_assert_eq!(<&DeviceResolutionState>::compute_wire_len(data.as_ptr(), ()), data.len());
DeviceResolutionStateBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
control_id: DeviceControl,
len: u16,
resolution_values: &[u32],
resolution_min: &[u32],
resolution_max: &[u32],
) -> DeviceResolutionStateBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 2; wire_sz += 2; wire_sz += 4; wire_sz += resolution_values.iter().map(|el| el.wire_len()).sum::<usize>();
wire_sz += resolution_min.iter().map(|el| el.wire_len()).sum::<usize>();
wire_sz += resolution_max.iter().map(|el| el.wire_len()).sum::<usize>();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(control_id) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (resolution_values.len() as u32).serialize(&mut wire_buf[wire_off .. ]);
for el in resolution_values {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
for el in resolution_min {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
for el in resolution_max {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
DeviceResolutionStateBuf { data: wire_buf }
}
}
}
impl base::WiredIn for DeviceResolutionStateBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&DeviceResolutionState>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceResolutionStateBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for DeviceResolutionStateBuf {
type Target = DeviceResolutionState;
fn deref(&self) -> &Self::Target {
unsafe { DeviceResolutionState::from_data(&self.data) }
}
}
impl std::borrow::Borrow<DeviceResolutionState> for DeviceResolutionStateBuf {
fn borrow(&self) -> &DeviceResolutionState {
unsafe { DeviceResolutionState::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for DeviceResolutionState {
type Owned = DeviceResolutionStateBuf;
fn to_owned(&self) -> Self::Owned {
DeviceResolutionStateBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for DeviceResolutionState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceResolutionState")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("num_valuators", &self.num_valuators())
.field("resolution_values", &self.resolution_values())
.field("resolution_min", &self.resolution_min())
.field("resolution_max", &self.resolution_max())
.finish()
}
}
impl std::fmt::Debug for DeviceResolutionStateBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceResolutionStateBuf")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("num_valuators", &self.num_valuators())
.field("resolution_values", &self.resolution_values())
.field("resolution_min", &self.resolution_min())
.field("resolution_max", &self.resolution_max())
.finish()
}
}
#[derive(Clone)]
pub struct DeviceResolutionStateIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a DeviceResolutionState>,
}
impl<'a> Iterator for DeviceResolutionStateIterator<'a> {
type Item = &'a DeviceResolutionState;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&DeviceResolutionState>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for DeviceResolutionStateIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone)]
pub struct DeviceAbsCalibState {
data: [u8; 36],
}
#[allow(unused_parens)]
impl DeviceAbsCalibState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceAbsCalibState {
debug_assert_eq!(data.as_ref().len(), 36);
&*(data.as_ref() as *const [u8] as *const DeviceAbsCalibState)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
control_id: DeviceControl,
len: u16,
min_x: i32,
max_x: i32,
min_y: i32,
max_y: i32,
flip_x: u32,
flip_y: u32,
rotation: u32,
button_threshold: u32,
) -> DeviceAbsCalibState {
unsafe {
let mut wire_buf = [0u8; 36];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(control_id) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += min_x.serialize(&mut wire_buf[wire_off .. ]);
wire_off += max_x.serialize(&mut wire_buf[wire_off .. ]);
wire_off += min_y.serialize(&mut wire_buf[wire_off .. ]);
wire_off += max_y.serialize(&mut wire_buf[wire_off .. ]);
wire_off += flip_x.serialize(&mut wire_buf[wire_off .. ]);
wire_off += flip_y.serialize(&mut wire_buf[wire_off .. ]);
wire_off += rotation.serialize(&mut wire_buf[wire_off .. ]);
wire_off += button_threshold.serialize(&mut wire_buf[wire_off .. ]);
DeviceAbsCalibState { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn control_id(&self) -> DeviceControl {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceControl>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn min_x(&self) -> i32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
pub fn max_x(&self) -> i32 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
pub fn min_y(&self) -> i32 {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
pub fn max_y(&self) -> i32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
pub fn flip_x(&self) -> u32 {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn flip_y(&self) -> u32 {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn rotation(&self) -> u32 {
unsafe {
let offset = 28usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn button_threshold(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_device_abs_calib_state() {
assert_eq!(std::mem::size_of::<DeviceAbsCalibState>(), 36);
}
impl base::WiredOut for DeviceAbsCalibState {
fn wire_len(&self) -> usize { 36 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for DeviceAbsCalibState {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 36 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 36;
*(ptr as *const DeviceAbsCalibState)
}
}
impl std::fmt::Debug for DeviceAbsCalibState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceAbsCalibState")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("min_x", &self.min_x())
.field("max_x", &self.max_x())
.field("min_y", &self.min_y())
.field("max_y", &self.max_y())
.field("flip_x", &self.flip_x())
.field("flip_y", &self.flip_y())
.field("rotation", &self.rotation())
.field("button_threshold", &self.button_threshold())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct DeviceAbsAreaState {
data: [u8; 28],
}
#[allow(unused_parens)]
impl DeviceAbsAreaState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceAbsAreaState {
debug_assert_eq!(data.as_ref().len(), 28);
&*(data.as_ref() as *const [u8] as *const DeviceAbsAreaState)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
control_id: DeviceControl,
len: u16,
offset_x: u32,
offset_y: u32,
width: u32,
height: u32,
screen: u32,
following: u32,
) -> DeviceAbsAreaState {
unsafe {
let mut wire_buf = [0u8; 28];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(control_id) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += offset_x.serialize(&mut wire_buf[wire_off .. ]);
wire_off += offset_y.serialize(&mut wire_buf[wire_off .. ]);
wire_off += width.serialize(&mut wire_buf[wire_off .. ]);
wire_off += height.serialize(&mut wire_buf[wire_off .. ]);
wire_off += screen.serialize(&mut wire_buf[wire_off .. ]);
wire_off += following.serialize(&mut wire_buf[wire_off .. ]);
DeviceAbsAreaState { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn control_id(&self) -> DeviceControl {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceControl>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn offset_x(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn offset_y(&self) -> u32 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn width(&self) -> u32 {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn height(&self) -> u32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn screen(&self) -> u32 {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn following(&self) -> u32 {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_device_abs_area_state() {
assert_eq!(std::mem::size_of::<DeviceAbsAreaState>(), 28);
}
impl base::WiredOut for DeviceAbsAreaState {
fn wire_len(&self) -> usize { 28 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for DeviceAbsAreaState {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 28 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 28;
*(ptr as *const DeviceAbsAreaState)
}
}
impl std::fmt::Debug for DeviceAbsAreaState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceAbsAreaState")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("offset_x", &self.offset_x())
.field("offset_y", &self.offset_y())
.field("width", &self.width())
.field("height", &self.height())
.field("screen", &self.screen())
.field("following", &self.following())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct DeviceCoreState {
data: [u8; 8],
}
#[allow(unused_parens)]
impl DeviceCoreState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceCoreState {
debug_assert_eq!(data.as_ref().len(), 8);
&*(data.as_ref() as *const [u8] as *const DeviceCoreState)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
control_id: DeviceControl,
len: u16,
status: u8,
iscore: u8,
) -> DeviceCoreState {
unsafe {
let mut wire_buf = [0u8; 8];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(control_id) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += status.serialize(&mut wire_buf[wire_off .. ]);
wire_off += iscore.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 2; DeviceCoreState { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn control_id(&self) -> DeviceControl {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceControl>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> u8 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn iscore(&self) -> u8 {
unsafe {
let offset = 5usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_device_core_state() {
assert_eq!(std::mem::size_of::<DeviceCoreState>(), 8);
}
impl base::WiredOut for DeviceCoreState {
fn wire_len(&self) -> usize { 8 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for DeviceCoreState {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 8 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 8;
*(ptr as *const DeviceCoreState)
}
}
impl std::fmt::Debug for DeviceCoreState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceCoreState")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("status", &self.status())
.field("iscore", &self.iscore())
.field("pad", &2)
.finish()
}
}
#[derive(Copy, Clone)]
pub struct DeviceEnableState {
data: [u8; 8],
}
#[allow(unused_parens)]
impl DeviceEnableState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceEnableState {
debug_assert_eq!(data.as_ref().len(), 8);
&*(data.as_ref() as *const [u8] as *const DeviceEnableState)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
control_id: DeviceControl,
len: u16,
enable: u8,
) -> DeviceEnableState {
unsafe {
let mut wire_buf = [0u8; 8];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(control_id) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += enable.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 3; DeviceEnableState { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn control_id(&self) -> DeviceControl {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceControl>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn enable(&self) -> u8 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_device_enable_state() {
assert_eq!(std::mem::size_of::<DeviceEnableState>(), 8);
}
impl base::WiredOut for DeviceEnableState {
fn wire_len(&self) -> usize { 8 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for DeviceEnableState {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 8 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 8;
*(ptr as *const DeviceEnableState)
}
}
impl std::fmt::Debug for DeviceEnableState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceEnableState")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("enable", &self.enable())
.field("pad", &3)
.finish()
}
}
#[derive(Copy, Clone, Debug)]
pub struct DeviceStateDataParams {
pub control_id: usize,
}
#[derive(Clone, Debug)]
pub enum DeviceStateData {
Resolution{
resolution_values: Vec<u32>,
resolution_min: Vec<u32>,
resolution_max: Vec<u32>,
},
AbsCalib{
min_x: i32,
max_x: i32,
min_y: i32,
max_y: i32,
flip_x: u32,
flip_y: u32,
rotation: u32,
button_threshold: u32,
},
Core{
status: u8,
iscore: u8,
},
Enable(u8),
AbsArea{
offset_x: u32,
offset_y: u32,
width: u32,
height: u32,
screen: u32,
following: u32,
},
}
impl DeviceStateData {
pub(crate) fn get_enum(&self) -> DeviceControl {
match self {
DeviceStateData::Resolution{..} => {
DeviceControl::Resolution
}
DeviceStateData::AbsCalib{..} => {
DeviceControl::AbsCalib
}
DeviceStateData::Core{..} => {
DeviceControl::Core
}
DeviceStateData::Enable{..} => {
DeviceControl::Enable
}
DeviceStateData::AbsArea{..} => {
DeviceControl::AbsArea
}
}
}
}
impl base::WiredOut for DeviceStateData {
fn wire_len(&self) -> usize {
let mut sz = 0usize;
match self {
DeviceStateData::Resolution{
resolution_values,
resolution_min,
resolution_max,
..
} => {
sz += 4;
for el in resolution_values {
sz += el.wire_len();
}
for el in resolution_min {
sz += el.wire_len();
}
for el in resolution_max {
sz += el.wire_len();
}
}
DeviceStateData::AbsCalib{
..
} => {
sz += 4;
sz += 4;
sz += 4;
sz += 4;
sz += 4;
sz += 4;
sz += 4;
sz += 4;
}
DeviceStateData::Core{
..
} => {
sz += 1;
sz += 1;
sz += 2;
}
DeviceStateData::Enable(
..
) => {
sz += 1;
sz += 3;
}
DeviceStateData::AbsArea{
..
} => {
sz += 4;
sz += 4;
sz += 4;
sz += 4;
sz += 4;
sz += 4;
}
}
sz
}
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let mut offset = 0usize;
match self {
DeviceStateData::Resolution{
resolution_values,
resolution_min,
resolution_max,
..
} => {
offset += (resolution_values.len() as u32).serialize(&mut wire_buf[offset..]);
for el in resolution_values {
offset += el.serialize(&mut wire_buf[offset..]);
}
for el in resolution_min {
offset += el.serialize(&mut wire_buf[offset..]);
}
for el in resolution_max {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
DeviceStateData::AbsCalib{
min_x,
max_x,
min_y,
max_y,
flip_x,
flip_y,
rotation,
button_threshold,
..
} => {
offset += min_x.serialize(&mut wire_buf[offset..]);
offset += max_x.serialize(&mut wire_buf[offset..]);
offset += min_y.serialize(&mut wire_buf[offset..]);
offset += max_y.serialize(&mut wire_buf[offset..]);
offset += flip_x.serialize(&mut wire_buf[offset..]);
offset += flip_y.serialize(&mut wire_buf[offset..]);
offset += rotation.serialize(&mut wire_buf[offset..]);
offset += button_threshold.serialize(&mut wire_buf[offset..]);
}
DeviceStateData::Core{
status,
iscore,
..
} => {
offset += status.serialize(&mut wire_buf[offset..]);
offset += iscore.serialize(&mut wire_buf[offset..]);
offset += 2;
}
DeviceStateData::Enable(
enable,
..
) => {
offset += enable.serialize(&mut wire_buf[offset..]);
offset += 3;
}
DeviceStateData::AbsArea{
offset_x,
offset_y,
width,
height,
screen,
following,
..
} => {
offset += offset_x.serialize(&mut wire_buf[offset..]);
offset += offset_y.serialize(&mut wire_buf[offset..]);
offset += width.serialize(&mut wire_buf[offset..]);
offset += height.serialize(&mut wire_buf[offset..]);
offset += screen.serialize(&mut wire_buf[offset..]);
offset += following.serialize(&mut wire_buf[offset..]);
}
}
offset
}
}
impl base::WiredIn for DeviceStateData {
type Params = DeviceStateDataParams;
unsafe fn compute_wire_len(ptr: *const u8, params: Self::Params) -> usize {
let DeviceStateDataParams {
control_id,
} = params;
let expr = (control_id as usize);
if expr == (DeviceControl::Resolution as usize) {
let mut sz = 0usize;
let num_valuators = *(ptr.add(sz) as *const u32);
sz += 4usize;
sz += ((num_valuators as usize) * 4usize);
sz += ((num_valuators as usize) * 4usize);
sz += ((num_valuators as usize) * 4usize);
return sz;
}
if expr == (DeviceControl::AbsCalib as usize) {
let mut sz = 0usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
return sz;
}
if expr == (DeviceControl::Core as usize) {
let mut sz = 0usize;
sz += 1usize;
sz += 1usize;
sz += 2usize;
return sz;
}
if expr == (DeviceControl::Enable as usize) {
let mut sz = 0usize;
sz += 1usize;
sz += 3usize;
return sz;
}
if expr == (DeviceControl::AbsArea as usize) {
let mut sz = 0usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
return sz;
}
unreachable!("could not match switch expression in xinput::DeviceStateData::compute_wire_len")
}
#[allow(unused_assignments)]
unsafe fn unserialize(wire_data: *const u8, params: DeviceStateDataParams, out_offset: &mut usize) -> DeviceStateData {
let DeviceStateDataParams{
control_id,
} = params;
let expr = (control_id as usize);
if expr == (DeviceControl::Resolution as usize) {
let mut offset = 0usize;
let num_valuators = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let resolution_values = {
let ptr = wire_data.add(offset) as *const u32;
let len = (num_valuators as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u32>();
data.to_vec()
};
let resolution_min = {
let ptr = wire_data.add(offset) as *const u32;
let len = (num_valuators as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u32>();
data.to_vec()
};
let resolution_max = {
let ptr = wire_data.add(offset) as *const u32;
let len = (num_valuators as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u32>();
data.to_vec()
};
*out_offset += offset;
return DeviceStateData::Resolution{
resolution_values,
resolution_min,
resolution_max,
};
}
if expr == (DeviceControl::AbsCalib as usize) {
let mut offset = 0usize;
let min_x = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
let max_x = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
let min_y = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
let max_y = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
let flip_x = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let flip_y = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let rotation = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let button_threshold = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
*out_offset += offset;
return DeviceStateData::AbsCalib{
min_x,
max_x,
min_y,
max_y,
flip_x,
flip_y,
rotation,
button_threshold,
};
}
if expr == (DeviceControl::Core as usize) {
let mut offset = 0usize;
let status = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
let iscore = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
offset += 2; *out_offset += offset;
return DeviceStateData::Core{
status,
iscore,
};
}
if expr == (DeviceControl::Enable as usize) {
let mut offset = 0usize;
let enable = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
offset += 3; *out_offset += offset;
return DeviceStateData::Enable(
enable,
);
}
if expr == (DeviceControl::AbsArea as usize) {
let mut offset = 0usize;
let offset_x = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let offset_y = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let width = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let height = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let screen = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let following = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
*out_offset += offset;
return DeviceStateData::AbsArea{
offset_x,
offset_y,
width,
height,
screen,
following,
};
}
unreachable!("Could not match any expression for DeviceStateData");
}
}
pub struct DeviceState {
data: [u8],
}
#[allow(unused_parens)]
impl DeviceState {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceState {
debug_assert_eq!(data.as_ref().len(), <&DeviceState as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const DeviceState)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn control_id(&self) -> DeviceControl {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceControl>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn data(&self) -> DeviceStateData {
let control_id = self.control_id();
let params = DeviceStateDataParams {control_id: control_id as usize};
let mut offset = 4usize;
unsafe {
DeviceStateData::unserialize(
self.wire_ptr().add(offset), params, &mut offset
)
}
}
}
impl base::WiredOut for DeviceState {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &DeviceState {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
let control_id = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 2usize;
sz += DeviceStateData::compute_wire_len(ptr.add(sz), DeviceStateDataParams {control_id: control_id as usize});
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceState::from_data(data)
}
}
#[derive(Clone)]
pub struct DeviceStateBuf {
data: Vec<u8>,
}
impl DeviceStateBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> DeviceStateBuf {
debug_assert_eq!(<&DeviceState>::compute_wire_len(data.as_ptr(), ()), data.len());
DeviceStateBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
len: u16,
data: DeviceStateData,
) -> DeviceStateBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 2; wire_sz += 2; wire_sz += data.wire_len();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(data.get_enum()) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += data.serialize(&mut wire_buf[wire_off ..]);
DeviceStateBuf { data: wire_buf }
}
}
}
impl base::WiredIn for DeviceStateBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&DeviceState>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceStateBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for DeviceStateBuf {
type Target = DeviceState;
fn deref(&self) -> &Self::Target {
unsafe { DeviceState::from_data(&self.data) }
}
}
impl std::borrow::Borrow<DeviceState> for DeviceStateBuf {
fn borrow(&self) -> &DeviceState {
unsafe { DeviceState::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for DeviceState {
type Owned = DeviceStateBuf;
fn to_owned(&self) -> Self::Owned {
DeviceStateBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for DeviceState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceState")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("data", &self.data())
.finish()
}
}
impl std::fmt::Debug for DeviceStateBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceStateBuf")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("data", &self.data())
.finish()
}
}
#[derive(Clone)]
pub struct DeviceStateIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a DeviceState>,
}
impl<'a> Iterator for DeviceStateIterator<'a> {
type Item = &'a DeviceState;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&DeviceState>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for DeviceStateIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
pub struct DeviceResolutionCtl {
data: [u8],
}
#[allow(unused_parens)]
impl DeviceResolutionCtl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceResolutionCtl {
debug_assert_eq!(data.as_ref().len(), <&DeviceResolutionCtl as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const DeviceResolutionCtl)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn control_id(&self) -> DeviceControl {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceControl>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn first_valuator(&self) -> u8 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
fn num_valuators(&self) -> u8 {
unsafe {
let offset = 5usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn resolution_values(&self) -> &[u32] {
unsafe {
let offset = 8usize;
let len = (self.num_valuators() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::WiredOut for DeviceResolutionCtl {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &DeviceResolutionCtl {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 2usize;
sz += 2usize;
sz += 1usize;
let num_valuators = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 2usize;
sz += ((num_valuators as usize) * 4usize);
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceResolutionCtl::from_data(data)
}
}
#[derive(Clone)]
pub struct DeviceResolutionCtlBuf {
data: Vec<u8>,
}
impl DeviceResolutionCtlBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> DeviceResolutionCtlBuf {
debug_assert_eq!(<&DeviceResolutionCtl>::compute_wire_len(data.as_ptr(), ()), data.len());
DeviceResolutionCtlBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
control_id: DeviceControl,
len: u16,
first_valuator: u8,
resolution_values: &[u32],
) -> DeviceResolutionCtlBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 2; wire_sz += 2; wire_sz += 1; wire_sz += 1; wire_sz += 2; wire_sz += resolution_values.iter().map(|el| el.wire_len()).sum::<usize>();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(control_id) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += first_valuator.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (resolution_values.len() as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += 2; for el in resolution_values {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
DeviceResolutionCtlBuf { data: wire_buf }
}
}
}
impl base::WiredIn for DeviceResolutionCtlBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&DeviceResolutionCtl>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceResolutionCtlBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for DeviceResolutionCtlBuf {
type Target = DeviceResolutionCtl;
fn deref(&self) -> &Self::Target {
unsafe { DeviceResolutionCtl::from_data(&self.data) }
}
}
impl std::borrow::Borrow<DeviceResolutionCtl> for DeviceResolutionCtlBuf {
fn borrow(&self) -> &DeviceResolutionCtl {
unsafe { DeviceResolutionCtl::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for DeviceResolutionCtl {
type Owned = DeviceResolutionCtlBuf;
fn to_owned(&self) -> Self::Owned {
DeviceResolutionCtlBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for DeviceResolutionCtl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceResolutionCtl")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("first_valuator", &self.first_valuator())
.field("num_valuators", &self.num_valuators())
.field("pad", &2)
.field("resolution_values", &self.resolution_values())
.finish()
}
}
impl std::fmt::Debug for DeviceResolutionCtlBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceResolutionCtlBuf")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("first_valuator", &self.first_valuator())
.field("num_valuators", &self.num_valuators())
.field("pad", &2)
.field("resolution_values", &self.resolution_values())
.finish()
}
}
#[derive(Clone)]
pub struct DeviceResolutionCtlIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a DeviceResolutionCtl>,
}
impl<'a> Iterator for DeviceResolutionCtlIterator<'a> {
type Item = &'a DeviceResolutionCtl;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&DeviceResolutionCtl>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for DeviceResolutionCtlIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone)]
pub struct DeviceAbsCalibCtl {
data: [u8; 36],
}
#[allow(unused_parens)]
impl DeviceAbsCalibCtl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceAbsCalibCtl {
debug_assert_eq!(data.as_ref().len(), 36);
&*(data.as_ref() as *const [u8] as *const DeviceAbsCalibCtl)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
control_id: DeviceControl,
len: u16,
min_x: i32,
max_x: i32,
min_y: i32,
max_y: i32,
flip_x: u32,
flip_y: u32,
rotation: u32,
button_threshold: u32,
) -> DeviceAbsCalibCtl {
unsafe {
let mut wire_buf = [0u8; 36];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(control_id) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += min_x.serialize(&mut wire_buf[wire_off .. ]);
wire_off += max_x.serialize(&mut wire_buf[wire_off .. ]);
wire_off += min_y.serialize(&mut wire_buf[wire_off .. ]);
wire_off += max_y.serialize(&mut wire_buf[wire_off .. ]);
wire_off += flip_x.serialize(&mut wire_buf[wire_off .. ]);
wire_off += flip_y.serialize(&mut wire_buf[wire_off .. ]);
wire_off += rotation.serialize(&mut wire_buf[wire_off .. ]);
wire_off += button_threshold.serialize(&mut wire_buf[wire_off .. ]);
DeviceAbsCalibCtl { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn control_id(&self) -> DeviceControl {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceControl>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn min_x(&self) -> i32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
pub fn max_x(&self) -> i32 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
pub fn min_y(&self) -> i32 {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
pub fn max_y(&self) -> i32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
pub fn flip_x(&self) -> u32 {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn flip_y(&self) -> u32 {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn rotation(&self) -> u32 {
unsafe {
let offset = 28usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn button_threshold(&self) -> u32 {
unsafe {
let offset = 32usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_device_abs_calib_ctl() {
assert_eq!(std::mem::size_of::<DeviceAbsCalibCtl>(), 36);
}
impl base::WiredOut for DeviceAbsCalibCtl {
fn wire_len(&self) -> usize { 36 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for DeviceAbsCalibCtl {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 36 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 36;
*(ptr as *const DeviceAbsCalibCtl)
}
}
impl std::fmt::Debug for DeviceAbsCalibCtl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceAbsCalibCtl")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("min_x", &self.min_x())
.field("max_x", &self.max_x())
.field("min_y", &self.min_y())
.field("max_y", &self.max_y())
.field("flip_x", &self.flip_x())
.field("flip_y", &self.flip_y())
.field("rotation", &self.rotation())
.field("button_threshold", &self.button_threshold())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct DeviceAbsAreaCtrl {
data: [u8; 28],
}
#[allow(unused_parens)]
impl DeviceAbsAreaCtrl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceAbsAreaCtrl {
debug_assert_eq!(data.as_ref().len(), 28);
&*(data.as_ref() as *const [u8] as *const DeviceAbsAreaCtrl)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
control_id: DeviceControl,
len: u16,
offset_x: u32,
offset_y: u32,
width: i32,
height: i32,
screen: i32,
following: u32,
) -> DeviceAbsAreaCtrl {
unsafe {
let mut wire_buf = [0u8; 28];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(control_id) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += offset_x.serialize(&mut wire_buf[wire_off .. ]);
wire_off += offset_y.serialize(&mut wire_buf[wire_off .. ]);
wire_off += width.serialize(&mut wire_buf[wire_off .. ]);
wire_off += height.serialize(&mut wire_buf[wire_off .. ]);
wire_off += screen.serialize(&mut wire_buf[wire_off .. ]);
wire_off += following.serialize(&mut wire_buf[wire_off .. ]);
DeviceAbsAreaCtrl { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn control_id(&self) -> DeviceControl {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceControl>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn offset_x(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn offset_y(&self) -> u32 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn width(&self) -> i32 {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
pub fn height(&self) -> i32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
pub fn screen(&self) -> i32 {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const i32;
base::value_from_ptr(ptr)
}
}
pub fn following(&self) -> u32 {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_device_abs_area_ctrl() {
assert_eq!(std::mem::size_of::<DeviceAbsAreaCtrl>(), 28);
}
impl base::WiredOut for DeviceAbsAreaCtrl {
fn wire_len(&self) -> usize { 28 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for DeviceAbsAreaCtrl {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 28 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 28;
*(ptr as *const DeviceAbsAreaCtrl)
}
}
impl std::fmt::Debug for DeviceAbsAreaCtrl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceAbsAreaCtrl")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("offset_x", &self.offset_x())
.field("offset_y", &self.offset_y())
.field("width", &self.width())
.field("height", &self.height())
.field("screen", &self.screen())
.field("following", &self.following())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct DeviceCoreCtrl {
data: [u8; 8],
}
#[allow(unused_parens)]
impl DeviceCoreCtrl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceCoreCtrl {
debug_assert_eq!(data.as_ref().len(), 8);
&*(data.as_ref() as *const [u8] as *const DeviceCoreCtrl)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
control_id: DeviceControl,
len: u16,
status: u8,
) -> DeviceCoreCtrl {
unsafe {
let mut wire_buf = [0u8; 8];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(control_id) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += status.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 3; DeviceCoreCtrl { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn control_id(&self) -> DeviceControl {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceControl>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> u8 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_device_core_ctrl() {
assert_eq!(std::mem::size_of::<DeviceCoreCtrl>(), 8);
}
impl base::WiredOut for DeviceCoreCtrl {
fn wire_len(&self) -> usize { 8 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for DeviceCoreCtrl {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 8 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 8;
*(ptr as *const DeviceCoreCtrl)
}
}
impl std::fmt::Debug for DeviceCoreCtrl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceCoreCtrl")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("status", &self.status())
.field("pad", &3)
.finish()
}
}
#[derive(Copy, Clone)]
pub struct DeviceEnableCtrl {
data: [u8; 8],
}
#[allow(unused_parens)]
impl DeviceEnableCtrl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceEnableCtrl {
debug_assert_eq!(data.as_ref().len(), 8);
&*(data.as_ref() as *const [u8] as *const DeviceEnableCtrl)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
control_id: DeviceControl,
len: u16,
enable: u8,
) -> DeviceEnableCtrl {
unsafe {
let mut wire_buf = [0u8; 8];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(control_id) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += enable.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 3; DeviceEnableCtrl { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn control_id(&self) -> DeviceControl {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceControl>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn enable(&self) -> u8 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_device_enable_ctrl() {
assert_eq!(std::mem::size_of::<DeviceEnableCtrl>(), 8);
}
impl base::WiredOut for DeviceEnableCtrl {
fn wire_len(&self) -> usize { 8 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for DeviceEnableCtrl {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 8 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 8;
*(ptr as *const DeviceEnableCtrl)
}
}
impl std::fmt::Debug for DeviceEnableCtrl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceEnableCtrl")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("enable", &self.enable())
.field("pad", &3)
.finish()
}
}
#[derive(Copy, Clone, Debug)]
pub struct DeviceCtlDataParams {
pub control_id: usize,
}
#[derive(Clone, Debug)]
pub enum DeviceCtlData {
Resolution{
first_valuator: u8,
resolution_values: Vec<u32>,
},
AbsCalib{
min_x: i32,
max_x: i32,
min_y: i32,
max_y: i32,
flip_x: u32,
flip_y: u32,
rotation: u32,
button_threshold: u32,
},
Core(u8),
Enable(u8),
AbsArea{
offset_x: u32,
offset_y: u32,
width: i32,
height: i32,
screen: i32,
following: u32,
},
}
impl DeviceCtlData {
pub(crate) fn get_enum(&self) -> DeviceControl {
match self {
DeviceCtlData::Resolution{..} => {
DeviceControl::Resolution
}
DeviceCtlData::AbsCalib{..} => {
DeviceControl::AbsCalib
}
DeviceCtlData::Core{..} => {
DeviceControl::Core
}
DeviceCtlData::Enable{..} => {
DeviceControl::Enable
}
DeviceCtlData::AbsArea{..} => {
DeviceControl::AbsArea
}
}
}
}
impl base::WiredOut for DeviceCtlData {
fn wire_len(&self) -> usize {
let mut sz = 0usize;
match self {
DeviceCtlData::Resolution{
resolution_values,
..
} => {
sz += 1;
sz += 1;
sz += 2;
for el in resolution_values {
sz += el.wire_len();
}
}
DeviceCtlData::AbsCalib{
..
} => {
sz += 4;
sz += 4;
sz += 4;
sz += 4;
sz += 4;
sz += 4;
sz += 4;
sz += 4;
}
DeviceCtlData::Core(
..
) => {
sz += 1;
sz += 3;
}
DeviceCtlData::Enable(
..
) => {
sz += 1;
sz += 3;
}
DeviceCtlData::AbsArea{
..
} => {
sz += 4;
sz += 4;
sz += 4;
sz += 4;
sz += 4;
sz += 4;
}
}
sz
}
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let mut offset = 0usize;
match self {
DeviceCtlData::Resolution{
first_valuator,
resolution_values,
..
} => {
offset += first_valuator.serialize(&mut wire_buf[offset..]);
offset += (resolution_values.len() as u8).serialize(&mut wire_buf[offset..]);
offset += 2;
for el in resolution_values {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
DeviceCtlData::AbsCalib{
min_x,
max_x,
min_y,
max_y,
flip_x,
flip_y,
rotation,
button_threshold,
..
} => {
offset += min_x.serialize(&mut wire_buf[offset..]);
offset += max_x.serialize(&mut wire_buf[offset..]);
offset += min_y.serialize(&mut wire_buf[offset..]);
offset += max_y.serialize(&mut wire_buf[offset..]);
offset += flip_x.serialize(&mut wire_buf[offset..]);
offset += flip_y.serialize(&mut wire_buf[offset..]);
offset += rotation.serialize(&mut wire_buf[offset..]);
offset += button_threshold.serialize(&mut wire_buf[offset..]);
}
DeviceCtlData::Core(
status,
..
) => {
offset += status.serialize(&mut wire_buf[offset..]);
offset += 3;
}
DeviceCtlData::Enable(
enable,
..
) => {
offset += enable.serialize(&mut wire_buf[offset..]);
offset += 3;
}
DeviceCtlData::AbsArea{
offset_x,
offset_y,
width,
height,
screen,
following,
..
} => {
offset += offset_x.serialize(&mut wire_buf[offset..]);
offset += offset_y.serialize(&mut wire_buf[offset..]);
offset += width.serialize(&mut wire_buf[offset..]);
offset += height.serialize(&mut wire_buf[offset..]);
offset += screen.serialize(&mut wire_buf[offset..]);
offset += following.serialize(&mut wire_buf[offset..]);
}
}
offset
}
}
impl base::WiredIn for DeviceCtlData {
type Params = DeviceCtlDataParams;
unsafe fn compute_wire_len(ptr: *const u8, params: Self::Params) -> usize {
let DeviceCtlDataParams {
control_id,
} = params;
let expr = (control_id as usize);
if expr == (DeviceControl::Resolution as usize) {
let mut sz = 0usize;
sz += 1usize;
let num_valuators = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 2usize;
sz += ((num_valuators as usize) * 4usize);
return sz;
}
if expr == (DeviceControl::AbsCalib as usize) {
let mut sz = 0usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
return sz;
}
if expr == (DeviceControl::Core as usize) {
let mut sz = 0usize;
sz += 1usize;
sz += 3usize;
return sz;
}
if expr == (DeviceControl::Enable as usize) {
let mut sz = 0usize;
sz += 1usize;
sz += 3usize;
return sz;
}
if expr == (DeviceControl::AbsArea as usize) {
let mut sz = 0usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
return sz;
}
unreachable!("could not match switch expression in xinput::DeviceCtlData::compute_wire_len")
}
#[allow(unused_assignments)]
unsafe fn unserialize(wire_data: *const u8, params: DeviceCtlDataParams, out_offset: &mut usize) -> DeviceCtlData {
let DeviceCtlDataParams{
control_id,
} = params;
let expr = (control_id as usize);
if expr == (DeviceControl::Resolution as usize) {
let mut offset = 0usize;
let first_valuator = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
let num_valuators = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
offset += 2; let resolution_values = {
let ptr = wire_data.add(offset) as *const u32;
let len = (num_valuators as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u32>();
data.to_vec()
};
*out_offset += offset;
return DeviceCtlData::Resolution{
first_valuator,
resolution_values,
};
}
if expr == (DeviceControl::AbsCalib as usize) {
let mut offset = 0usize;
let min_x = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
let max_x = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
let min_y = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
let max_y = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
let flip_x = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let flip_y = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let rotation = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let button_threshold = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
*out_offset += offset;
return DeviceCtlData::AbsCalib{
min_x,
max_x,
min_y,
max_y,
flip_x,
flip_y,
rotation,
button_threshold,
};
}
if expr == (DeviceControl::Core as usize) {
let mut offset = 0usize;
let status = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
offset += 3; *out_offset += offset;
return DeviceCtlData::Core(
status,
);
}
if expr == (DeviceControl::Enable as usize) {
let mut offset = 0usize;
let enable = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
offset += 3; *out_offset += offset;
return DeviceCtlData::Enable(
enable,
);
}
if expr == (DeviceControl::AbsArea as usize) {
let mut offset = 0usize;
let offset_x = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let offset_y = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let width = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
let height = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
let screen = *(wire_data.add(offset) as *const i32);
offset += std::mem::size_of::<i32>();
let following = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
*out_offset += offset;
return DeviceCtlData::AbsArea{
offset_x,
offset_y,
width,
height,
screen,
following,
};
}
unreachable!("Could not match any expression for DeviceCtlData");
}
}
pub struct DeviceCtl {
data: [u8],
}
#[allow(unused_parens)]
impl DeviceCtl {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceCtl {
debug_assert_eq!(data.as_ref().len(), <&DeviceCtl as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const DeviceCtl)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn control_id(&self) -> DeviceControl {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceControl>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn data(&self) -> DeviceCtlData {
let control_id = self.control_id();
let params = DeviceCtlDataParams {control_id: control_id as usize};
let mut offset = 4usize;
unsafe {
DeviceCtlData::unserialize(
self.wire_ptr().add(offset), params, &mut offset
)
}
}
}
impl base::WiredOut for DeviceCtl {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &DeviceCtl {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
let control_id = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 2usize;
sz += DeviceCtlData::compute_wire_len(ptr.add(sz), DeviceCtlDataParams {control_id: control_id as usize});
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceCtl::from_data(data)
}
}
#[derive(Clone)]
pub struct DeviceCtlBuf {
data: Vec<u8>,
}
impl DeviceCtlBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> DeviceCtlBuf {
debug_assert_eq!(<&DeviceCtl>::compute_wire_len(data.as_ptr(), ()), data.len());
DeviceCtlBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
len: u16,
data: DeviceCtlData,
) -> DeviceCtlBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 2; wire_sz += 2; wire_sz += data.wire_len();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(data.get_enum()) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += data.serialize(&mut wire_buf[wire_off ..]);
DeviceCtlBuf { data: wire_buf }
}
}
}
impl base::WiredIn for DeviceCtlBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&DeviceCtl>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceCtlBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for DeviceCtlBuf {
type Target = DeviceCtl;
fn deref(&self) -> &Self::Target {
unsafe { DeviceCtl::from_data(&self.data) }
}
}
impl std::borrow::Borrow<DeviceCtl> for DeviceCtlBuf {
fn borrow(&self) -> &DeviceCtl {
unsafe { DeviceCtl::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for DeviceCtl {
type Owned = DeviceCtlBuf;
fn to_owned(&self) -> Self::Owned {
DeviceCtlBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for DeviceCtl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceCtl")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("data", &self.data())
.finish()
}
}
impl std::fmt::Debug for DeviceCtlBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceCtlBuf")
.field("control_id", &self.control_id())
.field("len", &self.len())
.field("data", &self.data())
.finish()
}
}
#[derive(Clone)]
pub struct DeviceCtlIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a DeviceCtl>,
}
impl<'a> Iterator for DeviceCtlIterator<'a> {
type Item = &'a DeviceCtl;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&DeviceCtl>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for DeviceCtlIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum PropertyFormat {
N8Bits = 8,
N16Bits = 16,
N32Bits = 32,
}
#[derive(Copy, Clone, Debug)]
#[repr(C)]
pub struct GroupInfo {
pub base: u8,
pub latched: u8,
pub locked: u8,
pub effective: u8,
}
#[test]
fn test_sizeof_group_info() {
assert_eq!(std::mem::size_of::<GroupInfo>(), 4);
}
impl base::WiredOut for GroupInfo {
fn wire_len(&self) -> usize { 4 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let me = unsafe {
std::slice::from_raw_parts(self as *const GroupInfo as _, 4)
};
(&mut wire_buf[..me.len()]).copy_from_slice(me);
4
}
}
impl base::WiredIn for GroupInfo {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 4 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 4;
*(ptr as *const GroupInfo)
}
}
#[derive(Copy, Clone, Debug)]
#[repr(C)]
pub struct ModifierInfo {
pub base: u32,
pub latched: u32,
pub locked: u32,
pub effective: u32,
}
#[test]
fn test_sizeof_modifier_info() {
assert_eq!(std::mem::size_of::<ModifierInfo>(), 16);
}
impl base::WiredOut for ModifierInfo {
fn wire_len(&self) -> usize { 16 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let me = unsafe {
std::slice::from_raw_parts(self as *const ModifierInfo as _, 16)
};
(&mut wire_buf[..me.len()]).copy_from_slice(me);
16
}
}
impl base::WiredIn for ModifierInfo {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 16 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 16;
*(ptr as *const ModifierInfo)
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum HierarchyChangeType {
AddMaster = 1,
RemoveMaster = 2,
AttachSlave = 3,
DetachSlave = 4,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum ChangeMode {
Attach = 1,
Float = 2,
}
pub struct AddMaster {
data: [u8],
}
#[allow(unused_parens)]
impl AddMaster {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &AddMaster {
debug_assert_eq!(data.as_ref().len(), <&AddMaster as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const AddMaster)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn r#type(&self) -> HierarchyChangeType {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, HierarchyChangeType>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
fn name_len(&self) -> u16 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn send_core(&self) -> bool {
let val = unsafe { *(self.wire_ptr().add(6usize)) };
val != 0
}
pub fn enable(&self) -> bool {
let val = unsafe { *(self.wire_ptr().add(7usize)) };
val != 0
}
pub fn name(&self) -> &Lat1Str {
unsafe {
let offset = 8usize;
let len = (self.name_len() as usize) as _;
let ptr = self.wire_ptr().add(offset);
let bytes = std::slice::from_raw_parts(ptr, len);
Lat1Str::from_bytes(bytes)
}
}
}
impl base::WiredOut for AddMaster {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &AddMaster {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 2usize;
sz += 2usize;
let name_len = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 1usize;
sz += 1usize;
sz += (name_len as usize);
sz += base::align_pad(sz, 4);
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
AddMaster::from_data(data)
}
}
#[derive(Clone)]
pub struct AddMasterBuf {
data: Vec<u8>,
}
impl AddMasterBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> AddMasterBuf {
debug_assert_eq!(<&AddMaster>::compute_wire_len(data.as_ptr(), ()), data.len());
AddMasterBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
r#type: HierarchyChangeType,
len: u16,
send_core: bool,
enable: bool,
name: &[u8],
) -> AddMasterBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 2; wire_sz += 2; wire_sz += 2; wire_sz += 1; wire_sz += 1; wire_sz += name.len();
wire_sz += base::align_pad(wire_sz, 4);
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(r#type) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (name.len() as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += (if send_core { 1u8 } else { 0u8 }).serialize(&mut wire_buf[wire_off .. ]);
wire_off += (if enable { 1u8 } else { 0u8 }).serialize(&mut wire_buf[wire_off .. ]);
wire_buf[wire_off .. wire_off + name.len()].copy_from_slice(name);
wire_off += name.len();
wire_off += base::align_pad(wire_off, 4);
AddMasterBuf { data: wire_buf }
}
}
}
impl base::WiredIn for AddMasterBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&AddMaster>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
AddMasterBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for AddMasterBuf {
type Target = AddMaster;
fn deref(&self) -> &Self::Target {
unsafe { AddMaster::from_data(&self.data) }
}
}
impl std::borrow::Borrow<AddMaster> for AddMasterBuf {
fn borrow(&self) -> &AddMaster {
unsafe { AddMaster::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for AddMaster {
type Owned = AddMasterBuf;
fn to_owned(&self) -> Self::Owned {
AddMasterBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for AddMaster {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AddMaster")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("name_len", &self.name_len())
.field("send_core", &self.send_core())
.field("enable", &self.enable())
.field("name", &self.name())
.field("align_pad", &4)
.finish()
}
}
impl std::fmt::Debug for AddMasterBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AddMasterBuf")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("name_len", &self.name_len())
.field("send_core", &self.send_core())
.field("enable", &self.enable())
.field("name", &self.name())
.field("align_pad", &4)
.finish()
}
}
#[derive(Clone)]
pub struct AddMasterIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a AddMaster>,
}
impl<'a> Iterator for AddMasterIterator<'a> {
type Item = &'a AddMaster;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&AddMaster>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for AddMasterIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone)]
pub struct RemoveMaster {
data: [u8; 12],
}
#[allow(unused_parens)]
impl RemoveMaster {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &RemoveMaster {
debug_assert_eq!(data.as_ref().len(), 12);
&*(data.as_ref() as *const [u8] as *const RemoveMaster)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
r#type: HierarchyChangeType,
len: u16,
device: Device,
return_mode: ChangeMode,
return_pointer: Device,
return_keyboard: Device,
) -> RemoveMaster {
unsafe {
let mut wire_buf = [0u8; 12];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(r#type) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += device.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (std::mem::transmute::<_, u32>(return_mode) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += 1; wire_off += return_pointer.serialize(&mut wire_buf[wire_off .. ]);
wire_off += return_keyboard.serialize(&mut wire_buf[wire_off .. ]);
RemoveMaster { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn r#type(&self) -> HierarchyChangeType {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, HierarchyChangeType>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 4usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn return_mode(&self) -> ChangeMode {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, ChangeMode>(val)
}
}
pub fn return_pointer(&self) -> Device {
unsafe {
let mut offset = 8usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn return_keyboard(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
}
#[test]
fn test_sizeof_remove_master() {
assert_eq!(std::mem::size_of::<RemoveMaster>(), 12);
}
impl base::WiredOut for RemoveMaster {
fn wire_len(&self) -> usize { 12 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for RemoveMaster {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 12 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 12;
*(ptr as *const RemoveMaster)
}
}
impl std::fmt::Debug for RemoveMaster {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RemoveMaster")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("device", &self.device())
.field("return_mode", &self.return_mode())
.field("pad", &1)
.field("return_pointer", &self.return_pointer())
.field("return_keyboard", &self.return_keyboard())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct AttachSlave {
data: [u8; 8],
}
#[allow(unused_parens)]
impl AttachSlave {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &AttachSlave {
debug_assert_eq!(data.as_ref().len(), 8);
&*(data.as_ref() as *const [u8] as *const AttachSlave)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
r#type: HierarchyChangeType,
len: u16,
device: Device,
master: Device,
) -> AttachSlave {
unsafe {
let mut wire_buf = [0u8; 8];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(r#type) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += device.serialize(&mut wire_buf[wire_off .. ]);
wire_off += master.serialize(&mut wire_buf[wire_off .. ]);
AttachSlave { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn r#type(&self) -> HierarchyChangeType {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, HierarchyChangeType>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 4usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn master(&self) -> Device {
unsafe {
let mut offset = 6usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
}
#[test]
fn test_sizeof_attach_slave() {
assert_eq!(std::mem::size_of::<AttachSlave>(), 8);
}
impl base::WiredOut for AttachSlave {
fn wire_len(&self) -> usize { 8 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for AttachSlave {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 8 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 8;
*(ptr as *const AttachSlave)
}
}
impl std::fmt::Debug for AttachSlave {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AttachSlave")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("device", &self.device())
.field("master", &self.master())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct DetachSlave {
data: [u8; 8],
}
#[allow(unused_parens)]
impl DetachSlave {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DetachSlave {
debug_assert_eq!(data.as_ref().len(), 8);
&*(data.as_ref() as *const [u8] as *const DetachSlave)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
r#type: HierarchyChangeType,
len: u16,
device: Device,
) -> DetachSlave {
unsafe {
let mut wire_buf = [0u8; 8];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(r#type) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += device.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 2; DetachSlave { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn r#type(&self) -> HierarchyChangeType {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, HierarchyChangeType>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 4usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
}
#[test]
fn test_sizeof_detach_slave() {
assert_eq!(std::mem::size_of::<DetachSlave>(), 8);
}
impl base::WiredOut for DetachSlave {
fn wire_len(&self) -> usize { 8 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for DetachSlave {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 8 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 8;
*(ptr as *const DetachSlave)
}
}
impl std::fmt::Debug for DetachSlave {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DetachSlave")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("device", &self.device())
.field("pad", &2)
.finish()
}
}
#[derive(Copy, Clone, Debug)]
pub struct HierarchyChangeDataParams {
pub r#type: usize,
}
#[derive(Clone, Debug)]
pub enum HierarchyChangeData {
AddMaster{
send_core: bool,
enable: bool,
name: Lat1String,
},
RemoveMaster{
device: Device,
return_mode: ChangeMode,
return_pointer: Device,
return_keyboard: Device,
},
AttachSlave{
device: Device,
master: Device,
},
DetachSlave(Device),
}
impl HierarchyChangeData {
pub(crate) fn get_enum(&self) -> HierarchyChangeType {
match self {
HierarchyChangeData::AddMaster{..} => {
HierarchyChangeType::AddMaster
}
HierarchyChangeData::RemoveMaster{..} => {
HierarchyChangeType::RemoveMaster
}
HierarchyChangeData::AttachSlave{..} => {
HierarchyChangeType::AttachSlave
}
HierarchyChangeData::DetachSlave{..} => {
HierarchyChangeType::DetachSlave
}
}
}
}
impl base::WiredOut for HierarchyChangeData {
fn wire_len(&self) -> usize {
let mut sz = 0usize;
match self {
HierarchyChangeData::AddMaster{
name,
..
} => {
sz += 2;
sz += 1;
sz += 1;
sz += name.len();
sz += base::align_pad(sz, 4);
}
HierarchyChangeData::RemoveMaster{
..
} => {
sz += 2;
sz += 1;
sz += 1;
sz += 2;
sz += 2;
}
HierarchyChangeData::AttachSlave{
..
} => {
sz += 2;
sz += 2;
}
HierarchyChangeData::DetachSlave(
..
) => {
sz += 2;
sz += 2;
}
}
sz
}
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let mut offset = 0usize;
match self {
HierarchyChangeData::AddMaster{
send_core,
enable,
name,
..
} => {
offset += (name.len() as u16).serialize(&mut wire_buf[offset..]);
let send_core: u8 = if *send_core { 1 } else { 0 };
offset += send_core.serialize(&mut wire_buf[offset..]);
let enable: u8 = if *enable { 1 } else { 0 };
offset += enable.serialize(&mut wire_buf[offset..]);
wire_buf[offset..offset+name.len()].copy_from_slice(name.as_bytes());
offset += name.len();
offset += base::align_pad(offset, 4);
}
HierarchyChangeData::RemoveMaster{
device,
return_mode,
return_pointer,
return_keyboard,
..
} => {
offset += device.serialize(&mut wire_buf[offset..]);
offset += (unsafe { std::mem::transmute::<_, u32>(*return_mode) } as u8).serialize(&mut wire_buf[offset..]);
offset += 1;
offset += return_pointer.serialize(&mut wire_buf[offset..]);
offset += return_keyboard.serialize(&mut wire_buf[offset..]);
}
HierarchyChangeData::AttachSlave{
device,
master,
..
} => {
offset += device.serialize(&mut wire_buf[offset..]);
offset += master.serialize(&mut wire_buf[offset..]);
}
HierarchyChangeData::DetachSlave(
device,
..
) => {
offset += device.serialize(&mut wire_buf[offset..]);
offset += 2;
}
}
offset
}
}
impl base::WiredIn for HierarchyChangeData {
type Params = HierarchyChangeDataParams;
unsafe fn compute_wire_len(ptr: *const u8, params: Self::Params) -> usize {
let HierarchyChangeDataParams {
r#type,
} = params;
let expr = (r#type as usize);
if expr == (HierarchyChangeType::AddMaster as usize) {
let mut sz = 0usize;
let name_len = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 1usize;
sz += 1usize;
sz += (name_len as usize);
sz += base::align_pad(sz, 4);
return sz;
}
if expr == (HierarchyChangeType::RemoveMaster as usize) {
let mut sz = 0usize;
sz += 2usize;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 2usize;
return sz;
}
if expr == (HierarchyChangeType::AttachSlave as usize) {
let mut sz = 0usize;
sz += 2usize;
sz += 2usize;
return sz;
}
if expr == (HierarchyChangeType::DetachSlave as usize) {
let mut sz = 0usize;
sz += 2usize;
sz += 2usize;
return sz;
}
unreachable!("could not match switch expression in xinput::HierarchyChangeData::compute_wire_len")
}
#[allow(unused_assignments)]
unsafe fn unserialize(wire_data: *const u8, params: HierarchyChangeDataParams, out_offset: &mut usize) -> HierarchyChangeData {
let HierarchyChangeDataParams{
r#type,
} = params;
let expr = (r#type as usize);
if expr == (HierarchyChangeType::AddMaster as usize) {
let mut offset = 0usize;
let name_len = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let send_core = *(wire_data.add(offset) as *const u8) != 0;
offset += 1;
let enable = *(wire_data.add(offset) as *const u8) != 0;
offset += 1;
let name_ptr = wire_data.add(offset);
let name_bytes = std::slice::from_raw_parts(name_ptr, (name_len as usize));
let name = Lat1String::from_bytes(name_bytes);
offset += name.len();
offset += base::align_pad(offset, 4);
*out_offset += offset;
return HierarchyChangeData::AddMaster{
send_core,
enable,
name,
};
}
if expr == (HierarchyChangeType::RemoveMaster as usize) {
let mut offset = 0usize;
let device = *(wire_data.add(offset) as *const Device);
offset += std::mem::size_of::<Device>();
let return_mode = std::mem::transmute::<_, ChangeMode>(*(wire_data.add(offset) as *const u8) as u32);
offset += 1;
offset += 1; let return_pointer = *(wire_data.add(offset) as *const Device);
offset += std::mem::size_of::<Device>();
let return_keyboard = *(wire_data.add(offset) as *const Device);
offset += std::mem::size_of::<Device>();
*out_offset += offset;
return HierarchyChangeData::RemoveMaster{
device,
return_mode,
return_pointer,
return_keyboard,
};
}
if expr == (HierarchyChangeType::AttachSlave as usize) {
let mut offset = 0usize;
let device = *(wire_data.add(offset) as *const Device);
offset += std::mem::size_of::<Device>();
let master = *(wire_data.add(offset) as *const Device);
offset += std::mem::size_of::<Device>();
*out_offset += offset;
return HierarchyChangeData::AttachSlave{
device,
master,
};
}
if expr == (HierarchyChangeType::DetachSlave as usize) {
let mut offset = 0usize;
let device = *(wire_data.add(offset) as *const Device);
offset += std::mem::size_of::<Device>();
offset += 2; *out_offset += offset;
return HierarchyChangeData::DetachSlave(
device,
);
}
unreachable!("Could not match any expression for HierarchyChangeData");
}
}
pub struct HierarchyChange {
data: [u8],
}
#[allow(unused_parens)]
impl HierarchyChange {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &HierarchyChange {
debug_assert_eq!(data.as_ref().len(), <&HierarchyChange as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const HierarchyChange)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn r#type(&self) -> HierarchyChangeType {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, HierarchyChangeType>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn data(&self) -> HierarchyChangeData {
let r#type = self.r#type();
let params = HierarchyChangeDataParams {r#type: r#type as usize};
let mut offset = 4usize;
unsafe {
HierarchyChangeData::unserialize(
self.wire_ptr().add(offset), params, &mut offset
)
}
}
}
impl base::WiredOut for HierarchyChange {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &HierarchyChange {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
let r#type = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 2usize;
sz += HierarchyChangeData::compute_wire_len(ptr.add(sz), HierarchyChangeDataParams {r#type: r#type as usize});
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
HierarchyChange::from_data(data)
}
}
#[derive(Clone)]
pub struct HierarchyChangeBuf {
data: Vec<u8>,
}
impl HierarchyChangeBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> HierarchyChangeBuf {
debug_assert_eq!(<&HierarchyChange>::compute_wire_len(data.as_ptr(), ()), data.len());
HierarchyChangeBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
len: u16,
data: HierarchyChangeData,
) -> HierarchyChangeBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 2; wire_sz += 2; wire_sz += data.wire_len();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(data.get_enum()) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += data.serialize(&mut wire_buf[wire_off ..]);
HierarchyChangeBuf { data: wire_buf }
}
}
}
impl base::WiredIn for HierarchyChangeBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&HierarchyChange>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
HierarchyChangeBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for HierarchyChangeBuf {
type Target = HierarchyChange;
fn deref(&self) -> &Self::Target {
unsafe { HierarchyChange::from_data(&self.data) }
}
}
impl std::borrow::Borrow<HierarchyChange> for HierarchyChangeBuf {
fn borrow(&self) -> &HierarchyChange {
unsafe { HierarchyChange::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for HierarchyChange {
type Owned = HierarchyChangeBuf;
fn to_owned(&self) -> Self::Owned {
HierarchyChangeBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for HierarchyChange {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("HierarchyChange")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("data", &self.data())
.finish()
}
}
impl std::fmt::Debug for HierarchyChangeBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("HierarchyChangeBuf")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("data", &self.data())
.finish()
}
}
#[derive(Clone)]
pub struct HierarchyChangeIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a HierarchyChange>,
}
impl<'a> Iterator for HierarchyChangeIterator<'a> {
type Item = &'a HierarchyChange;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&HierarchyChange>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for HierarchyChangeIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
bitflags! {
pub struct XiEventMask: u32 {
const DEVICE_CHANGED = 0x00000002;
const KEY_PRESS = 0x00000004;
const KEY_RELEASE = 0x00000008;
const BUTTON_PRESS = 0x00000010;
const BUTTON_RELEASE = 0x00000020;
const MOTION = 0x00000040;
const ENTER = 0x00000080;
const LEAVE = 0x00000100;
const FOCUS_IN = 0x00000200;
const FOCUS_OUT = 0x00000400;
const HIERARCHY = 0x00000800;
const PROPERTY = 0x00001000;
const RAW_KEY_PRESS = 0x00002000;
const RAW_KEY_RELEASE = 0x00004000;
const RAW_BUTTON_PRESS = 0x00008000;
const RAW_BUTTON_RELEASE = 0x00010000;
const RAW_MOTION = 0x00020000;
const TOUCH_BEGIN = 0x00040000;
const TOUCH_UPDATE = 0x00080000;
const TOUCH_END = 0x00100000;
const TOUCH_OWNERSHIP = 0x00200000;
const RAW_TOUCH_BEGIN = 0x00400000;
const RAW_TOUCH_UPDATE = 0x00800000;
const RAW_TOUCH_END = 0x01000000;
const BARRIER_HIT = 0x02000000;
const BARRIER_LEAVE = 0x04000000;
}
}
pub struct EventMask {
data: [u8],
}
#[allow(unused_parens)]
impl EventMask {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &EventMask {
debug_assert_eq!(data.as_ref().len(), <&EventMask as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const EventMask)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn device(&self) -> Device {
unsafe {
let mut offset = 0usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
fn mask_len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn mask(&self) -> &[XiEventMask] {
unsafe {
let offset = 4usize;
let len = (self.mask_len() as usize);
let ptr = self.wire_ptr().add(offset) as *const XiEventMask;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::WiredOut for EventMask {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &EventMask {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 2usize;
let mask_len = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += ((mask_len as usize) * 4usize);
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
EventMask::from_data(data)
}
}
#[derive(Clone)]
pub struct EventMaskBuf {
data: Vec<u8>,
}
impl EventMaskBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> EventMaskBuf {
debug_assert_eq!(<&EventMask>::compute_wire_len(data.as_ptr(), ()), data.len());
EventMaskBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
device: Device,
mask: &[XiEventMask],
) -> EventMaskBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 2; wire_sz += 2; wire_sz += mask.len() * std::mem::size_of::<u32>();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += device.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (mask.len() as u16).serialize(&mut wire_buf[wire_off .. ]);
for el in mask.iter().map(|el| el.bits() as u32) {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
EventMaskBuf { data: wire_buf }
}
}
}
impl base::WiredIn for EventMaskBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&EventMask>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
EventMaskBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for EventMaskBuf {
type Target = EventMask;
fn deref(&self) -> &Self::Target {
unsafe { EventMask::from_data(&self.data) }
}
}
impl std::borrow::Borrow<EventMask> for EventMaskBuf {
fn borrow(&self) -> &EventMask {
unsafe { EventMask::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for EventMask {
type Owned = EventMaskBuf;
fn to_owned(&self) -> Self::Owned {
EventMaskBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for EventMask {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("EventMask")
.field("device", &self.device())
.field("mask_len", &self.mask_len())
.field("mask", &self.mask())
.finish()
}
}
impl std::fmt::Debug for EventMaskBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("EventMaskBuf")
.field("device", &self.device())
.field("mask_len", &self.mask_len())
.field("mask", &self.mask())
.finish()
}
}
#[derive(Clone)]
pub struct EventMaskIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a EventMask>,
}
impl<'a> Iterator for EventMaskIterator<'a> {
type Item = &'a EventMask;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&EventMask>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for EventMaskIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum DeviceClassType {
Key = 0,
Button = 1,
Valuator = 2,
Scroll = 3,
Touch = 8,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum DeviceType {
MasterPointer = 1,
MasterKeyboard = 2,
SlavePointer = 3,
SlaveKeyboard = 4,
FloatingSlave = 5,
}
bitflags! {
pub struct ScrollFlags: u32 {
const NO_EMULATION = 0x00000001;
const PREFERRED = 0x00000002;
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum ScrollType {
Vertical = 1,
Horizontal = 2,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum TouchMode {
Direct = 1,
Dependent = 2,
}
pub struct ButtonClass {
data: [u8],
}
#[allow(unused_parens)]
impl ButtonClass {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &ButtonClass {
debug_assert_eq!(data.as_ref().len(), <&ButtonClass as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const ButtonClass)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn r#type(&self) -> DeviceClassType {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceClassType>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 4usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
fn num_buttons(&self) -> u16 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn state(&self) -> &[u32] {
unsafe {
let offset = 8usize;
let len = (((self.num_buttons() as usize) + 31usize) / 32usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn labels(&self) -> &[xproto::Atom] {
unsafe {
let offset = (8usize + ((((self.num_buttons() as usize) + 31usize) / 32usize) * 4usize));
let len = (self.num_buttons() as usize);
let ptr = self.wire_ptr().add(offset) as *const xproto::Atom;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::WiredOut for ButtonClass {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &ButtonClass {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 2usize;
sz += 2usize;
sz += 2usize;
let num_buttons = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += ((((num_buttons as usize) + 31usize) / 32usize) * 4usize);
sz += ((num_buttons as usize) * 4usize);
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
ButtonClass::from_data(data)
}
}
#[derive(Clone)]
pub struct ButtonClassBuf {
data: Vec<u8>,
}
impl ButtonClassBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> ButtonClassBuf {
debug_assert_eq!(<&ButtonClass>::compute_wire_len(data.as_ptr(), ()), data.len());
ButtonClassBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
r#type: DeviceClassType,
len: u16,
source: Device,
state: &[u32],
labels: &[xproto::Atom],
) -> ButtonClassBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 2; wire_sz += 2; wire_sz += 2; wire_sz += 2; wire_sz += state.iter().map(|el| el.wire_len()).sum::<usize>();
wire_sz += labels.iter().map(|el| el.wire_len()).sum::<usize>();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(r#type) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += source.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (labels.len() as u16).serialize(&mut wire_buf[wire_off .. ]);
for el in state {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
for el in labels {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
ButtonClassBuf { data: wire_buf }
}
}
}
impl base::WiredIn for ButtonClassBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&ButtonClass>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
ButtonClassBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for ButtonClassBuf {
type Target = ButtonClass;
fn deref(&self) -> &Self::Target {
unsafe { ButtonClass::from_data(&self.data) }
}
}
impl std::borrow::Borrow<ButtonClass> for ButtonClassBuf {
fn borrow(&self) -> &ButtonClass {
unsafe { ButtonClass::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for ButtonClass {
type Owned = ButtonClassBuf;
fn to_owned(&self) -> Self::Owned {
ButtonClassBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for ButtonClass {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ButtonClass")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("source", &self.source())
.field("num_buttons", &self.num_buttons())
.field("state", &self.state())
.field("labels", &self.labels())
.finish()
}
}
impl std::fmt::Debug for ButtonClassBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ButtonClassBuf")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("source", &self.source())
.field("num_buttons", &self.num_buttons())
.field("state", &self.state())
.field("labels", &self.labels())
.finish()
}
}
#[derive(Clone)]
pub struct ButtonClassIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a ButtonClass>,
}
impl<'a> Iterator for ButtonClassIterator<'a> {
type Item = &'a ButtonClass;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&ButtonClass>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for ButtonClassIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
pub struct KeyClass {
data: [u8],
}
#[allow(unused_parens)]
impl KeyClass {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &KeyClass {
debug_assert_eq!(data.as_ref().len(), <&KeyClass as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const KeyClass)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn r#type(&self) -> DeviceClassType {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceClassType>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 4usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
fn num_keys(&self) -> u16 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn keys(&self) -> &[u32] {
unsafe {
let offset = 8usize;
let len = (self.num_keys() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::WiredOut for KeyClass {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &KeyClass {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 2usize;
sz += 2usize;
sz += 2usize;
let num_keys = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += ((num_keys as usize) * 4usize);
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
KeyClass::from_data(data)
}
}
#[derive(Clone)]
pub struct KeyClassBuf {
data: Vec<u8>,
}
impl KeyClassBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> KeyClassBuf {
debug_assert_eq!(<&KeyClass>::compute_wire_len(data.as_ptr(), ()), data.len());
KeyClassBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
r#type: DeviceClassType,
len: u16,
source: Device,
keys: &[u32],
) -> KeyClassBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 2; wire_sz += 2; wire_sz += 2; wire_sz += 2; wire_sz += keys.iter().map(|el| el.wire_len()).sum::<usize>();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(r#type) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += source.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (keys.len() as u16).serialize(&mut wire_buf[wire_off .. ]);
for el in keys {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
KeyClassBuf { data: wire_buf }
}
}
}
impl base::WiredIn for KeyClassBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&KeyClass>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
KeyClassBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for KeyClassBuf {
type Target = KeyClass;
fn deref(&self) -> &Self::Target {
unsafe { KeyClass::from_data(&self.data) }
}
}
impl std::borrow::Borrow<KeyClass> for KeyClassBuf {
fn borrow(&self) -> &KeyClass {
unsafe { KeyClass::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for KeyClass {
type Owned = KeyClassBuf;
fn to_owned(&self) -> Self::Owned {
KeyClassBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for KeyClass {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("KeyClass")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("source", &self.source())
.field("num_keys", &self.num_keys())
.field("keys", &self.keys())
.finish()
}
}
impl std::fmt::Debug for KeyClassBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("KeyClassBuf")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("source", &self.source())
.field("num_keys", &self.num_keys())
.field("keys", &self.keys())
.finish()
}
}
#[derive(Clone)]
pub struct KeyClassIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a KeyClass>,
}
impl<'a> Iterator for KeyClassIterator<'a> {
type Item = &'a KeyClass;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&KeyClass>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for KeyClassIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone)]
pub struct ScrollClass {
data: [u8; 24],
}
#[allow(unused_parens)]
impl ScrollClass {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &ScrollClass {
debug_assert_eq!(data.as_ref().len(), 24);
&*(data.as_ref() as *const [u8] as *const ScrollClass)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
r#type: DeviceClassType,
len: u16,
source: Device,
number: u16,
scroll_type: ScrollType,
flags: ScrollFlags,
increment: Fp3232,
) -> ScrollClass {
unsafe {
let mut wire_buf = [0u8; 24];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(r#type) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += source.serialize(&mut wire_buf[wire_off .. ]);
wire_off += number.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (std::mem::transmute::<_, u32>(scroll_type) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += 2; wire_off += flags.bits().serialize(&mut wire_buf[wire_off .. ]);
wire_off += increment.serialize(&mut wire_buf[wire_off .. ]);
ScrollClass { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn r#type(&self) -> DeviceClassType {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceClassType>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 4usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn number(&self) -> u16 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn scroll_type(&self) -> ScrollType {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, ScrollType>(val)
}
}
pub fn flags(&self) -> ScrollFlags {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, ScrollFlags>(val)
}
}
pub fn increment(&self) -> Fp3232 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_scroll_class() {
assert_eq!(std::mem::size_of::<ScrollClass>(), 24);
}
impl base::WiredOut for ScrollClass {
fn wire_len(&self) -> usize { 24 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for ScrollClass {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 24 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 24;
*(ptr as *const ScrollClass)
}
}
impl std::fmt::Debug for ScrollClass {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ScrollClass")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("source", &self.source())
.field("number", &self.number())
.field("scroll_type", &self.scroll_type())
.field("pad", &2)
.field("flags", &self.flags())
.field("increment", &self.increment())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct TouchClass {
data: [u8; 8],
}
#[allow(unused_parens)]
impl TouchClass {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &TouchClass {
debug_assert_eq!(data.as_ref().len(), 8);
&*(data.as_ref() as *const [u8] as *const TouchClass)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
r#type: DeviceClassType,
len: u16,
source: Device,
mode: TouchMode,
num_touches: u8,
) -> TouchClass {
unsafe {
let mut wire_buf = [0u8; 8];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(r#type) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += source.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (std::mem::transmute::<_, u32>(mode) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += num_touches.serialize(&mut wire_buf[wire_off .. ]);
TouchClass { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn r#type(&self) -> DeviceClassType {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceClassType>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 4usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn mode(&self) -> TouchMode {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, TouchMode>(val)
}
}
pub fn num_touches(&self) -> u8 {
unsafe {
let offset = 7usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_touch_class() {
assert_eq!(std::mem::size_of::<TouchClass>(), 8);
}
impl base::WiredOut for TouchClass {
fn wire_len(&self) -> usize { 8 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for TouchClass {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 8 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 8;
*(ptr as *const TouchClass)
}
}
impl std::fmt::Debug for TouchClass {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("TouchClass")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("source", &self.source())
.field("mode", &self.mode())
.field("num_touches", &self.num_touches())
.finish()
}
}
#[derive(Copy, Clone)]
pub struct ValuatorClass {
data: [u8; 44],
}
#[allow(unused_parens)]
impl ValuatorClass {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &ValuatorClass {
debug_assert_eq!(data.as_ref().len(), 44);
&*(data.as_ref() as *const [u8] as *const ValuatorClass)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
r#type: DeviceClassType,
len: u16,
source: Device,
number: u16,
label: xproto::Atom,
min: Fp3232,
max: Fp3232,
value: Fp3232,
resolution: u32,
mode: ValuatorMode,
) -> ValuatorClass {
unsafe {
let mut wire_buf = [0u8; 44];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(r#type) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += source.serialize(&mut wire_buf[wire_off .. ]);
wire_off += number.serialize(&mut wire_buf[wire_off .. ]);
wire_off += label.serialize(&mut wire_buf[wire_off .. ]);
wire_off += min.serialize(&mut wire_buf[wire_off .. ]);
wire_off += max.serialize(&mut wire_buf[wire_off .. ]);
wire_off += value.serialize(&mut wire_buf[wire_off .. ]);
wire_off += resolution.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (std::mem::transmute::<_, u32>(mode) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += 3; ValuatorClass { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn r#type(&self) -> DeviceClassType {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceClassType>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 4usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn number(&self) -> u16 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn label(&self) -> xproto::Atom {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Atom;
base::value_from_ptr(ptr)
}
}
pub fn min(&self) -> Fp3232 {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
base::value_from_ptr(ptr)
}
}
pub fn max(&self) -> Fp3232 {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
base::value_from_ptr(ptr)
}
}
pub fn value(&self) -> Fp3232 {
unsafe {
let offset = 28usize;
let ptr = self.wire_ptr().add(offset) as *const Fp3232;
base::value_from_ptr(ptr)
}
}
pub fn resolution(&self) -> u32 {
unsafe {
let offset = 36usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn mode(&self) -> ValuatorMode {
unsafe {
let offset = 40usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, ValuatorMode>(val)
}
}
}
#[test]
fn test_sizeof_valuator_class() {
assert_eq!(std::mem::size_of::<ValuatorClass>(), 44);
}
impl base::WiredOut for ValuatorClass {
fn wire_len(&self) -> usize { 44 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for ValuatorClass {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 44 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 44;
*(ptr as *const ValuatorClass)
}
}
impl std::fmt::Debug for ValuatorClass {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ValuatorClass")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("source", &self.source())
.field("number", &self.number())
.field("label", &self.label())
.field("min", &self.min())
.field("max", &self.max())
.field("value", &self.value())
.field("resolution", &self.resolution())
.field("mode", &self.mode())
.field("pad", &3)
.finish()
}
}
#[derive(Copy, Clone, Debug)]
pub struct DeviceClassDataParams {
pub r#type: usize,
}
#[derive(Clone, Debug)]
pub enum DeviceClassData {
Key{
keys: Vec<u32>,
},
Button{
state: Vec<u32>,
labels: Vec<xproto::Atom>,
},
Valuator{
number: u16,
label: xproto::Atom,
min: Fp3232,
max: Fp3232,
value: Fp3232,
resolution: u32,
mode: ValuatorMode,
},
Scroll{
number: u16,
scroll_type: ScrollType,
flags: ScrollFlags,
increment: Fp3232,
},
Touch{
mode: TouchMode,
num_touches: u8,
},
}
impl DeviceClassData {
pub(crate) fn get_enum(&self) -> DeviceClassType {
match self {
DeviceClassData::Key{..} => {
DeviceClassType::Key
}
DeviceClassData::Button{..} => {
DeviceClassType::Button
}
DeviceClassData::Valuator{..} => {
DeviceClassType::Valuator
}
DeviceClassData::Scroll{..} => {
DeviceClassType::Scroll
}
DeviceClassData::Touch{..} => {
DeviceClassType::Touch
}
}
}
}
impl base::WiredOut for DeviceClassData {
fn wire_len(&self) -> usize {
let mut sz = 0usize;
match self {
DeviceClassData::Key{
keys,
..
} => {
sz += 2;
for el in keys {
sz += el.wire_len();
}
}
DeviceClassData::Button{
state,
labels,
..
} => {
sz += 2;
for el in state {
sz += el.wire_len();
}
for el in labels {
sz += el.wire_len();
}
}
DeviceClassData::Valuator{
..
} => {
sz += 2;
sz += 4;
sz += 8;
sz += 8;
sz += 8;
sz += 4;
sz += 1;
sz += 3;
}
DeviceClassData::Scroll{
..
} => {
sz += 2;
sz += 2;
sz += 2;
sz += 4;
sz += 8;
}
DeviceClassData::Touch{
..
} => {
sz += 1;
sz += 1;
}
}
sz
}
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let mut offset = 0usize;
match self {
DeviceClassData::Key{
keys,
..
} => {
offset += (keys.len() as u16).serialize(&mut wire_buf[offset..]);
for el in keys {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
DeviceClassData::Button{
state,
labels,
..
} => {
offset += (labels.len() as u16).serialize(&mut wire_buf[offset..]);
for el in state {
offset += el.serialize(&mut wire_buf[offset..]);
}
for el in labels {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
DeviceClassData::Valuator{
number,
label,
min,
max,
value,
resolution,
mode,
..
} => {
offset += number.serialize(&mut wire_buf[offset..]);
offset += label.serialize(&mut wire_buf[offset..]);
offset += min.serialize(&mut wire_buf[offset..]);
offset += max.serialize(&mut wire_buf[offset..]);
offset += value.serialize(&mut wire_buf[offset..]);
offset += resolution.serialize(&mut wire_buf[offset..]);
offset += (unsafe { std::mem::transmute::<_, u32>(*mode) } as u8).serialize(&mut wire_buf[offset..]);
offset += 3;
}
DeviceClassData::Scroll{
number,
scroll_type,
flags,
increment,
..
} => {
offset += number.serialize(&mut wire_buf[offset..]);
offset += (unsafe { std::mem::transmute::<_, u32>(*scroll_type) } as u16).serialize(&mut wire_buf[offset..]);
offset += 2;
offset += (flags.bits() as u32).serialize(&mut wire_buf[offset..]);
offset += increment.serialize(&mut wire_buf[offset..]);
}
DeviceClassData::Touch{
mode,
num_touches,
..
} => {
offset += (unsafe { std::mem::transmute::<_, u32>(*mode) } as u8).serialize(&mut wire_buf[offset..]);
offset += num_touches.serialize(&mut wire_buf[offset..]);
}
}
offset
}
}
impl base::WiredIn for DeviceClassData {
type Params = DeviceClassDataParams;
unsafe fn compute_wire_len(ptr: *const u8, params: Self::Params) -> usize {
let DeviceClassDataParams {
r#type,
} = params;
let expr = (r#type as usize);
if expr == (DeviceClassType::Key as usize) {
let mut sz = 0usize;
let num_keys = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += ((num_keys as usize) * 4usize);
return sz;
}
if expr == (DeviceClassType::Button as usize) {
let mut sz = 0usize;
let num_buttons = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += ((((num_buttons as usize) + 31usize) / 32usize) * 4usize);
sz += ((num_buttons as usize) * 4usize);
return sz;
}
if expr == (DeviceClassType::Valuator as usize) {
let mut sz = 0usize;
sz += 2usize;
sz += 4usize;
sz += 8usize;
sz += 8usize;
sz += 8usize;
sz += 4usize;
sz += 1usize;
sz += 3usize;
return sz;
}
if expr == (DeviceClassType::Scroll as usize) {
let mut sz = 0usize;
sz += 2usize;
sz += 2usize;
sz += 2usize;
sz += 4usize;
sz += 8usize;
return sz;
}
if expr == (DeviceClassType::Touch as usize) {
let mut sz = 0usize;
sz += 1usize;
sz += 1usize;
return sz;
}
unreachable!("could not match switch expression in xinput::DeviceClassData::compute_wire_len")
}
#[allow(unused_assignments)]
unsafe fn unserialize(wire_data: *const u8, params: DeviceClassDataParams, out_offset: &mut usize) -> DeviceClassData {
let DeviceClassDataParams{
r#type,
} = params;
let expr = (r#type as usize);
if expr == (DeviceClassType::Key as usize) {
let mut offset = 0usize;
let num_keys = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let keys = {
let ptr = wire_data.add(offset) as *const u32;
let len = (num_keys as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u32>();
data.to_vec()
};
*out_offset += offset;
return DeviceClassData::Key{
keys,
};
}
if expr == (DeviceClassType::Button as usize) {
let mut offset = 0usize;
let num_buttons = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let state = {
let ptr = wire_data.add(offset) as *const u32;
let len = (((num_buttons as usize) + 31usize) / 32usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u32>();
data.to_vec()
};
let labels = {
let ptr = wire_data.add(offset) as *const xproto::Atom;
let len = (num_buttons as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<xproto::Atom>();
data.to_vec()
};
*out_offset += offset;
return DeviceClassData::Button{
state,
labels,
};
}
if expr == (DeviceClassType::Valuator as usize) {
let mut offset = 0usize;
let number = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let label = *(wire_data.add(offset) as *const xproto::Atom);
offset += std::mem::size_of::<xproto::Atom>();
let min = *(wire_data.add(offset) as *const Fp3232);
offset += std::mem::size_of::<Fp3232>();
let max = *(wire_data.add(offset) as *const Fp3232);
offset += std::mem::size_of::<Fp3232>();
let value = *(wire_data.add(offset) as *const Fp3232);
offset += std::mem::size_of::<Fp3232>();
let resolution = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let mode = std::mem::transmute::<_, ValuatorMode>(*(wire_data.add(offset) as *const u8) as u32);
offset += 1;
offset += 3; *out_offset += offset;
return DeviceClassData::Valuator{
number,
label,
min,
max,
value,
resolution,
mode,
};
}
if expr == (DeviceClassType::Scroll as usize) {
let mut offset = 0usize;
let number = *(wire_data.add(offset) as *const u16);
offset += std::mem::size_of::<u16>();
let scroll_type = std::mem::transmute::<_, ScrollType>(*(wire_data.add(offset) as *const u16) as u32);
offset += 2;
offset += 2; let flags = *(wire_data.add(offset) as *const u32);
offset += std::mem::size_of::<u32>();
let increment = *(wire_data.add(offset) as *const Fp3232);
offset += std::mem::size_of::<Fp3232>();
*out_offset += offset;
return DeviceClassData::Scroll{
number,
scroll_type,
flags: ScrollFlags::from_bits(flags as u32).unwrap(),
increment,
};
}
if expr == (DeviceClassType::Touch as usize) {
let mut offset = 0usize;
let mode = std::mem::transmute::<_, TouchMode>(*(wire_data.add(offset) as *const u8) as u32);
offset += 1;
let num_touches = *(wire_data.add(offset) as *const u8);
offset += std::mem::size_of::<u8>();
*out_offset += offset;
return DeviceClassData::Touch{
mode,
num_touches,
};
}
unreachable!("Could not match any expression for DeviceClassData");
}
}
pub struct DeviceClass {
data: [u8],
}
#[allow(unused_parens)]
impl DeviceClass {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &DeviceClass {
debug_assert_eq!(data.as_ref().len(), <&DeviceClass as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const DeviceClass)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn r#type(&self) -> DeviceClassType {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceClassType>(val)
}
}
pub fn len(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn source(&self) -> Device {
unsafe {
let mut offset = 4usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn data(&self) -> DeviceClassData {
let r#type = self.r#type();
let params = DeviceClassDataParams {r#type: r#type as usize};
let mut offset = 6usize;
unsafe {
DeviceClassData::unserialize(
self.wire_ptr().add(offset), params, &mut offset
)
}
}
}
impl base::WiredOut for DeviceClass {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &DeviceClass {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
let r#type = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 2usize;
sz += 2usize;
sz += DeviceClassData::compute_wire_len(ptr.add(sz), DeviceClassDataParams {r#type: r#type as usize});
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceClass::from_data(data)
}
}
#[derive(Clone)]
pub struct DeviceClassBuf {
data: Vec<u8>,
}
impl DeviceClassBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> DeviceClassBuf {
debug_assert_eq!(<&DeviceClass>::compute_wire_len(data.as_ptr(), ()), data.len());
DeviceClassBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
len: u16,
source: Device,
data: DeviceClassData,
) -> DeviceClassBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 2; wire_sz += 2; wire_sz += 2; wire_sz += data.wire_len();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += (std::mem::transmute::<_, u32>(data.get_enum()) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += len.serialize(&mut wire_buf[wire_off .. ]);
wire_off += source.serialize(&mut wire_buf[wire_off .. ]);
wire_off += data.serialize(&mut wire_buf[wire_off ..]);
DeviceClassBuf { data: wire_buf }
}
}
}
impl base::WiredIn for DeviceClassBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&DeviceClass>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
DeviceClassBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for DeviceClassBuf {
type Target = DeviceClass;
fn deref(&self) -> &Self::Target {
unsafe { DeviceClass::from_data(&self.data) }
}
}
impl std::borrow::Borrow<DeviceClass> for DeviceClassBuf {
fn borrow(&self) -> &DeviceClass {
unsafe { DeviceClass::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for DeviceClass {
type Owned = DeviceClassBuf;
fn to_owned(&self) -> Self::Owned {
DeviceClassBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for DeviceClass {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceClass")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("source", &self.source())
.field("data", &self.data())
.finish()
}
}
impl std::fmt::Debug for DeviceClassBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceClassBuf")
.field("r#type", &self.r#type())
.field("len", &self.len())
.field("source", &self.source())
.field("data", &self.data())
.finish()
}
}
#[derive(Clone)]
pub struct DeviceClassIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a DeviceClass>,
}
impl<'a> Iterator for DeviceClassIterator<'a> {
type Item = &'a DeviceClass;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&DeviceClass>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for DeviceClassIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
pub struct XiDeviceInfo {
data: [u8],
}
#[allow(unused_parens)]
impl XiDeviceInfo {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &XiDeviceInfo {
debug_assert_eq!(data.as_ref().len(), <&XiDeviceInfo as base::WiredIn>::compute_wire_len(data.as_ref().as_ptr(), ()));
&*(data.as_ref() as *const [u8] as *const XiDeviceInfo)
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
pub fn device(&self) -> Device {
unsafe {
let mut offset = 0usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn r#type(&self) -> DeviceType {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceType>(val)
}
}
pub fn attachment(&self) -> Device {
unsafe {
let mut offset = 4usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
fn num_classes(&self) -> u16 {
unsafe {
let offset = 6usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
fn name_len(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn enabled(&self) -> bool {
let val = unsafe { *(self.wire_ptr().add(10usize)) };
val != 0
}
pub fn name(&self) -> &Lat1Str {
unsafe {
let offset = 12usize;
let len = (self.name_len() as usize) as _;
let ptr = self.wire_ptr().add(offset);
let bytes = std::slice::from_raw_parts(ptr, len);
Lat1Str::from_bytes(bytes)
}
}
pub fn classes(&self) -> DeviceClassIterator {
unsafe {
let offset = ((12usize + (self.name_len() as usize)) + base::align_pad((12usize + (self.name_len() as usize)), 4));
DeviceClassIterator {
params: (),
rem: (self.num_classes() as usize),
ptr: self.wire_ptr().add(offset),
phantom: std::marker::PhantomData,
}
}
}
}
impl base::WiredOut for XiDeviceInfo {
fn wire_len(&self) -> usize { self.data.len() }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for &XiDeviceInfo {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 2usize;
sz += 2usize;
sz += 2usize;
let num_classes = *(ptr.add(sz) as *const u16);
sz += 2usize;
let name_len = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 1usize;
sz += 1usize;
sz += (name_len as usize);
sz += base::align_pad(sz, 4);
for _ in 0 .. (num_classes as usize) {
sz += <&DeviceClass>::compute_wire_len(ptr.add(sz), ());
}
sz
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
XiDeviceInfo::from_data(data)
}
}
#[derive(Clone)]
pub struct XiDeviceInfoBuf {
data: Vec<u8>,
}
impl XiDeviceInfoBuf {
pub(crate) unsafe fn from_data(data: Vec<u8>) -> XiDeviceInfoBuf {
debug_assert_eq!(<&XiDeviceInfo>::compute_wire_len(data.as_ptr(), ()), data.len());
XiDeviceInfoBuf { data }
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
device: Device,
r#type: DeviceType,
attachment: Device,
enabled: bool,
name: &[u8],
classes: &[DeviceClassBuf],
) -> XiDeviceInfoBuf {
unsafe {
let mut wire_sz = 0usize;
wire_sz += 2; wire_sz += 2; wire_sz += 2; wire_sz += 2; wire_sz += 2; wire_sz += 1; wire_sz += 1; wire_sz += name.len();
wire_sz += base::align_pad(wire_sz, 4);
wire_sz += classes.iter().map(|el| el.wire_len()).sum::<usize>();
let mut wire_buf = vec![0u8; wire_sz];
let mut wire_off = 0usize;
wire_off += device.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (std::mem::transmute::<_, u32>(r#type) as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += attachment.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (classes.len() as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += (name.len() as u16).serialize(&mut wire_buf[wire_off .. ]);
wire_off += (if enabled { 1u8 } else { 0u8 }).serialize(&mut wire_buf[wire_off .. ]);
wire_off += 1; wire_buf[wire_off .. wire_off + name.len()].copy_from_slice(name);
wire_off += name.len();
wire_off += base::align_pad(wire_off, 4);
for el in classes {
wire_off += el.serialize(&mut wire_buf[wire_off ..]);
}
XiDeviceInfoBuf { data: wire_buf }
}
}
}
impl base::WiredIn for XiDeviceInfoBuf {
type Params = ();
unsafe fn compute_wire_len(ptr: *const u8, params: ()) -> usize {
<&XiDeviceInfo>::compute_wire_len(ptr, params)
}
unsafe fn unserialize(ptr: *const u8, params: (), offset: &mut usize) -> Self {
let sz = Self::compute_wire_len(ptr, params);
*offset += sz;
let data = std::slice::from_raw_parts(ptr, sz);
XiDeviceInfoBuf::from_data(data.to_vec())
}
}
impl std::ops::Deref for XiDeviceInfoBuf {
type Target = XiDeviceInfo;
fn deref(&self) -> &Self::Target {
unsafe { XiDeviceInfo::from_data(&self.data) }
}
}
impl std::borrow::Borrow<XiDeviceInfo> for XiDeviceInfoBuf {
fn borrow(&self) -> &XiDeviceInfo {
unsafe { XiDeviceInfo::from_data(&self.data) }
}
}
impl std::borrow::ToOwned for XiDeviceInfo {
type Owned = XiDeviceInfoBuf;
fn to_owned(&self) -> Self::Owned {
XiDeviceInfoBuf {
data: self.data.to_vec()
}
}
}
impl std::fmt::Debug for XiDeviceInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XiDeviceInfo")
.field("device", &self.device())
.field("r#type", &self.r#type())
.field("attachment", &self.attachment())
.field("num_classes", &self.num_classes())
.field("name_len", &self.name_len())
.field("enabled", &self.enabled())
.field("pad", &1)
.field("name", &self.name())
.field("align_pad", &4)
.field("classes", &self.classes())
.finish()
}
}
impl std::fmt::Debug for XiDeviceInfoBuf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XiDeviceInfoBuf")
.field("device", &self.device())
.field("r#type", &self.r#type())
.field("attachment", &self.attachment())
.field("num_classes", &self.num_classes())
.field("name_len", &self.name_len())
.field("enabled", &self.enabled())
.field("pad", &1)
.field("name", &self.name())
.field("align_pad", &4)
.field("classes", &self.classes())
.finish()
}
}
#[derive(Clone)]
pub struct XiDeviceInfoIterator<'a> {
pub(crate) params: (),
pub(crate) rem: usize,
pub(crate) ptr: *const u8,
pub(crate) phantom: std::marker::PhantomData<&'a XiDeviceInfo>,
}
impl<'a> Iterator for XiDeviceInfoIterator<'a> {
type Item = &'a XiDeviceInfo;
fn next(&mut self) -> std::option::Option<Self::Item> {
if self.rem == 0 {
None
} else { unsafe {
self.rem -= 1;
let mut offset = 0;
let res = <&XiDeviceInfo>::unserialize(self.ptr, self.params, &mut offset);
self.ptr = self.ptr.add(offset);
Some(res)
}}
}
}
impl<'a> std::fmt::Debug for XiDeviceInfoIterator<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum GrabOwner {
NoOwner = 0,
Owner = 1,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum EventMode {
AsyncDevice = 0,
SyncDevice = 1,
ReplayDevice = 2,
AsyncPairedDevice = 3,
AsyncPair = 4,
SyncPair = 5,
AcceptTouch = 6,
RejectTouch = 7,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum GrabMode22 {
Sync = 0,
Async = 1,
Touch = 2,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum GrabType {
Button = 0,
Keycode = 1,
Enter = 2,
FocusIn = 3,
TouchBegin = 4,
}
bitflags! {
pub struct ModifierMask: u32 {
const ANY = 0x80000000;
}
}
#[derive(Copy, Clone)]
pub struct GrabModifierInfo {
data: [u8; 8],
}
#[allow(unused_parens)]
impl GrabModifierInfo {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &GrabModifierInfo {
debug_assert_eq!(data.as_ref().len(), 8);
&*(data.as_ref() as *const [u8] as *const GrabModifierInfo)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
modifiers: u32,
status: xproto::GrabStatus,
) -> GrabModifierInfo {
unsafe {
let mut wire_buf = [0u8; 8];
let mut wire_off = 0usize;
wire_off += modifiers.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (std::mem::transmute::<_, u32>(status) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += 3; GrabModifierInfo { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn modifiers(&self) -> u32 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> xproto::GrabStatus {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::GrabStatus>(val)
}
}
}
#[test]
fn test_sizeof_grab_modifier_info() {
assert_eq!(std::mem::size_of::<GrabModifierInfo>(), 8);
}
impl base::WiredOut for GrabModifierInfo {
fn wire_len(&self) -> usize { 8 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for GrabModifierInfo {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 8 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 8;
*(ptr as *const GrabModifierInfo)
}
}
impl std::fmt::Debug for GrabModifierInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GrabModifierInfo")
.field("modifiers", &self.modifiers())
.field("status", &self.status())
.field("pad", &3)
.finish()
}
}
#[derive(Copy, Clone)]
pub struct BarrierReleasePointerInfo {
data: [u8; 12],
}
#[allow(unused_parens)]
impl BarrierReleasePointerInfo {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &BarrierReleasePointerInfo {
debug_assert_eq!(data.as_ref().len(), 12);
&*(data.as_ref() as *const [u8] as *const BarrierReleasePointerInfo)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
device: Device,
barrier: xfixes::Barrier,
eventid: u32,
) -> BarrierReleasePointerInfo {
unsafe {
let mut wire_buf = [0u8; 12];
let mut wire_off = 0usize;
wire_off += device.serialize(&mut wire_buf[wire_off .. ]);
wire_off += 2; wire_off += barrier.serialize(&mut wire_buf[wire_off .. ]);
wire_off += eventid.serialize(&mut wire_buf[wire_off .. ]);
BarrierReleasePointerInfo { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn device(&self) -> Device {
unsafe {
let mut offset = 0usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn barrier(&self) -> xfixes::Barrier {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const xfixes::Barrier;
base::value_from_ptr(ptr)
}
}
pub fn eventid(&self) -> u32 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
}
#[test]
fn test_sizeof_barrier_release_pointer_info() {
assert_eq!(std::mem::size_of::<BarrierReleasePointerInfo>(), 12);
}
impl base::WiredOut for BarrierReleasePointerInfo {
fn wire_len(&self) -> usize { 12 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for BarrierReleasePointerInfo {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 12 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 12;
*(ptr as *const BarrierReleasePointerInfo)
}
}
impl std::fmt::Debug for BarrierReleasePointerInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BarrierReleasePointerInfo")
.field("device", &self.device())
.field("pad", &2)
.field("barrier", &self.barrier())
.field("eventid", &self.eventid())
.finish()
}
}
bitflags! {
pub struct MoreEventsMask: u32 {
const MORE_EVENTS = 0x00000080;
}
}
bitflags! {
pub struct ClassesReportedMask: u32 {
const OUT_OF_PROXIMITY = 0x00000080;
const DEVICE_MODE_ABSOLUTE = 0x00000040;
const REPORTING_VALUATORS = 0x00000004;
const REPORTING_BUTTONS = 0x00000002;
const REPORTING_KEYS = 0x00000001;
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum ChangeDevice {
NewPointer = 0,
NewKeyboard = 1,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum DeviceChange {
Added = 0,
Removed = 1,
Enabled = 2,
Disabled = 3,
Unrecoverable = 4,
ControlChanged = 5,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum ChangeReason {
SlaveSwitch = 1,
DeviceChange = 2,
}
bitflags! {
pub struct KeyEventFlags: u32 {
const KEY_REPEAT = 0x00010000;
}
}
bitflags! {
pub struct PointerEventFlags: u32 {
const POINTER_EMULATED = 0x00010000;
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum NotifyMode {
Normal = 0,
Grab = 1,
Ungrab = 2,
WhileGrabbed = 3,
PassiveGrab = 4,
PassiveUngrab = 5,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum NotifyDetail {
Ancestor = 0,
Virtual = 1,
Inferior = 2,
Nonlinear = 3,
NonlinearVirtual = 4,
Pointer = 5,
PointerRoot = 6,
None = 7,
}
bitflags! {
pub struct HierarchyMask: u32 {
const MASTER_ADDED = 0x00000001;
const MASTER_REMOVED = 0x00000002;
const SLAVE_ADDED = 0x00000004;
const SLAVE_REMOVED = 0x00000008;
const SLAVE_ATTACHED = 0x00000010;
const SLAVE_DETACHED = 0x00000020;
const DEVICE_ENABLED = 0x00000040;
const DEVICE_DISABLED = 0x00000080;
}
}
#[derive(Copy, Clone)]
pub struct HierarchyInfo {
data: [u8; 12],
}
#[allow(unused_parens)]
impl HierarchyInfo {
pub(crate) unsafe fn from_data<D: AsRef<[u8]> + ?Sized>(data: &D) -> &HierarchyInfo {
debug_assert_eq!(data.as_ref().len(), 12);
&*(data.as_ref() as *const [u8] as *const HierarchyInfo)
}
#[allow(unused_assignments, unused_unsafe)]
pub fn new(
device: Device,
attachment: Device,
r#type: DeviceType,
enabled: bool,
flags: HierarchyMask,
) -> HierarchyInfo {
unsafe {
let mut wire_buf = [0u8; 12];
let mut wire_off = 0usize;
wire_off += device.serialize(&mut wire_buf[wire_off .. ]);
wire_off += attachment.serialize(&mut wire_buf[wire_off .. ]);
wire_off += (std::mem::transmute::<_, u32>(r#type) as u8).serialize(&mut wire_buf[wire_off .. ]);
wire_off += (if enabled { 1u8 } else { 0u8 }).serialize(&mut wire_buf[wire_off .. ]);
wire_off += 2; wire_off += flags.bits().serialize(&mut wire_buf[wire_off .. ]);
HierarchyInfo { data: wire_buf }
}
}
fn wire_ptr(&self) -> *const u8 { self.data.as_ptr() }
fn wire_len(&self) -> usize { self.data.len() }
pub fn device(&self) -> Device {
unsafe {
let mut offset = 0usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn attachment(&self) -> Device {
unsafe {
let mut offset = 2usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
pub fn r#type(&self) -> DeviceType {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, DeviceType>(val)
}
}
pub fn enabled(&self) -> bool {
let val = unsafe { *(self.wire_ptr().add(5usize)) };
val != 0
}
pub fn flags(&self) -> HierarchyMask {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, HierarchyMask>(val)
}
}
}
#[test]
fn test_sizeof_hierarchy_info() {
assert_eq!(std::mem::size_of::<HierarchyInfo>(), 12);
}
impl base::WiredOut for HierarchyInfo {
fn wire_len(&self) -> usize { 12 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
(&mut wire_buf[..self.data.len()]).copy_from_slice(&self.data);
self.data.len()
}
}
impl base::WiredIn for HierarchyInfo {
type Params = ();
unsafe fn compute_wire_len(_ptr: *const u8, _params: ()) -> usize { 12 }
unsafe fn unserialize(ptr: *const u8, _params: (), offset: &mut usize) -> Self {
*offset += 12;
*(ptr as *const HierarchyInfo)
}
}
impl std::fmt::Debug for HierarchyInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("HierarchyInfo")
.field("device", &self.device())
.field("attachment", &self.attachment())
.field("r#type", &self.r#type())
.field("enabled", &self.enabled())
.field("pad", &2)
.field("flags", &self.flags())
.finish()
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum PropertyFlag {
Deleted = 0,
Created = 1,
Modified = 2,
}
bitflags! {
pub struct TouchEventFlags: u32 {
const TOUCH_PENDING_END = 0x00010000;
const TOUCH_EMULATING_POINTER = 0x00020000;
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u32)]
pub enum TouchOwnershipFlags {
None = 0,
}
bitflags! {
pub struct BarrierFlags: u32 {
const POINTER_RELEASED = 0x00000001;
const DEVICE_IS_GRABBED = 0x00000002;
}
}
#[derive(Copy, Clone, Debug)]
pub struct ChangeDevicePropertyItemsParams {
pub format: usize,
pub num_items: usize,
}
#[derive(Clone, Debug)]
pub enum ChangeDevicePropertyItems {
N8Bits(Vec<u8>),
N16Bits(Vec<u16>),
N32Bits(Vec<u32>),
}
impl ChangeDevicePropertyItems {
pub(crate) fn get_enum(&self) -> PropertyFormat {
match self {
ChangeDevicePropertyItems::N8Bits{..} => {
PropertyFormat::N8Bits
}
ChangeDevicePropertyItems::N16Bits{..} => {
PropertyFormat::N16Bits
}
ChangeDevicePropertyItems::N32Bits{..} => {
PropertyFormat::N32Bits
}
}
}
}
impl base::WiredOut for ChangeDevicePropertyItems {
fn wire_len(&self) -> usize {
let mut sz = 0usize;
match self {
ChangeDevicePropertyItems::N8Bits(
data8,
..
) => {
for el in data8 {
sz += el.wire_len();
}
sz += base::align_pad(sz, 4);
}
ChangeDevicePropertyItems::N16Bits(
data16,
..
) => {
for el in data16 {
sz += el.wire_len();
}
sz += base::align_pad(sz, 4);
}
ChangeDevicePropertyItems::N32Bits(
data32,
..
) => {
for el in data32 {
sz += el.wire_len();
}
}
}
sz
}
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let mut offset = 0usize;
match self {
ChangeDevicePropertyItems::N8Bits(
data8,
..
) => {
for el in data8 {
offset += el.serialize(&mut wire_buf[offset..]);
}
offset += base::align_pad(offset, 4);
}
ChangeDevicePropertyItems::N16Bits(
data16,
..
) => {
for el in data16 {
offset += el.serialize(&mut wire_buf[offset..]);
}
offset += base::align_pad(offset, 4);
}
ChangeDevicePropertyItems::N32Bits(
data32,
..
) => {
for el in data32 {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
}
offset
}
}
impl base::WiredIn for ChangeDevicePropertyItems {
type Params = ChangeDevicePropertyItemsParams;
unsafe fn compute_wire_len(ptr: *const u8, params: Self::Params) -> usize {
let ChangeDevicePropertyItemsParams {
format,
num_items,
} = params;
let expr = (format as usize);
if expr == (PropertyFormat::N8Bits as usize) {
let mut sz = 0usize;
sz += (num_items as usize);
sz += base::align_pad(sz, 4);
return sz;
}
if expr == (PropertyFormat::N16Bits as usize) {
let mut sz = 0usize;
sz += ((num_items as usize) * 2usize);
sz += base::align_pad(sz, 4);
return sz;
}
if expr == (PropertyFormat::N32Bits as usize) {
let mut sz = 0usize;
sz += ((num_items as usize) * 4usize);
return sz;
}
unreachable!("could not match switch expression in xinput::ChangeDevicePropertyItems::compute_wire_len")
}
#[allow(unused_assignments)]
unsafe fn unserialize(wire_data: *const u8, params: ChangeDevicePropertyItemsParams, out_offset: &mut usize) -> ChangeDevicePropertyItems {
let ChangeDevicePropertyItemsParams{
format,
num_items,
} = params;
let expr = (format as usize);
if expr == (PropertyFormat::N8Bits as usize) {
let mut offset = 0usize;
let data8 = {
let ptr = wire_data.add(offset) as *const u8;
let len = (num_items as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u8>();
data.to_vec()
};
offset += base::align_pad(offset, 4);
*out_offset += offset;
return ChangeDevicePropertyItems::N8Bits(
data8,
);
}
if expr == (PropertyFormat::N16Bits as usize) {
let mut offset = 0usize;
let data16 = {
let ptr = wire_data.add(offset) as *const u16;
let len = (num_items as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u16>();
data.to_vec()
};
offset += base::align_pad(offset, 4);
*out_offset += offset;
return ChangeDevicePropertyItems::N16Bits(
data16,
);
}
if expr == (PropertyFormat::N32Bits as usize) {
let mut offset = 0usize;
let data32 = {
let ptr = wire_data.add(offset) as *const u32;
let len = (num_items as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u32>();
data.to_vec()
};
*out_offset += offset;
return ChangeDevicePropertyItems::N32Bits(
data32,
);
}
unreachable!("Could not match any expression for ChangeDevicePropertyItems");
}
}
#[derive(Copy, Clone, Debug)]
pub struct GetDevicePropertyReplyItemsParams {
pub format: usize,
pub num_items: usize,
}
#[derive(Clone, Debug)]
pub enum GetDevicePropertyReplyItems {
N8Bits(Vec<u8>),
N16Bits(Vec<u16>),
N32Bits(Vec<u32>),
}
impl GetDevicePropertyReplyItems {
pub(crate) fn get_enum(&self) -> PropertyFormat {
match self {
GetDevicePropertyReplyItems::N8Bits{..} => {
PropertyFormat::N8Bits
}
GetDevicePropertyReplyItems::N16Bits{..} => {
PropertyFormat::N16Bits
}
GetDevicePropertyReplyItems::N32Bits{..} => {
PropertyFormat::N32Bits
}
}
}
}
impl base::WiredOut for GetDevicePropertyReplyItems {
fn wire_len(&self) -> usize {
let mut sz = 0usize;
match self {
GetDevicePropertyReplyItems::N8Bits(
data8,
..
) => {
for el in data8 {
sz += el.wire_len();
}
sz += base::align_pad(sz, 4);
}
GetDevicePropertyReplyItems::N16Bits(
data16,
..
) => {
for el in data16 {
sz += el.wire_len();
}
sz += base::align_pad(sz, 4);
}
GetDevicePropertyReplyItems::N32Bits(
data32,
..
) => {
for el in data32 {
sz += el.wire_len();
}
}
}
sz
}
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let mut offset = 0usize;
match self {
GetDevicePropertyReplyItems::N8Bits(
data8,
..
) => {
for el in data8 {
offset += el.serialize(&mut wire_buf[offset..]);
}
offset += base::align_pad(offset, 4);
}
GetDevicePropertyReplyItems::N16Bits(
data16,
..
) => {
for el in data16 {
offset += el.serialize(&mut wire_buf[offset..]);
}
offset += base::align_pad(offset, 4);
}
GetDevicePropertyReplyItems::N32Bits(
data32,
..
) => {
for el in data32 {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
}
offset
}
}
impl base::WiredIn for GetDevicePropertyReplyItems {
type Params = GetDevicePropertyReplyItemsParams;
unsafe fn compute_wire_len(ptr: *const u8, params: Self::Params) -> usize {
let GetDevicePropertyReplyItemsParams {
format,
num_items,
} = params;
let expr = (format as usize);
if expr == (PropertyFormat::N8Bits as usize) {
let mut sz = 0usize;
sz += (num_items as usize);
sz += base::align_pad(sz, 4);
return sz;
}
if expr == (PropertyFormat::N16Bits as usize) {
let mut sz = 0usize;
sz += ((num_items as usize) * 2usize);
sz += base::align_pad(sz, 4);
return sz;
}
if expr == (PropertyFormat::N32Bits as usize) {
let mut sz = 0usize;
sz += ((num_items as usize) * 4usize);
return sz;
}
unreachable!("could not match switch expression in xinput::GetDevicePropertyReplyItems::compute_wire_len")
}
#[allow(unused_assignments)]
unsafe fn unserialize(wire_data: *const u8, params: GetDevicePropertyReplyItemsParams, out_offset: &mut usize) -> GetDevicePropertyReplyItems {
let GetDevicePropertyReplyItemsParams{
format,
num_items,
} = params;
let expr = (format as usize);
if expr == (PropertyFormat::N8Bits as usize) {
let mut offset = 0usize;
let data8 = {
let ptr = wire_data.add(offset) as *const u8;
let len = (num_items as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u8>();
data.to_vec()
};
offset += base::align_pad(offset, 4);
*out_offset += offset;
return GetDevicePropertyReplyItems::N8Bits(
data8,
);
}
if expr == (PropertyFormat::N16Bits as usize) {
let mut offset = 0usize;
let data16 = {
let ptr = wire_data.add(offset) as *const u16;
let len = (num_items as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u16>();
data.to_vec()
};
offset += base::align_pad(offset, 4);
*out_offset += offset;
return GetDevicePropertyReplyItems::N16Bits(
data16,
);
}
if expr == (PropertyFormat::N32Bits as usize) {
let mut offset = 0usize;
let data32 = {
let ptr = wire_data.add(offset) as *const u32;
let len = (num_items as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u32>();
data.to_vec()
};
*out_offset += offset;
return GetDevicePropertyReplyItems::N32Bits(
data32,
);
}
unreachable!("Could not match any expression for GetDevicePropertyReplyItems");
}
}
#[derive(Copy, Clone, Debug)]
pub struct XiChangePropertyItemsParams {
pub format: usize,
pub num_items: usize,
}
#[derive(Clone, Debug)]
pub enum XiChangePropertyItems {
N8Bits(Vec<u8>),
N16Bits(Vec<u16>),
N32Bits(Vec<u32>),
}
impl XiChangePropertyItems {
pub(crate) fn get_enum(&self) -> PropertyFormat {
match self {
XiChangePropertyItems::N8Bits{..} => {
PropertyFormat::N8Bits
}
XiChangePropertyItems::N16Bits{..} => {
PropertyFormat::N16Bits
}
XiChangePropertyItems::N32Bits{..} => {
PropertyFormat::N32Bits
}
}
}
}
impl base::WiredOut for XiChangePropertyItems {
fn wire_len(&self) -> usize {
let mut sz = 0usize;
match self {
XiChangePropertyItems::N8Bits(
data8,
..
) => {
for el in data8 {
sz += el.wire_len();
}
sz += base::align_pad(sz, 4);
}
XiChangePropertyItems::N16Bits(
data16,
..
) => {
for el in data16 {
sz += el.wire_len();
}
sz += base::align_pad(sz, 4);
}
XiChangePropertyItems::N32Bits(
data32,
..
) => {
for el in data32 {
sz += el.wire_len();
}
}
}
sz
}
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let mut offset = 0usize;
match self {
XiChangePropertyItems::N8Bits(
data8,
..
) => {
for el in data8 {
offset += el.serialize(&mut wire_buf[offset..]);
}
offset += base::align_pad(offset, 4);
}
XiChangePropertyItems::N16Bits(
data16,
..
) => {
for el in data16 {
offset += el.serialize(&mut wire_buf[offset..]);
}
offset += base::align_pad(offset, 4);
}
XiChangePropertyItems::N32Bits(
data32,
..
) => {
for el in data32 {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
}
offset
}
}
impl base::WiredIn for XiChangePropertyItems {
type Params = XiChangePropertyItemsParams;
unsafe fn compute_wire_len(ptr: *const u8, params: Self::Params) -> usize {
let XiChangePropertyItemsParams {
format,
num_items,
} = params;
let expr = (format as usize);
if expr == (PropertyFormat::N8Bits as usize) {
let mut sz = 0usize;
sz += (num_items as usize);
sz += base::align_pad(sz, 4);
return sz;
}
if expr == (PropertyFormat::N16Bits as usize) {
let mut sz = 0usize;
sz += ((num_items as usize) * 2usize);
sz += base::align_pad(sz, 4);
return sz;
}
if expr == (PropertyFormat::N32Bits as usize) {
let mut sz = 0usize;
sz += ((num_items as usize) * 4usize);
return sz;
}
unreachable!("could not match switch expression in xinput::XiChangePropertyItems::compute_wire_len")
}
#[allow(unused_assignments)]
unsafe fn unserialize(wire_data: *const u8, params: XiChangePropertyItemsParams, out_offset: &mut usize) -> XiChangePropertyItems {
let XiChangePropertyItemsParams{
format,
num_items,
} = params;
let expr = (format as usize);
if expr == (PropertyFormat::N8Bits as usize) {
let mut offset = 0usize;
let data8 = {
let ptr = wire_data.add(offset) as *const u8;
let len = (num_items as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u8>();
data.to_vec()
};
offset += base::align_pad(offset, 4);
*out_offset += offset;
return XiChangePropertyItems::N8Bits(
data8,
);
}
if expr == (PropertyFormat::N16Bits as usize) {
let mut offset = 0usize;
let data16 = {
let ptr = wire_data.add(offset) as *const u16;
let len = (num_items as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u16>();
data.to_vec()
};
offset += base::align_pad(offset, 4);
*out_offset += offset;
return XiChangePropertyItems::N16Bits(
data16,
);
}
if expr == (PropertyFormat::N32Bits as usize) {
let mut offset = 0usize;
let data32 = {
let ptr = wire_data.add(offset) as *const u32;
let len = (num_items as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u32>();
data.to_vec()
};
*out_offset += offset;
return XiChangePropertyItems::N32Bits(
data32,
);
}
unreachable!("Could not match any expression for XiChangePropertyItems");
}
}
#[derive(Copy, Clone, Debug)]
pub struct XiGetPropertyReplyItemsParams {
pub format: usize,
pub num_items: usize,
}
#[derive(Clone, Debug)]
pub enum XiGetPropertyReplyItems {
N8Bits(Vec<u8>),
N16Bits(Vec<u16>),
N32Bits(Vec<u32>),
}
impl XiGetPropertyReplyItems {
pub(crate) fn get_enum(&self) -> PropertyFormat {
match self {
XiGetPropertyReplyItems::N8Bits{..} => {
PropertyFormat::N8Bits
}
XiGetPropertyReplyItems::N16Bits{..} => {
PropertyFormat::N16Bits
}
XiGetPropertyReplyItems::N32Bits{..} => {
PropertyFormat::N32Bits
}
}
}
}
impl base::WiredOut for XiGetPropertyReplyItems {
fn wire_len(&self) -> usize {
let mut sz = 0usize;
match self {
XiGetPropertyReplyItems::N8Bits(
data8,
..
) => {
for el in data8 {
sz += el.wire_len();
}
sz += base::align_pad(sz, 4);
}
XiGetPropertyReplyItems::N16Bits(
data16,
..
) => {
for el in data16 {
sz += el.wire_len();
}
sz += base::align_pad(sz, 4);
}
XiGetPropertyReplyItems::N32Bits(
data32,
..
) => {
for el in data32 {
sz += el.wire_len();
}
}
}
sz
}
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
let mut offset = 0usize;
match self {
XiGetPropertyReplyItems::N8Bits(
data8,
..
) => {
for el in data8 {
offset += el.serialize(&mut wire_buf[offset..]);
}
offset += base::align_pad(offset, 4);
}
XiGetPropertyReplyItems::N16Bits(
data16,
..
) => {
for el in data16 {
offset += el.serialize(&mut wire_buf[offset..]);
}
offset += base::align_pad(offset, 4);
}
XiGetPropertyReplyItems::N32Bits(
data32,
..
) => {
for el in data32 {
offset += el.serialize(&mut wire_buf[offset..]);
}
}
}
offset
}
}
impl base::WiredIn for XiGetPropertyReplyItems {
type Params = XiGetPropertyReplyItemsParams;
unsafe fn compute_wire_len(ptr: *const u8, params: Self::Params) -> usize {
let XiGetPropertyReplyItemsParams {
format,
num_items,
} = params;
let expr = (format as usize);
if expr == (PropertyFormat::N8Bits as usize) {
let mut sz = 0usize;
sz += (num_items as usize);
sz += base::align_pad(sz, 4);
return sz;
}
if expr == (PropertyFormat::N16Bits as usize) {
let mut sz = 0usize;
sz += ((num_items as usize) * 2usize);
sz += base::align_pad(sz, 4);
return sz;
}
if expr == (PropertyFormat::N32Bits as usize) {
let mut sz = 0usize;
sz += ((num_items as usize) * 4usize);
return sz;
}
unreachable!("could not match switch expression in xinput::XiGetPropertyReplyItems::compute_wire_len")
}
#[allow(unused_assignments)]
unsafe fn unserialize(wire_data: *const u8, params: XiGetPropertyReplyItemsParams, out_offset: &mut usize) -> XiGetPropertyReplyItems {
let XiGetPropertyReplyItemsParams{
format,
num_items,
} = params;
let expr = (format as usize);
if expr == (PropertyFormat::N8Bits as usize) {
let mut offset = 0usize;
let data8 = {
let ptr = wire_data.add(offset) as *const u8;
let len = (num_items as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u8>();
data.to_vec()
};
offset += base::align_pad(offset, 4);
*out_offset += offset;
return XiGetPropertyReplyItems::N8Bits(
data8,
);
}
if expr == (PropertyFormat::N16Bits as usize) {
let mut offset = 0usize;
let data16 = {
let ptr = wire_data.add(offset) as *const u16;
let len = (num_items as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u16>();
data.to_vec()
};
offset += base::align_pad(offset, 4);
*out_offset += offset;
return XiGetPropertyReplyItems::N16Bits(
data16,
);
}
if expr == (PropertyFormat::N32Bits as usize) {
let mut offset = 0usize;
let data32 = {
let ptr = wire_data.add(offset) as *const u32;
let len = (num_items as usize);
let data = std::slice::from_raw_parts(ptr, len);
offset += len * std::mem::size_of::<u32>();
data.to_vec()
};
*out_offset += offset;
return XiGetPropertyReplyItems::N32Bits(
data32,
);
}
unreachable!("Could not match any expression for XiGetPropertyReplyItems");
}
}
#[derive(Debug)]
pub enum EventForSend {
DeviceValuator(DeviceValuatorEvent),
DeviceKeyPress(DeviceKeyPressEvent),
DeviceKeyRelease(DeviceKeyReleaseEvent),
DeviceButtonPress(DeviceButtonPressEvent),
DeviceButtonRelease(DeviceButtonReleaseEvent),
DeviceMotionNotify(DeviceMotionNotifyEvent),
DeviceFocusIn(DeviceFocusInEvent),
DeviceFocusOut(DeviceFocusOutEvent),
ProximityIn(ProximityInEvent),
ProximityOut(ProximityOutEvent),
DeviceStateNotify(DeviceStateNotifyEvent),
DeviceMappingNotify(DeviceMappingNotifyEvent),
ChangeDeviceNotify(ChangeDeviceNotifyEvent),
DeviceKeyStateNotify(DeviceKeyStateNotifyEvent),
DeviceButtonStateNotify(DeviceButtonStateNotifyEvent),
DevicePresenceNotify(DevicePresenceNotifyEvent),
DevicePropertyNotify(DevicePropertyNotifyEvent),
}
impl base::WiredOut for EventForSend {
fn wire_len(&self) -> usize { 32 }
fn serialize(&self, wire_buf: &mut [u8]) -> usize {
match self {
EventForSend::DeviceValuator(device_valuator) => {
device_valuator.serialize(wire_buf);
}
EventForSend::DeviceKeyPress(device_key_press) => {
device_key_press.serialize(wire_buf);
}
EventForSend::DeviceKeyRelease(device_key_release) => {
device_key_release.serialize(wire_buf);
}
EventForSend::DeviceButtonPress(device_button_press) => {
device_button_press.serialize(wire_buf);
}
EventForSend::DeviceButtonRelease(device_button_release) => {
device_button_release.serialize(wire_buf);
}
EventForSend::DeviceMotionNotify(device_motion_notify) => {
device_motion_notify.serialize(wire_buf);
}
EventForSend::DeviceFocusIn(device_focus_in) => {
device_focus_in.serialize(wire_buf);
}
EventForSend::DeviceFocusOut(device_focus_out) => {
device_focus_out.serialize(wire_buf);
}
EventForSend::ProximityIn(proximity_in) => {
proximity_in.serialize(wire_buf);
}
EventForSend::ProximityOut(proximity_out) => {
proximity_out.serialize(wire_buf);
}
EventForSend::DeviceStateNotify(device_state_notify) => {
device_state_notify.serialize(wire_buf);
}
EventForSend::DeviceMappingNotify(device_mapping_notify) => {
device_mapping_notify.serialize(wire_buf);
}
EventForSend::ChangeDeviceNotify(change_device_notify) => {
change_device_notify.serialize(wire_buf);
}
EventForSend::DeviceKeyStateNotify(device_key_state_notify) => {
device_key_state_notify.serialize(wire_buf);
}
EventForSend::DeviceButtonStateNotify(device_button_state_notify) => {
device_button_state_notify.serialize(wire_buf);
}
EventForSend::DevicePresenceNotify(device_presence_notify) => {
device_presence_notify.serialize(wire_buf);
}
EventForSend::DevicePropertyNotify(device_property_notify) => {
device_property_notify.serialize(wire_buf);
}
}
32
}
}
pub(crate) fn request_name(opcode: u16) -> std::option::Option<&'static str> {
match opcode {
1 => Some("xinput::GetExtensionVersion"),
2 => Some("xinput::ListInputDevices"),
3 => Some("xinput::OpenDevice"),
4 => Some("xinput::CloseDevice"),
5 => Some("xinput::SetDeviceMode"),
6 => Some("xinput::SelectExtensionEvent"),
7 => Some("xinput::GetSelectedExtensionEvents"),
8 => Some("xinput::ChangeDeviceDontPropagateList"),
9 => Some("xinput::GetDeviceDontPropagateList"),
10 => Some("xinput::GetDeviceMotionEvents"),
11 => Some("xinput::ChangeKeyboardDevice"),
12 => Some("xinput::ChangePointerDevice"),
13 => Some("xinput::GrabDevice"),
14 => Some("xinput::UngrabDevice"),
15 => Some("xinput::GrabDeviceKey"),
16 => Some("xinput::UngrabDeviceKey"),
17 => Some("xinput::GrabDeviceButton"),
18 => Some("xinput::UngrabDeviceButton"),
19 => Some("xinput::AllowDeviceEvents"),
20 => Some("xinput::GetDeviceFocus"),
21 => Some("xinput::SetDeviceFocus"),
22 => Some("xinput::GetFeedbackControl"),
23 => Some("xinput::ChangeFeedbackControl"),
24 => Some("xinput::GetDeviceKeyMapping"),
25 => Some("xinput::ChangeDeviceKeyMapping"),
26 => Some("xinput::GetDeviceModifierMapping"),
27 => Some("xinput::SetDeviceModifierMapping"),
28 => Some("xinput::GetDeviceButtonMapping"),
29 => Some("xinput::SetDeviceButtonMapping"),
30 => Some("xinput::QueryDeviceState"),
32 => Some("xinput::DeviceBell"),
33 => Some("xinput::SetDeviceValuators"),
34 => Some("xinput::GetDeviceControl"),
35 => Some("xinput::ChangeDeviceControl"),
36 => Some("xinput::ListDeviceProperties"),
37 => Some("xinput::ChangeDeviceProperty"),
38 => Some("xinput::DeleteDeviceProperty"),
39 => Some("xinput::GetDeviceProperty"),
40 => Some("xinput::XiQueryPointer"),
41 => Some("xinput::XiWarpPointer"),
42 => Some("xinput::XiChangeCursor"),
43 => Some("xinput::XiChangeHierarchy"),
44 => Some("xinput::XiSetClientPointer"),
45 => Some("xinput::XiGetClientPointer"),
46 => Some("xinput::XiSelectEvents"),
47 => Some("xinput::XiQueryVersion"),
48 => Some("xinput::XiQueryDevice"),
49 => Some("xinput::XiSetFocus"),
50 => Some("xinput::XiGetFocus"),
51 => Some("xinput::XiGrabDevice"),
52 => Some("xinput::XiUngrabDevice"),
53 => Some("xinput::XiAllowEvents"),
54 => Some("xinput::XiPassiveGrabDevice"),
55 => Some("xinput::XiPassiveUngrabDevice"),
56 => Some("xinput::XiListProperties"),
57 => Some("xinput::XiChangeProperty"),
58 => Some("xinput::XiDeleteProperty"),
59 => Some("xinput::XiGetProperty"),
60 => Some("xinput::XiGetSelectedEvents"),
61 => Some("xinput::XiBarrierReleasePointer"),
31 => Some("xinput::SendExtensionEvent"),
_ => None,
}
}
pub struct GetExtensionVersionReply {
raw: *const u8,
}
impl GetExtensionVersionReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn server_major(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn server_minor(&self) -> u16 {
unsafe {
let offset = 10usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn present(&self) -> bool {
let val = unsafe { *(self.wire_ptr().add(12usize)) };
val != 0
}
}
impl base::Reply for GetExtensionVersionReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for GetExtensionVersionReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GetExtensionVersionReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("server_major", &self.server_major())
.field("server_minor", &self.server_minor())
.field("present", &self.present())
.field("pad", &19)
.finish()
}
}
impl Drop for GetExtensionVersionReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for GetExtensionVersionReply {}
unsafe impl std::marker::Sync for GetExtensionVersionReply {}
#[derive(Debug)]
pub struct GetExtensionVersionCookie {
seq: u64,
}
#[derive(Debug)]
pub struct GetExtensionVersionCookieUnchecked {
seq: u64,
}
impl base::Cookie for GetExtensionVersionCookie {
unsafe fn from_sequence(seq: u64) -> Self {
GetExtensionVersionCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for GetExtensionVersionCookie {
}
unsafe impl base::CookieWithReplyChecked for GetExtensionVersionCookie {
type Reply = GetExtensionVersionReply;
}
impl base::Cookie for GetExtensionVersionCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
GetExtensionVersionCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for GetExtensionVersionCookieUnchecked {
type Reply = GetExtensionVersionReply;
}
#[derive(Clone, Debug)]
pub struct GetExtensionVersion<'a> {
pub name: &'a [u8],
}
unsafe impl<'a> base::RawRequest for GetExtensionVersion<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 1,
isvoid: 0,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 8];
(self.name.len() as u16).serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.name.as_ptr() as *mut _;
sections[4].iov_len = self.name.len();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for GetExtensionVersion<'a> {
type Cookie = GetExtensionVersionCookie;
const IS_VOID: bool = false;
}
impl<'a> base::RequestWithReply for GetExtensionVersion<'a> {
type Reply = GetExtensionVersionReply;
type Cookie = GetExtensionVersionCookie;
type CookieUnchecked = GetExtensionVersionCookieUnchecked;
}
pub struct ListInputDevicesReply {
raw: *const u8,
}
impl ListInputDevicesReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_names_offset(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let devices_len = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 23usize;
let devices = {
let len = (devices_len as usize);
let data = ptr.add(sz) as *const DeviceInfo;
sz += len * std::mem::size_of::<DeviceInfo>();
std::slice::from_raw_parts(data, len)
};
for _ in 0 .. (devices.iter().map(|el| el.num_class_info()).sum::<u8>() as usize) {
sz += <&InputInfo>::compute_wire_len(ptr.add(sz), ());
}
sz
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let devices_len = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 23usize;
let devices = {
let len = (devices_len as usize);
let data = ptr.add(sz) as *const DeviceInfo;
sz += len * std::mem::size_of::<DeviceInfo>();
std::slice::from_raw_parts(data, len)
};
for _ in 0 .. (devices.iter().map(|el| el.num_class_info()).sum::<u8>() as usize) {
sz += <&InputInfo>::compute_wire_len(ptr.add(sz), ());
}
for _ in 0 .. (devices_len as usize) {
sz += <&xproto::Str>::compute_wire_len(ptr.add(sz), ());
}
sz += base::align_pad(sz, 4);
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn devices_len(&self) -> u8 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn devices(&self) -> &[DeviceInfo] {
unsafe {
let offset = 32usize;
let len = (self.devices_len() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const DeviceInfo;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn infos(&self) -> InputInfoIterator {
unsafe {
let offset = (32usize + ((self.devices_len() as usize) * 8usize));
InputInfoIterator {
params: (),
rem: (self.devices().iter().map(|el| el.num_class_info()).sum::<u8>() as usize),
ptr: self.wire_ptr().add(offset),
phantom: std::marker::PhantomData,
}
}
}
pub fn names(&self) -> xproto::StrIterator {
unsafe {
let offset = Self::compute_names_offset(self.wire_ptr(), ());
xproto::StrIterator {
params: (),
rem: (self.devices_len() as usize),
ptr: self.wire_ptr().add(offset),
phantom: std::marker::PhantomData,
}
}
}
}
impl base::Reply for ListInputDevicesReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for ListInputDevicesReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ListInputDevicesReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("devices_len", &self.devices_len())
.field("pad", &23)
.field("devices", &self.devices())
.field("infos", &self.infos())
.field("names", &self.names())
.field("align_pad", &4)
.finish()
}
}
impl Drop for ListInputDevicesReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for ListInputDevicesReply {}
unsafe impl std::marker::Sync for ListInputDevicesReply {}
#[derive(Debug)]
pub struct ListInputDevicesCookie {
seq: u64,
}
#[derive(Debug)]
pub struct ListInputDevicesCookieUnchecked {
seq: u64,
}
impl base::Cookie for ListInputDevicesCookie {
unsafe fn from_sequence(seq: u64) -> Self {
ListInputDevicesCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for ListInputDevicesCookie {
}
unsafe impl base::CookieWithReplyChecked for ListInputDevicesCookie {
type Reply = ListInputDevicesReply;
}
impl base::Cookie for ListInputDevicesCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
ListInputDevicesCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for ListInputDevicesCookieUnchecked {
type Reply = ListInputDevicesReply;
}
#[derive(Clone, Debug)]
pub struct ListInputDevices {
}
unsafe impl base::RawRequest for ListInputDevices {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 2,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 4];
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 4;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for ListInputDevices {
type Cookie = ListInputDevicesCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for ListInputDevices {
type Reply = ListInputDevicesReply;
type Cookie = ListInputDevicesCookie;
type CookieUnchecked = ListInputDevicesCookieUnchecked;
}
pub struct OpenDeviceReply {
raw: *const u8,
}
impl OpenDeviceReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let num_classes = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 23usize;
sz += ((num_classes as usize) * 2usize);
sz += base::align_pad(sz, 4);
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_classes(&self) -> u8 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn class_info(&self) -> &[InputClassInfo] {
unsafe {
let offset = 32usize;
let len = (self.num_classes() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const InputClassInfo;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::Reply for OpenDeviceReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for OpenDeviceReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("OpenDeviceReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("num_classes", &self.num_classes())
.field("pad", &23)
.field("class_info", &self.class_info())
.field("align_pad", &4)
.finish()
}
}
impl Drop for OpenDeviceReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for OpenDeviceReply {}
unsafe impl std::marker::Sync for OpenDeviceReply {}
#[derive(Debug)]
pub struct OpenDeviceCookie {
seq: u64,
}
#[derive(Debug)]
pub struct OpenDeviceCookieUnchecked {
seq: u64,
}
impl base::Cookie for OpenDeviceCookie {
unsafe fn from_sequence(seq: u64) -> Self {
OpenDeviceCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for OpenDeviceCookie {
}
unsafe impl base::CookieWithReplyChecked for OpenDeviceCookie {
type Reply = OpenDeviceReply;
}
impl base::Cookie for OpenDeviceCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
OpenDeviceCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for OpenDeviceCookieUnchecked {
type Reply = OpenDeviceReply;
}
#[derive(Clone, Debug)]
pub struct OpenDevice {
pub device_id: u8,
}
unsafe impl base::RawRequest for OpenDevice {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 3,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for OpenDevice {
type Cookie = OpenDeviceCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for OpenDevice {
type Reply = OpenDeviceReply;
type Cookie = OpenDeviceCookie;
type CookieUnchecked = OpenDeviceCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct CloseDevice {
pub device_id: u8,
}
unsafe impl base::RawRequest for CloseDevice {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 4,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for CloseDevice {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for CloseDevice {
}
pub struct SetDeviceModeReply {
raw: *const u8,
}
impl SetDeviceModeReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> xproto::GrabStatus {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::GrabStatus>(val)
}
}
}
impl base::Reply for SetDeviceModeReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for SetDeviceModeReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SetDeviceModeReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("status", &self.status())
.field("pad", &23)
.finish()
}
}
impl Drop for SetDeviceModeReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for SetDeviceModeReply {}
unsafe impl std::marker::Sync for SetDeviceModeReply {}
#[derive(Debug)]
pub struct SetDeviceModeCookie {
seq: u64,
}
#[derive(Debug)]
pub struct SetDeviceModeCookieUnchecked {
seq: u64,
}
impl base::Cookie for SetDeviceModeCookie {
unsafe fn from_sequence(seq: u64) -> Self {
SetDeviceModeCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for SetDeviceModeCookie {
}
unsafe impl base::CookieWithReplyChecked for SetDeviceModeCookie {
type Reply = SetDeviceModeReply;
}
impl base::Cookie for SetDeviceModeCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
SetDeviceModeCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for SetDeviceModeCookieUnchecked {
type Reply = SetDeviceModeReply;
}
#[derive(Clone, Debug)]
pub struct SetDeviceMode {
pub device_id: u8,
pub mode: ValuatorMode,
}
unsafe impl base::RawRequest for SetDeviceMode {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 5,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
(std::mem::transmute::<_, u32>(self.mode) as u8).serialize(&mut buf0[5 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for SetDeviceMode {
type Cookie = SetDeviceModeCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for SetDeviceMode {
type Reply = SetDeviceModeReply;
type Cookie = SetDeviceModeCookie;
type CookieUnchecked = SetDeviceModeCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct SelectExtensionEvent<'a> {
pub window: xproto::Window,
pub classes: &'a [EventClass],
}
unsafe impl<'a> base::RawRequest for SelectExtensionEvent<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 6,
isvoid: 1,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 12];
self.window.serialize(&mut buf0[4 .. ]);
(self.classes.len() as u16).serialize(&mut buf0[8 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 12;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.classes.as_ptr() as *mut _;
sections[4].iov_len = self.classes.len() * std::mem::size_of::<EventClass>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for SelectExtensionEvent<'a> {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl<'a> base::RequestWithoutReply for SelectExtensionEvent<'a> {
}
pub struct GetSelectedExtensionEventsReply {
raw: *const u8,
}
impl GetSelectedExtensionEventsReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let num_this_classes = *(ptr.add(sz) as *const u16);
sz += 2usize;
let num_all_classes = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 20usize;
sz += ((num_this_classes as usize) * 4usize);
sz += ((num_all_classes as usize) * 4usize);
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_this_classes(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
fn num_all_classes(&self) -> u16 {
unsafe {
let offset = 10usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn this_classes(&self) -> &[EventClass] {
unsafe {
let offset = 32usize;
let len = (self.num_this_classes() as usize);
let ptr = self.wire_ptr().add(offset) as *const EventClass;
std::slice::from_raw_parts(ptr, len)
}
}
pub fn all_classes(&self) -> &[EventClass] {
unsafe {
let offset = (32usize + ((self.num_this_classes() as usize) * 4usize));
let len = (self.num_all_classes() as usize);
let ptr = self.wire_ptr().add(offset) as *const EventClass;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::Reply for GetSelectedExtensionEventsReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for GetSelectedExtensionEventsReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GetSelectedExtensionEventsReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("num_this_classes", &self.num_this_classes())
.field("num_all_classes", &self.num_all_classes())
.field("pad", &20)
.field("this_classes", &self.this_classes())
.field("all_classes", &self.all_classes())
.finish()
}
}
impl Drop for GetSelectedExtensionEventsReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for GetSelectedExtensionEventsReply {}
unsafe impl std::marker::Sync for GetSelectedExtensionEventsReply {}
#[derive(Debug)]
pub struct GetSelectedExtensionEventsCookie {
seq: u64,
}
#[derive(Debug)]
pub struct GetSelectedExtensionEventsCookieUnchecked {
seq: u64,
}
impl base::Cookie for GetSelectedExtensionEventsCookie {
unsafe fn from_sequence(seq: u64) -> Self {
GetSelectedExtensionEventsCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for GetSelectedExtensionEventsCookie {
}
unsafe impl base::CookieWithReplyChecked for GetSelectedExtensionEventsCookie {
type Reply = GetSelectedExtensionEventsReply;
}
impl base::Cookie for GetSelectedExtensionEventsCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
GetSelectedExtensionEventsCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for GetSelectedExtensionEventsCookieUnchecked {
type Reply = GetSelectedExtensionEventsReply;
}
#[derive(Clone, Debug)]
pub struct GetSelectedExtensionEvents {
pub window: xproto::Window,
}
unsafe impl base::RawRequest for GetSelectedExtensionEvents {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 7,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.window.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for GetSelectedExtensionEvents {
type Cookie = GetSelectedExtensionEventsCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for GetSelectedExtensionEvents {
type Reply = GetSelectedExtensionEventsReply;
type Cookie = GetSelectedExtensionEventsCookie;
type CookieUnchecked = GetSelectedExtensionEventsCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct ChangeDeviceDontPropagateList<'a> {
pub window: xproto::Window,
pub mode: PropagateMode,
pub classes: &'a [EventClass],
}
unsafe impl<'a> base::RawRequest for ChangeDeviceDontPropagateList<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 8,
isvoid: 1,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 12];
self.window.serialize(&mut buf0[4 .. ]);
(self.classes.len() as u16).serialize(&mut buf0[8 .. ]);
(std::mem::transmute::<_, u32>(self.mode) as u8).serialize(&mut buf0[10 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 12;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.classes.as_ptr() as *mut _;
sections[4].iov_len = self.classes.len() * std::mem::size_of::<EventClass>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for ChangeDeviceDontPropagateList<'a> {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl<'a> base::RequestWithoutReply for ChangeDeviceDontPropagateList<'a> {
}
pub struct GetDeviceDontPropagateListReply {
raw: *const u8,
}
impl GetDeviceDontPropagateListReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let num_classes = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 22usize;
sz += ((num_classes as usize) * 4usize);
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_classes(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn classes(&self) -> &[EventClass] {
unsafe {
let offset = 32usize;
let len = (self.num_classes() as usize);
let ptr = self.wire_ptr().add(offset) as *const EventClass;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::Reply for GetDeviceDontPropagateListReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for GetDeviceDontPropagateListReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GetDeviceDontPropagateListReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("num_classes", &self.num_classes())
.field("pad", &22)
.field("classes", &self.classes())
.finish()
}
}
impl Drop for GetDeviceDontPropagateListReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for GetDeviceDontPropagateListReply {}
unsafe impl std::marker::Sync for GetDeviceDontPropagateListReply {}
#[derive(Debug)]
pub struct GetDeviceDontPropagateListCookie {
seq: u64,
}
#[derive(Debug)]
pub struct GetDeviceDontPropagateListCookieUnchecked {
seq: u64,
}
impl base::Cookie for GetDeviceDontPropagateListCookie {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceDontPropagateListCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for GetDeviceDontPropagateListCookie {
}
unsafe impl base::CookieWithReplyChecked for GetDeviceDontPropagateListCookie {
type Reply = GetDeviceDontPropagateListReply;
}
impl base::Cookie for GetDeviceDontPropagateListCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceDontPropagateListCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for GetDeviceDontPropagateListCookieUnchecked {
type Reply = GetDeviceDontPropagateListReply;
}
#[derive(Clone, Debug)]
pub struct GetDeviceDontPropagateList {
pub window: xproto::Window,
}
unsafe impl base::RawRequest for GetDeviceDontPropagateList {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 9,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.window.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for GetDeviceDontPropagateList {
type Cookie = GetDeviceDontPropagateListCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for GetDeviceDontPropagateList {
type Reply = GetDeviceDontPropagateListReply;
type Cookie = GetDeviceDontPropagateListCookie;
type CookieUnchecked = GetDeviceDontPropagateListCookieUnchecked;
}
pub struct GetDeviceMotionEventsReply {
raw: *const u8,
}
impl GetDeviceMotionEventsReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let num_events = *(ptr.add(sz) as *const u32);
sz += 4usize;
let num_axes = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 1usize;
sz += 18usize;
for _ in 0 .. (num_events as usize) {
sz += <&DeviceTimeCoord>::compute_wire_len(ptr.add(sz), DeviceTimeCoordParams {num_axes: num_axes as usize});
}
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_events(&self) -> u32 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn num_axes(&self) -> u8 {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn device_mode(&self) -> ValuatorMode {
unsafe {
let offset = 13usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, ValuatorMode>(val)
}
}
pub fn events(&self) -> DeviceTimeCoordIterator {
unsafe {
let offset = 32usize;
DeviceTimeCoordIterator {
params: DeviceTimeCoordParams {num_axes: self.num_axes() as usize},
rem: (self.num_events() as usize),
ptr: self.wire_ptr().add(offset),
phantom: std::marker::PhantomData,
}
}
}
}
impl base::Reply for GetDeviceMotionEventsReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for GetDeviceMotionEventsReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GetDeviceMotionEventsReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("num_events", &self.num_events())
.field("num_axes", &self.num_axes())
.field("device_mode", &self.device_mode())
.field("pad", &18)
.finish()
}
}
impl Drop for GetDeviceMotionEventsReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for GetDeviceMotionEventsReply {}
unsafe impl std::marker::Sync for GetDeviceMotionEventsReply {}
#[derive(Debug)]
pub struct GetDeviceMotionEventsCookie {
seq: u64,
}
#[derive(Debug)]
pub struct GetDeviceMotionEventsCookieUnchecked {
seq: u64,
}
impl base::Cookie for GetDeviceMotionEventsCookie {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceMotionEventsCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for GetDeviceMotionEventsCookie {
}
unsafe impl base::CookieWithReplyChecked for GetDeviceMotionEventsCookie {
type Reply = GetDeviceMotionEventsReply;
}
impl base::Cookie for GetDeviceMotionEventsCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceMotionEventsCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for GetDeviceMotionEventsCookieUnchecked {
type Reply = GetDeviceMotionEventsReply;
}
#[derive(Clone, Debug)]
pub struct GetDeviceMotionEvents {
pub start: xproto::Timestamp,
pub stop: xproto::Timestamp,
pub device_id: u8,
}
unsafe impl base::RawRequest for GetDeviceMotionEvents {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 10,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 16];
self.start.serialize(&mut buf0[4 .. ]);
self.stop.serialize(&mut buf0[8 .. ]);
self.device_id.serialize(&mut buf0[12 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 16;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for GetDeviceMotionEvents {
type Cookie = GetDeviceMotionEventsCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for GetDeviceMotionEvents {
type Reply = GetDeviceMotionEventsReply;
type Cookie = GetDeviceMotionEventsCookie;
type CookieUnchecked = GetDeviceMotionEventsCookieUnchecked;
}
pub struct ChangeKeyboardDeviceReply {
raw: *const u8,
}
impl ChangeKeyboardDeviceReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> xproto::GrabStatus {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::GrabStatus>(val)
}
}
}
impl base::Reply for ChangeKeyboardDeviceReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for ChangeKeyboardDeviceReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ChangeKeyboardDeviceReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("status", &self.status())
.field("pad", &23)
.finish()
}
}
impl Drop for ChangeKeyboardDeviceReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for ChangeKeyboardDeviceReply {}
unsafe impl std::marker::Sync for ChangeKeyboardDeviceReply {}
#[derive(Debug)]
pub struct ChangeKeyboardDeviceCookie {
seq: u64,
}
#[derive(Debug)]
pub struct ChangeKeyboardDeviceCookieUnchecked {
seq: u64,
}
impl base::Cookie for ChangeKeyboardDeviceCookie {
unsafe fn from_sequence(seq: u64) -> Self {
ChangeKeyboardDeviceCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for ChangeKeyboardDeviceCookie {
}
unsafe impl base::CookieWithReplyChecked for ChangeKeyboardDeviceCookie {
type Reply = ChangeKeyboardDeviceReply;
}
impl base::Cookie for ChangeKeyboardDeviceCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
ChangeKeyboardDeviceCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for ChangeKeyboardDeviceCookieUnchecked {
type Reply = ChangeKeyboardDeviceReply;
}
#[derive(Clone, Debug)]
pub struct ChangeKeyboardDevice {
pub device_id: u8,
}
unsafe impl base::RawRequest for ChangeKeyboardDevice {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 11,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for ChangeKeyboardDevice {
type Cookie = ChangeKeyboardDeviceCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for ChangeKeyboardDevice {
type Reply = ChangeKeyboardDeviceReply;
type Cookie = ChangeKeyboardDeviceCookie;
type CookieUnchecked = ChangeKeyboardDeviceCookieUnchecked;
}
pub struct ChangePointerDeviceReply {
raw: *const u8,
}
impl ChangePointerDeviceReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> xproto::GrabStatus {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::GrabStatus>(val)
}
}
}
impl base::Reply for ChangePointerDeviceReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for ChangePointerDeviceReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ChangePointerDeviceReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("status", &self.status())
.field("pad", &23)
.finish()
}
}
impl Drop for ChangePointerDeviceReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for ChangePointerDeviceReply {}
unsafe impl std::marker::Sync for ChangePointerDeviceReply {}
#[derive(Debug)]
pub struct ChangePointerDeviceCookie {
seq: u64,
}
#[derive(Debug)]
pub struct ChangePointerDeviceCookieUnchecked {
seq: u64,
}
impl base::Cookie for ChangePointerDeviceCookie {
unsafe fn from_sequence(seq: u64) -> Self {
ChangePointerDeviceCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for ChangePointerDeviceCookie {
}
unsafe impl base::CookieWithReplyChecked for ChangePointerDeviceCookie {
type Reply = ChangePointerDeviceReply;
}
impl base::Cookie for ChangePointerDeviceCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
ChangePointerDeviceCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for ChangePointerDeviceCookieUnchecked {
type Reply = ChangePointerDeviceReply;
}
#[derive(Clone, Debug)]
pub struct ChangePointerDevice {
pub x_axis: u8,
pub y_axis: u8,
pub device_id: u8,
}
unsafe impl base::RawRequest for ChangePointerDevice {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 12,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.x_axis.serialize(&mut buf0[4 .. ]);
self.y_axis.serialize(&mut buf0[5 .. ]);
self.device_id.serialize(&mut buf0[6 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for ChangePointerDevice {
type Cookie = ChangePointerDeviceCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for ChangePointerDevice {
type Reply = ChangePointerDeviceReply;
type Cookie = ChangePointerDeviceCookie;
type CookieUnchecked = ChangePointerDeviceCookieUnchecked;
}
pub struct GrabDeviceReply {
raw: *const u8,
}
impl GrabDeviceReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> xproto::GrabStatus {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::GrabStatus>(val)
}
}
}
impl base::Reply for GrabDeviceReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for GrabDeviceReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GrabDeviceReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("status", &self.status())
.field("pad", &23)
.finish()
}
}
impl Drop for GrabDeviceReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for GrabDeviceReply {}
unsafe impl std::marker::Sync for GrabDeviceReply {}
#[derive(Debug)]
pub struct GrabDeviceCookie {
seq: u64,
}
#[derive(Debug)]
pub struct GrabDeviceCookieUnchecked {
seq: u64,
}
impl base::Cookie for GrabDeviceCookie {
unsafe fn from_sequence(seq: u64) -> Self {
GrabDeviceCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for GrabDeviceCookie {
}
unsafe impl base::CookieWithReplyChecked for GrabDeviceCookie {
type Reply = GrabDeviceReply;
}
impl base::Cookie for GrabDeviceCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
GrabDeviceCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for GrabDeviceCookieUnchecked {
type Reply = GrabDeviceReply;
}
#[derive(Clone, Debug)]
pub struct GrabDevice<'a> {
pub grab_window: xproto::Window,
pub time: xproto::Timestamp,
pub this_device_mode: xproto::GrabMode,
pub other_device_mode: xproto::GrabMode,
pub owner_events: bool,
pub device_id: u8,
pub classes: &'a [EventClass],
}
unsafe impl<'a> base::RawRequest for GrabDevice<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 13,
isvoid: 0,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 20];
self.grab_window.serialize(&mut buf0[4 .. ]);
self.time.serialize(&mut buf0[8 .. ]);
(self.classes.len() as u16).serialize(&mut buf0[12 .. ]);
(std::mem::transmute::<_, u32>(self.this_device_mode) as u8).serialize(&mut buf0[14 .. ]);
(std::mem::transmute::<_, u32>(self.other_device_mode) as u8).serialize(&mut buf0[15 .. ]);
(if self.owner_events { 1u8 } else { 0u8 }).serialize(&mut buf0[16 .. ]);
self.device_id.serialize(&mut buf0[17 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 20;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.classes.as_ptr() as *mut _;
sections[4].iov_len = self.classes.len() * std::mem::size_of::<EventClass>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for GrabDevice<'a> {
type Cookie = GrabDeviceCookie;
const IS_VOID: bool = false;
}
impl<'a> base::RequestWithReply for GrabDevice<'a> {
type Reply = GrabDeviceReply;
type Cookie = GrabDeviceCookie;
type CookieUnchecked = GrabDeviceCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct UngrabDevice {
pub time: xproto::Timestamp,
pub device_id: u8,
}
unsafe impl base::RawRequest for UngrabDevice {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 14,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 12];
self.time.serialize(&mut buf0[4 .. ]);
self.device_id.serialize(&mut buf0[8 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 12;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for UngrabDevice {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for UngrabDevice {
}
#[derive(Clone, Debug)]
pub struct GrabDeviceKey<'a> {
pub grab_window: xproto::Window,
pub modifiers: xproto::ModMask,
pub modifier_device: u8,
pub grabbed_device: u8,
pub key: u8,
pub this_device_mode: xproto::GrabMode,
pub other_device_mode: xproto::GrabMode,
pub owner_events: bool,
pub classes: &'a [EventClass],
}
unsafe impl<'a> base::RawRequest for GrabDeviceKey<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 15,
isvoid: 1,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 20];
self.grab_window.serialize(&mut buf0[4 .. ]);
(self.classes.len() as u16).serialize(&mut buf0[8 .. ]);
(self.modifiers.bits() as u16).serialize(&mut buf0[10 .. ]);
self.modifier_device.serialize(&mut buf0[12 .. ]);
self.grabbed_device.serialize(&mut buf0[13 .. ]);
self.key.serialize(&mut buf0[14 .. ]);
(std::mem::transmute::<_, u32>(self.this_device_mode) as u8).serialize(&mut buf0[15 .. ]);
(std::mem::transmute::<_, u32>(self.other_device_mode) as u8).serialize(&mut buf0[16 .. ]);
(if self.owner_events { 1u8 } else { 0u8 }).serialize(&mut buf0[17 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 20;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.classes.as_ptr() as *mut _;
sections[4].iov_len = self.classes.len() * std::mem::size_of::<EventClass>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for GrabDeviceKey<'a> {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl<'a> base::RequestWithoutReply for GrabDeviceKey<'a> {
}
#[derive(Clone, Debug)]
pub struct UngrabDeviceKey {
pub grab_window: xproto::Window,
pub modifiers: xproto::ModMask,
pub modifier_device: u8,
pub key: u8,
pub grabbed_device: u8,
}
unsafe impl base::RawRequest for UngrabDeviceKey {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 16,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 13];
self.grab_window.serialize(&mut buf0[4 .. ]);
(self.modifiers.bits() as u16).serialize(&mut buf0[8 .. ]);
self.modifier_device.serialize(&mut buf0[10 .. ]);
self.key.serialize(&mut buf0[11 .. ]);
self.grabbed_device.serialize(&mut buf0[12 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 13;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for UngrabDeviceKey {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for UngrabDeviceKey {
}
#[derive(Clone, Debug)]
pub struct GrabDeviceButton<'a> {
pub grab_window: xproto::Window,
pub grabbed_device: u8,
pub modifier_device: u8,
pub modifiers: xproto::ModMask,
pub this_device_mode: xproto::GrabMode,
pub other_device_mode: xproto::GrabMode,
pub button: u8,
pub owner_events: bool,
pub classes: &'a [EventClass],
}
unsafe impl<'a> base::RawRequest for GrabDeviceButton<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 17,
isvoid: 1,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 20];
self.grab_window.serialize(&mut buf0[4 .. ]);
self.grabbed_device.serialize(&mut buf0[8 .. ]);
self.modifier_device.serialize(&mut buf0[9 .. ]);
(self.classes.len() as u16).serialize(&mut buf0[10 .. ]);
(self.modifiers.bits() as u16).serialize(&mut buf0[12 .. ]);
(std::mem::transmute::<_, u32>(self.this_device_mode) as u8).serialize(&mut buf0[14 .. ]);
(std::mem::transmute::<_, u32>(self.other_device_mode) as u8).serialize(&mut buf0[15 .. ]);
self.button.serialize(&mut buf0[16 .. ]);
(if self.owner_events { 1u8 } else { 0u8 }).serialize(&mut buf0[17 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 20;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.classes.as_ptr() as *mut _;
sections[4].iov_len = self.classes.len() * std::mem::size_of::<EventClass>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for GrabDeviceButton<'a> {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl<'a> base::RequestWithoutReply for GrabDeviceButton<'a> {
}
#[derive(Clone, Debug)]
pub struct UngrabDeviceButton {
pub grab_window: xproto::Window,
pub modifiers: xproto::ModMask,
pub modifier_device: u8,
pub button: u8,
pub grabbed_device: u8,
}
unsafe impl base::RawRequest for UngrabDeviceButton {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 18,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 16];
self.grab_window.serialize(&mut buf0[4 .. ]);
(self.modifiers.bits() as u16).serialize(&mut buf0[8 .. ]);
self.modifier_device.serialize(&mut buf0[10 .. ]);
self.button.serialize(&mut buf0[11 .. ]);
self.grabbed_device.serialize(&mut buf0[12 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 16;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for UngrabDeviceButton {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for UngrabDeviceButton {
}
#[derive(Clone, Debug)]
pub struct AllowDeviceEvents {
pub time: xproto::Timestamp,
pub mode: DeviceInputMode,
pub device_id: u8,
}
unsafe impl base::RawRequest for AllowDeviceEvents {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 19,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 12];
self.time.serialize(&mut buf0[4 .. ]);
(std::mem::transmute::<_, u32>(self.mode) as u8).serialize(&mut buf0[8 .. ]);
self.device_id.serialize(&mut buf0[9 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 12;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for AllowDeviceEvents {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for AllowDeviceEvents {
}
pub struct GetDeviceFocusReply {
raw: *const u8,
}
impl GetDeviceFocusReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn focus(&self) -> xproto::Window {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn time(&self) -> xproto::Timestamp {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Timestamp;
base::value_from_ptr(ptr)
}
}
pub fn revert_to(&self) -> xproto::InputFocus {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::InputFocus>(val)
}
}
}
impl base::Reply for GetDeviceFocusReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for GetDeviceFocusReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GetDeviceFocusReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("focus", &self.focus())
.field("time", &self.time())
.field("revert_to", &self.revert_to())
.field("pad", &15)
.finish()
}
}
impl Drop for GetDeviceFocusReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for GetDeviceFocusReply {}
unsafe impl std::marker::Sync for GetDeviceFocusReply {}
#[derive(Debug)]
pub struct GetDeviceFocusCookie {
seq: u64,
}
#[derive(Debug)]
pub struct GetDeviceFocusCookieUnchecked {
seq: u64,
}
impl base::Cookie for GetDeviceFocusCookie {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceFocusCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for GetDeviceFocusCookie {
}
unsafe impl base::CookieWithReplyChecked for GetDeviceFocusCookie {
type Reply = GetDeviceFocusReply;
}
impl base::Cookie for GetDeviceFocusCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceFocusCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for GetDeviceFocusCookieUnchecked {
type Reply = GetDeviceFocusReply;
}
#[derive(Clone, Debug)]
pub struct GetDeviceFocus {
pub device_id: u8,
}
unsafe impl base::RawRequest for GetDeviceFocus {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 20,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for GetDeviceFocus {
type Cookie = GetDeviceFocusCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for GetDeviceFocus {
type Reply = GetDeviceFocusReply;
type Cookie = GetDeviceFocusCookie;
type CookieUnchecked = GetDeviceFocusCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct SetDeviceFocus {
pub focus: xproto::Window,
pub time: xproto::Timestamp,
pub revert_to: xproto::InputFocus,
pub device_id: u8,
}
unsafe impl base::RawRequest for SetDeviceFocus {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 21,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 16];
self.focus.serialize(&mut buf0[4 .. ]);
self.time.serialize(&mut buf0[8 .. ]);
(std::mem::transmute::<_, u32>(self.revert_to) as u8).serialize(&mut buf0[12 .. ]);
self.device_id.serialize(&mut buf0[13 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 16;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for SetDeviceFocus {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for SetDeviceFocus {
}
pub struct GetFeedbackControlReply {
raw: *const u8,
}
impl GetFeedbackControlReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let num_feedbacks = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 22usize;
for _ in 0 .. (num_feedbacks as usize) {
sz += <&FeedbackState>::compute_wire_len(ptr.add(sz), ());
}
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_feedbacks(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn feedbacks(&self) -> FeedbackStateIterator {
unsafe {
let offset = 32usize;
FeedbackStateIterator {
params: (),
rem: (self.num_feedbacks() as usize),
ptr: self.wire_ptr().add(offset),
phantom: std::marker::PhantomData,
}
}
}
}
impl base::Reply for GetFeedbackControlReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for GetFeedbackControlReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GetFeedbackControlReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("num_feedbacks", &self.num_feedbacks())
.field("pad", &22)
.field("feedbacks", &self.feedbacks())
.finish()
}
}
impl Drop for GetFeedbackControlReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for GetFeedbackControlReply {}
unsafe impl std::marker::Sync for GetFeedbackControlReply {}
#[derive(Debug)]
pub struct GetFeedbackControlCookie {
seq: u64,
}
#[derive(Debug)]
pub struct GetFeedbackControlCookieUnchecked {
seq: u64,
}
impl base::Cookie for GetFeedbackControlCookie {
unsafe fn from_sequence(seq: u64) -> Self {
GetFeedbackControlCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for GetFeedbackControlCookie {
}
unsafe impl base::CookieWithReplyChecked for GetFeedbackControlCookie {
type Reply = GetFeedbackControlReply;
}
impl base::Cookie for GetFeedbackControlCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
GetFeedbackControlCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for GetFeedbackControlCookieUnchecked {
type Reply = GetFeedbackControlReply;
}
#[derive(Clone, Debug)]
pub struct GetFeedbackControl {
pub device_id: u8,
}
unsafe impl base::RawRequest for GetFeedbackControl {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 22,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for GetFeedbackControl {
type Cookie = GetFeedbackControlCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for GetFeedbackControl {
type Reply = GetFeedbackControlReply;
type Cookie = GetFeedbackControlCookie;
type CookieUnchecked = GetFeedbackControlCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct ChangeFeedbackControl<'a> {
pub mask: ChangeFeedbackControlMask,
pub device_id: u8,
pub feedback_id: u8,
pub feedback: &'a FeedbackCtl,
}
unsafe impl<'a> base::RawRequest for ChangeFeedbackControl<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 23,
isvoid: 1,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 12];
self.mask.bits().serialize(&mut buf0[4 .. ]);
self.device_id.serialize(&mut buf0[8 .. ]);
self.feedback_id.serialize(&mut buf0[9 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 12;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.feedback.wire_ptr() as *mut _;
sections[4].iov_len = self.feedback.wire_len();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for ChangeFeedbackControl<'a> {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl<'a> base::RequestWithoutReply for ChangeFeedbackControl<'a> {
}
pub struct GetDeviceKeyMappingReply {
raw: *const u8,
}
impl GetDeviceKeyMappingReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
let length = *(ptr.add(sz) as *const u32);
sz += 4usize;
sz += 1usize;
sz += 23usize;
sz += ((length as usize) * 4usize);
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn keysyms_per_keycode(&self) -> u8 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn keysyms(&self) -> &[xproto::Keysym] {
unsafe {
let offset = 32usize;
let len = (self.length() as usize);
let ptr = self.wire_ptr().add(offset) as *const xproto::Keysym;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::Reply for GetDeviceKeyMappingReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for GetDeviceKeyMappingReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GetDeviceKeyMappingReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("keysyms_per_keycode", &self.keysyms_per_keycode())
.field("pad", &23)
.field("keysyms", &self.keysyms())
.finish()
}
}
impl Drop for GetDeviceKeyMappingReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for GetDeviceKeyMappingReply {}
unsafe impl std::marker::Sync for GetDeviceKeyMappingReply {}
#[derive(Debug)]
pub struct GetDeviceKeyMappingCookie {
seq: u64,
}
#[derive(Debug)]
pub struct GetDeviceKeyMappingCookieUnchecked {
seq: u64,
}
impl base::Cookie for GetDeviceKeyMappingCookie {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceKeyMappingCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for GetDeviceKeyMappingCookie {
}
unsafe impl base::CookieWithReplyChecked for GetDeviceKeyMappingCookie {
type Reply = GetDeviceKeyMappingReply;
}
impl base::Cookie for GetDeviceKeyMappingCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceKeyMappingCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for GetDeviceKeyMappingCookieUnchecked {
type Reply = GetDeviceKeyMappingReply;
}
#[derive(Clone, Debug)]
pub struct GetDeviceKeyMapping {
pub device_id: u8,
pub first_keycode: KeyCode,
pub count: u8,
}
unsafe impl base::RawRequest for GetDeviceKeyMapping {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 24,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
self.first_keycode.serialize(&mut buf0[5 .. ]);
self.count.serialize(&mut buf0[6 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for GetDeviceKeyMapping {
type Cookie = GetDeviceKeyMappingCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for GetDeviceKeyMapping {
type Reply = GetDeviceKeyMappingReply;
type Cookie = GetDeviceKeyMappingCookie;
type CookieUnchecked = GetDeviceKeyMappingCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct ChangeDeviceKeyMapping<'a> {
pub device_id: u8,
pub first_keycode: KeyCode,
pub keysyms_per_keycode: u8,
pub keycode_count: u8,
pub keysyms: &'a [xproto::Keysym],
}
unsafe impl<'a> base::RawRequest for ChangeDeviceKeyMapping<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 25,
isvoid: 1,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
self.first_keycode.serialize(&mut buf0[5 .. ]);
self.keysyms_per_keycode.serialize(&mut buf0[6 .. ]);
self.keycode_count.serialize(&mut buf0[7 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.keysyms.as_ptr() as *mut _;
sections[4].iov_len = self.keysyms.len() * std::mem::size_of::<xproto::Keysym>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for ChangeDeviceKeyMapping<'a> {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl<'a> base::RequestWithoutReply for ChangeDeviceKeyMapping<'a> {
}
pub struct GetDeviceModifierMappingReply {
raw: *const u8,
}
impl GetDeviceModifierMappingReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let keycodes_per_modifier = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 23usize;
sz += ((keycodes_per_modifier as usize) * 8usize);
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn keycodes_per_modifier(&self) -> u8 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn keymaps(&self) -> &[u8] {
unsafe {
let offset = 32usize;
let len = ((self.keycodes_per_modifier() as usize) * 8usize);
let ptr = self.wire_ptr().add(offset) as *const u8;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::Reply for GetDeviceModifierMappingReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for GetDeviceModifierMappingReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GetDeviceModifierMappingReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("keycodes_per_modifier", &self.keycodes_per_modifier())
.field("pad", &23)
.field("keymaps", &self.keymaps())
.finish()
}
}
impl Drop for GetDeviceModifierMappingReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for GetDeviceModifierMappingReply {}
unsafe impl std::marker::Sync for GetDeviceModifierMappingReply {}
#[derive(Debug)]
pub struct GetDeviceModifierMappingCookie {
seq: u64,
}
#[derive(Debug)]
pub struct GetDeviceModifierMappingCookieUnchecked {
seq: u64,
}
impl base::Cookie for GetDeviceModifierMappingCookie {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceModifierMappingCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for GetDeviceModifierMappingCookie {
}
unsafe impl base::CookieWithReplyChecked for GetDeviceModifierMappingCookie {
type Reply = GetDeviceModifierMappingReply;
}
impl base::Cookie for GetDeviceModifierMappingCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceModifierMappingCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for GetDeviceModifierMappingCookieUnchecked {
type Reply = GetDeviceModifierMappingReply;
}
#[derive(Clone, Debug)]
pub struct GetDeviceModifierMapping {
pub device_id: u8,
}
unsafe impl base::RawRequest for GetDeviceModifierMapping {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 26,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for GetDeviceModifierMapping {
type Cookie = GetDeviceModifierMappingCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for GetDeviceModifierMapping {
type Reply = GetDeviceModifierMappingReply;
type Cookie = GetDeviceModifierMappingCookie;
type CookieUnchecked = GetDeviceModifierMappingCookieUnchecked;
}
pub struct SetDeviceModifierMappingReply {
raw: *const u8,
}
impl SetDeviceModifierMappingReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> xproto::MappingStatus {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::MappingStatus>(val)
}
}
}
impl base::Reply for SetDeviceModifierMappingReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for SetDeviceModifierMappingReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SetDeviceModifierMappingReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("status", &self.status())
.field("pad", &23)
.finish()
}
}
impl Drop for SetDeviceModifierMappingReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for SetDeviceModifierMappingReply {}
unsafe impl std::marker::Sync for SetDeviceModifierMappingReply {}
#[derive(Debug)]
pub struct SetDeviceModifierMappingCookie {
seq: u64,
}
#[derive(Debug)]
pub struct SetDeviceModifierMappingCookieUnchecked {
seq: u64,
}
impl base::Cookie for SetDeviceModifierMappingCookie {
unsafe fn from_sequence(seq: u64) -> Self {
SetDeviceModifierMappingCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for SetDeviceModifierMappingCookie {
}
unsafe impl base::CookieWithReplyChecked for SetDeviceModifierMappingCookie {
type Reply = SetDeviceModifierMappingReply;
}
impl base::Cookie for SetDeviceModifierMappingCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
SetDeviceModifierMappingCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for SetDeviceModifierMappingCookieUnchecked {
type Reply = SetDeviceModifierMappingReply;
}
#[derive(Clone, Debug)]
pub struct SetDeviceModifierMapping<'a> {
pub device_id: u8,
pub keycodes_per_modifier: u8,
pub keymaps: &'a [u8],
}
unsafe impl<'a> base::RawRequest for SetDeviceModifierMapping<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 27,
isvoid: 0,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
self.keycodes_per_modifier.serialize(&mut buf0[5 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.keymaps.as_ptr() as *mut _;
sections[4].iov_len = self.keymaps.len() * std::mem::size_of::<u8>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for SetDeviceModifierMapping<'a> {
type Cookie = SetDeviceModifierMappingCookie;
const IS_VOID: bool = false;
}
impl<'a> base::RequestWithReply for SetDeviceModifierMapping<'a> {
type Reply = SetDeviceModifierMappingReply;
type Cookie = SetDeviceModifierMappingCookie;
type CookieUnchecked = SetDeviceModifierMappingCookieUnchecked;
}
pub struct GetDeviceButtonMappingReply {
raw: *const u8,
}
impl GetDeviceButtonMappingReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let map_size = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 23usize;
sz += (map_size as usize);
sz += base::align_pad(sz, 4);
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn map_size(&self) -> u8 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn map(&self) -> &[u8] {
unsafe {
let offset = 32usize;
let len = (self.map_size() as usize);
let ptr = self.wire_ptr().add(offset) as *const u8;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::Reply for GetDeviceButtonMappingReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for GetDeviceButtonMappingReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GetDeviceButtonMappingReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("map_size", &self.map_size())
.field("pad", &23)
.field("map", &self.map())
.field("align_pad", &4)
.finish()
}
}
impl Drop for GetDeviceButtonMappingReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for GetDeviceButtonMappingReply {}
unsafe impl std::marker::Sync for GetDeviceButtonMappingReply {}
#[derive(Debug)]
pub struct GetDeviceButtonMappingCookie {
seq: u64,
}
#[derive(Debug)]
pub struct GetDeviceButtonMappingCookieUnchecked {
seq: u64,
}
impl base::Cookie for GetDeviceButtonMappingCookie {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceButtonMappingCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for GetDeviceButtonMappingCookie {
}
unsafe impl base::CookieWithReplyChecked for GetDeviceButtonMappingCookie {
type Reply = GetDeviceButtonMappingReply;
}
impl base::Cookie for GetDeviceButtonMappingCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceButtonMappingCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for GetDeviceButtonMappingCookieUnchecked {
type Reply = GetDeviceButtonMappingReply;
}
#[derive(Clone, Debug)]
pub struct GetDeviceButtonMapping {
pub device_id: u8,
}
unsafe impl base::RawRequest for GetDeviceButtonMapping {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 28,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for GetDeviceButtonMapping {
type Cookie = GetDeviceButtonMappingCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for GetDeviceButtonMapping {
type Reply = GetDeviceButtonMappingReply;
type Cookie = GetDeviceButtonMappingCookie;
type CookieUnchecked = GetDeviceButtonMappingCookieUnchecked;
}
pub struct SetDeviceButtonMappingReply {
raw: *const u8,
}
impl SetDeviceButtonMappingReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> xproto::MappingStatus {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::MappingStatus>(val)
}
}
}
impl base::Reply for SetDeviceButtonMappingReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for SetDeviceButtonMappingReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SetDeviceButtonMappingReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("status", &self.status())
.field("pad", &23)
.finish()
}
}
impl Drop for SetDeviceButtonMappingReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for SetDeviceButtonMappingReply {}
unsafe impl std::marker::Sync for SetDeviceButtonMappingReply {}
#[derive(Debug)]
pub struct SetDeviceButtonMappingCookie {
seq: u64,
}
#[derive(Debug)]
pub struct SetDeviceButtonMappingCookieUnchecked {
seq: u64,
}
impl base::Cookie for SetDeviceButtonMappingCookie {
unsafe fn from_sequence(seq: u64) -> Self {
SetDeviceButtonMappingCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for SetDeviceButtonMappingCookie {
}
unsafe impl base::CookieWithReplyChecked for SetDeviceButtonMappingCookie {
type Reply = SetDeviceButtonMappingReply;
}
impl base::Cookie for SetDeviceButtonMappingCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
SetDeviceButtonMappingCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for SetDeviceButtonMappingCookieUnchecked {
type Reply = SetDeviceButtonMappingReply;
}
#[derive(Clone, Debug)]
pub struct SetDeviceButtonMapping<'a> {
pub device_id: u8,
pub map: &'a [u8],
}
unsafe impl<'a> base::RawRequest for SetDeviceButtonMapping<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 29,
isvoid: 0,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
(self.map.len() as u8).serialize(&mut buf0[5 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.map.as_ptr() as *mut _;
sections[4].iov_len = self.map.len() * std::mem::size_of::<u8>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for SetDeviceButtonMapping<'a> {
type Cookie = SetDeviceButtonMappingCookie;
const IS_VOID: bool = false;
}
impl<'a> base::RequestWithReply for SetDeviceButtonMapping<'a> {
type Reply = SetDeviceButtonMappingReply;
type Cookie = SetDeviceButtonMappingCookie;
type CookieUnchecked = SetDeviceButtonMappingCookieUnchecked;
}
pub struct QueryDeviceStateReply {
raw: *const u8,
}
impl QueryDeviceStateReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let num_classes = *(ptr.add(sz) as *const u8);
sz += 1usize;
sz += 23usize;
for _ in 0 .. (num_classes as usize) {
sz += <&InputState>::compute_wire_len(ptr.add(sz), ());
}
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_classes(&self) -> u8 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn classes(&self) -> InputStateIterator {
unsafe {
let offset = 32usize;
InputStateIterator {
params: (),
rem: (self.num_classes() as usize),
ptr: self.wire_ptr().add(offset),
phantom: std::marker::PhantomData,
}
}
}
}
impl base::Reply for QueryDeviceStateReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for QueryDeviceStateReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("QueryDeviceStateReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("num_classes", &self.num_classes())
.field("pad", &23)
.field("classes", &self.classes())
.finish()
}
}
impl Drop for QueryDeviceStateReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for QueryDeviceStateReply {}
unsafe impl std::marker::Sync for QueryDeviceStateReply {}
#[derive(Debug)]
pub struct QueryDeviceStateCookie {
seq: u64,
}
#[derive(Debug)]
pub struct QueryDeviceStateCookieUnchecked {
seq: u64,
}
impl base::Cookie for QueryDeviceStateCookie {
unsafe fn from_sequence(seq: u64) -> Self {
QueryDeviceStateCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for QueryDeviceStateCookie {
}
unsafe impl base::CookieWithReplyChecked for QueryDeviceStateCookie {
type Reply = QueryDeviceStateReply;
}
impl base::Cookie for QueryDeviceStateCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
QueryDeviceStateCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for QueryDeviceStateCookieUnchecked {
type Reply = QueryDeviceStateReply;
}
#[derive(Clone, Debug)]
pub struct QueryDeviceState {
pub device_id: u8,
}
unsafe impl base::RawRequest for QueryDeviceState {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 30,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for QueryDeviceState {
type Cookie = QueryDeviceStateCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for QueryDeviceState {
type Reply = QueryDeviceStateReply;
type Cookie = QueryDeviceStateCookie;
type CookieUnchecked = QueryDeviceStateCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct DeviceBell {
pub device_id: u8,
pub feedback_id: u8,
pub feedback_class: u8,
pub percent: i8,
}
unsafe impl base::RawRequest for DeviceBell {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 32,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
self.feedback_id.serialize(&mut buf0[5 .. ]);
self.feedback_class.serialize(&mut buf0[6 .. ]);
self.percent.serialize(&mut buf0[7 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for DeviceBell {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for DeviceBell {
}
pub struct SetDeviceValuatorsReply {
raw: *const u8,
}
impl SetDeviceValuatorsReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> xproto::GrabStatus {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::GrabStatus>(val)
}
}
}
impl base::Reply for SetDeviceValuatorsReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for SetDeviceValuatorsReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SetDeviceValuatorsReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("status", &self.status())
.field("pad", &23)
.finish()
}
}
impl Drop for SetDeviceValuatorsReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for SetDeviceValuatorsReply {}
unsafe impl std::marker::Sync for SetDeviceValuatorsReply {}
#[derive(Debug)]
pub struct SetDeviceValuatorsCookie {
seq: u64,
}
#[derive(Debug)]
pub struct SetDeviceValuatorsCookieUnchecked {
seq: u64,
}
impl base::Cookie for SetDeviceValuatorsCookie {
unsafe fn from_sequence(seq: u64) -> Self {
SetDeviceValuatorsCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for SetDeviceValuatorsCookie {
}
unsafe impl base::CookieWithReplyChecked for SetDeviceValuatorsCookie {
type Reply = SetDeviceValuatorsReply;
}
impl base::Cookie for SetDeviceValuatorsCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
SetDeviceValuatorsCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for SetDeviceValuatorsCookieUnchecked {
type Reply = SetDeviceValuatorsReply;
}
#[derive(Clone, Debug)]
pub struct SetDeviceValuators<'a> {
pub device_id: u8,
pub first_valuator: u8,
pub valuators: &'a [i32],
}
unsafe impl<'a> base::RawRequest for SetDeviceValuators<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 33,
isvoid: 0,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
self.first_valuator.serialize(&mut buf0[5 .. ]);
(self.valuators.len() as u8).serialize(&mut buf0[6 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.valuators.as_ptr() as *mut _;
sections[4].iov_len = self.valuators.len() * std::mem::size_of::<i32>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for SetDeviceValuators<'a> {
type Cookie = SetDeviceValuatorsCookie;
const IS_VOID: bool = false;
}
impl<'a> base::RequestWithReply for SetDeviceValuators<'a> {
type Reply = SetDeviceValuatorsReply;
type Cookie = SetDeviceValuatorsCookie;
type CookieUnchecked = SetDeviceValuatorsCookieUnchecked;
}
pub struct GetDeviceControlReply {
raw: *const u8,
}
impl GetDeviceControlReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
sz += 1usize;
sz += 23usize;
sz += <&DeviceState>::compute_wire_len(ptr.add(sz), ());
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> u8 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn control(&self) -> &DeviceState {
unsafe {
let offset = 32usize;
let len = <&DeviceState>::compute_wire_len(self.wire_ptr().add(offset), ());
let data = std::slice::from_raw_parts(self.wire_ptr().add(offset), len);
DeviceState::from_data(data)
}
}
}
impl base::Reply for GetDeviceControlReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for GetDeviceControlReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GetDeviceControlReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("status", &self.status())
.field("pad", &23)
.field("control", &self.control())
.finish()
}
}
impl Drop for GetDeviceControlReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for GetDeviceControlReply {}
unsafe impl std::marker::Sync for GetDeviceControlReply {}
#[derive(Debug)]
pub struct GetDeviceControlCookie {
seq: u64,
}
#[derive(Debug)]
pub struct GetDeviceControlCookieUnchecked {
seq: u64,
}
impl base::Cookie for GetDeviceControlCookie {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceControlCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for GetDeviceControlCookie {
}
unsafe impl base::CookieWithReplyChecked for GetDeviceControlCookie {
type Reply = GetDeviceControlReply;
}
impl base::Cookie for GetDeviceControlCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
GetDeviceControlCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for GetDeviceControlCookieUnchecked {
type Reply = GetDeviceControlReply;
}
#[derive(Clone, Debug)]
pub struct GetDeviceControl {
pub control_id: DeviceControl,
pub device_id: u8,
}
unsafe impl base::RawRequest for GetDeviceControl {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 34,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
(std::mem::transmute::<_, u32>(self.control_id) as u16).serialize(&mut buf0[4 .. ]);
self.device_id.serialize(&mut buf0[6 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for GetDeviceControl {
type Cookie = GetDeviceControlCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for GetDeviceControl {
type Reply = GetDeviceControlReply;
type Cookie = GetDeviceControlCookie;
type CookieUnchecked = GetDeviceControlCookieUnchecked;
}
pub struct ChangeDeviceControlReply {
raw: *const u8,
}
impl ChangeDeviceControlReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> u8 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
}
impl base::Reply for ChangeDeviceControlReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for ChangeDeviceControlReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ChangeDeviceControlReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("status", &self.status())
.field("pad", &23)
.finish()
}
}
impl Drop for ChangeDeviceControlReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for ChangeDeviceControlReply {}
unsafe impl std::marker::Sync for ChangeDeviceControlReply {}
#[derive(Debug)]
pub struct ChangeDeviceControlCookie {
seq: u64,
}
#[derive(Debug)]
pub struct ChangeDeviceControlCookieUnchecked {
seq: u64,
}
impl base::Cookie for ChangeDeviceControlCookie {
unsafe fn from_sequence(seq: u64) -> Self {
ChangeDeviceControlCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for ChangeDeviceControlCookie {
}
unsafe impl base::CookieWithReplyChecked for ChangeDeviceControlCookie {
type Reply = ChangeDeviceControlReply;
}
impl base::Cookie for ChangeDeviceControlCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
ChangeDeviceControlCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for ChangeDeviceControlCookieUnchecked {
type Reply = ChangeDeviceControlReply;
}
#[derive(Clone, Debug)]
pub struct ChangeDeviceControl<'a> {
pub control_id: DeviceControl,
pub device_id: u8,
pub control: &'a DeviceCtl,
}
unsafe impl<'a> base::RawRequest for ChangeDeviceControl<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 35,
isvoid: 0,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 8];
(std::mem::transmute::<_, u32>(self.control_id) as u16).serialize(&mut buf0[4 .. ]);
self.device_id.serialize(&mut buf0[6 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.control.wire_ptr() as *mut _;
sections[4].iov_len = self.control.wire_len();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for ChangeDeviceControl<'a> {
type Cookie = ChangeDeviceControlCookie;
const IS_VOID: bool = false;
}
impl<'a> base::RequestWithReply for ChangeDeviceControl<'a> {
type Reply = ChangeDeviceControlReply;
type Cookie = ChangeDeviceControlCookie;
type CookieUnchecked = ChangeDeviceControlCookieUnchecked;
}
pub struct ListDevicePropertiesReply {
raw: *const u8,
}
impl ListDevicePropertiesReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let num_atoms = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 22usize;
sz += ((num_atoms as usize) * 4usize);
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_atoms(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn atoms(&self) -> &[xproto::Atom] {
unsafe {
let offset = 32usize;
let len = (self.num_atoms() as usize);
let ptr = self.wire_ptr().add(offset) as *const xproto::Atom;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::Reply for ListDevicePropertiesReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for ListDevicePropertiesReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ListDevicePropertiesReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("num_atoms", &self.num_atoms())
.field("pad", &22)
.field("atoms", &self.atoms())
.finish()
}
}
impl Drop for ListDevicePropertiesReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for ListDevicePropertiesReply {}
unsafe impl std::marker::Sync for ListDevicePropertiesReply {}
#[derive(Debug)]
pub struct ListDevicePropertiesCookie {
seq: u64,
}
#[derive(Debug)]
pub struct ListDevicePropertiesCookieUnchecked {
seq: u64,
}
impl base::Cookie for ListDevicePropertiesCookie {
unsafe fn from_sequence(seq: u64) -> Self {
ListDevicePropertiesCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for ListDevicePropertiesCookie {
}
unsafe impl base::CookieWithReplyChecked for ListDevicePropertiesCookie {
type Reply = ListDevicePropertiesReply;
}
impl base::Cookie for ListDevicePropertiesCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
ListDevicePropertiesCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for ListDevicePropertiesCookieUnchecked {
type Reply = ListDevicePropertiesReply;
}
#[derive(Clone, Debug)]
pub struct ListDeviceProperties {
pub device_id: u8,
}
unsafe impl base::RawRequest for ListDeviceProperties {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 36,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device_id.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for ListDeviceProperties {
type Cookie = ListDevicePropertiesCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for ListDeviceProperties {
type Reply = ListDevicePropertiesReply;
type Cookie = ListDevicePropertiesCookie;
type CookieUnchecked = ListDevicePropertiesCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct ChangeDeviceProperty {
pub property: xproto::Atom,
pub r#type: xproto::Atom,
pub device_id: u8,
pub mode: xproto::PropMode,
pub num_items: u32,
pub items: ChangeDevicePropertyItems,
}
unsafe impl base::RawRequest for ChangeDeviceProperty {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 37,
isvoid: 1,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 20];
self.property.serialize(&mut buf0[4 .. ]);
self.r#type.serialize(&mut buf0[8 .. ]);
self.device_id.serialize(&mut buf0[12 .. ]);
(std::mem::transmute::<_, u32>(self.items.get_enum()) as u8).serialize(&mut buf0[13 .. ]);
(std::mem::transmute::<_, u32>(self.mode) as u8).serialize(&mut buf0[14 .. ]);
self.num_items.serialize(&mut buf0[16 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 20;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let len1 = self.items.wire_len();
let mut buf1 = vec![0u8; len1];
self.items.serialize(&mut buf1);
sections[4].iov_base = buf1.as_ptr() as *mut _;
sections[4].iov_len = buf1.len();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for ChangeDeviceProperty {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for ChangeDeviceProperty {
}
#[derive(Clone, Debug)]
pub struct DeleteDeviceProperty {
pub property: xproto::Atom,
pub device_id: u8,
}
unsafe impl base::RawRequest for DeleteDeviceProperty {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 38,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 12];
self.property.serialize(&mut buf0[4 .. ]);
self.device_id.serialize(&mut buf0[8 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 12;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for DeleteDeviceProperty {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for DeleteDeviceProperty {
}
pub struct GetDevicePropertyReply {
raw: *const u8,
}
impl GetDevicePropertyReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn xi_reply_type(&self) -> u8 {
unsafe {
let offset = 1usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn r#type(&self) -> xproto::Atom {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Atom;
base::value_from_ptr(ptr)
}
}
pub fn bytes_after(&self) -> u32 {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_items(&self) -> u32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn format(&self) -> PropertyFormat {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, PropertyFormat>(val)
}
}
pub fn device_id(&self) -> u8 {
unsafe {
let offset = 21usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn items(&self) -> GetDevicePropertyReplyItems {
let format = self.format();
let num_items = self.num_items();
let params = GetDevicePropertyReplyItemsParams {format: format as usize, num_items: num_items as usize};
let mut offset = 32usize;
unsafe {
GetDevicePropertyReplyItems::unserialize(
self.wire_ptr().add(offset), params, &mut offset
)
}
}
}
impl base::Reply for GetDevicePropertyReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for GetDevicePropertyReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GetDevicePropertyReply")
.field("response_type", &self.response_type())
.field("xi_reply_type", &self.xi_reply_type())
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("r#type", &self.r#type())
.field("bytes_after", &self.bytes_after())
.field("num_items", &self.num_items())
.field("format", &self.format())
.field("device_id", &self.device_id())
.field("pad", &10)
.field("items", &self.items())
.finish()
}
}
impl Drop for GetDevicePropertyReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for GetDevicePropertyReply {}
unsafe impl std::marker::Sync for GetDevicePropertyReply {}
#[derive(Debug)]
pub struct GetDevicePropertyCookie {
seq: u64,
}
#[derive(Debug)]
pub struct GetDevicePropertyCookieUnchecked {
seq: u64,
}
impl base::Cookie for GetDevicePropertyCookie {
unsafe fn from_sequence(seq: u64) -> Self {
GetDevicePropertyCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for GetDevicePropertyCookie {
}
unsafe impl base::CookieWithReplyChecked for GetDevicePropertyCookie {
type Reply = GetDevicePropertyReply;
}
impl base::Cookie for GetDevicePropertyCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
GetDevicePropertyCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for GetDevicePropertyCookieUnchecked {
type Reply = GetDevicePropertyReply;
}
#[derive(Clone, Debug)]
pub struct GetDeviceProperty {
pub property: xproto::Atom,
pub r#type: xproto::Atom,
pub offset: u32,
pub len: u32,
pub device_id: u8,
pub delete: bool,
}
unsafe impl base::RawRequest for GetDeviceProperty {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 39,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 24];
self.property.serialize(&mut buf0[4 .. ]);
self.r#type.serialize(&mut buf0[8 .. ]);
self.offset.serialize(&mut buf0[12 .. ]);
self.len.serialize(&mut buf0[16 .. ]);
self.device_id.serialize(&mut buf0[20 .. ]);
(if self.delete { 1u8 } else { 0u8 }).serialize(&mut buf0[21 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 24;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for GetDeviceProperty {
type Cookie = GetDevicePropertyCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for GetDeviceProperty {
type Reply = GetDevicePropertyReply;
type Cookie = GetDevicePropertyCookie;
type CookieUnchecked = GetDevicePropertyCookieUnchecked;
}
pub struct XiQueryPointerReply {
raw: *const u8,
}
impl XiQueryPointerReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 4usize;
sz += 1usize;
sz += 1usize;
let buttons_len = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 16usize;
sz += 4usize;
sz += ((buttons_len as usize) * 4usize);
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn root(&self) -> xproto::Window {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn child(&self) -> xproto::Window {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
pub fn root_x(&self) -> Fp1616 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn root_y(&self) -> Fp1616 {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn win_x(&self) -> Fp1616 {
unsafe {
let offset = 24usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn win_y(&self) -> Fp1616 {
unsafe {
let offset = 28usize;
let ptr = self.wire_ptr().add(offset) as *const Fp1616;
base::value_from_ptr(ptr)
}
}
pub fn same_screen(&self) -> bool {
let val = unsafe { *(self.wire_ptr().add(32usize)) };
val != 0
}
fn buttons_len(&self) -> u16 {
unsafe {
let offset = 34usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn mods(&self) -> ModifierInfo {
unsafe {
let offset = 36usize;
let ptr = self.wire_ptr().add(offset) as *const ModifierInfo;
base::value_from_ptr(ptr)
}
}
pub fn group(&self) -> GroupInfo {
unsafe {
let offset = 52usize;
let ptr = self.wire_ptr().add(offset) as *const GroupInfo;
base::value_from_ptr(ptr)
}
}
pub fn buttons(&self) -> &[u32] {
unsafe {
let offset = 56usize;
let len = (self.buttons_len() as usize);
let ptr = self.wire_ptr().add(offset) as *const u32;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::Reply for XiQueryPointerReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for XiQueryPointerReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XiQueryPointerReply")
.field("response_type", &self.response_type())
.field("pad", &1)
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("root", &self.root())
.field("child", &self.child())
.field("root_x", &self.root_x())
.field("root_y", &self.root_y())
.field("win_x", &self.win_x())
.field("win_y", &self.win_y())
.field("same_screen", &self.same_screen())
.field("pad", &1)
.field("buttons_len", &self.buttons_len())
.field("mods", &self.mods())
.field("group", &self.group())
.field("buttons", &self.buttons())
.finish()
}
}
impl Drop for XiQueryPointerReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for XiQueryPointerReply {}
unsafe impl std::marker::Sync for XiQueryPointerReply {}
#[derive(Debug)]
pub struct XiQueryPointerCookie {
seq: u64,
}
#[derive(Debug)]
pub struct XiQueryPointerCookieUnchecked {
seq: u64,
}
impl base::Cookie for XiQueryPointerCookie {
unsafe fn from_sequence(seq: u64) -> Self {
XiQueryPointerCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for XiQueryPointerCookie {
}
unsafe impl base::CookieWithReplyChecked for XiQueryPointerCookie {
type Reply = XiQueryPointerReply;
}
impl base::Cookie for XiQueryPointerCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
XiQueryPointerCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for XiQueryPointerCookieUnchecked {
type Reply = XiQueryPointerReply;
}
#[derive(Clone, Debug)]
pub struct XiQueryPointer {
pub window: xproto::Window,
pub device: Device,
}
unsafe impl base::RawRequest for XiQueryPointer {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 40,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 12];
self.window.serialize(&mut buf0[4 .. ]);
self.device.serialize(&mut buf0[8 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 12;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiQueryPointer {
type Cookie = XiQueryPointerCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for XiQueryPointer {
type Reply = XiQueryPointerReply;
type Cookie = XiQueryPointerCookie;
type CookieUnchecked = XiQueryPointerCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct XiWarpPointer {
pub src_win: xproto::Window,
pub dst_win: xproto::Window,
pub src_x: Fp1616,
pub src_y: Fp1616,
pub src_width: u16,
pub src_height: u16,
pub dst_x: Fp1616,
pub dst_y: Fp1616,
pub device: Device,
}
unsafe impl base::RawRequest for XiWarpPointer {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 41,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 36];
self.src_win.serialize(&mut buf0[4 .. ]);
self.dst_win.serialize(&mut buf0[8 .. ]);
self.src_x.serialize(&mut buf0[12 .. ]);
self.src_y.serialize(&mut buf0[16 .. ]);
self.src_width.serialize(&mut buf0[20 .. ]);
self.src_height.serialize(&mut buf0[22 .. ]);
self.dst_x.serialize(&mut buf0[24 .. ]);
self.dst_y.serialize(&mut buf0[28 .. ]);
self.device.serialize(&mut buf0[32 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 36;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiWarpPointer {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for XiWarpPointer {
}
#[derive(Clone, Debug)]
pub struct XiChangeCursor {
pub window: xproto::Window,
pub cursor: xproto::Cursor,
pub device: Device,
}
unsafe impl base::RawRequest for XiChangeCursor {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 42,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 16];
self.window.serialize(&mut buf0[4 .. ]);
self.cursor.serialize(&mut buf0[8 .. ]);
self.device.serialize(&mut buf0[12 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 16;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiChangeCursor {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for XiChangeCursor {
}
#[derive(Clone, Debug)]
pub struct XiChangeHierarchy<'a> {
pub changes: &'a [HierarchyChangeBuf],
}
unsafe impl<'a> base::RawRequest for XiChangeHierarchy<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 43,
isvoid: 1,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 8];
(self.changes.len() as u8).serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let len1: usize = self.changes.iter().map(|el| el.wire_len()).sum();
let mut buf1 = vec![0u8; len1];
let mut offset = 0usize;
for el in self.changes {
offset += el.serialize(&mut buf1[offset..]);
}
sections[4].iov_base = buf1.as_ptr() as *mut _;
sections[4].iov_len = buf1.len();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for XiChangeHierarchy<'a> {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl<'a> base::RequestWithoutReply for XiChangeHierarchy<'a> {
}
#[derive(Clone, Debug)]
pub struct XiSetClientPointer {
pub window: xproto::Window,
pub device: Device,
}
unsafe impl base::RawRequest for XiSetClientPointer {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 44,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 12];
self.window.serialize(&mut buf0[4 .. ]);
self.device.serialize(&mut buf0[8 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 12;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiSetClientPointer {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for XiSetClientPointer {
}
pub struct XiGetClientPointerReply {
raw: *const u8,
}
impl XiGetClientPointerReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn set(&self) -> bool {
let val = unsafe { *(self.wire_ptr().add(8usize)) };
val != 0
}
pub fn device(&self) -> Device {
unsafe {
let mut offset = 10usize;
Device::unserialize(self.wire_ptr().add(offset), (), &mut offset)
}
}
}
impl base::Reply for XiGetClientPointerReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for XiGetClientPointerReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XiGetClientPointerReply")
.field("response_type", &self.response_type())
.field("pad", &1)
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("set", &self.set())
.field("pad", &1)
.field("device", &self.device())
.field("pad", &20)
.finish()
}
}
impl Drop for XiGetClientPointerReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for XiGetClientPointerReply {}
unsafe impl std::marker::Sync for XiGetClientPointerReply {}
#[derive(Debug)]
pub struct XiGetClientPointerCookie {
seq: u64,
}
#[derive(Debug)]
pub struct XiGetClientPointerCookieUnchecked {
seq: u64,
}
impl base::Cookie for XiGetClientPointerCookie {
unsafe fn from_sequence(seq: u64) -> Self {
XiGetClientPointerCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for XiGetClientPointerCookie {
}
unsafe impl base::CookieWithReplyChecked for XiGetClientPointerCookie {
type Reply = XiGetClientPointerReply;
}
impl base::Cookie for XiGetClientPointerCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
XiGetClientPointerCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for XiGetClientPointerCookieUnchecked {
type Reply = XiGetClientPointerReply;
}
#[derive(Clone, Debug)]
pub struct XiGetClientPointer {
pub window: xproto::Window,
}
unsafe impl base::RawRequest for XiGetClientPointer {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 45,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.window.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiGetClientPointer {
type Cookie = XiGetClientPointerCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for XiGetClientPointer {
type Reply = XiGetClientPointerReply;
type Cookie = XiGetClientPointerCookie;
type CookieUnchecked = XiGetClientPointerCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct XiSelectEvents<'a> {
pub window: xproto::Window,
pub masks: &'a [EventMaskBuf],
}
unsafe impl<'a> base::RawRequest for XiSelectEvents<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 46,
isvoid: 1,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 12];
self.window.serialize(&mut buf0[4 .. ]);
(self.masks.len() as u16).serialize(&mut buf0[8 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 12;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let len1: usize = self.masks.iter().map(|el| el.wire_len()).sum();
let mut buf1 = vec![0u8; len1];
let mut offset = 0usize;
for el in self.masks {
offset += el.serialize(&mut buf1[offset..]);
}
sections[4].iov_base = buf1.as_ptr() as *mut _;
sections[4].iov_len = buf1.len();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for XiSelectEvents<'a> {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl<'a> base::RequestWithoutReply for XiSelectEvents<'a> {
}
pub struct XiQueryVersionReply {
raw: *const u8,
}
impl XiQueryVersionReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn major_version(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn minor_version(&self) -> u16 {
unsafe {
let offset = 10usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
}
impl base::Reply for XiQueryVersionReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for XiQueryVersionReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XiQueryVersionReply")
.field("response_type", &self.response_type())
.field("pad", &1)
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("major_version", &self.major_version())
.field("minor_version", &self.minor_version())
.field("pad", &20)
.finish()
}
}
impl Drop for XiQueryVersionReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for XiQueryVersionReply {}
unsafe impl std::marker::Sync for XiQueryVersionReply {}
#[derive(Debug)]
pub struct XiQueryVersionCookie {
seq: u64,
}
#[derive(Debug)]
pub struct XiQueryVersionCookieUnchecked {
seq: u64,
}
impl base::Cookie for XiQueryVersionCookie {
unsafe fn from_sequence(seq: u64) -> Self {
XiQueryVersionCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for XiQueryVersionCookie {
}
unsafe impl base::CookieWithReplyChecked for XiQueryVersionCookie {
type Reply = XiQueryVersionReply;
}
impl base::Cookie for XiQueryVersionCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
XiQueryVersionCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for XiQueryVersionCookieUnchecked {
type Reply = XiQueryVersionReply;
}
#[derive(Clone, Debug)]
pub struct XiQueryVersion {
pub major_version: u16,
pub minor_version: u16,
}
unsafe impl base::RawRequest for XiQueryVersion {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 47,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.major_version.serialize(&mut buf0[4 .. ]);
self.minor_version.serialize(&mut buf0[6 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiQueryVersion {
type Cookie = XiQueryVersionCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for XiQueryVersion {
type Reply = XiQueryVersionReply;
type Cookie = XiQueryVersionCookie;
type CookieUnchecked = XiQueryVersionCookieUnchecked;
}
pub struct XiQueryDeviceReply {
raw: *const u8,
}
impl XiQueryDeviceReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let num_infos = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 22usize;
for _ in 0 .. (num_infos as usize) {
sz += <&XiDeviceInfo>::compute_wire_len(ptr.add(sz), ());
}
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_infos(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn infos(&self) -> XiDeviceInfoIterator {
unsafe {
let offset = 32usize;
XiDeviceInfoIterator {
params: (),
rem: (self.num_infos() as usize),
ptr: self.wire_ptr().add(offset),
phantom: std::marker::PhantomData,
}
}
}
}
impl base::Reply for XiQueryDeviceReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for XiQueryDeviceReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XiQueryDeviceReply")
.field("response_type", &self.response_type())
.field("pad", &1)
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("num_infos", &self.num_infos())
.field("pad", &22)
.field("infos", &self.infos())
.finish()
}
}
impl Drop for XiQueryDeviceReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for XiQueryDeviceReply {}
unsafe impl std::marker::Sync for XiQueryDeviceReply {}
#[derive(Debug)]
pub struct XiQueryDeviceCookie {
seq: u64,
}
#[derive(Debug)]
pub struct XiQueryDeviceCookieUnchecked {
seq: u64,
}
impl base::Cookie for XiQueryDeviceCookie {
unsafe fn from_sequence(seq: u64) -> Self {
XiQueryDeviceCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for XiQueryDeviceCookie {
}
unsafe impl base::CookieWithReplyChecked for XiQueryDeviceCookie {
type Reply = XiQueryDeviceReply;
}
impl base::Cookie for XiQueryDeviceCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
XiQueryDeviceCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for XiQueryDeviceCookieUnchecked {
type Reply = XiQueryDeviceReply;
}
#[derive(Clone, Debug)]
pub struct XiQueryDevice {
pub device: Device,
}
unsafe impl base::RawRequest for XiQueryDevice {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 48,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiQueryDevice {
type Cookie = XiQueryDeviceCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for XiQueryDevice {
type Reply = XiQueryDeviceReply;
type Cookie = XiQueryDeviceCookie;
type CookieUnchecked = XiQueryDeviceCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct XiSetFocus {
pub window: xproto::Window,
pub time: xproto::Timestamp,
pub device: Device,
}
unsafe impl base::RawRequest for XiSetFocus {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 49,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 16];
self.window.serialize(&mut buf0[4 .. ]);
self.time.serialize(&mut buf0[8 .. ]);
self.device.serialize(&mut buf0[12 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 16;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiSetFocus {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for XiSetFocus {
}
pub struct XiGetFocusReply {
raw: *const u8,
}
impl XiGetFocusReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn focus(&self) -> xproto::Window {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Window;
base::value_from_ptr(ptr)
}
}
}
impl base::Reply for XiGetFocusReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for XiGetFocusReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XiGetFocusReply")
.field("response_type", &self.response_type())
.field("pad", &1)
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("focus", &self.focus())
.field("pad", &20)
.finish()
}
}
impl Drop for XiGetFocusReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for XiGetFocusReply {}
unsafe impl std::marker::Sync for XiGetFocusReply {}
#[derive(Debug)]
pub struct XiGetFocusCookie {
seq: u64,
}
#[derive(Debug)]
pub struct XiGetFocusCookieUnchecked {
seq: u64,
}
impl base::Cookie for XiGetFocusCookie {
unsafe fn from_sequence(seq: u64) -> Self {
XiGetFocusCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for XiGetFocusCookie {
}
unsafe impl base::CookieWithReplyChecked for XiGetFocusCookie {
type Reply = XiGetFocusReply;
}
impl base::Cookie for XiGetFocusCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
XiGetFocusCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for XiGetFocusCookieUnchecked {
type Reply = XiGetFocusReply;
}
#[derive(Clone, Debug)]
pub struct XiGetFocus {
pub device: Device,
}
unsafe impl base::RawRequest for XiGetFocus {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 50,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiGetFocus {
type Cookie = XiGetFocusCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for XiGetFocus {
type Reply = XiGetFocusReply;
type Cookie = XiGetFocusCookie;
type CookieUnchecked = XiGetFocusCookieUnchecked;
}
pub struct XiGrabDeviceReply {
raw: *const u8,
}
impl XiGrabDeviceReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn status(&self) -> xproto::GrabStatus {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, xproto::GrabStatus>(val)
}
}
}
impl base::Reply for XiGrabDeviceReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for XiGrabDeviceReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XiGrabDeviceReply")
.field("response_type", &self.response_type())
.field("pad", &1)
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("status", &self.status())
.field("pad", &23)
.finish()
}
}
impl Drop for XiGrabDeviceReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for XiGrabDeviceReply {}
unsafe impl std::marker::Sync for XiGrabDeviceReply {}
#[derive(Debug)]
pub struct XiGrabDeviceCookie {
seq: u64,
}
#[derive(Debug)]
pub struct XiGrabDeviceCookieUnchecked {
seq: u64,
}
impl base::Cookie for XiGrabDeviceCookie {
unsafe fn from_sequence(seq: u64) -> Self {
XiGrabDeviceCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for XiGrabDeviceCookie {
}
unsafe impl base::CookieWithReplyChecked for XiGrabDeviceCookie {
type Reply = XiGrabDeviceReply;
}
impl base::Cookie for XiGrabDeviceCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
XiGrabDeviceCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for XiGrabDeviceCookieUnchecked {
type Reply = XiGrabDeviceReply;
}
#[derive(Clone, Debug)]
pub struct XiGrabDevice<'a> {
pub window: xproto::Window,
pub time: xproto::Timestamp,
pub cursor: xproto::Cursor,
pub device: Device,
pub mode: xproto::GrabMode,
pub paired_device_mode: xproto::GrabMode,
pub owner_events: GrabOwner,
pub mask: &'a [u32],
}
unsafe impl<'a> base::RawRequest for XiGrabDevice<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 51,
isvoid: 0,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 24];
self.window.serialize(&mut buf0[4 .. ]);
self.time.serialize(&mut buf0[8 .. ]);
self.cursor.serialize(&mut buf0[12 .. ]);
self.device.serialize(&mut buf0[16 .. ]);
(std::mem::transmute::<_, u32>(self.mode) as u8).serialize(&mut buf0[18 .. ]);
(std::mem::transmute::<_, u32>(self.paired_device_mode) as u8).serialize(&mut buf0[19 .. ]);
(std::mem::transmute::<_, u32>(self.owner_events) as u8).serialize(&mut buf0[20 .. ]);
(self.mask.len() as u16).serialize(&mut buf0[22 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 24;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.mask.as_ptr() as *mut _;
sections[4].iov_len = self.mask.len() * std::mem::size_of::<u32>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for XiGrabDevice<'a> {
type Cookie = XiGrabDeviceCookie;
const IS_VOID: bool = false;
}
impl<'a> base::RequestWithReply for XiGrabDevice<'a> {
type Reply = XiGrabDeviceReply;
type Cookie = XiGrabDeviceCookie;
type CookieUnchecked = XiGrabDeviceCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct XiUngrabDevice {
pub time: xproto::Timestamp,
pub device: Device,
}
unsafe impl base::RawRequest for XiUngrabDevice {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 52,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 12];
self.time.serialize(&mut buf0[4 .. ]);
self.device.serialize(&mut buf0[8 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 12;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiUngrabDevice {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for XiUngrabDevice {
}
#[derive(Clone, Debug)]
pub struct XiAllowEvents {
pub time: xproto::Timestamp,
pub device: Device,
pub event_mode: EventMode,
pub touchid: u32,
pub grab_window: xproto::Window,
}
unsafe impl base::RawRequest for XiAllowEvents {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 53,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 20];
self.time.serialize(&mut buf0[4 .. ]);
self.device.serialize(&mut buf0[8 .. ]);
(std::mem::transmute::<_, u32>(self.event_mode) as u8).serialize(&mut buf0[10 .. ]);
self.touchid.serialize(&mut buf0[12 .. ]);
self.grab_window.serialize(&mut buf0[16 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 20;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiAllowEvents {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for XiAllowEvents {
}
pub struct XiPassiveGrabDeviceReply {
raw: *const u8,
}
impl XiPassiveGrabDeviceReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let num_modifiers = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 22usize;
sz += ((num_modifiers as usize) * 8usize);
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_modifiers(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn modifiers(&self) -> &[GrabModifierInfo] {
unsafe {
let offset = 32usize;
let len = (self.num_modifiers() as usize) as _;
let ptr = self.wire_ptr().add(offset) as *const GrabModifierInfo;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::Reply for XiPassiveGrabDeviceReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for XiPassiveGrabDeviceReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XiPassiveGrabDeviceReply")
.field("response_type", &self.response_type())
.field("pad", &1)
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("num_modifiers", &self.num_modifiers())
.field("pad", &22)
.field("modifiers", &self.modifiers())
.finish()
}
}
impl Drop for XiPassiveGrabDeviceReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for XiPassiveGrabDeviceReply {}
unsafe impl std::marker::Sync for XiPassiveGrabDeviceReply {}
#[derive(Debug)]
pub struct XiPassiveGrabDeviceCookie {
seq: u64,
}
#[derive(Debug)]
pub struct XiPassiveGrabDeviceCookieUnchecked {
seq: u64,
}
impl base::Cookie for XiPassiveGrabDeviceCookie {
unsafe fn from_sequence(seq: u64) -> Self {
XiPassiveGrabDeviceCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for XiPassiveGrabDeviceCookie {
}
unsafe impl base::CookieWithReplyChecked for XiPassiveGrabDeviceCookie {
type Reply = XiPassiveGrabDeviceReply;
}
impl base::Cookie for XiPassiveGrabDeviceCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
XiPassiveGrabDeviceCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for XiPassiveGrabDeviceCookieUnchecked {
type Reply = XiPassiveGrabDeviceReply;
}
#[derive(Clone, Debug)]
pub struct XiPassiveGrabDevice<'a> {
pub time: xproto::Timestamp,
pub grab_window: xproto::Window,
pub cursor: xproto::Cursor,
pub detail: u32,
pub device: Device,
pub grab_type: GrabType,
pub grab_mode: GrabMode22,
pub paired_device_mode: xproto::GrabMode,
pub owner_events: GrabOwner,
pub mask: &'a [u32],
pub modifiers: &'a [u32],
}
unsafe impl<'a> base::RawRequest for XiPassiveGrabDevice<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 6,
ext: (&mut FFI_EXT) as *mut _,
opcode: 54,
isvoid: 0,
};
let mut sections: [iovec; 8] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 8];
let buf0: &mut [u8] = &mut [0; 32];
self.time.serialize(&mut buf0[4 .. ]);
self.grab_window.serialize(&mut buf0[8 .. ]);
self.cursor.serialize(&mut buf0[12 .. ]);
self.detail.serialize(&mut buf0[16 .. ]);
self.device.serialize(&mut buf0[20 .. ]);
(self.modifiers.len() as u16).serialize(&mut buf0[22 .. ]);
(self.mask.len() as u16).serialize(&mut buf0[24 .. ]);
(std::mem::transmute::<_, u32>(self.grab_type) as u8).serialize(&mut buf0[26 .. ]);
(std::mem::transmute::<_, u32>(self.grab_mode) as u8).serialize(&mut buf0[27 .. ]);
(std::mem::transmute::<_, u32>(self.paired_device_mode) as u8).serialize(&mut buf0[28 .. ]);
(std::mem::transmute::<_, u32>(self.owner_events) as u8).serialize(&mut buf0[29 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 32;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.mask.as_ptr() as *mut _;
sections[4].iov_len = self.mask.len() * std::mem::size_of::<u32>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
sections[6].iov_base = self.modifiers.as_ptr() as *mut _;
sections[6].iov_len = self.modifiers.len() * std::mem::size_of::<u32>();
sections[7].iov_len = base::align_pad(sections[6].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for XiPassiveGrabDevice<'a> {
type Cookie = XiPassiveGrabDeviceCookie;
const IS_VOID: bool = false;
}
impl<'a> base::RequestWithReply for XiPassiveGrabDevice<'a> {
type Reply = XiPassiveGrabDeviceReply;
type Cookie = XiPassiveGrabDeviceCookie;
type CookieUnchecked = XiPassiveGrabDeviceCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct XiPassiveUngrabDevice<'a> {
pub grab_window: xproto::Window,
pub detail: u32,
pub device: Device,
pub grab_type: GrabType,
pub modifiers: &'a [u32],
}
unsafe impl<'a> base::RawRequest for XiPassiveUngrabDevice<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 55,
isvoid: 1,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 20];
self.grab_window.serialize(&mut buf0[4 .. ]);
self.detail.serialize(&mut buf0[8 .. ]);
self.device.serialize(&mut buf0[12 .. ]);
(self.modifiers.len() as u16).serialize(&mut buf0[14 .. ]);
(std::mem::transmute::<_, u32>(self.grab_type) as u8).serialize(&mut buf0[16 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 20;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.modifiers.as_ptr() as *mut _;
sections[4].iov_len = self.modifiers.len() * std::mem::size_of::<u32>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for XiPassiveUngrabDevice<'a> {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl<'a> base::RequestWithoutReply for XiPassiveUngrabDevice<'a> {
}
pub struct XiListPropertiesReply {
raw: *const u8,
}
impl XiListPropertiesReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let num_properties = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 22usize;
sz += ((num_properties as usize) * 4usize);
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_properties(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn properties(&self) -> &[xproto::Atom] {
unsafe {
let offset = 32usize;
let len = (self.num_properties() as usize);
let ptr = self.wire_ptr().add(offset) as *const xproto::Atom;
std::slice::from_raw_parts(ptr, len)
}
}
}
impl base::Reply for XiListPropertiesReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for XiListPropertiesReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XiListPropertiesReply")
.field("response_type", &self.response_type())
.field("pad", &1)
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("num_properties", &self.num_properties())
.field("pad", &22)
.field("properties", &self.properties())
.finish()
}
}
impl Drop for XiListPropertiesReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for XiListPropertiesReply {}
unsafe impl std::marker::Sync for XiListPropertiesReply {}
#[derive(Debug)]
pub struct XiListPropertiesCookie {
seq: u64,
}
#[derive(Debug)]
pub struct XiListPropertiesCookieUnchecked {
seq: u64,
}
impl base::Cookie for XiListPropertiesCookie {
unsafe fn from_sequence(seq: u64) -> Self {
XiListPropertiesCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for XiListPropertiesCookie {
}
unsafe impl base::CookieWithReplyChecked for XiListPropertiesCookie {
type Reply = XiListPropertiesReply;
}
impl base::Cookie for XiListPropertiesCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
XiListPropertiesCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for XiListPropertiesCookieUnchecked {
type Reply = XiListPropertiesReply;
}
#[derive(Clone, Debug)]
pub struct XiListProperties {
pub device: Device,
}
unsafe impl base::RawRequest for XiListProperties {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 56,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.device.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiListProperties {
type Cookie = XiListPropertiesCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for XiListProperties {
type Reply = XiListPropertiesReply;
type Cookie = XiListPropertiesCookie;
type CookieUnchecked = XiListPropertiesCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct XiChangeProperty {
pub device: Device,
pub mode: xproto::PropMode,
pub property: xproto::Atom,
pub r#type: xproto::Atom,
pub num_items: u32,
pub items: XiChangePropertyItems,
}
unsafe impl base::RawRequest for XiChangeProperty {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 57,
isvoid: 1,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 20];
self.device.serialize(&mut buf0[4 .. ]);
(std::mem::transmute::<_, u32>(self.mode) as u8).serialize(&mut buf0[6 .. ]);
(std::mem::transmute::<_, u32>(self.items.get_enum()) as u8).serialize(&mut buf0[7 .. ]);
self.property.serialize(&mut buf0[8 .. ]);
self.r#type.serialize(&mut buf0[12 .. ]);
self.num_items.serialize(&mut buf0[16 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 20;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let len1 = self.items.wire_len();
let mut buf1 = vec![0u8; len1];
self.items.serialize(&mut buf1);
sections[4].iov_base = buf1.as_ptr() as *mut _;
sections[4].iov_len = buf1.len();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiChangeProperty {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for XiChangeProperty {
}
#[derive(Clone, Debug)]
pub struct XiDeleteProperty {
pub device: Device,
pub property: xproto::Atom,
}
unsafe impl base::RawRequest for XiDeleteProperty {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 58,
isvoid: 1,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 12];
self.device.serialize(&mut buf0[4 .. ]);
self.property.serialize(&mut buf0[8 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 12;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiDeleteProperty {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl base::RequestWithoutReply for XiDeleteProperty {
}
pub struct XiGetPropertyReply {
raw: *const u8,
}
impl XiGetPropertyReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn r#type(&self) -> xproto::Atom {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const xproto::Atom;
base::value_from_ptr(ptr)
}
}
pub fn bytes_after(&self) -> u32 {
unsafe {
let offset = 12usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_items(&self) -> u32 {
unsafe {
let offset = 16usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
pub fn format(&self) -> PropertyFormat {
unsafe {
let offset = 20usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
let val = base::value_from_ptr(ptr) as u32;
std::mem::transmute::<u32, PropertyFormat>(val)
}
}
pub fn items(&self) -> XiGetPropertyReplyItems {
let format = self.format();
let num_items = self.num_items();
let params = XiGetPropertyReplyItemsParams {format: format as usize, num_items: num_items as usize};
let mut offset = 32usize;
unsafe {
XiGetPropertyReplyItems::unserialize(
self.wire_ptr().add(offset), params, &mut offset
)
}
}
}
impl base::Reply for XiGetPropertyReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for XiGetPropertyReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XiGetPropertyReply")
.field("response_type", &self.response_type())
.field("pad", &1)
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("r#type", &self.r#type())
.field("bytes_after", &self.bytes_after())
.field("num_items", &self.num_items())
.field("format", &self.format())
.field("pad", &11)
.field("items", &self.items())
.finish()
}
}
impl Drop for XiGetPropertyReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for XiGetPropertyReply {}
unsafe impl std::marker::Sync for XiGetPropertyReply {}
#[derive(Debug)]
pub struct XiGetPropertyCookie {
seq: u64,
}
#[derive(Debug)]
pub struct XiGetPropertyCookieUnchecked {
seq: u64,
}
impl base::Cookie for XiGetPropertyCookie {
unsafe fn from_sequence(seq: u64) -> Self {
XiGetPropertyCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for XiGetPropertyCookie {
}
unsafe impl base::CookieWithReplyChecked for XiGetPropertyCookie {
type Reply = XiGetPropertyReply;
}
impl base::Cookie for XiGetPropertyCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
XiGetPropertyCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for XiGetPropertyCookieUnchecked {
type Reply = XiGetPropertyReply;
}
#[derive(Clone, Debug)]
pub struct XiGetProperty {
pub device: Device,
pub delete: bool,
pub property: xproto::Atom,
pub r#type: xproto::Atom,
pub offset: u32,
pub len: u32,
}
unsafe impl base::RawRequest for XiGetProperty {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 59,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 24];
self.device.serialize(&mut buf0[4 .. ]);
(if self.delete { 1u8 } else { 0u8 }).serialize(&mut buf0[6 .. ]);
self.property.serialize(&mut buf0[8 .. ]);
self.r#type.serialize(&mut buf0[12 .. ]);
self.offset.serialize(&mut buf0[16 .. ]);
self.len.serialize(&mut buf0[20 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 24;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiGetProperty {
type Cookie = XiGetPropertyCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for XiGetProperty {
type Reply = XiGetPropertyReply;
type Cookie = XiGetPropertyCookie;
type CookieUnchecked = XiGetPropertyCookieUnchecked;
}
pub struct XiGetSelectedEventsReply {
raw: *const u8,
}
impl XiGetSelectedEventsReply {
fn wire_ptr(&self) -> *const u8 {
self.raw
}
fn wire_len(&self) -> usize {
(32 + self.length() * 4) as _
}
unsafe fn compute_len(ptr: *const u8, _params: ()) -> usize {
let mut sz = 0;
sz += 1usize;
sz += 1usize;
sz += 2usize;
sz += 4usize;
let num_masks = *(ptr.add(sz) as *const u16);
sz += 2usize;
sz += 22usize;
for _ in 0 .. (num_masks as usize) {
sz += <&EventMask>::compute_wire_len(ptr.add(sz), ());
}
sz
}
pub fn response_type(&self) -> u8 {
unsafe {
let offset = 0usize;
let ptr = self.wire_ptr().add(offset) as *const u8;
base::value_from_ptr(ptr)
}
}
pub fn sequence(&self) -> u16 {
unsafe {
let offset = 2usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn length(&self) -> u32 {
unsafe {
let offset = 4usize;
let ptr = self.wire_ptr().add(offset) as *const u32;
base::value_from_ptr(ptr)
}
}
fn num_masks(&self) -> u16 {
unsafe {
let offset = 8usize;
let ptr = self.wire_ptr().add(offset) as *const u16;
base::value_from_ptr(ptr)
}
}
pub fn masks(&self) -> EventMaskIterator {
unsafe {
let offset = 32usize;
EventMaskIterator {
params: (),
rem: (self.num_masks() as usize),
ptr: self.wire_ptr().add(offset),
phantom: std::marker::PhantomData,
}
}
}
}
impl base::Reply for XiGetSelectedEventsReply {
unsafe fn from_raw(raw: *const u8) -> Self {
Self { raw }
}
unsafe fn into_raw(self) -> *const u8 {
let raw = self.raw;
std::mem::forget(self);
raw
}
}
impl std::fmt::Debug for XiGetSelectedEventsReply {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XiGetSelectedEventsReply")
.field("response_type", &self.response_type())
.field("pad", &1)
.field("sequence", &self.sequence())
.field("length", &self.length())
.field("num_masks", &self.num_masks())
.field("pad", &22)
.field("masks", &self.masks())
.finish()
}
}
impl Drop for XiGetSelectedEventsReply {
fn drop(&mut self) {
unsafe { libc::free(self.raw as *mut _); }
}
}
unsafe impl std::marker::Send for XiGetSelectedEventsReply {}
unsafe impl std::marker::Sync for XiGetSelectedEventsReply {}
#[derive(Debug)]
pub struct XiGetSelectedEventsCookie {
seq: u64,
}
#[derive(Debug)]
pub struct XiGetSelectedEventsCookieUnchecked {
seq: u64,
}
impl base::Cookie for XiGetSelectedEventsCookie {
unsafe fn from_sequence(seq: u64) -> Self {
XiGetSelectedEventsCookie { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieChecked for XiGetSelectedEventsCookie {
}
unsafe impl base::CookieWithReplyChecked for XiGetSelectedEventsCookie {
type Reply = XiGetSelectedEventsReply;
}
impl base::Cookie for XiGetSelectedEventsCookieUnchecked {
unsafe fn from_sequence(seq: u64) -> Self {
XiGetSelectedEventsCookieUnchecked { seq }
}
fn sequence(&self) -> u64 {
self.seq
}
}
unsafe impl base::CookieWithReplyUnchecked for XiGetSelectedEventsCookieUnchecked {
type Reply = XiGetSelectedEventsReply;
}
#[derive(Clone, Debug)]
pub struct XiGetSelectedEvents {
pub window: xproto::Window,
}
unsafe impl base::RawRequest for XiGetSelectedEvents {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 2,
ext: (&mut FFI_EXT) as *mut _,
opcode: 60,
isvoid: 0,
};
let mut sections: [iovec; 4] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 4];
let buf0: &mut [u8] = &mut [0; 8];
self.window.serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl base::Request for XiGetSelectedEvents {
type Cookie = XiGetSelectedEventsCookie;
const IS_VOID: bool = false;
}
impl base::RequestWithReply for XiGetSelectedEvents {
type Reply = XiGetSelectedEventsReply;
type Cookie = XiGetSelectedEventsCookie;
type CookieUnchecked = XiGetSelectedEventsCookieUnchecked;
}
#[derive(Clone, Debug)]
pub struct XiBarrierReleasePointer<'a> {
pub barriers: &'a [BarrierReleasePointerInfo],
}
unsafe impl<'a> base::RawRequest for XiBarrierReleasePointer<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 4,
ext: (&mut FFI_EXT) as *mut _,
opcode: 61,
isvoid: 1,
};
let mut sections: [iovec; 6] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 6];
let buf0: &mut [u8] = &mut [0; 8];
(self.barriers.len() as u32).serialize(&mut buf0[4 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 8;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
sections[4].iov_base = self.barriers.as_ptr() as *mut _;
sections[4].iov_len = self.barriers.len() * std::mem::size_of::<BarrierReleasePointerInfo>();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for XiBarrierReleasePointer<'a> {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl<'a> base::RequestWithoutReply for XiBarrierReleasePointer<'a> {
}
#[derive(Clone, Debug)]
pub struct SendExtensionEvent<'a> {
pub destination: xproto::Window,
pub device_id: u8,
pub propagate: bool,
pub events: &'a [EventForSend],
pub classes: &'a [EventClass],
}
unsafe impl<'a> base::RawRequest for SendExtensionEvent<'a> {
fn raw_request(&self, c: &base::Connection, checked: bool) -> u64 { unsafe {
let mut protocol_request = xcb_protocol_request_t {
count: 6,
ext: (&mut FFI_EXT) as *mut _,
opcode: 31,
isvoid: 1,
};
let mut sections: [iovec; 8] = [iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; 8];
let buf0: &mut [u8] = &mut [0; 16];
self.destination.serialize(&mut buf0[4 .. ]);
self.device_id.serialize(&mut buf0[8 .. ]);
(if self.propagate { 1u8 } else { 0u8 }).serialize(&mut buf0[9 .. ]);
(self.classes.len() as u16).serialize(&mut buf0[10 .. ]);
(self.events.len() as u8).serialize(&mut buf0[12 .. ]);
sections[2].iov_base = buf0.as_mut_ptr() as *mut _;
sections[2].iov_len = 16;
sections[3].iov_len = base::align_pad(sections[2].iov_len, 4);
let len1 = self.events.iter().map(|el| el.wire_len()).sum::<usize>();
let mut buf1 = vec![0u8; len1];
let mut offset1 = 0usize;
for el in self.events {
offset1 += el.serialize(&mut buf1[offset1 ..]);
}
sections[4].iov_base = buf1.as_ptr() as *mut _;
sections[4].iov_len = buf1.len();
sections[5].iov_len = base::align_pad(sections[4].iov_len, 4);
sections[6].iov_base = self.classes.as_ptr() as *mut _;
sections[6].iov_len = self.classes.len() * std::mem::size_of::<EventClass>();
sections[7].iov_len = base::align_pad(sections[6].iov_len, 4);
let flags = if checked { base::RequestFlags::CHECKED } else { base::RequestFlags::NONE };
xcb_send_request64(
c.get_raw_conn(),
flags.bits() as _,
sections.as_mut_ptr().add(2),
&mut protocol_request as *mut _,
)
}
}}
impl<'a> base::Request for SendExtensionEvent<'a> {
type Cookie = base::VoidCookie;
const IS_VOID: bool = true;
}
impl<'a> base::RequestWithoutReply for SendExtensionEvent<'a> {
}