path: root/libxklavier/xklavier_evt.c

/*
 * 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 <string.h>
#include <time.h>

#include <X11/Xatom.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>

#include "xklavier_private.h"

gint
xkl_engine_filter_events(XklEngine * engine, XEvent * xev)
{
	XAnyEvent *pe = (XAnyEvent *) xev;
	xkl_debug(400,
		  "**> Filtering event %d of type %d from window %d\n",
		  pe->serial, pe->type, pe->window);
	xkl_engine_ensure_vtable_inited(engine);
	if (!xkl_engine_vcall(engine, process_x_event) (engine, xev))
		switch (xev->type) {	/* core events */
		case FocusIn:
			xkl_engine_process_focus_in_evt(engine,
							&xev->xfocus);
			break;
		case FocusOut:
			xkl_engine_process_focus_out_evt(engine,
							 &xev->xfocus);
			break;
		case PropertyNotify:
			xkl_engine_process_property_evt(engine,
							&xev->xproperty);
			break;
		case CreateNotify:
			xkl_engine_process_create_window_evt(engine,
							     &xev->xcreatewindow);
			break;
		case DestroyNotify:
			xkl_debug(150,
				  "Window " WINID_FORMAT " destroyed\n",
				  xev->xdestroywindow.window);
			break;
		case UnmapNotify:
			xkl_debug(200,
				  "Window " WINID_FORMAT " unmapped\n",
				  xev->xunmap.window);
			break;
		case MapNotify:
		case GravityNotify:
			xkl_debug(200, "%s\n",
				  xkl_event_get_name(xev->type));
			break;	/* Ignore these events */
		case ReparentNotify:
			xkl_debug(200,
				  "Window " WINID_FORMAT " reparented to "
				  WINID_FORMAT "\n", xev->xreparent.window,
				  xev->xreparent.parent);
			break;	/* Ignore these events */
		case MappingNotify:
			xkl_debug(200, "%s\n",
				  xkl_event_get_name(xev->type));
			xkl_engine_reset_all_info(engine, FALSE,
						  "X event: MappingNotify");
			break;
		default:
			{
				xkl_debug(200, "Unknown event %d [%s]\n",
					  xev->type,
					  xkl_event_get_name(xev->type));
				return 1;
			}
		}
	xkl_debug(400, "Filtered event %d of type %d from window %d **>\n",
		  pe->serial, pe->type, pe->window);
	return 1;
}

/*
 * FocusIn handler
 */
