summaryrefslogtreecommitdiff
path: root/src/core/window.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/window.c')
-rw-r--r--src/core/window.c8178
1 files changed, 8178 insertions, 0 deletions
diff --git a/src/core/window.c b/src/core/window.c
new file mode 100644
index 00000000..08ab9ec9
--- /dev/null
+++ b/src/core/window.c
@@ -0,0 +1,8178 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X managed windows */
+
+/*
+ * Copyright (C) 2001 Havoc Pennington, Anders Carlsson
+ * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "window-private.h"
+#include "edge-resistance.h"
+#include "util.h"
+#include "frame-private.h"
+#include "errors.h"
+#include "workspace.h"
+#include "stack.h"
+#include "keybindings.h"
+#include "ui.h"
+#include "place.h"
+#include "session.h"
+#include "effects.h"
+#include "prefs.h"
+#include "resizepopup.h"
+#include "xprops.h"
+#include "group.h"
+#include "window-props.h"
+#include "constraints.h"
+#include "compositor.h"
+#include "effects.h"
+
+#include <X11/Xatom.h>
+#include <string.h>
+
+#ifdef HAVE_SHAPE
+#include <X11/extensions/shape.h>
+#endif
+
+static int destroying_windows_disallowed = 0;
+
+
+static void update_sm_hints (MetaWindow *window);
+static void update_net_frame_extents (MetaWindow *window);
+static void recalc_window_type (MetaWindow *window);
+static void recalc_window_features (MetaWindow *window);
+static void invalidate_work_areas (MetaWindow *window);
+static void recalc_window_type (MetaWindow *window);
+static void set_wm_state (MetaWindow *window,
+ int state);
+static void set_net_wm_state (MetaWindow *window);
+
+static void send_configure_notify (MetaWindow *window);
+static gboolean process_property_notify (MetaWindow *window,
+ XPropertyEvent *event);
+static void meta_window_show (MetaWindow *window);
+static void meta_window_hide (MetaWindow *window);
+
+static void meta_window_save_rect (MetaWindow *window);
+static void save_user_window_placement (MetaWindow *window);
+static void force_save_user_window_placement (MetaWindow *window);
+
+static void meta_window_move_resize_internal (MetaWindow *window,
+ MetaMoveResizeFlags flags,
+ int resize_gravity,
+ int root_x_nw,
+ int root_y_nw,
+ int w,
+ int h);
+
+static void ensure_mru_position_after (MetaWindow *window,
+ MetaWindow *after_this_one);
+
+
+static void meta_window_move_resize_now (MetaWindow *window);
+
+static void meta_window_unqueue (MetaWindow *window, guint queuebits);
+
+static void update_move (MetaWindow *window,
+ gboolean snap,
+ int x,
+ int y);
+static gboolean update_move_timeout (gpointer data);
+static void update_resize (MetaWindow *window,
+ gboolean snap,
+ int x,
+ int y,
+ gboolean force);
+static gboolean update_resize_timeout (gpointer data);
+
+
+static void meta_window_flush_calc_showing (MetaWindow *window);
+
+static gboolean queue_calc_showing_func (MetaWindow *window,
+ void *data);
+
+static void meta_window_apply_session_info (MetaWindow *window,
+ const MetaWindowSessionInfo *info);
+
+static void unmaximize_window_before_freeing (MetaWindow *window);
+static void unminimize_window_and_all_transient_parents (MetaWindow *window);
+
+/* Idle handlers for the three queues. The "data" parameter in each case
+ * will be a GINT_TO_POINTER of the index into the queue arrays to use.
+ *
+ * TODO: Possibly there is still some code duplication among these, which we
+ * need to sort out at some point.
+ */
+static gboolean idle_calc_showing (gpointer data);
+static gboolean idle_move_resize (gpointer data);
+static gboolean idle_update_icon (gpointer data);
+
+#ifdef WITH_VERBOSE_MODE
+static const char*
+wm_state_to_string (int state)
+{
+ switch (state)
+ {
+ case NormalState:
+ return "NormalState";
+ case IconicState:
+ return "IconicState";
+ case WithdrawnState:
+ return "WithdrawnState";
+ }
+
+ return "Unknown";
+}
+#endif
+
+static gboolean
+is_desktop_or_dock_foreach (MetaWindow *window,
+ void *data)
+{
+ gboolean *result = data;
+
+ *result =
+ window->type == META_WINDOW_DESKTOP ||
+ window->type == META_WINDOW_DOCK;
+ if (*result)
+ return FALSE; /* stop as soon as we find one */
+ else
+ return TRUE;
+}
+
+/* window is the window that's newly mapped provoking
+ * the possible change
+ */
+static void
+maybe_leave_show_desktop_mode (MetaWindow *window)
+{
+ gboolean is_desktop_or_dock;
+
+ if (!window->screen->active_workspace->showing_desktop)
+ return;
+
+ /* If the window is a transient for the dock or desktop, don't
+ * leave show desktop mode when the window opens. That's
+ * so you can e.g. hide all windows, manipulate a file on
+ * the desktop via a dialog, then unshow windows again.
+ */
+ is_desktop_or_dock = FALSE;
+ is_desktop_or_dock_foreach (window,
+ &is_desktop_or_dock);
+
+ meta_window_foreach_ancestor (window, is_desktop_or_dock_foreach,
+ &is_desktop_or_dock);
+
+ if (!is_desktop_or_dock)
+ {
+ meta_screen_minimize_all_on_active_workspace_except (window->screen,
+ window);
+ meta_screen_unshow_desktop (window->screen);
+ }
+}
+
+MetaWindow*
+meta_window_new (MetaDisplay *display,
+ Window xwindow,
+ gboolean must_be_viewable)
+{
+ XWindowAttributes attrs;
+ MetaWindow *window;
+
+ meta_display_grab (display);
+ meta_error_trap_push (display); /* Push a trap over all of window
+ * creation, to reduce XSync() calls
+ */
+
+ meta_error_trap_push_with_return (display);
+
+ if (XGetWindowAttributes (display->xdisplay,xwindow, &attrs))
+ {
+ if(meta_error_trap_pop_with_return (display, TRUE) != Success)
+ {
+ meta_verbose ("Failed to get attributes for window 0x%lx\n",
+ xwindow);
+ meta_error_trap_pop (display, TRUE);
+ meta_display_ungrab (display);
+ return NULL;
+ }
+ window = meta_window_new_with_attrs (display, xwindow,
+ must_be_viewable, &attrs);
+ }
+ else
+ {
+ meta_error_trap_pop_with_return (display, TRUE);
+ meta_verbose ("Failed to get attributes for window 0x%lx\n",
+ xwindow);
+ meta_error_trap_pop (display, TRUE);
+ meta_display_ungrab (display);
+ return NULL;
+ }
+
+
+ meta_error_trap_pop (display, FALSE);
+ meta_display_ungrab (display);
+
+ return window;
+}
+
+MetaWindow*
+meta_window_new_with_attrs (MetaDisplay *display,
+ Window xwindow,
+ gboolean must_be_viewable,
+ XWindowAttributes *attrs)
+{
+ MetaWindow *window;
+ GSList *tmp;
+ MetaWorkspace *space;
+ gulong existing_wm_state;
+ gulong event_mask;
+ MetaMoveResizeFlags flags;
+#define N_INITIAL_PROPS 19
+ Atom initial_props[N_INITIAL_PROPS];
+ int i;
+ gboolean has_shape;
+
+ g_assert (attrs != NULL);
+ g_assert (N_INITIAL_PROPS == (int) G_N_ELEMENTS (initial_props));
+
+ meta_verbose ("Attempting to manage 0x%lx\n", xwindow);
+
+ if (meta_display_xwindow_is_a_no_focus_window (display, xwindow))
+ {
+ meta_verbose ("Not managing no_focus_window 0x%lx\n",
+ xwindow);
+ return NULL;
+ }
+
+ if (attrs->override_redirect)
+ {
+ meta_verbose ("Deciding not to manage override_redirect window 0x%lx\n", xwindow);
+ return NULL;
+ }
+
+ /* Grab server */
+ meta_display_grab (display);
+ meta_error_trap_push (display); /* Push a trap over all of window
+ * creation, to reduce XSync() calls
+ */
+
+ meta_verbose ("must_be_viewable = %d attrs->map_state = %d (%s)\n",
+ must_be_viewable,
+ attrs->map_state,
+ (attrs->map_state == IsUnmapped) ?
+ "IsUnmapped" :
+ (attrs->map_state == IsViewable) ?
+ "IsViewable" :
+ (attrs->map_state == IsUnviewable) ?
+ "IsUnviewable" :
+ "(unknown)");
+
+ existing_wm_state = WithdrawnState;
+ if (must_be_viewable && attrs->map_state != IsViewable)
+ {
+ /* Only manage if WM_STATE is IconicState or NormalState */
+ gulong state;
+
+ /* WM_STATE isn't a cardinal, it's type WM_STATE, but is an int */
+ if (!(meta_prop_get_cardinal_with_atom_type (display, xwindow,
+ display->atom_WM_STATE,
+ display->atom_WM_STATE,
+ &state) &&
+ (state == IconicState || state == NormalState)))
+ {
+ meta_verbose ("Deciding not to manage unmapped or unviewable window 0x%lx\n", xwindow);
+ meta_error_trap_pop (display, TRUE);
+ meta_display_ungrab (display);
+ return NULL;
+ }
+
+ existing_wm_state = state;
+ meta_verbose ("WM_STATE of %lx = %s\n", xwindow,
+ wm_state_to_string (existing_wm_state));
+ }
+
+ meta_error_trap_push_with_return (display);
+
+ XAddToSaveSet (display->xdisplay, xwindow);
+
+ event_mask =
+ PropertyChangeMask | EnterWindowMask | LeaveWindowMask |
+ FocusChangeMask | ColormapChangeMask;
+
+ XSelectInput (display->xdisplay, xwindow, event_mask);
+
+ has_shape = FALSE;
+#ifdef HAVE_SHAPE
+ if (META_DISPLAY_HAS_SHAPE (display))
+ {
+ int x_bounding, y_bounding, x_clip, y_clip;
+ unsigned w_bounding, h_bounding, w_clip, h_clip;
+ int bounding_shaped, clip_shaped;
+
+ XShapeSelectInput (display->xdisplay, xwindow, ShapeNotifyMask);
+
+ XShapeQueryExtents (display->xdisplay, xwindow,
+ &bounding_shaped, &x_bounding, &y_bounding,
+ &w_bounding, &h_bounding,
+ &clip_shaped, &x_clip, &y_clip,
+ &w_clip, &h_clip);
+
+ has_shape = bounding_shaped != FALSE;
+
+ meta_topic (META_DEBUG_SHAPES,
+ "Window has_shape = %d extents %d,%d %u x %u\n",
+ has_shape, x_bounding, y_bounding,
+ w_bounding, h_bounding);
+ }
+#endif
+
+ /* Get rid of any borders */
+ if (attrs->border_width != 0)
+ XSetWindowBorderWidth (display->xdisplay, xwindow, 0);
+
+ /* Get rid of weird gravities */
+ if (attrs->win_gravity != NorthWestGravity)
+ {
+ XSetWindowAttributes set_attrs;
+
+ set_attrs.win_gravity = NorthWestGravity;
+
+ XChangeWindowAttributes (display->xdisplay,
+ xwindow,
+ CWWinGravity,
+ &set_attrs);
+ }
+
+ if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+ {
+ meta_verbose ("Window 0x%lx disappeared just as we tried to manage it\n",
+ xwindow);
+ meta_error_trap_pop (display, FALSE);
+ meta_display_ungrab (display);
+ return NULL;
+ }
+
+ g_assert (!attrs->override_redirect);
+
+ window = g_new (MetaWindow, 1);
+
+ window->constructing = TRUE;
+
+ window->dialog_pid = -1;
+
+ window->xwindow = xwindow;
+
+ /* this is in window->screen->display, but that's too annoying to
+ * type
+ */
+ window->display = display;
+ window->workspace = NULL;
+
+#ifdef HAVE_XSYNC
+ window->sync_request_counter = None;
+ window->sync_request_serial = 0;
+ window->sync_request_time.tv_sec = 0;
+ window->sync_request_time.tv_usec = 0;
+#endif
+
+ window->screen = NULL;
+ tmp = display->screens;
+ while (tmp != NULL)
+ {
+ MetaScreen *scr = tmp->data;
+
+ if (scr->xroot == attrs->root)
+ {
+ window->screen = tmp->data;
+ break;
+ }
+
+ tmp = tmp->next;
+ }
+
+ g_assert (window->screen);
+
+ window->desc = g_strdup_printf ("0x%lx", window->xwindow);
+
+ /* avoid tons of stack updates */
+ meta_stack_freeze (window->screen->stack);
+
+ window->has_shape = has_shape;
+
+ window->rect.x = attrs->x;
+ window->rect.y = attrs->y;
+ window->rect.width = attrs->width;
+ window->rect.height = attrs->height;
+
+ /* And border width, size_hints are the "request" */
+ window->border_width = attrs->border_width;
+ window->size_hints.x = attrs->x;
+ window->size_hints.y = attrs->y;
+ window->size_hints.width = attrs->width;
+ window->size_hints.height = attrs->height;
+ /* initialize the remaining size_hints as if size_hints.flags were zero */
+ meta_set_normal_hints (window, NULL);
+
+ /* And this is our unmaximized size */
+ window->saved_rect = window->rect;
+ window->user_rect = window->rect;
+
+ window->depth = attrs->depth;
+ window->xvisual = attrs->visual;
+ window->colormap = attrs->colormap;
+
+ window->title = NULL;
+ window->icon_name = NULL;
+ window->icon = NULL;
+ window->mini_icon = NULL;
+ meta_icon_cache_init (&window->icon_cache);
+ window->wm_hints_pixmap = None;
+ window->wm_hints_mask = None;
+
+ window->frame = NULL;
+ window->has_focus = FALSE;
+
+ window->maximized_horizontally = FALSE;
+ window->maximized_vertically = FALSE;
+ window->maximize_horizontally_after_placement = FALSE;
+ window->maximize_vertically_after_placement = FALSE;
+ window->minimize_after_placement = FALSE;
+ window->fullscreen_after_placement = FALSE;
+ window->fullscreen_monitors[0] = -1;
+ window->require_fully_onscreen = TRUE;
+ window->require_on_single_xinerama = TRUE;
+ window->require_titlebar_visible = TRUE;
+ window->on_all_workspaces = FALSE;
+ window->shaded = FALSE;
+ window->initially_iconic = FALSE;
+ window->minimized = FALSE;
+ window->was_minimized = FALSE;
+ window->tab_unminimized = FALSE;
+ window->iconic = FALSE;
+ window->mapped = attrs->map_state != IsUnmapped;
+ /* if already mapped, no need to worry about focus-on-first-time-showing */
+ window->showing_for_first_time = !window->mapped;
+ /* if already mapped we don't want to do the placement thing */
+ window->placed = window->mapped;
+ if (window->placed)
+ meta_topic (META_DEBUG_PLACEMENT,
+ "Not placing window 0x%lx since it's already mapped\n",
+ xwindow);
+ window->force_save_user_rect = TRUE;
+ window->denied_focus_and_not_transient = FALSE;
+ window->unmanaging = FALSE;
+ window->is_in_queues = 0;
+ window->keys_grabbed = FALSE;
+ window->grab_on_frame = FALSE;
+ window->all_keys_grabbed = FALSE;
+ window->withdrawn = FALSE;
+ window->initial_workspace_set = FALSE;
+ window->initial_timestamp_set = FALSE;
+ window->net_wm_user_time_set = FALSE;
+ window->user_time_window = None;
+ window->calc_placement = FALSE;
+ window->shaken_loose = FALSE;
+ window->have_focus_click_grab = FALSE;
+ window->disable_sync = FALSE;
+
+ window->unmaps_pending = 0;
+
+ window->mwm_decorated = TRUE;
+ window->mwm_border_only = FALSE;
+ window->mwm_has_close_func = TRUE;
+ window->mwm_has_minimize_func = TRUE;
+ window->mwm_has_maximize_func = TRUE;
+ window->mwm_has_move_func = TRUE;
+ window->mwm_has_resize_func = TRUE;
+
+ window->decorated = TRUE;
+ window->has_close_func = TRUE;
+ window->has_minimize_func = TRUE;
+ window->has_maximize_func = TRUE;
+ window->has_move_func = TRUE;
+ window->has_resize_func = TRUE;
+
+ window->has_shade_func = TRUE;
+
+ window->has_fullscreen_func = TRUE;
+
+ window->always_sticky = FALSE;
+
+ window->wm_state_modal = FALSE;
+ window->skip_taskbar = FALSE;
+ window->skip_pager = FALSE;
+ window->wm_state_skip_taskbar = FALSE;
+ window->wm_state_skip_pager = FALSE;
+ window->wm_state_above = FALSE;
+ window->wm_state_below = FALSE;
+ window->wm_state_demands_attention = FALSE;
+
+ window->res_class = NULL;
+ window->res_name = NULL;
+ window->role = NULL;
+ window->sm_client_id = NULL;
+ window->wm_client_machine = NULL;
+ window->startup_id = NULL;
+
+ window->net_wm_pid = -1;
+
+ window->xtransient_for = None;
+ window->xclient_leader = None;
+ window->transient_parent_is_root_window = FALSE;
+
+ window->type = META_WINDOW_NORMAL;
+ window->type_atom = None;
+
+ window->struts = NULL;
+
+ window->using_net_wm_name = FALSE;
+ window->using_net_wm_visible_name = FALSE;
+ window->using_net_wm_icon_name = FALSE;
+ window->using_net_wm_visible_icon_name = FALSE;
+
+ window->need_reread_icon = TRUE;
+
+ window->layer = META_LAYER_LAST; /* invalid value */
+ window->stack_position = -1;
+ window->initial_workspace = 0; /* not used */
+ window->initial_timestamp = 0; /* not used */
+
+ meta_display_register_x_window (display, &window->xwindow, window);
+
+
+ /* assign the window to its group, or create a new group if needed
+ */
+ window->group = NULL;
+ window->xgroup_leader = None;
+ meta_window_compute_group (window);
+
+ /* Fill these in the order we want them to be gotten. we want to
+ * get window name and class first so we can use them in error
+ * messages and such. However, name is modified depending on
+ * wm_client_machine, so push it slightly sooner.
+ */
+ i = 0;
+ initial_props[i++] = display->atom_WM_CLIENT_MACHINE;
+ initial_props[i++] = display->atom__NET_WM_PID;
+ initial_props[i++] = display->atom__NET_WM_NAME;
+ initial_props[i++] = XA_WM_CLASS;
+ initial_props[i++] = XA_WM_NAME;
+ initial_props[i++] = display->atom__NET_WM_ICON_NAME;
+ initial_props[i++] = XA_WM_ICON_NAME;
+ initial_props[i++] = display->atom__NET_WM_DESKTOP;
+ initial_props[i++] = display->atom__NET_STARTUP_ID;
+ initial_props[i++] = display->atom__NET_WM_SYNC_REQUEST_COUNTER;
+ initial_props[i++] = XA_WM_NORMAL_HINTS;
+ initial_props[i++] = display->atom_WM_PROTOCOLS;
+ initial_props[i++] = XA_WM_HINTS;
+ initial_props[i++] = display->atom__NET_WM_USER_TIME;
+ initial_props[i++] = display->atom__NET_WM_STATE;
+ initial_props[i++] = display->atom__MOTIF_WM_HINTS;
+ initial_props[i++] = XA_WM_TRANSIENT_FOR;
+ initial_props[i++] = display->atom__NET_WM_USER_TIME_WINDOW;
+ initial_props[i++] = display->atom__NET_WM_FULLSCREEN_MONITORS;
+ g_assert (N_INITIAL_PROPS == i);
+
+ meta_window_reload_properties (window, initial_props, N_INITIAL_PROPS, TRUE);
+
+ update_sm_hints (window); /* must come after transient_for */
+ meta_window_update_role (window);
+ meta_window_update_net_wm_type (window);
+ meta_window_update_icon_now (window);
+
+ if (window->initially_iconic)
+ {
+ /* WM_HINTS said minimized */
+ window->minimized = TRUE;
+ meta_verbose ("Window %s asked to start out minimized\n", window->desc);
+ }
+
+ if (existing_wm_state == IconicState)
+ {
+ /* WM_STATE said minimized */
+ window->minimized = TRUE;
+ meta_verbose ("Window %s had preexisting WM_STATE = IconicState, minimizing\n",
+ window->desc);
+
+ /* Assume window was previously placed, though perhaps it's
+ * been iconic its whole life, we have no way of knowing.
+ */
+ window->placed = TRUE;
+ }
+
+ /* Apply any window attributes such as initial workspace
+ * based on startup notification
+ */
+ meta_screen_apply_startup_properties (window->screen, window);
+
+ /* Try to get a "launch timestamp" for the window. If the window is
+ * a transient, we'd like to be able to get a last-usage timestamp
+ * from the parent window. If the window has no parent, there isn't
+ * much we can do...except record the current time so that any children
+ * can use this time as a fallback.
+ */
+ if (!window->net_wm_user_time_set) {
+ MetaWindow *parent = NULL;
+ if (window->xtransient_for)
+ parent = meta_display_lookup_x_window (window->display,
+ window->xtransient_for);
+
+ /* First, maybe the app was launched with startup notification using an
+ * obsolete version of the spec; use that timestamp if it exists.
+ */
+ if (window->initial_timestamp_set)
+ /* NOTE: Do NOT toggle net_wm_user_time_set to true; this is just
+ * being recorded as a fallback for potential transients
+ */
+ window->net_wm_user_time = window->initial_timestamp;
+ else if (parent != NULL)
+ meta_window_set_user_time(window, parent->net_wm_user_time);
+ else
+ /* NOTE: Do NOT toggle net_wm_user_time_set to true; this is just
+ * being recorded as a fallback for potential transients
+ */
+ window->net_wm_user_time =
+ meta_display_get_current_time_roundtrip (window->display);
+ }
+
+ if (window->decorated)
+ meta_window_ensure_frame (window);
+
+ meta_window_grab_keys (window);
+ if (window->type != META_WINDOW_DOCK)
+ {
+ meta_display_grab_window_buttons (window->display, window->xwindow);
+ meta_display_grab_focus_window_button (window->display, window);
+ }
+
+ if (window->type == META_WINDOW_DESKTOP ||
+ window->type == META_WINDOW_DOCK)
+ {
+ /* Change the default, but don't enforce this if the user
+ * focuses the dock/desktop and unsticks it using key shortcuts.
+ * Need to set this before adding to the workspaces so the MRU
+ * lists will be updated.
+ */
+ window->on_all_workspaces = TRUE;
+ }
+
+ /* For the workspace, first honor hints,
+ * if that fails put transients with parents,
+ * otherwise put window on active space
+ */
+
+ if (window->initial_workspace_set)
+ {
+ if (window->initial_workspace == (int) 0xFFFFFFFF)
+ {
+ meta_topic (META_DEBUG_PLACEMENT,
+ "Window %s is initially on all spaces\n",
+ window->desc);
+
+ /* need to set on_all_workspaces first so that it will be
+ * added to all the MRU lists
+ */
+ window->on_all_workspaces = TRUE;
+ meta_workspace_add_window (window->screen->active_workspace, window);
+ }
+ else
+ {
+ meta_topic (META_DEBUG_PLACEMENT,
+ "Window %s is initially on space %d\n",
+ window->desc, window->initial_workspace);
+
+ space =
+ meta_screen_get_workspace_by_index (window->screen,
+ window->initial_workspace);
+
+ if (space)
+ meta_workspace_add_window (space, window);
+ }
+ }
+
+ if (window->workspace == NULL &&
+ window->xtransient_for != None)
+ {
+ /* Try putting dialog on parent's workspace */
+ MetaWindow *parent;
+
+ parent = meta_display_lookup_x_window (window->display,
+ window->xtransient_for);
+
+ if (parent && parent->workspace)
+ {
+ meta_topic (META_DEBUG_PLACEMENT,
+ "Putting window %s on same workspace as parent %s\n",
+ window->desc, parent->desc);
+
+ if (parent->on_all_workspaces)
+ window->on_all_workspaces = TRUE;
+
+ /* this will implicitly add to the appropriate MRU lists
+ */
+ meta_workspace_add_window (parent->workspace, window);
+ }
+ }
+
+ if (window->workspace == NULL)
+ {
+ meta_topic (META_DEBUG_PLACEMENT,
+ "Putting window %s on active workspace\n",
+ window->desc);
+
+ space = window->screen->active_workspace;
+
+ meta_workspace_add_window (space, window);
+ }
+
+ /* for the various on_all_workspaces = TRUE possible above */
+ meta_window_set_current_workspace_hint (window);
+
+ meta_window_update_struts (window);
+
+ /* Must add window to stack before doing move/resize, since the
+ * window might have fullscreen size (i.e. should have been
+ * fullscreen'd; acrobat is one such braindead case; it withdraws
+ * and remaps its window whenever trying to become fullscreen...)
+ * and thus constraints may try to auto-fullscreen it which also
+ * means restacking it.
+ */
+ meta_stack_add (window->screen->stack,
+ window);
+
+ /* Put our state back where it should be,
+ * passing TRUE for is_configure_request, ICCCM says
+ * initial map is handled same as configure request
+ */
+ flags =
+ META_IS_CONFIGURE_REQUEST | META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION;
+ meta_window_move_resize_internal (window,
+ flags,
+ window->size_hints.win_gravity,
+ window->size_hints.x,
+ window->size_hints.y,
+ window->size_hints.width,
+ window->size_hints.height);
+
+ /* Now try applying saved stuff from the session */
+ {
+ const MetaWindowSessionInfo *info;
+
+ info = meta_window_lookup_saved_state (window);
+
+ if (info)
+ {
+ meta_window_apply_session_info (window, info);
+ meta_window_release_saved_state (info);
+ }
+ }
+
+ /* FIXME we have a tendency to set this then immediately
+ * change it again.
+ */
+ set_wm_state (window, window->iconic ? IconicState : NormalState);
+ set_net_wm_state (window);
+
+ /* Sync stack changes */
+ meta_stack_thaw (window->screen->stack);
+
+ /* disable show desktop mode unless we're a desktop component */
+ maybe_leave_show_desktop_mode (window);
+
+ meta_window_queue (window, META_QUEUE_CALC_SHOWING);
+ /* See bug 303284; a transient of the given window can already exist, in which
+ * case we think it should probably be shown.
+ */
+ meta_window_foreach_transient (window,
+ queue_calc_showing_func,
+ NULL);
+ /* See bug 334899; the window may have minimized ancestors
+ * which need to be shown.
+ *
+ * However, we shouldn't unminimize windows here when opening
+ * a new display because that breaks passing _NET_WM_STATE_HIDDEN
+ * between window managers when replacing them; see bug 358042.
+ *
+ * And we shouldn't unminimize windows if they were initially
+ * iconic.
+ */
+ if (!display->display_opening && !window->initially_iconic)
+ unminimize_window_and_all_transient_parents (window);
+
+ meta_error_trap_pop (display, FALSE); /* pop the XSync()-reducing trap */
+ meta_display_ungrab (display);
+
+ window->constructing = FALSE;
+
+ return window;
+}
+
+/* This function should only be called from the end of meta_window_new_with_attrs () */
+static void
+meta_window_apply_session_info (MetaWindow *window,
+ const MetaWindowSessionInfo *info)
+{
+ if (info->stack_position_set)
+ {
+ meta_topic (META_DEBUG_SM,
+ "Restoring stack position %d for window %s\n",
+ info->stack_position, window->desc);
+
+ /* FIXME well, I'm not sure how to do this. */
+ }
+
+ if (info->minimized_set)
+ {
+ meta_topic (META_DEBUG_SM,
+ "Restoring minimized state %d for window %s\n",
+ info->minimized, window->desc);
+
+ if (window->has_minimize_func && info->minimized)
+ meta_window_minimize (window);
+ }
+
+ if (info->maximized_set)
+ {
+ meta_topic (META_DEBUG_SM,
+ "Restoring maximized state %d for window %s\n",
+ info->maximized, window->desc);
+
+ if (window->has_maximize_func && info->maximized)
+ {
+ meta_window_maximize (window,
+ META_MAXIMIZE_HORIZONTAL |
+ META_MAXIMIZE_VERTICAL);
+
+ if (info->saved_rect_set)
+ {
+ meta_topic (META_DEBUG_SM,
+ "Restoring saved rect %d,%d %dx%d for window %s\n",
+ info->saved_rect.x,
+ info->saved_rect.y,
+ info->saved_rect.width,
+ info->saved_rect.height,
+ window->desc);
+
+ window->saved_rect.x = info->saved_rect.x;
+ window->saved_rect.y = info->saved_rect.y;
+ window->saved_rect.width = info->saved_rect.width;
+ window->saved_rect.height = info->saved_rect.height;
+ }
+ }
+ }
+
+ if (info->on_all_workspaces_set)
+ {
+ window->on_all_workspaces = info->on_all_workspaces;
+ meta_topic (META_DEBUG_SM,
+ "Restoring sticky state %d for window %s\n",
+ window->on_all_workspaces, window->desc);
+ }
+
+ if (info->workspace_indices)
+ {
+ GSList *tmp;
+ GSList *spaces;
+
+ spaces = NULL;
+
+ tmp = info->workspace_indices;
+ while (tmp != NULL)
+ {
+ MetaWorkspace *space;
+
+ space =
+ meta_screen_get_workspace_by_index (window->screen,
+ GPOINTER_TO_INT (tmp->data));
+
+ if (space)
+ spaces = g_slist_prepend (spaces, space);
+
+ tmp = tmp->next;
+ }
+
+ if (spaces)
+ {
+ /* This briefly breaks the invariant that we are supposed
+ * to always be on some workspace. But we paranoically
+ * ensured that one of the workspaces from the session was
+ * indeed valid, so we know we'll go right back to one.
+ */
+ if (window->workspace)
+ meta_workspace_remove_window (window->workspace, window);
+
+ /* Only restore to the first workspace if the window
+ * happened to be on more than one, since we have replaces
+ * window->workspaces with window->workspace
+ */
+ meta_workspace_add_window (spaces->data, window);
+
+ meta_topic (META_DEBUG_SM,
+ "Restoring saved window %s to workspace %d\n",
+ window->desc,
+ meta_workspace_index (spaces->data));
+
+ g_slist_free (spaces);
+ }
+ }
+
+ if (info->geometry_set)
+ {
+ int x, y, w, h;
+ MetaMoveResizeFlags flags;
+
+ window->placed = TRUE; /* don't do placement algorithms later */
+
+ x = info->rect.x;
+ y = info->rect.y;
+
+ w = window->size_hints.base_width +
+ info->rect.width * window->size_hints.width_inc;
+ h = window->size_hints.base_height +
+ info->rect.height * window->size_hints.height_inc;
+
+ /* Force old gravity, ignoring anything now set */
+ window->size_hints.win_gravity = info->gravity;
+
+ meta_topic (META_DEBUG_SM,
+ "Restoring pos %d,%d size %d x %d for %s\n",
+ x, y, w, h, window->desc);
+
+ flags = META_DO_GRAVITY_ADJUST | META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION;
+ meta_window_move_resize_internal (window,
+ flags,
+ window->size_hints.win_gravity,
+ x, y, w, h);
+ }
+}
+
+void
+meta_window_free (MetaWindow *window,
+ guint32 timestamp)
+{
+ GList *tmp;
+
+ meta_verbose ("Unmanaging 0x%lx\n", window->xwindow);
+
+ if (window->display->compositor)
+ meta_compositor_free_window (window->display->compositor, window);
+
+ if (window->display->window_with_menu == window)
+ {
+ meta_ui_window_menu_free (window->display->window_menu);
+ window->display->window_menu = NULL;
+ window->display->window_with_menu = NULL;
+ }
+
+ if (destroying_windows_disallowed > 0)
+ meta_bug ("Tried to destroy window %s while destruction was not allowed\n",
+ window->desc);
+
+ window->unmanaging = TRUE;
+
+ if (window->fullscreen)
+ {
+ MetaGroup *group;
+
+ /* If the window is fullscreen, it may be forcing
+ * other windows in its group to a higher layer
+ */
+
+ meta_stack_freeze (window->screen->stack);
+ group = meta_window_get_group (window);
+ if (group)
+ meta_group_update_layers (group);
+ meta_stack_thaw (window->screen->stack);
+ }
+
+ meta_window_shutdown_group (window); /* safe to do this early as
+ * group.c won't re-add to the
+ * group if window->unmanaging
+ */
+
+ /* If we have the focus, focus some other window.
+ * This is done first, so that if the unmap causes
+ * an EnterNotify the EnterNotify will have final say
+ * on what gets focused, maintaining sloppy focus
+ * invariants.
+ */
+ if (window->has_focus)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "Focusing default window since we're unmanaging %s\n",
+ window->desc);
+ meta_workspace_focus_default_window (window->screen->active_workspace,
+ window,
+ timestamp);
+ }
+ else if (window->display->expected_focus_window == window)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "Focusing default window since expected focus window freed %s\n",
+ window->desc);
+ window->display->expected_focus_window = NULL;
+ meta_workspace_focus_default_window (window->screen->active_workspace,
+ window,
+ timestamp);
+ }
+ else
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "Unmanaging window %s which doesn't currently have focus\n",
+ window->desc);
+ }
+
+ if (window->struts)
+ {
+ meta_free_gslist_and_elements (window->struts);
+ window->struts = NULL;
+
+ meta_topic (META_DEBUG_WORKAREA,
+ "Unmanaging window %s which has struts, so invalidating work areas\n",
+ window->desc);
+ invalidate_work_areas (window);
+ }
+
+ if (window->display->grab_window == window)
+ meta_display_end_grab_op (window->display, timestamp);
+
+ g_assert (window->display->grab_window != window);
+
+ if (window->display->focus_window == window)
+ {
+ window->display->focus_window = NULL;
+ meta_compositor_set_active_window (window->display->compositor,
+ window->screen, NULL);
+ }
+
+ if (window->maximized_horizontally || window->maximized_vertically)
+ unmaximize_window_before_freeing (window);
+
+ /* The XReparentWindow call in meta_window_destroy_frame() moves the
+ * window so we need to send a configure notify; see bug 399552. (We
+ * also do this just in case a window got unmaximized.)
+ */
+ send_configure_notify (window);
+
+ meta_window_unqueue (window, META_QUEUE_CALC_SHOWING |
+ META_QUEUE_MOVE_RESIZE |
+ META_QUEUE_UPDATE_ICON);
+ meta_window_free_delete_dialog (window);
+
+ if (window->workspace)
+ meta_workspace_remove_window (window->workspace, window);
+
+ g_assert (window->workspace == NULL);
+
+#ifndef G_DISABLE_CHECKS
+ tmp = window->screen->workspaces;
+ while (tmp != NULL)
+ {
+ MetaWorkspace *workspace = tmp->data;
+
+ g_assert (g_list_find (workspace->windows, window) == NULL);
+ g_assert (g_list_find (workspace->mru_list, window) == NULL);
+
+ tmp = tmp->next;
+ }
+#endif
+
+ meta_stack_remove (window->screen->stack, window);
+
+ if (window->frame)
+ meta_window_destroy_frame (window);
+
+ if (window->withdrawn)
+ {
+ /* We need to clean off the window's state so it
+ * won't be restored if the app maps it again.
+ */
+ meta_error_trap_push (window->display);
+ meta_verbose ("Cleaning state from window %s\n", window->desc);
+ XDeleteProperty (window->display->xdisplay,
+ window->xwindow,
+ window->display->atom__NET_WM_DESKTOP);
+ XDeleteProperty (window->display->xdisplay,
+ window->xwindow,
+ window->display->atom__NET_WM_STATE);
+ XDeleteProperty (window->display->xdisplay,
+ window->xwindow,
+ window->display->atom__NET_WM_FULLSCREEN_MONITORS);
+ set_wm_state (window, WithdrawnState);
+ meta_error_trap_pop (window->display, FALSE);
+ }
+ else
+ {
+ /* We need to put WM_STATE so that others will understand it on
+ * restart.
+ */
+ if (!window->minimized)
+ {
+ meta_error_trap_push (window->display);
+ set_wm_state (window, NormalState);
+ meta_error_trap_pop (window->display, FALSE);
+ }
+
+ /* And we need to be sure the window is mapped so other WMs
+ * know that it isn't Withdrawn
+ */
+ meta_error_trap_push (window->display);
+ XMapWindow (window->display->xdisplay,
+ window->xwindow);
+ meta_error_trap_pop (window->display, FALSE);
+ }
+
+ meta_window_ungrab_keys (window);
+ meta_display_ungrab_window_buttons (window->display, window->xwindow);
+ meta_display_ungrab_focus_window_button (window->display, window);
+
+ meta_display_unregister_x_window (window->display, window->xwindow);
+
+
+ meta_error_trap_push (window->display);
+
+ /* Put back anything we messed up */
+ if (window->border_width != 0)
+ XSetWindowBorderWidth (window->display->xdisplay,
+ window->xwindow,
+ window->border_width);
+
+ /* No save set */
+ XRemoveFromSaveSet (window->display->xdisplay,
+ window->xwindow);
+
+ /* Don't get events on not-managed windows */
+ XSelectInput (window->display->xdisplay,
+ window->xwindow,
+ NoEventMask);
+
+ /* Stop getting events for the window's _NET_WM_USER_TIME_WINDOW too */
+ if (window->user_time_window != None)
+ {
+ meta_display_unregister_x_window (window->display,
+ window->user_time_window);
+ XSelectInput (window->display->xdisplay,
+ window->user_time_window,
+ NoEventMask);
+ window->user_time_window = None;
+ }
+
+#ifdef HAVE_SHAPE
+ if (META_DISPLAY_HAS_SHAPE (window->display))
+ XShapeSelectInput (window->display->xdisplay, window->xwindow, NoEventMask);
+#endif
+
+ meta_error_trap_pop (window->display, FALSE);
+
+ if (window->icon)
+ g_object_unref (G_OBJECT (window->icon));
+
+ if (window->mini_icon)
+ g_object_unref (G_OBJECT (window->mini_icon));
+
+ meta_icon_cache_free (&window->icon_cache);
+
+ g_free (window->sm_client_id);
+ g_free (window->wm_client_machine);
+ g_free (window->startup_id);
+ g_free (window->role);
+ g_free (window->res_class);
+ g_free (window->res_name);
+ g_free (window->title);
+ g_free (window->icon_name);
+ g_free (window->desc);
+ g_free (window);
+}
+
+static void
+set_wm_state (MetaWindow *window,
+ int state)
+{
+ unsigned long data[2];
+
+ meta_verbose ("Setting wm state %s on %s\n",
+ wm_state_to_string (state), window->desc);
+
+ /* Marco doesn't use icon windows, so data[1] should be None
+ * according to the ICCCM 2.0 Section 4.1.3.1.
+ */
+ data[0] = state;
+ data[1] = None;
+
+ meta_error_trap_push (window->display);
+ XChangeProperty (window->display->xdisplay, window->xwindow,
+ window->display->atom_WM_STATE,
+ window->display->atom_WM_STATE,
+ 32, PropModeReplace, (guchar*) data, 2);
+ meta_error_trap_pop (window->display, FALSE);
+}
+
+static void
+set_net_wm_state (MetaWindow *window)
+{
+ int i;
+ unsigned long data[12];
+
+ i = 0;
+ if (window->shaded)
+ {
+ data[i] = window->display->atom__NET_WM_STATE_SHADED;
+ ++i;
+ }
+ if (window->wm_state_modal)
+ {
+ data[i] = window->display->atom__NET_WM_STATE_MODAL;
+ ++i;
+ }
+ if (window->skip_pager)
+ {
+ data[i] = window->display->atom__NET_WM_STATE_SKIP_PAGER;
+ ++i;
+ }
+ if (window->skip_taskbar)
+ {
+ data[i] = window->display->atom__NET_WM_STATE_SKIP_TASKBAR;
+ ++i;
+ }
+ if (window->maximized_horizontally)
+ {
+ data[i] = window->display->atom__NET_WM_STATE_MAXIMIZED_HORZ;
+ ++i;
+ }
+ if (window->maximized_vertically)
+ {
+ data[i] = window->display->atom__NET_WM_STATE_MAXIMIZED_VERT;
+ ++i;
+ }
+ if (window->fullscreen)
+ {
+ data[i] = window->display->atom__NET_WM_STATE_FULLSCREEN;
+ ++i;
+ }
+ if (!meta_window_showing_on_its_workspace (window) || window->shaded)
+ {
+ data[i] = window->display->atom__NET_WM_STATE_HIDDEN;
+ ++i;
+ }
+ if (window->wm_state_above)
+ {
+ data[i] = window->display->atom__NET_WM_STATE_ABOVE;
+ ++i;
+ }
+ if (window->wm_state_below)
+ {
+ data[i] = window->display->atom__NET_WM_STATE_BELOW;
+ ++i;
+ }
+ if (window->wm_state_demands_attention)
+ {
+ data[i] = window->display->atom__NET_WM_STATE_DEMANDS_ATTENTION;
+ ++i;
+ }
+ if (window->on_all_workspaces)
+ {
+ data[i] = window->display->atom__NET_WM_STATE_STICKY;
+ ++i;
+ }
+
+ meta_verbose ("Setting _NET_WM_STATE with %d atoms\n", i);
+
+ meta_error_trap_push (window->display);
+ XChangeProperty (window->display->xdisplay, window->xwindow,
+ window->display->atom__NET_WM_STATE,
+ XA_ATOM,
+ 32, PropModeReplace, (guchar*) data, i);
+ meta_error_trap_pop (window->display, FALSE);
+
+ if (window->fullscreen)
+ {
+ data[0] = window->fullscreen_monitors[0];
+ data[1] = window->fullscreen_monitors[1];
+ data[2] = window->fullscreen_monitors[2];
+ data[3] = window->fullscreen_monitors[3];
+
+ meta_verbose ("Setting _NET_WM_FULLSCREEN_MONITORS\n");
+ meta_error_trap_push (window->display);
+ XChangeProperty (window->display->xdisplay,
+ window->xwindow,
+ window->display->atom__NET_WM_FULLSCREEN_MONITORS,
+ XA_CARDINAL, 32, PropModeReplace,
+ (guchar*) data, 4);
+ meta_error_trap_pop (window->display, FALSE);
+ }
+}
+
+gboolean
+meta_window_located_on_workspace (MetaWindow *window,
+ MetaWorkspace *workspace)
+{
+ return (window->on_all_workspaces && window->screen == workspace->screen) ||
+ (window->workspace == workspace);
+}
+
+static gboolean
+is_minimized_foreach (MetaWindow *window,
+ void *data)
+{
+ gboolean *result = data;
+
+ *result = window->minimized;
+ if (*result)
+ return FALSE; /* stop as soon as we find one */
+ else
+ return TRUE;
+}
+
+static gboolean
+ancestor_is_minimized (MetaWindow *window)
+{
+ gboolean is_minimized;
+
+ is_minimized = FALSE;
+
+ meta_window_foreach_ancestor (window, is_minimized_foreach, &is_minimized);
+
+ return is_minimized;
+}
+
+gboolean
+meta_window_showing_on_its_workspace (MetaWindow *window)
+{
+ gboolean showing;
+ gboolean is_desktop_or_dock;
+ MetaWorkspace* workspace_of_window;
+
+ showing = TRUE;
+
+ /* 1. See if we're minimized */
+ if (window->minimized)
+ showing = FALSE;
+
+ /* 2. See if we're in "show desktop" mode */
+ is_desktop_or_dock = FALSE;
+ is_desktop_or_dock_foreach (window,
+ &is_desktop_or_dock);
+
+ meta_window_foreach_ancestor (window, is_desktop_or_dock_foreach,
+ &is_desktop_or_dock);
+
+ if (window->on_all_workspaces)
+ workspace_of_window = window->screen->active_workspace;
+ else if (window->workspace)
+ workspace_of_window = window->workspace;
+ else /* This only seems to be needed for startup */
+ workspace_of_window = NULL;
+
+ if (showing &&
+ workspace_of_window && workspace_of_window->showing_desktop &&
+ !is_desktop_or_dock)
+ {
+ meta_verbose ("We're showing the desktop on the workspace(s) that window %s is on\n",
+ window->desc);
+ showing = FALSE;
+ }
+
+ /* 3. See if an ancestor is minimized (note that
+ * ancestor's "mapped" field may not be up to date
+ * since it's being computed in this same idle queue)
+ */
+
+ if (showing)
+ {
+ if (ancestor_is_minimized (window))
+ showing = FALSE;
+ }
+
+#if 0
+ /* 4. See if we're drawing wireframe
+ */
+ if (window->display->grab_window == window &&
+ window->display->grab_wireframe_active)
+ showing = FALSE;
+#endif
+
+ return showing;
+}
+
+gboolean
+meta_window_should_be_showing (MetaWindow *window)
+{
+ gboolean on_workspace;
+
+ meta_verbose ("Should be showing for window %s\n", window->desc);
+
+ /* See if we're on the workspace */
+ on_workspace = meta_window_located_on_workspace (window,
+ window->screen->active_workspace);
+
+ if (!on_workspace)
+ meta_verbose ("Window %s is not on workspace %d\n",
+ window->desc,
+ meta_workspace_index (window->screen->active_workspace));
+ else
+ meta_verbose ("Window %s is on the active workspace %d\n",
+ window->desc,
+ meta_workspace_index (window->screen->active_workspace));
+
+ if (window->on_all_workspaces)
+ meta_verbose ("Window %s is on all workspaces\n", window->desc);
+
+ return on_workspace && meta_window_showing_on_its_workspace (window);
+}
+
+static void
+finish_minimize (gpointer data)
+{
+ MetaWindow *window = data;
+ /* FIXME: It really sucks to put timestamp pinging here; it'd
+ * probably make more sense in implement_showing() so that it's at
+ * least not duplicated in meta_window_show; but since
+ * finish_minimize is a callback making things just slightly icky, I
+ * haven't done that yet.
+ */
+ guint32 timestamp = meta_display_get_current_time_roundtrip (window->display);
+
+ meta_window_hide (window);
+ if (window->has_focus)
+ {
+ meta_workspace_focus_default_window (window->screen->active_workspace,
+ window,
+ timestamp);
+ }
+}
+
+static void
+implement_showing (MetaWindow *window,
+ gboolean showing)
+{
+ /* Actually show/hide the window */
+ meta_verbose ("Implement showing = %d for window %s\n",
+ showing, window->desc);
+
+ if (!showing)
+ {
+ gboolean on_workspace;
+
+ on_workspace = meta_window_located_on_workspace (window,
+ window->screen->active_workspace);
+
+ /* Really this effects code should probably
+ * be in meta_window_hide so the window->mapped
+ * test isn't duplicated here. Anyhow, we animate
+ * if we are mapped now, we are supposed to
+ * be minimized, and we are on the current workspace.
+ */
+ if (on_workspace && window->minimized && window->mapped &&
+ !meta_prefs_get_reduced_resources ())
+ {
+ MetaRectangle icon_rect, window_rect;
+ gboolean result;
+
+ /* Check if the window has an icon geometry */
+ result = meta_window_get_icon_geometry (window, &icon_rect);
+
+ if (!result)
+ {
+ /* just animate into the corner somehow - maybe
+ * not a good idea...
+ */
+ icon_rect.x = window->screen->rect.width;
+ icon_rect.y = window->screen->rect.height;
+ icon_rect.width = 1;
+ icon_rect.height = 1;
+ }
+
+ meta_window_get_outer_rect (window, &window_rect);
+
+ meta_effect_run_minimize (window,
+ &window_rect,
+ &icon_rect,
+ finish_minimize,
+ window);
+ }
+ else
+ {
+ finish_minimize (window);
+ }
+ }
+ else
+ {
+ meta_window_show (window);
+ }
+}
+
+void
+meta_window_calc_showing (MetaWindow *window)
+{
+ implement_showing (window, meta_window_should_be_showing (window));
+}
+
+static guint queue_idle[NUMBER_OF_QUEUES] = {0, 0, 0};
+static GSList *queue_pending[NUMBER_OF_QUEUES] = {NULL, NULL, NULL};
+
+static int
+stackcmp (gconstpointer a, gconstpointer b)
+{
+ MetaWindow *aw = (gpointer) a;
+ MetaWindow *bw = (gpointer) b;
+
+ if (aw->screen != bw->screen)
+ return 0; /* don't care how they sort with respect to each other */
+ else
+ return meta_stack_windows_cmp (aw->screen->stack,
+ aw, bw);
+}
+
+static gboolean
+idle_calc_showing (gpointer data)
+{
+ GSList *tmp;
+ GSList *copy;
+ GSList *should_show;
+ GSList *should_hide;
+ GSList *unplaced;
+ GSList *displays;
+ MetaWindow *first_window;
+ guint queue_index = GPOINTER_TO_INT (data);
+
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "Clearing the calc_showing queue\n");
+
+ /* Work with a copy, for reentrancy. The allowed reentrancy isn't
+ * complete; destroying a window while we're in here would result in
+ * badness. But it's OK to queue/unqueue calc_showings.
+ */
+ copy = g_slist_copy (queue_pending[queue_index]);
+ g_slist_free (queue_pending[queue_index]);
+ queue_pending[queue_index] = NULL;
+ queue_idle[queue_index] = 0;
+
+ destroying_windows_disallowed += 1;
+
+ /* We map windows from top to bottom and unmap from bottom to
+ * top, to avoid extra expose events. The exception is
+ * for unplaced windows, which have to be mapped from bottom to
+ * top so placement works.
+ */
+ should_show = NULL;
+ should_hide = NULL;
+ unplaced = NULL;
+ displays = NULL;
+
+ tmp = copy;
+ while (tmp != NULL)
+ {
+ MetaWindow *window;
+
+ window = tmp->data;
+
+ if (!window->placed)
+ unplaced = g_slist_prepend (unplaced, window);
+ else if (meta_window_should_be_showing (window))
+ should_show = g_slist_prepend (should_show, window);
+ else
+ should_hide = g_slist_prepend (should_hide, window);
+
+ tmp = tmp->next;
+ }
+
+ /* bottom to top */
+ unplaced = g_slist_sort (unplaced, stackcmp);
+ should_hide = g_slist_sort (should_hide, stackcmp);
+ /* top to bottom */
+ should_show = g_slist_sort (should_show, stackcmp);
+ should_show = g_slist_reverse (should_show);
+
+ first_window = copy->data;
+
+ meta_display_grab (first_window->display);
+
+ tmp = unplaced;
+ while (tmp != NULL)
+ {
+ MetaWindow *window;
+
+ window = tmp->data;
+
+ meta_window_calc_showing (window);
+
+ tmp = tmp->next;
+ }
+
+ tmp = should_show;
+ while (tmp != NULL)
+ {
+ MetaWindow *window;
+
+ window = tmp->data;
+
+ implement_showing (window, TRUE);
+
+ tmp = tmp->next;
+ }
+
+ tmp = should_hide;
+ while (tmp != NULL)
+ {
+ MetaWindow *window;
+
+ window = tmp->data;
+
+ implement_showing (window, FALSE);
+
+ tmp = tmp->next;
+ }
+
+ tmp = copy;
+ while (tmp != NULL)
+ {
+ MetaWindow *window;
+
+ window = tmp->data;
+
+ /* important to set this here for reentrancy -
+ * if we queue a window again while it's in "copy",
+ * then queue_calc_showing will just return since
+ * we are still in the calc_showing queue
+ */
+ window->is_in_queues &= ~META_QUEUE_CALC_SHOWING;
+
+ tmp = tmp->next;
+ }
+
+ if (meta_prefs_get_focus_mode () != META_FOCUS_MODE_CLICK)
+ {
+ /* When display->mouse_mode is false, we want to ignore
+ * EnterNotify events unless they come from mouse motion. To do
+ * that, we set a sentinel property on the root window if we're
+ * not in mouse_mode.
+ */
+ tmp = should_show;
+ while (tmp != NULL)
+ {
+ MetaWindow *window = tmp->data;
+
+ if (!window->display->mouse_mode)
+ meta_display_increment_focus_sentinel (window->display);
+
+ tmp = tmp->next;
+ }
+ }
+
+ meta_display_ungrab (first_window->display);
+
+ g_slist_free (copy);
+
+ g_slist_free (unplaced);
+ g_slist_free (should_show);
+ g_slist_free (should_hide);
+ g_slist_free (displays);
+
+ destroying_windows_disallowed -= 1;
+
+ return FALSE;
+}
+
+#ifdef WITH_VERBOSE_MODE
+static const gchar* meta_window_queue_names[NUMBER_OF_QUEUES] =
+ {"calc_showing", "move_resize", "update_icon"};
+#endif
+
+static void
+meta_window_unqueue (MetaWindow *window, guint queuebits)
+{
+ gint queuenum;
+
+ for (queuenum=0; queuenum<NUMBER_OF_QUEUES; queuenum++)
+ {
+ if ((queuebits & 1<<queuenum) /* they have asked to unqueue */
+ &&
+ (window->is_in_queues & 1<<queuenum)) /* it's in the queue */
+ {
+
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "Removing %s from the %s queue\n",
+ window->desc,
+ meta_window_queue_names[queuenum]);
+
+ /* Note that window may not actually be in the queue
+ * because it may have been in "copy" inside the idle handler
+ */
+ queue_pending[queuenum] = g_slist_remove (queue_pending[queuenum], window);
+ window->is_in_queues &= ~(1<<queuenum);
+
+ /* Okay, so maybe we've used up all the entries in the queue.
+ * In that case, we should kill the function that deals with
+ * the queue, because there's nothing left for it to do.
+ */
+ if (queue_pending[queuenum] == NULL && queue_idle[queuenum] != 0)
+ {
+ g_source_remove (queue_idle[queuenum]);
+ queue_idle[queuenum] = 0;
+ }
+ }
+ }
+}
+
+static void
+meta_window_flush_calc_showing (MetaWindow *window)
+{
+ if (window->is_in_queues & META_QUEUE_CALC_SHOWING)
+ {
+ meta_window_unqueue (window, META_QUEUE_CALC_SHOWING);
+ meta_window_calc_showing (window);
+ }
+}
+
+void
+meta_window_queue (MetaWindow *window, guint queuebits)
+{
+ guint queuenum;
+
+ for (queuenum=0; queuenum<NUMBER_OF_QUEUES; queuenum++)
+ {
+ if (queuebits & 1<<queuenum)
+ {
+ /* Data which varies between queues.
+ * Yes, these do look a lot like associative arrays:
+ * I seem to be turning into a Perl programmer.
+ */
+
+ const gint window_queue_idle_priority[NUMBER_OF_QUEUES] =
+ {
+ G_PRIORITY_DEFAULT_IDLE, /* CALC_SHOWING */
+ META_PRIORITY_RESIZE, /* MOVE_RESIZE */
+ G_PRIORITY_DEFAULT_IDLE /* UPDATE_ICON */
+ };
+
+ const GSourceFunc window_queue_idle_handler[NUMBER_OF_QUEUES] =
+ {
+ idle_calc_showing,
+ idle_move_resize,
+ idle_update_icon,
+ };
+
+ /* If we're about to drop the window, there's no point in putting
+ * it on a queue.
+ */
+ if (window->unmanaging)
+ break;
+
+ /* If the window already claims to be in that queue, there's no
+ * point putting it in the queue.
+ */
+ if (window->is_in_queues & 1<<queuenum)
+ break;
+
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "Putting %s in the %s queue\n",
+ window->desc,
+ meta_window_queue_names[queuenum]);
+
+ /* So, mark it as being in this queue. */
+ window->is_in_queues |= 1<<queuenum;
+
+ /* There's not a lot of point putting things into a queue if
+ * nobody's on the other end pulling them out. Therefore,
+ * let's check to see whether an idle handler exists to do
+ * that. If not, we'll create one.
+ */
+
+ if (queue_idle[queuenum] == 0)
+ queue_idle[queuenum] = g_idle_add_full
+ (
+ window_queue_idle_priority[queuenum],
+ window_queue_idle_handler[queuenum],
+ GUINT_TO_POINTER(queuenum),
+ NULL
+ );
+
+ /* And now we actually put it on the queue. */
+ queue_pending[queuenum] = g_slist_prepend (queue_pending[queuenum],
+ window);
+ }
+ }
+}
+
+static gboolean
+intervening_user_event_occurred (MetaWindow *window)
+{
+ guint32 compare;
+ MetaWindow *focus_window;
+
+ focus_window = window->display->focus_window;
+
+ meta_topic (META_DEBUG_STARTUP,
+ "COMPARISON:\n"
+ " net_wm_user_time_set : %d\n"
+ " net_wm_user_time : %u\n"
+ " initial_timestamp_set: %d\n"
+ " initial_timestamp : %u\n",
+ window->net_wm_user_time_set,
+ window->net_wm_user_time,
+ window->initial_timestamp_set,
+ window->initial_timestamp);
+ if (focus_window != NULL)
+ {
+ meta_topic (META_DEBUG_STARTUP,
+ "COMPARISON (continued):\n"
+ " focus_window : %s\n"
+ " fw->net_wm_user_time_set : %d\n"
+ " fw->net_wm_user_time : %u\n",
+ focus_window->desc,
+ focus_window->net_wm_user_time_set,
+ focus_window->net_wm_user_time);
+ }
+
+ /* We expect the most common case for not focusing a new window
+ * to be when a hint to not focus it has been set. Since we can
+ * deal with that case rapidly, we use special case it--this is
+ * merely a preliminary optimization. :)
+ */
+ if ( ((window->net_wm_user_time_set == TRUE) &&
+ (window->net_wm_user_time == 0))
+ ||
+ ((window->initial_timestamp_set == TRUE) &&
+ (window->initial_timestamp == 0)))
+ {
+ meta_topic (META_DEBUG_STARTUP,
+ "window %s explicitly requested no focus\n",
+ window->desc);
+ return TRUE;
+ }
+
+ if (!(window->net_wm_user_time_set) && !(window->initial_timestamp_set))
+ {
+ meta_topic (META_DEBUG_STARTUP,
+ "no information about window %s found\n",
+ window->desc);
+ return FALSE;
+ }
+
+ if (focus_window != NULL &&
+ !focus_window->net_wm_user_time_set)
+ {
+ meta_topic (META_DEBUG_STARTUP,
+ "focus window, %s, doesn't have a user time set yet!\n",
+ window->desc);
+ return FALSE;
+ }
+
+ /* To determine the "launch" time of an application,
+ * startup-notification can set the TIMESTAMP and the
+ * application (usually via its toolkit such as gtk or qt) can
+ * set the _NET_WM_USER_TIME. If both are set, we need to be
+ * using the newer of the two values.
+ *
+ * See http://bugzilla.gnome.org/show_bug.cgi?id=573922
+ */
+ compare = 0;
+ if (window->net_wm_user_time_set &&
+ window->initial_timestamp_set)
+ compare =
+ XSERVER_TIME_IS_BEFORE (window->net_wm_user_time,
+ window->initial_timestamp) ?
+ window->initial_timestamp : window->net_wm_user_time;
+ else if (window->net_wm_user_time_set)
+ compare = window->net_wm_user_time;
+ else if (window->initial_timestamp_set)
+ compare = window->initial_timestamp;
+
+ if ((focus_window != NULL) &&
+ XSERVER_TIME_IS_BEFORE (compare, focus_window->net_wm_user_time))
+ {
+ meta_topic (META_DEBUG_STARTUP,
+ "window %s focus prevented by other activity; %u < %u\n",
+ window->desc,
+ compare,
+ focus_window->net_wm_user_time);
+ return TRUE;
+ }
+ else
+ {
+ meta_topic (META_DEBUG_STARTUP,
+ "new window %s with no intervening events\n",
+ window->desc);
+ return FALSE;
+ }
+}
+
+/* This function is an ugly hack. It's experimental in nature and ought to be
+ * replaced by a real hint from the app to the WM if we decide the experimental
+ * behavior is worthwhile. The basic idea is to get more feedback about how
+ * usage scenarios of "strict" focus users and what they expect. See #326159.
+ */
+gboolean
+__window_is_terminal (MetaWindow *window)
+{
+ if (window == NULL || window->res_class == NULL)
+ return FALSE;
+
+ /*
+ * Compare res_class, which is not user-settable, and thus theoretically
+ * a more-reliable indication of term-ness.
+ */
+
+ /* mate-terminal -- if you couldn't guess */
+ if (strcmp (window->res_class, "Mate-terminal") == 0)
+ return TRUE;
+ /* xterm, rxvt, aterm */
+ else if (strcmp (window->res_class, "XTerm") == 0)
+ return TRUE;
+ /* konsole, KDE's terminal program */
+ else if (strcmp (window->res_class, "Konsole") == 0)
+ return TRUE;
+ /* rxvt-unicode */
+ else if (strcmp (window->res_class, "URxvt") == 0)
+ return TRUE;
+ /* eterm */
+ else if (strcmp (window->res_class, "Eterm") == 0)
+ return TRUE;
+ /* KTerm -- some terminal not KDE based; so not like Konsole */
+ else if (strcmp (window->res_class, "KTerm") == 0)
+ return TRUE;
+ /* Multi-mate-terminal */
+ else if (strcmp (window->res_class, "Multi-mate-terminal") == 0)
+ return TRUE;
+ /* mlterm ("multi lingual terminal emulator on X") */
+ else if (strcmp (window->res_class, "mlterm") == 0)
+ return TRUE;
+ /* Terminal -- XFCE Terminal */
+ else if (strcmp (window->res_class, "Terminal") == 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+/* This function determines what state the window should have assuming that it
+ * and the focus_window have no relation
+ */
+static void
+window_state_on_map (MetaWindow *window,
+ gboolean *takes_focus,
+ gboolean *places_on_top)
+{
+ gboolean intervening_events;
+
+ intervening_events = intervening_user_event_occurred (window);
+
+ *takes_focus = !intervening_events;
+ *places_on_top = *takes_focus;
+
+ /* don't initially focus windows that are intended to not accept
+ * focus
+ */
+ if (!(window->input || window->take_focus))
+ {
+ *takes_focus = FALSE;
+ return;
+ }
+
+ /* Terminal usage may be different; some users intend to launch
+ * many apps in quick succession or to just view things in the new
+ * window while still interacting with the terminal. In that case,
+ * apps launched from the terminal should not take focus. This
+ * isn't quite the same as not allowing focus to transfer from
+ * terminals due to new window map, but the latter is a much easier
+ * approximation to enforce so we do that.
+ */
+ if (*takes_focus &&
+ meta_prefs_get_focus_new_windows () == META_FOCUS_NEW_WINDOWS_STRICT &&
+ !window->display->allow_terminal_deactivation &&
+ __window_is_terminal (window->display->focus_window) &&
+ !meta_window_is_ancestor_of_transient (window->display->focus_window,
+ window))
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "focus_window is terminal; not focusing new window.\n");
+ *takes_focus = FALSE;
+ *places_on_top = FALSE;
+ }
+
+ switch (window->type)
+ {
+ case META_WINDOW_UTILITY:
+ case META_WINDOW_TOOLBAR:
+ *takes_focus = FALSE;
+ *places_on_top = FALSE;
+ break;
+ case META_WINDOW_DOCK:
+ case META_WINDOW_DESKTOP:
+ case META_WINDOW_SPLASHSCREEN:
+ case META_WINDOW_MENU:
+ /* don't focus any of these; places_on_top may be irrelevant for some of
+ * these (e.g. dock)--but you never know--the focus window might also be
+ * of the same type in some weird situation...
+ */
+ *takes_focus = FALSE;
+ break;
+ case META_WINDOW_NORMAL:
+ case META_WINDOW_DIALOG:
+ case META_WINDOW_MODAL_DIALOG:
+ /* The default is correct for these */
+ break;
+ }
+}
+
+static gboolean
+windows_overlap (const MetaWindow *w1, const MetaWindow *w2)
+{
+ MetaRectangle w1rect, w2rect;
+ meta_window_get_outer_rect (w1, &w1rect);
+ meta_window_get_outer_rect (w2, &w2rect);
+ return meta_rectangle_overlap (&w1rect, &w2rect);
+}
+
+/* Returns whether a new window would be covered by any
+ * existing window on the same workspace that is set
+ * to be "above" ("always on top"). A window that is not
+ * set "above" would be underneath the new window anyway.
+ *
+ * We take "covered" to mean even partially covered, but
+ * some people might prefer entirely covered. I think it
+ * is more useful to behave this way if any part of the
+ * window is covered, because a partial coverage could be
+ * (say) ninety per cent and almost indistinguishable from total.
+ */
+static gboolean
+window_would_be_covered (const MetaWindow *newbie)
+{
+ MetaWorkspace *workspace = newbie->workspace;
+ GList *tmp, *windows;
+
+ windows = meta_workspace_list_windows (workspace);
+
+ tmp = windows;
+ while (tmp != NULL)
+ {
+ MetaWindow *w = tmp->data;
+
+ if (w->wm_state_above && w != newbie)
+ {
+ /* We have found a window that is "above". Perhaps it overlaps. */
+ if (windows_overlap (w, newbie))
+ {
+ g_list_free (windows); /* clean up... */
+ return TRUE; /* yes, it does */
+ }
+ }
+
+ tmp = tmp->next;
+ }
+
+ g_list_free (windows);
+ return FALSE; /* none found */
+}
+
+/* XXX META_EFFECT_*_MAP */
+void
+meta_window_show (MetaWindow *window)
+{
+ gboolean did_show;
+ gboolean takes_focus_on_map;
+ gboolean place_on_top_on_map;
+ gboolean needs_stacking_adjustment;
+ MetaWindow *focus_window;
+ guint32 timestamp;
+
+ /* FIXME: It really sucks to put timestamp pinging here; it'd
+ * probably make more sense in implement_showing() so that it's at
+ * least not duplicated in finish_minimize. *shrug*
+ */
+ timestamp = meta_display_get_current_time_roundtrip (window->display);
+
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "Showing window %s, shaded: %d iconic: %d placed: %d\n",
+ window->desc, window->shaded, window->iconic, window->placed);
+
+ focus_window = window->display->focus_window; /* May be NULL! */
+ did_show = FALSE;
+ window_state_on_map (window, &takes_focus_on_map, &place_on_top_on_map);
+ needs_stacking_adjustment = FALSE;
+
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "Window %s %s focus on map, and %s place on top on map.\n",
+ window->desc,
+ takes_focus_on_map ? "does" : "does not",
+ place_on_top_on_map ? "does" : "does not");
+
+ /* Now, in some rare cases we should *not* put a new window on top.
+ * These cases include certain types of windows showing for the first
+ * time, and any window which would be covered because of another window
+ * being set "above" ("always on top").
+ *
+ * FIXME: Although "place_on_top_on_map" and "takes_focus_on_map" are
+ * generally based on the window type, there is a special case when the
+ * focus window is a terminal for them both to be false; this should
+ * probably rather be a term in the "if" condition below.
+ */
+
+ if ( focus_window != NULL && window->showing_for_first_time &&
+ ( (!place_on_top_on_map && !takes_focus_on_map) ||
+ window_would_be_covered (window) )
+ ) {
+ if (meta_window_is_ancestor_of_transient (focus_window, window))
+ {
+ /* This happens for error dialogs or alerts; these need to remain on
+ * top, but it would be confusing to have its ancestor remain
+ * focused.
+ */
+ meta_topic (META_DEBUG_STARTUP,
+ "The focus window %s is an ancestor of the newly mapped "
+ "window %s which isn't being focused. Unfocusing the "
+ "ancestor.\n",
+ focus_window->desc, window->desc);
+
+ meta_display_focus_the_no_focus_window (window->display,
+ window->screen,
+ timestamp);
+ }
+ else
+ {
+ needs_stacking_adjustment = TRUE;
+ if (!window->placed)
+ window->denied_focus_and_not_transient = TRUE;
+ }
+ }
+
+ if (!window->placed)
+ {
+ /* We have to recalc the placement here since other windows may
+ * have been mapped/placed since we last did constrain_position
+ */
+
+ /* calc_placement is an efficiency hack to avoid
+ * multiple placement calculations before we finally
+ * show the window.
+ */
+ window->calc_placement = TRUE;
+ meta_window_move_resize_now (window);
+ window->calc_placement = FALSE;
+
+ /* don't ever do the initial position constraint thing again.
+ * This is toggled here so that initially-iconified windows
+ * still get placed when they are ultimately shown.
+ */
+ window->placed = TRUE;
+
+ /* Don't want to accidentally reuse the fact that we had been denied
+ * focus in any future constraints unless we're denied focus again.
+ */
+ window->denied_focus_and_not_transient = FALSE;
+ }
+
+ if (needs_stacking_adjustment)
+ {
+ gboolean overlap;
+
+ /* This window isn't getting focus on map. We may need to do some
+ * special handing with it in regards to
+ * - the stacking of the window
+ * - the MRU position of the window
+ * - the demands attention setting of the window
+ *
+ * Firstly, set the flag so we don't give the window focus anyway
+ * and confuse people.
+ */
+
+ takes_focus_on_map = FALSE;
+
+ overlap = windows_overlap (window, focus_window);
+
+ /* We want alt tab to go to the denied-focus window */
+ ensure_mru_position_after (window, focus_window);
+
+ /* We don't want the denied-focus window to obscure the focus
+ * window, and if we're in both click-to-focus mode and
+ * raise-on-click mode then we want to maintain the invariant
+ * that MRU order == stacking order. The need for this if
+ * comes from the fact that in sloppy/mouse focus the focus
+ * window may not overlap other windows and also can be
+ * considered "below" them; this combination means that
+ * placing the denied-focus window "below" the focus window
+ * in the stack when it doesn't overlap it confusingly places
+ * that new window below a lot of other windows.
+ */
+ if (overlap ||
+ (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK &&
+ meta_prefs_get_raise_on_click ()))
+ meta_window_stack_just_below (window, focus_window);
+
+ /* If the window will be obscured by the focus window, then the
+ * user might not notice the window appearing so set the
+ * demands attention hint.
+ *
+ * We set the hint ourselves rather than calling
+ * meta_window_set_demands_attention() because that would cause
+ * a recalculation of overlap, and a call to set_net_wm_state()
+ * which we are going to call ourselves here a few lines down.
+ */
+ if (overlap)
+ window->wm_state_demands_attention = TRUE;
+ }
+
+ /* Shaded means the frame is mapped but the window is not */
+
+ if (window->frame && !window->frame->mapped)
+ {
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "Frame actually needs map\n");
+ window->frame->mapped = TRUE;
+ meta_ui_map_frame (window->screen->ui, window->frame->xwindow);
+ did_show = TRUE;
+ }
+
+ if (window->shaded)
+ {
+ if (window->mapped)
+ {
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "%s actually needs unmap (shaded)\n", window->desc);
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "Incrementing unmaps_pending on %s for shade\n",
+ window->desc);
+ window->mapped = FALSE;
+ window->unmaps_pending += 1;
+ meta_error_trap_push (window->display);
+ XUnmapWindow (window->display->xdisplay, window->xwindow);
+ meta_error_trap_pop (window->display, FALSE);
+ }
+
+ if (!window->iconic)
+ {
+ window->iconic = TRUE;
+ set_wm_state (window, IconicState);
+ }
+ }
+ else
+ {
+ if (!window->mapped)
+ {
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "%s actually needs map\n", window->desc);
+ window->mapped = TRUE;
+ meta_error_trap_push (window->display);
+ XMapWindow (window->display->xdisplay, window->xwindow);
+ meta_error_trap_pop (window->display, FALSE);
+ did_show = TRUE;
+
+ if (window->was_minimized)
+ {
+ MetaRectangle window_rect;
+ MetaRectangle icon_rect;
+
+ window->was_minimized = FALSE;
+
+ if (meta_window_get_icon_geometry (window, &icon_rect))
+ {
+ meta_window_get_outer_rect (window, &window_rect);
+
+ meta_effect_run_unminimize (window,
+ &window_rect,
+ &icon_rect,
+ NULL, NULL);
+ }
+ }
+ }
+
+ if (window->iconic)
+ {
+ window->iconic = FALSE;
+ set_wm_state (window, NormalState);
+ }
+ }
+
+ /* We don't want to worry about all cases from inside
+ * implement_showing(); we only want to worry about focus if this
+ * window has not been shown before.
+ */
+ if (window->showing_for_first_time)
+ {
+ window->showing_for_first_time = FALSE;
+ if (takes_focus_on_map)
+ {
+ meta_window_focus (window, timestamp);
+ }
+ else
+ {
+ /* Prevent EnterNotify events in sloppy/mouse focus from
+ * erroneously focusing the window that had been denied
+ * focus. FIXME: This introduces a race; I have a couple
+ * ideas for a better way to accomplish the same thing, but
+ * they're more involved so do it this way for now.
+ */
+ meta_display_increment_focus_sentinel (window->display);
+ }
+ }
+
+ set_net_wm_state (window);
+
+ if (did_show && window->struts)
+ {
+ meta_topic (META_DEBUG_WORKAREA,
+ "Mapped window %s with struts, so invalidating work areas\n",
+ window->desc);
+ invalidate_work_areas (window);
+ }
+
+ /*
+ * Now that we have shown the window, we no longer want to consider the
+ * initial timestamp in any subsequent deliberations whether to focus this
+ * window or not, so clear the flag.
+ *
+ * See http://bugzilla.gnome.org/show_bug.cgi?id=573922
+ */
+ window->initial_timestamp_set = FALSE;
+}
+
+/* XXX META_EFFECT_*_UNMAP */
+static void
+meta_window_hide (MetaWindow *window)
+{
+ gboolean did_hide;
+
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "Hiding window %s\n", window->desc);
+
+ did_hide = FALSE;
+
+ if (window->frame && window->frame->mapped)
+ {
+ meta_topic (META_DEBUG_WINDOW_STATE, "Frame actually needs unmap\n");
+ window->frame->mapped = FALSE;
+ meta_ui_unmap_frame (window->screen->ui, window->frame->xwindow);
+ did_hide = TRUE;
+ }
+
+ if (window->mapped)
+ {
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "%s actually needs unmap\n", window->desc);
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "Incrementing unmaps_pending on %s for hide\n",
+ window->desc);
+ window->mapped = FALSE;
+ window->unmaps_pending += 1;
+ meta_error_trap_push (window->display);
+ XUnmapWindow (window->display->xdisplay, window->xwindow);
+ meta_error_trap_pop (window->display, FALSE);
+ did_hide = TRUE;
+ }
+
+ if (!window->iconic)
+ {
+ window->iconic = TRUE;
+ set_wm_state (window, IconicState);
+ }
+
+ set_net_wm_state (window);
+
+ if (did_hide && window->struts)
+ {
+ meta_topic (META_DEBUG_WORKAREA,
+ "Unmapped window %s with struts, so invalidating work areas\n",
+ window->desc);
+ invalidate_work_areas (window);
+ }
+}
+
+static gboolean
+queue_calc_showing_func (MetaWindow *window,
+ void *data)
+{
+ meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+ return TRUE;
+}
+
+void
+meta_window_minimize (MetaWindow *window)
+{
+ if (!window->minimized)
+ {
+ window->minimized = TRUE;
+ meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+
+ meta_window_foreach_transient (window,
+ queue_calc_showing_func,
+ NULL);
+
+ if (window->has_focus)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "Focusing default window due to minimization of focus window %s\n",
+ window->desc);
+ }
+ else
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "Minimizing window %s which doesn't have the focus\n",
+ window->desc);
+ }
+ }
+}
+
+void
+meta_window_unminimize (MetaWindow *window)
+{
+ if (window->minimized)
+ {
+ window->minimized = FALSE;
+ window->was_minimized = TRUE;
+ meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+
+ meta_window_foreach_transient (window,
+ queue_calc_showing_func,
+ NULL);
+ }
+}
+
+static void
+ensure_size_hints_satisfied (MetaRectangle *rect,
+ const XSizeHints *size_hints)
+{
+ int minw, minh, maxw, maxh; /* min/max width/height */
+ int basew, baseh, winc, hinc; /* base width/height, width/height increment */
+ int extra_width, extra_height;
+
+ minw = size_hints->min_width; minh = size_hints->min_height;
+ maxw = size_hints->max_width; maxh = size_hints->max_height;
+ basew = size_hints->base_width; baseh = size_hints->base_height;
+ winc = size_hints->width_inc; hinc = size_hints->height_inc;
+
+ /* First, enforce min/max size constraints */
+ rect->width = CLAMP (rect->width, minw, maxw);
+ rect->height = CLAMP (rect->height, minh, maxh);
+
+ /* Now, verify size increment constraints are satisfied, or make them be */
+ extra_width = (rect->width - basew) % winc;
+ extra_height = (rect->height - baseh) % hinc;
+
+ rect->width -= extra_width;
+ rect->height -= extra_height;
+
+ /* Adjusting width/height down, as done above, may violate minimum size
+ * constraints, so one last fix.
+ */
+ if (rect->width < minw)
+ rect->width += ((minw - rect->width)/winc + 1)*winc;
+ if (rect->height < minh)
+ rect->height += ((minh - rect->height)/hinc + 1)*hinc;
+}
+
+static void
+meta_window_save_rect (MetaWindow *window)
+{
+ if (!(META_WINDOW_MAXIMIZED (window) || window->fullscreen))
+ {
+ /* save size/pos as appropriate args for move_resize */
+ if (!window->maximized_horizontally)
+ {
+ window->saved_rect.x = window->rect.x;
+ window->saved_rect.width = window->rect.width;
+ if (window->frame)
+ window->saved_rect.x += window->frame->rect.x;
+ }
+ if (!window->maximized_vertically)
+ {
+ window->saved_rect.y = window->rect.y;
+ window->saved_rect.height = window->rect.height;
+ if (window->frame)
+ window->saved_rect.y += window->frame->rect.y;
+ }
+ }
+}
+
+/**
+ * Save the user_rect regardless of whether the window is maximized or
+ * fullscreen. See save_user_window_placement() for most uses.
+ *
+ * \param window Store current position of this window for future reference
+ */
+static void
+force_save_user_window_placement (MetaWindow *window)
+{
+ meta_window_get_client_root_coords (window, &window->user_rect);
+}
+
+/**
+ * Save the user_rect, but only if the window is neither maximized nor
+ * fullscreen, otherwise the window may snap back to those dimensions
+ * (bug #461927).
+ *
+ * \param window Store current position of this window for future reference
+ */
+static void
+save_user_window_placement (MetaWindow *window)
+{
+ if (!(META_WINDOW_MAXIMIZED (window) || window->fullscreen))
+ {
+ MetaRectangle user_rect;
+
+ meta_window_get_client_root_coords (window, &user_rect);
+
+ if (!window->maximized_horizontally)
+ {
+ window->user_rect.x = user_rect.x;
+ window->user_rect.width = user_rect.width;
+ }
+ if (!window->maximized_vertically)
+ {
+ window->user_rect.y = user_rect.y;
+ window->user_rect.height = user_rect.height;
+ }
+ }
+}
+
+void
+meta_window_maximize_internal (MetaWindow *window,
+ MetaMaximizeFlags directions,
+ MetaRectangle *saved_rect)
+{
+ /* At least one of the two directions ought to be set */
+ gboolean maximize_horizontally, maximize_vertically;
+ maximize_horizontally = directions & META_MAXIMIZE_HORIZONTAL;
+ maximize_vertically = directions & META_MAXIMIZE_VERTICAL;
+ g_assert (maximize_horizontally || maximize_vertically);
+
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Maximizing %s%s\n",
+ window->desc,
+ maximize_horizontally && maximize_vertically ? "" :
+ maximize_horizontally ? " horizontally" :
+ maximize_vertically ? " vertically" : "BUGGGGG");
+
+ if (saved_rect != NULL)
+ window->saved_rect = *saved_rect;
+ else
+ meta_window_save_rect (window);
+
+ window->maximized_horizontally =
+ window->maximized_horizontally || maximize_horizontally;
+ window->maximized_vertically =
+ window->maximized_vertically || maximize_vertically;
+ if (maximize_horizontally || maximize_vertically)
+ window->force_save_user_rect = FALSE;
+
+ /* Fix for #336850: If the frame shape isn't reapplied, it is
+ * possible that the frame will retains its rounded corners. That
+ * happens if the client's size when maximized equals the unmaximized
+ * size.
+ */
+ if (window->frame)
+ window->frame->need_reapply_frame_shape = TRUE;
+
+ recalc_window_features (window);
+ set_net_wm_state (window);
+}
+
+void
+meta_window_maximize (MetaWindow *window,
+ MetaMaximizeFlags directions)
+{
+ /* At least one of the two directions ought to be set */
+ gboolean maximize_horizontally, maximize_vertically;
+ maximize_horizontally = directions & META_MAXIMIZE_HORIZONTAL;
+ maximize_vertically = directions & META_MAXIMIZE_VERTICAL;
+ g_assert (maximize_horizontally || maximize_vertically);
+
+ /* Only do something if the window isn't already maximized in the
+ * given direction(s).
+ */
+ if ((maximize_horizontally && !window->maximized_horizontally) ||
+ (maximize_vertically && !window->maximized_vertically))
+ {
+ if (window->shaded && maximize_vertically)
+ {
+ /* Shading sucks anyway; I'm not adding a timestamp argument
+ * to this function just for this niche usage & corner case.
+ */
+ guint32 timestamp =
+ meta_display_get_current_time_roundtrip (window->display);
+ meta_window_unshade (window, timestamp);
+ }
+
+ /* if the window hasn't been placed yet, we'll maximize it then
+ */
+ if (!window->placed)
+ {
+ window->maximize_horizontally_after_placement =
+ window->maximize_horizontally_after_placement ||
+ maximize_horizontally;
+ window->maximize_vertically_after_placement =
+ window->maximize_vertically_after_placement ||
+ maximize_vertically;
+ return;
+ }
+
+ meta_window_maximize_internal (window,
+ directions,
+ NULL);
+
+ /* move_resize with new maximization constraints
+ */
+ meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+ }
+}
+
+static void
+unmaximize_window_before_freeing (MetaWindow *window)
+{
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Unmaximizing %s just before freeing\n",
+ window->desc);
+
+ window->maximized_horizontally = FALSE;
+ window->maximized_vertically = FALSE;
+
+ if (window->withdrawn) /* See bug #137185 */
+ {
+ window->rect = window->saved_rect;
+ set_net_wm_state (window);
+ }
+ else if (window->screen->closing) /* See bug #358042 */
+ {
+ /* Do NOT update net_wm_state: this screen is closing,
+ * it likely will be managed by another window manager
+ * that will need the current _NET_WM_STATE atoms.
+ * Moreover, it will need to know the unmaximized geometry,
+ * therefore move_resize the window to saved_rect here
+ * before closing it. */
+ meta_window_move_resize (window,
+ FALSE,
+ window->saved_rect.x,
+ window->saved_rect.y,
+ window->saved_rect.width,
+ window->saved_rect.height);
+ }
+}
+
+void
+meta_window_unmaximize (MetaWindow *window,
+ MetaMaximizeFlags directions)
+{
+ /* At least one of the two directions ought to be set */
+ gboolean unmaximize_horizontally, unmaximize_vertically;
+ unmaximize_horizontally = directions & META_MAXIMIZE_HORIZONTAL;
+ unmaximize_vertically = directions & META_MAXIMIZE_VERTICAL;
+ g_assert (unmaximize_horizontally || unmaximize_vertically);
+
+ /* Only do something if the window isn't already maximized in the
+ * given direction(s).
+ */
+ if ((unmaximize_horizontally && window->maximized_horizontally) ||
+ (unmaximize_vertically && window->maximized_vertically))
+ {
+ MetaRectangle target_rect;
+
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Unmaximizing %s%s\n",
+ window->desc,
+ unmaximize_horizontally && unmaximize_vertically ? "" :
+ unmaximize_horizontally ? " horizontally" :
+ unmaximize_vertically ? " vertically" : "BUGGGGG");
+
+ window->maximized_horizontally =
+ window->maximized_horizontally && !unmaximize_horizontally;
+ window->maximized_vertically =
+ window->maximized_vertically && !unmaximize_vertically;
+
+ /* Unmaximize to the saved_rect position in the direction(s)
+ * being unmaximized.
+ */
+ meta_window_get_client_root_coords (window, &target_rect);
+ if (unmaximize_horizontally)
+ {
+ target_rect.x = window->saved_rect.x;
+ target_rect.width = window->saved_rect.width;
+ }
+ if (unmaximize_vertically)
+ {
+ target_rect.y = window->saved_rect.y;
+ target_rect.height = window->saved_rect.height;
+ }
+
+ /* Window's size hints may have changed while maximized, making
+ * saved_rect invalid. #329152
+ */
+ ensure_size_hints_satisfied (&target_rect, &window->size_hints);
+
+ /* When we unmaximize, if we're doing a mouse move also we could
+ * get the window suddenly jumping to the upper left corner of
+ * the workspace, since that's where it was when the grab op
+ * started. So we need to update the grab state.
+ */
+ if (meta_grab_op_is_moving (window->display->grab_op) &&
+ window->display->grab_window == window)
+ {
+ window->display->grab_anchor_window_pos = target_rect;
+ }
+
+ meta_window_move_resize (window,
+ FALSE,
+ target_rect.x,
+ target_rect.y,
+ target_rect.width,
+ target_rect.height);
+
+ /* Make sure user_rect is current.
+ */
+ force_save_user_window_placement (window);
+
+ if (window->display->grab_wireframe_active)
+ {
+ window->display->grab_wireframe_rect = target_rect;
+ }
+
+ recalc_window_features (window);
+ set_net_wm_state (window);
+ }
+}
+
+void
+meta_window_make_above (MetaWindow *window)
+{
+ window->wm_state_above = TRUE;
+ meta_window_update_layer (window);
+ meta_window_raise (window);
+ set_net_wm_state (window);
+}
+
+void
+meta_window_unmake_above (MetaWindow *window)
+{
+ window->wm_state_above = FALSE;
+ meta_window_raise (window);
+ meta_window_update_layer (window);
+ set_net_wm_state (window);
+}
+
+void
+meta_window_make_fullscreen_internal (MetaWindow *window)
+{
+ if (!window->fullscreen)
+ {
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Fullscreening %s\n", window->desc);
+
+ if (window->shaded)
+ {
+ /* Shading sucks anyway; I'm not adding a timestamp argument
+ * to this function just for this niche usage & corner case.
+ */
+ guint32 timestamp =
+ meta_display_get_current_time_roundtrip (window->display);
+ meta_window_unshade (window, timestamp);
+ }
+
+ meta_window_save_rect (window);
+
+ window->fullscreen = TRUE;
+ window->force_save_user_rect = FALSE;
+
+ meta_stack_freeze (window->screen->stack);
+ meta_window_update_layer (window);
+
+ meta_window_raise (window);
+ meta_stack_thaw (window->screen->stack);
+
+ recalc_window_features (window);
+ set_net_wm_state (window);
+ }
+}
+
+void
+meta_window_make_fullscreen (MetaWindow *window)
+{
+ if (!window->fullscreen)
+ {
+ meta_window_make_fullscreen_internal (window);
+ /* move_resize with new constraints
+ */
+ meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+ }
+}
+
+void
+meta_window_unmake_fullscreen (MetaWindow *window)
+{
+ if (window->fullscreen)
+ {
+ MetaRectangle target_rect;
+
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Unfullscreening %s\n", window->desc);
+
+ window->fullscreen = FALSE;
+ target_rect = window->saved_rect;
+
+ /* Window's size hints may have changed while maximized, making
+ * saved_rect invalid. #329152
+ */
+ ensure_size_hints_satisfied (&target_rect, &window->size_hints);
+
+ meta_window_move_resize (window,
+ FALSE,
+ target_rect.x,
+ target_rect.y,
+ target_rect.width,
+ target_rect.height);
+
+ /* Make sure user_rect is current.
+ */
+ force_save_user_window_placement (window);
+
+ meta_window_update_layer (window);
+
+ recalc_window_features (window);
+ set_net_wm_state (window);
+ }
+}
+
+void
+meta_window_update_fullscreen_monitors (MetaWindow *window,
+ unsigned long top,
+ unsigned long bottom,
+ unsigned long left,
+ unsigned long right)
+{
+ if ((int)top < window->screen->n_xinerama_infos &&
+ (int)bottom < window->screen->n_xinerama_infos &&
+ (int)left < window->screen->n_xinerama_infos &&
+ (int)right < window->screen->n_xinerama_infos)
+ {
+ window->fullscreen_monitors[0] = top;
+ window->fullscreen_monitors[1] = bottom;
+ window->fullscreen_monitors[2] = left;
+ window->fullscreen_monitors[3] = right;
+ }
+ else
+ {
+ window->fullscreen_monitors[0] = -1;
+ }
+
+ if (window->fullscreen)
+ {
+ meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+ }
+}
+
+void
+meta_window_shade (MetaWindow *window,
+ guint32 timestamp)
+{
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Shading %s\n", window->desc);
+ if (!window->shaded)
+ {
+ window->shaded = TRUE;
+
+ meta_window_queue(window, META_QUEUE_MOVE_RESIZE | META_QUEUE_CALC_SHOWING);
+
+ /* After queuing the calc showing, since _focus flushes it,
+ * and we need to focus the frame
+ */
+ meta_topic (META_DEBUG_FOCUS,
+ "Re-focusing window %s after shading it\n",
+ window->desc);
+ meta_window_focus (window, timestamp);
+
+ set_net_wm_state (window);
+ }
+}
+
+void
+meta_window_unshade (MetaWindow *window,
+ guint32 timestamp)
+{
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Unshading %s\n", window->desc);
+ if (window->shaded)
+ {
+ window->shaded = FALSE;
+ meta_window_queue(window, META_QUEUE_MOVE_RESIZE | META_QUEUE_CALC_SHOWING);
+
+ /* focus the window */
+ meta_topic (META_DEBUG_FOCUS,
+ "Focusing window %s after unshading it\n",
+ window->desc);
+ meta_window_focus (window, timestamp);
+
+ set_net_wm_state (window);
+ }
+}
+
+static gboolean
+unminimize_func (MetaWindow *window,
+ void *data)
+{
+ meta_window_unminimize (window);
+ return TRUE;
+}
+
+static void
+unminimize_window_and_all_transient_parents (MetaWindow *window)
+{
+ meta_window_unminimize (window);
+ meta_window_foreach_ancestor (window, unminimize_func, NULL);
+}
+
+static void
+window_activate (MetaWindow *window,
+ guint32 timestamp,
+ MetaClientType source_indication,
+ MetaWorkspace *workspace)
+{
+ gboolean can_ignore_outdated_timestamps;
+ meta_topic (META_DEBUG_FOCUS,
+ "_NET_ACTIVE_WINDOW message sent for %s at time %u "
+ "by client type %u.\n",
+ window->desc, timestamp, source_indication);
+
+ /* Older EWMH spec didn't specify a timestamp; we decide to honor these only
+ * if the app specifies that it is a pager.
+ *
+ * Update: Unconditionally honor 0 timestamps for now; we'll fight
+ * that battle later. Just remove the "FALSE &&" in order to only
+ * honor 0 timestamps for pagers.
+ */
+ can_ignore_outdated_timestamps =
+ (timestamp != 0 || (FALSE && source_indication != META_CLIENT_TYPE_PAGER));
+ if (XSERVER_TIME_IS_BEFORE (timestamp, window->display->last_user_time) &&
+ can_ignore_outdated_timestamps)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "last_user_time (%u) is more recent; ignoring "
+ " _NET_ACTIVE_WINDOW message.\n",
+ window->display->last_user_time);
+ meta_window_set_demands_attention(window);
+ return;
+ }
+
+ /* For those stupid pagers, get a valid timestamp and show a warning */
+ if (timestamp == 0)
+ {
+ meta_warning ("meta_window_activate called by a pager with a 0 timestamp; "
+ "the pager needs to be fixed.\n");
+ timestamp = meta_display_get_current_time_roundtrip (window->display);
+ }
+
+ meta_window_set_user_time (window, timestamp);
+
+ /* disable show desktop mode unless we're a desktop component */
+ maybe_leave_show_desktop_mode (window);
+
+ /* Get window on current or given workspace */
+ if (workspace == NULL)
+ workspace = window->screen->active_workspace;
+
+ /* For non-transient windows, we just set up a pulsing indicator,
+ rather than move windows or workspaces.
+ See http://bugzilla.gnome.org/show_bug.cgi?id=482354 */
+ if (window->xtransient_for == None &&
+ !meta_window_located_on_workspace (window, workspace))
+ {
+ meta_window_set_demands_attention (window);
+ /* We've marked it as demanding, don't need to do anything else. */
+ return;
+ }
+ else if (window->xtransient_for != None)
+ {
+ /* Move transients to current workspace - preference dialogs should appear over
+ the source window. */
+ meta_window_change_workspace (window, workspace);
+ }
+
+ if (window->shaded)
+ meta_window_unshade (window, timestamp);
+
+ unminimize_window_and_all_transient_parents (window);
+
+ if (meta_prefs_get_raise_on_click () ||
+ source_indication == META_CLIENT_TYPE_PAGER)
+ meta_window_raise (window);
+
+ meta_topic (META_DEBUG_FOCUS,
+ "Focusing window %s due to activation\n",
+ window->desc);
+ meta_window_focus (window, timestamp);
+}
+
+/* This function exists since most of the functionality in window_activate
+ * is useful for Marco, but Marco shouldn't need to specify a client
+ * type for itself. ;-)
+ */
+void
+meta_window_activate (MetaWindow *window,
+ guint32 timestamp)
+{
+ /* We're not really a pager, but the behavior we want is the same as if
+ * we were such. If we change the pager behavior later, we could revisit
+ * this and just add extra flags to window_activate.
+ */
+ window_activate (window, timestamp, META_CLIENT_TYPE_PAGER, NULL);
+}
+
+void
+meta_window_activate_with_workspace (MetaWindow *window,
+ guint32 timestamp,
+ MetaWorkspace *workspace)
+{
+ /* We're not really a pager, but the behavior we want is the same as if
+ * we were such. If we change the pager behavior later, we could revisit
+ * this and just add extra flags to window_activate.
+ */
+ window_activate (window, timestamp, META_CLIENT_TYPE_APPLICATION, workspace);
+}
+
+/* Manually fix all the weirdness explained in the big comment at the
+ * beginning of meta_window_move_resize_internal() giving positions
+ * expected by meta_window_constrain (i.e. positions & sizes of the
+ * internal or client window).
+ */
+static void
+adjust_for_gravity (MetaWindow *window,
+ MetaFrameGeometry *fgeom,
+ gboolean coords_assume_border,
+ int gravity,
+ MetaRectangle *rect)
+{
+ int ref_x, ref_y;
+ int bw;
+ int child_x, child_y;
+ int frame_width, frame_height;
+
+ if (coords_assume_border)
+ bw = window->border_width;
+ else
+ bw = 0;
+
+ if (fgeom)
+ {
+ child_x = fgeom->left_width;
+ child_y = fgeom->top_height;
+ frame_width = child_x + rect->width + fgeom->right_width;
+ frame_height = child_y + rect->height + fgeom->bottom_height;
+ }
+ else
+ {
+ child_x = 0;
+ child_y = 0;
+ frame_width = rect->width;
+ frame_height = rect->height;
+ }
+
+ /* We're computing position to pass to window_move, which is
+ * the position of the client window (StaticGravity basically)
+ *
+ * (see WM spec description of gravity computation, but note that
+ * their formulas assume we're honoring the border width, rather
+ * than compensating for having turned it off)
+ */
+ switch (gravity)
+ {
+ case NorthWestGravity:
+ ref_x = rect->x;
+ ref_y = rect->y;
+ break;
+ case NorthGravity:
+ ref_x = rect->x + rect->width / 2 + bw;
+ ref_y = rect->y;
+ break;
+ case NorthEastGravity:
+ ref_x = rect->x + rect->width + bw * 2;
+ ref_y = rect->y;
+ break;
+ case WestGravity:
+ ref_x = rect->x;
+ ref_y = rect->y + rect->height / 2 + bw;
+ break;
+ case CenterGravity:
+ ref_x = rect->x + rect->width / 2 + bw;
+ ref_y = rect->y + rect->height / 2 + bw;
+ break;
+ case EastGravity:
+ ref_x = rect->x + rect->width + bw * 2;
+ ref_y = rect->y + rect->height / 2 + bw;
+ break;
+ case SouthWestGravity:
+ ref_x = rect->x;
+ ref_y = rect->y + rect->height + bw * 2;
+ break;
+ case SouthGravity:
+ ref_x = rect->x + rect->width / 2 + bw;
+ ref_y = rect->y + rect->height + bw * 2;
+ break;
+ case SouthEastGravity:
+ ref_x = rect->x + rect->width + bw * 2;
+ ref_y = rect->y + rect->height + bw * 2;
+ break;
+ case StaticGravity:
+ default:
+ ref_x = rect->x;
+ ref_y = rect->y;
+ break;
+ }
+
+ switch (gravity)
+ {
+ case NorthWestGravity:
+ rect->x = ref_x + child_x;
+ rect->y = ref_y + child_y;
+ break;
+ case NorthGravity:
+ rect->x = ref_x - frame_width / 2 + child_x;
+ rect->y = ref_y + child_y;
+ break;
+ case NorthEastGravity:
+ rect->x = ref_x - frame_width + child_x;
+ rect->y = ref_y + child_y;
+ break;
+ case WestGravity:
+ rect->x = ref_x + child_x;
+ rect->y = ref_y - frame_height / 2 + child_y;
+ break;
+ case CenterGravity:
+ rect->x = ref_x - frame_width / 2 + child_x;
+ rect->y = ref_y - frame_height / 2 + child_y;
+ break;
+ case EastGravity:
+ rect->x = ref_x - frame_width + child_x;
+ rect->y = ref_y - frame_height / 2 + child_y;
+ break;
+ case SouthWestGravity:
+ rect->x = ref_x + child_x;
+ rect->y = ref_y - frame_height + child_y;
+ break;
+ case SouthGravity:
+ rect->x = ref_x - frame_width / 2 + child_x;
+ rect->y = ref_y - frame_height + child_y;
+ break;
+ case SouthEastGravity:
+ rect->x = ref_x - frame_width + child_x;
+ rect->y = ref_y - frame_height + child_y;
+ break;
+ case StaticGravity:
+ default:
+ rect->x = ref_x;
+ rect->y = ref_y;
+ break;
+ }
+}
+
+static gboolean
+static_gravity_works (MetaDisplay *display)
+{
+ return display->static_gravity_works;
+}
+
+#ifdef HAVE_XSYNC
+static void
+send_sync_request (MetaWindow *window)
+{
+ XSyncValue value;
+ XClientMessageEvent ev;
+
+ window->sync_request_serial++;
+
+ XSyncIntToValue (&value, window->sync_request_serial);
+
+ ev.type = ClientMessage;
+ ev.window = window->xwindow;
+ ev.message_type = window->display->atom_WM_PROTOCOLS;
+ ev.format = 32;
+ ev.data.l[0] = window->display->atom__NET_WM_SYNC_REQUEST;
+ /* FIXME: meta_display_get_current_time() is bad, but since calls
+ * come from meta_window_move_resize_internal (which in turn come
+ * from all over), I'm not sure what we can do to fix it. Do we
+ * want to use _roundtrip, though?
+ */
+ ev.data.l[1] = meta_display_get_current_time (window->display);
+ ev.data.l[2] = XSyncValueLow32 (value);
+ ev.data.l[3] = XSyncValueHigh32 (value);
+
+ /* We don't need to trap errors here as we are already
+ * inside an error_trap_push()/pop() pair.
+ */
+ XSendEvent (window->display->xdisplay,
+ window->xwindow, False, 0, (XEvent*) &ev);
+
+ g_get_current_time (&window->sync_request_time);
+}
+#endif
+
+static void
+meta_window_move_resize_internal (MetaWindow *window,
+ MetaMoveResizeFlags flags,
+ int gravity,
+ int root_x_nw,
+ int root_y_nw,
+ int w,
+ int h)
+{
+ /* meta_window_move_resize_internal gets called with very different
+ * meanings for root_x_nw and root_y_nw. w & h are always the area
+ * of the inner or client window (i.e. excluding the frame) and
+ * gravity is the relevant gravity associated with the request (note
+ * that gravity is ignored for move-only operations unless its
+ * e.g. a configure request). The location is different for
+ * different cases because of how this function gets called; note
+ * that in all cases what we want to find out is the upper left
+ * corner of the position of the inner window:
+ *
+ * Case | Called from (flags; gravity)
+ * -----+-----------------------------------------------
+ * 1 | A resize only ConfigureRequest
+ * 1 | meta_window_resize
+ * 1 | meta_window_resize_with_gravity
+ * 2 | New window
+ * 2 | Session restore
+ * 2 | A not-resize-only ConfigureRequest/net_moveresize_window request
+ * 3 | meta_window_move
+ * 3 | meta_window_move_resize
+ *
+ * For each of the cases, root_x_nw and root_y_nw must be treated as follows:
+ *
+ * (1) They should be entirely ignored; instead the previous position
+ * and size of the window should be resized according to the given
+ * gravity in order to determine the new position of the window.
+ * (2) Needs to be fixed up by adjust_for_gravity() as these
+ * coordinates are relative to some corner or side of the outer
+ * window (except for the case of StaticGravity) and we want to
+ * know the location of the upper left corner of the inner window.
+ * (3) These values are already the desired positon of the NW corner
+ * of the inner window
+ */
+ XWindowChanges values;
+ unsigned int mask;
+ gboolean need_configure_notify;
+ MetaFrameGeometry fgeom;
+ gboolean need_move_client = FALSE;
+ gboolean need_move_frame = FALSE;
+ gboolean need_resize_client = FALSE;
+ gboolean need_resize_frame = FALSE;
+ int frame_size_dx;
+ int frame_size_dy;
+ int size_dx;
+ int size_dy;
+ gboolean is_configure_request;
+ gboolean do_gravity_adjust;
+ gboolean is_user_action;
+ gboolean configure_frame_first;
+ gboolean use_static_gravity;
+ /* used for the configure request, but may not be final
+ * destination due to StaticGravity etc.
+ */
+ int client_move_x;
+ int client_move_y;
+ MetaRectangle new_rect;
+ MetaRectangle old_rect;
+
+ is_configure_request = (flags & META_IS_CONFIGURE_REQUEST) != 0;
+ do_gravity_adjust = (flags & META_DO_GRAVITY_ADJUST) != 0;
+ is_user_action = (flags & META_IS_USER_ACTION) != 0;
+
+ /* The action has to be a move or a resize or both... */
+ g_assert (flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION));
+
+ /* We don't need it in the idle queue anymore. */
+ meta_window_unqueue (window, META_QUEUE_MOVE_RESIZE);
+
+ meta_window_get_client_root_coords (window, &old_rect);
+
+ meta_topic (META_DEBUG_GEOMETRY,
+ "Move/resize %s to %d,%d %dx%d%s%s from %d,%d %dx%d\n",
+ window->desc, root_x_nw, root_y_nw, w, h,
+ is_configure_request ? " (configure request)" : "",
+ is_user_action ? " (user move/resize)" : "",
+ old_rect.x, old_rect.y, old_rect.width, old_rect.height);
+
+ if (window->frame)
+ meta_frame_calc_geometry (window->frame,
+ &fgeom);
+
+ new_rect.x = root_x_nw;
+ new_rect.y = root_y_nw;
+ new_rect.width = w;
+ new_rect.height = h;
+
+ /* If this is a resize only, the position should be ignored and
+ * instead obtained by resizing the old rectangle according to the
+ * relevant gravity.
+ */
+ if ((flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION)) ==
+ META_IS_RESIZE_ACTION)
+ {
+ meta_rectangle_resize_with_gravity (&old_rect,
+ &new_rect,
+ gravity,
+ new_rect.width,
+ new_rect.height);
+
+ meta_topic (META_DEBUG_GEOMETRY,
+ "Compensated for gravity in resize action; new pos %d,%d\n",
+ new_rect.x, new_rect.y);
+ }
+ else if (is_configure_request || do_gravity_adjust)
+ {
+ adjust_for_gravity (window,
+ window->frame ? &fgeom : NULL,
+ /* configure request coords assume
+ * the border width existed
+ */
+ is_configure_request,
+ gravity,
+ &new_rect);
+
+ meta_topic (META_DEBUG_GEOMETRY,
+ "Compensated for configure_request/do_gravity_adjust needing "
+ "weird positioning; new pos %d,%d\n",
+ new_rect.x, new_rect.y);
+ }
+
+ meta_window_constrain (window,
+ window->frame ? &fgeom : NULL,
+ flags,
+ gravity,
+ &old_rect,
+ &new_rect);
+
+ w = new_rect.width;
+ h = new_rect.height;
+ root_x_nw = new_rect.x;
+ root_y_nw = new_rect.y;
+
+ if (w != window->rect.width ||
+ h != window->rect.height)
+ need_resize_client = TRUE;
+
+ window->rect.width = w;
+ window->rect.height = h;
+
+ if (window->frame)
+ {
+ int new_w, new_h;
+
+ new_w = window->rect.width + fgeom.left_width + fgeom.right_width;
+
+ if (window->shaded)
+ new_h = fgeom.top_height;
+ else
+ new_h = window->rect.height + fgeom.top_height + fgeom.bottom_height;
+
+ frame_size_dx = new_w - window->frame->rect.width;
+ frame_size_dy = new_h - window->frame->rect.height;
+
+ need_resize_frame = (frame_size_dx != 0 || frame_size_dy != 0);
+
+ window->frame->rect.width = new_w;
+ window->frame->rect.height = new_h;
+
+ meta_topic (META_DEBUG_GEOMETRY,
+ "Calculated frame size %dx%d\n",
+ window->frame->rect.width,
+ window->frame->rect.height);
+ }
+ else
+ {
+ frame_size_dx = 0;
+ frame_size_dy = 0;
+ }
+
+ /* For nice effect, when growing the window we want to move/resize
+ * the frame first, when shrinking the window we want to move/resize
+ * the client first. If we grow one way and shrink the other,
+ * see which way we're moving "more"
+ *
+ * Mail from Owen subject "Suggestion: Gravity and resizing from the left"
+ * http://mail.gnome.org/archives/wm-spec-list/1999-November/msg00088.html
+ *
+ * An annoying fact you need to know in this code is that StaticGravity
+ * does nothing if you _only_ resize or _only_ move the frame;
+ * it must move _and_ resize, otherwise you get NorthWestGravity
+ * behavior. The move and resize must actually occur, it is not
+ * enough to set CWX | CWWidth but pass in the current size/pos.
+ */
+
+ if (window->frame)
+ {
+ int new_x, new_y;
+ int frame_pos_dx, frame_pos_dy;
+
+ /* Compute new frame coords */
+ new_x = root_x_nw - fgeom.left_width;
+ new_y = root_y_nw - fgeom.top_height;
+
+ frame_pos_dx = new_x - window->frame->rect.x;
+ frame_pos_dy = new_y - window->frame->rect.y;
+
+ need_move_frame = (frame_pos_dx != 0 || frame_pos_dy != 0);
+
+ window->frame->rect.x = new_x;
+ window->frame->rect.y = new_y;
+
+ /* If frame will both move and resize, then StaticGravity
+ * on the child window will kick in and implicitly move
+ * the child with respect to the frame. The implicit
+ * move will keep the child in the same place with
+ * respect to the root window. If frame only moves
+ * or only resizes, then the child will just move along
+ * with the frame.
+ */
+
+ /* window->rect.x, window->rect.y are relative to frame,
+ * remember they are the server coords
+ */
+
+ new_x = fgeom.left_width;
+ new_y = fgeom.top_height;
+
+ if (need_resize_frame && need_move_frame &&
+ static_gravity_works (window->display))
+ {
+ /* static gravity kicks in because frame
+ * is both moved and resized
+ */
+ /* when we move the frame by frame_pos_dx, frame_pos_dy the
+ * client will implicitly move relative to frame by the
+ * inverse delta.
+ *
+ * When moving client then frame, we move the client by the
+ * frame delta, to be canceled out by the implicit move by
+ * the inverse frame delta, resulting in a client at new_x,
+ * new_y.
+ *
+ * When moving frame then client, we move the client
+ * by the same delta as the frame, because the client
+ * was "left behind" by the frame - resulting in a client
+ * at new_x, new_y.
+ *
+ * In both cases we need to move the client window
+ * in all cases where we had to move the frame window.
+ */
+
+ client_move_x = new_x + frame_pos_dx;
+ client_move_y = new_y + frame_pos_dy;
+
+ if (need_move_frame)
+ need_move_client = TRUE;
+
+ use_static_gravity = TRUE;
+ }
+ else
+ {
+ client_move_x = new_x;
+ client_move_y = new_y;
+
+ if (client_move_x != window->rect.x ||
+ client_move_y != window->rect.y)
+ need_move_client = TRUE;
+
+ use_static_gravity = FALSE;
+ }
+
+ /* This is the final target position, but not necessarily what
+ * we pass to XConfigureWindow, due to StaticGravity implicit
+ * movement.
+ */
+ window->rect.x = new_x;
+ window->rect.y = new_y;
+ }
+ else
+ {
+ if (root_x_nw != window->rect.x ||
+ root_y_nw != window->rect.y)
+ need_move_client = TRUE;
+
+ window->rect.x = root_x_nw;
+ window->rect.y = root_y_nw;
+
+ client_move_x = window->rect.x;
+ client_move_y = window->rect.y;
+
+ use_static_gravity = FALSE;
+ }
+
+ /* If frame extents have changed, fill in other frame fields and
+ change frame's extents property. */
+ if (window->frame &&
+ (window->frame->child_x != fgeom.left_width ||
+ window->frame->child_y != fgeom.top_height ||
+ window->frame->right_width != fgeom.right_width ||
+ window->frame->bottom_height != fgeom.bottom_height))
+ {
+ window->frame->child_x = fgeom.left_width;
+ window->frame->child_y = fgeom.top_height;
+ window->frame->right_width = fgeom.right_width;
+ window->frame->bottom_height = fgeom.bottom_height;
+
+ update_net_frame_extents (window);
+ }
+
+ /* See ICCCM 4.1.5 for when to send ConfigureNotify */
+
+ need_configure_notify = FALSE;
+
+ /* If this is a configure request and we change nothing, then we
+ * must send configure notify.
+ */
+ if (is_configure_request &&
+ !(need_move_client || need_move_frame ||
+ need_resize_client || need_resize_frame ||
+ window->border_width != 0))
+ need_configure_notify = TRUE;
+
+ /* We must send configure notify if we move but don't resize, since
+ * the client window may not get a real event
+ */
+ if ((need_move_client || need_move_frame) &&
+ !(need_resize_client || need_resize_frame))
+ need_configure_notify = TRUE;
+
+ /* MapRequest events with a PPosition or UPosition hint with a frame
+ * are moved by marco without resizing; send a configure notify
+ * in such cases. See #322840. (Note that window->constructing is
+ * only true iff this call is due to a MapRequest, and when
+ * PPosition/UPosition hints aren't set, marco seems to send a
+ * ConfigureNotify anyway due to the above code.)
+ */
+ if (window->constructing && window->frame &&
+ ((window->size_hints.flags & PPosition) ||
+ (window->size_hints.flags & USPosition)))
+ need_configure_notify = TRUE;
+
+ /* The rest of this function syncs our new size/pos with X as
+ * efficiently as possible
+ */
+
+ /* configure frame first if we grow more than we shrink
+ */
+ size_dx = w - window->rect.width;
+ size_dy = h - window->rect.height;
+
+ configure_frame_first = (size_dx + size_dy >= 0);
+
+ if (use_static_gravity)
+ meta_window_set_gravity (window, StaticGravity);
+
+ if (configure_frame_first && window->frame)
+ meta_frame_sync_to_window (window->frame,
+ gravity,
+ need_move_frame, need_resize_frame);
+
+ values.border_width = 0;
+ values.x = client_move_x;
+ values.y = client_move_y;
+ values.width = window->rect.width;
+ values.height = window->rect.height;
+
+ mask = 0;
+ if (is_configure_request && window->border_width != 0)
+ mask |= CWBorderWidth; /* must force to 0 */
+ if (need_move_client)
+ mask |= (CWX | CWY);
+ if (need_resize_client)
+ mask |= (CWWidth | CWHeight);
+
+ if (mask != 0)
+ {
+ {
+ int newx, newy;
+ meta_window_get_position (window, &newx, &newy);
+ meta_topic (META_DEBUG_GEOMETRY,
+ "Syncing new client geometry %d,%d %dx%d, border: %s pos: %s size: %s\n",
+ newx, newy,
+ window->rect.width, window->rect.height,
+ mask & CWBorderWidth ? "true" : "false",
+ need_move_client ? "true" : "false",
+ need_resize_client ? "true" : "false");
+ }
+
+ meta_error_trap_push (window->display);
+
+#ifdef HAVE_XSYNC
+ if (window->sync_request_counter != None &&
+ window->display->grab_sync_request_alarm != None &&
+ window->sync_request_time.tv_usec == 0 &&
+ window->sync_request_time.tv_sec == 0)
+ {
+ /* turn off updating */
+ if (window->display->compositor)
+ meta_compositor_set_updates (window->display->compositor, window, FALSE);
+
+ send_sync_request (window);
+ }
+#endif
+
+ XConfigureWindow (window->display->xdisplay,
+ window->xwindow,
+ mask,
+ &values);
+
+ meta_error_trap_pop (window->display, FALSE);
+ }
+
+ if (!configure_frame_first && window->frame)
+ meta_frame_sync_to_window (window->frame,
+ gravity,
+ need_move_frame, need_resize_frame);
+
+ /* Put gravity back to be nice to lesser window managers */
+ if (use_static_gravity)
+ meta_window_set_gravity (window, NorthWestGravity);
+
+ if (need_configure_notify)
+ send_configure_notify (window);
+
+ if (!window->placed && window->force_save_user_rect && !window->fullscreen)
+ force_save_user_window_placement (window);
+ else if (is_user_action)
+ save_user_window_placement (window);
+
+ if (need_move_frame || need_resize_frame ||
+ need_move_client || need_resize_client)
+ {
+ int newx, newy;
+ meta_window_get_position (window, &newx, &newy);
+ meta_topic (META_DEBUG_GEOMETRY,
+ "New size/position %d,%d %dx%d (user %d,%d %dx%d)\n",
+ newx, newy, window->rect.width, window->rect.height,
+ window->user_rect.x, window->user_rect.y,
+ window->user_rect.width, window->user_rect.height);
+ }
+ else
+ {
+ meta_topic (META_DEBUG_GEOMETRY, "Size/position not modified\n");
+ }
+
+ if (window->display->grab_wireframe_active)
+ meta_window_update_wireframe (window, root_x_nw, root_y_nw, w, h);
+ else
+ meta_window_refresh_resize_popup (window);
+
+ /* Invariants leaving this function are:
+ * a) window->rect and frame->rect reflect the actual
+ * server-side size/pos of window->xwindow and frame->xwindow
+ * b) all constraints are obeyed by window->rect and frame->rect
+ */
+}
+
+void
+meta_window_resize (MetaWindow *window,
+ gboolean user_op,
+ int w,
+ int h)
+{
+ int x, y;
+ MetaMoveResizeFlags flags;
+
+ meta_window_get_position (window, &x, &y);
+
+ flags = (user_op ? META_IS_USER_ACTION : 0) | META_IS_RESIZE_ACTION;
+ meta_window_move_resize_internal (window,
+ flags,
+ NorthWestGravity,
+ x, y, w, h);
+}
+
+void
+meta_window_move (MetaWindow *window,
+ gboolean user_op,
+ int root_x_nw,
+ int root_y_nw)
+{
+ MetaMoveResizeFlags flags =
+ (user_op ? META_IS_USER_ACTION : 0) | META_IS_MOVE_ACTION;
+ meta_window_move_resize_internal (window,
+ flags,
+ NorthWestGravity,
+ root_x_nw, root_y_nw,
+ window->rect.width,
+ window->rect.height);
+}
+
+void
+meta_window_move_resize (MetaWindow *window,
+ gboolean user_op,
+ int root_x_nw,
+ int root_y_nw,
+ int w,
+ int h)
+{
+ MetaMoveResizeFlags flags =
+ (user_op ? META_IS_USER_ACTION : 0) |
+ META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION;
+ meta_window_move_resize_internal (window,
+ flags,
+ NorthWestGravity,
+ root_x_nw, root_y_nw,
+ w, h);
+}
+
+void
+meta_window_resize_with_gravity (MetaWindow *window,
+ gboolean user_op,
+ int w,
+ int h,
+ int gravity)
+{
+ int x, y;
+ MetaMoveResizeFlags flags;
+
+ meta_window_get_position (window, &x, &y);
+
+ flags = (user_op ? META_IS_USER_ACTION : 0) | META_IS_RESIZE_ACTION;
+ meta_window_move_resize_internal (window,
+ flags,
+ gravity,
+ x, y, w, h);
+}
+
+static void
+meta_window_move_resize_now (MetaWindow *window)
+{
+ /* If constraints have changed then we want to snap back to wherever
+ * the user had the window. We use user_rect for this reason. See
+ * also bug 426519 comment 3.
+ */
+ meta_window_move_resize (window, FALSE,
+ window->user_rect.x,
+ window->user_rect.y,
+ window->user_rect.width,
+ window->user_rect.height);
+}
+
+static gboolean
+idle_move_resize (gpointer data)
+{
+ GSList *tmp;
+ GSList *copy;
+ guint queue_index = GPOINTER_TO_INT (data);
+
+ meta_topic (META_DEBUG_GEOMETRY, "Clearing the move_resize queue\n");
+
+ /* Work with a copy, for reentrancy. The allowed reentrancy isn't
+ * complete; destroying a window while we're in here would result in
+ * badness. But it's OK to queue/unqueue move_resizes.
+ */
+ copy = g_slist_copy (queue_pending[queue_index]);
+ g_slist_free (queue_pending[queue_index]);
+ queue_pending[queue_index] = NULL;
+ queue_idle[queue_index] = 0;
+
+ destroying_windows_disallowed += 1;
+
+ tmp = copy;
+ while (tmp != NULL)
+ {
+ MetaWindow *window;
+
+ window = tmp->data;
+
+ /* As a side effect, sets window->move_resize_queued = FALSE */
+ meta_window_move_resize_now (window);
+
+ tmp = tmp->next;
+ }
+
+ g_slist_free (copy);
+
+ destroying_windows_disallowed -= 1;
+
+ return FALSE;
+}
+
+void
+meta_window_get_position (MetaWindow *window,
+ int *x,
+ int *y)
+{
+ if (window->frame)
+ {
+ if (x)
+ *x = window->frame->rect.x + window->frame->child_x;
+ if (y)
+ *y = window->frame->rect.y + window->frame->child_y;
+ }
+ else
+ {
+ if (x)
+ *x = window->rect.x;
+ if (y)
+ *y = window->rect.y;
+ }
+}
+
+void
+meta_window_get_client_root_coords (MetaWindow *window,
+ MetaRectangle *rect)
+{
+ meta_window_get_position (window, &rect->x, &rect->y);
+ rect->width = window->rect.width;
+ rect->height = window->rect.height;
+}
+
+void
+meta_window_get_gravity_position (MetaWindow *window,
+ int gravity,
+ int *root_x,
+ int *root_y)
+{
+ MetaRectangle frame_extents;
+ int w, h;
+ int x, y;
+
+ w = window->rect.width;
+ h = window->rect.height;
+
+ if (gravity == StaticGravity)
+ {
+ frame_extents = window->rect;
+ if (window->frame)
+ {
+ frame_extents.x = window->frame->rect.x + window->frame->child_x;
+ frame_extents.y = window->frame->rect.y + window->frame->child_y;
+ }
+ }
+ else
+ {
+ if (window->frame == NULL)
+ frame_extents = window->rect;
+ else
+ frame_extents = window->frame->rect;
+ }
+
+ x = frame_extents.x;
+ y = frame_extents.y;
+
+ switch (gravity)
+ {
+ case NorthGravity:
+ case CenterGravity:
+ case SouthGravity:
+ /* Find center of frame. */
+ x += frame_extents.width / 2;
+ /* Center client window on that point. */
+ x -= w / 2;
+ break;
+
+ case SouthEastGravity:
+ case EastGravity:
+ case NorthEastGravity:
+ /* Find right edge of frame */
+ x += frame_extents.width;
+ /* Align left edge of client at that point. */
+ x -= w;
+ break;
+ default:
+ break;
+ }
+
+ switch (gravity)
+ {
+ case WestGravity:
+ case CenterGravity:
+ case EastGravity:
+ /* Find center of frame. */
+ y += frame_extents.height / 2;
+ /* Center client window there. */
+ y -= h / 2;
+ break;
+ case SouthWestGravity:
+ case SouthGravity:
+ case SouthEastGravity:
+ /* Find south edge of frame */
+ y += frame_extents.height;
+ /* Place bottom edge of client there */
+ y -= h;
+ break;
+ default:
+ break;
+ }
+
+ if (root_x)
+ *root_x = x;
+ if (root_y)
+ *root_y = y;
+}
+
+void
+meta_window_get_geometry (MetaWindow *window,
+ int *x,
+ int *y,
+ int *width,
+ int *height)
+{
+ meta_window_get_gravity_position (window,
+ window->size_hints.win_gravity,
+ x, y);
+
+ *width = (window->rect.width - window->size_hints.base_width) /
+ window->size_hints.width_inc;
+ *height = (window->rect.height - window->size_hints.base_height) /
+ window->size_hints.height_inc;
+}
+
+void
+meta_window_get_outer_rect (const MetaWindow *window,
+ MetaRectangle *rect)
+{
+ if (window->frame)
+ *rect = window->frame->rect;
+ else
+ *rect = window->rect;
+}
+
+void
+meta_window_get_xor_rect (MetaWindow *window,
+ const MetaRectangle *grab_wireframe_rect,
+ MetaRectangle *xor_rect)
+{
+ if (window->frame)
+ {
+ xor_rect->x = grab_wireframe_rect->x - window->frame->child_x;
+ xor_rect->y = grab_wireframe_rect->y - window->frame->child_y;
+ xor_rect->width = grab_wireframe_rect->width + window->frame->child_x + window->frame->right_width;
+
+ if (window->shaded)
+ xor_rect->height = window->frame->child_y;
+ else
+ xor_rect->height = grab_wireframe_rect->height + window->frame->child_y + window->frame->bottom_height;
+ }
+ else
+ *xor_rect = *grab_wireframe_rect;
+}
+
+/* Figure out the numbers that show up in the
+ * resize popup when in reduced resources mode.
+ */
+static void
+meta_window_get_wireframe_geometry (MetaWindow *window,
+ int *width,
+ int *height)
+{
+ if (!window->display->grab_wireframe_active)
+ return;
+
+ if ((width == NULL) || (height == NULL))
+ return;
+
+ if ((window->display->grab_window->size_hints.width_inc <= 1) ||
+ (window->display->grab_window->size_hints.height_inc <= 1))
+ {
+ *width = -1;
+ *height = -1;
+ return;
+ }
+
+ *width = window->display->grab_wireframe_rect.width -
+ window->display->grab_window->size_hints.base_width;
+ *width /= window->display->grab_window->size_hints.width_inc;
+
+ *height = window->display->grab_wireframe_rect.height -
+ window->display->grab_window->size_hints.base_height;
+ *height /= window->display->grab_window->size_hints.height_inc;
+}
+
+/* XXX META_EFFECT_ALT_TAB, well, this and others */
+void
+meta_window_begin_wireframe (MetaWindow *window)
+{
+
+ MetaRectangle new_xor;
+ int display_width, display_height;
+
+ meta_window_get_client_root_coords (window,
+ &window->display->grab_wireframe_rect);
+
+ meta_window_get_xor_rect (window, &window->display->grab_wireframe_rect,
+ &new_xor);
+ meta_window_get_wireframe_geometry (window, &display_width, &display_height);
+
+ meta_effects_begin_wireframe (window->screen,
+ &new_xor, display_width, display_height);
+
+ window->display->grab_wireframe_last_xor_rect = new_xor;
+ window->display->grab_wireframe_last_display_width = display_width;
+ window->display->grab_wireframe_last_display_height = display_height;
+}
+
+void
+meta_window_update_wireframe (MetaWindow *window,
+ int x,
+ int y,
+ int width,
+ int height)
+{
+
+ MetaRectangle new_xor;
+ int display_width, display_height;
+
+ window->display->grab_wireframe_rect.x = x;
+ window->display->grab_wireframe_rect.y = y;
+ window->display->grab_wireframe_rect.width = width;
+ window->display->grab_wireframe_rect.height = height;
+
+ meta_window_get_xor_rect (window, &window->display->grab_wireframe_rect,
+ &new_xor);
+ meta_window_get_wireframe_geometry (window, &display_width, &display_height);
+
+ meta_effects_update_wireframe (window->screen,
+ &window->display->grab_wireframe_last_xor_rect,
+ window->display->grab_wireframe_last_display_width,
+ window->display->grab_wireframe_last_display_height,
+ &new_xor, display_width, display_height);
+
+ window->display->grab_wireframe_last_xor_rect = new_xor;
+ window->display->grab_wireframe_last_display_width = display_width;
+ window->display->grab_wireframe_last_display_height = display_height;
+}
+
+void
+meta_window_end_wireframe (MetaWindow *window)
+{
+ meta_effects_end_wireframe (window->display->grab_window->screen,
+ &window->display->grab_wireframe_last_xor_rect,
+ window->display->grab_wireframe_last_display_width,
+ window->display->grab_wireframe_last_display_height);
+}
+
+const char*
+meta_window_get_startup_id (MetaWindow *window)
+{
+ if (window->startup_id == NULL)
+ {
+ MetaGroup *group;
+
+ group = meta_window_get_group (window);
+
+ if (group != NULL)
+ return meta_group_get_startup_id (group);
+ }
+
+ return window->startup_id;
+}
+
+static MetaWindow*
+get_modal_transient (MetaWindow *window)
+{
+ GSList *windows;
+ GSList *tmp;
+ MetaWindow *modal_transient;
+
+ /* A window can't be the transient of itself, but this is just for
+ * convenience in the loop below; we manually fix things up at the
+ * end if no real modal transient was found.
+ */
+ modal_transient = window;
+
+ windows = meta_display_list_windows (window->display);
+ tmp = windows;
+ while (tmp != NULL)
+ {
+ MetaWindow *transient = tmp->data;
+
+ if (transient->xtransient_for == modal_transient->xwindow &&
+ transient->wm_state_modal)
+ {
+ modal_transient = transient;
+ tmp = windows;
+ continue;
+ }
+
+ tmp = tmp->next;
+ }
+
+ g_slist_free (windows);
+
+ if (window == modal_transient)
+ modal_transient = NULL;
+
+ return modal_transient;
+}
+
+/* XXX META_EFFECT_FOCUS */
+void
+meta_window_focus (MetaWindow *window,
+ guint32 timestamp)
+{
+ MetaWindow *modal_transient;
+
+ meta_topic (META_DEBUG_FOCUS,
+ "Setting input focus to window %s, input: %d take_focus: %d\n",
+ window->desc, window->input, window->take_focus);
+
+ if (window->display->grab_window &&
+ window->display->grab_window->all_keys_grabbed)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "Current focus window %s has global keygrab, not focusing window %s after all\n",
+ window->display->grab_window->desc, window->desc);
+ return;
+ }
+
+ modal_transient = get_modal_transient (window);
+ if (modal_transient != NULL &&
+ !modal_transient->unmanaging)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "%s has %s as a modal transient, so focusing it instead.\n",
+ window->desc, modal_transient->desc);
+ if (!modal_transient->on_all_workspaces &&
+ modal_transient->workspace != window->screen->active_workspace)
+ meta_window_change_workspace (modal_transient,
+ window->screen->active_workspace);
+ window = modal_transient;
+ }
+
+ meta_window_flush_calc_showing (window);
+
+ if (!window->mapped && !window->shaded)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "Window %s is not showing, not focusing after all\n",
+ window->desc);
+ return;
+ }
+
+ /* For output-only or shaded windows, focus the frame.
+ * This seems to result in the client window getting key events
+ * though, so I don't know if it's icccm-compliant.
+ *
+ * Still, we have to do this or keynav breaks for these windows.
+ */
+ if (window->frame &&
+ (window->shaded ||
+ !(window->input || window->take_focus)))
+ {
+ if (window->frame)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "Focusing frame of %s\n", window->desc);
+ meta_display_set_input_focus_window (window->display,
+ window,
+ TRUE,
+ timestamp);
+ }
+ }
+ else
+ {
+ if (window->input)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "Setting input focus on %s since input = true\n",
+ window->desc);
+ meta_display_set_input_focus_window (window->display,
+ window,
+ FALSE,
+ timestamp);
+ }
+
+ if (window->take_focus)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "Sending WM_TAKE_FOCUS to %s since take_focus = true\n",
+ window->desc);
+ meta_window_send_icccm_message (window,
+ window->display->atom_WM_TAKE_FOCUS,
+ timestamp);
+ window->display->expected_focus_window = window;
+ }
+ }
+
+ if (window->wm_state_demands_attention)
+ meta_window_unset_demands_attention(window);
+
+ meta_effect_run_focus(window, NULL, NULL);
+}
+
+static void
+meta_window_change_workspace_without_transients (MetaWindow *window,
+ MetaWorkspace *workspace)
+{
+ meta_verbose ("Changing window %s to workspace %d\n",
+ window->desc, meta_workspace_index (workspace));
+
+ /* unstick if stuck. meta_window_unstick would call
+ * meta_window_change_workspace recursively if the window
+ * is not in the active workspace.
+ */
+ if (window->on_all_workspaces)
+ meta_window_unstick (window);
+
+ /* See if we're already on this space. If not, make sure we are */
+ if (window->workspace != workspace)
+ {
+ meta_workspace_remove_window (window->workspace, window);
+ meta_workspace_add_window (workspace, window);
+ }
+}
+
+static gboolean
+change_workspace_foreach (MetaWindow *window,
+ void *data)
+{
+ meta_window_change_workspace_without_transients (window, data);
+ return TRUE;
+}
+
+void
+meta_window_change_workspace (MetaWindow *window,
+ MetaWorkspace *workspace)
+{
+ meta_window_change_workspace_without_transients (window, workspace);
+
+ meta_window_foreach_transient (window, change_workspace_foreach,
+ workspace);
+ meta_window_foreach_ancestor (window, change_workspace_foreach,
+ workspace);
+}
+
+static void
+window_stick_impl (MetaWindow *window)
+{
+ GList *tmp;
+ MetaWorkspace *workspace;
+
+ meta_verbose ("Sticking window %s current on_all_workspaces = %d\n",
+ window->desc, window->on_all_workspaces);
+
+ if (window->on_all_workspaces)
+ return;
+
+ /* We don't change window->workspaces, because we revert
+ * to that original workspace list if on_all_workspaces is
+ * toggled back off.
+ */
+ window->on_all_workspaces = TRUE;
+
+ /* We do, however, change the MRU lists of all the workspaces
+ */
+ tmp = window->screen->workspaces;
+ while (tmp)
+ {
+ workspace = (MetaWorkspace *) tmp->data;
+ if (!g_list_find (workspace->mru_list, window))
+ workspace->mru_list = g_list_prepend (workspace->mru_list, window);
+
+ tmp = tmp->next;
+ }
+
+ meta_window_set_current_workspace_hint (window);
+
+ meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+}
+
+static void
+window_unstick_impl (MetaWindow *window)
+{
+ GList *tmp;
+ MetaWorkspace *workspace;
+
+ if (!window->on_all_workspaces)
+ return;
+
+ /* Revert to window->workspaces */
+
+ window->on_all_workspaces = FALSE;
+
+ /* Remove window from MRU lists that it doesn't belong in */
+ tmp = window->screen->workspaces;
+ while (tmp)
+ {
+ workspace = (MetaWorkspace *) tmp->data;
+ if (window->workspace != workspace)
+ workspace->mru_list = g_list_remove (workspace->mru_list, window);
+ tmp = tmp->next;
+ }
+
+ /* We change ourselves to the active workspace, since otherwise you'd get
+ * a weird window-vaporization effect. Once we have UI for being
+ * on more than one workspace this should probably be add_workspace
+ * not change_workspace.
+ */
+ if (window->screen->active_workspace != window->workspace)
+ meta_window_change_workspace (window, window->screen->active_workspace);
+
+ meta_window_set_current_workspace_hint (window);
+
+ meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+}
+
+static gboolean
+stick_foreach_func (MetaWindow *window,
+ void *data)
+{
+ gboolean stick;
+
+ stick = *(gboolean*)data;
+ if (stick)
+ window_stick_impl (window);
+ else
+ window_unstick_impl (window);
+ return TRUE;
+}
+
+void
+meta_window_stick (MetaWindow *window)
+{
+ gboolean stick = TRUE;
+ window_stick_impl (window);
+ meta_window_foreach_transient (window,
+ stick_foreach_func,
+ &stick);
+}
+
+void
+meta_window_unstick (MetaWindow *window)
+{
+ gboolean stick = FALSE;
+ window_unstick_impl (window);
+ meta_window_foreach_transient (window,
+ stick_foreach_func,
+ &stick);
+}
+
+unsigned long
+meta_window_get_net_wm_desktop (MetaWindow *window)
+{
+ if (window->on_all_workspaces)
+ return 0xFFFFFFFF;
+ else
+ return meta_workspace_index (window->workspace);
+}
+
+static void
+update_net_frame_extents (MetaWindow *window)
+{
+ unsigned long data[4] = { 0, 0, 0, 0 };
+
+ if (window->frame)
+ {
+ /* Left */
+ data[0] = window->frame->child_x;
+ /* Right */
+ data[1] = window->frame->right_width;
+ /* Top */
+ data[2] = window->frame->child_y;
+ /* Bottom */
+ data[3] = window->frame->bottom_height;
+ }
+
+ meta_topic (META_DEBUG_GEOMETRY,
+ "Setting _NET_FRAME_EXTENTS on managed window 0x%lx "
+ "to left = %lu, right = %lu, top = %lu, bottom = %lu\n",
+ window->xwindow, data[0], data[1], data[2], data[3]);
+
+ meta_error_trap_push (window->display);
+ XChangeProperty (window->display->xdisplay, window->xwindow,
+ window->display->atom__NET_FRAME_EXTENTS,
+ XA_CARDINAL,
+ 32, PropModeReplace, (guchar*) data, 4);
+ meta_error_trap_pop (window->display, FALSE);
+}
+
+void
+meta_window_set_current_workspace_hint (MetaWindow *window)
+{
+ /* FIXME if on more than one workspace, we claim to be "sticky",
+ * the WM spec doesn't say what to do here.
+ */
+ unsigned long data[1];
+
+ if (window->workspace == NULL)
+ {
+ /* this happens when unmanaging windows */
+ return;
+ }
+
+ data[0] = meta_window_get_net_wm_desktop (window);
+
+ meta_verbose ("Setting _NET_WM_DESKTOP of %s to %lu\n",
+ window->desc, data[0]);
+
+ meta_error_trap_push (window->display);
+ XChangeProperty (window->display->xdisplay, window->xwindow,
+ window->display->atom__NET_WM_DESKTOP,
+ XA_CARDINAL,
+ 32, PropModeReplace, (guchar*) data, 1);
+ meta_error_trap_pop (window->display, FALSE);
+}
+
+static gboolean
+find_root_ancestor (MetaWindow *window,
+ void *data)
+{
+ MetaWindow **ancestor = data;
+
+ /* Overwrite the previously "most-root" ancestor with the new one found */
+ *ancestor = window;
+
+ /* We want this to continue until meta_window_foreach_ancestor quits because
+ * there are no more valid ancestors.
+ */
+ return TRUE;
+}
+
+MetaWindow *
+meta_window_find_root_ancestor (MetaWindow *window)
+{
+ MetaWindow *ancestor;
+ ancestor = window;
+ meta_window_foreach_ancestor (window, find_root_ancestor, &ancestor);
+ return ancestor;
+}
+
+void
+meta_window_raise (MetaWindow *window)
+{
+ MetaWindow *ancestor;
+ ancestor = meta_window_find_root_ancestor (window);
+
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Raising window %s, ancestor of %s\n",
+ ancestor->desc, window->desc);
+
+ /* Raise the ancestor of the window (if the window has no ancestor,
+ * then ancestor will be set to the window itself); do this because
+ * it's weird to see windows from other apps stacked between a child
+ * and parent window of the currently active app. The stacking
+ * constraints in stack.c then magically take care of raising all
+ * the child windows appropriately.
+ */
+ if (window->screen->stack == ancestor->screen->stack)
+ meta_stack_raise (window->screen->stack, ancestor);
+ else
+ {
+ meta_warning (
+ "Either stacks aren't per screen or some window has a weird "
+ "transient_for hint; window->screen->stack != "
+ "ancestor->screen->stack. window = %s, ancestor = %s.\n",
+ window->desc, ancestor->desc);
+ /* We could raise the window here, but don't want to do that twice and
+ * so we let the case below handle that.
+ */
+ }
+
+ /* Okay, so stacking constraints misses one case: If a window has
+ * two children and we want to raise one of those children, then
+ * raising the ancestor isn't enough; we need to also raise the
+ * correct child. See bug 307875.
+ */
+ if (window != ancestor)
+ meta_stack_raise (window->screen->stack, window);
+}
+
+void
+meta_window_lower (MetaWindow *window)
+{
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Lowering window %s\n", window->desc);
+
+ meta_stack_lower (window->screen->stack, window);
+}
+
+void
+meta_window_send_icccm_message (MetaWindow *window,
+ Atom atom,
+ guint32 timestamp)
+{
+ /* This comment and code are from twm, copyright
+ * Open Group, Evans & Sutherland, etc.
+ */
+
+ /*
+ * ICCCM Client Messages - Section 4.2.8 of the ICCCM dictates that all
+ * client messages will have the following form:
+ *
+ * event type ClientMessage
+ * message type _XA_WM_PROTOCOLS
+ * window tmp->w
+ * format 32
+ * data[0] message atom
+ * data[1] time stamp
+ */
+
+ XClientMessageEvent ev;
+
+ ev.type = ClientMessage;
+ ev.window = window->xwindow;
+ ev.message_type = window->display->atom_WM_PROTOCOLS;
+ ev.format = 32;
+ ev.data.l[0] = atom;
+ ev.data.l[1] = timestamp;
+
+ meta_error_trap_push (window->display);
+ XSendEvent (window->display->xdisplay,
+ window->xwindow, False, 0, (XEvent*) &ev);
+ meta_error_trap_pop (window->display, FALSE);
+}
+
+void
+meta_window_move_resize_request (MetaWindow *window,
+ guint value_mask,
+ int gravity,
+ int new_x,
+ int new_y,
+ int new_width,
+ int new_height)
+{
+ int x, y, width, height;
+ gboolean allow_position_change;
+ gboolean in_grab_op;
+ MetaMoveResizeFlags flags;
+
+ /* We ignore configure requests while the user is moving/resizing
+ * the window, since these represent the app sucking and fighting
+ * the user, most likely due to a bug in the app (e.g. pfaedit
+ * seemed to do this)
+ *
+ * Still have to do the ConfigureNotify and all, but pretend the
+ * app asked for the current size/position instead of the new one.
+ */
+ in_grab_op = FALSE;
+ if (window->display->grab_op != META_GRAB_OP_NONE &&
+ window == window->display->grab_window)
+ {
+ switch (window->display->grab_op)
+ {
+ case META_GRAB_OP_MOVING:
+ case META_GRAB_OP_RESIZING_SE:
+ case META_GRAB_OP_RESIZING_S:
+ case META_GRAB_OP_RESIZING_SW:
+ case META_GRAB_OP_RESIZING_N:
+ case META_GRAB_OP_RESIZING_NE:
+ case META_GRAB_OP_RESIZING_NW:
+ case META_GRAB_OP_RESIZING_W:
+ case META_GRAB_OP_RESIZING_E:
+ in_grab_op = TRUE;
+ break;
+ default:
+ break;
+ }
+ }
+
+ /* it's essential to use only the explicitly-set fields,
+ * and otherwise use our current up-to-date position.
+ *
+ * Otherwise you get spurious position changes when the app changes
+ * size, for example, if window->rect is not in sync with the
+ * server-side position in effect when the configure request was
+ * generated.
+ */
+ meta_window_get_gravity_position (window,
+ gravity,
+ &x, &y);
+
+ allow_position_change = FALSE;
+
+ if (meta_prefs_get_disable_workarounds ())
+ {
+ if (window->type == META_WINDOW_DIALOG ||
+ window->type == META_WINDOW_MODAL_DIALOG ||
+ window->type == META_WINDOW_SPLASHSCREEN)
+ ; /* No position change for these */
+ else if ((window->size_hints.flags & PPosition) ||
+ /* USPosition is just stale if window is placed;
+ * no --geometry involved here.
+ */
+ ((window->size_hints.flags & USPosition) &&
+ !window->placed))
+ allow_position_change = TRUE;
+ }
+ else
+ {
+ allow_position_change = TRUE;
+ }
+
+ if (in_grab_op)
+ allow_position_change = FALSE;
+
+ if (allow_position_change)
+ {
+ if (value_mask & CWX)
+ x = new_x;
+ if (value_mask & CWY)
+ y = new_y;
+ if (value_mask & (CWX | CWY))
+ {
+ /* Once manually positioned, windows shouldn't be placed
+ * by the window manager.
+ */
+ window->placed = TRUE;
+ }
+ }
+ else
+ {
+ meta_topic (META_DEBUG_GEOMETRY,
+ "Not allowing position change for window %s PPosition 0x%lx USPosition 0x%lx type %u\n",
+ window->desc, window->size_hints.flags & PPosition,
+ window->size_hints.flags & USPosition,
+ window->type);
+ }
+
+ width = window->rect.width;
+ height = window->rect.height;
+ if (!in_grab_op)
+ {
+ if (value_mask & CWWidth)
+ width = new_width;
+
+ if (value_mask & CWHeight)
+ height = new_height;
+ }
+
+ /* ICCCM 4.1.5 */
+
+ /* We're ignoring the value_mask here, since sizes
+ * not in the mask will be the current window geometry.
+ */
+ window->size_hints.x = x;
+ window->size_hints.y = y;
+ window->size_hints.width = width;
+ window->size_hints.height = height;
+
+ /* NOTE: We consider ConfigureRequests to be "user" actions in one
+ * way, but not in another. Explanation of the two cases are in the
+ * next two big comments.
+ */
+
+ /* The constraints code allows user actions to move windows
+ * offscreen, etc., and configure request actions would often send
+ * windows offscreen when users don't want it if not constrained
+ * (e.g. hitting a dropdown triangle in a fileselector to show more
+ * options, which makes the window bigger). Thus we do not set
+ * META_IS_USER_ACTION in flags to the
+ * meta_window_move_resize_internal() call.
+ */
+ flags = META_IS_CONFIGURE_REQUEST;
+ if (value_mask & (CWX | CWY))
+ flags |= META_IS_MOVE_ACTION;
+ if (value_mask & (CWWidth | CWHeight))
+ flags |= META_IS_RESIZE_ACTION;
+
+ if (flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION))
+ meta_window_move_resize_internal (window,
+ flags,
+ gravity,
+ x,
+ y,
+ width,
+ height);
+
+ /* window->user_rect exists to allow "snapping-back" the window if a
+ * new strut is set (causing the window to move) and then the strut
+ * is later removed without the user moving the window in the
+ * interim. We'd like to "snap-back" to the position specified by
+ * ConfigureRequest events (at least the constrained version of the
+ * ConfigureRequest, since that is guaranteed to be onscreen) so we
+ * set user_rect here.
+ *
+ * See also bug 426519.
+ */
+ save_user_window_placement (window);
+}
+
+gboolean
+meta_window_configure_request (MetaWindow *window,
+ XEvent *event)
+{
+ /* Note that x, y is the corner of the window border,
+ * and width, height is the size of the window inside
+ * its border, but that we always deny border requests
+ * and give windows a border of 0. But we save the
+ * requested border here.
+ */
+ if (event->xconfigurerequest.value_mask & CWBorderWidth)
+ window->border_width = event->xconfigurerequest.border_width;
+
+ meta_window_move_resize_request(window,
+ event->xconfigurerequest.value_mask,
+ window->size_hints.win_gravity,
+ event->xconfigurerequest.x,
+ event->xconfigurerequest.y,
+ event->xconfigurerequest.width,
+ event->xconfigurerequest.height);
+
+ /* Handle stacking. We only handle raises/lowers, mostly because
+ * stack.c really can't deal with anything else. I guess we'll fix
+ * that if a client turns up that really requires it. Only a very
+ * few clients even require the raise/lower (and in fact all client
+ * attempts to deal with stacking order are essentially broken,
+ * since they have no idea what other clients are involved or how
+ * the stack looks).
+ *
+ * I'm pretty sure no interesting client uses TopIf, BottomIf, or
+ * Opposite anyway, so the only possible missing thing is
+ * Above/Below with a sibling set. For now we just pretend there's
+ * never a sibling set and always do the full raise/lower instead of
+ * the raise-just-above/below-sibling.
+ */
+ if (event->xconfigurerequest.value_mask & CWStackMode)
+ {
+ MetaWindow *active_window;
+ active_window = window->display->expected_focus_window;
+ if (meta_prefs_get_disable_workarounds () ||
+ !meta_prefs_get_raise_on_click ())
+ {
+ meta_topic (META_DEBUG_STACK,
+ "%s sent an xconfigure stacking request; this is "
+ "broken behavior and the request is being ignored.\n",
+ window->desc);
+ }
+ else if (active_window &&
+ !meta_window_same_application (window, active_window) &&
+ XSERVER_TIME_IS_BEFORE (window->net_wm_user_time,
+ active_window->net_wm_user_time))
+ {
+ meta_topic (META_DEBUG_STACK,
+ "Ignoring xconfigure stacking request from %s (with "
+ "user_time %u); currently active application is %s (with "
+ "user_time %u).\n",
+ window->desc,
+ window->net_wm_user_time,
+ active_window->desc,
+ active_window->net_wm_user_time);
+ if (event->xconfigurerequest.detail == Above)
+ meta_window_set_demands_attention(window);
+ }
+ else
+ {
+ switch (event->xconfigurerequest.detail)
+ {
+ case Above:
+ meta_window_raise (window);
+ break;
+ case Below:
+ meta_window_lower (window);
+ break;
+ case TopIf:
+ case BottomIf:
+ case Opposite:
+ break;
+ }
+ }
+ }
+
+ return TRUE;
+}
+
+gboolean
+meta_window_property_notify (MetaWindow *window,
+ XEvent *event)
+{
+ return process_property_notify (window, &event->xproperty);
+}
+
+#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT 0
+#define _NET_WM_MOVERESIZE_SIZE_TOP 1
+#define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT 2
+#define _NET_WM_MOVERESIZE_SIZE_RIGHT 3
+#define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT 4
+#define _NET_WM_MOVERESIZE_SIZE_BOTTOM 5
+#define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT 6
+#define _NET_WM_MOVERESIZE_SIZE_LEFT 7
+#define _NET_WM_MOVERESIZE_MOVE 8
+#define _NET_WM_MOVERESIZE_SIZE_KEYBOARD 9
+#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD 10
+#define _NET_WM_MOVERESIZE_CANCEL 11
+
+gboolean
+meta_window_client_message (MetaWindow *window,
+ XEvent *event)
+{
+ MetaDisplay *display;
+
+ display = window->display;
+
+ if (event->xclient.message_type ==
+ display->atom__NET_CLOSE_WINDOW)
+ {
+ guint32 timestamp;
+
+ if (event->xclient.data.l[0] != 0)
+ timestamp = event->xclient.data.l[0];
+ else
+ {
+ meta_warning ("Receiving a NET_CLOSE_WINDOW message for %s without "
+ "a timestamp! This means some buggy (outdated) "
+ "application is on the loose!\n",
+ window->desc);
+ timestamp = meta_display_get_current_time (window->display);
+ }
+
+ meta_window_delete (window, timestamp);
+
+ return TRUE;
+ }
+ else if (event->xclient.message_type ==
+ display->atom__NET_WM_DESKTOP)
+ {
+ int space;
+ MetaWorkspace *workspace;
+
+ space = event->xclient.data.l[0];
+
+ meta_verbose ("Request to move %s to workspace %d\n",
+ window->desc, space);
+
+ workspace =
+ meta_screen_get_workspace_by_index (window->screen,
+ space);
+
+ if (workspace)
+ {
+ if (window->on_all_workspaces)
+ meta_window_unstick (window);
+ meta_window_change_workspace (window, workspace);
+ }
+ else if (space == (int) 0xFFFFFFFF)
+ {
+ meta_window_stick (window);
+ }
+ else
+ {
+ meta_verbose ("No such workspace %d for screen\n", space);
+ }
+
+ meta_verbose ("Window %s now on_all_workspaces = %d\n",
+ window->desc, window->on_all_workspaces);
+
+ return TRUE;
+ }
+ else if (event->xclient.message_type ==
+ display->atom__NET_WM_STATE)
+ {
+ gulong action;
+ Atom first;
+ Atom second;
+
+ action = event->xclient.data.l[0];
+ first = event->xclient.data.l[1];
+ second = event->xclient.data.l[2];
+
+ if (meta_is_verbose ())
+ {
+ char *str1;
+ char *str2;
+
+ meta_error_trap_push_with_return (display);
+ str1 = XGetAtomName (display->xdisplay, first);
+ if (meta_error_trap_pop_with_return (display, TRUE) != Success)
+ str1 = NULL;
+
+ meta_error_trap_push_with_return (display);
+ str2 = XGetAtomName (display->xdisplay, second);
+ if (meta_error_trap_pop_with_return (display, TRUE) != Success)
+ str2 = NULL;
+
+ meta_verbose ("Request to change _NET_WM_STATE action %lu atom1: %s atom2: %s\n",
+ action,
+ str1 ? str1 : "(unknown)",
+ str2 ? str2 : "(unknown)");
+
+ meta_XFree (str1);
+ meta_XFree (str2);
+ }
+
+ if (first == display->atom__NET_WM_STATE_SHADED ||
+ second == display->atom__NET_WM_STATE_SHADED)
+ {
+ gboolean shade;
+ guint32 timestamp;
+
+ /* Stupid protocol has no timestamp; of course, shading
+ * sucks anyway so who really cares that we're forced to do
+ * a roundtrip here?
+ */
+ timestamp = meta_display_get_current_time_roundtrip (window->display);
+
+ shade = (action == _NET_WM_STATE_ADD ||
+ (action == _NET_WM_STATE_TOGGLE && !window->shaded));
+ if (shade && window->has_shade_func)
+ meta_window_shade (window, timestamp);
+ else
+ meta_window_unshade (window, timestamp);
+ }
+
+ if (first == display->atom__NET_WM_STATE_FULLSCREEN ||
+ second == display->atom__NET_WM_STATE_FULLSCREEN)
+ {
+ gboolean make_fullscreen;
+
+ make_fullscreen = (action == _NET_WM_STATE_ADD ||
+ (action == _NET_WM_STATE_TOGGLE && !window->fullscreen));
+ if (make_fullscreen && window->has_fullscreen_func)
+ meta_window_make_fullscreen (window);
+ else
+ meta_window_unmake_fullscreen (window);
+ }
+
+ if (first == display->atom__NET_WM_STATE_MAXIMIZED_HORZ ||
+ second == display->atom__NET_WM_STATE_MAXIMIZED_HORZ)
+ {
+ gboolean max;
+
+ max = (action == _NET_WM_STATE_ADD ||
+ (action == _NET_WM_STATE_TOGGLE &&
+ !window->maximized_horizontally));
+ if (max && window->has_maximize_func)
+ {
+ if (meta_prefs_get_raise_on_click ())
+ meta_window_raise (window);
+ meta_window_maximize (window, META_MAXIMIZE_HORIZONTAL);
+ }
+ else
+ {
+ if (meta_prefs_get_raise_on_click ())
+ meta_window_raise (window);
+ meta_window_unmaximize (window, META_MAXIMIZE_HORIZONTAL);
+ }
+ }
+
+ if (first == display->atom__NET_WM_STATE_MAXIMIZED_VERT ||
+ second == display->atom__NET_WM_STATE_MAXIMIZED_VERT)
+ {
+ gboolean max;
+
+ max = (action == _NET_WM_STATE_ADD ||
+ (action == _NET_WM_STATE_TOGGLE &&
+ !window->maximized_vertically));
+ if (max && window->has_maximize_func)
+ {
+ if (meta_prefs_get_raise_on_click ())
+ meta_window_raise (window);
+ meta_window_maximize (window, META_MAXIMIZE_VERTICAL);
+ }
+ else
+ {
+ if (meta_prefs_get_raise_on_click ())
+ meta_window_raise (window);
+ meta_window_unmaximize (window, META_MAXIMIZE_VERTICAL);
+ }
+ }
+
+ if (first == display->atom__NET_WM_STATE_MODAL ||
+ second == display->atom__NET_WM_STATE_MODAL)
+ {
+ window->wm_state_modal =
+ (action == _NET_WM_STATE_ADD) ||
+ (action == _NET_WM_STATE_TOGGLE && !window->wm_state_modal);
+
+ recalc_window_type (window);
+ meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+ }
+
+ if (first == display->atom__NET_WM_STATE_SKIP_PAGER ||
+ second == display->atom__NET_WM_STATE_SKIP_PAGER)
+ {
+ window->wm_state_skip_pager =
+ (action == _NET_WM_STATE_ADD) ||
+ (action == _NET_WM_STATE_TOGGLE && !window->skip_pager);
+
+ recalc_window_features (window);
+ set_net_wm_state (window);
+ }
+
+ if (first == display->atom__NET_WM_STATE_SKIP_TASKBAR ||
+ second == display->atom__NET_WM_STATE_SKIP_TASKBAR)
+ {
+ window->wm_state_skip_taskbar =
+ (action == _NET_WM_STATE_ADD) ||
+ (action == _NET_WM_STATE_TOGGLE && !window->skip_taskbar);
+
+ recalc_window_features (window);
+ set_net_wm_state (window);
+ }
+
+ if (first == display->atom__NET_WM_STATE_ABOVE ||
+ second == display->atom__NET_WM_STATE_ABOVE)
+ {
+ window->wm_state_above =
+ (action == _NET_WM_STATE_ADD) ||
+ (action == _NET_WM_STATE_TOGGLE && !window->wm_state_above);
+
+ meta_window_update_layer (window);
+ set_net_wm_state (window);
+ }
+
+ if (first == display->atom__NET_WM_STATE_BELOW ||
+ second == display->atom__NET_WM_STATE_BELOW)
+ {
+ window->wm_state_below =
+ (action == _NET_WM_STATE_ADD) ||
+ (action == _NET_WM_STATE_TOGGLE && !window->wm_state_below);
+
+ meta_window_update_layer (window);
+ set_net_wm_state (window);
+ }
+
+ if (first == display->atom__NET_WM_STATE_DEMANDS_ATTENTION ||
+ second == display->atom__NET_WM_STATE_DEMANDS_ATTENTION)
+ {
+ if ((action == _NET_WM_STATE_ADD) ||
+ (action == _NET_WM_STATE_TOGGLE && !window->wm_state_demands_attention))
+ meta_window_set_demands_attention (window);
+ else
+ meta_window_unset_demands_attention (window);
+ }
+
+ if (first == display->atom__NET_WM_STATE_STICKY ||
+ second == display->atom__NET_WM_STATE_STICKY)
+ {
+ if ((action == _NET_WM_STATE_ADD) ||
+ (action == _NET_WM_STATE_TOGGLE && !window->on_all_workspaces))
+ meta_window_stick (window);
+ else
+ meta_window_unstick (window);
+ }
+
+ return TRUE;
+ }
+ else if (event->xclient.message_type ==
+ display->atom_WM_CHANGE_STATE)
+ {
+ meta_verbose ("WM_CHANGE_STATE client message, state: %ld\n",
+ event->xclient.data.l[0]);
+ if (event->xclient.data.l[0] == IconicState &&
+ window->has_minimize_func)
+ meta_window_minimize (window);
+
+ return TRUE;
+ }
+ else if (event->xclient.message_type ==
+ display->atom__NET_WM_MOVERESIZE)
+ {
+ int x_root;
+ int y_root;
+ int action;
+ MetaGrabOp op;
+ int button;
+ guint32 timestamp;
+
+ /* _NET_WM_MOVERESIZE messages are almost certainly going to come from
+ * clients when users click on the fake "frame" that the client has,
+ * thus we should also treat such messages as though it were a
+ * "frame action".
+ */
+ gboolean const frame_action = TRUE;
+
+ x_root = event->xclient.data.l[0];
+ y_root = event->xclient.data.l[1];
+ action = event->xclient.data.l[2];
+ button = event->xclient.data.l[3];
+
+ /* FIXME: What a braindead protocol; no timestamp?!? */
+ timestamp = meta_display_get_current_time_roundtrip (display);
+ meta_warning ("Received a _NET_WM_MOVERESIZE message for %s; these "
+ "messages lack timestamps and therefore suck.\n",
+ window->desc);
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Received _NET_WM_MOVERESIZE message on %s, %d,%d action = %d, button %d\n",
+ window->desc,
+ x_root, y_root, action, button);
+
+ op = META_GRAB_OP_NONE;
+ switch (action)
+ {
+ case _NET_WM_MOVERESIZE_SIZE_TOPLEFT:
+ op = META_GRAB_OP_RESIZING_NW;
+ break;
+ case _NET_WM_MOVERESIZE_SIZE_TOP:
+ op = META_GRAB_OP_RESIZING_N;
+ break;
+ case _NET_WM_MOVERESIZE_SIZE_TOPRIGHT:
+ op = META_GRAB_OP_RESIZING_NE;
+ break;
+ case _NET_WM_MOVERESIZE_SIZE_RIGHT:
+ op = META_GRAB_OP_RESIZING_E;
+ break;
+ case _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT:
+ op = META_GRAB_OP_RESIZING_SE;
+ break;
+ case _NET_WM_MOVERESIZE_SIZE_BOTTOM:
+ op = META_GRAB_OP_RESIZING_S;
+ break;
+ case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT:
+ op = META_GRAB_OP_RESIZING_SW;
+ break;
+ case _NET_WM_MOVERESIZE_SIZE_LEFT:
+ op = META_GRAB_OP_RESIZING_W;
+ break;
+ case _NET_WM_MOVERESIZE_MOVE:
+ op = META_GRAB_OP_MOVING;
+ break;
+ case _NET_WM_MOVERESIZE_SIZE_KEYBOARD:
+ op = META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN;
+ break;
+ case _NET_WM_MOVERESIZE_MOVE_KEYBOARD:
+ op = META_GRAB_OP_KEYBOARD_MOVING;
+ break;
+ case _NET_WM_MOVERESIZE_CANCEL:
+ /* handled below */
+ break;
+ default:
+ break;
+ }
+
+ if (action == _NET_WM_MOVERESIZE_CANCEL)
+ {
+ meta_display_end_grab_op (window->display, timestamp);
+ }
+ else if (op != META_GRAB_OP_NONE &&
+ ((window->has_move_func && op == META_GRAB_OP_KEYBOARD_MOVING) ||
+ (window->has_resize_func && op == META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN)))
+ {
+ meta_window_begin_grab_op (window, op, frame_action, timestamp);
+ }
+ else if (op != META_GRAB_OP_NONE &&
+ ((window->has_move_func && op == META_GRAB_OP_MOVING) ||
+ (window->has_resize_func &&
+ (op != META_GRAB_OP_MOVING &&
+ op != META_GRAB_OP_KEYBOARD_MOVING))))
+ {
+ /*
+ * the button SHOULD already be included in the message
+ */
+ if (button == 0)
+ {
+ int x, y, query_root_x, query_root_y;
+ Window root, child;
+ guint mask;
+
+ /* The race conditions in this _NET_WM_MOVERESIZE thing
+ * are mind-boggling
+ */
+ mask = 0;
+ meta_error_trap_push (window->display);
+ XQueryPointer (window->display->xdisplay,
+ window->xwindow,
+ &root, &child,
+ &query_root_x, &query_root_y,
+ &x, &y,
+ &mask);
+ meta_error_trap_pop (window->display, TRUE);
+
+ if (mask & Button1Mask)
+ button = 1;
+ else if (mask & Button2Mask)
+ button = 2;
+ else if (mask & Button3Mask)
+ button = 3;
+ else
+ button = 0;
+ }
+
+ if (button != 0)
+ {
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Beginning move/resize with button = %d\n", button);
+ meta_display_begin_grab_op (window->display,
+ window->screen,
+ window,
+ op,
+ FALSE,
+ frame_action,
+ button, 0,
+ timestamp,
+ x_root,
+ y_root);
+ }
+ }
+
+ return TRUE;
+ }
+ else if (event->xclient.message_type ==
+ display->atom__NET_MOVERESIZE_WINDOW)
+ {
+ int gravity, source;
+ guint value_mask;
+
+ gravity = (event->xclient.data.l[0] & 0xff);
+ value_mask = (event->xclient.data.l[0] & 0xf00) >> 8;
+ source = (event->xclient.data.l[0] & 0xf000) >> 12;
+
+ if (gravity == 0)
+ gravity = window->size_hints.win_gravity;
+
+ meta_window_move_resize_request(window,
+ value_mask,
+ gravity,
+ event->xclient.data.l[1], /* x */
+ event->xclient.data.l[2], /* y */
+ event->xclient.data.l[3], /* width */
+ event->xclient.data.l[4]); /* height */
+ }
+ else if (event->xclient.message_type ==
+ display->atom__NET_ACTIVE_WINDOW)
+ {
+ MetaClientType source_indication;
+ guint32 timestamp;
+
+ meta_verbose ("_NET_ACTIVE_WINDOW request for window '%s', activating\n",
+ window->desc);
+
+ source_indication = event->xclient.data.l[0];
+ timestamp = event->xclient.data.l[1];
+
+ if (source_indication > META_CLIENT_TYPE_MAX_RECOGNIZED)
+ source_indication = META_CLIENT_TYPE_UNKNOWN;
+
+ if (timestamp == 0)
+ {
+ /* Client using older EWMH _NET_ACTIVE_WINDOW without a timestamp */
+ meta_warning ("Buggy client sent a _NET_ACTIVE_WINDOW message with a "
+ "timestamp of 0 for %s\n",
+ window->desc);
+ timestamp = meta_display_get_current_time (display);
+ }
+
+ window_activate (window, timestamp, source_indication, NULL);
+ return TRUE;
+ }
+ else if (event->xclient.message_type ==
+ display->atom__NET_WM_FULLSCREEN_MONITORS)
+ {
+ MetaClientType source_indication;
+ gulong top, bottom, left, right;
+
+ meta_verbose ("_NET_WM_FULLSCREEN_MONITORS request for window '%s'\n",
+ window->desc);
+
+ top = event->xclient.data.l[0];
+ bottom = event->xclient.data.l[1];
+ left = event->xclient.data.l[2];
+ right = event->xclient.data.l[3];
+ source_indication = event->xclient.data.l[4];
+
+ meta_window_update_fullscreen_monitors (window, top, bottom, left, right);
+ }
+
+ return FALSE;
+}
+
+gboolean
+meta_window_notify_focus (MetaWindow *window,
+ XEvent *event)
+{
+ /* note the event can be on either the window or the frame,
+ * we focus the frame for shaded windows
+ */
+
+ /* The event can be FocusIn, FocusOut, or UnmapNotify.
+ * On UnmapNotify we have to pretend it's focus out,
+ * because we won't get a focus out if it occurs, apparently.
+ */
+
+ /* We ignore grabs, though this is questionable.
+ * It may be better to increase the intelligence of
+ * the focus window tracking.
+ *
+ * The problem is that keybindings for windows are done with
+ * XGrabKey, which means focus_window disappears and the front of
+ * the MRU list gets confused from what the user expects once a
+ * keybinding is used.
+ */
+ meta_topic (META_DEBUG_FOCUS,
+ "Focus %s event received on %s 0x%lx (%s) "
+ "mode %s detail %s\n",
+ event->type == FocusIn ? "in" :
+ event->type == FocusOut ? "out" :
+ event->type == UnmapNotify ? "unmap" :
+ "???",
+ window->desc, event->xany.window,
+ event->xany.window == window->xwindow ?
+ "client window" :
+ (window->frame && event->xany.window == window->frame->xwindow) ?
+ "frame window" :
+ "unknown window",
+ event->type != UnmapNotify ?
+ meta_event_mode_to_string (event->xfocus.mode) : "n/a",
+ event->type != UnmapNotify ?
+ meta_event_detail_to_string (event->xfocus.detail) : "n/a");
+
+ /* FIXME our pointer tracking is broken; see how
+ * gtk+/gdk/x11/gdkevents-x11.c or XFree86/xc/programs/xterm/misc.c
+ * handle it for the correct way. In brief you need to track
+ * pointer focus and regular focus, and handle EnterNotify in
+ * PointerRoot mode with no window manager. However as noted above,
+ * accurate focus tracking will break things because we want to keep
+ * windows "focused" when using keybindings on them, and also we
+ * sometimes "focus" a window by focusing its frame or
+ * no_focus_window; so this all needs rethinking massively.
+ *
+ * My suggestion is to change it so that we clearly separate
+ * actual keyboard focus tracking using the xterm algorithm,
+ * and marco's "pretend" focus window, and go through all
+ * the code and decide which one should be used in each place;
+ * a hard bit is deciding on a policy for that.
+ *
+ * http://bugzilla.gnome.org/show_bug.cgi?id=90382
+ */
+
+ if ((event->type == FocusIn ||
+ event->type == FocusOut) &&
+ (event->xfocus.mode == NotifyGrab ||
+ event->xfocus.mode == NotifyUngrab ||
+ /* From WindowMaker, ignore all funky pointer root events */
+ event->xfocus.detail > NotifyNonlinearVirtual))
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "Ignoring focus event generated by a grab or other weirdness\n");
+ return TRUE;
+ }
+
+ if (event->type == FocusIn)
+ {
+ if (window != window->display->focus_window)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "* Focus --> %s\n", window->desc);
+ window->display->focus_window = window;
+ window->has_focus = TRUE;
+ meta_compositor_set_active_window (window->display->compositor,
+ window->screen, window);
+
+ /* Move to the front of the focusing workspace's MRU list.
+ * We should only be "removing" it from the MRU list if it's
+ * not already there. Note that it's possible that we might
+ * be processing this FocusIn after we've changed to a
+ * different workspace; we should therefore update the MRU
+ * list only if the window is actually on the active
+ * workspace.
+ */
+ if (window->screen->active_workspace &&
+ meta_window_located_on_workspace (window,
+ window->screen->active_workspace))
+ {
+ GList* link;
+ link = g_list_find (window->screen->active_workspace->mru_list,
+ window);
+ g_assert (link);
+
+ window->screen->active_workspace->mru_list =
+ g_list_remove_link (window->screen->active_workspace->mru_list,
+ link);
+ g_list_free (link);
+
+ window->screen->active_workspace->mru_list =
+ g_list_prepend (window->screen->active_workspace->mru_list,
+ window);
+ }
+
+ if (window->frame)
+ meta_frame_queue_draw (window->frame);
+
+ meta_error_trap_push (window->display);
+ XInstallColormap (window->display->xdisplay,
+ window->colormap);
+ meta_error_trap_pop (window->display, FALSE);
+
+ /* move into FOCUSED_WINDOW layer */
+ meta_window_update_layer (window);
+
+ /* Ungrab click to focus button since the sync grab can interfere
+ * with some things you might do inside the focused window, by
+ * causing the client to get funky enter/leave events.
+ *
+ * The reason we usually have a passive grab on the window is
+ * so that we can intercept clicks and raise the window in
+ * response. For click-to-focus we don't need that since the
+ * focused window is already raised. When raise_on_click is
+ * FALSE we also don't need that since we don't do anything
+ * when the window is clicked.
+ *
+ * There is dicussion in bugs 102209, 115072, and 461577
+ */
+ if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK ||
+ !meta_prefs_get_raise_on_click())
+ meta_display_ungrab_focus_window_button (window->display, window);
+ }
+ }
+ else if (event->type == FocusOut ||
+ event->type == UnmapNotify)
+ {
+ if (event->type == FocusOut &&
+ event->xfocus.detail == NotifyInferior)
+ {
+ /* This event means the client moved focus to a subwindow */
+ meta_topic (META_DEBUG_FOCUS,
+ "Ignoring focus out on %s with NotifyInferior\n",
+ window->desc);
+ return TRUE;
+ }
+
+ if (window == window->display->focus_window)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "%s is now the previous focus window due to being focused out or unmapped\n",
+ window->desc);
+
+ meta_topic (META_DEBUG_FOCUS,
+ "* Focus --> NULL (was %s)\n", window->desc);
+
+ window->display->focus_window = NULL;
+ window->has_focus = FALSE;
+ if (window->frame)
+ meta_frame_queue_draw (window->frame);
+
+ meta_compositor_set_active_window (window->display->compositor,
+ window->screen, NULL);
+
+ meta_error_trap_push (window->display);
+ XUninstallColormap (window->display->xdisplay,
+ window->colormap);
+ meta_error_trap_pop (window->display, FALSE);
+
+ /* move out of FOCUSED_WINDOW layer */
+ meta_window_update_layer (window);
+
+ /* Re-grab for click to focus and raise-on-click, if necessary */
+ if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK ||
+ !meta_prefs_get_raise_on_click ())
+ meta_display_grab_focus_window_button (window->display, window);
+ }
+ }
+
+ /* Now set _NET_ACTIVE_WINDOW hint */
+ meta_display_update_active_window_hint (window->display);
+
+ return FALSE;
+}
+
+static gboolean
+process_property_notify (MetaWindow *window,
+ XPropertyEvent *event)
+{
+ Window xid = window->xwindow;
+
+ if (meta_is_verbose ()) /* avoid looking up the name if we don't have to */
+ {
+ char *property_name = XGetAtomName (window->display->xdisplay,
+ event->atom);
+
+ meta_verbose ("Property notify on %s for %s\n",
+ window->desc, property_name);
+ XFree (property_name);
+ }
+
+ if (event->atom == window->display->atom__NET_WM_USER_TIME &&
+ window->user_time_window)
+ {
+ xid = window->user_time_window;
+ }
+
+ meta_window_reload_property (window, event->atom, FALSE);
+
+ return TRUE;
+}
+
+static void
+send_configure_notify (MetaWindow *window)
+{
+ XEvent event;
+
+ /* from twm */
+
+ event.type = ConfigureNotify;
+ event.xconfigure.display = window->display->xdisplay;
+ event.xconfigure.event = window->xwindow;
+ event.xconfigure.window = window->xwindow;
+ event.xconfigure.x = window->rect.x - window->border_width;
+ event.xconfigure.y = window->rect.y - window->border_width;
+ if (window->frame)
+ {
+ if (window->withdrawn)
+ {
+ /* WARNING: x & y need to be set to whatever the XReparentWindow
+ * call in meta_window_destroy_frame will use so that the window
+ * has the right coordinates. Currently, that means no change to
+ * x & y.
+ */
+ }
+ else
+ {
+ /* Need to be in root window coordinates */
+ event.xconfigure.x += window->frame->rect.x;
+ event.xconfigure.y += window->frame->rect.y;
+ }
+ }
+ event.xconfigure.width = window->rect.width;
+ event.xconfigure.height = window->rect.height;
+ event.xconfigure.border_width = window->border_width; /* requested not actual */
+ event.xconfigure.above = None; /* FIXME */
+ event.xconfigure.override_redirect = False;
+
+ meta_topic (META_DEBUG_GEOMETRY,
+ "Sending synthetic configure notify to %s with x: %d y: %d w: %d h: %d\n",
+ window->desc,
+ event.xconfigure.x, event.xconfigure.y,
+ event.xconfigure.width, event.xconfigure.height);
+
+ meta_error_trap_push (window->display);
+ XSendEvent (window->display->xdisplay,
+ window->xwindow,
+ False, StructureNotifyMask, &event);
+ meta_error_trap_pop (window->display, FALSE);
+}
+
+gboolean
+meta_window_get_icon_geometry (MetaWindow *window,
+ MetaRectangle *rect)
+{
+ gulong *geometry = NULL;
+ int nitems;
+
+ if (meta_prop_get_cardinal_list (window->display,
+ window->xwindow,
+ window->display->atom__NET_WM_ICON_GEOMETRY,
+ &geometry, &nitems))
+ {
+ if (nitems != 4)
+ {
+ meta_verbose ("_NET_WM_ICON_GEOMETRY on %s has %d values instead of 4\n",
+ window->desc, nitems);
+ meta_XFree (geometry);
+ return FALSE;
+ }
+
+ if (rect)
+ {
+ rect->x = geometry[0];
+ rect->y = geometry[1];
+ rect->width = geometry[2];
+ rect->height = geometry[3];
+ }
+
+ meta_XFree (geometry);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static Window
+read_client_leader (MetaDisplay *display,
+ Window xwindow)
+{
+ Window retval = None;
+
+ meta_prop_get_window (display, xwindow,
+ display->atom_WM_CLIENT_LEADER,
+ &retval);
+
+ return retval;
+}
+
+typedef struct
+{
+ Window leader;
+} ClientLeaderData;
+
+static gboolean
+find_client_leader_func (MetaWindow *ancestor,
+ void *data)
+{
+ ClientLeaderData *d;
+
+ d = data;
+
+ d->leader = read_client_leader (ancestor->display,
+ ancestor->xwindow);
+
+ /* keep going if no client leader found */
+ return d->leader == None;
+}
+
+static void
+update_sm_hints (MetaWindow *window)
+{
+ Window leader;
+
+ window->xclient_leader = None;
+ window->sm_client_id = NULL;
+
+ /* If not on the current window, we can get the client
+ * leader from transient parents. If we find a client
+ * leader, we read the SM_CLIENT_ID from it.
+ */
+ leader = read_client_leader (window->display, window->xwindow);
+ if (leader == None)
+ {
+ ClientLeaderData d;
+ d.leader = None;
+ meta_window_foreach_ancestor (window, find_client_leader_func,
+ &d);
+ leader = d.leader;
+ }
+
+ if (leader != None)
+ {
+ char *str;
+
+ window->xclient_leader = leader;
+
+ if (meta_prop_get_latin1_string (window->display, leader,
+ window->display->atom_SM_CLIENT_ID,
+ &str))
+ {
+ window->sm_client_id = g_strdup (str);
+ meta_XFree (str);
+ }
+ }
+ else
+ {
+ meta_verbose ("Didn't find a client leader for %s\n", window->desc);
+
+ if (!meta_prefs_get_disable_workarounds ())
+ {
+ /* Some broken apps (kdelibs fault?) set SM_CLIENT_ID on the app
+ * instead of the client leader
+ */
+ char *str;
+
+ str = NULL;
+ if (meta_prop_get_latin1_string (window->display, window->xwindow,
+ window->display->atom_SM_CLIENT_ID,
+ &str))
+ {
+ if (window->sm_client_id == NULL) /* first time through */
+ meta_warning (_("Window %s sets SM_CLIENT_ID on itself, instead of on the WM_CLIENT_LEADER window as specified in the ICCCM.\n"),
+ window->desc);
+
+ window->sm_client_id = g_strdup (str);
+ meta_XFree (str);
+ }
+ }
+ }
+
+ meta_verbose ("Window %s client leader: 0x%lx SM_CLIENT_ID: '%s'\n",
+ window->desc, window->xclient_leader,
+ window->sm_client_id ? window->sm_client_id : "none");
+}
+
+void
+meta_window_update_role (MetaWindow *window)
+{
+ char *str;
+
+ if (window->role)
+ g_free (window->role);
+ window->role = NULL;
+
+ if (meta_prop_get_latin1_string (window->display, window->xwindow,
+ window->display->atom_WM_WINDOW_ROLE,
+ &str))
+ {
+ window->role = g_strdup (str);
+ meta_XFree (str);
+ }
+
+ meta_verbose ("Updated role of %s to '%s'\n",
+ window->desc, window->role ? window->role : "null");
+}
+
+void
+meta_window_update_net_wm_type (MetaWindow *window)
+{
+ int n_atoms;
+ Atom *atoms;
+ int i;
+
+ window->type_atom = None;
+ n_atoms = 0;
+ atoms = NULL;
+
+ meta_prop_get_atom_list (window->display, window->xwindow,
+ window->display->atom__NET_WM_WINDOW_TYPE,
+ &atoms, &n_atoms);
+
+ i = 0;
+ while (i < n_atoms)
+ {
+ /* We break as soon as we find one we recognize,
+ * supposed to prefer those near the front of the list
+ */
+ if (atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DESKTOP ||
+ atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DOCK ||
+ atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_TOOLBAR ||
+ atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_MENU ||
+ atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG ||
+ atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL ||
+ atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_UTILITY ||
+ atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_SPLASH)
+ {
+ window->type_atom = atoms[i];
+ break;
+ }
+
+ ++i;
+ }
+
+ meta_XFree (atoms);
+
+ if (meta_is_verbose ())
+ {
+ char *str;
+
+ str = NULL;
+ if (window->type_atom != None)
+ {
+ meta_error_trap_push (window->display);
+ str = XGetAtomName (window->display->xdisplay, window->type_atom);
+ meta_error_trap_pop (window->display, TRUE);
+ }
+
+ meta_verbose ("Window %s type atom %s\n", window->desc,
+ str ? str : "(none)");
+
+ if (str)
+ meta_XFree (str);
+ }
+
+ meta_window_recalc_window_type (window);
+}
+
+static void
+redraw_icon (MetaWindow *window)
+{
+ /* We could probably be smart and just redraw the icon here,
+ * instead of the whole frame.
+ */
+ if (window->frame && (window->mapped || window->frame->mapped))
+ meta_ui_queue_frame_draw (window->screen->ui, window->frame->xwindow);
+}
+
+void
+meta_window_update_icon_now (MetaWindow *window)
+{
+ GdkPixbuf *icon;
+ GdkPixbuf *mini_icon;
+
+ icon = NULL;
+ mini_icon = NULL;
+
+ if (meta_read_icons (window->screen,
+ window->xwindow,
+ &window->icon_cache,
+ window->wm_hints_pixmap,
+ window->wm_hints_mask,
+ &icon,
+ META_ICON_WIDTH, META_ICON_HEIGHT,
+ &mini_icon,
+ META_MINI_ICON_WIDTH,
+ META_MINI_ICON_HEIGHT))
+ {
+ if (window->icon)
+ g_object_unref (G_OBJECT (window->icon));
+
+ if (window->mini_icon)
+ g_object_unref (G_OBJECT (window->mini_icon));
+
+ window->icon = icon;
+ window->mini_icon = mini_icon;
+
+ redraw_icon (window);
+ }
+
+ g_assert (window->icon);
+ g_assert (window->mini_icon);
+}
+
+static gboolean
+idle_update_icon (gpointer data)
+{
+ GSList *tmp;
+ GSList *copy;
+ guint queue_index = GPOINTER_TO_INT (data);
+
+ meta_topic (META_DEBUG_GEOMETRY, "Clearing the update_icon queue\n");
+
+ /* Work with a copy, for reentrancy. The allowed reentrancy isn't
+ * complete; destroying a window while we're in here would result in
+ * badness. But it's OK to queue/unqueue update_icons.
+ */
+ copy = g_slist_copy (queue_pending[queue_index]);
+ g_slist_free (queue_pending[queue_index]);
+ queue_pending[queue_index] = NULL;
+ queue_idle[queue_index] = 0;
+
+ destroying_windows_disallowed += 1;
+
+ tmp = copy;
+ while (tmp != NULL)
+ {
+ MetaWindow *window;
+
+ window = tmp->data;
+
+ meta_window_update_icon_now (window);
+ window->is_in_queues &= ~META_QUEUE_UPDATE_ICON;
+
+ tmp = tmp->next;
+ }
+
+ g_slist_free (copy);
+
+ destroying_windows_disallowed -= 1;
+
+ return FALSE;
+}
+
+GList*
+meta_window_get_workspaces (MetaWindow *window)
+{
+ if (window->on_all_workspaces)
+ return window->screen->workspaces;
+ else
+ return window->workspace->list_containing_self;
+}
+
+static void
+invalidate_work_areas (MetaWindow *window)
+{
+ GList *tmp;
+
+ tmp = meta_window_get_workspaces (window);
+
+ while (tmp != NULL)
+ {
+ meta_workspace_invalidate_work_area (tmp->data);
+ tmp = tmp->next;
+ }
+}
+
+void
+meta_window_update_struts (MetaWindow *window)
+{
+ GSList *old_struts;
+ GSList *new_struts;
+ GSList *old_iter, *new_iter;
+ gulong *struts = NULL;
+ int nitems;
+ gboolean changed;
+
+ meta_verbose ("Updating struts for %s\n", window->desc);
+
+ old_struts = window->struts;
+ new_struts = NULL;
+
+ if (meta_prop_get_cardinal_list (window->display,
+ window->xwindow,
+ window->display->atom__NET_WM_STRUT_PARTIAL,
+ &struts, &nitems))
+ {
+ if (nitems != 12)
+ meta_verbose ("_NET_WM_STRUT_PARTIAL on %s has %d values instead "
+ "of 12\n",
+ window->desc, nitems);
+ else
+ {
+ /* Pull out the strut info for each side in the hint */
+ int i;
+ for (i=0; i<4; i++)
+ {
+ MetaStrut *temp;
+ int thickness, strut_begin, strut_end;
+
+ thickness = struts[i];
+ if (thickness == 0)
+ continue;
+ strut_begin = struts[4+(i*2)];
+ strut_end = struts[4+(i*2)+1];
+
+ temp = g_new (MetaStrut, 1);
+ temp->side = 1 << i; /* See MetaSide def. Matches nicely, eh? */
+ temp->rect = window->screen->rect;
+ switch (temp->side)
+ {
+ case META_SIDE_RIGHT:
+ temp->rect.x = BOX_RIGHT(temp->rect) - thickness;
+ /* Intentionally fall through without breaking */
+ case META_SIDE_LEFT:
+ temp->rect.width = thickness;
+ temp->rect.y = strut_begin;
+ temp->rect.height = strut_end - strut_begin + 1;
+ break;
+ case META_SIDE_BOTTOM:
+ temp->rect.y = BOX_BOTTOM(temp->rect) - thickness;
+ /* Intentionally fall through without breaking */
+ case META_SIDE_TOP:
+ temp->rect.height = thickness;
+ temp->rect.x = strut_begin;
+ temp->rect.width = strut_end - strut_begin + 1;
+ break;
+ default:
+ g_assert_not_reached ();
+ }
+
+ new_struts = g_slist_prepend (new_struts, temp);
+ }
+
+ meta_verbose ("_NET_WM_STRUT_PARTIAL struts %lu %lu %lu %lu for "
+ "window %s\n",
+ struts[0], struts[1], struts[2], struts[3],
+ window->desc);
+ }
+ meta_XFree (struts);
+ }
+ else
+ {
+ meta_verbose ("No _NET_WM_STRUT property for %s\n",
+ window->desc);
+ }
+
+ if (!new_struts &&
+ meta_prop_get_cardinal_list (window->display,
+ window->xwindow,
+ window->display->atom__NET_WM_STRUT,
+ &struts, &nitems))
+ {
+ if (nitems != 4)
+ meta_verbose ("_NET_WM_STRUT on %s has %d values instead of 4\n",
+ window->desc, nitems);
+ else
+ {
+ /* Pull out the strut info for each side in the hint */
+ int i;
+ for (i=0; i<4; i++)
+ {
+ MetaStrut *temp;
+ int thickness;
+
+ thickness = struts[i];
+ if (thickness == 0)
+ continue;
+
+ temp = g_new (MetaStrut, 1);
+ temp->side = 1 << i;
+ temp->rect = window->screen->rect;
+ switch (temp->side)
+ {
+ case META_SIDE_RIGHT:
+ temp->rect.x = BOX_RIGHT(temp->rect) - thickness;
+ /* Intentionally fall through without breaking */
+ case META_SIDE_LEFT:
+ temp->rect.width = thickness;
+ break;
+ case META_SIDE_BOTTOM:
+ temp->rect.y = BOX_BOTTOM(temp->rect) - thickness;
+ /* Intentionally fall through without breaking */
+ case META_SIDE_TOP:
+ temp->rect.height = thickness;
+ break;
+ default:
+ g_assert_not_reached ();
+ }
+
+ new_struts = g_slist_prepend (new_struts, temp);
+ }
+
+ meta_verbose ("_NET_WM_STRUT struts %lu %lu %lu %lu for window %s\n",
+ struts[0], struts[1], struts[2], struts[3],
+ window->desc);
+ }
+ meta_XFree (struts);
+ }
+ else if (!new_struts)
+ {
+ meta_verbose ("No _NET_WM_STRUT property for %s\n",
+ window->desc);
+ }
+
+ /* Determine whether old_struts and new_struts are the same */
+ old_iter = old_struts;
+ new_iter = new_struts;
+ while (old_iter && new_iter)
+ {
+ MetaStrut *old_strut = (MetaStrut*) old_iter->data;
+ MetaStrut *new_strut = (MetaStrut*) new_iter->data;
+
+ if (old_strut->side != new_strut->side ||
+ !meta_rectangle_equal (&old_strut->rect, &new_strut->rect))
+ break;
+
+ old_iter = old_iter->next;
+ new_iter = new_iter->next;
+ }
+ changed = (old_iter != NULL || new_iter != NULL);
+
+ /* Update appropriately */
+ meta_free_gslist_and_elements (old_struts);
+ window->struts = new_struts;
+ if (changed)
+ {
+ meta_topic (META_DEBUG_WORKAREA,
+ "Invalidating work areas of window %s due to struts update\n",
+ window->desc);
+ invalidate_work_areas (window);
+ }
+ else
+ {
+ meta_topic (META_DEBUG_WORKAREA,
+ "Struts on %s were unchanged\n", window->desc);
+ }
+}
+
+void
+meta_window_recalc_window_type (MetaWindow *window)
+{
+ recalc_window_type (window);
+}
+
+static void
+recalc_window_type (MetaWindow *window)
+{
+ MetaWindowType old_type;
+
+ old_type = window->type;
+
+ if (window->type_atom != None)
+ {
+ if (window->type_atom == window->display->atom__NET_WM_WINDOW_TYPE_DESKTOP)
+ window->type = META_WINDOW_DESKTOP;
+ else if (window->type_atom == window->display->atom__NET_WM_WINDOW_TYPE_DOCK)
+ window->type = META_WINDOW_DOCK;
+ else if (window->type_atom == window->display->atom__NET_WM_WINDOW_TYPE_TOOLBAR)
+ window->type = META_WINDOW_TOOLBAR;
+ else if (window->type_atom == window->display->atom__NET_WM_WINDOW_TYPE_MENU)
+ window->type = META_WINDOW_MENU;
+ else if (window->type_atom == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG)
+ window->type = META_WINDOW_DIALOG;
+ else if (window->type_atom == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL)
+ window->type = META_WINDOW_NORMAL;
+ else if (window->type_atom == window->display->atom__NET_WM_WINDOW_TYPE_UTILITY)
+ window->type = META_WINDOW_UTILITY;
+ else if (window->type_atom == window->display->atom__NET_WM_WINDOW_TYPE_SPLASH)
+ window->type = META_WINDOW_SPLASHSCREEN;
+ else
+ meta_bug ("Set a type atom for %s that wasn't handled in recalc_window_type\n",
+ window->desc);
+ }
+ else if (window->xtransient_for != None)
+ {
+ window->type = META_WINDOW_DIALOG;
+ }
+ else
+ {
+ window->type = META_WINDOW_NORMAL;
+ }
+
+ if (window->type == META_WINDOW_DIALOG &&
+ window->wm_state_modal)
+ window->type = META_WINDOW_MODAL_DIALOG;
+
+ meta_verbose ("Calculated type %u for %s, old type %u\n",
+ window->type, window->desc, old_type);
+
+ if (old_type != window->type)
+ {
+ recalc_window_features (window);
+
+ set_net_wm_state (window);
+
+ /* Update frame */
+ if (window->decorated)
+ meta_window_ensure_frame (window);
+ else
+ meta_window_destroy_frame (window);
+
+ /* update stacking constraints */
+ meta_window_update_layer (window);
+
+ meta_window_grab_keys (window);
+ }
+}
+
+static void
+set_allowed_actions_hint (MetaWindow *window)
+{
+#define MAX_N_ACTIONS 12
+ unsigned long data[MAX_N_ACTIONS];
+ int i;
+
+ i = 0;
+ if (window->has_move_func)
+ {
+ data[i] = window->display->atom__NET_WM_ACTION_MOVE;
+ ++i;
+ }
+ if (window->has_resize_func)
+ {
+ data[i] = window->display->atom__NET_WM_ACTION_RESIZE;
+ ++i;
+ }
+ if (window->has_fullscreen_func)
+ {
+ data[i] = window->display->atom__NET_WM_ACTION_FULLSCREEN;
+ ++i;
+ }
+ if (window->has_minimize_func)
+ {
+ data[i] = window->display->atom__NET_WM_ACTION_MINIMIZE;
+ ++i;
+ }
+ if (window->has_shade_func)
+ {
+ data[i] = window->display->atom__NET_WM_ACTION_SHADE;
+ ++i;
+ }
+ /* sticky according to EWMH is different from marco's sticky;
+ * marco doesn't support EWMH sticky
+ */
+ if (window->has_maximize_func)
+ {
+ data[i] = window->display->atom__NET_WM_ACTION_MAXIMIZE_HORZ;
+ ++i;
+ data[i] = window->display->atom__NET_WM_ACTION_MAXIMIZE_VERT;
+ ++i;
+ }
+ /* We always allow this */
+ data[i] = window->display->atom__NET_WM_ACTION_CHANGE_DESKTOP;
+ ++i;
+ if (window->has_close_func)
+ {
+ data[i] = window->display->atom__NET_WM_ACTION_CLOSE;
+ ++i;
+ }
+
+ /* I guess we always allow above/below operations */
+ data[i] = window->display->atom__NET_WM_ACTION_ABOVE;
+ ++i;
+ data[i] = window->display->atom__NET_WM_ACTION_BELOW;
+ ++i;
+
+ g_assert (i <= MAX_N_ACTIONS);
+
+ meta_verbose ("Setting _NET_WM_ALLOWED_ACTIONS with %d atoms\n", i);
+
+ meta_error_trap_push (window->display);
+ XChangeProperty (window->display->xdisplay, window->xwindow,
+ window->display->atom__NET_WM_ALLOWED_ACTIONS,
+ XA_ATOM,
+ 32, PropModeReplace, (guchar*) data, i);
+ meta_error_trap_pop (window->display, FALSE);
+#undef MAX_N_ACTIONS
+}
+
+void
+meta_window_recalc_features (MetaWindow *window)
+{
+ recalc_window_features (window);
+}
+
+static void
+recalc_window_features (MetaWindow *window)
+{
+ gboolean old_has_close_func;
+ gboolean old_has_minimize_func;
+ gboolean old_has_move_func;
+ gboolean old_has_resize_func;
+ gboolean old_has_shade_func;
+ gboolean old_always_sticky;
+
+ old_has_close_func = window->has_close_func;
+ old_has_minimize_func = window->has_minimize_func;
+ old_has_move_func = window->has_move_func;
+ old_has_resize_func = window->has_resize_func;
+ old_has_shade_func = window->has_shade_func;
+ old_always_sticky = window->always_sticky;
+
+ /* Use MWM hints initially */
+ window->decorated = window->mwm_decorated;
+ window->border_only = window->mwm_border_only;
+ window->has_close_func = window->mwm_has_close_func;
+ window->has_minimize_func = window->mwm_has_minimize_func;
+ window->has_maximize_func = window->mwm_has_maximize_func;
+ window->has_move_func = window->mwm_has_move_func;
+
+ window->has_resize_func = TRUE;
+
+ /* If min_size == max_size, then don't allow resize */
+ if (window->size_hints.min_width == window->size_hints.max_width &&
+ window->size_hints.min_height == window->size_hints.max_height)
+ window->has_resize_func = FALSE;
+ else if (!window->mwm_has_resize_func)
+ {
+ /* We ignore mwm_has_resize_func because WM_NORMAL_HINTS is the
+ * authoritative source for that info. Some apps such as mplayer or
+ * xine disable resize via MWM but not WM_NORMAL_HINTS, but that
+ * leads to e.g. us not fullscreening their windows. Apps that set
+ * MWM but not WM_NORMAL_HINTS are basically broken. We complain
+ * about these apps but make them work.
+ */
+
+ meta_warning (_("Window %s sets an MWM hint indicating it isn't resizable, but sets min size %d x %d and max size %d x %d; this doesn't make much sense.\n"),
+ window->desc,
+ window->size_hints.min_width,
+ window->size_hints.min_height,
+ window->size_hints.max_width,
+ window->size_hints.max_height);
+ }
+
+ window->has_shade_func = TRUE;
+ window->has_fullscreen_func = TRUE;
+
+ window->always_sticky = FALSE;
+
+ /* Semantic category overrides the MWM hints */
+ if (window->type == META_WINDOW_TOOLBAR)
+ window->decorated = FALSE;
+
+ if (window->type == META_WINDOW_DESKTOP ||
+ window->type == META_WINDOW_DOCK)
+ window->always_sticky = TRUE;
+
+ if (window->type == META_WINDOW_DESKTOP ||
+ window->type == META_WINDOW_DOCK ||
+ window->type == META_WINDOW_SPLASHSCREEN)
+ {
+ window->decorated = FALSE;
+ window->has_close_func = FALSE;
+ window->has_shade_func = FALSE;
+
+ /* FIXME this keeps panels and things from using
+ * NET_WM_MOVERESIZE; the problem is that some
+ * panels (edge panels) have fixed possible locations,
+ * and others ("floating panels") do not.
+ *
+ * Perhaps we should require edge panels to explicitly
+ * disable movement?
+ */
+ window->has_move_func = FALSE;
+ window->has_resize_func = FALSE;
+ }
+
+ if (window->type != META_WINDOW_NORMAL)
+ {
+ window->has_minimize_func = FALSE;
+ window->has_maximize_func = FALSE;
+ window->has_fullscreen_func = FALSE;
+ }
+
+ if (!window->has_resize_func)
+ {
+ window->has_maximize_func = FALSE;
+
+ /* don't allow fullscreen if we can't resize, unless the size
+ * is entire screen size (kind of broken, because we
+ * actually fullscreen to xinerama head size not screen size)
+ */
+ if (window->size_hints.min_width == window->screen->rect.width &&
+ window->size_hints.min_height == window->screen->rect.height)
+ ; /* leave fullscreen available */
+ else
+ window->has_fullscreen_func = FALSE;
+ }
+
+ /* We leave fullscreen windows decorated, just push the frame outside
+ * the screen. This avoids flickering to unparent them.
+ *
+ * Note that setting has_resize_func = FALSE here must come after the
+ * above code that may disable fullscreen, because if the window
+ * is not resizable purely due to fullscreen, we don't want to
+ * disable fullscreen mode.
+ */
+ if (window->fullscreen)
+ {
+ window->has_shade_func = FALSE;
+ window->has_move_func = FALSE;
+ window->has_resize_func = FALSE;
+ window->has_maximize_func = FALSE;
+ }
+
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Window %s fullscreen = %d not resizable, maximizable = %d fullscreenable = %d min size %dx%d max size %dx%d\n",
+ window->desc,
+ window->fullscreen,
+ window->has_maximize_func, window->has_fullscreen_func,
+ window->size_hints.min_width,
+ window->size_hints.min_height,
+ window->size_hints.max_width,
+ window->size_hints.max_height);
+
+ /* no shading if not decorated */
+ if (!window->decorated || window->border_only)
+ window->has_shade_func = FALSE;
+
+ window->skip_taskbar = FALSE;
+ window->skip_pager = FALSE;
+
+ if (window->wm_state_skip_taskbar)
+ window->skip_taskbar = TRUE;
+
+ if (window->wm_state_skip_pager)
+ window->skip_pager = TRUE;
+
+ switch (window->type)
+ {
+ /* Force skip taskbar/pager on these window types */
+ case META_WINDOW_DESKTOP:
+ case META_WINDOW_DOCK:
+ case META_WINDOW_TOOLBAR:
+ case META_WINDOW_MENU:
+ case META_WINDOW_UTILITY:
+ case META_WINDOW_SPLASHSCREEN:
+ window->skip_taskbar = TRUE;
+ window->skip_pager = TRUE;
+ break;
+
+ case META_WINDOW_DIALOG:
+ case META_WINDOW_MODAL_DIALOG:
+ /* only skip taskbar if we have a real transient parent */
+ if (window->xtransient_for != None &&
+ window->xtransient_for != window->screen->xroot)
+ window->skip_taskbar = TRUE;
+ break;
+
+ case META_WINDOW_NORMAL:
+ break;
+ }
+
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Window %s decorated = %d border_only = %d has_close = %d has_minimize = %d has_maximize = %d has_move = %d has_shade = %d skip_taskbar = %d skip_pager = %d\n",
+ window->desc,
+ window->decorated,
+ window->border_only,
+ window->has_close_func,
+ window->has_minimize_func,
+ window->has_maximize_func,
+ window->has_move_func,
+ window->has_shade_func,
+ window->skip_taskbar,
+ window->skip_pager);
+
+ /* FIXME:
+ * Lame workaround for recalc_window_features
+ * being used overzealously. The fix is to
+ * only recalc_window_features when something
+ * has actually changed.
+ */
+ if (window->constructing ||
+ old_has_close_func != window->has_close_func ||
+ old_has_minimize_func != window->has_minimize_func ||
+ old_has_move_func != window->has_move_func ||
+ old_has_resize_func != window->has_resize_func ||
+ old_has_shade_func != window->has_shade_func ||
+ old_always_sticky != window->always_sticky)
+ set_allowed_actions_hint (window);
+
+ /* FIXME perhaps should ensure if we don't have a shade func,
+ * we aren't shaded, etc.
+ */
+}
+
+static void
+menu_callback (MetaWindowMenu *menu,
+ Display *xdisplay,
+ Window client_xwindow,
+ guint32 timestamp,
+ MetaMenuOp op,
+ int workspace_index,
+ gpointer data)
+{
+ MetaDisplay *display;
+ MetaWindow *window;
+ MetaWorkspace *workspace;
+
+ display = meta_display_for_x_display (xdisplay);
+ window = meta_display_lookup_x_window (display, client_xwindow);
+ workspace = NULL;
+
+ if (window != NULL) /* window can be NULL */
+ {
+ meta_verbose ("Menu op %u on %s\n", op, window->desc);
+
+ switch (op)
+ {
+ case META_MENU_OP_NONE:
+ /* nothing */
+ break;
+
+ case META_MENU_OP_DELETE:
+ meta_window_delete (window, timestamp);
+ break;
+
+ case META_MENU_OP_MINIMIZE:
+ meta_window_minimize (window);
+ break;
+
+ case META_MENU_OP_UNMAXIMIZE:
+ meta_window_unmaximize (window,
+ META_MAXIMIZE_HORIZONTAL |
+ META_MAXIMIZE_VERTICAL);
+ break;
+
+ case META_MENU_OP_MAXIMIZE:
+ meta_window_maximize (window,
+ META_MAXIMIZE_HORIZONTAL |
+ META_MAXIMIZE_VERTICAL);
+ break;
+
+ case META_MENU_OP_UNSHADE:
+ meta_window_unshade (window, timestamp);
+ break;
+
+ case META_MENU_OP_SHADE:
+ meta_window_shade (window, timestamp);
+ break;
+
+ case META_MENU_OP_MOVE_LEFT:
+ workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
+ META_MOTION_LEFT);
+ break;
+
+ case META_MENU_OP_MOVE_RIGHT:
+ workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
+ META_MOTION_RIGHT);
+ break;
+
+ case META_MENU_OP_MOVE_UP:
+ workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
+ META_MOTION_UP);
+ break;
+
+ case META_MENU_OP_MOVE_DOWN:
+ workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
+ META_MOTION_DOWN);
+ break;
+
+ case META_MENU_OP_WORKSPACES:
+ workspace = meta_screen_get_workspace_by_index (window->screen,
+ workspace_index);
+ break;
+
+ case META_MENU_OP_STICK:
+ meta_window_stick (window);
+ break;
+
+ case META_MENU_OP_UNSTICK:
+ meta_window_unstick (window);
+ break;
+
+ case META_MENU_OP_ABOVE:
+ case META_MENU_OP_UNABOVE:
+ if (window->wm_state_above == FALSE)
+ meta_window_make_above (window);
+ else
+ meta_window_unmake_above (window);
+ break;
+
+ case META_MENU_OP_MOVE:
+ meta_window_begin_grab_op (window,
+ META_GRAB_OP_KEYBOARD_MOVING,
+ TRUE,
+ timestamp);
+ break;
+
+ case META_MENU_OP_RESIZE:
+ meta_window_begin_grab_op (window,
+ META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN,
+ TRUE,
+ timestamp);
+ break;
+
+ case META_MENU_OP_RECOVER:
+ meta_window_shove_titlebar_onscreen (window);
+ break;
+
+ default:
+ meta_warning (G_STRLOC": Unknown window op\n");
+ break;
+ }
+
+ if (workspace)
+ {
+ meta_window_change_workspace (window,
+ workspace);
+#if 0
+ meta_workspace_activate (workspace);
+ meta_window_raise (window);
+#endif
+ }
+ }
+ else
+ {
+ meta_verbose ("Menu callback on nonexistent window\n");
+ }
+
+ if (display->window_menu == menu)
+ {
+ display->window_menu = NULL;
+ display->window_with_menu = NULL;
+ }
+
+ meta_ui_window_menu_free (menu);
+}
+
+void
+meta_window_show_menu (MetaWindow *window,
+ int root_x,
+ int root_y,
+ int button,
+ guint32 timestamp)
+{
+ MetaMenuOp ops;
+ MetaMenuOp insensitive;
+ MetaWindowMenu *menu;
+ MetaWorkspaceLayout layout;
+ int n_workspaces;
+ gboolean ltr;
+
+ if (window->display->window_menu)
+ {
+ meta_ui_window_menu_free (window->display->window_menu);
+ window->display->window_menu = NULL;
+ window->display->window_with_menu = NULL;
+ }
+
+ ops = META_MENU_OP_NONE;
+ insensitive = META_MENU_OP_NONE;
+
+ ops |= (META_MENU_OP_DELETE | META_MENU_OP_MINIMIZE | META_MENU_OP_MOVE | META_MENU_OP_RESIZE);
+
+ if (!meta_window_titlebar_is_onscreen (window) &&
+ window->type != META_WINDOW_DOCK &&
+ window->type != META_WINDOW_DESKTOP)
+ ops |= META_MENU_OP_RECOVER;
+
+ n_workspaces = meta_screen_get_n_workspaces (window->screen);
+
+ if (n_workspaces > 1)
+ ops |= META_MENU_OP_WORKSPACES;
+
+ meta_screen_calc_workspace_layout (window->screen,
+ n_workspaces,
+ meta_workspace_index ( window->screen->active_workspace),
+ &layout);
+
+ if (!window->on_all_workspaces)
+ {
+ ltr = meta_ui_get_direction() == META_UI_DIRECTION_LTR;
+
+ if (layout.current_col > 0)
+ ops |= ltr ? META_MENU_OP_MOVE_LEFT : META_MENU_OP_MOVE_RIGHT;
+ if ((layout.current_col < layout.cols - 1) &&
+ (layout.current_row * layout.cols + (layout.current_col + 1) < n_workspaces))
+ ops |= ltr ? META_MENU_OP_MOVE_RIGHT : META_MENU_OP_MOVE_LEFT;
+ if (layout.current_row > 0)
+ ops |= META_MENU_OP_MOVE_UP;
+ if ((layout.current_row < layout.rows - 1) &&
+ ((layout.current_row + 1) * layout.cols + layout.current_col < n_workspaces))
+ ops |= META_MENU_OP_MOVE_DOWN;
+ }
+
+ meta_screen_free_workspace_layout (&layout);
+
+ if (META_WINDOW_MAXIMIZED (window))
+ ops |= META_MENU_OP_UNMAXIMIZE;
+ else
+ ops |= META_MENU_OP_MAXIMIZE;
+
+#if 0
+ if (window->shaded)
+ ops |= META_MENU_OP_UNSHADE;
+ else
+ ops |= META_MENU_OP_SHADE;
+#endif
+
+ ops |= META_MENU_OP_UNSTICK;
+ ops |= META_MENU_OP_STICK;
+
+ if (window->wm_state_above)
+ ops |= META_MENU_OP_UNABOVE;
+ else
+ ops |= META_MENU_OP_ABOVE;
+
+ if (!window->has_maximize_func)
+ insensitive |= META_MENU_OP_UNMAXIMIZE | META_MENU_OP_MAXIMIZE;
+
+ /*if (!window->has_minimize_func)
+ insensitive |= META_MENU_OP_MINIMIZE;*/
+
+ /*if (!window->has_close_func)
+ insensitive |= META_MENU_OP_DELETE;*/
+
+ if (!window->has_shade_func)
+ insensitive |= META_MENU_OP_SHADE | META_MENU_OP_UNSHADE;
+
+ if (!META_WINDOW_ALLOWS_MOVE (window))
+ insensitive |= META_MENU_OP_MOVE;
+
+ if (!META_WINDOW_ALLOWS_RESIZE (window))
+ insensitive |= META_MENU_OP_RESIZE;
+
+ if (window->always_sticky)
+ insensitive |= META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES;
+
+ if ((window->type == META_WINDOW_DESKTOP) ||
+ (window->type == META_WINDOW_DOCK) ||
+ (window->type == META_WINDOW_SPLASHSCREEN))
+ insensitive |= META_MENU_OP_ABOVE | META_MENU_OP_UNABOVE;
+
+ /* If all operations are disabled, just quit without showing the menu.
+ * This is the case, for example, with META_WINDOW_DESKTOP windows.
+ */
+ if ((ops & ~insensitive) == 0)
+ return;
+
+ menu =
+ meta_ui_window_menu_new (window->screen->ui,
+ window->xwindow,
+ ops,
+ insensitive,
+ meta_window_get_net_wm_desktop (window),
+ meta_screen_get_n_workspaces (window->screen),
+ menu_callback,
+ NULL);
+
+ window->display->window_menu = menu;
+ window->display->window_with_menu = window;
+
+ meta_verbose ("Popping up window menu for %s\n", window->desc);
+
+ meta_ui_window_menu_popup (menu, root_x, root_y, button, timestamp);
+}
+
+void
+meta_window_shove_titlebar_onscreen (MetaWindow *window)
+{
+ MetaRectangle outer_rect;
+ GList *onscreen_region;
+ int horiz_amount, vert_amount;
+ int newx, newy;
+
+ /* If there's no titlebar, don't bother */
+ if (!window->frame)
+ return;
+
+ /* Get the basic info we need */
+ meta_window_get_outer_rect (window, &outer_rect);
+ onscreen_region = window->screen->active_workspace->screen_region;
+
+ /* Extend the region (just in case the window is too big to fit on the
+ * screen), then shove the window on screen, then return the region to
+ * normal.
+ */
+ horiz_amount = outer_rect.width;
+ vert_amount = outer_rect.height;
+ meta_rectangle_expand_region (onscreen_region,
+ horiz_amount,
+ horiz_amount,
+ 0,
+ vert_amount);
+ meta_rectangle_shove_into_region(onscreen_region,
+ FIXED_DIRECTION_X,
+ &outer_rect);
+ meta_rectangle_expand_region (onscreen_region,
+ -horiz_amount,
+ -horiz_amount,
+ 0,
+ -vert_amount);
+
+ newx = outer_rect.x + window->frame->child_x;
+ newy = outer_rect.y + window->frame->child_y;
+ meta_window_move_resize (window,
+ FALSE,
+ newx,
+ newy,
+ window->rect.width,
+ window->rect.height);
+}
+
+gboolean
+meta_window_titlebar_is_onscreen (MetaWindow *window)
+{
+ MetaRectangle titlebar_rect;
+ GList *onscreen_region;
+ int titlebar_size;
+ gboolean is_onscreen;
+
+ const int min_height_needed = 8;
+ const int min_width_percent = 0.5;
+ const int min_width_absolute = 50;
+
+ /* Titlebar can't be offscreen if there is no titlebar... */
+ if (!window->frame)
+ return FALSE;
+
+ /* Get the rectangle corresponding to the titlebar */
+ meta_window_get_outer_rect (window, &titlebar_rect);
+ titlebar_rect.height = window->frame->child_y;
+ titlebar_size = meta_rectangle_area (&titlebar_rect);
+
+ /* Run through the spanning rectangles for the screen and see if one of
+ * them overlaps with the titlebar sufficiently to consider it onscreen.
+ */
+ is_onscreen = FALSE;
+ onscreen_region = window->screen->active_workspace->screen_region;
+ while (onscreen_region)
+ {
+ MetaRectangle *spanning_rect = onscreen_region->data;
+ MetaRectangle overlap;
+
+ meta_rectangle_intersect (&titlebar_rect, spanning_rect, &overlap);
+ if (overlap.height > MIN (titlebar_rect.height, min_height_needed) &&
+ overlap.width > MIN (titlebar_rect.width * min_width_percent,
+ min_width_absolute))
+ {
+ is_onscreen = TRUE;
+ break;
+ }
+
+ onscreen_region = onscreen_region->next;
+ }
+
+ return is_onscreen;
+}
+
+static double
+timeval_to_ms (const GTimeVal *timeval)
+{
+ return (timeval->tv_sec * G_USEC_PER_SEC + timeval->tv_usec) / 1000.0;
+}
+
+static double
+time_diff (const GTimeVal *first,
+ const GTimeVal *second)
+{
+ double first_ms = timeval_to_ms (first);
+ double second_ms = timeval_to_ms (second);
+
+ return first_ms - second_ms;
+}
+
+static gboolean
+check_moveresize_frequency (MetaWindow *window,
+ gdouble *remaining)
+{
+ GTimeVal current_time;
+
+ g_get_current_time (&current_time);
+
+#ifdef HAVE_XSYNC
+ if (!window->disable_sync &&
+ window->display->grab_sync_request_alarm != None)
+ {
+ if (window->sync_request_time.tv_sec != 0 ||
+ window->sync_request_time.tv_usec != 0)
+ {
+ double elapsed =
+ time_diff (&current_time, &window->sync_request_time);
+
+ if (elapsed < 1000.0)
+ {
+ /* We want to be sure that the timeout happens at
+ * a time where elapsed will definitely be
+ * greater than 1000, so we can disable sync
+ */
+ if (remaining)
+ *remaining = 1000.0 - elapsed + 100;
+
+ return FALSE;
+ }
+ else
+ {
+ /* We have now waited for more than a second for the
+ * application to respond to the sync request
+ */
+ window->disable_sync = TRUE;
+ return TRUE;
+ }
+ }
+ else
+ {
+ /* No outstanding sync requests. Go ahead and resize
+ */
+ return TRUE;
+ }
+ }
+ else
+#endif /* HAVE_XSYNC */
+ {
+ const double max_resizes_per_second = 25.0;
+ const double ms_between_resizes = 1000.0 / max_resizes_per_second;
+ double elapsed;
+
+ elapsed = time_diff (&current_time, &window->display->grab_last_moveresize_time);
+
+ if (elapsed >= 0.0 && elapsed < ms_between_resizes)
+ {
+ meta_topic (META_DEBUG_RESIZING,
+ "Delaying move/resize as only %g of %g ms elapsed\n",
+ elapsed, ms_between_resizes);
+
+ if (remaining)
+ *remaining = (ms_between_resizes - elapsed);
+
+ return FALSE;
+ }
+
+ meta_topic (META_DEBUG_RESIZING,
+ " Checked moveresize freq, allowing move/resize now (%g of %g seconds elapsed)\n",
+ elapsed / 1000.0, 1.0 / max_resizes_per_second);
+
+ return TRUE;
+ }
+}
+
+static gboolean
+update_move_timeout (gpointer data)
+{
+ MetaWindow *window = data;
+
+ update_move (window,
+ window->display->grab_last_user_action_was_snap,
+ window->display->grab_latest_motion_x,
+ window->display->grab_latest_motion_y);
+
+ return FALSE;
+}
+
+static void
+update_move (MetaWindow *window,
+ gboolean snap,
+ int x,
+ int y)
+{
+ int dx, dy;
+ int new_x, new_y;
+ MetaRectangle old;
+ int shake_threshold;
+ MetaDisplay *display = window->display;
+
+ display->grab_latest_motion_x = x;
+ display->grab_latest_motion_y = y;
+
+ dx = x - display->grab_anchor_root_x;
+ dy = y - display->grab_anchor_root_y;
+
+ new_x = display->grab_anchor_window_pos.x + dx;
+ new_y = display->grab_anchor_window_pos.y + dy;
+
+ meta_verbose ("x,y = %d,%d anchor ptr %d,%d anchor pos %d,%d dx,dy %d,%d\n",
+ x, y,
+ display->grab_anchor_root_x,
+ display->grab_anchor_root_y,
+ display->grab_anchor_window_pos.x,
+ display->grab_anchor_window_pos.y,
+ dx, dy);
+
+ /* Don't bother doing anything if no move has been specified. (This
+ * happens often, even in keyboard moving, due to the warping of the
+ * pointer.
+ */
+ if (dx == 0 && dy == 0)
+ return;
+
+ /* shake loose (unmaximize) maximized window if dragged beyond the threshold
+ * in the Y direction. You can't pull a window loose via X motion.
+ */
+
+#define DRAG_THRESHOLD_TO_SHAKE_THRESHOLD_FACTOR 6
+ shake_threshold = meta_ui_get_drag_threshold (window->screen->ui) *
+ DRAG_THRESHOLD_TO_SHAKE_THRESHOLD_FACTOR;
+
+ if (META_WINDOW_MAXIMIZED (window) && ABS (dy) >= shake_threshold)
+ {
+ double prop;
+
+ /* Shake loose */
+ window->shaken_loose = TRUE;
+
+ /* move the unmaximized window to the cursor */
+ prop =
+ ((double)(x - display->grab_initial_window_pos.x)) /
+ ((double)display->grab_initial_window_pos.width);
+
+ display->grab_initial_window_pos.x =
+ x - window->saved_rect.width * prop;
+ display->grab_initial_window_pos.y = y;
+
+ if (window->frame)
+ {
+ display->grab_initial_window_pos.y += window->frame->child_y / 2;
+ }
+
+ window->saved_rect.x = display->grab_initial_window_pos.x;
+ window->saved_rect.y = display->grab_initial_window_pos.y;
+ display->grab_anchor_root_x = x;
+ display->grab_anchor_root_y = y;
+
+ meta_window_unmaximize (window,
+ META_MAXIMIZE_HORIZONTAL |
+ META_MAXIMIZE_VERTICAL);
+
+ return;
+ }
+ /* remaximize window on an other xinerama monitor if window has
+ * been shaken loose or it is still maximized (then move straight)
+ */
+ else if (window->shaken_loose || META_WINDOW_MAXIMIZED (window))
+ {
+ const MetaXineramaScreenInfo *wxinerama;
+ MetaRectangle work_area;
+ int monitor;
+
+ wxinerama = meta_screen_get_xinerama_for_window (window->screen, window);
+
+ for (monitor = 0; monitor < window->screen->n_xinerama_infos; monitor++)
+ {
+ meta_window_get_work_area_for_xinerama (window, monitor, &work_area);
+
+ /* check if cursor is near the top of a xinerama work area */
+ if (x >= work_area.x &&
+ x < (work_area.x + work_area.width) &&
+ y >= work_area.y &&
+ y < (work_area.y + shake_threshold))
+ {
+ /* move the saved rect if window will become maximized on an
+ * other monitor so user isn't surprised on a later unmaximize
+ */
+ if (wxinerama->number != monitor)
+ {
+ window->saved_rect.x = work_area.x;
+ window->saved_rect.y = work_area.y;
+
+ if (window->frame)
+ {
+ window->saved_rect.x += window->frame->child_x;
+ window->saved_rect.y += window->frame->child_y;
+ }
+
+ window->user_rect.x = window->saved_rect.x;
+ window->user_rect.y = window->saved_rect.y;
+
+ meta_window_unmaximize (window,
+ META_MAXIMIZE_HORIZONTAL |
+ META_MAXIMIZE_VERTICAL);
+ }
+
+ display->grab_initial_window_pos = work_area;
+ display->grab_anchor_root_x = x;
+ display->grab_anchor_root_y = y;
+ window->shaken_loose = FALSE;
+
+ meta_window_maximize (window,
+ META_MAXIMIZE_HORIZONTAL |
+ META_MAXIMIZE_VERTICAL);
+
+ return;
+ }
+ }
+ }
+
+ if (display->grab_wireframe_active)
+ old = display->grab_wireframe_rect;
+ else
+ meta_window_get_client_root_coords (window, &old);
+
+ /* Don't allow movement in the maximized directions */
+ if (window->maximized_horizontally)
+ new_x = old.x;
+ if (window->maximized_vertically)
+ new_y = old.y;
+
+ /* Do any edge resistance/snapping */
+ meta_window_edge_resistance_for_move (window,
+ old.x,
+ old.y,
+ &new_x,
+ &new_y,
+ update_move_timeout,
+ snap,
+ FALSE);
+
+ if (display->compositor)
+ {
+ int root_x = new_x - display->grab_anchor_window_pos.x + display->grab_anchor_root_x;
+ int root_y = new_y - display->grab_anchor_window_pos.y + display->grab_anchor_root_y;
+
+ meta_compositor_update_move (display->compositor,
+ window, root_x, root_y);
+ }
+
+ if (display->grab_wireframe_active)
+ meta_window_update_wireframe (window, new_x, new_y,
+ display->grab_wireframe_rect.width,
+ display->grab_wireframe_rect.height);
+ else
+ meta_window_move (window, TRUE, new_x, new_y);
+}
+
+static gboolean
+update_resize_timeout (gpointer data)
+{
+ MetaWindow *window = data;
+
+ update_resize (window,
+ window->display->grab_last_user_action_was_snap,
+ window->display->grab_latest_motion_x,
+ window->display->grab_latest_motion_y,
+ TRUE);
+ return FALSE;
+}
+
+static void
+update_resize (MetaWindow *window,
+ gboolean snap,
+ int x, int y,
+ gboolean force)
+{
+ int dx, dy;
+ int new_w, new_h;
+ int gravity;
+ MetaRectangle old;
+ int new_x, new_y;
+ double remaining;
+
+ window->display->grab_latest_motion_x = x;
+ window->display->grab_latest_motion_y = y;
+
+ dx = x - window->display->grab_anchor_root_x;
+ dy = y - window->display->grab_anchor_root_y;
+
+ new_w = window->display->grab_anchor_window_pos.width;
+ new_h = window->display->grab_anchor_window_pos.height;
+
+ /* Don't bother doing anything if no move has been specified. (This
+ * happens often, even in keyboard resizing, due to the warping of the
+ * pointer.
+ */
+ if (dx == 0 && dy == 0)
+ return;
+
+ /* FIXME this is only used in wireframe mode */
+ new_x = window->display->grab_anchor_window_pos.x;
+ new_y = window->display->grab_anchor_window_pos.y;
+
+ if (window->display->grab_op == META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN)
+ {
+ if ((dx > 0) && (dy > 0))
+ {
+ window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_SE;
+ meta_window_update_keyboard_resize (window, TRUE);
+ }
+ else if ((dx < 0) && (dy > 0))
+ {
+ window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_SW;
+ meta_window_update_keyboard_resize (window, TRUE);
+ }
+ else if ((dx > 0) && (dy < 0))
+ {
+ window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_NE;
+ meta_window_update_keyboard_resize (window, TRUE);
+ }
+ else if ((dx < 0) && (dy < 0))
+ {
+ window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_NW;
+ meta_window_update_keyboard_resize (window, TRUE);
+ }
+ else if (dx < 0)
+ {
+ window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W;
+ meta_window_update_keyboard_resize (window, TRUE);
+ }
+ else if (dx > 0)
+ {
+ window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E;
+ meta_window_update_keyboard_resize (window, TRUE);
+ }
+ else if (dy > 0)
+ {
+ window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S;
+ meta_window_update_keyboard_resize (window, TRUE);
+ }
+ else if (dy < 0)
+ {
+ window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N;
+ meta_window_update_keyboard_resize (window, TRUE);
+ }
+ }
+
+ /* FIXME: This stupidity only needed because of wireframe mode and
+ * the fact that wireframe isn't making use of
+ * meta_rectangle_resize_with_gravity(). If we were to use that, we
+ * could just increment new_w and new_h by dx and dy in all cases.
+ */
+ switch (window->display->grab_op)
+ {
+ case META_GRAB_OP_RESIZING_SE:
+ case META_GRAB_OP_RESIZING_NE:
+ case META_GRAB_OP_RESIZING_E:
+ case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+ case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+ case META_GRAB_OP_KEYBOARD_RESIZING_E:
+ new_w += dx;
+ break;
+
+ case META_GRAB_OP_RESIZING_NW:
+ case META_GRAB_OP_RESIZING_SW:
+ case META_GRAB_OP_RESIZING_W:
+ case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+ case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+ case META_GRAB_OP_KEYBOARD_RESIZING_W:
+ new_w -= dx;
+ new_x += dx;
+ break;
+
+ default:
+ break;
+ }
+
+ switch (window->display->grab_op)
+ {
+ case META_GRAB_OP_RESIZING_SE:
+ case META_GRAB_OP_RESIZING_S:
+ case META_GRAB_OP_RESIZING_SW:
+ case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+ case META_GRAB_OP_KEYBOARD_RESIZING_S:
+ case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+ new_h += dy;
+ break;
+
+ case META_GRAB_OP_RESIZING_N:
+ case META_GRAB_OP_RESIZING_NE:
+ case META_GRAB_OP_RESIZING_NW:
+ case META_GRAB_OP_KEYBOARD_RESIZING_N:
+ case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+ case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+ new_h -= dy;
+ new_y += dy;
+ break;
+ default:
+ break;
+ }
+
+ if (!check_moveresize_frequency (window, &remaining) && !force)
+ {
+ /* we are ignoring an event here, so we schedule a
+ * compensation event when we would otherwise not ignore
+ * an event. Otherwise we can become stuck if the user never
+ * generates another event.
+ */
+ if (!window->display->grab_resize_timeout_id)
+ {
+ window->display->grab_resize_timeout_id =
+ g_timeout_add ((int)remaining, update_resize_timeout, window);
+ }
+
+ return;
+ }
+
+ /* If we get here, it means the client should have redrawn itself */
+ if (window->display->compositor)
+ meta_compositor_set_updates (window->display->compositor, window, TRUE);
+
+ /* Remove any scheduled compensation events */
+ if (window->display->grab_resize_timeout_id)
+ {
+ g_source_remove (window->display->grab_resize_timeout_id);
+ window->display->grab_resize_timeout_id = 0;
+ }
+
+ if (window->display->grab_wireframe_active)
+ old = window->display->grab_wireframe_rect;
+ else
+ old = window->rect; /* Don't actually care about x,y */
+
+ /* One sided resizing ought to actually be one-sided, despite the fact that
+ * aspect ratio windows don't interact nicely with the above stuff. So,
+ * to avoid some nasty flicker, we enforce that.
+ */
+ switch (window->display->grab_op)
+ {
+ case META_GRAB_OP_RESIZING_S:
+ case META_GRAB_OP_RESIZING_N:
+ new_w = old.width;
+ break;
+
+ case META_GRAB_OP_RESIZING_E:
+ case META_GRAB_OP_RESIZING_W:
+ new_h = old.height;
+ break;
+
+ default:
+ break;
+ }
+
+ /* compute gravity of client during operation */
+ gravity = meta_resize_gravity_from_grab_op (window->display->grab_op);
+ g_assert (gravity >= 0);
+
+ /* Do any edge resistance/snapping */
+ meta_window_edge_resistance_for_resize (window,
+ old.width,
+ old.height,
+ &new_w,
+ &new_h,
+ gravity,
+ update_resize_timeout,
+ snap,
+ FALSE);
+
+ if (window->display->grab_wireframe_active)
+ {
+ if ((new_x + new_w <= new_x) || (new_y + new_h <= new_y))
+ return;
+
+ /* FIXME This is crap. For example, the wireframe isn't
+ * constrained in the way that a real resize would be. An
+ * obvious elegant solution is to unmap the window during
+ * wireframe, but still resize it; however, that probably
+ * confuses broken clients that have problems with opaque
+ * resize, they probably don't track their visibility.
+ */
+ meta_window_update_wireframe (window, new_x, new_y, new_w, new_h);
+ }
+ else
+ {
+ /* We don't need to update unless the specified width and height
+ * are actually different from what we had before.
+ */
+ if (old.width != new_w || old.height != new_h)
+ meta_window_resize_with_gravity (window, TRUE, new_w, new_h, gravity);
+ }
+
+ /* Store the latest resize time, if we actually resized. */
+ if (window->rect.width != old.width || window->rect.height != old.height)
+ g_get_current_time (&window->display->grab_last_moveresize_time);
+}
+
+typedef struct
+{
+ const XEvent *current_event;
+ int count;
+ guint32 last_time;
+} EventScannerData;
+
+static Bool
+find_last_time_predicate (Display *display,
+ XEvent *xevent,
+ XPointer arg)
+{
+ EventScannerData *esd = (void*) arg;
+
+ if (esd->current_event->type == xevent->type &&
+ esd->current_event->xany.window == xevent->xany.window)
+ {
+ esd->count += 1;
+ esd->last_time = xevent->xmotion.time;
+ }
+
+ return False;
+}
+
+static gboolean
+check_use_this_motion_notify (MetaWindow *window,
+ XEvent *event)
+{
+ EventScannerData esd;
+ XEvent useless;
+
+ /* This code is copied from Owen's GDK code. */
+
+ if (window->display->grab_motion_notify_time != 0)
+ {
+ /* == is really the right test, but I'm all for paranoia */
+ if (window->display->grab_motion_notify_time <=
+ event->xmotion.time)
+ {
+ meta_topic (META_DEBUG_RESIZING,
+ "Arrived at event with time %u (waiting for %u), using it\n",
+ (unsigned int)event->xmotion.time,
+ window->display->grab_motion_notify_time);
+ window->display->grab_motion_notify_time = 0;
+ return TRUE;
+ }
+ else
+ return FALSE; /* haven't reached the saved timestamp yet */
+ }
+
+ esd.current_event = event;
+ esd.count = 0;
+ esd.last_time = 0;
+
+ /* "useless" isn't filled in because the predicate never returns True */
+ XCheckIfEvent (window->display->xdisplay,
+ &useless,
+ find_last_time_predicate,
+ (XPointer) &esd);
+
+ if (esd.count > 0)
+ meta_topic (META_DEBUG_RESIZING,
+ "Will skip %d motion events and use the event with time %u\n",
+ esd.count, (unsigned int) esd.last_time);
+
+ if (esd.last_time == 0)
+ return TRUE;
+ else
+ {
+ /* Save this timestamp, and ignore all motion notify
+ * until we get to the one with this stamp.
+ */
+ window->display->grab_motion_notify_time = esd.last_time;
+ return FALSE;
+ }
+}
+
+void
+meta_window_handle_mouse_grab_op_event (MetaWindow *window,
+ XEvent *event)
+{
+#ifdef HAVE_XSYNC
+ if (event->type == (window->display->xsync_event_base + XSyncAlarmNotify))
+ {
+ meta_topic (META_DEBUG_RESIZING,
+ "Alarm event received last motion x = %d y = %d\n",
+ window->display->grab_latest_motion_x,
+ window->display->grab_latest_motion_y);
+
+ /* If sync was previously disabled, turn it back on and hope
+ * the application has come to its senses (maybe it was just
+ * busy with a pagefault or a long computation).
+ */
+ window->disable_sync = FALSE;
+ window->sync_request_time.tv_sec = 0;
+ window->sync_request_time.tv_usec = 0;
+
+ /* This means we are ready for another configure. */
+ switch (window->display->grab_op)
+ {
+ case META_GRAB_OP_RESIZING_E:
+ case META_GRAB_OP_RESIZING_W:
+ case META_GRAB_OP_RESIZING_S:
+ case META_GRAB_OP_RESIZING_N:
+ case META_GRAB_OP_RESIZING_SE:
+ case META_GRAB_OP_RESIZING_SW:
+ case META_GRAB_OP_RESIZING_NE:
+ case META_GRAB_OP_RESIZING_NW:
+ case META_GRAB_OP_KEYBOARD_RESIZING_S:
+ case META_GRAB_OP_KEYBOARD_RESIZING_N:
+ case META_GRAB_OP_KEYBOARD_RESIZING_W:
+ case META_GRAB_OP_KEYBOARD_RESIZING_E:
+ case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+ case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+ case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+ case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+ /* no pointer round trip here, to keep in sync */
+ update_resize (window,
+ window->display->grab_last_user_action_was_snap,
+ window->display->grab_latest_motion_x,
+ window->display->grab_latest_motion_y,
+ TRUE);
+ break;
+
+ default:
+ break;
+ }
+ }
+#endif /* HAVE_XSYNC */
+
+ switch (event->type)
+ {
+ case ButtonRelease:
+ meta_display_check_threshold_reached (window->display,
+ event->xbutton.x_root,
+ event->xbutton.y_root);
+ /* If the user was snap moving then ignore the button release
+ * because they may have let go of shift before releasing the
+ * mouse button and they almost certainly do not want a
+ * non-snapped movement to occur from the button release.
+ */
+ if (!window->display->grab_last_user_action_was_snap)
+ {
+ if (meta_grab_op_is_moving (window->display->grab_op))
+ {
+ if (event->xbutton.root == window->screen->xroot)
+ update_move (window, event->xbutton.state & ShiftMask,
+ event->xbutton.x_root, event->xbutton.y_root);
+ }
+ else if (meta_grab_op_is_resizing (window->display->grab_op))
+ {
+ if (event->xbutton.root == window->screen->xroot)
+ update_resize (window,
+ event->xbutton.state & ShiftMask,
+ event->xbutton.x_root,
+ event->xbutton.y_root,
+ TRUE);
+ if (window->display->compositor)
+ meta_compositor_set_updates (window->display->compositor, window, TRUE);
+ }
+ }
+
+ meta_display_end_grab_op (window->display, event->xbutton.time);
+ break;
+
+ case MotionNotify:
+ meta_display_check_threshold_reached (window->display,
+ event->xmotion.x_root,
+ event->xmotion.y_root);
+ if (meta_grab_op_is_moving (window->display->grab_op))
+ {
+ if (event->xmotion.root == window->screen->xroot)
+ {
+ if (check_use_this_motion_notify (window,
+ event))
+ update_move (window,
+ event->xmotion.state & ShiftMask,
+ event->xmotion.x_root,
+ event->xmotion.y_root);
+ }
+ }
+ else if (meta_grab_op_is_resizing (window->display->grab_op))
+ {
+ if (event->xmotion.root == window->screen->xroot)
+ {
+ if (check_use_this_motion_notify (window,
+ event))
+ update_resize (window,
+ event->xmotion.state & ShiftMask,
+ event->xmotion.x_root,
+ event->xmotion.y_root,
+ FALSE);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+void
+meta_window_set_gravity (MetaWindow *window,
+ int gravity)
+{
+ XSetWindowAttributes attrs;
+
+ meta_verbose ("Setting gravity of %s to %d\n", window->desc, gravity);
+
+ attrs.win_gravity = gravity;
+
+ meta_error_trap_push (window->display);
+
+ XChangeWindowAttributes (window->display->xdisplay,
+ window->xwindow,
+ CWWinGravity,
+ &attrs);
+
+ meta_error_trap_pop (window->display, FALSE);
+}
+
+static void
+get_work_area_xinerama (MetaWindow *window,
+ MetaRectangle *area,
+ int which_xinerama)
+{
+ GList *tmp;
+
+ g_assert (which_xinerama >= 0);
+
+ /* Initialize to the whole xinerama */
+ *area = window->screen->xinerama_infos[which_xinerama].rect;
+
+ tmp = meta_window_get_workspaces (window);
+ while (tmp != NULL)
+ {
+ MetaRectangle workspace_work_area;
+ meta_workspace_get_work_area_for_xinerama (tmp->data,
+ which_xinerama,
+ &workspace_work_area);
+ meta_rectangle_intersect (area,
+ &workspace_work_area,
+ area);
+ tmp = tmp->next;
+ }
+
+ meta_topic (META_DEBUG_WORKAREA,
+ "Window %s xinerama %d has work area %d,%d %d x %d\n",
+ window->desc, which_xinerama,
+ area->x, area->y, area->width, area->height);
+}
+
+void
+meta_window_get_work_area_current_xinerama (MetaWindow *window,
+ MetaRectangle *area)
+{
+ const MetaXineramaScreenInfo *xinerama = NULL;
+ xinerama = meta_screen_get_xinerama_for_window (window->screen,
+ window);
+
+ meta_window_get_work_area_for_xinerama (window,
+ xinerama->number,
+ area);
+}
+
+void
+meta_window_get_work_area_for_xinerama (MetaWindow *window,
+ int which_xinerama,
+ MetaRectangle *area)
+{
+ g_return_if_fail (which_xinerama >= 0);
+
+ get_work_area_xinerama (window,
+ area,
+ which_xinerama);
+}
+
+void
+meta_window_get_work_area_all_xineramas (MetaWindow *window,
+ MetaRectangle *area)
+{
+ GList *tmp;
+
+ /* Initialize to the whole screen */
+ *area = window->screen->rect;
+
+ tmp = meta_window_get_workspaces (window);
+ while (tmp != NULL)
+ {
+ MetaRectangle workspace_work_area;
+ meta_workspace_get_work_area_all_xineramas (tmp->data,
+ &workspace_work_area);
+ meta_rectangle_intersect (area,
+ &workspace_work_area,
+ area);
+ tmp = tmp->next;
+ }
+
+ meta_topic (META_DEBUG_WORKAREA,
+ "Window %s has whole-screen work area %d,%d %d x %d\n",
+ window->desc, area->x, area->y, area->width, area->height);
+}
+
+
+gboolean
+meta_window_same_application (MetaWindow *window,
+ MetaWindow *other_window)
+{
+ MetaGroup *group = meta_window_get_group (window);
+ MetaGroup *other_group = meta_window_get_group (other_window);
+
+ return
+ group!=NULL &&
+ other_group!=NULL &&
+ group==other_group;
+}
+
+void
+meta_window_refresh_resize_popup (MetaWindow *window)
+{
+ if (window->display->grab_op == META_GRAB_OP_NONE)
+ return;
+
+ if (window->display->grab_window != window)
+ return;
+
+ /* We shouldn't ever get called when the wireframe is active
+ * because that's handled by a different code path in effects.c
+ */
+ if (window->display->grab_wireframe_active)
+ {
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "refresh_resize_popup called when wireframe active\n");
+ return;
+ }
+
+ switch (window->display->grab_op)
+ {
+ case META_GRAB_OP_RESIZING_SE:
+ case META_GRAB_OP_RESIZING_S:
+ case META_GRAB_OP_RESIZING_SW:
+ case META_GRAB_OP_RESIZING_N:
+ case META_GRAB_OP_RESIZING_NE:
+ case META_GRAB_OP_RESIZING_NW:
+ case META_GRAB_OP_RESIZING_W:
+ case META_GRAB_OP_RESIZING_E:
+ case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+ case META_GRAB_OP_KEYBOARD_RESIZING_S:
+ case META_GRAB_OP_KEYBOARD_RESIZING_N:
+ case META_GRAB_OP_KEYBOARD_RESIZING_W:
+ case META_GRAB_OP_KEYBOARD_RESIZING_E:
+ case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+ case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+ case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+ case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+ break;
+
+ default:
+ /* Not resizing */
+ return;
+ }
+
+ if (window->display->grab_resize_popup == NULL)
+ {
+ if (window->size_hints.width_inc > 1 ||
+ window->size_hints.height_inc > 1)
+ window->display->grab_resize_popup =
+ meta_ui_resize_popup_new (window->display->xdisplay,
+ window->screen->number);
+ }
+
+ if (window->display->grab_resize_popup != NULL)
+ {
+ MetaRectangle rect;
+
+ if (window->display->grab_wireframe_active)
+ rect = window->display->grab_wireframe_rect;
+ else
+ meta_window_get_client_root_coords (window, &rect);
+
+ meta_ui_resize_popup_set (window->display->grab_resize_popup,
+ rect,
+ window->size_hints.base_width,
+ window->size_hints.base_height,
+ window->size_hints.width_inc,
+ window->size_hints.height_inc);
+
+ meta_ui_resize_popup_set_showing (window->display->grab_resize_popup,
+ TRUE);
+ }
+}
+
+void
+meta_window_foreach_transient (MetaWindow *window,
+ MetaWindowForeachFunc func,
+ void *data)
+{
+ GSList *windows;
+ GSList *tmp;
+
+ windows = meta_display_list_windows (window->display);
+
+ tmp = windows;
+ while (tmp != NULL)
+ {
+ MetaWindow *transient = tmp->data;
+
+ if (meta_window_is_ancestor_of_transient (window, transient))
+ {
+ if (!(* func) (transient, data))
+ break;
+ }
+
+ tmp = tmp->next;
+ }
+
+ g_slist_free (windows);
+}
+
+void
+meta_window_foreach_ancestor (MetaWindow *window,
+ MetaWindowForeachFunc func,
+ void *data)
+{
+ MetaWindow *w;
+ MetaWindow *tortoise;
+
+ w = window;
+ tortoise = window;
+ while (TRUE)
+ {
+ if (w->xtransient_for == None ||
+ w->transient_parent_is_root_window)
+ break;
+
+ w = meta_display_lookup_x_window (w->display, w->xtransient_for);
+
+ if (w == NULL || w == tortoise)
+ break;
+
+ if (!(* func) (w, data))
+ break;
+
+ if (w->xtransient_for == None ||
+ w->transient_parent_is_root_window)
+ break;
+
+ w = meta_display_lookup_x_window (w->display, w->xtransient_for);
+
+ if (w == NULL || w == tortoise)
+ break;
+
+ if (!(* func) (w, data))
+ break;
+
+ tortoise = meta_display_lookup_x_window (tortoise->display,
+ tortoise->xtransient_for);
+
+ /* "w" should have already covered all ground covered by the
+ * tortoise, so the following must hold.
+ */
+ g_assert (tortoise != NULL);
+ g_assert (tortoise->xtransient_for != None);
+ g_assert (!tortoise->transient_parent_is_root_window);
+ }
+}
+
+typedef struct
+{
+ MetaWindow *ancestor;
+ gboolean found;
+} FindAncestorData;
+
+static gboolean
+find_ancestor_func (MetaWindow *window,
+ void *data)
+{
+ FindAncestorData *d = data;
+
+ if (window == d->ancestor)
+ {
+ d->found = TRUE;
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+gboolean
+meta_window_is_ancestor_of_transient (MetaWindow *window,
+ MetaWindow *transient)
+{
+ FindAncestorData d;
+
+ d.ancestor = window;
+ d.found = FALSE;
+
+ meta_window_foreach_ancestor (transient, find_ancestor_func, &d);
+
+ return d.found;
+}
+
+/* Warp pointer to location appropriate for grab,
+ * return root coordinates where pointer ended up.
+ */
+static gboolean
+warp_grab_pointer (MetaWindow *window,
+ MetaGrabOp grab_op,
+ int *x,
+ int *y)
+{
+ MetaRectangle rect;
+ MetaDisplay *display;
+
+ display = window->display;
+
+ /* We may not have done begin_grab_op yet, i.e. may not be in a grab
+ */
+
+ if (window == display->grab_window && display->grab_wireframe_active)
+ {
+ meta_window_get_xor_rect (window, &display->grab_wireframe_rect, &rect);
+ }
+ else
+ {
+ meta_window_get_outer_rect (window, &rect);
+ }
+
+ switch (grab_op)
+ {
+ case META_GRAB_OP_KEYBOARD_MOVING:
+ case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+ *x = rect.width / 2;
+ *y = rect.height / 2;
+ break;
+
+ case META_GRAB_OP_KEYBOARD_RESIZING_S:
+ *x = rect.width / 2;
+ *y = rect.height - 1;
+ break;
+
+ case META_GRAB_OP_KEYBOARD_RESIZING_N:
+ *x = rect.width / 2;
+ *y = 0;
+ break;
+
+ case META_GRAB_OP_KEYBOARD_RESIZING_W:
+ *x = 0;
+ *y = rect.height / 2;
+ break;
+
+ case META_GRAB_OP_KEYBOARD_RESIZING_E:
+ *x = rect.width - 1;
+ *y = rect.height / 2;
+ break;
+
+ case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+ *x = rect.width - 1;
+ *y = rect.height - 1;
+ break;
+
+ case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+ *x = rect.width - 1;
+ *y = 0;
+ break;
+
+ case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+ *x = 0;
+ *y = rect.height - 1;
+ break;
+
+ case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+ *x = 0;
+ *y = 0;
+ break;
+
+ default:
+ return FALSE;
+ }
+
+ *x += rect.x;
+ *y += rect.y;
+
+ /* Avoid weird bouncing at the screen edge; see bug 154706 */
+ *x = CLAMP (*x, 0, window->screen->rect.width-1);
+ *y = CLAMP (*y, 0, window->screen->rect.height-1);
+
+ meta_error_trap_push_with_return (display);
+
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Warping pointer to %d,%d with window at %d,%d\n",
+ *x, *y, rect.x, rect.y);
+
+ /* Need to update the grab positions so that the MotionNotify and other
+ * events generated by the XWarpPointer() call below don't cause complete
+ * funkiness. See bug 124582 and bug 122670.
+ */
+ display->grab_anchor_root_x = *x;
+ display->grab_anchor_root_y = *y;
+ display->grab_latest_motion_x = *x;
+ display->grab_latest_motion_y = *y;
+ if (display->grab_wireframe_active)
+ display->grab_anchor_window_pos = display->grab_wireframe_rect;
+ else
+ meta_window_get_client_root_coords (window,
+ &display->grab_anchor_window_pos);
+
+ XWarpPointer (display->xdisplay,
+ None,
+ window->screen->xroot,
+ 0, 0, 0, 0,
+ *x, *y);
+
+ if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+ {
+ meta_verbose ("Failed to warp pointer for window %s\n",
+ window->desc);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+void
+meta_window_begin_grab_op (MetaWindow *window,
+ MetaGrabOp op,
+ gboolean frame_action,
+ guint32 timestamp)
+{
+ int x, y;
+
+ warp_grab_pointer (window,
+ op, &x, &y);
+
+ meta_display_begin_grab_op (window->display,
+ window->screen,
+ window,
+ op,
+ FALSE,
+ frame_action,
+ 0 /* button */,
+ 0,
+ timestamp,
+ x, y);
+}
+
+void
+meta_window_update_keyboard_resize (MetaWindow *window,
+ gboolean update_cursor)
+{
+ int x, y;
+
+ warp_grab_pointer (window,
+ window->display->grab_op,
+ &x, &y);
+
+ if (update_cursor)
+ {
+ guint32 timestamp;
+ /* FIXME: Using CurrentTime is really bad mojo */
+ timestamp = CurrentTime;
+ meta_display_set_grab_op_cursor (window->display,
+ NULL,
+ window->display->grab_op,
+ TRUE,
+ window->display->grab_xwindow,
+ timestamp);
+ }
+}
+
+void
+meta_window_update_keyboard_move (MetaWindow *window)
+{
+ int x, y;
+
+ warp_grab_pointer (window,
+ window->display->grab_op,
+ &x, &y);
+}
+
+void
+meta_window_update_layer (MetaWindow *window)
+{
+ MetaGroup *group;
+
+ meta_stack_freeze (window->screen->stack);
+ group = meta_window_get_group (window);
+ if (group)
+ meta_group_update_layers (group);
+ else
+ meta_stack_update_layer (window->screen->stack, window);
+ meta_stack_thaw (window->screen->stack);
+}
+
+/* ensure_mru_position_after ensures that window appears after
+ * below_this_one in the active_workspace's mru_list (i.e. it treats
+ * window as having been less recently used than below_this_one)
+ */
+static void
+ensure_mru_position_after (MetaWindow *window,
+ MetaWindow *after_this_one)
+{
+ /* This is sort of slow since it runs through the entire list more
+ * than once (especially considering the fact that we expect the
+ * windows of interest to be the first two elements in the list),
+ * but it doesn't matter while we're only using it on new window
+ * map.
+ */
+
+ GList* active_mru_list;
+ GList* window_position;
+ GList* after_this_one_position;
+
+ active_mru_list = window->screen->active_workspace->mru_list;
+ window_position = g_list_find (active_mru_list, window);
+ after_this_one_position = g_list_find (active_mru_list, after_this_one);
+
+ /* after_this_one_position is NULL when we switch workspaces, but in
+ * that case we don't need to do any MRU shuffling so we can simply
+ * return.
+ */
+ if (after_this_one_position == NULL)
+ return;
+
+ if (g_list_length (window_position) > g_list_length (after_this_one_position))
+ {
+ window->screen->active_workspace->mru_list =
+ g_list_delete_link (window->screen->active_workspace->mru_list,
+ window_position);
+
+ window->screen->active_workspace->mru_list =
+ g_list_insert_before (window->screen->active_workspace->mru_list,
+ after_this_one_position->next,
+ window);
+ }
+}
+
+void
+meta_window_stack_just_below (MetaWindow *window,
+ MetaWindow *below_this_one)
+{
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (below_this_one != NULL);
+
+ if (window->stack_position > below_this_one->stack_position)
+ {
+ meta_topic (META_DEBUG_STACK,
+ "Setting stack position of window %s to %d (making it below window %s).\n",
+ window->desc,
+ below_this_one->stack_position,
+ below_this_one->desc);
+ meta_window_set_stack_position (window, below_this_one->stack_position);
+ }
+ else
+ {
+ meta_topic (META_DEBUG_STACK,
+ "Window %s was already below window %s.\n",
+ window->desc, below_this_one->desc);
+ }
+}
+
+void
+meta_window_set_user_time (MetaWindow *window,
+ guint32 timestamp)
+{
+ /* FIXME: If Soeren's suggestion in bug 151984 is implemented, it will allow
+ * us to sanity check the timestamp here and ensure it doesn't correspond to
+ * a future time.
+ */
+
+ /* Only update the time if this timestamp is newer... */
+ if (window->net_wm_user_time_set &&
+ XSERVER_TIME_IS_BEFORE (timestamp, window->net_wm_user_time))
+ {
+ meta_topic (META_DEBUG_STARTUP,
+ "Window %s _NET_WM_USER_TIME not updated to %u, because it "
+ "is less than %u\n",
+ window->desc, timestamp, window->net_wm_user_time);
+ }
+ else
+ {
+ meta_topic (META_DEBUG_STARTUP,
+ "Window %s has _NET_WM_USER_TIME of %u\n",
+ window->desc, timestamp);
+ window->net_wm_user_time_set = TRUE;
+ window->net_wm_user_time = timestamp;
+ if (XSERVER_TIME_IS_BEFORE (window->display->last_user_time, timestamp))
+ window->display->last_user_time = timestamp;
+
+ /* If this is a terminal, user interaction with it means the user likely
+ * doesn't want to have focus transferred for now due to new windows.
+ */
+ if (meta_prefs_get_focus_new_windows () ==
+ META_FOCUS_NEW_WINDOWS_STRICT &&
+ __window_is_terminal (window))
+ window->display->allow_terminal_deactivation = FALSE;
+ }
+}
+
+/* Sets the demands_attention hint on a window, but only
+ * if it's at least partially obscured (see #305882).
+ */
+void
+meta_window_set_demands_attention (MetaWindow *window)
+{
+ MetaRectangle candidate_rect, other_rect;
+ GList *stack = window->screen->stack->sorted;
+ MetaWindow *other_window;
+ gboolean obscured = FALSE;
+
+ MetaWorkspace *workspace = window->screen->active_workspace;
+ if (workspace!=window->workspace)
+ {
+ /* windows on other workspaces are necessarily obscured */
+ obscured = TRUE;
+ }
+ else if (window->minimized)
+ {
+ obscured = TRUE;
+ }
+ else
+ {
+ meta_window_get_outer_rect (window, &candidate_rect);
+
+ /* The stack is sorted with the top windows first. */
+
+ while (stack != NULL && stack->data != window)
+ {
+ other_window = stack->data;
+ stack = stack->next;
+
+ if (other_window->on_all_workspaces ||
+ window->on_all_workspaces ||
+ other_window->workspace == window->workspace)
+ {
+ meta_window_get_outer_rect (other_window, &other_rect);
+
+ if (meta_rectangle_overlap (&candidate_rect, &other_rect))
+ {
+ obscured = TRUE;
+ break;
+ }
+ }
+ }
+ }
+
+ if (obscured)
+ {
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Marking %s as needing attention\n",
+ window->desc);
+
+ window->wm_state_demands_attention = TRUE;
+ set_net_wm_state (window);
+ }
+ else
+ {
+ /* If the window's in full view, there's no point setting the flag. */
+
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Not marking %s as needing attention because "
+ "it's in full view\n",
+ window->desc);
+ }
+}
+
+void
+meta_window_unset_demands_attention (MetaWindow *window)
+{
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Marking %s as not needing attention\n", window->desc);
+
+ window->wm_state_demands_attention = FALSE;
+ set_net_wm_state (window);
+}
+
+MetaFrame *
+meta_window_get_frame (MetaWindow *window)
+{
+ return window->frame;
+}
+
+gboolean
+meta_window_has_focus (MetaWindow *window)
+{
+ return window->has_focus;
+}
+
+gboolean
+meta_window_is_shaded (MetaWindow *window)
+{
+ return window->shaded;
+}
+
+MetaRectangle *
+meta_window_get_rect (MetaWindow *window)
+{
+ return &window->rect;
+}
+
+MetaScreen *
+meta_window_get_screen (MetaWindow *window)
+{
+ return window->screen;
+}
+
+MetaDisplay *
+meta_window_get_display (MetaWindow *window)
+{
+ return window->display;
+}
+
+Window
+meta_window_get_xwindow (MetaWindow *window)
+{
+ return window->xwindow;
+}