core/screen.c

Bug Summary

File:	core/screen.c
Warning:	line 1733, column 32 Out of bound memory access (access exceeds upper limit of memory block)
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 screen.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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-14/lib/clang/14.0.6 -D HAVE_CONFIG_H -I . -I .. -I ./include -D CROMA_LIBEXECDIR="/usr/local/libexec" -D HOST_ALIAS="" -D CROMA_LOCALEDIR="/usr/local/share/locale" -D CROMA_PKGDATADIR="/usr/local/share/croma" -D CROMA_DATADIR="/usr/local/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/uuid -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/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-14/lib/clang/14.0.6/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/12/../../../../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/2022-12-30-180607-30189-1 -x c core/screen.c
1/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */

3/* Croma X screen handler */

5/*
* Copyright (C) 2001, 2002 Havoc Pennington
* Copyright (C) 2002, 2003 Red Hat Inc.
* Some ICCCM manager selection code derived from fvwm2,
* Copyright (C) 2001 Dominik Vogt, Matthias Clasen, and fvwm2 team
* 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.
*/

29#include <config.h>
30#include "screen-private.h"
31#include "util.h"
32#include "errors.h"
33#include "window-private.h"
34#include "frame-private.h"
35#include "prefs.h"
36#include "workspace.h"
37#include "keybindings.h"
38#include "prefs.h"
39#include "stack.h"
40#include "xprops.h"
41#include "compositor.h"

43#ifdef HAVE_SOLARIS_XINERAMA
44#include <X11/extensions/xinerama.h>
45#endif
46#ifdef HAVE_XFREE_XINERAMA
47#include <X11/extensions/Xinerama.h>
48#endif

50#include <X11/Xatom.h>
51#include <cairo/cairo-xlib.h>
52#include <locale.h>
53#include <string.h>
54#include <stdio.h>

56static char* get_screen_name (MetaDisplay *display,
                            int          number);

59static void update_num_workspaces  (MetaScreen *screen,
                                  guint32     timestamp);
61static void update_focus_mode      (MetaScreen *screen);
62static void set_workspace_names    (MetaScreen *screen);
63static void prefs_changed_callback (MetaPreference pref,
                                  gpointer       data);

66static void set_desktop_geometry_hint (MetaScreen *screen);
67static void set_desktop_viewport_hint (MetaScreen *screen);

69#ifdef HAVE_STARTUP_NOTIFICATION
70static void meta_screen_sn_event   (SnMonitorEvent *event,
                                  void           *user_data);
72#endif

74static int
75set_wm_check_hint (MetaScreen *screen)
76{
unsigned long data[1];

g_return_val_if_fail (screen->display->leader_window != None, 0)do { if ((screen->display->leader_window != 0L)) { } else
 { g_return_if_fail_warning ("croma", ((const char*) (__func__
)), "screen->display->leader_window != None"); return (
0); } } while (0);

data[0] = screen->display->leader_window;

XChangeProperty (screen->display->xdisplay, screen->xroot,
                 screen->display->atom__NET_SUPPORTING_WM_CHECK,
                 XA_WINDOW((Atom) 33),
                 32, PropModeReplace0, (guchar*) data, 1);

return Success0;
89}

91static void
92unset_wm_check_hint (MetaScreen *screen)
93{
XDeleteProperty (screen->display->xdisplay, screen->xroot,
                 screen->display->atom__NET_SUPPORTING_WM_CHECK);
96}

98static int
99set_supported_hint (MetaScreen *screen)
100{
Atom atoms[] = {
102#define EWMH_ATOMS_ONLY
103#define item(x)  screen->display->atom_##x,
104#include "atomnames.h"
105#undef item
106#undef EWMH_ATOMS_ONLY
  screen->display->atom__CTK_FRAME_EXTENTS,
  screen->display->atom__CTK_SHOW_WINDOW_MENU,
};

XChangeProperty (screen->display->xdisplay, screen->xroot,
                 screen->display->atom__NET_SUPPORTED,
                 XA_ATOM((Atom) 4),
                 32, PropModeReplace0,
                 (guchar*) atoms, G_N_ELEMENTS(atoms)(sizeof (atoms) / sizeof ((atoms)[0])));

return Success0;
118}

120static int
121set_wm_icon_size_hint (MetaScreen *screen)
122{
int icon_size = meta_prefs_get_icon_size();
124#define N_VALS 6
gulong vals[N_VALS];

/* min width, min height, max w, max h, width inc, height inc */
vals[0] = icon_size; /* width */
vals[1] = icon_size; /* height */
vals[2] = icon_size; /* width */
vals[3] = icon_size; /* height */
vals[4] = 0;
vals[5] = 0;

XChangeProperty (screen->display->xdisplay, screen->xroot,
                 screen->display->atom_WM_ICON_SIZE,
                 XA_CARDINAL((Atom) 6),
                 32, PropModeReplace0, (guchar*) vals, N_VALS);

return Success0;
141#undef N_VALS
142}

144static void
145reload_xinerama_infos (MetaScreen *screen)
146{
MetaDisplay *display;

{
  GList *tmp;

  tmp = screen->workspaces;
  while (tmp != NULL((void*)0))
    {
      MetaWorkspace *space = tmp->data;

      meta_workspace_invalidate_work_area (space);

      tmp = tmp->next;
    }
}

display = screen->display;

if (screen->xinerama_infos)
  g_free (screen->xinerama_infos);

screen->xinerama_infos = NULL((void*)0);
screen->n_xinerama_infos = 0;
screen->last_xinerama_index = 0;

screen->display->xinerama_cache_invalidated = TRUE(!(0));

174#ifdef HAVE_XFREE_XINERAMA
if (XineramaIsActive (display->xdisplay))
  {
    XineramaScreenInfo *infos;
    int n_infos;

    n_infos = 0;
    infos = XineramaQueryScreens (display->xdisplay, &n_infos);

    meta_topicmeta_topic_real (META_DEBUG_XINERAMA,
                "Found %d Xinerama screens on display %s\n",
                n_infos, display->name);

    if (n_infos > 0)
      {
        int i;

        screen->xinerama_infos = g_new (MetaXineramaScreenInfo, n_infos)((MetaXineramaScreenInfo *) g_malloc_n ((n_infos), sizeof (MetaXineramaScreenInfo
)));
        screen->n_xinerama_infos = n_infos;

        i = 0;
        while (i < n_infos)
          {
            screen->xinerama_infos[i].number = infos[i].screen_number;
            screen->xinerama_infos[i].rect.x = infos[i].x_org;
            screen->xinerama_infos[i].rect.y = infos[i].y_org;
            screen->xinerama_infos[i].rect.width = infos[i].width;
            screen->xinerama_infos[i].rect.height = infos[i].height;

            meta_topicmeta_topic_real (META_DEBUG_XINERAMA,
                        "Xinerama %d is %d,%d %d x %d\n",
                        screen->xinerama_infos[i].number,
                        screen->xinerama_infos[i].rect.x,
                        screen->xinerama_infos[i].rect.y,
                        screen->xinerama_infos[i].rect.width,
                        screen->xinerama_infos[i].rect.height);

            ++i;
          }
      }

    meta_XFree (infos)do { if ((infos)) XFree ((infos)); } while (0);
  }
else
  {
    meta_topicmeta_topic_real (META_DEBUG_XINERAMA,
                "No XFree86 Xinerama extension or XFree86 Xinerama inactive on display %s\n",
                display->name);
  }
223#else
meta_topicmeta_topic_real (META_DEBUG_XINERAMA,
            "Croma compiled without XFree86 Xinerama support\n");
226#endif /* HAVE_XFREE_XINERAMA */

228#ifdef HAVE_SOLARIS_XINERAMA
/* This code from CDK, Copyright (C) 2002 Sun Microsystems */
if (screen->n_xinerama_infos == 0 &&
    XineramaGetState (screen->display->xdisplay,
                      screen->number))
  {
    XRectangle monitors[MAXFRAMEBUFFERS];
    unsigned char hints[16];
    int result;
    int n_monitors;

    n_monitors = 0;
    result = XineramaGetInfo (screen->display->xdisplay,
                              screen->number,
		monitors, hints,
                              &n_monitors);
    /* Yes I know it should be Success but the current implementation
     * returns the num of monitor
     */
    if (result > 0)
{
        int i;

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

        screen->xinerama_infos = g_new (MetaXineramaScreenInfo, n_monitors)((MetaXineramaScreenInfo *) g_malloc_n ((n_monitors), sizeof (
MetaXineramaScreenInfo)));
        screen->n_xinerama_infos = n_monitors;

        i = 0;
        while (i < n_monitors)
          {
            screen->xinerama_infos[i].number = i;
            screen->xinerama_infos[i].rect.x = monitors[i].x;
            screen->xinerama_infos[i].rect.y = monitors[i].y;
            screen->xinerama_infos[i].rect.width = monitors[i].width;
            screen->xinerama_infos[i].rect.height = monitors[i].height;

            meta_topicmeta_topic_real (META_DEBUG_XINERAMA,
                        "Xinerama %d is %d,%d %d x %d\n",
                        screen->xinerama_infos[i].number,
                        screen->xinerama_infos[i].rect.x,
                        screen->xinerama_infos[i].rect.y,
                        screen->xinerama_infos[i].rect.width,
                        screen->xinerama_infos[i].rect.height);

            ++i;
          }
}
  }
else if (screen->n_xinerama_infos == 0)
  {
    meta_topicmeta_topic_real (META_DEBUG_XINERAMA,
                "No Solaris Xinerama extension or Solaris Xinerama inactive on display %s\n",
                display->name);
  }
283#else
meta_topicmeta_topic_real (META_DEBUG_XINERAMA,
            "Croma compiled without Solaris Xinerama support\n");
286#endif /* HAVE_SOLARIS_XINERAMA */


/* If no Xinerama, fill in the single screen info so
 * we can use the field unconditionally
 */
if (screen->n_xinerama_infos == 0)
  {
    if (g_getenv ("CROMA_DEBUG_XINERAMA"))
      {
        meta_topicmeta_topic_real (META_DEBUG_XINERAMA,
                    "Pretending a single monitor has two Xinerama screens\n");

        screen->xinerama_infos = g_new (MetaXineramaScreenInfo, 2)((MetaXineramaScreenInfo *) g_malloc_n ((2), sizeof (MetaXineramaScreenInfo
)));
        screen->n_xinerama_infos = 2;

        screen->xinerama_infos[0].number = 0;
        screen->xinerama_infos[0].rect = screen->rect;
        screen->xinerama_infos[0].rect.width = screen->rect.width / 2;

        screen->xinerama_infos[1].number = 1;
        screen->xinerama_infos[1].rect = screen->rect;
        screen->xinerama_infos[1].rect.x = screen->rect.width / 2;
        screen->xinerama_infos[1].rect.width = screen->rect.width / 2;
      }
    else
      {
        meta_topicmeta_topic_real (META_DEBUG_XINERAMA,
                    "No Xinerama screens, using default screen info\n");

        screen->xinerama_infos = g_new (MetaXineramaScreenInfo, 1)((MetaXineramaScreenInfo *) g_malloc_n ((1), sizeof (MetaXineramaScreenInfo
)));
        screen->n_xinerama_infos = 1;

        screen->xinerama_infos[0].number = 0;
        screen->xinerama_infos[0].rect = screen->rect;
      }
  }

g_assert (screen->n_xinerama_infos > 0)do { if (screen->n_xinerama_infos > 0) ; else g_assertion_message_expr
 ("croma", "core/screen.c", 324, ((const char*) (__func__)), "screen->n_xinerama_infos > 0"
); } while (0);
g_assert (screen->xinerama_infos != NULL)do { if (screen->xinerama_infos != ((void*)0)) ; else g_assertion_message_expr
 ("croma", "core/screen.c", 325, ((const char*) (__func__)), "screen->xinerama_infos != NULL"
); } while (0);
326}

