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