core/window.c

Bug Summary

File:	core/window.c
Warning:	line 1645, column 18 Access to field 'data' results in a dereference of a null pointer (loaded from variable 'copy')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name window.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/rootdir/src -resource-dir /usr/lib/llvm-16/lib/clang/16 -D HAVE_CONFIG_H -I . -I .. -I ./include -D CROMA_LIBEXECDIR="/usr/libexec" -D HOST_ALIAS="" -D CROMA_LOCALEDIR="/usr/share/locale" -D CROMA_PKGDATADIR="/usr/share/croma" -D CROMA_DATADIR="/usr/share" -D G_LOG_DOMAIN="croma" -D SN_API_NOT_YET_FROZEN=1 -I /usr/include/ctk-3.0 -I /usr/include/pango-1.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/gio-unix-2.0 -I /usr/include/atk-1.0 -I /usr/include/at-spi2-atk/2.0 -I /usr/include/at-spi-2.0 -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -D _REENTRANT -D _REENTRANT -I /usr/include/startup-notification-1.0 -I /usr/include/libgtop-2.0 -D PIC -internal-isystem /usr/lib/llvm-16/lib/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/13/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fdebug-compilation-dir=/rootdir/src -ferror-limit 19 -fgnuc-version=4.2.1 -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.core.SizeofPtr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2024-02-14-231308-31150-1 -x c core/window.c
1/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */

3/* Croma X managed windows */

5/*
* 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., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/

27#include <config.h>
28#include "window-private.h"
29#include "edge-resistance.h"
30#include "util.h"
31#include "frame-private.h"
32#include "errors.h"
33#include "workspace.h"
34#include "stack.h"
35#include "keybindings.h"
36#include "ui.h"
37#include "place.h"
38#include "session.h"
39#include "effects.h"
40#include "prefs.h"
41#include "resizepopup.h"
42#include "xprops.h"
43#include "group.h"
44#include "window-props.h"
45#include "constraints.h"
46#include "compositor.h"
47#include "effects.h"

49#include <X11/Xatom.h>
50#include <X11/Xlibint.h> /* For display->resource_mask */
51#include <string.h>

53#ifdef HAVE_SHAPE
54#include <X11/extensions/shape.h>
55#endif

57static int destroying_windows_disallowed = 0;


60static void     update_sm_hints           (MetaWindow     *window);
61static void     update_net_frame_extents  (MetaWindow     *window);
62static void     recalc_window_type        (MetaWindow     *window);
63static void     recalc_window_features    (MetaWindow     *window);
64static void     invalidate_work_areas     (MetaWindow     *window);
65static void     recalc_window_type        (MetaWindow     *window);
66static void     set_wm_state              (MetaWindow     *window,
                                         int             state);
68static void     set_net_wm_state          (MetaWindow     *window);
69static void     set_allowed_actions_hint  (MetaWindow     *window);
70static void     send_configure_notify     (MetaWindow     *window);
71static gboolean process_property_notify   (MetaWindow     *window,
                                         XPropertyEvent *event);
73static void     meta_window_show          (MetaWindow     *window);
74static void     meta_window_hide          (MetaWindow     *window);

76static gboolean meta_window_same_client (MetaWindow *window,
                                       MetaWindow *other_window);

79static void     meta_window_save_rect         (MetaWindow    *window);
80static void     save_user_window_placement    (MetaWindow    *window);
81static void     force_save_user_window_placement (MetaWindow    *window);

83static 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);

91static void     ensure_mru_position_after (MetaWindow *window,
                                         MetaWindow *after_this_one);


95static void meta_window_move_resize_now (MetaWindow  *window);

97static void meta_window_unqueue (MetaWindow *window, guint queuebits);

99static void     update_move           (MetaWindow   *window,
                                     gboolean      snap,
                                     int           x,
                                     int           y);
103static gboolean update_move_timeout   (gpointer data);
104static void     update_resize         (MetaWindow   *window,
                                     gboolean      snap,
                                     int           x,
                                     int           y,
                                     gboolean      force);

110static MetaTileMode calculate_tiling_mode(int x,
                                        int y,
                                        MetaWindow *window,
                                        const MetaXineramaScreenInfo *monitor,
                                        MetaRectangle work_area,
                                        int shake_threshold);

117static void         meta_window_transform_to_monitor (MetaRectangle *target_rect,
                                                  const MetaRectangle *from_monitor,
                                                  const MetaRectangle *to_monitor);


122static gboolean update_resize_timeout (gpointer data);


125static void meta_window_flush_calc_showing   (MetaWindow *window);

127static gboolean queue_calc_showing_func (MetaWindow *window,
                                       void       *data);

130static void meta_window_apply_session_info (MetaWindow                  *window,
                                          const MetaWindowSessionInfo *info);

133static void unmaximize_window_before_freeing (MetaWindow        *window);
134static void unminimize_window_and_all_transient_parents (MetaWindow *window);

136/* 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.
*/
142static gboolean idle_calc_showing (gpointer data);
143static gboolean idle_move_resize (gpointer data);
144static gboolean idle_update_icon (gpointer data);

146#ifdef WITH_VERBOSE_MODE1
147static const char*
148wm_state_to_string (int state)
149{
switch (state)
  {
  case NormalState1:
    return "NormalState";
  case IconicState3:
    return "IconicState";
  case WithdrawnState0:
    return "WithdrawnState";
  }

return "Unknown";
161}
162#endif

164static gboolean
165is_desktop_or_dock_foreach (MetaWindow *window,
                          void       *data)
167{
gboolean *result = data;

*result =
  window->type == META_WINDOW_DESKTOP ||
  window->type == META_WINDOW_DOCK;
if (*result)
  return FALSE(0); /* stop as soon as we find one */
else
  return TRUE(!(0));
177}

179/* window is the window that's newly mapped provoking
* the possible change
*/
182static void
183maybe_leave_show_desktop_mode (MetaWindow *window)
184{
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(0);
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);
  }
208}

210MetaWindow*
211meta_window_new (MetaDisplay *display,
               Window       xwindow,
               gboolean     must_be_viewable)
214{
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 (display);

if (XGetWindowAttributes (display->xdisplay,xwindow, &attrs))
 {
    if(meta_error_trap_pop_with_return (display, TRUE(!(0))) != Success0)
     {
        meta_verbosemeta_verbose_real ("Failed to get attributes for window 0x%lx\n",
                      xwindow);
        meta_error_trap_pop (display, TRUE(!(0)));
        meta_display_ungrab (display);
        return NULL((void*)0);
     }
    window = meta_window_new_with_attrs (display, xwindow,
                                     must_be_viewable, &attrs);
 }
else
 {
       meta_error_trap_pop_with_return (display, TRUE(!(0)));
       meta_verbosemeta_verbose_real ("Failed to get attributes for window 0x%lx\n",
                      xwindow);
       meta_error_trap_pop (display, TRUE(!(0)));
       meta_display_ungrab (display);
       return NULL((void*)0);
 }


meta_error_trap_pop (display, FALSE(0));
meta_display_ungrab (display);

return window;
253}

255MetaWindow*
256meta_window_new_with_attrs (MetaDisplay       *display,
                          Window             xwindow,
                          gboolean           must_be_viewable,
                          XWindowAttributes *attrs)
260{
MetaWindow *window;
GSList *tmp;
MetaWorkspace *space;
gulong existing_wm_state;
gulong event_mask;
MetaMoveResizeFlags flags;
267#define N_INITIAL_PROPS20 20
Atom initial_props[N_INITIAL_PROPS20];
int i;
gboolean has_shape;

g_assert (attrs != NULL)do { if (attrs != ((void*)0)) ; else g_assertion_message_expr
 ("croma", "core/window.c", 272, ((const char*) (__func__)), "attrs != NULL"
); } while (0);
g_assert (N_INITIAL_PROPS == (int) G_N_ELEMENTS (initial_props))do { if (20 == (int) (sizeof (initial_props) / sizeof ((initial_props
)[0]))) ; else g_assertion_message_expr ("croma", "core/window.c"
, 273, ((const char*) (__func__)), "N_INITIAL_PROPS == (int) G_N_ELEMENTS (initial_props)"
); } while (0);

meta_verbosemeta_verbose_real ("Attempting to manage 0x%lx\n", xwindow);

if (meta_display_xwindow_is_a_no_focus_window (display, xwindow))
  {
    meta_verbosemeta_verbose_real ("Not managing no_focus_window 0x%lx\n",
                  xwindow);
    return NULL((void*)0);
  }

if (attrs->override_redirect)
  {
    meta_verbosemeta_verbose_real ("Deciding not to manage override_redirect window 0x%lx\n", xwindow);
    return NULL((void*)0);
  }

/* Grab server */
meta_display_grab (display);
meta_error_trap_push (display); /* Push a trap over all of window
                                 * creation, to reduce XSync() calls
                                 */

meta_verbosemeta_verbose_real ("must_be_viewable = %d attrs->map_state = %d (%s)\n",
              must_be_viewable,
              attrs->map_state,
              (attrs->map_state == IsUnmapped0) ?
              "IsUnmapped" :
              (attrs->map_state == IsViewable2) ?
              "IsViewable" :
              (attrs->map_state == IsUnviewable1) ?
              "IsUnviewable" :
              "(unknown)");

existing_wm_state = WithdrawnState0;
if (must_be_viewable && attrs->map_state != IsViewable2)
  {
    /* 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 == IconicState3 || state == NormalState1)))
      {
        meta_verbosemeta_verbose_real ("Deciding not to manage unmapped or unviewable window 0x%lx\n", xwindow);
        meta_error_trap_pop (display, TRUE(!(0)));
        meta_display_ungrab (display);
        return NULL((void*)0);
      }

    existing_wm_state = state;
    meta_verbosemeta_verbose_real ("WM_STATE of %lx = %s\n", xwindow,
                  wm_state_to_string (existing_wm_state));
  }

meta_error_trap_push (display);

XAddToSaveSet (display->xdisplay, xwindow);

event_mask =
  PropertyChangeMask(1L<<22) | EnterWindowMask(1L<<4) | LeaveWindowMask(1L<<5) |
  FocusChangeMask(1L<<21) | ColormapChangeMask(1L<<23);

XSelectInput (display->xdisplay, xwindow, event_mask);

has_shape = FALSE(0);
342#ifdef HAVE_SHAPE
if (META_DISPLAY_HAS_SHAPE (display)((display)->have_shape))
  {
    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(1L << 0));

    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(0);

    meta_topicmeta_topic_real (META_DEBUG_SHAPES,
                "Window has_shape = %d extents %d,%d %u x %u\n",
                has_shape, x_bounding, y_bounding,
                w_bounding, h_bounding);
  }
364#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 != NorthWestGravity1)
  {
    XSetWindowAttributes set_attrs;

    set_attrs.win_gravity = NorthWestGravity1;

    XChangeWindowAttributes (display->xdisplay,
                             xwindow,
                             CWWinGravity(1L<<5),
                             &set_attrs);
  }

if (meta_error_trap_pop_with_return (display, FALSE(0)) != Success0)
  {
    meta_verbosemeta_verbose_real ("Window 0x%lx disappeared just as we tried to manage it\n",
                  xwindow);
    meta_error_trap_pop (display, FALSE(0));
    meta_display_ungrab (display);
    return NULL((void*)0);
  }

g_assert (!attrs->override_redirect)do { if (!attrs->override_redirect) ; else g_assertion_message_expr
 ("croma", "core/window.c", 392, ((const char*) (__func__)), "!attrs->override_redirect"
); } while (0);

window = g_new (MetaWindow, 1)((MetaWindow *) g_malloc_n ((1), sizeof (MetaWindow)));

window->constructing = TRUE(!(0));

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((void*)0);

408#ifdef HAVE_XSYNC
window->sync_request_counter = None0L;
window->sync_request_serial = 0;
window->sync_request_time = 0;
412#endif

window->screen = NULL((void*)0);
tmp = display->screens;
while (tmp != NULL((void*)0))
  {
    MetaScreen *scr = tmp->data;

    if (scr->xroot == attrs->root)
      {
        window->screen = tmp->data;
        break;
      }

    tmp = tmp->next;
  }

g_assert (window->screen)do { if (window->screen) ; else g_assertion_message_expr (
"croma", "core/window.c", 429, ((const char*) (__func__)), "window->screen"
); } while (0);

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((void*)0));

window->has_custom_frame_extents = FALSE(0);
window->custom_frame_extents.left = 0;
window->custom_frame_extents.right = 0;
window->custom_frame_extents.top = 0;
window->custom_frame_extents.bottom = 0;

/* 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((void*)0);
window->icon_name = NULL((void*)0);
window->icon = NULL((void*)0);
window->mini_icon = NULL((void*)0);
meta_icon_cache_init (&window->icon_cache);
window->wm_hints_pixmap = None0L;
window->wm_hints_mask = None0L;

window->frame = NULL((void*)0);
window->has_focus = FALSE(0);

window->maximized_horizontally = FALSE(0);
window->maximized_vertically = FALSE(0);
window->maximize_horizontally_after_placement = FALSE(0);
window->maximize_vertically_after_placement = FALSE(0);
window->minimize_after_placement = FALSE(0);
window->move_after_placement = FALSE(0);
window->fullscreen = FALSE(0);
window->fullscreen_after_placement = FALSE(0);
window->fullscreen_monitors[0] = -1;
window->require_fully_onscreen = TRUE(!(0));
window->require_on_single_xinerama = TRUE(!(0));
window->require_titlebar_visible = TRUE(!(0));
window->on_all_workspaces = FALSE(0);
window->tile_mode = META_TILE_NONE;
window->tile_resized = FALSE(0);
window->tile_monitor_number = -1;
window->shaded = FALSE(0);
window->initially_iconic = FALSE(0);
window->minimized = FALSE(0);
window->was_minimized = FALSE(0);
window->tab_unminimized = FALSE(0);
window->iconic = FALSE(0);
window->mapped = attrs->map_state != IsUnmapped0;
/* 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_topicmeta_topic_real (META_DEBUG_PLACEMENT,
              "Not placing window 0x%lx since it's already mapped\n",
              xwindow);
window->force_save_user_rect = TRUE(!(0));
window->denied_focus_and_not_transient = FALSE(0);
window->unmanaging = FALSE(0);
window->is_in_queues = 0;
window->keys_grabbed = FALSE(0);
window->grab_on_frame = FALSE(0);
window->all_keys_grabbed = FALSE(0);
window->withdrawn = FALSE(0);
window->initial_workspace_set = FALSE(0);
window->initial_timestamp_set = FALSE(0);
window->net_wm_user_time_set = FALSE(0);
window->user_time_window = None0L;
window->take_focus = FALSE(0);
window->input = TRUE(!(0));
window->calc_placement = FALSE(0);
window->shaken_loose = FALSE(0);
window->have_focus_click_grab = FALSE(0);
window->disable_sync = FALSE(0);
window->frame_bounds = NULL((void*)0);

window->unmaps_pending = 0;

window->mwm_decorated = TRUE(!(0));
window->mwm_border_only = FALSE(0);
window->mwm_has_close_func = TRUE(!(0));
window->mwm_has_minimize_func = TRUE(!(0));
window->mwm_has_maximize_func = TRUE(!(0));
window->mwm_has_move_func = TRUE(!(0));
window->mwm_has_resize_func = TRUE(!(0));

window->decorated = TRUE(!(0));
window->has_close_func = TRUE(!(0));
window->has_minimize_func = TRUE(!(0));
window->has_maximize_func = TRUE(!(0));
window->has_move_func = TRUE(!(0));
window->has_resize_func = TRUE(!(0));

window->has_shade_func = TRUE(!(0));

window->has_fullscreen_func = TRUE(!(0));

window->always_sticky = FALSE(0);

window->wm_state_modal = FALSE(0);
window->skip_taskbar = FALSE(0);
window->skip_pager = FALSE(0);
window->wm_state_skip_taskbar = FALSE(0);
window->wm_state_skip_pager = FALSE(0);
window->wm_state_above = FALSE(0);
window->wm_state_below = FALSE(0);
window->wm_state_demands_attention = FALSE(0);

window->res_class = NULL((void*)0);
window->res_name = NULL((void*)0);
window->role = NULL((void*)0);
window->sm_client_id = NULL((void*)0);
window->wm_client_machine = NULL((void*)0);
window->startup_id = NULL((void*)0);
window->ctk_theme_variant = NULL((void*)0);

window->net_wm_pid = -1;

window->xtransient_for = None0L;
window->xclient_leader = None0L;
window->transient_parent_is_root_window = FALSE(0);

window->type = META_WINDOW_NORMAL;
window->type_atom = None0L;

window->struts = NULL((void*)0);

window->using_net_wm_name              = FALSE(0);
window->using_net_wm_visible_name      = FALSE(0);
window->using_net_wm_icon_name         = FALSE(0);
window->using_net_wm_visible_icon_name = FALSE(0);

window->need_reread_icon = TRUE(!(0));

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((void*)0);
window->xgroup_leader = None0L;
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((Atom) 67);
initial_props[i++] = XA_WM_NAME((Atom) 39);
initial_props[i++] = display->atom__NET_WM_ICON_NAME;
initial_props[i++] = XA_WM_ICON_NAME((Atom) 37);
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((Atom) 40);
initial_props[i++] = display->atom_WM_PROTOCOLS;
initial_props[i++] = XA_WM_HINTS((Atom) 35);
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((Atom) 68);
initial_props[i++] = display->atom__NET_WM_USER_TIME_WINDOW;
initial_props[i++] = display->atom__NET_WM_FULLSCREEN_MONITORS;
initial_props[i++] = display->atom__CTK_THEME_VARIANT;
g_assert (N_INITIAL_PROPS == i)do { if (20 == i) ; else g_assertion_message_expr ("croma", "core/window.c"
, 626, ((const char*) (__func__)), "N_INITIAL_PROPS == i"); }
 while (0);

meta_window_reload_properties (window, initial_props, N_INITIAL_PROPS20, TRUE(!(0)));

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(!(0));
    meta_verbosemeta_verbose_real ("Window %s asked to start out minimized\n", window->desc);
  }

if (existing_wm_state == IconicState3)
  {
    /* WM_STATE said minimized */
    window->minimized = TRUE(!(0));
    meta_verbosemeta_verbose_real ("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(!(0));
  }

/* 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((void*)0);
  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((void*)0))
    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(!(0));
  }

/* 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_topicmeta_topic_real (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(!(0));
        meta_workspace_add_window (window->screen->active_workspace, window);
      }
    else
      {
        meta_topicmeta_topic_real (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((void*)0) &&
    window->xtransient_for != None0L)
  {
    /* 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_topicmeta_topic_real (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(!(0));

 /* this will implicitly add to the appropriate MRU lists
  */
        meta_workspace_add_window (parent->workspace, window);
      }
  }