328MetaScreen*
329meta_screen_new (MetaDisplay *display,
               int          number,
               guint32      timestamp)
332{
MetaScreen *screen;
Window xroot;
Display *xdisplay;
XWindowAttributes attr;
Window new_wm_sn_owner;
Window current_wm_sn_owner;
gboolean replace_current_wm;
Atom wm_sn_atom;
char buf[128];
guint32 manager_timestamp;
gulong current_workspace;

replace_current_wm = meta_get_replace_current_wm ();

/* Only display->name, display->xdisplay, and display->error_traps
 * can really be used in this function, since normally screens are
 * created from the MetaDisplay constructor
 */

xdisplay = display->xdisplay;

meta_verbosemeta_verbose_real ("Trying screen %d on display '%s'\n",
              number, display->name);

xroot = RootWindow (xdisplay, number)((&((_XPrivDisplay)(xdisplay))->screens[number])->root
);

/* FVWM checks for None here, I don't know if this
 * ever actually happens
 */
if (xroot == None0L)
  {
    meta_warning (_("Screen %d on display '%s' is invalid\n")dgettext ("croma", "Screen %d on display '%s' is invalid\n"),
                  number, display->name);
    return NULL((void*)0);
  }

sprintf (buf, "WM_S%d", number);
wm_sn_atom = XInternAtom (xdisplay, buf, False0);

current_wm_sn_owner = XGetSelectionOwner (xdisplay, wm_sn_atom);

if (current_wm_sn_owner != None0L)
  {
    XSetWindowAttributes attrs;

    if (!replace_current_wm)
      {
        meta_warning (_("Screen %d on display \"%s\" already has a window manager; try using the --replace option to replace the current window manager.\n")dgettext ("croma", "Screen %d on display \"%s\" already has a window manager; try using the --replace option to replace the current window manager.\n"
),
                      number, display->name);

        return NULL((void*)0);
      }

    /* We want to find out when the current selection owner dies */
    meta_error_trap_push (display);
    attrs.event_mask = StructureNotifyMask(1L<<17);
    XChangeWindowAttributes (xdisplay,
                             current_wm_sn_owner, CWEventMask(1L<<11), &attrs);
    if (meta_error_trap_pop_with_return (display, FALSE(0)) != Success0)
      current_wm_sn_owner = None0L; /* don't wait for it to die later on */
  }

/* We need SelectionClear and SelectionRequest events on the new_wm_sn_owner,
 * but those cannot be masked, so we only need NoEventMask.
 */
new_wm_sn_owner = meta_create_offscreen_window (xdisplay, xroot, NoEventMask0L);

manager_timestamp = timestamp;

XSetSelectionOwner (xdisplay, wm_sn_atom, new_wm_sn_owner,
                    manager_timestamp);

if (XGetSelectionOwner (xdisplay, wm_sn_atom) != new_wm_sn_owner)
  {
    meta_warning (_("Could not acquire window manager selection on screen %d display \"%s\"\n")dgettext ("croma", "Could not acquire window manager selection on screen %d display \"%s\"\n"
),
                  number, display->name);

    XDestroyWindow (xdisplay, new_wm_sn_owner);

    return NULL((void*)0);
  }

{
  /* Send client message indicating that we are now the WM */
  XClientMessageEvent ev;

  ev.type = ClientMessage33;
  ev.window = xroot;
  ev.message_type = display->atom_MANAGER;
  ev.format = 32;
  ev.data.l[0] = manager_timestamp;
  ev.data.l[1] = wm_sn_atom;

  XSendEvent (xdisplay, xroot, False0, StructureNotifyMask(1L<<17), (XEvent*)&ev);
}

/* Wait for old window manager to go away */
if (current_wm_sn_owner != None0L)
  {
    XEvent event;

    /* We sort of block infinitely here which is probably lame. */

    meta_verbosemeta_verbose_real ("Waiting for old window manager to exit\n");
    do
      {
        XWindowEvent (xdisplay, current_wm_sn_owner,
                      StructureNotifyMask(1L<<17), &event);
      }
    while (event.type != DestroyNotify17);
  }

/* select our root window events */
meta_error_trap_push (display);

/* We need to or with the existing event mask since
 * ctk+ may be interested in other events.
 */
XGetWindowAttributes (xdisplay, xroot, &attr);
XSelectInput (xdisplay,
              xroot,
              SubstructureRedirectMask(1L<<20) | SubstructureNotifyMask(1L<<19) |
              ColormapChangeMask(1L<<23) | PropertyChangeMask(1L<<22) |
              LeaveWindowMask(1L<<5) | EnterWindowMask(1L<<4) |
              KeyPressMask(1L<<0) | KeyReleaseMask(1L<<1) |
              FocusChangeMask(1L<<21) | StructureNotifyMask(1L<<17) |
459#ifdef HAVE_COMPOSITE_EXTENSIONS1
              ExposureMask(1L<<15) |
461#endif
attr.your_event_mask);
if (meta_error_trap_pop_with_return (display, FALSE(0)) != Success0)
  {
    meta_warning (_("Screen %d on display \"%s\" already has a window manager\n")dgettext ("croma", "Screen %d on display \"%s\" already has a window manager\n"
),
                  number, display->name);

    XDestroyWindow (xdisplay, new_wm_sn_owner);

    return NULL((void*)0);
  }

screen = g_new (MetaScreen, 1)((MetaScreen *) g_malloc_n ((1), sizeof (MetaScreen)));
screen->closing = 0;

screen->display = display;
screen->number = number;
screen->screen_name = get_screen_name (display, number);
screen->xscreen = ScreenOfDisplay (xdisplay, number)(&((_XPrivDisplay)(xdisplay))->screens[number]);
screen->xroot = xroot;
screen->rect.x = screen->rect.y = 0;
screen->rect.width = WidthOfScreen (screen->xscreen)((screen->xscreen)->width);
screen->rect.height = HeightOfScreen (screen->xscreen)((screen->xscreen)->height);
screen->current_cursor = -1; /* invalid/unset */
screen->default_xvisual = DefaultVisualOfScreen (screen->xscreen)((screen->xscreen)->root_visual);
screen->default_depth = DefaultDepthOfScreen (screen->xscreen)((screen->xscreen)->root_depth);
screen->flash_window = None0L;

screen->wm_sn_selection_window = new_wm_sn_owner;
screen->wm_sn_atom = wm_sn_atom;
screen->wm_sn_timestamp = manager_timestamp;

493#ifdef HAVE_COMPOSITE_EXTENSIONS1
g_snprintf (buf, sizeof(buf), "_NET_WM_CM_S%d", screen->number);
screen->wm_cm_atom = XInternAtom (screen->display->xdisplay, buf, FALSE(0));
screen->wm_cm_selection_window = meta_create_offscreen_window (xdisplay,
                                                               xroot,
                                                               NoEventMask0L);
499#endif
screen->work_area_idle = 0;

screen->active_workspace = NULL((void*)0);
screen->workspaces = NULL((void*)0);
screen->rows_of_workspaces = 1;
screen->columns_of_workspaces = -1;
screen->vertical_workspaces = FALSE(0);
screen->starting_corner = META_SCREEN_TOPLEFT;
screen->compositor_data = NULL((void*)0);

{
  XFontStruct *font_info;
  XGCValues gc_values;
  gulong value_mask = 0;

  gc_values.subwindow_mode = IncludeInferiors1;
  value_mask |= GCSubwindowMode(1L<<15);
  gc_values.function = GXinvert0xa;
  value_mask |= GCFunction(1L<<0);
  gc_values.line_width = META_WIREFRAME_XOR_LINE_WIDTH2;
  value_mask |= GCLineWidth(1L<<4);

  font_info = XLoadQueryFont (screen->display->xdisplay, "fixed");

  if (font_info != NULL((void*)0))
    {
      gc_values.font = font_info->fid;
      value_mask |= GCFont(1L<<14);
      XFreeFontInfo (NULL((void*)0), font_info, 1);
    }
  else
    meta_warning ("xserver doesn't have 'fixed' font.\n");

  screen->root_xor_gc = XCreateGC (screen->display->xdisplay,
                                   screen->xroot,
                                   value_mask,
                                   &gc_values);
}

screen->xinerama_infos = NULL((void*)0);
screen->n_xinerama_infos = 0;
screen->last_xinerama_index = 0;

reload_xinerama_infos (screen);

meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);

/* Handle creating a no_focus_window for this screen */
screen->no_focus_window =
  meta_create_offscreen_window (display->xdisplay,
                                screen->xroot,
                                FocusChangeMask(1L<<21)|KeyPressMask(1L<<0)|KeyReleaseMask(1L<<1));
XMapWindow (display->xdisplay, screen->no_focus_window);
/* Done with no_focus_window stuff */

set_wm_icon_size_hint (screen);

set_supported_hint (screen);

set_wm_check_hint (screen);

set_desktop_viewport_hint (screen);

set_desktop_geometry_hint (screen);

meta_screen_update_workspace_layout (screen);

/* Get current workspace */
current_workspace = 0;
if (meta_prop_get_cardinal (screen->display,
                            screen->xroot,
                            screen->display->atom__NET_CURRENT_DESKTOP,
                            &current_workspace))
  meta_verbosemeta_verbose_real ("Read existing _NET_CURRENT_DESKTOP = %d\n",
                (int) current_workspace);
else
  meta_verbosemeta_verbose_real ("No _NET_CURRENT_DESKTOP present\n");

/* Screens must have at least one workspace at all times,
 * so create that required workspace.
 */
meta_workspace_activate (meta_workspace_new (screen), timestamp);
update_num_workspaces (screen, timestamp);

set_workspace_names (screen);

screen->all_keys_grabbed = FALSE(0);
screen->keys_grabbed = FALSE(0);
meta_screen_grab_keys (screen);

screen->ui = meta_ui_new (screen->display->xdisplay,
                          screen->xscreen);

screen->tab_popup = NULL((void*)0);
screen->tile_preview = NULL((void*)0);

screen->tile_preview_timeout_id = 0;

screen->stack = meta_stack_new (screen);

meta_prefs_add_listener (prefs_changed_callback, screen);

