/* GDK - The GIMP Drawing Kit

 * Copyright (C) 2000 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.

 */

#include "config.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <limits.h>

#include <errno.h>

#include "gdk.h"

#include "gdkx.h"

#include "gdkprivate-x11.h"

#include "gdkinternals.h"

#include "gdkdisplay-x11.h"

#include "gdkkeysyms.h"

#include "gdkalias.h"

#ifdef HAVE_XKB

#include <X11/XKBlib.h>

/* OSF-4.0 is apparently missing this macro

 */

#  ifndef XkbKeySymEntry

#    define XkbKeySymEntry(d,k,sl,g) \

 	(XkbKeySym(d,k,((XkbKeyGroupsWidth(d,k)*(g))+(sl))))

#  endif

#endif /* HAVE_XKB */

typedef struct _GdkKeymapX11   GdkKeymapX11;

typedef struct _GdkKeymapClass GdkKeymapX11Class;

#define GDK_TYPE_KEYMAP_X11          (gdk_keymap_x11_get_type ())

#define GDK_KEYMAP_X11(object)       (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_KEYMAP_X11, GdkKeymapX11))

#define GDK_IS_KEYMAP_X11(object)    (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_KEYMAP_X11))

typedef struct _DirectionCacheEntry DirectionCacheEntry;

struct _DirectionCacheEntry

{

  guint serial;

  Atom group_atom;

  PangoDirection direction;

};

struct _GdkKeymapX11

{

  GdkKeymap     parent_instance;

  gint min_keycode;

  gint max_keycode;

  KeySym* keymap;

  gint keysyms_per_keycode;

  XModifierKeymap* mod_keymap;

  guint lock_keysym;

  GdkModifierType group_switch_mask;

  GdkModifierType num_lock_mask;

  GdkModifierType modmap[8];

  PangoDirection current_direction;

  guint sun_keypad      : 1;

  guint have_direction  : 1;

  guint caps_lock_state : 1;

  guint current_serial;

#ifdef HAVE_XKB

  XkbDescPtr xkb_desc;

  /* We cache the directions */

  Atom current_group_atom;

  guint current_cache_serial;

  /* A cache of size four should be more than enough, people usually

   * have two groups around, and the xkb limit is four.  It still

   * works correct for more than four groups.  It's just the

   * cache.

   */

  DirectionCacheEntry group_direction_cache[4];

#endif

};

#define KEYMAP_USE_XKB(keymap) GDK_DISPLAY_X11 ((keymap)->display)->use_xkb

#define KEYMAP_XDISPLAY(keymap) GDK_DISPLAY_XDISPLAY ((keymap)->display)

static GType gdk_keymap_x11_get_type   (void);

static void  gdk_keymap_x11_class_init (GdkKeymapX11Class *klass);

static void  gdk_keymap_x11_init       (GdkKeymapX11      *keymap);

static void  gdk_keymap_x11_finalize   (GObject           *object);

static GdkKeymapClass *parent_class = NULL;

static GType

gdk_keymap_x11_get_type (void)

{

  static GType object_type = 0;

  if (!object_type)

    {

      const GTypeInfo object_info =

	{

	  sizeof (GdkKeymapClass),

	  (GBaseInitFunc) NULL,

	  (GBaseFinalizeFunc) NULL,

	  (GClassInitFunc) gdk_keymap_x11_class_init,

	  NULL,           /* class_finalize */

	  NULL,           /* class_data */

	  sizeof (GdkKeymapX11),

	  0,              /* n_preallocs */

	  (GInstanceInitFunc) gdk_keymap_x11_init,

	};

      object_type = g_type_register_static (GDK_TYPE_KEYMAP,

                                            g_intern_static_string ("GdkKeymapX11"),

                                            &object_info, 0);

    }

  return object_type;

}

static void

gdk_keymap_x11_class_init (GdkKeymapX11Class *klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  parent_class = g_type_class_peek_parent (klass);

  object_class->finalize = gdk_keymap_x11_finalize;

}

static void

gdk_keymap_x11_init (GdkKeymapX11 *keymap)

