← Back to branch summary

~ubuntu-branches/debian/sid/openbox/sid

« back to all changes in this revision

Viewing changes to openbox/screen.c

  • Committer: Bazaar Package Importer
  • Author(s): Nico Golde, Nico Golde, Eugenio Paolantonio
  • Date: 2011-10-03 22:59:30 UTC
  • mfrom: (1.1.11 upstream)
  • Revision ID: james.westby@ubuntu.com-20111003225930-tdvyax5tx63dyoez
Tags: 3.5.0-1
http://bugs.debian.org/638783
http://bugs.debian.org/563891
http://bugs.debian.org/627912
[Nico Golde]
* New upstream release (Closes: #638783).
  - Fix crashes in the menu code (Closes: #563891).
* Add Brazilian translation to openbox.desktop,
  thanks Sérgio Cipolla (Closes: #627912).
* Remove 06_fix_swap_byte_order.patch, applied upstream.
* Bump debhelper dependency to >= 7.0.50~ due to override.
* Remove CHANGELOG from openbox.docs to prevent double installation.
* Add 02_fix_freedesktop_compliance.dpatch desktop file to
  /usr/share/applications.

[Eugenio Paolantonio]
* debian/patches:
  - Disabled 03_place_windows_in_quadrants.patch
  - Updated 01_rc.xml.patch and 06_fix_swap_byte_order.patch
  - Removed 04_fix_ftbfs_no-add-needed.patch and 20_24bits_support.patch
* debian/control:
  - Added myself to the Uploaders.
  - Build-Depends: removed libxau-dev, libxft-dev and python-xdg;
    added libimlib2-dev
  - openbox Suggests: added python-xdg
  - libobrender21 renamed to libobrender27
  - libobparser21 renamed to libobt0
* debian/rules:
  - Rewrote using a simpler debhelper syntax
  - Moved the install pass to openbox.install
* debian/*.{install,links,dirs}:
  - Updated.
* debian/openbox.xsession:
  - Removed. Openbox now ships it by default.

Show diffs side-by-side

added added

removed removed

Lines of Context:
openbox/screen.c
20
20
#include "debug.h"
21
21
#include "openbox.h"
22
22
#include "dock.h"
23
 
#include "xerror.h"
24
 
#include "prop.h"
25
23
#include "grab.h"
26
24
#include "startupnotify.h"
27
25
#include "moveresize.h"
28
26
#include "config.h"
29
 
#include "mainloop.h"
30
27
#include "screen.h"
31
28
#include "client.h"
32
29
#include "session.h"
35
32
#include "focus.h"
36
33
#include "focus_cycle.h"
37
34
#include "popup.h"
38
 
#include "extensions.h"
39
 
#include "render/render.h"
 
35
#include "version.h"
 
36
#include "obrender/render.h"
40
37
#include "gettext.h"
 
38
#include "obt/display.h"
 
39
#include "obt/xqueue.h"
 
40
#include "obt/prop.h"
41
41
 
42
42
#include <X11/Xlib.h>
43
43
#ifdef HAVE_UNISTD_H
70
70
static Size     screen_physical_size;
71
71
static guint    screen_old_desktop;
72
72
static gboolean screen_desktop_timeout = TRUE;
 
73
static guint    screen_desktop_timer = 0;
73
74
/*! An array of desktops, holding an array of areas per monitor */
74
75
static Rect  *monitor_area = NULL;
75
76
/*! An array of desktops, holding an array of struts */
79
80
static GSList *struts_bottom = NULL;
80
81
 
81
82
static ObPagerPopup *desktop_popup;
 
83
static guint         desktop_popup_timer = 0;
 
84
static gboolean      desktop_popup_perm;
82
85
 
83
86
/*! The number of microseconds that you need to be on a desktop before it will
84
87
  replace the remembered "last desktop" */
85
 
#define REMEMBER_LAST_DESKTOP_TIME 750000
 
88
#define REMEMBER_LAST_DESKTOP_TIME 750
86
89
 
87
90
static gboolean replace_wm(void)
88
91
{
92
95
    Time timestamp;
93
96
 
94
97
    wm_sn = g_strdup_printf("WM_S%d", ob_screen);
95
 
    wm_sn_atom = XInternAtom(ob_display, wm_sn, FALSE);
 
98
    wm_sn_atom = XInternAtom(obt_display, wm_sn, FALSE);
96
99
    g_free(wm_sn);
97
100
 
98
 
    current_wm_sn_owner = XGetSelectionOwner(ob_display, wm_sn_atom);
 
101
    current_wm_sn_owner = XGetSelectionOwner(obt_display, wm_sn_atom);
99
102
    if (current_wm_sn_owner == screen_support_win)
100
103
        current_wm_sn_owner = None;
101
104
    if (current_wm_sn_owner) {
104
107
                      ob_screen);
105
108
            return FALSE;
106
109
        }
107
 
        xerror_set_ignore(TRUE);
108
 
        xerror_occured = FALSE;
 
110
        obt_display_ignore_errors(TRUE);
109
111
 
110
112
        /* We want to find out when the current selection owner dies */
111
 
        XSelectInput(ob_display, current_wm_sn_owner, StructureNotifyMask);
112
 
        XSync(ob_display, FALSE);
 
113
        XSelectInput(obt_display, current_wm_sn_owner, StructureNotifyMask);
 
114
        XSync(obt_display, FALSE);
113
115
 
114
 
        xerror_set_ignore(FALSE);
115
 
        if (xerror_occured)
 
116
        obt_display_ignore_errors(FALSE);
 
117
        if (obt_display_error_occured)
116
118
            current_wm_sn_owner = None;
117
119
    }
118
120
 
119
 
    timestamp = event_get_server_time();
 
121
    timestamp = event_time();
120
122
 
121
 
    XSetSelectionOwner(ob_display, wm_sn_atom, screen_support_win,
 
123
    XSetSelectionOwner(obt_display, wm_sn_atom, screen_support_win,
122
124
                       timestamp);
123
125
 
124
 
    if (XGetSelectionOwner(ob_display, wm_sn_atom) != screen_support_win) {
 
126
    if (XGetSelectionOwner(obt_display, wm_sn_atom) != screen_support_win) {
125
127
        g_message(_("Could not acquire window manager selection on screen %d"),
126
128
                  ob_screen);
127
129
        return FALSE;
129
131
 
130
132
    /* Wait for old window manager to go away */
131
133
    if (current_wm_sn_owner) {
132
 
      XEvent event;
133
134
      gulong wait = 0;
134
135
      const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
 
136
      ObtXQueueWindowType wt;
 
137
 
 
138
      wt.window = current_wm_sn_owner;
 
139
      wt.type = DestroyNotify;
135
140
 
136
141
      while (wait < timeout) {
137
 
          if (XCheckWindowEvent(ob_display, current_wm_sn_owner,
138
 
                                StructureNotifyMask, &event) &&
139
 
              event.type == DestroyNotify)
 
142
          /* Checks the local queue and incoming events for this event */
 
143
          if (xqueue_exists_local(xqueue_match_window_type, &wt))
140
144
              break;
141
145
          g_usleep(G_USEC_PER_SEC / 10);
142
146
          wait += G_USEC_PER_SEC / 10;
149
153
    }
150
154
 
151
155
    /* Send client message indicating that we are now the WM */
152
 
    prop_message(RootWindow(ob_display, ob_screen), prop_atoms.manager,
153
 
                 timestamp, wm_sn_atom, screen_support_win, 0,
154
 
                 SubstructureNotifyMask);
 
156
    obt_prop_message(ob_screen, obt_root(ob_screen), OBT_PROP_ATOM(MANAGER),
 
157
                     timestamp, wm_sn_atom, screen_support_win, 0, 0,
 
158
                     SubstructureNotifyMask);
155
159
 
156
160
    return TRUE;
157
161
}
161
165
    XSetWindowAttributes attrib;
162
166
    pid_t pid;
163
167
    gint i, num_support;
164
 
    Atom *prop_atoms_start, *wm_supported_pos;
165
168
    gulong *supported;
166
169
 
167
170
    /* create the netwm support window */
168
171
    attrib.override_redirect = TRUE;
169
172
    attrib.event_mask = PropertyChangeMask;
170
 
    screen_support_win = XCreateWindow(ob_display,
171
 
                                       RootWindow(ob_display, ob_screen),
 
173
    screen_support_win = XCreateWindow(obt_display, obt_root(ob_screen),
172
174
                                       -100, -100, 1, 1, 0,
173
175
                                       CopyFromParent, InputOutput,
174
176
                                       CopyFromParent,
175
177
                                       CWEventMask | CWOverrideRedirect,
176
178
                                       &attrib);
177
 
    XMapWindow(ob_display, screen_support_win);
178
 
    XLowerWindow(ob_display, screen_support_win);
 
179
    XMapWindow(obt_display, screen_support_win);
 
180
    XLowerWindow(obt_display, screen_support_win);
179
181
 
180
182
    if (!replace_wm()) {
181
 
        XDestroyWindow(ob_display, screen_support_win);
 
183
        XDestroyWindow(obt_display, screen_support_win);
182
184
        return FALSE;
183
185
    }
184
186
 
185
 
    xerror_set_ignore(TRUE);
186
 
    xerror_occured = FALSE;
187
 
    XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
188
 
                 ROOT_EVENTMASK);
189
 
    xerror_set_ignore(FALSE);
190
 
    if (xerror_occured) {
 
187
    obt_display_ignore_errors(TRUE);
 
188
    XSelectInput(obt_display, obt_root(ob_screen), ROOT_EVENTMASK);
 
189
    obt_display_ignore_errors(FALSE);
 
190
    if (obt_display_error_occured) {
191
191
        g_message(_("A window manager is already running on screen %d"),
192
192
                  ob_screen);
193
193
 
194
 
        XDestroyWindow(ob_display, screen_support_win);
 
194
        XDestroyWindow(obt_display, screen_support_win);
195
195
        return FALSE;
196
196
    }
197
197
 
199
199
 
200
200
    /* set the OPENBOX_PID hint */
201
201
    pid = getpid();
202
 
    PROP_SET32(RootWindow(ob_display, ob_screen),
203
 
               openbox_pid, cardinal, pid);
 
202
    OBT_PROP_SET32(obt_root(ob_screen), OPENBOX_PID, CARDINAL, pid);
204
203
 
205
204
    /* set supporting window */
206
 
    PROP_SET32(RootWindow(ob_display, ob_screen),
207
 
               net_supporting_wm_check, window, screen_support_win);
 
205
    OBT_PROP_SET32(obt_root(ob_screen),
 
206
                   NET_SUPPORTING_WM_CHECK, WINDOW, screen_support_win);
208
207
 
209
208
    /* set properties on the supporting window */
210
 
    PROP_SETS(screen_support_win, net_wm_name, "Openbox");
211
 
    PROP_SET32(screen_support_win, net_supporting_wm_check,
212
 
               window, screen_support_win);
 
209
    OBT_PROP_SETS(screen_support_win, NET_WM_NAME, "Openbox");
 
210
    OBT_PROP_SET32(screen_support_win, NET_SUPPORTING_WM_CHECK,
 
211
                   WINDOW, screen_support_win);
213
212
 
214
213
    /* set the _NET_SUPPORTED_ATOMS hint */
215
214
 
216
 
    /* this is all the atoms after net_supported in the prop_atoms struct */
217
 
    prop_atoms_start = (Atom*)&prop_atoms;
218
 
    wm_supported_pos = (Atom*)&(prop_atoms.net_supported);
219
 
    num_support = sizeof(prop_atoms) / sizeof(Atom) -
220
 
        (wm_supported_pos - prop_atoms_start) - 1;
 
215
    /* this is all the atoms after NET_SUPPORTED in the ObtPropAtoms enum */
 
216
    num_support = OBT_PROP_NUM_ATOMS - OBT_PROP_NET_SUPPORTED - 1;
221
217
    i = 0;
222
218
    supported = g_new(gulong, num_support);
223
 
    supported[i++] = prop_atoms.net_supporting_wm_check;
224
 
    supported[i++] = prop_atoms.net_wm_full_placement;
225
 
    supported[i++] = prop_atoms.net_current_desktop;
226
 
    supported[i++] = prop_atoms.net_number_of_desktops;
227
 
    supported[i++] = prop_atoms.net_desktop_geometry;
228
 
    supported[i++] = prop_atoms.net_desktop_viewport;
229
 
    supported[i++] = prop_atoms.net_active_window;
230
 
    supported[i++] = prop_atoms.net_workarea;
231
 
    supported[i++] = prop_atoms.net_client_list;
232
 
    supported[i++] = prop_atoms.net_client_list_stacking;
233
 
    supported[i++] = prop_atoms.net_desktop_names;
234
 
    supported[i++] = prop_atoms.net_close_window;
235
 
    supported[i++] = prop_atoms.net_desktop_layout;
236
 
    supported[i++] = prop_atoms.net_showing_desktop;
237
 
    supported[i++] = prop_atoms.net_wm_name;
238
 
    supported[i++] = prop_atoms.net_wm_visible_name;
239
 
    supported[i++] = prop_atoms.net_wm_icon_name;
240
 
    supported[i++] = prop_atoms.net_wm_visible_icon_name;
241
 
    supported[i++] = prop_atoms.net_wm_desktop;
242
 
    supported[i++] = prop_atoms.net_wm_strut;
243
 
    supported[i++] = prop_atoms.net_wm_strut_partial;
244
 
    supported[i++] = prop_atoms.net_wm_icon;
245
 
    supported[i++] = prop_atoms.net_wm_icon_geometry;
246
 
    supported[i++] = prop_atoms.net_wm_window_type;
247
 
    supported[i++] = prop_atoms.net_wm_window_type_desktop;
248
 
    supported[i++] = prop_atoms.net_wm_window_type_dock;
249
 
    supported[i++] = prop_atoms.net_wm_window_type_toolbar;
250
 
    supported[i++] = prop_atoms.net_wm_window_type_menu;
251
 
    supported[i++] = prop_atoms.net_wm_window_type_utility;
252
 
    supported[i++] = prop_atoms.net_wm_window_type_splash;
253
 
    supported[i++] = prop_atoms.net_wm_window_type_dialog;
254
 
    supported[i++] = prop_atoms.net_wm_window_type_normal;
255
 
    supported[i++] = prop_atoms.net_wm_allowed_actions;
256
 
    supported[i++] = prop_atoms.net_wm_action_move;
257
 
    supported[i++] = prop_atoms.net_wm_action_resize;
258
 
    supported[i++] = prop_atoms.net_wm_action_minimize;
259
 
    supported[i++] = prop_atoms.net_wm_action_shade;
260
 
    supported[i++] = prop_atoms.net_wm_action_maximize_horz;
261
 
    supported[i++] = prop_atoms.net_wm_action_maximize_vert;
262
 
    supported[i++] = prop_atoms.net_wm_action_fullscreen;
263
 
    supported[i++] = prop_atoms.net_wm_action_change_desktop;
264
 
    supported[i++] = prop_atoms.net_wm_action_close;
265
 
    supported[i++] = prop_atoms.net_wm_action_above;
266
 
    supported[i++] = prop_atoms.net_wm_action_below;
267
 
    supported[i++] = prop_atoms.net_wm_state;
268
 
    supported[i++] = prop_atoms.net_wm_state_modal;
269
 
    supported[i++] = prop_atoms.net_wm_state_maximized_vert;
270
 
    supported[i++] = prop_atoms.net_wm_state_maximized_horz;
271
 
    supported[i++] = prop_atoms.net_wm_state_shaded;
272
 
    supported[i++] = prop_atoms.net_wm_state_skip_taskbar;
273
 
    supported[i++] = prop_atoms.net_wm_state_skip_pager;
274
 
    supported[i++] = prop_atoms.net_wm_state_hidden;
275
 
    supported[i++] = prop_atoms.net_wm_state_fullscreen;
276
 
    supported[i++] = prop_atoms.net_wm_state_above;
277
 
    supported[i++] = prop_atoms.net_wm_state_below;
278
 
    supported[i++] = prop_atoms.net_wm_state_demands_attention;
279
 
    supported[i++] = prop_atoms.net_moveresize_window;
280
 
    supported[i++] = prop_atoms.net_wm_moveresize;
281
 
    supported[i++] = prop_atoms.net_wm_user_time;
 
219
    supported[i++] = OBT_PROP_ATOM(NET_SUPPORTING_WM_CHECK);
 
220
    supported[i++] = OBT_PROP_ATOM(NET_WM_FULL_PLACEMENT);
 
221
    supported[i++] = OBT_PROP_ATOM(NET_CURRENT_DESKTOP);
 
222
    supported[i++] = OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS);
 
223
    supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_GEOMETRY);
 
224
    supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_VIEWPORT);
 
225
    supported[i++] = OBT_PROP_ATOM(NET_ACTIVE_WINDOW);
 
226
    supported[i++] = OBT_PROP_ATOM(NET_WORKAREA);
 
227
    supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST);
 
228
    supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST_STACKING);
 
229
    supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_NAMES);
 