602#ifdef HAVE_STARTUP_NOTIFICATION
screen->sn_context =
  sn_monitor_context_new (screen->display->sn_display,
                          screen->number,
                          meta_screen_sn_event,
                          screen,
                          NULL((void*)0));
screen->startup_sequences = NULL((void*)0);
screen->startup_sequence_timeout = 0;
611#endif

/* Switch to the _NET_CURRENT_DESKTOP workspace */
{
  MetaWorkspace *space;

  space = meta_screen_get_workspace_by_index (screen,
                                              current_workspace);

  if (space != NULL((void*)0))
    meta_workspace_activate (space, timestamp);
}

meta_verbosemeta_verbose_real ("Added screen %d ('%s') root 0x%lx\n",
              screen->number, screen->screen_name, screen->xroot);

return screen;
628}

630void
631meta_screen_free (MetaScreen *screen,
                guint32     timestamp)
633{
MetaDisplay *display;
XGCValues gc_values = { 0 };

display = screen->display;

screen->closing += 1;

meta_display_grab (display);

if (screen->display->compositor)
  {
    meta_compositor_unmanage_screen (screen->display->compositor,
		       screen);
  }

meta_display_unmanage_windows_for_screen (display, screen, timestamp);

meta_prefs_remove_listener (prefs_changed_callback, screen);

meta_screen_ungrab_keys (screen);

655#ifdef HAVE_STARTUP_NOTIFICATION
g_slist_free_full (screen->startup_sequences,
                   (GDestroyNotify) sn_startup_sequence_unref);
screen->startup_sequences = NULL((void*)0);

if (screen->startup_sequence_timeout != 0)
  {
    g_source_remove (screen->startup_sequence_timeout);
    screen->startup_sequence_timeout = 0;
  }
if (screen->sn_context)
  {
    sn_monitor_context_unref (screen->sn_context);
    screen->sn_context = NULL((void*)0);
  }
670#endif

meta_ui_free (screen->ui);

meta_stack_free (screen->stack);

meta_error_trap_push (screen->display);
XSelectInput (screen->display->xdisplay, screen->xroot, 0);
if (meta_error_trap_pop_with_return (screen->display, FALSE(0)) != Success0)
  meta_warning (_("Could not release screen %d on display \"%s\"\n")dgettext ("croma", "Could not release screen %d on display \"%s\"\n"
),
                screen->number, screen->display->name);

unset_wm_check_hint (screen);

XDestroyWindow (screen->display->xdisplay,
                screen->wm_sn_selection_window);

if (screen->work_area_idle != 0)
  g_source_remove (screen->work_area_idle);


if (XGetGCValues (screen->display->xdisplay,
                  screen->root_xor_gc,
                  GCFont(1L<<14),
                  &gc_values))
  {
    XUnloadFont (screen->display->xdisplay,
                 gc_values.font);
  }

XFreeGC (screen->display->xdisplay,
         screen->root_xor_gc);

if (screen->xinerama_infos)
  g_free (screen->xinerama_infos);

if (screen->tile_preview_timeout_id)
  g_source_remove (screen->tile_preview_timeout_id);

if (screen->tile_preview)
  meta_tile_preview_free (screen->tile_preview);

g_free (screen->screen_name);
g_free (screen);

XFlush (display->xdisplay);
meta_display_ungrab (display);
717}

719typedef struct
720{
Window		xwindow;
XWindowAttributes	attrs;
723} WindowInfo;

725static GList *
726list_windows (MetaScreen *screen)
727{
Window ignored1, ignored2;
Window *children;
guint n_children, i;
GList *result;

XQueryTree (screen->display->xdisplay,
            screen->xroot,
            &ignored1, &ignored2, &children, &n_children);

result = NULL((void*)0);
for (i = 0; i < n_children; ++i)
  {
    WindowInfo *info = g_new0 (WindowInfo, 1)((WindowInfo *) g_malloc0_n ((1), sizeof (WindowInfo)));

    meta_error_trap_push (screen->display);

    XGetWindowAttributes (screen->display->xdisplay,
                          children[i], &info->attrs);

    if (meta_error_trap_pop_with_return (screen->display, TRUE(!(0))))
{
        meta_verbosemeta_verbose_real ("Failed to get attributes for window 0x%lx\n",
                      children[i]);
 g_free (info);
      }
    else
      {
 info->xwindow = children[i];
        result = g_list_prepend (result, info);
}
  }

if (children)
  XFree (children);

return g_list_reverse (result);
764}

766void
767meta_screen_manage_all_windows (MetaScreen *screen)
768{
GList *windows;
GList *list;

meta_display_grab (screen->display);

windows = list_windows (screen);

meta_stack_freeze (screen->stack);
for (list = windows; list != NULL((void*)0); list = list->next)
  {
    WindowInfo *info = list->data;
    MetaWindow *window;
    gboolean test_window_owner;

    window = meta_window_new_with_attrs (screen->display, info->xwindow, TRUE(!(0)),
                                         &info->attrs);
    test_window_owner = info->xwindow == screen->no_focus_window ||
     info->xwindow == screen->flash_window ||
     info->xwindow == screen->wm_sn_selection_window;

789#ifdef HAVE_COMPOSITE_EXTENSIONS1
    test_window_owner = test_window_owner ||  info->xwindow == screen->wm_cm_selection_window;
791#endif
    if (test_window_owner)
    {
      meta_verbosemeta_verbose_real ("Not managing our own windows\n");
      continue;
    }

    if (screen->display->compositor)
      meta_compositor_add_window (screen->display->compositor, window,
                                  info->xwindow, &info->attrs);
  }
meta_stack_thaw (screen->stack);

g_list_free_full (windows, g_free);

meta_display_ungrab (screen->display);
807}

809void
810meta_screen_composite_all_windows (MetaScreen *screen)
811{
812#ifdef HAVE_COMPOSITE_EXTENSIONS1
MetaDisplay *display;
GList *windows, *list;

display = screen->display;
if (!display->compositor)
  return;

windows = list_windows (screen);

meta_stack_freeze (screen->stack);

for (list = windows; list != NULL((void*)0); list = list->next)
  {
    WindowInfo *info = list->data;

    if (info->xwindow == screen->no_focus_window ||
        info->xwindow == screen->flash_window ||
        info->xwindow == screen->wm_sn_selection_window ||
        info->xwindow == screen->wm_cm_selection_window) {
      meta_verbosemeta_verbose_real ("Not managing our own windows\n");
      continue;
    }

    meta_compositor_add_window (display->compositor,
                                meta_display_lookup_x_window (display,
                                                              info->xwindow),
		  info->xwindow, &info->attrs);
  }

meta_stack_thaw (screen->stack);

g_list_free_full (windows, g_free);
845#endif
846}

848MetaScreen*
849meta_screen_for_x_screen (Screen *xscreen)
850{
MetaDisplay *display;

display = meta_display_for_x_display (DisplayOfScreen (xscreen)((xscreen)->display));

if (display == NULL((void*)0))
  return NULL((void*)0);

return meta_display_screen_for_x_screen (display, xscreen);
859}

861static void
862prefs_changed_callback (MetaPreference pref,
                      gpointer       data)
864{
MetaScreen *screen = data;

if (pref == META_PREF_NUM_WORKSPACES)
  {
    /* GSettings doesn't provide timestamps, but luckily update_num_workspaces
     * often doesn't need it...
     */
    guint32 timestamp =
      meta_display_get_current_time_roundtrip (screen->display);
    update_num_workspaces (screen, timestamp);
  }
else if (pref == META_PREF_FOCUS_MODE)
  {
    update_focus_mode (screen);
  }
else if (pref == META_PREF_WORKSPACE_NAMES)
  {
    set_workspace_names (screen);
  }
884}


887static char*
888get_screen_name (MetaDisplay *display,
               int          number)
890{
char *p;
char *dname;
char *scr;

/* DisplayString gives us a sort of canonical display,
 * vs. the user-entered name from XDisplayName()
 */
dname = g_strdup (DisplayString (display->xdisplay)(((_XPrivDisplay)(display->xdisplay))->display_name));

/* Change display name to specify this screen.
 */
p = strrchr (dname, ':');
if (p)
  {
    p = strchr (p, '.');
    if (p)
      *p = '\0';
  }

scr = g_strdup_printf ("%s.%d", dname, number);

g_free (dname);

return scr;
915}

917static gint
918ptrcmp (gconstpointer a, gconstpointer b)
919{
if (a < b)
  return -1;
else if (a > b)
  return 1;
else
  return 0;
926}

928static void
929listify_func (gpointer key, gpointer value, gpointer data)
930{
GSList **listp;

listp = data;

*listp = g_slist_prepend (*listp, value);
936}

938void
939meta_screen_foreach_window (MetaScreen *screen,
                          MetaScreenWindowFunc func,
                          gpointer data)
942{
GSList *winlist;
GSList *tmp;

/* If we end up doing this often, just keeping a list
 * of windows might be sensible.
 */

winlist = NULL((void*)0);
g_hash_table_foreach (screen->display->window_ids,
                      listify_func,
                      &winlist);

winlist = g_slist_sort (winlist, ptrcmp);

tmp = winlist;
while (tmp != NULL((void*)0))
  {
    /* If the next node doesn't contain this window
     * a second time, delete the window.
     */
    if (tmp->next == NULL((void*)0) ||
        (tmp->next && tmp->next->data != tmp->data))
      {
        MetaWindow *window = tmp->data;

        if (window->screen == screen)
          (* func) (screen, window, data);
      }

    tmp = tmp->next;
  }
g_slist_free (winlist);
975}

977static void
978queue_draw (MetaScreen *screen, MetaWindow *window, gpointer data)
979{
if (window->frame)
  meta_frame_queue_draw (window->frame);
982}

984void
985meta_screen_queue_frame_redraws (MetaScreen *screen)
986{
meta_screen_foreach_window (screen, queue_draw, NULL((void*)0));
988}

990static void
991queue_resize (MetaScreen *screen, MetaWindow *window, gpointer data)
992{
meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
994}

996void
997meta_screen_queue_window_resizes (MetaScreen *screen)
998{
meta_screen_foreach_window (screen, queue_resize, NULL((void*)0));
1000}

1002int
1003meta_screen_get_n_workspaces (MetaScreen *screen)
1004{
return g_list_length (screen->workspaces);
1006}

1008MetaWorkspace*
1009meta_screen_get_workspace_by_index (MetaScreen  *screen,
                                  int          idx)
1011{
GList *tmp;
int i;

/* should be robust, idx is maybe from an app */
if (idx < 0)
  return NULL((void*)0);

i = 0;
tmp = screen->workspaces;
while (tmp != NULL((void*)0))
  {
    MetaWorkspace *w = tmp->data;

    if (i == idx)
      return w;

    ++i;
    tmp = tmp->next;
  }

return NULL((void*)0);
1033}

1035static void
1036set_number_of_spaces_hint (MetaScreen *screen,
	   int         n_spaces)
