/*

 * Copyright (C) 2002-2006 Sergey V. Udaltsov <svu@gnome.org>

 *

 * 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.

 */

#include <time.h>

#include <stdlib.h>

#include <X11/Xatom.h>

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include "xklavier_private.h"

#include "xklavier_private_xkb.h"

#ifdef HAVE_XINPUT

#include <X11/extensions/XI.h>

#include <X11/extensions/XInput.h>

#endif

#ifdef LIBXKBFILE_PRESENT

const gchar **

xkl_xkb_get_groups_names(XklEngine * engine)

{

	return (const gchar **) xkl_engine_backend(engine, XklXkb,

						   group_names);

}

const gchar **

xkl_xkb_get_indicators_names(XklEngine * engine)

{

	return (const gchar **) xkl_engine_backend(engine, XklXkb,

						   indicator_names);

}

gint

xkl_xkb_pause_listen(XklEngine * engine)

{

	XkbSelectEvents(xkl_engine_get_display(engine),

			xkl_engine_backend(engine, XklXkb, device_id),

			XkbAllEventsMask, 0);

	return 0;

}

gint

xkl_xkb_resume_listen(XklEngine * engine)

{

#ifdef HAVE_XINPUT

	int xitype;

	XEventClass xiclass;

#endif

	/* What events we want */

#define XKB_EVT_MASK \

         (XkbStateNotifyMask| \

          XkbNamesNotifyMask| \

          XkbControlsNotifyMask| \

          XkbIndicatorStateNotifyMask| \

          XkbIndicatorMapNotifyMask| \

          XkbNewKeyboardNotifyMask)

	Display *display = xkl_engine_get_display(engine);

	XkbSelectEvents(display,

			xkl_engine_backend(engine, XklXkb, device_id),

			XKB_EVT_MASK, XKB_EVT_MASK);

#define XKB_STATE_EVT_DTL_MASK \

         (XkbGroupStateMask)

	XkbSelectEventDetails(display,

			      xkl_engine_backend(engine, XklXkb,

						 device_id),

			      XkbStateNotify, XKB_STATE_EVT_DTL_MASK,

			      XKB_STATE_EVT_DTL_MASK);

#define XKB_NAMES_EVT_DTL_MASK \

         (XkbGroupNamesMask|XkbIndicatorNamesMask)

	XkbSelectEventDetails(display,

			      xkl_engine_backend(engine, XklXkb,

						 device_id),

			      XkbNamesNotify, XKB_NAMES_EVT_DTL_MASK,

			      XKB_NAMES_EVT_DTL_MASK);

#ifdef HAVE_XINPUT

	if (xkl_engine_priv(engine, features) & XKLF_DEVICE_DISCOVERY) {

		DevicePresence(display, xitype, xiclass);

		XSelectExtensionEvent(display,

				      xkl_engine_priv(engine, root_window),

				      &xiclass, 1);

		xkl_engine_backend(engine, XklXkb, xi_event_type) = xitype;

	} else

		xkl_engine_backend(engine, XklXkb, xi_event_type) = -1;

#endif

	return 0;

}

guint

xkl_xkb_get_max_num_groups(XklEngine * engine)

{

	return xkl_engine_priv(engine,

			       features) & XKLF_MULTIPLE_LAYOUTS_SUPPORTED

	    ? XkbNumKbdGroups : 1;

}

guint

xkl_xkb_get_num_groups(XklEngine * engine)

{

	return xkl_engine_backend(engine, XklXkb,

				  cached_desc)->ctrls->num_groups;

}

#define KBD_MASK \

    ( 0 )

#define CTRLS_MASK \

  ( XkbSlowKeysMask )

#define NAMES_MASK \

  ( XkbGroupNamesMask | XkbIndicatorNamesMask )

void

xkl_xkb_free_all_info(XklEngine * engine)