void
xkl_engine_process_focus_in_evt(XklEngine * engine,
				XFocusChangeEvent * fev)
{
	Window win;
	Window prev_toplevel_win =
	    xkl_engine_priv(engine, curr_toplvl_win);
	Window toplevel_win;
	XklState selected_window_state;

	if (!
	    (xkl_engine_is_listening_for
	     (engine, XKLL_MANAGE_WINDOW_STATES)))
		return;

	win = fev->window;

	switch (fev->mode) {
	case NotifyNormal:
	case NotifyWhileGrabbed:
		break;
	default:
		xkl_debug(160,
			  "Window " WINID_FORMAT
			  " has got focus during special action %d\n", win,
			  fev->mode);
		return;
	}

	xkl_debug(150, "Window " WINID_FORMAT ", '%s' has got focus\n",
		  win, xkl_get_debug_window_title(engine, win));

	if (!xkl_engine_find_toplevel_window(engine, win, &toplevel_win)) {
		return;
	}

	xkl_debug(150, "Appwin " WINID_FORMAT ", '%s' has got focus\n",
		  toplevel_win, xkl_get_debug_window_title(engine,
							   toplevel_win));

	if (xkl_engine_get_toplevel_window_state
	    (engine, toplevel_win, &selected_window_state)) {
		if (prev_toplevel_win != toplevel_win) {
			gboolean new_win_transparent;
			Window parent = (Window) NULL, root =
			    (Window) NULL, *children = NULL;
			guint nchildren = 0;

			/*
			 * If previous focused window exists - handle transparency and state
			 * (optional)
			 */
			if (xkl_engine_query_tree
			    (engine, prev_toplevel_win, &root, &parent,
			     &children, &nchildren) == Success) {
				XklState tmp_state;
				gboolean old_win_transparent =
				    xkl_engine_is_toplevel_window_transparent
				    (engine, prev_toplevel_win);

				if (children != NULL)
					XFree(children);

				if (old_win_transparent)
					xkl_debug(150,
						  "Leaving transparent window\n");
				/*
				 * Reload the current state from the current window. 
				 * Do not do it for transparent window - we keep the state from 
				 * the _previous_ window.
				 */
				if (!old_win_transparent
				    &&
				    xkl_engine_get_toplevel_window_state
				    (engine, prev_toplevel_win,
				     &tmp_state)) {
					xkl_engine_update_current_state
					    (engine, tmp_state.group,
					     tmp_state.indicators,
					     "Loading current (previous) state from the current (previous) window");
				}
			} else
				xkl_debug(150,
					  "Current (previous) window "
					  WINID_FORMAT
					  " does not exist any more, so transparency/state are not analyzed\n",
					  prev_toplevel_win);

			xkl_engine_priv(engine, curr_toplvl_win) =
			    toplevel_win;
			xkl_debug(150,
				  "CurClient:changed to " WINID_FORMAT
				  ", '%s'\n", xkl_engine_priv(engine,
							      curr_toplvl_win),
				  xkl_get_debug_window_title(engine,
							     xkl_engine_priv
							     (engine,
							      curr_toplvl_win)));

			new_win_transparent =
			    xkl_engine_is_toplevel_window_transparent
			    (engine, toplevel_win);
			if (new_win_transparent)
				xkl_debug(150,
					  "Entering transparent window\n");

			if (xkl_engine_is_group_per_toplevel_window(engine)
			    == !new_win_transparent) {
				/* We skip restoration only if we return to the same app window */
				gboolean do_skip = FALSE;
				if (xkl_engine_priv
				    (engine, skip_one_restore)) {
					xkl_engine_priv(engine,
							skip_one_restore) =
					    FALSE;
					if (toplevel_win ==
					    xkl_engine_priv(engine,
							    prev_toplvl_win))
						do_skip = TRUE;
				}

				if (do_skip) {
					xkl_debug(150,
						  "Skipping one restore as requested - instead, "
						  "saving the current group into the window state\n");
					xkl_engine_save_toplevel_window_state
					    (engine, toplevel_win,
					     &xkl_engine_priv(engine,
							      curr_state));
				} else {
					if (xkl_engine_priv
					    (engine,
					     curr_state).group !=
					    selected_window_state.group) {
						xkl_debug(150,
							  "Restoring the group from %d to %d after gaining focus\n",
							  xkl_engine_priv
							  (engine,
							   curr_state).group,
							  selected_window_state.group);
						/*
						 *  For fast mouse movements - the state is probably not updated yet
						 *  (because of the group change notification being late).
						 *  so we'll enforce the update. But this should only happen in GPA mode
						 */
						xkl_engine_update_current_state
						    (engine,
						     selected_window_state.group,
						     selected_window_state.indicators,
						     "Enforcing fast update of the current state");
						xkl_engine_lock_group
						    (engine,
						     selected_window_state.group);
						xkl_engine_priv(engine, skip_one_save) = TRUE;
					} else {
						xkl_debug(150,
							  "Both old and new focused window "
							  "have group %d so no point restoring it\n",
							  selected_window_state.group);
						xkl_engine_one_switch_to_secondary_group_performed
						    (engine);
					}
				}

				if ((xkl_engine_priv(engine, features) &
				     XKLF_CAN_TOGGLE_INDICATORS)
				    &&
				    xkl_engine_get_indicators_handling
				    (engine)) {
					xkl_debug(150,
						  "Restoring the indicators from %X to %X after gaining focus\n",
						  xkl_engine_priv(engine,
								  curr_state).indicators,
						  selected_window_state.indicators);
					xkl_engine_ensure_vtable_inited
					    (engine);
					xkl_engine_vcall(engine,
							 set_indicators)
					    (engine,
					     &selected_window_state);
				} else
					xkl_debug(150,
						  "Not restoring the indicators %X after gaining focus: indicator handling is not enabled\n",
						  xkl_engine_priv(engine,
								  curr_state).indicators);
			} else
				xkl_debug(150,
					  "Not restoring the group %d after gaining focus: global layout (xor transparent window)\n",
					  xkl_engine_priv(engine,
							  curr_state).group);
		} else
			xkl_debug(150,
				  "Same app window - just do nothing\n");
	} else {
		xkl_debug(150, "But it does not have xklavier_state\n");
		if (xkl_engine_if_window_has_wm_state(engine, win)) {
			xkl_debug(150,
				  "But it does have wm_state so we'll add it\n");
			xkl_engine_priv(engine, curr_toplvl_win) =
			    toplevel_win;
			xkl_debug(150,
				  "CurClient:changed to " WINID_FORMAT
				  ", '%s'\n", xkl_engine_priv(engine,
							      curr_toplvl_win),
				  xkl_get_debug_window_title(engine,
							     xkl_engine_priv
							     (engine,
							      curr_toplvl_win)));
			xkl_engine_add_toplevel_window(engine,
						       xkl_engine_priv
						       (engine,
							curr_toplvl_win),
						       (Window) NULL,
						       FALSE,
						       &xkl_engine_priv
						       (engine,
							curr_state));
		} else
			xkl_debug(150,
				  "And it does have wm_state either\n");
	}
}