{

  keymap->min_keycode = 0;

  keymap->max_keycode = 0;

  keymap->keymap = NULL;

  keymap->keysyms_per_keycode = 0;

  keymap->mod_keymap = NULL;

  keymap->num_lock_mask = 0;

  keymap->sun_keypad = FALSE;

  keymap->group_switch_mask = 0;

  keymap->lock_keysym = GDK_Caps_Lock;

  keymap->have_direction = FALSE;

  keymap->current_serial = 0;

#ifdef HAVE_XKB

  keymap->xkb_desc = NULL;

  keymap->current_group_atom = 0;

  keymap->current_cache_serial = 0;

#endif

}

static void

gdk_keymap_x11_finalize (GObject *object)

{

  GdkKeymapX11 *keymap_x11 = GDK_KEYMAP_X11 (object);

  if (keymap_x11->keymap)

    XFree (keymap_x11->keymap);

  if (keymap_x11->mod_keymap)

    XFreeModifiermap (keymap_x11->mod_keymap);

#ifdef HAVE_XKB

  if (keymap_x11->xkb_desc)

    XkbFreeKeyboard (keymap_x11->xkb_desc, XkbAllComponentsMask, True);

#endif

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static inline void

update_keyrange (GdkKeymapX11 *keymap_x11)

{

  if (keymap_x11->max_keycode == 0)

    XDisplayKeycodes (KEYMAP_XDISPLAY (GDK_KEYMAP (keymap_x11)),

		      &keymap_x11->min_keycode, &keymap_x11->max_keycode);

}

#ifdef HAVE_XKB

static void

update_modmap (Display      *display,

	       GdkKeymapX11 *keymap_x11)

{

  static struct {

    const gchar *name;

    Atom atom;

    GdkModifierType mask;

  } vmods[] = {

    { "Meta", 0, GDK_META_MASK },

    { "Super", 0, GDK_SUPER_MASK },

    { "Hyper", 0, GDK_HYPER_MASK },

    { NULL, 0, 0 }

  };

  gint i, j, k;

  if (!vmods[0].atom)

    for (i = 0; vmods[i].name; i++)

      vmods[i].atom = XInternAtom (display, vmods[i].name, FALSE);

  for (i = 0; i < 8; i++)

    keymap_x11->modmap[i] = 1 << i;

  for (i = 0; i < XkbNumVirtualMods; i++)

    {

      for (j = 0; vmods[j].atom; j++)

	{

	  if (keymap_x11->xkb_desc->names->vmods[i] == vmods[j].atom)

	    {

	      for (k = 0; k < 8; k++)

		{

		  if (keymap_x11->xkb_desc->server->vmods[i] & (1 << k))

		    keymap_x11->modmap[k] |= vmods[j].mask;

		}

	    }

	}

    }

}

static XkbDescPtr

get_xkb (GdkKeymapX11 *keymap_x11)

{

  GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (GDK_KEYMAP (keymap_x11)->display);

  Display *xdisplay = display_x11->xdisplay;

  update_keyrange (keymap_x11);

  if (keymap_x11->xkb_desc == NULL)

    {

      keymap_x11->xkb_desc = XkbGetMap (xdisplay, XkbKeySymsMask | XkbKeyTypesMask | XkbModifierMapMask | XkbVirtualModsMask, XkbUseCoreKbd);

      if (keymap_x11->xkb_desc == NULL)

        {

	  g_error ("Failed to get keymap");

          return NULL;

        }

      XkbGetNames (xdisplay, XkbGroupNamesMask | XkbVirtualModNamesMask, keymap_x11->xkb_desc);

      update_modmap (xdisplay, keymap_x11);

    }

  else if (keymap_x11->current_serial != display_x11->keymap_serial)

    {

      XkbGetUpdatedMap (xdisplay, XkbKeySymsMask | XkbKeyTypesMask | XkbModifierMapMask | XkbVirtualModsMask,

			keymap_x11->xkb_desc);

      XkbGetNames (xdisplay, XkbGroupNamesMask | XkbVirtualModNamesMask, keymap_x11->xkb_desc);

      update_modmap (xdisplay, keymap_x11);

    }

  keymap_x11->current_serial = display_x11->keymap_serial;

  return keymap_x11->xkb_desc;

}

#endif /* HAVE_XKB */

/* Whether we were able to turn on detectable-autorepeat using

 * XkbSetDetectableAutorepeat. If FALSE, we'll fall back

 * to checking the next event with XPending().

 */

/** 

 * gdk_keymap_get_for_display:

 * @display: the #GdkDisplay.

 * @returns: the #GdkKeymap attached to @display.

 *

 * Returns the #GdkKeymap attached to @display.

 *

 * Since: 2.2

 **/

GdkKeymap*

gdk_keymap_get_for_display (GdkDisplay *display)

{

  GdkDisplayX11 *display_x11;

  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);

  display_x11 = GDK_DISPLAY_X11 (display);

  if (!display_x11->keymap)

    display_x11->keymap = g_object_new (gdk_keymap_x11_get_type (), NULL);

  display_x11->keymap->display = display;

  return display_x11->keymap;

}

