tests/cspi/key-listener-test.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2002 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002 Ximian, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <ctype.h>
  27 #include <unistd.h>
  28 #include <sys/socket.h>
  29 #include <netinet/in.h>
  30 #include <sys/un.h>
  31 #include "../../cspi/spi.h"
  32
  33 static SPIBoolean report_command_key_event  (const AccessibleKeystroke *stroke, void *user_data);
  34 static SPIBoolean report_ordinary_key_event (const AccessibleKeystroke *stroke, void *user_data);
  35 static SPIBoolean report_synchronous_key_event (const AccessibleKeystroke *stroke, void *user_data);
  36 static SPIBoolean report_tab_key_event (const AccessibleKeystroke *stroke, void *user_data);
  37 static SPIBoolean report_all_key_event (const AccessibleKeystroke *stroke, void *user_data);
  38
  39 static AccessibleKeystrokeListener *command_key_listener;
  40 static AccessibleKeystrokeListener *ordinary_key_listener;
  41 static AccessibleKeystrokeListener *synchronous_key_listener;
  42 static AccessibleKeystrokeListener *tab_key_listener;
  43 static AccessibleKeystrokeListener *all_key_listener;
  44 static AccessibleKeySet            *command_keyset;
  45 static AccessibleKeySet            *async_keyset;
  46 static AccessibleKeySet            *sync_keyset;
  47 static AccessibleKeySet            *tab_keyset;
  48
  49 int
  50 main (int argc, char **argv)
  51 {
  52   const char *tab_strings[1] = {"Tab"};
  53   short keycodes[] = {65, 64, 23};
  54   SPIBoolean retval = FALSE;
  55
  56   SPI_init ();
  57
  58   /* prepare the keyboard snoopers */
  59   command_key_listener = SPI_createAccessibleKeystrokeListener (report_command_key_event, NULL);
  60   ordinary_key_listener = SPI_createAccessibleKeystrokeListener (report_ordinary_key_event, NULL);
  61   synchronous_key_listener = SPI_createAccessibleKeystrokeListener (report_synchronous_key_event, NULL);
  62   tab_key_listener = SPI_createAccessibleKeystrokeListener (report_tab_key_event, NULL);
  63   all_key_listener = SPI_createAccessibleKeystrokeListener (report_all_key_event, NULL);
  64
  65   command_keyset = SPI_createAccessibleKeySet (1, "q", NULL, NULL);
  66   async_keyset = SPI_createAccessibleKeySet (3, NULL, keycodes, NULL);
  67   sync_keyset = SPI_createAccessibleKeySet (3, "def", NULL, NULL);
  68   tab_keyset = SPI_createAccessibleKeySet (1,  NULL, NULL, tab_strings);
  69   retval = SPI_registerAccessibleKeystrokeListener(command_key_listener,
  70                                           command_keyset,
  71                                           SPI_KEYMASK_ALT | SPI_KEYMASK_CONTROL,
  72                                           (unsigned long) ( SPI_KEY_PRESSED ),
  73                                           SPI_KEYLISTENER_ALL_WINDOWS);
  74   fprintf (stderr, "Command key registry: result %s\n", retval ? "succeeded" :
  75         "failed");
  76   retval = SPI_registerAccessibleKeystrokeListener(ordinary_key_listener,
  77                                           async_keyset,
  78                                           SPI_KEYMASK_UNMODIFIED,
  79                                           (unsigned long) ( SPI_KEY_PRESSED | SPI_KEY_RELEASED ),
  80                                           SPI_KEYLISTENER_NOSYNC);
  81
  82   retval = SPI_registerAccessibleKeystrokeListener(synchronous_key_listener,
  83                                           sync_keyset,
  84                                           SPI_KEYMASK_UNMODIFIED,
  85                                           (unsigned long) ( SPI_KEY_PRESSED | SPI_KEY_RELEASED ),
  86                                           SPI_KEYLISTENER_CANCONSUME);
  87
  88   retval = SPI_registerAccessibleKeystrokeListener(tab_key_listener,
  89                                           tab_keyset,
  90                                           SPI_KEYMASK_ALT,
  91                                           (unsigned long) ( SPI_KEY_PRESSED | SPI_KEY_RELEASED ),
  92                                           SPI_KEYLISTENER_ALL_WINDOWS);
  93   fprintf (stderr, "tab listener registry: %s\n", retval ? "succeeded" : "failed");
  94
  95   retval = SPI_registerAccessibleKeystrokeListener(all_key_listener,
  96                                           SPI_KEYSET_ALL_KEYS,
  97                                           SPI_KEYMASK_CONTROL | SPI_KEYMASK_SHIFT,
  98                                           (unsigned long) ( SPI_KEY_PRESSED | SPI_KEY_RELEASED ),
  99                                           SPI_KEYLISTENER_ALL_WINDOWS);
 100
 101   fprintf (stderr, "all key registry: %s\n", retval ? "succeeded" : "failed" );
 102
 103   SPI_registerAccessibleKeystrokeListener(all_key_listener,
 104                                          SPI_KEYSET_ALL_KEYS,
 105                                          SPI_KEYMASK_SHIFT,
 106                                          (unsigned long) ( SPI_KEY_PRESSED ),
 107                                          SPI_KEYLISTENER_NOSYNC | SPI_KEYLISTENER_CANCONSUME);
 108
 109   SPI_event_main ();
 110
 111   putenv ("AT_BRIDGE_SHUTDOWN=1");
 112
 113   return SPI_exit ();
 114 }
 115
 116 static void
 117 simple_at_exit (void)
 118 {
 119   SPI_deregisterAccessibleKeystrokeListener (command_key_listener, SPI_KEYMASK_ALT | SPI_KEYMASK_CONTROL);
 120   AccessibleKeystrokeListener_unref         (command_key_listener);
 121   SPI_freeAccessibleKeySet                  (command_keyset);
 122
 123 /*
 124   SPI_deregisterAccessibleKeystrokeListener (ordinary_key_listener, SPI_KEYMASK_ALT | SPI_KEYMASK_CONTROL); */
 125   AccessibleKeystrokeListener_unref         (ordinary_key_listener);
 126   SPI_freeAccessibleKeySet                  (async_keyset);
 127
 128 /*  SPI_deregisterAccessibleKeystrokeListener (synchronous_key_listener, SPI_KEYMASK_ALT | SPI_KEYMASK_CONTROL); */
 129   AccessibleKeystrokeListener_unref         (synchronous_key_listener);
 130   SPI_freeAccessibleKeySet                  (sync_keyset);
 131
 132   SPI_deregisterAccessibleKeystrokeListener (tab_key_listener, SPI_KEYMASK_ALT | SPI_KEYMASK_CONTROL);
 133   AccessibleKeystrokeListener_unref         (tab_key_listener);
 134   SPI_freeAccessibleKeySet                  (tab_keyset);
 135
 136   SPI_event_quit ();
 137 }
 138
 139 static SPIBoolean
 140 is_command_key (const AccessibleKeystroke *key)
 141 {
 142   switch (key->keyID)
 143     {
 144     case 'Q':
 145     case 'q':
 146             simple_at_exit();
 147             return TRUE; /* not reached */
 148     default:
 149             return FALSE;
 150     }
 151 }
 152
 153 static void
 154 print_key_event (const AccessibleKeystroke *key, char *prefix)
 155 {
 156   fprintf (stderr, "%s KeyEvent %s%c (keycode %d); string=%s; time=%lx\n",
 157            prefix,
 158           (key->modifiers & SPI_KEYMASK_ALT)?"Alt-":"",
 159           ((key->modifiers & SPI_KEYMASK_SHIFT)^(key->modifiers & SPI_KEYMASK_SHIFTLOCK))?
 160           (char) toupper((int) key->keyID) : (char) tolower((int) key->keyID),
 161           (int) key->keycode,
 162           key->keystring,
 163           (long int) key->timestamp);
 164 }
 165
 166 static SPIBoolean
 167 report_command_key_event (const AccessibleKeystroke *key, void *user_data)
 168 {
 169   print_key_event (key, "command");
 170   return is_command_key (key);
 171 }
 172
 173 static SPIBoolean
 174 report_ordinary_key_event (const AccessibleKeystroke *key, void *user_data)
 175 {
 176   print_key_event (key, "ordinary");
 177   return FALSE;
 178 }
 179
 180 static SPIBoolean
 181 report_synchronous_key_event (const AccessibleKeystroke *key, void *user_data)
 182 {
 183   /* consume 'd' key, let others pass through */
 184   print_key_event (key, "synchronous (consumable) ");
 185   return ( key->keyID == 'd' ) ? TRUE : FALSE;
 186 }
 187
 188 static SPIBoolean
 189 report_tab_key_event (const AccessibleKeystroke *key, void *user_data)
 190 {
 191   print_key_event (key, "[TAB]");
 192   return FALSE;
 193 }
 194
 195 static SPIBoolean
 196 report_all_key_event (const AccessibleKeystroke *key, void *user_data)
 197 {
 198   fprintf(stderr, "(%ld)", key->keyID);
 199   return FALSE;
 200 }
 201