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 *UNUSED(dpy), XErrorEvent *UNUSED(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 bool rootwin_init(WRootWin *rootwin, int xscr)
 204 {
 205     Display *dpy=ioncore_g.dpy;
 206     WFitParams fp;
 207     Window root;
 208     WScreen *scr;
 209
 210     /* Try to select input on the root window */
 211     root=RootWindow(dpy, xscr);
 212
 213     redirect_error=FALSE;
 214
 215     XSetErrorHandler(my_redirect_error_handler);
 216     XSelectInput(dpy, root, IONCORE_EVENTMASK_ROOT);
 217     XSync(dpy, 0);
 218     XSetErrorHandler(my_error_handler);
 219
 220     if(redirect_error){
 221         warn(TR("Unable to redirect root window events for screen %d."
 222                 "Maybe another window manager is running?"),
 223              xscr);
 224         return FALSE;
 225     }
 226
 227     rootwin->xscr=xscr;
 228     rootwin->default_cmap=DefaultColormap(dpy, xscr);
 229     rootwin->tmpwins=NULL;
 230     rootwin->tmpnwins=0;
 231     rootwin->dummy_win=None;
 232     rootwin->xor_gc=None;
 233
 234     fp.mode=REGION_FIT_EXACT;
 235     fp.g.x=0; fp.g.y=0;
 236     fp.g.w=DisplayWidth(dpy, xscr);
 237     fp.g.h=DisplayHeight(dpy, xscr);
 238
 239     if(!window_do_init((WWindow*)rootwin, NULL, &fp, root, "WRootWin")){
 240         return FALSE;
 241     }
 242
 243     ((WWindow*)rootwin)->event_mask=IONCORE_EVENTMASK_ROOT;
 244     ((WRegion*)rootwin)->flags|=REGION_BINDINGS_ARE_GRABBED|REGION_PLEASE_WARP;
 245     ((WRegion*)rootwin)->rootwin=rootwin;
 246
 247     REGION_MARK_MAPPED(rootwin);
 248
 249     scan_initial_windows(rootwin);
 250
 251     create_wm_windows(rootwin);
 252     preinit_gr(rootwin);
 253     netwm_init_rootwin(rootwin);
 254
 255     region_add_bindmap((WRegion*)rootwin, ioncore_screen_bindmap);
 256
 257     scr=create_screen(rootwin, &fp, xscr);
 258     if(scr==NULL){
 259         return FALSE;
 260     }
 261     region_set_manager((WRegion*)scr, (WRegion*)rootwin);
 262     region_map((WRegion*)scr);
 263
 264     LINK_ITEM(*(WRegion**)&ioncore_g.rootwins, (WRegion*)rootwin, p_next, p_prev);
 265
 266     ioncore_screens_updated(rootwin);
 267
 268     xwindow_set_cursor(root, IONCORE_CURSOR_DEFAULT);
 269
 270     return TRUE;
 271 }
 272
 273
 274 WRootWin *create_rootwin(int xscr)
 275 {
 276     CREATEOBJ_IMPL(WRootWin, rootwin, (p, xscr));
 277 }
 278
 279
 280 void rootwin_deinit(WRootWin *rw)
 281 {
 282     WScreen *scr, *next;
 283
 284     FOR_ALL_SCREENS_W_NEXT(scr, next){
 285         if(REGION_MANAGER(scr)==(WRegion*)rw)
 286             destroy_obj((Obj*)scr);
 287     }
 288
 289     UNLINK_ITEM(*(WRegion**)&ioncore_g.rootwins, (WRegion*)rw, p_next, p_prev);
 290
 291     XSelectInput(ioncore_g.dpy, WROOTWIN_ROOT(rw), 0);
 292
 293     XFreeGC(ioncore_g.dpy, rw->xor_gc);
 294
 295     window_deinit((WWindow*)rw);
 296 }
 297
 298
 299 /*}}}*/
 300
 301
 302 /*{{{ region dynfun implementations */
 303
 304
 305 static void rootwin_do_set_focus(WRootWin *rootwin, bool warp)
 306 {
 307     WRegion *sub;
 308
 309     sub=REGION_ACTIVE_SUB(rootwin);
 310
 311     if(sub==NULL || !REGION_IS_MAPPED(sub)){
 312         WScreen *scr;
 313         FOR_ALL_SCREENS(scr){
 314             if(REGION_IS_MAPPED(scr)){
 315                 sub=(WRegion*)scr;
 316                 break;
 317             }
 318         }
 319     }
 320
 321     if(sub!=NULL)
 322         region_do_set_focus(sub, warp);
 323     else
 324         window_do_set_focus((WWindow*)rootwin, warp);
 325 }
 326
 327
 328 static bool rootwin_fitrep(WRootWin *UNUSED(rootwin), WWindow *UNUSED(par),
 329                            const WFitParams *UNUSED(fp))
 330 {
 331     D(warn("Don't know how to reparent or fit root windows."));
 332     return FALSE;
 333 }
 334
 335
 336 static void rootwin_map(WRootWin *UNUSED(rootwin))
 337 {
 338     D(warn("Attempt to map a root window."));
 339 }
 340
 341
 342 static void rootwin_unmap(WRootWin *UNUSED(rootwin))
 343 {
 344     D(warn("Attempt to unmap a root window -- impossible."));
 345 }
 346
 347
 348 static void rootwin_managed_remove(WRootWin *rootwin, WRegion *reg)
 349 {
 350     region_unset_manager(reg, (WRegion*)rootwin);
 351 }
 352
 353 static WRegion *rootwin_managed_disposeroot(WRootWin *UNUSED(rootwin), WRegion *reg)
 354 {
 355     WScreen *scr=OBJ_CAST(reg, WScreen);
 356     if(scr!=NULL && scr==scr->prev_scr){
 357         warn(TR("Only screen may not be destroyed/detached."));
 358         return NULL;
 359     }
 360
 361     return reg;
 362 }
 363
 364
 365
 366 static Window rootwin_x_window(WRootWin *rootwin)
 367 {
 368     return WROOTWIN_ROOT(rootwin);
 369 }
 370
 371
 372 /*}}}*/
 373
 374
 375 /*{{{ Misc */
 376
 377
 378 static bool scr_ok(WRegion *r)
 379 {
 380     return (OBJ_IS(r, WScreen) && REGION_IS_MAPPED(r));
 381 }
 382
 383
 384 /*EXTL_DOC
 385  * Returns previously active screen on root window \var{rootwin}.
 386  */
 387 EXTL_SAFE
 388 EXTL_EXPORT_MEMBER
 389 WScreen *rootwin_current_scr(WRootWin *rootwin)
 390 {
 391     WRegion *r=REGION_ACTIVE_SUB(rootwin);
 392     WScreen *scr;
 393
 394     /* There should be no non-WScreen as children or managed by us, but... */
 395
 396     if(r!=NULL && scr_ok(r))
 397         return (WScreen*)r;
 398
 399     FOR_ALL_SCREENS(scr){
 400         if(REGION_MANAGER(scr)==(WRegion*)rootwin
 401            && REGION_IS_MAPPED(scr)){
 402             break;
 403         }
 404     }
 405
 406     return scr;
 407 }
 408
 409 /*EXTL_DOC
 410  * Warp the cursor pointer to this location
 411  *
 412  * I'm not *entirely* sure what 'safe' means, but this doesn't change internal
 413  * notion state, so I guess it's 'safe'...
 414  */
 415 EXTL_SAFE
 416 EXTL_EXPORT_MEMBER
 417 void rootwin_warp_pointer(WRootWin *root, int x, int y)
 418 {
 419     XWarpPointer(ioncore_g.dpy, None, WROOTWIN_ROOT(root), 0, 0, 0, 0, x, y);
 420 }
 421
 422
 423 /*EXTL_DOC
 424  * Returns the first WRootWin
 425  */
 426 EXTL_SAFE
 427 EXTL_EXPORT
 428 WRootWin *ioncore_rootwin()
 429 {
 430     return ioncore_g.rootwins;
 431 }
 432
 433
 434 /*}}}*/
 435
 436
 437 /*{{{ Dynamic function table and class implementation */
 438
 439
 440 static DynFunTab rootwin_dynfuntab[]={
 441     {region_map, rootwin_map},
 442     {region_unmap, rootwin_unmap},
 443     {region_do_set_focus, rootwin_do_set_focus},
 444     {(DynFun*)region_xwindow, (DynFun*)rootwin_x_window},
 445     {(DynFun*)region_fitrep, (DynFun*)rootwin_fitrep},
 446     {region_managed_remove, rootwin_managed_remove},
 447     {(DynFun*)region_managed_disposeroot,
 448      (DynFun*)rootwin_managed_disposeroot},
 449     END_DYNFUNTAB
 450 };
 451
 452
 453 EXTL_EXPORT
 454 IMPLCLASS(WRootWin, WWindow, rootwin_deinit, rootwin_dynfuntab);
 455
 456
 457 /*}}}*/