1038{
unsigned long data[1];

if (screen->closing > 0)
  return;

data[0] = n_spaces;

meta_verbosemeta_verbose_real ("Setting _NET_NUMBER_OF_DESKTOPS to %lu\n", data[0]);

meta_error_trap_push (screen->display);
XChangeProperty (screen->display->xdisplay, screen->xroot,
                 screen->display->atom__NET_NUMBER_OF_DESKTOPS,
                 XA_CARDINAL((Atom) 6),
                 32, PropModeReplace0, (guchar*) data, 1);
meta_error_trap_pop (screen->display, FALSE(0));
1054}

1056static void
1057set_desktop_geometry_hint (MetaScreen *screen)
1058{
unsigned long data[2];

if (screen->closing > 0)
  return;

data[0] = screen->rect.width;
data[1] = screen->rect.height;

meta_verbosemeta_verbose_real ("Setting _NET_DESKTOP_GEOMETRY to %lu, %lu\n", data[0], data[1]);

meta_error_trap_push (screen->display);
XChangeProperty (screen->display->xdisplay, screen->xroot,
                 screen->display->atom__NET_DESKTOP_GEOMETRY,
                 XA_CARDINAL((Atom) 6),
                 32, PropModeReplace0, (guchar*) data, 2);
meta_error_trap_pop (screen->display, FALSE(0));
1075}

1077static void
1078set_desktop_viewport_hint (MetaScreen *screen)
1079{
unsigned long data[2];

if (screen->closing > 0)
  return;

/*
 * Croma does not implement viewports, so this is a fixed 0,0
 */
data[0] = 0;
data[1] = 0;

meta_verbosemeta_verbose_real ("Setting _NET_DESKTOP_VIEWPORT to 0, 0\n");

meta_error_trap_push (screen->display);
XChangeProperty (screen->display->xdisplay, screen->xroot,
                 screen->display->atom__NET_DESKTOP_VIEWPORT,
                 XA_CARDINAL((Atom) 6),
                 32, PropModeReplace0, (guchar*) data, 2);
meta_error_trap_pop (screen->display, FALSE(0));
1099}

1101static void
1102update_num_workspaces (MetaScreen *screen,
                     guint32     timestamp)
1104{
int new_num;
GList *tmp;
int i;
GList *extras;
MetaWorkspace *last_remaining;
gboolean need_change_space;

new_num = meta_prefs_get_num_workspaces ();

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

last_remaining = NULL((void*)0);
extras = NULL((void*)0);
i = 0;
tmp = screen->workspaces;
while (tmp != NULL((void*)0))
  {
    MetaWorkspace *w = tmp->data;

    if (i >= new_num)
      extras = g_list_prepend (extras, w);
    else
      last_remaining = w;

    ++i;
    tmp = tmp->next;
  }

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

/* Get rid of the extra workspaces by moving all their windows
 * to last_remaining, then activating last_remaining if
 * one of the removed workspaces was active. This will be a bit
 * wacky if the config tool for changing number of workspaces
 * is on a removed workspace ;-)
 */
need_change_space = FALSE(0);
tmp = extras;
while (tmp != NULL((void*)0))
  {
    MetaWorkspace *w = tmp->data;

    meta_workspace_relocate_windows (w, last_remaining);

    if (w == screen->active_workspace)
      need_change_space = TRUE(!(0));

    tmp = tmp->next;
  }

if (need_change_space)
  meta_workspace_activate (last_remaining, timestamp);

/* Should now be safe to free the workspaces */
tmp = extras;
while (tmp != NULL((void*)0))
  {
    MetaWorkspace *w = tmp->data;

    g_assert (w->windows == NULL)do { if (w->windows == ((void*)0)) ; else g_assertion_message_expr
 ("croma", "core/screen.c", 1164, ((const char*) (__func__)),
 "w->windows == NULL"); } while (0);
    meta_workspace_free (w);

    tmp = tmp->next;
  }

g_list_free (extras);

while (i < new_num)
  {
    meta_workspace_new (screen);
    ++i;
  }

set_number_of_spaces_hint (screen, new_num);

meta_screen_queue_workarea_recalc (screen);
1181}

1183static void
1184update_focus_mode (MetaScreen *screen)
1185{
/* nothing to do anymore */ ;
1187}

1189void
1190meta_screen_set_cursor (MetaScreen *screen,
                      MetaCursor  cursor)
1192{
Cursor xcursor;

if (cursor == screen->current_cursor)
  return;

screen->current_cursor = cursor;

xcursor = meta_display_create_x_cursor (screen->display, cursor);
XDefineCursor (screen->display->xdisplay, screen->xroot, xcursor);
XFlush (screen->display->xdisplay);
XFreeCursor (screen->display->xdisplay, xcursor);
1204}

1206void
1207meta_screen_update_cursor (MetaScreen *screen)
1208{
Cursor xcursor;

xcursor = meta_display_create_x_cursor (screen->display,
			  screen->current_cursor);
XDefineCursor (screen->display->xdisplay, screen->xroot, xcursor);
XFlush (screen->display->xdisplay);
XFreeCursor (screen->display->xdisplay, xcursor);
1216}

1218#define MAX_PREVIEW_SCREEN_FRACTION0.33 0.33
1219#define MAX_PREVIEW_SIZE300 300

1221static cairo_surface_t *
1222get_window_surface (MetaWindow *window)
1223{
cairo_surface_t *surface, *scaled;
cairo_t *cr;
const MetaXineramaScreenInfo *current;
int width, height, max_columns, max_size;
double ratio;

surface = meta_compositor_get_window_surface (window->display->compositor, window);

if (surface == NULL((void*)0))
  return NULL((void*)0);

width = cairo_xlib_surface_get_width (surface);
height = cairo_xlib_surface_get_height (surface);

current = meta_screen_get_current_xinerama (window->screen);
max_columns = meta_prefs_get_alt_tab_max_columns ();

/* Scale surface to fit current screen */
if (width > height)
  {
    max_size = MIN (MAX_PREVIEW_SIZE, current->rect.width / max_columns * MAX_PREVIEW_SCREEN_FRACTION)(((300) < (current->rect.width / max_columns * 0.33)) ?
 (300) : (current->rect.width / max_columns * 0.33));
    ratio = ((double) width) / max_size;
    width = (int) max_size;
    height = (int) (((double) height) / ratio);
  }
else
  {
    max_size = MIN (MAX_PREVIEW_SIZE, current->rect.height / max_columns * MAX_PREVIEW_SCREEN_FRACTION)(((300) < (current->rect.height / max_columns * 0.33)) ?
 (300) : (current->rect.height / max_columns * 0.33));
    ratio = ((double) height) / max_size;
    height = (int) max_size;
    width = (int) (((double) width) / ratio);
  }

meta_error_trap_push (window->display);
scaled = cairo_surface_create_similar (surface,
                                       cairo_surface_get_content (surface),
                                       width, height);
if (meta_error_trap_pop_with_return (window->display, FALSE(0)) != Success0)
  return NULL((void*)0);

cr = cairo_create (scaled);
cairo_scale (cr, 1/ratio, 1/ratio);
cairo_set_source_surface (cr, surface, 0, 0);
cairo_paint (cr);

cairo_destroy (cr);
cairo_surface_destroy (surface);

return scaled;
1273}

1275void
1276meta_screen_ensure_tab_popup (MetaScreen      *screen,
                            MetaTabList      list_type,
                            MetaTabShowType  show_type)
1279{
MetaTabEntry *entries;
GList *tab_list;
GList *tmp;
int len;
int i;
gint border;
int scale;

if (screen->tab_popup)
  return;

tab_list = meta_display_get_tab_list (screen->display,
                                      list_type,
                                      screen,
                                      screen->active_workspace);

len = g_list_length (tab_list);
scale = cdk_window_get_scale_factor (cdk_get_default_root_window ());

entries = g_new (MetaTabEntry, len + 1)((MetaTabEntry *) g_malloc_n ((len + 1), sizeof (MetaTabEntry
)));
entries[len].key = NULL((void*)0);
entries[len].title = NULL((void*)0);
entries[len].icon = NULL((void*)0);
entries[len].win_surface = NULL((void*)0);

border = meta_prefs_show_tab_border() ? BORDER_OUTLINE_TAB |
  BORDER_OUTLINE_WINDOW : BORDER_OUTLINE_TAB;
i = 0;
tmp = tab_list;
while (i < len)
  {
    MetaWindow *window;
    MetaRectangle r;

    window = tmp->data;

    entries[i].key = (MetaTabEntryKey) window->xwindow;
    entries[i].title = window->title;
    entries[i].win_surface = NULL((void*)0);

    entries[i].icon = g_object_ref (window->icon)((__typeof__ (window->icon)) (g_object_ref) (window->icon
));

    /* Only get the window thumbnail surface if the user has a compositor
     * enabled and does NOT have compositing-fast-alt-tab-set to true in
     * GSettings. There is an obvious lag when the surface is retrieved. */
    if (meta_prefs_get_compositing_manager() && !meta_prefs_get_compositing_fast_alt_tab())
      {
        cairo_surface_t *win_surface;

        /* Get window thumbnail */
        win_surface = get_window_surface (window);

        if (win_surface != NULL((void*)0))
          {
            cairo_surface_t *surface, *icon;
            cairo_t *cr;
            int width, height, icon_width, icon_height;

1338#define ICON_OFFSET6 6

            width = cairo_xlib_surface_get_width (win_surface);
            height = cairo_xlib_surface_get_height (win_surface);

            /* Create a new surface to overlap the window icon into */
            surface = cairo_surface_create_similar (win_surface,
                                                    cairo_surface_get_content (win_surface),
                                                    width, height);

            cr = cairo_create (surface);
            cairo_set_source_surface (cr, win_surface, 0, 0);
            cairo_paint (cr);

            /* Get the window icon as a surface */
            icon = cdk_cairo_surface_create_from_pixbuf (window->icon, scale, NULL((void*)0));

            icon_width = cairo_image_surface_get_width (icon) / scale;
            icon_height = cairo_image_surface_get_height (icon) / scale;

            /* Overlap the window icon surface over the window thumbnail */
            cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
            cairo_set_source_surface (cr, icon,
                                      width  - icon_width - ICON_OFFSET6,
                                      height - icon_height - ICON_OFFSET6);
            cairo_paint (cr);

            entries[i].win_surface = surface;

            cairo_destroy (cr);
            cairo_surface_destroy (icon);
            cairo_surface_destroy (win_surface);
          }
      }

    entries[i].blank = FALSE(0);
    entries[i].hidden = !meta_window_showing_on_its_workspace (window);
    entries[i].demands_attention = window->wm_state_demands_attention;

    if (show_type == META_TAB_SHOW_INSTANTLY ||
        !entries[i].hidden                   ||
        !meta_window_get_icon_geometry (window, &r))
      meta_window_get_outer_rect (window, &r);

    entries[i].rect = r;

    /* Find inside of highlight rectangle to be used when window is
     * outlined for tabbing.  This should be the size of the
     * east/west frame, and the size of the south frame, on those
     * sides.  On the top it should be the size of the south frame
     * edge.
     */
     if (border & BORDER_OUTLINE_WINDOW)
     {
1392#define OUTLINE_WIDTH5 5
       /* Top side */
       entries[i].inner_rect.y = OUTLINE_WIDTH5;

       /* Bottom side */
       entries[i].inner_rect.height = r.height - entries[i].inner_rect.y - OUTLINE_WIDTH5;

       /* Left side */
       entries[i].inner_rect.x = OUTLINE_WIDTH5;

       /* Right side */
       entries[i].inner_rect.width = r.width - entries[i].inner_rect.x - OUTLINE_WIDTH5;
     }

    ++i;
    tmp = tmp->next;
  }

screen->tab_popup = meta_ui_tab_popup_new (entries,
                                           len,
                                           meta_prefs_get_alt_tab_max_columns(),
                                           meta_prefs_get_alt_tab_expand_to_fit_title(),
                                           border);

for (i = 0; i < len; i++)
  {
    g_object_unref (entries[i].icon);
    if (entries[i].win_surface)
      cairo_surface_destroy (entries[i].win_surface);
  }

g_free (entries);

g_list_free (tab_list);

/* don't show tab popup, since proper window isn't selected yet */
1428}

