idl/controller.didl

   1
   2 interface org.freestandards.atspi.DeviceEventController {
   3
   4         enum <uint32> KeySynthType {
   5                 KEY_PRESS=0,
   6                 KEY_RELEASE,
   7                 KEY_PRESSRELEASE,
   8                 KEY_SYM,
   9                 KEY_STRING
  10         }
  11
  12         /*
  13           Consumption of events and syncronous event delivery is a sore-thumb.
  14
  15           The client should really have no say over what the DeviceEventController
  16           does with regards to event delivery as such the 'syncronous' flag is redundant.
  17
  18           The 'global' flag is now useless as XEVIE is no longer maintained. As such
  19           the DeviceEventController will not recieve any device events from applications
  20           not participating.
  21
  22           The only possibly useful flag is 'preemptive'. However all keyboard events are
  23           sent as pre-emptive from gail so its debateable whether even this flag is really
  24           in-use.
  25          */
  26         struct EventListenerMode {
  27                 /* Controller should block while delivering this event. */
  28                 boolean syncronous;
  29                 /* Clients are allowed to consume this event. */
  30                 boolean preemptive;
  31                 /*
  32                  Event notifications should be sent regardless of whether
  33                  focused application participates in AT-SPI accessibility.
  34                  */
  35                 boolean global;
  36         }
  37
  38         struct KeyDefinition {
  39                 int32  keycode;
  40                 int32  keysym;
  41                 string keystring;
  42                 int32  unused;
  43         }
  44
  45         method RegisterKeystrokeListener {
  46                 object            listener;
  47                 KeyDefinition[]   keys;
  48                 uint32            mask;
  49                 EventType[]       type;
  50                 EventListenerMode mode;
  51         } reply {
  52                 boolean           success;
  53         }
  54
  55         method DeregisterKeystrokeListener {
  56                 object            listener;
  57                 KeyDefinition[]   keys;
  58                 uint32            mask;
  59                 EventType[]       type;
  60         }
  61
  62         method RegisterDeviceEventListener {
  63                 object      listener;
  64                 EventType[] type;
  65         } reply {
  66                 boolean     success;
  67         }
  68
  69         method DeregisterDeviceEventListener {
  70                 object      listener;
  71                 EventType[] type;
  72         }
  73
  74         method NotifyListenersSync {
  75                 DeviceEvent event;
  76         } reply {
  77                 boolean     consumed;
  78         }
  79
  80         method NotifyListenersAsync {
  81                 DeviceEvent event;
  82         }
  83
  84         method GenerateKeyboardEvent {
  85                 int32        keycode;
  86                 string       keystring;
  87                 KeySynthType type;
  88         }
  89
  90         method GenerateMouseEvent {
  91                 int32  x;
  92                 int32  y;
  93                 string event_name;
  94         }
  95 }