fvwm/gnome.c

   1 /* -*-c-*- */
   2 /*
   3  * GNOME WM Compliance adapted for fvwm
   4  * Properties set on the root window (or desktop window)
   5  *
   6  * Even though the rest of fvwm is GPL consider this file
   7  * Public Domain - use it however you see fit to make
   8  * your WM GNOME compiant
   9  *
  10  * written by Raster
  11  * adapted for fvwm by Jay Painter <jpaint@gnu.org>
  12  */
  13 #include "config.h"
  14
  15 #include <stdio.h>
  16 #ifdef HAVE_FCNTL_H
  17 #include <fcntl.h>
  18 #endif
  19
  20 #include <X11/Xlib.h>
  21 #include <X11/Xmd.h>
  22 #include <X11/Xatom.h>
  23
  24 #include "libs/fvwmlib.h"
  25 #include "libs/Parse.h"
  26 #include "fvwm.h"
  27 #include "externs.h"
  28 #include "cursor.h"
  29 #include "functions.h"
  30 #include "commands.h"
  31 #include "misc.h"
  32 #include "screen.h"
  33 #include "gnome.h"
  34 #include "move_resize.h"
  35 #include "stack.h"
  36 #include "update.h"
  37 #include "style.h"
  38 #include "virtual.h"
  39 #include "window_flags.h"
  40 #include "borders.h"
  41 #include "decorations.h"
  42
  43
  44 /*
  45  * Properties set on the root window (or desktop window)
  46  */
  47
  48 /* WIN_AREA CARD32[2] contains the current desktop area X,Y */
  49 #define XA_WIN_AREA                        "_WIN_AREA"
  50
  51 /* WIN_AREA CARD32[2] contains the current desktop area size WxH */
  52 #define XA_WIN_AREA_COUNT                        "_WIN_AREA_COUNT"
  53
  54 /* array of atoms - atom being one of the following atoms */
  55 #define XA_WIN_PROTOCOLS                   "_WIN_PROTOCOLS"
  56
  57 /* array of iocn in various sizes */
  58 /* Type: array of CARD32 */
  59 /*       first item is icon count (n) */
  60 /*       second item is icon record length (in CARD32s) */
  61 /*       this is followed by (n) icon records as follows */
  62 /*           pixmap (XID) */
  63 /*           mask (XID) */
  64 /*           width (CARD32) */
  65 /*           height (CARD32) */
  66 /*           depth (of pixmap, mask is assumed to be of depth 1) (CARD32) */
  67 /*           drawable (screen root drawable of pixmap) (XID) */
  68 /*           ... additional fields can be added at the end of this list */
  69 #define XA_WIN_ICONS                    "_WIN_ICONS"
  70
  71 /* WIN_WORKSPACE CARD32 contains the current desktop number */
  72 #define XA_WIN_WORKSPACE                   "_WIN_WORKSPACE"
  73 /* WIN_WORKSPACE_COUNT CARD32 contains the number of desktops */
  74 #define XA_WIN_WORKSPACE_COUNT             "_WIN_WORKSPACE_COUNT"
  75
  76 /* WIN_WORKSPACE_NAMES StringList (Text Property) of workspace names */
  77 /* unused by enlightenment */
  78 #define XA_WIN_WORKSPACE_NAMES             "_WIN_WORKSPACE_NAMES"
  79
  80 /* *** Don't use this.. iffy at best. ** */
  81 /* The available work area for client windows. The WM can set this and the WM */
  82 /* and/or clients may change it at any time. If it is changed the WM and/or  */
  83 /* clients should honor the changes. If this property does not exist a client */
  84 /* or WM can create it. */
  85 /*
  86  * CARD32              min_x;
  87  * CARD32              min_y;
  88  * CARD32              max_x;
  89  * CARD32              max_y;
  90  */
  91 #define XA_WIN_WORKAREA                    "_WIN_WORKAREA"
  92 /* array of 4 CARD32's */
  93
  94 /* This is a list of window id's the WM is currently managing - primarily */
  95 /* for being able to have external "tasklist" apps */
  96 #define XA_WIN_CLIENT_LIST                 "_WIN_CLIENT_LIST"
  97 /* array of N XID's */
  98
  99 /*
 100  * Properties on client windows
 101  */
 102
 103 /* The layer the window exists in */
 104 /*      0 = Desktop */
 105 /*      1 = Below */
 106 /*      2 = Normal (default app layer) */
 107 /*      4 = OnTop */
 108 /*      6 = Dock (always on top - for panel) */
 109 /* The app sets this alone, not the WM. If this property changes the WM */
 110 /* should comply and change the appearance/behavior of the Client window */
 111 /* if this hint does not exist the WM Will create it on the Client window */
 112 #define WIN_LAYER_DESKTOP                0
 113 #define WIN_LAYER_BELOW                  2
 114 #define WIN_LAYER_NORMAL                 4
 115 #define WIN_LAYER_ONTOP                  6
 116 #define WIN_LAYER_DOCK                   8
 117 #define WIN_LAYER_ABOVE_DOCK             10
 118 #define WIN_LAYER_MENU                   12
 119 #define XA_WIN_LAYER                     "_WIN_LAYER"
 120 /* WIN_LAYER = CARD32 */
 121
 122 /* flags for the window's state. The WM will change these as needed when */
 123 /* state changes. If the property contains info on client map, E will modify */
 124 /* the windows state accordingly. if the Hint does not exist the WM will */
 125 /* create it on the client window. 0 for the bit means off, 1 means on. */
 126 /* unused (default) values are 0 */
 127
 128 /* removed Minimized - no explanation of what it really means - ambiguity */
 129 /* should not be here if not clear */
 130 #define WIN_STATE_STICKY          (1<<0) /* everyone knows sticky */
 131 #define WIN_STATE_RESERVED_BIT1   (1<<1) /* removed minimize here */
 132 #define WIN_STATE_MAXIMIZED_VERT  (1<<2) /* window in maximized V state */
 133 #define WIN_STATE_MAXIMIZED_HORIZ (1<<3) /* window in maximized H state */
 134 #define WIN_STATE_HIDDEN          (1<<4) /* not on taskbar but window visible */
 135 #define WIN_STATE_SHADED          (1<<5) /* shaded (NeXT style) */
 136 #define WIN_STATE_HID_WORKSPACE   (1<<6) /* not on current desktop */
 137 #define WIN_STATE_HID_TRANSIENT   (1<<7) /* Owner of transient is hidden */
 138 #define WIN_STATE_FIXED_POSITION  (1<<8) /* window is fixed in position even */
 139 #define WIN_STATE_ARRANGE_IGNORE  (1<<9) /* ignore for auto arranging */
 140 /* when scrolling about large */
 141 /* virtual desktops ala fvwm */
 142 #define XA_WIN_STATE              "_WIN_STATE"
 143 /* WIN_STATE = CARD32 */
 144
 145 /* Preferences for behavior for app */
 146 /* ONLY the client sets this */
 147 #define WIN_HINTS_SKIP_FOCUS      (1<<0) /* "alt-tab" skips this win */
 148 #define WIN_HINTS_SKIP_WINLIST    (1<<1) /* not in win list */
 149 #define WIN_HINTS_SKIP_TASKBAR    (1<<2) /* not on taskbar */
 150 #define WIN_HINTS_GROUP_TRANSIENT (1<<3) /* ??????? */
 151 #define WIN_HINTS_FOCUS_ON_CLICK  (1<<4) /* app only accepts focus when clicked
 152                                           */
 153 #define XA_WIN_HINTS                     "_WIN_HINTS"
 154 /* WIN_HINTS = CARD32 */
 155
 156 /* Application state - also "color reactiveness" - the app can keep changing */
 157 /* this property when it changes its state and the WM or monitoring program */
 158 /* will pick this up and dpylay somehting accordingly. ONLY the client sets */
 159 /* this. */
 160 #define WIN_APP_STATE_NONE                 0
 161 #define WIN_APP_STATE_ACTIVE1              1
 162 #define WIN_APP_STATE_ACTIVE2              2
 163 #define WIN_APP_STATE_ERROR1               3
 164 #define WIN_APP_STATE_ERROR2               4
 165 #define WIN_APP_STATE_FATAL_ERROR1         5
 166 #define WIN_APP_STATE_FATAL_ERROR2         6
 167 #define WIN_APP_STATE_IDLE1                7
 168 #define WIN_APP_STATE_IDLE2                8
 169 #define WIN_APP_STATE_WAITING1             9
 170 #define WIN_APP_STATE_WAITING2             10
 171 #define WIN_APP_STATE_WORKING1             11
 172 #define WIN_APP_STATE_WORKING2             12
 173 #define WIN_APP_STATE_NEED_USER_INPUT1     13
 174 #define WIN_APP_STATE_NEED_USER_INPUT2     14
 175 #define WIN_APP_STATE_STRUGGLING1          15
 176 #define WIN_APP_STATE_STRUGGLING2          16
 177 #define WIN_APP_STATE_DISK_TRAFFIC1        17
 178 #define WIN_APP_STATE_DISK_TRAFFIC2        18
 179 #define WIN_APP_STATE_NETWORK_TRAFFIC1     19
 180 #define WIN_APP_STATE_NETWORK_TRAFFIC2     20
 181 #define WIN_APP_STATE_OVERLOADED1          21
 182 #define WIN_APP_STATE_OVERLOADED2          22
 183 #define WIN_APP_STATE_PERCENT000_1         23
 184 #define WIN_APP_STATE_PERCENT000_2         24
 185 #define WIN_APP_STATE_PERCENT010_1         25
 186 #define WIN_APP_STATE_PERCENT010_2         26
 187 #define WIN_APP_STATE_PERCENT020_1         27
 188 #define WIN_APP_STATE_PERCENT020_2         28
 189 #define WIN_APP_STATE_PERCENT030_1         29
 190 #define WIN_APP_STATE_PERCENT030_2         30
 191 #define WIN_APP_STATE_PERCENT040_1         31
 192 #define WIN_APP_STATE_PERCENT040_2         32
 193 #define WIN_APP_STATE_PERCENT050_1         33
 194 #define WIN_APP_STATE_PERCENT050_2         34
 195 #define WIN_APP_STATE_PERCENT060_1         35
 196 #define WIN_APP_STATE_PERCENT060_2         36
 197 #define WIN_APP_STATE_PERCENT070_1         37
 198 #define WIN_APP_STATE_PERCENT070_2         38
 199 #define WIN_APP_STATE_PERCENT080_1         39
 200 #define WIN_APP_STATE_PERCENT080_2         40
 201 #define WIN_APP_STATE_PERCENT090_1         41
 202 #define WIN_APP_STATE_PERCENT090_2         42
 203 #define WIN_APP_STATE_PERCENT100_1         43
 204 #define WIN_APP_STATE_PERCENT100_2         44
 205 #define XA_WIN_APP_STATE                   "_WIN_APP_STATE"
 206 /* WIN_APP_STATE = CARD32 */
 207
 208 /* Expanded space occupied - this is the area on screen the app's window */
 209 /* will occupy when "expanded" - ie if you have a button on an app that */
 210 /* "hides" it by reducing its size, this is the geometry of the expanded */
 211 /* window - so the window manager can allow for this when doign auto */
 212 /* positioing of client windows assuming the app can at any point use this */
 213 /* this area and thus try and keep it clear. ONLY the client sets this */
 214 /*
 215  * CARD32              x;
 216  * CARD32              y;
 217  * CARD32              width;
 218  * CARD32              height;
 219  */
 220 #define XA_WIN_EXPANDED_SIZE               "_WIN_EXPANDED_SIZE"
 221 /* array of 4 CARD32's */
 222
 223 /* CARD32 that contians the desktop number the application is on If the */
 224 /* application's state is "sticky" it is irrelevant. Only the WM should */
 225 /* change this. */
 226 #define XA_WIN_WORKSPACE                   "_WIN_WORKSPACE"
 227
 228 /* This atom is a 32-bit integer that is either 0 or 1 (currently). */
 229 /* 0 denotes everything is as per usual but 1 denotes that ALL configure */
 230 /* requests by the client on the client window with this property are */
 231 /* not just a simple "moving" of the window, but the result of a user */
 232 /* moving the window BUT the client handling that interaction by moving */
 233 /* its own window. The window manager should respond accordingly by assuming */
 234 /* any configure requests for this window whilst this atom is "active" in */
 235 /* the "1" state are a client move and should handle flipping desktops if */
 236 /* the window is being dragged "off screem" or across desktop boundaries */
 237 /* etc. This atom is ONLY ever set by the client */
 238 #define XA_WIN_CLIENT_MOVING               "_WIN_CLIENT_MOVING"
 239 /* WIN_CLIENT_MOVING = CARD32 */
 240
 241 /* Designed for checking if the WIN_ supporting WM is still there  */
 242 /* and kicking about - basically check this property - check the window */
 243 /* ID it points to - then check that window Id has this property too */
 244 /* if that is the case the WIN_ supporting WM is there and alive and the */
 245 /* list of WIN_PROTOCOLS is valid */
 246 #define XA_WIN_SUPPORTING_WM_CHECK         "_WIN_SUPPORTING_WM_CHECK"
 247 /* CARD32 */
 248
 249 /* for root window button clicks */
 250 #define XA_WIN_DESKTOP_BUTTON_PROXY        "_WIN_DESKTOP_BUTTON_PROXY"
 251 /* CARD32 */
 252
 253
 254 /* for the root window clicks */
 255 static Window __button_proxy = 0;
 256
 257
 258 /* how many desks does gnome know about */
 259 static int gnome_max_desk = 1;
 260
 261 static int atom_size(int format)
 262 {
 263         if (format == 32)
 264         {
 265                 return sizeof(long);
 266         }
 267         else
 268         {
 269                 return (format >> 3);
 270         }
 271 }
 272
 273 static void *
 274 AtomGet(Window win, Atom to_get, Atom type, int *size)
 275 {
 276         unsigned char *retval;
 277         Atom type_ret;
 278         unsigned long bytes_after, num_ret;
 279         int format_ret;
 280         long length;
 281         void *data;
 282
 283         retval = NULL;
 284         length = 0x7fffffff;
 285         XGetWindowProperty(
 286                 dpy, win, to_get, 0L, length, False, type, &type_ret,
 287                 &format_ret, &num_ret, &bytes_after, &retval);
 288
 289         if ((retval) && (num_ret > 0) && (format_ret > 0))
 290         {
 291                 int asize;
 292
 293                 asize = atom_size(format_ret);
 294                 data = safemalloc(num_ret * asize);
 295                 if (data)
 296                 {
 297                         memcpy(data, retval, num_ret * asize);
 298                 }
 299                 XFree(retval);
 300                 *size = num_ret * (format_ret >> 3);
 301                 return data;
 302         }
 303
 304         return NULL;
 305 }
 306
 307
 308 /*** GET WINDOW PROPERTIES ***/
 309
 310 #if 0
 311 static void
 312 GNOME_GetHintIcons(FvwmWindow *fwin)
 313 {
 314         Atom atom_get;
 315         long *retval;
 316         int size;
 317         int i;
 318         Pixmap pmap;
 319         Pixmap mask;
 320
 321         atom_get = XInternAtom(dpy, XA_WIN_ICONS, False);
 322         retval = AtomGet(FW_W(fwin), atom_get, XA_PIXMAP, &size);
 323         if (retval)
 324         {
 325                 int n;
 326
 327                 n = size / atom_size(32);
 328                 for (i = 0; i < n; i += 2)
 329                 {
 330                         pmap = retval[i];
 331                         mask = retval[i + 1];
 332                 }
 333                 free(retval);
 334         }
 335
 336         return;
 337 }
 338
 339 static void
 340 GNOME_GetHintLayer(FvwmWindow *fwin)
 341 {
 342         Atom atom_get;
 343         long *retval;
 344         int size;
 345
 346         atom_get = XInternAtom(dpy, XA_WIN_LAYER, False);
 347         retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
 348         if (retval)
 349         {
 350                 set_layer(fwin, *retval);
 351                 free(retval);
 352         }
 353
 354         return;
 355 }
 356
 357 static void
 358 GNOME_GetHintState(FvwmWindow *fwin)
 359 {
 360         Atom atom_get;
 361         long *retval;
 362         int size;
 363
 364         atom_get = XInternAtom(dpy, XA_WIN_STATE, False);
 365         retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
 366         if (retval)
 367         {
 368                 if (*retval & WIN_STATE_STICKY)
 369                 {
 370                         SET_STICKY(fwin, 1);
 371                 }
 372
 373                 if (*retval & WIN_STATE_SHADED)
 374                 {
 375                         /* Fixme: how do we find out the correct shade
 376                          * direction here? */
 377                         SET_SHADED(fwin, 1);
 378                         SET_SHADED_DIR(fwin, DIR_N);
 379                 }
 380
 381                 if (*retval & WIN_STATE_FIXED_POSITION)
 382                 {
 383                         SET_FIXED(fwin, 1);
 384                 }
 385
 386                 free(retval);
 387         }
 388
 389         return;
 390 }
 391
 392 static void
 393 GNOME_GetHintAppState(FvwmWindow *fwin)
 394 {
 395         Atom atom_get;
 396         unsigned char *retval;
 397         int size;
 398
 399         /* have nothing interesting to do with an app state (lamp) right now */
 400         atom_get = XInternAtom(dpy, XA_WIN_APP_STATE, False);
 401         retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
 402         if (retval)
 403         {
 404                 free(retval);
 405         }
 406
 407         return;
 408 }
 409
 410 static void
 411 GNOME_GetHintDesktop(FvwmWindow *fwin)
 412 {
 413         Atom atom_get;
 414         unsigned char *retval;
 415         int size;
 416         int *desk;
 417
 418         atom_get = XInternAtom(dpy, XA_WIN_WORKSPACE, False);
 419         retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
 420         if (retval)
 421         {
 422                 desk = (int *)retval;
 423                 fwin->Desk = *desk;
 424
 425                 /* XXX: hide window if it's not on the current desktop! */
 426                 free(retval);
 427         }
 428
 429         return;
 430 }
 431
 432 static void
 433 GNOME_GetHint(FvwmWindow *fwin)
 434 {
 435         Atom atom_get;
 436         int *retval;
 437         int size;
 438
 439         atom_get = XInternAtom(dpy, XA_WIN_HINTS, False);
 440         retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
 441         if (retval)
 442         {
 443                 if (*retval & WIN_HINTS_SKIP_WINLIST)
 444                 {
 445                         SET_DO_SKIP_WINDOW_LIST(fwin, 1);
 446                 }
 447                 /* XXX: unimplimented */
 448                 if (*retval & WIN_HINTS_SKIP_TASKBAR)
 449                 {
 450                         ;
 451                 }
 452                 if (*retval & WIN_HINTS_SKIP_FOCUS)
 453                 {
 454                         ;
 455                 }
 456                 if (*retval & WIN_HINTS_FOCUS_ON_CLICK)
 457                 {
 458                         ;
 459                 }
 460                 /* if (*retval & WIN_HINTS_DO_NOT_COVER);*/
 461
 462                 free(retval);
 463         }
 464
 465         return;
 466 }
 467
 468 static void
 469 GNOME_GetExpandedSize(FvwmWindow *fwin)
 470 {
 471         Atom atom_get;
 472         long *retval;
 473         int size;
 474
 475         /* unimplimented */
 476         int expanded_x, expanded_y, expanded_width, expanded_height;
 477
 478         atom_get = XInternAtom(dpy, XA_WIN_EXPANDED_SIZE, False);
 479         retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
 480         if (retval)
 481         {
 482                 expanded_x = retval[0];
 483                 expanded_y = retval[1];
 484                 expanded_width = retval[2];
 485                 expanded_height = retval[3];
 486                 free(retval);
 487         }
 488
 489         return;
 490 }
 491
 492 void
 493 GNOME_GetHints(FvwmWindow *fwin)
 494 {
 495         if (DO_IGNORE_GNOME_HINTS(fwin))
 496         {
 497                 return;
 498         }
 499         GNOME_GetHintDesktop(fwin);
 500         GNOME_GetHintIcons(fwin);
 501         GNOME_GetHintLayer(fwin);
 502         GNOME_GetHintState(fwin);
 503         GNOME_GetHintAppState(fwin);
 504         GNOME_GetHint(fwin);
 505         GNOME_GetExpandedSize(fwin);
 506
 507         return;
 508 }
 509 #endif
 510
 511 void
 512 GNOME_SetHints(FvwmWindow *fwin)
 513 {
 514         Atom atom_set;
 515         long val;
 516
 517         atom_set = XInternAtom(dpy, XA_WIN_STATE, False);
 518         val = 0;
 519
 520         if (IS_STICKY_ACROSS_PAGES(fwin) && IS_STICKY_ACROSS_DESKS(fwin))
 521         {
 522                 val |= WIN_STATE_STICKY;
 523         }
 524         if (IS_SHADED(fwin))
 525         {
 526                 val |= WIN_STATE_SHADED;
 527         }
 528         if (!is_function_allowed(F_MOVE, NULL, fwin, RQORIG_PROGRAM_US, False))
 529         {
 530                 val |= WIN_STATE_FIXED_POSITION;
 531         }
 532         XChangeProperty(
 533                 dpy, FW_W(fwin), atom_set, XA_CARDINAL, 32, PropModeReplace,
 534                 (unsigned char *)&val, 1);
 535
 536         return;
 537 }
 538
 539
 540 /* this duplicates most of the above... and it assumes
 541    that style is inizialized to zero.
 542 */
 543 void
 544 GNOME_GetStyle (FvwmWindow *fwin, window_style *style)
 545 {
 546         Atom atom_get;
 547         unsigned char *retval;
 548         int size;
 549
 550         if (S_DO_IGNORE_GNOME_HINTS(SCF(*style)))
 551         {
 552                 return;
 553         }
 554         /* Desktop */
 555         atom_get = XInternAtom(dpy, XA_WIN_WORKSPACE, False);
 556         retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
 557         if (retval)
 558         {
 559                 SSET_START_DESK(*style, *(int*)retval);
 560                 /* Allow special case of -1 to work. */
 561                 if (SGET_START_DESK(*style) > -1)
 562                 {
 563                         SSET_START_DESK(*style, SGET_START_DESK(*style) + 1);
 564                 }
 565                 style->flags.use_start_on_desk = 1;
 566                 style->flag_mask.use_start_on_desk = 1;
 567                 free(retval);
 568         }
 569
 570         /* Icons - not implemented */
 571
 572         /* Layer */
 573         atom_get = XInternAtom(dpy, XA_WIN_LAYER, False);
 574         retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
 575         if (retval)
 576         {
 577                 SSET_LAYER(*style, *(int*)retval);
 578                 style->flags.use_layer = (SGET_LAYER(*style) >= 0) ? 1 : 0;
 579                 style->flag_mask.use_layer = 1;
 580                 free(retval);
 581         }
 582
 583         /* State */
 584         atom_get = XInternAtom(dpy, XA_WIN_STATE, False);
 585         retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
 586         if (retval)
 587         {
 588                 if (*(int*)retval & WIN_STATE_STICKY)
 589                 {
 590                         S_SET_IS_STICKY_ACROSS_PAGES(SCF(*style), 1);
 591                         S_SET_IS_STICKY_ACROSS_PAGES(SCM(*style), 1);
 592                         S_SET_IS_STICKY_ACROSS_PAGES(SCC(*style), 1);
 593                         S_SET_IS_STICKY_ACROSS_DESKS(SCF(*style), 1);
 594                         S_SET_IS_STICKY_ACROSS_DESKS(SCM(*style), 1);
 595                         S_SET_IS_STICKY_ACROSS_DESKS(SCC(*style), 1);
 596                 }
 597
 598                 if (*(int*)retval & WIN_STATE_SHADED)
 599                 {
 600                         /* unimplemented, since we don't have a
 601                            start_shaded flag. SM code relies on a
 602                            separate do_shade flag, but that is ugly.
 603                         */
 604                 }
 605
 606                 if ((*(int*)retval & WIN_STATE_FIXED_POSITION))
 607                 {
 608                         S_SET_IS_FIXED(SCF(*style), 1);
 609                         S_SET_IS_FIXED(SCM(*style), 1);
 610                         S_SET_IS_FIXED(SCC(*style), 1);
 611                 }
 612
 613                 free(retval);
 614         }
 615
 616         /* App state - not implemented */
 617
 618         /* Hints */
 619         atom_get = XInternAtom(dpy, XA_WIN_HINTS, False);
 620         retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
 621         if (retval)
 622         {
 623                 if (*retval & WIN_HINTS_SKIP_WINLIST)
 624                 {
 625                         S_SET_DO_WINDOW_LIST_SKIP(SCF(*style), 1);
 626                         S_SET_DO_WINDOW_LIST_SKIP(SCM(*style), 1);
 627                         S_SET_DO_WINDOW_LIST_SKIP(SCC(*style), 1);
 628                 }
 629
 630                 free(retval);
 631         }
 632
 633         /* Expanded size - not implemented */
 634
 635         return;
 636 }
 637
 638
 639 /*** SET WINDOW PROPERTIES ***/
 640 void
 641 GNOME_SetDesk(FvwmWindow *fwin)
 642 {
 643         Atom atom_set;
 644         long val;
 645
 646         atom_set = XInternAtom(dpy, XA_WIN_WORKSPACE, False);
 647         val = fwin->Desk;
 648         if (val >= gnome_max_desk)
 649         {
 650                 GNOME_SetDeskCount();
 651         }
 652         XChangeProperty(
 653                 dpy, FW_W(fwin), atom_set, XA_CARDINAL, 32, PropModeReplace,
 654                 (unsigned char *)&val, 1);
 655
 656         return;
 657 }
 658
 659
 660 void
 661 GNOME_SetLayer(FvwmWindow *fwin)
 662 {
 663         Atom atom_set;
 664         long val;
 665
 666         atom_set = XInternAtom(dpy, XA_WIN_LAYER, False);
 667         val = get_layer(fwin);
 668         XChangeProperty(
 669                 dpy, FW_W(fwin), atom_set, XA_CARDINAL, 32, PropModeReplace,
 670                 (unsigned char *)&val, 1);
 671
 672         return;
 673 }
 674
 675
 676 /*** INITIALIZE GNOME WM SUPPORT ***/
 677
 678 /* sets the virtual desktop grid properties */
 679 void
 680 GNOME_SetAreaCount(void)
 681 {
 682         Atom atom_set;
 683         long val[2];
 684
 685         atom_set = XInternAtom(dpy, XA_WIN_AREA_COUNT, False);
 686         val[0] = (Scr.VxMax + Scr.MyDisplayWidth) / Scr.MyDisplayWidth;
 687         val[1] = (Scr.VyMax + Scr.MyDisplayHeight) / Scr.MyDisplayHeight;
 688         XChangeProperty(
 689                 dpy, Scr.Root, atom_set, XA_CARDINAL, 32, PropModeReplace,
 690                 (unsigned char *)val, 2);
 691
 692         return;
 693 }
 694
 695
 696 /* sets the property indicating the current virtual desktop
 697  * location
 698  */
 699 void
 700 GNOME_SetCurrentArea(void)
 701 {
 702         Atom atom_set;
 703         long val[2];
 704
 705         atom_set = XInternAtom(dpy, XA_WIN_AREA, False);
 706         val[0] = Scr.Vx / Scr.MyDisplayWidth;
 707         val[1] = Scr.Vy / Scr.MyDisplayHeight;
 708         XChangeProperty(
 709                 dpy, Scr.Root, atom_set, XA_CARDINAL, 32, PropModeReplace,
 710                 (unsigned char *)val, 2);
 711
 712         return;
 713 }
 714
 715 /* FIXME: what to do about negative desks ? */
 716 /* ignore them! */
 717 void
 718 GNOME_SetDeskCount(void)
 719 {
 720         Atom atom_set;
 721         long val;
 722         FvwmWindow *t;
 723
 724         atom_set = XInternAtom(dpy, XA_WIN_WORKSPACE_COUNT, False);
 725         val = 0;
 726         if (Scr.CurrentDesk > 0)
 727         {
 728                 val = Scr.CurrentDesk;
 729         }
 730         for (t = get_next_window_in_stack_ring(&Scr.FvwmRoot);
 731              t != &Scr.FvwmRoot; t = get_next_window_in_stack_ring(t))
 732         {
 733                 if (t->Desk > val)
 734                 {
 735                         val = t->Desk;
 736                 }
 737         }
 738         val++;
 739         if (gnome_max_desk > val)
 740         {
 741                 val = gnome_max_desk;
 742         }
 743         XChangeProperty(
 744                 dpy, Scr.Root, atom_set, XA_CARDINAL, 32, PropModeReplace,
 745                 (unsigned char *)&val, 1);
 746
 747         return;
 748 }
 749
 750
 751 /* XXX: this function is hard-coded to one! -JMP */
 752 void
 753 GNOME_SetCurrentDesk(void)
 754 {
 755         Atom atom_set;
 756         long val;
 757
 758         atom_set = XInternAtom(dpy, XA_WIN_WORKSPACE, False);
 759         val = (long) Scr.CurrentDesk;
 760         if (val >= gnome_max_desk)
 761         {
 762                 GNOME_SetDeskCount();
 763         }
 764         XChangeProperty(
 765                 dpy, Scr.Root, atom_set, XA_CARDINAL, 32, PropModeReplace,
 766                 (unsigned char *)&val, 1);
 767         GNOME_SetCurrentArea();
 768
 769         return;
 770 }
 771
 772
 773 /* sets the names assigned to the desktops */
 774 void
 775 GNOME_SetDeskNames(void)
 776 {
 777         Atom atom_set;
 778         XTextProperty text;
 779         char *names[1];
 780
 781         atom_set = XInternAtom(dpy, XA_WIN_WORKSPACE_NAMES, False);
 782         names[0] = "GNOME Desktop";
 783         if (XStringListToTextProperty(names, 1, &text))
 784         {
 785                 XSetTextProperty(dpy, Scr.Root, &text, atom_set);
 786                 XFree(text.value);
 787         }
 788
 789         return;
 790 }
 791
 792
 793 void
 794 GNOME_SetClientList(void)
 795 {
 796         Atom atom_set;
 797         Window *wl=NULL;
 798         int displayed=0;
 799         int i = 0;
 800         FvwmWindow *t;
 801
 802         /* Find out how many window pointers we need to store, allocate
 803          * the space and go through the list again to actually store them.
 804          */
 805         for (t = Scr.FvwmRoot.next; t; t = t->next)
 806         {
 807                 if (!DO_SKIP_WINDOW_LIST(t))
 808                 {
 809                         displayed++;
 810                 }
 811         }
 812         if(displayed)
 813         {
 814                 wl=(Window*)safemalloc(sizeof(Window*)*displayed);
 815                 for (t = Scr.FvwmRoot.next; t; t = t->next)
 816                 {
 817                         if (!DO_SKIP_WINDOW_LIST(t))
 818                         {
 819                                 wl[i++] = FW_W(t);
 820                         }
 821                 }
 822         }
 823         /* Update X */
 824         atom_set = XInternAtom(dpy, XA_WIN_CLIENT_LIST, False);
 825         XChangeProperty(
 826                 dpy, Scr.Root, atom_set, XA_CARDINAL, 32,
 827                 PropModeReplace, (unsigned char *)wl, i);
 828         if(wl)
 829                 free(wl);
 830
 831         return;
 832 }
 833
 834 void
 835 GNOME_SetWinArea(FvwmWindow *w)
 836 {
 837         Atom atom_set;
 838         long val[2];
 839
 840         atom_set = XInternAtom(dpy, XA_WIN_AREA, False);
 841
 842         if (!DO_SKIP_WINDOW_LIST(w))
 843         {
 844                 if (IsRectangleOnThisPage(&(w->g.frame), w->Desk))
 845                 {
 846                         val[0] = Scr.Vx / Scr.MyDisplayWidth;
 847                         val[1] = Scr.Vy / Scr.MyDisplayHeight;
 848                 }
 849                 else
 850                 {
 851                         val[0] = (w->g.frame.x + Scr.Vx) / Scr.MyDisplayWidth;
 852                         if (val[0] < 0 &&
 853                             w->g.frame.x + Scr.Vx + w->g.frame.width > 0)
 854                         {
 855                                 val[0] = 0;
 856                         }
 857                         val[1] = (w->g.frame.y + Scr.Vy) / Scr.MyDisplayHeight;
 858                         if (val[1] < 0 &&
 859                             w->g.frame.y + Scr.Vy + w->g.frame.height > 0)
 860                         {
 861                                 val[1] = 0;
 862                         }
 863                 }
 864                 XChangeProperty(
 865                         dpy, FW_W(w), atom_set, XA_CARDINAL, 32,
 866                         PropModeReplace, (unsigned char *)val, 2);
 867         }
 868
 869         return;
 870 }
 871
 872 void
 873 GNOME_Init(void)
 874 {
 875         int i;
 876         Atom atom_set, list[11];
 877         long val;
 878
 879         atom_set = XInternAtom(dpy, XA_WIN_PROTOCOLS, False);
 880         /* these indicate what GNOME compliance properties have been
 881          * implemented */
 882         i = 0;
 883         list[i++] = XInternAtom(dpy, XA_WIN_LAYER, False);
 884         list[i++] = XInternAtom(dpy, XA_WIN_STATE, False);
 885         list[i++] = XInternAtom(dpy, XA_WIN_HINTS, False);
 886         /* list[i++] = XInternAtom(dpy, XA_WIN_APP_STATE, False); */
 887         /* list[i++] = XInternAtom(dpy, XA_WIN_EXPANDED_SIZE, False); */
 888         /* list[i++] = XInternAtom(dpy, XA_WIN_ICONS, False); */
 889         list[i++] = XInternAtom(dpy, XA_WIN_WORKSPACE, False);
 890         list[i++] = XInternAtom(dpy, XA_WIN_WORKSPACE_COUNT, False);
 891         list[i++] = XInternAtom(dpy, XA_WIN_WORKSPACE_NAMES, False);
 892         list[i++] = XInternAtom(dpy, XA_WIN_CLIENT_LIST, False);
 893         list[i++] = XInternAtom(dpy, XA_WIN_DESKTOP_BUTTON_PROXY, False);
 894         XChangeProperty(
 895                 dpy, Scr.Root, atom_set, XA_ATOM, 32, PropModeReplace,
 896                 (unsigned char *)list, i);
 897
 898         /*--------------------------------------------------------------------
 899           why use two windows when one does just fine ?
 900           --------------------------------------------------------------------*/
 901         /* create a window which is a child of the root window and set the
 902          * XA_WIN_SUPPORTING_WM_CHECK property on it, and also set the
 903          * same property on the root window with the window ID of of the
 904          * window we just created
 905          */
 906         __button_proxy = XCreateWindow(dpy, Scr.Root, -10, -10, 10, 10, 0, 0,
 907                                        InputOnly, CopyFromParent, 0, NULL);
 908         atom_set = XInternAtom(dpy, XA_WIN_SUPPORTING_WM_CHECK, False);
 909         val = __button_proxy;
 910         XChangeProperty(
 911                 dpy, Scr.Root, atom_set, XA_CARDINAL, 32, PropModeReplace,
 912                 (unsigned char *)&val, 1);
 913         XChangeProperty(
 914                 dpy, __button_proxy, atom_set, XA_CARDINAL, 32,
 915                 PropModeReplace, (unsigned char *)&val, 1);
 916
 917         /* create a window which is the child of the root window for proxying
 918          * root window clicks
 919          */
 920         atom_set = XInternAtom(dpy, XA_WIN_DESKTOP_BUTTON_PROXY, False);
 921         XChangeProperty(
 922                 dpy, Scr.Root, atom_set, XA_CARDINAL, 32,
 923                 PropModeReplace, (unsigned char *)&val, 1);
 924         XChangeProperty(
 925                 dpy, __button_proxy, atom_set, XA_CARDINAL, 32,
 926                 PropModeReplace, (unsigned char *)&val, 1);
 927
 928         /* some initial settings */
 929         GNOME_SetDeskCount();
 930         GNOME_SetCurrentDesk();
 931         GNOME_SetDeskNames();
 932         GNOME_SetAreaCount();
 933         GNOME_SetCurrentArea();
 934         GNOME_SetClientList();
 935
 936         return;
 937 }
 938
 939
 940 /*-----------------------------------------------------------------------
 941   tell gnome how many desks to show
 942   -----------------------------------------------------------------------*/
 943 void
 944 CMD_GnomeShowDesks(F_CMD_ARGS)
 945 {
 946         int n;
 947         Atom atom_set;
 948         long val[1];
 949
 950         atom_set = XInternAtom(dpy, XA_WIN_WORKSPACE_COUNT, False);
 951         DBUG("GNOME_ShowDesks","Routine Entered");
 952         n = GetIntegerArguments(action, NULL, (int *)val, 1);
 953         if(n != 1)
 954         {
 955                 fvwm_msg(ERR, "GnomeShowDesks", "requires one argument");
 956                 return;
 957         }
 958         gnome_max_desk = val[0];
 959         XChangeProperty(
 960                 dpy, Scr.Root, atom_set, XA_CARDINAL, 32, PropModeReplace,
 961                 (unsigned char *)(&val[0]), 1);
 962
 963         return;
 964 }
 965
 966
 967 /*** RECIVING MESSAGES ***/
 968 int
 969 GNOME_ProcessClientMessage(const exec_context_t *exc)
 970 {
 971         Atom a;
 972         FvwmWindow *fw = exc->w.fw;
 973         XEvent *ev = exc->x.etrigger;
 974         long p0 = 0;
 975         long p1 = 0;
 976         const char* invalid_req = "---";
 977         const char* invalid_prop = "---";
 978
 979         if (fw != NULL  && DO_IGNORE_GNOME_HINTS(fw))
 980         {
 981                 return 0;
 982         }
 983         a = XInternAtom(dpy, XA_WIN_AREA, False);
 984         if (ev->xclient.message_type == a)
 985         {
 986                 /* convert to integer grid */
 987                 p0 = ev->xclient.data.l[0] * Scr.MyDisplayWidth;
 988                 p1 = ev->xclient.data.l[1] * Scr.MyDisplayHeight;
 989                 if (p0 < 0 || p0 > 0x7fffffff || p1 < 0 || p1 > 0x7fffffff)
 990                 {
 991                         invalid_prop = "page";
 992                         invalid_req = "_WIN_AREA";
 993                         goto err_msg;
 994                 }
 995                 MoveViewport(p0, p1, 1);
 996
 997                 return 1;
 998         }
 999         a = XInternAtom(dpy, XA_WIN_WORKSPACE, False);
1000         if (ev->xclient.message_type == a)
1001         {
1002                 p0 = ev->xclient.data.l[0];
1003                 if (p0 < 0 || p0 > 0x7fffffff)
1004                 {
1005                         invalid_prop = "desk";
1006                         invalid_req = "_WIN_WORKSPACE";
1007                         goto err_msg;
1008                 }
1009                 goto_desk(p0);
1010
1011                 return 1;
1012         }
1013         a = XInternAtom(dpy, XA_WIN_LAYER, False);
1014         if (ev->xclient.message_type == a && fw)
1015         {
1016                 p0 = ev->xclient.data.l[0];
1017                 if (p0 < 0 || p0 > 0x7fffffff)
1018                 {
1019                         invalid_prop = "layer";
1020                         invalid_req = "_WIN_LAYER";
1021                         goto err_msg;
1022                 }
1023                 new_layer(fw, p0);
1024
1025                 return 1;
1026         }
1027         a = XInternAtom(dpy, XA_WIN_STATE, False);
1028         if (ev->xclient.message_type == a && fw)
1029         {
1030                 GNOME_HandlePropRequest(
1031                         exc, ev->xclient.data.l[0], ev->xclient.data.l[1]);
1032
1033                 return 1;
1034         }
1035
1036         return 0;
1037
1038   err_msg:
1039         fvwm_msg(
1040                 WARN, "GNOME_ProcessClientMessage",
1041                 "The application window (id %#lx)\n"
1042                 "  \"%s\" has requested an invalid %s (%ld, %ld)\n"
1043                 "  using a %s client message.\n"
1044                 "    fvwm is ignoring this request.\n",
1045                 fw ? FW_W(fw) : 0, fw ? fw->name.name : "(none)", invalid_prop,
1046                 p0, p1, invalid_req);
1047         fvwm_msg_report_app_and_workers();
1048
1049         return 0;
1050
1051 }
1052
1053 void GNOME_HandlePropRequest(
1054         const exec_context_t *exc, unsigned int propm, unsigned int prop)
1055 {
1056         Atom atype;
1057         Atom a;
1058         int aformat;
1059         FvwmWindow *fwin;
1060         unsigned char *indi;
1061         unsigned long nitems, bytes_remain, oldprop;
1062         indi = (unsigned char *)&oldprop;
1063         DBUG("HandleGnomePropRequest","Routine Entered");
1064
1065         a = XInternAtom(dpy, XA_WIN_STATE, False);
1066
1067         for (fwin = Scr.FvwmRoot.next; fwin; fwin = fwin->next)
1068         {
1069                 if (FW_W(fwin) == exc->w.w)
1070                 {
1071                         break;
1072                 }
1073         }
1074         /*--------------------------------------------------------------------
1075           First change the props on the window so the gnome app knows we did
1076           something.
1077           --------------------------------------------------------------------*/
1078 #ifdef FVWM_DEBUG_MSGS
1079         fvwm_msg(
1080                 DBG, "HandleGnomePropRequest", "window is %d", (int)FW_W(fwin));
1081 #endif
1082         if (fwin == NULL)
1083         {
1084                 return;
1085         }
1086         if (DO_IGNORE_GNOME_HINTS(fwin))
1087         {
1088                 return;
1089         }
1090
1091 #ifdef FVWM_DEBUG_MSGS
1092         fvwm_msg(DBG, "HandleGnomePropRequest", "prop req is %d", prop);
1093         fvwm_msg(DBG, "HandleGnomePropRequest", "propm req is %d", propm);
1094 #endif
1095         XGetWindowProperty(dpy, FW_W(fwin), a, 0L, 3L, False, a,
1096                            &atype, &aformat, &nitems, &bytes_remain, &indi);
1097         oldprop &= ~(propm);
1098         oldprop |= (propm & prop);
1099 #ifdef FVWM_DEBUG_MSGS
1100         fvwm_msg(
1101                 DBG, "HandleGnomePropRequest", "oldprop req is %d",
1102                 (int)oldprop);
1103 #endif
1104         XChangeProperty(
1105                 dpy, FW_W(fwin), a, XA_CARDINAL, 32, PropModeReplace,
1106                 (unsigned char *)&oldprop, 1);
1107
1108         /*--------------------------------------------------------------------
1109           Then apply the requests
1110           --------------------------------------------------------------------*/
1111
1112         /*--------------------------------------------------------------------
1113           Sticky
1114           --------------------------------------------------------------------*/
1115         if (propm & WIN_STATE_STICKY)
1116         {
1117                 if (prop & WIN_STATE_STICKY)
1118                 {
1119                         SET_STICKY_ACROSS_PAGES(fwin, 1);
1120                         SET_STICKY_ACROSS_DESKS(fwin, 1);
1121                 }
1122                 else
1123                 {
1124                         SET_STICKY_ACROSS_PAGES(fwin, 0);
1125                         SET_STICKY_ACROSS_DESKS(fwin, 0);
1126                 }
1127                 border_draw_decorations(
1128                         fwin, PART_TITLE, (Scr.Hilite==fwin), True, CLEAR_ALL,
1129                         NULL, NULL);
1130         }
1131         /*--------------------------------------------------------------------
1132           WindowShade
1133           -------------------------------------------------------------------*/
1134         if (propm & WIN_STATE_SHADED)
1135         {
1136                 if (prop & WIN_STATE_SHADED)
1137                 {
1138                         /* shade up */
1139                         execute_function_override_window(
1140                                 NULL, exc, "WindowShade True", 0, fwin);
1141                 }
1142                 else
1143                 {
1144                         /* shade down */
1145                         execute_function_override_window(
1146                                 NULL, exc, "WindowShade False", 0, fwin);
1147                 }
1148         }
1149
1150         return;
1151 }
1152
1153 void
1154 GNOME_ProxyButtonEvent(const XEvent *ev)
1155 {
1156         switch (ev->type)
1157         {
1158         case ButtonPress:
1159                 XUngrabPointer(dpy, CurrentTime);
1160                 FSendEvent(
1161                         dpy, __button_proxy, False, SubstructureNotifyMask,
1162                         (XEvent *)ev);
1163                 break;
1164
1165         case ButtonRelease:
1166                 FSendEvent(
1167                         dpy, __button_proxy, False, SubstructureNotifyMask,
1168                         (XEvent *)ev);
1169                 break;
1170         }
1171
1172         return;
1173 }
1174
1175
1176 /* this is the function entered into fvwm's functions table */
1177 void
1178 CMD_GnomeButton(F_CMD_ARGS)
1179 {
1180         /* send off the button press event */
1181         GNOME_ProxyButtonEvent(exc->x.etrigger);
1182
1183         return;
1184 }