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
 784     if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_STICKY, &val) && val) {
 785
 786         wwin->client_flags.omnipresent = 1;
 787     }
 788     if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_ICONIFIED, &val) && val) {
 789
 790         wwin->flags.miniaturized = 1;
 791     }
 792     if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_MAXIMIZED, &val) && val) {
 793
 794         wwin->flags.maximized = MAX_VERTICAL|MAX_HORIZONTAL;
 795     }
 796 }
 797
 798
 799 Bool
 800 wKWMCheckClientHintChange(WWindow *wwin, XPropertyEvent *event)
 801 {
 802     Bool processed = True;
 803     Bool flag;
 804     long value;
 805
 806
 807     if (!wwin->frame) {
 808         return False;
 809     }
 810
 811     if (event->atom == _XA_KWM_WIN_UNSAVED_DATA) {
 812 #ifdef DEBUG1
 813         printf("got KDE unsaved data change\n");
 814 #endif
 815
 816         flag = getSimpleHint(wwin->client_win, _XA_KWM_WIN_UNSAVED_DATA,
 817                              &value) && value;
 818
 819         if (flag != wwin->client_flags.broken_close) {
 820             wwin->client_flags.broken_close = flag;
 821             if (wwin->frame)
 822                 wWindowUpdateButtonImages(wwin);
 823         }
 824     } else if (event->atom == _XA_KWM_WIN_STICKY) {
 825
 826 #ifdef DEBUG1
 827         printf("got KDE sticky change\n");
 828 #endif
 829         flag = !getSimpleHint(wwin->client_win, _XA_KWM_WIN_STICKY,
 830                               &value) || value;
 831
 832         if (flag != wwin->client_flags.omnipresent) {
 833
 834             wwin->client_flags.omnipresent = flag;
 835
 836             UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_WORKSPACE);
 837
 838         }
 839     } else if (event->atom == _XA_KWM_WIN_MAXIMIZED) {
 840
 841 #ifdef DEBUG1
 842         printf("got KDE maximize change\n");
 843 #endif
 844         flag = !getSimpleHint(wwin->client_win, _XA_KWM_WIN_MAXIMIZED,
 845                              &value) || value;
 846
 847         if (flag != (wwin->flags.maximized!=0)) {
 848
 849             if (flag)
 850                 wMaximizeWindow(wwin, flag*(MAX_VERTICAL|MAX_HORIZONTAL));
 851             else
 852                 wUnmaximizeWindow(wwin);
 853         }
 854     } else if (event->atom == _XA_KWM_WIN_ICONIFIED) {
 855
 856 #ifdef DEBUG1
 857         printf("got KDE iconify change\n");
 858 #endif
 859         flag = !getSimpleHint(wwin->client_win, _XA_KWM_WIN_ICONIFIED,
 860                              &value) || value;
 861
 862         if (flag != wwin->flags.miniaturized) {
 863
 864             if (flag)
 865                 wIconifyWindow(wwin);
 866             else
 867                 wDeiconifyWindow(wwin);
 868         }
 869
 870     } else if (event->atom == _XA_KWM_WIN_DECORATION) {
 871         Bool refresh = False;
 872         int oldnofocus;
 873
 874 #ifdef DEBUG1
 875         printf("got KDE decoration change\n");
 876 #endif
 877
 878         oldnofocus = wwin->client_flags.no_focusable;
 879
 880         if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_DECORATION, &value)) {
 881             wwin->client_flags.no_focusable = (value & KWMnoFocus)!=0;
 882
 883             switch (value & ~KWMnoFocus) {
 884              case KWMnoDecoration:
 885                 if (!WFLAGP(wwin, no_titlebar) || !WFLAGP(wwin, no_resizebar))
 886                     refresh = True;
 887
 888                 wwin->client_flags.no_titlebar = 1;
 889                 wwin->client_flags.no_resizebar = 1;
 890                 break;
 891
 892              case KWMtinyDecoration:
 893                 if (WFLAGP(wwin, no_titlebar) || !WFLAGP(wwin, no_resizebar))
 894                     refresh = True;
 895
 896                 wwin->client_flags.no_titlebar = 0;
 897                 wwin->client_flags.no_resizebar = 1;
 898                 break;
 899
 900              case KWMnormalDecoration:
 901              default:
 902                 if (WFLAGP(wwin, no_titlebar) || WFLAGP(wwin, no_resizebar))
 903                     refresh = True;
 904
 905                 wwin->client_flags.no_titlebar = 0;
 906                 wwin->client_flags.no_resizebar = 0;
 907                 break;
 908             }
 909         } else {
 910             if (WFLAGP(wwin, no_titlebar) || WFLAGP(wwin, no_resizebar))
 911                 refresh = True;
 912             wwin->client_flags.no_focusable = (value & KWMnoFocus)!=0;
 913             wwin->client_flags.no_titlebar = 0;
 914             wwin->client_flags.no_resizebar = 0;
 915         }
 916
 917         if (refresh)
 918             wWindowConfigureBorders(wwin);
 919
 920         if (wwin->client_flags.no_focusable && !oldnofocus) {
 921
 922             sendToModules(wwin->screen_ptr, _XA_KWM_MODULE_WIN_REMOVE,
 923                           wwin, 0);
 924             wwin->flags.kwm_hidden_for_modules = 1;
 925
 926         } else if (!wwin->client_flags.no_focusable && oldnofocus) {
 927
 928             if (wwin->flags.kwm_hidden_for_modules) {
 929                 sendToModules(wwin->screen_ptr, _XA_KWM_MODULE_WIN_ADD,
 930                               wwin, 0);
 931                 wwin->flags.kwm_hidden_for_modules = 0;
 932             }
 933         }
 934     } else if (event->atom == _XA_KWM_WIN_DESKTOP && wwin->frame) {
 935 #ifdef DEBUG1
 936         printf("got KDE workspace change for %s\n", wwin->frame->title);
 937 #endif
 938         if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_DESKTOP, &value)
 939             && value-1 != wwin->frame->workspace) {
 940             wWindowChangeWorkspace(wwin, value-1);
 941         }
 942
 943     } else if (event->atom == _XA_KWM_WIN_GEOMETRY_RESTORE) {
 944         WArea area;
 945
 946 #ifdef DEBUG1
 947         printf("got KDE geometry restore change\n");
 948 #endif
 949         if (getAreaHint(wwin->client_win, _XA_KWM_WIN_GEOMETRY_RESTORE, &area)
 950             && (wwin->old_geometry.x != area.x1
 951                 || wwin->old_geometry.y != area.y1
 952                 || wwin->old_geometry.width != area.x2 - area.x1
 953                 || wwin->old_geometry.height != area.y2 - area.y1)) {
 954
 955                 wwin->old_geometry.x = area.x1;
 956                 wwin->old_geometry.y = area.y1;
 957                 wwin->old_geometry.width = area.x2 - area.x1;
 958                 wwin->old_geometry.height = area.y2 - area.y1;
 959             }
 960     } else {
 961         processed = False;
 962     }
 963
 964     return processed;
 965 }
 966
 967
 968 static Bool
 969 performWindowCommand(WScreen *scr, char *command)
 970 {
 971     WWindow *wwin = NULL;
 972
 973
 974     wwin = scr->focused_window;
 975     if (!wwin || !wwin->flags.focused || !wwin->flags.mapped) {
 976         wwin = NULL;
 977     }
 978
 979     CloseWindowMenu(scr);
 980
 981
 982     if (strcmp(command, "winMove")==0 || strcmp(command, "winResize")==0) {
 983
 984         if (wwin)
 985             wKeyboardMoveResizeWindow(wwin);
 986
 987     } else if (strcmp(command, "winMaximize")==0) {
 988
 989         if (wwin)
 990             wMaximizeWindow(wwin, MAX_VERTICAL|MAX_HORIZONTAL);
 991
 992     } else if (strcmp(command, "winRestore")==0) {
 993
 994         if (wwin && wwin->flags.maximized)
 995             wUnmaximizeWindow(wwin);
 996
 997     } else if (strcmp(command, "winIconify")==0) {
 998
 999
1000         if (wwin && !WFLAGP(wwin, no_miniaturizable)) {
1001             if (wwin->protocols.MINIATURIZE_WINDOW)
1002                 wClientSendProtocol(wwin, _XA_GNUSTEP_WM_MINIATURIZE_WINDOW,
1003                                     LastTimestamp);
1004             else {
1005                 wIconifyWindow(wwin);
1006             }
1007         }
1008
1009     } else if (strcmp(command, "winClose")==0) {
1010
1011         if (wwin && !WFLAGP(wwin, no_closable)) {
1012             if (wwin->protocols.DELETE_WINDOW)
1013                 wClientSendProtocol(wwin, _XA_WM_DELETE_WINDOW, LastTimestamp);
1014         }
1015
1016     } else if (strcmp(command, "winSticky")==0) {
1017
1018         if (wwin) {
1019             wwin->client_flags.omnipresent ^= 1;
1020             UpdateSwitchMenu(scr, wwin, ACTION_CHANGE_WORKSPACE);
1021         }
1022
1023     } else if (strcmp(command, "winShade")==0) {
1024
1025         if (wwin && !WFLAGP(wwin, no_shadeable)) {
1026             if (wwin->flags.shaded)
1027                 wUnshadeWindow(wwin);
1028             else
1029                 wShadeWindow(wwin);
1030         }
1031
1032     } else if (strcmp(command, "winOperation")==0) {
1033
1034         if (wwin)
1035             OpenWindowMenu(wwin, wwin->frame_x,
1036                            wwin->frame_y+wwin->frame->top_width, True);
1037
1038     } else {
1039         return False;
1040     }
1041
1042     return True;
1043 }
1044
1045
1046 static void
1047 performCommand(WScreen *scr, char *command, XClientMessageEvent *event)
1048 {
1049     assert(scr != NULL);
1050
1051     if (strcmp(command, "commandLine")==0
1052        || strcmp(command, "execute")==0) {
1053         char *cmd;
1054
1055         cmd = ExpandOptions(scr, _("%a(Run Command,Type the command to run:)"));
1056         if (cmd) {
1057             ExecuteShellCommand(scr, cmd);
1058             free(cmd);
1059         }
1060     } else if (strcmp(command, "logout")==0) {
1061
1062         Shutdown(WSLogoutMode);
1063
1064     } else if (strcmp(command, "refreshScreen")==0) {
1065
1066         wRefreshDesktop(scr);
1067
1068     } else if (strncmp(command, "go:", 3)==0) {
1069
1070         Shutdown(WSRestartPreparationMode);
1071         Restart(&command[3], False);
1072         Restart(NULL, True);
1073
1074     } else if (strcmp(command, "desktop+1")==0) {
1075
1076         wWorkspaceRelativeChange(scr, 1);
1077
1078     } else if (strcmp(command, "desktop-1")==0) {
1079
1080         wWorkspaceRelativeChange(scr, -1);
1081
1082     } else if (strcmp(command, "desktop+2")==0) {
1083
1084         wWorkspaceRelativeChange(scr, 2);
1085
1086     } else if (strcmp(command, "desktop-2")==0) {
1087
1088         wWorkspaceRelativeChange(scr, -2);
1089
1090     } else if (strcmp(command, "desktop%%2")==0) {
1091
1092         if (scr->current_workspace % 2 == 1)
1093             wWorkspaceRelativeChange(scr, 1);
1094         else
1095             wWorkspaceRelativeChange(scr, -1);
1096     } else if (strncmp(command, "desktop", 7)==0) {
1097         int ws;
1098
1099         ws = atoi(&command[7]);
1100         wWorkspaceChange(scr, ws);
1101
1102         /* wmaker specific stuff */
1103     } else if (strcmp(command, "wmaker:info")==0) {
1104
1105         wShowInfoPanel(scr);
1106
1107     } else if (strcmp(command, "wmaker:legal")==0) {
1108
1109         wShowLegalPanel(scr);
1110
1111     } else if (strcmp(command, "wmaker:arrangeIcons")==0) {
1112
1113         wArrangeIcons(scr, True);
1114
1115     } else if (strcmp(command, "wmaker:showAll")==0) {
1116
1117         wShowAllWindows(scr);
1118
1119     } else if (strcmp(command, "wmaker:hideOthers")==0) {
1120
1121         wHideOtherApplications(scr->focused_window);
1122
1123     } else if (strcmp(command, "wmaker:restart")==0) {
1124
1125         Shutdown(WSRestartPreparationMode);
1126         Restart(NULL, True);
1127
1128     } else if (strcmp(command, "wmaker:exit")==0) {
1129
1130         Shutdown(WSExitMode);
1131
1132 #ifdef UNSUPPORTED_STUFF
1133     } else if (strcmp(command, "moduleRaised")==0) { /* useless */
1134     } else if (strcmp(command, "deskUnclutter")==0) {
1135     } else if (strcmp(command, "deskCascade")==0) {
1136     } else if (strcmp(command, "configure")==0) {
1137     } else if (strcmp(command, "taskManager")==0) {
1138     } else if (strcmp(command, "darkenScreen")==0) { /* breaks consistency */
1139 #endif
1140     } else if (!performWindowCommand(scr, command)) {
1141         KWMModuleList *module;
1142         long mask = 0;
1143         XEvent ev;
1144         /* do message relay thing */
1145
1146         ev.xclient = *event;
1147         for (module = KWMModules; module != NULL; module = module->next) {
1148
1149             ev.xclient.window = module->window;
1150             if (module->window == scr->root_win)
1151                 mask = SubstructureRedirectMask;
1152             else
1153                 mask = 0;
1154
1155             XSendEvent(dpy, module->window, False, mask, &ev);
1156         }
1157     }
1158 }
1159
1160
1161 Bool
1162 wKWMProcessClientMessage(XClientMessageEvent *event)
1163 {
1164     Bool processed = True;
1165     WScreen *scr;
1166 #ifdef DEBUG1
1167     printf("CLIENT MESS %s\n", XGetAtomName(dpy, event->message_type));
1168 #endif
1169     if (event->message_type == _XA_KWM_COMMAND && event->format==8) {
1170         char buffer[24];
1171         int i;
1172
1173         scr = wScreenForRootWindow(event->window);
1174
1175         for (i=0; i<20; i++) {
1176             buffer[i] = event->data.b[i];
1177         }
1178         buffer[i] = 0;
1179
1180 #ifdef DEBUG1
1181         printf("got KDE command %s\n", buffer);
1182 #endif
1183         performCommand(scr, buffer, event);
1184
1185     } else if (event->message_type == _XA_KWM_ACTIVATE_WINDOW) {
1186         WWindow *wwin;
1187
1188 #ifdef DEBUG1
1189         printf("got KDE activate internal\n");
1190 #endif
1191         wwin = wWindowFor(event->data.l[0]);
1192
1193         if (wwin)
1194             wSetFocusTo(wwin->screen_ptr, wwin);
1195
1196     } else if (event->message_type == _XA_KWM_DO_NOT_MANAGE
1197                && event->format == 8) {
1198         KWMDoNotManageList *node;
1199         int i;
1200
1201 #ifdef DEBUG1
1202         printf("got KDE dont manage\n");
1203 #endif
1204
1205         node = malloc(sizeof(KWMDoNotManageList));
1206         if (!node) {
1207             wwarning("out of memory processing KWM_DO_NOT_MANAGE message");
1208         }
1209         for (i=0; i<20 && event->data.b[i]; i++)
1210             node->title[i] = event->data.b[i];
1211         node->title[i] = 0;
1212
1213         node->next = KWMDoNotManageCrap;
1214         KWMDoNotManageCrap = node;
1215
1216     } else if (event->message_type == _XA_KWM_MODULE) {
1217         long val;
1218         Window modwin = event->data.l[0];
1219
1220         scr = wScreenForRootWindow(event->window);
1221
1222         if (getSimpleHint(modwin, _XA_KWM_MODULE, &val) && val) {
1223 #ifdef DEBUG1
1224             puts("got KDE module startup");
1225 #endif
1226             addModule(scr, modwin);
1227         } else {
1228 #ifdef DEBUG1
1229             puts("got KDE module finish");
1230 #endif
1231             removeModule(scr, modwin);
1232         }
1233     } else {
1234         processed = False;
1235     }
1236
1237     return processed;
1238 }
1239
1240
1241 void
1242 wKWMCheckModule(WScreen *scr, Window window)
1243 {
1244     long val;
1245
1246     if (getSimpleHint(window, _XA_KWM_MODULE, &val) && val) {
1247 #ifdef DEBUG1
1248         puts("got KDE module startup");
1249 #endif
1250         addModule(scr, window);
1251     }
1252 }
1253
1254
1255 Bool
1256 wKWMCheckRootHintChange(WScreen *scr, XPropertyEvent *event)
1257 {
1258     Bool processed = True;
1259     long value;
1260
1261     if (event->atom == _XA_KWM_CURRENT_DESKTOP) {
1262         if (getSimpleHint(scr->root_win, _XA_KWM_CURRENT_DESKTOP, &value)) {
1263 #ifdef DEBUG1
1264             printf("got KDE workspace switch to %li\n", value);
1265 #endif
1266             if (value-1 != scr->current_workspace) {
1267                 wWorkspaceChange(scr, value-1);
1268             }
1269         }
1270     } else if (event->atom == _XA_KWM_NUMBER_OF_DESKTOPS) {
1271 #ifdef DEBUG1
1272             printf("got KDE workspace number change\n");
1273 #endif
1274
1275         if (getSimpleHint(scr->root_win, _XA_KWM_NUMBER_OF_DESKTOPS, &value)) {
1276
1277             /* increasing is easy... */
1278             if (value > scr->workspace_count) {
1279                 scr->flags.kwm_syncing_count = 1;
1280
1281                 wWorkspaceMake(scr, value - scr->workspace_count);
1282
1283                 scr->flags.kwm_syncing_count = 0;
1284
1285             } else if (value < scr->workspace_count) {
1286                 int i;
1287                 Bool rebuild = False;
1288
1289                 scr->flags.kwm_syncing_count = 1;
1290
1291                 /* decrease all we can do */
1292                 for (i = scr->workspace_count; i >= value; i--) {
1293                     if (!wWorkspaceDelete(scr, i)) {
1294                         rebuild = True;
1295                         break;
1296                     }
1297                 }
1298
1299                 scr->flags.kwm_syncing_count = 0;
1300
1301                 /* someone destroyed a workspace that can't be destroyed.
1302                  * Reset the hints to reflect our internal state.
1303                  */
1304                 if (rebuild) {
1305                     wKWMUpdateWorkspaceCountHint(scr);
1306                 }
1307             }
1308         }
1309     } else {
1310         int i;
1311
1312         processed = False;
1313
1314         for (i = 0; i < MAX_WORKSPACES && i < scr->workspace_count; i++) {
1315              if (event->atom == _XA_KWM_DESKTOP_NAME_[i]) {
1316                  char *name;
1317
1318                  name = wKWMGetWorkspaceName(scr, i);
1319
1320 #ifdef DEBUG1
1321                  printf("got KDE workspace name change to %s\n", name);
1322 #endif
1323
1324                  if (name && strncmp(name, scr->workspaces[i]->name,
1325                                      MAX_WORKSPACENAME_WIDTH)!=0) {
1326                      scr->flags.kwm_syncing_name = 1;
1327                      wWorkspaceRename(scr, i, name);
1328                      scr->flags.kwm_syncing_name = 0;
1329                  }
1330                  if (name)
1331                      XFree(name);
1332                  processed = True;
1333                  break;
1334              } else if (event->atom == _XA_KWM_WINDOW_REGION_[i]) {
1335                  WArea area;
1336
1337                  if (getAreaHint(scr->root_win, event->atom, &area)) {
1338
1339                      if (scr->totalUsableArea.x1 != area.x1
1340                          || scr->totalUsableArea.y1 != area.y1
1341                          || scr->totalUsableArea.x2 != area.x2
1342                          || scr->totalUsableArea.y2 != area.y2) {
1343                          wScreenUpdateUsableArea(scr);
1344                      }
1345                  }
1346
1347                  processed = True;
1348                  break;
1349              }
1350         }
1351     }
1352
1353     return processed;
1354 }
1355
1356
1357 Bool
1358 wKWMManageableClient(WScreen *scr, Window win, char *title)
1359 {
1360     KWMDoNotManageList *ptr, *next;
1361     long val;
1362
1363     if (getSimpleHint(win, _XA_KWM_DOCKWINDOW, &val) && val) {
1364         addDockWindow(scr, win);
1365         return False;
1366     }
1367
1368     ptr = KWMDoNotManageCrap;
1369     /*
1370      * TODO: support for glob patterns or regexes
1371      */
1372     if (ptr && strncmp(ptr->title, title, strlen(ptr->title))==0) {
1373         next = ptr->next;
1374         free(ptr);
1375         KWMDoNotManageCrap = next;
1376 #ifdef DEBUG1
1377         printf("window %s not managed per KDE request\n", title);
1378 #endif
1379
1380         sendToModules(scr, _XA_KWM_MODULE_WIN_ADD, NULL, win);
1381         sendToModules(scr, _XA_KWM_MODULE_WIN_REMOVE, NULL, win);
1382
1383         return False;
1384     } else if (ptr) {
1385         while (ptr->next) {
1386             if (strncmp(ptr->next->title, title, strlen(ptr->next->title))==0) {
1387 #ifdef DEBUG1
1388                 printf("window %s not managed per KDE request\n", title);
1389 #endif
1390                 next = ptr->next->next;
1391                 free(ptr->next);
1392                 ptr->next = next;
1393
1394                 sendToModules(scr, _XA_KWM_MODULE_WIN_ADD, NULL, win);
1395                 sendToModules(scr, _XA_KWM_MODULE_WIN_REMOVE, NULL, win);
1396
1397                 return False;
1398             }
1399
1400             ptr = ptr->next;
1401         }
1402     }
1403
1404     return True;
1405 }
1406
1407
1408 void
1409 wKWMUpdateCurrentWorkspaceHint(WScreen *scr)
1410 {
1411     setSimpleHint(scr->root_win, _XA_KWM_CURRENT_DESKTOP,
1412                   scr->current_workspace+1);
1413
1414     sendToModules(scr, _XA_KWM_MODULE_DESKTOP_CHANGE, NULL,
1415                   scr->current_workspace+1);
1416 }
1417
1418
1419 void
1420 wKWMUpdateActiveWindowHint(WScreen *scr)
1421 {
1422     long val;
1423     WWindow *wwin, *tmp;
1424
1425     if (!scr->focused_window || !scr->focused_window->flags.focused)
1426         val = None;
1427     else {
1428         val = (long)(scr->focused_window->client_win);
1429
1430         /* raise the menubar thing */
1431         wwin = scr->focused_window;
1432         tmp = wwin->prev;
1433         while (tmp) {
1434             if (tmp->flags.kwm_menubar
1435                 && tmp->transient_for == wwin->client_win) {
1436                 wRaiseFrame(tmp->frame->core);
1437                 break;
1438             }
1439             tmp = tmp->prev;
1440         }
1441     }
1442
1443     XChangeProperty(dpy, scr->root_win, _XA_KWM_ACTIVE_WINDOW,
1444                     _XA_KWM_ACTIVE_WINDOW, 32, PropModeReplace,
1445                     (unsigned char*)&val, 1);
1446     XFlush(dpy);
1447 }
1448
1449
1450 void
1451 wKWMUpdateWorkspaceCountHint(WScreen *scr)
1452 {
1453     if (scr->flags.kwm_syncing_count)
1454         return;
1455
1456     setSimpleHint(scr->root_win, _XA_KWM_NUMBER_OF_DESKTOPS,
1457                   scr->workspace_count);
1458
1459     sendToModules(scr, _XA_KWM_MODULE_DESKTOP_NUMBER_CHANGE, NULL,
1460                   scr->workspace_count);
1461 }
1462
1463
1464 void
1465 wKWMCheckDestroy(XDestroyWindowEvent *event)
1466 {
1467     WScreen *scr;
1468
1469     if (event->event == event->window) {
1470         return;
1471     }
1472
1473     scr = wScreenSearchForRootWindow(event->event);
1474     if (!scr) {
1475         return;
1476     }
1477
1478     removeModule(scr, event->window);
1479     removeDockWindow(scr, event->window);
1480 }
1481
1482
1483 void
1484 wKWMUpdateWorkspaceNameHint(WScreen *scr, int workspace)
1485 {
1486     char buffer[64];
1487
1488     assert(workspace >= 0 && workspace < MAX_WORKSPACES);
1489
1490     if (_XA_KWM_DESKTOP_NAME_[workspace]==0) {
1491         sprintf(buffer, "KWM_DESKTOP_NAME_%d", workspace + 1);
1492
1493         _XA_KWM_DESKTOP_NAME_[workspace] = XInternAtom(dpy, buffer, False);
1494     }
1495
1496     XChangeProperty(dpy, scr->root_win, _XA_KWM_DESKTOP_NAME_[workspace],
1497                     XA_STRING, 8, PropModeReplace,
1498                     (unsigned char*)scr->workspaces[workspace]->name,
1499                     strlen(scr->workspaces[workspace]->name)+1);
1500
1501     sendToModules(scr, _XA_KWM_MODULE_DESKTOP_NAME_CHANGE, NULL, workspace+1);
1502 }
1503
1504
1505
1506 void
1507 wKWMUpdateClientWorkspace(WWindow *wwin)
1508 {
1509 #ifdef DEBUG1
1510     printf("updating workspace of %s to %i\n",
1511            wwin->frame->title, wwin->frame->workspace+1);
1512 #endif
1513     setSimpleHint(wwin->client_win, _XA_KWM_WIN_DESKTOP,
1514                   wwin->frame->workspace+1);
1515 }
1516
1517
1518 void
1519 wKWMUpdateClientGeometryRestore(WWindow *wwin)
1520 {
1521     WArea rect;
1522
1523     rect.x1 = wwin->old_geometry.x;
1524     rect.y1 = wwin->old_geometry.y;
1525     rect.x2 = wwin->old_geometry.x + wwin->old_geometry.width;
1526     rect.y2 = wwin->old_geometry.y + wwin->old_geometry.height;
1527
1528     setAreaHint(wwin->client_win, _XA_KWM_WIN_GEOMETRY_RESTORE, rect);
1529 }
1530
1531
1532 void
1533 wKWMUpdateClientStateHint(WWindow *wwin, WKWMStateFlag flags)
1534 {
1535     if (flags & KWMIconifiedFlag) {
1536         setSimpleHint(wwin->client_win, _XA_KWM_WIN_ICONIFIED,
1537                       wwin->flags.miniaturized /*|| wwin->flags.shaded
1538                       || wwin->flags.hidden*/);
1539     }
1540     if (flags & KWMStickyFlag) {
1541         setSimpleHint(wwin->client_win, _XA_KWM_WIN_STICKY,
1542                       IS_OMNIPRESENT(wwin));
1543     }
1544     if (flags & KWMMaximizedFlag) {
1545         setSimpleHint(wwin->client_win, _XA_KWM_WIN_MAXIMIZED,
1546                       wwin->flags.maximized!=0);
1547     }
1548 }
1549
1550
1551 Bool
1552 wKWMGetUsableArea(WScreen *scr, WArea *area)
1553 {
1554     char buffer[64];
1555
1556     if (_XA_KWM_WINDOW_REGION_[0]==0) {
1557         sprintf(buffer, "KWM_WINDOW_REGION_%d", 1);
1558
1559         _XA_KWM_WINDOW_REGION_[0] = XInternAtom(dpy, buffer, False);
1560     }
1561
1562     return getAreaHint(scr->root_win, _XA_KWM_WINDOW_REGION_[0], area);
1563 }
1564
1565
1566
1567 Bool
1568 wKWMGetIconGeometry(WWindow *wwin, WArea *area)
1569 {
1570     return getAreaHint(wwin->client_win, _XA_KWM_WIN_ICON_GEOMETRY, area);
1571 }
1572
1573
1574
1575 #ifdef not_used
1576 void
1577 wKWMSetUsableAreaHint(WScreen *scr, int workspace)
1578 {
1579     /* if we set this after making changes of our own to the area,
1580      * the next time the area changes, we won't know what should
1581      * be the new final area. This protocol isn't worth a shit :/
1582      */
1583 /*
1584  * According to Matthias Ettrich:
1585  * Indeed, there's no protocol to deal with the area yet in case several
1586  * clients want to influence it. It is sufficent, though, if it is clear
1587  * that one process is responsable for the area. For KDE this is kpanel, but
1588  * I see that there might be a conflict with the docking area of windowmaker
1589  * itself.
1590  *
1591  */
1592
1593 #ifdef notdef
1594     char buffer[64];
1595
1596     assert(workspace >= 0 && workspace < MAX_WORKSPACES);
1597
1598     if (_XA_KWM_WINDOW_REGION_[workspace]==0) {
1599         sprintf(buffer, "KWM_WINDOW_REGION_%d", workspace+1);
1600
1601         _XA_KWM_WINDOW_REGION_[workspace] = XInternAtom(dpy, buffer, False);
1602     }
1603
1604     setAreaHint(scr->root_win, _XA_KWM_WINDOW_REGION_[workspace],
1605                 scr->totalUsableArea);
1606 #endif
1607 }
1608 #endif /* not_used */
1609
1610 void
1611 wKWMSendEventMessage(WWindow *wwin, WKWMEventMessage message)
1612 {
1613     Atom msg;
1614
1615     if (wwin && (wwin->flags.internal_window
1616                  || wwin->flags.kwm_hidden_for_modules
1617                  || !wwin->flags.kwm_managed
1618                  || WFLAGP(wwin, skip_window_list)))
1619         return;
1620
1621     switch (message) {
1622      case WKWMAddWindow:
1623         msg = _XA_KWM_MODULE_WIN_ADD;
1624         break;
1625      case WKWMRemoveWindow:
1626         msg = _XA_KWM_MODULE_WIN_REMOVE;
1627         break;
1628      case WKWMFocusWindow:
1629         msg = _XA_KWM_MODULE_WIN_ACTIVATE;
1630         break;
1631      case WKWMRaiseWindow:
1632         msg = _XA_KWM_MODULE_WIN_RAISE;
1633         break;
1634      case WKWMLowerWindow:
1635         msg = _XA_KWM_MODULE_WIN_LOWER;
1636         break;
1637      case WKWMChangedClient:
1638         msg = _XA_KWM_MODULE_WIN_CHANGE;
1639         break;
1640      case WKWMIconChange:
1641         msg = _XA_KWM_MODULE_WIN_ICON_CHANGE;
1642         break;
1643      default:
1644         return;
1645     }
1646
1647     sendToModules(wwin ? wwin->screen_ptr : NULL, msg, wwin, 0);
1648 }
1649
1650
1651 static void
1652 writeSocket(int sock, char *data)
1653 {
1654     char buffer[128];
1655
1656     sprintf(buffer, "%i ", strlen(data));
1657     write(sock, buffer, strlen(buffer));
1658     write(sock, data, strlen(data));
1659 }
1660
1661
1662 static int
1663 connectKFM(WScreen *scr)
1664 {
1665     char *path;
1666     char buffer[128];
1667     char *ptr;
1668     FILE *f;
1669     int pid;
1670     int sock = 0;
1671     struct sockaddr_un addr;
1672
1673     path = wstrappend(wgethomedir(), "/.kde/share/apps/kfm/pid");
1674     strcpy(buffer, getenv("DISPLAY"));
1675
1676     ptr = strchr(buffer, ':');
1677     if (ptr)
1678         *ptr = '_';
1679
1680     ptr = strrchr(buffer, '.');
1681     if (ptr)
1682         *ptr = 0;
1683     {
1684         char b[32];
1685
1686         sprintf(b, ".%i", scr->screen);
1687         strcat(buffer, b);
1688     }
1689     ptr = path;
1690     path = wstrappend(ptr, buffer);
1691     free(ptr);
1692
1693     /* pid file */
1694     f = fopen(path, "r");
1695     free(path);
1696     if (!f)
1697         return -1;
1698
1699     buffer[0] = 0;
1700     fgets(buffer, 123, f);
1701     pid = atoi(buffer);
1702     if (pid <= 0)
1703         return -1;
1704
1705     if (kill(pid, 0) != 0)
1706         return -1;
1707
1708     buffer[0] = 0;
1709     fscanf(f, "%s", buffer);
1710     fclose(f);
1711
1712     sock = socket(AF_UNIX, SOCK_STREAM, 0);
1713     if (sock < 0)
1714         return -1;
1715     addr.sun_family = AF_UNIX;
1716     strcpy(addr.sun_path, buffer);
1717
1718     if (connect(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
1719         close(sock);
1720         return -1;
1721     }
1722
1723     path = wstrappend(wgethomedir(), "/.kde/share/apps/kfm/magic");
1724     f = fopen(path, "r");
1725     if (!f) {
1726         return -1;
1727     }
1728     ptr = fgets(buffer, 123, f);
1729     fclose(f);
1730     if (!ptr) {
1731         return -1;
1732     }
1733     puts(buffer);
1734
1735     ptr = wstrappend("auth", buffer);
1736
1737     writeSocket(sock, ptr);
1738     free(ptr);
1739
1740     return sock;
1741 }
1742
1743
1744 void
1745 wKWMSelectRootRegion(WScreen *scr, int x, int y, int w, int h, Bool control)
1746 {
1747 #if 0
1748     char buffer[128];
1749     int sock;
1750
1751     puts("CONNECTING");
1752     sock = connectKFM(scr);
1753     if (sock < 0)
1754         return;
1755     puts("SENDING DATA");
1756
1757     sprintf(buffer, "selectRootIcons %i %i %i %i %c", x, y, w, h, control);
1758     writeSocket(sock, buffer);
1759
1760     close(sock);
1761 #endif
1762 }
1763
1764
1765 #endif /* KWM_HINTS */