{

	gint i;

	gchar **pi = xkl_engine_backend(engine, XklXkb, indicator_names);

	XkbDescPtr desc;

	for (i = 0; i < XkbNumIndicators; i++, pi++) {

		/* only free non-empty ones */

		if (*pi && **pi)

			XFree(*pi);

	}

	desc = xkl_engine_backend(engine, XklXkb, cached_desc);

	if (desc != NULL) {

		int i;

		char **group_name =

		    xkl_engine_backend(engine, XklXkb, group_names);

		for (i = desc->ctrls->num_groups; --i >= 0; group_name++)

			if (*group_name) {

				XFree(*group_name);

				*group_name = NULL;

			}

		XkbFreeKeyboard(desc, XkbAllComponentsMask, True);

		xkl_engine_backend(engine, XklXkb, cached_desc) = NULL;

	}

	/* just in case - never actually happens... */

	desc = xkl_engine_backend(engine, XklXkb, actual_desc);

	if (desc != NULL) {

		XkbFreeKeyboard(desc, XkbAllComponentsMask, True);

		xkl_engine_backend(engine, XklXkb, actual_desc) = NULL;

	}

}

static gboolean

xkl_xkb_load_actual_desc(XklEngine * engine)

{

	gboolean rv = FALSE;

	Status status;

	Display *display = xkl_engine_get_display(engine);

	XkbDescPtr desc = XkbGetMap(display, KBD_MASK,

				    xkl_engine_backend(engine, XklXkb,

						       device_id));

	xkl_engine_backend(engine, XklXkb, actual_desc) = desc;

	if (desc != NULL) {

		rv = Success == (status = XkbGetControls(display,

							 CTRLS_MASK,

							 desc)) &&

		    Success == (status = XkbGetNames(display,

						     NAMES_MASK,

						     desc)) &&

		    Success == (status = XkbGetIndicatorMap(display,

							    XkbAllIndicatorsMask,

							    desc));

		if (!rv) {

			xkl_last_error_message =

			    "Could not load controls/names/indicators";

			xkl_debug(0, "%s: %d\n", xkl_last_error_message,

				  status);

			XkbFreeKeyboard(desc, XkbAllComponentsMask, True);

			xkl_engine_backend(engine, XklXkb, actual_desc) =

			    NULL;

		}

	}

	return rv;

}

gboolean

xkl_xkb_if_cached_info_equals_actual(XklEngine * engine)

{

	gint i;

	Atom *pa1, *pa2;

	gboolean rv = FALSE;

	if (xkl_xkb_load_actual_desc(engine)) {

		/* First, compare the number of groups */

		XkbDescPtr cached =

		    xkl_engine_backend(engine, XklXkb, cached_desc);

		XkbDescPtr actual =

		    xkl_engine_backend(engine, XklXkb, actual_desc);

		if (cached->ctrls->num_groups == actual->ctrls->num_groups) {

			/* Then, compare group names, just atoms */

			pa1 = cached->names->groups;

			pa2 = actual->names->groups;

			for (i = cached->ctrls->num_groups; --i >= 0;

			     pa1++, pa2++)

				if (*pa1 != *pa2)

					break;

			/* Then, compare indicator names, just atoms */

			if (i < 0) {

				pa1 = cached->names->indicators;

				pa2 = actual->names->indicators;

				for (i = XkbNumIndicators; --i >= 0;

				     pa1++, pa2++)

					if (*pa1 != *pa2)

						break;

				rv = i < 0;

			}

		}

		/* 

		 * in case of failure, reuse in _XklXkbLoadAllInfo

		 * in case of success - free it

		 */

		if (rv) {

			XkbFreeKeyboard(actual, XkbAllComponentsMask,

					True);

			xkl_engine_backend(engine, XklXkb, actual_desc) =

			    NULL;

		}

	} else {

		xkl_debug(0,

			  "Could not load the XkbDescPtr for comparison\n");

	}

	return rv;

}

/*

 * Load some XKB parameters

 */

gboolean

xkl_xkb_load_all_info(XklEngine * engine)