1430void
1431meta_screen_ensure_workspace_popup (MetaScreen *screen)
1432{
MetaTabEntry *entries;
int len;
int i;
MetaWorkspaceLayout layout;
int n_workspaces;
int current_workspace;

if (screen->tab_popup)
  return;

current_workspace = meta_workspace_index (screen->active_workspace);
n_workspaces = meta_screen_get_n_workspaces (screen);

meta_screen_calc_workspace_layout (screen, n_workspaces,
                                   current_workspace, &layout);

len = layout.grid_area;

entries = g_new (MetaTabEntry, len + 1)((MetaTabEntry *) g_malloc_n ((len + 1), sizeof (MetaTabEntry
)));
entries[len].key = NULL((void*)0);
entries[len].title = NULL((void*)0);
entries[len].icon = NULL((void*)0);
entries[len].win_surface = NULL((void*)0);

i = 0;
while (i < len)
  {
    if (layout.grid[i] >= 0)
      {
        MetaWorkspace *workspace;

        workspace = meta_screen_get_workspace_by_index (screen,
                                                        layout.grid[i]);

        entries[i].key = (MetaTabEntryKey) workspace;
        entries[i].title = meta_workspace_get_name (workspace);
        entries[i].icon = NULL((void*)0);
        entries[i].win_surface = NULL((void*)0);
        entries[i].blank = FALSE(0);

        g_assert (entries[i].title != NULL)do { if (entries[i].title != ((void*)0)) ; else g_assertion_message_expr
 ("croma", "core/screen.c", 1473, ((const char*) (__func__)),
 "entries[i].title != NULL"); } while (0);
      }
    else
      {
        entries[i].key = NULL((void*)0);
        entries[i].title = NULL((void*)0);
        entries[i].icon = NULL((void*)0);
        entries[i].win_surface = NULL((void*)0);
        entries[i].blank = TRUE(!(0));
      }
    entries[i].hidden = FALSE(0);
    entries[i].demands_attention = FALSE(0);

    ++i;
  }

screen->tab_popup = meta_ui_tab_popup_new (entries,
                                           len,
                                           layout.cols,
                                           FALSE(0), /* expand_for_titles */
                                           BORDER_OUTLINE_WORKSPACE);

g_free (entries);
meta_screen_free_workspace_layout (&layout);

/* don't show tab popup, since proper space isn't selected yet */
1499}

1501static gboolean
1502meta_screen_tile_preview_update_timeout (gpointer data)
1503{
MetaScreen *screen = data;
MetaWindow *window = screen->display->grab_window;
gboolean needs_preview = FALSE(0);

screen->tile_preview_timeout_id = 0;

if (!screen->tile_preview)
  screen->tile_preview = meta_tile_preview_new ();

if (window)
  {
    switch (window->tile_mode)
      {     
      case META_TILE_MAXIMIZED:
        if (!META_WINDOW_MAXIMIZED (window)((window)->maximized_horizontally && (window)->
maximized_vertically))
          needs_preview = TRUE(!(0));
        break;
            
      case META_TILE_NONE:
        needs_preview = FALSE(0);
        break;

      default:
        if (!META_WINDOW_SIDE_TILED (window)((window)->tiled && ((window)->tile_mode == META_TILE_LEFT
 || (window)->tile_mode == META_TILE_RIGHT)))
          needs_preview = TRUE(!(0));
        break;

      }
  }

if (needs_preview)
  {
    MetaRectangle tile_rect;

    meta_window_get_current_tile_area (window, &tile_rect);
    meta_tile_preview_show (screen->tile_preview, &tile_rect, screen);
  }
else
  meta_tile_preview_hide (screen->tile_preview);

return FALSE(0);
1545}

1547#define TILE_PREVIEW_TIMEOUT_MS200 200

1549void
1550meta_screen_tile_preview_update (MetaScreen *screen,
                               gboolean    delay)
1552{
if (delay)
  {
    if (screen->tile_preview_timeout_id > 0)
      return;

    screen->tile_preview_timeout_id =
      g_timeout_add (TILE_PREVIEW_TIMEOUT_MS200,
                     meta_screen_tile_preview_update_timeout,
                     screen);
  }
else
  {
    if (screen->tile_preview_timeout_id > 0)
      g_source_remove (screen->tile_preview_timeout_id);

    meta_screen_tile_preview_update_timeout ((gpointer)screen);
  }
1570}

1572void
1573meta_screen_tile_preview_hide (MetaScreen *screen)
1574{
if (screen->tile_preview_timeout_id > 0)
  g_source_remove (screen->tile_preview_timeout_id);

if (screen->tile_preview)
  meta_tile_preview_hide (screen->tile_preview);
1580}

1582MetaWindow*
1583meta_screen_get_mouse_window (MetaScreen  *screen,
                            MetaWindow  *not_this_one)
1585{
MetaWindow *window;
Window root_return, child_return;
int root_x_return, root_y_return;
int win_x_return, win_y_return;
unsigned int mask_return;

if (not_this_one)
  meta_topicmeta_topic_real (META_DEBUG_FOCUS,
              "Focusing mouse window excluding %s\n", not_this_one->desc);

meta_error_trap_push (screen->display);
XQueryPointer (screen->display->xdisplay,
               screen->xroot,
               &root_return,
               &child_return,
               &root_x_return,
               &root_y_return,
               &win_x_return,
               &win_y_return,
               &mask_return);
meta_error_trap_pop (screen->display, TRUE(!(0)));

window = meta_stack_get_default_focus_window_at_point (screen->stack,
                                                       screen->active_workspace,
                                                       not_this_one,
                                                       root_x_return,
                                                       root_y_return);

return window;
1615}

1617const MetaXineramaScreenInfo*
1618meta_screen_get_xinerama_for_rect (MetaScreen    *screen,
		   MetaRectangle *rect)
1620{
int i;
int best_xinerama, xinerama_score;

if (screen->n_xinerama_infos == 1)
  return &screen->xinerama_infos[0];

best_xinerama = 0;
xinerama_score = 0;

for (i = 0; i < screen->n_xinerama_infos; i++)
  {
    MetaRectangle dest;
    if (meta_rectangle_intersect (&screen->xinerama_infos[i].rect,
                                  rect,
                                  &dest))
      {
        int cur = meta_rectangle_area (&dest);
        if (cur > xinerama_score)
          {
            xinerama_score = cur;
            best_xinerama = i;
          }
      }
  }

return &screen->xinerama_infos[best_xinerama];
1647}

1649const MetaXineramaScreenInfo*
1650meta_screen_get_xinerama_for_window (MetaScreen *screen,
		     MetaWindow *window)
1652{
MetaRectangle window_rect;

meta_window_get_outer_rect (window, &window_rect);

return meta_screen_get_xinerama_for_rect (screen, &window_rect);
1658}

1660const MetaXineramaScreenInfo*
1661meta_screen_get_xinerama_neighbor (MetaScreen         *screen,
                                 int                 which_xinerama,
                                 MetaScreenDirection direction)
1664{
MetaXineramaScreenInfo* input = screen->xinerama_infos + which_xinerama;
MetaXineramaScreenInfo* current;
int i;

for (i = 0; i < screen->n_xinerama_infos; i++)
  {
    current = screen->xinerama_infos + i;

    if ((direction == META_SCREEN_RIGHT &&
         current->rect.x == input->rect.x + input->rect.width &&
         meta_rectangle_vert_overlap(&current->rect, &input->rect)) ||
        (direction == META_SCREEN_LEFT &&
         input->rect.x == current->rect.x + current->rect.width &&
         meta_rectangle_vert_overlap(&current->rect, &input->rect)) ||
        (direction == META_SCREEN_UP &&
         input->rect.y == current->rect.y + current->rect.height &&
         meta_rectangle_horiz_overlap(&current->rect, &input->rect)) ||
        (direction == META_SCREEN_DOWN &&
         current->rect.y == input->rect.y + input->rect.height &&
         meta_rectangle_horiz_overlap(&current->rect, &input->rect)))
      {
        return current;
      }
  }

return NULL((void*)0);
1691}

1693void
1694meta_screen_get_natural_xinerama_list (MetaScreen *screen,
                                     int**       xineramas_list,
                                     int*        n_xineramas)
