src/kwm.c

   1 /* kwm.c-- stuff for support for kwm 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  *
  25  * Supported stuff:
  26  * ================
  27  *
  28  * kfm icon selection from krootbgwm
  29  *
  30  * kwm.h function/method        Notes
  31  *----------------------------------------------------------------------------
  32  * setUnsavedDataHint()         currently, only gives visual clue that
  33  *                              there is unsaved data (broken X close button)
  34  * setSticky()
  35  * setIcon()                    std X thing...
  36  * setDecoration()
  37  * logout()
  38  * refreshScreen()
  39  * setWmCommand()               std X thing
  40  * currentDesktop()
  41  * setKWMModule()
  42  *
  43  * isKWMInitialized()           not trustworthy
  44  * activeWindow()               dunno it's use, but since it's easy to
  45  *                              implement it won't hurt to support
  46  * switchToDesktop()
  47  * (set/get)WindowRegion()
  48  * (set)numberOfDesktops()      KDE limits to 32, but wmaker is virtually
  49  *                              unlimited. May raise some incompatibility
  50  *                              in badly written KDE modules?
  51  * (set/get)DesktopName()
  52  * sendKWMCommand()             also does the message relay thing
  53  * desktop()
  54  * geometryRestore()
  55  * isIconified()
  56  * isMaximized()
  57  * isSticky()
  58  * moveToDesktop()              WARNING: evil mechanism
  59  * setGeometryRestore()         WARNING: evil mechanism
  60  * setMaximize()                woo hoo! wanna race?
  61  * setIconify()                 BAH!: why reinvent the f'ing wheel!?
  62  *                              its even broken!!!
  63  * move()                       std X thing
  64  * setGeometry()                std X thing
  65  * close()                      std X thing
  66  * activate()
  67  * activateInternal()
  68  * raise()                      std X thing
  69  * lower()                      std X thing
  70  * prepareForSwallowing()       std X thing
  71  * doNotManage()                klugy thing...
  72  * getBlablablaString()
  73  * setKWMDockModule()           maybe we can make the Dock behave as the KDE
  74  *                              dock, but must figure where to show the windows
  75  * setDockWindow()
  76  *
  77  * Unsupported stuff (superfluous/not-essential/nonsense):
  78  * =======================================================
  79  *
  80  * darkenScreen()
  81  * setMiniIcon()
  82  * configureWm()
  83  * raiseSoundEvent()
  84  * registerSoundEvent()
  85  * unregisterSoundEvent()
  86  * title()
  87  * titleWithState()
  88  * geometry()                   kde lib code makes it unnecessary
  89  *
  90  *
  91  * Extensions to KDE:
  92  * ==================
  93  *
  94  * These are clientmessage-type messages specific to Window Maker:
  95  * wmaker:info - show info panel
  96  * wmaker:legal - show legal panel
  97  * wmaker:arrangeIcons - arrange icons
  98  * wmaker:showAll - show all windows
  99  * wmaker:hideOthers - hide others
 100  * wmaker:restart - restart wmaker
 101  * wmaker:exit - exit wmaker
 102  */
 103
 104 /*
 105  * TODO
 106  * different WORKAREA for each workspace
 107  */
 108
 109
 110 #include "wconfig.h"
 111
 112 #ifdef KWM_HINTS
 113
 114 #include <X11/Xlib.h>
 115 #include <X11/Xutil.h>
 116 #include <X11/Xatom.h>
 117
 118 #include <stdlib.h>
 119 #include <stdio.h>
 120 #include <string.h>
 121 #include <unistd.h>
 122
 123 #include <sys/types.h>
 124 #include <sys/socket.h>
 125 #include <sys/un.h>
 126 #include <signal.h>
 127
 128
 129 #include "WindowMaker.h"
 130
 131 #include "screen.h"
 132 #include "wcore.h"
 133 #include "framewin.h"
 134 #include "window.h"
 135 #include "properties.h"
 136 #include "icon.h"
 137 #include "client.h"
 138 #include "funcs.h"
 139 #include "actions.h"
 140 #include "workspace.h"
 141 #include "dialog.h"
 142 #include "stacking.h"
 143
 144 #include "kwm.h"
 145
 146 /*#define DEBUG1
 147 */
 148 /******* Global ******/
 149
 150 extern Time LastFocusChange;
 151 extern Time LastTimestamp;
 152
 153
 154 extern Atom _XA_GNUSTEP_WM_MINIATURIZE_WINDOW;
 155 extern Atom _XA_WM_DELETE_WINDOW;
 156
 157 /** Local **/
 158
 159 static Atom _XA_KWM_COMMAND = 0;
 160 static Atom _XA_KWM_ACTIVATE_WINDOW = 0;
 161 static Atom _XA_KWM_ACTIVE_WINDOW = 0;
 162 static Atom _XA_KWM_DO_NOT_MANAGE = 0;
 163 static Atom _XA_KWM_DOCKWINDOW = 0;
 164 static Atom _XA_KWM_RUNNING = 0;
 165
 166 static Atom _XA_KWM_MODULE = 0;
 167
 168 static Atom _XA_KWM_MODULE_INIT = 0;
 169 static Atom _XA_KWM_MODULE_INITIALIZED = 0;
 170 static Atom _XA_KWM_MODULE_DESKTOP_CHANGE = 0;
 171 static Atom _XA_KWM_MODULE_DESKTOP_NAME_CHANGE = 0;
 172 static Atom _XA_KWM_MODULE_DESKTOP_NUMBER_CHANGE = 0;
 173 static Atom _XA_KWM_MODULE_WIN_ADD = 0;
 174 static Atom _XA_KWM_MODULE_WIN_REMOVE = 0;
 175 static Atom _XA_KWM_MODULE_WIN_CHANGE = 0;
 176 static Atom _XA_KWM_MODULE_WIN_RAISE = 0;
 177 static Atom _XA_KWM_MODULE_WIN_LOWER = 0;
 178 static Atom _XA_KWM_MODULE_WIN_ACTIVATE = 0;
 179 static Atom _XA_KWM_MODULE_WIN_ICON_CHANGE = 0;
 180 static Atom _XA_KWM_MODULE_DOCKWIN_ADD = 0;
 181 static Atom _XA_KWM_MODULE_DOCKWIN_REMOVE = 0;
 182
 183 static Atom _XA_KWM_WIN_UNSAVED_DATA = 0;
 184 static Atom _XA_KWM_WIN_DECORATION = 0;
 185 static Atom _XA_KWM_WIN_DESKTOP = 0;
 186 static Atom _XA_KWM_WIN_GEOMETRY_RESTORE = 0;
 187 static Atom _XA_KWM_WIN_ICONIFIED = 0;
 188 static Atom _XA_KWM_WIN_MAXIMIZED = 0;
 189 static Atom _XA_KWM_WIN_STICKY = 0;
 190
 191 static Atom _XA_KWM_WIN_ICON_GEOMETRY = 0;
 192
 193 static Atom _XA_KWM_CURRENT_DESKTOP = 0;
 194 static Atom _XA_KWM_NUMBER_OF_DESKTOPS = 0;
 195 static Atom _XA_KWM_DESKTOP_NAME_[MAX_WORKSPACES];
 196 static Atom _XA_KWM_WINDOW_REGION_[MAX_WORKSPACES];
 197
 198
 199
 200 /* list of window titles that must not be managed */
 201 typedef struct KWMDoNotManageList {
 202     char title[20];
 203     struct KWMDoNotManageList *next;
 204 } KWMDoNotManageList;
 205
 206 static KWMDoNotManageList *KWMDoNotManageCrap = NULL;
 207
 208
 209 /* list of KWM modules */
 210 typedef struct KWMModuleList {
 211     Window window;
 212     struct KWMModuleList *next;
 213 #ifdef DEBUG1
 214     char *title;
 215 #endif
 216 } KWMModuleList;
 217
 218 static KWMModuleList *KWMModules = NULL;
 219
 220 static KWMModuleList *KWMDockWindows = NULL;
 221
 222 /* window decoration types */
 223 enum {
 224     KWMnoDecoration = 0,
 225     KWMnormalDecoration = 1,
 226     KWMtinyDecoration = 2,
 227     KWMnoFocus = 256,
 228     KWMstandaloneMenuBar = 512,
 229     KWMdesktopIcon = 1024,
 230     KWMstaysOnTop = 2048
 231 };
 232
 233
 234
 235 static Bool
 236 getSimpleHint(Window win, Atom atom, long *retval)
 237 {
 238     long *data = 0;
 239
 240     assert(atom!=0);
 241
 242     data = (long*)PropGetCheckProperty(win, atom, atom, 32, 1, NULL);
 243
 244     if (!data)
 245         return False;
 246
 247     *retval = *data;
 248
 249     XFree(data);
 250
 251     return True;
 252 }
 253
 254
 255
 256 static void
 257 setSimpleHint(Window win, Atom atom, long value)
 258 {
 259     assert(atom!=0);
 260     XChangeProperty(dpy, win, atom, atom,
 261                     32, PropModeReplace, (unsigned char*)&value, 1);
 262 }
 263
 264
 265 static void
 266 sendClientMessage(WScreen *scr, Window window, Atom atom, long value)
 267 {
 268     XEvent event;
 269     long mask = 0;
 270
 271     assert(atom!=0);
 272
 273     memset(&event, 0, sizeof(XEvent));
 274     event.xclient.type = ClientMessage;
 275     event.xclient.message_type = atom;
 276     event.xclient.window = window;
 277     event.xclient.format = 32;
 278     event.xclient.data.l[0] = value;
 279     event.xclient.data.l[1] = LastTimestamp;
 280
 281     if (scr && scr->root_win == window)
 282         mask = SubstructureRedirectMask;
 283
 284     XSendEvent(dpy, window, False, mask, &event);
 285 }
 286
 287
 288 static void
 289 sendTextMessage(WScreen *scr, Window window, Atom atom, char *text)
 290 {
 291     XEvent event;
 292     long mask = 0;
 293     int i;
 294
 295     assert(atom!=0);
 296
 297     memset(&event, 0, sizeof(XEvent));
 298     event.xclient.type = ClientMessage;
 299     event.xclient.message_type = atom;
 300     event.xclient.window = window;
 301     event.xclient.format = 8;
 302
 303     for (i=0; i<20 && text[i]; i++)
 304         event.xclient.data.b[i] = text[i];
 305
 306     if (scr && scr->root_win == window)
 307         mask = SubstructureRedirectMask;
 308
 309     XSendEvent(dpy, window, False, mask, &event);
 310 }
 311
 312
 313 static Bool
 314 getAreaHint(Window win, Atom atom, WArea *area)
 315 {
 316     long *data = 0;
 317
 318     data = (long*)PropGetCheckProperty(win, atom, atom, 32, 4, NULL);
 319
 320     if (!data)
 321         return False;
 322
 323     area->x1 = data[0];
 324     area->y1 = data[1];
 325     area->x2 = data[2] + area->x1;
 326     area->y2 = data[3] + area->y1;
 327
 328     XFree(data);
 329
 330     return True;
 331 }
 332
 333
 334 static void
 335 setAreaHint(Window win, Atom atom, WArea area)
 336 {
 337     long value[4];
 338
 339     assert(atom!=0);
 340     value[0] = area.x1;
 341     value[1] = area.y1;
 342     value[2] = area.x2 - area.x1;
 343     value[3] = area.y2 - area.y1;
 344     XChangeProperty(dpy, win, atom, atom, 32, PropModeReplace,
 345                     (unsigned char*)&value, 4);
 346 }
 347
 348
 349 static void
 350 addModule(WScreen *scr, Window window)
 351 {
 352     KWMModuleList *node;
 353     long val;
 354     WWindow *ptr;
 355
 356     node = malloc(sizeof(KWMModuleList));
 357     if (!node) {
 358         wwarning("out of memory while registering KDE module");
 359         return;
 360     }
 361
 362     node->next = KWMModules;
 363     node->window = window;
 364     KWMModules = node;
 365
 366     sendClientMessage(scr, window, _XA_KWM_MODULE_INIT, 0);
 367
 368     if (getSimpleHint(window, _XA_KWM_MODULE, &val) && val==2) {
 369         if (scr->kwm_dock != None) {
 370             setSimpleHint(window, _XA_KWM_MODULE, 1);
 371         } else {
 372             KWMModuleList *ptr;
 373
 374             scr->kwm_dock = window;
 375
 376             for (ptr = KWMDockWindows; ptr!=NULL; ptr = ptr->next) {
 377                 sendClientMessage(scr, scr->kwm_dock, _XA_KWM_MODULE_DOCKWIN_ADD,
 378                                   ptr->window);
 379             }
 380         }
 381     }
 382
 383     /* send list of windows */
 384     for (ptr = scr->focused_window; ptr!=NULL; ptr = ptr->prev) {
 385         if (!ptr->flags.kwm_hidden_for_modules
 386             && !WFLAGP(ptr, skip_window_list)) {
 387             sendClientMessage(scr, window, _XA_KWM_MODULE_WIN_ADD,
 388                               ptr->client_win);
 389         }
 390     }
 391
 392     /* send window stacking order */
 393     wKWMSendStacking(scr, window);
 394
 395     /* send focused window */
 396     if (scr->focused_window && scr->focused_window->flags.focused) {
 397         sendClientMessage(scr, window, _XA_KWM_MODULE_WIN_ACTIVATE,
 398                           scr->focused_window->client_win);
 399     }
 400
 401     /* tell who we are */
 402     sendTextMessage(scr, window, _XA_KWM_COMMAND, "wm:wmaker");
 403
 404
 405     sendClientMessage(scr, window, _XA_KWM_MODULE_INITIALIZED, 0);
 406 #ifdef DEBUG1
 407     KWMModules->title = NULL;
 408     XFetchName(dpy, window, &KWMModules->title);
 409     printf("NEW MODULE %s\n", KWMModules->title);
 410 #endif
 411 }
 412
 413
 414 static void
 415 removeModule(WScreen *scr, Window window)
 416 {
 417     KWMModuleList *next;
 418
 419     if (!KWMModules) {
 420         return;
 421     }
 422
 423     if (KWMModules->window == window) {
 424         next = KWMModules->next;
 425 #ifdef DEBUG1
 426         printf("REMOVING MODULE %s\n", KWMModules->title);
 427         if (KWMModules->title)
 428             XFree(KWMModules->title);
 429 #endif
 430         free(KWMModules);
 431         KWMModules = next;
 432     } else {
 433         KWMModuleList *ptr;
 434
 435         ptr = KWMModules;
 436         while (ptr->next) {
 437             if (ptr->next->window == window) {
 438                 next = ptr->next->next;
 439 #ifdef DEBUG1
 440                 printf("REMOVING MODULE %s\n", ptr->next->title);
 441                 if (ptr->next->title)
 442                     XFree(ptr->next->title);
 443 #endif
 444                 free(ptr->next);
 445                 ptr->next->next = next;
 446                 break;
 447             }
 448             ptr->next = ptr->next->next;
 449         }
 450     }
 451
 452     if (scr->kwm_dock == window)
 453         scr->kwm_dock = None;
 454 }
 455
 456
 457
 458 static void
 459 addDockWindow(WScreen *scr, Window window)
 460 {
 461     KWMModuleList *ptr;
 462
 463     for (ptr = KWMDockWindows; ptr != NULL; ptr = ptr->next) {
 464         if (ptr->window == window)
 465             break;
 466     }
 467     if (!ptr) {
 468         KWMModuleList *node;
 469
 470         node = malloc(sizeof(KWMModuleList));
 471         if (!node) {
 472             wwarning("out of memory while processing KDE dock window");
 473             return;
 474         }
 475         node->next = KWMDockWindows;
 476         KWMDockWindows = node;
 477         node->window = window;
 478         XSelectInput(dpy, window, StructureNotifyMask);
 479
 480         sendClientMessage(scr, scr->kwm_dock, _XA_KWM_MODULE_DOCKWIN_ADD,
 481                           window);
 482     }
 483 }
 484
 485
 486 static void
 487 removeDockWindow(WScreen *scr, Window window)
 488 {
 489     if (!KWMDockWindows)
 490         return;
 491
 492     if (KWMDockWindows->window == window) {
 493         KWMModuleList *next;
 494
 495         sendClientMessage(scr, scr->kwm_dock, _XA_KWM_MODULE_DOCKWIN_REMOVE,
 496                           window);
 497
 498         next = KWMDockWindows->next;
 499         free(KWMDockWindows);
 500         KWMDockWindows = next;
 501
 502     } else {
 503         KWMModuleList *ptr, *next;
 504
 505         ptr = KWMDockWindows;
 506         while (ptr->next) {
 507             if (ptr->next->window == window) {
 508                 sendClientMessage(scr, scr->kwm_dock,
 509                                   _XA_KWM_MODULE_DOCKWIN_REMOVE, window);
 510                 next = ptr->next->next;
 511                 free(ptr->next);
 512                 ptr->next = next;
 513                 return;
 514             }
 515             ptr = ptr->next;
 516         }
 517     }
 518 }
 519
 520
 521 static void
 522 sendToModules(WScreen *scr, Atom atom, WWindow *wwin, long data)
 523 {
 524     KWMModuleList *ptr;
 525     XEvent event;
 526     long mask;
 527
 528     if (wwin) {
 529         if (wwin->flags.kwm_hidden_for_modules
 530             || WFLAGP(wwin, skip_window_list))
 531             return;
 532         data = wwin->client_win;
 533     }
 534 #ifdef DEBUG1
 535     printf("notifying %s\n",XGetAtomName(dpy, atom));
 536 #endif
 537     memset(&event, 0, sizeof(XEvent));
 538     event.xclient.type = ClientMessage;
 539     event.xclient.message_type = atom;
 540     event.xclient.format = 32;
 541     event.xclient.data.l[1] = LastTimestamp;
 542
 543     mask = 0;
 544     if (scr && scr->root_win == data)
 545         mask = SubstructureRedirectMask;
 546
 547     for (ptr = KWMModules; ptr!=NULL; ptr = ptr->next) {
 548         event.xclient.window = ptr->window;
 549         event.xclient.data.l[0] = data;
 550         XSendEvent(dpy, ptr->window, False, mask, &event);
 551     }
 552 }
 553
 554
 555 void
 556 wKWMInitStuff(WScreen *scr)
 557 {
 558     if (!_XA_KWM_WIN_STICKY) {
 559         _XA_KWM_WIN_UNSAVED_DATA = XInternAtom(dpy, "KWM_WIN_UNSAVED_DATA",
 560                                                False);
 561
 562         _XA_KWM_WIN_DECORATION = XInternAtom(dpy, "KWM_WIN_DECORATION", False);
 563
 564         _XA_KWM_WIN_DESKTOP = XInternAtom(dpy, "KWM_WIN_DESKTOP", False);
 565
 566         _XA_KWM_WIN_GEOMETRY_RESTORE = XInternAtom(dpy,
 567                                                    "KWM_WIN_GEOMETRY_RESTORE",
 568                                                    False);
 569
 570         _XA_KWM_WIN_STICKY = XInternAtom(dpy, "KWM_WIN_STICKY", False);
 571
 572         _XA_KWM_WIN_ICONIFIED = XInternAtom(dpy, "KWM_WIN_ICONIFIED", False);
 573
 574         _XA_KWM_WIN_MAXIMIZED = XInternAtom(dpy, "KWM_WIN_MAXIMIZED", False);
 575
 576         _XA_KWM_WIN_ICON_GEOMETRY = XInternAtom(dpy, "KWM_WIN_ICON_GEOMETRY",
 577                                                 False);
 578
 579         _XA_KWM_COMMAND = XInternAtom(dpy, "KWM_COMMAND", False);
 580
 581         _XA_KWM_ACTIVE_WINDOW = XInternAtom(dpy, "KWM_ACTIVE_WINDOW", False);
 582
 583         _XA_KWM_ACTIVATE_WINDOW = XInternAtom(dpy, "KWM_ACTIVATE_WINDOW",
 584                                               False);
 585
 586         _XA_KWM_DO_NOT_MANAGE = XInternAtom(dpy, "KWM_DO_NOT_MANAGE", False);
 587
 588         _XA_KWM_CURRENT_DESKTOP = XInternAtom(dpy, "KWM_CURRENT_DESKTOP",
 589                                               False);
 590
 591         _XA_KWM_NUMBER_OF_DESKTOPS = XInternAtom(dpy, "KWM_NUMBER_OF_DESKTOPS",
 592                                                  False);
 593
 594         _XA_KWM_DOCKWINDOW = XInternAtom(dpy, "KWM_DOCKWINDOW", False);
 595
 596         _XA_KWM_RUNNING = XInternAtom(dpy, "KWM_RUNNING", False);
 597
 598         _XA_KWM_MODULE = XInternAtom(dpy, "KWM_MODULE", False);
 599
 600         _XA_KWM_MODULE_INIT = XInternAtom(dpy, "KWM_MODULE_INIT", False);
 601         _XA_KWM_MODULE_INITIALIZED = XInternAtom(dpy, "KWM_MODULE_INITIALIZED", False);
 602
 603         /* dunno what these do, but Matthias' patch contains it... */
 604         _XA_KWM_MODULE_DESKTOP_CHANGE = XInternAtom(dpy, "KWM_MODULE_DESKTOP_CHANGE", False);
 605         _XA_KWM_MODULE_DESKTOP_NAME_CHANGE = XInternAtom(dpy, "KWM_MODULE_DESKTOP_NAME_CHANGE", False);
 606         _XA_KWM_MODULE_DESKTOP_NUMBER_CHANGE = XInternAtom(dpy, "KWM_MODULE_DESKTOP_NUMBER_CHANGE", False);
 607
 608         _XA_KWM_MODULE_WIN_ADD = XInternAtom(dpy, "KWM_MODULE_WIN_ADD", False);
 609         _XA_KWM_MODULE_WIN_REMOVE = XInternAtom(dpy, "KWM_MODULE_WIN_REMOVE", False);
 610         _XA_KWM_MODULE_WIN_CHANGE = XInternAtom(dpy, "KWM_MODULE_WIN_CHANGE", False);
 611         _XA_KWM_MODULE_WIN_RAISE = XInternAtom(dpy, "KWM_MODULE_WIN_RAISE", False);
 612         _XA_KWM_MODULE_WIN_LOWER = XInternAtom(dpy, "KWM_MODULE_WIN_LOWER", False);
 613         _XA_KWM_MODULE_WIN_ACTIVATE = XInternAtom(dpy, "KWM_MODULE_WIN_ACTIVATE", False);
 614         _XA_KWM_MODULE_WIN_ICON_CHANGE = XInternAtom(dpy, "KWM_MODULE_WIN_ICON_CHANGE", False);
 615         _XA_KWM_MODULE_DOCKWIN_ADD = XInternAtom(dpy, "KWM_MODULE_DOCKWIN_ADD", False);
 616         _XA_KWM_MODULE_DOCKWIN_REMOVE = XInternAtom(dpy, "KWM_MODULE_DOCKWIN_REMOVE", False);
 617
 618         memset(_XA_KWM_WINDOW_REGION_, 0, sizeof(_XA_KWM_WINDOW_REGION_));
 619
 620         memset(_XA_KWM_DESKTOP_NAME_, 0, sizeof(_XA_KWM_DESKTOP_NAME_));
 621     }
 622
 623 #define SETSTR(hint, str) {\
 624         static Atom a = 0; if (!a) a = XInternAtom(dpy, #hint, False);\
 625         XChangeProperty(dpy, scr->root_win, a, XA_STRING, 8, PropModeReplace,\
 626                     (unsigned char*)str, strlen(str));}
 627
 628     SETSTR(KWM_STRING_MAXIMIZE, _("Maximize"));
 629     SETSTR(KWM_STRING_UNMAXIMIZE, _("Unmaximize"));
 630     SETSTR(KWM_STRING_ICONIFY, _("Miniaturize"));
 631     SETSTR(KWM_STRING_UNICONIFY, _("Deminiaturize"));
 632     SETSTR(KWM_STRING_STICKY, _("Omnipresent"));
 633     SETSTR(KWM_STRING_UNSTICKY, _("Not Omnipresent"));
 634     SETSTR(KWM_STRING_STRING_MOVE, _("Move"));
 635     SETSTR(KWM_STRING_STRING_RESIZE, _("Resize"));
 636     SETSTR(KWM_STRING_CLOSE, _("Close"));
 637     SETSTR(KWM_STRING_TODESKTOP, _("Move To"));
 638     SETSTR(KWM_STRING_ONTOCURRENTDESKTOP, _("Bring Here"));
 639 #undef SETSTR
 640 }
 641
 642
 643 void
 644 wKWMSendStacking(WScreen *scr, Window module)
 645 {
 646     int i;
 647     WCoreWindow *core;
 648
 649     for (i = 0; i < MAX_WINDOW_LEVELS; i++) {
 650         for (core = scr->stacking_list[i]; core != NULL;
 651              core = core->stacking->under) {
 652             WWindow *wwin;
 653
 654             wwin = wWindowFor(core->window);
 655             if (wwin)
 656                 sendClientMessage(scr, module, _XA_KWM_MODULE_WIN_RAISE,
 657                                   wwin->client_win);
 658         }
 659     }
 660 }
 661
 662
 663 void
 664 wKWMBroadcastStacking(WScreen *scr)
 665 {
 666     KWMModuleList *ptr = KWMModules;
 667
 668     while (ptr) {
 669         wKWMSendStacking(scr, ptr->window);
 670
 671         ptr = ptr->next;
 672     }
 673 }
 674
 675
 676 char*
 677 wKWMGetWorkspaceName(WScreen *scr, int workspace)
 678 {
 679     Atom type_ret;
 680     int fmt_ret;
 681     unsigned long nitems_ret;
 682     unsigned long bytes_after_ret;
 683     char *data = NULL, *tmp;
 684     char buffer[64];
 685
 686     assert(workspace >= 0 && workspace < MAX_WORKSPACES);
 687
 688     if (_XA_KWM_DESKTOP_NAME_[workspace]==0) {
 689         sprintf(buffer, "KWM_DESKTOP_NAME_%d", workspace + 1);
 690
 691         _XA_KWM_DESKTOP_NAME_[workspace] = XInternAtom(dpy, buffer, False);
 692     }
 693
 694     /* What do these people have against correctly using property types? */
 695     if (XGetWindowProperty(dpy, scr->root_win,
 696                            _XA_KWM_DESKTOP_NAME_[workspace], 0, 128, False,
 697                            XA_STRING,
 698                            &type_ret, &fmt_ret, &nitems_ret, &bytes_after_ret,
 699                            (unsigned char**)&data)!=Success || !data)
 700         return NULL;
 701
 702     tmp = wstrdup(data);
 703     XFree(data);
 704
 705     return tmp;
 706 }
 707
 708
 709 void
 710 wKWMSetInitializedHint(WScreen *scr)
 711 {
 712     setSimpleHint(scr->root_win, _XA_KWM_RUNNING, 1);
 713 }
 714
 715
 716 void
 717 wKWMShutdown(WScreen *scr, Bool closeModules)
 718 {
 719     KWMModuleList *ptr;
 720
 721     XDeleteProperty(dpy, scr->root_win, _XA_KWM_RUNNING);
 722
 723     if (closeModules) {
 724         for (ptr = KWMModules; ptr != NULL; ptr = ptr->next) {
 725             XKillClient(dpy, ptr->window);
 726         }
 727     }
 728 }
 729
 730
 731 void
 732 wKWMCheckClientHints(WWindow *wwin, int *layer, int *workspace)
 733 {
 734     long val;
 735
 736     if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_UNSAVED_DATA, &val)
 737         && val) {
 738
 739         wwin->client_flags.broken_close = 1;
 740     }
 741     if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_DECORATION, &val)) {
 742         if (val & KWMnoFocus) {
 743             wwin->client_flags.no_focusable = 1;
 744         }
 745         switch (val & ~KWMnoFocus) {
 746          case KWMnoDecoration:
 747             wwin->client_flags.no_titlebar = 1;
 748             wwin->client_flags.no_resizebar = 1;
 749             break;
 750          case KWMtinyDecoration:
 751             wwin->client_flags.no_resizebar = 1;
 752             break;
 753          case KWMstandaloneMenuBar:
 754             wwin->client_flags.no_titlebar = 1;
 755             wwin->client_flags.no_resizebar = 1;
 756             wwin->client_flags.no_resizable = 1;
 757             wwin->client_flags.skip_window_list = 1;
 758             wwin->client_flags.no_hide_others = 1;
 759             wwin->flags.kwm_menubar = 1;
 760             *layer = WMMainMenuLevel;
 761             break;
 762          case KWMdesktopIcon:
 763             *layer = WMDesktopLevel;
 764             break;
 765          case KWMstaysOnTop:
 766             *layer = WMFloatingLevel;
 767             break;
 768          case KWMnormalDecoration:
 769          default:
 770             break;
 771         }
 772     }
 773     if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_DESKTOP, &val)) {
 774         *workspace = val - 1;
 775     }
 776 }
 777
 778
 779 void
 780 wKWMCheckClientInitialState(WWindow *wwin)
 781 {
 782     long val;
 783     WArea area;
 784
 785     if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_STICKY, &val) && val) {
 786
 787         wwin->client_flags.omnipresent = 1;
 788     }
 789     if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_ICONIFIED, &val) && val) {
 790
 791         wwin->flags.miniaturized = 1;
 792     }
 793     if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_MAXIMIZED, &val) && val) {
 794
 795         wwin->flags.maximized = MAX_VERTICAL|MAX_HORIZONTAL;
 796     }
 797     if (getAreaHint(wwin->client_win, _XA_KWM_WIN_GEOMETRY_RESTORE, &area)
 798         && (wwin->old_geometry.x != area.x1
 799             || wwin->old_geometry.y != area.y1
 800             || wwin->old_geometry.width != area.x2 - area.x1
 801             || wwin->old_geometry.height != area.y2 - area.y1)) {
 802
 803         wwin->old_geometry.x = area.x1;
 804         wwin->old_geometry.y = area.y1;
 805         wwin->old_geometry.width = area.x2 - area.x1;
 806         wwin->old_geometry.height = area.y2 - area.y1;
 807     }
 808 }
 809
 810
 811 Bool
 812 wKWMCheckClientHintChange(WWindow *wwin, XPropertyEvent *event)
 813 {
 814     Bool processed = True;
 815     Bool flag;
 816     long value;
 817
 818
 819     if (!wwin->frame) {
 820         return False;
 821     }
 822
 823     if (event->atom == _XA_KWM_WIN_UNSAVED_DATA) {
 824 #ifdef DEBUG1
 825         printf("got KDE unsaved data change\n");
 826 #endif
 827
 828         flag = getSimpleHint(wwin->client_win, _XA_KWM_WIN_UNSAVED_DATA,
 829                              &value) && value;
 830
 831         if (flag != wwin->client_flags.broken_close) {
 832             wwin->client_flags.broken_close = flag;
 833             if (wwin->frame)
 834                 wWindowUpdateButtonImages(wwin);
 835         }
 836     } else if (event->atom == _XA_KWM_WIN_STICKY) {
 837
 838 #ifdef DEBUG1
 839         printf("got KDE sticky change\n");
 840 #endif
 841         flag = !getSimpleHint(wwin->client_win, _XA_KWM_WIN_STICKY,
 842                               &value) || value;
 843
 844         if (flag != wwin->client_flags.omnipresent) {
 845
 846             wwin->client_flags.omnipresent = flag;
 847
 848             UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_WORKSPACE);
 849
 850         }
 851     } else if (event->atom == _XA_KWM_WIN_MAXIMIZED) {
 852
 853 #ifdef DEBUG1
 854         printf("got KDE maximize change\n");
 855 #endif
 856         flag = !getSimpleHint(wwin->client_win, _XA_KWM_WIN_MAXIMIZED,
 857                              &value) || value;
 858
 859         if (flag != (wwin->flags.maximized!=0)) {
 860
 861             if (flag)
 862                 wMaximizeWindow(wwin, flag*(MAX_VERTICAL|MAX_HORIZONTAL));
 863             else
 864                 wUnmaximizeWindow(wwin);
 865         }
 866     } else if (event->atom == _XA_KWM_WIN_ICONIFIED) {
 867
 868 #ifdef DEBUG1
 869         printf("got KDE iconify change\n");
 870 #endif
 871         flag = !getSimpleHint(wwin->client_win, _XA_KWM_WIN_ICONIFIED,
 872                              &value) || value;
 873
 874         if (flag != wwin->flags.miniaturized) {
 875
 876             if (flag)
 877                 wIconifyWindow(wwin);
 878             else
 879                 wDeiconifyWindow(wwin);
 880         }
 881
 882     } else if (event->atom == _XA_KWM_WIN_DECORATION) {
 883         Bool refresh = False;
 884         int oldnofocus;
 885
 886 #ifdef DEBUG1
 887         printf("got KDE decoration change\n");
 888 #endif
 889
 890         oldnofocus = wwin->client_flags.no_focusable;
 891
 892         if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_DECORATION, &value)) {
 893             wwin->client_flags.no_focusable = (value & KWMnoFocus)!=0;
 894
 895             switch (value & ~KWMnoFocus) {
 896              case KWMnoDecoration:
 897                 if (!WFLAGP(wwin, no_titlebar) || !WFLAGP(wwin, no_resizebar))
 898                     refresh = True;
 899
 900                 wwin->client_flags.no_titlebar = 1;
 901                 wwin->client_flags.no_resizebar = 1;
 902                 break;
 903
 904              case KWMtinyDecoration:
 905                 if (WFLAGP(wwin, no_titlebar) || !WFLAGP(wwin, no_resizebar))
 906                     refresh = True;
 907
 908                 wwin->client_flags.no_titlebar = 0;
 909                 wwin->client_flags.no_resizebar = 1;
 910                 break;
 911
 912              case KWMnormalDecoration:
 913              default:
 914                 if (WFLAGP(wwin, no_titlebar) || WFLAGP(wwin, no_resizebar))
 915                     refresh = True;
 916
 917                 wwin->client_flags.no_titlebar = 0;
 918                 wwin->client_flags.no_resizebar = 0;
 919                 break;
 920             }
 921         } else {
 922             if (WFLAGP(wwin, no_titlebar) || WFLAGP(wwin, no_resizebar))
 923                 refresh = True;
 924             wwin->client_flags.no_focusable = (value & KWMnoFocus)!=0;
 925             wwin->client_flags.no_titlebar = 0;
 926             wwin->client_flags.no_resizebar = 0;
 927         }
 928
 929         if (refresh)
 930             wWindowConfigureBorders(wwin);
 931
 932         if (wwin->client_flags.no_focusable && !oldnofocus) {
 933
 934             sendToModules(wwin->screen_ptr, _XA_KWM_MODULE_WIN_REMOVE,
 935                           wwin, 0);
 936             wwin->flags.kwm_hidden_for_modules = 1;
 937
 938         } else if (!wwin->client_flags.no_focusable && oldnofocus) {
 939
 940             if (wwin->flags.kwm_hidden_for_modules) {
 941                 sendToModules(wwin->screen_ptr, _XA_KWM_MODULE_WIN_ADD,
 942                               wwin, 0);
 943                 wwin->flags.kwm_hidden_for_modules = 0;
 944             }
 945         }
 946     } else if (event->atom == _XA_KWM_WIN_DESKTOP && wwin->frame) {
 947 #ifdef DEBUG1
 948         printf("got KDE workspace change for %s\n", wwin->frame->title);
 949 #endif
 950         if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_DESKTOP, &value)
 951             && value-1 != wwin->frame->workspace) {
 952             wWindowChangeWorkspace(wwin, value-1);
 953         }
 954
 955     } else if (event->atom == _XA_KWM_WIN_GEOMETRY_RESTORE) {
 956         WArea area;
 957
 958 #ifdef DEBUG1
 959         printf("got KDE geometry restore change\n");
 960 #endif
 961         if (getAreaHint(wwin->client_win, _XA_KWM_WIN_GEOMETRY_RESTORE, &area)
 962             && (wwin->old_geometry.x != area.x1
 963                 || wwin->old_geometry.y != area.y1
 964                 || wwin->old_geometry.width != area.x2 - area.x1
 965                 || wwin->old_geometry.height != area.y2 - area.y1)) {
 966
 967                 wwin->old_geometry.x = area.x1;
 968                 wwin->old_geometry.y = area.y1;
 969                 wwin->old_geometry.width = area.x2 - area.x1;
 970                 wwin->old_geometry.height = area.y2 - area.y1;
 971             }
 972     } else {
 973         processed = False;
 974     }
 975
 976     return processed;
 977 }
 978
 979
 980 static Bool
 981 performWindowCommand(WScreen *scr, char *command)
 982 {
 983     WWindow *wwin = NULL;
 984
 985
 986     wwin = scr->focused_window;
 987     if (!wwin || !wwin->flags.focused || !wwin->flags.mapped) {
 988         wwin = NULL;
 989     }
 990
 991     CloseWindowMenu(scr);
 992
 993
 994     if (strcmp(command, "winMove")==0 || strcmp(command, "winResize")==0) {
 995
 996         if (wwin)
 997             wKeyboardMoveResizeWindow(wwin);
 998
 999     } else if (strcmp(command, "winMaximize")==0) {
1000
1001         if (wwin)
1002             wMaximizeWindow(wwin, MAX_VERTICAL|MAX_HORIZONTAL);
1003
1004     } else if (strcmp(command, "winRestore")==0) {
1005
1006         if (wwin && wwin->flags.maximized)
1007             wUnmaximizeWindow(wwin);
1008
1009     } else if (strcmp(command, "winIconify")==0) {
1010
1011
1012         if (wwin && !WFLAGP(wwin, no_miniaturizable)) {
1013             if (wwin->protocols.MINIATURIZE_WINDOW)
1014                 wClientSendProtocol(wwin, _XA_GNUSTEP_WM_MINIATURIZE_WINDOW,
1015                                     LastTimestamp);
1016             else {
1017                 wIconifyWindow(wwin);
1018             }
1019         }
1020
1021     } else if (strcmp(command, "winClose")==0) {
1022
1023         if (wwin && !WFLAGP(wwin, no_closable)) {
1024             if (wwin->protocols.DELETE_WINDOW)
1025                 wClientSendProtocol(wwin, _XA_WM_DELETE_WINDOW, LastTimestamp);
1026         }
1027
1028     } else if (strcmp(command, "winSticky")==0) {
1029
1030         if (wwin) {
1031             wwin->client_flags.omnipresent ^= 1;
1032             UpdateSwitchMenu(scr, wwin, ACTION_CHANGE_WORKSPACE);
1033         }
1034
1035     } else if (strcmp(command, "winShade")==0) {
1036
1037         if (wwin && !WFLAGP(wwin, no_shadeable)) {
1038             if (wwin->flags.shaded)
1039                 wUnshadeWindow(wwin);
1040             else
1041                 wShadeWindow(wwin);
1042         }
1043
1044     } else if (strcmp(command, "winOperation")==0) {
1045
1046         if (wwin)
1047             OpenWindowMenu(wwin, wwin->frame_x,
1048                            wwin->frame_y+wwin->frame->top_width, True);
1049
1050     } else {
1051         return False;
1052     }
1053
1054     return True;
1055 }
1056
1057
1058 static void
1059 performCommand(WScreen *scr, char *command, XClientMessageEvent *event)
1060 {
1061     assert(scr != NULL);
1062
1063     if (strcmp(command, "commandLine")==0
1064        || strcmp(command, "execute")==0) {
1065         char *cmd;
1066
1067         cmd = ExpandOptions(scr, _("%a(Run Command,Type the command to run:)"));
1068         if (cmd) {
1069             ExecuteShellCommand(scr, cmd);
1070             free(cmd);
1071         }
1072     } else if (strcmp(command, "logout")==0) {
1073
1074         Shutdown(WSLogoutMode);
1075
1076     } else if (strcmp(command, "refreshScreen")==0) {
1077
1078         wRefreshDesktop(scr);
1079
1080     } else if (strncmp(command, "go:", 3)==0) {
1081
1082         Shutdown(WSRestartPreparationMode);
1083         Restart(&command[3], False);
1084         Restart(NULL, True);
1085
1086     } else if (strcmp(command, "desktop+1")==0) {
1087
1088         wWorkspaceRelativeChange(scr, 1);
1089
1090     } else if (strcmp(command, "desktop-1")==0) {
1091
1092         wWorkspaceRelativeChange(scr, -1);
1093
1094     } else if (strcmp(command, "desktop+2")==0) {
1095
1096         wWorkspaceRelativeChange(scr, 2);
1097
1098     } else if (strcmp(command, "desktop-2")==0) {
1099
1100         wWorkspaceRelativeChange(scr, -2);
1101
1102     } else if (strcmp(command, "desktop%%2")==0) {
1103
1104         if (scr->current_workspace % 2 == 1)
1105             wWorkspaceRelativeChange(scr, 1);
1106         else
1107             wWorkspaceRelativeChange(scr, -1);
1108     } else if (strncmp(command, "desktop", 7)==0) {
1109         int ws;
1110
1111         ws = atoi(&command[7]);
1112         wWorkspaceChange(scr, ws);
1113
1114         /* wmaker specific stuff */
1115     } else if (strcmp(command, "wmaker:info")==0) {
1116
1117         wShowInfoPanel(scr);
1118
1119     } else if (strcmp(command, "wmaker:legal")==0) {
1120
1121         wShowLegalPanel(scr);
1122
1123     } else if (strcmp(command, "wmaker:arrangeIcons")==0) {
1124
1125         wArrangeIcons(scr, True);
1126
1127     } else if (strcmp(command, "wmaker:showAll")==0) {
1128
1129         wShowAllWindows(scr);
1130
1131     } else if (strcmp(command, "wmaker:hideOthers")==0) {
1132
1133         wHideOtherApplications(scr->focused_window);
1134
1135     } else if (strcmp(command, "wmaker:restart")==0) {
1136
1137         Shutdown(WSRestartPreparationMode);
1138         Restart(NULL, True);
1139
1140     } else if (strcmp(command, "wmaker:exit")==0) {
1141
1142         Shutdown(WSExitMode);
1143
1144 #ifdef UNSUPPORTED_STUFF
1145     } else if (strcmp(command, "moduleRaised")==0) { /* useless */
1146     } else if (strcmp(command, "deskUnclutter")==0) {
1147     } else if (strcmp(command, "deskCascade")==0) {
1148     } else if (strcmp(command, "configure")==0) {
1149     } else if (strcmp(command, "taskManager")==0) {
1150     } else if (strcmp(command, "darkenScreen")==0) { /* breaks consistency */
1151 #endif
1152     } else if (!performWindowCommand(scr, command)) {
1153         KWMModuleList *module;
1154         long mask = 0;
1155         XEvent ev;
1156         /* do message relay thing */
1157
1158         ev.xclient = *event;
1159         for (module = KWMModules; module != NULL; module = module->next) {
1160
1161             ev.xclient.window = module->window;
1162             if (module->window == scr->root_win)
1163                 mask = SubstructureRedirectMask;
1164             else
1165                 mask = 0;
1166
1167             XSendEvent(dpy, module->window, False, mask, &ev);
1168         }
1169     }
1170 }
1171
1172
1173 Bool
1174 wKWMProcessClientMessage(XClientMessageEvent *event)
1175 {
1176     Bool processed = True;
1177     WScreen *scr;
1178 #ifdef DEBUG1
1179     printf("CLIENT MESS %s\n", XGetAtomName(dpy, event->message_type));
1180 #endif
1181     if (event->message_type == _XA_KWM_COMMAND && event->format==8) {
1182         char buffer[24];
1183         int i;
1184
1185         scr = wScreenForRootWindow(event->window);
1186
1187         for (i=0; i<20; i++) {
1188             buffer[i] = event->data.b[i];
1189         }
1190         buffer[i] = 0;
1191
1192 #ifdef DEBUG1
1193         printf("got KDE command %s\n", buffer);
1194 #endif
1195         performCommand(scr, buffer, event);
1196
1197     } else if (event->message_type == _XA_KWM_ACTIVATE_WINDOW) {
1198         WWindow *wwin;
1199
1200 #ifdef DEBUG1
1201         printf("got KDE activate internal\n");
1202 #endif
1203         wwin = wWindowFor(event->data.l[0]);
1204
1205         if (wwin)
1206             wSetFocusTo(wwin->screen_ptr, wwin);
1207
1208     } else if (event->message_type == _XA_KWM_DO_NOT_MANAGE
1209                && event->format == 8) {
1210         KWMDoNotManageList *node;
1211         int i;
1212
1213 #ifdef DEBUG1
1214         printf("got KDE dont manage\n");
1215 #endif
1216
1217         node = malloc(sizeof(KWMDoNotManageList));
1218         if (!node) {
1219             wwarning("out of memory processing KWM_DO_NOT_MANAGE message");
1220         }
1221         for (i=0; i<20 && event->data.b[i]; i++)
1222             node->title[i] = event->data.b[i];
1223         node->title[i] = 0;
1224
1225         node->next = KWMDoNotManageCrap;
1226         KWMDoNotManageCrap = node;
1227
1228     } else if (event->message_type == _XA_KWM_MODULE) {
1229         long val;
1230         Window modwin = event->data.l[0];
1231
1232         scr = wScreenForRootWindow(event->window);
1233
1234         if (getSimpleHint(modwin, _XA_KWM_MODULE, &val) && val) {
1235 #ifdef DEBUG1
1236             puts("got KDE module startup");
1237 #endif
1238             addModule(scr, modwin);
1239         } else {
1240 #ifdef DEBUG1
1241             puts("got KDE module finish");
1242 #endif
1243             removeModule(scr, modwin);
1244         }
1245     } else {
1246         processed = False;
1247     }
1248
1249     return processed;
1250 }
1251
1252
1253 void
1254 wKWMCheckModule(WScreen *scr, Window window)
1255 {
1256     long val;
1257
1258     if (getSimpleHint(window, _XA_KWM_MODULE, &val) && val) {
1259 #ifdef DEBUG1
1260         puts("got KDE module startup");
1261 #endif
1262         addModule(scr, window);
1263     }
1264 }
1265
1266
1267 Bool
1268 wKWMCheckRootHintChange(WScreen *scr, XPropertyEvent *event)
1269 {
1270     Bool processed = True;
1271     long value;
1272
1273     if (event->atom == _XA_KWM_CURRENT_DESKTOP) {
1274         if (getSimpleHint(scr->root_win, _XA_KWM_CURRENT_DESKTOP, &value)) {
1275 #ifdef DEBUG1
1276             printf("got KDE workspace switch to %li\n", value);
1277 #endif
1278             if (value-1 != scr->current_workspace) {
1279                 wWorkspaceChange(scr, value-1);
1280             }
1281         }
1282     } else if (event->atom == _XA_KWM_NUMBER_OF_DESKTOPS) {
1283 #ifdef DEBUG1
1284             printf("got KDE workspace number change\n");
1285 #endif
1286
1287         if (getSimpleHint(scr->root_win, _XA_KWM_NUMBER_OF_DESKTOPS, &value)) {
1288
1289             /* increasing is easy... */
1290             if (value > scr->workspace_count) {
1291                 scr->flags.kwm_syncing_count = 1;
1292
1293                 wWorkspaceMake(scr, value - scr->workspace_count);
1294
1295                 scr->flags.kwm_syncing_count = 0;
1296
1297             } else if (value < scr->workspace_count) {
1298                 int i;
1299                 Bool rebuild = False;
1300
1301                 scr->flags.kwm_syncing_count = 1;
1302
1303                 /* decrease all we can do */
1304                 for (i = scr->workspace_count; i >= value; i--) {
1305                     if (!wWorkspaceDelete(scr, i)) {
1306                         rebuild = True;
1307                         break;
1308                     }
1309                 }
1310
1311                 scr->flags.kwm_syncing_count = 0;
1312
1313                 /* someone destroyed a workspace that can't be destroyed.
1314                  * Reset the hints to reflect our internal state.
1315                  */
1316                 if (rebuild) {
1317                     wKWMUpdateWorkspaceCountHint(scr);
1318                 }
1319             }
1320         }
1321     } else {
1322         int i;
1323
1324         processed = False;
1325
1326         for (i = 0; i < MAX_WORKSPACES && i < scr->workspace_count; i++) {
1327              if (event->atom == _XA_KWM_DESKTOP_NAME_[i]) {
1328                  char *name;
1329
1330                  name = wKWMGetWorkspaceName(scr, i);
1331
1332 #ifdef DEBUG1
1333                  printf("got KDE workspace name change to %s\n", name);
1334 #endif
1335
1336                  if (name && strncmp(name, scr->workspaces[i]->name,
1337                                      MAX_WORKSPACENAME_WIDTH)!=0) {
1338                      scr->flags.kwm_syncing_name = 1;
1339                      wWorkspaceRename(scr, i, name);
1340                      scr->flags.kwm_syncing_name = 0;
1341                  }
1342                  if (name)
1343                      XFree(name);
1344                  processed = True;
1345                  break;
1346              } else if (event->atom == _XA_KWM_WINDOW_REGION_[i]) {
1347                  WArea area;
1348
1349                  if (getAreaHint(scr->root_win, event->atom, &area)) {
1350
1351                      if (scr->totalUsableArea.x1 != area.x1
1352                          || scr->totalUsableArea.y1 != area.y1
1353                          || scr->totalUsableArea.x2 != area.x2
1354                          || scr->totalUsableArea.y2 != area.y2) {
1355                          wScreenUpdateUsableArea(scr);
1356                      }
1357                  }
1358
1359                  processed = True;
1360                  break;
1361              }
1362         }
1363     }
1364
1365     return processed;
1366 }
1367
1368
1369 Bool
1370 wKWMManageableClient(WScreen *scr, Window win, char *title)
1371 {
1372     KWMDoNotManageList *ptr, *next;
1373     long val;
1374
1375     if (getSimpleHint(win, _XA_KWM_DOCKWINDOW, &val) && val) {
1376         addDockWindow(scr, win);
1377         return False;
1378     }
1379
1380     ptr = KWMDoNotManageCrap;
1381     /*
1382      * TODO: support for glob patterns or regexes
1383      */
1384     if (ptr && strncmp(ptr->title, title, strlen(ptr->title))==0) {
1385         next = ptr->next;
1386         free(ptr);
1387         KWMDoNotManageCrap = next;
1388 #ifdef DEBUG1
1389         printf("window %s not managed per KDE request\n", title);
1390 #endif
1391
1392         sendToModules(scr, _XA_KWM_MODULE_WIN_ADD, NULL, win);
1393         sendToModules(scr, _XA_KWM_MODULE_WIN_REMOVE, NULL, win);
1394
1395         return False;
1396     } else if (ptr) {
1397         while (ptr->next) {
1398             if (strncmp(ptr->next->title, title, strlen(ptr->next->title))==0) {
1399 #ifdef DEBUG1
1400                 printf("window %s not managed per KDE request\n", title);
1401 #endif
1402                 next = ptr->next->next;
1403                 free(ptr->next);
1404                 ptr->next = next;
1405
1406                 sendToModules(scr, _XA_KWM_MODULE_WIN_ADD, NULL, win);
1407                 sendToModules(scr, _XA_KWM_MODULE_WIN_REMOVE, NULL, win);
1408
1409                 return False;
1410             }
1411
1412             ptr = ptr->next;
1413         }
1414     }
1415
1416     return True;
1417 }
1418
1419
1420 void
1421 wKWMUpdateCurrentWorkspaceHint(WScreen *scr)
1422 {
1423     setSimpleHint(scr->root_win, _XA_KWM_CURRENT_DESKTOP,
1424                   scr->current_workspace+1);
1425
1426     sendToModules(scr, _XA_KWM_MODULE_DESKTOP_CHANGE, NULL,
1427                   scr->current_workspace+1);
1428 }
1429
1430
1431 void
1432 wKWMUpdateActiveWindowHint(WScreen *scr)
1433 {
1434     long val;
1435     WWindow *wwin, *tmp;
1436
1437     if (!scr->focused_window || !scr->focused_window->flags.focused)
1438         val = None;
1439     else {
1440         val = (long)(scr->focused_window->client_win);
1441
1442         /* raise the menubar thing */
1443         wwin = scr->focused_window;
1444         tmp = wwin->prev;
1445         while (tmp) {
1446             if (tmp->flags.kwm_menubar
1447                 && tmp->transient_for == wwin->client_win) {
1448                 wRaiseFrame(tmp->frame->core);
1449                 break;
1450             }
1451             tmp = tmp->prev;
1452         }
1453     }
1454
1455     XChangeProperty(dpy, scr->root_win, _XA_KWM_ACTIVE_WINDOW,
1456                     _XA_KWM_ACTIVE_WINDOW, 32, PropModeReplace,
1457                     (unsigned char*)&val, 1);
1458     XFlush(dpy);
1459 }
1460
1461
1462 void
1463 wKWMUpdateWorkspaceCountHint(WScreen *scr)
1464 {
1465     if (scr->flags.kwm_syncing_count)
1466         return;
1467
1468     setSimpleHint(scr->root_win, _XA_KWM_NUMBER_OF_DESKTOPS,
1469                   scr->workspace_count);
1470
1471     sendToModules(scr, _XA_KWM_MODULE_DESKTOP_NUMBER_CHANGE, NULL,
1472                   scr->workspace_count);
1473 }
1474
1475
1476 void
1477 wKWMCheckDestroy(XDestroyWindowEvent *event)
1478 {
1479     WScreen *scr;
1480
1481     if (event->event == event->window) {
1482         return;
1483     }
1484
1485     scr = wScreenSearchForRootWindow(event->event);
1486     if (!scr) {
1487         return;
1488     }
1489
1490     removeModule(scr, event->window);
1491     removeDockWindow(scr, event->window);
1492 }
1493
1494
1495 void
1496 wKWMUpdateWorkspaceNameHint(WScreen *scr, int workspace)
1497 {
1498     char buffer[64];
1499
1500     assert(workspace >= 0 && workspace < MAX_WORKSPACES);
1501
1502     if (_XA_KWM_DESKTOP_NAME_[workspace]==0) {
1503         sprintf(buffer, "KWM_DESKTOP_NAME_%d", workspace + 1);
1504
1505         _XA_KWM_DESKTOP_NAME_[workspace] = XInternAtom(dpy, buffer, False);
1506     }
1507
1508     XChangeProperty(dpy, scr->root_win, _XA_KWM_DESKTOP_NAME_[workspace],
1509                     XA_STRING, 8, PropModeReplace,
1510                     (unsigned char*)scr->workspaces[workspace]->name,
1511                     strlen(scr->workspaces[workspace]->name)+1);
1512
1513     sendToModules(scr, _XA_KWM_MODULE_DESKTOP_NAME_CHANGE, NULL, workspace+1);
1514 }
1515
1516
1517
1518 void
1519 wKWMUpdateClientWorkspace(WWindow *wwin)
1520 {
1521 #ifdef DEBUG1
1522     printf("updating workspace of %s to %i\n",
1523            wwin->frame->title, wwin->frame->workspace+1);
1524 #endif
1525     setSimpleHint(wwin->client_win, _XA_KWM_WIN_DESKTOP,
1526                   wwin->frame->workspace+1);
1527 }
1528
1529
1530 void
1531 wKWMUpdateClientGeometryRestore(WWindow *wwin)
1532 {
1533     WArea rect;
1534
1535     rect.x1 = wwin->old_geometry.x;
1536     rect.y1 = wwin->old_geometry.y;
1537     rect.x2 = wwin->old_geometry.x + wwin->old_geometry.width;
1538     rect.y2 = wwin->old_geometry.y + wwin->old_geometry.height;
1539
1540     setAreaHint(wwin->client_win, _XA_KWM_WIN_GEOMETRY_RESTORE, rect);
1541 }
1542
1543
1544 void
1545 wKWMUpdateClientStateHint(WWindow *wwin, WKWMStateFlag flags)
1546 {
1547     if (flags & KWMIconifiedFlag) {
1548         setSimpleHint(wwin->client_win, _XA_KWM_WIN_ICONIFIED,
1549                       wwin->flags.miniaturized /*|| wwin->flags.shaded
1550                       || wwin->flags.hidden*/);
1551     }
1552     if (flags & KWMStickyFlag) {
1553         setSimpleHint(wwin->client_win, _XA_KWM_WIN_STICKY,
1554                       IS_OMNIPRESENT(wwin));
1555     }
1556     if (flags & KWMMaximizedFlag) {
1557         setSimpleHint(wwin->client_win, _XA_KWM_WIN_MAXIMIZED,
1558                       wwin->flags.maximized!=0);
1559     }
1560 }
1561
1562
1563 Bool
1564 wKWMGetUsableArea(WScreen *scr, WArea *area)
1565 {
1566     char buffer[64];
1567
1568     if (_XA_KWM_WINDOW_REGION_[0]==0) {
1569         sprintf(buffer, "KWM_WINDOW_REGION_%d", 1);
1570
1571         _XA_KWM_WINDOW_REGION_[0] = XInternAtom(dpy, buffer, False);
1572     }
1573
1574     return getAreaHint(scr->root_win, _XA_KWM_WINDOW_REGION_[0], area);
1575 }
1576
1577
1578
1579 Bool
1580 wKWMGetIconGeometry(WWindow *wwin, WArea *area)
1581 {
1582     return getAreaHint(wwin->client_win, _XA_KWM_WIN_ICON_GEOMETRY, area);
1583 }
1584
1585
1586
1587 #ifdef not_used
1588 void
1589 wKWMSetUsableAreaHint(WScreen *scr, int workspace)
1590 {
1591     /* if we set this after making changes of our own to the area,
1592      * the next time the area changes, we won't know what should
1593      * be the new final area. This protocol isn't worth a shit :/
1594      */
1595 /*
1596  * According to Matthias Ettrich:
1597  * Indeed, there's no protocol to deal with the area yet in case several
1598  * clients want to influence it. It is sufficent, though, if it is clear
1599  * that one process is responsable for the area. For KDE this is kpanel, but
1600  * I see that there might be a conflict with the docking area of windowmaker
1601  * itself.
1602  *
1603  */
1604
1605 #ifdef notdef
1606     char buffer[64];
1607
1608     assert(workspace >= 0 && workspace < MAX_WORKSPACES);
1609
1610     if (_XA_KWM_WINDOW_REGION_[workspace]==0) {
1611         sprintf(buffer, "KWM_WINDOW_REGION_%d", workspace+1);
1612
1613         _XA_KWM_WINDOW_REGION_[workspace] = XInternAtom(dpy, buffer, False);
1614     }
1615
1616     setAreaHint(scr->root_win, _XA_KWM_WINDOW_REGION_[workspace],
1617                 scr->totalUsableArea);
1618 #endif
1619 }
1620 #endif /* not_used */
1621
1622 void
1623 wKWMSendEventMessage(WWindow *wwin, WKWMEventMessage message)
1624 {
1625     Atom msg;
1626
1627     if (wwin && (wwin->flags.internal_window
1628                  || wwin->flags.kwm_hidden_for_modules
1629                  || !wwin->flags.kwm_managed
1630                  || WFLAGP(wwin, skip_window_list)))
1631         return;
1632
1633     switch (message) {
1634      case WKWMAddWindow:
1635         msg = _XA_KWM_MODULE_WIN_ADD;
1636         break;
1637      case WKWMRemoveWindow:
1638         msg = _XA_KWM_MODULE_WIN_REMOVE;
1639         break;
1640      case WKWMFocusWindow:
1641         msg = _XA_KWM_MODULE_WIN_ACTIVATE;
1642         break;
1643      case WKWMRaiseWindow:
1644         msg = _XA_KWM_MODULE_WIN_RAISE;
1645         break;
1646      case WKWMLowerWindow:
1647         msg = _XA_KWM_MODULE_WIN_LOWER;
1648         break;
1649      case WKWMChangedClient:
1650         msg = _XA_KWM_MODULE_WIN_CHANGE;
1651         break;
1652      case WKWMIconChange:
1653         msg = _XA_KWM_MODULE_WIN_ICON_CHANGE;
1654         break;
1655      default:
1656         return;
1657     }
1658
1659     sendToModules(wwin ? wwin->screen_ptr : NULL, msg, wwin, 0);
1660 }
1661
1662
1663 static void
1664 writeSocket(int sock, char *data)
1665 {
1666     char buffer[128];
1667
1668     sprintf(buffer, "%i ", strlen(data));
1669     write(sock, buffer, strlen(buffer));
1670     write(sock, data, strlen(data));
1671 }
1672
1673
1674 static int
1675 connectKFM(WScreen *scr)
1676 {
1677     char *path;
1678     char buffer[128];
1679     char *ptr;
1680     FILE *f;
1681     int pid;
1682     int sock = 0;
1683     struct sockaddr_un addr;
1684
1685     path = wstrappend(wgethomedir(), "/.kde/share/apps/kfm/pid");
1686     strcpy(buffer, getenv("DISPLAY"));
1687
1688     ptr = strchr(buffer, ':');
1689     if (ptr)
1690         *ptr = '_';
1691
1692     ptr = strrchr(buffer, '.');
1693     if (ptr)
1694         *ptr = 0;
1695     {
1696         char b[32];
1697
1698         sprintf(b, ".%i", scr->screen);
1699         strcat(buffer, b);
1700     }
1701     ptr = path;
1702     path = wstrappend(ptr, buffer);
1703     free(ptr);
1704
1705     /* pid file */
1706     f = fopen(path, "r");
1707     free(path);
1708     if (!f)
1709         return -1;
1710
1711     buffer[0] = 0;
1712     fgets(buffer, 123, f);
1713     pid = atoi(buffer);
1714     if (pid <= 0)
1715         return -1;
1716
1717     if (kill(pid, 0) != 0)
1718         return -1;
1719
1720     buffer[0] = 0;
1721     fscanf(f, "%s", buffer);
1722     fclose(f);
1723
1724     sock = socket(AF_UNIX, SOCK_STREAM, 0);
1725     if (sock < 0)
1726         return -1;
1727     addr.sun_family = AF_UNIX;
1728     strcpy(addr.sun_path, buffer);
1729
1730     if (connect(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
1731         close(sock);
1732         return -1;
1733     }
1734
1735     path = wstrappend(wgethomedir(), "/.kde/share/apps/kfm/magic");
1736     f = fopen(path, "r");
1737     if (!f) {
1738         return -1;
1739     }
1740     ptr = fgets(buffer, 123, f);
1741     fclose(f);
1742     if (!ptr) {
1743         return -1;
1744     }
1745     puts(buffer);
1746
1747     ptr = wstrappend("auth", buffer);
1748
1749     writeSocket(sock, ptr);
1750     free(ptr);
1751
1752     return sock;
1753 }
1754
1755
1756 void
1757 wKWMSelectRootRegion(WScreen *scr, int x, int y, int w, int h, Bool control)
1758 {
1759 #if 0
1760     char buffer[128];
1761     int sock;
1762
1763     puts("CONNECTING");
1764     sock = connectKFM(scr);
1765     if (sock < 0)
1766         return;
1767     puts("SENDING DATA");
1768
1769     sprintf(buffer, "selectRootIcons %i %i %i %i %c", x, y, w, h, control);
1770     writeSocket(sock, buffer);
1771
1772     close(sock);
1773 #endif
1774 }
1775
1776
1777 #endif /* KWM_HINTS */