if (window->workspace == NULL((void*)0))
  {
    meta_topicmeta_topic_real (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 ? IconicState3 : NormalState1);
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((void*)0));
/* 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(0)); /* pop the XSync()-reducing trap */
meta_display_ungrab (display);

window->constructing = FALSE(0);

return window;
860}

862/* This function should only be called from the end of meta_window_new_with_attrs () */
863static void
864meta_window_apply_session_info (MetaWindow *window,
                              const MetaWindowSessionInfo *info)
866{
if (info->stack_position_set)
  {
    meta_topicmeta_topic_real (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_topicmeta_topic_real (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_topicmeta_topic_real (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_topicmeta_topic_real (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_topicmeta_topic_real (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((void*)0);

    tmp = info->workspace_indices;
    while (tmp != NULL((void*)0))
      {
        MetaWorkspace *space;

        space =
          meta_screen_get_workspace_by_index (window->screen,
                                              GPOINTER_TO_INT (tmp->data)((gint) (glong) (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_topicmeta_topic_real (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(!(0)); /* 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_topicmeta_topic_real (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);
  }
999}

1001void
1002meta_window_free (MetaWindow  *window,
                guint32      timestamp)
1004{
GList *tmp;

meta_verbosemeta_verbose_real ("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((void*)0);
    window->display->window_with_menu = NULL((void*)0);
  }

if (destroying_windows_disallowed > 0)
  meta_bug ("Tried to destroy window %s while destruction was not allowed\n",
            window->desc);

window->unmanaging = TRUE(!(0));

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_topicmeta_topic_real (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_topicmeta_topic_real (META_DEBUG_FOCUS,
                "Focusing default window since expected focus window freed %s\n",
                window->desc);
    window->display->expected_focus_window = NULL((void*)0);
    meta_workspace_focus_default_window (window->screen->active_workspace,
                                         window,
                                         timestamp);
  }
else
  {
    meta_topicmeta_topic_real (META_DEBUG_FOCUS,
                "Unmanaging window %s which doesn't currently have focus\n",
                window->desc);
  }

if (window->struts)
  {
    g_slist_free_full (window->struts, g_free);
    window->struts = NULL((void*)0);

    meta_topicmeta_topic_real (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)do { if (window->display->grab_window != window) ; else
 g_assertion_message_expr ("croma", "core/window.c", 1091, ((
const char*) (__func__)), "window->display->grab_window != window"
); } while (0);

if (window->display->focus_window == window)
  {
    window->display->focus_window = NULL((void*)0);
    meta_compositor_set_active_window (window->display->compositor,
                                       window->screen, NULL((void*)0));
  }

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)do { if (window->workspace == ((void*)0)) ; else g_assertion_message_expr
 ("croma", "core/window.c", 1117, ((const char*) (__func__)),
 "window->workspace == NULL"); } while (0);

1119#ifndef G_DISABLE_CHECKS
tmp = window->screen->workspaces;
while (tmp != NULL((void*)0))
  {
    MetaWorkspace *workspace = tmp->data;

    g_assert (g_list_find (workspace->windows, window) == NULL)do { if (g_list_find (workspace->windows, window) == ((void
*)0)) ; else g_assertion_message_expr ("croma", "core/window.c"
, 1125, ((const char*) (__func__)), "g_list_find (workspace->windows, window) == NULL"
); } while (0);
    g_assert (g_list_find (workspace->mru_list, window) == NULL)do { if (g_list_find (workspace->mru_list, window) == ((void
*)0)) ; else g_assertion_message_expr ("croma", "core/window.c"
, 1126, ((const char*) (__func__)), "g_list_find (workspace->mru_list, window) == NULL"
); } while (0);

    tmp = tmp->next;
  }
1130#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_verbosemeta_verbose_real ("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, WithdrawnState0);
    meta_error_trap_pop (window->display, FALSE(0));
  }
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, NormalState1);
        meta_error_trap_pop (window->display, FALSE(0));
      }

    /* 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(0));
  }

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,
              NoEventMask0L);

/* Stop getting events for the window's _NET_WM_USER_TIME_WINDOW too */
if (window->user_time_window != None0L)
  {
    meta_display_unregister_x_window (window->display,
                                      window->user_time_window);
    XSelectInput (window->display->xdisplay,
                  window->user_time_window,
                  NoEventMask0L);
    window->user_time_window = None0L;
  }

1212#ifdef HAVE_SHAPE
if (META_DISPLAY_HAS_SHAPE (window->display)((window->display)->have_shape))
  XShapeSelectInput (window->display->xdisplay, window->xwindow, NoEventMask0L);
1215#endif

meta_error_trap_pop (window->display, FALSE(0));

if (window->icon)
  g_object_unref (G_OBJECT (window->icon)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->icon)), (((GType) ((20) << (2)))))))));

if (window->mini_icon)
  g_object_unref (G_OBJECT (window->mini_icon)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->mini_icon)), (((GType) ((20) << (2)))))
))));

if (window->frame_bounds)
  cairo_region_destroy (window->frame_bounds);

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->ctk_theme_variant);
g_free (window);
1241}

1243static void
1244set_wm_state (MetaWindow *window,
            int         state)
1246{
unsigned long data[2];

meta_verbosemeta_verbose_real ("Setting wm state %s on %s\n",
              wm_state_to_string (state), window->desc);

/* Croma 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] = None0L;

meta_error_trap_push (window->display);
XChangeProperty (window->display->xdisplay, window->xwindow,
                 window->display->atom_WM_STATE,
                 window->display->atom_WM_STATE,
                 32, PropModeReplace0, (guchar*) data, 2);
meta_error_trap_pop (window->display, FALSE(0));
1264}

1266static void
1267set_net_wm_state (MetaWindow *window)
1268{
int i;
unsigned long data[13];

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;
  }
if (meta_window_appears_focused (window))
  {
    data[i] = window->display->atom__NET_WM_STATE_FOCUSED;
    ++i;
  }

meta_verbosemeta_verbose_real ("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((Atom) 4),
                 32, PropModeReplace0, (guchar*) data, i);
meta_error_trap_pop (window->display, FALSE(0));

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_verbosemeta_verbose_real ("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((Atom) 6), 32, PropModeReplace0,
                     (guchar*) data, 4);
    meta_error_trap_pop (window->display, FALSE(0));
  }
1364}

1366gboolean
1367meta_window_located_on_workspace (MetaWindow    *window,
                                MetaWorkspace *workspace)
1369{
return (window->on_all_workspaces && window->screen == workspace->screen) ||
  (window->workspace == workspace);
1372}

1374static gboolean
1375is_minimized_foreach (MetaWindow *window,
                    void       *data)
1377{
gboolean *result = data;

*result = window->minimized;
if (*result)
  return FALSE(0); /* stop as soon as we find one */
else
  return TRUE(!(0));
1385}

1387static gboolean
1388ancestor_is_minimized (MetaWindow *window)
1389{
gboolean is_minimized;

is_minimized = FALSE(0);

meta_window_foreach_ancestor (window, is_minimized_foreach, &is_minimized);

return is_minimized;
1397}

1399gboolean
1400meta_window_showing_on_its_workspace (MetaWindow *window)
1401{
gboolean showing;
gboolean is_desktop_or_dock;
MetaWorkspace* workspace_of_window;

showing = TRUE(!(0));

/* 1. See if we're minimized */
if (window->minimized)
  showing = FALSE(0);

/* 2. See if we're in "show desktop" mode */
is_desktop_or_dock = FALSE(0);
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((void*)0);

if (showing &&
    workspace_of_window && workspace_of_window->showing_desktop &&
    !is_desktop_or_dock)
  {
    meta_verbosemeta_verbose_real ("We're showing the desktop on the workspace(s) that window %s is on\n",
                  window->desc);
    showing = FALSE(0);
  }

/* 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(0);
  }

1447#if 0
/* 4. See if we're drawing wireframe
 */
if (window->display->grab_window == window &&
    window->display->grab_wireframe_active)
  showing = FALSE(0);
1453#endif

return showing;
1456}

1458gboolean
1459meta_window_should_be_showing (MetaWindow  *window)
1460{
gboolean on_workspace;

meta_verbosemeta_verbose_real ("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_verbosemeta_verbose_real ("Window %s is not on workspace %d\n",
                window->desc,
                meta_workspace_index (window->screen->active_workspace));
else
  meta_verbosemeta_verbose_real ("Window %s is on the active workspace %d\n",
                window->desc,
                meta_workspace_index (window->screen->active_workspace));

if (window->on_all_workspaces)
  meta_verbosemeta_verbose_real ("Window %s is on all workspaces\n", window->desc);

return on_workspace && meta_window_showing_on_its_workspace (window);
1482}

1484static void
1485finish_minimize (gpointer data)
1486{
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);
  }
1503}

1505static void
1506implement_showing (MetaWindow *window,
                 gboolean    showing)
1508{
/* Actually show/hide the window */
meta_verbosemeta_verbose_real ("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 anicafe
     * 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 anicafe 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);
  }
1563}

1565void
1566meta_window_calc_showing (MetaWindow  *window)
1567{
implement_showing (window, meta_window_should_be_showing (window));
1569}

1571static guint queue_idle[NUMBER_OF_QUEUES3] = {0, 0, 0};
1572static GSList *queue_pending[NUMBER_OF_QUEUES3] = {NULL((void*)0), NULL((void*)0), NULL((void*)0)};

1574static int
1575stackcmp (gconstpointer a, gconstpointer b)
1576{
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);
1585}

1587static gboolean
1588idle_calc_showing (gpointer data)
1589{
GSList *tmp;
GSList *copy;
GSList *should_show;
GSList *should_hide;
GSList *unplaced;
MetaWindow *first_window;
guint queue_index = GPOINTER_TO_INT (data)((gint) (glong) (data));

meta_topicmeta_topic_real (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]);
1
Value assigned to 'copy'→
g_slist_free (queue_pending[queue_index]);
queue_pending[queue_index] = NULL((void*)0);
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((void*)0);
should_hide = NULL((void*)0);
unplaced = NULL((void*)0);

tmp = copy;
while (tmp != NULL((void*)0))
2
←
Assuming 'tmp' is equal to NULL→
3
←
Loop condition is false. Execution continues on line 1639→
  {
    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;
4
←
Access to field 'data' results in a dereference of a null pointer (loaded from variable 'copy')

meta_display_grab (first_window->display);

tmp = unplaced;
while (tmp != NULL((void*)0))
  {
    MetaWindow *window;

    window = tmp->data;

    meta_window_calc_showing (window);

    tmp = tmp->next;
  }

tmp = should_show;
while (tmp != NULL((void*)0))
  {
    MetaWindow *window;

    window = tmp->data;

    implement_showing (window, TRUE(!(0)));

    tmp = tmp->next;
  }

tmp = should_hide;
while (tmp != NULL((void*)0))
  {
    MetaWindow *window;

    window = tmp->data;

    implement_showing (window, FALSE(0));

    tmp = tmp->next;
  }

tmp = copy;
while (tmp != NULL((void*)0))
  {
    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((void*)0))
      {
        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);

destroying_windows_disallowed -= 1;

return FALSE(0);
1732}

1734#ifdef WITH_VERBOSE_MODE1
1735static const gchar* meta_window_queue_names[NUMBER_OF_QUEUES3] =
{"calc_showing", "move_resize", "update_icon"};
1737#endif

1739static void
1740meta_window_unqueue (MetaWindow *window, guint queuebits)
1741{
gint queuenum;

for (queuenum=0; queuenum<NUMBER_OF_QUEUES3; queuenum++)
  {
    if ((queuebits & 1<<queuenum) /* they have asked to unqueue */
        &&
        (window->is_in_queues & 1<<queuenum)) /* it's in the queue */
      {

        meta_topicmeta_topic_real (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((void*)0) && queue_idle[queuenum] != 0)
          {
            g_source_remove (queue_idle[queuenum]);
            queue_idle[queuenum] = 0;
          }
      }
  }
1773}

1775static void
1776meta_window_flush_calc_showing (MetaWindow *window)
1777{
if (window->is_in_queues & META_QUEUE_CALC_SHOWING)
  {
    meta_window_unqueue (window, META_QUEUE_CALC_SHOWING);
    meta_window_calc_showing (window);
  }
1783}

1785void
1786meta_window_queue (MetaWindow *window, guint queuebits)
1787{
guint queuenum;

for (queuenum=0; queuenum<NUMBER_OF_QUEUES3; 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_QUEUES3] =
          {
            G_PRIORITY_DEFAULT_IDLE200,  /* CALC_SHOWING */
            META_PRIORITY_RESIZE(100 + 15),     /* MOVE_RESIZE */
            G_PRIORITY_DEFAULT_IDLE200   /* UPDATE_ICON */
          };

        const GSourceFunc window_queue_idle_handler[NUMBER_OF_QUEUES3] =
          {
            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_topicmeta_topic_real (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)((gpointer) (gulong) (queuenum)),
              NULL((void*)0)
            );

        /* And now we actually put it on the queue. */
        queue_pending[queuenum] = g_slist_prepend (queue_pending[queuenum],
                                                   window);
    }
}
1853}

1855static gboolean
1856intervening_user_event_occurred (MetaWindow *window)
1857{
guint32 compare;
MetaWindow *focus_window;

focus_window = window->display->focus_window;

meta_topicmeta_topic_real (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((void*)0))
  {
    meta_topicmeta_topic_real (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(!(0))) &&
     (window->net_wm_user_time == 0))
    ||
     ((window->initial_timestamp_set == TRUE(!(0))) &&
     (window->initial_timestamp == 0)))
  {
    meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                "window %s explicitly requested no focus\n",
                window->desc);
    return TRUE(!(0));
  }

if (!(window->net_wm_user_time_set) && !(window->initial_timestamp_set))
  {
    meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                "no information about window %s found\n",
                window->desc);
    return FALSE(0);
  }

if (focus_window != NULL((void*)0) &&
    !focus_window->net_wm_user_time_set)
  {
    meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                "focus window, %s, doesn't have a user time set yet!\n",
                window->desc);
    return FALSE(0);
  }

/* To determine the "launch" time of an application,
 * startup-notification can set the TIMESTAMP and the
 * application (usually via its toolkit such as ctk 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->net_wm_user_time) == 0 || (( (( (window->net_wm_user_time
) < (window->initial_timestamp) ) && ( (window->
initial_timestamp) - (window->net_wm_user_time) < ((guint32
)-1)/2 )) || (( (window->net_wm_user_time) > (window->
initial_timestamp) ) && ( (window->net_wm_user_time
) - (window->initial_timestamp) > ((guint32)-1)/2 )) ) &&
 (window->initial_timestamp) != 0) )
                            window->initial_timestamp)( (window->net_wm_user_time) == 0 || (( (( (window->net_wm_user_time
) < (window->initial_timestamp) ) && ( (window->
initial_timestamp) - (window->net_wm_user_time) < ((guint32
)-1)/2 )) || (( (window->net_wm_user_time) > (window->
initial_timestamp) ) && ( (window->net_wm_user_time
) - (window->initial_timestamp) > ((guint32)-1)/2 )) ) &&
 (window->initial_timestamp) != 0) ) ?
    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((void*)0)) &&
    XSERVER_TIME_IS_BEFORE (compare, focus_window->net_wm_user_time)( (compare) == 0 || (( (( (compare) < (focus_window->net_wm_user_time
) ) && ( (focus_window->net_wm_user_time) - (compare
) < ((guint32)-1)/2 )) || (( (compare) > (focus_window->
net_wm_user_time) ) && ( (compare) - (focus_window->
net_wm_user_time) > ((guint32)-1)/2 )) ) && (focus_window
->net_wm_user_time) != 0) ))
  {
    meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                "window %s focus prevented by other activity; %u < %u\n",
                window->desc,
                compare,
                focus_window->net_wm_user_time);
    return TRUE(!(0));
  }
else
  {
    meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                "new window %s with no intervening events\n",
                window->desc);
    return FALSE(0);
  }
1956}

1958/* 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.
*/
1963gboolean
1964__window_is_terminal (MetaWindow *window)
1965{
if (window == NULL((void*)0) || window->res_class == NULL((void*)0))
  return FALSE(0);

/*
 * Compare res_class, which is not user-settable, and thus theoretically
 * a more-reliable indication of term-ness.
 */

/* cafe-terminal -- if you couldn't guess */
if (strcmp (window->res_class, "Cafe-terminal") == 0)
  return TRUE(!(0));
/* xterm, rxvt, aterm */
else if (strcmp (window->res_class, "XTerm") == 0)
  return TRUE(!(0));
/* konsole, KDE's terminal program */
else if (strcmp (window->res_class, "Konsole") == 0)
  return TRUE(!(0));
/* rxvt-unicode */
else if (strcmp (window->res_class, "URxvt") == 0)
  return TRUE(!(0));
/* eterm */
else if (strcmp (window->res_class, "Eterm") == 0)
  return TRUE(!(0));
/* KTerm -- some terminal not KDE based; so not like Konsole */
else if (strcmp (window->res_class, "KTerm") == 0)
  return TRUE(!(0));
/* Multi-cafe-terminal */
else if (strcmp (window->res_class, "Multi-cafe-terminal") == 0)
  return TRUE(!(0));
/* mlterm ("multi lingual terminal emulator on X") */
else if (strcmp (window->res_class, "mlterm") == 0)
  return TRUE(!(0));
/* Terminal -- XFCE Terminal */
else if (strcmp (window->res_class, "Terminal") == 0)
  return TRUE(!(0));

return FALSE(0);
2003}

2005/* This function determines what state the window should have assuming that it
* and the focus_window have no relation
*/
2008static void
2009window_state_on_map (MetaWindow *window,
                   gboolean *takes_focus,
                   gboolean *places_on_top)
2012{
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(0);
    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_topicmeta_topic_real (META_DEBUG_FOCUS,
                "focus_window is terminal; not focusing new window.\n");
    *takes_focus = FALSE(0);
    *places_on_top = FALSE(0);
  }

switch (window->type)
  {
  case META_WINDOW_UTILITY:
  case META_WINDOW_TOOLBAR:
    *takes_focus = FALSE(0);
    *places_on_top = FALSE(0);
    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(0);
    break;
  case META_WINDOW_NORMAL:
  case META_WINDOW_DIALOG:
  case META_WINDOW_MODAL_DIALOG:
    /* The default is correct for these */
    break;
  }
2073}