230
    supported[i++] = OBT_PROP_ATOM(NET_CLOSE_WINDOW);
 
231
    supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_LAYOUT);
 
232
    supported[i++] = OBT_PROP_ATOM(NET_SHOWING_DESKTOP);
 
233
    supported[i++] = OBT_PROP_ATOM(NET_WM_NAME);
 
234
    supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_NAME);
 
235
    supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_NAME);
 
236
    supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_ICON_NAME);
 
237
    supported[i++] = OBT_PROP_ATOM(NET_WM_DESKTOP);
 
238
    supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT);
 
239
    supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL);
 
240
    supported[i++] = OBT_PROP_ATOM(NET_WM_ICON);
 
241
    supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY);
 
242
    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE);
 
243
    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP);
 
244
    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK);
 
245
    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR);
 
246
    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU);
 
247
    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY);
 
248
    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH);
 
249
    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG);
 
250
    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL);
 
251
    supported[i++] = OBT_PROP_ATOM(NET_WM_ALLOWED_ACTIONS);
 
252
    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE);
 
253
    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE);
 
254
    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE);
 
255
    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE);
 
256
    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ);
 
257
    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT);
 
258
    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN);
 
259
    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP);
 
260
    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE);
 
261
    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE);
 
262
    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW);
 