{

	gint i;

	Atom *pa;

	gchar **group_name;

	gchar **pi = xkl_engine_backend(engine, XklXkb, indicator_names);

	Display *display = xkl_engine_get_display(engine);

	XkbDescPtr actual =

	    xkl_engine_backend(engine, XklXkb, actual_desc);

	XkbDescPtr cached;

	if (actual == NULL)

		if (!xkl_xkb_load_actual_desc(engine)) {

			xkl_last_error_message = "Could not load keyboard";

			return FALSE;

		}

	/* take it from the cache (in most cases LoadAll is called from ResetAll which in turn ...) */

	cached = actual = xkl_engine_backend(engine, XklXkb, actual_desc);

	xkl_engine_backend(engine, XklXkb, cached_desc) =

	    xkl_engine_backend(engine, XklXkb, actual_desc);

	xkl_engine_backend(engine, XklXkb, actual_desc) = NULL;

	/* First, output the number of the groups */

	xkl_debug(200, "found %d groups\n", cached->ctrls->num_groups);

	/* Then, cache (and output) the names of the groups */

	pa = cached->names->groups;

	group_name = xkl_engine_backend(engine, XklXkb, group_names);

	for (i = cached->ctrls->num_groups; --i >= 0; pa++, group_name++) {

		*group_name =

		    XGetAtomName(display,

				 *pa == None ? XInternAtom(display, "-",

							   False) : *pa);

		xkl_debug(200, "Group %d has name [%s]\n", i, *group_name);

	}

	xkl_engine_priv(engine, last_error_code) =

	    XkbGetIndicatorMap(display, XkbAllIndicatorsMask, cached);

	if (xkl_engine_priv(engine, last_error_code) != Success) {

		xkl_last_error_message = "Could not load indicator map";

		return FALSE;

	}

	/* Then, cache (and output) the names of the indicators */

	pa = cached->names->indicators;

	for (i = XkbNumIndicators; --i >= 0; pi++, pa++) {

		Atom a = *pa;

		if (a != None)

			*pi = XGetAtomName(display, a);

		else

			*pi = "";

		xkl_debug(200, "Indicator[%d] is %s\n", i, *pi);

	}

	xkl_debug(200, "Real indicators are %X\n",

		  cached->indicators->phys_indicators);

	g_signal_emit_by_name(engine, "X-config-changed");

	return TRUE;

}

void

xkl_xkb_lock_group(XklEngine * engine, gint group)

{

	Display *display = xkl_engine_get_display(engine);

	xkl_debug(100, "Posted request for change the group to %d ##\n",

		  group);

	XkbLockGroup(display,

		     xkl_engine_backend(engine, XklXkb, device_id), group);

	XSync(display, False);

}

/*

 * Updates current internal state from X state

 */

void

xkl_xkb_get_server_state(XklEngine * engine, XklState * current_state_out)

{

	XkbStateRec state;

	Display *display = xkl_engine_get_display(engine);

	current_state_out->group = 0;

	if (Success ==

	    XkbGetState(display,

			xkl_engine_backend(engine, XklXkb, device_id),

			&state))

		current_state_out->group = state.locked_group;

	if (Success ==

	    XkbGetIndicatorState(display,

				 xkl_engine_backend(engine, XklXkb,

						    device_id),

				 &current_state_out->indicators))

		current_state_out->indicators &=

		    xkl_engine_backend(engine, XklXkb,

				       cached_desc)->indicators->

		    phys_indicators;

	else

		current_state_out->indicators = 0;

}

/*

 * Actually taken from mxkbledpanel, valueChangedProc

 */

gboolean

xkl_xkb_set_indicator(XklEngine * engine, gint indicator_num, gboolean set)