/* Find the index of the group/level pair within the keysyms for a key.

 * We round up the number of keysyms per keycode to the next even number,

 * otherwise we lose a whole group of keys

 */

#define KEYSYM_INDEX(keymap_impl, group, level) \

  (2 * ((group) % (gint)((keymap_impl->keysyms_per_keycode + 1) / 2)) + (level))

#define KEYSYM_IS_KEYPAD(s) (((s) >= 0xff80 && (s) <= 0xffbd) || \

                             ((s) >= 0x11000000 && (s) <= 0x1100ffff))

static gint

get_symbol (const KeySym *syms,

	    GdkKeymapX11 *keymap_x11,

	    gint group,

	    gint level)

{

  gint index;

  index = KEYSYM_INDEX(keymap_x11, group, level);

  if (index >= keymap_x11->keysyms_per_keycode)

      return NoSymbol;

  return syms[index];

}

static void

set_symbol (KeySym       *syms, 

	    GdkKeymapX11 *keymap_x11, 

	    gint          group, 

	    gint          level, 

	    KeySym        sym)

{

  gint index;

  index = KEYSYM_INDEX(keymap_x11, group, level);

  if (index >= keymap_x11->keysyms_per_keycode)

      return;

  syms[index] = sym;

}

static void

update_keymaps (GdkKeymapX11 *keymap_x11)