263
    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE);
 
264
    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL);
 
265
    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT);
 
266
    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ);
 
267
    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED);
 
268
    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR);
 
269
    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER);
 
270
    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN);
 
271
    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN);
 
272
    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE);
 
273
    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW);
 
274
    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION);
 
275
    supported[i++] = OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW);
 
276
    supported[i++] = OBT_PROP_ATOM(NET_WM_MOVERESIZE);
 
277
    supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME);
282
278
/*
283
 
    supported[i++] = prop_atoms.net_wm_user_time_window;
 
279
    supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME_WINDOW);
284
280
*/
285
 
    supported[i++] = prop_atoms.net_frame_extents;
286
 
    supported[i++] = prop_atoms.net_request_frame_extents;
287
 
    supported[i++] = prop_atoms.net_restack_window;
288
 
    supported[i++] = prop_atoms.net_startup_id;
 
281
    supported[i++] = OBT_PROP_ATOM(NET_FRAME_EXTENTS);
 
282
    supported[i++] = OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS);
 
283
    supported[i++] = OBT_PROP_ATOM(NET_RESTACK_WINDOW);
 
284
    supported[i++] = OBT_PROP_ATOM(NET_STARTUP_ID);
289
285
#ifdef SYNC
290
 
    supported[i++] = prop_atoms.net_wm_sync_request;