1697{
const MetaXineramaScreenInfo* current;
GQueue* xinerama_queue;
int* visited;
int cur = 0;
int i;

*n_xineramas = screen->n_xinerama_infos;
*xineramas_list = g_new (int, screen->n_xinerama_infos)((int *) g_malloc_n ((screen->n_xinerama_infos), sizeof (int
)));

/* we calculate a natural ordering by which to choose xineramas for
 * window placement.  We start at the current xinerama, and perform
 * a breadth-first search of the xineramas starting from that
 * xinerama.  We choose preferentially left, then right, then down,
 * then up.  The visitation order produced by this traversal is the
 * natural xinerama ordering.
 */

visited = g_new (int, screen->n_xinerama_infos)((int *) g_malloc_n ((screen->n_xinerama_infos), sizeof (int
)));
for (i = 0; i < screen->n_xinerama_infos; i++)
1
Assuming 'i' is < field 'n_xinerama_infos'→
2
←
Loop condition is true.  Entering loop body→
3
←
Assuming 'i' is >= field 'n_xinerama_infos'→
4
←
Loop condition is false. Execution continues on line 1721→
  {
    visited[i] = FALSE(0);
  }

current = meta_screen_get_current_xinerama (screen);
xinerama_queue = g_queue_new ();
g_queue_push_tail (xinerama_queue, (gpointer) current);
visited[current->number] = TRUE(!(0));

while (!g_queue_is_empty (xinerama_queue))
5
←
Assuming the condition is true→
6
←
Loop condition is true.  Entering loop body→
9
←
Assuming the condition is true→
10
←
Loop condition is true.  Entering loop body→
  {
    const MetaXineramaScreenInfo* tmp;

    current = (const MetaXineramaScreenInfo*)
      g_queue_pop_head (xinerama_queue);

    (*xineramas_list)[cur++] = current->number;
11
←
Out of bound memory access (access exceeds upper limit of memory block)

    /* enqueue each of the directions */
    tmp = meta_screen_get_xinerama_neighbor (screen,
                                             current->number,
                                             META_SCREEN_LEFT);
    if (tmp6.1
'tmp' is null
 && !visited[tmp->number])
      {
        g_queue_push_tail (xinerama_queue,
                           (MetaXineramaScreenInfo*) tmp);
        visited[tmp->number] = TRUE(!(0));
      }
    tmp = meta_screen_get_xinerama_neighbor (screen,
                                             current->number,
                                             META_SCREEN_RIGHT);
    if (tmp6.2
'tmp' is null
 && !visited[tmp->number])
      {
        g_queue_push_tail (xinerama_queue,
                           (MetaXineramaScreenInfo*) tmp);
        visited[tmp->number] = TRUE(!(0));
      }
    tmp = meta_screen_get_xinerama_neighbor (screen,
                                             current->number,
                                             META_SCREEN_UP);
    if (tmp && !visited[tmp->number])
7
←
Assuming 'tmp' is null→
      {
        g_queue_push_tail (xinerama_queue,
                           (MetaXineramaScreenInfo*) tmp);
        visited[tmp->number] = TRUE(!(0));
      }
    tmp = meta_screen_get_xinerama_neighbor (screen,
                                             current->number,
                                             META_SCREEN_DOWN);
    if (tmp && !visited[tmp->number])
8
←
Assuming 'tmp' is null→
      {
        g_queue_push_tail (xinerama_queue,
                           (MetaXineramaScreenInfo*) tmp);
        visited[tmp->number] = TRUE(!(0));
      }
  }

/* in case we somehow missed some set of xineramas, go through the
 * visited list and add in any xineramas that were missed
 */
for (i = 0; i < screen->n_xinerama_infos; i++)
  {
    if (visited[i] == FALSE(0))
      {
        (*xineramas_list)[cur++] = i;
      }
  }

g_free (visited);
g_queue_free (xinerama_queue);
1787}

1789const MetaXineramaScreenInfo*
1790meta_screen_get_current_xinerama (MetaScreen *screen)
1791{
if (screen->n_xinerama_infos == 1)
  return &screen->xinerama_infos[0];

/* Sadly, we have to do it this way. Yuck.
 */

if (screen->display->xinerama_cache_invalidated)
  {
    Window root_return, child_return;
    int win_x_return, win_y_return;
    unsigned int mask_return;
    int i;
    MetaRectangle pointer_position;

    screen->display->xinerama_cache_invalidated = FALSE(0);

    pointer_position.width = pointer_position.height = 1;
    XQueryPointer (screen->display->xdisplay,
                   screen->xroot,
                   &root_return,
                   &child_return,
                   &pointer_position.x,
                   &pointer_position.y,
                   &win_x_return,
                   &win_y_return,
                   &mask_return);

    screen->last_xinerama_index = 0;
    for (i = 0; i < screen->n_xinerama_infos; i++)
      {
        if (meta_rectangle_contains_rect (&screen->xinerama_infos[i].rect,
                                          &pointer_position))
          {
            screen->last_xinerama_index = i;
            break;
          }
      }

    meta_topicmeta_topic_real (META_DEBUG_XINERAMA,
                "Rechecked current Xinerama, now %d\n",
                screen->last_xinerama_index);
  }

return &screen->xinerama_infos[screen->last_xinerama_index];
1836}

1838#define _NET_WM_ORIENTATION_HORZ0 0
1839#define _NET_WM_ORIENTATION_VERT1 1

1841#define _NET_WM_TOPLEFT0     0
1842#define _NET_WM_TOPRIGHT1    1
1843#define _NET_WM_BOTTOMRIGHT2 2
1844#define _NET_WM_BOTTOMLEFT3  3

