git.hungrycats.org Git - xscreensaver/blob - utils/logo.c

   1 /* xscreensaver, Copyright (c) 2001-2002 Jamie Zawinski <jwz@jwz.org>
   2  *
   3  * Permission to use, copy, modify, distribute, and sell this software and its
   4  * documentation for any purpose is hereby granted without fee, provided that
   5  * the above copyright notice appear in all copies and that both that
   6  * copyright notice and this permission notice appear in supporting
   7  * documentation.  No representations are made about the suitability of this
   8  * software for any purpose.  It is provided "as is" without express or
   9  * implied warranty.
  10  */
  11
  12 /* XScreenSaver Logo designed by Angela Goodman <rzr_grl@yahoo.com>
  13  */
  14
  15 /* I basically implemented libXPM here, because I don't want the
  16    xscreensaver daemon to depend on libXPM for two reasons: first,
  17    because I want the logo to show up even if libXPM is not installed
  18    on the system; and second, I don't want to have to security-audit
  19    libXPM.  The fewer libraries that are linked into the xscreensaver
  20    daemon, the more likely to be secure it is.
  21  */
  22
  23 /* If you are looking in here because you're trying to figure out how to
  24    change the logo that xscreensaver displays on the splash screen and
  25    password dialog, please don't.  The logo is xscreensaver's identity.
  26    You wouldn't alter the name or copyright notice on a program that
  27    you didn't write; please don't alter its logo either.
  28  */
  29
  30 #include "utils.h"
  31 #include "resources.h"
  32
  33 #include <stdio.h>
  34 #include <X11/Xutil.h>
  35
  36 #include "images/logo-50.xpm"
  37 #include "images/logo-180.xpm"
  38
  39 static const char hex[128] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  40                               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  41                               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  42                               0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0,
  43                               0, 10,11,12,13,14,15,0, 0, 0, 0, 0, 0, 0, 0, 0,
  44                               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  45                               0, 10,11,12,13,14,15,0, 0, 0, 0, 0, 0, 0, 0, 0,
  46                               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  47
  48 static XImage *
  49 parse_xpm_data (Display *dpy, Visual *visual, Colormap colormap, int depth,
  50                 unsigned long transparent_color,
  51                 unsigned const char * const * data,
  52                 int *width_ret, int *height_ret,
  53                 unsigned long **pixels_ret, int *npixels_ret,
  54                 unsigned char **mask_ret)
  55 {
  56   int w, w8, h, ncolors, nbytes;
  57   char c;
  58   int i, pixel_count;
  59   struct {
  60     char byte;
  61     int cr; int cg; int cb;
  62     int mr; int mg; int mb;
  63   } cmap[256];
  64   unsigned char rmap[256];
  65
  66   unsigned long *pixels;
  67   XImage *ximage = 0;
  68
  69   if (4 != sscanf ((const char *) *data,
  70                    "%d %d %d %d %c", &w, &h, &ncolors, &nbytes, &c))
  71     abort();
  72   if (ncolors < 1 || ncolors > 255)
  73     abort();
  74   if (nbytes != 1)
  75     abort();
  76   data++;
  77
  78   w8 = (w + 8) / 8;
  79
  80   if (mask_ret)
  81     {
  82       int s = (w8 * h) + 1;
  83       *mask_ret = (unsigned char *) malloc (s);
  84       if (!*mask_ret)
  85         mask_ret = 0;
  86       else
  87         memset (*mask_ret, 255, s);
  88     }
  89
  90   for (i = 0; i < ncolors; i++)
  91     {
  92       const unsigned char *line = *data;
  93       cmap[i].byte = *line++;
  94       while (*line)
  95         {
  96           int r, g, b;
  97           char which;
  98           while (*line == ' ' || *line == '\t')
  99             line++;
 100           which = *line++;
 101           if (which != 'c' && which != 'm')
 102             abort();
 103           while (*line == ' ' || *line == '\t')
 104             line++;
 105           if (!strncasecmp(line, "None", 4))
 106             {
 107               r = g = b = -1;
 108               line += 4;
 109             }
 110           else
 111             {
 112               if (*line == '#')
 113                 line++;
 114               r = (hex[(int) line[0]] << 4) | hex[(int) line[1]]; line += 2;
 115               g = (hex[(int) line[0]] << 4) | hex[(int) line[1]]; line += 2;
 116               b = (hex[(int) line[0]] << 4) | hex[(int) line[1]]; line += 2;
 117             }
 118
 119           if (which == 'c')
 120             {
 121               cmap[i].cr = r;
 122               cmap[i].cg = g;
 123               cmap[i].cb = b;
 124             }
 125           else
 126             {
 127               cmap[i].mr = r;
 128               cmap[i].mg = g;
 129               cmap[i].mb = b;
 130             }
 131         }
 132
 133       data++;
 134     }
 135
 136   if (depth == 1) transparent_color = 1;
 137
 138   pixels = (unsigned long *) calloc (ncolors+1, sizeof(*pixels));
 139   pixel_count = 0;
 140   for (i = 0; i < ncolors; i++)
 141     {
 142       if (cmap[i].cr == -1) /* transparent */
 143         {
 144           rmap[(int) cmap[i].byte] = 255;
 145         }
 146       else
 147         {
 148           XColor color;
 149           color.flags = DoRed|DoGreen|DoBlue;
 150           color.red   = (cmap[i].cr << 8) | cmap[i].cr;
 151           color.green = (cmap[i].cg << 8) | cmap[i].cg;
 152           color.blue  = (cmap[i].cb << 8) | cmap[i].cb;
 153           if (depth == 1 ||
 154               !XAllocColor (dpy, colormap, &color))
 155             {
 156               color.red   = (cmap[i].mr << 8) | cmap[i].mr;
 157               color.green = (cmap[i].mg << 8) | cmap[i].mg;
 158               color.blue  = (cmap[i].mb << 8) | cmap[i].mb;
 159               if (!XAllocColor (dpy, colormap, &color))
 160                 abort();
 161             }
 162           pixels[pixel_count] = color.pixel;
 163           rmap[(int) cmap[i].byte] = pixel_count;
 164           pixel_count++;
 165         }
 166     }
 167
 168   ximage = XCreateImage (dpy, visual, depth,
 169                          (depth == 1 ? XYBitmap : ZPixmap),
 170                          0, 0, w, h, 8, 0);
 171   if (ximage)
 172     {
 173       int x, y;
 174       ximage->data = (char *) calloc (ximage->height, ximage->bytes_per_line);
 175       for (y = 0; y < h; y++)
 176         {
 177           const unsigned char *line = *data++;
 178           for (x = 0; x < w; x++)
 179             {
 180               int p = rmap[*line++];
 181               XPutPixel (ximage, x, y,
 182                          (p == 255 ? transparent_color : pixels[p]));
 183
 184               if (p == 255 && mask_ret)
 185                 (*mask_ret)[(y * w8) + (x >> 3)] &= (~(1 << (x % 8)));
 186             }
 187         }
 188     }
 189
 190   *width_ret = w;
 191   *height_ret = h;
 192   *pixels_ret = pixels;
 193   *npixels_ret = pixel_count;
 194   return ximage;
 195 }
 196
 197
 198
 199 /* Draws the logo centered in the given Drawable (presumably a Pixmap.)
 200    next_frame_p means randomize the flame shape.
 201  */
 202 Pixmap
 203 xscreensaver_logo (Display *dpy, Window window, Colormap cmap,
 204                    unsigned long background_color,
 205                    unsigned long **pixels_ret, int *npixels_ret,
 206                    Pixmap *mask_ret,
 207                    Bool big_p)
 208 {
 209   int iw, ih;
 210   XImage *image;
 211   Pixmap p = 0;
 212   XWindowAttributes xgwa;
 213   unsigned char *mask = 0;
 214
 215   XGetWindowAttributes (dpy, window, &xgwa);
 216
 217   image = parse_xpm_data (dpy, xgwa.visual, xgwa.colormap, xgwa.depth,
 218                           background_color,
 219                           (big_p ? logo_180_xpm : logo_50_xpm),
 220                           &iw, &ih, pixels_ret, npixels_ret,
 221                           (mask_ret ? &mask : 0));
 222
 223   if (image)
 224     {
 225       XGCValues gcv;
 226       GC gc;
 227       p = XCreatePixmap (dpy, window, iw, ih, xgwa.depth);
 228       gc = XCreateGC (dpy, p, 0, &gcv);
 229       XPutImage (dpy, p, gc, image, 0, 0, 0, 0, iw, ih);
 230       free (image->data);
 231       image->data = 0;
 232       XDestroyImage (image);
 233       XFreeGC (dpy, gc);
 234
 235       if (mask_ret && mask)
 236         {
 237           *mask_ret = (Pixmap)
 238             XCreatePixmapFromBitmapData (dpy, window, (char *) mask,
 239                                          iw, ih, 1L, 0L, 1);
 240           free (mask);
 241         }
 242     }
 243   return p;
 244 }