Pileus Git - ~andy/gtk/blob - gdk/win32/gdkkeys-win32.c

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 2000 Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26 #include <ctype.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <limits.h>
  31 #include <errno.h>
  32
  33 #include "gdk.h"
  34
  35 #include "gdkprivate-win32.h"
  36 #include "gdkinternals.h"
  37 #include "gdkkeysyms.h"
  38
  39 #include "config.h"
  40
  41 guint _gdk_keymap_serial = 0;
  42 gboolean _gdk_keyboard_has_altgr = FALSE;
  43
  44 static GdkKeymap *default_keymap = NULL;
  45
  46 static guint *keysym_tab = NULL;
  47
  48 #ifdef G_ENABLE_DEBUG
  49 static void
  50 print_keysym_tab (void)
  51 {
  52   gint vk;
  53
  54   g_print ("keymap:%s\n", _gdk_keyboard_has_altgr ? " (uses AltGr)" : "");
  55   for (vk = 0; vk < 256; vk++)
  56     {
  57       gint state;
  58
  59       g_print ("%#.02x: ", vk);
  60       for (state = 0; state < 4; state++)
  61         {
  62           gchar *name = gdk_keyval_name (keysym_tab[vk*4 + state]);
  63           if (name == NULL)
  64             name = "(none)";
  65           g_print ("%s ", name);
  66         }
  67       g_print ("\n");
  68     }
  69 }
  70 #endif
  71
  72 static void
  73 update_keymap (void)
  74 {
  75   static guint current_serial = 0;
  76   guchar key_state[256], temp_key_state[256];
  77   wchar_t wcs[1];
  78   guint scancode;
  79   guint vk;
  80
  81   if (keysym_tab != NULL && current_serial == _gdk_keymap_serial)
  82     return;
  83
  84   current_serial = _gdk_keymap_serial;
  85
  86   if (keysym_tab == NULL)
  87     keysym_tab = g_new (guint, 4*256);
  88
  89   memset (key_state, 0, sizeof (key_state));
  90
  91   _gdk_keyboard_has_altgr = FALSE;
  92
  93   for (vk = 0; vk < 256; vk++)
  94     {
  95       if ((scancode = MapVirtualKey (vk, 0)) == 0)
  96         keysym_tab[vk*4+0] =
  97           keysym_tab[vk*4+1] =
  98           keysym_tab[vk*4+2] =
  99           keysym_tab[vk*4+3] = GDK_VoidSymbol;
 100       else
 101         {
 102           gint shift;
 103
 104           key_state[vk] = 0x80;
 105           for (shift = 0; shift < 4; shift++)
 106             {
 107               guint *ksymp = keysym_tab + vk*4 + shift;
 108               guchar chars[2];
 109
 110               switch (shift)
 111                 {
 112                 case 0:
 113                   key_state[VK_SHIFT] = 0;
 114                   key_state[VK_CONTROL] = key_state[VK_MENU] = 0;
 115                   break;
 116                 case 1:
 117                   key_state[VK_SHIFT] = 0x80;
 118                   key_state[VK_CONTROL] = key_state[VK_MENU] = 0;
 119                   break;
 120                 case 2:
 121                   key_state[VK_SHIFT] = 0;
 122                   key_state[VK_CONTROL] = key_state[VK_MENU] = 0x80;
 123                   break;
 124                 case 3:
 125                   key_state[VK_SHIFT] = 0x80;
 126                   key_state[VK_CONTROL] = key_state[VK_MENU] = 0x80;
 127                   break;
 128                 }
 129
 130               *ksymp = 0;
 131
 132               /* First, handle those virtual keys that we always want
 133                * as special GDK_* keysyms, even if ToAsciiEx might
 134                * turn some them into a ASCII character (like TAB and
 135                * ESC).
 136                */
 137               switch (vk)
 138                 {
 139                 case VK_CANCEL:
 140                   *ksymp = GDK_Cancel; break;
 141                 case VK_BACK:
 142                   *ksymp = GDK_BackSpace; break;
 143                 case VK_TAB:
 144                   if (shift & 0x1)
 145                     *ksymp = GDK_ISO_Left_Tab;
 146                   else
 147                     *ksymp = GDK_Tab;
 148                   break;
 149                 case VK_CLEAR:
 150                   *ksymp = GDK_Clear; break;
 151                 case VK_RETURN:
 152                   *ksymp = GDK_Return; break;
 153                 case VK_SHIFT:
 154                 case VK_LSHIFT:
 155                   *ksymp = GDK_Shift_L; break;
 156                 case VK_CONTROL:
 157                 case VK_LCONTROL:
 158                   *ksymp = GDK_Control_L; break;
 159                 case VK_MENU:
 160                 case VK_LMENU:
 161                   *ksymp = GDK_Alt_L; break;
 162                 case VK_PAUSE:
 163                   *ksymp = GDK_Pause; break;
 164                 case VK_ESCAPE:
 165                   *ksymp = GDK_Escape; break;
 166                 case VK_PRIOR:
 167                   *ksymp = GDK_Prior; break;
 168                 case VK_NEXT:
 169                   *ksymp = GDK_Next; break;
 170                 case VK_END:
 171                   *ksymp = GDK_End; break;
 172                 case VK_HOME:
 173                   *ksymp = GDK_Home; break;
 174                 case VK_LEFT:
 175                   *ksymp = GDK_Left; break;
 176                 case VK_UP:
 177                   *ksymp = GDK_Up; break;
 178                 case VK_RIGHT:
 179                   *ksymp = GDK_Right; break;
 180                 case VK_DOWN:
 181                   *ksymp = GDK_Down; break;
 182                 case VK_SELECT:
 183                   *ksymp = GDK_Select; break;
 184                 case VK_PRINT:
 185                   *ksymp = GDK_Print; break;
 186                 case VK_EXECUTE:
 187                   *ksymp = GDK_Execute; break;
 188                 case VK_INSERT:
 189                   *ksymp = GDK_Insert; break;
 190                 case VK_DELETE:
 191                   *ksymp = GDK_Delete; break;
 192                 case VK_HELP:
 193                   *ksymp = GDK_Help; break;
 194                 case VK_LWIN:
 195                   *ksymp = GDK_Meta_L; break;
 196                 case VK_RWIN:
 197                   *ksymp = GDK_Meta_R; break;
 198                 case VK_MULTIPLY:
 199                   *ksymp = GDK_KP_Multiply; break;
 200                 case VK_ADD:
 201                   *ksymp = GDK_KP_Add; break;
 202                 case VK_SEPARATOR:
 203                   *ksymp = GDK_KP_Separator; break;
 204                 case VK_SUBTRACT:
 205                   *ksymp = GDK_KP_Subtract; break;
 206                 case VK_DECIMAL:
 207                   *ksymp = GDK_KP_Decimal; break;
 208                 case VK_DIVIDE:
 209                   *ksymp = GDK_KP_Divide; break;
 210                 case VK_F1:
 211                   *ksymp = GDK_F1; break;
 212                 case VK_F2:
 213                   *ksymp = GDK_F2; break;
 214                 case VK_F3:
 215                   *ksymp = GDK_F3; break;
 216                 case VK_F4:
 217                   *ksymp = GDK_F4; break;
 218                 case VK_F5:
 219                   *ksymp = GDK_F5; break;
 220                 case VK_F6:
 221                   *ksymp = GDK_F6; break;
 222                 case VK_F7:
 223                   *ksymp = GDK_F7; break;
 224                 case VK_F8:
 225                   *ksymp = GDK_F8; break;
 226                 case VK_F9:
 227                   *ksymp = GDK_F9; break;
 228                 case VK_F10:
 229                   *ksymp = GDK_F10; break;
 230                 case VK_F11:
 231                   *ksymp = GDK_F11; break;
 232                 case VK_F12:
 233                   *ksymp = GDK_F12; break;
 234                 case VK_F13:
 235                   *ksymp = GDK_F13; break;
 236                 case VK_F14:
 237                   *ksymp = GDK_F14; break;
 238                 case VK_F15:
 239                   *ksymp = GDK_F15; break;
 240                 case VK_F16:
 241                   *ksymp = GDK_F16; break;
 242                 case VK_F17:
 243                   *ksymp = GDK_F17; break;
 244                 case VK_F18:
 245                   *ksymp = GDK_F18; break;
 246                 case VK_F19:
 247                   *ksymp = GDK_F19; break;
 248                 case VK_F20:
 249                   *ksymp = GDK_F20; break;
 250                 case VK_F21:
 251                   *ksymp = GDK_F21; break;
 252                 case VK_F22:
 253                   *ksymp = GDK_F22; break;
 254                 case VK_F23:
 255                   *ksymp = GDK_F23; break;
 256                 case VK_F24:
 257                   *ksymp = GDK_F24; break;
 258                 case VK_NUMLOCK:
 259                   *ksymp = GDK_Num_Lock; break;
 260                 case VK_SCROLL:
 261                   *ksymp = GDK_Scroll_Lock; break;
 262                 case VK_RSHIFT:
 263                   *ksymp = GDK_Shift_R; break;
 264                 case VK_RCONTROL:
 265                   *ksymp = GDK_Control_R; break;
 266                 case VK_RMENU:
 267                   *ksymp = GDK_Alt_R; break;
 268                 }
 269               if (*ksymp == 0)
 270                 {
 271                   gint k = ToAsciiEx (vk, scancode, key_state,
 272                                       (LPWORD) chars, 0, _gdk_input_locale);
 273 #if 0
 274                   g_print ("ToAsciiEx(%02x: %d: %d: %d, %02x%02x\n",
 275                            vk, scancode, shift, k, chars[0], chars[1]);
 276 #endif
 277                   if (k == 1)
 278                     {
 279                       if (_gdk_input_codepage >= 1250 &&
 280                           _gdk_input_codepage <= 1258 &&
 281                           chars[0] >= GDK_space && chars[0] <= GDK_asciitilde)
 282                         *ksymp = chars[0];
 283                       else
 284                         {
 285                           if (MultiByteToWideChar (_gdk_input_codepage, 0,
 286                                                    chars, 1, wcs, 1) > 0)
 287                             *ksymp = gdk_unicode_to_keyval (wcs[0]);
 288                         }
 289                     }
 290                   else if (k == -1)
 291                     {
 292                       MultiByteToWideChar (_gdk_input_codepage, 0,
 293                                            chars, 1, wcs, 1);
 294
 295                       /* It is a dead key, and it's has been stored in
 296                        * the keyboard layout's state by ToAsciiEx().
 297                        * Yes, this is an incredibly silly API! Make
 298                        * the keyboard layout forget it by calling
 299                        * ToAsciiEx() once more, with the virtual key
 300                        * code and scancode for the spacebar, without
 301                        * shift or AltGr. Otherwise the next call to
 302                        * ToAsciiEx() with a different key would try to
 303                        * combine with the dead key.
 304                        */
 305
 306                       memmove (temp_key_state, key_state, sizeof (key_state));
 307                       temp_key_state[VK_SHIFT] =
 308                         temp_key_state[VK_CONTROL] =
 309                         temp_key_state[VK_MENU] = 0;
 310                       ToAsciiEx (VK_SPACE, MapVirtualKey (VK_SPACE, 0),
 311                                  temp_key_state, (LPWORD) chars, 0,
 312                                  _gdk_input_locale);
 313
 314                       /* Use dead keysyms instead of "undead" ones */
 315                       switch (gdk_unicode_to_keyval (wcs[0]))
 316                         {
 317                         case '"': /* 0x022 */
 318                           *ksymp = GDK_dead_diaeresis; break;
 319                         case '\'': /* 0x027 */
 320                           *ksymp = GDK_dead_acute; break;
 321                         case GDK_asciicircum: /* 0x05e */
 322                           *ksymp = GDK_dead_circumflex; break;
 323                         case GDK_grave: /* 0x060 */
 324                           *ksymp = GDK_dead_grave; break;
 325                         case GDK_asciitilde: /* 0x07e */
 326                           *ksymp = GDK_dead_tilde; break;
 327                         case GDK_diaeresis: /* 0x0a8 */
 328                           *ksymp = GDK_dead_diaeresis; break;
 329                         case GDK_degree: /* 0x0b0 */
 330                           *ksymp = GDK_dead_abovering; break;
 331                         case GDK_acute: /* 0x0b4 */
 332                           *ksymp = GDK_dead_acute; break;
 333                         case GDK_periodcentered: /* 0x0b7 */
 334                           *ksymp = GDK_dead_abovedot; break;
 335                         case GDK_cedilla: /* 0x0b8 */
 336                           *ksymp = GDK_dead_cedilla; break;
 337                         case GDK_breve: /* 0x1a2 */
 338                           *ksymp = GDK_dead_breve; break;
 339                         case GDK_ogonek: /* 0x1b2 */
 340                           *ksymp = GDK_dead_ogonek; break;
 341                         case GDK_caron: /* 0x1b7 */
 342                           *ksymp = GDK_dead_caron; break;
 343                         case GDK_doubleacute: /* 0x1bd */
 344                           *ksymp = GDK_dead_doubleacute; break;
 345                         case GDK_abovedot: /* 0x1ff */
 346                           *ksymp = GDK_dead_abovedot; break;
 347                         case GDK_Greek_accentdieresis: /* 0x7ae */
 348                           *ksymp = GDK_Greek_accentdieresis; break;
 349                         default:
 350                           GDK_NOTE (EVENTS,
 351                                     g_print ("Unhandled dead key cp:%d vk:%02x, sc:%x, ch:%02x%s%s\n",
 352                                              _gdk_input_codepage, vk,
 353                                              scancode, chars[0],
 354                                              (shift&0x1 ? " shift" : ""),
 355                                              (shift&0x2 ? " altgr" : "")));
 356                         }
 357                     }
 358                   else if (k == 0)
 359                     {
 360                       /* Seems to be necessary to "reset" the keyboard layout
 361                        * in this case, too. Otherwise problems on NT4.
 362                        */
 363                       memmove (temp_key_state, key_state, sizeof (key_state));
 364                       temp_key_state[VK_SHIFT] =
 365                         temp_key_state[VK_CONTROL] =
 366                         temp_key_state[VK_MENU] = 0;
 367                       ToAsciiEx (VK_SPACE, MapVirtualKey (VK_SPACE, 0),
 368                                  temp_key_state, (LPWORD) chars, 0,
 369                                  _gdk_input_locale);
 370                     }
 371                   else
 372                     {
 373 #if 0
 374                       GDK_NOTE (EVENTS, g_print ("ToAsciiEx returns %d "
 375                                                  "for vk:%02x, sc:%02x%s%s\n",
 376                                                  k, vk, scancode,
 377                                                  (shift&0x1 ? " shift" : ""),
 378                                                  (shift&0x2 ? " altgr" : "")));
 379 #endif
 380                     }
 381                 }
 382               if (*ksymp == 0)
 383                 *ksymp = GDK_VoidSymbol;
 384             }
 385           key_state[vk] = 0;
 386         }
 387       if ((keysym_tab[vk*4 + 2] != GDK_VoidSymbol &&
 388            keysym_tab[vk*4] != keysym_tab[vk*4 + 2]) ||
 389           (keysym_tab[vk*4 + 3] != GDK_VoidSymbol &&
 390            keysym_tab[vk*4 + 1] != keysym_tab[vk*4 + 3]))
 391         _gdk_keyboard_has_altgr = TRUE;
 392     }
 393   GDK_NOTE (EVENTS, print_keysym_tab ());
 394 }
 395
 396 GdkKeymap*
 397 gdk_keymap_get_for_display (GdkDisplay *display)
 398 {
 399   g_return_val_if_fail (display == gdk_display_get_default (), NULL);
 400
 401   if (default_keymap == NULL)
 402     default_keymap = g_object_new (gdk_keymap_get_type (), NULL);
 403
 404   return default_keymap;
 405 }
 406
 407 PangoDirection
 408 gdk_keymap_get_direction (GdkKeymap *keymap)
 409 {
 410   update_keymap ();
 411
 412   switch (PRIMARYLANGID (LOWORD ((DWORD) _gdk_input_locale)))
 413     {
 414     case LANG_HEBREW:
 415     case LANG_ARABIC:
 416 #ifdef LANG_URDU
 417     case LANG_URDU:
 418 #endif
 419     case LANG_FARSI:
 420       /* Others? */
 421       return PANGO_DIRECTION_RTL;
 422
 423     default:
 424       return PANGO_DIRECTION_LTR;
 425     }
 426 }
 427
 428 gboolean
 429 gdk_keymap_get_entries_for_keyval (GdkKeymap     *keymap,
 430                                    guint          keyval,
 431                                    GdkKeymapKey **keys,
 432                                    gint          *n_keys)
 433 {
 434   GArray *retval;
 435
 436   g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), FALSE);
 437   g_return_val_if_fail (keys != NULL, FALSE);
 438   g_return_val_if_fail (n_keys != NULL, FALSE);
 439   g_return_val_if_fail (keyval != 0, FALSE);
 440
 441   retval = g_array_new (FALSE, FALSE, sizeof (GdkKeymapKey));
 442
 443   /* Accept only the default keymap */
 444   if (keymap == NULL || keymap == gdk_keymap_get_default ())
 445     {
 446       gint vk;
 447
 448       update_keymap ();
 449
 450       for (vk = 0; vk < 256; vk++)
 451         {
 452           gint i;
 453
 454           for (i = 0; i < 4; i++)
 455             {
 456               if (keysym_tab[vk*4+i] == keyval)
 457                 {
 458                   GdkKeymapKey key;
 459
 460                   key.keycode = vk;
 461
 462                   /* 2 levels (normal, shift), two groups (normal, AltGr) */
 463                   key.group = i / 2;
 464                   key.level = i % 2;
 465
 466                   g_array_append_val (retval, key);
 467                 }
 468             }
 469         }
 470     }
 471
 472 #ifdef G_ENABLE_DEBUG
 473   if (_gdk_debug_flags & GDK_DEBUG_EVENTS)
 474     {
 475       gint i;
 476
 477       g_print ("gdk_keymap_get_entries_for_keyval: %#.04x (%s):",
 478                keyval, gdk_keyval_name (keyval));
 479       for (i = 0; i < retval->len; i++)
 480         {
 481           GdkKeymapKey *entry = (GdkKeymapKey *) retval->data + i;
 482           g_print ("  %#.02x %d %d", entry->keycode, entry->group, entry->level);
 483         }
 484       g_print ("\n");
 485     }
 486 #endif
 487
 488   if (retval->len > 0)
 489     {
 490       *keys = (GdkKeymapKey*) retval->data;
 491       *n_keys = retval->len;
 492     }
 493   else
 494     {
 495       *keys = NULL;
 496       *n_keys = 0;
 497     }
 498
 499   g_array_free (retval, retval->len > 0 ? FALSE : TRUE);
 500
 501   return *n_keys > 0;
 502 }
 503
 504 gboolean
 505 gdk_keymap_get_entries_for_keycode (GdkKeymap     *keymap,
 506                                     guint          hardware_keycode,
 507                                     GdkKeymapKey **keys,
 508                                     guint        **keyvals,
 509                                     gint          *n_entries)
 510 {
 511   GArray *key_array;
 512   GArray *keyval_array;
 513
 514   g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), FALSE);
 515   g_return_val_if_fail (n_entries != NULL, FALSE);
 516
 517   if (hardware_keycode <= 0 ||
 518       hardware_keycode >= 256)
 519     {
 520       if (keys)
 521         *keys = NULL;
 522       if (keyvals)
 523         *keyvals = NULL;
 524
 525       *n_entries = 0;
 526       return FALSE;
 527     }
 528
 529   if (keys)
 530     key_array = g_array_new (FALSE, FALSE, sizeof (GdkKeymapKey));
 531   else
 532     key_array = NULL;
 533
 534   if (keyvals)
 535     keyval_array = g_array_new (FALSE, FALSE, sizeof (guint));
 536   else
 537     keyval_array = NULL;
 538
 539   /* Accept only the default keymap */
 540   if (keymap == NULL || keymap == gdk_keymap_get_default ())
 541     {
 542       gint i;
 543
 544       update_keymap ();
 545
 546       for (i = 0; i < 4; i++)
 547         {
 548           if (key_array)
 549             {
 550               GdkKeymapKey key;
 551
 552               key.keycode = hardware_keycode;
 553
 554               key.group = i / 2;
 555               key.level = i % 2;
 556
 557               g_array_append_val (key_array, key);
 558             }
 559
 560           if (keyval_array)
 561             g_array_append_val (keyval_array, keysym_tab[hardware_keycode*4+i]);
 562         }
 563     }
 564
 565   if ((key_array && key_array->len > 0) ||
 566       (keyval_array && keyval_array->len > 0))
 567     {
 568       if (keys)
 569         *keys = (GdkKeymapKey*) key_array->data;
 570
 571       if (keyvals)
 572         *keyvals = (guint*) keyval_array->data;
 573
 574       if (key_array)
 575         *n_entries = key_array->len;
 576       else
 577         *n_entries = keyval_array->len;
 578     }
 579   else
 580     {
 581       if (keys)
 582         *keys = NULL;
 583
 584       if (keyvals)
 585         *keyvals = NULL;
 586
 587       *n_entries = 0;
 588     }
 589
 590   if (key_array)
 591     g_array_free (key_array, key_array->len > 0 ? FALSE : TRUE);
 592   if (keyval_array)
 593     g_array_free (keyval_array, keyval_array->len > 0 ? FALSE : TRUE);
 594
 595   return *n_entries > 0;
 596 }
 597
 598 guint
 599 gdk_keymap_lookup_key (GdkKeymap          *keymap,
 600                        const GdkKeymapKey *key)
 601 {
 602   guint sym;
 603
 604   g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), 0);
 605   g_return_val_if_fail (key != NULL, 0);
 606   g_return_val_if_fail (key->group < 4, 0);
 607
 608   /* Accept only the default keymap */
 609   if (keymap != NULL && keymap != gdk_keymap_get_default ())
 610     return 0;
 611
 612   update_keymap ();
 613
 614   if (key->keycode >= 256 ||
 615       key->group < 0 || key->group >= 2 ||
 616       key->level < 0 || key->level >= 2)
 617     return 0;
 618
 619   sym = keysym_tab[key->keycode*4 + key->group*2 + key->level];
 620
 621   if (sym == GDK_VoidSymbol)
 622     return 0;
 623   else
 624     return sym;
 625 }
 626
 627 gboolean
 628 gdk_keymap_translate_keyboard_state (GdkKeymap       *keymap,
 629                                      guint            hardware_keycode,
 630                                      GdkModifierType  state,
 631                                      gint             group,
 632                                      guint           *keyval,
 633                                      gint            *effective_group,
 634                                      gint            *level,
 635                                      GdkModifierType *consumed_modifiers)
 636 {
 637   guint tmp_keyval;
 638   guint tmp_modifiers;
 639   guint *keyvals;
 640   gint shift_level;
 641   gboolean ignore_shift = FALSE;
 642   gboolean ignore_group = FALSE;
 643
 644   g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), FALSE);
 645   g_return_val_if_fail (group < 4, FALSE);
 646
 647 #if 0
 648   GDK_NOTE (EVENTS, g_print ("gdk_keymap_translate_keyboard_state: keycode=%#x state=%#x group=%d\n",
 649                              hardware_keycode, state, group));
 650 #endif
 651   if (keyval)
 652     *keyval = 0;
 653   if (effective_group)
 654     *effective_group = 0;
 655   if (level)
 656     *level = 0;
 657   if (consumed_modifiers)
 658     *consumed_modifiers = 0;
 659
 660   /* Accept only the default keymap */
 661   if (keymap != NULL && keymap != gdk_keymap_get_default ())
 662     return FALSE;
 663
 664   if (hardware_keycode >= 256)
 665     return FALSE;
 666
 667   if (group < 0 || group >= 2)
 668     return FALSE;
 669
 670   if ((state & GDK_SHIFT_MASK) && (state & GDK_LOCK_MASK))
 671     shift_level = 0;            /* shift disables caps lock */
 672   else if (state & GDK_SHIFT_MASK)
 673     shift_level = 1;
 674   else
 675     shift_level = 0;
 676
 677   update_keymap ();
 678
 679   keyvals = keysym_tab + hardware_keycode*4;
 680
 681   /* Drop group and shift if there are no keysymbols on
 682    * the key for those.
 683    */
 684   if (shift_level == 1 &&
 685       keyvals[group*2 + 1] == GDK_VoidSymbol &&
 686       keyvals[group*2] != GDK_VoidSymbol)
 687     {
 688       shift_level = 0;
 689       ignore_shift = TRUE;
 690     }
 691
 692   if (group == 1 &&
 693       keyvals[2 + shift_level] == GDK_VoidSymbol &&
 694       keyvals[0 + shift_level] != GDK_VoidSymbol)
 695     {
 696       group = 0;
 697       ignore_group = TRUE;
 698     }
 699
 700   if (keyvals[group *2 + shift_level] == GDK_VoidSymbol &&
 701       keyvals[0 + 0] != GDK_VoidSymbol)
 702     {
 703       shift_level = 0;
 704       group = 0;
 705       ignore_group = TRUE;
 706       ignore_shift = TRUE;
 707     }
 708
 709   /* See whether the group and shift level actually mattered
 710    * to know what to put in consumed_modifiers
 711    */
 712   if (keyvals[group*2 + 1] == GDK_VoidSymbol ||
 713       keyvals[group*2 + 0] == keyvals[group*2 + 1])
 714     ignore_shift = TRUE;
 715
 716   if (keyvals[2 + shift_level] == GDK_VoidSymbol ||
 717       keyvals[0 + shift_level] == keyvals[2 + shift_level])
 718     ignore_group = TRUE;
 719
 720   tmp_keyval = keyvals[group*2 + shift_level];
 721
 722   tmp_modifiers = ignore_group ? 0 : GDK_MOD2_MASK;
 723   tmp_modifiers |= ignore_shift ? 0 : (GDK_SHIFT_MASK | GDK_LOCK_MASK);
 724
 725   if (effective_group)
 726     *effective_group = group;
 727
 728   if (!(state & GDK_SHIFT_MASK) && (state & GDK_LOCK_MASK))
 729     {
 730       guint upper = gdk_keyval_to_upper (tmp_keyval);
 731       if (upper != tmp_keyval)
 732         tmp_keyval = upper;
 733     }
 734
 735   if (level)
 736     *level = shift_level;
 737
 738   if (consumed_modifiers)
 739     *consumed_modifiers = tmp_modifiers;
 740
 741   if (keyval)
 742     *keyval = tmp_keyval;
 743
 744 #if 0
 745   GDK_NOTE (EVENTS, g_print ("...group=%d level=%d cmods=%#x keyval=%s\n",
 746                              group, shift_level, tmp_modifiers, gdk_keyval_name (tmp_keyval)));
 747 #endif
 748
 749   return tmp_keyval != GDK_VoidSymbol;
 750 }