0213661a7c
Xcursor loading code has hardcoded search paths, in order to take into account distros installing app data in a different location, libwayland-cursor sets the ICONDIR to the icon directory computed based on the install prefix. However, that won't work with gitlab CI because it relocates binaries. A more robust way to find cursors would be to use QStandardPaths to find all the icon directories on the system. Another advantage of using own cursor loading code is that it allows us to reuse cursor images that are symlinks. For example, with breeze_cursors, almost half of the files in the cursors directory are symlinks. The main disadvantage of this approach is that we would have to keep the search paths up to date. However, on the hand, there are not that many of them, e.g. ~/.icons, ~/.local/share/icons, /usr/share/icons, /usr/local/share/icons. The last three are implicitly handled by the QStandardPaths.
594 lines
15 KiB
C
594 lines
15 KiB
C
/*
|
|
* 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;
|
|
}
|