Dogcows Code - chaz/openbox/blob - 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
  30 static GHashTable *window_map;
  31
  32 static guint window_hash(Window *w) { return *w; }
  33 static gboolean window_comp(Window *w1, Window *w2) { return *w1 == *w2; }
  34
  35 void window_startup(gboolean reconfig)
  36 {
  37     if (reconfig) return;
  38
  39     window_map = g_hash_table_new((GHashFunc)window_hash,
  40                                   (GEqualFunc)window_comp);
  41 }
  42
  43 void window_shutdown(gboolean reconfig)
  44 {
  45     if (reconfig) return;
  46
  47     g_hash_table_destroy(window_map);
  48 }
  49
  50 Window window_top(ObWindow *self)
  51 {
  52     switch (self->type) {
  53     case OB_WINDOW_CLASS_MENUFRAME:
  54         return WINDOW_AS_MENUFRAME(self)->window;
  55     case OB_WINDOW_CLASS_DOCK:
  56         return WINDOW_AS_DOCK(self)->frame;
  57     case OB_WINDOW_CLASS_CLIENT:
  58         return WINDOW_AS_CLIENT(self)->frame->window;
  59     case OB_WINDOW_CLASS_INTERNAL:
  60         return WINDOW_AS_INTERNAL(self)->window;
  61     case OB_WINDOW_CLASS_PROMPT:
  62         return WINDOW_AS_PROMPT(self)->super.window;
  63     }
  64     g_assert_not_reached();
  65     return None;
  66 }
  67
  68 ObStackingLayer window_layer(ObWindow *self)
  69 {
  70     switch (self->type) {
  71     case OB_WINDOW_CLASS_DOCK:
  72         return config_dock_layer;
  73     case OB_WINDOW_CLASS_CLIENT:
  74         return ((ObClient*)self)->layer;
  75     case OB_WINDOW_CLASS_MENUFRAME:
  76     case OB_WINDOW_CLASS_INTERNAL:
  77         return OB_STACKING_LAYER_INTERNAL;
  78     case OB_WINDOW_CLASS_PROMPT:
  79         /* not used directly for stacking, prompts are managed as clients */
  80         g_assert_not_reached();
  81         break;
  82     }
  83     g_assert_not_reached();
  84     return None;
  85 }
  86
  87 ObWindow* window_find(Window xwin)
  88 {
  89     return g_hash_table_lookup(window_map, &xwin);
  90 }
  91
  92 void window_add(Window *xwin, ObWindow *win)
  93 {
  94     g_assert(xwin != NULL);
  95     g_assert(win != NULL);
  96     g_hash_table_insert(window_map, xwin, win);
  97 }
  98
  99 void window_remove(Window xwin)
 100 {
 101     g_assert(xwin != None);
 102     g_hash_table_remove(window_map, &xwin);
 103 }
 104
 105 void window_manage_all(void)
 106 {
 107     guint i, j, nchild;
 108     Window w, *children;
 109     XWMHints *wmhints;
 110     XWindowAttributes attrib;
 111
 112     if (!XQueryTree(obt_display, RootWindow(obt_display, ob_screen),
 113                     &w, &w, &children, &nchild)) {
 114         ob_debug("XQueryTree failed in window_manage_all");
 115         nchild = 0;
 116     }
 117
 118     /* remove all icon windows from the list */
 119     for (i = 0; i < nchild; i++) {
 120         if (children[i] == None) continue;
 121         wmhints = XGetWMHints(obt_display, children[i]);
 122         if (wmhints) {
 123             if ((wmhints->flags & IconWindowHint) &&
 124                 (wmhints->icon_window != children[i]))
 125                 for (j = 0; j < nchild; j++)
 126                     if (children[j] == wmhints->icon_window) {
 127                         /* XXX watch the window though */
 128                         children[j] = None;
 129                         break;
 130                     }
 131             XFree(wmhints);
 132         }
 133     }
 134
 135     for (i = 0; i < nchild; ++i) {
 136         if (children[i] == None) continue;
 137         if (window_find(children[i])) continue; /* skip our own windows */
 138         if (XGetWindowAttributes(obt_display, children[i], &attrib)) {
 139             if (attrib.map_state == IsUnmapped)
 140                 ;
 141             else
 142                 window_manage(children[i]);
 143         }
 144     }
 145
 146     if (children) XFree(children);
 147 }
 148
 149 static Bool check_unmap(Display *d, XEvent *e, XPointer arg)
 150 {
 151     const Window win = *(Window*)arg;
 152     return ((e->type == DestroyNotify && e->xdestroywindow.window == win) ||
 153             (e->type == UnmapNotify && e->xunmap.window == win));
 154 }
 155
 156 void window_manage(Window win)
 157 {
 158     XEvent e;
 159     XWindowAttributes attrib;
 160     gboolean no_manage = FALSE;
 161     gboolean is_dockapp = FALSE;
 162     Window icon_win = None;
 163
 164     grab_server(TRUE);
 165
 166     /* check if it has already been unmapped by the time we started
 167        mapping. the grab does a sync so we don't have to here */
 168     if (XCheckIfEvent(obt_display, &e, check_unmap, (XPointer)&win)) {
 169         ob_debug("Trying to manage unmapped window. Aborting that.");
 170         no_manage = TRUE;
 171     }
 172
 173     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     }
 191
 192     if (!no_manage) {
 193         if (attrib.override_redirect) {
 194             ob_debug("not managing override redirect window 0x%x", win);
 195             grab_server(FALSE);
 196         }
 197         else if (is_dockapp) {
 198             if (!icon_win)
 199                 icon_win = win;
 200             dock_manage(icon_win, win);
 201         }
 202         else
 203             client_manage(win, NULL);
 204     }
 205     else {
 206         grab_server(FALSE);
 207         ob_debug("FAILED to manage window 0x%x", win);
 208     }
 209 }
 210
 211 void window_unmanage_all(void)
 212 {
 213     dock_unmanage_all();
 214     client_unmanage_all();
 215 }