fvwm/colormaps.c

   1 /* -*-c-*- */
   2 /* This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /* This module is all new
  18  * by Rob Nation
  19  *
  20  * This code handles colormaps for fvwm.
  21  *
  22  * Copyright 1994 Robert Nation. No restrictions are placed on this code,
  23  * as long as the copyright notice is preserved . No guarantees or
  24  * warrantees of any sort whatsoever are given or implied or anything.
  25  */
  26
  27 /* ---------------------------- included header files ---------------------- */
  28
  29 #include "config.h"
  30
  31 #include <stdio.h>
  32
  33 #include "libs/fvwmlib.h"
  34 #include "fvwm.h"
  35 #include "externs.h"
  36 #include "cursor.h"
  37 #include "execcontext.h"
  38 #include "eventhandler.h"
  39 #include "functions.h"
  40 #include "bindings.h"
  41 #include "misc.h"
  42 #include "screen.h"
  43 #include "colormaps.h"
  44
  45 /* ---------------------------- local definitions -------------------------- */
  46
  47 /* ---------------------------- local macros ------------------------------- */
  48
  49 /* ---------------------------- imports ------------------------------------ */
  50
  51 /* ---------------------------- included code files ------------------------ */
  52
  53 /* ---------------------------- local types -------------------------------- */
  54
  55 /* ---------------------------- forward declarations ----------------------- */
  56
  57 /* ---------------------------- local variables ---------------------------- */
  58
  59 static Bool client_controls_colormaps = False;
  60 static Colormap last_cmap = None;
  61
  62 /* ---------------------------- exported variables (globals) --------------- */
  63
  64 const FvwmWindow *colormap_win;
  65
  66 /* ---------------------------- local functions ---------------------------- */
  67
  68 /* ---------------------------- interface functions ------------------------ */
  69
  70 void set_client_controls_colormaps(Bool flag)
  71 {
  72         client_controls_colormaps = flag;
  73
  74         return;
  75 }
  76
  77 /* HandleColormapNotify - colormap notify event handler
  78  *
  79  * This procedure handles both a client changing its own colormap, and
  80  * a client explicitly installing its colormap itself (only the window
  81  * manager should do that, so we must set it correctly).
  82  */
  83 void colormap_handle_colormap_notify(const evh_args_t *ea)
  84 {
  85         XEvent evdummy;
  86         XColormapEvent *cevent = (XColormapEvent *)ea->exc->x.etrigger;
  87         Bool ReInstall = False;
  88         XWindowAttributes attr;
  89         FvwmWindow *fw = ea->exc->w.fw;
  90
  91         if (!fw)
  92         {
  93                 return;
  94         }
  95         if (cevent->new)
  96         {
  97                 if (XGetWindowAttributes(dpy, FW_W(fw), &attr) != 0)
  98                 {
  99                         fw->attr_backup.colormap = attr.colormap;
 100                         if (fw == colormap_win &&
 101                             fw->number_cmap_windows == 0)
 102                         {
 103                                 last_cmap = attr.colormap;
 104                         }
 105                         ReInstall = True;
 106                 }
 107         }
 108         else if ((cevent->state == ColormapUninstalled)&&
 109                 (last_cmap == cevent->colormap))
 110         {
 111                 /* Some window installed its colormap, change it back */
 112                 ReInstall = True;
 113         }
 114
 115         while (FCheckTypedEvent(dpy, ColormapNotify, &evdummy))
 116         {
 117                 if (XFindContext(
 118                             dpy, cevent->window, FvwmContext,
 119                             (caddr_t *) &fw) == XCNOENT)
 120                 {
 121                         fw = NULL;
 122                 }
 123                 if ((fw)&&(cevent->new))
 124                 {
 125                         if (XGetWindowAttributes(dpy, FW_W(fw), &attr) != 0)
 126                         {
 127                                 fw->attr_backup.colormap = attr.colormap;
 128                                 if (fw == colormap_win &&
 129                                     fw->number_cmap_windows == 0)
 130                                 {
 131                                         last_cmap = attr.colormap;
 132                                 }
 133                                 ReInstall = True;
 134                         }
 135                 }
 136                 else if ((fw)&&
 137                         (cevent->state == ColormapUninstalled)&&
 138                         (last_cmap == cevent->colormap))
 139                 {
 140                         /* Some window installed its colormap, change it back */
 141                         ReInstall = True;
 142                 }
 143                 else if ((fw)&&
 144                         (cevent->state == ColormapInstalled)&&
 145                         (last_cmap == cevent->colormap))
 146                 {
 147                         /* The last color map installed was the correct one.
 148                          * Do not change anything */
 149                         ReInstall = False;
 150                 }
 151         }
 152
 153         /* Reinstall the colormap that we think should be installed,
 154          * UNLESS and unrecognized window has the focus - it might be
 155          * an override-redirect window that has its own colormap. */
 156         if (ReInstall && Scr.UnknownWinFocused == None &&
 157             !client_controls_colormaps)
 158         {
 159                 XInstallColormap(dpy,last_cmap);
 160         }
 161
 162         return;
 163 }
 164
 165 /* Re-Install the active colormap */
 166 void ReInstallActiveColormap(void)
 167 {
 168         InstallWindowColormaps(colormap_win);
 169
 170         return;
 171 }
 172
 173 /*  Procedure:
 174  *      InstallWindowColormaps - install the colormaps for one fvwm window
 175  *
 176  *  Inputs:
 177  *      type    - type of event that caused the installation
 178  *      tmp     - for a subset of event types, the address of the
 179  *                window structure, whose colormaps are to be installed.
 180  */
 181 void InstallWindowColormaps(const FvwmWindow *fw)
 182 {
 183         int i;
 184         XWindowAttributes attributes;
 185         Window w;
 186         Bool ThisWinInstalled = False;
 187
 188         /* If no window, then install fvwm colormap */
 189         if (!fw)
 190         {
 191                 fw = &Scr.FvwmRoot;
 192         }
 193
 194         colormap_win = fw;
 195         /* Save the colormap to be loaded for when force loading of
 196          * root colormap(s) ends.
 197          */
 198         Scr.pushed_window = fw;
 199         /* Don't load any new colormap if root/fvwm colormap(s) has been
 200          * force loaded.
 201          */
 202         if (Scr.root_pushes || Scr.fvwm_pushes || client_controls_colormaps)
 203         {
 204                 return;
 205         }
 206
 207         if (fw->number_cmap_windows > 0)
 208         {
 209                 for (i=fw->number_cmap_windows -1; i>=0;i--)
 210                 {
 211                         w = fw->cmap_windows[i];
 212                         if (w == FW_W(fw))
 213                         {
 214                                 ThisWinInstalled = True;
 215                         }
 216                         if (!XGetWindowAttributes(dpy,w,&attributes))
 217                         {
 218                                 attributes.colormap = last_cmap;
 219                         }
 220
 221                         /*
 222                          * On Sun X servers, don't install 24 bit TrueColor
 223                          * colourmaps.  Despite what the server says, these
 224                          * colourmaps are always installed. */
 225                         if (last_cmap != attributes.colormap
 226 #if defined(sun) && defined(TRUECOLOR_ALWAYS_INSTALLED)
 227                            && !(attributes.depth == 24 &&
 228                                 attributes.visual->class == TrueColor)
 229 #endif
 230                                 )
 231                         {
 232                                 last_cmap = attributes.colormap;
 233                                 XInstallColormap(dpy, last_cmap);
 234                         }
 235                 }
 236         }
 237
 238         if (!ThisWinInstalled)
 239         {
 240                 if (last_cmap != fw->attr_backup.colormap
 241 #if defined(sun) && defined(TRUECOLOR_ALWAYS_INSTALLED)
 242                    && !(fw->attr_backup.depth == 24 &&
 243                         fw->attr_backup.visual->class == TrueColor)
 244 #endif
 245                         )
 246                 {
 247                         last_cmap = fw->attr_backup.colormap;
 248                         XInstallColormap(dpy, last_cmap);
 249                 }
 250         }
 251
 252         return;
 253 }
 254
 255
 256 /* Force (un)loads root colormap(s)
 257  *
 258  * These matching routines provide a mechanism to insure that
 259  * the root colormap(s) is installed during operations like
 260  * rubber banding that require colors from
 261  * that colormap.  Calls may be nested arbitrarily deeply,
 262  * as long as there is one UninstallRootColormap call per
 263  * InstallRootColormap call.
 264  *
 265  * {Uni,I}nstall{Root,Fvwm}Colormap calls may be freely intermixed
 266  */
 267 void InstallRootColormap(void)
 268 {
 269         if (last_cmap != DefaultColormap(dpy, Scr.screen))
 270         {
 271                 last_cmap = DefaultColormap(dpy, Scr.screen);
 272                 XInstallColormap(dpy, last_cmap);
 273         }
 274         Scr.root_pushes++;
 275
 276         return;
 277 }
 278
 279 /* Unstacks one layer of root colormap pushing
 280  * If we peel off the last layer, re-install the application colormap
 281  * or the fvwm colormap if fvwm has a menu posted
 282  */
 283 void UninstallRootColormap(void)
 284 {
 285         if (Scr.root_pushes)
 286         {
 287                 Scr.root_pushes--;
 288         }
 289
 290         if (!Scr.root_pushes)
 291         {
 292                 if (!Scr.fvwm_pushes)
 293                 {
 294                         InstallWindowColormaps(Scr.pushed_window);
 295                 }
 296                 else if (last_cmap != Pcmap)
 297                 {
 298                         last_cmap = Pcmap;
 299                         XInstallColormap(dpy, last_cmap);
 300                 }
 301         }
 302
 303         return;
 304 }
 305
 306 /*  Procedures:
 307  *      {Uni/I}nstallFvwmColormap - Force (un)loads fvwm colormap(s)
 308  *      This is used to ensure the fvwm colormap is installed during
 309  *      menu operations
 310  */
 311 void InstallFvwmColormap(void)
 312 {
 313         if (last_cmap != Pcmap)
 314         {
 315                 last_cmap = Pcmap;
 316                 XInstallColormap(dpy, last_cmap);
 317         }
 318         Scr.fvwm_pushes++;
 319
 320         return;
 321 }
 322
 323 void UninstallFvwmColormap(void)
 324 {
 325         if (Scr.fvwm_pushes)
 326         {
 327                 Scr.fvwm_pushes--;
 328         }
 329
 330         if (!Scr.fvwm_pushes)
 331         {
 332                 if (!Scr.root_pushes)
 333                 {
 334                         InstallWindowColormaps(Scr.pushed_window);
 335                 }
 336                 else if (last_cmap != DefaultColormap(dpy, Scr.screen))
 337                 {
 338                         last_cmap = DefaultColormap(dpy, Scr.screen);
 339                         XInstallColormap(dpy, last_cmap);
 340                 }
 341         }
 342
 343         return;
 344 }
 345
 346 /* Gets the WM_COLORMAP_WINDOWS property from the window
 347  *
 348  * This property typically doesn't exist, but a few applications
 349  * use it. These seem to occur mostly on SGI machines.
 350  */
 351 void FetchWmColormapWindows (FvwmWindow *fw)
 352 {
 353         XWindowAttributes getattribs;
 354         XSetWindowAttributes setattribs;
 355         long i;
 356         unsigned long valuemask;
 357
 358         if (fw->cmap_windows != (Window *)NULL)
 359         {
 360                 XFree((void *)fw->cmap_windows);
 361         }
 362
 363         if (!XGetWMColormapWindows (dpy, FW_W(fw), &(fw->cmap_windows),
 364                                    &(fw->number_cmap_windows)))
 365         {
 366                 fw->number_cmap_windows = 0;
 367                 fw->cmap_windows = NULL;
 368         }
 369         /* we need to be notified of Enter events into these subwindows
 370          * so we can set their colormaps */
 371         if (fw->number_cmap_windows != 0)
 372         {
 373                 for (i = 0; i < fw->number_cmap_windows; i++)
 374                 {
 375                         if (XGetWindowAttributes(
 376                                     dpy, fw->cmap_windows[i], &getattribs))
 377                         {
 378                                 valuemask = CWEventMask;
 379                                 setattribs.event_mask =
 380                                         getattribs.your_event_mask |
 381                                         EnterWindowMask | LeaveWindowMask;
 382                                 XChangeWindowAttributes(
 383                                         dpy, fw->cmap_windows[i], valuemask,
 384                                         &setattribs);
 385                         }
 386                 }
 387         }
 388         return;
 389 }
 390
 391 /* Looks through the window list for any matching COLORMAP_WINDOWS
 392  *   windows and installs the colormap if one exists.
 393  */
 394 void EnterSubWindowColormap(Window win)
 395 {
 396         FvwmWindow         *t;
 397         long                i;
 398         XWindowAttributes   attribs;
 399
 400         for (t = Scr.FvwmRoot.next; t != NULL; t = t->next)
 401         {
 402                 if (t->number_cmap_windows != 0)
 403                 {
 404                         for (i = 0; i < t->number_cmap_windows; i++)
 405                         {
 406                                 if (t->cmap_windows[i] == win)
 407                                 {
 408                                         if (XGetWindowAttributes(
 409                                                     dpy,win,&attribs))
 410                                         {
 411                                                 last_cmap = attribs.colormap;
 412                                                 XInstallColormap(
 413                                                         dpy, last_cmap);
 414                                         }
 415                                         return;
 416                                 }
 417                         }
 418                 }
 419         }
 420
 421         return;
 422 }
 423
 424 void LeaveSubWindowColormap(Window win)
 425 {
 426         FvwmWindow *t;
 427         long i;
 428         int bWinInList, bParentInList;
 429
 430         for (t = Scr.FvwmRoot.next; t != NULL; t = t->next)
 431         {
 432                 if (t->number_cmap_windows != 0)
 433                 {
 434                         bWinInList = 0;
 435                         bParentInList = 0;
 436                         for (i=0;i<t->number_cmap_windows;i++)
 437                         {
 438                                 if (t->cmap_windows[i] == win)
 439                                 {
 440                                         bWinInList = 1;
 441                                 }
 442                                 if (t->cmap_windows[i] == FW_W(t))
 443                                 {
 444                                         bParentInList = 1;
 445                                 }
 446                         }
 447                         if (bWinInList)
 448                         {
 449                                 if (bParentInList)
 450                                 {
 451                                         InstallWindowColormaps(t);
 452                                 }
 453                                 else
 454                                 {
 455                                         InstallWindowColormaps(NULL);
 456                                 }
 457                                 return;
 458                         }
 459                 }
 460         }
 461
 462         return;
 463 }