291
 
    supported[i++] = prop_atoms.net_wm_sync_request_counter;
 
286
    supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST);
 
287
    supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER);
292
288
#endif
293
 
    supported[i++] = prop_atoms.net_wm_pid;
294
 
    supported[i++] = prop_atoms.net_wm_ping;
295
 
 
296
 
    supported[i++] = prop_atoms.kde_wm_change_state;
297
 
    supported[i++] = prop_atoms.kde_net_wm_frame_strut;
298
 
    supported[i++] = prop_atoms.kde_net_wm_window_type_override;
299
 
 
300
 
    supported[i++] = prop_atoms.ob_wm_action_undecorate;
301
 
    supported[i++] = prop_atoms.ob_wm_state_undecorated;
302
 
    supported[i++] = prop_atoms.openbox_pid;
303
 
    supported[i++] = prop_atoms.ob_theme;
304
 
    supported[i++] = prop_atoms.ob_config_file;
305
 
    supported[i++] = prop_atoms.ob_control;
306
 
    supported[i++] = prop_atoms.ob_version;
307
 
    supported[i++] = prop_atoms.ob_app_role;
308
 
    supported[i++] = prop_atoms.ob_app_name;
309
 
    supported[i++] = prop_atoms.ob_app_class;
310
 
    supported[i++] = prop_atoms.ob_app_type;
 
289
    supported[i++] = OBT_PROP_ATOM(NET_WM_PID);
 
290
    supported[i++] = OBT_PROP_ATOM(NET_WM_PING);
 
291
 
 
292
    supported[i++] = OBT_PROP_ATOM(KDE_WM_CHANGE_STATE);
 
293
    supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_FRAME_STRUT);
 
294
    supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE);
 
295
 
 
296
    supported[i++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE);
 
297
    supported[i++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED);
 
298
    supported[i++] = OBT_PROP_ATOM(OPENBOX_PID);
 
299
    supported[i++] = OBT_PROP_ATOM(OB_THEME);
 
300
    supported[i++] = OBT_PROP_ATOM(OB_CONFIG_FILE);
 
301
    supported[i++] = OBT_PROP_ATOM(OB_CONTROL);
 
302
    supported[i++] = OBT_PROP_ATOM(OB_VERSION);
 
303
    supported[i++] = OBT_PROP_ATOM(OB_APP_ROLE);
 
304
    supported[i++] = OBT_PROP_ATOM(OB_APP_TITLE);
 
305
    supported[i++] = OBT_PROP_ATOM(OB_APP_NAME);
 
306
    supported[i++] = OBT_PROP_ATOM(OB_APP_CLASS);
 
307
    supported[i++] = OBT_PROP_ATOM(OB_APP_TYPE);
311
308
    g_assert(i == num_support);
312
309
 
313
 
    PROP_SETA32(RootWindow(ob_display, ob_screen),
314
 
                net_supported, atom, supported, num_support);
 
310
    OBT_PROP_SETA32(obt_root(ob_screen),
 
311
                    NET_SUPPORTED, ATOM, supported, num_support);
315
312
    g_free(supported);
316
313
 
317
 
    PROP_SETS(RootWindow(ob_display, ob_screen), ob_version,
318
 
              OB_VERSION);
 
314
    OBT_PROP_SETS(RootWindow(obt_display, ob_screen), OB_VERSION,
 
315
                  OPENBOX_VERSION);
319
316
 
320
317
    screen_tell_ksplash();
321
318
 
346
343
       hear it anyways. perhaps it is for old ksplash. or new ksplash. or
347
344
       something. oh well. */
348
345
    e.xclient.type = ClientMessage;
349
 
    e.xclient.display = ob_display;
350
 
    e.xclient.window = RootWindow(ob_display, ob_screen);
 
346
    e.xclient.display = obt_display;
 
347
    e.xclient.window = obt_root(ob_screen);
351
348
    e.xclient.message_type =
352
 
        XInternAtom(ob_display, "_KDE_SPLASH_PROGRESS", False);
 
349
        XInternAtom(obt_display, "_KDE_SPLASH_PROGRESS", False);
353
350
    e.xclient.format = 8;
354
351
    strcpy(e.xclient.data.b, "wm started");
355
 
    XSendEvent(ob_display, RootWindow(ob_display, ob_screen),
356
 
               False, SubstructureNotifyMask, &e );
 
352
    XSendEvent(obt_display, obt_root(ob_screen),
 
353
               False, SubstructureNotifyMask, &e);
357
354
}
358
355
 
359
356
void screen_startup(gboolean reconfig)
363
360
    gboolean namesexist = FALSE;
364
361
 
365
362
    desktop_popup = pager_popup_new();
 
363
    desktop_popup_perm = FALSE;
366
364
    pager_popup_height(desktop_popup, POPUP_HEIGHT);
367
365
 
368
366
    if (reconfig) {
377
375
    screen_resize();
378
376
 
379
377
    /* have names already been set for the desktops? */
380
 
    if (PROP_GETSS(RootWindow(ob_display, ob_screen),
381
 
                   net_desktop_names, utf8, &names))
382
 
    {
 
378
    if (OBT_PROP_GETSS_UTF8(obt_root(ob_screen), NET_DESKTOP_NAMES, &names)) {
383
379
        g_strfreev(names);
384
380
        namesexist = TRUE;
385
381
    }
400
396
            names[i] = g_strdup(it->data);
401
397
 
402
398
        /* set the root window property */
403
 
        PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,names);
 
399
        OBT_PROP_SETSS(obt_root(ob_screen),
 
400
                       NET_DESKTOP_NAMES, (const gchar*const*)names);
404
401
 
405
402
        g_strfreev(names);
406
403
    }