{

  GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (GDK_KEYMAP (keymap_x11)->display);

  Display *xdisplay = display_x11->xdisplay;

#ifdef HAVE_XKB

  g_assert (!KEYMAP_USE_XKB (GDK_KEYMAP (keymap_x11)));

#endif

  if (keymap_x11->keymap == NULL ||

      keymap_x11->current_serial != display_x11->keymap_serial)

    {

      gint i;

      gint map_size;

      gint keycode;

      keymap_x11->current_serial = display_x11->keymap_serial;

      update_keyrange (keymap_x11);

      if (keymap_x11->keymap)

        XFree (keymap_x11->keymap);

      if (keymap_x11->mod_keymap)

        XFreeModifiermap (keymap_x11->mod_keymap);

      keymap_x11->keymap = XGetKeyboardMapping (xdisplay, keymap_x11->min_keycode,

						keymap_x11->max_keycode - keymap_x11->min_keycode + 1,

						&keymap_x11->keysyms_per_keycode);

      /* GDK_ISO_Left_Tab, as usually configured through XKB, really messes

       * up the whole idea of "consumed modifiers" because shift is consumed.

       * However, <shift>Tab is not usually GDK_ISO_Left_Tab without XKB,

       * we we fudge the map here.

       */

      keycode = keymap_x11->min_keycode;

      while (keycode <= keymap_x11->max_keycode)

        {

          KeySym *syms = keymap_x11->keymap + (keycode - keymap_x11->min_keycode) * keymap_x11->keysyms_per_keycode;

	  /* Check both groups */

	  for (i = 0 ; i < 2 ; i++)

	    {

	      if (get_symbol (syms, keymap_x11, i, 0) == GDK_Tab)

		set_symbol (syms, keymap_x11, i, 1, GDK_ISO_Left_Tab);

	    }

          /*

           * If there is one keysym and the key symbol has upper and lower

           * case variants fudge the keymap

           */

          if (get_symbol (syms, keymap_x11, 0, 1) == 0)

            {

              guint lower;

              guint upper;

              gdk_keyval_convert_case (get_symbol (syms, keymap_x11, 0, 0), &lower, &upper);

              if (lower != upper)

                {

		  set_symbol (syms, keymap_x11, 0, 0, lower);

		  set_symbol (syms, keymap_x11, 0, 1, upper);

                }

            }

          ++keycode;

        }

      keymap_x11->mod_keymap = XGetModifierMapping (xdisplay);

      keymap_x11->lock_keysym = GDK_VoidSymbol;

      keymap_x11->group_switch_mask = 0;

      keymap_x11->num_lock_mask = 0;

      for (i = 0; i < 8; i++)

	keymap_x11->modmap[i] = 1 << i;

      /* There are 8 sets of modifiers, with each set containing

       * max_keypermod keycodes.

       */

      map_size = 8 * keymap_x11->mod_keymap->max_keypermod;

      for (i = 0; i < map_size; i++)

        {

          /* Get the key code at this point in the map. */

          gint keycode = keymap_x11->mod_keymap->modifiermap[i];

          gint j;

          KeySym *syms;

	  guint mask;

          /* Ignore invalid keycodes. */

          if (keycode < keymap_x11->min_keycode ||

              keycode > keymap_x11->max_keycode)

            continue;

          syms = keymap_x11->keymap + (keycode - keymap_x11->min_keycode) * keymap_x11->keysyms_per_keycode;

	  mask = 0;

	  for (j = 0; j < keymap_x11->keysyms_per_keycode; j++)

	    {

	      if (syms[j] == GDK_Meta_L ||

		  syms[j] == GDK_Meta_R)

		mask |= GDK_META_MASK;

	      else if (syms[j] == GDK_Hyper_L ||

		       syms[j] == GDK_Hyper_R)

		mask |= GDK_HYPER_MASK;

	      else if (syms[j] == GDK_Super_L ||

		       syms[j] == GDK_Super_R)

		mask |= GDK_SUPER_MASK;

	    }

	  keymap_x11->modmap[i/keymap_x11->mod_keymap->max_keypermod] |= mask;

          /* The fourth modifier, GDK_MOD1_MASK is 1 << 3.

	   * Each group of max_keypermod entries refers to the same modifier.

           */

          mask = 1 << (i / keymap_x11->mod_keymap->max_keypermod);

          switch (mask)

            {

            case GDK_LOCK_MASK:

              /* Get the Lock keysym.  If any keysym bound to the Lock modifier

               * is Caps_Lock, we will interpret the modifier as Caps_Lock;

               * otherwise, if any is bound to Shift_Lock, we will interpret

               * the modifier as Shift_Lock. Otherwise, the lock modifier

	       * has no effect.

               */

	      for (j = 0; j < keymap_x11->keysyms_per_keycode; j++)

		{

		  if (syms[j] == GDK_Caps_Lock)

		    keymap_x11->lock_keysym = GDK_Caps_Lock;

		  else if (syms[j] == GDK_Shift_Lock &&

			   keymap_x11->lock_keysym == GDK_VoidSymbol)

		    keymap_x11->lock_keysym = GDK_Shift_Lock;

		}

              break;

            case GDK_CONTROL_MASK:

            case GDK_SHIFT_MASK:

            case GDK_MOD1_MASK:

              /* Some keyboard maps are known to map Mode_Switch as an

               * extra Mod1 key. In circumstances like that, it won't be

               * used to switch groups.

               */

              break;

            default:

              /* Find the Mode_Switch and Num_Lock modifiers. */

              for (j = 0; j < keymap_x11->keysyms_per_keycode; j++)

                {

                  if (syms[j] == GDK_Mode_switch)

                    {

                      /* This modifier swaps groups */

                      keymap_x11->group_switch_mask |= mask;

                    }

                  else if (syms[j] == GDK_Num_Lock)

                    {

                      /* This modifier is used for Num_Lock */

                      keymap_x11->num_lock_mask |= mask;

                    }

                }

              break;

            }

        }

      /* Hack: The Sun X server puts the keysym to use when the Num Lock

       * modifier is on in the third element of the keysym array, instead

       * of the second.

       */

      if ((strcmp (ServerVendor (xdisplay), "Sun Microsystems, Inc.") == 0) &&

          (keymap_x11->keysyms_per_keycode > 2))

        keymap_x11->sun_keypad = TRUE;

      else

        keymap_x11->sun_keypad = FALSE;

    }

}

