ioncore/rootwin.c

   1 /*
   2  * ion/ioncore/rootwin.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2009.
   5  *
   6  * See the included file LICENSE for details.
   7  */
   8
   9 #include <unistd.h>
  10 #include <sys/types.h>
  11 #include <sys/wait.h>
  12 #include <sys/time.h>
  13 #include <time.h>
  14 #include <signal.h>
  15 #include <string.h>
  16 #include <stdlib.h>
  17 #include <stdio.h>
  18 #include <X11/Xlib.h>
  19 #include <X11/Xproto.h>
  20
  21 #include <libtu/objp.h>
  22 #include "common.h"
  23 #include "rootwin.h"
  24 #include "cursor.h"
  25 #include "global.h"
  26 #include "event.h"
  27 #include "gr.h"
  28 #include "clientwin.h"
  29 #include "property.h"
  30 #include "focus.h"
  31 #include "regbind.h"
  32 #include "screen.h"
  33 #include "bindmaps.h"
  34 #include <libextl/readconfig.h>
  35 #include "resize.h"
  36 #include "saveload.h"
  37 #include "netwm.h"
  38 #include "xwindow.h"
  39
  40
  41 /*{{{ Error handling */
  42
  43
  44 static bool redirect_error=FALSE;
  45 static bool ignore_badwindow=TRUE;
  46
  47
  48 static int my_redirect_error_handler(Display *dpy, XErrorEvent *ev)
  49 {
  50     redirect_error=TRUE;
  51     return 0;
  52 }
  53
  54
  55 static int my_error_handler(Display *dpy, XErrorEvent *ev)
  56 {
  57     static char msg[128], request[64], num[32];
  58
  59     /* Just ignore bad window and similar errors; makes the rest of
  60      * the code simpler.
  61      *
  62      * Apparently XGetWindowProperty can return BadMatch on a race
  63      * condition where the server is already reusing the XID for a
  64      * non-window drawable, so let's just ignore BadMatch entirely...
  65      */
  66     if((ev->error_code==BadWindow ||
  67         (ev->error_code==BadMatch /*&& ev->request_code==X_SetInputFocus*/) ||
  68         (ev->error_code==BadDrawable && ev->request_code==X_GetGeometry)) &&
  69        ignore_badwindow)
  70         return 0;
  71
  72 #if 0
  73     XmuPrintDefaultErrorMessage(dpy, ev, stderr);
  74 #else
  75     XGetErrorText(dpy, ev->error_code, msg, 128);
  76     snprintf(num, 32, "%d", ev->request_code);
  77     XGetErrorDatabaseText(dpy, "XRequest", num, "", request, 64);
  78
  79     if(request[0]=='\0')
  80         snprintf(request, 64, "<unknown request>");
  81
  82     if(ev->minor_code!=0){
  83         warn("[%d] %s (%d.%d) %#lx: %s", ev->serial, request,
  84              ev->request_code, ev->minor_code, ev->resourceid,msg);
  85     }else{
  86         warn("[%d] %s (%d) %#lx: %s", ev->serial, request,
  87              ev->request_code, ev->resourceid,msg);
  88     }
  89 #endif
  90
  91     kill(getpid(), SIGTRAP);
  92
  93     return 0;
  94 }
  95
  96
  97 /*}}}*/
  98
  99
 100 /*{{{ Init/deinit */
 101
 102
 103 static void scan_initial_windows(WRootWin *rootwin)
 104 {
 105     Window dummy_root, dummy_parent, *wins=NULL;
 106     uint nwins=0, i, j;
 107     XWMHints *hints;
 108
 109     XQueryTree(ioncore_g.dpy, WROOTWIN_ROOT(rootwin), &dummy_root, &dummy_parent,
 110                &wins, &nwins);
 111
 112     for(i=0; i<nwins; i++){
 113         if(wins[i]==None)
 114             continue;
 115         hints=XGetWMHints(ioncore_g.dpy, wins[i]);
 116         if(hints!=NULL && hints->flags&IconWindowHint){
 117             for(j=0; j<nwins; j++){
 118                 if(wins[j]==hints->icon_window){
 119                     wins[j]=None;
 120                     break;
 121                 }
 122             }
 123         }
 124         if(hints!=NULL)
 125             XFree((void*)hints);
 126     }
 127
 128     rootwin->tmpwins=wins;
 129     rootwin->tmpnwins=nwins;
 130 }
 131
 132
 133 void rootwin_manage_initial_windows(WRootWin *rootwin)
 134 {
 135     Window *wins=rootwin->tmpwins;
 136     Window tfor=None;
 137     int i, nwins=rootwin->tmpnwins;
 138
 139     rootwin->tmpwins=NULL;
 140     rootwin->tmpnwins=0;
 141
 142     for(i=0; i<nwins; i++){
 143         if(XWINDOW_REGION_OF(wins[i])!=NULL)
 144             wins[i]=None;
 145         if(wins[i]==None)
 146             continue;
 147         if(XGetTransientForHint(ioncore_g.dpy, wins[i], &tfor))
 148             continue;
 149         ioncore_manage_clientwin(wins[i], FALSE);
 150         wins[i]=None;
 151     }
 152
 153     for(i=0; i<nwins; i++){
 154         if(wins[i]==None)
 155             continue;
 156         ioncore_manage_clientwin(wins[i], FALSE);
 157     }
 158
 159     XFree((void*)wins);
 160 }
 161
 162
 163 static void create_wm_windows(WRootWin *rootwin)
 164 {
 165     const char *p[1];
 166
 167     rootwin->dummy_win=XCreateWindow(ioncore_g.dpy, WROOTWIN_ROOT(rootwin),
 168                                      0, 0, 1, 1, 0,
 169                                      CopyFromParent, InputOnly,
 170                                      CopyFromParent, 0, NULL);
 171
 172     p[0] = "WRootWin";
 173     xwindow_set_text_property(rootwin->dummy_win, XA_WM_NAME, p, 1);
 174
 175     XSelectInput(ioncore_g.dpy, rootwin->dummy_win, PropertyChangeMask);
 176 }
 177
 178
 179 static void preinit_gr(WRootWin *rootwin)
 180 {
 181     XGCValues gcv;
 182     ulong gcvmask;
 183
 184     /* Create XOR gc (for resize) */
 185     gcv.line_style=LineSolid;
 186     gcv.join_style=JoinBevel;
 187     gcv.cap_style=CapButt;
 188     gcv.fill_style=FillSolid;
 189     gcv.line_width=2;
 190     gcv.subwindow_mode=IncludeInferiors;
 191     gcv.function=GXxor;
 192     gcv.foreground=~0L;
 193
 194     gcvmask=(GCLineStyle|GCLineWidth|GCFillStyle|
 195              GCJoinStyle|GCCapStyle|GCFunction|
 196              GCSubwindowMode|GCForeground);
 197
 198     rootwin->xor_gc=XCreateGC(ioncore_g.dpy, WROOTWIN_ROOT(rootwin),
 199                               gcvmask, &gcv);
 200 }
 201
 202
 203 static Atom net_virtual_roots=None;
 204
 205
 206 static bool rootwin_init(WRootWin *rootwin, int xscr)
 207 {
 208     Display *dpy=ioncore_g.dpy;
 209     WFitParams fp;
 210     Window root;
 211     WScreen *scr;
 212
 213     /* Try to select input on the root window */
 214     root=RootWindow(dpy, xscr);
 215
 216     redirect_error=FALSE;
 217
 218     XSetErrorHandler(my_redirect_error_handler);
 219     XSelectInput(dpy, root, IONCORE_EVENTMASK_ROOT);
 220     XSync(dpy, 0);
 221     XSetErrorHandler(my_error_handler);
 222
 223     if(redirect_error){
 224         warn(TR("Unable to redirect root window events for screen %d."
 225                 "Maybe another window manager is running?"),
 226              xscr);
 227         return FALSE;
 228     }
 229
 230     rootwin->xscr=xscr;
 231     rootwin->default_cmap=DefaultColormap(dpy, xscr);
 232     rootwin->tmpwins=NULL;
 233     rootwin->tmpnwins=0;
 234     rootwin->dummy_win=None;
 235     rootwin->xor_gc=None;
 236
 237     fp.mode=REGION_FIT_EXACT;
 238     fp.g.x=0; fp.g.y=0;
 239     fp.g.w=DisplayWidth(dpy, xscr);
 240     fp.g.h=DisplayHeight(dpy, xscr);
 241
 242     if(!window_do_init((WWindow*)rootwin, NULL, &fp, root, "WRootWin")){
 243         free(rootwin);
 244         return FALSE;
 245     }
 246
 247     ((WWindow*)rootwin)->event_mask=IONCORE_EVENTMASK_ROOT;
 248     ((WRegion*)rootwin)->flags|=REGION_BINDINGS_ARE_GRABBED|REGION_PLEASE_WARP;
 249     ((WRegion*)rootwin)->rootwin=rootwin;
 250
 251     REGION_MARK_MAPPED(rootwin);
 252
 253     scan_initial_windows(rootwin);
 254
 255     create_wm_windows(rootwin);
 256     preinit_gr(rootwin);
 257     netwm_init_rootwin(rootwin);
 258
 259     region_add_bindmap((WRegion*)rootwin, ioncore_screen_bindmap);
 260
 261     scr=create_screen(rootwin, &fp, xscr);
 262     if(scr==NULL){
 263         free(rootwin);
 264         return FALSE;
 265     }
 266     region_set_manager((WRegion*)scr, (WRegion*)rootwin);
 267     region_map((WRegion*)scr);
 268
 269     LINK_ITEM(*(WRegion**)&ioncore_g.rootwins, (WRegion*)rootwin, p_next, p_prev);
 270
 271     ioncore_screens_updated(rootwin);
 272
 273     xwindow_set_cursor(root, IONCORE_CURSOR_DEFAULT);
 274
 275     return TRUE;
 276 }
 277
 278
 279 WRootWin *create_rootwin(int xscr)
 280 {
 281     CREATEOBJ_IMPL(WRootWin, rootwin, (p, xscr));
 282 }
 283
 284
 285 void rootwin_deinit(WRootWin *rw)
 286 {
 287     WScreen *scr, *next;
 288
 289     FOR_ALL_SCREENS_W_NEXT(scr, next){
 290         if(REGION_MANAGER(scr)==(WRegion*)rw)
 291             destroy_obj((Obj*)scr);
 292     }
 293
 294     UNLINK_ITEM(*(WRegion**)&ioncore_g.rootwins, (WRegion*)rw, p_next, p_prev);
 295
 296     XSelectInput(ioncore_g.dpy, WROOTWIN_ROOT(rw), 0);
 297
 298     XFreeGC(ioncore_g.dpy, rw->xor_gc);
 299
 300     window_deinit((WWindow*)rw);
 301 }
 302
 303
 304 /*}}}*/
 305
 306
 307 /*{{{ region dynfun implementations */
 308
 309
 310 static void rootwin_do_set_focus(WRootWin *rootwin, bool warp)
 311 {
 312     WRegion *sub;
 313
 314     sub=REGION_ACTIVE_SUB(rootwin);
 315
 316     if(sub==NULL || !REGION_IS_MAPPED(sub)){
 317         WScreen *scr;
 318         FOR_ALL_SCREENS(scr){
 319             if(REGION_IS_MAPPED(scr)){
 320                 sub=(WRegion*)scr;
 321                 break;
 322             }
 323         }
 324     }
 325
 326     if(sub!=NULL)
 327         region_do_set_focus(sub, warp);
 328     else
 329         window_do_set_focus((WWindow*)rootwin, warp);
 330 }
 331
 332
 333 static bool rootwin_fitrep(WRootWin *rootwin, WWindow *par,
 334                            const WFitParams *fp)
 335 {
 336     D(warn("Don't know how to reparent or fit root windows."));
 337     return FALSE;
 338 }
 339
 340
 341 static void rootwin_map(WRootWin *rootwin)
 342 {
 343     D(warn("Attempt to map a root window."));
 344 }
 345
 346
 347 static void rootwin_unmap(WRootWin *rootwin)
 348 {
 349     D(warn("Attempt to unmap a root window -- impossible."));
 350 }
 351
 352
 353 static void rootwin_managed_remove(WRootWin *rootwin, WRegion *reg)
 354 {
 355     region_unset_manager(reg, (WRegion*)rootwin);
 356 }
 357
 358 static WRegion *rootwin_managed_disposeroot(WRootWin *rootwin, WRegion *reg)
 359 {
 360     WScreen *scr=OBJ_CAST(reg, WScreen);
 361     if(scr!=NULL && scr==scr->prev_scr){
 362         warn(TR("Only screen may not be destroyed/detached."));
 363         return NULL;
 364     }
 365
 366     return reg;
 367 }
 368
 369
 370
 371 static Window rootwin_x_window(WRootWin *rootwin)
 372 {
 373     return WROOTWIN_ROOT(rootwin);
 374 }
 375
 376
 377 /*}}}*/
 378
 379
 380 /*{{{ Misc */
 381
 382
 383 static bool scr_ok(WRegion *r)
 384 {
 385     return (OBJ_IS(r, WScreen) && REGION_IS_MAPPED(r));
 386 }
 387
 388
 389 /*EXTL_DOC
 390  * Returns previously active screen on root window \var{rootwin}.
 391  */
 392 EXTL_SAFE
 393 EXTL_EXPORT_MEMBER
 394 WScreen *rootwin_current_scr(WRootWin *rootwin)
 395 {
 396     WRegion *r=REGION_ACTIVE_SUB(rootwin);
 397     WScreen *scr;
 398
 399     /* There should be no non-WScreen as children or managed by us, but... */
 400
 401     if(r!=NULL && scr_ok(r))
 402         return (WScreen*)r;
 403
 404     FOR_ALL_SCREENS(scr){
 405         if(REGION_MANAGER(scr)==(WRegion*)rootwin
 406            && REGION_IS_MAPPED(scr)){
 407             break;
 408         }
 409     }
 410
 411     return scr;
 412 }
 413
 414
 415 /*EXTL_DOC
 416  * Returns the first WRootWin
 417  */
 418 EXTL_SAFE
 419 EXTL_EXPORT
 420 WRootWin *ioncore_rootwin()
 421 {
 422     return ioncore_g.rootwins;
 423 }
 424
 425
 426 /*}}}*/
 427
 428
 429 /*{{{ Dynamic function table and class implementation */
 430
 431
 432 static DynFunTab rootwin_dynfuntab[]={
 433     {region_map, rootwin_map},
 434     {region_unmap, rootwin_unmap},
 435     {region_do_set_focus, rootwin_do_set_focus},
 436     {(DynFun*)region_xwindow, (DynFun*)rootwin_x_window},
 437     {(DynFun*)region_fitrep, (DynFun*)rootwin_fitrep},
 438     {region_managed_remove, rootwin_managed_remove},
 439     {(DynFun*)region_managed_disposeroot,
 440      (DynFun*)rootwin_managed_disposeroot},
 441     END_DYNFUNTAB
 442 };
 443
 444
 445 EXTL_EXPORT
 446 IMPLCLASS(WRootWin, WWindow, rootwin_deinit, rootwin_dynfuntab);
 447
 448
 449 /*}}}*/