410
407
       this will also set the default names from the config file up for
411
408
       desktops that don't have names yet */
412
409
    screen_num_desktops = 0;
413
 
    if (PROP_GET32(RootWindow(ob_display, ob_screen),
414
 
                   net_number_of_desktops, cardinal, &d))
 
410
    if (OBT_PROP_GET32(obt_root(ob_screen),
 
411
                       NET_NUMBER_OF_DESKTOPS, CARDINAL, &d))
415
412
    {
416
413
        if (d != config_desktops_num) {
417
414
            /* TRANSLATORS: If you need to specify a different order of the
431
428
 
432
429
    screen_desktop = screen_num_desktops;  /* something invalid */
433
430
    /* start on the current desktop when a wm was already running */
434
 
    if (PROP_GET32(RootWindow(ob_display, ob_screen),
435
 
                   net_current_desktop, cardinal, &d) &&
 
431
    if (OBT_PROP_GET32(obt_root(ob_screen),
 
432
                       NET_CURRENT_DESKTOP, CARDINAL, &d) &&
436
433
        d < screen_num_desktops)
437
434
    {
438
435
        screen_set_desktop(d, FALSE);
446
443
 
447
444
    /* don't start in showing-desktop mode */
448
445
    screen_showing_desktop = FALSE;
449
 
    PROP_SET32(RootWindow(ob_display, ob_screen),
450
 
               net_showing_desktop, cardinal, screen_showing_desktop);
 
446
    OBT_PROP_SET32(obt_root(ob_screen),
 
447
                   NET_SHOWING_DESKTOP, CARDINAL, screen_showing_desktop);
451
448
 
452
449
    if (session_desktop_layout_present &&
453
450
        screen_validate_layout(&session_desktop_layout))
465
462
    if (reconfig)
466
463
        return;
467
464
 
468
 
    XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
469
 
                 NoEventMask);
 
465
    XSelectInput(obt_display, obt_root(ob_screen), NoEventMask);
470
466
 
471
467
    /* we're not running here no more! */
472
 
    PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid);
 
468
    OBT_PROP_ERASE(obt_root(ob_screen), OPENBOX_PID);
473
469
    /* not without us */
474
 
    PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported);
 
470
    OBT_PROP_ERASE(obt_root(ob_screen), NET_SUPPORTED);
475
471
    /* don't keep this mode */
476
 
    PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop);
 
472
    OBT_PROP_ERASE(obt_root(ob_screen), NET_SHOWING_DESKTOP);
477
473
 
478
 
    XDestroyWindow(ob_display, screen_support_win);
 
474
    XDestroyWindow(obt_display, screen_support_win);
479
475
 
480
476
    g_strfreev(screen_desktop_names);
481
477
    screen_desktop_names = NULL;
488
484
    GList *it;
489
485
    gulong geometry[2];
490
486
 
491
 
    w = WidthOfScreen(ScreenOfDisplay(ob_display, ob_screen));
492
 
    h = HeightOfScreen(ScreenOfDisplay(ob_display, ob_screen));
 
487
    w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
 
488
    h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
493
489
 
494
490
    if (w == oldw && h == oldh) return;
495
491
 
498
494
    /* Set the _NET_DESKTOP_GEOMETRY hint */
499
495
    screen_physical_size.width = geometry[0] = w;
500
496
    screen_physical_size.height = geometry[1] = h;
501
 
    PROP_SETA32(RootWindow(ob_display, ob_screen),
502
 
                net_desktop_geometry, cardinal, geometry, 2);
 
497
    OBT_PROP_SETA32(obt_root(ob_screen),
 
498
                    NET_DESKTOP_GEOMETRY, CARDINAL, geometry, 2);
503
499
 
504
500
    if (ob_state() != OB_STATE_RUNNING)
505
501
        return;
506
502
 
507
 
    screen_update_areas();
 
503
    /* this calls screen_update_areas(), which we need ! */
508
504
    dock_configure();
509
505
 
510
 
    for (it = client_list; it; it = g_list_next(it))
511
 
        client_move_onscreen(it->data, FALSE);
 
506
    if (oldw)
 
507
        for (it = client_list; it; it = g_list_next(it))
 
508
            client_move_onscreen(it->data, FALSE);
512
509
}
513
510
 
514
511
void screen_set_num_desktops(guint num)
521
518
    if (screen_num_desktops == num) return;
522
519
 
523
520
    screen_num_desktops = num;
524
 
    PROP_SET32(RootWindow(ob_display, ob_screen),
525
 
               net_number_of_desktops, cardinal, num);
 
521
    OBT_PROP_SET32(obt_root(ob_screen), NET_NUMBER_OF_DESKTOPS, CARDINAL, num);
526
522
 
527
523
    /* set the viewport hint */
528
524
    viewport = g_new0(gulong, num * 2);
529
 
    PROP_SETA32(RootWindow(ob_display, ob_screen),
530
 
                net_desktop_viewport, cardinal, viewport, num * 2);
 
525
    OBT_PROP_SETA32(obt_root(ob_screen),
 
526
                    NET_DESKTOP_VIEWPORT, CARDINAL, viewport, num * 2);
531
527
    g_free(viewport);
532
528
 
533
529
    /* the number of rows/columns will differ */
607
603
static gboolean last_desktop_func(gpointer data)
608
604
{
609
605
    screen_desktop_timeout = TRUE;
610
 
    return FALSE;
 
606
    screen_desktop_timer = 0;
 
607
    return FALSE; /* don't repeat */
611
608
}
612
609
 
613
610
void screen_set_desktop(guint num, gboolean dofocus)
623
620
 
624
621
    if (previous == num) return;
625
622
 
626
 
    PROP_SET32(RootWindow(ob_display, ob_screen),
627
 
               net_current_desktop, cardinal, num);
 
623
    OBT_PROP_SET32(obt_root(ob_screen), NET_CURRENT_DESKTOP, CARDINAL, num);
628
624
 
629
625
    /* This whole thing decides when/how to save the screen_last_desktop so
630
626
       that it can be restored later if you want */
690
686
        }
691
687
    }
692
688
    screen_desktop_timeout = FALSE;
693
 
    ob_main_loop_timeout_remove(ob_main_loop, last_desktop_func);
694
 
    ob_main_loop_timeout_add(ob_main_loop, REMEMBER_LAST_DESKTOP_TIME,
695
 
                             last_desktop_func, NULL, NULL, NULL);
 