{

	XkbIndicatorMapPtr map;

	Display *display = xkl_engine_get_display(engine);

	XkbDescPtr cached =

	    xkl_engine_backend(engine, XklXkb, cached_desc);

	map = cached->indicators->maps + indicator_num;

	/* The 'flags' field tells whether this indicator is automatic

	 * (XkbIM_NoExplicit - 0x80), explicit (XkbIM_NoAutomatic - 0x40),

	 * or neither (both - 0xC0).

	 *

	 * If NoAutomatic is set, the server ignores the rest of the 

	 * fields in the indicator map (i.e. it disables automatic control 

	 * of the LED).   If NoExplicit is set, the server prevents clients 

	 * from explicitly changing the value of the LED (using the core 

	 * protocol *or* XKB).   If NoAutomatic *and* NoExplicit are set, 

	 * the LED cannot be changed (unless you change the map first).   

	 * If neither NoAutomatic nor NoExplicit are set, the server will 

	 * change the LED according to the indicator map, but clients can 

	 * override that (until the next automatic change) using the core 

	 * protocol or XKB.

	 */

	switch (map->flags & (XkbIM_NoExplicit | XkbIM_NoAutomatic)) {

	case XkbIM_NoExplicit | XkbIM_NoAutomatic:

		{

			/* Can do nothing. Just ignore the indicator */

			return TRUE;

		}

	case XkbIM_NoAutomatic:

		{

			if (cached->names->indicators[indicator_num] !=

			    None)

				XkbSetNamedIndicator(display,

						     xkl_engine_backend

						     (engine, XklXkb,

						      device_id),

						     cached->names->

						     indicators

						     [indicator_num], set,

						     False, NULL);

			else {

				XKeyboardControl xkc;

				xkc.led = indicator_num;

				xkc.led_mode =

				    set ? LedModeOn : LedModeOff;

				XChangeKeyboardControl(display,

						       KBLed | KBLedMode,

						       &xkc);

				XSync(display, False);

			}

			return TRUE;

		}

	case XkbIM_NoExplicit:

		break;

	}

	/* The 'ctrls' field tells what controls tell this indicator to

	 * to turn on:  RepeatKeys (0x1), SlowKeys (0x2), BounceKeys (0x4),

	 *              StickyKeys (0x8), MouseKeys (0x10), AccessXKeys (0x20),

	 *              TimeOut (0x40), Feedback (0x80), ToggleKeys (0x100),

	 *              Overlay1 (0x200), Overlay2 (0x400), GroupsWrap (0x800),

	 *              InternalMods (0x1000), IgnoreLockMods (0x2000),

	 *              PerKeyRepeat (0x3000), or ControlsEnabled (0x4000)

	 */

	if (map->ctrls) {

		gulong which = map->ctrls;

		XkbGetControls(display, XkbAllControlsMask, cached);

		if (set)

			cached->ctrls->enabled_ctrls |= which;

		else

			cached->ctrls->enabled_ctrls &= ~which;

		XkbSetControls(display, which | XkbControlsEnabledMask,

			       cached);

	}

	/* The 'which_groups' field tells when this indicator turns on

	 * for the 'groups' field:  base (0x1), latched (0x2), locked (0x4),

	 * or effective (0x8).

	 */

	if (map->groups) {

		gint i;

		guint group = 1;

		/* Turning on a group indicator is kind of tricky.  For

		 * now, we will just Latch or Lock the first group we find

		 * if that is what this indicator does.  Otherwise, we're

		 * just going to punt and get out of here.

		 */

		if (set) {

			for (i = XkbNumKbdGroups; --i >= 0;)

				if ((1 << i) & map->groups) {

					group = i;

					break;

				}

			if (map->which_groups & (XkbIM_UseLocked |

						 XkbIM_UseEffective)) {

				/* Important: Groups should be ignored here - because they are handled separately! */

				/* XklLockGroup( group ); */

			} else if (map->which_groups & XkbIM_UseLatched)

				XkbLatchGroup(display,

					      xkl_engine_backend(engine,

								 XklXkb,

								 device_id),

					      group);

			else {

				/* Can do nothing. Just ignore the indicator */

				return TRUE;

			}

		} else

			/* Turning off a group indicator will mean that we just

			 * Lock the first group that this indicator doesn't watch.

			 */

		{

			for (i = XkbNumKbdGroups; --i >= 0;)

				if (!((1 << i) & map->groups)) {

					group = i;

					break;

				}

			xkl_xkb_lock_group(engine, group);

		}

	}

	/* The 'which_mods' field tells when this indicator turns on

	 * for the modifiers:  base (0x1), latched (0x2), locked (0x4),

	 *                     or effective (0x8).

	 *

	 * The 'real_mods' field tells whether this turns on when one of 

	 * the real X modifiers is set:  Shift (0x1), Lock (0x2), Control (0x4),

	 * Mod1 (0x8), Mod2 (0x10), Mod3 (0x20), Mod4 (0x40), or Mod5 (0x80). 

	 *

	 * The 'virtual_mods' field tells whether this turns on when one of

	 * the virtual modifiers is set.

	 *

	 * The 'mask' field tells what real X modifiers the virtual_modifiers

	 * map to?

	 */

	if (map->mods.real_mods || map->mods.mask) {

		guint affect, mods;

		affect = (map->mods.real_mods | map->mods.mask);

		mods = set ? affect : 0;

		if (map->which_mods &

		    (XkbIM_UseLocked | XkbIM_UseEffective))

			XkbLockModifiers(display,

					 xkl_engine_backend(engine, XklXkb,

							    device_id),

					 affect, mods);

		else if (map->which_mods & XkbIM_UseLatched)

			XkbLatchModifiers(display,

					  xkl_engine_backend(engine,

							     XklXkb,

							     device_id),

					  affect, mods);

		else {

			return TRUE;

		}

	}

	return TRUE;

}

