/*

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

#include <X11/Xmd.h>

#include <X11/Xatom.h>

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include "xklavier_private.h"

Window xkl_toplevel_window_prev;

void

xkl_engine_set_toplevel_window_transparent(XklEngine * engine,

					   Window toplevel_win,

					   gboolean transparent)

{

	gboolean oldval;

	oldval =

	    xkl_engine_is_toplevel_window_transparent(engine,

						      toplevel_win);

	xkl_debug(150, "toplevel_win " WINID_FORMAT " was %stransparent\n",

		  toplevel_win, oldval ? "" : "not ");

	if (transparent && !oldval) {

		CARD32 prop = 1;

		XChangeProperty(xkl_engine_get_display(engine),

				toplevel_win,

				xkl_engine_priv(engine, atoms)

				[XKLAVIER_TRANSPARENT], XA_INTEGER, 32,

				PropModeReplace,

				(const unsigned char *) &prop, 1);

	} else if (!transparent && oldval) {

		XDeleteProperty(xkl_engine_get_display(engine),

				toplevel_win,

				xkl_engine_priv(engine, atoms)

				[XKLAVIER_TRANSPARENT]);

	}

}

/*

 * "Adds" app window to the set of managed windows.

 * Actually, no data structures involved. The only thing we do is save app state

 * and register ourselves us listeners.

 * Note: User's callback is called

 */

void

xkl_engine_add_toplevel_window(XklEngine * engine, Window toplevel_win,

			       Window parent,

			       gboolean ignore_existing_state,

			       XklState * init_state)

{

	XklState state = *init_state;

	gint default_group_to_use = -1;

	GValue params[3];

	GValue rv;

	guint signal_id;

	if (toplevel_win == xkl_engine_priv(engine, root_window))

		xkl_debug(150, "??? root app win ???\n");

	xkl_debug(150,

		  "Trying to add window " WINID_FORMAT

		  "/%s with group %d\n", toplevel_win,

		  xkl_get_debug_window_title(engine, toplevel_win),

		  init_state->group);

	if (!ignore_existing_state) {

		gboolean have_state =

		    xkl_engine_get_toplevel_window_state(engine,

							 toplevel_win,

							 &state);

		if (have_state) {

			xkl_debug(150,

				  "The window " WINID_FORMAT

				  " does not require to be added, it already has the xklavier state \n",

				  toplevel_win);

			return;

		}

	}

	memset(params, 0, sizeof(params));

	g_value_init(params, XKL_TYPE_ENGINE);

	g_value_set_object(params, engine);

	g_value_init(params + 1, G_TYPE_LONG);

	g_value_set_long(params + 1, toplevel_win);

	g_value_init(params + 2, G_TYPE_LONG);

	g_value_set_long(params + 2, parent);

	memset(&rv, 0, sizeof(rv));

	g_value_init(&rv, G_TYPE_INT);

	g_value_set_int(&rv, default_group_to_use);

	signal_id =

	    g_signal_lookup("new-toplevel-window", xkl_engine_get_type());

	g_signal_emitv(params, signal_id, 0, &rv;;

	default_group_to_use = g_value_get_int(&rv;;

	if (default_group_to_use == -1) {

		Window transient_for = 0;

		if (XGetTransientForHint(xkl_engine_get_display(engine), toplevel_win, &transient_for)) {

			if (transient_for) {

				XklState trans_state;

				gboolean have_state =

					xkl_engine_get_toplevel_window_state(engine,

							 transient_for,

							 &trans_state);

				if (have_state) {

					default_group_to_use = trans_state.group;

				}

			}

		}

	}

	if (default_group_to_use == -1)

		default_group_to_use =

		    xkl_engine_priv(engine, default_group);

	if (default_group_to_use != -1)

		state.group = default_group_to_use;

	xkl_engine_save_toplevel_window_state(engine, toplevel_win,

					      &state);

	xkl_engine_select_input_merging(engine, toplevel_win,

					FocusChangeMask |

					PropertyChangeMask);

	if (default_group_to_use != -1) {

		if (xkl_engine_priv(engine, curr_toplvl_win) ==

		    toplevel_win) {

			if ((xkl_engine_priv(engine, secondary_groups_mask)

			     & (1 << default_group_to_use)) != 0)

				xkl_engine_allow_one_switch_to_secondary_group

				    (engine);

			xkl_engine_lock_group(engine,

					      default_group_to_use);

		}

	}

	if (parent == (Window) NULL)

		parent =

		    xkl_engine_get_registered_parent(engine, toplevel_win);

	xkl_debug(150, "done\n");

}

/*

 * Checks the window and goes up

 */

gboolean

xkl_engine_find_toplevel_window_bottom_to_top(XklEngine * engine,

					      Window win,

					      Window * toplevel_win_out)

{

	Window parent = (Window) NULL, rwin = (Window) NULL, *children =

	    NULL;

	guint num = 0;

	if (win == (Window) NULL

	    || win == xkl_engine_priv(engine, root_window)) {

		*toplevel_win_out = win;

		xkl_last_error_message = "The window is either 0 or root";

		return FALSE;

	}

	if (xkl_engine_if_window_has_wm_state(engine, win)) {

		*toplevel_win_out = win;

		return TRUE;

	}

	xkl_engine_priv(engine, last_error_code) =

	    xkl_engine_query_tree(engine, win, &rwin, &parent, &children,

				  &num);

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

		*toplevel_win_out = (Window) NULL;

		return FALSE;

	}

	if (children != NULL)

		XFree(children);

	return xkl_engine_find_toplevel_window_bottom_to_top(engine,

							     parent,

							     toplevel_win_out);

}

/*

 * Recursively finds "App window" (window with WM_STATE) for given window.

 * First, checks the window itself

 * Then, for first level of recursion, checks childen,

 * Then, goes to parent.

 * NOTE: root window cannot be "App window" under normal circumstances

 */

gboolean

xkl_engine_find_toplevel_window(XklEngine * engine, Window win,

				Window * toplevel_win_out)

{

	Window parent = (Window) NULL,

	    rwin = (Window) NULL, *children = NULL, *child;

	guint num = 0;

	gboolean rv;

	if (win == (Window) NULL

	    || win == PointerRoot

	    || win == xkl_engine_priv(engine, root_window)) {

		*toplevel_win_out = (Window) NULL;

		xkl_last_error_message = "The window is either 0 or root";

		xkl_debug(150,

			  "Window " WINID_FORMAT

			  " is either 0 or root so could not get the app window for it\n",

			  win);

		return FALSE;

	}

	if (xkl_engine_if_window_has_wm_state(engine, win)) {

		*toplevel_win_out = win;

		return TRUE;

	}

	xkl_engine_priv(engine, last_error_code) =

	    xkl_engine_query_tree(engine, win, &rwin, &parent, &children,

				  &num);

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

		*toplevel_win_out = (Window) NULL;

		xkl_debug(150,

			  "Could not get tree for window " WINID_FORMAT

			  " so could not get the app window for it\n",

			  win);

		return FALSE;

	}

	/*

	 * Here we first check the children (in case win is just above some "App Window")

	 * and then go upstairs

	 */

	child = children;

	while (num) {

		if (xkl_engine_if_window_has_wm_state(engine, *child)) {

			*toplevel_win_out = *child;

			if (children != NULL)

				XFree(children);

			return TRUE;

		}

		child++;

		num--;

	}

	if (children != NULL)

		XFree(children);

	rv = xkl_engine_find_toplevel_window_bottom_to_top(engine, parent,

							   toplevel_win_out);

	if (!rv)

		xkl_debug(200,

			  "Could not get the app window for " WINID_FORMAT

			  "/%s\n", win, xkl_get_debug_window_title(engine,

								   win));

	return rv;

}

