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 #include "gdkkeysprivate.h"
  39 #include "gdkwin32keys.h"
  40
  41 #include "config.h"
  42
  43 struct _GdkWin32KeymapClass
  44 {
  45   GdkKeymapClass parent_class;
  46 };
  47
  48 struct _GdkWin32Keymap
  49 {
  50   GdkKeymap parent_instance;
  51 };
  52
  53 G_DEFINE_TYPE (GdkWin32Keymap, gdk_win32_keymap, GDK_TYPE_KEYMAP)
  54
  55 static void
  56 gdk_win32_keymap_init (GdkWin32Keymap *keymap)
  57 {
  58 }
  59
  60 guint _gdk_keymap_serial = 0;
  61 gboolean _gdk_keyboard_has_altgr = FALSE;
  62 guint _scancode_rshift = 0;
  63
  64 static GdkModifierType gdk_shift_modifiers = GDK_SHIFT_MASK;
  65
  66 static GdkKeymap *default_keymap = NULL;
  67
  68 static guint *keysym_tab = NULL;
  69
  70 #ifdef G_ENABLE_DEBUG
  71 static void
  72 print_keysym_tab (void)
  73 {
  74   gint vk;
  75
  76   g_print ("keymap:%s%s\n",
  77            _gdk_keyboard_has_altgr ? " (uses AltGr)" : "",
  78            (gdk_shift_modifiers & GDK_LOCK_MASK) ? " (has ShiftLock)" : "");
  79   for (vk = 0; vk < 256; vk++)
  80     {
  81       gint state;
  82
  83       g_print ("%#.02x: ", vk);
  84       for (state = 0; state < 4; state++)
  85         {
  86           gchar *name = gdk_keyval_name (keysym_tab[vk*4 + state]);
  87           if (name == NULL)
  88             name = "(none)";
  89           g_print ("%s ", name);
  90         }
  91       g_print ("\n");
  92     }
  93 }
  94 #endif
  95
  96 static void
  97 handle_special (guint  vk,
  98                 guint *ksymp,
  99                 gint   shift)
 100
 101 {
 102   switch (vk)
 103     {
 104     case VK_CANCEL:
 105       *ksymp = GDK_KEY_Cancel; break;
 106     case VK_BACK:
 107       *ksymp = GDK_KEY_BackSpace; break;
 108     case VK_TAB:
 109       if (shift & 0x1)
 110         *ksymp = GDK_KEY_ISO_Left_Tab;
 111       else
 112         *ksymp = GDK_KEY_Tab;
 113       break;
 114     case VK_CLEAR:
 115       *ksymp = GDK_KEY_Clear; break;
 116     case VK_RETURN:
 117       *ksymp = GDK_KEY_Return; break;
 118     case VK_SHIFT:
 119     case VK_LSHIFT:
 120       *ksymp = GDK_KEY_Shift_L; break;
 121     case VK_CONTROL:
 122     case VK_LCONTROL:
 123       *ksymp = GDK_KEY_Control_L; break;
 124     case VK_MENU:
 125     case VK_LMENU:
 126       *ksymp = GDK_KEY_Alt_L; break;
 127     case VK_PAUSE:
 128       *ksymp = GDK_KEY_Pause; break;
 129     case VK_ESCAPE:
 130       *ksymp = GDK_KEY_Escape; break;
 131     case VK_PRIOR:
 132       *ksymp = GDK_KEY_Prior; break;
 133     case VK_NEXT:
 134       *ksymp = GDK_KEY_Next; break;
 135     case VK_END:
 136       *ksymp = GDK_KEY_End; break;
 137     case VK_HOME:
 138       *ksymp = GDK_KEY_Home; break;
 139     case VK_LEFT:
 140       *ksymp = GDK_KEY_Left; break;
 141     case VK_UP:
 142       *ksymp = GDK_KEY_Up; break;
 143     case VK_RIGHT:
 144       *ksymp = GDK_KEY_Right; break;
 145     case VK_DOWN:
 146       *ksymp = GDK_KEY_Down; break;
 147     case VK_SELECT:
 148       *ksymp = GDK_KEY_Select; break;
 149     case VK_PRINT:
 150       *ksymp = GDK_KEY_Print; break;
 151     case VK_EXECUTE:
 152       *ksymp = GDK_KEY_Execute; break;
 153     case VK_INSERT:
 154       *ksymp = GDK_KEY_Insert; break;
 155     case VK_DELETE:
 156       *ksymp = GDK_KEY_Delete; break;
 157     case VK_HELP:
 158       *ksymp = GDK_KEY_Help; break;
 159     case VK_LWIN:
 160       *ksymp = GDK_KEY_Meta_L; break;
 161     case VK_RWIN:
 162       *ksymp = GDK_KEY_Meta_R; break;
 163     case VK_APPS:
 164       *ksymp = GDK_KEY_Menu; break;
 165     case VK_MULTIPLY:
 166       *ksymp = GDK_KEY_KP_Multiply; break;
 167     case VK_ADD:
 168       *ksymp = GDK_KEY_KP_Add; break;
 169     case VK_SEPARATOR:
 170       *ksymp = GDK_KEY_KP_Separator; break;
 171     case VK_SUBTRACT:
 172       *ksymp = GDK_KEY_KP_Subtract; break;
 173     case VK_DIVIDE:
 174       *ksymp = GDK_KEY_KP_Divide; break;
 175     case VK_NUMPAD0:
 176       *ksymp = GDK_KEY_KP_0; break;
 177     case VK_NUMPAD1:
 178       *ksymp = GDK_KEY_KP_1; break;
 179     case VK_NUMPAD2:
 180       *ksymp = GDK_KEY_KP_2; break;
 181     case VK_NUMPAD3:
 182       *ksymp = GDK_KEY_KP_3; break;
 183     case VK_NUMPAD4:
 184       *ksymp = GDK_KEY_KP_4; break;
 185     case VK_NUMPAD5:
 186       *ksymp = GDK_KEY_KP_5; break;
 187     case VK_NUMPAD6:
 188       *ksymp = GDK_KEY_KP_6; break;
 189     case VK_NUMPAD7:
 190       *ksymp = GDK_KEY_KP_7; break;
 191     case VK_NUMPAD8:
 192       *ksymp = GDK_KEY_KP_8; break;
 193     case VK_NUMPAD9:
 194       *ksymp = GDK_KEY_KP_9; break;
 195     case VK_F1:
 196       *ksymp = GDK_KEY_F1; break;
 197     case VK_F2:
 198       *ksymp = GDK_KEY_F2; break;
 199     case VK_F3:
 200       *ksymp = GDK_KEY_F3; break;
 201     case VK_F4:
 202       *ksymp = GDK_KEY_F4; break;
 203     case VK_F5:
 204       *ksymp = GDK_KEY_F5; break;
 205     case VK_F6:
 206       *ksymp = GDK_KEY_F6; break;
 207     case VK_F7:
 208       *ksymp = GDK_KEY_F7; break;
 209     case VK_F8:
 210       *ksymp = GDK_KEY_F8; break;
 211     case VK_F9:
 212       *ksymp = GDK_KEY_F9; break;
 213     case VK_F10:
 214       *ksymp = GDK_KEY_F10; break;
 215     case VK_F11:
 216       *ksymp = GDK_KEY_F11; break;
 217     case VK_F12:
 218       *ksymp = GDK_KEY_F12; break;
 219     case VK_F13:
 220       *ksymp = GDK_KEY_F13; break;
 221     case VK_F14:
 222       *ksymp = GDK_KEY_F14; break;
 223     case VK_F15:
 224       *ksymp = GDK_KEY_F15; break;
 225     case VK_F16:
 226       *ksymp = GDK_KEY_F16; break;
 227     case VK_F17:
 228       *ksymp = GDK_KEY_F17; break;
 229     case VK_F18:
 230       *ksymp = GDK_KEY_F18; break;
 231     case VK_F19:
 232       *ksymp = GDK_KEY_F19; break;
 233     case VK_F20:
 234       *ksymp = GDK_KEY_F20; break;
 235     case VK_F21:
 236       *ksymp = GDK_KEY_F21; break;
 237     case VK_F22:
 238       *ksymp = GDK_KEY_F22; break;
 239     case VK_F23:
 240       *ksymp = GDK_KEY_F23; break;
 241     case VK_F24:
 242       *ksymp = GDK_KEY_F24; break;
 243     case VK_NUMLOCK:
 244       *ksymp = GDK_KEY_Num_Lock; break;
 245     case VK_SCROLL:
 246       *ksymp = GDK_KEY_Scroll_Lock; break;
 247     case VK_RSHIFT:
 248       *ksymp = GDK_KEY_Shift_R; break;
 249     case VK_RCONTROL:
 250       *ksymp = GDK_KEY_Control_R; break;
 251     case VK_RMENU:
 252       *ksymp = GDK_KEY_Alt_R; break;
 253     }
 254 }
 255
 256 static void
 257 set_shift_vks (guchar *key_state,
 258                gint    shift)
 259 {
 260   switch (shift)
 261     {
 262     case 0:
 263       key_state[VK_SHIFT] = 0;
 264       key_state[VK_CONTROL] = key_state[VK_MENU] = 0;
 265       break;
 266     case 1:
 267       key_state[VK_SHIFT] = 0x80;
 268       key_state[VK_CONTROL] = key_state[VK_MENU] = 0;
 269       break;
 270     case 2:
 271       key_state[VK_SHIFT] = 0;
 272       key_state[VK_CONTROL] = key_state[VK_MENU] = 0x80;
 273       break;
 274     case 3:
 275       key_state[VK_SHIFT] = 0x80;
 276       key_state[VK_CONTROL] = key_state[VK_MENU] = 0x80;
 277       break;
 278     }
 279 }
 280
 281 static void
 282 reset_after_dead (guchar key_state[256])
 283 {
 284   guchar temp_key_state[256];
 285   wchar_t wcs[2];
 286
 287   memmove (temp_key_state, key_state, sizeof (key_state));
 288
 289   temp_key_state[VK_SHIFT] =
 290     temp_key_state[VK_CONTROL] =
 291     temp_key_state[VK_MENU] = 0;
 292
 293   ToUnicodeEx (VK_SPACE, MapVirtualKey (VK_SPACE, 0),
 294                temp_key_state, wcs, G_N_ELEMENTS (wcs),
 295                0, _gdk_input_locale);
 296 }
 297
 298 static void
 299 handle_dead (guint  keysym,
 300              guint *ksymp)
 301 {
 302   switch (keysym)
 303     {
 304     case '"': /* 0x022 */
 305       *ksymp = GDK_KEY_dead_diaeresis; break;
 306     case '\'': /* 0x027 */
 307       *ksymp = GDK_KEY_dead_acute; break;
 308     case GDK_KEY_asciicircum: /* 0x05e */
 309       *ksymp = GDK_KEY_dead_circumflex; break;
 310     case GDK_KEY_grave: /* 0x060 */
 311       *ksymp = GDK_KEY_dead_grave; break;
 312     case GDK_KEY_asciitilde: /* 0x07e */
 313       *ksymp = GDK_KEY_dead_tilde; break;
 314     case GDK_KEY_diaeresis: /* 0x0a8 */
 315       *ksymp = GDK_KEY_dead_diaeresis; break;
 316     case GDK_KEY_degree: /* 0x0b0 */
 317       *ksymp = GDK_KEY_dead_abovering; break;
 318     case GDK_KEY_acute: /* 0x0b4 */
 319       *ksymp = GDK_KEY_dead_acute; break;
 320     case GDK_KEY_periodcentered: /* 0x0b7 */
 321       *ksymp = GDK_KEY_dead_abovedot; break;
 322     case GDK_KEY_cedilla: /* 0x0b8 */
 323       *ksymp = GDK_KEY_dead_cedilla; break;
 324     case GDK_KEY_breve: /* 0x1a2 */
 325       *ksymp = GDK_KEY_dead_breve; break;
 326     case GDK_KEY_ogonek: /* 0x1b2 */
 327       *ksymp = GDK_KEY_dead_ogonek; break;
 328     case GDK_KEY_caron: /* 0x1b7 */
 329       *ksymp = GDK_KEY_dead_caron; break;
 330     case GDK_KEY_doubleacute: /* 0x1bd */
 331       *ksymp = GDK_KEY_dead_doubleacute; break;
 332     case GDK_KEY_abovedot: /* 0x1ff */
 333       *ksymp = GDK_KEY_dead_abovedot; break;
 334     case 0x1000384: /* Greek tonos */
 335       *ksymp = GDK_KEY_dead_acute; break;
 336     case GDK_KEY_Greek_accentdieresis: /* 0x7ae */
 337       *ksymp = GDK_KEY_Greek_accentdieresis; break;
 338     default:
 339       /* By default use the keysym as such. This takes care of for
 340        * instance the dead U+09CD (BENGALI VIRAMA) on the ekushey
 341        * Bengali layout.
 342        */
 343       *ksymp = keysym; break;
 344     }
 345 }
 346
 347 static void
 348 update_keymap (void)
 349 {
 350   static guint current_serial = 0;
 351   guchar key_state[256];
 352   guint scancode;
 353   guint vk;
 354   gboolean capslock_tested = FALSE;
 355
 356   if (keysym_tab != NULL && current_serial == _gdk_keymap_serial)
 357     return;
 358
 359   current_serial = _gdk_keymap_serial;
 360
 361   if (keysym_tab == NULL)
 362     keysym_tab = g_new (guint, 4*256);
 363
 364   memset (key_state, 0, sizeof (key_state));
 365
 366   _gdk_keyboard_has_altgr = FALSE;
 367   gdk_shift_modifiers = GDK_SHIFT_MASK;
 368
 369   for (vk = 0; vk < 256; vk++)
 370     {
 371       if ((scancode = MapVirtualKey (vk, 0)) == 0 &&
 372           vk != VK_DIVIDE)
 373         keysym_tab[vk*4+0] =
 374           keysym_tab[vk*4+1] =
 375           keysym_tab[vk*4+2] =
 376           keysym_tab[vk*4+3] = GDK_KEY_VoidSymbol;
 377       else
 378         {
 379           gint shift;
 380
 381           if (vk == VK_RSHIFT)
 382             _scancode_rshift = scancode;
 383
 384           key_state[vk] = 0x80;
 385           for (shift = 0; shift < 4; shift++)
 386             {
 387               guint *ksymp = keysym_tab + vk*4 + shift;
 388
 389               set_shift_vks (key_state, shift);
 390
 391               *ksymp = 0;
 392
 393               /* First, handle those virtual keys that we always want
 394                * as special GDK_* keysyms, even if ToAsciiEx might
 395                * turn some them into a ASCII character (like TAB and
 396                * ESC).
 397                */
 398               handle_special (vk, ksymp, shift);
 399
 400               if (*ksymp == 0)
 401                 {
 402                   wchar_t wcs[10];
 403                   gint k;
 404
 405                   wcs[0] = wcs[1] = 0;
 406                   k = ToUnicodeEx (vk, scancode, key_state,
 407                                    wcs, G_N_ELEMENTS (wcs),
 408                                    0, _gdk_input_locale);
 409 #if 0
 410                   g_print ("ToUnicodeEx(%#02x, %d: %d): %d, %04x %04x\n",
 411                            vk, scancode, shift, k,
 412                            wcs[0], wcs[1]);
 413 #endif
 414                   if (k == 1)
 415                     *ksymp = gdk_unicode_to_keyval (wcs[0]);
 416                   else if (k == -1)
 417                     {
 418                       guint keysym = gdk_unicode_to_keyval (wcs[0]);
 419
 420                       /* It is a dead key, and it has been stored in
 421                        * the keyboard layout's state by
 422                        * ToAsciiEx()/ToUnicodeEx(). Yes, this is an
 423                        * incredibly silly API! Make the keyboard
 424                        * layout forget it by calling
 425                        * ToAsciiEx()/ToUnicodeEx() once more, with the
 426                        * virtual key code and scancode for the
 427                        * spacebar, without shift or AltGr. Otherwise
 428                        * the next call to ToAsciiEx() with a different
 429                        * key would try to combine with the dead key.
 430                        */
 431                       reset_after_dead (key_state);
 432
 433                       /* Use dead keysyms instead of "undead" ones */
 434                       handle_dead (keysym, ksymp);
 435                     }
 436                   else if (k == 0)
 437                     {
 438                       /* Seems to be necessary to "reset" the keyboard layout
 439                        * in this case, too. Otherwise problems on NT4.
 440                        */
 441                       reset_after_dead (key_state);
 442                     }
 443                   else
 444                     {
 445 #if 0
 446                       GDK_NOTE (EVENTS,
 447                                 g_print ("ToUnicodeEx returns %d "
 448                                          "for vk:%02x, sc:%02x%s%s\n",
 449                                          k, vk, scancode,
 450                                          (shift&0x1 ? " shift" : ""),
 451                                          (shift&0x2 ? " altgr" : "")));
 452 #endif
 453                     }
 454                 }
 455               if (*ksymp == 0)
 456                 *ksymp = GDK_KEY_VoidSymbol;
 457             }
 458           key_state[vk] = 0;
 459
 460           /* Check if keyboard has an AltGr key by checking if
 461            * the mapping with Control+Alt is different.
 462            */
 463           if (!_gdk_keyboard_has_altgr)
 464             if ((keysym_tab[vk*4 + 2] != GDK_KEY_VoidSymbol &&
 465                  keysym_tab[vk*4] != keysym_tab[vk*4 + 2]) ||
 466                 (keysym_tab[vk*4 + 3] != GDK_KEY_VoidSymbol &&
 467                  keysym_tab[vk*4 + 1] != keysym_tab[vk*4 + 3]))
 468               _gdk_keyboard_has_altgr = TRUE;
 469
 470           if (!capslock_tested)
 471             {
 472               /* Can we use this virtual key to determine the CapsLock
 473                * key behaviour: CapsLock or ShiftLock? If it generates
 474                * keysyms for printable characters and has a shifted
 475                * keysym that isn't just the upperacase of the
 476                * unshifted keysym, check the behaviour of VK_CAPITAL.
 477                */
 478               if (g_unichar_isgraph (gdk_keyval_to_unicode (keysym_tab[vk*4 + 0])) &&
 479                   keysym_tab[vk*4 + 1] != keysym_tab[vk*4 + 0] &&
 480                   g_unichar_isgraph (gdk_keyval_to_unicode (keysym_tab[vk*4 + 1])) &&
 481                   keysym_tab[vk*4 + 1] != gdk_keyval_to_upper (keysym_tab[vk*4 + 0]))
 482                 {
 483                   guchar chars[2];
 484
 485                   capslock_tested = TRUE;
 486
 487                   key_state[VK_SHIFT] = 0;
 488                   key_state[VK_CONTROL] = key_state[VK_MENU] = 0;
 489                   key_state[VK_CAPITAL] = 1;
 490
 491                   if (ToAsciiEx (vk, scancode, key_state,
 492                                  (LPWORD) chars, 0, _gdk_input_locale) == 1)
 493                     {
 494                       if (chars[0] >= GDK_KEY_space &&
 495                           chars[0] <= GDK_KEY_asciitilde &&
 496                           chars[0] == keysym_tab[vk*4 + 1])
 497                         {
 498                           /* CapsLock acts as ShiftLock */
 499                           gdk_shift_modifiers |= GDK_LOCK_MASK;
 500                         }
 501                     }
 502                   key_state[VK_CAPITAL] = 0;
 503                 }
 504             }
 505         }
 506     }
 507   GDK_NOTE (EVENTS, print_keysym_tab ());
 508 }
 509
 510 GdkKeymap*
 511 _gdk_win32_display_get_keymap (GdkDisplay *display)
 512 {
 513   g_return_val_if_fail (display == gdk_display_get_default (), NULL);
 514
 515   if (default_keymap == NULL)
 516     default_keymap = g_object_new (gdk_win32_keymap_get_type (), NULL);
 517
 518   return default_keymap;
 519 }
 520
 521 static PangoDirection
 522 gdk_win32_keymap_get_direction (GdkKeymap *keymap)
 523 {
 524   update_keymap ();
 525
 526   switch (PRIMARYLANGID (LOWORD ((DWORD) (gintptr) _gdk_input_locale)))
 527     {
 528     case LANG_HEBREW:
 529     case LANG_ARABIC:
 530 #ifdef LANG_URDU
 531     case LANG_URDU:
 532 #endif
 533     case LANG_FARSI:
 534       /* Others? */
 535       return PANGO_DIRECTION_RTL;
 536
 537     default:
 538       return PANGO_DIRECTION_LTR;
 539     }
 540 }
 541
 542 static gboolean
 543 gdk_win32_keymap_have_bidi_layouts (GdkKeymap *keymap)
 544 {
 545   /* Should we check if the kayboard layouts switchable at the moment
 546    * cover both directionalities? What does the doc comment in
 547    * ../x11/gdkkeys-x11.c exactly mean?
 548    */
 549   return FALSE;
 550 }
 551
 552 static gboolean
 553 gdk_win32_keymap_get_caps_lock_state (GdkKeymap *keymap)
 554 {
 555   return ((GetKeyState (VK_CAPITAL) & 1) != 0);
 556 }
 557
 558 static gboolean
 559 gdk_win32_keymap_get_num_lock_state (GdkKeymap *keymap)
 560 {
 561   return ((GetKeyState (VK_NUMLOCK) & 1) != 0);
 562 }
 563
 564 static gboolean
 565 gdk_win32_keymap_get_entries_for_keyval (GdkKeymap     *keymap,
 566                                    guint          keyval,
 567                                    GdkKeymapKey **keys,
 568                                    gint          *n_keys)
 569 {
 570   GArray *retval;
 571
 572   g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), FALSE);
 573   g_return_val_if_fail (keys != NULL, FALSE);
 574   g_return_val_if_fail (n_keys != NULL, FALSE);
 575   g_return_val_if_fail (keyval != 0, FALSE);
 576
 577   retval = g_array_new (FALSE, FALSE, sizeof (GdkKeymapKey));
 578
 579   /* Accept only the default keymap */
 580   if (keymap == NULL || keymap == gdk_keymap_get_default ())
 581     {
 582       gint vk;
 583
 584       update_keymap ();
 585
 586       for (vk = 0; vk < 256; vk++)
 587         {
 588           gint i;
 589
 590           for (i = 0; i < 4; i++)
 591             {
 592               if (keysym_tab[vk*4+i] == keyval)
 593                 {
 594                   GdkKeymapKey key;
 595
 596                   key.keycode = vk;
 597
 598                   /* 2 levels (normal, shift), two groups (normal, AltGr) */
 599                   key.group = i / 2;
 600                   key.level = i % 2;
 601
 602                   g_array_append_val (retval, key);
 603                 }
 604             }
 605         }
 606     }
 607
 608 #ifdef G_ENABLE_DEBUG
 609   if (_gdk_debug_flags & GDK_DEBUG_EVENTS)
 610     {
 611       gint i;
 612
 613       g_print ("gdk_keymap_get_entries_for_keyval: %#.04x (%s):",
 614                keyval, gdk_keyval_name (keyval));
 615       for (i = 0; i < retval->len; i++)
 616         {
 617           GdkKeymapKey *entry = (GdkKeymapKey *) retval->data + i;
 618           g_print ("  %#.02x %d %d", entry->keycode, entry->group, entry->level);
 619         }
 620       g_print ("\n");
 621     }
 622 #endif
 623
 624   if (retval->len > 0)
 625     {
 626       *keys = (GdkKeymapKey*) retval->data;
 627       *n_keys = retval->len;
 628     }
 629   else
 630     {
 631       *keys = NULL;
 632       *n_keys = 0;
 633     }
 634
 635   g_array_free (retval, retval->len > 0 ? FALSE : TRUE);
 636
 637   return *n_keys > 0;
 638 }
 639
 640 static gboolean
 641 gdk_win32_keymap_get_entries_for_keycode (GdkKeymap     *keymap,
 642                                     guint          hardware_keycode,
 643                                     GdkKeymapKey **keys,
 644                                     guint        **keyvals,
 645                                     gint          *n_entries)
 646 {
 647   GArray *key_array;
 648   GArray *keyval_array;
 649
 650   g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), FALSE);
 651   g_return_val_if_fail (n_entries != NULL, FALSE);
 652
 653   if (hardware_keycode <= 0 ||
 654       hardware_keycode >= 256)
 655     {
 656       if (keys)
 657         *keys = NULL;
 658       if (keyvals)
 659         *keyvals = NULL;
 660
 661       *n_entries = 0;
 662       return FALSE;
 663     }
 664
 665   if (keys)
 666     key_array = g_array_new (FALSE, FALSE, sizeof (GdkKeymapKey));
 667   else
 668     key_array = NULL;
 669
 670   if (keyvals)
 671     keyval_array = g_array_new (FALSE, FALSE, sizeof (guint));
 672   else
 673     keyval_array = NULL;
 674
 675   /* Accept only the default keymap */
 676   if (keymap == NULL || keymap == gdk_keymap_get_default ())
 677     {
 678       gint i;
 679
 680       update_keymap ();
 681
 682       for (i = 0; i < 4; i++)
 683         {
 684           if (key_array)
 685             {
 686               GdkKeymapKey key;
 687
 688               key.keycode = hardware_keycode;
 689
 690               key.group = i / 2;
 691               key.level = i % 2;
 692
 693               g_array_append_val (key_array, key);
 694             }
 695
 696           if (keyval_array)
 697             g_array_append_val (keyval_array, keysym_tab[hardware_keycode*4+i]);
 698         }
 699     }
 700
 701   if ((key_array && key_array->len > 0) ||
 702       (keyval_array && keyval_array->len > 0))
 703     {
 704       if (keys)
 705         *keys = (GdkKeymapKey*) key_array->data;
 706
 707       if (keyvals)
 708         *keyvals = (guint*) keyval_array->data;
 709
 710       if (key_array)
 711         *n_entries = key_array->len;
 712       else
 713         *n_entries = keyval_array->len;
 714     }
 715   else
 716     {
 717       if (keys)
 718         *keys = NULL;
 719
 720       if (keyvals)
 721         *keyvals = NULL;
 722
 723       *n_entries = 0;
 724     }
 725
 726   if (key_array)
 727     g_array_free (key_array, key_array->len > 0 ? FALSE : TRUE);
 728   if (keyval_array)
 729     g_array_free (keyval_array, keyval_array->len > 0 ? FALSE : TRUE);
 730
 731   return *n_entries > 0;
 732 }
 733
 734 static guint
 735 gdk_win32_keymap_lookup_key (GdkKeymap          *keymap,
 736                        const GdkKeymapKey *key)
 737 {
 738   guint sym;
 739
 740   g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), 0);
 741   g_return_val_if_fail (key != NULL, 0);
 742   g_return_val_if_fail (key->group < 4, 0);
 743
 744   /* Accept only the default keymap */
 745   if (keymap != NULL && keymap != gdk_keymap_get_default ())
 746     return 0;
 747
 748   update_keymap ();
 749
 750   if (key->keycode >= 256 ||
 751       key->group < 0 || key->group >= 2 ||
 752       key->level < 0 || key->level >= 2)
 753     return 0;
 754
 755   sym = keysym_tab[key->keycode*4 + key->group*2 + key->level];
 756
 757   if (sym == GDK_KEY_VoidSymbol)
 758     return 0;
 759   else
 760     return sym;
 761 }
 762
 763 static gboolean
 764 gdk_win32_keymap_translate_keyboard_state (GdkKeymap       *keymap,
 765                                      guint            hardware_keycode,
 766                                      GdkModifierType  state,
 767                                      gint             group,
 768                                      guint           *keyval,
 769                                      gint            *effective_group,
 770                                      gint            *level,
 771                                      GdkModifierType *consumed_modifiers)
 772 {
 773   guint tmp_keyval;
 774   guint *keyvals;
 775   gint shift_level;
 776   gboolean ignore_shift = FALSE;
 777   gboolean ignore_group = FALSE;
 778
 779   g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), FALSE);
 780   g_return_val_if_fail (group < 4, FALSE);
 781
 782 #if 0
 783   GDK_NOTE (EVENTS, g_print ("gdk_keymap_translate_keyboard_state: keycode=%#x state=%#x group=%d\n",
 784                              hardware_keycode, state, group));
 785 #endif
 786   if (keyval)
 787     *keyval = 0;
 788   if (effective_group)
 789     *effective_group = 0;
 790   if (level)
 791     *level = 0;
 792   if (consumed_modifiers)
 793     *consumed_modifiers = 0;
 794
 795   /* Accept only the default keymap */
 796   if (keymap != NULL && keymap != gdk_keymap_get_default ())
 797     return FALSE;
 798
 799   if (hardware_keycode >= 256)
 800     return FALSE;
 801
 802   if (group < 0 || group >= 2)
 803     return FALSE;
 804
 805   update_keymap ();
 806
 807   keyvals = keysym_tab + hardware_keycode*4;
 808
 809   if ((state & GDK_LOCK_MASK) &&
 810       (state & GDK_SHIFT_MASK) &&
 811       ((gdk_shift_modifiers & GDK_LOCK_MASK) ||
 812        (keyvals[group*2 + 1] == gdk_keyval_to_upper (keyvals[group*2 + 0]))))
 813     /* Shift always disables ShiftLock. Shift disables CapsLock for
 814      * keys with lowercase/uppercase letter pairs.
 815      */
 816     shift_level = 0;
 817   else if (state & gdk_shift_modifiers)
 818     shift_level = 1;
 819   else
 820     shift_level = 0;
 821
 822   /* Drop group and shift if there are no keysymbols on
 823    * the key for those.
 824    */
 825   if (shift_level == 1 &&
 826       keyvals[group*2 + 1] == GDK_KEY_VoidSymbol &&
 827       keyvals[group*2] != GDK_KEY_VoidSymbol)
 828     {
 829       shift_level = 0;
 830       ignore_shift = TRUE;
 831     }
 832
 833   if (group == 1 &&
 834       keyvals[2 + shift_level] == GDK_KEY_VoidSymbol &&
 835       keyvals[0 + shift_level] != GDK_KEY_VoidSymbol)
 836     {
 837       group = 0;
 838       ignore_group = TRUE;
 839     }
 840
 841   if (keyvals[group *2 + shift_level] == GDK_KEY_VoidSymbol &&
 842       keyvals[0 + 0] != GDK_KEY_VoidSymbol)
 843     {
 844       shift_level = 0;
 845       group = 0;
 846       ignore_group = TRUE;
 847       ignore_shift = TRUE;
 848     }
 849
 850   /* See whether the group and shift level actually mattered
 851    * to know what to put in consumed_modifiers
 852    */
 853   if (keyvals[group*2 + 1] == GDK_KEY_VoidSymbol ||
 854       keyvals[group*2 + 0] == keyvals[group*2 + 1])
 855     ignore_shift = TRUE;
 856
 857   if (keyvals[2 + shift_level] == GDK_KEY_VoidSymbol ||
 858       keyvals[0 + shift_level] == keyvals[2 + shift_level])
 859     ignore_group = TRUE;
 860
 861   tmp_keyval = keyvals[group*2 + shift_level];
 862
 863   /* If a true CapsLock is toggled, and Shift is not down,
 864    * and the shifted keysym is the uppercase of the unshifted,
 865    * use it.
 866    */
 867   if (!(gdk_shift_modifiers & GDK_LOCK_MASK) &&
 868       !(state & GDK_SHIFT_MASK) &&
 869       (state & GDK_LOCK_MASK))
 870     {
 871       guint upper = gdk_keyval_to_upper (tmp_keyval);
 872       if (upper == keyvals[group*2 + 1])
 873         tmp_keyval = upper;
 874     }
 875
 876   if (keyval)
 877     *keyval = tmp_keyval;
 878
 879   if (effective_group)
 880     *effective_group = group;
 881
 882   if (level)
 883     *level = shift_level;
 884
 885   if (consumed_modifiers)
 886     {
 887       *consumed_modifiers =
 888         (ignore_group ? 0 : GDK_MOD2_MASK) |
 889         (ignore_shift ? 0 : (GDK_SHIFT_MASK|GDK_LOCK_MASK));
 890     }
 891
 892 #if 0
 893   GDK_NOTE (EVENTS, g_print ("... group=%d level=%d cmods=%#x keyval=%s\n",
 894                              group, shift_level, tmp_modifiers, gdk_keyval_name (tmp_keyval)));
 895 #endif
 896
 897   return tmp_keyval != GDK_KEY_VoidSymbol;
 898 }
 899
 900 static void
 901 gdk_win32_keymap_add_virtual_modifiers (GdkKeymap       *keymap,
 902                                   GdkModifierType *state)
 903 {
 904 }
 905
 906 static gboolean
 907 gdk_win32_keymap_map_virtual_modifiers (GdkKeymap       *keymap,
 908                                   GdkModifierType *state)
 909 {
 910   /* FIXME: Is this the right thing to do? */
 911   return TRUE;
 912 }
 913
 914 static void
 915 gdk_win32_keymap_finalize (GObject *object)
 916 {
 917 }
 918
 919 static void
 920 gdk_win32_keymap_class_init (GdkWin32KeymapClass *klass)
 921 {
 922   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 923   GdkKeymapClass *keymap_class = GDK_KEYMAP_CLASS (klass);
 924
 925   object_class->finalize = gdk_win32_keymap_finalize;
 926
 927   keymap_class->get_direction = gdk_win32_keymap_get_direction;
 928   keymap_class->have_bidi_layouts = gdk_win32_keymap_have_bidi_layouts;
 929   keymap_class->get_caps_lock_state = gdk_win32_keymap_get_caps_lock_state;
 930   keymap_class->get_num_lock_state = gdk_win32_keymap_get_num_lock_state;
 931   keymap_class->get_entries_for_keyval = gdk_win32_keymap_get_entries_for_keyval;
 932   keymap_class->get_entries_for_keycode = gdk_win32_keymap_get_entries_for_keycode;
 933   keymap_class->lookup_key = gdk_win32_keymap_lookup_key;
 934   keymap_class->translate_keyboard_state = gdk_win32_keymap_translate_keyboard_state;
 935   keymap_class->add_virtual_modifiers = gdk_win32_keymap_add_virtual_modifiers;
 936   keymap_class->map_virtual_modifiers = gdk_win32_keymap_map_virtual_modifiers;
 937 }