2075static gboolean
2076windows_overlap (const MetaWindow *w1, const MetaWindow *w2)
2077{
if (w1->minimized || w2->minimized)
  return FALSE(0);

MetaRectangle w1rect, w2rect;
meta_window_get_outer_rect (w1, &w1rect);
meta_window_get_outer_rect (w2, &w2rect);
return meta_rectangle_overlap (&w1rect, &w2rect);
2085}

2087/* 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.
*/
2098static gboolean
2099window_would_be_covered (const MetaWindow *newbie)
2100{
MetaWorkspace *workspace;
GList *tmp, *windows;

workspace = meta_window_get_workspace ((MetaWindow *) newbie);
windows = meta_workspace_list_windows (workspace);

tmp = windows;
while (tmp != NULL((void*)0))
  {
    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(!(0)); /* yes, it does */
          }
      }

    tmp = tmp->next;
  }

g_list_free (windows);
return FALSE(0); /* none found */
2127}

2129/* XXX META_EFFECT_*_MAP */
2130void
2131meta_window_show (MetaWindow *window)
2132{
gboolean did_show;
gboolean takes_focus_on_map;
gboolean place_on_top_on_map;
gboolean needs_stacking_adjustment;
gboolean will_be_covered;
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_topicmeta_topic_real (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(0);
window_state_on_map (window, &takes_focus_on_map, &place_on_top_on_map);
needs_stacking_adjustment = FALSE(0);
will_be_covered = window_would_be_covered (window);

meta_topicmeta_topic_real (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((void*)0) && window->showing_for_first_time &&
    ( (!place_on_top_on_map && !takes_focus_on_map) ||
    will_be_covered )
  ) {
    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_topicmeta_topic_real (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(!(0));
        if (!window->placed)
          window->denied_focus_and_not_transient = TRUE(!(0));
      }
  }

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(!(0));
    meta_window_move_resize_now (window);
    window->calc_placement = FALSE(0);

    /* 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 ulticafely shown.
     */
    window->placed = TRUE(!(0));

    /* 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(0);
  }

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(0);

    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 (!will_be_covered && (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 or a window set to
     * always on top, 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 || will_be_covered)
      window->wm_state_demands_attention = TRUE(!(0));
  }

/* Shaded means the frame is mapped but the window is not */

if (window->frame && !window->frame->mapped)
  {
    meta_topicmeta_topic_real (META_DEBUG_WINDOW_STATE,
                "Frame actually needs map\n");
    window->frame->mapped = TRUE(!(0));
    meta_ui_map_frame (window->screen->ui, window->frame->xwindow);
    did_show = TRUE(!(0));
  }

if (window->shaded)
  {
    if (window->mapped)
      {
        meta_topicmeta_topic_real (META_DEBUG_WINDOW_STATE,
                    "%s actually needs unmap (shaded)\n", window->desc);
        meta_topicmeta_topic_real (META_DEBUG_WINDOW_STATE,
                    "Incrementing unmaps_pending on %s for shade\n",
                    window->desc);
        window->mapped = FALSE(0);
        window->unmaps_pending += 1;
        meta_error_trap_push (window->display);
        XUnmapWindow (window->display->xdisplay, window->xwindow);
        meta_error_trap_pop (window->display, FALSE(0));
      }

    if (!window->iconic)
      {
        window->iconic = TRUE(!(0));
        set_wm_state (window, IconicState3);
      }
  }
else
  {
    if (!window->mapped)
      {
        meta_topicmeta_topic_real (META_DEBUG_WINDOW_STATE,
                    "%s actually needs map\n", window->desc);
        window->mapped = TRUE(!(0));
        meta_error_trap_push (window->display);
        XMapWindow (window->display->xdisplay, window->xwindow);
        meta_error_trap_pop (window->display, FALSE(0));
        did_show = TRUE(!(0));

        if (window->was_minimized)
          {
            MetaRectangle window_rect;
            MetaRectangle icon_rect;

            window->was_minimized = FALSE(0);

            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((void*)0), NULL((void*)0));
              }
          }
      }

    if (window->iconic)
      {
        window->iconic = FALSE(0);
        set_wm_state (window, NormalState1);
      }
  }

/* 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(0);
    if (takes_focus_on_map)
      {
        meta_window_focus (window, timestamp);

        if (window->move_after_placement)
          {
            meta_window_begin_grab_op(window, META_GRAB_OP_KEYBOARD_MOVING,
                                      FALSE(0), timestamp);
            window->move_after_placement = FALSE(0);
          }
      }
    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_topicmeta_topic_real (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(0);
2397}

2399/* XXX META_EFFECT_*_UNMAP */
2400static void
2401meta_window_hide (MetaWindow *window)
2402{
gboolean did_hide;

meta_topicmeta_topic_real (META_DEBUG_WINDOW_STATE,
            "Hiding window %s\n", window->desc);

did_hide = FALSE(0);

if (window->frame && window->frame->mapped)
  {
    meta_topicmeta_topic_real (META_DEBUG_WINDOW_STATE, "Frame actually needs unmap\n");
    window->frame->mapped = FALSE(0);
    meta_ui_unmap_frame (window->screen->ui, window->frame->xwindow);
    did_hide = TRUE(!(0));
  }

if (window->mapped)
  {
    meta_topicmeta_topic_real (META_DEBUG_WINDOW_STATE,
                "%s actually needs unmap\n", window->desc);
    meta_topicmeta_topic_real (META_DEBUG_WINDOW_STATE,
                "Incrementing unmaps_pending on %s for hide\n",
                window->desc);
    window->mapped = FALSE(0);
    window->unmaps_pending += 1;
    meta_error_trap_push (window->display);
    XUnmapWindow (window->display->xdisplay, window->xwindow);
    meta_error_trap_pop (window->display, FALSE(0));
    did_hide = TRUE(!(0));
  }

if (!window->iconic)
  {
    window->iconic = TRUE(!(0));
    set_wm_state (window, IconicState3);
  }

set_net_wm_state (window);

if (did_hide && window->struts)
  {
    meta_topicmeta_topic_real (META_DEBUG_WORKAREA,
                "Unmapped window %s with struts, so invalidating work areas\n",
                window->desc);
    invalidate_work_areas (window);
  }
2448}

2450static gboolean
2451queue_calc_showing_func (MetaWindow *window,
                       void       *data)
2453{
meta_window_queue(window, META_QUEUE_CALC_SHOWING);
return TRUE(!(0));
2456}

2458void
2459meta_window_minimize (MetaWindow  *window)
2460{
if (!window->minimized)
  {
    window->minimized = TRUE(!(0));
    meta_window_queue(window, META_QUEUE_CALC_SHOWING);

    meta_window_foreach_transient (window,
                                   queue_calc_showing_func,
                                   NULL((void*)0));

    set_allowed_actions_hint (window);

    if (window->has_focus)
      {
        meta_topicmeta_topic_real (META_DEBUG_FOCUS,
                    "Focusing default window due to minimization of focus window %s\n",
                    window->desc);
      }
    else
      {
        meta_topicmeta_topic_real (META_DEBUG_FOCUS,
                    "Minimizing window %s which doesn't have the focus\n",
                    window->desc);
      }
  }
2485}

2487void
2488meta_window_unminimize (MetaWindow  *window)
2489{
if (window->minimized)
  {
    window->minimized = FALSE(0);
    window->was_minimized = TRUE(!(0));
    meta_window_queue(window, META_QUEUE_CALC_SHOWING);

    meta_window_foreach_transient (window,
                                   queue_calc_showing_func,
                                   NULL((void*)0));

    set_allowed_actions_hint (window);
  }
2502}

2504static void
2505ensure_size_hints_satisfied (MetaRectangle    *rect,
                           const XSizeHints *size_hints)
2507{
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->width) > (maxw)) ? (maxw) : (((rect->width)
 < (minw)) ? (minw) : (rect->width)));
rect->height = CLAMP (rect->height, minh, maxh)(((rect->height) > (maxh)) ? (maxh) : (((rect->height
) < (minh)) ? (minh) : (rect->height)));

/* 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;
2535}

2537static void
2538meta_window_save_rect (MetaWindow *window)
2539{
if (!(META_WINDOW_MAXIMIZED (window)((window)->maximized_horizontally && (window)->
maximized_vertically) || META_WINDOW_SIDE_TILED (window)((window)->tiled && ((window)->tile_mode == META_TILE_LEFT
 || (window)->tile_mode == META_TILE_RIGHT)) ||
      META_WINDOW_CORNER_TILED(window)((window)->tiled && ((window)->tile_mode == META_TILE_BOTTOM_RIGHT
 || (window)->tile_mode == META_TILE_BOTTOM_LEFT || (window
)->tile_mode == META_TILE_TOP_RIGHT || (window)->tile_mode
 == META_TILE_TOP_LEFT)) || 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;
      }
  }
2559}

2561/**
* 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
*/
2567static void
2568force_save_user_window_placement (MetaWindow *window)
2569{
meta_window_get_client_root_coords (window, &window->user_rect);
2571}

2573/**
* 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
*/
2580static void
2581save_user_window_placement (MetaWindow *window)
2582{
if (!(META_WINDOW_MAXIMIZED (window)((window)->maximized_horizontally && (window)->
maximized_vertically) || META_WINDOW_SIDE_TILED (window)((window)->tiled && ((window)->tile_mode == META_TILE_LEFT
 || (window)->tile_mode == META_TILE_RIGHT)) || 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;
}
  }
2600}

2602void
2603meta_window_maximize_internal (MetaWindow        *window,
                             MetaMaximizeFlags  directions,
                             MetaRectangle     *saved_rect)
2606{
/* 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)do { if (maximize_horizontally || maximize_vertically) ; else
 g_assertion_message_expr ("croma", "core/window.c", 2611, ((
const char*) (__func__)), "maximize_horizontally || maximize_vertically"
); } while (0);

meta_topicmeta_topic_real (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((void*)0))
  window->saved_rect = *saved_rect;
else
  meta_window_save_rect (window);

if (maximize_horizontally && maximize_vertically)
  window->saved_maximize = TRUE(!(0));

window->maximized_horizontally =
  window->maximized_horizontally || maximize_horizontally;
window->maximized_vertically =
  window->maximized_vertically   || maximize_vertically;

/* 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(!(0));

recalc_window_features (window);
set_allowed_actions_hint (window);
set_net_wm_state (window);
2644}

2646void
2647meta_window_maximize (MetaWindow        *window,
                    MetaMaximizeFlags  directions)
2649{
MetaRectangle *saved_rect = NULL((void*)0);
/* 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)do { if (maximize_horizontally || maximize_vertically) ; else
 g_assertion_message_expr ("croma", "core/window.c", 2655, ((
const char*) (__func__)), "maximize_horizontally || maximize_vertically"
); } while (0);

/* 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;
      }

    if (window->tile_mode != META_TILE_NONE)
      {
        saved_rect = &window->saved_rect;

        window->maximized_vertically = FALSE(0);
        window->tile_mode = META_TILE_NONE;
      }

    meta_window_maximize_internal (window,
                                   directions,
                                   saved_rect);

    /* move_resize with new maximization constraints
     */
    meta_window_queue(window, META_QUEUE_MOVE_RESIZE);

    meta_compositor_maximize_window (window->display->compositor, window);
  }
2700}

2702static void
2703unmaximize_window_before_freeing (MetaWindow        *window)
2704{
meta_topicmeta_topic_real (META_DEBUG_WINDOW_OPS,
            "Unmaximizing %s just before freeing\n",
            window->desc);

window->maximized_horizontally = FALSE(0);
window->maximized_vertically = FALSE(0);

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(0),
                             window->saved_rect.x,
                             window->saved_rect.y,
                             window->saved_rect.width,
                             window->saved_rect.height);
  }
2732}

2734void
2735meta_window_tile (MetaWindow *window)
2736{
/* Don't do anything if no tiling is requested */
if (window->tile_mode == META_TILE_NONE)
  return;

if(window->tile_mode == META_TILE_LEFT || window->tile_mode == META_TILE_RIGHT)
  meta_window_maximize_internal (window, META_MAXIMIZE_VERTICAL, NULL((void*)0));
else
  meta_window_save_rect(window);

  
window->tiled = TRUE(!(0));
/* move_resize with new tiling constraints
 */
meta_window_queue (window, META_QUEUE_MOVE_RESIZE);

set_allowed_actions_hint (window);
2753}

2755void
2756meta_window_untile (MetaWindow *window)
2757{
window->tiled = FALSE(0);

meta_window_unmaximize (window, META_MAXIMIZE_VERTICAL | META_MAXIMIZE_HORIZONTAL);
2761}

2763static gboolean
2764meta_window_can_tile_maximized (MetaWindow *window)
2765{
return window->has_maximize_func;
2767}

2769gboolean
2770meta_window_can_tile (MetaWindow *window)
2771{
const MetaXineramaScreenInfo *monitor;
MetaRectangle tile_area;

/*if (!META_WINDOW_ALLOWS_RESIZE (window))*/
if (!meta_window_can_tile_maximized (window) || window->shaded)
  return FALSE(0);

monitor = meta_screen_get_current_xinerama (window->screen);
meta_window_get_work_area_for_xinerama (window, monitor->number, &tile_area);

tile_area.width /= 2;

if (window->frame)
  {
    MetaFrameBorders borders;

    meta_frame_calc_borders (window->frame, &borders);

    tile_area.width  -= (borders.visible.left + borders.visible.right);
    tile_area.height -= (borders.visible.top + borders.visible.bottom);
  }

return tile_area.width >= window->size_hints.min_width &&
       tile_area.height >= window->size_hints.min_height;
2796}

2798void
2799meta_window_unmaximize (MetaWindow        *window,
                      MetaMaximizeFlags  directions)
2801{
/* 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)do { if (unmaximize_horizontally || unmaximize_vertically) ; else
 g_assertion_message_expr ("croma", "core/window.c", 2807, ((
const char*) (__func__)), "unmaximize_horizontally || unmaximize_vertically"
); } while (0);

if (unmaximize_horizontally && unmaximize_vertically)
  window->saved_maximize = FALSE(0);

window->tile_mode = META_TILE_NONE;
window->tiled = FALSE(0);

/* Only do something if the window isn't already maximized in the
 * given direction(s).
 */
MetaRectangle target_rect;

meta_topicmeta_topic_real (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);

meta_window_move_resize (window,
                         FALSE(0),
                         target_rect.x,
                         target_rect.y,
                         target_rect.width,
                         target_rect.height);

/* Make sure user_rect is current.
 */
force_save_user_window_placement (window);

/* 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. We have to do
 * it after the actual operation, as the window may have been moved
 * by constraints.
 */
if (meta_grab_op_is_moving (window->display->grab_op) &&
    window->display->grab_window == window)
  {
    window->display->grab_anchor_window_pos = window->user_rect;
  }

if (window->display->grab_wireframe_active)
  {
    window->display->grab_wireframe_rect = target_rect;
  }

recalc_window_features (window);
set_allowed_actions_hint (window);
set_net_wm_state (window);

meta_compositor_unmaximize_window (window->display->compositor, window);
2886}


2889void
2890meta_window_move_to_monitor(MetaWindow *window,
                          const MetaXineramaScreenInfo *from_monitor,
                          const MetaXineramaScreenInfo *to_monitor)
2893{
MetaRectangle target_rect;

if(META_WINDOW_TILED (window)(((window)->tiled && ((window)->tile_mode == META_TILE_LEFT
 || (window)->tile_mode == META_TILE_RIGHT)) || ((window)->
tiled && ((window)->tile_mode == META_TILE_BOTTOM_RIGHT
 || (window)->tile_mode == META_TILE_BOTTOM_LEFT || (window
)->tile_mode == META_TILE_TOP_RIGHT || (window)->tile_mode
 == META_TILE_TOP_LEFT))))
  {
    window->tile_monitor_number = to_monitor->number;

    /* Transform user_rect and saved_rect to the other monitor */
    meta_window_transform_to_monitor(&window->saved_rect,
                                   &from_monitor->rect,
                                   &to_monitor->rect);
    meta_window_transform_to_monitor(&window->user_rect,
                                   &from_monitor->rect,
                                   &to_monitor->rect);

    meta_window_tile(window);
    return;
  }

/* Normally, just transform the window itself */
meta_window_get_client_root_coords(window, &target_rect);

meta_window_transform_to_monitor(&target_rect,
                               &from_monitor->rect,
                               &to_monitor->rect);

meta_window_move_resize(window, TRUE(!(0)),
                        target_rect.x,
                        target_rect.y,
                        target_rect.width,
                        target_rect.height);
2924}

2926static void meta_window_transform_to_monitor(MetaRectangle *target_rect,
                                         const MetaRectangle *from_monitor,
                                         const MetaRectangle *to_monitor)
2929{
double horizontal_ratio;
double vertical_ratio;

horizontal_ratio = (double)to_monitor->width / from_monitor->width;
vertical_ratio = (double)to_monitor->height / from_monitor->height;

target_rect->x -= from_monitor->x;
target_rect->y -= from_monitor->y;

target_rect->width *= horizontal_ratio;
target_rect->height *= vertical_ratio;
target_rect->x *= horizontal_ratio;
target_rect->y *= vertical_ratio;

target_rect->x += to_monitor->x;
target_rect->y += to_monitor->y;

2947}



2951void
2952meta_window_make_above (MetaWindow  *window)
2953{
window->wm_state_above = TRUE(!(0));
meta_window_update_layer (window);
meta_window_raise (window);
set_net_wm_state (window);
2958}

2960void
2961meta_window_unmake_above (MetaWindow  *window)
2962{
window->wm_state_above = FALSE(0);
meta_window_raise (window);
meta_window_update_layer (window);
set_net_wm_state (window);
2967}

2969void
2970meta_window_make_fullscreen_internal (MetaWindow  *window)
2971{
if (!window->fullscreen)
  {
    meta_topicmeta_topic_real (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(!(0));
    window->tile_resized = FALSE(0);
    window->force_save_user_rect = FALSE(0);

    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_allowed_actions_hint (window);
    set_net_wm_state (window);
  }
3003}

3005void
3006meta_window_make_fullscreen (MetaWindow  *window)
3007{
if (!window->fullscreen)
  {
    meta_window_make_fullscreen_internal (window);
    /* move_resize with new constraints
     */
    meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
  }
3015}

3017void
3018meta_window_unmake_fullscreen (MetaWindow  *window)
3019{
if (window->fullscreen)
  {
    MetaRectangle target_rect;

    meta_topicmeta_topic_real (META_DEBUG_WINDOW_OPS,
                "Unfullscreening %s\n", window->desc);

    window->fullscreen = FALSE(0);

    if(!META_WINDOW_TILED (window)(((window)->tiled && ((window)->tile_mode == META_TILE_LEFT
 || (window)->tile_mode == META_TILE_RIGHT)) || ((window)->
tiled && ((window)->tile_mode == META_TILE_BOTTOM_RIGHT
 || (window)->tile_mode == META_TILE_BOTTOM_LEFT || (window
)->tile_mode == META_TILE_TOP_RIGHT || (window)->tile_mode
 == META_TILE_TOP_LEFT))))
      target_rect = window->saved_rect;
    else
      meta_window_get_current_tile_area(window, &target_rect);

    /* Window's size hints may have changed while maximized, making
     * saved_rect invalid.  #329152
     */
    ensure_size_hints_satisfied (&target_rect, &window->size_hints);

    /* Need to update window->has_resize_func before we move_resize()
     */
    recalc_window_features (window);
    set_net_wm_state (window);

    meta_window_move_resize (window,
                             FALSE(0),
                             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);
  }
3057}

3059void
3060meta_window_update_fullscreen_monitors (MetaWindow    *window,
                                      unsigned long  top,
                                      unsigned long  bottom,
                                      unsigned long  left,
                                      unsigned long  right)
3065{
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);
  }