static const KeySym*

get_keymap (GdkKeymapX11 *keymap_x11)

{

  update_keymaps (keymap_x11);

  return keymap_x11->keymap;

}

#define GET_EFFECTIVE_KEYMAP(keymap) get_effective_keymap ((keymap), G_STRFUNC)

static GdkKeymap *

get_effective_keymap (GdkKeymap  *keymap,

		      const char *function)

{

  if (!keymap)

    {

      GDK_NOTE (MULTIHEAD,

		g_message ("reverting to default display keymap in %s",

			   function));

      return gdk_keymap_get_default ();

    }

  return keymap;

}

#if HAVE_XKB

static PangoDirection

get_direction (XkbDescRec *xkb, 

	       gint group)

{

  gint code;

  gint rtl_minus_ltr = 0; /* total number of RTL keysyms minus LTR ones */

  for (code = xkb->min_key_code; code <= xkb->max_key_code; code++)

    {

      gint level = 0;

      KeySym sym = XkbKeySymEntry (xkb, code, level, group);

      PangoDirection dir = pango_unichar_direction (gdk_keyval_to_unicode (sym));

      switch (dir)

	{

	case PANGO_DIRECTION_RTL:

	  rtl_minus_ltr++;

	  break;

	case PANGO_DIRECTION_LTR:

	  rtl_minus_ltr--;

	  break;

	default:

	  break;

	}

    }

  if (rtl_minus_ltr > 0)

    return PANGO_DIRECTION_RTL;

  else

    return PANGO_DIRECTION_LTR;

}

static PangoDirection

get_direction_from_cache (GdkKeymapX11 *keymap_x11,

			  XkbDescPtr xkb,

			  gint group)

{

  Atom group_atom = xkb->names->groups[group];

  gboolean cache_hit = FALSE;

  DirectionCacheEntry *cache = keymap_x11->group_direction_cache;

  PangoDirection direction = PANGO_DIRECTION_NEUTRAL;

  gint i;

  if (keymap_x11->have_direction)

    {

      /* lookup in cache */

      for (i = 0; i < G_N_ELEMENTS (keymap_x11->group_direction_cache); i++)

      {

	if (cache[i].group_atom == group_atom)

	  {

	    cache_hit = TRUE;

	    cache[i].serial = keymap_x11->current_cache_serial++; /* freshen */

	    direction = cache[i].direction;

	    group_atom = cache[i].group_atom;

	    break;

	  }

      }

    }

  else

    {

      /* initialize cache */

      for (i = 0; i < G_N_ELEMENTS (keymap_x11->group_direction_cache); i++)

	{

	  cache[i].group_atom = 0;

	  cache[i].serial = keymap_x11->current_cache_serial;

	}

      keymap_x11->current_cache_serial++;

    }

  /* insert in cache */

  if (!cache_hit)

    {

      gint oldest = 0;

      direction = get_direction (xkb, group);

      /* remove the oldest entry */

      for (i = 0; i < G_N_ELEMENTS (keymap_x11->group_direction_cache); i++)

	{

	  if (cache[i].serial < cache[oldest].serial)

	    oldest = i;

	}

      cache[oldest].group_atom = group_atom;

      cache[oldest].direction = direction;

      cache[oldest].serial = keymap_x11->current_cache_serial++;

    }

  return direction;

}