/* 
 * FocusOut handler
 */
void
xkl_engine_process_focus_out_evt(XklEngine * engine,
				 XFocusChangeEvent * fev)
{
	if (!
	    (xkl_engine_is_listening_for
	     (engine, XKLL_MANAGE_WINDOW_STATES)))
		return;

	if (fev->mode != NotifyNormal) {
		xkl_debug(200,
			  "Window " WINID_FORMAT
			  " has lost focus during special action %d\n",
			  fev->window, fev->mode);
		return;
	}

	xkl_debug(160, "Window " WINID_FORMAT ", '%s' has lost focus\n",
		  fev->window, xkl_get_debug_window_title(engine,
							  fev->window));

	if (xkl_engine_is_toplevel_window_transparent(engine, fev->window)) {
		xkl_debug(150, "Leaving transparent window!\n");
/* 
 * If we are leaving the transparent window - we skip the restore operation.
 * This is useful for secondary groups switching from the transparent control 
 * window.
 */
		xkl_engine_priv(engine, skip_one_restore) = TRUE;
	} else {
		Window p;
		if (xkl_engine_find_toplevel_window
		    (engine, fev->window, &p))
			xkl_engine_priv(engine, prev_toplvl_win) = p;
	}
}

/*
 * PropertyChange handler
 * Interested in :
 *  + for XKLL_MANAGE_WINDOW_STATES
 *    - WM_STATE property for all windows
 *    - Configuration property of the root window
 *  + for XKLL_TRACK_KEYBOARD_STATE
 *    - Configuration property of the root window
 */
void
xkl_engine_process_property_evt(XklEngine * engine, XPropertyEvent * pev)
{
	if (400 <= xkl_debug_level) {
		char *atom_name =
		    XGetAtomName(xkl_engine_get_display(engine),
				 pev->atom);
		if (atom_name != NULL) {
			xkl_debug(400,
				  "The property '%s' changed for "
				  WINID_FORMAT "\n", atom_name,
				  pev->window);
			XFree(atom_name);
		} else {
			xkl_debug(200,
				  "Some magic property changed for "
				  WINID_FORMAT "\n", pev->window);
		}
	}

	if (pev->atom == xkl_engine_priv(engine, atoms)[WM_STATE]) {
		if (xkl_engine_is_listening_for
		    (engine, XKLL_MANAGE_WINDOW_STATES)) {
			gboolean has_xkl_state =
			    xkl_engine_get_state(engine, pev->window,
						 NULL);

			if (pev->state == PropertyNewValue) {
				xkl_debug(160,
					  "New value of WM_STATE on window "
					  WINID_FORMAT "\n", pev->window);
				if (!has_xkl_state) {	/* Is this event the first or not? */
					xkl_engine_add_toplevel_window
					    (engine, pev->window, (Window)
					     NULL, FALSE,
					     &xkl_engine_priv(engine,
							      curr_state));
				}
			} else {	/* ev->xproperty.state == PropertyDelete, either client or WM can remove it, ICCCM 4.1.3.1 */
				xkl_debug(160,
					  "Something (%d) happened to WM_STATE of window 0x%x\n",
					  pev->state, pev->window);
				xkl_engine_select_input_merging(engine,
								pev->window,
								PropertyChangeMask);
				if (has_xkl_state) {
					xkl_engine_delete_state(engine,
								pev->window);
				}
			}
		}		/* XKLL_MANAGE_WINDOW_STATES */
	} else if (pev->atom == xkl_engine_priv(engine, base_config_atom)
		   && pev->window == xkl_engine_priv(engine, root_window)) {
		if (xkl_engine_is_listening_for
		    (engine,
		     XKLL_MANAGE_WINDOW_STATES) |
		    xkl_engine_is_listening_for(engine,
						XKLL_TRACK_KEYBOARD_STATE))
		{
			if (pev->state == PropertyNewValue) {
				/* If root window got new *_NAMES_PROP_ATOM -
				   it most probably means new keyboard config is loaded by somebody */
				xkl_engine_reset_all_info
				    (engine, TRUE,
				     "New value of *_NAMES_PROP_ATOM on root window");
			}
		}		/* XKLL_MANAGE_WINDOW_STATES | XKLL_TRACK_KEYBOARD_STATE */
	}
}