3085}

3087void
3088meta_window_shade (MetaWindow  *window,
                 guint32      timestamp)
3090{
meta_topicmeta_topic_real (META_DEBUG_WINDOW_OPS,
            "Shading %s\n", window->desc);
if (!window->shaded)
  {
    window->shaded = TRUE(!(0));

    meta_window_queue(window, META_QUEUE_MOVE_RESIZE | META_QUEUE_CALC_SHOWING);

    set_allowed_actions_hint (window);

    /* After queuing the calc showing, since _focus flushes it,
     * and we need to focus the frame
     */
    meta_topicmeta_topic_real (META_DEBUG_FOCUS,
                "Re-focusing window %s after shading it\n",
                window->desc);
    meta_window_focus (window, timestamp);

    set_net_wm_state (window);
  }
3111}

3113void
3114meta_window_unshade (MetaWindow  *window,
                   guint32      timestamp)
3116{
meta_topicmeta_topic_real (META_DEBUG_WINDOW_OPS,
            "Unshading %s\n", window->desc);
if (window->shaded)
  {
    window->shaded = FALSE(0);
    meta_window_queue(window, META_QUEUE_MOVE_RESIZE | META_QUEUE_CALC_SHOWING);

    set_allowed_actions_hint (window);

    /* focus the window */
    meta_topicmeta_topic_real (META_DEBUG_FOCUS,
                "Focusing window %s after unshading it\n",
                window->desc);
    meta_window_focus (window, timestamp);

    set_net_wm_state (window);
  }
3134}

3136static gboolean
3137unminimize_func (MetaWindow *window,
               void       *data)
3139{
meta_window_unminimize (window);
return TRUE(!(0));
3142}

3144static void
3145unminimize_window_and_all_transient_parents (MetaWindow *window)
3146{
meta_window_unminimize (window);
meta_window_foreach_ancestor (window, unminimize_func, NULL((void*)0));
3149}

3151static void
3152window_activate (MetaWindow     *window,
               guint32         timestamp,
               MetaClientType  source_indication,
               MetaWorkspace  *workspace)
3156{
gboolean can_ignore_outdated_timestamps;
meta_topicmeta_topic_real (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(0) && source_indication != META_CLIENT_TYPE_PAGER));
if (XSERVER_TIME_IS_BEFORE (timestamp, window->display->last_user_time)( (timestamp) == 0 || (( (( (timestamp) < (window->display
->last_user_time) ) && ( (window->display->last_user_time
) - (timestamp) < ((guint32)-1)/2 )) || (( (timestamp) >
 (window->display->last_user_time) ) && ( (timestamp
) - (window->display->last_user_time) > ((guint32)-1
)/2 )) ) && (window->display->last_user_time) !=
 0) ) &&
    can_ignore_outdated_timestamps)
  {
    meta_topicmeta_topic_real (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((void*)0))
  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 == None0L &&
    !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 != None0L)
  {
    /* 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_topicmeta_topic_real (META_DEBUG_FOCUS,
            "Focusing window %s due to activation\n",
            window->desc);
meta_window_focus (window, timestamp);
3230}

3232/* This function exists since most of the functionality in window_activate
* is useful for Croma, but Croma shouldn't need to specify a client
* type for itself.  ;-)
*/
3236void
3237meta_window_activate (MetaWindow     *window,
                    guint32         timestamp)
3239{
/* 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*)0));
3245}

3247void
3248meta_window_activate_with_workspace (MetaWindow     *window,
                                   guint32         timestamp,
                                   MetaWorkspace  *workspace)
3251{
/* 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);
3257}

3259/* 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).
*/
3264static void
3265adjust_for_gravity (MetaWindow       *window,
                  MetaFrameBorders *borders,
                  gboolean          coords_assume_border,
                  int               gravity,
                  MetaRectangle    *rect)
3270{
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 (borders)
  {
    child_x = borders->visible.left;
    child_y = borders->visible.top;
    frame_width = child_x + rect->width + borders->visible.right;
    frame_height = child_y + rect->height + borders->visible.bottom;
  }
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 NorthWestGravity1:
    ref_x = rect->x;
    ref_y = rect->y;
    break;
  case NorthGravity2:
    ref_x = rect->x + rect->width / 2 + bw;
    ref_y = rect->y;
    break;
  case NorthEastGravity3:
    ref_x = rect->x + rect->width + bw * 2;
    ref_y = rect->y;
    break;
  case WestGravity4:
    ref_x = rect->x;
    ref_y = rect->y + rect->height / 2 + bw;
    break;
  case CenterGravity5:
    ref_x = rect->x + rect->width / 2 + bw;
    ref_y = rect->y + rect->height / 2 + bw;
    break;
  case EastGravity6:
    ref_x = rect->x + rect->width + bw * 2;
    ref_y = rect->y + rect->height / 2 + bw;
    break;
  case SouthWestGravity7:
    ref_x = rect->x;
    ref_y = rect->y + rect->height + bw * 2;
    break;
  case SouthGravity8:
    ref_x = rect->x + rect->width / 2 + bw;
    ref_y = rect->y + rect->height + bw * 2;
    break;
  case SouthEastGravity9:
    ref_x = rect->x + rect->width + bw * 2;
    ref_y = rect->y + rect->height + bw * 2;
    break;
  case StaticGravity10:
  default:
    ref_x = rect->x;
    ref_y = rect->y;
    break;
  }

switch (gravity)
  {
  case NorthWestGravity1:
    rect->x = ref_x + child_x;
    rect->y = ref_y + child_y;
    break;
  case NorthGravity2:
    rect->x = ref_x - frame_width / 2 + child_x;
    rect->y = ref_y + child_y;
    break;
  case NorthEastGravity3:
    rect->x = ref_x - frame_width + child_x;
    rect->y = ref_y + child_y;
    break;
  case WestGravity4:
    rect->x = ref_x + child_x;
    rect->y = ref_y - frame_height / 2 + child_y;
    break;
  case CenterGravity5:
    rect->x = ref_x - frame_width / 2 + child_x;
    rect->y = ref_y - frame_height / 2 + child_y;
    break;
  case EastGravity6:
    rect->x = ref_x - frame_width + child_x;
    rect->y = ref_y - frame_height / 2 + child_y;
    break;
  case SouthWestGravity7:
    rect->x = ref_x + child_x;
    rect->y = ref_y - frame_height + child_y;
    break;
  case SouthGravity8:
    rect->x = ref_x - frame_width / 2 + child_x;
    rect->y = ref_y - frame_height + child_y;
    break;
  case SouthEastGravity9:
    rect->x = ref_x - frame_width + child_x;
    rect->y = ref_y - frame_height + child_y;
    break;
  case StaticGravity10:
  default:
    rect->x = ref_x;
    rect->y = ref_y;
    break;
  }
3392}

3394static gboolean
3395static_gravity_works (MetaDisplay *display)
3396{
return display->static_gravity_works;
3398}

3400#ifdef HAVE_XSYNC
3401static void
3402send_sync_request (MetaWindow *window)
3403{
XSyncValue value;
XClientMessageEvent ev;

window->sync_request_serial++;

XSyncIntToValue (&value, window->sync_request_serial);

ev.type = ClientMessage33;
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);
ev.data.l[4] = 0;

/* 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, False0, 0, (XEvent*) &ev);

window->sync_request_time = g_get_real_time ();
3433}
3434#endif

3436static gboolean
3437move_attached_dialog (MetaWindow *window,
                    void       *data)
3439{
MetaWindow *parent = meta_window_get_transient_for (window);

if (window->type == META_WINDOW_MODAL_DIALOG && parent && parent != window)
  /* It ignores x,y for such a dialog */
  meta_window_move (window, FALSE(0), 0, 0);

return FALSE(0);
3447}

3449static void
3450meta_window_move_resize_internal (MetaWindow          *window,
                                MetaMoveResizeFlags  flags,
                                int                  gravity,
                                int                  root_x_nw,
                                int                  root_y_nw,
                                int                  w,
                                int                  h)
3457{
/* 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;
MetaFrameBorders borders;
gboolean need_move_client = FALSE(0);
gboolean need_move_frame = FALSE(0);
gboolean need_resize_client = FALSE(0);
gboolean need_resize_frame = FALSE(0);
int size_dx;
int size_dy;
gboolean frame_shape_changed = FALSE(0);
gboolean is_configure_request;
gboolean do_gravity_adjust;
gboolean is_user_action;
gboolean configure_frame_first;
gboolean use_static_gravity;
gboolean have_window_frame;
/* 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;

if (window->frame)
  have_window_frame = TRUE(!(0));
else
  have_window_frame = FALSE(0);

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))do { if (flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION
)) ; else g_assertion_message_expr ("croma", "core/window.c",
 3526, ((const char*) (__func__)), "flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION)"
); } while (0);

/* 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_topicmeta_topic_real (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 (have_window_frame)
  meta_frame_calc_borders (window->frame, &borders);

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_topicmeta_topic_real (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,
                        have_window_frame ? &borders : NULL((void*)0),
                        /* configure request coords assume
                         * the border width existed
                         */
                        is_configure_request,
                        gravity,
                        &new_rect);

    meta_topicmeta_topic_real (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,
                       have_window_frame ? &borders : NULL((void*)0),
                       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(!(0));

window->rect.width = w;
window->rect.height = h;

if (have_window_frame)
  {
    int frame_size_dx, frame_size_dy, new_w, new_h;

    new_w = window->rect.width + borders.total.left + borders.total.right;

    if (window->shaded)
      new_h = borders.total.top;
    else
      new_h = window->rect.height + borders.total.top + borders.total.bottom;

    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_topicmeta_topic_real (META_DEBUG_GEOMETRY,
                "Calculated frame size %dx%d\n",
                window->frame->rect.width,
                window->frame->rect.height);
  }

/* 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 (have_window_frame)
  {
    int new_x, new_y;
    int frame_pos_dx, frame_pos_dy;

    /* Compute new frame coords */
    new_x = root_x_nw - borders.total.left;
    new_y = root_y_nw - borders.total.top;

    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 = borders.total.left;
    new_y = borders.total.top;

    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(!(0));

        use_static_gravity = TRUE(!(0));
      }
    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(!(0));

        use_static_gravity = FALSE(0);
      }

    /* 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(!(0));

    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(0);
  }

/* If frame extents have changed, fill in other frame fields and
   change frame's extents property. */
if (have_window_frame &&
    (window->frame->child_x != borders.total.left ||
     window->frame->child_y != borders.total.top ||
     window->frame->right_width != borders.total.right ||
     window->frame->bottom_height != borders.total.bottom))
  {
    window->frame->child_x = borders.total.left;
    window->frame->child_y = borders.total.top;
    window->frame->right_width = borders.total.right;
    window->frame->bottom_height = borders.total.bottom;

    update_net_frame_extents (window);
  }

/* See ICCCM 4.1.5 for when to send ConfigureNotify */

need_configure_notify = FALSE(0);

/* 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(!(0));

/* 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(!(0));

/* MapRequest events with a PPosition or UPosition hint with a frame
 * are moved by croma 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, croma seems to send a
 * ConfigureNotify anyway due to the above code.)
 */
if (window->constructing && have_window_frame &&
    ((window->size_hints.flags & PPosition(1L << 2)) ||
     (window->size_hints.flags & USPosition(1L << 0))))
  need_configure_notify = TRUE(!(0));

/* 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, StaticGravity10);

if (configure_frame_first && have_window_frame)
  frame_shape_changed = 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(1<<4); /* must force to 0 */
if (need_move_client)
  mask |= (CWX(1<<0) | CWY(1<<1));
if (need_resize_client)
  mask |= (CWWidth(1<<2) | CWHeight(1<<3));

if (mask != 0)
  {
    {
      int newx, newy;
      meta_window_get_position (window, &newx, &newy);
      meta_topicmeta_topic_real (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(1<<4) ? "true" : "false",
                  need_move_client ? "true" : "false",
                  need_resize_client ? "true" : "false");
    }

    meta_error_trap_push (window->display);

3838#ifdef HAVE_XSYNC
    if (window->sync_request_counter != None0L &&
 window->display->grab_sync_request_alarm != None0L &&
        window->sync_request_time == 0)
{
 /* turn off updating */
 if (window->display->compositor)
   meta_compositor_set_updates (window->display->compositor, window, FALSE(0));

 send_sync_request (window);
}
3849#endif

    XConfigureWindow (window->display->xdisplay,
                      window->xwindow,
                      mask,
                      &values);

    meta_error_trap_pop (window->display, FALSE(0));
  }

if (!configure_frame_first && have_window_frame)
  frame_shape_changed = 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, NorthWestGravity1);

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_topicmeta_topic_real (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_topicmeta_topic_real (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
 */
if (frame_shape_changed && window->frame_bounds)
  {
    cairo_region_destroy (window->frame_bounds);
    window->frame_bounds = NULL((void*)0);
  }

if (meta_prefs_get_attach_modal_dialogs ())
  meta_window_foreach_transient (window, move_attached_dialog, NULL((void*)0));
3911}

3913void
3914meta_window_resize (MetaWindow  *window,
                  gboolean     user_op,
                  int          w,
                  int          h)
3918{
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,
                                  NorthWestGravity1,
                                  x, y, w, h);
3929}

3931void
3932meta_window_move (MetaWindow  *window,
                gboolean     user_op,
                int          root_x_nw,
                int          root_y_nw)
3936{
MetaMoveResizeFlags flags =
  (user_op ? META_IS_USER_ACTION : 0) | META_IS_MOVE_ACTION;
meta_window_move_resize_internal (window,
                                  flags,
                                  NorthWestGravity1,
                                  root_x_nw, root_y_nw,
                                  window->rect.width,
                                  window->rect.height);
3945}

3947void
3948meta_window_move_resize (MetaWindow  *window,
                       gboolean     user_op,
                       int          root_x_nw,
                       int          root_y_nw,
                       int          w,
                       int          h)
3954{
MetaMoveResizeFlags flags =
  (user_op ? META_IS_USER_ACTION : 0) |
  META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION;
meta_window_move_resize_internal (window,
                                  flags,
                                  NorthWestGravity1,
                                  root_x_nw, root_y_nw,
                                  w, h);
3963}

3965void
3966meta_window_resize_with_gravity (MetaWindow *window,
                               gboolean     user_op,
                               int          w,
                               int          h,
                               int          gravity)
3971{
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);
3982}

3984static void
3985meta_window_move_resize_now (MetaWindow  *window)
3986{
/* 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(0),
                         window->user_rect.x,
                         window->user_rect.y,
                         window->user_rect.width,
                         window->user_rect.height);
3996}

3998static gboolean
3999idle_move_resize (gpointer data)
4000{
GSList *tmp;
GSList *copy;
guint queue_index = GPOINTER_TO_INT (data)((gint) (glong) (data));

meta_topicmeta_topic_real (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((void*)0);
queue_idle[queue_index] = 0;

destroying_windows_disallowed += 1;

tmp = copy;
while (tmp != NULL((void*)0))
  {
    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(0);
4036}

4038void
4039meta_window_get_position (MetaWindow  *window,
                        int         *x,
                        int         *y)
4042{
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;
  }
4057}

4059void
4060meta_window_get_client_root_coords (MetaWindow    *window,
                                  MetaRectangle *rect)
4062{
meta_window_get_position (window, &rect->x, &rect->y);
rect->width  = window->rect.width;
rect->height = window->rect.height;
4066}

4068void
4069meta_window_get_gravity_position (MetaWindow  *window,
                                int          gravity,
                                int         *root_x,
                                int         *root_y)
4073{
MetaRectangle frame_extents;
int w, h;
int x, y;

w = window->rect.width;
h = window->rect.height;

if (gravity == StaticGravity10)
  {
    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((void*)0))
      frame_extents = window->rect;
    else
      frame_extents = window->frame->rect;
  }

x = frame_extents.x;
y = frame_extents.y;

switch (gravity)
  {
  case NorthGravity2:
  case CenterGravity5:
  case SouthGravity8:
    /* Find center of frame. */
    x += frame_extents.width / 2;
    /* Center client window on that point. */
    x -= w / 2;
    break;

  case SouthEastGravity9:
  case EastGravity6:
  case NorthEastGravity3:
    /* 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 WestGravity4:
  case CenterGravity5:
  case EastGravity6:
    /* Find center of frame. */
    y += frame_extents.height / 2;
    /* Center client window there. */
    y -= h / 2;
    break;
  case SouthWestGravity7:
  case SouthGravity8:
  case SouthEastGravity9:
    /* 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;
4150}

4152void
4153meta_window_get_geometry (MetaWindow  *window,
                        int         *x,
                        int         *y,
                        int         *width,
                        int         *height)
4158{
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;
4167}

4169/**
* meta_window_get_input_rect:
* @window: a #MetaWindow
* @rect: (out): pointer to an allocated #MetaRectangle
*
* Gets the rectangle that bounds @window that is responsive to mouse events.
* This includes decorations - the visible portion of its border - and (if
* present) any invisible area that we make make responsive to mouse clicks in
* order to allow convenient border dragging.
*/
4179void
4180meta_window_get_input_rect (const MetaWindow *window,
                          MetaRectangle    *rect)
4182{
if (window->frame)
  *rect = window->frame->rect;
else
  *rect = window->rect;
4187}

4189/**
* meta_window_get_outer_rect:
* @window: a #MetaWindow
* @rect: (out): pointer to an allocated #MetaRectangle
*
* Gets the rectangle that bounds @window that is responsive to mouse events.
* This includes only what is visible; it doesn't include any extra reactive
* area we add to the edges of windows.
*/
4198void
4199meta_window_get_outer_rect (const MetaWindow *window,
                          MetaRectangle    *rect)
4201{
if (window->frame)
  {
    MetaFrameBorders borders;
    *rect = window->frame->rect;
    meta_frame_calc_borders (window->frame, &borders);

    rect->x += borders.invisible.left;
    rect->y += borders.invisible.top;
    rect->width -= borders.invisible.left + borders.invisible.right;
    rect->height -= borders.invisible.top + borders.invisible.bottom;
  }
else
  {
    *rect = window->rect;

    if (window->has_custom_frame_extents)
      {
        const CtkBorder *extents = &window->custom_frame_extents;
        rect->x += extents->left;
        rect->y += extents->top;
        rect->width -= extents->left + extents->right;
        rect->height -= extents->top + extents->bottom;
      }
  }
4226}

4228void
4229meta_window_get_xor_rect (MetaWindow          *window,
                        const MetaRectangle *grab_wireframe_rect,
                        MetaRectangle       *xor_rect)
4232{
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;
4246}

4248/* Figure out the numbers that show up in the
* resize popup when in reduced resources mode.
*/
4251static void
4252meta_window_get_wireframe_geometry (MetaWindow    *window,
                                  int           *width,
                                  int           *height)
4255{
if (!window->display->grab_wireframe_active)
  return;

if ((width == NULL((void*)0)) || (height == NULL((void*)0)))
  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;
4277}

4279/* XXX META_EFFECT_ALT_TAB, well, this and others */
4280void
4281meta_window_begin_wireframe (MetaWindow *window)
4282{

MetaRectangle new_xor;
int display_width, display_height;

display_width = 0;
display_height = 0;

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;
4303}

4305void
4306meta_window_update_wireframe (MetaWindow *window,
                            int         x,
                            int         y,
                            int         width,
                            int         height)
4311{

MetaRectangle new_xor;
int display_width, display_height;

display_width = 0;
display_height = 0;

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;
4337}

4339void
4340meta_window_end_wireframe (MetaWindow *window)
4341{
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);
4346}