1846void
1847meta_screen_update_workspace_layout (MetaScreen *screen)
1848{
gulong *list;
int n_items;

list = NULL((void*)0);
n_items = 0;

if (meta_prop_get_cardinal_list (screen->display,
                                 screen->xroot,
                                 screen->display->atom__NET_DESKTOP_LAYOUT,
                                 &list, &n_items))
  {
    if (n_items == 3 || n_items == 4)
      {
        int cols, rows;

        switch (list[0])
          {
          case _NET_WM_ORIENTATION_HORZ0:
            screen->vertical_workspaces = FALSE(0);
            break;
          case _NET_WM_ORIENTATION_VERT1:
            screen->vertical_workspaces = TRUE(!(0));
            break;
          default:
            meta_warning ("Someone set a weird orientation in _NET_DESKTOP_LAYOUT\n");
            break;
          }

        cols = list[1];
        rows = list[2];

        if (rows <= 0 && cols <= 0)
          {
            meta_warning ("Columns = %d rows = %d in _NET_DESKTOP_LAYOUT makes no sense\n", rows, cols);
          }
        else
          {
            if (rows > 0)
              screen->rows_of_workspaces = rows;
            else
              screen->rows_of_workspaces = -1;

            if (cols > 0)
              screen->columns_of_workspaces = cols;
            else
              screen->columns_of_workspaces = -1;
          }

        if (n_items == 4)
          {
            switch (list[3])
              {
                case _NET_WM_TOPLEFT0:
                  screen->starting_corner = META_SCREEN_TOPLEFT;
                  break;
                case _NET_WM_TOPRIGHT1:
                  screen->starting_corner = META_SCREEN_TOPRIGHT;
                  break;
                case _NET_WM_BOTTOMRIGHT2:
                  screen->starting_corner = META_SCREEN_BOTTOMRIGHT;
                  break;
                case _NET_WM_BOTTOMLEFT3:
                  screen->starting_corner = META_SCREEN_BOTTOMLEFT;
                  break;
                default:
                  meta_warning ("Someone set a weird starting corner in _NET_DESKTOP_LAYOUT\n");
                  break;
              }
          }
        else
          screen->starting_corner = META_SCREEN_TOPLEFT;
      }
    else
      {
        meta_warning ("Someone set _NET_DESKTOP_LAYOUT to %d integers instead of 4 "
                      "(3 is accepted for backwards compat)\n", n_items);
      }

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

meta_verbosemeta_verbose_real ("Workspace layout rows = %d cols = %d orientation = %d starting corner = %u\n",
              screen->rows_of_workspaces,
              screen->columns_of_workspaces,
              screen->vertical_workspaces,
              screen->starting_corner);
1935}

1937static void
1938set_workspace_names (MetaScreen *screen)
1939{
/* This updates names on root window when the pref changes,
 * note we only get prefs change notify if things have
 * really changed.
 */
GString *flattened;
int i;
int n_spaces;

/* flatten to nul-separated list */
n_spaces = meta_screen_get_n_workspaces (screen);
flattened = g_string_new ("");
i = 0;
while (i < n_spaces)
  {
    const char *name;

    name = meta_prefs_get_workspace_name (i);

    if (name)
      g_string_append_len (flattened, name,
                           strlen (name) + 1);
    else
      g_string_append_len (flattened, "", 1);

    ++i;
  }

meta_error_trap_push (screen->display);
XChangeProperty (screen->display->xdisplay,
                 screen->xroot,
                 screen->display->atom__NET_DESKTOP_NAMES,
   screen->display->atom_UTF8_STRING,
                 8, PropModeReplace0,
   (unsigned char *)flattened->str, flattened->len);
meta_error_trap_pop (screen->display, FALSE(0));

g_string_free (flattened, TRUE(!(0)));
1977}

1979void
1980meta_screen_update_workspace_names (MetaScreen *screen)
1981{
char **names;
int n_names;
int i;

/* this updates names in prefs when the root window property changes,
 * iff the new property contents don't match what's already in prefs
 */

names = NULL((void*)0);
n_names = 0;
if (!meta_prop_get_utf8_list (screen->display,
                              screen->xroot,
                              screen->display->atom__NET_DESKTOP_NAMES,
                              &names, &n_names))
  {
    meta_verbosemeta_verbose_real ("Failed to get workspace names from root window %d\n",
                  screen->number);
    return;
  }

i = 0;
while (i < n_names)
  {
    meta_topicmeta_topic_real (META_DEBUG_PREFS,
                "Setting workspace %d name to \"%s\" due to _NET_DESKTOP_NAMES change\n",
                i, names[i] ? names[i] : "null");
    meta_prefs_change_workspace_name (i, names[i]);

    ++i;
  }

g_strfreev (names);
2014}

2016Window
2017meta_create_offscreen_window (Display *xdisplay,
                            Window   parent,
                            long     valuemask)
2020{
XSetWindowAttributes attrs;

/* we want to be override redirect because sometimes we
 * create a window on a screen we aren't managing.
 * (but on a display we are managing at least one screen for)
 */
attrs.override_redirect = True1;
attrs.event_mask = valuemask;

return XCreateWindow (xdisplay,
                      parent,
                      -100, -100, 1, 1,
                      0,
                      CopyFromParent0L,
                      CopyFromParent0L,
                      (Visual *)CopyFromParent0L,
                      CWOverrideRedirect(1L<<9) | CWEventMask(1L<<11),
                      &attrs);
2039}

2041static void
2042set_work_area_hint (MetaScreen *screen)
2043{
int num_workspaces;
GList *tmp_list;
unsigned long *data, *tmp;
MetaRectangle area;

num_workspaces = meta_screen_get_n_workspaces (screen);
data = g_new (unsigned long, num_workspaces * 4)((unsigned long *) g_malloc_n ((num_workspaces * 4), sizeof (
unsigned long)));
tmp_list = screen->workspaces;
tmp = data;

while (tmp_list != NULL((void*)0))
  {
    MetaWorkspace *workspace = tmp_list->data;

    if (workspace->screen == screen)
      {
        meta_workspace_get_work_area_all_xineramas (workspace, &area);
        tmp[0] = area.x;
        tmp[1] = area.y;
        tmp[2] = area.width;
        tmp[3] = area.height;

 tmp += 4;
      }

    tmp_list = tmp_list->next;
  }

meta_error_trap_push (screen->display);
XChangeProperty (screen->display->xdisplay, screen->xroot,
   screen->display->atom__NET_WORKAREA,
   XA_CARDINAL((Atom) 6), 32, PropModeReplace0,
   (guchar*) data, num_workspaces*4);
g_free (data);
meta_error_trap_pop (screen->display, FALSE(0));
2079}

2081static gboolean
2082set_work_area_idle_func (MetaScreen *screen)
2083{
meta_topicmeta_topic_real (META_DEBUG_WORKAREA,
            "Running work area idle function\n");

screen->work_area_idle = 0;

set_work_area_hint (screen);

return FALSE(0);
2092}

2094void
2095meta_screen_queue_workarea_recalc (MetaScreen *screen)
2096{
/* Recompute work area in an idle */
if (screen->work_area_idle == 0)
  {
    meta_topicmeta_topic_real (META_DEBUG_WORKAREA,
                "Adding work area hint idle function\n");
    screen->work_area_idle =
      g_idle_add_full (META_PRIORITY_WORK_AREA_HINT(200 + 15),
                       (GSourceFunc) set_work_area_idle_func,
                       screen,
                       NULL((void*)0));
  }
2108}


2111#ifdef WITH_VERBOSE_MODE1
2112static char *
2113meta_screen_corner_to_string (MetaScreenCorner corner)
2114{
switch (corner)
  {
  case META_SCREEN_TOPLEFT:
    return "TopLeft";
  case META_SCREEN_TOPRIGHT:
    return "TopRight";
  case META_SCREEN_BOTTOMLEFT:
    return "BottomLeft";
  case META_SCREEN_BOTTOMRIGHT:
    return "BottomRight";
  }

return "Unknown";
2128}
2129#endif /* WITH_VERBOSE_MODE */

2131void
2132meta_screen_calc_workspace_layout (MetaScreen          *screen,
                                 int                  num_workspaces,
                                 int                  current_space,
                                 MetaWorkspaceLayout *layout)
2136{
int rows, cols;
int grid_area;
int *grid;
int i, r, c;
int current_row, current_col;

rows = screen->rows_of_workspaces;
cols = screen->columns_of_workspaces;
if (rows <= 0 && cols <= 0)
  cols = num_workspaces;

if (rows <= 0)
  rows = num_workspaces / cols + ((num_workspaces % cols) > 0 ? 1 : 0);
if (cols <= 0)
  cols = num_workspaces / rows + ((num_workspaces % rows) > 0 ? 1 : 0);

/* paranoia */
if (rows < 1)
  rows = 1;
if (cols < 1)
  cols = 1;

g_assert (rows != 0 && cols != 0)do { if (rows != 0 && cols != 0) ; else g_assertion_message_expr
 ("croma", "core/screen.c", 2159, ((const char*) (__func__)),
 "rows != 0 && cols != 0"); } while (0);

grid_area = rows * cols;

meta_verbosemeta_verbose_real ("Getting layout rows = %d cols = %d current = %d "
              "num_spaces = %d vertical = %s corner = %s\n",
              rows, cols, current_space, num_workspaces,
              screen->vertical_workspaces ? "(true)" : "(false)",
              meta_screen_corner_to_string (screen->starting_corner));

/* ok, we want to setup the distances in the workspace array to go
 * in each direction. Remember, there are many ways that a workspace
 * array can be setup.
 * see http://www.freedesktop.org/standards/wm-spec/1.2/html/x109.html
 * and look at the _NET_DESKTOP_LAYOUT section for details.
 * For instance:
 */
/* starting_corner = META_SCREEN_TOPLEFT
 *  vertical_workspaces = 0                 vertical_workspaces=1
 *       1234                                    1357
 *       5678                                    2468
 *
 * starting_corner = META_SCREEN_TOPRIGHT
 *  vertical_workspaces = 0                 vertical_workspaces=1
 *       4321                                    7531
 *       8765                                    8642
 *
 * starting_corner = META_SCREEN_BOTTOMLEFT
 *  vertical_workspaces = 0                 vertical_workspaces=1
 *       5678                                    2468
 *       1234                                    1357
 *
 * starting_corner = META_SCREEN_BOTTOMRIGHT
 *  vertical_workspaces = 0                 vertical_workspaces=1
 *       8765                                    8642
 *       4321                                    7531
 *
 */
/* keep in mind that we could have a ragged layout, e.g. the "8"
 * in the above grids could be missing
 */


grid = g_new (int, grid_area)((int *) g_malloc_n ((grid_area), sizeof (int)));

i = 0;
switch (screen->starting_corner)
  {
  case META_SCREEN_TOPLEFT:
    if (screen->vertical_workspaces)
      {
        c = 0;
        while (c < cols)
          {
            r = 0;
            while (r < rows)
              {
                grid[r*cols+c] = i;
                ++i;
                ++r;
              }
            ++c;
          }
      }
    else
      {
        r = 0;
        while (r < rows)
          {
            c = 0;
            while (c < cols)
              {
                grid[r*cols+c] = i;
                ++i;
                ++c;
              }
            ++r;
          }
      }
    break;
  case META_SCREEN_TOPRIGHT:
    if (screen->vertical_workspaces)
      {
        c = cols - 1;
        while (c >= 0)
          {
            r = 0;
            while (r < rows)
              {
                grid[r*cols+c] = i;
                ++i;
                ++r;
              }
            --c;
          }
      }
    else
      {
        r = 0;
        while (r < rows)
          {
            c = cols - 1;
            while (c >= 0)
              {
                grid[r*cols+c] = i;
                ++i;
                --c;
              }
            ++r;
          }
      }
    break;
  case META_SCREEN_BOTTOMLEFT:
    if (screen->vertical_workspaces)
      {
        c = 0;
        while (c < cols)
          {
            r = rows - 1;
            while (r >= 0)
              {
                grid[r*cols+c] = i;
                ++i;
                --r;
              }
            ++c;
          }
      }
    else
      {
        r = rows - 1;
        while (r >= 0)
          {
            c = 0;
            while (c < cols)
              {
                grid[r*cols+c] = i;
                ++i;
                ++c;
              }
            --r;
          }
      }
    break;
  case META_SCREEN_BOTTOMRIGHT:
    if (screen->vertical_workspaces)
      {
        c = cols - 1;
        while (c >= 0)
          {
            r = rows - 1;
            while (r >= 0)
              {
                grid[r*cols+c] = i;
                ++i;
                --r;
              }
            --c;
          }
      }
    else
      {
        r = rows - 1;
        while (r >= 0)
          {
            c = cols - 1;
            while (c >= 0)
              {
                grid[r*cols+c] = i;
                ++i;
                --c;
              }
            --r;
          }
      }
    break;
  }

if (i != grid_area)
  meta_bug ("did not fill in the whole workspace grid in %s (%d filled)\n",
            G_STRFUNC((const char*) (__func__)), i);

current_row = 0;
current_col = 0;
r = 0;
while (r < rows)
  {
    c = 0;
    while (c < cols)
      {
        if (grid[r*cols+c] == current_space)
          {
            current_row = r;
            current_col = c;
          }
        else if (grid[r*cols+c] >= num_workspaces)
          {
            /* flag nonexistent spaces with -1 */
            grid[r*cols+c] = -1;
          }
        ++c;
      }
    ++r;
  }

layout->rows = rows;
layout->cols = cols;
layout->grid = grid;
layout->grid_area = grid_area;
layout->current_row = current_row;
layout->current_col = current_col;

2371#ifdef WITH_VERBOSE_MODE1
if (meta_is_verbose ())
  {
    r = 0;
    while (r < layout->rows)
      {
        meta_verbosemeta_verbose_real (" ");
        meta_push_no_msg_prefix ();
        c = 0;
        while (c < layout->cols)
          {
            if (r == layout->current_row &&
                c == layout->current_col)
              meta_verbosemeta_verbose_real ("*%2d ", layout->grid[r*layout->cols+c]);
            else
              meta_verbosemeta_verbose_real ("%3d ", layout->grid[r*layout->cols+c]);
            ++c;
          }
        meta_verbosemeta_verbose_real ("\n");
        meta_pop_no_msg_prefix ();
        ++r;
      }
  }
2394#endif /* WITH_VERBOSE_MODE */
2395}

2397void
2398meta_screen_free_workspace_layout (MetaWorkspaceLayout *layout)
2399{
g_free (layout->grid);
2401}

2403static void
2404meta_screen_resize_func (MetaScreen *screen,
                       MetaWindow *window,
                       void       *user_data)
2407{
if (window->struts)
  {
    meta_window_update_struts (window);
  }
meta_window_queue (window, META_QUEUE_MOVE_RESIZE);

meta_window_recalc_features (window);
2415}

2417void
2418meta_screen_resize (MetaScreen *screen,
                  int         width,
                  int         height)
2421{
screen->rect.width = width;
screen->rect.height = height;

reload_xinerama_infos (screen);
set_desktop_geometry_hint (screen);

/* Queue a resize on all the windows */
meta_screen_foreach_window (screen, meta_screen_resize_func, 0);
2430}

2432void
2433meta_screen_update_showing_desktop_hint (MetaScreen *screen)
2434{
unsigned long data[1];

data[0] = screen->active_workspace->showing_desktop ? 1 : 0;

meta_error_trap_push (screen->display);
XChangeProperty (screen->display->xdisplay, screen->xroot,
                 screen->display->atom__NET_SHOWING_DESKTOP,
                 XA_CARDINAL((Atom) 6),
                 32, PropModeReplace0, (guchar*) data, 1);
meta_error_trap_pop (screen->display, FALSE(0));
2445}

2447static void
2448queue_windows_showing (MetaScreen *screen)
2449{
GSList *windows;
GSList *tmp;

/* Must operate on all windows on display instead of just on the
 * active_workspace's window list, because the active_workspace's
 * window list may not contain the on_all_workspace windows.
 */
windows = meta_display_list_windows (screen->display);

tmp = windows;
while (tmp != NULL((void*)0))
  {
    MetaWindow *w = tmp->data;

    if (w->screen == screen && !meta_prefs_is_in_skip_list (w->res_class))
      meta_window_queue (w, META_QUEUE_CALC_SHOWING);

    tmp = tmp->next;
  }

g_slist_free (windows);
2471}

2473void
2474meta_screen_minimize_all_on_active_workspace_except (MetaScreen *screen,
                                                   MetaWindow *keep)
2476{
GList *windows;
GList *tmp;

windows = screen->active_workspace->windows;

tmp = windows;
while (tmp != NULL((void*)0))
  {
    MetaWindow *w = tmp->data;

    if (w->screen == screen  &&
        w->has_minimize_func &&
 w != keep)
meta_window_minimize (w);

    tmp = tmp->next;
  }
2494}

2496void
2497meta_screen_show_desktop (MetaScreen *screen,
                        guint32     timestamp)
2499{
GList *windows;

if (screen->active_workspace->showing_desktop)
  return;

screen->active_workspace->showing_desktop = TRUE(!(0));

queue_windows_showing (screen);

/* Focus the most recently used META_WINDOW_DESKTOP window, if there is one;
 * see bug 159257.
 */
windows = screen->active_workspace->mru_list;
while (windows != NULL((void*)0))
  {
    MetaWindow *w = windows->data;

    if (w->screen == screen  &&
        w->type == META_WINDOW_DESKTOP &&
        !meta_prefs_is_in_skip_list (w->res_class))
      {
        meta_window_focus (w, timestamp);
        break;
      }

    windows = windows->next;
  }


meta_screen_update_showing_desktop_hint (screen);
2530}

2532void
2533meta_screen_unshow_desktop (MetaScreen *screen)
2534{
if (!screen->active_workspace->showing_desktop)
  return;

screen->active_workspace->showing_desktop = FALSE(0);

queue_windows_showing (screen);

meta_screen_update_showing_desktop_hint (screen);
2543}


2546#ifdef HAVE_STARTUP_NOTIFICATION
2547static gboolean startup_sequence_timeout (void *data);

2549static void
2550update_startup_feedback (MetaScreen *screen)
2551{
if (screen->startup_sequences != NULL((void*)0))
  {
    meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                "Setting busy cursor\n");
    meta_screen_set_cursor (screen, META_CURSOR_BUSY);
  }
else
  {
    meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                "Setting default cursor\n");
    meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
  }
