Add include of cairo.h when using librsvg
[dana/openbox.git] / openbox / window.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    window.c for the Openbox window manager
4    Copyright (c) 2003-2007   Dana Jansens
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    See the COPYING file for a copy of the GNU General Public License.
17 */
18
19 #include "window.h"
20 #include "menuframe.h"
21 #include "config.h"
22 #include "dock.h"
23 #include "client.h"
24 #include "frame.h"
25 #include "openbox.h"
26 #include "prompt.h"
27 #include "debug.h"
28 #include "grab.h"
29 #include "obt/prop.h"
30 #include "obt/xqueue.h"
31
32 static GHashTable *window_map;
33
34 static guint window_hash(Window *w) { return *w; }
35 static gboolean window_comp(Window *w1, Window *w2) { return *w1 == *w2; }
36
37 void window_startup(gboolean reconfig)
38 {
39     if (reconfig) return;
40
41     window_map = g_hash_table_new((GHashFunc)window_hash,
42                                   (GEqualFunc)window_comp);
43 }
44
45 void window_shutdown(gboolean reconfig)
46 {
47     if (reconfig) return;
48
49     g_hash_table_destroy(window_map);
50 }
51
52 Window window_top(ObWindow *self)
53 {
54     switch (self->type) {
55     case OB_WINDOW_CLASS_MENUFRAME:
56         return WINDOW_AS_MENUFRAME(self)->window;
57     case OB_WINDOW_CLASS_DOCK:
58         return WINDOW_AS_DOCK(self)->frame;
59     case OB_WINDOW_CLASS_CLIENT:
60         return WINDOW_AS_CLIENT(self)->frame->window;
61     case OB_WINDOW_CLASS_INTERNAL:
62         return WINDOW_AS_INTERNAL(self)->window;
63     case OB_WINDOW_CLASS_PROMPT:
64         return WINDOW_AS_PROMPT(self)->super.window;
65     }
66     g_assert_not_reached();
67     return None;
68 }
69
70 ObStackingLayer window_layer(ObWindow *self)
71 {
72     switch (self->type) {
73     case OB_WINDOW_CLASS_DOCK:
74         return config_dock_layer;
75     case OB_WINDOW_CLASS_CLIENT:
76         return ((ObClient*)self)->layer;
77     case OB_WINDOW_CLASS_MENUFRAME:
78     case OB_WINDOW_CLASS_INTERNAL:
79         return OB_STACKING_LAYER_INTERNAL;
80     case OB_WINDOW_CLASS_PROMPT:
81         /* not used directly for stacking, prompts are managed as clients */
82         g_assert_not_reached();
83         break;
84     }
85     g_assert_not_reached();
86     return None;
87 }
88
89 ObWindow* window_find(Window xwin)
90 {
91     return g_hash_table_lookup(window_map, &xwin);
92 }
93
94 void window_add(Window *xwin, ObWindow *win)
95 {
96     g_assert(xwin != NULL);
97     g_assert(win != NULL);
98     g_hash_table_insert(window_map, xwin, win);
99 }
100
101 void window_remove(Window xwin)
102 {
103     g_assert(xwin != None);
104     g_hash_table_remove(window_map, &xwin);
105 }
106
107 void window_manage_all(void)
108 {
109     guint i, j, nchild;
110     Window w, *children;
111     XWMHints *wmhints;
112     XWindowAttributes attrib;
113
114     if (!XQueryTree(obt_display, RootWindow(obt_display, ob_screen),
115                     &w, &w, &children, &nchild)) {
116         ob_debug("XQueryTree failed in window_manage_all");
117         nchild = 0;
118     }
119
120     /* remove all icon windows from the list */
121     for (i = 0; i < nchild; i++) {
122         if (children[i] == None) continue;
123         wmhints = XGetWMHints(obt_display, children[i]);
124         if (wmhints) {
125             if ((wmhints->flags & IconWindowHint) &&
126                 (wmhints->icon_window != children[i]))
127                 for (j = 0; j < nchild; j++)
128                     if (children[j] == wmhints->icon_window) {
129                         /* XXX watch the window though */
130                         children[j] = None;
131                         break;
132                     }
133             XFree(wmhints);
134         }
135     }
136
137     for (i = 0; i < nchild; ++i) {
138         if (children[i] == None) continue;
139         if (window_find(children[i])) continue; /* skip our own windows */
140         if (XGetWindowAttributes(obt_display, children[i], &attrib)) {
141             if (attrib.map_state == IsUnmapped)
142                 ;
143             else
144                 window_manage(children[i]);
145         }
146     }
147
148     if (children) XFree(children);
149 }
150
151 static gboolean check_unmap(XEvent *e, gpointer data)
152 {
153     const Window win = *(Window*)data;
154     return ((e->type == DestroyNotify && e->xdestroywindow.window == win) ||
155             (e->type == UnmapNotify && e->xunmap.window == win));
156 }
157
158 void window_manage(Window win)
159 {
160     XWindowAttributes attrib;
161     gboolean no_manage = FALSE;
162     gboolean is_dockapp = FALSE;
163     Window icon_win = None;
164
165     grab_server(TRUE);
166
167     /* check if it has already been unmapped by the time we started
168        mapping. the grab does a sync so we don't have to here */
169     if (xqueue_exists_local(check_unmap, &win)) {
170         ob_debug("Trying to manage unmapped window. Aborting that.");
171         no_manage = TRUE;
172     }
173     else if (!XGetWindowAttributes(obt_display, win, &attrib))
174         no_manage = TRUE;
175     else {
176         XWMHints *wmhints;
177
178         /* is the window a docking app */
179         is_dockapp = FALSE;
180         if ((wmhints = XGetWMHints(obt_display, win))) {
181             if ((wmhints->flags & StateHint) &&
182                 wmhints->initial_state == WithdrawnState)
183             {
184                 if (wmhints->flags & IconWindowHint)
185                     icon_win = wmhints->icon_window;
186                 is_dockapp = TRUE;
187             }
188             XFree(wmhints);
189         }
190         /* This is a new method to declare that a window is a dockapp, being
191            implemented by Windowmaker, to alleviate pain in writing GTK+
192            dock apps.
193            http://thread.gmane.org/gmane.comp.window-managers.openbox/4881
194         */
195         if (!is_dockapp) {
196             gchar **ss;
197             if (OBT_PROP_GETSS_TYPE(win, WM_CLASS, STRING_NO_CC, &ss))
198             {
199                 if (ss[0] && ss[1] && strcmp(ss[1], "DockApp") == 0)
200                     is_dockapp = TRUE;
201                 g_strfreev(ss);
202             }
203         }
204     }
205
206     if (!no_manage) {
207         if (attrib.override_redirect) {
208             ob_debug("not managing override redirect window 0x%x", win);
209             grab_server(FALSE);
210         }
211         else if (is_dockapp) {
212             if (!icon_win)
213                 icon_win = win;
214             dock_manage(icon_win, win);
215         }
216         else
217             client_manage(win, NULL);
218     }
219     else {
220         grab_server(FALSE);
221         ob_debug("FAILED to manage window 0x%x", win);
222     }
223 }
224
225 void window_unmanage_all(void)
226 {
227     dock_unmanage_all();
228     client_unmanage_all();
229 }