/*
 * CreateNotify handler. Just interested in properties and focus events...
 */
void
xkl_engine_process_create_window_evt(XklEngine * engine,
				     XCreateWindowEvent * cev)
{
	if (!xkl_engine_is_listening_for
	    (engine, XKLL_MANAGE_WINDOW_STATES))
		return;

	xkl_debug(200,
		  "Under-root window " WINID_FORMAT
		  "/%s (%d,%d,%d x %d) is created\n", cev->window,
		  xkl_get_debug_window_title(engine, cev->window), cev->x,
		  cev->y, cev->width, cev->height);

	if (!cev->override_redirect) {
/* ICCCM 4.1.6: override-redirect is NOT private to
* client (and must not be changed - am I right?) 
* We really need only PropertyChangeMask on this window but even in the case of
* local server we can lose PropertyNotify events (the trip time for this CreateNotify
* event + SelectInput request is not zero) and we definitely will (my system DO)
* lose FocusIn/Out events after the following call of PropertyNotifyHandler.
* So I just decided to purify this extra FocusChangeMask in the FocusIn/OutHandler. */
		xkl_engine_select_input_merging(engine, cev->window,
						PropertyChangeMask |
						FocusChangeMask);

		if (xkl_engine_if_window_has_wm_state(engine, cev->window)) {
			xkl_debug(200,
				  "Just created window already has WM_STATE - so I'll add it");
			xkl_engine_add_toplevel_window(engine, cev->window,
						       (Window) NULL,
						       FALSE,
						       &xkl_engine_priv
						       (engine,
							curr_state));
		}
	}
}

/*
 * Just error handler - sometimes we get BadWindow error for already gone 
 * windows, so we'll just ignore
 * This handler can be called in the middle of the engine initialization -
 * so it is not fair to assume that the engine is available
 */
int
xkl_process_error(Display * dpy, XErrorEvent * evt)
{
	char buf[128] = "";
	XklEngine *engine = xkl_get_the_engine();

	if (engine != NULL)
		xkl_engine_priv(engine, last_error_code) = evt->error_code;

	switch (evt->error_code) {
	case BadAccess:
	case BadDrawable:
	case BadWindow:
	case BadMatch:
		{
			XGetErrorText(evt->display, evt->error_code, buf,
				      sizeof(buf));
			/* in most cases this means we are late:) */
			xkl_debug(200,
				  "ERROR: %p, " WINID_FORMAT ", %d [%s], "
				  "X11 request: %d, minor code: %d\n", dpy,
				  (unsigned long) evt->resourceid,
				  (int) evt->error_code, buf,
				  (int) evt->request_code,
				  (int) evt->minor_code);
			break;
		}
	default:
		if (engine != NULL
		    && xkl_engine_priv(engine, process_x_error)) {
			if (xkl_engine_priv(engine, process_x_error)
			    (engine, evt)) {
				xkl_debug(200,
					  "X ERROR processed by the engine: %p, "
					  WINID_FORMAT ", %d [%s], "
					  "X11 request: %d, minor code: %d\n",
					  dpy,
					  (unsigned long) evt->resourceid,
					  (int) evt->error_code, buf,
					  (int) evt->request_code,
					  (int) evt->minor_code);
				break;
			}
		}
		xkl_debug(200,
			  "Unexpected by libxklavier X ERROR: %p, "
			  WINID_FORMAT ", %d [%s], "
			  "X11 request: %d, minor code: %d\n", dpy,
			  (unsigned long) evt->resourceid,
			  (int) evt->error_code, buf,
			  (int) evt->request_code, (int) evt->minor_code);
		if (engine != NULL)
			if (!xkl_engine_priv(engine, critical_section))
				(*xkl_engine_priv
				 (engine, default_error_handler))
				    (dpy, evt);
	}

	/* X ignores this return value anyway */
	return 0;
}

