src/gnome.c

   1 /* gnome.c-- support for the GNOME Hints
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1998, 1999 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 /*
  24  * According to the author of this thing, it should not be taken seriously.
  25  * IMHO, there are lot's of weirdnesses and it's quite unelegant. I'd
  26  * rather not support it, but here it goes anyway.
  27  */
  28
  29 #include "wconfig.h"
  30
  31 #ifdef GNOME_STUFF
  32
  33 #include <X11/Xlib.h>
  34 #include <X11/Xutil.h>
  35 #include <X11/Xatom.h>
  36
  37 #include <stdlib.h>
  38 #include <stdio.h>
  39 #include <string.h>
  40
  41
  42 #include "WindowMaker.h"
  43 #include "screen.h"
  44 #include "wcore.h"
  45 #include "framewin.h"
  46 #include "window.h"
  47 #include "workspace.h"
  48 #include "funcs.h"
  49 #include "actions.h"
  50 #include "stacking.h"
  51
  52 #include "gnome.h"
  53
  54
  55
  56
  57
  58
  59 #define WIN_HINTS_SKIP_FOCUS      (1<<0) /*"alt-tab" skips this win*/
  60 #define WIN_HINTS_SKIP_WINLIST    (1<<1) /*do not show in window list*/
  61 #define WIN_HINTS_SKIP_TASKBAR    (1<<2) /*do not show on taskbar*/
  62 #define WIN_HINTS_GROUP_TRANSIENT (1<<3) /*Reserved - definition is unclear*/
  63 #define WIN_HINTS_FOCUS_ON_CLICK  (1<<4) /*app only accepts focus if clicked*/
  64
  65
  66 #define WIN_STATE_STICKY          (1<<0) /*everyone knows sticky*/
  67 #define WIN_STATE_MINIMIZED       (1<<1) /*Reserved - definition is unclear*/
  68 #define WIN_STATE_MAXIMIZED_VERT  (1<<2) /*window in maximized V state*/
  69 #define WIN_STATE_MAXIMIZED_HORIZ (1<<3) /*window in maximized H state*/
  70 #define WIN_STATE_HIDDEN          (1<<4) /*not on taskbar but window visible*/
  71 #define WIN_STATE_SHADED          (1<<5) /*shaded (MacOS / Afterstep style)*/
  72 /* these are bogus states defined in "the spec" */
  73 #define WIN_STATE_HID_WORKSPACE   (1<<6) /*not on current desktop*/
  74 #define WIN_STATE_HID_TRANSIENT   (1<<7) /*owner of transient is hidden*/
  75 #define WIN_STATE_FIXED_POSITION  (1<<8) /*window is fixed in position even*/
  76 #define WIN_STATE_ARRANGE_IGNORE  (1<<9) /*ignore for auto arranging*/
  77
  78
  79 #define WIN_LAYER_DESKTOP                0
  80 #define WIN_LAYER_BELOW                  2
  81 #define WIN_LAYER_NORMAL                 4
  82 #define WIN_LAYER_ONTOP                  6
  83 #define WIN_LAYER_DOCK                   8
  84 #define WIN_LAYER_ABOVE_DOCK             10
  85 #define WIN_LAYER_MENU                   12
  86
  87
  88
  89 static Atom _XA_WIN_SUPPORTING_WM_CHECK = 0;
  90 static Atom _XA_WIN_PROTOCOLS;
  91 static Atom _XA_WIN_LAYER;
  92 static Atom _XA_WIN_STATE;
  93 static Atom _XA_WIN_HINTS;
  94 static Atom _XA_WIN_APP_STATE;
  95 static Atom _XA_WIN_EXPANDED_SIZE;
  96 static Atom _XA_WIN_ICONS;
  97 static Atom _XA_WIN_WORKSPACE;
  98 static Atom _XA_WIN_WORKSPACE_COUNT;
  99 static Atom _XA_WIN_WORKSPACE_NAMES;
 100 static Atom _XA_WIN_CLIENT_LIST;
 101 static Atom _XA_WIN_DESKTOP_BUTTON_PROXY;
 102
 103
 104 void
 105 wGNOMEInitStuff(WScreen *scr)
 106 {
 107     Atom supportedStuff[10];
 108     int count;
 109
 110     if (!_XA_WIN_SUPPORTING_WM_CHECK) {
 111
 112         _XA_WIN_SUPPORTING_WM_CHECK =
 113             XInternAtom(dpy, "_WIN_SUPPORTING_WM_CHECK", False);
 114
 115         _XA_WIN_PROTOCOLS = XInternAtom(dpy, "_WIN_PROTOCOLS", False);
 116
 117         _XA_WIN_LAYER = XInternAtom(dpy, "_WIN_LAYER", False);
 118
 119         _XA_WIN_STATE = XInternAtom(dpy, "_WIN_STATE", False);
 120
 121         _XA_WIN_HINTS = XInternAtom(dpy, "_WIN_HINTS", False);
 122
 123         _XA_WIN_APP_STATE = XInternAtom(dpy, "_WIN_APP_STATE", False);
 124
 125         _XA_WIN_EXPANDED_SIZE = XInternAtom(dpy, "_WIN_EXPANDED_SIZE", False);
 126
 127         _XA_WIN_ICONS = XInternAtom(dpy, "_WIN_ICONS", False);
 128
 129         _XA_WIN_WORKSPACE = XInternAtom(dpy, "_WIN_WORKSPACE", False);
 130
 131         _XA_WIN_WORKSPACE_COUNT =
 132             XInternAtom(dpy, "_WIN_WORKSPACE_COUNT", False);
 133
 134         _XA_WIN_WORKSPACE_NAMES =
 135             XInternAtom(dpy, "_WIN_WORKSPACE_NAMES", False);
 136
 137         _XA_WIN_CLIENT_LIST = XInternAtom(dpy, "_WIN_CLIENT_LIST", False);
 138
 139         _XA_WIN_DESKTOP_BUTTON_PROXY =
 140             XInternAtom(dpy, "_WIN_DESKTOP_BUTTON_PROXY", False);
 141     }
 142
 143     /* I'd rather use the ICCCM 2.0 mechanisms, but
 144      * since some people prefer to reinvent the wheel instead of
 145      * conforming to standards... */
 146
 147     /* setup the "We're compliant, you idiot!" hint */
 148
 149     /* why XA_CARDINAL instead of XA_WINDOW? */
 150     XChangeProperty(dpy, scr->root_win, _XA_WIN_SUPPORTING_WM_CHECK,
 151                     XA_CARDINAL, 32, PropModeReplace,
 152                     (unsigned char*)&scr->no_focus_win, 1);
 153
 154     XChangeProperty(dpy, scr->no_focus_win, _XA_WIN_SUPPORTING_WM_CHECK,
 155                     XA_CARDINAL, 32, PropModeReplace,
 156                     (unsigned char*)&scr->no_focus_win, 1);
 157
 158
 159     /* setup the "desktop button proxy" thing */
 160     XChangeProperty(dpy, scr->root_win, _XA_WIN_DESKTOP_BUTTON_PROXY,
 161                     XA_CARDINAL, 32, PropModeReplace,
 162                     (unsigned char*)&scr->no_focus_win, 1);
 163     XChangeProperty(dpy, scr->no_focus_win, _XA_WIN_DESKTOP_BUTTON_PROXY,
 164                     XA_CARDINAL, 32, PropModeReplace,
 165                     (unsigned char*)&scr->no_focus_win, 1);
 166
 167
 168     /* setup the list of supported protocols */
 169     count = 0;
 170     supportedStuff[count++] = _XA_WIN_LAYER;
 171     supportedStuff[count++] = _XA_WIN_STATE;
 172     supportedStuff[count++] = _XA_WIN_HINTS;
 173     supportedStuff[count++] = _XA_WIN_APP_STATE;
 174     supportedStuff[count++] = _XA_WIN_EXPANDED_SIZE;
 175     supportedStuff[count++] = _XA_WIN_ICONS;
 176     supportedStuff[count++] = _XA_WIN_WORKSPACE;
 177     supportedStuff[count++] = _XA_WIN_WORKSPACE_COUNT;
 178     supportedStuff[count++] = _XA_WIN_WORKSPACE_NAMES;
 179     supportedStuff[count++] = _XA_WIN_CLIENT_LIST;
 180
 181     XChangeProperty(dpy, scr->root_win, _XA_WIN_PROTOCOLS, XA_ATOM, 32,
 182                     PropModeReplace, (unsigned char*)supportedStuff, count);
 183
 184     XFlush(dpy);
 185 }
 186
 187
 188 void
 189 wGNOMEUpdateClientListHint(WScreen *scr)
 190 {
 191     WWindow *wwin;
 192     Window *windows;
 193     int count;
 194
 195     windows = malloc(sizeof(Window)*scr->window_count);
 196     if (!windows) {
 197         wwarning(_("out of memory while updating GNOME hints"));
 198         return;
 199     }
 200
 201     count = 0;
 202     wwin = scr->focused_window;
 203     while (wwin) {
 204         if (!wwin->flags.internal_window) {
 205
 206             windows[count++] = wwin->client_win;
 207         }
 208
 209         wwin = wwin->prev;
 210     }
 211
 212     XChangeProperty(dpy, scr->root_win, _XA_WIN_CLIENT_LIST, XA_CARDINAL, 32,
 213                     PropModeReplace, (unsigned char *)windows, count);
 214
 215     free(windows);
 216     XFlush(dpy);
 217 }
 218
 219
 220 void
 221 wGNOMEUpdateWorkspaceHints(WScreen *scr)
 222 {
 223     long val;
 224
 225     val = scr->workspace_count;
 226
 227     XChangeProperty(dpy, scr->root_win, _XA_WIN_WORKSPACE_COUNT, XA_CARDINAL,
 228                     32, PropModeReplace, (unsigned char*)&val, 1);
 229
 230     wGNOMEUpdateWorkspaceNamesHint(scr);
 231 }
 232
 233
 234 void
 235 wGNOMEUpdateWorkspaceNamesHint(WScreen *scr)
 236 {
 237     char *wsNames[MAX_WORKSPACES];
 238     XTextProperty textProp;
 239     int i;
 240
 241     for (i = 0; i < scr->workspace_count; i++) {
 242         wsNames[i] = scr->workspaces[i]->name;
 243     }
 244
 245     if (XStringListToTextProperty(wsNames, scr->workspace_count, &textProp)) {
 246         XSetTextProperty(dpy, scr->root_win, &textProp,
 247                          _XA_WIN_WORKSPACE_NAMES);
 248         XFree(textProp.value);
 249     }
 250 }
 251
 252
 253 void
 254 wGNOMEUpdateCurrentWorkspaceHint(WScreen *scr)
 255 {
 256     long val;
 257
 258     val = scr->current_workspace;
 259
 260     XChangeProperty(dpy, scr->root_win, _XA_WIN_WORKSPACE, XA_CARDINAL,
 261                     32, PropModeReplace, (unsigned char*)&val, 1);
 262 }
 263
 264
 265 static int
 266 getWindowLevel(int layer)
 267 {
 268     int level;
 269
 270     if (layer <= WIN_LAYER_DESKTOP)
 271         level = WMDesktopLevel;
 272     else if (layer <= WIN_LAYER_BELOW)
 273         level = WMSunkenLevel;
 274     else if (layer <= WIN_LAYER_NORMAL)
 275         level = WMNormalLevel;
 276     else if (layer <= WIN_LAYER_ONTOP)
 277         level = WMFloatingLevel;
 278     else if (layer <= WIN_LAYER_DOCK)
 279         level = WMDockLevel;
 280     else if (layer <= WIN_LAYER_ABOVE_DOCK)
 281         level = WMSubmenuLevel;
 282     else if (layer <= WIN_LAYER_MENU)
 283         level = WMMainMenuLevel;
 284     else
 285         level = WMOuterSpaceLevel;
 286
 287     return level;
 288 }
 289
 290
 291 Bool
 292 wGNOMECheckClientHints(WWindow *wwin, int *layer, int *workspace)
 293 {
 294     Atom type_ret;
 295     int fmt_ret;
 296     unsigned long nitems_ret;
 297     unsigned long bytes_after_ret;
 298     long flags, val, *data = 0;
 299     Bool hasHints = False;
 300
 301     /* hints */
 302
 303     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_HINTS, 0, 1, False,
 304                            /* should be XA_INTEGER, but spec is broken */
 305                            XA_CARDINAL, &type_ret, &fmt_ret, &nitems_ret,
 306                            &bytes_after_ret,
 307                            (unsigned char**)&data)==Success && data) {
 308         flags = *data;
 309
 310         XFree(data);
 311
 312         if (flags & (WIN_HINTS_SKIP_FOCUS|WIN_HINTS_SKIP_WINLIST)) {
 313             wwin->client_flags.skip_window_list = 1;
 314         }
 315         hasHints = True;
 316     }
 317
 318     /* layer */
 319     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_LAYER, 0, 1, False,
 320                            XA_CARDINAL, &type_ret, &fmt_ret, &nitems_ret,
 321                            &bytes_after_ret,
 322                            (unsigned char**)&data)==Success  && data) {
 323         val = *data;
 324
 325         XFree(data);
 326
 327         *layer = getWindowLevel(val);
 328         hasHints = True;
 329     }
 330
 331     /* workspace */
 332     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_WORKSPACE, 0, 1,
 333                            False, XA_CARDINAL, &type_ret, &fmt_ret,
 334                            &nitems_ret, &bytes_after_ret,
 335                            (unsigned char**)&data)==Success && data) {
 336         val = *data;
 337
 338         XFree(data);
 339
 340         if (val > 0)
 341             *workspace = val;
 342         hasHints = True;
 343     }
 344
 345     /* reserved area */
 346     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_EXPANDED_SIZE, 0, 1,
 347                            False, XA_CARDINAL, &type_ret, &fmt_ret,
 348                            &nitems_ret, &bytes_after_ret,
 349                            (unsigned char**)&data)==Success && data) {
 350         WReservedArea *area;
 351
 352         area = malloc(sizeof(WReservedArea));
 353         if (!area) {
 354             wwarning(_("out of memory while updating GNOME hints"));
 355         } else {
 356             area->area.x1 = data[0];
 357             area->area.y1 = data[1];
 358             area->area.x2 = data[2] - data[0];
 359             area->area.y2 = data[3] - data[1];
 360             XFree(data);
 361
 362             area->window = wwin->client_win;
 363         }
 364
 365         area->next = wwin->screen_ptr->reservedAreas;
 366         wwin->screen_ptr->reservedAreas = area;
 367
 368         wScreenUpdateUsableArea(wwin->screen_ptr);
 369         hasHints = True;
 370     }
 371
 372     return hasHints;
 373 }
 374
 375
 376 Bool
 377 wGNOMECheckInitialClientState(WWindow *wwin)
 378 {
 379     Atom type_ret;
 380     int fmt_ret;
 381     unsigned long nitems_ret;
 382     unsigned long bytes_after_ret;
 383     long flags, *data = 0;
 384
 385     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_STATE, 0, 1, False,
 386                            XA_CARDINAL, &type_ret, &fmt_ret, &nitems_ret,
 387                            &bytes_after_ret,
 388                            (unsigned char**)&data)!=Success || !data)
 389         return False;
 390
 391     flags = *data;
 392
 393     XFree(data);
 394
 395     if (flags & WIN_STATE_STICKY)
 396         wwin->client_flags.omnipresent = 1;
 397
 398     if (flags & (WIN_STATE_MAXIMIZED_VERT|WIN_STATE_MAXIMIZED_HORIZ)) {
 399
 400         if (flags & WIN_STATE_MAXIMIZED_VERT)
 401             wwin->flags.maximized |= MAX_VERTICAL;
 402
 403         if (flags & WIN_STATE_MAXIMIZED_HORIZ)
 404             wwin->flags.maximized |= MAX_HORIZONTAL;
 405     }
 406
 407     if (flags & WIN_STATE_SHADED)
 408         wwin->flags.shaded = 1;
 409
 410     return True;
 411 }
 412
 413
 414 void
 415 wGNOMEUpdateClientStateHint(WWindow *wwin, Bool changedWorkspace)
 416 {
 417     long val;
 418     long flags = 0;
 419
 420     if (changedWorkspace) {
 421         val = wwin->frame->workspace;
 422
 423         XChangeProperty(dpy, wwin->client_win, _XA_WIN_WORKSPACE, XA_CARDINAL,
 424                         32, PropModeReplace, (unsigned char*)&val, 1);
 425
 426         if (val != wwin->screen_ptr->current_workspace)
 427             flags |= WIN_STATE_HID_WORKSPACE;
 428     }
 429
 430     if (IS_OMNIPRESENT(wwin))
 431         flags |= WIN_STATE_STICKY;
 432
 433     if (wwin->flags.miniaturized)
 434         flags |= WIN_STATE_MINIMIZED;
 435
 436     if (wwin->flags.maximized & MAX_VERTICAL)
 437         flags |= WIN_STATE_MAXIMIZED_VERT;
 438
 439     if (wwin->flags.maximized & MAX_HORIZONTAL)
 440         flags |= WIN_STATE_MAXIMIZED_HORIZ;
 441
 442     if (wwin->flags.shaded)
 443         flags |= WIN_STATE_SHADED;
 444
 445     if (wwin->transient_for != None) {
 446         WWindow *owner = wWindowFor(wwin->transient_for);
 447
 448         if (owner && !owner->flags.mapped)
 449             flags |= WIN_STATE_HID_TRANSIENT;
 450     }
 451
 452     /* ? */
 453     if (wwin->flags.hidden)
 454         flags |= WIN_STATE_HIDDEN;
 455
 456     XChangeProperty(dpy, wwin->client_win, _XA_WIN_STATE, XA_CARDINAL,
 457                     32, PropModeReplace, (unsigned char*)&flags, 1);
 458 }
 459
 460
 461 Bool
 462 wGNOMEProcessClientMessage(XClientMessageEvent *event)
 463 {
 464     WScreen *scr;
 465     WWindow *wwin;
 466     Bool done = True;
 467
 468     scr = wScreenForWindow(event->window);
 469     if (scr) {
 470         /* generic client messages */
 471         if (event->message_type == _XA_WIN_WORKSPACE) {
 472             wWorkspaceChange(scr, event->data.l[0]);
 473         } else {
 474             done = False;
 475         }
 476
 477         if (done)
 478             return True;
 479     }
 480
 481     /* window specific client messages */
 482
 483     wwin = wWindowFor(event->window);
 484     if (!wwin)
 485         return False;
 486
 487     if (event->message_type == _XA_WIN_LAYER) {
 488         int level = getWindowLevel(event->data.l[0]);
 489
 490         if (WINDOW_LEVEL(wwin) != level) {
 491             ChangeStackingLevel(wwin->frame->core, level);
 492         }
 493     } else if (event->message_type == _XA_WIN_STATE) {
 494         int flags, mask;
 495         Bool updateWindowList = False;
 496         int maximize = 0;
 497
 498         mask = event->data.l[0];
 499         flags = event->data.l[1];
 500
 501         if (mask & WIN_STATE_STICKY) {
 502             if ((flags & WIN_STATE_STICKY) != WFLAGP(wwin, omnipresent)) {
 503                 wwin->client_flags.omnipresent = 1;
 504                 updateWindowList = True;
 505             }
 506         }
 507
 508         if (mask & WIN_STATE_MAXIMIZED_VERT) {
 509             if (flags & WIN_STATE_MAXIMIZED_VERT)
 510                 maximize = MAX_VERTICAL;
 511             else
 512                 maximize = 0;
 513         } else {
 514             maximize = wwin->flags.maximized & MAX_VERTICAL;
 515         }
 516
 517         if (mask & WIN_STATE_MAXIMIZED_HORIZ) {
 518             if (flags & WIN_STATE_MAXIMIZED_HORIZ)
 519                 maximize |= MAX_HORIZONTAL;
 520             else
 521                 maximize |= 0;
 522         } else {
 523             maximize |= wwin->flags.maximized & MAX_HORIZONTAL;
 524         }
 525
 526         if (maximize != wwin->flags.maximized) {
 527 #define both (MAX_HORIZONTAL|MAX_VERTICAL)
 528             if (!(maximize & both) && (wwin->flags.maximized & both)) {
 529                 wUnmaximizeWindow(wwin);
 530             }
 531             if ((maximize & both) && !(wwin->flags.maximized & both)) {
 532                 wMaximizeWindow(wwin, maximize);
 533             }
 534             updateWindowList = False;
 535 #undef both
 536         }
 537
 538         if (mask & WIN_STATE_SHADED) {
 539             if ((flags & WIN_STATE_SHADED) != wwin->flags.shaded) {
 540                 if (wwin->flags.shaded)
 541                     wUnshadeWindow(wwin);
 542                 else
 543                     wShadeWindow(wwin);
 544                 updateWindowList = False;
 545             }
 546         }
 547
 548         if (updateWindowList) {
 549             UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_STATE);
 550         }
 551     } else if (event->message_type == _XA_WIN_WORKSPACE) {
 552
 553         if (event->data.l[0] != wwin->frame->workspace) {
 554             wWindowChangeWorkspace(wwin, event->data.l[0]);
 555         }
 556     } else {
 557         done = False;
 558     }
 559
 560     return done;
 561 }
 562
 563
 564 Bool
 565 wGNOMEProxyizeButtonEvent(WScreen *scr, XEvent *event)
 566 {
 567     if (event->type == ButtonPress)
 568         XUngrabPointer(dpy, CurrentTime);
 569     XSendEvent(dpy, scr->no_focus_win, False, SubstructureNotifyMask, event);
 570
 571     return True;
 572 }
 573
 574
 575 void
 576 wGNOMERemoveClient(WWindow *wwin)
 577 {
 578     int flag = 0;
 579     WReservedArea *area;
 580
 581     wGNOMEUpdateClientListHint(wwin->screen_ptr);
 582
 583     area = wwin->screen_ptr->reservedAreas;
 584
 585     if (area) {
 586         if (area->window == wwin->client_win) {
 587             wwin->screen_ptr->reservedAreas = area->next;
 588             free(area);
 589             flag = 1;
 590         } else {
 591             while (area->next && area->next->window != wwin->client_win)
 592                 area = area->next;
 593
 594             if (area->next) {
 595                 WReservedArea *next;
 596
 597                 next = area->next->next;
 598                 free(area->next);
 599                 area->next = next;
 600
 601                 flag = 1;
 602             }
 603         }
 604     }
 605
 606     if (flag) {
 607         wScreenUpdateUsableArea(wwin->screen_ptr);
 608     }
 609 }
 610
 611
 612 #endif /* GNOME_STUFF */