689
    if (screen_desktop_timer) g_source_remove(screen_desktop_timer);
 
690
    screen_desktop_timer = g_timeout_add(REMEMBER_LAST_DESKTOP_TIME,
 
691
                                         last_desktop_func, NULL);
696
692
 
697
 
    ob_debug("Moving to desktop %d\n", num+1);
 
693
    ob_debug("Moving to desktop %d", num+1);
698
694
 
699
695
    if (ob_state() == OB_STATE_RUNNING)
700
 
        screen_show_desktop_popup(screen_desktop);
 
696
        screen_show_desktop_popup(screen_desktop, FALSE);
701
697
 
702
698
    /* ignore enter events caused by the move */
703
699
    ignore_start = event_start_ignore_all_enters();
741
737
 
742
738
    event_end_ignore_all_enters(ignore_start);
743
739
 
744
 
    if (event_curtime != CurrentTime)
745
 
        screen_desktop_user_time = event_curtime;
 
740
    if (event_source_time() != CurrentTime)
 
741
        screen_desktop_user_time = event_source_time();
746
742
}
747
743
 
748
744
void screen_add_desktop(gboolean current)
765
761
                   parent - which will have to be on the same desktop */
766
762
                !client_direct_parent(c))
767
763
            {
768
 
                ob_debug("moving window %s\n", c->title);
 
764
                ob_debug("moving window %s", c->title);
769
765
                client_set_desktop(c, c->desktop+1, FALSE, TRUE);
770
766
            }
771
767
        }
806
802
                   parent - which will have to be on the same desktop */
807
803
                !client_direct_parent(c))
808
804
            {
809
 
                ob_debug("moving window %s\n", c->title);
 
805
                ob_debug("moving window %s", c->title);
810
806
                client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
811
807
            }
812
808
            /* raise all the windows that are on the current desktop which
816
812
                (d == DESKTOP_ALL || d == screen_desktop))
817
813
            {
818
814
                stacking_raise(CLIENT_AS_WINDOW(c));
819
 
                ob_debug("raising window %s\n", c->title);
 
815
                ob_debug("raising window %s", c->title);
820
816
            }
821
817
        }
822
818
    }
825
821
    /* fallback focus like we're changing desktops */
826
822
    if (screen_desktop < screen_num_desktops - 1) {
827
823
        screen_fallback_focus();
828
 
        ob_debug("fake desktop change\n");
 
824
        ob_debug("fake desktop change");
829
825
    }
830
826
 
831
827
    screen_set_num_desktops(screen_num_desktops-1);
944
940
static gboolean hide_desktop_popup_func(gpointer data)
945
941
{
946
942
    pager_popup_hide(desktop_popup);
 
943
    desktop_popup_timer = 0;
947
944
    return FALSE; /* don't repeat */
948
945
}
949
946
 
950
 
void screen_show_desktop_popup(guint d)
 
947
void screen_show_desktop_popup(guint d, gboolean perm)
951
948
{
952
 
    Rect *a;
 
949
    const Rect *a;
953
950
 
954
951
    /* 0 means don't show the popup */
955
952
    if (!config_desktop_popup_time) return;
966
963
                          MAX(a->width/3, POPUP_WIDTH));
967
964
    pager_popup_show(desktop_popup, screen_desktop_names[d], d);
968
965
 
969
 
    ob_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
970
 
    ob_main_loop_timeout_add(ob_main_loop, config_desktop_popup_time * 1000,
971
 
                             hide_desktop_popup_func, NULL, NULL, NULL);
972
 
    g_free(a);
 
966
    if (desktop_popup_timer) g_source_remove(desktop_popup_timer);
 
967
    desktop_popup_timer = 0;
 
968
    if (!perm && !desktop_popup_perm)
 
969
        /* only hide if its not already being show permanently */
 
970
        desktop_popup_timer = g_timeout_add(config_desktop_popup_time,
 
971
                                            hide_desktop_popup_func,
 
972
                                            desktop_popup);
 
973
    if (perm)
 
974
        desktop_popup_perm = TRUE;
973
975
}
974
976
 
975
977
void screen_hide_desktop_popup(void)
976
978
{
977
 
    ob_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
 
979
    if (desktop_popup_timer) g_source_remove(desktop_popup_timer);
 
980
    desktop_popup_timer = 0;
978
981
    pager_popup_hide(desktop_popup);
 
982
    desktop_popup_perm = FALSE;
979
983
}
980
984
 
981
985
guint screen_find_desktop(guint from, ObDirection dir,
1133
1137
    screen_desktop_layout.rows = 1;
1134
1138
    screen_desktop_layout.columns = screen_num_desktops;
1135
1139
 
1136
 
    if (PROP_GETA32(RootWindow(ob_display, ob_screen),
1137
 
                    net_desktop_layout, cardinal, &data, &num)) {
 
1140
    if (OBT_PROP_GETA32(obt_root(ob_screen),
 
1141
                        NET_DESKTOP_LAYOUT, CARDINAL, &data, &num)) {
1138
1142
        if (num == 3 || num == 4) {
1139
1143
 
1140
 
            if (data[0] == prop_atoms.net_wm_orientation_vert)
 
1144
            if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_VERT))
1141
1145
                l.orientation = OB_ORIENTATION_VERT;
1142
 
            else if (data[0] == prop_atoms.net_wm_orientation_horz)
 
1146
            else if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_HORZ))
1143
1147
                l.orientation = OB_ORIENTATION_HORZ;
1144
1148
            else
1145
1149
                return;
1147
1151
            if (num < 4)
1148
1152
                l.start_corner = OB_CORNER_TOPLEFT;
1149
1153
            else {
1150
 
                if (data[3] == prop_atoms.net_wm_topleft)
 
1154
                if (data[3] == OBT_PROP_ATOM(NET_WM_TOPLEFT))
1151
1155
                    l.start_corner = OB_CORNER_TOPLEFT;
1152
 
                else if (data[3] == prop_atoms.net_wm_topright)
 
1156
                else if (data[3] == OBT_PROP_ATOM(NET_WM_TOPRIGHT))
1153
1157
                    l.start_corner = OB_CORNER_TOPRIGHT;
1154
 
                else if (data[3] == prop_atoms.net_wm_bottomright)
 
1158
                else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMRIGHT))
1155
1159
                    l.start_corner = OB_CORNER_BOTTOMRIGHT;
1156
 
                else if (data[3] == prop_atoms.net_wm_bottomleft)
 