4348const char*
4349meta_window_get_startup_id (MetaWindow *window)
4350{
if (window->startup_id == NULL((void*)0))
  {
    MetaGroup *group;

    group = meta_window_get_group (window);

    if (group != NULL((void*)0))
      return meta_group_get_startup_id (group);
  }

return window->startup_id;
4362}

4364static MetaWindow*
4365get_modal_transient (MetaWindow *window)
4366{
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((void*)0))
  {
    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((void*)0);

return modal_transient;
4400}

4402/* XXX META_EFFECT_FOCUS */
4403void
4404meta_window_focus (MetaWindow  *window,
                 guint32      timestamp)
4406{
MetaWindow *modal_transient;

meta_topicmeta_topic_real (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_topicmeta_topic_real (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((void*)0) &&
    !modal_transient->unmanaging)
  {
    meta_topicmeta_topic_real (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_topicmeta_topic_real (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)))
  {
    meta_topicmeta_topic_real (META_DEBUG_FOCUS,
                "Focusing frame of %s\n", window->desc);
    meta_display_set_input_focus_window (window->display,
                                         window,
                                         TRUE(!(0)),
                                         timestamp);
  }
else
  {
    if (window->input)
      {
        meta_topicmeta_topic_real (META_DEBUG_FOCUS,
                    "Setting input focus on %s since input = true\n",
                    window->desc);
        meta_display_set_input_focus_window (window->display,
                                             window,
                                             FALSE(0),
                                             timestamp);
      }

    if (window->take_focus)
      {
        meta_topicmeta_topic_real (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((void*)0), NULL((void*)0));
4492}

4494static void
4495meta_window_change_workspace_without_transients (MetaWindow    *window,
                                               MetaWorkspace *workspace)
4497{
meta_verbosemeta_verbose_real ("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);
  }
4514}

4516static gboolean
4517change_workspace_foreach (MetaWindow *window,
                        void       *data)
4519{
meta_window_change_workspace_without_transients (window, data);
return TRUE(!(0));
4522}

4524void
4525meta_window_change_workspace (MetaWindow    *window,
                            MetaWorkspace *workspace)
4527{
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);
4534}

4536static void
4537window_stick_impl (MetaWindow  *window)
4538{
GList *tmp;

meta_verbosemeta_verbose_real ("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(!(0));

/* We do, however, change the MRU lists of all the workspaces
 */
tmp = window->screen->workspaces;
while (tmp)
  {
    MetaWorkspace *workspace;

    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);
4571}

4573static void
4574window_unstick_impl (MetaWindow  *window)
4575{
GList *tmp;

if (!window->on_all_workspaces)
  return;

/* Revert to window->workspaces */

window->on_all_workspaces = FALSE(0);

/* Remove window from MRU lists that it doesn't belong in */
tmp = window->screen->workspaces;
while (tmp)
  {
    MetaWorkspace *workspace;

    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);
4609}

4611static gboolean
4612stick_foreach_func (MetaWindow *window,
                  void       *data)
4614{
gboolean stick;

stick = *(gboolean*)data;
if (stick)
  window_stick_impl (window);
else
  window_unstick_impl (window);
return TRUE(!(0));
4623}

4625void
4626meta_window_stick (MetaWindow  *window)
4627{
gboolean stick = TRUE(!(0));
window_stick_impl (window);
meta_window_foreach_transient (window,
                               stick_foreach_func,
                               &stick);
4633}

4635void
4636meta_window_unstick (MetaWindow  *window)
4637{
gboolean stick = FALSE(0);
window_unstick_impl (window);
meta_window_foreach_transient (window,
                               stick_foreach_func,
                               &stick);
4643}

4645unsigned long
4646meta_window_get_net_wm_desktop (MetaWindow *window)
4647{
if (window->on_all_workspaces)
  return 0xFFFFFFFF;
else
  return meta_workspace_index (window->workspace);
4652}

4654static void
4655update_net_frame_extents (MetaWindow *window)
4656{
unsigned long data[4] = { 0, 0, 0, 0 };

if (window->frame)
  {
    MetaFrameBorders borders;

    meta_frame_calc_borders (window->frame, &borders);
    /* Left */
    data[0] = borders.visible.left;
    /* Right */
    data[1] = borders.visible.right;
    /* Top */
    data[2] = borders.visible.top;
    /* Bottom */
    data[3] = borders.visible.bottom;
  }

meta_topicmeta_topic_real (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((Atom) 6),
                 32, PropModeReplace0, (guchar*) data, 4);
meta_error_trap_pop (window->display, FALSE(0));
4685}

4687void
4688meta_window_set_current_workspace_hint (MetaWindow *window)
4689{
/* 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((void*)0))
  {
    /* this happens when unmanaging windows */
    return;
  }

data[0] = meta_window_get_net_wm_desktop (window);

meta_verbosemeta_verbose_real ("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((Atom) 6),
                 32, PropModeReplace0, (guchar*) data, 1);
meta_error_trap_pop (window->display, FALSE(0));
4712}

4714static gboolean
4715find_root_ancestor (MetaWindow *window,
                  void       *data)
4717{
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(!(0));
4727}

4729MetaWindow *
4730meta_window_find_root_ancestor (MetaWindow *window)
4731{
MetaWindow *ancestor;
ancestor = window;
meta_window_foreach_ancestor (window, find_root_ancestor, &ancestor);
return ancestor;
4736}

4738void
4739meta_window_raise (MetaWindow  *window)
4740{
MetaWindow *ancestor;
ancestor = meta_window_find_root_ancestor (window);

meta_topicmeta_topic_real (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);
4776}

4778void
4779meta_window_lower (MetaWindow  *window)
4780{
meta_topicmeta_topic_real (META_DEBUG_WINDOW_OPS,
            "Lowering window %s\n", window->desc);

meta_stack_lower (window->screen->stack, window);
4785}

4787void
4788meta_window_send_icccm_message (MetaWindow *window,
                              Atom        atom,
                              guint32     timestamp)
4791{
/* 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 = ClientMessage33;
  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, False0, 0, (XEvent*) &ev);
  meta_error_trap_pop (window->display, FALSE(0));
4821}

4823void
4824meta_window_move_resize_request (MetaWindow *window,
                               guint       value_mask,
                               int         gravity,
                               int         new_x,
                               int         new_y,
                               int         new_width,
                               int         new_height)
4831{
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(0);
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(!(0));
        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(0);

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(1L << 2)) ||
             /* USPosition is just stale if window is placed;
              * no --geometry involved here.
              */
             ((window->size_hints.flags & USPosition(1L << 0)) &&
              !window->placed))
      allow_position_change = TRUE(!(0));
  }
else
  {
    allow_position_change = TRUE(!(0));
  }

if (in_grab_op)
  allow_position_change = FALSE(0);

if (allow_position_change)
  {
    if (value_mask & CWX(1<<0))
      x = new_x;
    if (value_mask & CWY(1<<1))
      y = new_y;
    if (value_mask & (CWX(1<<0) | CWY(1<<1)))
      {
        /* Once manually positioned, windows shouldn't be placed
         * by the window manager.
         */
        window->placed = TRUE(!(0));
      }
  }
else
  {
    meta_topicmeta_topic_real (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(1L << 2),
  window->size_hints.flags & USPosition(1L << 0),
  window->type);
  }

width = window->rect.width;
height = window->rect.height;
if (!in_grab_op)
  {
    if (value_mask & CWWidth(1<<2))
      width = new_width;

    if (value_mask & CWHeight(1<<3))
      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(1<<0) | CWY(1<<1)))
  flags |= META_IS_MOVE_ACTION;
if (value_mask & (CWWidth(1<<2) | CWHeight(1<<3)))
  flags |= META_IS_RESIZE_ACTION;

if (flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION))
 {
    const MetaXineramaScreenInfo *xinerama_info;
    MetaRectangle rect;

    rect.x = x;
    rect.y = y;
    rect.width = width;
    rect.height = height;

    xinerama_info = meta_screen_get_xinerama_for_rect (window->screen, &rect);

    /* Workaround braindead legacy apps that don't know how to
     * fullscreen themselves properly - don't get fooled by
     * windows which are client decorated; that's not the same
     * as fullscreen, even if there are no struts making the
     * workarea smaller than the monitor.
     */
    if (meta_prefs_get_force_fullscreen() &&
        (window->decorated || !meta_window_is_client_decorated (window)) &&
        meta_rectangle_equal (&rect, &xinerama_info->rect) &&
        window->has_fullscreen_func &&
        !window->fullscreen)
      {
        g_warning ("Treating resize request of legacy application %s as a "
                   "fullscreen request", window->desc);
        meta_window_make_fullscreen_internal (window);
      }
    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);
5015}

5017gboolean
5018meta_window_configure_request (MetaWindow *window,
                             XEvent     *event)
5020{
/* 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(1<<4))
  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(1<<6))
  {
    MetaWindow *active_window;
    active_window = window->display->expected_focus_window;
    if (meta_prefs_get_disable_workarounds () ||
        !meta_prefs_get_raise_on_click ())
      {
        meta_topicmeta_topic_real (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) &&
             !meta_window_same_client (window, active_window) &&
             XSERVER_TIME_IS_BEFORE (window->net_wm_user_time,( (window->net_wm_user_time) == 0 || (( (( (window->net_wm_user_time
) < (active_window->net_wm_user_time) ) && ( (active_window
->net_wm_user_time) - (window->net_wm_user_time) < (
(guint32)-1)/2 )) || (( (window->net_wm_user_time) > (active_window
->net_wm_user_time) ) && ( (window->net_wm_user_time
) - (active_window->net_wm_user_time) > ((guint32)-1)/2
 )) ) && (active_window->net_wm_user_time) != 0) )
                                     active_window->net_wm_user_time)( (window->net_wm_user_time) == 0 || (( (( (window->net_wm_user_time
) < (active_window->net_wm_user_time) ) && ( (active_window
->net_wm_user_time) - (window->net_wm_user_time) < (
(guint32)-1)/2 )) || (( (window->net_wm_user_time) > (active_window
->net_wm_user_time) ) && ( (window->net_wm_user_time
) - (active_window->net_wm_user_time) > ((guint32)-1)/2
 )) ) && (active_window->net_wm_user_time) != 0) ))
      {
        meta_topicmeta_topic_real (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 == Above0)
          meta_window_set_demands_attention(window);
      }
    else
      {
        switch (event->xconfigurerequest.detail)
          {
          case Above0:
            meta_window_raise (window);
            break;
          case Below1:
            meta_window_lower (window);
            break;
          case TopIf2:
          case BottomIf3:
          case Opposite4:
            break;
          }
      }
  }

return TRUE(!(0));
5100}

5102gboolean
5103meta_window_property_notify (MetaWindow *window,
                           XEvent     *event)
5105{
return process_property_notify (window, &event->xproperty);
5107}

5109#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT0      0
5110#define _NET_WM_MOVERESIZE_SIZE_TOP1          1
5111#define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT2     2
5112#define _NET_WM_MOVERESIZE_SIZE_RIGHT3        3
5113#define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT4  4
5114#define _NET_WM_MOVERESIZE_SIZE_BOTTOM5       5
5115#define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT6   6
5116#define _NET_WM_MOVERESIZE_SIZE_LEFT7         7
5117#define _NET_WM_MOVERESIZE_MOVE8              8
5118#define _NET_WM_MOVERESIZE_SIZE_KEYBOARD9     9
5119#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD10    10
5120#define _NET_WM_MOVERESIZE_CANCEL11           11

5122gboolean
5123meta_window_client_message (MetaWindow *window,
                          XEvent     *event)
5125{
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(!(0));
  }
else if (event->xclient.message_type ==
         display->atom__NET_WM_DESKTOP)
  {
    int space;
    MetaWorkspace *workspace;

    space = event->xclient.data.l[0];

    meta_verbosemeta_verbose_real ("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_verbosemeta_verbose_real ("No such workspace %d for screen\n", space);
      }

    meta_verbosemeta_verbose_real ("Window %s now on_all_workspaces = %d\n",
                  window->desc, window->on_all_workspaces);

    return TRUE(!(0));
  }
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 (display);
        str1 = XGetAtomName (display->xdisplay, first);
        if (meta_error_trap_pop_with_return (display, TRUE(!(0))) != Success0)
          str1 = NULL((void*)0);

        meta_error_trap_push (display);
        str2 = XGetAtomName (display->xdisplay, second);
        if (meta_error_trap_pop_with_return (display, TRUE(!(0))) != Success0)
          str2 = NULL((void*)0);

        meta_verbosemeta_verbose_real ("Request to change _NET_WM_STATE action %lu atom1: %s atom2: %s\n",
                      action,
                      str1 ? str1 : "(unknown)",
                      str2 ? str2 : "(unknown)");

        meta_XFree (str1)do { if ((str1)) XFree ((str1)); } while (0);
        meta_XFree (str2)do { if ((str2)) XFree ((str2)); } while (0);
      }

    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_ADD1 ||
                 (action == _NET_WM_STATE_TOGGLE2 && !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_ADD1 ||
                           (action == _NET_WM_STATE_TOGGLE2 && !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_ADD1 ||
               (action == _NET_WM_STATE_TOGGLE2 &&
                !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_ADD1 ||
               (action == _NET_WM_STATE_TOGGLE2 &&
                !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_ADD1) ||
          (action == _NET_WM_STATE_TOGGLE2 && !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_ADD1) ||
          (action == _NET_WM_STATE_TOGGLE2 && !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_ADD1) ||
          (action == _NET_WM_STATE_TOGGLE2 && !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_ADD1) ||
          (action == _NET_WM_STATE_TOGGLE2 && !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_ADD1) ||
          (action == _NET_WM_STATE_TOGGLE2 && !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_ADD1) ||
            (action == _NET_WM_STATE_TOGGLE2 && !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_ADD1) ||
            (action == _NET_WM_STATE_TOGGLE2 && !window->on_all_workspaces))
          meta_window_stick (window);
        else
          meta_window_unstick (window);
      }

    return TRUE(!(0));
  }
else if (event->xclient.message_type ==
         display->atom_WM_CHANGE_STATE)
  {
    meta_verbosemeta_verbose_real ("WM_CHANGE_STATE client message, state: %ld\n",
                  event->xclient.data.l[0]);
    if (event->xclient.data.l[0] == IconicState3)
      meta_window_minimize (window);

    return TRUE(!(0));
  }
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(!(0));

    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_topicmeta_topic_real (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_TOPLEFT0:
        op = META_GRAB_OP_RESIZING_NW;
        break;
      case _NET_WM_MOVERESIZE_SIZE_TOP1:
        op = META_GRAB_OP_RESIZING_N;
        break;
      case _NET_WM_MOVERESIZE_SIZE_TOPRIGHT2:
        op = META_GRAB_OP_RESIZING_NE;
        break;
      case _NET_WM_MOVERESIZE_SIZE_RIGHT3:
        op = META_GRAB_OP_RESIZING_E;
        break;
      case _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT4:
        op = META_GRAB_OP_RESIZING_SE;
        break;
      case _NET_WM_MOVERESIZE_SIZE_BOTTOM5:
        op = META_GRAB_OP_RESIZING_S;
        break;
      case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT6:
        op = META_GRAB_OP_RESIZING_SW;
        break;
      case _NET_WM_MOVERESIZE_SIZE_LEFT7:
        op = META_GRAB_OP_RESIZING_W;
        break;
      case _NET_WM_MOVERESIZE_MOVE8:
        op = META_GRAB_OP_MOVING;
        break;
      case _NET_WM_MOVERESIZE_SIZE_KEYBOARD9:
        op = META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN;
        break;
      case _NET_WM_MOVERESIZE_MOVE_KEYBOARD10:
        op = META_GRAB_OP_KEYBOARD_MOVING;
        break;
      case _NET_WM_MOVERESIZE_CANCEL11:
        /* handled below */
        break;
      default:
        break;
      }

    if (action == _NET_WM_MOVERESIZE_CANCEL11)
      {
        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(!(0)));

            if (mask & Button1Mask(1<<8))
              button = 1;
            else if (mask & Button2Mask(1<<9))
              button = 2;
            else if (mask & Button3Mask(1<<10))
              button = 3;
            else
              button = 0;
          }

        if (button != 0)
          {
            meta_topicmeta_topic_real (META_DEBUG_WINDOW_OPS,
                        "Beginning move/resize with button = %d\n", button);
            meta_display_begin_grab_op (window->display,
                                        window->screen,
                                        window,
                                        op,
                                        FALSE(0),
                                        frame_action,
                                        button, 0,
                                        timestamp,
                                        x_root,
                                        y_root);
          }
      }

    return TRUE(!(0));
  }