static int

get_num_groups (GdkKeymap *keymap,

		XkbDescPtr xkb)

{

      Display *display = KEYMAP_XDISPLAY (keymap);

      XkbGetControls(display, XkbSlowKeysMask, xkb);

      XkbGetUpdatedMap (display, XkbKeySymsMask | XkbKeyTypesMask |

			XkbModifierMapMask | XkbVirtualModsMask, xkb);

      return xkb->ctrls->num_groups;

}

static gboolean

update_direction (GdkKeymapX11 *keymap_x11,

		  gint          group)

{

  XkbDescPtr xkb = get_xkb (keymap_x11);

  Atom group_atom;

  gboolean had_direction;

  PangoDirection old_direction;

  had_direction = keymap_x11->have_direction;

  old_direction = keymap_x11->current_direction;

  group_atom = xkb->names->groups[group];

  /* a group change? */

  if (!keymap_x11->have_direction || keymap_x11->current_group_atom != group_atom)

    {

      keymap_x11->current_direction = get_direction_from_cache (keymap_x11, xkb, group);

      keymap_x11->current_group_atom = group_atom;

      keymap_x11->have_direction = TRUE;

    }

  return !had_direction || old_direction != keymap_x11->current_direction;

}

static gboolean

update_lock_state (GdkKeymapX11 *keymap_x11,

                   gint          locked_mods)

{

  gboolean caps_lock_state;

  caps_lock_state = keymap_x11->caps_lock_state;

  keymap_x11->caps_lock_state = (locked_mods & GDK_LOCK_MASK) != 0;

  return caps_lock_state != keymap_x11->caps_lock_state;

}

/* keep this in sync with the XkbSelectEventDetails() call 

 * in gdk_display_open()

 */

void

_gdk_keymap_state_changed (GdkDisplay *display,

			   XEvent     *xevent)

{

  GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);

  XkbEvent *xkb_event = (XkbEvent *)xevent;

  if (display_x11->keymap)

    {

      GdkKeymapX11 *keymap_x11 = GDK_KEYMAP_X11 (display_x11->keymap);

      if (update_direction (keymap_x11, XkbStateGroup (&xkb_event->state)))

	g_signal_emit_by_name (keymap_x11, "direction-changed");      

      if (update_lock_state (keymap_x11, xkb_event->state.locked_mods))

	g_signal_emit_by_name (keymap_x11, "state-changed");      

    }

}

#endif /* HAVE_XKB */

void

_gdk_keymap_keys_changed (GdkDisplay *display)

{

  GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);

  ++display_x11->keymap_serial;

  if (display_x11->keymap)

    g_signal_emit_by_name (display_x11->keymap, "keys_changed", 0);

}

/** 

 * gdk_keymap_get_direction:

 * @keymap: a #GdkKeymap or %NULL to use the default keymap

 *

 * Returns the direction of effective layout of the keymap.

 *

 * Note that passing %NULL for @keymap is deprecated and will stop

 * to work in GTK+ 3.0. Use gdk_keymap_get_for_display() instead.

 *

 * Returns: %PANGO_DIRECTION_LTR or %PANGO_DIRECTION_RTL

 *   if it can determine the direction. %PANGO_DIRECTION_NEUTRAL

 *   otherwise.

 **/

PangoDirection

gdk_keymap_get_direction (GdkKeymap *keymap)

{

  keymap = GET_EFFECTIVE_KEYMAP (keymap);

#if HAVE_XKB

  if (KEYMAP_USE_XKB (keymap))

    {

      GdkKeymapX11 *keymap_x11 = GDK_KEYMAP_X11 (keymap);

      if (!keymap_x11->have_direction)

	{

	  GdkDisplay *display = GDK_KEYMAP (keymap_x11)->display;

	  XkbStateRec state_rec;

	  XkbGetState (GDK_DISPLAY_XDISPLAY (display), XkbUseCoreKbd, 

		       &state_rec);

	  update_direction (keymap_x11, XkbStateGroup (&state_rec));

	}

      return keymap_x11->current_direction;

    }

  else

#endif /* HAVE_XKB */

    return PANGO_DIRECTION_NEUTRAL;

}