1160
                else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMLEFT))
1157
1161
                    l.start_corner = OB_CORNER_BOTTOMLEFT;
1158
1162
                else
1159
1163
                    return;
1178
1182
    g_strfreev(screen_desktop_names);
1179
1183
    screen_desktop_names = NULL;
1180
1184
 
1181
 
    if (PROP_GETSS(RootWindow(ob_display, ob_screen),
1182
 
                   net_desktop_names, utf8, &screen_desktop_names))
 
1185
    if (OBT_PROP_GETSS(obt_root(ob_screen),
 
1186
                       NET_DESKTOP_NAMES, &screen_desktop_names))
1183
1187
        for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
1184
1188
    else
1185
1189
        i = 0;
1205
1209
 
1206
1210
        /* if we changed any names, then set the root property so we can
1207
1211
           all agree on the names */
1208
 
        PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,
1209
 
                   screen_desktop_names);
 
1212
        OBT_PROP_SETSS(obt_root(ob_screen), NET_DESKTOP_NAMES,
 
1213
                       (const gchar*const*)screen_desktop_names);
1210
1214
    }
1211
1215
 
1212
1216
    /* resize the pager for these names */
1273
1277
    }
1274
1278
 
1275
1279
    show = !!show; /* make it boolean */
1276
 
    PROP_SET32(RootWindow(ob_display, ob_screen),
1277
 
               net_showing_desktop, cardinal, show);
 
1280
    OBT_PROP_SET32(obt_root(ob_screen), NET_SHOWING_DESKTOP, CARDINAL, show);
1278
1281
}
1279
1282
 
1280
1283
void screen_install_colormap(ObClient *client, gboolean install)
1281
1284
{
1282
1285
    if (client == NULL || client->colormap == None) {
1283
1286
        if (install)
1284
 
            XInstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
 
1287
            XInstallColormap(obt_display, RrColormap(ob_rr_inst));
1285
1288
        else
1286
 
            XUninstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
 
1289
            XUninstallColormap(obt_display, RrColormap(ob_rr_inst));
1287
1290
    } else {
1288
 
        xerror_set_ignore(TRUE);
 
1291
        obt_display_ignore_errors(TRUE);
1289
1292
        if (install)
1290
 
            XInstallColormap(RrDisplay(ob_rr_inst), client->colormap);
 
1293
            XInstallColormap(obt_display, client->colormap);
1291
1294
        else
1292
 
            XUninstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1293
 
        xerror_set_ignore(FALSE);
 
1295
            XUninstallColormap(obt_display, client->colormap);
 
1296
        obt_display_ignore_errors(FALSE);
1294
1297
    }
1295
1298
}
1296
1299
 
1300
1303
} ObScreenStrut;
1301
1304
 
1302
1305
#define RESET_STRUT_LIST(sl) \
1303
 
    (g_slist_free(sl), sl = NULL)
 
1306
    while (sl) { \
 
1307
        g_slice_free(ObScreenStrut, (sl)->data); \
 
1308
        sl = g_slist_delete_link(sl, sl); \
 
1309
    }
1304
1310
 
1305
1311
#define ADD_STRUT_TO_LIST(sl, d, s) \
1306
1312
{ \
1307
 
    ObScreenStrut *ss = g_new(ObScreenStrut, 1); \
 
1313
    ObScreenStrut *ss = g_slice_new(ObScreenStrut); \
1308
1314
    ss->desktop = d; \
1309
1315
    ss->strut = s;  \
1310
1316
    sl = g_slist_prepend(sl, ss); \
1319
1325
    } \
1320
1326
}
1321
1327
 
 
1328
static void get_xinerama_screens(Rect **xin_areas, guint *nxin)
 
1329
{
 
1330
    guint i;
 
1331
    gint n, l, r, t, b;
 
1332
#ifdef XINERAMA
 
1333
    XineramaScreenInfo *info;
 
1334
#endif
 
1335
 
 
1336
    if (ob_debug_xinerama) {
 
1337
        gint w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
 
1338
        gint h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
 
1339
        *nxin = 2;
 
1340
        *xin_areas = g_new(Rect, *nxin + 1);
 
1341
        RECT_SET((*xin_areas)[0], 0, 0, w/2, h);
 
1342
        RECT_SET((*xin_areas)[1], w/2, 0, w-(w/2), h);
 
1343
    }
 
1344
#ifdef XINERAMA
 
1345
    else if (obt_display_extension_xinerama &&
 
1346
             (info = XineramaQueryScreens(obt_display, &n))) {
 
1347
        *nxin = n;
 
1348
        *xin_areas = g_new(Rect, *nxin + 1);
 
1349
        for (i = 0; i < *nxin; ++i)
 
1350
            RECT_SET((*xin_areas)[i], info[i].x_org, info[i].y_org,
 
1351
                     info[i].width, info[i].height);
 
1352
        XFree(info);
 
1353
    }
 
1354
#endif
 
1355
    else {
 
1356
        *nxin = 1;
 
1357
        *xin_areas = g_new(Rect, *nxin + 1);
 
1358
        RECT_SET((*xin_areas)[0], 0, 0,
 
1359
                 WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)),
 
1360
                 HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen)));
 
1361
    }
 
1362
 
 
1363
    /* returns one extra with the total area in it */
 
1364
    l = (*xin_areas)[0].x;
 
1365
    t = (*xin_areas)[0].y;
 
1366
    r = (*xin_areas)[0].x + (*xin_areas)[0].width - 1;
 
1367
    b = (*xin_areas)[0].y + (*xin_areas)[0].height - 1;
 
1368
    for (i = 1; i < *nxin; ++i) {
 
1369
        l = MIN(l, (*xin_areas)[i].x);
 
1370
        t = MIN(l, (*xin_areas)[i].y);
 
1371
        r = MAX(r, (*xin_areas)[i].x + (*xin_areas)[i].width - 1);
 
1372
        b = MAX(b, (*xin_areas)[i].y + (*xin_areas)[i].height - 1);
 
1373
    }
 
1374
    RECT_SET((*xin_areas)[*nxin], l, t, r - l + 1, b - t + 1);
 
1375
}
 
1376
 