else if (event->xclient.message_type ==
         display->atom__NET_MOVERESIZE_WINDOW)
  {
    int gravity;
    guint value_mask;

    gravity = (event->xclient.data.l[0] & 0xff);
    value_mask = (event->xclient.data.l[0] & 0xf00) >> 8;

    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_verbosemeta_verbose_real ("_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((void*)0));
    return TRUE(!(0));
  }
else if (event->xclient.message_type ==
         display->atom__NET_WM_FULLSCREEN_MONITORS)
  {
    gulong top, bottom, left, right;

    meta_verbosemeta_verbose_real ("_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);
  }
else if (event->xclient.message_type ==
         display->atom__CTK_SHOW_WINDOW_MENU)
  {
    gulong x_root, y_root;
    guint32 timestamp;
    int button;

    if (meta_prefs_get_raise_on_click ())
      meta_window_raise (window);

    timestamp = meta_display_get_current_time_roundtrip (display);
    x_root = event->xclient.data.l[1];
    y_root = event->xclient.data.l[2];
    button = 3;

    meta_window_show_menu (window,
                           x_root,
                           y_root,
                           button,
                           timestamp);
  }

return FALSE(0);
5609}

5611static void
5612meta_window_appears_focused_changed (MetaWindow *window)
5613{
set_net_wm_state (window);

if (window->frame)
  meta_frame_queue_draw (window->frame);
5618}

5620static void
5621check_ancestor_focus_appearance (MetaWindow *window)
5622{
MetaWindow *parent = meta_window_get_transient_for (window);

if (!meta_prefs_get_attach_modal_dialogs ())
  return;

if (window->type != META_WINDOW_MODAL_DIALOG || !parent || parent == window)
  return;

if (parent->frame)
  meta_frame_queue_draw (parent->frame);

check_ancestor_focus_appearance (parent);
5635}

5637gboolean
5638meta_window_notify_focus (MetaWindow *window,
                        XEvent     *event)
5640{
/* 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_topicmeta_topic_real (META_DEBUG_FOCUS,
            "Focus %s event received on %s 0x%lx (%s) "
            "mode %s detail %s\n",
            event->type == FocusIn9 ? "in" :
            event->type == FocusOut10 ? "out" :
            event->type == UnmapNotify18 ? "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 != UnmapNotify18 ?
            meta_event_mode_to_string (event->xfocus.mode) : "n/a",
            event->type != UnmapNotify18 ?
            meta_event_detail_to_string (event->xfocus.detail) : "n/a");

/* FIXME our pointer tracking is broken; see how
 * ctk+/cdk/x11/cdkevents-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 croma'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 == FocusIn9 ||
     event->type == FocusOut10) &&
    (event->xfocus.mode == NotifyGrab1 ||
     event->xfocus.mode == NotifyUngrab2 ||
     /* From WindowMaker, ignore all funky pointer root events */
     event->xfocus.detail > NotifyNonlinearVirtual4))
  {
    meta_topicmeta_topic_real (META_DEBUG_FOCUS,
                "Ignoring focus event generated by a grab or other weirdness\n");
    return TRUE(!(0));
  }

if (event->type == FocusIn9)
  {
    if (window != window->display->focus_window)
      {
        meta_topicmeta_topic_real (META_DEBUG_FOCUS,
                    "* Focus --> %s\n", window->desc);
        window->display->focus_window = window;
        window->has_focus = TRUE(!(0));
        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)do { if (link) ; else g_assertion_message_expr ("croma", "core/window.c"
, 5734, ((const char*) (__func__)), "link"); } while (0);

            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);
          }

        meta_window_appears_focused_changed (window);

        meta_error_trap_push (window->display);
        XInstallColormap (window->display->xdisplay,
                          window->colormap);
        meta_error_trap_pop (window->display, FALSE(0));

        /* 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);

        /* parent window become active. */
        check_ancestor_focus_appearance (window);
      }
  }
else if (event->type == FocusOut10 ||
         event->type == UnmapNotify18)
  {
    if (event->type == FocusOut10 &&
        event->xfocus.detail == NotifyInferior2)
      {
        /* This event means the client moved focus to a subwindow */
        meta_topicmeta_topic_real (META_DEBUG_FOCUS,
                    "Ignoring focus out on %s with NotifyInferior\n",
                    window->desc);
        return TRUE(!(0));
      }

    if (window == window->display->focus_window)
      {
        meta_topicmeta_topic_real (META_DEBUG_FOCUS,
                    "%s is now the previous focus window due to being focused out or unmapped\n",
                    window->desc);

        meta_topicmeta_topic_real (META_DEBUG_FOCUS,
                    "* Focus --> NULL (was %s)\n", window->desc);

        window->display->focus_window = NULL((void*)0);
        window->has_focus = FALSE(0);

        /* parent window become active. */
        check_ancestor_focus_appearance (window);

        meta_window_appears_focused_changed (window);

        meta_compositor_set_active_window (window->display->compositor,
                                           window->screen, NULL((void*)0));

        meta_error_trap_push (window->display);
        XUninstallColormap (window->display->xdisplay,
                            window->colormap);
        meta_error_trap_pop (window->display, FALSE(0));

        /* 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(0);
5829}

5831static gboolean
5832process_property_notify (MetaWindow     *window,
                       XPropertyEvent *event)
5834{
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_verbosemeta_verbose_real ("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_from_xwindow (window, xid, event->atom, FALSE(0));

return TRUE(!(0));
5856}

5858static void
5859send_configure_notify (MetaWindow *window)
5860{
XEvent event;

/* from twm */

event.type = ConfigureNotify22;
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)
      {
        MetaFrameBorders borders;
        /* We reparent the client window and put it to the position
         * where the visible top-left of the frame window currently is.
         */

        meta_frame_calc_borders (window->frame, &borders);

        event.xconfigure.x = window->frame->rect.x + borders.invisible.left;
        event.xconfigure.y = window->frame->rect.y + borders.invisible.top;
      }
    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 = None0L; /* FIXME */
event.xconfigure.override_redirect = False0;

meta_topicmeta_topic_real (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,
            False0, StructureNotifyMask(1L<<17), &event);
meta_error_trap_pop (window->display, FALSE(0));
5909}

5911gboolean
5912meta_window_get_icon_geometry (MetaWindow    *window,
                             MetaRectangle *rect)
5914{
gulong *geometry = NULL((void*)0);
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_verbosemeta_verbose_real ("_NET_WM_ICON_GEOMETRY on %s has %d values instead of 4\n",
                      window->desc, nitems);
        meta_XFree (geometry)do { if ((geometry)) XFree ((geometry)); } while (0);
        return FALSE(0);
      }

    if (rect)
      {
        rect->x = geometry[0];
        rect->y = geometry[1];
        rect->width = geometry[2];
        rect->height = geometry[3];
      }

    meta_XFree (geometry)do { if ((geometry)) XFree ((geometry)); } while (0);

    return TRUE(!(0));
  }

return FALSE(0);
5945}

5947static Window
5948read_client_leader (MetaDisplay *display,
                  Window       xwindow)
5950{
Window retval = None0L;

meta_prop_get_window (display, xwindow,
                      display->atom_WM_CLIENT_LEADER,
                      &retval);

return retval;
5958}

5960typedef struct
5961{
Window leader;
5963} ClientLeaderData;

5965static gboolean
5966find_client_leader_func (MetaWindow *ancestor,
                       void       *data)
5968{
ClientLeaderData *d;

d = data;

d->leader = read_client_leader (ancestor->display,
                                ancestor->xwindow);

/* keep going if no client leader found */
return d->leader == None0L;
5978}

5980static void
5981update_sm_hints (MetaWindow *window)
5982{
Window leader;

window->xclient_leader = None0L;
window->sm_client_id = NULL((void*)0);

/* 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 == None0L)
  {
    ClientLeaderData d;
    d.leader = None0L;
    meta_window_foreach_ancestor (window, find_client_leader_func,
                                  &d);
    leader = d.leader;
  }

if (leader != None0L)
  {
    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)g_strdup_inline (str);
        meta_XFree (str)do { if ((str)) XFree ((str)); } while (0);
      }
  }
else
  {
    meta_verbosemeta_verbose_real ("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((void*)0);
        if (meta_prop_get_latin1_string (window->display, window->xwindow,
                                         window->display->atom_SM_CLIENT_ID,
                                         &str))
          {
            if (window->sm_client_id == NULL((void*)0)) /* 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")dgettext ("croma", "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)g_strdup_inline (str);
            meta_XFree (str)do { if ((str)) XFree ((str)); } while (0);
          }
      }
  }

meta_verbosemeta_verbose_real ("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");
6045}

6047void
6048meta_window_update_role (MetaWindow *window)
6049{
char *str;

if (window->role)
  g_free (window->role);
window->role = NULL((void*)0);

if (meta_prop_get_latin1_string (window->display, window->xwindow,
                                 window->display->atom_WM_WINDOW_ROLE,
                                 &str))
  {
    window->role = g_strdup (str)g_strdup_inline (str);
    meta_XFree (str)do { if ((str)) XFree ((str)); } while (0);
  }

meta_verbosemeta_verbose_real ("Updated role of %s to '%s'\n",
              window->desc, window->role ? window->role : "null");
6066}

6068void
6069meta_window_update_net_wm_type (MetaWindow *window)
6070{
int n_atoms;
Atom *atoms;
int i;

window->type_atom = None0L;
n_atoms = 0;
atoms = NULL((void*)0);

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)do { if ((atoms)) XFree ((atoms)); } while (0);

if (meta_is_verbose ())
  {
    char *str;

    str = NULL((void*)0);
    if (window->type_atom != None0L)
      {
        meta_error_trap_push (window->display);
        str = XGetAtomName (window->display->xdisplay, window->type_atom);
        meta_error_trap_pop (window->display, TRUE(!(0)));
      }

    meta_verbosemeta_verbose_real ("Window %s type atom %s\n", window->desc,
                  str ? str : "(none)");

    if (str)
      meta_XFree (str)do { if ((str)) XFree ((str)); } while (0);
  }

meta_window_recalc_window_type (window);
6127}

6129static void
6130redraw_icon (MetaWindow *window)
6131{
/* 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);
6137}

6139void
6140meta_window_update_icon_now (MetaWindow *window)
6141{
GdkPixbuf *icon;
GdkPixbuf *mini_icon;

icon = NULL((void*)0);
mini_icon = NULL((void*)0);

int icon_size = meta_prefs_get_icon_size();

if (meta_read_icons (window->screen,
                     window->xwindow,
                     &window->icon_cache,
                     window->wm_hints_pixmap,
                     window->wm_hints_mask,
                     &icon,
                     icon_size, /* width  */
                     icon_size, /* height */
                     &mini_icon,
                     META_MINI_ICON_WIDTH16,
                     META_MINI_ICON_HEIGHT16))
  {
    if (window->icon)
      g_object_unref (G_OBJECT (window->icon)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->icon)), (((GType) ((20) << (2)))))))));

    if (window->mini_icon)
      g_object_unref (G_OBJECT (window->mini_icon)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->mini_icon)), (((GType) ((20) << (2)))))
))));

    window->icon = icon;
    window->mini_icon = mini_icon;

    redraw_icon (window);
  }

g_assert (window->icon)do { if (window->icon) ; else g_assertion_message_expr ("croma"
, "core/window.c", 6174, ((const char*) (__func__)), "window->icon"
); } while (0);
g_assert (window->mini_icon)do { if (window->mini_icon) ; else g_assertion_message_expr
 ("croma", "core/window.c", 6175, ((const char*) (__func__)),
 "window->mini_icon"); } while (0);
6176}

6178static gboolean
6179idle_update_icon (gpointer data)
6180{
GSList *tmp;
GSList *copy;
guint queue_index = GPOINTER_TO_INT (data)((gint) (glong) (data));

meta_topicmeta_topic_real (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((void*)0);
queue_idle[queue_index] = 0;

destroying_windows_disallowed += 1;

tmp = copy;
while (tmp != NULL((void*)0))
  {
    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(0);
6216}

6218MetaWorkspace *
6219meta_window_get_workspace (MetaWindow *window)
6220{
if (window->on_all_workspaces)
  return window->screen->active_workspace;
else
  return window->workspace;
6225}

6227GList*
6228meta_window_get_workspaces (MetaWindow *window)
6229{
if (window->on_all_workspaces)
  return window->screen->workspaces;
else
  return window->workspace->list_containing_self;
6234}

6236static void
6237invalidate_work_areas (MetaWindow *window)
6238{
GList *tmp;

tmp = meta_window_get_workspaces (window);

while (tmp != NULL((void*)0))
  {
    meta_workspace_invalidate_work_area (tmp->data);
    tmp = tmp->next;
  }
6248}

6250void
6251meta_window_update_struts (MetaWindow *window)
6252{
GSList *old_struts;
GSList *new_struts;
GSList *old_iter, *new_iter;
gulong *struts = NULL((void*)0);
int nitems;
gboolean changed;

meta_verbosemeta_verbose_real ("Updating struts for %s\n", window->desc);

old_struts = window->struts;
new_struts = NULL((void*)0);

if (meta_prop_get_cardinal_list (window->display,
                                 window->xwindow,
                                 window->display->atom__NET_WM_STRUT_PARTIAL,
                                 &struts, &nitems))
  {
    if (nitems != 12)
      meta_verbosemeta_verbose_real ("_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)((MetaStrut *) g_malloc_n ((1), sizeof (MetaStrut)));
            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)((temp->rect).x + (temp->rect).width) - 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)((temp->rect).y + (temp->rect).height) - 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 ()do { g_assertion_message_expr ("croma", "core/window.c", 6311
, ((const char*) (__func__)), ((void*)0)); } while (0);
              }

            new_struts = g_slist_prepend (new_struts, temp);
          }

        meta_verbosemeta_verbose_real ("_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)do { if ((struts)) XFree ((struts)); } while (0);
  }
else
  {
    meta_verbosemeta_verbose_real ("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_verbosemeta_verbose_real ("_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)((MetaStrut *) g_malloc_n ((1), sizeof (MetaStrut)));
            temp->side = 1 << i;
            temp->rect = window->screen->rect;
            switch (temp->side)
              {
              case META_SIDE_RIGHT:
                temp->rect.x = BOX_RIGHT(temp->rect)((temp->rect).x + (temp->rect).width) - 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)((temp->rect).y + (temp->rect).height) - thickness;
                /* Intentionally fall through without breaking */
              case META_SIDE_TOP:
                temp->rect.height = thickness;
                break;
              default:
                g_assert_not_reached ()do { g_assertion_message_expr ("croma", "core/window.c", 6370
, ((const char*) (__func__)), ((void*)0)); } while (0);
              }

            new_struts = g_slist_prepend (new_struts, temp);
          }

        meta_verbosemeta_verbose_real ("_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)do { if ((struts)) XFree ((struts)); } while (0);
  }
else if (!new_struts)
  {
    meta_verbosemeta_verbose_real ("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((void*)0) || new_iter != NULL((void*)0));

/* Update appropriately */
g_slist_free_full (old_struts, g_free);
window->struts = new_struts;
if (changed)
  {
    meta_topicmeta_topic_real (META_DEBUG_WORKAREA,
                "Invalidating work areas of window %s due to struts update\n",
                window->desc);
    invalidate_work_areas (window);
  }
else
  {
    meta_topicmeta_topic_real (META_DEBUG_WORKAREA,
                "Struts on %s were unchanged\n", window->desc);
  }
6420}

6422void
6423meta_window_recalc_window_type (MetaWindow *window)
6424{
recalc_window_type (window);
6426}

6428static void
6429recalc_window_type (MetaWindow *window)
6430{
MetaWindowType old_type;

old_type = window->type;

if (window->type_atom != None0L)
  {
    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 != None0L)
  {
    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_verbosemeta_verbose_real ("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);
  }
6490}

6492static void
6493set_allowed_actions_hint (MetaWindow *window)
6494{
6495#define MAX_N_ACTIONS 12
unsigned long data[MAX_N_ACTIONS];
int i;

i = 0;
if (window->has_move_func &&
    !window->minimized)
  {
    data[i] = window->display->atom__NET_WM_ACTION_MOVE;
    ++i;
  }
if (window->has_resize_func &&
    !window->minimized      &&
    !window->shaded         &&
    !window->tiled          &&
    !(window->maximized_horizontally && window->maximized_vertically))
  {
    data[i] = window->display->atom__NET_WM_ACTION_RESIZE;
    ++i;
  }
if (window->has_fullscreen_func &&
    !window->minimized          &&
    !window->shaded)
  {
    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 &&
    !window->minimized)
  {
    data[i] = window->display->atom__NET_WM_ACTION_SHADE;
    ++i;
  }
/* sticky according to EWMH is different from croma's sticky;
 * croma doesn't support EWMH sticky
 */
if (window->has_maximize_func &&
    !window->minimized        &&
    !window->shaded)
  {
    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)do { if (i <= MAX_N_ACTIONS) ; else g_assertion_message_expr
 ("croma", "core/window.c", 6560, ((const char*) (__func__)),
 "i <= MAX_N_ACTIONS"); } while (0);

meta_verbosemeta_verbose_real ("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((Atom) 4),
                 32, PropModeReplace0, (guchar*) data, i);
meta_error_trap_pop (window->display, FALSE(0));
6570#undef MAX_N_ACTIONS
6571}

6573void
6574meta_window_recalc_features (MetaWindow *window)
6575{
recalc_window_features (window);
6577}

6579static void
6580recalc_window_features (MetaWindow *window)
6581{
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(!(0));

/* 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(0);
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")dgettext ("croma", "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(!(0));
window->has_fullscreen_func = TRUE(!(0));

window->always_sticky = FALSE(0);

/* Semantic category overrides the MWM hints */
if (window->type == META_WINDOW_TOOLBAR)
  window->decorated = FALSE(0);

if (window->type == META_WINDOW_MODAL_DIALOG && meta_prefs_get_attach_modal_dialogs ())
  {
    MetaWindow *parent = meta_window_get_transient_for (window);
    if (parent)
      {
        window->has_resize_func = FALSE(0);
        window->border_only = TRUE(!(0));
      }
  }

if (window->type == META_WINDOW_DESKTOP ||
    window->type == META_WINDOW_DOCK)
  window->always_sticky = TRUE(!(0));

if (window->type == META_WINDOW_DESKTOP ||
    window->type == META_WINDOW_DOCK ||
    window->type == META_WINDOW_SPLASHSCREEN)
  {
    window->decorated = FALSE(0);
    window->has_close_func = FALSE(0);
    window->has_shade_func = FALSE(0);

    /* 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(0);
    window->has_resize_func = FALSE(0);
  }

if (window->type != META_WINDOW_NORMAL)
  {
    window->has_minimize_func = FALSE(0);
    window->has_maximize_func = FALSE(0);
    window->has_fullscreen_func = FALSE(0);
  }

if (!window->has_resize_func)
  {
    window->has_maximize_func = FALSE(0);

    /* 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(0);
  }

/* 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(0);
    window->has_move_func = FALSE(0);
    window->has_resize_func = FALSE(0);
    window->has_maximize_func = FALSE(0);
  }

meta_topicmeta_topic_real (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(0);

window->skip_taskbar = FALSE(0);
window->skip_pager = FALSE(0);

if (window->wm_state_skip_taskbar)
  window->skip_taskbar = TRUE(!(0));

if (window->wm_state_skip_pager)
  window->skip_pager = TRUE(!(0));

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(!(0));
    window->skip_pager = TRUE(!(0));
    break;

  case META_WINDOW_DIALOG:
  case META_WINDOW_MODAL_DIALOG:
    /* only skip taskbar if we have a real transient parent */
    if (window->xtransient_for != None0L &&
        window->xtransient_for != window->screen->xroot)
      window->skip_taskbar = TRUE(!(0));
    break;

  case META_WINDOW_NORMAL:
    break;
  }

meta_topicmeta_topic_real (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.
 */
6788}

6790static void
6791menu_callback (MetaWindowMenu *menu,
             Display        *xdisplay,
             Window          client_xwindow,
             guint32         timestamp,
             MetaMenuOp      op,
             int             workspace_index,
             gpointer        data)
6798{
MetaDisplay *display;
MetaWindow *window;
MetaWorkspace *workspace;

display = meta_display_for_x_display (xdisplay);
window = meta_display_lookup_x_window (display, client_xwindow);
workspace = NULL((void*)0);

if (window != NULL((void*)0)) /* window can be NULL */
  {
    meta_verbosemeta_verbose_real ("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(0))
          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(!(0)),
                                   timestamp);
        break;

      case META_MENU_OP_RESIZE:
        meta_window_begin_grab_op (window,
                                   META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN,
                                   TRUE(!(0)),
                                   timestamp);
        break;

      case META_MENU_OP_RECOVER:
        meta_window_shove_titlebar_onscreen (window);
        break;

      default:
        meta_warning (G_STRLOC"core/window.c" ":" "6905"": Unknown window op\n");
        break;
      }

    if (workspace)
{
 meta_window_change_workspace (window,
			workspace);
6913#if 0
 meta_workspace_activate (workspace);
 meta_window_raise (window);
6916#endif
}
  }
else
  {
    meta_verbosemeta_verbose_real ("Menu callback on nonexistent window\n");
  }

if (display->window_menu == menu)
  {
    display->window_menu = NULL((void*)0);
    display->window_with_menu = NULL((void*)0);
  }

meta_ui_window_menu_free (menu);
6931}

6933void
6934meta_window_show_menu (MetaWindow *window,
                     int         root_x,
                     int         root_y,
                     int         button,
                     guint32     timestamp)
6939{
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((void*)0);
    window->display->window_with_menu = NULL((void*)0);
  }

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)((window)->maximized_horizontally && (window)->
maximized_vertically))
  ops |= META_MENU_OP_UNMAXIMIZE;
