* the next call to ToAsciiEx() with a different		       * key would try to combine with the dead key.		       */		      reset_after_dead (key_state);		      /* Use dead keysyms instead of "undead" ones */		      handle_dead (keysym, ksymp);		    }		  else if (k == 0)		    {		      /* Seems to be necessary to "reset" the keyboard layout		       * in this case, too. Otherwise problems on NT4.		       */		      reset_after_dead (key_state);		    }		  else		    {#if 0		      GDK_NOTE (EVENTS,				g_print ("%s returns %d "					 "for vk:%02x, sc:%02x%s%s\n",					 (G_WIN32_HAVE_WIDECHAR_API () ?					  "ToUnicodeEx" : "ToAsciiEx"),					 k, vk, scancode,					 (shift&0x1 ? " shift" : ""),					 (shift&0x2 ? " altgr" : "")));#endif		    }		}	      if (*ksymp == 0)		*ksymp = GDK_VoidSymbol;	    }	  key_state[vk] = 0;	  /* Check if keyboard has an AltGr key by checking if	   * the mapping with Control+Alt is different.	   */	  if (!_gdk_keyboard_has_altgr)	    if ((keysym_tab[vk*4 + 2] != GDK_VoidSymbol &&		 keysym_tab[vk*4] != keysym_tab[vk*4 + 2]) ||		(keysym_tab[vk*4 + 3] != GDK_VoidSymbol &&		 keysym_tab[vk*4 + 1] != keysym_tab[vk*4 + 3]))	      _gdk_keyboard_has_altgr = TRUE;	  	  if (!capslock_tested)	    {	      /* Can we use this virtual key to determine the CapsLock	       * key behaviour: CapsLock or ShiftLock? If it generates	       * keysyms for printable characters and has a shifted	       * keysym that isn't just the upperacase of the	       * unshifted keysym, check the behaviour of VK_CAPITAL.	       */	      if (g_unichar_isgraph (gdk_keyval_to_unicode (keysym_tab[vk*4 + 0])) &&		  keysym_tab[vk*4 + 1] != keysym_tab[vk*4 + 0] &&		  g_unichar_isgraph (gdk_keyval_to_unicode (keysym_tab[vk*4 + 1])) &&		  keysym_tab[vk*4 + 1] != gdk_keyval_to_upper (keysym_tab[vk*4 + 0]))		{		  guchar chars[2];		  		  capslock_tested = TRUE;		  		  key_state[VK_SHIFT] = 0;		  key_state[VK_CONTROL] = key_state[VK_MENU] = 0;		  key_state[VK_CAPITAL] = 1;		  if (ToAsciiEx (vk, scancode, key_state,				 (LPWORD) chars, 0, _gdk_input_locale) == 1)		    {		      if (chars[0] >= GDK_space &&			  chars[0] <= GDK_asciitilde &&			  chars[0] == keysym_tab[vk*4 + 1])			{			  /* CapsLock acts as ShiftLock */			  gdk_shift_modifiers |= GDK_LOCK_MASK;			}		    }		  key_state[VK_CAPITAL] = 0;		}    	    }	}    }  GDK_NOTE (EVENTS, print_keysym_tab ());} GdkKeymap*gdk_keymap_get_for_display (GdkDisplay *display){  g_return_val_if_fail (display == gdk_display_get_default (), NULL);  if (default_keymap == NULL)    default_keymap = g_object_new (gdk_keymap_get_type (), NULL);  return default_keymap;}PangoDirectiongdk_keymap_get_direction (GdkKeymap *keymap){  update_keymap ();  switch (PRIMARYLANGID (LOWORD ((DWORD) _gdk_input_locale)))    {    case LANG_HEBREW:    case LANG_ARABIC:#ifdef LANG_URDU    case LANG_URDU:#endif    case LANG_FARSI:      /* Others? */      return PANGO_DIRECTION_RTL;    default:      return PANGO_DIRECTION_LTR;    }}gbooleangdk_keymap_get_entries_for_keyval (GdkKeymap     *keymap,                                   guint          keyval,                                   GdkKeymapKey **keys,                                   gint          *n_keys){  GArray *retval;  g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), FALSE);  g_return_val_if_fail (keys != NULL, FALSE);  g_return_val_if_fail (n_keys != NULL, FALSE);  g_return_val_if_fail (keyval != 0, FALSE);    retval = g_array_new (FALSE, FALSE, sizeof (GdkKeymapKey));  /* Accept only the default keymap */  if (keymap == NULL || keymap == gdk_keymap_get_default ())    {      gint vk;            update_keymap ();      for (vk = 0; vk < 256; vk++)	{	  gint i;	  for (i = 0; i < 4; i++)	    {	      if (keysym_tab[vk*4+i] == keyval)		{		  GdkKeymapKey key;		  		  key.keycode = vk;		  		  /* 2 levels (normal, shift), two groups (normal, AltGr) */		  key.group = i / 2;		  key.level = i % 2;		  		  g_array_append_val (retval, key);		}	    }	}    }#ifdef G_ENABLE_DEBUG  if (_gdk_debug_flags & GDK_DEBUG_EVENTS)    {      gint i;      g_print ("gdk_keymap_get_entries_for_keyval: %#.04x (%s):",	       keyval, gdk_keyval_name (keyval));      for (i = 0; i < retval->len; i++)	{	  GdkKeymapKey *entry = (GdkKeymapKey *) retval->data + i;	  g_print ("  %#.02x %d %d", entry->keycode, entry->group, entry->level);	}      g_print ("\n");    }#endif  if (retval->len > 0)    {      *keys = (GdkKeymapKey*) retval->data;      *n_keys = retval->len;    }  else    {      *keys = NULL;      *n_keys = 0;    }        g_array_free (retval, retval->len > 0 ? FALSE : TRUE);  return *n_keys > 0;}gbooleangdk_keymap_get_entries_for_keycode (GdkKeymap     *keymap,                                    guint          hardware_keycode,                                    GdkKeymapKey **keys,                                    guint        **keyvals,                                    gint          *n_entries){  GArray *key_array;  GArray *keyval_array;  g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), FALSE);  g_return_val_if_fail (n_entries != NULL, FALSE);  if (hardware_keycode <= 0 ||      hardware_keycode >= 256)    {      if (keys)        *keys = NULL;      if (keyvals)        *keyvals = NULL;      *n_entries = 0;      return FALSE;    }    if (keys)    key_array = g_array_new (FALSE, FALSE, sizeof (GdkKeymapKey));  else    key_array = NULL;    if (keyvals)    keyval_array = g_array_new (FALSE, FALSE, sizeof (guint));  else    keyval_array = NULL;    /* Accept only the default keymap */  if (keymap == NULL || keymap == gdk_keymap_get_default ())    {      gint i;      update_keymap ();      for (i = 0; i < 4; i++)	{	  if (key_array)            {              GdkKeymapKey key;	                    key.keycode = hardware_keycode;                            key.group = i / 2;              key.level = i % 2;                            g_array_append_val (key_array, key);            }          if (keyval_array)            g_array_append_val (keyval_array, keysym_tab[hardware_keycode*4+i]);	}    }  if ((key_array && key_array->len > 0) ||      (keyval_array && keyval_array->len > 0))    {      if (keys)        *keys = (GdkKeymapKey*) key_array->data;      if (keyvals)        *keyvals = (guint*) keyval_array->data;      if (key_array)        *n_entries = key_array->len;      else        *n_entries = keyval_array->len;    }  else    {      if (keys)        *keys = NULL;      if (keyvals)        *keyvals = NULL;            *n_entries = 0;    }  if (key_array)    g_array_free (key_array, key_array->len > 0 ? FALSE : TRUE);  if (keyval_array)    g_array_free (keyval_array, keyval_array->len > 0 ? FALSE : TRUE);  return *n_entries > 0;}guintgdk_keymap_lookup_key (GdkKeymap          *keymap,                       const GdkKeymapKey *key){  guint sym;  g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), 0);  g_return_val_if_fail (key != NULL, 0);  g_return_val_if_fail (key->group < 4, 0);    /* Accept only the default keymap */  if (keymap != NULL && keymap != gdk_keymap_get_default ())    return 0;  update_keymap ();    if (key->keycode >= 256 ||      key->group < 0 || key->group >= 2 ||      key->level < 0 || key->level >= 2)    return 0;    sym = keysym_tab[key->keycode*4 + key->group*2 + key->level];    if (sym == GDK_VoidSymbol)    return 0;  else    return sym;}gbooleangdk_keymap_translate_keyboard_state (GdkKeymap       *keymap,                                     guint            hardware_keycode,                                     GdkModifierType  state,                                     gint             group,                                     guint           *keyval,                                     gint            *effective_group,                                     gint            *level,                                     GdkModifierType *consumed_modifiers){  guint tmp_keyval;  guint *keyvals;  gint shift_level;  gboolean ignore_shift = FALSE;  gboolean ignore_group = FALSE;        g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), FALSE);  g_return_val_if_fail (group < 4, FALSE);  #if 0  GDK_NOTE (EVENTS, g_print ("gdk_keymap_translate_keyboard_state: keycode=%#x state=%#x group=%d\n",			     hardware_keycode, state, group));#endif  if (keyval)    *keyval = 0;  if (effective_group)    *effective_group = 0;  if (level)    *level = 0;  if (consumed_modifiers)    *consumed_modifiers = 0;  /* Accept only the default keymap */  if (keymap != NULL && keymap != gdk_keymap_get_default ())    return FALSE;  if (hardware_keycode >= 256)    return FALSE;  if (group < 0 || group >= 2)    return FALSE;  update_keymap ();  keyvals = keysym_tab + hardware_keycode*4;  if ((state & GDK_LOCK_MASK) &&      (state & GDK_SHIFT_MASK) &&      ((gdk_shift_modifiers & GDK_LOCK_MASK) ||       (keyvals[group*2 + 1] == gdk_keyval_to_upper (keyvals[group*2 + 0]))))    /* Shift always disables ShiftLock. Shift disables CapsLock for     * keys with lowercase/uppercase letter pairs.     */    shift_level = 0;  else if (state & gdk_shift_modifiers)    shift_level = 1;  else    shift_level = 0;  /* Drop group and shift if there are no keysymbols on   * the key for those.   */  if (shift_level == 1 &&      keyvals[group*2 + 1] == GDK_VoidSymbol &&      keyvals[group*2] != GDK_VoidSymbol)    {      shift_level = 0;      ignore_shift = TRUE;    }  if (group == 1 &&      keyvals[2 + shift_level] == GDK_VoidSymbol &&      keyvals[0 + shift_level] != GDK_VoidSymbol)    {      group = 0;      ignore_group = TRUE;    }  if (keyvals[group *2 + shift_level] == GDK_VoidSymbol &&      keyvals[0 + 0] != GDK_VoidSymbol)    {      shift_level = 0;      group = 0;      ignore_group = TRUE;      ignore_shift = TRUE;    }  /* See whether the group and shift level actually mattered   * to know what to put in consumed_modifiers   */  if (keyvals[group*2 + 1] == GDK_VoidSymbol ||      keyvals[group*2 + 0] == keyvals[group*2 + 1])    ignore_shift = TRUE;  if (keyvals[2 + shift_level] == GDK_VoidSymbol ||      keyvals[0 + shift_level] == keyvals[2 + shift_level])    ignore_group = TRUE;  tmp_keyval = keyvals[group*2 + shift_level];  /* If a true CapsLock is toggled, and Shift is not down,   * and the shifted keysym is the uppercase of the unshifted,   * use it.   */  if (!(gdk_shift_modifiers & GDK_LOCK_MASK) &&      !(state & GDK_SHIFT_MASK) &&      (state & GDK_LOCK_MASK))    {      guint upper = gdk_keyval_to_upper (tmp_keyval);      if (upper == keyvals[group*2 + 1])	tmp_keyval = upper;    }  if (keyval)    *keyval = tmp_keyval;  if (effective_group)    *effective_group = group;  if (level)    *level = shift_level;  if (consumed_modifiers)    {      *consumed_modifiers =	(ignore_group ? 0 : GDK_MOD2_MASK) |	(ignore_shift ? 0 : (GDK_SHIFT_MASK|GDK_LOCK_MASK));    }				#if 0  GDK_NOTE (EVENTS, g_print ("...group=%d level=%d cmods=%#x keyval=%s\n",			     group, shift_level, tmp_modifiers, gdk_keyval_name (tmp_keyval)));#endif  return tmp_keyval != GDK_VoidSymbol;}