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