else
  ops |= META_MENU_OP_MAXIMIZE;

6997#if 0
if (window->shaded)
  ops |= META_MENU_OP_UNSHADE;
else
  ops |= META_MENU_OP_SHADE;
7002#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)((window)->has_move_func && !(window)->fullscreen
))
  insensitive |= META_MENU_OP_MOVE;

if (!META_WINDOW_ALLOWS_RESIZE (window)(((window)->has_resize_func && !((window)->maximized_horizontally
 && (window)->maximized_vertically) && !(window
)->fullscreen && !(window)->shaded) && (
((window)->size_hints.min_width < (window)->size_hints
.max_width) || ((window)->size_hints.min_height < (window
)->size_hints.max_height))))
  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((void*)0));

window->display->window_menu = menu;
window->display->window_with_menu = window;

meta_verbosemeta_verbose_real ("Popping up window menu for %s\n", window->desc);

meta_ui_window_menu_popup (menu, root_x, root_y, button, timestamp);
7060}

7062void
7063meta_window_shove_titlebar_onscreen (MetaWindow *window)
7064{
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(0),
                         newx,
                         newy,
                         window->rect.width,
                         window->rect.height);
7106}

7108gboolean
7109meta_window_titlebar_is_onscreen (MetaWindow *window)
7110{
MetaRectangle  titlebar_rect;
GList         *onscreen_region;
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 TRUE(!(0));

/* Get the rectangle corresponding to the titlebar */
meta_window_get_outer_rect (window, &titlebar_rect);
titlebar_rect.height = window->frame->child_y;

/* 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(0);
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)(((titlebar_rect.height) < (min_height_needed)) ? (titlebar_rect
.height) : (min_height_needed)) &&
        overlap.width  > MIN (titlebar_rect.width * min_width_percent,(((titlebar_rect.width * min_width_percent) < (min_width_absolute
)) ? (titlebar_rect.width * min_width_percent) : (min_width_absolute
))
                              min_width_absolute)(((titlebar_rect.width * min_width_percent) < (min_width_absolute
)) ? (titlebar_rect.width * min_width_percent) : (min_width_absolute
)))
      {
        is_onscreen = TRUE(!(0));
        break;
      }

    onscreen_region = onscreen_region->next;
  }

return is_onscreen;
7150}

7152static double
7153time_diff (const gint64 first,
         const gint64 second)
7155{
return (first - second) / 1000.0;
7157}

7159static gboolean
7160check_moveresize_frequency (MetaWindow *window,
	    gdouble    *remaining)
7162{
gint64 current_time;
current_time = g_get_real_time ();

7166#ifdef HAVE_XSYNC
if (!window->disable_sync &&
    window->display->grab_sync_request_alarm != None0L)
  {
    if (window->sync_request_time != 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(0);
   }
 else
   {
     /* We have now waited for more than a second for the
      * application to respond to the sync request
      */
     window->disable_sync = TRUE(!(0));
     return TRUE(!(0));
   }
}
    else
{
 /* No outstanding sync requests. Go ahead and resize
  */
 return TRUE(!(0));
}
  }
else
7203#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_topicmeta_topic_real (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(0);
}

    meta_topicmeta_topic_real (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(!(0));
  }
7229}

7231static gboolean
7232update_move_timeout (gpointer data)
7233{
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(0);
7242}

7244static void
7245update_move (MetaWindow  *window,
           gboolean     snap,
           int          x,
           int          y)
7249{
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_verbosemeta_verbose_real ("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;

/* Originally for detaching maximized windows, but we use this
 * for the zones at the sides of the monitor where trigger tiling
 * because it's about the right size
 */

7285#define DRAG_THRESHOLD_TO_SHAKE_THRESHOLD_FACTOR2 2
shake_threshold = meta_ui_get_drag_threshold (window->screen->ui) *
  DRAG_THRESHOLD_TO_SHAKE_THRESHOLD_FACTOR2;

if (snap)
  {
    /* We don't want to tile while snapping. Also, clear any previous tile
       request. */
    window->tile_mode = META_TILE_NONE;
    window->tile_monitor_number = -1;
    window->tile_cycle = META_TILE_CYCLE_NONE;
  }
else if (meta_prefs_get_allow_tiling () &&
         !META_WINDOW_MAXIMIZED (window)((window)->maximized_horizontally && (window)->
maximized_vertically) &&
         !META_WINDOW_TILED (window)(((window)->tiled && ((window)->tile_mode == META_TILE_LEFT
 || (window)->tile_mode == META_TILE_RIGHT)) || ((window)->
tiled && ((window)->tile_mode == META_TILE_BOTTOM_RIGHT
 || (window)->tile_mode == META_TILE_BOTTOM_LEFT || (window
)->tile_mode == META_TILE_TOP_RIGHT || (window)->tile_mode
 == META_TILE_TOP_LEFT))))
  {
    const MetaXineramaScreenInfo *monitor;
    MetaRectangle work_area;

    /* For side-by-side tiling we are interested in the inside vertical
     * edges of the work area of the monitor where the pointer is located,
     * and in the outside top edge for maximized tiling.
     *
     * For maximized tiling we use the outside edge instead of the
     * inside edge, because we don't want to force users to maximize
     * windows they are placing near the top of their screens.
     *
     * The "current" idea of meta_window_get_work_area_for_xinerama() and
     * meta_screen_get_current_xinerama() is slightly different: the former
     * refers to the monitor which contains the largest part of the window,
     * the latter to the one where the pointer is located.
     */
    monitor = meta_screen_get_current_xinerama (window->screen);
    meta_window_get_work_area_for_xinerama (window,
                                            monitor->number,
                                            &work_area);

    /* Check if the cursor is in a position which triggers tiling
     * and set tile_mode accordingly.
     */
    MetaTileMode old_tile_mode = window->tile_mode;
    window->tile_mode = calculate_tiling_mode(x, y, window, monitor,
                                              work_area, shake_threshold);

    if (window->tile_mode != META_TILE_NONE)
      window->tile_monitor_number = monitor->number;

    /* Reset resized and cycle flags when changing tile mode */
    if (old_tile_mode != window->tile_mode)
      {
        window->tile_resized = FALSE(0);
        window->tile_cycle = META_TILE_CYCLE_NONE;
      }
  }

/* shake loose (unmaximize) maximized or tiled window if dragged beyond
 * the threshold in the Y direction. Tiled windows can also be pulled
 * loose via X motion.
 */

if ((META_WINDOW_MAXIMIZED (window)((window)->maximized_horizontally && (window)->
maximized_vertically) && ABS (dy)(((dy) < 0) ? -(dy) : (dy)) >= shake_threshold) ||
    (META_WINDOW_TILED (window)(((window)->tiled && ((window)->tile_mode == META_TILE_LEFT
 || (window)->tile_mode == META_TILE_RIGHT)) || ((window)->
tiled && ((window)->tile_mode == META_TILE_BOTTOM_RIGHT
 || (window)->tile_mode == META_TILE_BOTTOM_LEFT || (window
)->tile_mode == META_TILE_TOP_RIGHT || (window)->tile_mode
 == META_TILE_TOP_LEFT))) && (MAX (ABS (dx), ABS (dy))((((((dx) < 0) ? -(dx) : (dx))) > ((((dy) < 0) ? -(dy
) : (dy)))) ? ((((dx) < 0) ? -(dx) : (dx))) : ((((dy) <
 0) ? -(dy) : (dy)))) >= shake_threshold)))
  {
    double prop;

    /* Shake loose, so that the window snaps back to maximized
     * when dragged near the top; do not snap back if the window
     * was tiled.
     */
    window->shaken_loose = META_WINDOW_MAXIMIZED (window)((window)->maximized_horizontally && (window)->
maximized_vertically);
    window->tile_mode = META_TILE_NONE;
    window->tile_cycle = META_TILE_CYCLE_NONE;
    window->tiled = FALSE(0);

    /* 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)((window)->maximized_horizontally && (window)->
maximized_vertically))
  {
    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 + shake_threshold &&
            x < (work_area.x + work_area.width - shake_threshold) &&
            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(0);

            window->tile_mode = META_TILE_NONE;
            window->tile_cycle = META_TILE_CYCLE_NONE;

            meta_window_maximize (window,
                                  META_MAXIMIZE_HORIZONTAL |
                                  META_MAXIMIZE_VERTICAL);

            return;
          }
      }
  }

/* Delay showing the tile preview slightly to make it more unlikely to
 * trigger it unwittingly, e.g. when shaking loose the window or moving
 * it to another monitor.
 */

meta_screen_tile_preview_update (window->screen,
                                 window->tile_mode != META_TILE_NONE);

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 or while tiled */

if (window->maximized_horizontally || META_WINDOW_TILED (window)(((window)->tiled && ((window)->tile_mode == META_TILE_LEFT
 || (window)->tile_mode == META_TILE_RIGHT)) || ((window)->
tiled && ((window)->tile_mode == META_TILE_BOTTOM_RIGHT
 || (window)->tile_mode == META_TILE_BOTTOM_LEFT || (window
)->tile_mode == META_TILE_TOP_RIGHT || (window)->tile_mode
 == META_TILE_TOP_LEFT))))
  {
    new_x = old.x;
  }
  
if (window->maximized_vertically || META_WINDOW_CORNER_TILED(window)((window)->tiled && ((window)->tile_mode == META_TILE_BOTTOM_RIGHT
 || (window)->tile_mode == META_TILE_BOTTOM_LEFT || (window
)->tile_mode == META_TILE_TOP_RIGHT || (window)->tile_mode
 == META_TILE_TOP_LEFT)))
  {
    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(0));

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(!(0)), new_x, new_y);
7495}


7498static MetaTileMode calculate_tiling_mode(int x,
                                        int y,
                                        MetaWindow *window,
                                        const MetaXineramaScreenInfo *monitor,
                                        MetaRectangle work_area,
                                        int shake_threshold)
7504{  
if (meta_window_can_tile (window) &&
    x >= monitor->rect.x
    && x < (work_area.x + shake_threshold))
  {
    if(y >= monitor->rect.y && y < work_area.y + shake_threshold)
      return META_TILE_TOP_LEFT; 
    else if(y < monitor->rect.y + monitor->rect.height
            && y > work_area.y + work_area.height - shake_threshold)
      return META_TILE_BOTTOM_LEFT; 
    else
      return META_TILE_LEFT; 
  }

else if (meta_window_can_tile (window) &&
         x >= work_area.x + work_area.width - shake_threshold &&
         x < (monitor->rect.x + monitor->rect.width))
  {
    if(y >= monitor->rect.y && y < work_area.y + shake_threshold)
      return META_TILE_TOP_RIGHT; 
    else if(y < monitor->rect.y + monitor->rect.height
            && y > work_area.y + work_area.height - shake_threshold)
      return META_TILE_BOTTOM_RIGHT; 
    else
      return META_TILE_RIGHT; 
  }
else if (meta_window_can_tile_maximized (window) &&
         y >= monitor->rect.y && y <= work_area.y &&
         meta_prefs_get_allow_top_tiling ())
  return META_TILE_MAXIMIZED; 
else
  return META_TILE_NONE;

7537}


7540static gboolean
7541update_resize_timeout (gpointer data)
7542{
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(!(0)));
return FALSE(0);
7551}

7553static void
7554update_resize (MetaWindow *window,
             gboolean    snap,
             int x, int y,
             gboolean force)
7558{
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(!(0)));
      }
    else if ((dx < 0) && (dy > 0))
      {
        window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_SW;
        meta_window_update_keyboard_resize (window, TRUE(!(0)));
      }
    else if ((dx > 0) && (dy < 0))
      {
        window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_NE;
        meta_window_update_keyboard_resize (window, TRUE(!(0)));
      }
    else if ((dx < 0) && (dy < 0))
      {
        window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_NW;
        meta_window_update_keyboard_resize (window, TRUE(!(0)));
      }
    else if (dx < 0)
      {
        window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W;
        meta_window_update_keyboard_resize (window, TRUE(!(0)));
      }
    else if (dx > 0)
      {
        window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E;
        meta_window_update_keyboard_resize (window, TRUE(!(0)));
      }
    else if (dy > 0)
      {
        window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S;
        meta_window_update_keyboard_resize (window, TRUE(!(0)));
      }
    else if (dy < 0)
      {
        window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N;
        meta_window_update_keyboard_resize (window, TRUE(!(0)));
      }
  }

/* 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(!(0)));

/* 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 { if (gravity >= 0) ; else g_assertion_message_expr ("croma"
, "core/window.c", 7738, ((const char*) (__func__)), "gravity >= 0"
); } while (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(0));

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(!(0)), 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)
  window->display->grab_last_moveresize_time = g_get_real_time ();
7777}

7779typedef struct
7780{
const XEvent *current_event;
int           count;
guint32       last_time;
7784} EventScannerData;

7786static Boolint
7787find_last_time_predicate (Display  *display,
                        XEvent   *xevent,
                        XPointer  arg)
7790{
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 False0;
7801}

7803static gboolean
7804check_use_this_motion_notify (MetaWindow *window,
                            XEvent     *event)
7806{
EventScannerData esd;
XEvent useless;

/* This code is copied from Owen's CDK 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_topicmeta_topic_real (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(!(0));
      }
    else
      return FALSE(0); /* 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_topicmeta_topic_real (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(!(0));
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(0);
  }
7855}

7857static void
7858update_tile_mode (MetaWindow *window)
7859{
switch (window->tile_mode)
  {
    case META_TILE_LEFT:
    case META_TILE_RIGHT:
        if (!META_WINDOW_SIDE_TILED (window)((window)->tiled && ((window)->tile_mode == META_TILE_LEFT
 || (window)->tile_mode == META_TILE_RIGHT)))
            window->tile_mode = META_TILE_NONE;
        break;
  }
7868}

7870void
7871meta_window_handle_mouse_grab_op_event (MetaWindow *window,
                                      XEvent     *event)
7873{
7874#ifdef HAVE_XSYNC
if (event->type == (window->display->xsync_event_base + XSyncAlarmNotify1))
  {
    meta_topicmeta_topic_real (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(0);
    window->sync_request_time = 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(!(0)));
        break;

      default:
        break;
      }
  }
7920#endif /* HAVE_XSYNC */

switch (event->type)
  {
  case ButtonRelease5:
    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 (window->tile_mode == META_TILE_MAXIMIZED)
       {
                meta_window_maximize (window, META_MAXIMIZE_VERTICAL |
                                              META_MAXIMIZE_HORIZONTAL);
                window->tile_mode = META_TILE_NONE;
}
     else if (window->tile_mode != META_TILE_NONE)
       {
  meta_window_tile (window);
}
     else if (event->xbutton.root == window->screen->xroot)
              update_move (window, event->xbutton.state & ShiftMask(1<<0),
                           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(1<<0),
                             event->xbutton.x_root,
                             event->xbutton.y_root,
                             TRUE(!(0)));
     if (window->display->compositor)
meta_compositor_set_updates (window->display->compositor, window, TRUE(!(0)));

            /* If a tiled window has been dragged free with a
             * mouse resize without snapping back to the tiled
             * state, it will end up with an inconsistent tile
             * mode on mouse release; cleaning the mode earlier
             * would break the ability to snap back to the tiled
             * state, so we wait until mouse release.
             */
            update_tile_mode (window);
          }
      }

    meta_display_end_grab_op (window->display, event->xbutton.time);
    break;

  case MotionNotify6:
    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(1<<0),
                           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(1<<0),
                             event->xmotion.x_root,
                             event->xmotion.y_root,
                             FALSE(0));
          }
      }
    break;

  default:
    break;
  }
8010}

8012void
8013meta_window_set_gravity (MetaWindow *window,
                       int         gravity)
