module Graphics.XHB.Gen.Input.Types (deserializeError, deserializeEvent, KeyCode, EventClass, ValuatorMode(..), PropagateMode(..), GetExtensionVersion(..), GetExtensionVersionReply(..), DeviceUse(..), DeviceInfo(..), ListInputDevices(..), ListInputDevicesReply(..), InputClass(..), InputInfo(..), KeyInfo(..), ButtonInfo(..), AxisInfo(..), ValuatorInfo(..), InputClassInfo(..), OpenDevice(..), OpenDeviceReply(..), CloseDevice(..), SetDeviceMode(..), SetDeviceModeReply(..), SelectExtensionEvent(..), GetSelectedExtensionEvents(..), GetSelectedExtensionEventsReply(..), ChangeDeviceDontPropagateList(..), GetDeviceDontPropagateList(..), GetDeviceDontPropagateListReply(..), GetDeviceMotionEvents(..), GetDeviceMotionEventsReply(..), DeviceTimeCoord(..), ChangeKeyboardDevice(..), ChangeKeyboardDeviceReply(..), ChangePointerDevice(..), ChangePointerDeviceReply(..), GrabDevice(..), GrabDeviceReply(..), UngrabDevice(..), GrabDeviceKey(..), UngrabDeviceKey(..), GrabDeviceButton(..), UngrabDeviceButton(..), DeviceInputMode(..), AllowDeviceEvents(..), GetDeviceFocus(..), GetDeviceFocusReply(..), SetDeviceFocus(..), GetFeedbackControl(..), GetFeedbackControlReply(..), FeedbackClass(..), FeedbackState(..), KbdFeedbackState(..), PtrFeedbackState(..), IntegerFeedbackState(..), StringFeedbackState(..), BellFeedbackState(..), LedFeedbackState(..), FeedbackCtl(..), KbdFeedbackCtl(..), PtrFeedbackCtl(..), IntegerFeedbackCtl(..), StringFeedbackCtl(..), BellFeedbackCtl(..), LedFeedbackCtl(..), GetDeviceKeyMapping(..), GetDeviceKeyMappingReply(..), ChangeDeviceKeyMapping(..), GetDeviceModifierMapping(..), GetDeviceModifierMappingReply(..), SetDeviceModifierMapping(..), SetDeviceModifierMappingReply(..), GetDeviceButtonMapping(..), GetDeviceButtonMappingReply(..), SetDeviceButtonMapping(..), SetDeviceButtonMappingReply(..), QueryDeviceState(..), QueryDeviceStateReply(..), InputState(..), KeyState(..), ButtonState(..), ValuatorState(..), SendExtensionEvent(..), DeviceBell(..), SetDeviceValuators(..), SetDeviceValuatorsReply(..), GetDeviceControl(..), GetDeviceControlReply(..), DeviceState(..), DeviceResolutionState(..), DeviceAbsCalibState(..), DeviceAbsAreaState(..), DeviceCoreState(..), DeviceEnableState(..), DeviceCtl(..), DeviceResolutionCtl(..), DeviceAbsCalibCtl(..), DeviceAbsAreaCtrl(..), DeviceCoreCtrl(..), DeviceEnableCtrl(..), DeviceValuatorEvent(..), DeviceKeyPressEvent(..), DeviceKeyReleaseEvent(..), DeviceButtonPressEvent(..), DeviceButtonReleaseEvent(..), DeviceMotionNotifyEvent(..), ProximityInEvent(..), ProximityOutEvent(..), FocusInEvent(..), FocusOutEvent(..), DeviceStateNotifyEvent(..), DeviceMappingNotifyEvent(..), ChangeDeviceNotifyEvent(..), DeviceKeyStateNotifyEvent(..), DeviceButtonStateNotifyEvent(..), DevicePresenceNotifyEvent(..)) where import Data.Word import Data.Int import Foreign.C.Types import Data.Bits import Data.Binary.Put import Data.Binary.Get import Data.Typeable import Control.Monad import Control.Exception import Data.List import Graphics.XHB.Shared hiding (Event, Error) import qualified Graphics.XHB.Shared import Graphics.XHB.Gen.Xproto.Types hiding (FocusInEvent(..), FocusOutEvent(..), deserializeError, deserializeEvent) import qualified Graphics.XHB.Gen.Xproto.Types deserializeError :: Word8 -> Maybe (Get SomeError) deserializeError _ = Nothing deserializeEvent :: Word8 -> Maybe (Get SomeEvent) deserializeEvent 0 = return (liftM toEvent (deserialize :: Get DeviceValuatorEvent)) deserializeEvent 1 = return (liftM toEvent (deserialize :: Get DeviceKeyPressEvent)) deserializeEvent 2 = return (liftM toEvent (deserialize :: Get DeviceKeyReleaseEvent)) deserializeEvent 3 = return (liftM toEvent (deserialize :: Get DeviceButtonPressEvent)) deserializeEvent 4 = return (liftM toEvent (deserialize :: Get DeviceButtonReleaseEvent)) deserializeEvent 5 = return (liftM toEvent (deserialize :: Get DeviceMotionNotifyEvent)) deserializeEvent 8 = return (liftM toEvent (deserialize :: Get ProximityInEvent)) deserializeEvent 9 = return (liftM toEvent (deserialize :: Get ProximityOutEvent)) deserializeEvent 6 = return (liftM toEvent (deserialize :: Get FocusInEvent)) deserializeEvent 7 = return (liftM toEvent (deserialize :: Get FocusOutEvent)) deserializeEvent 10 = return (liftM toEvent (deserialize :: Get DeviceStateNotifyEvent)) deserializeEvent 11 = return (liftM toEvent (deserialize :: Get DeviceMappingNotifyEvent)) deserializeEvent 12 = return (liftM toEvent (deserialize :: Get ChangeDeviceNotifyEvent)) deserializeEvent 13 = return (liftM toEvent (deserialize :: Get DeviceKeyStateNotifyEvent)) deserializeEvent 14 = return (liftM toEvent (deserialize :: Get DeviceButtonStateNotifyEvent)) deserializeEvent 15 = return (liftM toEvent (deserialize :: Get DevicePresenceNotifyEvent)) deserializeEvent _ = Nothing type KeyCode = Word8 type EventClass = Word32 data ValuatorMode = ValuatorModeRelative | ValuatorModeAbsolute deriving (Show, Eq, Ord, Enum) instance SimpleEnum ValuatorMode where toValue ValuatorModeRelative{} = 0 toValue ValuatorModeAbsolute{} = 1 fromValue 0 = ValuatorModeRelative fromValue 1 = ValuatorModeAbsolute data PropagateMode = PropagateModeAddToList | PropagateModeDeleteFromList deriving (Show, Eq, Ord, Enum) instance SimpleEnum PropagateMode where toValue PropagateModeAddToList{} = 0 toValue PropagateModeDeleteFromList{} = 1 fromValue 0 = PropagateModeAddToList fromValue 1 = PropagateModeDeleteFromList data GetExtensionVersion = MkGetExtensionVersion{name_len_GetExtensionVersion :: Word16, name_GetExtensionVersion :: [CChar]} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GetExtensionVersion where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 1 let size__ = 4 + size (name_len_GetExtensionVersion x) + 2 + sum (map size (name_GetExtensionVersion x)) serialize (convertBytesToRequestSize size__ :: Int16) serialize (name_len_GetExtensionVersion x) putSkip 2 serializeList (name_GetExtensionVersion x) putSkip (requiredPadding size__) data GetExtensionVersionReply = MkGetExtensionVersionReply{server_major_GetExtensionVersionReply :: Word16, server_minor_GetExtensionVersionReply :: Word16, present_GetExtensionVersionReply :: Bool} deriving (Show, Typeable, Eq, Ord) instance Deserialize GetExtensionVersionReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize server_major <- deserialize server_minor <- deserialize present <- deserialize skip 19 let _ = isCard32 length return (MkGetExtensionVersionReply server_major server_minor present) data DeviceUse = DeviceUseIsXPointer | DeviceUseIsXKeyboard | DeviceUseIsXExtensionDevice | DeviceUseIsXExtensionKeyboard | DeviceUseIsXExtensionPointer deriving (Show, Eq, Ord, Enum) instance SimpleEnum DeviceUse where toValue DeviceUseIsXPointer{} = 0 toValue DeviceUseIsXKeyboard{} = 1 toValue DeviceUseIsXExtensionDevice{} = 2 toValue DeviceUseIsXExtensionKeyboard{} = 3 toValue DeviceUseIsXExtensionPointer{} = 4 fromValue 0 = DeviceUseIsXPointer fromValue 1 = DeviceUseIsXKeyboard fromValue 2 = DeviceUseIsXExtensionDevice fromValue 3 = DeviceUseIsXExtensionKeyboard fromValue 4 = DeviceUseIsXExtensionPointer data DeviceInfo = MkDeviceInfo{device_type_DeviceInfo :: ATOM, device_id_DeviceInfo :: Word8, num_class_info_DeviceInfo :: Word8, device_use_DeviceInfo :: DeviceUse} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceInfo where serialize x = do serialize (device_type_DeviceInfo x) serialize (device_id_DeviceInfo x) serialize (num_class_info_DeviceInfo x) serialize (toValue (device_use_DeviceInfo x) :: Word8) putSkip 1 size x = size (device_type_DeviceInfo x) + size (device_id_DeviceInfo x) + size (num_class_info_DeviceInfo x) + size (undefined :: Word8) + 1 instance Deserialize DeviceInfo where deserialize = do device_type <- deserialize device_id <- deserialize num_class_info <- deserialize device_use <- liftM fromValue (deserialize :: Get Word8) skip 1 return (MkDeviceInfo device_type device_id num_class_info device_use) data ListInputDevices = MkListInputDevices{} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest ListInputDevices where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 2 let size__ = 4 serialize (convertBytesToRequestSize size__ :: Int16) putSkip (requiredPadding size__) data ListInputDevicesReply = MkListInputDevicesReply{devices_len_ListInputDevicesReply :: Word8, devices_ListInputDevicesReply :: [DeviceInfo]} deriving (Show, Typeable, Eq, Ord) instance Deserialize ListInputDevicesReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize devices_len <- deserialize skip 23 devices <- deserializeList (fromIntegral devices_len) let _ = isCard32 length return (MkListInputDevicesReply devices_len devices) data InputClass = InputClassKey | InputClassButton | InputClassValuator | InputClassFeedback | InputClassProximity | InputClassFocus | InputClassOther deriving (Show, Eq, Ord, Enum) instance SimpleEnum InputClass where toValue InputClassKey{} = 0 toValue InputClassButton{} = 1 toValue InputClassValuator{} = 2 toValue InputClassFeedback{} = 3 toValue InputClassProximity{} = 4 toValue InputClassFocus{} = 5 toValue InputClassOther{} = 6 fromValue 0 = InputClassKey fromValue 1 = InputClassButton fromValue 2 = InputClassValuator fromValue 3 = InputClassFeedback fromValue 4 = InputClassProximity fromValue 5 = InputClassFocus fromValue 6 = InputClassOther data InputInfo = MkInputInfo{class_id_InputInfo :: InputClass, len_InputInfo :: Word8} deriving (Show, Typeable, Eq, Ord) instance Serialize InputInfo where serialize x = do serialize (toValue (class_id_InputInfo x) :: Word8) serialize (len_InputInfo x) size x = size (undefined :: Word8) + size (len_InputInfo x) instance Deserialize InputInfo where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) len <- deserialize return (MkInputInfo class_id len) data KeyInfo = MkKeyInfo{class_id_KeyInfo :: InputClass, len_KeyInfo :: Word8, min_keycode_KeyInfo :: KeyCode, max_keycode_KeyInfo :: KeyCode, num_keys_KeyInfo :: Word16} deriving (Show, Typeable, Eq, Ord) instance Serialize KeyInfo where serialize x = do serialize (toValue (class_id_KeyInfo x) :: Word8) serialize (len_KeyInfo x) serialize (min_keycode_KeyInfo x) serialize (max_keycode_KeyInfo x) serialize (num_keys_KeyInfo x) putSkip 2 size x = size (undefined :: Word8) + size (len_KeyInfo x) + size (min_keycode_KeyInfo x) + size (max_keycode_KeyInfo x) + size (num_keys_KeyInfo x) + 2 instance Deserialize KeyInfo where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) len <- deserialize min_keycode <- deserialize max_keycode <- deserialize num_keys <- deserialize skip 2 return (MkKeyInfo class_id len min_keycode max_keycode num_keys) data ButtonInfo = MkButtonInfo{class_id_ButtonInfo :: InputClass, len_ButtonInfo :: Word8, num_buttons_ButtonInfo :: Word16} deriving (Show, Typeable, Eq, Ord) instance Serialize ButtonInfo where serialize x = do serialize (toValue (class_id_ButtonInfo x) :: Word8) serialize (len_ButtonInfo x) serialize (num_buttons_ButtonInfo x) size x = size (undefined :: Word8) + size (len_ButtonInfo x) + size (num_buttons_ButtonInfo x) instance Deserialize ButtonInfo where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) len <- deserialize num_buttons <- deserialize return (MkButtonInfo class_id len num_buttons) data AxisInfo = MkAxisInfo{resolution_AxisInfo :: Word32, minimum_AxisInfo :: Int32, maximum_AxisInfo :: Int32} deriving (Show, Typeable, Eq, Ord) instance Serialize AxisInfo where serialize x = do serialize (resolution_AxisInfo x) serialize (minimum_AxisInfo x) serialize (maximum_AxisInfo x) size x = size (resolution_AxisInfo x) + size (minimum_AxisInfo x) + size (maximum_AxisInfo x) instance Deserialize AxisInfo where deserialize = do resolution <- deserialize minimum <- deserialize maximum <- deserialize return (MkAxisInfo resolution minimum maximum) data ValuatorInfo = MkValuatorInfo{class_id_ValuatorInfo :: InputClass, len_ValuatorInfo :: Word8, axes_len_ValuatorInfo :: Word8, mode_ValuatorInfo :: ValuatorMode, motion_size_ValuatorInfo :: Word32, axes_ValuatorInfo :: [AxisInfo]} deriving (Show, Typeable, Eq, Ord) instance Serialize ValuatorInfo where serialize x = do serialize (toValue (class_id_ValuatorInfo x) :: Word8) serialize (len_ValuatorInfo x) serialize (axes_len_ValuatorInfo x) serialize (toValue (mode_ValuatorInfo x) :: Word8) serialize (motion_size_ValuatorInfo x) serializeList (axes_ValuatorInfo x) size x = size (undefined :: Word8) + size (len_ValuatorInfo x) + size (axes_len_ValuatorInfo x) + size (undefined :: Word8) + size (motion_size_ValuatorInfo x) + sum (map size (axes_ValuatorInfo x)) instance Deserialize ValuatorInfo where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) len <- deserialize axes_len <- deserialize mode <- liftM fromValue (deserialize :: Get Word8) motion_size <- deserialize axes <- deserializeList (fromIntegral axes_len) return (MkValuatorInfo class_id len axes_len mode motion_size axes) data InputClassInfo = MkInputClassInfo{class_id_InputClassInfo :: InputClass, event_type_base_InputClassInfo :: Word8} deriving (Show, Typeable, Eq, Ord) instance Serialize InputClassInfo where serialize x = do serialize (toValue (class_id_InputClassInfo x) :: Word8) serialize (event_type_base_InputClassInfo x) size x = size (undefined :: Word8) + size (event_type_base_InputClassInfo x) instance Deserialize InputClassInfo where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) event_type_base <- deserialize return (MkInputClassInfo class_id event_type_base) data OpenDevice = MkOpenDevice{device_id_OpenDevice :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest OpenDevice where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 3 let size__ = 4 + size (device_id_OpenDevice x) + 3 serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_OpenDevice x) putSkip 3 putSkip (requiredPadding size__) data OpenDeviceReply = MkOpenDeviceReply{num_classes_OpenDeviceReply :: Word8, class_info_OpenDeviceReply :: [InputClassInfo]} deriving (Show, Typeable, Eq, Ord) instance Deserialize OpenDeviceReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize num_classes <- deserialize skip 23 class_info <- deserializeList (fromIntegral num_classes) let _ = isCard32 length return (MkOpenDeviceReply num_classes class_info) data CloseDevice = MkCloseDevice{device_id_CloseDevice :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest CloseDevice where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 4 let size__ = 4 + size (device_id_CloseDevice x) + 3 serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_CloseDevice x) putSkip 3 putSkip (requiredPadding size__) data SetDeviceMode = MkSetDeviceMode{device_id_SetDeviceMode :: Word8, mode_SetDeviceMode :: ValuatorMode} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest SetDeviceMode where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 5 let size__ = 4 + size (device_id_SetDeviceMode x) + size (undefined :: Word8) + 2 serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_SetDeviceMode x) serialize (toValue (mode_SetDeviceMode x) :: Word8) putSkip 2 putSkip (requiredPadding size__) data SetDeviceModeReply = MkSetDeviceModeReply{status_SetDeviceModeReply :: Word8} deriving (Show, Typeable, Eq, Ord) instance Deserialize SetDeviceModeReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize status <- deserialize skip 23 let _ = isCard32 length return (MkSetDeviceModeReply status) data SelectExtensionEvent = MkSelectExtensionEvent{window_SelectExtensionEvent :: WINDOW, num_classes_SelectExtensionEvent :: Word16, classes_SelectExtensionEvent :: [EventClass]} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest SelectExtensionEvent where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 6 let size__ = 4 + size (window_SelectExtensionEvent x) + size (num_classes_SelectExtensionEvent x) + 2 + sum (map size (classes_SelectExtensionEvent x)) serialize (convertBytesToRequestSize size__ :: Int16) serialize (window_SelectExtensionEvent x) serialize (num_classes_SelectExtensionEvent x) putSkip 2 serializeList (classes_SelectExtensionEvent x) putSkip (requiredPadding size__) data GetSelectedExtensionEvents = MkGetSelectedExtensionEvents{window_GetSelectedExtensionEvents :: WINDOW} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GetSelectedExtensionEvents where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 7 let size__ = 4 + size (window_GetSelectedExtensionEvents x) serialize (convertBytesToRequestSize size__ :: Int16) serialize (window_GetSelectedExtensionEvents x) putSkip (requiredPadding size__) data GetSelectedExtensionEventsReply = MkGetSelectedExtensionEventsReply{num_this_classes_GetSelectedExtensionEventsReply :: Word16, num_all_classes_GetSelectedExtensionEventsReply :: Word16, this_classes_GetSelectedExtensionEventsReply :: [EventClass], all_classes_GetSelectedExtensionEventsReply :: [EventClass]} deriving (Show, Typeable, Eq, Ord) instance Deserialize GetSelectedExtensionEventsReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize num_this_classes <- deserialize num_all_classes <- deserialize skip 20 this_classes <- deserializeList (fromIntegral num_this_classes) all_classes <- deserializeList (fromIntegral num_all_classes) let _ = isCard32 length return (MkGetSelectedExtensionEventsReply num_this_classes num_all_classes this_classes all_classes) data ChangeDeviceDontPropagateList = MkChangeDeviceDontPropagateList{window_ChangeDeviceDontPropagateList :: WINDOW, num_classes_ChangeDeviceDontPropagateList :: Word16, mode_ChangeDeviceDontPropagateList :: PropagateMode, classes_ChangeDeviceDontPropagateList :: [EventClass]} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest ChangeDeviceDontPropagateList where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 8 let size__ = 4 + size (window_ChangeDeviceDontPropagateList x) + size (num_classes_ChangeDeviceDontPropagateList x) + size (undefined :: Word8) + 1 + sum (map size (classes_ChangeDeviceDontPropagateList x)) serialize (convertBytesToRequestSize size__ :: Int16) serialize (window_ChangeDeviceDontPropagateList x) serialize (num_classes_ChangeDeviceDontPropagateList x) serialize (toValue (mode_ChangeDeviceDontPropagateList x) :: Word8) putSkip 1 serializeList (classes_ChangeDeviceDontPropagateList x) putSkip (requiredPadding size__) data GetDeviceDontPropagateList = MkGetDeviceDontPropagateList{window_GetDeviceDontPropagateList :: WINDOW} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GetDeviceDontPropagateList where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 9 let size__ = 4 + size (window_GetDeviceDontPropagateList x) serialize (convertBytesToRequestSize size__ :: Int16) serialize (window_GetDeviceDontPropagateList x) putSkip (requiredPadding size__) data GetDeviceDontPropagateListReply = MkGetDeviceDontPropagateListReply{num_classes_GetDeviceDontPropagateListReply :: Word16, classes_GetDeviceDontPropagateListReply :: [EventClass]} deriving (Show, Typeable, Eq, Ord) instance Deserialize GetDeviceDontPropagateListReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize num_classes <- deserialize skip 22 classes <- deserializeList (fromIntegral num_classes) let _ = isCard32 length return (MkGetDeviceDontPropagateListReply num_classes classes) data GetDeviceMotionEvents = MkGetDeviceMotionEvents{start_GetDeviceMotionEvents :: TIMESTAMP, stop_GetDeviceMotionEvents :: TIMESTAMP, device_id_GetDeviceMotionEvents :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GetDeviceMotionEvents where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 10 let size__ = 4 + size (start_GetDeviceMotionEvents x) + size (stop_GetDeviceMotionEvents x) + size (device_id_GetDeviceMotionEvents x) serialize (convertBytesToRequestSize size__ :: Int16) serialize (start_GetDeviceMotionEvents x) serialize (stop_GetDeviceMotionEvents x) serialize (device_id_GetDeviceMotionEvents x) putSkip (requiredPadding size__) data GetDeviceMotionEventsReply = MkGetDeviceMotionEventsReply{num_coords_GetDeviceMotionEventsReply :: Word32, num_axes_GetDeviceMotionEventsReply :: Word8, device_mode_GetDeviceMotionEventsReply :: ValuatorMode} deriving (Show, Typeable, Eq, Ord) instance Deserialize GetDeviceMotionEventsReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize num_coords <- deserialize num_axes <- deserialize device_mode <- liftM fromValue (deserialize :: Get Word8) skip 18 let _ = isCard32 length return (MkGetDeviceMotionEventsReply num_coords num_axes device_mode) data DeviceTimeCoord = MkDeviceTimeCoord{time_DeviceTimeCoord :: TIMESTAMP} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceTimeCoord where serialize x = do serialize (time_DeviceTimeCoord x) size x = size (time_DeviceTimeCoord x) instance Deserialize DeviceTimeCoord where deserialize = do time <- deserialize return (MkDeviceTimeCoord time) data ChangeKeyboardDevice = MkChangeKeyboardDevice{device_id_ChangeKeyboardDevice :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest ChangeKeyboardDevice where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 11 let size__ = 4 + size (device_id_ChangeKeyboardDevice x) + 3 serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_ChangeKeyboardDevice x) putSkip 3 putSkip (requiredPadding size__) data ChangeKeyboardDeviceReply = MkChangeKeyboardDeviceReply{status_ChangeKeyboardDeviceReply :: Word8} deriving (Show, Typeable, Eq, Ord) instance Deserialize ChangeKeyboardDeviceReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize status <- deserialize skip 23 let _ = isCard32 length return (MkChangeKeyboardDeviceReply status) data ChangePointerDevice = MkChangePointerDevice{x_axis_ChangePointerDevice :: Word8, y_axis_ChangePointerDevice :: Word8, device_id_ChangePointerDevice :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest ChangePointerDevice where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 12 let size__ = 4 + size (x_axis_ChangePointerDevice x) + size (y_axis_ChangePointerDevice x) + size (device_id_ChangePointerDevice x) + 1 serialize (convertBytesToRequestSize size__ :: Int16) serialize (x_axis_ChangePointerDevice x) serialize (y_axis_ChangePointerDevice x) serialize (device_id_ChangePointerDevice x) putSkip 1 putSkip (requiredPadding size__) data ChangePointerDeviceReply = MkChangePointerDeviceReply{status_ChangePointerDeviceReply :: Word8} deriving (Show, Typeable, Eq, Ord) instance Deserialize ChangePointerDeviceReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize status <- deserialize skip 23 let _ = isCard32 length return (MkChangePointerDeviceReply status) data GrabDevice = MkGrabDevice{grab_window_GrabDevice :: WINDOW, time_GrabDevice :: TIMESTAMP, num_classes_GrabDevice :: Word16, this_device_mode_GrabDevice :: GrabMode, other_device_mode_GrabDevice :: GrabMode, owner_events_GrabDevice :: Bool, device_id_GrabDevice :: Word8, classes_GrabDevice :: [EventClass]} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GrabDevice where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 13 let size__ = 4 + size (grab_window_GrabDevice x) + size (time_GrabDevice x) + size (num_classes_GrabDevice x) + size (undefined :: Word8) + size (undefined :: Word8) + size (owner_events_GrabDevice x) + size (device_id_GrabDevice x) + 2 + sum (map size (classes_GrabDevice x)) serialize (convertBytesToRequestSize size__ :: Int16) serialize (grab_window_GrabDevice x) serialize (time_GrabDevice x) serialize (num_classes_GrabDevice x) serialize (toValue (this_device_mode_GrabDevice x) :: Word8) serialize (toValue (other_device_mode_GrabDevice x) :: Word8) serialize (owner_events_GrabDevice x) serialize (device_id_GrabDevice x) putSkip 2 serializeList (classes_GrabDevice x) putSkip (requiredPadding size__) data GrabDeviceReply = MkGrabDeviceReply{status_GrabDeviceReply :: GrabStatus} deriving (Show, Typeable, Eq, Ord) instance Deserialize GrabDeviceReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize status <- liftM fromValue (deserialize :: Get Word8) skip 23 let _ = isCard32 length return (MkGrabDeviceReply status) data UngrabDevice = MkUngrabDevice{time_UngrabDevice :: TIMESTAMP, device_id_UngrabDevice :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest UngrabDevice where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 14 let size__ = 4 + size (time_UngrabDevice x) + size (device_id_UngrabDevice x) serialize (convertBytesToRequestSize size__ :: Int16) serialize (time_UngrabDevice x) serialize (device_id_UngrabDevice x) putSkip (requiredPadding size__) data GrabDeviceKey = MkGrabDeviceKey{grab_window_GrabDeviceKey :: WINDOW, num_classes_GrabDeviceKey :: Word16, modifiers_GrabDeviceKey :: [ModMask], modifier_device_GrabDeviceKey :: Word8, grabbed_device_GrabDeviceKey :: Word8, key_GrabDeviceKey :: Word8, this_device_mode_GrabDeviceKey :: GrabMode, other_device_mode_GrabDeviceKey :: GrabMode, owner_events_GrabDeviceKey :: Bool, classes_GrabDeviceKey :: [EventClass]} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GrabDeviceKey where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 15 let size__ = 4 + size (grab_window_GrabDeviceKey x) + size (num_classes_GrabDeviceKey x) + size (undefined :: Word16) + size (modifier_device_GrabDeviceKey x) + size (grabbed_device_GrabDeviceKey x) + size (key_GrabDeviceKey x) + size (undefined :: Word8) + size (undefined :: Word8) + size (owner_events_GrabDeviceKey x) + 2 + sum (map size (classes_GrabDeviceKey x)) serialize (convertBytesToRequestSize size__ :: Int16) serialize (grab_window_GrabDeviceKey x) serialize (num_classes_GrabDeviceKey x) serialize (toMask (modifiers_GrabDeviceKey x) :: Word16) serialize (modifier_device_GrabDeviceKey x) serialize (grabbed_device_GrabDeviceKey x) serialize (key_GrabDeviceKey x) serialize (toValue (this_device_mode_GrabDeviceKey x) :: Word8) serialize (toValue (other_device_mode_GrabDeviceKey x) :: Word8) serialize (owner_events_GrabDeviceKey x) putSkip 2 serializeList (classes_GrabDeviceKey x) putSkip (requiredPadding size__) data UngrabDeviceKey = MkUngrabDeviceKey{grabWindow_UngrabDeviceKey :: WINDOW, modifiers_UngrabDeviceKey :: [ModMask], modifier_device_UngrabDeviceKey :: Word8, key_UngrabDeviceKey :: Word8, grabbed_device_UngrabDeviceKey :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest UngrabDeviceKey where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 16 let size__ = 4 + size (grabWindow_UngrabDeviceKey x) + size (undefined :: Word16) + size (modifier_device_UngrabDeviceKey x) + size (key_UngrabDeviceKey x) + size (grabbed_device_UngrabDeviceKey x) serialize (convertBytesToRequestSize size__ :: Int16) serialize (grabWindow_UngrabDeviceKey x) serialize (toMask (modifiers_UngrabDeviceKey x) :: Word16) serialize (modifier_device_UngrabDeviceKey x) serialize (key_UngrabDeviceKey x) serialize (grabbed_device_UngrabDeviceKey x) putSkip (requiredPadding size__) data GrabDeviceButton = MkGrabDeviceButton{grab_window_GrabDeviceButton :: WINDOW, grabbed_device_GrabDeviceButton :: Word8, modifier_device_GrabDeviceButton :: Word8, num_classes_GrabDeviceButton :: Word16, modifiers_GrabDeviceButton :: [ModMask], this_device_mode_GrabDeviceButton :: GrabMode, other_device_mode_GrabDeviceButton :: GrabMode, button_GrabDeviceButton :: Word8, owner_events_GrabDeviceButton :: Word8, classes_GrabDeviceButton :: [EventClass]} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GrabDeviceButton where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 17 let size__ = 4 + size (grab_window_GrabDeviceButton x) + size (grabbed_device_GrabDeviceButton x) + size (modifier_device_GrabDeviceButton x) + size (num_classes_GrabDeviceButton x) + size (undefined :: Word16) + size (undefined :: Word8) + size (undefined :: Word8) + size (button_GrabDeviceButton x) + size (owner_events_GrabDeviceButton x) + 2 + sum (map size (classes_GrabDeviceButton x)) serialize (convertBytesToRequestSize size__ :: Int16) serialize (grab_window_GrabDeviceButton x) serialize (grabbed_device_GrabDeviceButton x) serialize (modifier_device_GrabDeviceButton x) serialize (num_classes_GrabDeviceButton x) serialize (toMask (modifiers_GrabDeviceButton x) :: Word16) serialize (toValue (this_device_mode_GrabDeviceButton x) :: Word8) serialize (toValue (other_device_mode_GrabDeviceButton x) :: Word8) serialize (button_GrabDeviceButton x) serialize (owner_events_GrabDeviceButton x) putSkip 2 serializeList (classes_GrabDeviceButton x) putSkip (requiredPadding size__) data UngrabDeviceButton = MkUngrabDeviceButton{grab_window_UngrabDeviceButton :: WINDOW, modifiers_UngrabDeviceButton :: [ModMask], modifier_device_UngrabDeviceButton :: Word8, button_UngrabDeviceButton :: Word8, grabbed_device_UngrabDeviceButton :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest UngrabDeviceButton where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 18 let size__ = 4 + size (grab_window_UngrabDeviceButton x) + size (undefined :: Word16) + size (modifier_device_UngrabDeviceButton x) + size (button_UngrabDeviceButton x) + size (grabbed_device_UngrabDeviceButton x) serialize (convertBytesToRequestSize size__ :: Int16) serialize (grab_window_UngrabDeviceButton x) serialize (toMask (modifiers_UngrabDeviceButton x) :: Word16) serialize (modifier_device_UngrabDeviceButton x) serialize (button_UngrabDeviceButton x) serialize (grabbed_device_UngrabDeviceButton x) putSkip (requiredPadding size__) data DeviceInputMode = DeviceInputModeAsyncThisDevice | DeviceInputModeSyncThisDevice | DeviceInputModeReplayThisDevice | DeviceInputModeAsyncOtherDevices | DeviceInputModeAsyncAll | DeviceInputModeSyncAll deriving (Show, Eq, Ord, Enum) instance SimpleEnum DeviceInputMode where toValue DeviceInputModeAsyncThisDevice{} = 0 toValue DeviceInputModeSyncThisDevice{} = 1 toValue DeviceInputModeReplayThisDevice{} = 2 toValue DeviceInputModeAsyncOtherDevices{} = 3 toValue DeviceInputModeAsyncAll{} = 4 toValue DeviceInputModeSyncAll{} = 5 fromValue 0 = DeviceInputModeAsyncThisDevice fromValue 1 = DeviceInputModeSyncThisDevice fromValue 2 = DeviceInputModeReplayThisDevice fromValue 3 = DeviceInputModeAsyncOtherDevices fromValue 4 = DeviceInputModeAsyncAll fromValue 5 = DeviceInputModeSyncAll data AllowDeviceEvents = MkAllowDeviceEvents{time_AllowDeviceEvents :: TIMESTAMP, mode_AllowDeviceEvents :: DeviceInputMode, device_id_AllowDeviceEvents :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest AllowDeviceEvents where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 19 let size__ = 4 + size (time_AllowDeviceEvents x) + size (undefined :: Word8) + size (device_id_AllowDeviceEvents x) serialize (convertBytesToRequestSize size__ :: Int16) serialize (time_AllowDeviceEvents x) serialize (toValue (mode_AllowDeviceEvents x) :: Word8) serialize (device_id_AllowDeviceEvents x) putSkip (requiredPadding size__) data GetDeviceFocus = MkGetDeviceFocus{device_id_GetDeviceFocus :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GetDeviceFocus where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 20 let size__ = 4 + size (device_id_GetDeviceFocus x) + 3 serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_GetDeviceFocus x) putSkip 3 putSkip (requiredPadding size__) data GetDeviceFocusReply = MkGetDeviceFocusReply{focus_GetDeviceFocusReply :: WINDOW, time_GetDeviceFocusReply :: TIMESTAMP, revert_to_GetDeviceFocusReply :: InputFocus} deriving (Show, Typeable, Eq, Ord) instance Deserialize GetDeviceFocusReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize focus <- deserialize time <- deserialize revert_to <- liftM fromValue (deserialize :: Get Word8) skip 15 let _ = isCard32 length return (MkGetDeviceFocusReply focus time revert_to) data SetDeviceFocus = MkSetDeviceFocus{focus_SetDeviceFocus :: WINDOW, time_SetDeviceFocus :: TIMESTAMP, revert_to_SetDeviceFocus :: InputFocus, device_id_SetDeviceFocus :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest SetDeviceFocus where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 21 let size__ = 4 + size (focus_SetDeviceFocus x) + size (time_SetDeviceFocus x) + size (undefined :: Word8) + size (device_id_SetDeviceFocus x) serialize (convertBytesToRequestSize size__ :: Int16) serialize (focus_SetDeviceFocus x) serialize (time_SetDeviceFocus x) serialize (toValue (revert_to_SetDeviceFocus x) :: Word8) serialize (device_id_SetDeviceFocus x) putSkip (requiredPadding size__) data GetFeedbackControl = MkGetFeedbackControl{device_id_GetFeedbackControl :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GetFeedbackControl where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 22 let size__ = 4 + size (device_id_GetFeedbackControl x) + 3 serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_GetFeedbackControl x) putSkip 3 putSkip (requiredPadding size__) data GetFeedbackControlReply = MkGetFeedbackControlReply{num_feedback_GetFeedbackControlReply :: Word16} deriving (Show, Typeable, Eq, Ord) instance Deserialize GetFeedbackControlReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize num_feedback <- deserialize skip 22 let _ = isCard32 length return (MkGetFeedbackControlReply num_feedback) data FeedbackClass = FeedbackClassKeyboard | FeedbackClassPointer | FeedbackClassString | FeedbackClassInteger | FeedbackClassLed | FeedbackClassBell deriving (Show, Eq, Ord, Enum) instance SimpleEnum FeedbackClass where toValue FeedbackClassKeyboard{} = 0 toValue FeedbackClassPointer{} = 1 toValue FeedbackClassString{} = 2 toValue FeedbackClassInteger{} = 3 toValue FeedbackClassLed{} = 4 toValue FeedbackClassBell{} = 5 fromValue 0 = FeedbackClassKeyboard fromValue 1 = FeedbackClassPointer fromValue 2 = FeedbackClassString fromValue 3 = FeedbackClassInteger fromValue 4 = FeedbackClassLed fromValue 5 = FeedbackClassBell data FeedbackState = MkFeedbackState{class_id_FeedbackState :: FeedbackClass, id_FeedbackState :: Word8, len_FeedbackState :: Word16} deriving (Show, Typeable, Eq, Ord) instance Serialize FeedbackState where serialize x = do serialize (toValue (class_id_FeedbackState x) :: Word8) serialize (id_FeedbackState x) serialize (len_FeedbackState x) size x = size (undefined :: Word8) + size (id_FeedbackState x) + size (len_FeedbackState x) instance Deserialize FeedbackState where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize return (MkFeedbackState class_id id len) data KbdFeedbackState = MkKbdFeedbackState{class_id_KbdFeedbackState :: FeedbackClass, id_KbdFeedbackState :: Word8, len_KbdFeedbackState :: Word16, pitch_KbdFeedbackState :: Word16, duration_KbdFeedbackState :: Word16, led_mask_KbdFeedbackState :: Word32, led_values_KbdFeedbackState :: Word32, global_auto_repeat_KbdFeedbackState :: Bool, click_KbdFeedbackState :: Word8, percent_KbdFeedbackState :: Word8, auto_repeats_KbdFeedbackState :: [Word8]} deriving (Show, Typeable, Eq, Ord) instance Serialize KbdFeedbackState where serialize x = do serialize (toValue (class_id_KbdFeedbackState x) :: Word8) serialize (id_KbdFeedbackState x) serialize (len_KbdFeedbackState x) serialize (pitch_KbdFeedbackState x) serialize (duration_KbdFeedbackState x) serialize (led_mask_KbdFeedbackState x) serialize (led_values_KbdFeedbackState x) serialize (global_auto_repeat_KbdFeedbackState x) serialize (click_KbdFeedbackState x) serialize (percent_KbdFeedbackState x) putSkip 1 serializeList (auto_repeats_KbdFeedbackState x) size x = size (undefined :: Word8) + size (id_KbdFeedbackState x) + size (len_KbdFeedbackState x) + size (pitch_KbdFeedbackState x) + size (duration_KbdFeedbackState x) + size (led_mask_KbdFeedbackState x) + size (led_values_KbdFeedbackState x) + size (global_auto_repeat_KbdFeedbackState x) + size (click_KbdFeedbackState x) + size (percent_KbdFeedbackState x) + 1 + sum (map size (auto_repeats_KbdFeedbackState x)) instance Deserialize KbdFeedbackState where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize pitch <- deserialize duration <- deserialize led_mask <- deserialize led_values <- deserialize global_auto_repeat <- deserialize click <- deserialize percent <- deserialize skip 1 auto_repeats <- deserializeList (fromIntegral 32) return (MkKbdFeedbackState class_id id len pitch duration led_mask led_values global_auto_repeat click percent auto_repeats) data PtrFeedbackState = MkPtrFeedbackState{class_id_PtrFeedbackState :: FeedbackClass, id_PtrFeedbackState :: Word8, len_PtrFeedbackState :: Word16, accel_num_PtrFeedbackState :: Word16, accel_denom_PtrFeedbackState :: Word16, threshold_PtrFeedbackState :: Word16} deriving (Show, Typeable, Eq, Ord) instance Serialize PtrFeedbackState where serialize x = do serialize (toValue (class_id_PtrFeedbackState x) :: Word8) serialize (id_PtrFeedbackState x) serialize (len_PtrFeedbackState x) putSkip 2 serialize (accel_num_PtrFeedbackState x) serialize (accel_denom_PtrFeedbackState x) serialize (threshold_PtrFeedbackState x) size x = size (undefined :: Word8) + size (id_PtrFeedbackState x) + size (len_PtrFeedbackState x) + 2 + size (accel_num_PtrFeedbackState x) + size (accel_denom_PtrFeedbackState x) + size (threshold_PtrFeedbackState x) instance Deserialize PtrFeedbackState where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize skip 2 accel_num <- deserialize accel_denom <- deserialize threshold <- deserialize return (MkPtrFeedbackState class_id id len accel_num accel_denom threshold) data IntegerFeedbackState = MkIntegerFeedbackState{class_id_IntegerFeedbackState :: FeedbackClass, id_IntegerFeedbackState :: Word8, len_IntegerFeedbackState :: Word16, resolution_IntegerFeedbackState :: Word32, min_value_IntegerFeedbackState :: Int32, max_value_IntegerFeedbackState :: Int32} deriving (Show, Typeable, Eq, Ord) instance Serialize IntegerFeedbackState where serialize x = do serialize (toValue (class_id_IntegerFeedbackState x) :: Word8) serialize (id_IntegerFeedbackState x) serialize (len_IntegerFeedbackState x) serialize (resolution_IntegerFeedbackState x) serialize (min_value_IntegerFeedbackState x) serialize (max_value_IntegerFeedbackState x) size x = size (undefined :: Word8) + size (id_IntegerFeedbackState x) + size (len_IntegerFeedbackState x) + size (resolution_IntegerFeedbackState x) + size (min_value_IntegerFeedbackState x) + size (max_value_IntegerFeedbackState x) instance Deserialize IntegerFeedbackState where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize resolution <- deserialize min_value <- deserialize max_value <- deserialize return (MkIntegerFeedbackState class_id id len resolution min_value max_value) data StringFeedbackState = MkStringFeedbackState{class_id_StringFeedbackState :: FeedbackClass, id_StringFeedbackState :: Word8, len_StringFeedbackState :: Word16, max_symbols_StringFeedbackState :: Word16, num_keysyms_StringFeedbackState :: Word16, keysyms_StringFeedbackState :: [KEYSYM]} deriving (Show, Typeable, Eq, Ord) instance Serialize StringFeedbackState where serialize x = do serialize (toValue (class_id_StringFeedbackState x) :: Word8) serialize (id_StringFeedbackState x) serialize (len_StringFeedbackState x) serialize (max_symbols_StringFeedbackState x) serialize (num_keysyms_StringFeedbackState x) serializeList (keysyms_StringFeedbackState x) size x = size (undefined :: Word8) + size (id_StringFeedbackState x) + size (len_StringFeedbackState x) + size (max_symbols_StringFeedbackState x) + size (num_keysyms_StringFeedbackState x) + sum (map size (keysyms_StringFeedbackState x)) instance Deserialize StringFeedbackState where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize max_symbols <- deserialize num_keysyms <- deserialize keysyms <- deserializeList (fromIntegral num_keysyms) return (MkStringFeedbackState class_id id len max_symbols num_keysyms keysyms) data BellFeedbackState = MkBellFeedbackState{class_id_BellFeedbackState :: FeedbackClass, id_BellFeedbackState :: Word8, len_BellFeedbackState :: Word16, percent_BellFeedbackState :: Word8, pitch_BellFeedbackState :: Word16, duration_BellFeedbackState :: Word16} deriving (Show, Typeable, Eq, Ord) instance Serialize BellFeedbackState where serialize x = do serialize (toValue (class_id_BellFeedbackState x) :: Word8) serialize (id_BellFeedbackState x) serialize (len_BellFeedbackState x) serialize (percent_BellFeedbackState x) putSkip 3 serialize (pitch_BellFeedbackState x) serialize (duration_BellFeedbackState x) size x = size (undefined :: Word8) + size (id_BellFeedbackState x) + size (len_BellFeedbackState x) + size (percent_BellFeedbackState x) + 3 + size (pitch_BellFeedbackState x) + size (duration_BellFeedbackState x) instance Deserialize BellFeedbackState where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize percent <- deserialize skip 3 pitch <- deserialize duration <- deserialize return (MkBellFeedbackState class_id id len percent pitch duration) data LedFeedbackState = MkLedFeedbackState{class_id_LedFeedbackState :: FeedbackClass, id_LedFeedbackState :: Word8, len_LedFeedbackState :: Word16, led_mask_LedFeedbackState :: Word32, led_values_LedFeedbackState :: Word32} deriving (Show, Typeable, Eq, Ord) instance Serialize LedFeedbackState where serialize x = do serialize (toValue (class_id_LedFeedbackState x) :: Word8) serialize (id_LedFeedbackState x) serialize (len_LedFeedbackState x) serialize (led_mask_LedFeedbackState x) serialize (led_values_LedFeedbackState x) size x = size (undefined :: Word8) + size (id_LedFeedbackState x) + size (len_LedFeedbackState x) + size (led_mask_LedFeedbackState x) + size (led_values_LedFeedbackState x) instance Deserialize LedFeedbackState where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize led_mask <- deserialize led_values <- deserialize return (MkLedFeedbackState class_id id len led_mask led_values) data FeedbackCtl = MkFeedbackCtl{class_id_FeedbackCtl :: FeedbackClass, id_FeedbackCtl :: Word8, len_FeedbackCtl :: Word16} deriving (Show, Typeable, Eq, Ord) instance Serialize FeedbackCtl where serialize x = do serialize (toValue (class_id_FeedbackCtl x) :: Word8) serialize (id_FeedbackCtl x) serialize (len_FeedbackCtl x) size x = size (undefined :: Word8) + size (id_FeedbackCtl x) + size (len_FeedbackCtl x) instance Deserialize FeedbackCtl where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize return (MkFeedbackCtl class_id id len) data KbdFeedbackCtl = MkKbdFeedbackCtl{class_id_KbdFeedbackCtl :: FeedbackClass, id_KbdFeedbackCtl :: Word8, len_KbdFeedbackCtl :: Word16, key_KbdFeedbackCtl :: KeyCode, auto_repeat_mode_KbdFeedbackCtl :: Word8, key_click_percent_KbdFeedbackCtl :: Int8, bell_percent_KbdFeedbackCtl :: Int8, bell_pitch_KbdFeedbackCtl :: Int16, bell_duration_KbdFeedbackCtl :: Int16, led_mask_KbdFeedbackCtl :: Word32, led_values_KbdFeedbackCtl :: Word32} deriving (Show, Typeable, Eq, Ord) instance Serialize KbdFeedbackCtl where serialize x = do serialize (toValue (class_id_KbdFeedbackCtl x) :: Word8) serialize (id_KbdFeedbackCtl x) serialize (len_KbdFeedbackCtl x) serialize (key_KbdFeedbackCtl x) serialize (auto_repeat_mode_KbdFeedbackCtl x) serialize (key_click_percent_KbdFeedbackCtl x) serialize (bell_percent_KbdFeedbackCtl x) serialize (bell_pitch_KbdFeedbackCtl x) serialize (bell_duration_KbdFeedbackCtl x) serialize (led_mask_KbdFeedbackCtl x) serialize (led_values_KbdFeedbackCtl x) size x = size (undefined :: Word8) + size (id_KbdFeedbackCtl x) + size (len_KbdFeedbackCtl x) + size (key_KbdFeedbackCtl x) + size (auto_repeat_mode_KbdFeedbackCtl x) + size (key_click_percent_KbdFeedbackCtl x) + size (bell_percent_KbdFeedbackCtl x) + size (bell_pitch_KbdFeedbackCtl x) + size (bell_duration_KbdFeedbackCtl x) + size (led_mask_KbdFeedbackCtl x) + size (led_values_KbdFeedbackCtl x) instance Deserialize KbdFeedbackCtl where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize key <- deserialize auto_repeat_mode <- deserialize key_click_percent <- deserialize bell_percent <- deserialize bell_pitch <- deserialize bell_duration <- deserialize led_mask <- deserialize led_values <- deserialize return (MkKbdFeedbackCtl class_id id len key auto_repeat_mode key_click_percent bell_percent bell_pitch bell_duration led_mask led_values) data PtrFeedbackCtl = MkPtrFeedbackCtl{class_id_PtrFeedbackCtl :: FeedbackClass, id_PtrFeedbackCtl :: Word8, len_PtrFeedbackCtl :: Word16, num_PtrFeedbackCtl :: Int16, denom_PtrFeedbackCtl :: Int16, threshold_PtrFeedbackCtl :: Int16} deriving (Show, Typeable, Eq, Ord) instance Serialize PtrFeedbackCtl where serialize x = do serialize (toValue (class_id_PtrFeedbackCtl x) :: Word8) serialize (id_PtrFeedbackCtl x) serialize (len_PtrFeedbackCtl x) putSkip 2 serialize (num_PtrFeedbackCtl x) serialize (denom_PtrFeedbackCtl x) serialize (threshold_PtrFeedbackCtl x) size x = size (undefined :: Word8) + size (id_PtrFeedbackCtl x) + size (len_PtrFeedbackCtl x) + 2 + size (num_PtrFeedbackCtl x) + size (denom_PtrFeedbackCtl x) + size (threshold_PtrFeedbackCtl x) instance Deserialize PtrFeedbackCtl where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize skip 2 num <- deserialize denom <- deserialize threshold <- deserialize return (MkPtrFeedbackCtl class_id id len num denom threshold) data IntegerFeedbackCtl = MkIntegerFeedbackCtl{class_id_IntegerFeedbackCtl :: FeedbackClass, id_IntegerFeedbackCtl :: Word8, len_IntegerFeedbackCtl :: Word16, int_to_display_IntegerFeedbackCtl :: Int32} deriving (Show, Typeable, Eq, Ord) instance Serialize IntegerFeedbackCtl where serialize x = do serialize (toValue (class_id_IntegerFeedbackCtl x) :: Word8) serialize (id_IntegerFeedbackCtl x) serialize (len_IntegerFeedbackCtl x) serialize (int_to_display_IntegerFeedbackCtl x) size x = size (undefined :: Word8) + size (id_IntegerFeedbackCtl x) + size (len_IntegerFeedbackCtl x) + size (int_to_display_IntegerFeedbackCtl x) instance Deserialize IntegerFeedbackCtl where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize int_to_display <- deserialize return (MkIntegerFeedbackCtl class_id id len int_to_display) data StringFeedbackCtl = MkStringFeedbackCtl{class_id_StringFeedbackCtl :: FeedbackClass, id_StringFeedbackCtl :: Word8, len_StringFeedbackCtl :: Word16, num_keysyms_StringFeedbackCtl :: Word16, keysyms_StringFeedbackCtl :: [KEYSYM]} deriving (Show, Typeable, Eq, Ord) instance Serialize StringFeedbackCtl where serialize x = do serialize (toValue (class_id_StringFeedbackCtl x) :: Word8) serialize (id_StringFeedbackCtl x) serialize (len_StringFeedbackCtl x) putSkip 2 serialize (num_keysyms_StringFeedbackCtl x) serializeList (keysyms_StringFeedbackCtl x) size x = size (undefined :: Word8) + size (id_StringFeedbackCtl x) + size (len_StringFeedbackCtl x) + 2 + size (num_keysyms_StringFeedbackCtl x) + sum (map size (keysyms_StringFeedbackCtl x)) instance Deserialize StringFeedbackCtl where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize skip 2 num_keysyms <- deserialize keysyms <- deserializeList (fromIntegral num_keysyms) return (MkStringFeedbackCtl class_id id len num_keysyms keysyms) data BellFeedbackCtl = MkBellFeedbackCtl{class_id_BellFeedbackCtl :: FeedbackClass, id_BellFeedbackCtl :: Word8, len_BellFeedbackCtl :: Word16, percent_BellFeedbackCtl :: Int8, pitch_BellFeedbackCtl :: Int16, duration_BellFeedbackCtl :: Int16} deriving (Show, Typeable, Eq, Ord) instance Serialize BellFeedbackCtl where serialize x = do serialize (toValue (class_id_BellFeedbackCtl x) :: Word8) serialize (id_BellFeedbackCtl x) serialize (len_BellFeedbackCtl x) serialize (percent_BellFeedbackCtl x) putSkip 3 serialize (pitch_BellFeedbackCtl x) serialize (duration_BellFeedbackCtl x) size x = size (undefined :: Word8) + size (id_BellFeedbackCtl x) + size (len_BellFeedbackCtl x) + size (percent_BellFeedbackCtl x) + 3 + size (pitch_BellFeedbackCtl x) + size (duration_BellFeedbackCtl x) instance Deserialize BellFeedbackCtl where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize percent <- deserialize skip 3 pitch <- deserialize duration <- deserialize return (MkBellFeedbackCtl class_id id len percent pitch duration) data LedFeedbackCtl = MkLedFeedbackCtl{class_id_LedFeedbackCtl :: FeedbackClass, id_LedFeedbackCtl :: Word8, len_LedFeedbackCtl :: Word16, led_mask_LedFeedbackCtl :: Word32, led_values_LedFeedbackCtl :: Word32} deriving (Show, Typeable, Eq, Ord) instance Serialize LedFeedbackCtl where serialize x = do serialize (toValue (class_id_LedFeedbackCtl x) :: Word8) serialize (id_LedFeedbackCtl x) serialize (len_LedFeedbackCtl x) serialize (led_mask_LedFeedbackCtl x) serialize (led_values_LedFeedbackCtl x) size x = size (undefined :: Word8) + size (id_LedFeedbackCtl x) + size (len_LedFeedbackCtl x) + size (led_mask_LedFeedbackCtl x) + size (led_values_LedFeedbackCtl x) instance Deserialize LedFeedbackCtl where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) id <- deserialize len <- deserialize led_mask <- deserialize led_values <- deserialize return (MkLedFeedbackCtl class_id id len led_mask led_values) data GetDeviceKeyMapping = MkGetDeviceKeyMapping{device_id_GetDeviceKeyMapping :: Word8, first_keycode_GetDeviceKeyMapping :: KeyCode, count_GetDeviceKeyMapping :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GetDeviceKeyMapping where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 24 let size__ = 4 + size (device_id_GetDeviceKeyMapping x) + size (first_keycode_GetDeviceKeyMapping x) + size (count_GetDeviceKeyMapping x) serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_GetDeviceKeyMapping x) serialize (first_keycode_GetDeviceKeyMapping x) serialize (count_GetDeviceKeyMapping x) putSkip (requiredPadding size__) data GetDeviceKeyMappingReply = MkGetDeviceKeyMappingReply{keysyms_per_keycode_GetDeviceKeyMappingReply :: Word8, keysyms_GetDeviceKeyMappingReply :: [KEYSYM]} deriving (Show, Typeable, Eq, Ord) instance Deserialize GetDeviceKeyMappingReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize keysyms_per_keycode <- deserialize skip 23 keysyms <- deserializeList (fromIntegral length) let _ = isCard32 length return (MkGetDeviceKeyMappingReply keysyms_per_keycode keysyms) data ChangeDeviceKeyMapping = MkChangeDeviceKeyMapping{device_id_ChangeDeviceKeyMapping :: Word8, first_keycode_ChangeDeviceKeyMapping :: KeyCode, keysyms_per_keycode_ChangeDeviceKeyMapping :: Word8, keycode_count_ChangeDeviceKeyMapping :: Word8, keysyms_ChangeDeviceKeyMapping :: [KEYSYM]} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest ChangeDeviceKeyMapping where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 25 let size__ = 4 + size (device_id_ChangeDeviceKeyMapping x) + size (first_keycode_ChangeDeviceKeyMapping x) + size (keysyms_per_keycode_ChangeDeviceKeyMapping x) + size (keycode_count_ChangeDeviceKeyMapping x) + sum (map size (keysyms_ChangeDeviceKeyMapping x)) serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_ChangeDeviceKeyMapping x) serialize (first_keycode_ChangeDeviceKeyMapping x) serialize (keysyms_per_keycode_ChangeDeviceKeyMapping x) serialize (keycode_count_ChangeDeviceKeyMapping x) serializeList (keysyms_ChangeDeviceKeyMapping x) putSkip (requiredPadding size__) data GetDeviceModifierMapping = MkGetDeviceModifierMapping{device_id_GetDeviceModifierMapping :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GetDeviceModifierMapping where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 26 let size__ = 4 + size (device_id_GetDeviceModifierMapping x) + 3 serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_GetDeviceModifierMapping x) putSkip 3 putSkip (requiredPadding size__) data GetDeviceModifierMappingReply = MkGetDeviceModifierMappingReply{keycodes_per_modifier_GetDeviceModifierMappingReply :: Word8, keymaps_GetDeviceModifierMappingReply :: [Word8]} deriving (Show, Typeable, Eq, Ord) instance Deserialize GetDeviceModifierMappingReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize keycodes_per_modifier <- deserialize skip 23 keymaps <- deserializeList (fromIntegral (fromIntegral (keycodes_per_modifier * 8))) let _ = isCard32 length return (MkGetDeviceModifierMappingReply keycodes_per_modifier keymaps) data SetDeviceModifierMapping = MkSetDeviceModifierMapping{device_id_SetDeviceModifierMapping :: Word8, keycodes_per_modifier_SetDeviceModifierMapping :: Word8, keymaps_SetDeviceModifierMapping :: [Word8]} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest SetDeviceModifierMapping where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 27 let size__ = 4 + size (device_id_SetDeviceModifierMapping x) + size (keycodes_per_modifier_SetDeviceModifierMapping x) + 1 + sum (map size (keymaps_SetDeviceModifierMapping x)) serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_SetDeviceModifierMapping x) serialize (keycodes_per_modifier_SetDeviceModifierMapping x) putSkip 1 serializeList (keymaps_SetDeviceModifierMapping x) putSkip (requiredPadding size__) data SetDeviceModifierMappingReply = MkSetDeviceModifierMappingReply{status_SetDeviceModifierMappingReply :: MappingStatus} deriving (Show, Typeable, Eq, Ord) instance Deserialize SetDeviceModifierMappingReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize status <- liftM fromValue (deserialize :: Get Word8) skip 23 let _ = isCard32 length return (MkSetDeviceModifierMappingReply status) data GetDeviceButtonMapping = MkGetDeviceButtonMapping{device_id_GetDeviceButtonMapping :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GetDeviceButtonMapping where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 28 let size__ = 4 + size (device_id_GetDeviceButtonMapping x) + 3 serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_GetDeviceButtonMapping x) putSkip 3 putSkip (requiredPadding size__) data GetDeviceButtonMappingReply = MkGetDeviceButtonMappingReply{map_size_GetDeviceButtonMappingReply :: Word8, map_GetDeviceButtonMappingReply :: [Word8]} deriving (Show, Typeable, Eq, Ord) instance Deserialize GetDeviceButtonMappingReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize map_size <- deserialize skip 23 map <- deserializeList (fromIntegral map_size) let _ = isCard32 length return (MkGetDeviceButtonMappingReply map_size map) data SetDeviceButtonMapping = MkSetDeviceButtonMapping{device_id_SetDeviceButtonMapping :: Word8, map_size_SetDeviceButtonMapping :: Word8, map_SetDeviceButtonMapping :: [Word8]} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest SetDeviceButtonMapping where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 29 let size__ = 4 + size (device_id_SetDeviceButtonMapping x) + size (map_size_SetDeviceButtonMapping x) + 2 + sum (map size (map_SetDeviceButtonMapping x)) serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_SetDeviceButtonMapping x) serialize (map_size_SetDeviceButtonMapping x) putSkip 2 serializeList (map_SetDeviceButtonMapping x) putSkip (requiredPadding size__) data SetDeviceButtonMappingReply = MkSetDeviceButtonMappingReply{status_SetDeviceButtonMappingReply :: MappingStatus} deriving (Show, Typeable, Eq, Ord) instance Deserialize SetDeviceButtonMappingReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize status <- liftM fromValue (deserialize :: Get Word8) skip 23 let _ = isCard32 length return (MkSetDeviceButtonMappingReply status) data QueryDeviceState = MkQueryDeviceState{device_id_QueryDeviceState :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest QueryDeviceState where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 30 let size__ = 4 + size (device_id_QueryDeviceState x) + 3 serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_QueryDeviceState x) putSkip 3 putSkip (requiredPadding size__) data QueryDeviceStateReply = MkQueryDeviceStateReply{num_classes_QueryDeviceStateReply :: Word8} deriving (Show, Typeable, Eq, Ord) instance Deserialize QueryDeviceStateReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize num_classes <- deserialize skip 23 let _ = isCard32 length return (MkQueryDeviceStateReply num_classes) data InputState = MkInputState{class_id_InputState :: InputClass, len_InputState :: Word8, num_items_InputState :: Word8} deriving (Show, Typeable, Eq, Ord) instance Serialize InputState where serialize x = do serialize (toValue (class_id_InputState x) :: Word8) serialize (len_InputState x) serialize (num_items_InputState x) size x = size (undefined :: Word8) + size (len_InputState x) + size (num_items_InputState x) instance Deserialize InputState where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) len <- deserialize num_items <- deserialize return (MkInputState class_id len num_items) data KeyState = MkKeyState{class_id_KeyState :: InputClass, len_KeyState :: Word8, num_keys_KeyState :: Word8, keys_KeyState :: [Word8]} deriving (Show, Typeable, Eq, Ord) instance Serialize KeyState where serialize x = do serialize (toValue (class_id_KeyState x) :: Word8) serialize (len_KeyState x) serialize (num_keys_KeyState x) putSkip 1 serializeList (keys_KeyState x) size x = size (undefined :: Word8) + size (len_KeyState x) + size (num_keys_KeyState x) + 1 + sum (map size (keys_KeyState x)) instance Deserialize KeyState where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) len <- deserialize num_keys <- deserialize skip 1 keys <- deserializeList (fromIntegral 32) return (MkKeyState class_id len num_keys keys) data ButtonState = MkButtonState{class_id_ButtonState :: InputClass, len_ButtonState :: Word8, num_buttons_ButtonState :: Word8, buttons_ButtonState :: [Word8]} deriving (Show, Typeable, Eq, Ord) instance Serialize ButtonState where serialize x = do serialize (toValue (class_id_ButtonState x) :: Word8) serialize (len_ButtonState x) serialize (num_buttons_ButtonState x) putSkip 1 serializeList (buttons_ButtonState x) size x = size (undefined :: Word8) + size (len_ButtonState x) + size (num_buttons_ButtonState x) + 1 + sum (map size (buttons_ButtonState x)) instance Deserialize ButtonState where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) len <- deserialize num_buttons <- deserialize skip 1 buttons <- deserializeList (fromIntegral 32) return (MkButtonState class_id len num_buttons buttons) data ValuatorState = MkValuatorState{class_id_ValuatorState :: InputClass, len_ValuatorState :: Word8, num_valuators_ValuatorState :: Word8, mode_ValuatorState :: Word8, valuators_ValuatorState :: [Word32]} deriving (Show, Typeable, Eq, Ord) instance Serialize ValuatorState where serialize x = do serialize (toValue (class_id_ValuatorState x) :: Word8) serialize (len_ValuatorState x) serialize (num_valuators_ValuatorState x) serialize (mode_ValuatorState x) serializeList (valuators_ValuatorState x) size x = size (undefined :: Word8) + size (len_ValuatorState x) + size (num_valuators_ValuatorState x) + size (mode_ValuatorState x) + sum (map size (valuators_ValuatorState x)) instance Deserialize ValuatorState where deserialize = do class_id <- liftM fromValue (deserialize :: Get Word8) len <- deserialize num_valuators <- deserialize mode <- deserialize valuators <- deserializeList (fromIntegral num_valuators) return (MkValuatorState class_id len num_valuators mode valuators) data SendExtensionEvent = MkSendExtensionEvent{destination_SendExtensionEvent :: WINDOW, device_id_SendExtensionEvent :: Word8, propagate_SendExtensionEvent :: Bool, num_classes_SendExtensionEvent :: Word16, num_events_SendExtensionEvent :: Word8, events_SendExtensionEvent :: [CChar], classes_SendExtensionEvent :: [EventClass]} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest SendExtensionEvent where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 31 let size__ = 4 + size (destination_SendExtensionEvent x) + size (device_id_SendExtensionEvent x) + size (propagate_SendExtensionEvent x) + size (num_classes_SendExtensionEvent x) + size (num_events_SendExtensionEvent x) + 3 + sum (map size (events_SendExtensionEvent x)) + sum (map size (classes_SendExtensionEvent x)) serialize (convertBytesToRequestSize size__ :: Int16) serialize (destination_SendExtensionEvent x) serialize (device_id_SendExtensionEvent x) serialize (propagate_SendExtensionEvent x) serialize (num_classes_SendExtensionEvent x) serialize (num_events_SendExtensionEvent x) putSkip 3 serializeList (events_SendExtensionEvent x) serializeList (classes_SendExtensionEvent x) putSkip (requiredPadding size__) data DeviceBell = MkDeviceBell{device_id_DeviceBell :: Word8, feedback_id_DeviceBell :: Word8, feedback_class_DeviceBell :: Word8, percent_DeviceBell :: Int8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest DeviceBell where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 32 let size__ = 4 + size (device_id_DeviceBell x) + size (feedback_id_DeviceBell x) + size (feedback_class_DeviceBell x) + size (percent_DeviceBell x) serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_DeviceBell x) serialize (feedback_id_DeviceBell x) serialize (feedback_class_DeviceBell x) serialize (percent_DeviceBell x) putSkip (requiredPadding size__) data SetDeviceValuators = MkSetDeviceValuators{device_id_SetDeviceValuators :: Word8, first_valuator_SetDeviceValuators :: Word8, num_valuators_SetDeviceValuators :: Word8, valuators_SetDeviceValuators :: [Int32]} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest SetDeviceValuators where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 33 let size__ = 4 + size (device_id_SetDeviceValuators x) + size (first_valuator_SetDeviceValuators x) + size (num_valuators_SetDeviceValuators x) + 1 + sum (map size (valuators_SetDeviceValuators x)) serialize (convertBytesToRequestSize size__ :: Int16) serialize (device_id_SetDeviceValuators x) serialize (first_valuator_SetDeviceValuators x) serialize (num_valuators_SetDeviceValuators x) putSkip 1 serializeList (valuators_SetDeviceValuators x) putSkip (requiredPadding size__) data SetDeviceValuatorsReply = MkSetDeviceValuatorsReply{status_SetDeviceValuatorsReply :: GrabStatus} deriving (Show, Typeable, Eq, Ord) instance Deserialize SetDeviceValuatorsReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize status <- liftM fromValue (deserialize :: Get Word8) skip 23 let _ = isCard32 length return (MkSetDeviceValuatorsReply status) data GetDeviceControl = MkGetDeviceControl{control_id_GetDeviceControl :: Word16, device_id_GetDeviceControl :: Word8} deriving (Show, Typeable, Eq, Ord) instance ExtensionRequest GetDeviceControl where extensionId _ = "XInputExtension" serializeRequest x extOpCode = do putWord8 extOpCode putWord8 34 let size__ = 4 + size (control_id_GetDeviceControl x) + size (device_id_GetDeviceControl x) + 1 serialize (convertBytesToRequestSize size__ :: Int16) serialize (control_id_GetDeviceControl x) serialize (device_id_GetDeviceControl x) putSkip 1 putSkip (requiredPadding size__) data GetDeviceControlReply = MkGetDeviceControlReply{status_GetDeviceControlReply :: Word8} deriving (Show, Typeable, Eq, Ord) instance Deserialize GetDeviceControlReply where deserialize = do skip 1 skip 1 skip 2 length <- deserialize status <- deserialize skip 23 let _ = isCard32 length return (MkGetDeviceControlReply status) data DeviceState = MkDeviceState{control_id_DeviceState :: Word16, len_DeviceState :: Word16} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceState where serialize x = do serialize (control_id_DeviceState x) serialize (len_DeviceState x) size x = size (control_id_DeviceState x) + size (len_DeviceState x) instance Deserialize DeviceState where deserialize = do control_id <- deserialize len <- deserialize return (MkDeviceState control_id len) data DeviceResolutionState = MkDeviceResolutionState{control_id_DeviceResolutionState :: Word16, len_DeviceResolutionState :: Word16, num_valuators_DeviceResolutionState :: Word32, resolution_values_DeviceResolutionState :: [Word32], resolution_min_DeviceResolutionState :: [Word32], resolution_max_DeviceResolutionState :: [Word32]} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceResolutionState where serialize x = do serialize (control_id_DeviceResolutionState x) serialize (len_DeviceResolutionState x) serialize (num_valuators_DeviceResolutionState x) serializeList (resolution_values_DeviceResolutionState x) serializeList (resolution_min_DeviceResolutionState x) serializeList (resolution_max_DeviceResolutionState x) size x = size (control_id_DeviceResolutionState x) + size (len_DeviceResolutionState x) + size (num_valuators_DeviceResolutionState x) + sum (map size (resolution_values_DeviceResolutionState x)) + sum (map size (resolution_min_DeviceResolutionState x)) + sum (map size (resolution_max_DeviceResolutionState x)) instance Deserialize DeviceResolutionState where deserialize = do control_id <- deserialize len <- deserialize num_valuators <- deserialize resolution_values <- deserializeList (fromIntegral num_valuators) resolution_min <- deserializeList (fromIntegral num_valuators) resolution_max <- deserializeList (fromIntegral num_valuators) return (MkDeviceResolutionState control_id len num_valuators resolution_values resolution_min resolution_max) data DeviceAbsCalibState = MkDeviceAbsCalibState{control_id_DeviceAbsCalibState :: Word16, len_DeviceAbsCalibState :: Word16, min_x_DeviceAbsCalibState :: Int32, max_x_DeviceAbsCalibState :: Int32, min_y_DeviceAbsCalibState :: Int32, max_y_DeviceAbsCalibState :: Int32, flip_x_DeviceAbsCalibState :: Word32, flip_y_DeviceAbsCalibState :: Word32, rotation_DeviceAbsCalibState :: Word32, button_threshold_DeviceAbsCalibState :: Word32} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceAbsCalibState where serialize x = do serialize (control_id_DeviceAbsCalibState x) serialize (len_DeviceAbsCalibState x) serialize (min_x_DeviceAbsCalibState x) serialize (max_x_DeviceAbsCalibState x) serialize (min_y_DeviceAbsCalibState x) serialize (max_y_DeviceAbsCalibState x) serialize (flip_x_DeviceAbsCalibState x) serialize (flip_y_DeviceAbsCalibState x) serialize (rotation_DeviceAbsCalibState x) serialize (button_threshold_DeviceAbsCalibState x) size x = size (control_id_DeviceAbsCalibState x) + size (len_DeviceAbsCalibState x) + size (min_x_DeviceAbsCalibState x) + size (max_x_DeviceAbsCalibState x) + size (min_y_DeviceAbsCalibState x) + size (max_y_DeviceAbsCalibState x) + size (flip_x_DeviceAbsCalibState x) + size (flip_y_DeviceAbsCalibState x) + size (rotation_DeviceAbsCalibState x) + size (button_threshold_DeviceAbsCalibState x) instance Deserialize DeviceAbsCalibState where deserialize = do control_id <- deserialize len <- deserialize min_x <- deserialize max_x <- deserialize min_y <- deserialize max_y <- deserialize flip_x <- deserialize flip_y <- deserialize rotation <- deserialize button_threshold <- deserialize return (MkDeviceAbsCalibState control_id len min_x max_x min_y max_y flip_x flip_y rotation button_threshold) data DeviceAbsAreaState = MkDeviceAbsAreaState{control_id_DeviceAbsAreaState :: Word16, len_DeviceAbsAreaState :: Word16, offset_x_DeviceAbsAreaState :: Word32, offset_y_DeviceAbsAreaState :: Word32, width_DeviceAbsAreaState :: Word32, height_DeviceAbsAreaState :: Word32, screen_DeviceAbsAreaState :: Word32, following_DeviceAbsAreaState :: Word32} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceAbsAreaState where serialize x = do serialize (control_id_DeviceAbsAreaState x) serialize (len_DeviceAbsAreaState x) serialize (offset_x_DeviceAbsAreaState x) serialize (offset_y_DeviceAbsAreaState x) serialize (width_DeviceAbsAreaState x) serialize (height_DeviceAbsAreaState x) serialize (screen_DeviceAbsAreaState x) serialize (following_DeviceAbsAreaState x) size x = size (control_id_DeviceAbsAreaState x) + size (len_DeviceAbsAreaState x) + size (offset_x_DeviceAbsAreaState x) + size (offset_y_DeviceAbsAreaState x) + size (width_DeviceAbsAreaState x) + size (height_DeviceAbsAreaState x) + size (screen_DeviceAbsAreaState x) + size (following_DeviceAbsAreaState x) instance Deserialize DeviceAbsAreaState where deserialize = do control_id <- deserialize len <- deserialize offset_x <- deserialize offset_y <- deserialize width <- deserialize height <- deserialize screen <- deserialize following <- deserialize return (MkDeviceAbsAreaState control_id len offset_x offset_y width height screen following) data DeviceCoreState = MkDeviceCoreState{control_id_DeviceCoreState :: Word16, len_DeviceCoreState :: Word16, status_DeviceCoreState :: Word8, iscore_DeviceCoreState :: Word8} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceCoreState where serialize x = do serialize (control_id_DeviceCoreState x) serialize (len_DeviceCoreState x) serialize (status_DeviceCoreState x) serialize (iscore_DeviceCoreState x) putSkip 2 size x = size (control_id_DeviceCoreState x) + size (len_DeviceCoreState x) + size (status_DeviceCoreState x) + size (iscore_DeviceCoreState x) + 2 instance Deserialize DeviceCoreState where deserialize = do control_id <- deserialize len <- deserialize status <- deserialize iscore <- deserialize skip 2 return (MkDeviceCoreState control_id len status iscore) data DeviceEnableState = MkDeviceEnableState{control_id_DeviceEnableState :: Word16, len_DeviceEnableState :: Word16, enable_DeviceEnableState :: Word8} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceEnableState where serialize x = do serialize (control_id_DeviceEnableState x) serialize (len_DeviceEnableState x) serialize (enable_DeviceEnableState x) putSkip 3 size x = size (control_id_DeviceEnableState x) + size (len_DeviceEnableState x) + size (enable_DeviceEnableState x) + 3 instance Deserialize DeviceEnableState where deserialize = do control_id <- deserialize len <- deserialize enable <- deserialize skip 3 return (MkDeviceEnableState control_id len enable) data DeviceCtl = MkDeviceCtl{control_id_DeviceCtl :: Word16, len_DeviceCtl :: Word16} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceCtl where serialize x = do serialize (control_id_DeviceCtl x) serialize (len_DeviceCtl x) size x = size (control_id_DeviceCtl x) + size (len_DeviceCtl x) instance Deserialize DeviceCtl where deserialize = do control_id <- deserialize len <- deserialize return (MkDeviceCtl control_id len) data DeviceResolutionCtl = MkDeviceResolutionCtl{control_id_DeviceResolutionCtl :: Word16, len_DeviceResolutionCtl :: Word16, first_valuator_DeviceResolutionCtl :: Word8, num_valuators_DeviceResolutionCtl :: Word8, resolution_values_DeviceResolutionCtl :: [Word32]} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceResolutionCtl where serialize x = do serialize (control_id_DeviceResolutionCtl x) serialize (len_DeviceResolutionCtl x) serialize (first_valuator_DeviceResolutionCtl x) serialize (num_valuators_DeviceResolutionCtl x) serializeList (resolution_values_DeviceResolutionCtl x) size x = size (control_id_DeviceResolutionCtl x) + size (len_DeviceResolutionCtl x) + size (first_valuator_DeviceResolutionCtl x) + size (num_valuators_DeviceResolutionCtl x) + sum (map size (resolution_values_DeviceResolutionCtl x)) instance Deserialize DeviceResolutionCtl where deserialize = do control_id <- deserialize len <- deserialize first_valuator <- deserialize num_valuators <- deserialize resolution_values <- deserializeList (fromIntegral num_valuators) return (MkDeviceResolutionCtl control_id len first_valuator num_valuators resolution_values) data DeviceAbsCalibCtl = MkDeviceAbsCalibCtl{control_id_DeviceAbsCalibCtl :: Word16, len_DeviceAbsCalibCtl :: Word16, min_x_DeviceAbsCalibCtl :: Int32, max_x_DeviceAbsCalibCtl :: Int32, min_y_DeviceAbsCalibCtl :: Int32, max_y_DeviceAbsCalibCtl :: Int32, flip_x_DeviceAbsCalibCtl :: Word32, flip_y_DeviceAbsCalibCtl :: Word32, rotation_DeviceAbsCalibCtl :: Word32, button_threshold_DeviceAbsCalibCtl :: Word32} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceAbsCalibCtl where serialize x = do serialize (control_id_DeviceAbsCalibCtl x) serialize (len_DeviceAbsCalibCtl x) serialize (min_x_DeviceAbsCalibCtl x) serialize (max_x_DeviceAbsCalibCtl x) serialize (min_y_DeviceAbsCalibCtl x) serialize (max_y_DeviceAbsCalibCtl x) serialize (flip_x_DeviceAbsCalibCtl x) serialize (flip_y_DeviceAbsCalibCtl x) serialize (rotation_DeviceAbsCalibCtl x) serialize (button_threshold_DeviceAbsCalibCtl x) size x = size (control_id_DeviceAbsCalibCtl x) + size (len_DeviceAbsCalibCtl x) + size (min_x_DeviceAbsCalibCtl x) + size (max_x_DeviceAbsCalibCtl x) + size (min_y_DeviceAbsCalibCtl x) + size (max_y_DeviceAbsCalibCtl x) + size (flip_x_DeviceAbsCalibCtl x) + size (flip_y_DeviceAbsCalibCtl x) + size (rotation_DeviceAbsCalibCtl x) + size (button_threshold_DeviceAbsCalibCtl x) instance Deserialize DeviceAbsCalibCtl where deserialize = do control_id <- deserialize len <- deserialize min_x <- deserialize max_x <- deserialize min_y <- deserialize max_y <- deserialize flip_x <- deserialize flip_y <- deserialize rotation <- deserialize button_threshold <- deserialize return (MkDeviceAbsCalibCtl control_id len min_x max_x min_y max_y flip_x flip_y rotation button_threshold) data DeviceAbsAreaCtrl = MkDeviceAbsAreaCtrl{control_id_DeviceAbsAreaCtrl :: Word16, len_DeviceAbsAreaCtrl :: Word16, offset_x_DeviceAbsAreaCtrl :: Word32, offset_y_DeviceAbsAreaCtrl :: Word32, width_DeviceAbsAreaCtrl :: Int32, height_DeviceAbsAreaCtrl :: Int32, screen_DeviceAbsAreaCtrl :: Int32, following_DeviceAbsAreaCtrl :: Word32} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceAbsAreaCtrl where serialize x = do serialize (control_id_DeviceAbsAreaCtrl x) serialize (len_DeviceAbsAreaCtrl x) serialize (offset_x_DeviceAbsAreaCtrl x) serialize (offset_y_DeviceAbsAreaCtrl x) serialize (width_DeviceAbsAreaCtrl x) serialize (height_DeviceAbsAreaCtrl x) serialize (screen_DeviceAbsAreaCtrl x) serialize (following_DeviceAbsAreaCtrl x) size x = size (control_id_DeviceAbsAreaCtrl x) + size (len_DeviceAbsAreaCtrl x) + size (offset_x_DeviceAbsAreaCtrl x) + size (offset_y_DeviceAbsAreaCtrl x) + size (width_DeviceAbsAreaCtrl x) + size (height_DeviceAbsAreaCtrl x) + size (screen_DeviceAbsAreaCtrl x) + size (following_DeviceAbsAreaCtrl x) instance Deserialize DeviceAbsAreaCtrl where deserialize = do control_id <- deserialize len <- deserialize offset_x <- deserialize offset_y <- deserialize width <- deserialize height <- deserialize screen <- deserialize following <- deserialize return (MkDeviceAbsAreaCtrl control_id len offset_x offset_y width height screen following) data DeviceCoreCtrl = MkDeviceCoreCtrl{control_id_DeviceCoreCtrl :: Word16, len_DeviceCoreCtrl :: Word16, status_DeviceCoreCtrl :: Word8} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceCoreCtrl where serialize x = do serialize (control_id_DeviceCoreCtrl x) serialize (len_DeviceCoreCtrl x) serialize (status_DeviceCoreCtrl x) putSkip 3 size x = size (control_id_DeviceCoreCtrl x) + size (len_DeviceCoreCtrl x) + size (status_DeviceCoreCtrl x) + 3 instance Deserialize DeviceCoreCtrl where deserialize = do control_id <- deserialize len <- deserialize status <- deserialize skip 3 return (MkDeviceCoreCtrl control_id len status) data DeviceEnableCtrl = MkDeviceEnableCtrl{control_id_DeviceEnableCtrl :: Word16, len_DeviceEnableCtrl :: Word16, enable_DeviceEnableCtrl :: Word8} deriving (Show, Typeable, Eq, Ord) instance Serialize DeviceEnableCtrl where serialize x = do serialize (control_id_DeviceEnableCtrl x) serialize (len_DeviceEnableCtrl x) serialize (enable_DeviceEnableCtrl x) putSkip 3 size x = size (control_id_DeviceEnableCtrl x) + size (len_DeviceEnableCtrl x) + size (enable_DeviceEnableCtrl x) + 3 instance Deserialize DeviceEnableCtrl where deserialize = do control_id <- deserialize len <- deserialize enable <- deserialize skip 3 return (MkDeviceEnableCtrl control_id len enable) data DeviceValuatorEvent = MkDeviceValuatorEvent{device_id_DeviceValuatorEvent :: Word8, device_state_DeviceValuatorEvent :: Word16, num_valuators_DeviceValuatorEvent :: Word8, first_valuator_DeviceValuatorEvent :: Word8, valuators_DeviceValuatorEvent :: [Int32]} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event DeviceValuatorEvent instance Deserialize DeviceValuatorEvent where deserialize = do skip 1 device_id <- deserialize skip 2 device_state <- deserialize num_valuators <- deserialize first_valuator <- deserialize valuators <- deserializeList (fromIntegral 6) return (MkDeviceValuatorEvent device_id device_state num_valuators first_valuator valuators) data DeviceKeyPressEvent = MkDeviceKeyPressEvent{detail_DeviceKeyPressEvent :: Word8, time_DeviceKeyPressEvent :: TIMESTAMP, root_DeviceKeyPressEvent :: WINDOW, event_DeviceKeyPressEvent :: WINDOW, child_DeviceKeyPressEvent :: WINDOW, root_x_DeviceKeyPressEvent :: Int16, root_y_DeviceKeyPressEvent :: Int16, event_x_DeviceKeyPressEvent :: Int16, event_y_DeviceKeyPressEvent :: Int16, state_DeviceKeyPressEvent :: Word16, same_screen_DeviceKeyPressEvent :: Bool, device_id_DeviceKeyPressEvent :: Word8} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event DeviceKeyPressEvent instance Deserialize DeviceKeyPressEvent where deserialize = do skip 1 detail <- deserialize skip 2 time <- deserialize root <- deserialize event <- deserialize child <- deserialize root_x <- deserialize root_y <- deserialize event_x <- deserialize event_y <- deserialize state <- deserialize same_screen <- deserialize device_id <- deserialize return (MkDeviceKeyPressEvent detail time root event child root_x root_y event_x event_y state same_screen device_id) data DeviceKeyReleaseEvent = MkDeviceKeyReleaseEvent{detail_DeviceKeyReleaseEvent :: Word8, time_DeviceKeyReleaseEvent :: TIMESTAMP, root_DeviceKeyReleaseEvent :: WINDOW, event_DeviceKeyReleaseEvent :: WINDOW, child_DeviceKeyReleaseEvent :: WINDOW, root_x_DeviceKeyReleaseEvent :: Int16, root_y_DeviceKeyReleaseEvent :: Int16, event_x_DeviceKeyReleaseEvent :: Int16, event_y_DeviceKeyReleaseEvent :: Int16, state_DeviceKeyReleaseEvent :: Word16, same_screen_DeviceKeyReleaseEvent :: Bool, device_id_DeviceKeyReleaseEvent :: Word8} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event DeviceKeyReleaseEvent instance Deserialize DeviceKeyReleaseEvent where deserialize = do skip 1 detail <- deserialize skip 2 time <- deserialize root <- deserialize event <- deserialize child <- deserialize root_x <- deserialize root_y <- deserialize event_x <- deserialize event_y <- deserialize state <- deserialize same_screen <- deserialize device_id <- deserialize return (MkDeviceKeyReleaseEvent detail time root event child root_x root_y event_x event_y state same_screen device_id) data DeviceButtonPressEvent = MkDeviceButtonPressEvent{detail_DeviceButtonPressEvent :: Word8, time_DeviceButtonPressEvent :: TIMESTAMP, root_DeviceButtonPressEvent :: WINDOW, event_DeviceButtonPressEvent :: WINDOW, child_DeviceButtonPressEvent :: WINDOW, root_x_DeviceButtonPressEvent :: Int16, root_y_DeviceButtonPressEvent :: Int16, event_x_DeviceButtonPressEvent :: Int16, event_y_DeviceButtonPressEvent :: Int16, state_DeviceButtonPressEvent :: Word16, same_screen_DeviceButtonPressEvent :: Bool, device_id_DeviceButtonPressEvent :: Word8} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event DeviceButtonPressEvent instance Deserialize DeviceButtonPressEvent where deserialize = do skip 1 detail <- deserialize skip 2 time <- deserialize root <- deserialize event <- deserialize child <- deserialize root_x <- deserialize root_y <- deserialize event_x <- deserialize event_y <- deserialize state <- deserialize same_screen <- deserialize device_id <- deserialize return (MkDeviceButtonPressEvent detail time root event child root_x root_y event_x event_y state same_screen device_id) data DeviceButtonReleaseEvent = MkDeviceButtonReleaseEvent{detail_DeviceButtonReleaseEvent :: Word8, time_DeviceButtonReleaseEvent :: TIMESTAMP, root_DeviceButtonReleaseEvent :: WINDOW, event_DeviceButtonReleaseEvent :: WINDOW, child_DeviceButtonReleaseEvent :: WINDOW, root_x_DeviceButtonReleaseEvent :: Int16, root_y_DeviceButtonReleaseEvent :: Int16, event_x_DeviceButtonReleaseEvent :: Int16, event_y_DeviceButtonReleaseEvent :: Int16, state_DeviceButtonReleaseEvent :: Word16, same_screen_DeviceButtonReleaseEvent :: Bool, device_id_DeviceButtonReleaseEvent :: Word8} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event DeviceButtonReleaseEvent instance Deserialize DeviceButtonReleaseEvent where deserialize = do skip 1 detail <- deserialize skip 2 time <- deserialize root <- deserialize event <- deserialize child <- deserialize root_x <- deserialize root_y <- deserialize event_x <- deserialize event_y <- deserialize state <- deserialize same_screen <- deserialize device_id <- deserialize return (MkDeviceButtonReleaseEvent detail time root event child root_x root_y event_x event_y state same_screen device_id) data DeviceMotionNotifyEvent = MkDeviceMotionNotifyEvent{detail_DeviceMotionNotifyEvent :: Word8, time_DeviceMotionNotifyEvent :: TIMESTAMP, root_DeviceMotionNotifyEvent :: WINDOW, event_DeviceMotionNotifyEvent :: WINDOW, child_DeviceMotionNotifyEvent :: WINDOW, root_x_DeviceMotionNotifyEvent :: Int16, root_y_DeviceMotionNotifyEvent :: Int16, event_x_DeviceMotionNotifyEvent :: Int16, event_y_DeviceMotionNotifyEvent :: Int16, state_DeviceMotionNotifyEvent :: Word16, same_screen_DeviceMotionNotifyEvent :: Bool, device_id_DeviceMotionNotifyEvent :: Word8} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event DeviceMotionNotifyEvent instance Deserialize DeviceMotionNotifyEvent where deserialize = do skip 1 detail <- deserialize skip 2 time <- deserialize root <- deserialize event <- deserialize child <- deserialize root_x <- deserialize root_y <- deserialize event_x <- deserialize event_y <- deserialize state <- deserialize same_screen <- deserialize device_id <- deserialize return (MkDeviceMotionNotifyEvent detail time root event child root_x root_y event_x event_y state same_screen device_id) data ProximityInEvent = MkProximityInEvent{detail_ProximityInEvent :: Word8, time_ProximityInEvent :: TIMESTAMP, root_ProximityInEvent :: WINDOW, event_ProximityInEvent :: WINDOW, child_ProximityInEvent :: WINDOW, root_x_ProximityInEvent :: Int16, root_y_ProximityInEvent :: Int16, event_x_ProximityInEvent :: Int16, event_y_ProximityInEvent :: Int16, state_ProximityInEvent :: Word16, same_screen_ProximityInEvent :: Bool, device_id_ProximityInEvent :: Word8} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event ProximityInEvent instance Deserialize ProximityInEvent where deserialize = do skip 1 detail <- deserialize skip 2 time <- deserialize root <- deserialize event <- deserialize child <- deserialize root_x <- deserialize root_y <- deserialize event_x <- deserialize event_y <- deserialize state <- deserialize same_screen <- deserialize device_id <- deserialize return (MkProximityInEvent detail time root event child root_x root_y event_x event_y state same_screen device_id) data ProximityOutEvent = MkProximityOutEvent{detail_ProximityOutEvent :: Word8, time_ProximityOutEvent :: TIMESTAMP, root_ProximityOutEvent :: WINDOW, event_ProximityOutEvent :: WINDOW, child_ProximityOutEvent :: WINDOW, root_x_ProximityOutEvent :: Int16, root_y_ProximityOutEvent :: Int16, event_x_ProximityOutEvent :: Int16, event_y_ProximityOutEvent :: Int16, state_ProximityOutEvent :: Word16, same_screen_ProximityOutEvent :: Bool, device_id_ProximityOutEvent :: Word8} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event ProximityOutEvent instance Deserialize ProximityOutEvent where deserialize = do skip 1 detail <- deserialize skip 2 time <- deserialize root <- deserialize event <- deserialize child <- deserialize root_x <- deserialize root_y <- deserialize event_x <- deserialize event_y <- deserialize state <- deserialize same_screen <- deserialize device_id <- deserialize return (MkProximityOutEvent detail time root event child root_x root_y event_x event_y state same_screen device_id) data FocusInEvent = MkFocusInEvent{detail_FocusInEvent :: NotifyDetail, time_FocusInEvent :: TIMESTAMP, window_FocusInEvent :: WINDOW, mode_FocusInEvent :: NotifyMode, device_id_FocusInEvent :: Word8} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event FocusInEvent instance Deserialize FocusInEvent where deserialize = do skip 1 detail <- liftM fromValue (deserialize :: Get Word8) skip 2 time <- deserialize window <- deserialize mode <- liftM fromValue (deserialize :: Get Word8) device_id <- deserialize skip 18 return (MkFocusInEvent detail time window mode device_id) data FocusOutEvent = MkFocusOutEvent{detail_FocusOutEvent :: NotifyDetail, time_FocusOutEvent :: TIMESTAMP, window_FocusOutEvent :: WINDOW, mode_FocusOutEvent :: NotifyMode, device_id_FocusOutEvent :: Word8} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event FocusOutEvent instance Deserialize FocusOutEvent where deserialize = do skip 1 detail <- liftM fromValue (deserialize :: Get Word8) skip 2 time <- deserialize window <- deserialize mode <- liftM fromValue (deserialize :: Get Word8) device_id <- deserialize skip 18 return (MkFocusOutEvent detail time window mode device_id) data DeviceStateNotifyEvent = MkDeviceStateNotifyEvent{device_id_DeviceStateNotifyEvent :: Word8, time_DeviceStateNotifyEvent :: TIMESTAMP, num_keys_DeviceStateNotifyEvent :: Word8, num_buttons_DeviceStateNotifyEvent :: Word8, num_valuators_DeviceStateNotifyEvent :: Word8, classes_reported_DeviceStateNotifyEvent :: Word8, buttons_DeviceStateNotifyEvent :: [Word8], keys_DeviceStateNotifyEvent :: [Word8], valuators_DeviceStateNotifyEvent :: [Word32]} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event DeviceStateNotifyEvent instance Deserialize DeviceStateNotifyEvent where deserialize = do skip 1 device_id <- deserialize skip 2 time <- deserialize num_keys <- deserialize num_buttons <- deserialize num_valuators <- deserialize classes_reported <- deserialize buttons <- deserializeList (fromIntegral 4) keys <- deserializeList (fromIntegral 4) valuators <- deserializeList (fromIntegral 3) return (MkDeviceStateNotifyEvent device_id time num_keys num_buttons num_valuators classes_reported buttons keys valuators) data DeviceMappingNotifyEvent = MkDeviceMappingNotifyEvent{device_id_DeviceMappingNotifyEvent :: Word8, request_DeviceMappingNotifyEvent :: Word8, first_keycode_DeviceMappingNotifyEvent :: KeyCode, count_DeviceMappingNotifyEvent :: Word8, time_DeviceMappingNotifyEvent :: TIMESTAMP} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event DeviceMappingNotifyEvent instance Deserialize DeviceMappingNotifyEvent where deserialize = do skip 1 device_id <- deserialize skip 2 request <- deserialize first_keycode <- deserialize count <- deserialize skip 1 time <- deserialize skip 20 return (MkDeviceMappingNotifyEvent device_id request first_keycode count time) data ChangeDeviceNotifyEvent = MkChangeDeviceNotifyEvent{device_id_ChangeDeviceNotifyEvent :: Word8, time_ChangeDeviceNotifyEvent :: TIMESTAMP, request_ChangeDeviceNotifyEvent :: Word8} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event ChangeDeviceNotifyEvent instance Deserialize ChangeDeviceNotifyEvent where deserialize = do skip 1 device_id <- deserialize skip 2 time <- deserialize request <- deserialize skip 23 return (MkChangeDeviceNotifyEvent device_id time request) data DeviceKeyStateNotifyEvent = MkDeviceKeyStateNotifyEvent{device_id_DeviceKeyStateNotifyEvent :: Word8, keys_DeviceKeyStateNotifyEvent :: [Word8]} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event DeviceKeyStateNotifyEvent instance Deserialize DeviceKeyStateNotifyEvent where deserialize = do skip 1 device_id <- deserialize skip 2 keys <- deserializeList (fromIntegral 28) return (MkDeviceKeyStateNotifyEvent device_id keys) data DeviceButtonStateNotifyEvent = MkDeviceButtonStateNotifyEvent{device_id_DeviceButtonStateNotifyEvent :: Word8, buttons_DeviceButtonStateNotifyEvent :: [Word8]} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event DeviceButtonStateNotifyEvent instance Deserialize DeviceButtonStateNotifyEvent where deserialize = do skip 1 device_id <- deserialize skip 2 buttons <- deserializeList (fromIntegral 28) return (MkDeviceButtonStateNotifyEvent device_id buttons) data DevicePresenceNotifyEvent = MkDevicePresenceNotifyEvent{time_DevicePresenceNotifyEvent :: TIMESTAMP, devchange_DevicePresenceNotifyEvent :: Word8, device_id_DevicePresenceNotifyEvent :: Word8, control_DevicePresenceNotifyEvent :: Word16} deriving (Show, Typeable, Eq, Ord) instance Graphics.XHB.Shared.Event DevicePresenceNotifyEvent instance Deserialize DevicePresenceNotifyEvent where deserialize = do skip 1 skip 1 skip 2 time <- deserialize devchange <- deserialize device_id <- deserialize control <- deserialize skip 20 return (MkDevicePresenceNotifyEvent time devchange device_id control)