/*
 * Some common functionality for Xkb handler
 */
void
xkl_engine_process_state_modification(XklEngine * engine,
				      XklEngineStateChange change_type,
				      gint grp, guint inds,
				      gboolean set_inds)
{
	Window focused, focused_toplevel;
	XklState old_state;
	gint revert;
	gboolean have_old_state = TRUE;
	gboolean set_group = change_type == GROUP_CHANGED;

	if (xkl_engine_priv(engine, skip_one_save)) {
		xkl_debug(160, "Skipping one callback");
		xkl_engine_priv(engine, skip_one_save) = FALSE;
		return;
	}

	XGetInputFocus(xkl_engine_get_display(engine), &focused, &revert);

	if ((focused == None) || (focused == PointerRoot)) {
		xkl_debug(160, "Something with focus: " WINID_FORMAT "\n",
			  focused);
		return;
	}

	/* 
	 * Only if we manage states - otherwise xkl_engine_priv(engine,curr_toplvl_win) does not make sense 
	 */
	if (!xkl_engine_find_toplevel_window
	    (engine, focused, &focused_toplevel)
	    && xkl_engine_is_listening_for(engine,
					   XKLL_MANAGE_WINDOW_STATES))
		focused_toplevel = xkl_engine_priv(engine, curr_toplvl_win);	/* what else can I do */

	xkl_debug(150, "Focused window: " WINID_FORMAT ", '%s'\n",
		  focused_toplevel,
		  xkl_get_debug_window_title(engine, focused_toplevel));
	if (xkl_engine_is_listening_for(engine, XKLL_MANAGE_WINDOW_STATES)) {
		xkl_debug(150, "CurClient: " WINID_FORMAT ", '%s'\n",
			  xkl_engine_priv(engine, curr_toplvl_win),
			  xkl_get_debug_window_title(engine,
						     xkl_engine_priv
						     (engine,
						      curr_toplvl_win)));

		if (focused_toplevel !=
		    xkl_engine_priv(engine, curr_toplvl_win)) {
			/*
			 * If not state - we got the new window
			 */
			if (!xkl_engine_get_toplevel_window_state
			    (engine, focused_toplevel, &old_state)) {
				xkl_engine_update_current_state(engine,
								grp, inds,
								"Updating the state from new focused window");
				if (xkl_engine_is_listening_for
				    (engine, XKLL_MANAGE_WINDOW_STATES))
					xkl_engine_add_toplevel_window
					    (engine, focused_toplevel,
					     (Window) NULL, FALSE,
					     &xkl_engine_priv(engine,
							      curr_state));
			}
			/*
			 * There is state - just get the state from the window
			 */
			else {
				grp = old_state.group;
				inds = old_state.indicators;
			}
			xkl_engine_priv(engine, curr_toplvl_win) =
			    focused_toplevel;
			xkl_debug(160,
				  "CurClient:changed to " WINID_FORMAT
				  ", '%s'\n", xkl_engine_priv(engine,
							      curr_toplvl_win),
				  xkl_get_debug_window_title(engine,
							     xkl_engine_priv
							     (engine,
							      curr_toplvl_win)));
		}
		/* If the window already has this this state - we are just restoring it!
		   (see the second parameter of stateCallback */
		have_old_state =
		    xkl_engine_get_toplevel_window_state(engine,
							 xkl_engine_priv
							 (engine,
							  curr_toplvl_win),
							 &old_state);
	} else {		/* just tracking the stuff, no smart things */

		xkl_debug(160,
			  "Just updating the current state in the tracking mode\n");
		memcpy(&old_state, &xkl_engine_priv(engine, curr_state),
		       sizeof(XklState));
	}

	if (set_group || have_old_state) {
		xkl_engine_update_current_state(engine,
						set_group ? grp :
						old_state.group,
						set_inds ? inds :
						old_state.indicators,
						"Restoring the state from the window");
	}

	if (have_old_state)
		xkl_engine_try_call_state_func(engine, change_type,
					       &old_state);

	if (xkl_engine_is_listening_for(engine, XKLL_MANAGE_WINDOW_STATES))
		xkl_engine_save_toplevel_window_state(engine,
						      xkl_engine_priv
						      (engine,
						       curr_toplvl_win),
						      &xkl_engine_priv
						      (engine,
						       curr_state));
}