/*

 * 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 <X11/Xatom.h>

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include "xklavier_private.h"

#include "xklavier_private_xkb.h"

#ifdef HAVE_XINPUT

#include "config.h"

#include "X11/extensions/XInput.h"

static gint

xkl_xinput_process_x_event(XklEngine * engine, XEvent * xev)

{

	XDevicePresenceNotifyEvent *dpne =

	    (XDevicePresenceNotifyEvent *) xev;

	xkl_debug(200, "XInput event detected: %d\n", dpne->devchange);

	if (dpne->devchange == DeviceEnabled) {

		xkl_debug(150, "Device enabled: %d\n", dpne->deviceid);

		g_signal_emit_by_name(engine, "X-new-device");

	}

	return 1;

}

#endif

/*

 * XKB event handler

 */

gint

xkl_xkb_process_x_event(XklEngine * engine, XEvent * xev)

{

#ifdef LIBXKBFILE_PRESENT

	gint i;

	guint bit;

	guint inds;

	XkbEvent *kev = (XkbEvent *) xev;

	if (!

	    (xkl_engine_is_listening_for(engine, XKLL_MANAGE_WINDOW_STATES)

	     | xkl_engine_is_listening_for(engine,

					   XKLL_TRACK_KEYBOARD_STATE)))

		return 0;

#ifdef HAVE_XINPUT

	/* Special case XInput event */

	if (xev->type == xkl_engine_backend(engine, XklXkb, xi_event_type))

		return xkl_xinput_process_x_event(engine, xev);

#endif

	if (xev->type != xkl_engine_backend(engine, XklXkb, event_type))

		return 0;

	xkl_debug(150, "Xkb event detected\n");

	switch (kev->any.xkb_type) {

		/*

		 * Group is changed!

		 */

	case XkbStateNotify:

#define GROUP_CHANGE_MASK \

    ( XkbGroupStateMask | XkbGroupBaseMask | XkbGroupLatchMask | XkbGroupLockMask )

		xkl_debug(150,

			  "XkbStateNotify detected, changes: %X/(mask %X), new group %d\n",

			  kev->state.changed, GROUP_CHANGE_MASK,

			  kev->state.locked_group);

		if (kev->state.changed & GROUP_CHANGE_MASK)

			xkl_engine_process_state_modification(engine,

							      GROUP_CHANGED,

							      kev->

							      state.locked_group,

							      0, FALSE);

		else {		/* ...not interested... */

			xkl_debug(200,

				  "This type of state notification is not regarding groups\n");

			if (kev->state.locked_group !=

			    xkl_engine_priv(engine, curr_state).group)

				xkl_debug(0,

					  "ATTENTION! Currently cached group %d is not equal to the current group from the event: %d\n!",

					  xkl_engine_priv(engine,

							  curr_state).group,

					  kev->state.locked_group);

		}

		break;

		/*

		 * Indicators are changed!

		 */

	case XkbIndicatorStateNotify:

		xkl_debug(150, "XkbIndicatorStateNotify\n");

		inds = xkl_engine_priv(engine, curr_state).indicators;

		ForPhysIndicators(i,

				  bit) if (kev->indicators.changed & bit) {

			if (kev->indicators.state & bit)

				inds |= bit;

			else

				inds &= ~bit;

		}

		xkl_engine_process_state_modification(engine,

						      INDICATORS_CHANGED,

						      0, inds, TRUE);

		break;

		/*

		 * The configuration is changed!

		 */

	case XkbIndicatorMapNotify:

	case XkbControlsNotify:

	case XkbNamesNotify:

#if 0

		/* not really fair - but still better than flooding... */

		XklDebug(200,

			 "warning: configuration event %s is not actually processed\n",

			 _XklXkbGetXkbEventName(kev->any.xkb_type));

		break;

#endif

	case XkbNewKeyboardNotify:

		xkl_debug(150, "%s\n",

			  xkl_xkb_event_get_name(kev->any.xkb_type));

		xkl_engine_reset_all_info(engine, FALSE,

					  "XKB event: XkbNewKeyboardNotify");

		break;

		/*

		 * ...Not interested...

		 */

	default:

		xkl_debug(150, "Unknown XKB event %d [%s]\n",

			  kev->any.xkb_type,

			  xkl_xkb_event_get_name(kev->any.xkb_type));

		return 0;

	}

	return 1;

#else

	return 0;

#endif

}

/*

 * XKB error handler

 */

gint

xkl_xkb_process_x_error(XklEngine * engine, XErrorEvent * xerev)

{

#ifdef HAVE_XINPUT

	/* Ignore XInput errors */

	if (xerev->error_code >=

	    xkl_engine_backend(engine, XklXkb, xi_error_code)

	    && xerev->error_code <=

	    (xkl_engine_backend(engine, XklXkb, xi_error_code) +

	     XI_BadClass))

		return 1;

#endif

	return 0;

}

void

xkl_xkb_set_indicators(XklEngine * engine, const XklState * window_state)

{

#ifdef LIBXKBFILE_PRESENT

	int i;

	unsigned bit;

	XkbDescPtr cached =

	    xkl_engine_backend(engine, XklXkb, cached_desc);

	ForPhysIndicators(i, bit) if (cached->names->indicators[i] != None) {

		gboolean status;

		status = xkl_xkb_set_indicator(engine, i,

					       (window_state->indicators &

						bit) != 0);

		xkl_debug(150, "Set indicator \"%s\"/%d to %d: %d\n",

			  xkl_engine_backend(engine, XklXkb,

					     indicator_names)[i],

			  cached->names->indicators[i],

			  window_state->indicators & bit, status);

	}

#endif

}