8015{
XSetWindowAttributes attrs;

meta_verbosemeta_verbose_real ("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(1L<<5),
                         &attrs);

meta_error_trap_pop (window->display, FALSE(0));
8030}

8032static void
8033get_work_area_xinerama (MetaWindow    *window,
                      MetaRectangle *area,
                      int            which_xinerama)
8036{
GList *tmp;

g_assert (which_xinerama >= 0)do { if (which_xinerama >= 0) ; else g_assertion_message_expr
 ("croma", "core/window.c", 8039, ((const char*) (__func__)),
 "which_xinerama >= 0"); } while (0);

/* Initialize to the whole xinerama */
*area = window->screen->xinerama_infos[which_xinerama].rect;

tmp = meta_window_get_workspaces (window);
while (tmp != NULL((void*)0))
  {
    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_topicmeta_topic_real (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);
8061}

8063void
8064meta_window_get_work_area_current_xinerama (MetaWindow    *window,
			    MetaRectangle *area)
8066{
const MetaXineramaScreenInfo *xinerama = NULL((void*)0);
xinerama = meta_screen_get_xinerama_for_window (window->screen,
				  window);

meta_window_get_work_area_for_xinerama (window,
                                        xinerama->number,
                                        area);
8074}

8076void
8077meta_window_get_work_area_for_xinerama (MetaWindow    *window,
			int            which_xinerama,
			MetaRectangle *area)
8080{
g_return_if_fail (which_xinerama >= 0)do { if ((which_xinerama >= 0)) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "which_xinerama >= 0"
); return; } } while (0);

get_work_area_xinerama (window,
                        area,
                        which_xinerama);
8086}

8088void
8089meta_window_get_work_area_all_xineramas (MetaWindow    *window,
                                       MetaRectangle *area)
8091{
GList *tmp;

/* Initialize to the whole screen */
*area = window->screen->rect;

tmp = meta_window_get_workspaces (window);
while (tmp != NULL((void*)0))
  {
    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_topicmeta_topic_real (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);
8112}

8114void
8115meta_window_get_current_tile_area (MetaWindow    *window,
                                 MetaRectangle *tile_area)
8117{
int tile_monitor_number;
int width;
double tile_ratio;

g_return_if_fail (window->tile_mode != META_TILE_NONE)do { if ((window->tile_mode != META_TILE_NONE)) { } else {
 g_return_if_fail_warning ("croma", ((const char*) (__func__)
), "window->tile_mode != META_TILE_NONE"); return; } } while
 (0);

/* I don't know how to detect monitor configuration changes, so I have to take into account that
 * tile_monitor_number might be invalid. If this happens, I replace it with whatever monitor
 * the window is currently on. This is usually the correct monitor anyway, only in some special
 * cases is the real monitor number actually required (e.g. the window is being moved with the mouse but
 * is still mostly on the wrong monitor).
 */
if (window->tile_monitor_number >= window->screen->n_xinerama_infos)
  {
    window->tile_monitor_number = meta_screen_get_xinerama_for_window (window->screen, window)->number;
  }

tile_monitor_number = window->tile_monitor_number;
if (tile_monitor_number < 0)
  {
    meta_warning ("%s called with an invalid monitor number; using 0 instead\n", G_STRFUNC((const char*) (__func__)));
    tile_monitor_number = 0;
  }

meta_window_get_work_area_for_xinerama (window, tile_monitor_number, tile_area);

width = tile_area->width;

switch (window->tile_cycle)
  {
    case META_TILE_CYCLE_33:
      tile_ratio = 1 / 3.0;
      break;
    case META_TILE_CYCLE_25:
      tile_ratio = 1 / 4.0;
      break;
    case META_TILE_CYCLE_75:
      tile_ratio = 3 / 4.0;
      break;
    case META_TILE_CYCLE_66:
      tile_ratio = 2 / 3.0;
      break;
    case META_TILE_CYCLE_50:
    case META_TILE_CYCLE_NONE:
    default:
      tile_ratio = 1 / 2.0;
      break;
  }

if (window->tile_mode != META_TILE_NONE  &&
    window->tile_mode != META_TILE_MAXIMIZED)
  width = (int)(tile_area->width * tile_ratio);

if(window->tile_mode == META_TILE_BOTTOM_LEFT ||
   window->tile_mode == META_TILE_BOTTOM_RIGHT ||
   window->tile_mode == META_TILE_TOP_LEFT ||
   window->tile_mode == META_TILE_TOP_RIGHT)
  tile_area->height /= 2;

if (window->tile_mode == META_TILE_RIGHT ||
    window->tile_mode == META_TILE_TOP_RIGHT ||
    window->tile_mode == META_TILE_BOTTOM_RIGHT)
  tile_area->x += tile_area->width - width;

if(window->tile_mode == META_TILE_BOTTOM_LEFT ||
   window->tile_mode == META_TILE_BOTTOM_RIGHT)
  tile_area->y += tile_area->height;

tile_area->width = width;
8187}

8189gboolean
8190meta_window_same_application (MetaWindow *window,
                            MetaWindow *other_window)
8192{
MetaGroup *group       = meta_window_get_group (window);
MetaGroup *other_group = meta_window_get_group (other_window);

return
  group!=NULL((void*)0) &&
  other_group!=NULL((void*)0) &&
  group==other_group;
8200}

8202/* Generally meta_window_same_application() is a better idea
* of "sameness", since it handles the case where multiple apps
* want to look like the same app or the same app wants to look
* like multiple apps, but in the case of workarounds for legacy
* applications (which likely aren't setting the group properly
* anyways), it may be desirable to check this as well.
*/
8209static gboolean
8210meta_window_same_client (MetaWindow *window,
                       MetaWindow *other_window)
8212{
int resource_mask = window->display->xdisplay->resource_mask;

return ((window->xwindow & ~resource_mask) ==
        (other_window->xwindow & ~resource_mask));
8217}

8219void
8220meta_window_refresh_resize_popup (MetaWindow *window)
8221{
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_topicmeta_topic_real (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((void*)0))
  {
    gint scale = cdk_window_get_scale_factor (cdk_get_default_root_window ());
    /* Display the resize popup only for windows that report an
     * increment hint that's larger than the scale factor. */
    if (window->size_hints.width_inc > scale ||
        window->size_hints.height_inc > scale)
      window->display->grab_resize_popup =
        meta_ui_resize_popup_new (window->display->xdisplay,
                                  window->screen->number);
  }

if (window->display->grab_resize_popup != NULL((void*)0))
  {
    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(!(0)));
  }
8295}

8297void
8298meta_window_foreach_transient (MetaWindow            *window,
                             MetaWindowForeachFunc  func,
                             void                  *data)
8301{
GSList *windows;
GSList *tmp;

windows = meta_display_list_windows (window->display);

tmp = windows;
while (tmp != NULL((void*)0))
  {
    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);
8322}

8324void
8325meta_window_foreach_ancestor (MetaWindow            *window,
                            MetaWindowForeachFunc  func,
                            void                  *data)
8328{
MetaWindow *w;
MetaWindow *tortoise;

w = window;
tortoise = window;
while (TRUE(!(0)))
  {
    if (w->xtransient_for == None0L ||
        w->transient_parent_is_root_window)
      break;

    w = meta_display_lookup_x_window (w->display, w->xtransient_for);

    if (w == NULL((void*)0) || w == tortoise)
      break;

    if (!(* func) (w, data))
      break;

    if (w->xtransient_for == None0L ||
        w->transient_parent_is_root_window)
      break;

    w = meta_display_lookup_x_window (w->display, w->xtransient_for);

    if (w == NULL((void*)0) || 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)do { if (tortoise != ((void*)0)) ; else g_assertion_message_expr
 ("croma", "core/window.c", 8366, ((const char*) (__func__)),
 "tortoise != NULL"); } while (0);
    g_assert (tortoise->xtransient_for != None)do { if (tortoise->xtransient_for != 0L) ; else g_assertion_message_expr
 ("croma", "core/window.c", 8367, ((const char*) (__func__)),
 "tortoise->xtransient_for != None"); } while (0);
    g_assert (!tortoise->transient_parent_is_root_window)do { if (!tortoise->transient_parent_is_root_window) ; else
 g_assertion_message_expr ("croma", "core/window.c", 8368, ((
const char*) (__func__)), "!tortoise->transient_parent_is_root_window"
); } while (0);
  }
8370}

8372typedef struct
8373{
MetaWindow *ancestor;
gboolean found;
8376} FindAncestorData;

8378static gboolean
8379find_ancestor_func (MetaWindow *window,
                  void       *data)
8381{
FindAncestorData *d = data;

if (window == d->ancestor)
  {
    d->found = TRUE(!(0));
    return FALSE(0);
  }

return TRUE(!(0));
8391}

8393gboolean
8394meta_window_is_ancestor_of_transient (MetaWindow *window,
                                    MetaWindow *transient)
8396{
FindAncestorData d;

d.ancestor = window;
d.found = FALSE(0);

meta_window_foreach_ancestor (transient, find_ancestor_func, &d);

return d.found;
8405}

8407/* Warp pointer to location appropriate for grab,
* return root coordinates where pointer ended up.
*/
8410static gboolean
8411warp_grab_pointer (MetaWindow          *window,
                 MetaGrabOp           grab_op,
                 int                 *x,
                 int                 *y)
8415{
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(0);
  }

*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)(((*x) > (window->screen->rect.width-1)) ? (window->
screen->rect.width-1) : (((*x) < (0)) ? (0) : (*x)));
*y = CLAMP (*y, 0, window->screen->rect.height-1)(((*y) > (window->screen->rect.height-1)) ? (window->
screen->rect.height-1) : (((*y) < (0)) ? (0) : (*y)));

meta_error_trap_push (display);

meta_topicmeta_topic_real (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,
              None0L,
              window->screen->xroot,
              0, 0, 0, 0,
              *x, *y);

if (meta_error_trap_pop_with_return (display, FALSE(0)) != Success0)
  {
    meta_verbosemeta_verbose_real ("Failed to warp pointer for window %s\n",
                  window->desc);
    return FALSE(0);
  }

return TRUE(!(0));
8526}

8528void
8529meta_window_begin_grab_op (MetaWindow *window,
                         MetaGrabOp  op,
                         gboolean    frame_action,
                         guint32     timestamp)
8533{
int x, y;

warp_grab_pointer (window,
                   op, &x, &y);

meta_display_begin_grab_op (window->display,
                            window->screen,
                            window,
                            op,
                            FALSE(0),
                            frame_action,
                            0 /* button */,
                            0,
                            timestamp,
                            x, y);
8549}

8551void
8552meta_window_update_keyboard_resize (MetaWindow *window,
                                  gboolean    update_cursor)
8554{
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 = CurrentTime0L;
    meta_display_set_grab_op_cursor (window->display,
                                     NULL((void*)0),
                                     window->display->grab_op,
                                     TRUE(!(0)),
                                     window->display->grab_xwindow,
                                     timestamp);
  }
8573}

8575void
8576meta_window_update_keyboard_move (MetaWindow *window)
8577{
int x, y;

warp_grab_pointer (window,
                   window->display->grab_op,
                   &x, &y);
8583}

8585void
8586meta_window_update_layer (MetaWindow *window)
8587{
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);
8597}

8599/* 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)
*/
8603static void
8604ensure_mru_position_after (MetaWindow *window,
                         MetaWindow *after_this_one)
8606{
/* 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((void*)0))
  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);
  }
8640}

8642void
8643meta_window_stack_just_below (MetaWindow *window,
                            MetaWindow *below_this_one)
8645{
g_return_if_fail (window         != NULL)do { if ((window != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "window != NULL"); return
; } } while (0);
g_return_if_fail (below_this_one != NULL)do { if ((below_this_one != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "below_this_one != NULL"
); return; } } while (0);

if (window->stack_position > below_this_one->stack_position)
  {
    meta_topicmeta_topic_real (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_topicmeta_topic_real (META_DEBUG_STACK,
                "Window %s  was already below window %s.\n",
                window->desc, below_this_one->desc);
  }
8664}

8666void
8667meta_window_set_user_time (MetaWindow *window,
                         guint32     timestamp)
8669{
/* 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)( (timestamp) == 0 || (( (( (timestamp) < (window->net_wm_user_time
) ) && ( (window->net_wm_user_time) - (timestamp) <
 ((guint32)-1)/2 )) || (( (timestamp) > (window->net_wm_user_time
) ) && ( (timestamp) - (window->net_wm_user_time) >
 ((guint32)-1)/2 )) ) && (window->net_wm_user_time
) != 0) ))
  {
    meta_topicmeta_topic_real (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_topicmeta_topic_real (META_DEBUG_STARTUP,
                "Window %s has _NET_WM_USER_TIME of %u\n",
                window->desc, timestamp);
    window->net_wm_user_time_set = TRUE(!(0));
    window->net_wm_user_time = timestamp;
    if (XSERVER_TIME_IS_BEFORE (window->display->last_user_time, timestamp)( (window->display->last_user_time) == 0 || (( (( (window
->display->last_user_time) < (timestamp) ) &&
 ( (timestamp) - (window->display->last_user_time) <
 ((guint32)-1)/2 )) || (( (window->display->last_user_time
) > (timestamp) ) && ( (window->display->last_user_time
) - (timestamp) > ((guint32)-1)/2 )) ) && (timestamp
) != 0) ))
      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(0);
  }
8702}

8704/* Sets the demands_attention hint on a window, but only
* if it's at least partially obscured (see #305882).
*/
8707void
8708meta_window_set_demands_attention (MetaWindow *window)
8709{
MetaRectangle candidate_rect, other_rect;
GList *stack = window->screen->stack->sorted;
MetaWindow *other_window;
gboolean obscured = FALSE(0);

MetaWorkspace *workspace = window->screen->active_workspace;
if (workspace!=window->workspace)
  {
    /* windows on other workspaces are necessarily obscured */
    obscured = TRUE(!(0));
  }
else if (window->minimized)
  {
    obscured = TRUE(!(0));
  }
else
  {
    meta_window_get_outer_rect (window, &candidate_rect);

    /* The stack is sorted with the top windows first. */

    while (stack != NULL((void*)0) && 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(!(0));
                break;
              }
          }
      }
  }

if (obscured)
  {
    meta_topicmeta_topic_real (META_DEBUG_WINDOW_OPS,
                "Marking %s as needing attention\n",
                window->desc);

    window->wm_state_demands_attention = TRUE(!(0));
    set_net_wm_state (window);
  }
else
  {
    /* If the window's in full view, there's no point setting the flag. */

    meta_topicmeta_topic_real (META_DEBUG_WINDOW_OPS,
               "Not marking %s as needing attention because "
               "it's in full view\n",
               window->desc);
  }
8769}

8771void
8772meta_window_unset_demands_attention (MetaWindow *window)
8773{
meta_topicmeta_topic_real (META_DEBUG_WINDOW_OPS,
    "Marking %s as not needing attention\n", window->desc);

window->wm_state_demands_attention = FALSE(0);
set_net_wm_state (window);
8779}

8781MetaFrame *
8782meta_window_get_frame (MetaWindow *window)
8783{
return window->frame;
8785}

8787static gboolean
8788transient_has_focus (MetaWindow *window,
                   void       *data)
8790{
if (window->type == META_WINDOW_MODAL_DIALOG && meta_window_appears_focused (window))
  *((gboolean *)data) = TRUE(!(0));

return FALSE(0);
8795}

8797gboolean
8798meta_window_appears_focused (MetaWindow *window)
8799{
if (!window->has_focus && meta_prefs_get_attach_modal_dialogs ())
  {
    gboolean focus = FALSE(0);
    meta_window_foreach_transient (window, transient_has_focus, &focus);
    return focus;
  }

if (window->has_focus)
  return TRUE(!(0));

if (window->type == META_WINDOW_DOCK ||
    window->type == META_WINDOW_SPLASHSCREEN)
  return TRUE(!(0));

return FALSE(0);
8815}

8817gboolean
8818meta_window_has_focus (MetaWindow *window)
8819{
return window->has_focus;
8821}

8823gboolean
8824meta_window_is_shaded (MetaWindow *window)
8825{
return window->shaded;
8827}

8829MetaRectangle *
8830meta_window_get_rect (MetaWindow *window)
8831{
return &window->rect;
8833}

8835MetaScreen *
8836meta_window_get_screen (MetaWindow *window)
8837{
return window->screen;
8839}

8841MetaDisplay *
8842meta_window_get_display (MetaWindow *window)
8843{
return window->display;
8845}

8847Window
8848meta_window_get_xwindow (MetaWindow *window)
8849{
return window->xwindow;
8851}

8853/**
* meta_window_get_transient_for:
* @window: a #MetaWindow
*
* Returns the #MetaWindow for the window that is pointed to by the
* WM_TRANSIENT_FOR hint on this window (see XGetTransientForHint()
* or XSetTransientForHint()). Croma keeps transient windows above their
* parents. A typical usage of this hint is for a dialog that wants to stay
* above its associated window.
*
* Return value: (transfer none): the window this window is transient for, or
* %NULL if the WM_TRANSIENT_FOR hint is unset or does not point to a toplevel
* window that Croma knows about.
*/
8867MetaWindow *
8868meta_window_get_transient_for (MetaWindow *window)
8869{
if (window->xtransient_for)
  return meta_display_lookup_x_window (window->display, window->xtransient_for);
else
  return NULL((void*)0);
8874}

8876gboolean
8877meta_window_is_maximized (MetaWindow *window)
8878{
return META_WINDOW_MAXIMIZED (window)((window)->maximized_horizontally && (window)->
maximized_vertically);
8880}

8882/**
* meta_window_is_client_decorated:
*
* Check if if the window has decorations drawn by the client.
* (window->decorated refers only to whether we should add decorations)
*/
8888gboolean
8889meta_window_is_client_decorated (MetaWindow *window)
8890{
/* Currently the implementation here is hackish -
 * has_custom_frame_extents() is set if _CTK_FRAME_EXTENTS is set
 * to any value even 0. CTK+ always sets _CTK_FRAME_EXTENTS for
 * client-side-decorated window, even if the value is 0 because
 * the window is maxized and has no invisible borders or shadows.
 */
return window->has_custom_frame_extents;
8898}

8900/**
* meta_window_get_frame_bounds:
*
* Gets a region representing the outer bounds of the window's frame.
*
* Return value: (transfer none) (allow-none): a #cairo_region_t
* holding the outer bounds of the window, or %NULL if the window
* doesn't have a frame.
*/
8909cairo_region_t *
8910meta_window_get_frame_bounds (MetaWindow *window)
8911{
if (!window->frame_bounds)
  {
    if (window->frame)
      window->frame_bounds = meta_frame_get_frame_bounds (window->frame);
  }

return window->frame_bounds;
8919}