2564}

2566static void
2567add_sequence (MetaScreen        *screen,
            SnStartupSequence *sequence)
2569{
meta_topicmeta_topic_real (META_DEBUG_STARTUP,
            "Adding sequence %s\n",
            sn_startup_sequence_get_id (sequence));
sn_startup_sequence_ref (sequence);
screen->startup_sequences = g_slist_prepend (screen->startup_sequences,
                                             sequence);

/* our timeout just polls every second, instead of bothering
 * to compute exactly when we may next time out
 */
if (screen->startup_sequence_timeout == 0)
  screen->startup_sequence_timeout = g_timeout_add (1000,
                                                    startup_sequence_timeout,
                                                    screen);

update_startup_feedback (screen);
2586}

2588static void
2589remove_sequence (MetaScreen        *screen,
               SnStartupSequence *sequence)
2591{
meta_topicmeta_topic_real (META_DEBUG_STARTUP,
            "Removing sequence %s\n",
            sn_startup_sequence_get_id (sequence));

screen->startup_sequences = g_slist_remove (screen->startup_sequences,
                                            sequence);
sn_startup_sequence_unref (sequence);

if (screen->startup_sequences == NULL((void*)0) &&
    screen->startup_sequence_timeout != 0)
  {
    g_source_remove (screen->startup_sequence_timeout);
    screen->startup_sequence_timeout = 0;
  }

update_startup_feedback (screen);
2608}

2610typedef struct
2611{
GSList *list;
gint64 now;
2614} CollectTimedOutData;

2616/* This should be fairly long, as it should never be required unless
* apps or .desktop files are buggy, and it's confusing if
* OpenOffice or whatever seems to stop launching - people
* might decide they need to launch it again.
*/
2621#define STARTUP_TIMEOUT15000 15000

2623static void
2624collect_timed_out_foreach (void *element,
                         void *data)
2626{
CollectTimedOutData *ctod = data;
SnStartupSequence *sequence = element;
double elapsed;

time_t tv_sec;
suseconds_t  tv_usec;
gint64 tv;

sn_startup_sequence_get_last_active_time (sequence, &tv_sec, &tv_usec);
tv = (tv_sec * G_USEC_PER_SEC1000000) + tv_usec;
elapsed = (ctod->now - tv) / 1000.0;

meta_topicmeta_topic_real (META_DEBUG_STARTUP,
            "Sequence used %g seconds vs. %g max: %s\n",
            elapsed, (double) STARTUP_TIMEOUT15000,
            sn_startup_sequence_get_id (sequence));

if (elapsed > STARTUP_TIMEOUT15000)
  ctod->list = g_slist_prepend (ctod->list, sequence);
2646}

2648static gboolean
2649startup_sequence_timeout (void *data)
2650{
MetaScreen *screen = data;
CollectTimedOutData ctod;
GSList *tmp;

ctod.list = NULL((void*)0);

ctod.now = g_get_real_time ();
g_slist_foreach (screen->startup_sequences,
                 collect_timed_out_foreach,
                 &ctod);

tmp = ctod.list;
while (tmp != NULL((void*)0))
  {
    SnStartupSequence *sequence = tmp->data;

    meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                "Timed out sequence %s\n",
                sn_startup_sequence_get_id (sequence));

    sn_startup_sequence_complete (sequence);

    tmp = tmp->next;
  }

g_slist_free (ctod.list);

if (screen->startup_sequences != NULL((void*)0))
  {
    return TRUE(!(0));
  }
else
  {
    /* remove */
    screen->startup_sequence_timeout = 0;
    return FALSE(0);
  }
2688}

2690static void
2691meta_screen_sn_event (SnMonitorEvent *event,
                    void           *user_data)
2693{
MetaScreen *screen;
SnStartupSequence *sequence;

screen = user_data;

sequence = sn_monitor_event_get_startup_sequence (event);

switch (sn_monitor_event_get_type (event))
  {
  case SN_MONITOR_EVENT_INITIATED:
    {
      const char *wmclass;

      wmclass = sn_startup_sequence_get_wmclass (sequence);

      meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                  "Received startup initiated for %s wmclass %s\n",
                  sn_startup_sequence_get_id (sequence),
                  wmclass ? wmclass : "(unset)");
      add_sequence (screen, sequence);
    }
    break;

  case SN_MONITOR_EVENT_COMPLETED:
    {
      meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                  "Received startup completed for %s\n",
                  sn_startup_sequence_get_id (sequence));
      remove_sequence (screen,
                       sn_monitor_event_get_startup_sequence (event));
    }
    break;

  case SN_MONITOR_EVENT_CHANGED:
    meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                "Received startup changed for %s\n",
                sn_startup_sequence_get_id (sequence));
    break;

  case SN_MONITOR_EVENT_CANCELED:
    meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                "Received startup canceled for %s\n",
                sn_startup_sequence_get_id (sequence));
    break;
  }
2739}
2740#endif

2742/* Sets the initial_timestamp and initial_workspace properties
* of a window according to information given us by the
* startup-notification library.
*
* Returns TRUE if startup properties have been applied, and
* FALSE if they have not (for example, if they had already
* been applied.)
*/
2750gboolean
2751meta_screen_apply_startup_properties (MetaScreen *screen,
                                    MetaWindow *window)
2753{
2754#ifdef HAVE_STARTUP_NOTIFICATION
const char *startup_id;
GSList *tmp;
SnStartupSequence *sequence;

/* Does the window have a startup ID stored? */
startup_id = meta_window_get_startup_id (window);

meta_topicmeta_topic_real (META_DEBUG_STARTUP,
            "Applying startup props to %s id \"%s\"\n",
            window->desc,
            startup_id ? startup_id : "(none)");

sequence = NULL((void*)0);
if (startup_id == NULL((void*)0))
  {
    /* No startup ID stored for the window. Let's ask the
     * startup-notification library whether there's anything
     * stored for the resource name or resource class hints.
     */
    tmp = screen->startup_sequences;
    while (tmp != NULL((void*)0))
      {
        const char *wmclass;

        wmclass = sn_startup_sequence_get_wmclass (tmp->data);

        if (wmclass != NULL((void*)0) &&
            ((window->res_class &&
              strcmp (wmclass, window->res_class) == 0) ||
             (window->res_name &&
              strcmp (wmclass, window->res_name) == 0)))
          {
            sequence = tmp->data;

            g_assert (window->startup_id == NULL)do { if (window->startup_id == ((void*)0)) ; else g_assertion_message_expr
 ("croma", "core/screen.c", 2789, ((const char*) (__func__)),
 "window->startup_id == NULL"); } while (0);
            window->startup_id = g_strdup (sn_startup_sequence_get_id (sequence));
            startup_id = window->startup_id;

            meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                        "Ending legacy sequence %s due to window %s\n",
                        sn_startup_sequence_get_id (sequence),
                        window->desc);

            sn_startup_sequence_complete (sequence);
            break;
          }

        tmp = tmp->next;
      }
  }

/* Still no startup ID? Bail. */
if (startup_id == NULL((void*)0))
  return FALSE(0);

/* We might get this far and not know the sequence ID (if the window
 * already had a startup ID stored), so let's look for one if we don't
 * already know it.
 */
if (sequence == NULL((void*)0))
  {
    tmp = screen->startup_sequences;
    while (tmp != NULL((void*)0))
      {
        const char *id;

        id = sn_startup_sequence_get_id (tmp->data);

        if (strcmp (id, startup_id) == 0)
          {
            sequence = tmp->data;
            break;
          }

        tmp = tmp->next;
      }
  }

if (sequence != NULL((void*)0))
  {
    gboolean changed_something = FALSE(0);

    meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                "Found startup sequence for window %s ID \"%s\"\n",
                window->desc, startup_id);

    if (!window->initial_workspace_set)
      {
        int space = sn_startup_sequence_get_workspace (sequence);
        if (space >= 0)
          {
            meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                        "Setting initial window workspace to %d based on startup info\n",
                        space);

            window->initial_workspace_set = TRUE(!(0));
            window->initial_workspace = space;
            changed_something = TRUE(!(0));
          }
      }

    if (!window->initial_timestamp_set)
      {
        guint32 timestamp = sn_startup_sequence_get_timestamp (sequence);
        meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                    "Setting initial window timestamp to %u based on startup info\n",
                    timestamp);

        window->initial_timestamp_set = TRUE(!(0));
        window->initial_timestamp = timestamp;
        changed_something = TRUE(!(0));
      }

    return changed_something;
  }
else
  {
    meta_topicmeta_topic_real (META_DEBUG_STARTUP,
                "Did not find startup sequence for window %s ID \"%s\"\n",
                window->desc, startup_id);
  }

2877#endif /* HAVE_STARTUP_NOTIFICATION */

return FALSE(0);
2880}

2882int
2883meta_screen_get_screen_number (MetaScreen *screen)
2884{
return screen->number;
2886}

2888MetaDisplay *
2889meta_screen_get_display (MetaScreen *screen)
2890{
return screen->display;
2892}

2894Window
2895meta_screen_get_xroot (MetaScreen *screen)
2896{
return screen->xroot;
2898}

2900void
2901meta_screen_get_size (MetaScreen *screen,
                    int        *width,
                    int        *height)
2904{
*width = screen->rect.width;
*height = screen->rect.height;
2907}

2909gpointer
2910meta_screen_get_compositor_data (MetaScreen *screen)
2911{
return screen->compositor_data;
2913}

2915void
2916meta_screen_set_compositor_data (MetaScreen *screen,
                               gpointer    compositor)
2918{
screen->compositor_data = compositor;
2920}

2922#ifdef HAVE_COMPOSITE_EXTENSIONS1
2923void
2924meta_screen_set_cm_selection (MetaScreen *screen)
2925{
screen->wm_cm_timestamp = meta_display_get_current_time_roundtrip (
                                                             screen->display);

meta_verbosemeta_verbose_real ("Setting selection for screen: %d\n", screen->number);
XSetSelectionOwner (screen->display->xdisplay, screen->wm_cm_atom,
                    screen->wm_cm_selection_window, screen->wm_cm_timestamp);
2932}

2934void
2935meta_screen_unset_cm_selection (MetaScreen *screen)
2936{
XSetSelectionOwner (screen->display->xdisplay, screen->wm_cm_atom,
                    None0L, screen->wm_cm_timestamp);
2939}

2941gboolean
2942meta_screen_is_cm_selected (MetaScreen *screen)
2943{
Window owner = XGetSelectionOwner (screen->display->xdisplay, screen->wm_cm_atom);
return owner != None0L;
2946}
2947#endif /* HAVE_COMPOSITE_EXTENSIONS */