/** 

 * gdk_keymap_have_bidi_layouts:

 * @keymap: a #GdkKeymap or %NULL to use the default keymap

 *

 * Determines if keyboard layouts for both right-to-left and left-to-right

 * languages are in use.

 *

 * Note that passing %NULL for @keymap is deprecated and will stop

 * to work in GTK+ 3.0. Use gdk_keymap_get_for_display() instead.

 *

 * Returns: %TRUE if there are layouts in both directions, %FALSE otherwise

 *

 * Since: 2.12

 **/

gboolean

gdk_keymap_have_bidi_layouts (GdkKeymap *keymap)

{

  keymap = GET_EFFECTIVE_KEYMAP (keymap);

#if HAVE_XKB

  if (KEYMAP_USE_XKB (keymap))

    {

      GdkKeymapX11 *keymap_x11 = GDK_KEYMAP_X11 (keymap);

      XkbDescPtr xkb = get_xkb (keymap_x11);

      int num_groups = get_num_groups (keymap, xkb);

      int i;

      gboolean have_ltr_keyboard = FALSE;

      gboolean have_rtl_keyboard = FALSE;

      for (i = 0; i < num_groups; i++)

      {

	if (get_direction_from_cache (keymap_x11, xkb, i) == PANGO_DIRECTION_RTL)

	  have_rtl_keyboard = TRUE;

	else

	  have_ltr_keyboard = TRUE;

      }

      return have_ltr_keyboard && have_rtl_keyboard;

    }

  else

#endif /* HAVE_XKB */

    return FALSE;

}

/**

 * gdk_keymap_get_caps_lock_state:

 * @keymap: a #GdkKeymap

 *

 * Returns whether the Caps Lock modifer is locked. 

 *

 * Returns: %TRUE if Caps Lock is on

 *

 * Since: 2.16

 */

gboolean

gdk_keymap_get_caps_lock_state (GdkKeymap *keymap)

{

  GdkKeymapX11 *keymap_x11;

  keymap = GET_EFFECTIVE_KEYMAP (keymap);

  keymap_x11 = GDK_KEYMAP_X11 (keymap);

  return keymap_x11->caps_lock_state;

}

/**

 * gdk_keymap_get_entries_for_keyval:

 * @keymap: (allow-none): a #GdkKeymap, or %NULL to use the default keymap

 * @keyval: a keyval, such as %GDK_a, %GDK_Up, %GDK_Return, etc.

 * @keys: (out): return location for an array of #GdkKeymapKey

 * @n_keys: (out): return location for number of elements in returned array

 *

 * Obtains a list of keycode/group/level combinations that will

 * generate @keyval. Groups and levels are two kinds of keyboard mode;

 * in general, the level determines whether the top or bottom symbol

 * on a key is used, and the group determines whether the left or

 * right symbol is used. On US keyboards, the shift key changes the

 * keyboard level, and there are no groups. A group switch key might

 * convert a keyboard between Hebrew to English modes, for example.

 * #GdkEventKey contains a %group field that indicates the active

 * keyboard group. The level is computed from the modifier mask.

 * The returned array should be freed

 * with g_free().

 *

 * Note that passing %NULL for @keymap is deprecated and will stop

 * to work in GTK+ 3.0. Use gdk_keymap_get_for_display() instead.

 *

 * Return value: %TRUE if keys were found and returned

 **/

gboolean

gdk_keymap_get_entries_for_keyval (GdkKeymap     *keymap,

                                   guint          keyval,

                                   GdkKeymapKey **keys,

                                   gint          *n_keys)

{

  GArray *retval;

  GdkKeymapX11 *keymap_x11;

  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);

  keymap = GET_EFFECTIVE_KEYMAP (keymap);

  keymap_x11 = GDK_KEYMAP_X11 (keymap);