src/screen.c

   1 /* screen.c - screen management
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1997, 1998 Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23 #include "wconfig.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include <X11/Xlib.h>
  30 #include <X11/Xutil.h>
  31 #include <X11/Xatom.h>
  32 #ifdef SHAPE
  33 #include <X11/extensions/shape.h>
  34 #endif
  35 #ifdef KEEP_XKB_LOCK_STATUS
  36 #include <X11/XKBlib.h>
  37 #endif /* KEEP_XKB_LOCK_STATUS */
  38
  39 #include <wraster.h>
  40
  41 #include "WindowMaker.h"
  42 #include "def_pixmaps.h"
  43 #include "screen.h"
  44 #include "texture.h"
  45 #include "pixmap.h"
  46 #include "menu.h"
  47 #include "funcs.h"
  48 #include "actions.h"
  49 #include "properties.h"
  50 #include "dock.h"
  51 #include "resources.h"
  52 #include "workspace.h"
  53 #include "session.h"
  54 #include "balloon.h"
  55 #ifdef KWM_HINTS
  56 # include "kwm.h"
  57 #endif
  58 #ifdef GNOME_STUFF
  59 # include "gnome.h"
  60 #endif
  61 #ifdef OLWM_HINTS
  62 # include "openlook.h"
  63 #endif
  64
  65 #include <proplist.h>
  66
  67 #include "defaults.h"
  68
  69
  70 #ifdef LITE
  71 #define EVENT_MASK (LeaveWindowMask|EnterWindowMask|PropertyChangeMask\
  72                 |SubstructureNotifyMask|PointerMotionMask \
  73                 |SubstructureRedirectMask|KeyPressMask|KeyReleaseMask)
  74 #else
  75 #define EVENT_MASK (LeaveWindowMask|EnterWindowMask|PropertyChangeMask\
  76                 |SubstructureNotifyMask|PointerMotionMask \
  77                 |SubstructureRedirectMask|ButtonPressMask|ButtonReleaseMask\
  78                 |KeyPressMask|KeyReleaseMask)
  79 #endif
  80
  81 /**** Global variables ****/
  82
  83 extern Cursor wCursor[WCUR_LAST];
  84 extern WPreferences wPreferences;
  85 extern Atom _XA_WINDOWMAKER_STATE;
  86 extern Atom _XA_WINDOWMAKER_NOTICEBOARD;
  87
  88
  89 extern int wScreenCount;
  90
  91 extern WDDomain *WDWindowMaker;
  92
  93
  94 /**** Local ****/
  95
  96 #define STIPPLE_WIDTH 2
  97 #define STIPPLE_HEIGHT 2
  98 static char STIPPLE_DATA[] = {0x02, 0x01};
  99
 100 static int CantManageScreen = 0;
 101
 102 static proplist_t dApplications = NULL;
 103 static proplist_t dWorkspace;
 104 static proplist_t dDock;
 105 static proplist_t dClip;
 106
 107
 108 static void
 109 make_keys()
 110 {
 111     if (dApplications!=NULL)
 112         return;
 113
 114     dApplications = PLMakeString("Applications");
 115     dWorkspace = PLMakeString("Workspace");
 116     dDock = PLMakeString("Dock");
 117     dClip = PLMakeString("Clip");
 118 }
 119
 120
 121 /*
 122  *----------------------------------------------------------------------
 123  * alreadyRunningError--
 124  *      X error handler used to catch errors when trying to do
 125  * XSelectInput() on the root window. These errors probably mean that
 126  * there already is some other window manager running.
 127  *
 128  * Returns:
 129  *      Nothing, unless something really evil happens...
 130  *
 131  * Side effects:
 132  *      CantManageScreen is set to 1;
 133  *----------------------------------------------------------------------
 134  */
 135 static int
 136 alreadyRunningError(Display *dpy, XErrorEvent *error)
 137 {
 138     CantManageScreen = 1;
 139     return -1;
 140 }
 141
 142
 143 /*
 144  *----------------------------------------------------------------------
 145  * allocButtonPixmaps--
 146  *      Allocate pixmaps used on window operation buttons (those in the
 147  * titlebar). The pixmaps are linked to the program. If XPM is supported
 148  * XPM pixmaps are used otherwise, equivalent bitmaps are used.
 149  *
 150  * Returns:
 151  *      Nothing
 152  *
 153  * Side effects:
 154  *      Allocates shared pixmaps for the screen. These pixmaps should
 155  * not be freed by anybody.
 156  *----------------------------------------------------------------------
 157  */
 158 static void
 159 allocButtonPixmaps(WScreen *scr)
 160 {
 161     WPixmap *pix;
 162
 163     /* create predefined pixmaps */
 164     pix = wPixmapCreateFromXPMData(scr, PRED_CLOSE_XPM);
 165     if (pix)
 166       pix->shared = 1;
 167     scr->b_pixmaps[WBUT_CLOSE] = pix;
 168
 169     pix = wPixmapCreateFromXPMData(scr, PRED_BROKEN_CLOSE_XPM);
 170     if (pix)
 171       pix->shared = 1;
 172     scr->b_pixmaps[WBUT_BROKENCLOSE] = pix;
 173
 174     pix = wPixmapCreateFromXPMData(scr, PRED_ICONIFY_XPM);
 175     if (pix)
 176       pix->shared = 1;
 177     scr->b_pixmaps[WBUT_ICONIFY] = pix;
 178
 179     pix = wPixmapCreateFromXPMData(scr, PRED_KILL_XPM);
 180     if (pix)
 181       pix->shared = 1;
 182     scr->b_pixmaps[WBUT_KILL] = pix;
 183 }
 184
 185
 186 static void
 187 draw_dot(WScreen *scr, Drawable d, int x, int y, GC gc)
 188 {
 189     XSetForeground(dpy, gc, scr->black_pixel);
 190     XDrawLine(dpy, d, gc, x, y, x+1, y);
 191     XDrawPoint(dpy, d, gc, x, y+1);
 192     XSetForeground(dpy, gc, scr->white_pixel);
 193     XDrawLine(dpy, d, gc, x+2, y, x+2, y+1);
 194     XDrawPoint(dpy, d, gc, x+1, y+1);
 195 }
 196
 197
 198 static WPixmap*
 199 make3Dots(WScreen *scr)
 200 {
 201     WPixmap *wpix;
 202     GC gc2, gc;
 203     XGCValues gcv;
 204     Pixmap pix, mask;
 205
 206     gc = scr->copy_gc;
 207     pix = XCreatePixmap(dpy, scr->w_win, wPreferences.icon_size,
 208                         wPreferences.icon_size, scr->w_depth);
 209     XSetForeground(dpy, gc, scr->black_pixel);
 210     XFillRectangle(dpy, pix, gc, 0, 0, wPreferences.icon_size,
 211                    wPreferences.icon_size);
 212     XSetForeground(dpy, gc, scr->white_pixel);
 213     draw_dot(scr, pix, 4, wPreferences.icon_size-6, gc);
 214     draw_dot(scr, pix, 9, wPreferences.icon_size-6, gc);
 215     draw_dot(scr, pix, 14, wPreferences.icon_size-6, gc);
 216
 217     mask = XCreatePixmap(dpy, scr->w_win, wPreferences.icon_size,
 218                          wPreferences.icon_size, 1);
 219     gcv.foreground = 0;
 220     gcv.graphics_exposures = False;
 221     gc2 = XCreateGC(dpy, mask, GCForeground|GCGraphicsExposures, &gcv);
 222     XFillRectangle(dpy, mask, gc2, 0, 0, wPreferences.icon_size,
 223                    wPreferences.icon_size);
 224     XSetForeground(dpy, gc2, 1);
 225     XFillRectangle(dpy, mask, gc2, 4, wPreferences.icon_size-6, 3, 2);
 226     XFillRectangle(dpy, mask, gc2, 9, wPreferences.icon_size-6, 3, 2);
 227     XFillRectangle(dpy, mask, gc2, 14, wPreferences.icon_size-6, 3, 2);
 228
 229     XFreeGC(dpy, gc2);
 230
 231     wpix = wPixmapCreate(scr, pix, mask);
 232     wpix->shared = 1;
 233
 234     return wpix;
 235 }
 236
 237
 238 static void
 239 allocGCs(WScreen *scr)
 240 {
 241     XGCValues gcv;
 242     XColor color;
 243     unsigned long mtextcolor;
 244     int gcm;
 245
 246     scr->stipple_bitmap =
 247       XCreateBitmapFromData(dpy, scr->w_win, STIPPLE_DATA, STIPPLE_WIDTH,
 248                             STIPPLE_HEIGHT);
 249
 250     gcv.stipple = scr->stipple_bitmap;
 251     gcv.foreground = scr->white_pixel;
 252     gcv.fill_style = FillStippled;
 253     gcv.graphics_exposures = False;
 254     gcm = GCForeground|GCStipple|GCFillStyle|GCGraphicsExposures;
 255     scr->stipple_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
 256
 257
 258     /* selected icon border GCs */
 259     gcv.function    = GXcopy;
 260     gcv.foreground  = scr->white_pixel;
 261     gcv.background  = scr->black_pixel;
 262     gcv.line_width  = 1;
 263     gcv.line_style  = LineDoubleDash;
 264     gcv.fill_style  = FillSolid;
 265     gcv.dash_offset = 0;
 266     gcv.dashes      = 4;
 267     gcv.graphics_exposures = False;
 268
 269     gcm = GCFunction | GCGraphicsExposures;
 270     gcm |= GCForeground | GCBackground;
 271     gcm |= GCLineWidth | GCLineStyle;
 272     gcm |= GCFillStyle;
 273     gcm |= GCDashOffset | GCDashList;
 274
 275     scr->icon_select_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
 276
 277     gcm = GCForeground|GCGraphicsExposures;
 278
 279     scr->menu_title_pixel[0] = scr->white_pixel;
 280     gcv.foreground = scr->white_pixel;
 281     gcv.graphics_exposures = False;
 282     scr->menu_title_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
 283
 284     scr->mtext_pixel = scr->black_pixel;
 285     mtextcolor = gcv.foreground = scr->black_pixel;
 286     scr->menu_entry_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
 287
 288     /* selected menu entry GC */
 289     gcm = GCForeground|GCBackground|GCGraphicsExposures;
 290     gcv.foreground = scr->white_pixel;
 291     gcv.background = scr->white_pixel;
 292     gcv.graphics_exposures = False;
 293     scr->select_menu_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
 294
 295     /* disabled menu entry GC */
 296     scr->dtext_pixel = scr->black_pixel;
 297     gcm = GCForeground|GCBackground|GCStipple|GCGraphicsExposures;
 298     gcv.stipple = scr->stipple_bitmap;
 299     gcv.graphics_exposures = False;
 300     scr->disabled_menu_entry_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
 301
 302     /* frame GC */
 303     wGetColor(scr, DEF_FRAME_COLOR, &color);
 304     gcv.function = GXxor;
 305     /* this will raise the probability of the XORed color being different
 306      * of the original color in PseudoColor when not all color cells are
 307      * initialized */
 308     if (DefaultVisual(dpy, scr->screen)->class==PseudoColor)
 309         gcv.plane_mask = (1<<(scr->depth-1))|1;
 310     else
 311         gcv.plane_mask = AllPlanes;
 312     gcv.foreground = color.pixel;
 313     if (gcv.foreground == 0)
 314         gcv.foreground = 1;
 315     gcv.line_width = DEF_FRAME_THICKNESS;
 316     gcv.subwindow_mode = IncludeInferiors;
 317     gcv.graphics_exposures = False;
 318     scr->frame_gc = XCreateGC(dpy, scr->root_win, GCForeground|GCGraphicsExposures
 319                               |GCFunction|GCSubwindowMode|GCLineWidth
 320                               |GCPlaneMask, &gcv);
 321
 322     /* line GC */
 323     gcv.foreground = color.pixel;
 324
 325     if (gcv.foreground == 0)
 326         /* XOR:ing with a zero is not going to be of much use, so
 327            in that case, we somewhat arbitrarily xor with 17 instead. */
 328         gcv.foreground = 17;
 329
 330     gcv.function = GXxor;
 331     gcv.subwindow_mode = IncludeInferiors;
 332     gcv.line_width = 1;
 333     gcv.cap_style = CapRound;
 334     gcv.graphics_exposures = False;
 335     gcm = GCForeground|GCFunction|GCSubwindowMode|GCLineWidth|GCCapStyle
 336         |GCGraphicsExposures;
 337     scr->line_gc = XCreateGC(dpy, scr->root_win, gcm, &gcv);
 338
 339     scr->line_pixel = gcv.foreground;
 340
 341     /* copy GC */
 342     gcv.foreground = scr->white_pixel;
 343     gcv.background = scr->black_pixel;
 344     gcv.graphics_exposures = False;
 345     scr->copy_gc = XCreateGC(dpy, scr->w_win, GCForeground|GCBackground
 346                              |GCGraphicsExposures, &gcv);
 347
 348     /* window title text GC */
 349     gcv.graphics_exposures = False;
 350     scr->window_title_gc = XCreateGC(dpy, scr->w_win,GCGraphicsExposures,&gcv);
 351
 352     /* icon title GC */
 353     scr->icon_title_gc = XCreateGC(dpy, scr->w_win, GCGraphicsExposures, &gcv);
 354
 355     /* clip title GC */
 356     scr->clip_title_gc = XCreateGC(dpy, scr->w_win, GCGraphicsExposures, &gcv);
 357
 358     /* move/size display GC */
 359     gcv.graphics_exposures = False;
 360     gcm = GCGraphicsExposures;
 361     scr->info_text_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
 362
 363     /* misc drawing GC */
 364     gcv.graphics_exposures = False;
 365     gcm = GCGraphicsExposures;
 366     scr->draw_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
 367
 368     assert (scr->stipple_bitmap!=None);
 369
 370
 371     /* mono GC */
 372     scr->mono_gc = XCreateGC(dpy, scr->stipple_bitmap, gcm, &gcv);
 373 }
 374
 375
 376
 377 static void
 378 createPixmaps(WScreen *scr)
 379 {
 380     WPixmap *pix;
 381     WMPixmap *wmpix;
 382     RImage *image;
 383     Pixmap p, m;
 384
 385     /* load pixmaps */
 386     pix = wPixmapCreateFromXBMData(scr, (char*)MENU_RADIO_INDICATOR_XBM_DATA,
 387                                    (char*)MENU_RADIO_INDICATOR_XBM_DATA,
 388                                    MENU_RADIO_INDICATOR_XBM_SIZE,
 389                                    MENU_RADIO_INDICATOR_XBM_SIZE,
 390                                    scr->black_pixel, scr->white_pixel);
 391     if (pix!=NULL)
 392       pix->shared = 1;
 393     scr->menu_radio_indicator = pix;
 394
 395
 396     pix = wPixmapCreateFromXBMData(scr, (char*)MENU_CHECK_INDICATOR_XBM_DATA,
 397                                    (char*)MENU_CHECK_INDICATOR_XBM_DATA,
 398                                    MENU_CHECK_INDICATOR_XBM_SIZE,
 399                                    MENU_CHECK_INDICATOR_XBM_SIZE,
 400                                    scr->black_pixel, scr->white_pixel);
 401     if (pix!=NULL)
 402       pix->shared = 1;
 403     scr->menu_check_indicator = pix;
 404
 405     pix = wPixmapCreateFromXBMData(scr, (char*)MENU_MINI_INDICATOR_XBM_DATA,
 406                                    (char*)MENU_MINI_INDICATOR_XBM_DATA,
 407                                    MENU_MINI_INDICATOR_XBM_SIZE,
 408                                    MENU_MINI_INDICATOR_XBM_SIZE,
 409                                    scr->black_pixel, scr->white_pixel);
 410     if (pix!=NULL)
 411       pix->shared = 1;
 412     scr->menu_mini_indicator = pix;
 413
 414     pix = wPixmapCreateFromXBMData(scr, (char*)MENU_HIDE_INDICATOR_XBM_DATA,
 415                                    (char*)MENU_HIDE_INDICATOR_XBM_DATA,
 416                                    MENU_HIDE_INDICATOR_XBM_SIZE,
 417                                    MENU_HIDE_INDICATOR_XBM_SIZE,
 418                                    scr->black_pixel, scr->white_pixel);
 419     if (pix!=NULL)
 420       pix->shared = 1;
 421     scr->menu_hide_indicator = pix;
 422
 423     pix = wPixmapCreateFromXBMData(scr, (char*)MENU_SHADE_INDICATOR_XBM_DATA,
 424                                   (char*)MENU_SHADE_INDICATOR_XBM_DATA,
 425                                   MENU_SHADE_INDICATOR_XBM_SIZE,
 426                                   MENU_SHADE_INDICATOR_XBM_SIZE,
 427                                   scr->black_pixel, scr->white_pixel);
 428     if (pix!=NULL)
 429       pix->shared = 1;
 430     scr->menu_shade_indicator = pix;
 431
 432
 433     image = wDefaultGetImage(scr, "Logo", "WMPanel");
 434
 435     if (!image) {
 436         wwarning(_("could not load logo image for panels: %s"),
 437                  RMessageForError(RErrorCode));
 438     } else {
 439         if (!RConvertImageMask(scr->rcontext, image, &p, &m, 128)) {
 440             wwarning(_("error making logo image for panel:%s"), RMessageForError(RErrorCode));
 441         } else {
 442             wmpix = WMCreatePixmapFromXPixmaps(scr->wmscreen, p, m,
 443                                                image->width, image->height,
 444                                                scr->depth);
 445             WMSetApplicationIconImage(scr->wmscreen, wmpix);
 446             WMReleasePixmap(wmpix);
 447         }
 448         RDestroyImage(image);
 449     }
 450
 451 #ifdef HIDDENDOT
 452     if (!wPreferences.flags.nodock || !wPreferences.flags.noclip) {
 453             scr->dock_dots = make3Dots(scr);
 454     }
 455 #endif
 456
 457 #ifndef NEWSTUFF
 458     /* titlebar button pixmaps */
 459     allocButtonPixmaps(scr);
 460 #endif
 461 }
 462
 463
 464 /*
 465  *----------------------------------------------------------------------
 466  * createInternalWindows--
 467  *      Creates some windows used internally by the program. One to
 468  * receive input focus when no other window can get it and another
 469  * to display window geometry information during window resize/move.
 470  *
 471  * Returns:
 472  *      Nothing
 473  *
 474  * Side effects:
 475  *      Windows are created and some colors are allocated for the
 476  * window background.
 477  *----------------------------------------------------------------------
 478  */
 479 static void
 480 createInternalWindows(WScreen *scr)
 481 {
 482     int vmask;
 483     XSetWindowAttributes attribs;
 484
 485     /* window for displaying geometry information during resizes and moves */
 486     vmask = CWBorderPixel|CWBackPixmap|CWBackPixel|CWCursor|CWSaveUnder|CWOverrideRedirect;
 487     attribs.border_pixel = 0;
 488     attribs.save_under = True;
 489     attribs.override_redirect = True;
 490     attribs.cursor = wCursor[WCUR_DEFAULT];
 491     attribs.background_pixmap = None;
 492     if (scr->widget_texture)
 493         attribs.background_pixel = scr->widget_texture->normal.pixel;
 494     else
 495         attribs.background_pixel = scr->light_pixel;
 496     vmask |= CWColormap;
 497     attribs.colormap = scr->w_colormap;
 498
 499     wGetGeometryWindowSize(scr, &scr->geometry_display_width,
 500                            &scr->geometry_display_height);
 501     scr->geometry_display =
 502       XCreateWindow(dpy, scr->root_win, 1, 1,
 503                     scr->geometry_display_width,
 504                     scr->geometry_display_height,
 505                     1, scr->w_depth, CopyFromParent, scr->w_visual,
 506                     vmask, &attribs);
 507
 508     /* InputOnly window to get the focus when no other window can get it */
 509     vmask = CWEventMask|CWOverrideRedirect;
 510     attribs.event_mask = KeyPressMask|FocusChangeMask;
 511     attribs.override_redirect = True;
 512     scr->no_focus_win=XCreateWindow(dpy,scr->root_win,-10, -10, 4, 4, 0, 0,
 513                                     InputOnly,CopyFromParent, vmask, &attribs);
 514     XSelectInput(dpy, scr->no_focus_win, KeyPressMask|KeyReleaseMask);
 515     XMapWindow(dpy, scr->no_focus_win);
 516
 517     XSetInputFocus(dpy, scr->no_focus_win, RevertToParent, CurrentTime);
 518
 519     /* shadow window for dock buttons */
 520     vmask = CWBorderPixel|CWBackPixmap|CWBackPixel|CWCursor|CWSaveUnder|CWOverrideRedirect;
 521     attribs.border_pixel = 0;
 522     attribs.save_under = True;
 523     attribs.override_redirect = True;
 524     attribs.background_pixmap = None;
 525     attribs.background_pixel = scr->white_pixel;
 526     vmask |= CWColormap;
 527     attribs.colormap = scr->w_colormap;
 528     scr->dock_shadow =
 529       XCreateWindow(dpy, scr->root_win, 0, 0, wPreferences.icon_size,
 530                     wPreferences.icon_size, 0, scr->w_depth, CopyFromParent,
 531                     scr->w_visual, vmask, &attribs);
 532
 533     /* workspace name balloon for clip */
 534     vmask = CWBackPixel|CWSaveUnder|CWOverrideRedirect|CWColormap
 535         |CWBorderPixel;
 536     attribs.save_under = True;
 537     attribs.override_redirect = True;
 538     attribs.colormap = scr->w_colormap;
 539     attribs.background_pixel = scr->icon_back_texture->normal.pixel;
 540     attribs.border_pixel = 0; /* do not care */
 541     scr->clip_balloon =
 542       XCreateWindow(dpy, scr->root_win, 0, 0, 10, 10, 0, scr->w_depth,
 543                     CopyFromParent, scr->w_visual, vmask, &attribs);
 544
 545
 546     /* workspace name */
 547     vmask = CWBackPixel|CWSaveUnder|CWOverrideRedirect|CWColormap
 548         |CWBorderPixel;
 549     attribs.save_under = True;
 550     attribs.override_redirect = True;
 551     attribs.colormap = scr->w_colormap;
 552     attribs.background_pixel = scr->icon_back_texture->normal.pixel;
 553     attribs.border_pixel = 0; /* do not care */
 554     scr->workspace_name =
 555       XCreateWindow(dpy, scr->root_win, 0, 0, 10, 10, 0, scr->w_depth,
 556                     CopyFromParent, scr->w_visual, vmask, &attribs);
 557
 558
 559     /* for our window manager info notice board */
 560     scr->info_window =
 561       XCreateWindow(dpy, scr->root_win, 0, 0, 10, 10, 0, CopyFromParent,
 562                     CopyFromParent, CopyFromParent, CWOverrideRedirect,
 563                     &attribs);
 564
 565     /*
 566      * If the window is clicked without having ButtonPress selected, the
 567      * resulting event will have event.xbutton.window == root.
 568      */
 569     XSelectInput(dpy, scr->clip_balloon, ButtonPressMask);
 570 }
 571
 572
 573 #if 0
 574 static Bool
 575 aquireManagerSelection(WScreen *scr)
 576 {
 577     char buffer[32];
 578     XEvent ev;
 579     Time timestamp;
 580
 581     sprintf(buffer, "WM_S%i", scr->screen);
 582     scr->managerAtom = XInternAtom(dpy, buffer, False);
 583
 584     /* for race-conditions... */
 585     XGrabServer(dpy);
 586
 587     /* if there is another manager running, don't try to replace it
 588      * (for now, at least) */
 589     if (XGetSelectionOwner(dpy, scr->managerAtom) != None) {
 590         XUngrabServer(dpy);
 591         return False;
 592     }
 593
 594     /* become the manager for this screen */
 595
 596     scr->managerWindow = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 1, 1,
 597                                              0, 0, 0);
 598
 599     XSelectInput(dpy, scr->managerWindow, PropertyChangeMask);
 600     /* get a timestamp */
 601     XChangeProperty(dpy, scr->managerWindow, scr->managerAtom,
 602                     XA_INTEGER, 32, PropModeAppend, NULL, 0);
 603     while (1) {
 604         XWindowEvent(dpy, scr->managerWindow, &ev);
 605         if (ev.type == PropertyNotify) {
 606             timestamp = ev.xproperty.time;
 607             break;
 608         }
 609     }
 610     XSelectInput(dpy, scr->managerWindow, NoEvents);
 611     XDeleteProperty(dpy, scr->managerWindow, scr->managerAtom);
 612
 613     XSetSelectionOwner(dpy, scr->managerAtom, scr->managerWindow, CurrentTime);
 614
 615     XUngrabServer(dpy);
 616
 617     /* announce our arrival */
 618
 619     ev.xclient.type = ClientMessage;
 620     ev.xclient.message_type = XInternAtom(dpy, "MANAGER", False);
 621     ev.xclient.destination = scr->root_win;
 622     ev.xclient.format = 32;
 623     ev.xclient.data.l[0] = timestamp;
 624     ev.xclient.data.l[1] = scr->managerAtom;
 625     ev.xclient.data.l[2] = scr->managerWindow;
 626     ev.xclient.data.l[3] = 0;
 627     ev.xclient.data.l[4] = 0;
 628
 629     XSendEvent(dpy, scr->root_win, False, StructureNotify, &ev);
 630     XSync(dpy, False);
 631
 632     return True;
 633 }
 634 #endif
 635
 636 /*
 637  *----------------------------------------------------------------------
 638  * wScreenInit--
 639  *      Initializes the window manager for the given screen and
 640  * allocates a WScreen descriptor for it. Many resources are allocated
 641  * for the screen and the root window is setup appropriately.
 642  *
 643  * Returns:
 644  *      The WScreen descriptor for the screen.
 645  *
 646  * Side effects:
 647  *      Many resources are allocated and the IconSize property is
 648  * set on the root window.
 649  *      The program can be aborted if some fatal error occurs.
 650  *
 651  * TODO: User specifiable visual.
 652  *----------------------------------------------------------------------
 653  */
 654 WScreen*
 655 wScreenInit(int screen_number)
 656 {
 657     WScreen *scr;
 658     XIconSize icon_size[1];
 659     RContextAttributes rattr;
 660     extern int wVisualID;
 661     long event_mask;
 662     WMColor *color;
 663     XErrorHandler oldHandler;
 664
 665     scr = wmalloc(sizeof(WScreen));
 666     memset(scr, 0, sizeof(WScreen));
 667
 668     /* initialize globals */
 669     scr->screen = screen_number;
 670     scr->root_win = RootWindow(dpy, screen_number);
 671     scr->depth = DefaultDepth(dpy, screen_number);
 672     scr->colormap = DefaultColormap(dpy, screen_number);
 673
 674     scr->scr_width = WidthOfScreen(ScreenOfDisplay(dpy, screen_number));
 675     scr->scr_height = HeightOfScreen(ScreenOfDisplay(dpy, screen_number));
 676
 677     scr->usableArea.x2 = scr->scr_width;
 678     scr->usableArea.y2 = scr->scr_height;
 679     scr->totalUsableArea.x2 = scr->scr_width;
 680     scr->totalUsableArea.y2 = scr->scr_height;
 681
 682 #if 0
 683     if (!aquireManagerSelection(scr)) {
 684         free(scr);
 685
 686         return NULL;
 687     }
 688 #endif
 689     CantManageScreen = 0;
 690     oldHandler = XSetErrorHandler((XErrorHandler)alreadyRunningError);
 691
 692     event_mask = EVENT_MASK;
 693
 694     if (wPreferences.disable_root_mouse) {
 695         event_mask &= ~(ButtonPressMask|ButtonReleaseMask);
 696     }
 697
 698     XSelectInput(dpy, scr->root_win, event_mask);
 699
 700 #ifdef KEEP_XKB_LOCK_STATUS
 701     XkbSelectEvents(dpy,XkbUseCoreKbd,XkbIndicatorStateNotifyMask,
 702                                             XkbIndicatorStateNotifyMask);
 703 #endif /* KEEP_XKB_LOCK_STATUS */
 704
 705     XSync(dpy, False);
 706     XSetErrorHandler(oldHandler);
 707
 708     if (CantManageScreen) {
 709         free(scr);
 710         return NULL;
 711     }
 712
 713     XDefineCursor(dpy, scr->root_win, wCursor[WCUR_DEFAULT]);
 714
 715     /* screen descriptor for raster graphic library */
 716     rattr.flags = RC_RenderMode | RC_ColorsPerChannel;
 717     rattr.render_mode = wPreferences.no_dithering
 718                                 ? RBestMatchRendering
 719                                 : RDitheredRendering;
 720
 721     rattr.colors_per_channel = wPreferences.cmap_size;
 722     if (rattr.colors_per_channel<2)
 723         rattr.colors_per_channel = 2;
 724
 725     if (wVisualID>=0) {
 726         rattr.flags |= RC_VisualID;
 727         rattr.visualid = wVisualID;
 728     }
 729     scr->rcontext = RCreateContext(dpy, screen_number, &rattr);
 730     if (!scr->rcontext) {
 731         wwarning(_("could not initialize graphics library context: %s"),
 732                  RMessageForError(RErrorCode));
 733         wAbort(False);
 734     } else {
 735         char **formats;
 736         int i = 0;
 737
 738         formats = RSupportedFileFormats();
 739         if (formats) {
 740             for (i=0; formats[i]!=NULL; i++) {
 741                 if (strcmp(formats[i], "TIFF")==0) {
 742                     scr->flags.supports_tiff = 1;
 743                     break;
 744                 }
 745             }
 746         }
 747     }
 748
 749     scr->w_win = scr->rcontext->drawable;
 750     scr->w_visual = scr->rcontext->visual;
 751     scr->w_depth = scr->rcontext->depth;
 752     scr->w_colormap = scr->rcontext->cmap;
 753
 754     scr->black_pixel = scr->rcontext->black;
 755     scr->white_pixel = scr->rcontext->white;
 756
 757     /* create screen descriptor for WINGs */
 758     scr->wmscreen = WMCreateScreenWithRContext(dpy, screen_number,
 759                                                scr->rcontext);
 760
 761     if (!scr->wmscreen) {
 762         wfatal(_("could not do initialization of WINGs widget set"));
 763
 764         return NULL;
 765     }
 766
 767     color = WMGrayColor(scr->wmscreen);
 768     scr->light_pixel = WMColorPixel(color);
 769     WMReleaseColor(color);
 770
 771     color = WMDarkGrayColor(scr->wmscreen);
 772     scr->dark_pixel = WMColorPixel(color);
 773     WMReleaseColor(color);
 774
 775     {
 776         XColor xcol;
 777         /* frame boder color */
 778         wGetColor(scr, FRAME_BORDER_COLOR, &xcol);
 779         scr->frame_border_pixel = xcol.pixel;
 780     }
 781
 782     scr->workspace_name_font = wLoadFont(DEF_WORKSPACE_NAME_FONT);
 783
 784     /* create GCs with default values */
 785     allocGCs(scr);
 786
 787     /* read defaults for this screen */
 788     wReadDefaults(scr, WDWindowMaker->dictionary);
 789
 790     createInternalWindows(scr);
 791
 792 #ifdef KWM_HINTS
 793     wKWMInitStuff(scr);
 794 #endif
 795
 796 #ifdef GNOME_STUFF
 797     wGNOMEInitStuff(scr);
 798 #endif
 799
 800 #ifdef OLWM_HINTS
 801     wOLWMInitStuff(scr);
 802 #endif
 803
 804     /* create initial workspace */
 805     wWorkspaceNew(scr);
 806
 807     /* create shared pixmaps */
 808     createPixmaps(scr);
 809
 810     /* set icon sizes we can accept from clients */
 811     icon_size[0].min_width = 8;
 812     icon_size[0].min_height = 8;
 813     icon_size[0].max_width = wPreferences.icon_size-4;
 814     icon_size[0].max_height = wPreferences.icon_size-4;
 815     icon_size[0].width_inc = 1;
 816     icon_size[0].height_inc = 1;
 817     XSetIconSizes(dpy, scr->root_win, icon_size, 1);
 818
 819     /* setup WindowMaker protocols property in the root window*/
 820     PropSetWMakerProtocols(scr->root_win);
 821
 822     /* setup our noticeboard */
 823     XChangeProperty(dpy, scr->info_window, _XA_WINDOWMAKER_NOTICEBOARD,
 824                     XA_WINDOW, 32, PropModeReplace,
 825                     (unsigned char*)&scr->info_window, 1);
 826     XChangeProperty(dpy, scr->root_win, _XA_WINDOWMAKER_NOTICEBOARD,
 827                     XA_WINDOW, 32, PropModeReplace,
 828                     (unsigned char*)&scr->info_window, 1);
 829
 830
 831 #ifdef BALLOON_TEXT
 832     /* initialize balloon text stuff */
 833     wBalloonInitialize(scr);
 834 #endif
 835
 836     wScreenUpdateUsableArea(scr);
 837
 838 #ifndef LITE
 839     /* kluge to load menu configurations at startup */
 840     OpenRootMenu(scr, -10000, -10000, False);
 841     wMenuUnmap(scr->root_menu);
 842 #endif
 843
 844     return scr;
 845 }
 846
 847
 848 void
 849 wScreenUpdateUsableArea(WScreen *scr)
 850 {
 851 #ifdef GNOME_STUFF
 852     WReservedArea *area;
 853 #endif
 854
 855     scr->totalUsableArea = scr->usableArea;
 856
 857
 858     if (scr->dock && (!scr->dock->lowered
 859                       || wPreferences.no_window_over_dock)) {
 860
 861         int offset = wPreferences.icon_size + DOCK_EXTRA_SPACE;
 862
 863         if (scr->dock->on_right_side) {
 864             scr->totalUsableArea.x2 = WMIN(scr->totalUsableArea.x2,
 865                                           scr->scr_width - offset);
 866         } else {
 867             scr->totalUsableArea.x1 = WMAX(scr->totalUsableArea.x1, offset);
 868         }
 869     }
 870
 871     if (wPreferences.no_window_over_icons) {
 872         if (wPreferences.icon_yard & IY_VERT) {
 873
 874             if (!(wPreferences.icon_yard & IY_RIGHT)) {
 875                 scr->totalUsableArea.x1 += wPreferences.icon_size;
 876             } else {
 877                 scr->totalUsableArea.x2 -= wPreferences.icon_size;
 878             }
 879         } else {
 880
 881             if (wPreferences.icon_yard & IY_TOP) {
 882                 scr->totalUsableArea.y1 += wPreferences.icon_size;
 883             } else {
 884                 scr->totalUsableArea.y2 -= wPreferences.icon_size;
 885             }
 886         }
 887     }
 888
 889 #ifdef KWM_HINTS
 890     {
 891         WArea area;
 892
 893         if (wKWMGetUsableArea(scr, &area)) {
 894             scr->totalUsableArea.x1 = WMAX(scr->totalUsableArea.x1, area.x1);
 895             scr->totalUsableArea.y1 = WMAX(scr->totalUsableArea.y1, area.y1);
 896             scr->totalUsableArea.x2 = WMIN(scr->totalUsableArea.x2, area.x2);
 897             scr->totalUsableArea.y2 = WMIN(scr->totalUsableArea.y2, area.y2);
 898         }
 899     }
 900 #endif
 901
 902 #ifdef GNOME_STUFF
 903     area = scr->reservedAreas;
 904
 905     while (area) {
 906         int th, bh;
 907         int lw, rw;
 908         int w, h;
 909
 910         w = area->area.x2 - area->area.x1;
 911         h = area->area.y2 - area->area.y1;
 912
 913         th = area->area.y1;
 914         bh = scr->scr_height - area->area.y2;
 915         lw = area->area.x1;
 916         rw = scr->scr_width - area->area.x2;
 917
 918         if (WMIN(th, bh) < WMIN(lw, rw)) {
 919             /* horizontal */
 920             if (th < bh) {
 921                 /* on top */
 922                 if (scr->totalUsableArea.y1 < area->area.y2)
 923                     scr->totalUsableArea.y1 = area->area.y2;
 924             } else {
 925                 /* on bottom */
 926                 if (scr->totalUsableArea.y2 > area->area.y1)
 927                     scr->totalUsableArea.y2 = area->area.y1;
 928             }
 929         } else {
 930             /* vertical */
 931             if (lw < rw) {
 932                 /* on left */
 933                 if (scr->totalUsableArea.x1 < area->area.x2)
 934                     scr->totalUsableArea.x1 = area->area.x2;
 935             } else {
 936                 /* on right */
 937                 if (scr->totalUsableArea.x2 > area->area.x1)
 938                     scr->totalUsableArea.x2 = area->area.x1;
 939             }
 940         }
 941
 942         area = area->next;
 943     }
 944 #endif /* GNOME_STUFF */
 945
 946     if (scr->totalUsableArea.x2 - scr->totalUsableArea.x1 < scr->scr_width/2) {
 947         scr->totalUsableArea.x2 = scr->usableArea.x2;
 948         scr->totalUsableArea.x1 = scr->usableArea.x1;
 949     }
 950     if (scr->totalUsableArea.y2 - scr->totalUsableArea.y1 < scr->scr_height/2) {
 951         scr->totalUsableArea.y2 = scr->usableArea.y2;
 952         scr->totalUsableArea.y1 = scr->usableArea.y1;
 953     }
 954
 955 #ifdef not_used
 956 #ifdef KWM_HINTS
 957     {
 958         int i;
 959
 960         for (i = 0; i < scr->workspace_count; i++) {
 961             wKWMSetUsableAreaHint(scr, i);
 962         }
 963     }
 964 #endif
 965 #endif
 966 }
 967
 968
 969 void
 970 wScreenRestoreState(WScreen *scr)
 971 {
 972     proplist_t state;
 973     char *path;
 974
 975     make_keys();
 976
 977     if (wScreenCount == 1)
 978         path = wdefaultspathfordomain("WMState");
 979     else {
 980         char buf[16];
 981         sprintf(buf, "WMState.%i", scr->screen);
 982         path = wdefaultspathfordomain(buf);
 983     }
 984     scr->session_state = PLGetProplistWithPath(path);
 985     free(path);
 986     if (!scr->session_state && wScreenCount>1) {
 987         char buf[16];
 988         sprintf(buf, "WMState.%i", scr->screen);
 989         path = wdefaultspathfordomain(buf);
 990         scr->session_state = PLGetProplistWithPath(path);
 991         free(path);
 992     }
 993
 994     if (!wPreferences.flags.noclip) {
 995         state = PLGetDictionaryEntry(scr->session_state, dClip);
 996         scr->clip_icon = wClipRestoreState(scr, state);
 997     }
 998
 999     wWorkspaceRestoreState(scr);
1000
1001     if (!wPreferences.flags.nodock) {
1002         state = PLGetDictionaryEntry(scr->session_state, dDock);
1003         scr->dock = wDockRestoreState(scr, state, WM_DOCK);
1004     }
1005
1006     wScreenUpdateUsableArea(scr);
1007 }
1008
1009
1010 void
1011 wScreenSaveState(WScreen *scr)
1012 {
1013     WWorkspaceState wstate;
1014     WWindow *wwin;
1015     char *str;
1016     proplist_t path, old_state, foo;
1017     CARD32 data[2];
1018
1019
1020     make_keys();
1021
1022 /*
1023  * Save current workspace, so can go back to it upon restart.
1024  */
1025     wstate.workspace = scr->current_workspace;
1026
1027     data[0] = wstate.flags;
1028     data[1] = wstate.workspace;
1029
1030     XChangeProperty(dpy, scr->root_win, _XA_WINDOWMAKER_STATE,
1031                     _XA_WINDOWMAKER_STATE, 32, PropModeReplace,
1032                     (unsigned char *) data, 2);
1033
1034     /* save state of windows */
1035     wwin = scr->focused_window;
1036     while (wwin) {
1037         wWindowSaveState(wwin);
1038         wwin = wwin->prev;
1039     }
1040
1041
1042     if (wPreferences.flags.noupdates)
1043         return;
1044
1045
1046     old_state = scr->session_state;
1047     scr->session_state = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
1048
1049     PLSetStringCmpHook(NULL);
1050
1051     /* save dock state to file */
1052     if (!wPreferences.flags.nodock) {
1053         wDockSaveState(scr);
1054     } else {
1055         if ((foo = PLGetDictionaryEntry(old_state, dDock))!=NULL) {
1056             PLInsertDictionaryEntry(scr->session_state, dDock, foo);
1057         }
1058     }
1059     if (!wPreferences.flags.noclip) {
1060         wClipSaveState(scr);
1061     } else {
1062         if ((foo = PLGetDictionaryEntry(old_state, dClip))!=NULL) {
1063             PLInsertDictionaryEntry(scr->session_state, dClip, foo);
1064         }
1065     }
1066
1067     wWorkspaceSaveState(scr, old_state);
1068
1069     if (wPreferences.save_session_on_exit) {
1070         wSessionSaveState(scr);
1071     } else {
1072         if ((foo = PLGetDictionaryEntry(old_state, dApplications))!=NULL) {
1073             PLInsertDictionaryEntry(scr->session_state, dApplications, foo);
1074         }
1075         if ((foo = PLGetDictionaryEntry(old_state, dWorkspace))!=NULL) {
1076             PLInsertDictionaryEntry(scr->session_state, dWorkspace, foo);
1077         }
1078     }
1079
1080     /* clean up */
1081     PLSetStringCmpHook(StringCompareHook);
1082
1083     wMenuSaveState(scr);
1084
1085     if (wScreenCount == 1)
1086         str = wdefaultspathfordomain("WMState");
1087     else {
1088         char buf[16];
1089         sprintf(buf, "WMState.%i", scr->screen);
1090         str = wdefaultspathfordomain(buf);
1091     }
1092     path = PLMakeString(str);
1093     free(str);
1094     PLSetFilename(scr->session_state, path);
1095     if (!PLSave(scr->session_state, YES)) {
1096         wwarning(_("could not save session state in %s"), PLGetString(path));
1097     }
1098     PLRelease(path);
1099     PLRelease(old_state);
1100 }
1101
1102
1103
1104 int
1105 wScreenBringInside(WScreen *scr, int *x, int *y, int width, int height)
1106 {
1107     int moved = 0;
1108     int tol_w, tol_h;
1109
1110     if (width > 20)
1111         tol_w = width/2;
1112     else
1113         tol_w = 20;
1114
1115     if (height > 20)
1116         tol_h = height/2;
1117     else
1118         tol_h = 20;
1119
1120     if (*x+width < 10)
1121         *x = -tol_w, moved = 1;
1122     else if (*x >= scr->scr_width - 10)
1123         *x = scr->scr_width - tol_w - 1, moved = 1;
1124
1125     if (*y < -height + 10)
1126         *y = -tol_h, moved = 1;
1127     else if (*y >= scr->scr_height - 10)
1128         *y = scr->scr_height - tol_h - 1, moved = 1;
1129
1130     return moved;
1131 }
1132
1133