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