libs/Picture.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 /*
  18  * This module is all original code
  19  * by Rob Nation
  20  * Copyright 1993, Robert Nation
  21  *     You may use this code for any purpose, as long as the original
  22  *     copyright remains in the source code and all documentation
  23  */
  24 /*
  25   Changed 02/12/97 by Dan Espen:
  26   - added routines to determine color closeness, for color use reduction.
  27   Some of the logic comes from pixy2, so the copyright is below.
  28 */
  29 /*
  30  * Copyright 1996, Romano Giannetti. No guarantees or warantees or anything
  31  * are provided or implied in any way whatsoever. Use this program at your
  32  * own risk. Permission to use this program for any purpose is given,
  33  * as long as the copyright is kept intact.
  34  *
  35  * Romano Giannetti - Dipartimento di Ingegneria dell'Informazione
  36  *                    via Diotisalvi, 2  PISA
  37  * mailto:romano@iet.unipi.it
  38  * http://www.iet.unipi.it/~romano
  39  *
  40  */
  41
  42 /*
  43  *
  44  * Routines to handle initialization, loading, and removing of xpm's or mono-
  45  * icon images.
  46  *
  47  */
  48
  49 #include "config.h"
  50
  51 #include <stdio.h>
  52 #include <signal.h>
  53 #include <ctype.h>
  54
  55 #include "ftime.h"
  56
  57 #include <X11/Xlib.h>
  58 #include <X11/Xutil.h>
  59 #include <X11/Intrinsic.h>
  60
  61 #include "fvwmlib.h"
  62 #include "System.h"
  63 #include "Colorset.h"
  64 #include "Picture.h"
  65 #include "PictureUtils.h"
  66 #include "Fsvg.h"
  67
  68 static FvwmPicture *FvwmPictureList=NULL;
  69
  70 FvwmPicture *PGetFvwmPicture(
  71         Display *dpy, Window win, char *ImagePath, const char *name,
  72         FvwmPictureAttributes fpa)
  73 {
  74         char *path = PictureFindImageFile(name, ImagePath, R_OK);
  75         FvwmPicture *p;
  76
  77         if (path == NULL)
  78         {
  79                 return NULL;
  80         }
  81         p = PImageLoadFvwmPictureFromFile(dpy, win, path, fpa);
  82         if (p == NULL)
  83         {
  84                 free(path);
  85         }
  86
  87         return p;
  88 }
  89
  90 void PFreeFvwmPictureData(FvwmPicture *p)
  91 {
  92         if (!p)
  93         {
  94                 return;
  95         }
  96         if (p->alloc_pixels != NULL)
  97         {
  98                 free(p->alloc_pixels);
  99         }
 100         if(p->name!=NULL)
 101         {
 102                 free(p->name);
 103         }
 104         free(p);
 105
 106         return;
 107 }
 108
 109 FvwmPicture *PCacheFvwmPicture(
 110         Display *dpy, Window win, char *ImagePath, const char *name,
 111         FvwmPictureAttributes fpa)
 112 {
 113         char *path;
 114         char *real_path;
 115         FvwmPicture *p = FvwmPictureList;
 116
 117         /* First find the full pathname */
 118         if ((path = PictureFindImageFile(name, ImagePath, R_OK)) == NULL)
 119         {
 120                 return NULL;
 121         }
 122         /* Remove any svg rendering options from real_path */
 123         if (USE_SVG && *path == ':' &&
 124             (real_path = strchr(path + 1, ':')))
 125         {
 126                 real_path++;
 127         }
 128         else
 129         {
 130                 real_path = path;
 131         }
 132
 133         /* See if the picture is already cached */
 134         while (p)
 135         {
 136                 register char *p1, *p2;
 137
 138                 for (p1 = path, p2 = p->name; *p1 && *p2; ++p1, ++p2)
 139                 {
 140                         if (*p1 != *p2)
 141                         {
 142                                 break;
 143                         }
 144                 }
 145
 146                 /* If we have found a picture with the wanted name and stamp */
 147                 if (!*p1 && !*p2 && !isFileStampChanged(&p->stamp, real_path)
 148                     && PICTURE_FPA_AGREE(p,fpa))
 149                 {
 150                         p->count++; /* Put another weight on the picture */
 151                         free(path);
 152                         return p;
 153                 }
 154                 p=p->next;
 155         }
 156
 157         /* Not previously cached, have to load it ourself. Put it first in list
 158          */
 159         p = PImageLoadFvwmPictureFromFile(dpy, win, path, fpa);
 160         if(p)
 161         {
 162                 p->next=FvwmPictureList;
 163                 FvwmPictureList=p;
 164         }
 165         else
 166         {
 167                 free(path);
 168         }
 169
 170         return p;
 171 }
 172
 173 void PDestroyFvwmPicture(Display *dpy, FvwmPicture *p)
 174 {
 175         FvwmPicture *q = FvwmPictureList;
 176
 177         if (!p)
 178         {
 179                 return;
 180         }
 181         /* Remove a weight */
 182         if(--(p->count)>0)
 183         {
 184                 /* still too heavy? */
 185                 return;
 186         }
 187
 188         /* Let it fly */
 189         if (p->alloc_pixels != NULL)
 190         {
 191                 if (p->nalloc_pixels != 0)
 192                 {
 193                         PictureFreeColors(
 194                                 dpy, Pcmap, p->alloc_pixels, p->nalloc_pixels,
 195                                 0, p->no_limit);
 196                 }
 197                 free(p->alloc_pixels);
 198         }
 199         if(p->name!=NULL)
 200         {
 201                 free(p->name);
 202         }
 203         if(p->picture!=None)
 204         {
 205                 XFreePixmap(dpy,p->picture);
 206         }
 207         if(p->mask!=None)
 208         {
 209                 XFreePixmap(dpy,p->mask);
 210         }
 211         if(p->alpha != None)
 212         {
 213                 XFreePixmap(dpy, p->alpha);
 214         }
 215         /* Link it out of the list (it might not be there) */
 216         if(p==q) /* in head? simple */
 217         {
 218                 FvwmPictureList = p->next;
 219         }
 220         else
 221         {
 222                 while(q && q->next!=p) /* fast forward until end or found */
 223                 {
 224                         q = q->next;
 225                 }
 226                 if(q) /* not end? means we found it in there, possibly at end */
 227                 {
 228                         q->next = p->next; /* link around it */
 229                 }
 230         }
 231         free(p);
 232
 233         return;
 234 }
 235
 236 FvwmPicture *PLoadFvwmPictureFromPixmap(
 237         Display *dpy, Window win, char *name, Pixmap pixmap,
 238         Pixmap mask, Pixmap alpha, int width, int height, int nalloc_pixels,
 239         Pixel *alloc_pixels, int no_limit)
 240 {
 241         FvwmPicture *q;
 242
 243         q = (FvwmPicture*)safemalloc(sizeof(FvwmPicture));
 244         memset(q, 0, sizeof(FvwmPicture));
 245         q->count = 1;
 246         q->name = name;
 247         q->next = NULL;
 248         q->stamp = pixmap;
 249         q->picture = pixmap;
 250         q->mask = mask;
 251         q->alpha = alpha;
 252         q->width = width;
 253         q->height = height;
 254         q->depth = Pdepth;
 255         q->nalloc_pixels = nalloc_pixels;
 256         q->alloc_pixels = alloc_pixels;
 257         q->no_limit = no_limit;
 258         return q;
 259 }
 260
 261 FvwmPicture *PCacheFvwmPictureFromPixmap(
 262         Display *dpy, Window win, char *name, Pixmap pixmap,
 263         Pixmap mask, Pixmap alpha, int width, int height, int nalloc_pixels,
 264         Pixel *alloc_pixels, int no_limit)
 265 {
 266         FvwmPicture *p = FvwmPictureList;
 267
 268         /* See if the picture is already cached */
 269         for(; p != NULL; p = p->next)
 270         {
 271 #if 0
 272                 /* at th present time no good way to cache a pixmap */
 273                 if (!strcmp(p->name,name))
 274                 {
 275                         p->count++;
 276                         return p;
 277                 }
 278 #endif
 279         }
 280
 281         /* Not previously cached, have to load. Put it first in list */
 282         p = PLoadFvwmPictureFromPixmap(
 283                 dpy, win, name, pixmap, mask, alpha, width, height,
 284                 nalloc_pixels, alloc_pixels, no_limit);
 285         if(p)
 286         {
 287                 p->next = FvwmPictureList;
 288                 FvwmPictureList = p;
 289         }
 290
 291         return p;
 292 }
 293
 294 FvwmPicture *PCloneFvwmPicture(FvwmPicture *pic)
 295 {
 296         if (pic != NULL)
 297         {
 298                 pic->count++;
 299         }
 300
 301         return pic;
 302 }
 303
 304 void PicturePrintImageCache(int verbose)
 305 {
 306         FvwmPicture *p;
 307         unsigned int count = 0;
 308         unsigned int hits = 0;
 309         unsigned int num_alpha = 0;
 310         unsigned int num_mask = 0;
 311
 312         fflush(stderr);
 313         fflush(stdout);
 314         fprintf(stderr, "fvwm info on Image cache:\n");
 315
 316         for (p = FvwmPictureList; p != NULL; p = p->next)
 317         {
 318                 int num_pixmaps = 1;
 319                 if (p->mask != None)
 320                 {
 321                         num_mask++;
 322                         num_pixmaps++;
 323                 }
 324                 if (p->alpha != None)
 325                 {
 326                         num_alpha++;
 327                         num_pixmaps++;
 328                 }
 329                 if (verbose > 0)
 330                 {
 331                         fprintf(stderr,
 332                                 "Image: %s (%d pixmaps; used %d times)\n",
 333                                 p->name, num_pixmaps, p->count);
 334                 }
 335                 count++;
 336                 hits += p->count-1;
 337         }
 338
 339         fprintf(stderr, "%u images in cache (%d reuses) "
 340                 "(%u masks, %u alpha channels => %u pixmaps)\n",
 341                 count, hits, num_mask, num_alpha, count + num_mask + num_alpha);
 342         fflush(stderr);
 343 }