dc0186ab87151b2e4250c0de8c641a725001a651
[platform/core/uifw/at-spi2-atk.git] / 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, 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 <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   char *tab_strings[1];
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_strings[0] = "Tab";
69   tab_keyset = SPI_createAccessibleKeySet (1,  NULL, NULL, tab_strings);
70   retval = SPI_registerAccessibleKeystrokeListener(command_key_listener,
71                                           command_keyset,
72                                           SPI_KEYMASK_ALT | SPI_KEYMASK_CONTROL,
73                                           (unsigned long) ( SPI_KEY_PRESSED ),
74                                           SPI_KEYLISTENER_ALL_WINDOWS);
75   fprintf (stderr, "Command key registry: result %s\n", retval ? "succeeded" : 
76         "failed");
77   retval = SPI_registerAccessibleKeystrokeListener(ordinary_key_listener,
78                                           async_keyset,
79                                           SPI_KEYMASK_UNMODIFIED,
80                                           (unsigned long) ( SPI_KEY_PRESSED | SPI_KEY_RELEASED ),
81                                           SPI_KEYLISTENER_NOSYNC);
82
83   retval = SPI_registerAccessibleKeystrokeListener(synchronous_key_listener,
84                                           sync_keyset,
85                                           SPI_KEYMASK_UNMODIFIED,
86                                           (unsigned long) ( SPI_KEY_PRESSED | SPI_KEY_RELEASED ),
87                                           SPI_KEYLISTENER_CANCONSUME);
88
89   retval = SPI_registerAccessibleKeystrokeListener(tab_key_listener,
90                                           tab_keyset,
91                                           SPI_KEYMASK_ALT,
92                                           (unsigned long) ( SPI_KEY_PRESSED | SPI_KEY_RELEASED ),
93                                           SPI_KEYLISTENER_ALL_WINDOWS);
94   fprintf (stderr, "tab listener registry: %s\n", retval ? "succeeded" : "failed");
95
96   retval = SPI_registerAccessibleKeystrokeListener(all_key_listener,
97                                           SPI_KEYSET_ALL_KEYS,
98                                           SPI_KEYMASK_CONTROL,
99                                           (unsigned long) ( SPI_KEY_PRESSED | SPI_KEY_RELEASED ),
100                                           SPI_KEYLISTENER_ALL_WINDOWS);
101         
102   fprintf (stderr, "all key registry: %s\n", retval ? "succeeded" : "failed" );
103
104   SPI_registerAccessibleKeystrokeListener(all_key_listener,
105                                          SPI_KEYSET_ALL_KEYS,
106                                          SPI_KEYMASK_SHIFT,
107                                          (unsigned long) ( SPI_KEY_PRESSED ),
108                                          SPI_KEYLISTENER_NOSYNC | SPI_KEYLISTENER_CANCONSUME);
109
110   SPI_event_main ();
111
112   putenv ("AT_BRIDGE_SHUTDOWN=1");
113
114   return SPI_exit ();
115 }
116
117 static void
118 simple_at_exit ()
119 {
120   SPI_deregisterAccessibleKeystrokeListener (command_key_listener, SPI_KEYMASK_ALT | SPI_KEYMASK_CONTROL);
121   AccessibleKeystrokeListener_unref         (command_key_listener);
122   SPI_freeAccessibleKeySet                  (command_keyset);
123   
124 /*
125   SPI_deregisterAccessibleKeystrokeListener (ordinary_key_listener, SPI_KEYMASK_ALT | SPI_KEYMASK_CONTROL); */
126   AccessibleKeystrokeListener_unref         (ordinary_key_listener);
127   SPI_freeAccessibleKeySet                  (async_keyset);
128   
129 /*  SPI_deregisterAccessibleKeystrokeListener (synchronous_key_listener, SPI_KEYMASK_ALT | SPI_KEYMASK_CONTROL); */
130   AccessibleKeystrokeListener_unref         (synchronous_key_listener);
131   SPI_freeAccessibleKeySet                  (sync_keyset);
132
133   SPI_deregisterAccessibleKeystrokeListener (tab_key_listener, SPI_KEYMASK_ALT | SPI_KEYMASK_CONTROL);
134   AccessibleKeystrokeListener_unref         (tab_key_listener);
135   SPI_freeAccessibleKeySet                  (tab_keyset);
136
137   SPI_event_quit ();
138 }
139
140 static SPIBoolean
141 is_command_key (const AccessibleKeystroke *key)
142 {
143   switch (key->keyID)
144     {
145     case 'Q':
146     case 'q':
147             simple_at_exit(); 
148             return TRUE; /* not reached */
149     default:
150             return FALSE;
151     }
152 }
153
154 static void
155 print_key_event (const AccessibleKeystroke *key, char *prefix)
156 {
157   fprintf (stderr, "%s KeyEvent %s%c (keycode %d); string=%s; time=%lx\n",
158            prefix,
159           (key->modifiers & SPI_KEYMASK_ALT)?"Alt-":"",
160           ((key->modifiers & SPI_KEYMASK_SHIFT)^(key->modifiers & SPI_KEYMASK_SHIFTLOCK))?
161           (char) toupper((int) key->keyID) : (char) tolower((int) key->keyID),
162           (int) key->keycode,
163           key->keystring,
164           (long int) key->timestamp);   
165 }
166
167 static SPIBoolean
168 report_command_key_event (const AccessibleKeystroke *key, void *user_data)
169 {
170   print_key_event (key, "command");
171   return is_command_key (key);
172 }
173
174 static SPIBoolean
175 report_ordinary_key_event (const AccessibleKeystroke *key, void *user_data)
176 {
177   print_key_event (key, "ordinary");    
178   return FALSE;
179 }
180
181 static SPIBoolean
182 report_synchronous_key_event (const AccessibleKeystroke *key, void *user_data)
183 {
184   /* consume 'd' key, let others pass through */        
185   print_key_event (key, "synchronous (consumable) ");   
186   return ( key->keyID == 'd' ) ? TRUE : FALSE;
187 }
188
189 static SPIBoolean
190 report_tab_key_event (const AccessibleKeystroke *key, void *user_data)
191 {
192   print_key_event (key, "[TAB]");       
193   return FALSE;
194 }
195
196 static SPIBoolean
197 report_all_key_event (const AccessibleKeystroke *key, void *user_data)
198 {
199   g_print("(%d)", key->keyID);
200   return FALSE;
201 }
202