/*

 * Gets the state from the window property

 */

gboolean

xkl_engine_get_toplevel_window_state(XklEngine * engine,

				     Window toplevel_win,

				     XklState * state_out)

{

	Atom type_ret;

	int format_ret;

	unsigned long nitems, rest;

	CARD32 *prop = NULL;

	gboolean ret = FALSE;

	gint grp = -1;

	guint inds = 0;

	if ((XGetWindowProperty

	     (xkl_engine_get_display(engine), toplevel_win,

	      xkl_engine_priv(engine, atoms)[XKLAVIER_STATE], 0L,

	      XKLAVIER_STATE_PROP_LENGTH, False, XA_INTEGER, &type_ret,

	      &format_ret, &nitems, &rest,

	      (unsigned char **) (void *) &prop) == Success)

	    && (type_ret == XA_INTEGER) && (format_ret == 32)) {

		grp = prop[0];

		if (grp >= xkl_engine_get_num_groups(engine) || grp < 0)

			grp = 0;

		inds = prop[1];

		if (state_out != NULL) {

			state_out->group = grp;

			state_out->indicators = inds;

		}

		if (prop != NULL)

			XFree(prop);

		ret = TRUE;

	}

	if (ret)

		xkl_debug(150,

			  "Appwin " WINID_FORMAT

			  ", '%s' has the group %d, indicators %X\n",

			  toplevel_win,

			  xkl_get_debug_window_title(engine, toplevel_win),

			  grp, inds);

	else

		xkl_debug(150,

			  "Appwin " WINID_FORMAT

			  ", '%s' does not have state\n", toplevel_win,

			  xkl_get_debug_window_title(engine,

						     toplevel_win));

	return ret;

}

/*

 * Deletes the state from the window properties

 */

void

xkl_engine_remove_toplevel_window_state(XklEngine * engine,

					Window toplevel_win)

{

	XDeleteProperty(xkl_engine_get_display(engine), toplevel_win,

			xkl_engine_priv(engine, atoms)[XKLAVIER_STATE]);

}

/*

 * Saves the state into the window properties

 */

void

xkl_engine_save_toplevel_window_state(XklEngine * engine,

				      Window toplevel_win,

				      XklState * state)

{

	CARD32 prop[XKLAVIER_STATE_PROP_LENGTH];

	prop[0] = state->group;

	prop[1] = state->indicators;

	XChangeProperty(xkl_engine_get_display(engine), toplevel_win,

			xkl_engine_priv(engine, atoms)[XKLAVIER_STATE],

			XA_INTEGER, 32, PropModeReplace,

			(const unsigned char *) prop,

			XKLAVIER_STATE_PROP_LENGTH);

	xkl_debug(160,

		  "Saved the group %d, indicators %X for appwin "

		  WINID_FORMAT "\n", state->group, state->indicators,

		  toplevel_win);

}

gboolean

xkl_engine_is_toplevel_window_transparent(XklEngine * engine,

					  Window toplevel_win)

{

	Atom type_ret;

	int format_ret;

	unsigned long nitems, rest;

	CARD32 *prop = NULL;

	if ((XGetWindowProperty

	     (xkl_engine_get_display(engine), toplevel_win,

	      xkl_engine_priv(engine, atoms)[XKLAVIER_TRANSPARENT], 0L, 1,

	      False, XA_INTEGER, &type_ret, &format_ret, &nitems, &rest,

	      (unsigned char **) (void *) &prop) == Success)

	    && (type_ret == XA_INTEGER) && (format_ret == 32)) {

		if (prop != NULL)

			XFree(prop);

		return TRUE;

	}

	return FALSE;

}