static AccessibleKeystrokeListener *key_listener;
static AccessibleKeystrokeListener *switch_listener;
-static boolean shift_latched = False;
-static boolean caps_lock = False;
+static SPIBoolean shift_latched = False;
+static SPIBoolean caps_lock = False;
static GtkButton **buttons[MAX_ROWS];
typedef enum {
}
static void
-label_buttons(boolean shifted)
+label_buttons(SPIBoolean shifted)
{
int i, j;
KeySym keysym;
/* Note: these routines are not i18n-savvy, we need to use XIM, other methods here */
if (keysym && g_ascii_isprint((int)keysym))
{
- snprintf (label, 2, "%c", (int) keysym);
+ g_snprintf (label, 2, "%c", (int) keysym);
}
else
{
}
static void
-show_shift (GtkButton *button, boolean *is_shifted)
+show_shift (GtkButton *button, SPIBoolean *is_shifted)
{
label_buttons (*is_shifted ^ caps_lock);
}
}
static void
-keysynth_exit()
+keysynth_exit (void)
{
- deregisterAccessibleKeystrokeListener (key_listener, SPI_KEYMASK_ALT );
- deregisterAccessibleKeystrokeListener (switch_listener, SPI_KEYMASK_UNMODIFIED );
- SPI_exit ();
+ SPI_deregisterAccessibleKeystrokeListener (key_listener, SPI_KEYMASK_ALT);
+ AccessibleKeystrokeListener_unref (key_listener);
+
+ SPI_deregisterAccessibleKeystrokeListener (switch_listener, SPI_KEYMASK_UNMODIFIED);
+ AccessibleKeystrokeListener_unref (switch_listener);
+
+ SPI_event_quit ();
}
static void
}
static void
-button_exit(GtkButton *notused, void *alsonotused)
+button_exit (GtkButton *notused, void *alsonotused)
{
- keysynth_exit();
+ keysynth_exit ();
}
-static boolean
-is_command_key (AccessibleKeystroke *key)
+static SPIBoolean
+is_command_key (const AccessibleKeystroke *key, void *user_data)
{
switch (key->keyID)
{
case 'Q':
case 'q':
- keysynth_exit();
+ keysynth_exit ();
return TRUE; /* not reached */
}
return FALSE;
}
-static boolean
-switch_callback (AccessibleKeystroke *key)
+static SPIBoolean
+switch_callback (const AccessibleKeystroke *key, void *user_data)
{
- static boolean is_down = FALSE;
+ static SPIBoolean is_down = FALSE;
+
if (key->type == SPI_KEY_RELEASED)
{
- g_print ("spacebar up\n");
+ g_print ("switch up\n");
is_down = FALSE;
scan_stop (key->timestamp);
}
else
if (!is_down)
{
- g_print ("spacebar down\n");
+ g_print ("switch down\n");
is_down = TRUE;
scan_start (key->timestamp);
}
static KeyCode shift_keycode = 0;
if (!shift_keycode) shift_keycode = XKeysymToKeycode(GDK_DISPLAY(), (KeySym) 0xFFE1);
/* Note: in a real onscreen keyboard shift keycode should not be hard-coded! */
+
if (*keycode)
{
if (*keycode == CAPSLOCK_KEYCODE)
label_buttons (caps_lock || shift_latched);
}
if (shift_latched)
- generateKeyEvent (shift_keycode, SPI_KEY_PRESS);
-
- generateKeyEvent ((long) *keycode, SPI_KEY_PRESSRELEASE);
+ SPI_generateKeyboardEvent (shift_keycode, NULL, SPI_KEY_PRESS);
+
+ g_print ("generating key %d\n", (int) *keycode);
+ SPI_generateKeyboardEvent ((long) *keycode, NULL, SPI_KEY_PRESSRELEASE);
if (shift_latched)
{
- generateKeyEvent (shift_keycode, SPI_KEY_RELEASE);
+ SPI_generateKeyboardEvent (shift_keycode, NULL, SPI_KEY_RELEASE);
toggle_shift_latch (button);
}
}
GtkWidget *window, *container, *hbox;
int i, j;
KeyCode *keycodeptr, keycode = MIN_KEYCODE;
- static boolean true_val = True;
- static boolean false_val = False;
+ static SPIBoolean true_val = True;
+ static SPIBoolean false_val = False;
window = g_object_connect (gtk_widget_new (gtk_window_get_type (),
"user_data", NULL,
}
int
-main(int argc, char **argv)
+main (int argc, char **argv)
{
AccessibleKeySet switch_set;
- if ((argc > 1) && (!strncmp(argv[1],"-h",2)))
+ if ((argc > 1) && (!strncmp (argv[1], "-h", 2)))
{
printf ("Usage: keysynth-demo\n");
exit (1);
SPI_init ();
- key_listener = createAccessibleKeystrokeListener (is_command_key);
+ key_listener = SPI_createAccessibleKeystrokeListener (is_command_key, NULL);
/* will listen only to Alt-key combinations */
- registerAccessibleKeystrokeListener (key_listener,
- (AccessibleKeySet *) SPI_KEYSET_ALL_KEYS,
- SPI_KEYMASK_ALT,
- (unsigned long) ( KeyPress | KeyRelease),
- SPI_KEYLISTENER_CANCONSUME | SPI_KEYLISTENER_ALL_WINDOWS);
+ SPI_registerAccessibleKeystrokeListener (key_listener,
+ (AccessibleKeySet *) SPI_KEYSET_ALL_KEYS,
+ SPI_KEYMASK_ALT | SPI_KEYMASK_CONTROL,
+ (unsigned long) ( KeyPress | KeyRelease),
+ SPI_KEYLISTENER_CANCONSUME | SPI_KEYLISTENER_ALL_WINDOWS);
create_vkbd ();
/*
* Register a listener on an 'unused' key, to serve as a 'single switch'.
* On most Intel boxes there is at least one 'special' system key that does not
* have a non-zero keycode assigned in the Xserver, so we will intercept any keycode
- * that is 'zero'. Often these the "windows" key or the "menu" key.
+ * that is 'zero'. Often these the are the "windows" or the "menu" keys.
*/
switch_set.keysyms = g_new0 (unsigned long, 1);
switch_set.keycodes = g_new0 (unsigned short, 1);
+ switch_set.keystrings = g_new0 (char *, 1);
switch_set.len = 1;
switch_set.keysyms[0] = (unsigned long) 0;
switch_set.keycodes[0] = (unsigned short) 0;
- switch_listener = createAccessibleKeystrokeListener (switch_callback);
- registerAccessibleKeystrokeListener (switch_listener,
- &switch_set,
- SPI_KEYMASK_UNMODIFIED,
- (unsigned long) ( KeyPress | KeyRelease),
- SPI_KEYLISTENER_CANCONSUME);
+ switch_set.keystrings[0] = "";
+ switch_listener = SPI_createAccessibleKeystrokeListener (switch_callback, NULL);
+ SPI_registerAccessibleKeystrokeListener (switch_listener,
+ &switch_set,
+ SPI_KEYMASK_UNMODIFIED,
+ (unsigned long) ( SPI_KEY_PRESSED | SPI_KEY_RELEASED ),
+ SPI_KEYLISTENER_NOSYNC);
- SPI_event_main (TRUE);
+ SPI_event_main ();
- return 0;
+ return SPI_exit ();
}