File indexing completed on 2024-05-19 05:31:17

 /*
  * Copyright © 2002 Keith Packard
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sublicense, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
  *
  * The above copyright notice and this permission notice (including the
  * next paragraph) shall be included in all copies or substantial
  * portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
 
 #define _DEFAULT_SOURCE
 #include "xcursor.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <dirent.h>
 
 /*
  * From libXcursor/include/X11/extensions/Xcursor.h
  */
 
 #define XcursorTrue 1
 #define XcursorFalse    0
 
 /*
  * Cursor files start with a header.  The header
  * contains a magic number, a version number and a
  * table of contents which has type and offset information
  * for the remaining tables in the file.
  *
  * File minor versions increment for compatible changes
  * File major versions increment for incompatible changes (never, we hope)
  *
  * Chunks of the same type are always upward compatible.  Incompatible
  * changes are made with new chunk types; the old data can remain under
  * the old type.  Upward compatible changes can add header data as the
  * header lengths are specified in the file.
  *
  *  File:
  *  FileHeader
  *  LISTofChunk
  *
  *  FileHeader:
  *  CARD32      magic       magic number
  *  CARD32      header      bytes in file header
  *  CARD32      version     file version
  *  CARD32      ntoc        number of toc entries
  *  LISTofFileToc   toc     table of contents
  *
  *  FileToc:
  *  CARD32      type        entry type
  *  CARD32      subtype     entry subtype (size for images)
  *  CARD32      position    absolute file position
  */
 
 #define XCURSOR_MAGIC   0x72756358  /* "Xcur" LSBFirst */
 
 /*
  * Current Xcursor version number.  Will be substituted by configure
  * from the version in the libXcursor configure.ac file.
  */
 
 #define XCURSOR_LIB_MAJOR 1
 #define XCURSOR_LIB_MINOR 1
 #define XCURSOR_LIB_REVISION 13
 #define XCURSOR_LIB_VERSION ((XCURSOR_LIB_MAJOR * 10000) + \
                  (XCURSOR_LIB_MINOR * 100) + \
                  (XCURSOR_LIB_REVISION))
 
 /*
  * This version number is stored in cursor files; changes to the
  * file format require updating this version number
  */
 #define XCURSOR_FILE_MAJOR  1
 #define XCURSOR_FILE_MINOR  0
 #define XCURSOR_FILE_VERSION    ((XCURSOR_FILE_MAJOR << 16) | (XCURSOR_FILE_MINOR))
 #define XCURSOR_FILE_HEADER_LEN (4 * 4)
 #define XCURSOR_FILE_TOC_LEN    (3 * 4)
 
 typedef struct _XcursorFileToc {
     XcursorUInt     type;   /* chunk type */
     XcursorUInt     subtype;    /* subtype (size for images) */
     XcursorUInt     position;   /* absolute position in file */
 } XcursorFileToc;
 
 typedef struct _XcursorFileHeader {
     XcursorUInt     magic;  /* magic number */
     XcursorUInt     header; /* byte length of header */
     XcursorUInt     version;    /* file version number */
     XcursorUInt     ntoc;   /* number of toc entries */
     XcursorFileToc  *tocs;  /* table of contents */
 } XcursorFileHeader;
 
 /*
  * The rest of the file is a list of chunks, each tagged by type
  * and version.
  *
  *  Chunk:
  *  ChunkHeader
  *  <extra type-specific header fields>
  *  <type-specific data>
  *
  *  ChunkHeader:
  *  CARD32      header  bytes in chunk header + type header
  *  CARD32      type    chunk type
  *  CARD32      subtype chunk subtype
  *  CARD32      version chunk type version
  */
 
 #define XCURSOR_CHUNK_HEADER_LEN    (4 * 4)
 
 typedef struct _XcursorChunkHeader {
     XcursorUInt     header; /* bytes in chunk header */
     XcursorUInt     type;   /* chunk type */
     XcursorUInt     subtype;    /* chunk subtype (size for images) */
     XcursorUInt     version;    /* version of this type */
 } XcursorChunkHeader;
 
 /*
  * Here's a list of the known chunk types
  */
 
 /*
  * Comments consist of a 4-byte length field followed by
  * UTF-8 encoded text
  *
  *  Comment:
  *  ChunkHeader header  chunk header
  *  CARD32      length  bytes in text
  *  LISTofCARD8 text    UTF-8 encoded text
  */
 
 #define XCURSOR_COMMENT_TYPE        0xfffe0001
 #define XCURSOR_COMMENT_VERSION     1
 #define XCURSOR_COMMENT_HEADER_LEN  (XCURSOR_CHUNK_HEADER_LEN + (1 *4))
 #define XCURSOR_COMMENT_COPYRIGHT   1
 #define XCURSOR_COMMENT_LICENSE     2
 #define XCURSOR_COMMENT_OTHER       3
 #define XCURSOR_COMMENT_MAX_LEN     0x100000
 
 typedef struct _XcursorComment {
     XcursorUInt     version;
     XcursorUInt     comment_type;
     char        *comment;
 } XcursorComment;
 
 /*
  * Each cursor image occupies a separate image chunk.
  * The length of the image header follows the chunk header
  * so that future versions can extend the header without
  * breaking older applications
  *
  *  Image:
  *  ChunkHeader header  chunk header
  *  CARD32      width   actual width
  *  CARD32      height  actual height
  *  CARD32      xhot    hot spot x
  *  CARD32      yhot    hot spot y
  *  CARD32      delay   animation delay
  *  LISTofCARD32    pixels  ARGB pixels
  */
 
 #define XCURSOR_IMAGE_TYPE          0xfffd0002
 #define XCURSOR_IMAGE_VERSION       1
 #define XCURSOR_IMAGE_HEADER_LEN    (XCURSOR_CHUNK_HEADER_LEN + (5*4))
 #define XCURSOR_IMAGE_MAX_SIZE      0x7fff  /* 32767x32767 max cursor size */
 
 typedef struct _XcursorFile XcursorFile;
 
 struct _XcursorFile {
     void    *closure;
     int     (*read)  (XcursorFile *file, unsigned char *buf, int len);
     int     (*write) (XcursorFile *file, unsigned char *buf, int len);
     int     (*seek)  (XcursorFile *file, long offset, int whence);
 };
 
 typedef struct _XcursorComments {
     int         ncomment;   /* number of comments */
     XcursorComment  **comments; /* array of XcursorComment pointers */
 } XcursorComments;
 
 /*
  * From libXcursor/src/file.c
  */
 
 static XcursorImage *
 XcursorImageCreate (int width, int height)
 {
     XcursorImage    *image;
 
     if (width < 0 || height < 0)
        return NULL;
     if (width > XCURSOR_IMAGE_MAX_SIZE || height > XCURSOR_IMAGE_MAX_SIZE)
        return NULL;
 
     image = malloc (sizeof (XcursorImage) +
             width * height * sizeof (XcursorPixel));
     if (!image)
     return NULL;
     image->version = XCURSOR_IMAGE_VERSION;
     image->pixels = (XcursorPixel *) (image + 1);
     image->size = width > height ? width : height;
     image->width = width;
     image->height = height;
     image->delay = 0;
     return image;
 }
 
 static void
 XcursorImageDestroy (XcursorImage *image)
 {
     free (image);
 }
 
 static XcursorImages *
 XcursorImagesCreate (int size)
 {
     XcursorImages   *images;
 
     images = malloc (sizeof (XcursorImages) +
              size * sizeof (XcursorImage *));
     if (!images)
     return NULL;
     images->nimage = 0;
     images->images = (XcursorImage **) (images + 1);
     return images;
 }
 
 void
 XcursorImagesDestroy (XcursorImages *images)
 {
     int n;
 
     if (!images)
         return;
 
     for (n = 0; n < images->nimage; n++)
     XcursorImageDestroy (images->images[n]);
     free (images);
 }
 
 static XcursorBool
 _XcursorReadUInt (XcursorFile *file, XcursorUInt *u)
 {
     unsigned char   bytes[4];
 
     if (!file || !u)
         return XcursorFalse;
 
     if ((*file->read) (file, bytes, 4) != 4)
     return XcursorFalse;
 
     *u = ((XcursorUInt)(bytes[0]) << 0) |
          ((XcursorUInt)(bytes[1]) << 8) |
          ((XcursorUInt)(bytes[2]) << 16) |
          ((XcursorUInt)(bytes[3]) << 24);
     return XcursorTrue;
 }
 
 static void
 _XcursorFileHeaderDestroy (XcursorFileHeader *fileHeader)
 {
     free (fileHeader);
 }
 
 static XcursorFileHeader *
 _XcursorFileHeaderCreate (XcursorUInt ntoc)
 {
     XcursorFileHeader   *fileHeader;
 
     if (ntoc > 0x10000)
     return NULL;
     fileHeader = malloc (sizeof (XcursorFileHeader) +
              ntoc * sizeof (XcursorFileToc));
     if (!fileHeader)
     return NULL;
     fileHeader->magic = XCURSOR_MAGIC;
     fileHeader->header = XCURSOR_FILE_HEADER_LEN;
     fileHeader->version = XCURSOR_FILE_VERSION;
     fileHeader->ntoc = ntoc;
     fileHeader->tocs = (XcursorFileToc *) (fileHeader + 1);
     return fileHeader;
 }
 
 static XcursorFileHeader *
 _XcursorReadFileHeader (XcursorFile *file)
 {
     XcursorFileHeader   head, *fileHeader;
     XcursorUInt     skip;
     unsigned int    n;
 
     if (!file)
         return NULL;
 
     if (!_XcursorReadUInt (file, &head.magic))
     return NULL;
     if (head.magic != XCURSOR_MAGIC)
     return NULL;
     if (!_XcursorReadUInt (file, &head.header))
     return NULL;
     if (!_XcursorReadUInt (file, &head.version))
     return NULL;
     if (!_XcursorReadUInt (file, &head.ntoc))
     return NULL;
     skip = head.header - XCURSOR_FILE_HEADER_LEN;
     if (skip)
     if ((*file->seek) (file, skip, SEEK_CUR) == EOF)
         return NULL;
     fileHeader = _XcursorFileHeaderCreate (head.ntoc);
     if (!fileHeader)
     return NULL;
     fileHeader->magic = head.magic;
     fileHeader->header = head.header;
     fileHeader->version = head.version;
     fileHeader->ntoc = head.ntoc;
     for (n = 0; n < fileHeader->ntoc; n++)
     {
     if (!_XcursorReadUInt (file, &fileHeader->tocs[n].type))
         break;
     if (!_XcursorReadUInt (file, &fileHeader->tocs[n].subtype))
         break;
     if (!_XcursorReadUInt (file, &fileHeader->tocs[n].position))
         break;
     }
     if (n != fileHeader->ntoc)
     {
     _XcursorFileHeaderDestroy (fileHeader);
     return NULL;
     }
     return fileHeader;
 }
 
 static XcursorBool
 _XcursorSeekToToc (XcursorFile      *file,
            XcursorFileHeader    *fileHeader,
            int          toc)
 {
     if (!file || !fileHeader || \
         (*file->seek) (file, fileHeader->tocs[toc].position, SEEK_SET) == EOF)
     return XcursorFalse;
     return XcursorTrue;
 }
 
 static XcursorBool
 _XcursorFileReadChunkHeader (XcursorFile    *file,
                  XcursorFileHeader  *fileHeader,
                  int        toc,
                  XcursorChunkHeader *chunkHeader)
 {
     if (!file || !fileHeader || !chunkHeader)
         return XcursorFalse;
     if (!_XcursorSeekToToc (file, fileHeader, toc))
     return XcursorFalse;
     if (!_XcursorReadUInt (file, &chunkHeader->header))
     return XcursorFalse;
     if (!_XcursorReadUInt (file, &chunkHeader->type))
     return XcursorFalse;
     if (!_XcursorReadUInt (file, &chunkHeader->subtype))
     return XcursorFalse;
     if (!_XcursorReadUInt (file, &chunkHeader->version))
     return XcursorFalse;
     /* sanity check */
     if (chunkHeader->type != fileHeader->tocs[toc].type ||
     chunkHeader->subtype != fileHeader->tocs[toc].subtype)
     return XcursorFalse;
     return XcursorTrue;
 }
 
 #define dist(a,b)   ((a) > (b) ? (a) - (b) : (b) - (a))
 
 static XcursorDim
 _XcursorFindBestSize (XcursorFileHeader *fileHeader,
               XcursorDim    size,
               int       *nsizesp)
 {
     unsigned int n;
     int     nsizes = 0;
     XcursorDim  bestSize = 0;
     XcursorDim  thisSize;
 
     if (!fileHeader || !nsizesp)
         return 0;
 
     for (n = 0; n < fileHeader->ntoc; n++)
     {
     if (fileHeader->tocs[n].type != XCURSOR_IMAGE_TYPE)
         continue;
     thisSize = fileHeader->tocs[n].subtype;
     if (!bestSize || dist (thisSize, size) < dist (bestSize, size))
     {
         bestSize = thisSize;
         nsizes = 1;
     }
     else if (thisSize == bestSize)
         nsizes++;
     }
     *nsizesp = nsizes;
     return bestSize;
 }
 
 static int
 _XcursorFindImageToc (XcursorFileHeader *fileHeader,
               XcursorDim    size,
               int       count)
 {
     unsigned int    toc;
     XcursorDim      thisSize;
 
     if (!fileHeader)
         return 0;
 
     for (toc = 0; toc < fileHeader->ntoc; toc++)
     {
     if (fileHeader->tocs[toc].type != XCURSOR_IMAGE_TYPE)
         continue;
     thisSize = fileHeader->tocs[toc].subtype;
     if (thisSize != size)
         continue;
     if (!count)
         break;
     count--;
     }
     if (toc == fileHeader->ntoc)
     return -1;
     return toc;
 }
 
 static XcursorImage *
 _XcursorReadImage (XcursorFile      *file,
            XcursorFileHeader    *fileHeader,
            int          toc)
 {
     XcursorChunkHeader  chunkHeader;
     XcursorImage    head;
     XcursorImage    *image;
     int         n;
     XcursorPixel    *p;
 
     if (!file || !fileHeader)
         return NULL;
 
     if (!_XcursorFileReadChunkHeader (file, fileHeader, toc, &chunkHeader))
     return NULL;
     if (!_XcursorReadUInt (file, &head.width))
     return NULL;
     if (!_XcursorReadUInt (file, &head.height))
     return NULL;
     if (!_XcursorReadUInt (file, &head.xhot))
     return NULL;
     if (!_XcursorReadUInt (file, &head.yhot))
     return NULL;
     if (!_XcursorReadUInt (file, &head.delay))
     return NULL;
     /* sanity check data */
     if (head.width > XCURSOR_IMAGE_MAX_SIZE  ||
     head.height > XCURSOR_IMAGE_MAX_SIZE)
     return NULL;
     if (head.width == 0 || head.height == 0)
     return NULL;
     if (head.xhot > head.width || head.yhot > head.height)
     return NULL;
 
     /* Create the image and initialize it */
     image = XcursorImageCreate (head.width, head.height);
     if (image == NULL)
         return NULL;
     if (chunkHeader.version < image->version)
     image->version = chunkHeader.version;
     image->size = chunkHeader.subtype;
     image->xhot = head.xhot;
     image->yhot = head.yhot;
     image->delay = head.delay;
     n = image->width * image->height;
     p = image->pixels;
     while (n--)
     {
     if (!_XcursorReadUInt (file, p))
     {
         XcursorImageDestroy (image);
         return NULL;
     }
     p++;
     }
     return image;
 }
 
 static XcursorImages *
 XcursorXcFileLoadImages (XcursorFile *file, int size)
 {
     XcursorFileHeader   *fileHeader;
     XcursorDim      bestSize;
     int         nsize;
     XcursorImages   *images;
     int         n;
     int         toc;
 
     if (!file || size < 0)
     return NULL;
     fileHeader = _XcursorReadFileHeader (file);
     if (!fileHeader)
     return NULL;
     bestSize = _XcursorFindBestSize (fileHeader, (XcursorDim) size, &nsize);
     if (!bestSize)
     {
         _XcursorFileHeaderDestroy (fileHeader);
     return NULL;
     }
     images = XcursorImagesCreate (nsize);
     if (!images)
     {
         _XcursorFileHeaderDestroy (fileHeader);
     return NULL;
     }
     for (n = 0; n < nsize; n++)
     {
     toc = _XcursorFindImageToc (fileHeader, bestSize, n);
     if (toc < 0)
         break;
     images->images[images->nimage] = _XcursorReadImage (file, fileHeader,
                                 toc);
     if (!images->images[images->nimage])
         break;
     images->nimage++;
     }
     _XcursorFileHeaderDestroy (fileHeader);
     if (images->nimage != nsize)
     {
     XcursorImagesDestroy (images);
     images = NULL;
     }
     return images;
 }
 
 static int
 _XcursorStdioFileRead (XcursorFile *file, unsigned char *buf, int len)
 {
     FILE    *f = file->closure;
     return fread (buf, 1, len, f);
 }
 
 static int
 _XcursorStdioFileWrite (XcursorFile *file, unsigned char *buf, int len)
 {
     FILE    *f = file->closure;
     return fwrite (buf, 1, len, f);
 }
 
 static int
 _XcursorStdioFileSeek (XcursorFile *file, long offset, int whence)
 {
     FILE    *f = file->closure;
     return fseek (f, offset, whence);
 }
 
 static void
 _XcursorStdioFileInitialize (FILE *stdfile, XcursorFile *file)
 {
     file->closure = stdfile;
     file->read = _XcursorStdioFileRead;
     file->write = _XcursorStdioFileWrite;
     file->seek = _XcursorStdioFileSeek;
 }
 
 XcursorImages *
 XcursorFileLoadImages (const char *file, int size)
 {
     XcursorFile f;
     XcursorImages *images;
 
     FILE *fp = fopen(file, "r");
     if (!fp)
         return NULL;
 
     _XcursorStdioFileInitialize (fp, &f);
     images = XcursorXcFileLoadImages (&f, size);
     fclose(fp);
 
     return images;
 }