1322
1377
void screen_update_areas(void)
1323
1378
{
1324
1379
    guint i;
1325
1380
    gulong *dims;
1326
 
    GList *it;
 
1381
    GList *it, *onscreen;
 
1382
 
 
1383
    /* collect the clients that are on screen */
 
1384
    onscreen = NULL;
 
1385
    for (it = client_list; it; it = g_list_next(it)) {
 
1386
        if (client_monitor(it->data) != screen_num_monitors)
 
1387
            onscreen = g_list_prepend(onscreen, it->data);
 
1388
    }
1327
1389
 
1328
1390
    g_free(monitor_area);
1329
 
    extensions_xinerama_screens(&monitor_area, &screen_num_monitors);
 
1391
    get_xinerama_screens(&monitor_area, &screen_num_monitors);
1330
1392
 
1331
1393
    /* set up the user-specified margins */
1332
1394
    config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1389
1451
        dims[i*4+1] = area->y;
1390
1452
        dims[i*4+2] = area->width;
1391
1453
        dims[i*4+3] = area->height;
1392
 
        g_free(area);
 
1454
        g_slice_free(Rect, area);
1393
1455
    }
1394
1456
 
1395
1457
    /* set the legacy workarea hint to the union of all the monitors */
1396
 
    PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal,
1397
 
                dims, 4 * screen_num_desktops);
 
1458
    OBT_PROP_SETA32(obt_root(ob_screen), NET_WORKAREA, CARDINAL,
 
1459
                    dims, 4 * screen_num_desktops);
1398
1460
 
1399
1461
    /* the area has changed, adjust all the windows if they need it */
1400
 
    for (it = client_list; it; it = g_list_next(it))
 
1462
    for (it = onscreen; it; it = g_list_next(it))
1401
1463
        client_reconfigure(it->data, FALSE);
1402
1464
 
1403
1465
    g_free(dims);
1480
1542
    }
1481
1543
    if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1482
1544
 
 
1545
    /* al is "all left" meaning the furthest left you can get, l is our
 
1546
       "working left" meaning our current strut edge which we're calculating
 
1547
    */
 
1548
 
1483
1549
    /* only include monitors which the search area lines up with */
1484
1550
    if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1485
1551
        l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1557
1623
        }
1558
1624
    }
1559
1625
 
1560
 
    a = g_new(Rect, 1);
 
1626
    a = g_slice_new(Rect);
1561
1627
    a->x = l;
1562
1628
    a->y = t;
1563
1629
    a->width = r - l + 1;
1565
1631
    return a;
1566
1632
}
1567
1633
 
1568
 
guint screen_find_monitor(Rect *search)
 
1634
guint screen_find_monitor(const Rect *search)
1569
1635
{
1570
1636
    guint i;
1571
1637
    guint most = screen_num_monitors;
1572
1638
    guint mostv = 0;
1573
1639
 
1574
1640
    for (i = 0; i < screen_num_monitors; ++i) {
1575
 
        Rect *area = screen_physical_area_monitor(i);
 
1641
        const Rect *area = screen_physical_area_monitor(i);
1576
1642
        if (RECT_INTERSECTS_RECT(*area, *search)) {
1577
1643
            Rect r;
1578
1644
            guint v;
1585
1651
                most = i;
1586
1652
            }
1587
1653
        }
1588
 
        g_free(area);
1589
1654
    }
1590
 
    return most;
 
1655
    return most < screen_num_monitors ? most : screen_monitor_primary(FALSE);
1591
1656
}
1592
1657
 
1593
 
Rect* screen_physical_area_all_monitors(void)
 
1658
const Rect* screen_physical_area_all_monitors(void)
1594
1659
{
1595
1660
    return screen_physical_area_monitor(screen_num_monitors);
1596
1661
}
1597
1662
 
1598
 
Rect* screen_physical_area_monitor(guint head)
 
1663
const Rect* screen_physical_area_monitor(guint head)
1599
1664
{
1600
 
    Rect *a;
1601
1665
    g_assert(head <= screen_num_monitors);
1602
1666
 
1603
 
    a = g_new(Rect, 1);
1604
 
    *a = monitor_area[head];
1605
 
    return a;
 
1667
    return &monitor_area[head];
1606
1668
}
1607
1669
 
1608
1670
gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1622
1684
        return screen_monitor_pointer();
1623
1685
}
1624
1686
 
1625
 
Rect* screen_physical_area_active(void)
 
1687
const Rect* screen_physical_area_active(void)
1626
1688
{
1627
1689
    return screen_physical_area_monitor(screen_monitor_active());
1628
1690
}
1643
1705
        return screen_monitor_pointer();
1644
1706
}
1645
1707
 
1646
 
Rect *screen_physical_area_primary(gboolean fixed)
 
1708
const Rect* screen_physical_area_primary(gboolean fixed)
1647
1709
{
1648
1710
    return screen_physical_area_monitor(screen_monitor_primary(fixed));
1649
1711
}
1651
1713
void screen_set_root_cursor(void)
1652
1714
{
1653
1715
    if (sn_app_starting())
1654
 
        XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
 
1716
        XDefineCursor(obt_display, obt_root(ob_screen),
1655
1717
                      ob_cursor(OB_CURSOR_BUSYPOINTER));
1656
1718
    else
1657
 
        XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
 
1719
        XDefineCursor(obt_display, obt_root(ob_screen),
1658
1720
                      ob_cursor(OB_CURSOR_POINTER));
1659
1721
}
1660
1722
 
1680
1742
    guint u;
1681
1743
    gboolean ret;
1682
1744
 
1683
 
    ret = !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen),
 
1745
    ret = !!XQueryPointer(obt_display, obt_root(ob_screen),
1684
1746
                          &w, &w, x, y, &i, &i, &u);
1685
1747
    if (!ret) {
1686
 
        for (i = 0; i < ScreenCount(ob_display); ++i)
 
1748
        for (i = 0; i < ScreenCount(obt_display); ++i)
1687
1749
            if (i != ob_screen)
1688
 
                if (XQueryPointer(ob_display, RootWindow(ob_display, i),
 
1750
                if (XQueryPointer(obt_display, obt_root(i),
1689
1751
                                  &w, &w, x, y, &i, &i, &u))
1690
1752
                    break;
1691
1753
    }
1692
1754
    return ret;
1693
1755
}
 
1756
 
 
1757
gboolean screen_compare_desktops(guint a, guint b)
 
1758
{
 
1759
    if (a == DESKTOP_ALL)
 
1760
        a = screen_desktop;
 
1761
    if (b == DESKTOP_ALL)
 
1762
        b = screen_desktop;
 
1763
    return a == b;
 
1764
}