#endif

gint

xkl_xkb_init(XklEngine * engine)

{

	Display *display = xkl_engine_get_display(engine);

#ifdef LIBXKBFILE_PRESENT

	gint opcode;

	gboolean xkl_xkb_ext_present;

	int xi_opc;

	xkl_engine_priv(engine, backend_id) = "XKB";

	xkl_engine_priv(engine, features) = XKLF_CAN_TOGGLE_INDICATORS |

	    XKLF_CAN_OUTPUT_CONFIG_AS_ASCII |

	    XKLF_CAN_OUTPUT_CONFIG_AS_BINARY;

	xkl_engine_priv(engine, activate_config_rec) =

	    xkl_xkb_activate_config_rec;

	xkl_engine_priv(engine, init_config_registry) =

	    xkl_xkb_init_config_registry;

	xkl_engine_priv(engine, load_config_registry) =

	    xkl_xkb_load_config_registry;

	xkl_engine_priv(engine, write_config_rec_to_file) =

	    xkl_xkb_write_config_rec_to_file;

	xkl_engine_priv(engine, get_groups_names) =

	    xkl_xkb_get_groups_names;

	xkl_engine_priv(engine, get_indicators_names) =

	    xkl_xkb_get_indicators_names;

	xkl_engine_priv(engine, get_max_num_groups) =

	    xkl_xkb_get_max_num_groups;

	xkl_engine_priv(engine, get_num_groups) = xkl_xkb_get_num_groups;

	xkl_engine_priv(engine, lock_group) = xkl_xkb_lock_group;

	xkl_engine_priv(engine, process_x_event) = xkl_xkb_process_x_event;

	xkl_engine_priv(engine, process_x_error) = xkl_xkb_process_x_error;

	xkl_engine_priv(engine, free_all_info) = xkl_xkb_free_all_info;

	xkl_engine_priv(engine, if_cached_info_equals_actual) =

	    xkl_xkb_if_cached_info_equals_actual;

	xkl_engine_priv(engine, load_all_info) = xkl_xkb_load_all_info;

	xkl_engine_priv(engine, get_server_state) =

	    xkl_xkb_get_server_state;

	xkl_engine_priv(engine, pause_listen) = xkl_xkb_pause_listen;

	xkl_engine_priv(engine, resume_listen) = xkl_xkb_resume_listen;

	xkl_engine_priv(engine, set_indicators) = xkl_xkb_set_indicators;

	xkl_engine_priv(engine, finalize) = xkl_xkb_term;

	if (getenv("XKL_XKB_DISABLE") != NULL)

		return -1;

	xkl_engine_priv(engine, backend) = g_new0(XklXkb, 1);

	xkl_engine_backend(engine, XklXkb, device_id) = XkbUseCoreKbd;

	xkl_xkb_ext_present = XkbQueryExtension(display,

						&opcode,

						&xkl_engine_backend(engine,

								    XklXkb,

								    event_type),

						&xkl_engine_backend(engine,

								    XklXkb,

								    error_code),

						NULL, NULL);

	if (!xkl_xkb_ext_present)

		return -1;

	xkl_debug(160,

		  "xkbEvenType: %X, xkbError: %X, display: %p, root: "

		  WINID_FORMAT "\n", xkl_engine_backend(engine, XklXkb,

							event_type),

		  xkl_engine_backend(engine, XklXkb, error_code), display,

		  xkl_engine_priv(engine, root_window));

	xkl_engine_priv(engine, base_config_atom) =

	    XInternAtom(display, _XKB_RF_NAMES_PROP_ATOM, False);

	xkl_engine_priv(engine, backup_config_atom) =

	    XInternAtom(display, "_XKB_RULES_NAMES_BACKUP", False);

	xkl_engine_priv(engine, default_model) = "pc101";

	xkl_engine_priv(engine, default_layout) = "us";

	/* First, we have to assign xkl_vtable - 

	   because this function uses it */

	if (xkl_xkb_multiple_layouts_supported(engine))

		xkl_engine_priv(engine, features) |=

		    XKLF_MULTIPLE_LAYOUTS_SUPPORTED;

#if HAVE_XINPUT

	if (XQueryExtension

	    (display, "XInputExtension", &xi_opc,

	     &xkl_engine_backend(engine, XklXkb, xi_event_type),

	     &xkl_engine_backend(engine, XklXkb, xi_error_code))) {

		XExtensionVersion *ev =

		    XGetExtensionVersion(display, "XInputExtension");

		xkl_debug(150,

			  "XInputExtension found (%d, %d, %d) version %d.%d\n",

			  xi_opc, xkl_engine_backend(engine, XklXkb,

						     xi_event_type),

			  xkl_engine_backend(engine, XklXkb,

					     xi_error_code),

			  ev->major_version, ev->minor_version);

		/* DevicePresence is available from XI 1.4 */

		if ((ev->major_version * 10) + ev->minor_version >= 14) {

			xkl_debug(200, "DevicePresence available\n");

			xkl_engine_priv(engine, features) |=

			    XKLF_DEVICE_DISCOVERY;

		} else {

			xkl_debug(200, "DevicePresence not available\n");

		}

		XFree(ev);

	} else {

		xkl_debug(0, "XInputExtension not found\n");

		xkl_engine_backend(engine, XklXkb, xi_event_type) = -1;

		xkl_engine_backend(engine, XklXkb, xi_error_code) = -1;

	}

#endif

	return 0;

#else

	xkl_debug(160,

		  "NO XKB LIBS, display: %p, root: " WINID_FORMAT

		  "\n", display, xkl_engine_priv(engine, root_window));

	return -1;

#endif

}

void

xkl_xkb_term(XklEngine * engine)

{

}

#ifdef LIBXKBFILE_PRESENT

const gchar *

xkl_xkb_event_get_name(gint xkb_type)

{

	/* Not really good to use the fact of consecutivity

	   but XKB protocol extension is already standartized so... */

	static const gchar *evt_names[] = {

		"XkbNewKeyboardNotify",

		"XkbMapNotify",

		"XkbStateNotify",

		"XkbControlsNotify",

		"XkbIndicatorStateNotify",

		"XkbIndicatorMapNotify",

		"XkbNamesNotify",

		"XkbCompatMapNotify",

		"XkbBellNotify",

		"XkbActionMessage",

		"XkbAccessXNotify",

		"XkbExtensionDeviceNotify",

		"LASTEvent"

	};

	xkb_type -= XkbNewKeyboardNotify;

	if (xkb_type < 0 ||

	    xkb_type >= (sizeof(evt_names) / sizeof(evt_names[0])))

		return "UNKNOWN/OOR";

	return evt_names[xkb_type];

}

#endif