~ubuntu-branches/ubuntu/raring/metacity/raring
» Revision
122
: .pc/16-capture-before-unmap.patch/src/core/screen.c
« back to all changes in this revision
Viewing changes to .pc/16-capture-before-unmap.patch/src/core/screen.c
- browse files at revision 122
- compare with another revision
- download diff
- download tarball
- view history from revision 122
- Committer: Package Import Robot
- Author(s): Jeremy Bicha
- Date: 2012-08-23 11:12:43 UTC
- mfrom: (1.2.64) (2.1.13 quantal-proposed)
- Revision ID: package-import@ubuntu.com-20120823111243-v2ome3yisozc1dhw
* Resync with Debian & refresh patches. (LP: #1032120, LP: #1035261)
Remaining changes:
* debian/control:
- Suggest gnome-themes-standard instead of recommend
- Add Vcs-Bzr link
* debian/metacity-common.gsettings-override:
- Set Ubuntu default button layout order for Classic session
- Drop previous gconf overrides as obsolete
* debian/patches/04_support_drag_drop_with_alt_tab.patch:
- Support alt-tab during drag and drop.
* debian/patches/05_raise_on_click_for_click_mode.patch:
- Use raise on click option.
* debian/patches/06_Add_UXD_shadows_and_borders.patch:
- patch for a new key in the ubuntu theme for shows and borders
* debian/patches/10_no-ws-switcher.patch:
- Don't show the workspace switcher if we only have one.
* debian/patches/12_dont-show-as-user.patch:
- Don't show "as user" in title bar.
* debian/patches/13_better_support_for_button_layout.patch:
- Corrected support for buttons backgrounds with transparency
* debian/patches/14_wrong_colormap.patch:
- Use correct colormap to avoid crash with client side decorations
* debian/patches/20_do-not-place-windows-over-the-launcher.patch:
- Try to avoid an already visible launcher in intellihide mode when
initially positioning new windows.
* debian/patches/21_fix_compositing_startup.patch:
Fix some weird rendering effect at startup with compositing activated
* debian/patches/100_fade_on_long_title.patch:
- Fade on the end if the title is too long.
* debian/patches/102_workarea.patch,
debian/patches/103_struts_in_the_middle.patch,
debian/patches/104_workarea_union.patch:
- Add barriers and multimonitor strut support for unity-2d
* debian/patches/104_workarea_union.patch:
- Ensure each screen_region generated by
meta_rectangle_get_minimal_spanning_set_for_region is not outside
the xinerama screens
* Dropped patch:
- 11_hide_tooltip_on_decorator.patch: Obsolete
* debian/patches/03_strict_focus.patch:
- Disabled. This needs gsettings-desktop-schemas to be patched if
we want to bring this back
* Disabled Unity 2D-related patches that need porting to gsettings:
- 15_show_maximized_titlebars.patch
- 16-capture-before-unmap.patch
- 17-workspace-switcher-cycle.patch
- 18-auto-maximize-windows.patch
- 19_add_unity_hud_configuration.patch
- 101_override_gconf_settings.patch
Remaining changes:
* debian/control:
- Suggest gnome-themes-standard instead of recommend
- Add Vcs-Bzr link
* debian/metacity-common.gsettings-override:
- Set Ubuntu default button layout order for Classic session
- Drop previous gconf overrides as obsolete
* debian/patches/04_support_drag_drop_with_alt_tab.patch:
- Support alt-tab during drag and drop.
* debian/patches/05_raise_on_click_for_click_mode.patch:
- Use raise on click option.
* debian/patches/06_Add_UXD_shadows_and_borders.patch:
- patch for a new key in the ubuntu theme for shows and borders
* debian/patches/10_no-ws-switcher.patch:
- Don't show the workspace switcher if we only have one.
* debian/patches/12_dont-show-as-user.patch:
- Don't show "as user" in title bar.
* debian/patches/13_better_support_for_button_layout.patch:
- Corrected support for buttons backgrounds with transparency
* debian/patches/14_wrong_colormap.patch:
- Use correct colormap to avoid crash with client side decorations
* debian/patches/20_do-not-place-windows-over-the-launcher.patch:
- Try to avoid an already visible launcher in intellihide mode when
initially positioning new windows.
* debian/patches/21_fix_compositing_startup.patch:
Fix some weird rendering effect at startup with compositing activated
* debian/patches/100_fade_on_long_title.patch:
- Fade on the end if the title is too long.
* debian/patches/102_workarea.patch,
debian/patches/103_struts_in_the_middle.patch,
debian/patches/104_workarea_union.patch:
- Add barriers and multimonitor strut support for unity-2d
* debian/patches/104_workarea_union.patch:
- Ensure each screen_region generated by
meta_rectangle_get_minimal_spanning_set_for_region is not outside
the xinerama screens
* Dropped patch:
- 11_hide_tooltip_on_decorator.patch: Obsolete
* debian/patches/03_strict_focus.patch:
- Disabled. This needs gsettings-desktop-schemas to be patched if
we want to bring this back
* Disabled Unity 2D-related patches that need porting to gsettings:
- 15_show_maximized_titlebars.patch
- 16-capture-before-unmap.patch
- 17-workspace-switcher-cycle.patch
- 18-auto-maximize-windows.patch
- 19_add_unity_hud_configuration.patch
- 101_override_gconf_settings.patch
- files added:
- .pc/.quilt_patches
- .pc/01_focus_new_window.patch
- .pc/01_focus_new_window.patch/src
- .pc/01_focus_new_window.patch/src/core
- files removed:
- .pc/03_strict_focus.patch
- .pc/03_strict_focus.patch/src
- .pc/03_strict_focus.patch/src/core
- .pc/03_strict_focus.patch/src/include
- .pc/101_override_gconf_settings.patch
- .pc/101_override_gconf_settings.patch/src
- .pc/101_override_gconf_settings.patch/src/core
- .pc/101_override_gconf_settings.patch/src/include
- .pc/11_hide_tooltip_on_decorator.patch
- .pc/11_hide_tooltip_on_decorator.patch/src
- .pc/11_hide_tooltip_on_decorator.patch/src/core
- .pc/11_hide_tooltip_on_decorator.patch/src/include
- .pc/11_hide_tooltip_on_decorator.patch/src/ui
- .pc/15_show_maximized_titlebars.patch
- .pc/15_show_maximized_titlebars.patch/src
- .pc/15_show_maximized_titlebars.patch/src/core
- .pc/15_show_maximized_titlebars.patch/src/include
- .pc/15_show_maximized_titlebars.patch/src/ui
- .pc/16-capture-before-unmap.patch
- .pc/16-capture-before-unmap.patch/src
- .pc/16-capture-before-unmap.patch/src/compositor
- .pc/16-capture-before-unmap.patch/src/core
- .pc/16-capture-before-unmap.patch/src/include
- .pc/17-workspace-switcher-cycle.patch
- .pc/17-workspace-switcher-cycle.patch/src
- .pc/17-workspace-switcher-cycle.patch/src/core
- .pc/17-workspace-switcher-cycle.patch/src/include
- .pc/18-auto-maximize-windows.patch
- .pc/18-auto-maximize-windows.patch/src
- .pc/18-auto-maximize-windows.patch/src/core
- .pc/18-auto-maximize-windows.patch/src/include
- .pc/19_add_unity_hud_configuration.patch
- .pc/19_add_unity_hud_configuration.patch/src
- files modified:
- .pc/04_support_drag_drop_with_alt_tab.patch/src/core/display.c
added
removed
.pc/16-capture-before-unmap.patch/src/core/screen.c
1
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2
3
/* Metacity X screen handler */
4
5
/*
6
* Copyright (C) 2001, 2002 Havoc Pennington
7
* Copyright (C) 2002, 2003 Red Hat Inc.
8
* Some ICCCM manager selection code derived from fvwm2,
9
* Copyright (C) 2001 Dominik Vogt, Matthias Clasen, and fvwm2 team
10
* Copyright (C) 2003 Rob Adams
11
* Copyright (C) 2004-2006 Elijah Newren
12
*
13
* This program is free software; you can redistribute it and/or
14
* modify it under the terms of the GNU General Public License as
15
* published by the Free Software Foundation; either version 2 of the
16
* License, or (at your option) any later version.
17
*
18
* This program is distributed in the hope that it will be useful, but
19
* WITHOUT ANY WARRANTY; without even the implied warranty of
20
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21
* General Public License for more details.
22
*
23
* You should have received a copy of the GNU General Public License
24
* along with this program; if not, write to the Free Software
25
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26
* 02111-1307, USA.
27
*/
28
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 "stack.h"
39
#include "xprops.h"
40
#include "compositor.h"
41
42
#ifdef HAVE_SOLARIS_XINERAMA
43
#include <X11/extensions/xinerama.h>
44
#endif
45
#ifdef HAVE_XFREE_XINERAMA
46
#include <X11/extensions/Xinerama.h>
47
#endif
48
49
#include <X11/Xatom.h>
50
#include <locale.h>
51
#include <string.h>
52
#include <stdio.h>
53
54
static char* get_screen_name (MetaDisplay *display,
55
int number);
56
57
static void update_num_workspaces (MetaScreen *screen,
58
guint32 timestamp);
59
static void update_focus_mode (MetaScreen *screen);
60
static void set_workspace_names (MetaScreen *screen);
61
static void prefs_changed_callback (MetaPreference pref,
62
gpointer data);
63
64
static void set_desktop_geometry_hint (MetaScreen *screen);
65
static void set_desktop_viewport_hint (MetaScreen *screen);
66
67
#ifdef HAVE_STARTUP_NOTIFICATION
68
static void meta_screen_sn_event (SnMonitorEvent *event,
69
void *user_data);
70
#endif
71
72
static int
73
set_wm_check_hint (MetaScreen *screen)
74
{
75
unsigned long data[1];
76
77
g_return_val_if_fail (screen->display->leader_window != None, 0);
78
79
data[0] = screen->display->leader_window;
80
81
XChangeProperty (screen->display->xdisplay, screen->xroot,
82
screen->display->atom__NET_SUPPORTING_WM_CHECK,
83
XA_WINDOW,
84
32, PropModeReplace, (guchar*) data, 1);
85
86
return Success;
87
}
88
89
static void
90
unset_wm_check_hint (MetaScreen *screen)
91
{
92
XDeleteProperty (screen->display->xdisplay, screen->xroot,
93
screen->display->atom__NET_SUPPORTING_WM_CHECK);
94
}
95
96
static int
97
set_supported_hint (MetaScreen *screen)
98
{
99
Atom atoms[] = {
100
#define EWMH_ATOMS_ONLY
101
#define item(x) screen->display->atom_##x,
102
#include "atomnames.h"
103
#undef item
104
#undef EWMH_ATOMS_ONLY
105
};
106
107
XChangeProperty (screen->display->xdisplay, screen->xroot,
108
screen->display->atom__NET_SUPPORTED,
109
XA_ATOM,
110
32, PropModeReplace,
111
(guchar*) atoms, G_N_ELEMENTS(atoms));
112
113
return Success;
114
}
115
116
static int
117
set_wm_icon_size_hint (MetaScreen *screen)
118
{
119
#define N_VALS 6
120
gulong vals[N_VALS];
121
122
/* min width, min height, max w, max h, width inc, height inc */
123
vals[0] = META_ICON_WIDTH;
124
vals[1] = META_ICON_HEIGHT;
125
vals[2] = META_ICON_WIDTH;
126
vals[3] = META_ICON_HEIGHT;
127
vals[4] = 0;
128
vals[5] = 0;
129
130
XChangeProperty (screen->display->xdisplay, screen->xroot,
131
screen->display->atom_WM_ICON_SIZE,
132
XA_CARDINAL,
133
32, PropModeReplace, (guchar*) vals, N_VALS);
134
135
return Success;
136
#undef N_VALS
137
}
138
139
static void
140
reload_xinerama_infos (MetaScreen *screen)
141
{
142
MetaDisplay *display;
143
144
{
145
GList *tmp;
146
147
tmp = screen->workspaces;
148
while (tmp != NULL)
149
{
150
MetaWorkspace *space = tmp->data;
151
152
meta_workspace_invalidate_work_area (space);
153
154
tmp = tmp->next;
155
}
156
}
157
158
display = screen->display;
159
160
if (screen->xinerama_infos)
161
g_free (screen->xinerama_infos);
162
163
screen->xinerama_infos = NULL;
164
screen->n_xinerama_infos = 0;
165
screen->last_xinerama_index = 0;
166
167
screen->display->xinerama_cache_invalidated = TRUE;
168
169
#ifdef HAVE_XFREE_XINERAMA
170
if (XineramaIsActive (display->xdisplay))
171
{
172
XineramaScreenInfo *infos;
173
int n_infos;
174
int i;
175
176
n_infos = 0;
177
infos = XineramaQueryScreens (display->xdisplay, &n_infos);
178
179
meta_topic (META_DEBUG_XINERAMA,
180
"Found %d Xinerama screens on display %s\n",
181
n_infos, display->name);
182
183
if (n_infos > 0)
184
{
185
screen->xinerama_infos = g_new (MetaXineramaScreenInfo, n_infos);
186
screen->n_xinerama_infos = n_infos;
187
188
i = 0;
189
while (i < n_infos)
190
{
191
screen->xinerama_infos[i].number = infos[i].screen_number;
192
screen->xinerama_infos[i].rect.x = infos[i].x_org;
193
screen->xinerama_infos[i].rect.y = infos[i].y_org;
194
screen->xinerama_infos[i].rect.width = infos[i].width;
195
screen->xinerama_infos[i].rect.height = infos[i].height;
196
197
meta_topic (META_DEBUG_XINERAMA,
198
"Xinerama %d is %d,%d %d x %d\n",
199
screen->xinerama_infos[i].number,
200
screen->xinerama_infos[i].rect.x,
201
screen->xinerama_infos[i].rect.y,
202
screen->xinerama_infos[i].rect.width,
203
screen->xinerama_infos[i].rect.height);
204
205
++i;
206
}
207
}
208
209
meta_XFree (infos);
210
}
211
else
212
{
213
meta_topic (META_DEBUG_XINERAMA,
214
"No XFree86 Xinerama extension or XFree86 Xinerama inactive on display %s\n",
215
display->name);
216
}
217
#else
218
meta_topic (META_DEBUG_XINERAMA,
219
"Metacity compiled without XFree86 Xinerama support\n");
220
#endif /* HAVE_XFREE_XINERAMA */
221
222
#ifdef HAVE_SOLARIS_XINERAMA
223
/* This code from GDK, Copyright (C) 2002 Sun Microsystems */
224
if (screen->n_xinerama_infos == 0 &&
225
XineramaGetState (screen->display->xdisplay,
226
screen->number))
227
{
228
XRectangle monitors[MAXFRAMEBUFFERS];
229
unsigned char hints[16];
230
int result;
231
int n_monitors;
232
int i;
233
234
n_monitors = 0;
235
result = XineramaGetInfo (screen->display->xdisplay,
236
screen->number,
237
monitors, hints,
238
&n_monitors);
239
/* Yes I know it should be Success but the current implementation
240
* returns the num of monitor
241
*/
242
if (result > 0)
243
{
244
g_assert (n_monitors > 0);
245
246
screen->xinerama_infos = g_new (MetaXineramaScreenInfo, n_monitors);
247
screen->n_xinerama_infos = n_monitors;
248
249
i = 0;
250
while (i < n_monitors)
251
{
252
screen->xinerama_infos[i].number = i;
253
screen->xinerama_infos[i].rect.x = monitors[i].x;
254
screen->xinerama_infos[i].rect.y = monitors[i].y;
255
screen->xinerama_infos[i].rect.width = monitors[i].width;
256
screen->xinerama_infos[i].rect.height = monitors[i].height;
257
258
meta_topic (META_DEBUG_XINERAMA,
259
"Xinerama %d is %d,%d %d x %d\n",
260
screen->xinerama_infos[i].number,
261
screen->xinerama_infos[i].rect.x,
262
screen->xinerama_infos[i].rect.y,
263
screen->xinerama_infos[i].rect.width,
264
screen->xinerama_infos[i].rect.height);
265
266
++i;
267
}
268
}
269
}
270
else if (screen->n_xinerama_infos == 0)
271
{
272
meta_topic (META_DEBUG_XINERAMA,
273
"No Solaris Xinerama extension or Solaris Xinerama inactive on display %s\n",
274
display->name);
275
}
276
#else
277
meta_topic (META_DEBUG_XINERAMA,
278
"Metacity compiled without Solaris Xinerama support\n");
279
#endif /* HAVE_SOLARIS_XINERAMA */
280
281
282
/* If no Xinerama, fill in the single screen info so
283
* we can use the field unconditionally
284
*/
285
if (screen->n_xinerama_infos == 0)
286
{
287
if (g_getenv ("METACITY_DEBUG_XINERAMA"))
288
{
289
meta_topic (META_DEBUG_XINERAMA,
290
"Pretending a single monitor has two Xinerama screens\n");
291
292
screen->xinerama_infos = g_new (MetaXineramaScreenInfo, 2);
293
screen->n_xinerama_infos = 2;
294
295
screen->xinerama_infos[0].number = 0;
296
screen->xinerama_infos[0].rect = screen->rect;
297
screen->xinerama_infos[0].rect.width = screen->rect.width / 2;
298
299
screen->xinerama_infos[1].number = 1;
300
screen->xinerama_infos[1].rect = screen->rect;
301
screen->xinerama_infos[1].rect.x = screen->rect.width / 2;
302
screen->xinerama_infos[1].rect.width = screen->rect.width / 2;
303
}
304
else
305
{
306
meta_topic (META_DEBUG_XINERAMA,
307
"No Xinerama screens, using default screen info\n");
308
309
screen->xinerama_infos = g_new (MetaXineramaScreenInfo, 1);
310
screen->n_xinerama_infos = 1;
311
312
screen->xinerama_infos[0].number = 0;
313
screen->xinerama_infos[0].rect = screen->rect;
314
}
315
}
316
317
g_assert (screen->n_xinerama_infos > 0);
318
g_assert (screen->xinerama_infos != NULL);
319
}
320
321
MetaScreen*
322
meta_screen_new (MetaDisplay *display,
323
int number,
324
guint32 timestamp)
325
{
326
MetaScreen *screen;
327
Window xroot;
328
Display *xdisplay;
329
XWindowAttributes attr;
330
Window new_wm_sn_owner;
331
Window current_wm_sn_owner;
332
gboolean replace_current_wm;
333
Atom wm_sn_atom;
334
char buf[128];
335
guint32 manager_timestamp;
336
gulong current_workspace;
337
338
replace_current_wm = meta_get_replace_current_wm ();
339
340
/* Only display->name, display->xdisplay, and display->error_traps
341
* can really be used in this function, since normally screens are
342
* created from the MetaDisplay constructor
343
*/
344
345
xdisplay = display->xdisplay;
346
347
meta_verbose ("Trying screen %d on display '%s'\n",
348
number, display->name);
349
350
xroot = RootWindow (xdisplay, number);
351
352
/* FVWM checks for None here, I don't know if this
353
* ever actually happens
354
*/
355
if (xroot == None)
356
{
357
meta_warning (_("Screen %d on display '%s' is invalid\n"),
358
number, display->name);
359
return NULL;
360
}
361
362
sprintf (buf, "WM_S%d", number);
363
wm_sn_atom = XInternAtom (xdisplay, buf, False);
364
365
current_wm_sn_owner = XGetSelectionOwner (xdisplay, wm_sn_atom);
366
367
if (current_wm_sn_owner != None)
368
{
369
XSetWindowAttributes attrs;
370
371
if (!replace_current_wm)
372
{
373
meta_warning (_("Screen %d on display \"%s\" already has a window manager; try using the --replace option to replace the current window manager.\n"),
374
number, display->name);
375
376
return NULL;
377
}
378
379
/* We want to find out when the current selection owner dies */
380
meta_error_trap_push_with_return (display);
381
attrs.event_mask = StructureNotifyMask;
382
XChangeWindowAttributes (xdisplay,
383
current_wm_sn_owner, CWEventMask, &attrs);
384
if (meta_error_trap_pop_with_return (display, FALSE) != Success)
385
current_wm_sn_owner = None; /* don't wait for it to die later on */
386
}
387
388
/* We need SelectionClear and SelectionRequest events on the new_wm_sn_owner,
389
* but those cannot be masked, so we only need NoEventMask.
390
*/
391
new_wm_sn_owner = meta_create_offscreen_window (xdisplay, xroot, NoEventMask);
392
393
manager_timestamp = timestamp;
394
395
XSetSelectionOwner (xdisplay, wm_sn_atom, new_wm_sn_owner,
396
manager_timestamp);
397
398
if (XGetSelectionOwner (xdisplay, wm_sn_atom) != new_wm_sn_owner)
399
{
400
meta_warning (_("Could not acquire window manager selection on screen %d display \"%s\"\n"),
401
number, display->name);
402
403
XDestroyWindow (xdisplay, new_wm_sn_owner);
404
405
return NULL;
406
}
407
408
{
409
/* Send client message indicating that we are now the WM */
410
XClientMessageEvent ev;
411
412
ev.type = ClientMessage;
413
ev.window = xroot;
414
ev.message_type = display->atom_MANAGER;
415
ev.format = 32;
416
ev.data.l[0] = manager_timestamp;
417
ev.data.l[1] = wm_sn_atom;
418
419
XSendEvent (xdisplay, xroot, False, StructureNotifyMask, (XEvent*)&ev);
420
}
421
422
/* Wait for old window manager to go away */
423
if (current_wm_sn_owner != None)
424
{
425
XEvent event;
426
427
/* We sort of block infinitely here which is probably lame. */
428
429
meta_verbose ("Waiting for old window manager to exit\n");
430
do
431
{
432
XWindowEvent (xdisplay, current_wm_sn_owner,
433
StructureNotifyMask, &event);
434
}
435
while (event.type != DestroyNotify);
436
}
437
438
/* select our root window events */
439
meta_error_trap_push_with_return (display);
440
441
/* We need to or with the existing event mask since
442
* gtk+ may be interested in other events.
443
*/
444
XGetWindowAttributes (xdisplay, xroot, &attr);
445
XSelectInput (xdisplay,
446
xroot,
447
SubstructureRedirectMask | SubstructureNotifyMask |
448
ColormapChangeMask | PropertyChangeMask |
449
LeaveWindowMask | EnterWindowMask |
450
KeyPressMask | KeyReleaseMask |
451
FocusChangeMask | StructureNotifyMask |
452
#ifdef HAVE_COMPOSITE_EXTENSIONS
453
ExposureMask |
454
#endif
455
attr.your_event_mask);
456
if (meta_error_trap_pop_with_return (display, FALSE) != Success)
457
{
458
meta_warning (_("Screen %d on display \"%s\" already has a window manager\n"),
459
number, display->name);
460
461
XDestroyWindow (xdisplay, new_wm_sn_owner);
462
463
return NULL;
464
}
465
466
screen = g_new (MetaScreen, 1);
467
screen->closing = 0;
468
469
screen->display = display;
470
screen->number = number;
471
screen->screen_name = get_screen_name (display, number);
472
screen->xscreen = ScreenOfDisplay (xdisplay, number);
473
screen->xroot = xroot;
474
screen->rect.x = screen->rect.y = 0;
475
screen->rect.width = WidthOfScreen (screen->xscreen);
476
screen->rect.height = HeightOfScreen (screen->xscreen);
477
screen->current_cursor = -1; /* invalid/unset */
478
screen->default_xvisual = DefaultVisualOfScreen (screen->xscreen);
479
screen->default_depth = DefaultDepthOfScreen (screen->xscreen);
480
screen->flash_window = None;
481
482
screen->wm_sn_selection_window = new_wm_sn_owner;
483
screen->wm_sn_atom = wm_sn_atom;
484
screen->wm_sn_timestamp = manager_timestamp;
485
486
#ifdef HAVE_COMPOSITE_EXTENSIONS
487
screen->wm_cm_selection_window = meta_create_offscreen_window (xdisplay,
488
xroot,
489
NoEventMask);
490
#endif
491
screen->work_area_idle = 0;
492
493
screen->active_workspace = NULL;
494
screen->workspaces = NULL;
495
screen->rows_of_workspaces = 1;
496
screen->columns_of_workspaces = -1;
497
screen->vertical_workspaces = FALSE;
498
screen->starting_corner = META_SCREEN_TOPLEFT;
499
screen->compositor_data = NULL;
500
501
{
502
XFontStruct *font_info;
503
XGCValues gc_values;
504
gulong value_mask = 0;
505
506
gc_values.subwindow_mode = IncludeInferiors;
507
value_mask |= GCSubwindowMode;
508
gc_values.function = GXinvert;
509
value_mask |= GCFunction;
510
gc_values.line_width = META_WIREFRAME_XOR_LINE_WIDTH;
511
value_mask |= GCLineWidth;
512
513
font_info = XLoadQueryFont (screen->display->xdisplay, "fixed");
514
515
if (font_info != NULL)
516
{
517
gc_values.font = font_info->fid;
518
value_mask |= GCFont;
519
XFreeFontInfo (NULL, font_info, 1);
520
}
521
else
522
meta_warning ("xserver doesn't have 'fixed' font.\n");
523
524
screen->root_xor_gc = XCreateGC (screen->display->xdisplay,
525
screen->xroot,
526
value_mask,
527
&gc_values);
528
}
529
530
screen->xinerama_infos = NULL;
531
screen->n_xinerama_infos = 0;
532
screen->last_xinerama_index = 0;
533
534
reload_xinerama_infos (screen);
535
536
meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
537
538
/* Handle creating a no_focus_window for this screen */
539
screen->no_focus_window =
540
meta_create_offscreen_window (display->xdisplay,
541
screen->xroot,
542
FocusChangeMask|KeyPressMask|KeyReleaseMask);
543
XMapWindow (display->xdisplay, screen->no_focus_window);
544
/* Done with no_focus_window stuff */
545
546
set_wm_icon_size_hint (screen);
547
548
set_supported_hint (screen);
549
550
set_wm_check_hint (screen);
551
552
set_desktop_viewport_hint (screen);
553
554
set_desktop_geometry_hint (screen);
555
556
meta_screen_update_workspace_layout (screen);
557
558
/* Get current workspace */
559
current_workspace = 0;
560
if (meta_prop_get_cardinal (screen->display,
561
screen->xroot,
562
screen->display->atom__NET_CURRENT_DESKTOP,
563
¤t_workspace))
564
meta_verbose ("Read existing _NET_CURRENT_DESKTOP = %d\n",
565
(int) current_workspace);
566
else
567
meta_verbose ("No _NET_CURRENT_DESKTOP present\n");
568
569
/* Screens must have at least one workspace at all times,
570
* so create that required workspace.
571
*/
572
meta_workspace_activate (meta_workspace_new (screen), timestamp);
573
update_num_workspaces (screen, timestamp);
574
575
set_workspace_names (screen);
576
577
screen->all_keys_grabbed = FALSE;
578
screen->keys_grabbed = FALSE;
579
meta_screen_grab_keys (screen);
580
581
screen->ui = meta_ui_new (screen->display->xdisplay,
582
screen->xscreen);
583
584
screen->tab_popup = NULL;
585
586
screen->stack = meta_stack_new (screen);
587
588
meta_prefs_add_listener (prefs_changed_callback, screen);
589
590
#ifdef HAVE_STARTUP_NOTIFICATION
591
screen->sn_context =
592
sn_monitor_context_new (screen->display->sn_display,
593
screen->number,
594
meta_screen_sn_event,
595
screen,
596
NULL);
597
screen->startup_sequences = NULL;
598
screen->startup_sequence_timeout = 0;
599
#endif
600
601
/* Switch to the _NET_CURRENT_DESKTOP workspace */
602
{
603
MetaWorkspace *space;
604
605
space = meta_screen_get_workspace_by_index (screen,
606
current_workspace);
607
608
if (space != NULL)
609
meta_workspace_activate (space, timestamp);
610
}
611
612
meta_verbose ("Added screen %d ('%s') root 0x%lx\n",
613
screen->number, screen->screen_name, screen->xroot);
614
615
return screen;
616
}
617
618
void
619
meta_screen_free (MetaScreen *screen,
620
guint32 timestamp)
621
{
622
MetaDisplay *display;
623
XGCValues gc_values = { 0 };
624
625
display = screen->display;
626
627
screen->closing += 1;
628
629
meta_display_grab (display);
630
631
if (screen->display->compositor)
632
{
633
meta_compositor_unmanage_screen (screen->display->compositor,
634
screen);
635
}
636
637
meta_display_unmanage_windows_for_screen (display, screen, timestamp);
638
639
meta_prefs_remove_listener (prefs_changed_callback, screen);
640
641
meta_screen_ungrab_keys (screen);
642
643
#ifdef HAVE_STARTUP_NOTIFICATION
644
g_slist_foreach (screen->startup_sequences,
645
(GFunc) sn_startup_sequence_unref, NULL);
646
g_slist_free (screen->startup_sequences);
647
screen->startup_sequences = NULL;
648
649
if (screen->startup_sequence_timeout != 0)
650
{
651
g_source_remove (screen->startup_sequence_timeout);
652
screen->startup_sequence_timeout = 0;
653
}
654
if (screen->sn_context)
655
{
656
sn_monitor_context_unref (screen->sn_context);
657
screen->sn_context = NULL;
658
}
659
#endif
660
661
meta_ui_free (screen->ui);
662
663
meta_stack_free (screen->stack);
664
665
meta_error_trap_push_with_return (screen->display);
666
XSelectInput (screen->display->xdisplay, screen->xroot, 0);
667
if (meta_error_trap_pop_with_return (screen->display, FALSE) != Success)
668
meta_warning (_("Could not release screen %d on display \"%s\"\n"),
669
screen->number, screen->display->name);
670
671
unset_wm_check_hint (screen);
672
673
XDestroyWindow (screen->display->xdisplay,
674
screen->wm_sn_selection_window);
675
676
if (screen->work_area_idle != 0)
677
g_source_remove (screen->work_area_idle);
678
679
680
if (XGetGCValues (screen->display->xdisplay,
681
screen->root_xor_gc,
682
GCFont,
683
&gc_values))
684
{
685
XUnloadFont (screen->display->xdisplay,
686
gc_values.font);
687
}
688
689
XFreeGC (screen->display->xdisplay,
690
screen->root_xor_gc);
691
692
if (screen->xinerama_infos)
693
g_free (screen->xinerama_infos);
694
695
g_free (screen->screen_name);
696
g_free (screen);
697
698
XFlush (display->xdisplay);
699
meta_display_ungrab (display);
700
}
701
702
typedef struct
703
{
704
Window xwindow;
705
XWindowAttributes attrs;
706
} WindowInfo;
707
708
static GList *
709
list_windows (MetaScreen *screen)
710
{
711
Window ignored1, ignored2;
712
Window *children;
713
guint n_children, i;
714
GList *result;
715
716
XQueryTree (screen->display->xdisplay,
717
screen->xroot,
718
&ignored1, &ignored2, &children, &n_children);
719
720
result = NULL;
721
for (i = 0; i < n_children; ++i)
722
{
723
WindowInfo *info = g_new0 (WindowInfo, 1);
724
725
meta_error_trap_push_with_return (screen->display);
726
727
XGetWindowAttributes (screen->display->xdisplay,
728
children[i], &info->attrs);
729
730
if (meta_error_trap_pop_with_return (screen->display, TRUE))
731
{
732
meta_verbose ("Failed to get attributes for window 0x%lx\n",
733
children[i]);
734
g_free (info);
735
}
736
else
737
{
738
info->xwindow = children[i];
739
}
740
741
result = g_list_prepend (result, info);
742
}
743
744
if (children)
745
XFree (children);
746
747
return g_list_reverse (result);
748
}
749
750
void
751
meta_screen_manage_all_windows (MetaScreen *screen)
752
{
753
GList *windows;
754
GList *list;
755
756
meta_display_grab (screen->display);
757
758
windows = list_windows (screen);
759
760
meta_stack_freeze (screen->stack);
761
for (list = windows; list != NULL; list = list->next)
762
{
763
WindowInfo *info = list->data;
764
MetaWindow *window;
765
766
window = meta_window_new_with_attrs (screen->display, info->xwindow, TRUE,
767
&info->attrs);
768
if (info->xwindow == screen->no_focus_window ||
769
info->xwindow == screen->flash_window ||
770
#ifdef HAVE_COMPOSITE_EXTENSIONS
771
info->xwindow == screen->wm_cm_selection_window ||
772
#endif
773
info->xwindow == screen->wm_sn_selection_window) {
774
meta_verbose ("Not managing our own windows\n");
775
continue;
776
}
777
778
if (screen->display->compositor)
779
meta_compositor_add_window (screen->display->compositor, window,
780
info->xwindow, &info->attrs);
781
}
782
meta_stack_thaw (screen->stack);
783
784
g_list_foreach (windows, (GFunc)g_free, NULL);
785
g_list_free (windows);
786
787
meta_display_ungrab (screen->display);
788
}
789
790
void
791
meta_screen_composite_all_windows (MetaScreen *screen)
792
{
793
#ifdef HAVE_COMPOSITE_EXTENSIONS
794
MetaDisplay *display;
795
GList *windows, *list;
796
797
display = screen->display;
798
if (!display->compositor)
799
return;
800
801
windows = list_windows (screen);
802
803
meta_stack_freeze (screen->stack);
804
805
for (list = windows; list != NULL; list = list->next)
806
{
807
WindowInfo *info = list->data;
808
809
if (info->xwindow == screen->no_focus_window ||
810
info->xwindow == screen->flash_window ||
811
info->xwindow == screen->wm_sn_selection_window ||
812
info->xwindow == screen->wm_cm_selection_window) {
813
meta_verbose ("Not managing our own windows\n");
814
continue;
815
}
816
817
meta_compositor_add_window (display->compositor,
818
meta_display_lookup_x_window (display,
819
info->xwindow),
820
info->xwindow, &info->attrs);
821
}
822
823
meta_stack_thaw (screen->stack);
824
825
g_list_foreach (windows, (GFunc)g_free, NULL);
826
g_list_free (windows);
827
#endif
828
}
829
830
MetaScreen*
831
meta_screen_for_x_screen (Screen *xscreen)
832
{
833
MetaDisplay *display;
834
835
display = meta_display_for_x_display (DisplayOfScreen (xscreen));
836
837
if (display == NULL)
838
return NULL;
839
840
return meta_display_screen_for_x_screen (display, xscreen);
841
}
842
843
static void
844
prefs_changed_callback (MetaPreference pref,
845
gpointer data)
846
{
847
MetaScreen *screen = data;
848
849
if (pref == META_PREF_NUM_WORKSPACES)
850
{
851
/* GConf doesn't provide timestamps, but luckily update_num_workspaces
852
* often doesn't need it...
853
*/
854
guint32 timestamp =
855
meta_display_get_current_time_roundtrip (screen->display);
856
update_num_workspaces (screen, timestamp);
857
}
858
else if (pref == META_PREF_FOCUS_MODE)
859
{
860
update_focus_mode (screen);
861
}
862
else if (pref == META_PREF_WORKSPACE_NAMES)
863
{
864
set_workspace_names (screen);
865
}
866
}
867
868
869
static char*
870
get_screen_name (MetaDisplay *display,
871
int number)
872
{
873
char *p;
874
char *dname;
875
char *scr;
876
877
/* DisplayString gives us a sort of canonical display,
878
* vs. the user-entered name from XDisplayName()
879
*/
880
dname = g_strdup (DisplayString (display->xdisplay));
881
882
/* Change display name to specify this screen.
883
*/
884
p = strrchr (dname, ':');
885
if (p)
886
{
887
p = strchr (p, '.');
888
if (p)
889
*p = '\0';
890
}
891
892
scr = g_strdup_printf ("%s.%d", dname, number);
893
894
g_free (dname);
895
896
return scr;
897
}
898
899
static gint
900
ptrcmp (gconstpointer a, gconstpointer b)
901
{
902
if (a < b)
903
return -1;
904
else if (a > b)
905
return 1;
906
else
907
return 0;
908
}
909
910
static void
911
listify_func (gpointer key, gpointer value, gpointer data)
912
{
913
GSList **listp;
914
915
listp = data;
916
917
*listp = g_slist_prepend (*listp, value);
918
}
919
920
void
921
meta_screen_foreach_window (MetaScreen *screen,
922
MetaScreenWindowFunc func,
923
gpointer data)
924
{
925
GSList *winlist;
926
GSList *tmp;
927
928
/* If we end up doing this often, just keeping a list
929
* of windows might be sensible.
930
*/
931
932
winlist = NULL;
933
g_hash_table_foreach (screen->display->window_ids,
934
listify_func,
935
&winlist);
936
937
winlist = g_slist_sort (winlist, ptrcmp);
938
939
tmp = winlist;
940
while (tmp != NULL)
941
{
942
/* If the next node doesn't contain this window
943
* a second time, delete the window.
944
*/
945
if (tmp->next == NULL ||
946
(tmp->next && tmp->next->data != tmp->data))
947
{
948
MetaWindow *window = tmp->data;
949
950
if (window->screen == screen)
951
(* func) (screen, window, data);
952
}
953
954
tmp = tmp->next;
955
}
956
g_slist_free (winlist);
957
}
958
959
static void
960
queue_draw (MetaScreen *screen, MetaWindow *window, gpointer data)
961
{
962
if (window->frame)
963
meta_frame_queue_draw (window->frame);
964
}
965
966
void
967
meta_screen_queue_frame_redraws (MetaScreen *screen)
968
{
969
meta_screen_foreach_window (screen, queue_draw, NULL);
970
}
971
972
static void
973
queue_resize (MetaScreen *screen, MetaWindow *window, gpointer data)
974
{
975
meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
976
}
977
978
void
979
meta_screen_queue_window_resizes (MetaScreen *screen)
980
{
981
meta_screen_foreach_window (screen, queue_resize, NULL);
982
}
983
984
int
985
meta_screen_get_n_workspaces (MetaScreen *screen)
986
{
987
return g_list_length (screen->workspaces);
988
}
989
990
MetaWorkspace*
991
meta_screen_get_workspace_by_index (MetaScreen *screen,
992
int idx)
993
{
994
GList *tmp;
995
int i;
996
997
/* should be robust, idx is maybe from an app */
998
if (idx < 0)
999
return NULL;
1000
1001
i = 0;
1002
tmp = screen->workspaces;
1003
while (tmp != NULL)
1004
{
1005
MetaWorkspace *w = tmp->data;
1006
1007
if (i == idx)
1008
return w;
1009
1010
++i;
1011
tmp = tmp->next;
1012
}
1013
1014
return NULL;
1015
}
1016
1017
static void
1018
set_number_of_spaces_hint (MetaScreen *screen,
1019
int n_spaces)
1020
{
1021
unsigned long data[1];
1022
1023
if (screen->closing > 0)
1024
return;
1025
1026
data[0] = n_spaces;
1027
1028
meta_verbose ("Setting _NET_NUMBER_OF_DESKTOPS to %lu\n", data[0]);
1029
1030
meta_error_trap_push (screen->display);
1031
XChangeProperty (screen->display->xdisplay, screen->xroot,
1032
screen->display->atom__NET_NUMBER_OF_DESKTOPS,
1033
XA_CARDINAL,
1034
32, PropModeReplace, (guchar*) data, 1);
1035
meta_error_trap_pop (screen->display, FALSE);
1036
}
1037
1038
static void
1039
set_desktop_geometry_hint (MetaScreen *screen)
1040
{
1041
unsigned long data[2];
1042
1043
if (screen->closing > 0)
1044
return;
1045
1046
data[0] = screen->rect.width;
1047
data[1] = screen->rect.height;
1048
1049
meta_verbose ("Setting _NET_DESKTOP_GEOMETRY to %lu, %lu\n", data[0], data[1]);
1050
1051
meta_error_trap_push (screen->display);
1052
XChangeProperty (screen->display->xdisplay, screen->xroot,
1053
screen->display->atom__NET_DESKTOP_GEOMETRY,
1054
XA_CARDINAL,
1055
32, PropModeReplace, (guchar*) data, 2);
1056
meta_error_trap_pop (screen->display, FALSE);
1057
}
1058
1059
static void
1060
set_desktop_viewport_hint (MetaScreen *screen)
1061
{
1062
unsigned long data[2];
1063
1064
if (screen->closing > 0)
1065
return;
1066
1067
/*
1068
* Metacity does not implement viewports, so this is a fixed 0,0
1069
*/
1070
data[0] = 0;
1071
data[1] = 0;
1072
1073
meta_verbose ("Setting _NET_DESKTOP_VIEWPORT to 0, 0\n");
1074
1075
meta_error_trap_push (screen->display);
1076
XChangeProperty (screen->display->xdisplay, screen->xroot,
1077
screen->display->atom__NET_DESKTOP_VIEWPORT,
1078
XA_CARDINAL,
1079
32, PropModeReplace, (guchar*) data, 2);
1080
meta_error_trap_pop (screen->display, FALSE);
1081
}
1082
1083
static void
1084
update_num_workspaces (MetaScreen *screen,
1085
guint32 timestamp)
1086
{
1087
int new_num;
1088
GList *tmp;
1089
int i;
1090
GList *extras;
1091
MetaWorkspace *last_remaining;
1092
gboolean need_change_space;
1093
1094
new_num = meta_prefs_get_num_workspaces ();
1095
1096
g_assert (new_num > 0);
1097
1098
last_remaining = NULL;
1099
extras = NULL;
1100
i = 0;
1101
tmp = screen->workspaces;
1102
while (tmp != NULL)
1103
{
1104
MetaWorkspace *w = tmp->data;
1105
1106
if (i >= new_num)
1107
extras = g_list_prepend (extras, w);
1108
else
1109
last_remaining = w;
1110
1111
++i;
1112
tmp = tmp->next;
1113
}
1114
1115
g_assert (last_remaining);
1116
1117
/* Get rid of the extra workspaces by moving all their windows
1118
* to last_remaining, then activating last_remaining if
1119
* one of the removed workspaces was active. This will be a bit
1120
* wacky if the config tool for changing number of workspaces
1121
* is on a removed workspace ;-)
1122
*/
1123
need_change_space = FALSE;
1124
tmp = extras;
1125
while (tmp != NULL)
1126
{
1127
MetaWorkspace *w = tmp->data;
1128
1129
meta_workspace_relocate_windows (w, last_remaining);
1130
1131
if (w == screen->active_workspace)
1132
need_change_space = TRUE;
1133
1134
tmp = tmp->next;
1135
}
1136
1137
if (need_change_space)
1138
meta_workspace_activate (last_remaining, timestamp);
1139
1140
/* Should now be safe to free the workspaces */
1141
tmp = extras;
1142
while (tmp != NULL)
1143
{
1144
MetaWorkspace *w = tmp->data;
1145
1146
g_assert (w->windows == NULL);
1147
meta_workspace_free (w);
1148
1149
tmp = tmp->next;
1150
}
1151
1152
g_list_free (extras);
1153
1154
while (i < new_num)
1155
{
1156
meta_workspace_new (screen);
1157
++i;
1158
}
1159
1160
set_number_of_spaces_hint (screen, new_num);
1161
1162
meta_screen_queue_workarea_recalc (screen);
1163
}
1164
1165
static void
1166
update_focus_mode (MetaScreen *screen)
1167
{
1168
/* nothing to do anymore */ ;
1169
}
1170
1171
void
1172
meta_screen_set_cursor (MetaScreen *screen,
1173
MetaCursor cursor)
1174
{
1175
Cursor xcursor;
1176
1177
if (cursor == screen->current_cursor)
1178
return;
1179
1180
screen->current_cursor = cursor;
1181
1182
xcursor = meta_display_create_x_cursor (screen->display, cursor);
1183
XDefineCursor (screen->display->xdisplay, screen->xroot, xcursor);
1184
XFlush (screen->display->xdisplay);
1185
XFreeCursor (screen->display->xdisplay, xcursor);
1186
}
1187
1188
void
1189
meta_screen_update_cursor (MetaScreen *screen)
1190
{
1191
Cursor xcursor;
1192
1193
xcursor = meta_display_create_x_cursor (screen->display,
1194
screen->current_cursor);
1195
XDefineCursor (screen->display->xdisplay, screen->xroot, xcursor);
1196
XFlush (screen->display->xdisplay);
1197
XFreeCursor (screen->display->xdisplay, xcursor);
1198
}
1199
1200
#define MAX_PREVIEW_SIZE 150.0
1201
1202
static GdkPixbuf *
1203
get_window_pixbuf (MetaWindow *window,
1204
int *width,
1205
int *height)
1206
{
1207
Pixmap pmap;
1208
GdkPixbuf *pixbuf, *scaled;
1209
double ratio;
1210
1211
pmap = meta_compositor_get_window_pixmap (window->display->compositor,
1212
window);
1213
if (pmap == None)
1214
return NULL;
1215
1216
pixbuf = meta_ui_get_pixbuf_from_pixmap (pmap);
1217
if (pixbuf == NULL)
1218
return NULL;
1219
1220
*width = gdk_pixbuf_get_width (pixbuf);
1221
*height = gdk_pixbuf_get_height (pixbuf);
1222
1223
/* Scale pixbuf to max dimension MAX_PREVIEW_SIZE */
1224
if (*width > *height)
1225
{
1226
ratio = ((double) *width) / MAX_PREVIEW_SIZE;
1227
*width = (int) MAX_PREVIEW_SIZE;
1228
*height = (int) (((double) *height) / ratio);
1229
}
1230
else
1231
{
1232
ratio = ((double) *height) / MAX_PREVIEW_SIZE;
1233
*height = (int) MAX_PREVIEW_SIZE;
1234
*width = (int) (((double) *width) / ratio);
1235
}
1236
1237
scaled = gdk_pixbuf_scale_simple (pixbuf, *width, *height,
1238
GDK_INTERP_BILINEAR);
1239
g_object_unref (pixbuf);
1240
return scaled;
1241
}
1242
1243
void
1244
meta_screen_ensure_tab_popup (MetaScreen *screen,
1245
MetaTabList list_type,
1246
MetaTabShowType show_type)
1247
{
1248
MetaTabEntry *entries;
1249
GList *tab_list;
1250
GList *tmp;
1251
int len;
1252
int i;
1253
1254
if (screen->tab_popup)
1255
return;
1256
1257
tab_list = meta_display_get_tab_list (screen->display,
1258
list_type,
1259
screen,
1260
screen->active_workspace);
1261
1262
len = g_list_length (tab_list);
1263
1264
entries = g_new (MetaTabEntry, len + 1);
1265
entries[len].key = NULL;
1266
entries[len].title = NULL;
1267
entries[len].icon = NULL;
1268
1269
i = 0;
1270
tmp = tab_list;
1271
while (i < len)
1272
{
1273
MetaWindow *window;
1274
MetaRectangle r;
1275
GdkPixbuf *win_pixbuf;
1276
int width, height;
1277
1278
window = tmp->data;
1279
1280
entries[i].key = (MetaTabEntryKey) window->xwindow;
1281
entries[i].title = window->title;
1282
1283
win_pixbuf = get_window_pixbuf (window, &width, &height);
1284
if (win_pixbuf == NULL)
1285
entries[i].icon = g_object_ref (window->icon);
1286
else
1287
{
1288
int icon_width, icon_height, t_width, t_height;
1289
#define ICON_OFFSET 6
1290
1291
icon_width = gdk_pixbuf_get_width (window->icon);
1292
icon_height = gdk_pixbuf_get_height (window->icon);
1293
1294
t_width = width + ICON_OFFSET;
1295
t_height = height + ICON_OFFSET;
1296
1297
entries[i].icon = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
1298
t_width, t_height);
1299
gdk_pixbuf_fill (entries[i].icon, 0x00000000);
1300
gdk_pixbuf_copy_area (win_pixbuf, 0, 0, width, height,
1301
entries[i].icon, 0, 0);
1302
g_object_unref (win_pixbuf);
1303
gdk_pixbuf_composite (window->icon, entries[i].icon,
1304
t_width - icon_width, t_height - icon_height,
1305
icon_width, icon_height,
1306
t_width - icon_width, t_height - icon_height,
1307
1.0, 1.0, GDK_INTERP_BILINEAR, 255);
1308
}
1309
1310
entries[i].blank = FALSE;
1311
entries[i].hidden = !meta_window_showing_on_its_workspace (window);
1312
entries[i].demands_attention = window->wm_state_demands_attention;
1313
1314
if (show_type == META_TAB_SHOW_INSTANTLY ||
1315
!entries[i].hidden ||
1316
!meta_window_get_icon_geometry (window, &r))
1317
meta_window_get_outer_rect (window, &r);
1318
1319
entries[i].rect = r;
1320
1321
/* Find inside of highlight rectangle to be used when window is
1322
* outlined for tabbing. This should be the size of the
1323
* east/west frame, and the size of the south frame, on those
1324
* sides. On the top it should be the size of the south frame
1325
* edge.
1326
*/
1327
#define OUTLINE_WIDTH 5
1328
/* Top side */
1329
if (!entries[i].hidden &&
1330
window->frame && window->frame->bottom_height > 0 &&
1331
window->frame->child_y >= window->frame->bottom_height)
1332
entries[i].inner_rect.y = window->frame->bottom_height;
1333
else
1334
entries[i].inner_rect.y = OUTLINE_WIDTH;
1335
1336
/* Bottom side */
1337
if (!entries[i].hidden &&
1338
window->frame && window->frame->bottom_height != 0)
1339
entries[i].inner_rect.height = r.height
1340
- entries[i].inner_rect.y - window->frame->bottom_height;
1341
else
1342
entries[i].inner_rect.height = r.height
1343
- entries[i].inner_rect.y - OUTLINE_WIDTH;
1344
1345
/* Left side */
1346
if (!entries[i].hidden && window->frame && window->frame->child_x != 0)
1347
entries[i].inner_rect.x = window->frame->child_x;
1348
else
1349
entries[i].inner_rect.x = OUTLINE_WIDTH;
1350
1351
/* Right side */
1352
if (!entries[i].hidden &&
1353
window->frame && window->frame->right_width != 0)
1354
entries[i].inner_rect.width = r.width
1355
- entries[i].inner_rect.x - window->frame->right_width;
1356
else
1357
entries[i].inner_rect.width = r.width
1358
- entries[i].inner_rect.x - OUTLINE_WIDTH;
1359
1360
++i;
1361
tmp = tmp->next;
1362
}
1363
1364
screen->tab_popup = meta_ui_tab_popup_new (entries,
1365
screen->number,
1366
len,
1367
5, /* FIXME */
1368
TRUE);
1369
1370
for (i = 0; i < len; i++)
1371
g_object_unref (entries[i].icon);
1372
1373
g_free (entries);
1374
1375
g_list_free (tab_list);
1376
1377
/* don't show tab popup, since proper window isn't selected yet */
1378
}
1379
1380
void
1381
meta_screen_ensure_workspace_popup (MetaScreen *screen)
1382
{
1383
MetaTabEntry *entries;
1384
int len;
1385
int i;
1386
MetaWorkspaceLayout layout;
1387
int n_workspaces;
1388
int current_workspace;
1389
1390
if (screen->tab_popup)
1391
return;
1392
1393
current_workspace = meta_workspace_index (screen->active_workspace);
1394
n_workspaces = meta_screen_get_n_workspaces (screen);
1395
1396
meta_screen_calc_workspace_layout (screen, n_workspaces,
1397
current_workspace, &layout);
1398
1399
len = layout.grid_area;
1400
1401
entries = g_new (MetaTabEntry, len + 1);
1402
entries[len].key = NULL;
1403
entries[len].title = NULL;
1404
entries[len].icon = NULL;
1405
1406
i = 0;
1407
while (i < len)
1408
{
1409
if (layout.grid[i] >= 0)
1410
{
1411
MetaWorkspace *workspace;
1412
1413
workspace = meta_screen_get_workspace_by_index (screen,
1414
layout.grid[i]);
1415
1416
entries[i].key = (MetaTabEntryKey) workspace;
1417
entries[i].title = meta_workspace_get_name (workspace);
1418
entries[i].icon = NULL;
1419
entries[i].blank = FALSE;
1420
1421
g_assert (entries[i].title != NULL);
1422
}
1423
else
1424
{
1425
entries[i].key = NULL;
1426
entries[i].title = NULL;
1427
entries[i].icon = NULL;
1428
entries[i].blank = TRUE;
1429
}
1430
entries[i].hidden = FALSE;
1431
entries[i].demands_attention = FALSE;
1432
1433
++i;
1434
}
1435
1436
screen->tab_popup = meta_ui_tab_popup_new (entries,
1437
screen->number,
1438
len,
1439
layout.cols,
1440
FALSE);
1441
1442
g_free (entries);
1443
meta_screen_free_workspace_layout (&layout);
1444
1445
/* don't show tab popup, since proper space isn't selected yet */
1446
}
1447
1448
MetaWindow*
1449
meta_screen_get_mouse_window (MetaScreen *screen,
1450
MetaWindow *not_this_one)
1451
{
1452
MetaWindow *window;
1453
Window root_return, child_return;
1454
int root_x_return, root_y_return;
1455
int win_x_return, win_y_return;
1456
unsigned int mask_return;
1457
1458
if (not_this_one)
1459
meta_topic (META_DEBUG_FOCUS,
1460
"Focusing mouse window excluding %s\n", not_this_one->desc);
1461
1462
meta_error_trap_push (screen->display);
1463
XQueryPointer (screen->display->xdisplay,
1464
screen->xroot,
1465
&root_return,
1466
&child_return,
1467
&root_x_return,
1468
&root_y_return,
1469
&win_x_return,
1470
&win_y_return,
1471
&mask_return);
1472
meta_error_trap_pop (screen->display, TRUE);
1473
1474
window = meta_stack_get_default_focus_window_at_point (screen->stack,
1475
screen->active_workspace,
1476
not_this_one,
1477
root_x_return,
1478
root_y_return);
1479
1480
return window;
1481
}
1482
1483
const MetaXineramaScreenInfo*
1484
meta_screen_get_xinerama_for_rect (MetaScreen *screen,
1485
MetaRectangle *rect)
1486
{
1487
int i;
1488
int best_xinerama, xinerama_score;
1489
1490
if (screen->n_xinerama_infos == 1)
1491
return &screen->xinerama_infos[0];
1492
1493
best_xinerama = 0;
1494
xinerama_score = 0;
1495
1496
for (i = 0; i < screen->n_xinerama_infos; i++)
1497
{
1498
MetaRectangle dest;
1499
if (meta_rectangle_intersect (&screen->xinerama_infos[i].rect,
1500
rect,
1501
&dest))
1502
{
1503
int cur = meta_rectangle_area (&dest);
1504
if (cur > xinerama_score)
1505
{
1506
xinerama_score = cur;
1507
best_xinerama = i;
1508
}
1509
}
1510
}
1511
1512
return &screen->xinerama_infos[best_xinerama];
1513
}
1514
1515
const MetaXineramaScreenInfo*
1516
meta_screen_get_xinerama_for_window (MetaScreen *screen,
1517
MetaWindow *window)
1518
{
1519
MetaRectangle window_rect;
1520
1521
meta_window_get_outer_rect (window, &window_rect);
1522
1523
return meta_screen_get_xinerama_for_rect (screen, &window_rect);
1524
}
1525
1526
const MetaXineramaScreenInfo*
1527
meta_screen_get_xinerama_neighbor (MetaScreen *screen,
1528
int which_xinerama,
1529
MetaScreenDirection direction)
1530
{
1531
MetaXineramaScreenInfo* input = screen->xinerama_infos + which_xinerama;
1532
MetaXineramaScreenInfo* current;
1533
int i;
1534
1535
for (i = 0; i < screen->n_xinerama_infos; i++)
1536
{
1537
current = screen->xinerama_infos + i;
1538
1539
if ((direction == META_SCREEN_RIGHT &&
1540
current->rect.x == input->rect.x + input->rect.width &&
1541
meta_rectangle_vert_overlap(¤t->rect, &input->rect)) ||
1542
(direction == META_SCREEN_LEFT &&
1543
input->rect.x == current->rect.x + current->rect.width &&
1544
meta_rectangle_vert_overlap(¤t->rect, &input->rect)) ||
1545
(direction == META_SCREEN_UP &&
1546
input->rect.y == current->rect.y + current->rect.height &&
1547
meta_rectangle_horiz_overlap(¤t->rect, &input->rect)) ||
1548
(direction == META_SCREEN_DOWN &&
1549
current->rect.y == input->rect.y + input->rect.height &&
1550
meta_rectangle_horiz_overlap(¤t->rect, &input->rect)))
1551
{
1552
return current;
1553
}
1554
}
1555
1556
return NULL;
1557
}
1558
1559
void
1560
meta_screen_get_natural_xinerama_list (MetaScreen *screen,
1561
int** xineramas_list,
1562
int* n_xineramas)
1563
{
1564
const MetaXineramaScreenInfo* current;
1565
const MetaXineramaScreenInfo* tmp;
1566
GQueue* xinerama_queue;
1567
int* visited;
1568
int cur = 0;
1569
int i;
1570
1571
*n_xineramas = screen->n_xinerama_infos;
1572
*xineramas_list = g_new (int, screen->n_xinerama_infos);
1573
1574
/* we calculate a natural ordering by which to choose xineramas for
1575
* window placement. We start at the current xinerama, and perform
1576
* a breadth-first search of the xineramas starting from that
1577
* xinerama. We choose preferentially left, then right, then down,
1578
* then up. The visitation order produced by this traversal is the
1579
* natural xinerama ordering.
1580
*/
1581
1582
visited = g_new (int, screen->n_xinerama_infos);
1583
for (i = 0; i < screen->n_xinerama_infos; i++)
1584
{
1585
visited[i] = FALSE;
1586
}
1587
1588
current = meta_screen_get_current_xinerama (screen);
1589
xinerama_queue = g_queue_new ();
1590
g_queue_push_tail (xinerama_queue, (gpointer) current);
1591
visited[current->number] = TRUE;
1592
1593
while (!g_queue_is_empty (xinerama_queue))
1594
{
1595
current = (const MetaXineramaScreenInfo*)
1596
g_queue_pop_head (xinerama_queue);
1597
1598
(*xineramas_list)[cur++] = current->number;
1599
1600
/* enqueue each of the directions */
1601
tmp = meta_screen_get_xinerama_neighbor (screen,
1602
current->number,
1603
META_SCREEN_LEFT);
1604
if (tmp && !visited[tmp->number])
1605
{
1606
g_queue_push_tail (xinerama_queue,
1607
(MetaXineramaScreenInfo*) tmp);
1608
visited[tmp->number] = TRUE;
1609
}
1610
tmp = meta_screen_get_xinerama_neighbor (screen,
1611
current->number,
1612
META_SCREEN_RIGHT);
1613
if (tmp && !visited[tmp->number])
1614
{
1615
g_queue_push_tail (xinerama_queue,
1616
(MetaXineramaScreenInfo*) tmp);
1617
visited[tmp->number] = TRUE;
1618
}
1619
tmp = meta_screen_get_xinerama_neighbor (screen,
1620
current->number,
1621
META_SCREEN_UP);
1622
if (tmp && !visited[tmp->number])
1623
{
1624
g_queue_push_tail (xinerama_queue,
1625
(MetaXineramaScreenInfo*) tmp);
1626
visited[tmp->number] = TRUE;
1627
}
1628
tmp = meta_screen_get_xinerama_neighbor (screen,
1629
current->number,
1630
META_SCREEN_DOWN);
1631
if (tmp && !visited[tmp->number])
1632
{
1633
g_queue_push_tail (xinerama_queue,
1634
(MetaXineramaScreenInfo*) tmp);
1635
visited[tmp->number] = TRUE;
1636
}
1637
}
1638
1639
/* in case we somehow missed some set of xineramas, go through the
1640
* visited list and add in any xineramas that were missed
1641
*/
1642
for (i = 0; i < screen->n_xinerama_infos; i++)
1643
{
1644
if (visited[i] == FALSE)
1645
{
1646
(*xineramas_list)[cur++] = i;
1647
}
1648
}
1649
1650
g_free (visited);
1651
g_queue_free (xinerama_queue);
1652
}
1653
1654
const MetaXineramaScreenInfo*
1655
meta_screen_get_current_xinerama (MetaScreen *screen)
1656
{
1657
if (screen->n_xinerama_infos == 1)
1658
return &screen->xinerama_infos[0];
1659
1660
/* Sadly, we have to do it this way. Yuck.
1661
*/
1662
1663
if (screen->display->xinerama_cache_invalidated)
1664
{
1665
Window root_return, child_return;
1666
int win_x_return, win_y_return;
1667
unsigned int mask_return;
1668
int i;
1669
MetaRectangle pointer_position;
1670
1671
screen->display->xinerama_cache_invalidated = FALSE;
1672
1673
pointer_position.width = pointer_position.height = 1;
1674
XQueryPointer (screen->display->xdisplay,
1675
screen->xroot,
1676
&root_return,
1677
&child_return,
1678
&pointer_position.x,
1679
&pointer_position.y,
1680
&win_x_return,
1681
&win_y_return,
1682
&mask_return);
1683
1684
screen->last_xinerama_index = 0;
1685
for (i = 0; i < screen->n_xinerama_infos; i++)
1686
{
1687
if (meta_rectangle_contains_rect (&screen->xinerama_infos[i].rect,
1688
&pointer_position))
1689
{
1690
screen->last_xinerama_index = i;
1691
break;
1692
}
1693
}
1694
1695
meta_topic (META_DEBUG_XINERAMA,
1696
"Rechecked current Xinerama, now %d\n",
1697
screen->last_xinerama_index);
1698
}
1699
1700
return &screen->xinerama_infos[screen->last_xinerama_index];
1701
}
1702
1703
#define _NET_WM_ORIENTATION_HORZ 0
1704
#define _NET_WM_ORIENTATION_VERT 1
1705
1706
#define _NET_WM_TOPLEFT 0
1707
#define _NET_WM_TOPRIGHT 1
1708
#define _NET_WM_BOTTOMRIGHT 2
1709
#define _NET_WM_BOTTOMLEFT 3
1710
1711
void
1712
meta_screen_update_workspace_layout (MetaScreen *screen)
1713
{
1714
gulong *list;
1715
int n_items;
1716
1717
list = NULL;
1718
n_items = 0;
1719
1720
if (meta_prop_get_cardinal_list (screen->display,
1721
screen->xroot,
1722
screen->display->atom__NET_DESKTOP_LAYOUT,
1723
&list, &n_items))
1724
{
1725
if (n_items == 3 || n_items == 4)
1726
{
1727
int cols, rows;
1728
1729
switch (list[0])
1730
{
1731
case _NET_WM_ORIENTATION_HORZ:
1732
screen->vertical_workspaces = FALSE;
1733
break;
1734
case _NET_WM_ORIENTATION_VERT:
1735
screen->vertical_workspaces = TRUE;
1736
break;
1737
default:
1738
meta_warning ("Someone set a weird orientation in _NET_DESKTOP_LAYOUT\n");
1739
break;
1740
}
1741
1742
cols = list[1];
1743
rows = list[2];
1744
1745
if (rows <= 0 && cols <= 0)
1746
{
1747
meta_warning ("Columns = %d rows = %d in _NET_DESKTOP_LAYOUT makes no sense\n", rows, cols);
1748
}
1749
else
1750
{
1751
if (rows > 0)
1752
screen->rows_of_workspaces = rows;
1753
else
1754
screen->rows_of_workspaces = -1;
1755
1756
if (cols > 0)
1757
screen->columns_of_workspaces = cols;
1758
else
1759
screen->columns_of_workspaces = -1;
1760
}
1761
1762
if (n_items == 4)
1763
{
1764
switch (list[3])
1765
{
1766
case _NET_WM_TOPLEFT:
1767
screen->starting_corner = META_SCREEN_TOPLEFT;
1768
break;
1769
case _NET_WM_TOPRIGHT:
1770
screen->starting_corner = META_SCREEN_TOPRIGHT;
1771
break;
1772
case _NET_WM_BOTTOMRIGHT:
1773
screen->starting_corner = META_SCREEN_BOTTOMRIGHT;
1774
break;
1775
case _NET_WM_BOTTOMLEFT:
1776
screen->starting_corner = META_SCREEN_BOTTOMLEFT;
1777
break;
1778
default:
1779
meta_warning ("Someone set a weird starting corner in _NET_DESKTOP_LAYOUT\n");
1780
break;
1781
}
1782
}
1783
else
1784
screen->starting_corner = META_SCREEN_TOPLEFT;
1785
}
1786
else
1787
{
1788
meta_warning ("Someone set _NET_DESKTOP_LAYOUT to %d integers instead of 4 "
1789
"(3 is accepted for backwards compat)\n", n_items);
1790
}
1791
1792
meta_XFree (list);
1793
}
1794
1795
meta_verbose ("Workspace layout rows = %d cols = %d orientation = %d starting corner = %u\n",
1796
screen->rows_of_workspaces,
1797
screen->columns_of_workspaces,
1798
screen->vertical_workspaces,
1799
screen->starting_corner);
1800
}
1801
1802
static void
1803
set_workspace_names (MetaScreen *screen)
1804
{
1805
/* This updates names on root window when the pref changes,
1806
* note we only get prefs change notify if things have
1807
* really changed.
1808
*/
1809
GString *flattened;
1810
int i;
1811
int n_spaces;
1812
1813
/* flatten to nul-separated list */
1814
n_spaces = meta_screen_get_n_workspaces (screen);
1815
flattened = g_string_new ("");
1816
i = 0;
1817
while (i < n_spaces)
1818
{
1819
const char *name;
1820
1821
name = meta_prefs_get_workspace_name (i);
1822
1823
if (name)
1824
g_string_append_len (flattened, name,
1825
strlen (name) + 1);
1826
else
1827
g_string_append_len (flattened, "", 1);
1828
1829
++i;
1830
}
1831
1832
meta_error_trap_push (screen->display);
1833
XChangeProperty (screen->display->xdisplay,
1834
screen->xroot,
1835
screen->display->atom__NET_DESKTOP_NAMES,
1836
screen->display->atom_UTF8_STRING,
1837
8, PropModeReplace,
1838
(unsigned char *)flattened->str, flattened->len);
1839
meta_error_trap_pop (screen->display, FALSE);
1840
1841
g_string_free (flattened, TRUE);
1842
}
1843
1844
void
1845
meta_screen_update_workspace_names (MetaScreen *screen)
1846
{
1847
char **names;
1848
int n_names;
1849
int i;
1850
1851
/* this updates names in prefs when the root window property changes,
1852
* iff the new property contents don't match what's already in prefs
1853
*/
1854
1855
names = NULL;
1856
n_names = 0;
1857
if (!meta_prop_get_utf8_list (screen->display,
1858
screen->xroot,
1859
screen->display->atom__NET_DESKTOP_NAMES,
1860
&names, &n_names))
1861
{
1862
meta_verbose ("Failed to get workspace names from root window %d\n",
1863
screen->number);
1864
return;
1865
}
1866
1867
i = 0;
1868
while (i < n_names)
1869
{
1870
meta_topic (META_DEBUG_PREFS,
1871
"Setting workspace %d name to \"%s\" due to _NET_DESKTOP_NAMES change\n",
1872
i, names[i] ? names[i] : "null");
1873
meta_prefs_change_workspace_name (i, names[i]);
1874
1875
++i;
1876
}
1877
1878
g_strfreev (names);
1879
}
1880
1881
Window
1882
meta_create_offscreen_window (Display *xdisplay,
1883
Window parent,
1884
long valuemask)
1885
{
1886
XSetWindowAttributes attrs;
1887
1888
/* we want to be override redirect because sometimes we
1889
* create a window on a screen we aren't managing.
1890
* (but on a display we are managing at least one screen for)
1891
*/
1892
attrs.override_redirect = True;
1893
attrs.event_mask = valuemask;
1894
1895
return XCreateWindow (xdisplay,
1896
parent,
1897
-100, -100, 1, 1,
1898
0,
1899
CopyFromParent,
1900
CopyFromParent,
1901
(Visual *)CopyFromParent,
1902
CWOverrideRedirect | CWEventMask,
1903
&attrs);
1904
}
1905
1906
static void
1907
set_work_area_hint (MetaScreen *screen)
1908
{
1909
int num_workspaces;
1910
GList *tmp_list;
1911
unsigned long *data, *tmp;
1912
MetaRectangle area;
1913
1914
num_workspaces = meta_screen_get_n_workspaces (screen);
1915
data = g_new (unsigned long, num_workspaces * 4);
1916
tmp_list = screen->workspaces;
1917
tmp = data;
1918
1919
while (tmp_list != NULL)
1920
{
1921
MetaWorkspace *workspace = tmp_list->data;
1922
1923
if (workspace->screen == screen)
1924
{
1925
meta_workspace_get_work_area_all_xineramas (workspace, &area);
1926
tmp[0] = area.x;
1927
tmp[1] = area.y;
1928
tmp[2] = area.width;
1929
tmp[3] = area.height;
1930
1931
tmp += 4;
1932
}
1933
1934
tmp_list = tmp_list->next;
1935
}
1936
1937
meta_error_trap_push (screen->display);
1938
XChangeProperty (screen->display->xdisplay, screen->xroot,
1939
screen->display->atom__NET_WORKAREA,
1940
XA_CARDINAL, 32, PropModeReplace,
1941
(guchar*) data, num_workspaces*4);
1942
g_free (data);
1943
meta_error_trap_pop (screen->display, FALSE);
1944
}
1945
1946
static gboolean
1947
set_work_area_idle_func (MetaScreen *screen)
1948
{
1949
meta_topic (META_DEBUG_WORKAREA,
1950
"Running work area idle function\n");
1951
1952
screen->work_area_idle = 0;
1953
1954
set_work_area_hint (screen);
1955
1956
return FALSE;
1957
}
1958
1959
void
1960
meta_screen_queue_workarea_recalc (MetaScreen *screen)
1961
{
1962
/* Recompute work area in an idle */
1963
if (screen->work_area_idle == 0)
1964
{
1965
meta_topic (META_DEBUG_WORKAREA,
1966
"Adding work area hint idle function\n");
1967
screen->work_area_idle =
1968
g_idle_add_full (META_PRIORITY_WORK_AREA_HINT,
1969
(GSourceFunc) set_work_area_idle_func,
1970
screen,
1971
NULL);
1972
}
1973
}
1974
1975
1976
#ifdef WITH_VERBOSE_MODE
1977
static char *
1978
meta_screen_corner_to_string (MetaScreenCorner corner)
1979
{
1980
switch (corner)
1981
{
1982
case META_SCREEN_TOPLEFT:
1983
return "TopLeft";
1984
case META_SCREEN_TOPRIGHT:
1985
return "TopRight";
1986
case META_SCREEN_BOTTOMLEFT:
1987
return "BottomLeft";
1988
case META_SCREEN_BOTTOMRIGHT:
1989
return "BottomRight";
1990
}
1991
1992
return "Unknown";
1993
}
1994
#endif /* WITH_VERBOSE_MODE */
1995
1996
void
1997
meta_screen_calc_workspace_layout (MetaScreen *screen,
1998
int num_workspaces,
1999
int current_space,
2000
MetaWorkspaceLayout *layout)
2001
{
2002
int rows, cols;
2003
int grid_area;
2004
int *grid;
2005
int i, r, c;
2006
int current_row, current_col;
2007
2008
rows = screen->rows_of_workspaces;
2009
cols = screen->columns_of_workspaces;
2010
if (rows <= 0 && cols <= 0)
2011
cols = num_workspaces;
2012
2013
if (rows <= 0)
2014
rows = num_workspaces / cols + ((num_workspaces % cols) > 0 ? 1 : 0);
2015
if (cols <= 0)
2016
cols = num_workspaces / rows + ((num_workspaces % rows) > 0 ? 1 : 0);
2017
2018
/* paranoia */
2019
if (rows < 1)
2020
rows = 1;
2021
if (cols < 1)
2022
cols = 1;
2023
2024
g_assert (rows != 0 && cols != 0);
2025
2026
grid_area = rows * cols;
2027
2028
meta_verbose ("Getting layout rows = %d cols = %d current = %d "
2029
"num_spaces = %d vertical = %s corner = %s\n",
2030
rows, cols, current_space, num_workspaces,
2031
screen->vertical_workspaces ? "(true)" : "(false)",
2032
meta_screen_corner_to_string (screen->starting_corner));
2033
2034
/* ok, we want to setup the distances in the workspace array to go
2035
* in each direction. Remember, there are many ways that a workspace
2036
* array can be setup.
2037
* see http://www.freedesktop.org/standards/wm-spec/1.2/html/x109.html
2038
* and look at the _NET_DESKTOP_LAYOUT section for details.
2039
* For instance:
2040
*/
2041
/* starting_corner = META_SCREEN_TOPLEFT
2042
* vertical_workspaces = 0 vertical_workspaces=1
2043
* 1234 1357
2044
* 5678 2468
2045
*
2046
* starting_corner = META_SCREEN_TOPRIGHT
2047
* vertical_workspaces = 0 vertical_workspaces=1
2048
* 4321 7531
2049
* 8765 8642
2050
*
2051
* starting_corner = META_SCREEN_BOTTOMLEFT
2052
* vertical_workspaces = 0 vertical_workspaces=1
2053
* 5678 2468
2054
* 1234 1357
2055
*
2056
* starting_corner = META_SCREEN_BOTTOMRIGHT
2057
* vertical_workspaces = 0 vertical_workspaces=1
2058
* 8765 8642
2059
* 4321 7531
2060
*
2061
*/
2062
/* keep in mind that we could have a ragged layout, e.g. the "8"
2063
* in the above grids could be missing
2064
*/
2065
2066
2067
grid = g_new (int, grid_area);
2068
2069
current_row = -1;
2070
current_col = -1;
2071
i = 0;
2072
2073
switch (screen->starting_corner)
2074
{
2075
case META_SCREEN_TOPLEFT:
2076
if (screen->vertical_workspaces)
2077
{
2078
c = 0;
2079
while (c < cols)
2080
{
2081
r = 0;
2082
while (r < rows)
2083
{
2084
grid[r*cols+c] = i;
2085
++i;
2086
++r;
2087
}
2088
++c;
2089
}
2090
}
2091
else
2092
{
2093
r = 0;
2094
while (r < rows)
2095
{
2096
c = 0;
2097
while (c < cols)
2098
{
2099
grid[r*cols+c] = i;
2100
++i;
2101
++c;
2102
}
2103
++r;
2104
}
2105
}
2106
break;
2107
case META_SCREEN_TOPRIGHT:
2108
if (screen->vertical_workspaces)
2109
{
2110
c = cols - 1;
2111
while (c >= 0)
2112
{
2113
r = 0;
2114
while (r < rows)
2115
{
2116
grid[r*cols+c] = i;
2117
++i;
2118
++r;
2119
}
2120
--c;
2121
}
2122
}
2123
else
2124
{
2125
r = 0;
2126
while (r < rows)
2127
{
2128
c = cols - 1;
2129
while (c >= 0)
2130
{
2131
grid[r*cols+c] = i;
2132
++i;
2133
--c;
2134
}
2135
++r;
2136
}
2137
}
2138
break;
2139
case META_SCREEN_BOTTOMLEFT:
2140
if (screen->vertical_workspaces)
2141
{
2142
c = 0;
2143
while (c < cols)
2144
{
2145
r = rows - 1;
2146
while (r >= 0)
2147
{
2148
grid[r*cols+c] = i;
2149
++i;
2150
--r;
2151
}
2152
++c;
2153
}
2154
}
2155
else
2156
{
2157
r = rows - 1;
2158
while (r >= 0)
2159
{
2160
c = 0;
2161
while (c < cols)
2162
{
2163
grid[r*cols+c] = i;
2164
++i;
2165
++c;
2166
}
2167
--r;
2168
}
2169
}
2170
break;
2171
case META_SCREEN_BOTTOMRIGHT:
2172
if (screen->vertical_workspaces)
2173
{
2174
c = cols - 1;
2175
while (c >= 0)
2176
{
2177
r = rows - 1;
2178
while (r >= 0)
2179
{
2180
grid[r*cols+c] = i;
2181
++i;
2182
--r;
2183
}
2184
--c;
2185
}
2186
}
2187
else
2188
{
2189
r = rows - 1;
2190
while (r >= 0)
2191
{
2192
c = cols - 1;
2193
while (c >= 0)
2194
{
2195
grid[r*cols+c] = i;
2196
++i;
2197
--c;
2198
}
2199
--r;
2200
}
2201
}
2202
break;
2203
}
2204
2205
if (i != grid_area)
2206
meta_bug ("did not fill in the whole workspace grid in %s (%d filled)\n",
2207
G_STRFUNC, i);
2208
2209
current_row = 0;
2210
current_col = 0;
2211
r = 0;
2212
while (r < rows)
2213
{
2214
c = 0;
2215
while (c < cols)
2216
{
2217
if (grid[r*cols+c] == current_space)
2218
{
2219
current_row = r;
2220
current_col = c;
2221
}
2222
else if (grid[r*cols+c] >= num_workspaces)
2223
{
2224
/* flag nonexistent spaces with -1 */
2225
grid[r*cols+c] = -1;
2226
}
2227
++c;
2228
}
2229
++r;
2230
}
2231
2232
layout->rows = rows;
2233
layout->cols = cols;
2234
layout->grid = grid;
2235
layout->grid_area = grid_area;
2236
layout->current_row = current_row;
2237
layout->current_col = current_col;
2238
2239
#ifdef WITH_VERBOSE_MODE
2240
if (meta_is_verbose ())
2241
{
2242
r = 0;
2243
while (r < layout->rows)
2244
{
2245
meta_verbose (" ");
2246
meta_push_no_msg_prefix ();
2247
c = 0;
2248
while (c < layout->cols)
2249
{
2250
if (r == layout->current_row &&
2251
c == layout->current_col)
2252
meta_verbose ("*%2d ", layout->grid[r*layout->cols+c]);
2253
else
2254
meta_verbose ("%3d ", layout->grid[r*layout->cols+c]);
2255
++c;
2256
}
2257
meta_verbose ("\n");
2258
meta_pop_no_msg_prefix ();
2259
++r;
2260
}
2261
}
2262
#endif /* WITH_VERBOSE_MODE */
2263
}
2264
2265
void
2266
meta_screen_free_workspace_layout (MetaWorkspaceLayout *layout)
2267
{
2268
g_free (layout->grid);
2269
}
2270
2271
static void
2272
meta_screen_resize_func (MetaScreen *screen,
2273
MetaWindow *window,
2274
void *user_data)
2275
{
2276
if (window->struts)
2277
{
2278
meta_window_update_struts (window);
2279
}
2280
meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
2281
2282
meta_window_recalc_features (window);
2283
}
2284
2285
void
2286
meta_screen_resize (MetaScreen *screen,
2287
int width,
2288
int height)
2289
{
2290
screen->rect.width = width;
2291
screen->rect.height = height;
2292
2293
reload_xinerama_infos (screen);
2294
set_desktop_geometry_hint (screen);
2295
2296
/* Queue a resize on all the windows */
2297
meta_screen_foreach_window (screen, meta_screen_resize_func, 0);
2298
}
2299
2300
void
2301
meta_screen_update_showing_desktop_hint (MetaScreen *screen)
2302
{
2303
unsigned long data[1];
2304
2305
data[0] = screen->active_workspace->showing_desktop ? 1 : 0;
2306
2307
meta_error_trap_push (screen->display);
2308
XChangeProperty (screen->display->xdisplay, screen->xroot,
2309
screen->display->atom__NET_SHOWING_DESKTOP,
2310
XA_CARDINAL,
2311
32, PropModeReplace, (guchar*) data, 1);
2312
meta_error_trap_pop (screen->display, FALSE);
2313
}
2314
2315
static void
2316
queue_windows_showing (MetaScreen *screen)
2317
{
2318
GSList *windows;
2319
GSList *tmp;
2320
2321
/* Must operate on all windows on display instead of just on the
2322
* active_workspace's window list, because the active_workspace's
2323
* window list may not contain the on_all_workspace windows.
2324
*/
2325
windows = meta_display_list_windows (screen->display);
2326
2327
tmp = windows;
2328
while (tmp != NULL)
2329
{
2330
MetaWindow *w = tmp->data;
2331
2332
if (w->screen == screen)
2333
meta_window_queue (w, META_QUEUE_CALC_SHOWING);
2334
2335
tmp = tmp->next;
2336
}
2337
2338
g_slist_free (windows);
2339
}
2340
2341
void
2342
meta_screen_minimize_all_on_active_workspace_except (MetaScreen *screen,
2343
MetaWindow *keep)
2344
{
2345
GList *windows;
2346
GList *tmp;
2347
2348
windows = screen->active_workspace->windows;
2349
2350
tmp = windows;
2351
while (tmp != NULL)
2352
{
2353
MetaWindow *w = tmp->data;
2354
2355
if (w->screen == screen &&
2356
w->has_minimize_func &&
2357
w != keep)
2358
meta_window_minimize (w);
2359
2360
tmp = tmp->next;
2361
}
2362
}
2363
2364
void
2365
meta_screen_show_desktop (MetaScreen *screen,
2366
guint32 timestamp)
2367
{
2368
GList *windows;
2369
2370
if (screen->active_workspace->showing_desktop)
2371
return;
2372
2373
screen->active_workspace->showing_desktop = TRUE;
2374
2375
queue_windows_showing (screen);
2376
2377
/* Focus the most recently used META_WINDOW_DESKTOP window, if there is one;
2378
* see bug 159257.
2379
*/
2380
windows = screen->active_workspace->mru_list;
2381
while (windows != NULL)
2382
{
2383
MetaWindow *w = windows->data;
2384
2385
if (w->screen == screen &&
2386
w->type == META_WINDOW_DESKTOP)
2387
{
2388
meta_window_focus (w, timestamp);
2389
break;
2390
}
2391
2392
windows = windows->next;
2393
}
2394
2395
2396
meta_screen_update_showing_desktop_hint (screen);
2397
}
2398
2399
void
2400
meta_screen_unshow_desktop (MetaScreen *screen)
2401
{
2402
if (!screen->active_workspace->showing_desktop)
2403
return;
2404
2405
screen->active_workspace->showing_desktop = FALSE;
2406
2407
queue_windows_showing (screen);
2408
2409
meta_screen_update_showing_desktop_hint (screen);
2410
}
2411
2412
2413
#ifdef HAVE_STARTUP_NOTIFICATION
2414
static gboolean startup_sequence_timeout (void *data);
2415
2416
static void
2417
update_startup_feedback (MetaScreen *screen)
2418
{
2419
if (screen->startup_sequences != NULL)
2420
{
2421
meta_topic (META_DEBUG_STARTUP,
2422
"Setting busy cursor\n");
2423
meta_screen_set_cursor (screen, META_CURSOR_BUSY);
2424
}
2425
else
2426
{
2427
meta_topic (META_DEBUG_STARTUP,
2428
"Setting default cursor\n");
2429
meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
2430
}
2431
}
2432
2433
static void
2434
add_sequence (MetaScreen *screen,
2435
SnStartupSequence *sequence)
2436
{
2437
meta_topic (META_DEBUG_STARTUP,
2438
"Adding sequence %s\n",
2439
sn_startup_sequence_get_id (sequence));
2440
sn_startup_sequence_ref (sequence);
2441
screen->startup_sequences = g_slist_prepend (screen->startup_sequences,
2442
sequence);
2443
2444
/* our timeout just polls every second, instead of bothering
2445
* to compute exactly when we may next time out
2446
*/
2447
if (screen->startup_sequence_timeout == 0)
2448
screen->startup_sequence_timeout = g_timeout_add (1000,
2449
startup_sequence_timeout,
2450
screen);
2451
2452
update_startup_feedback (screen);
2453
}
2454
2455
static void
2456
remove_sequence (MetaScreen *screen,
2457
SnStartupSequence *sequence)
2458
{
2459
meta_topic (META_DEBUG_STARTUP,
2460
"Removing sequence %s\n",
2461
sn_startup_sequence_get_id (sequence));
2462
2463
screen->startup_sequences = g_slist_remove (screen->startup_sequences,
2464
sequence);
2465
sn_startup_sequence_unref (sequence);
2466
2467
if (screen->startup_sequences == NULL &&
2468
screen->startup_sequence_timeout != 0)
2469
{
2470
g_source_remove (screen->startup_sequence_timeout);
2471
screen->startup_sequence_timeout = 0;
2472
}
2473
2474
update_startup_feedback (screen);
2475
}
2476
2477
typedef struct
2478
{
2479
GSList *list;
2480
GTimeVal now;
2481
} CollectTimedOutData;
2482
2483
/* This should be fairly long, as it should never be required unless
2484
* apps or .desktop files are buggy, and it's confusing if
2485
* OpenOffice or whatever seems to stop launching - people
2486
* might decide they need to launch it again.
2487
*/
2488
#define STARTUP_TIMEOUT 15000
2489
2490
static void
2491
collect_timed_out_foreach (void *element,
2492
void *data)
2493
{
2494
CollectTimedOutData *ctod = data;
2495
SnStartupSequence *sequence = element;
2496
long tv_sec, tv_usec;
2497
double elapsed;
2498
2499
sn_startup_sequence_get_last_active_time (sequence, &tv_sec, &tv_usec);
2500
2501
elapsed =
2502
((((double)ctod->now.tv_sec - tv_sec) * G_USEC_PER_SEC +
2503
(ctod->now.tv_usec - tv_usec))) / 1000.0;
2504
2505
meta_topic (META_DEBUG_STARTUP,
2506
"Sequence used %g seconds vs. %g max: %s\n",
2507
elapsed, (double) STARTUP_TIMEOUT,
2508
sn_startup_sequence_get_id (sequence));
2509
2510
if (elapsed > STARTUP_TIMEOUT)
2511
ctod->list = g_slist_prepend (ctod->list, sequence);
2512
}
2513
2514
static gboolean
2515
startup_sequence_timeout (void *data)
2516
{
2517
MetaScreen *screen = data;
2518
CollectTimedOutData ctod;
2519
GSList *tmp;
2520
2521
ctod.list = NULL;
2522
g_get_current_time (&ctod.now);
2523
g_slist_foreach (screen->startup_sequences,
2524
collect_timed_out_foreach,
2525
&ctod);
2526
2527
tmp = ctod.list;
2528
while (tmp != NULL)
2529
{
2530
SnStartupSequence *sequence = tmp->data;
2531
2532
meta_topic (META_DEBUG_STARTUP,
2533
"Timed out sequence %s\n",
2534
sn_startup_sequence_get_id (sequence));
2535
2536
sn_startup_sequence_complete (sequence);
2537
2538
tmp = tmp->next;
2539
}
2540
2541
g_slist_free (ctod.list);
2542
2543
if (screen->startup_sequences != NULL)
2544
{
2545
return TRUE;
2546
}
2547
else
2548
{
2549
/* remove */
2550
screen->startup_sequence_timeout = 0;
2551
return FALSE;
2552
}
2553
}
2554
2555
static void
2556
meta_screen_sn_event (SnMonitorEvent *event,
2557
void *user_data)
2558
{
2559
MetaScreen *screen;
2560
SnStartupSequence *sequence;
2561
2562
screen = user_data;
2563
2564
sequence = sn_monitor_event_get_startup_sequence (event);
2565
2566
switch (sn_monitor_event_get_type (event))
2567
{
2568
case SN_MONITOR_EVENT_INITIATED:
2569
{
2570
const char *wmclass;
2571
2572
wmclass = sn_startup_sequence_get_wmclass (sequence);
2573
2574
meta_topic (META_DEBUG_STARTUP,
2575
"Received startup initiated for %s wmclass %s\n",
2576
sn_startup_sequence_get_id (sequence),
2577
wmclass ? wmclass : "(unset)");
2578
add_sequence (screen, sequence);
2579
}
2580
break;
2581
2582
case SN_MONITOR_EVENT_COMPLETED:
2583
{
2584
meta_topic (META_DEBUG_STARTUP,
2585
"Received startup completed for %s\n",
2586
sn_startup_sequence_get_id (sequence));
2587
remove_sequence (screen,
2588
sn_monitor_event_get_startup_sequence (event));
2589
}
2590
break;
2591
2592
case SN_MONITOR_EVENT_CHANGED:
2593
meta_topic (META_DEBUG_STARTUP,
2594
"Received startup changed for %s\n",
2595
sn_startup_sequence_get_id (sequence));
2596
break;
2597
2598
case SN_MONITOR_EVENT_CANCELED:
2599
meta_topic (META_DEBUG_STARTUP,
2600
"Received startup canceled for %s\n",
2601
sn_startup_sequence_get_id (sequence));
2602
break;
2603
}
2604
}
2605
#endif
2606
2607
/* Sets the initial_timestamp and initial_workspace properties
2608
* of a window according to information given us by the
2609
* startup-notification library.
2610
*
2611
* Returns TRUE if startup properties have been applied, and
2612
* FALSE if they have not (for example, if they had already
2613
* been applied.)
2614
*/
2615
gboolean
2616
meta_screen_apply_startup_properties (MetaScreen *screen,
2617
MetaWindow *window)
2618
{
2619
#ifdef HAVE_STARTUP_NOTIFICATION
2620
const char *startup_id;
2621
GSList *tmp;
2622
SnStartupSequence *sequence;
2623
2624
/* Does the window have a startup ID stored? */
2625
startup_id = meta_window_get_startup_id (window);
2626
2627
meta_topic (META_DEBUG_STARTUP,
2628
"Applying startup props to %s id \"%s\"\n",
2629
window->desc,
2630
startup_id ? startup_id : "(none)");
2631
2632
sequence = NULL;
2633
if (startup_id == NULL)
2634
{
2635
/* No startup ID stored for the window. Let's ask the
2636
* startup-notification library whether there's anything
2637
* stored for the resource name or resource class hints.
2638
*/
2639
tmp = screen->startup_sequences;
2640
while (tmp != NULL)
2641
{
2642
const char *wmclass;
2643
2644
wmclass = sn_startup_sequence_get_wmclass (tmp->data);
2645
2646
if (wmclass != NULL &&
2647
((window->res_class &&
2648
strcmp (wmclass, window->res_class) == 0) ||
2649
(window->res_name &&
2650
strcmp (wmclass, window->res_name) == 0)))
2651
{
2652
sequence = tmp->data;
2653
2654
g_assert (window->startup_id == NULL);
2655
window->startup_id = g_strdup (sn_startup_sequence_get_id (sequence));
2656
startup_id = window->startup_id;
2657
2658
meta_topic (META_DEBUG_STARTUP,
2659
"Ending legacy sequence %s due to window %s\n",
2660
sn_startup_sequence_get_id (sequence),
2661
window->desc);
2662
2663
sn_startup_sequence_complete (sequence);
2664
break;
2665
}
2666
2667
tmp = tmp->next;
2668
}
2669
}
2670
2671
/* Still no startup ID? Bail. */
2672
if (startup_id == NULL)
2673
return FALSE;
2674
2675
/* We might get this far and not know the sequence ID (if the window
2676
* already had a startup ID stored), so let's look for one if we don't
2677
* already know it.
2678
*/
2679
if (sequence == NULL)
2680
{
2681
tmp = screen->startup_sequences;
2682
while (tmp != NULL)
2683
{
2684
const char *id;
2685
2686
id = sn_startup_sequence_get_id (tmp->data);
2687
2688
if (strcmp (id, startup_id) == 0)
2689
{
2690
sequence = tmp->data;
2691
break;
2692
}
2693
2694
tmp = tmp->next;
2695
}
2696
}
2697
2698
if (sequence != NULL)
2699
{
2700
gboolean changed_something = FALSE;
2701
2702
meta_topic (META_DEBUG_STARTUP,
2703
"Found startup sequence for window %s ID \"%s\"\n",
2704
window->desc, startup_id);
2705
2706
if (!window->initial_workspace_set)
2707
{
2708
int space = sn_startup_sequence_get_workspace (sequence);
2709
if (space >= 0)
2710
{
2711
meta_topic (META_DEBUG_STARTUP,
2712
"Setting initial window workspace to %d based on startup info\n",
2713
space);
2714
2715
window->initial_workspace_set = TRUE;
2716
window->initial_workspace = space;
2717
changed_something = TRUE;
2718
}
2719
}
2720
2721
if (!window->initial_timestamp_set)
2722
{
2723
guint32 timestamp = sn_startup_sequence_get_timestamp (sequence);
2724
meta_topic (META_DEBUG_STARTUP,
2725
"Setting initial window timestamp to %u based on startup info\n",
2726
timestamp);
2727
2728
window->initial_timestamp_set = TRUE;
2729
window->initial_timestamp = timestamp;
2730
changed_something = TRUE;
2731
}
2732
2733
return changed_something;
2734
}
2735
else
2736
{
2737
meta_topic (META_DEBUG_STARTUP,
2738
"Did not find startup sequence for window %s ID \"%s\"\n",
2739
window->desc, startup_id);
2740
}
2741
2742
#endif /* HAVE_STARTUP_NOTIFICATION */
2743
2744
return FALSE;
2745
}
2746
2747
int
2748
meta_screen_get_screen_number (MetaScreen *screen)
2749
{
2750
return screen->number;
2751
}
2752
2753
MetaDisplay *
2754
meta_screen_get_display (MetaScreen *screen)
2755
{
2756
return screen->display;
2757
}
2758
2759
Window
2760
meta_screen_get_xroot (MetaScreen *screen)
2761
{
2762
return screen->xroot;
2763
}
2764
2765
void
2766
meta_screen_get_size (MetaScreen *screen,
2767
int *width,
2768
int *height)
2769
{
2770
*width = screen->rect.width;
2771
*height = screen->rect.height;
2772
}
2773
2774
gpointer
2775
meta_screen_get_compositor_data (MetaScreen *screen)
2776
{
2777
return screen->compositor_data;
2778
}
2779
2780
void
2781
meta_screen_set_compositor_data (MetaScreen *screen,
2782
gpointer compositor)
2783
{
2784
screen->compositor_data = compositor;
2785
}
2786
2787
#ifdef HAVE_COMPOSITE_EXTENSIONS
2788
void
2789
meta_screen_set_cm_selection (MetaScreen *screen)
2790
{
2791
char selection[32];
2792
Atom a;
2793
2794
screen->wm_cm_timestamp = meta_display_get_current_time_roundtrip (
2795
screen->display);
2796
2797
g_snprintf (selection, sizeof(selection), "_NET_WM_CM_S%d", screen->number);
2798
meta_verbose ("Setting selection: %s\n", selection);
2799
a = XInternAtom (screen->display->xdisplay, selection, FALSE);
2800
XSetSelectionOwner (screen->display->xdisplay, a,
2801
screen->wm_cm_selection_window, screen->wm_cm_timestamp);
2802
}
2803
2804
void
2805
meta_screen_unset_cm_selection (MetaScreen *screen)
2806
{
2807
char selection[32];
2808
Atom a;
2809
2810
g_snprintf (selection, sizeof(selection), "_NET_WM_CM_S%d", screen->number);
2811
a = XInternAtom (screen->display->xdisplay, selection, FALSE);
2812
XSetSelectionOwner (screen->display->xdisplay, a,
2813
None, screen->wm_cm_timestamp);
2814
}
2815
#endif /* HAVE_COMPOSITE_EXTENSIONS */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1