summaryrefslogtreecommitdiff
path: root/src/file.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/file.c')
-rw-r--r--src/file.c992
1 files changed, 992 insertions, 0 deletions
diff --git a/src/file.c b/src/file.c
new file mode 100644
index 0000000..813ac28
--- /dev/null
+++ b/src/file.c
@@ -0,0 +1,992 @@
+/*
+ * $XFree86: xc/lib/Xcursor/file.c,v 1.2 2002/09/18 17:11:42 tsi Exp $
+ *
+ * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Keith Packard makes no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "xcursorint.h"
+#include <stdlib.h>
+#include <string.h>
+
+XcursorImage *
+XcursorImageCreate (int width, int height)
+{
+ XcursorImage *image;
+
+ image = malloc (sizeof (XcursorImage) +
+ width * height * sizeof (XcursorPixel));
+ if (!image)
+ return 0;
+ 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;
+}
+
+void
+XcursorImageDestroy (XcursorImage *image)
+{
+ free (image);
+}
+
+XcursorImages *
+XcursorImagesCreate (int size)
+{
+ XcursorImages *images;
+
+ images = malloc (sizeof (XcursorImages) +
+ size * sizeof (XcursorImage *));
+ if (!images)
+ return 0;
+ images->nimage = 0;
+ images->images = (XcursorImage **) (images + 1);
+ return images;
+}
+
+void
+XcursorImagesDestroy (XcursorImages *images)
+{
+ int n;
+
+ for (n = 0; n < images->nimage; n++)
+ XcursorImageDestroy (images->images[n]);
+ free (images);
+}
+
+XcursorComment *
+XcursorCommentCreate (XcursorUInt comment_type, int length)
+{
+ XcursorComment *comment;
+
+ if (length > XCURSOR_COMMENT_MAX_LEN)
+ return 0;
+
+ comment = malloc (sizeof (XcursorComment) + length + 1);
+ if (!comment)
+ return 0;
+ comment->version = XCURSOR_COMMENT_VERSION;
+ comment->comment_type = comment_type;
+ comment->comment = (char *) (comment + 1);
+ comment->comment[0] = '\0';
+ return comment;
+}
+
+void
+XcursorCommentDestroy (XcursorComment *comment)
+{
+ free (comment);
+}
+
+XcursorComments *
+XcursorCommentsCreate (int size)
+{
+ XcursorComments *comments;
+
+ comments = malloc (sizeof (XcursorComments) +
+ size * sizeof (XcursorComment *));
+ if (!comments)
+ return 0;
+ comments->ncomment = 0;
+ comments->comments = (XcursorComment **) (comments + 1);
+ return comments;
+}
+
+void
+XcursorCommentsDestroy (XcursorComments *comments)
+{
+ int n;
+
+ for (n = 0; n < comments->ncomment; n++)
+ XcursorCommentDestroy (comments->comments[n]);
+ free (comments);
+}
+
+static XcursorBool
+_XcursorReadUInt (XcursorFile *file, XcursorUInt *u)
+{
+ unsigned char bytes[4];
+
+ if ((*file->read) (file, bytes, 4) != 4)
+ return XcursorFalse;
+ *u = ((bytes[0] << 0) |
+ (bytes[1] << 8) |
+ (bytes[2] << 16) |
+ (bytes[3] << 24));
+ return XcursorTrue;
+}
+
+static XcursorBool
+_XcursorReadBytes (XcursorFile *file, char *bytes, int length)
+{
+ if ((*file->read) (file, (unsigned char *) bytes, length) != length)
+ return XcursorFalse;
+ return XcursorTrue;
+}
+
+static XcursorBool
+_XcursorWriteUInt (XcursorFile *file, XcursorUInt u)
+{
+ unsigned char bytes[4];
+
+ bytes[0] = u;
+ bytes[1] = u >> 8;
+ bytes[2] = u >> 16;
+ bytes[3] = u >> 24;
+ if ((*file->write) (file, bytes, 4) != 4)
+ return XcursorFalse;
+ return XcursorTrue;
+}
+
+static XcursorBool
+_XcursorWriteBytes (XcursorFile *file, char *bytes, int length)
+{
+ if ((*file->write) (file, (unsigned char *) bytes, length) != length)
+ return XcursorFalse;
+ return XcursorTrue;
+}
+
+static void
+_XcursorFileHeaderDestroy (XcursorFileHeader *fileHeader)
+{
+ free (fileHeader);
+}
+
+static XcursorFileHeader *
+_XcursorFileHeaderCreate (int ntoc)
+{
+ XcursorFileHeader *fileHeader;
+
+ if (ntoc > 0x10000)
+ return 0;
+ fileHeader = malloc (sizeof (XcursorFileHeader) +
+ ntoc * sizeof (XcursorFileToc));
+ if (!fileHeader)
+ return 0;
+ fileHeader->magic = XCURSOR_MAGIC;
+ fileHeader->header = XCURSOR_FILE_HEADER_LEN;
+ fileHeader->version = XCURSOR_VERSION;
+ fileHeader->ntoc = ntoc;
+ fileHeader->tocs = (XcursorFileToc *) (fileHeader + 1);
+ return fileHeader;
+}
+
+static XcursorFileHeader *
+_XcursorReadFileHeader (XcursorFile *file)
+{
+ XcursorFileHeader head, *fileHeader;
+ XcursorUInt skip;
+ int n;
+
+ if (!_XcursorReadUInt (file, &head.magic))
+ return 0;
+ if (head.magic != XCURSOR_MAGIC)
+ return 0;
+ if (!_XcursorReadUInt (file, &head.header))
+ return 0;
+ if (!_XcursorReadUInt (file, &head.version))
+ return 0;
+ if (!_XcursorReadUInt (file, &head.ntoc))
+ return 0;
+ skip = head.header - XCURSOR_FILE_HEADER_LEN;
+ if (skip)
+ if ((*file->seek) (file, skip, SEEK_CUR) == EOF)
+ return 0;
+ fileHeader = _XcursorFileHeaderCreate (head.ntoc);
+ if (!fileHeader)
+ return 0;
+ 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 0;
+ }
+ return fileHeader;
+}
+
+static XcursorUInt
+_XcursorFileHeaderLength (XcursorFileHeader *fileHeader)
+{
+ return (XCURSOR_FILE_HEADER_LEN +
+ fileHeader->ntoc * XCURSOR_FILE_TOC_LEN);
+}
+
+static XcursorBool
+_XcursorWriteFileHeader (XcursorFile *file, XcursorFileHeader *fileHeader)
+{
+ int toc;
+
+ if (!_XcursorWriteUInt (file, fileHeader->magic))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, fileHeader->header))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, fileHeader->version))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, fileHeader->ntoc))
+ return XcursorFalse;
+ for (toc = 0; toc < fileHeader->ntoc; toc++)
+ {
+ if (!_XcursorWriteUInt (file, fileHeader->tocs[toc].type))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, fileHeader->tocs[toc].subtype))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, fileHeader->tocs[toc].position))
+ return XcursorFalse;
+ }
+ return XcursorTrue;
+}
+
+static XcursorBool
+_XcursorSeekToToc (XcursorFile *file,
+ XcursorFileHeader *fileHeader,
+ int toc)
+{
+ if ((*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 (!_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;
+}
+
+static XcursorBool
+_XcursorFileWriteChunkHeader (XcursorFile *file,
+ XcursorFileHeader *fileHeader,
+ int toc,
+ XcursorChunkHeader *chunkHeader)
+{
+ if (!_XcursorSeekToToc (file, fileHeader, toc))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, chunkHeader->header))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, chunkHeader->type))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, chunkHeader->subtype))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, chunkHeader->version))
+ return XcursorFalse;
+ return XcursorTrue;
+}
+
+#define dist(a,b) ((a) > (b) ? (a) - (b) : (b) - (a))
+
+static XcursorDim
+_XcursorFindBestSize (XcursorFileHeader *fileHeader,
+ XcursorDim size,
+ int *nsizesp)
+{
+ int n;
+ int nsizes = 0;
+ XcursorDim bestSize = 0;
+ XcursorDim thisSize;
+
+ 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)
+{
+ int toc;
+ XcursorDim thisSize;
+
+ 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 (!_XcursorFileReadChunkHeader (file, fileHeader, toc, &chunkHeader))
+ return 0;
+ if (!_XcursorReadUInt (file, &head.width))
+ return 0;
+ if (!_XcursorReadUInt (file, &head.height))
+ return 0;
+ if (!_XcursorReadUInt (file, &head.xhot))
+ return 0;
+ if (!_XcursorReadUInt (file, &head.yhot))
+ return 0;
+ if (!_XcursorReadUInt (file, &head.delay))
+ return 0;
+ /* sanity check data */
+ if (head.width >= 0x10000 || head.height > 0x10000)
+ return 0;
+ if (head.width == 0 || head.height == 0)
+ return 0;
+ if (head.xhot > head.width || head.yhot > head.height)
+ return 0;
+
+ /* Create the image and initialize it */
+ image = XcursorImageCreate (head.width, head.height);
+ 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 0;
+ }
+ p++;
+ }
+ return image;
+}
+
+static XcursorUInt
+_XcursorImageLength (XcursorImage *image)
+{
+ return XCURSOR_IMAGE_HEADER_LEN + (image->width * image->height) * 4;
+}
+
+static XcursorBool
+_XcursorWriteImage (XcursorFile *file,
+ XcursorFileHeader *fileHeader,
+ int toc,
+ XcursorImage *image)
+{
+ XcursorChunkHeader chunkHeader;
+ int n;
+ XcursorPixel *p;
+
+ /* sanity check data */
+ if (image->width > XCURSOR_IMAGE_MAX_SIZE ||
+ image->height > XCURSOR_IMAGE_MAX_SIZE)
+ return XcursorFalse;
+ if (image->width == 0 || image->height == 0)
+ return XcursorFalse;
+ if (image->xhot > image->width || image->yhot > image->height)
+ return XcursorFalse;
+
+ /* write chunk header */
+ chunkHeader.header = XCURSOR_IMAGE_HEADER_LEN;
+ chunkHeader.type = XCURSOR_IMAGE_TYPE;
+ chunkHeader.subtype = image->size;
+ chunkHeader.version = XCURSOR_IMAGE_VERSION;
+
+ if (!_XcursorFileWriteChunkHeader (file, fileHeader, toc, &chunkHeader))
+ return XcursorFalse;
+
+ /* write extra image header fields */
+ if (!_XcursorWriteUInt (file, image->width))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, image->height))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, image->xhot))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, image->yhot))
+ return XcursorFalse;
+ if (!_XcursorWriteUInt (file, image->delay))
+ return XcursorFalse;
+
+ /* write the image */
+ n = image->width * image->height;
+ p = image->pixels;
+ while (n--)
+ {
+ if (!_XcursorWriteUInt (file, *p))
+ return XcursorFalse;
+ p++;
+ }
+ return XcursorTrue;
+}
+
+static XcursorComment *
+_XcursorReadComment (XcursorFile *file,
+ XcursorFileHeader *fileHeader,
+ int toc)
+{
+ XcursorChunkHeader chunkHeader;
+ XcursorUInt length;
+ XcursorComment *comment;
+
+ /* read chunk header */
+ if (!_XcursorFileReadChunkHeader (file, fileHeader, toc, &chunkHeader))
+ return 0;
+ /* read extra comment header fields */
+ if (!_XcursorReadUInt (file, &length))
+ return 0;
+ comment = XcursorCommentCreate (chunkHeader.subtype, length);
+ if (!comment)
+ return 0;
+ if (!_XcursorReadBytes (file, comment->comment, length))
+ {
+ XcursorCommentDestroy (comment);
+ return 0;
+ }
+ comment->comment[length] = '\0';
+ return comment;
+}
+
+static XcursorUInt
+_XcursorCommentLength (XcursorComment *comment)
+{
+ return XCURSOR_COMMENT_HEADER_LEN + strlen (comment->comment);
+}
+
+static XcursorBool
+_XcursorWriteComment (XcursorFile *file,
+ XcursorFileHeader *fileHeader,
+ int toc,
+ XcursorComment *comment)
+{
+ XcursorChunkHeader chunkHeader;
+ XcursorUInt length;
+
+ length = strlen (comment->comment);
+
+ /* sanity check data */
+ if (length > XCURSOR_COMMENT_MAX_LEN)
+ return XcursorFalse;
+
+ /* read chunk header */
+ chunkHeader.header = XCURSOR_COMMENT_HEADER_LEN;
+ chunkHeader.type = XCURSOR_COMMENT_TYPE;
+ chunkHeader.subtype = comment->comment_type;
+ chunkHeader.version = XCURSOR_COMMENT_VERSION;
+
+ if (!_XcursorFileWriteChunkHeader (file, fileHeader, toc, &chunkHeader))
+ return XcursorFalse;
+
+ /* write extra comment header fields */
+ if (!_XcursorWriteUInt (file, length))
+ return XcursorFalse;
+
+ if (!_XcursorWriteBytes (file, comment->comment, length))
+ return XcursorFalse;
+ return XcursorTrue;
+}
+
+XcursorImage *
+XcursorXcFileLoadImage (XcursorFile *file, int size)
+{
+ XcursorFileHeader *fileHeader;
+ XcursorDim bestSize;
+ int nsize;
+ int toc;
+ XcursorImage *image;
+
+ if (size < 0)
+ return 0;
+ fileHeader = _XcursorReadFileHeader (file);
+ if (!fileHeader)
+ return 0;
+ bestSize = _XcursorFindBestSize (fileHeader, (XcursorDim) size, &nsize);
+ if (!bestSize)
+ return 0;
+ toc = _XcursorFindImageToc (fileHeader, bestSize, 0);
+ if (toc < 0)
+ return 0;
+ image = _XcursorReadImage (file, fileHeader, toc);
+ _XcursorFileHeaderDestroy (fileHeader);
+ return image;
+}
+
+XcursorImages *
+XcursorXcFileLoadImages (XcursorFile *file, int size)
+{
+ XcursorFileHeader *fileHeader;
+ XcursorDim bestSize;
+ int nsize;
+ XcursorImages *images;
+ int n;
+ int toc;
+
+ if (size < 0)
+ return 0;
+ fileHeader = _XcursorReadFileHeader (file);
+ if (!fileHeader)
+ return 0;
+ bestSize = _XcursorFindBestSize (fileHeader, (XcursorDim) size, &nsize);
+ if (!bestSize)
+ return 0;
+ images = XcursorImagesCreate (nsize);
+ if (!images)
+ return 0;
+ 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 = 0;
+ }
+ return images;
+}
+
+XcursorImages *
+XcursorXcFileLoadAllImages (XcursorFile *file)
+{
+ XcursorFileHeader *fileHeader;
+ XcursorImage *image;
+ XcursorImages *images;
+ int nimage;
+ int n;
+ int toc;
+
+ fileHeader = _XcursorReadFileHeader (file);
+ if (!fileHeader)
+ return 0;
+ nimage = 0;
+ for (n = 0; n < fileHeader->ntoc; n++)
+ {
+ switch (fileHeader->tocs[n].type) {
+ case XCURSOR_IMAGE_TYPE:
+ nimage++;
+ break;
+ }
+ }
+ images = XcursorImagesCreate (nimage);
+ if (!images)
+ return 0;
+ for (toc = 0; toc < fileHeader->ntoc; toc++)
+ {
+ switch (fileHeader->tocs[toc].type) {
+ case XCURSOR_IMAGE_TYPE:
+ image = _XcursorReadImage (file, fileHeader, toc);
+ if (image)
+ {
+ images->images[images->nimage] = image;
+ images->nimage++;
+ }
+ break;
+ }
+ }
+ _XcursorFileHeaderDestroy (fileHeader);
+ if (images->nimage != nimage)
+ {
+ XcursorImagesDestroy (images);
+ images = 0;
+ }
+ return images;
+}
+
+XcursorBool
+XcursorXcFileLoad (XcursorFile *file,
+ XcursorComments **commentsp,
+ XcursorImages **imagesp)
+{
+ XcursorFileHeader *fileHeader;
+ int nimage;
+ int ncomment;
+ XcursorImages *images;
+ XcursorImage *image;
+ XcursorComment *comment;
+ XcursorComments *comments;
+ int toc;
+
+ fileHeader = _XcursorReadFileHeader (file);
+ if (!fileHeader)
+ return 0;
+ nimage = 0;
+ ncomment = 0;
+ for (toc = 0; toc < fileHeader->ntoc; toc++)
+ {
+ switch (fileHeader->tocs[toc].type) {
+ case XCURSOR_COMMENT_TYPE:
+ ncomment++;
+ break;
+ case XCURSOR_IMAGE_TYPE:
+ nimage++;
+ break;
+ }
+ }
+ images = XcursorImagesCreate (nimage);
+ if (!images)
+ return 0;
+ comments = XcursorCommentsCreate (ncomment);
+ if (!comments)
+ {
+ XcursorImagesDestroy (images);
+ return 0;
+ }
+ for (toc = 0; toc < fileHeader->ntoc; toc++)
+ {
+ switch (fileHeader->tocs[toc].type) {
+ case XCURSOR_COMMENT_TYPE:
+ comment = _XcursorReadComment (file, fileHeader, toc);
+ if (comment)
+ {
+ comments->comments[comments->ncomment] = comment;
+ comments->ncomment++;
+ }
+ break;
+ case XCURSOR_IMAGE_TYPE:
+ image = _XcursorReadImage (file, fileHeader, toc);
+ if (image)
+ {
+ images->images[images->nimage] = image;
+ images->nimage++;
+ }
+ break;
+ }
+ }
+ _XcursorFileHeaderDestroy (fileHeader);
+ if (images->nimage != nimage || comments->ncomment != ncomment)
+ {
+ XcursorImagesDestroy (images);
+ XcursorCommentsDestroy (comments);
+ images = 0;
+ comments = 0;
+ return XcursorFalse;
+ }
+ *imagesp = images;
+ *commentsp = comments;
+ return XcursorTrue;
+}
+
+XcursorBool
+XcursorXcFileSave (XcursorFile *file,
+ const XcursorComments *comments,
+ const XcursorImages *images)
+{
+ XcursorFileHeader *fileHeader;
+ XcursorUInt position;
+ int n;
+ int toc;
+
+ fileHeader = _XcursorFileHeaderCreate (comments->ncomment + images->nimage);
+ if (!fileHeader)
+ return XcursorFalse;
+
+ position = _XcursorFileHeaderLength (fileHeader);
+
+ /*
+ * Compute the toc. Place the images before the comments
+ * as they're more often read
+ */
+
+ toc = 0;
+ for (n = 0; n < images->nimage; n++)
+ {
+ fileHeader->tocs[toc].type = XCURSOR_IMAGE_TYPE;
+ fileHeader->tocs[toc].subtype = images->images[n]->size;
+ fileHeader->tocs[toc].position = position;
+ position += _XcursorImageLength (images->images[n]);
+ toc++;
+ }
+
+ for (n = 0; n < comments->ncomment; n++)
+ {
+ fileHeader->tocs[toc].type = XCURSOR_COMMENT_TYPE;
+ fileHeader->tocs[toc].subtype = comments->comments[n]->comment_type;
+ fileHeader->tocs[toc].position = position;
+ position += _XcursorCommentLength (comments->comments[n]);
+ toc++;
+ }
+
+ /*
+ * Write the header and the toc
+ */
+ if (!_XcursorWriteFileHeader (file, fileHeader))
+ goto bail;
+
+ /*
+ * Write the images
+ */
+ toc = 0;
+ for (n = 0; n < images->nimage; n++)
+ {
+ if (!_XcursorWriteImage (file, fileHeader, toc, images->images[n]))
+ goto bail;
+ toc++;
+ }
+
+ /*
+ * Write the comments
+ */
+ for (n = 0; n < comments->ncomment; n++)
+ {
+ if (!_XcursorWriteComment (file, fileHeader, toc, comments->comments[n]))
+ goto bail;
+ toc++;
+ }
+
+ _XcursorFileHeaderDestroy (fileHeader);
+ return XcursorTrue;
+bail:
+ _XcursorFileHeaderDestroy (fileHeader);
+ return XcursorFalse;
+}
+
+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;
+}
+
+XcursorImage *
+XcursorFileLoadImage (FILE *file, int size)
+{
+ XcursorFile f;
+
+ _XcursorStdioFileInitialize (file, &f);
+ return XcursorXcFileLoadImage (&f, size);
+}
+
+XcursorImages *
+XcursorFileLoadImages (FILE *file, int size)
+{
+ XcursorFile f;
+
+ _XcursorStdioFileInitialize (file, &f);
+ return XcursorXcFileLoadImages (&f, size);
+}
+
+XcursorImages *
+XcursorFileLoadAllImages (FILE *file)
+{
+ XcursorFile f;
+
+ _XcursorStdioFileInitialize (file, &f);
+ return XcursorXcFileLoadAllImages (&f);
+}
+
+XcursorBool
+XcursorFileLoad (FILE *file,
+ XcursorComments **commentsp,
+ XcursorImages **imagesp)
+{
+ XcursorFile f;
+
+ _XcursorStdioFileInitialize (file, &f);
+ return XcursorXcFileLoad (&f, commentsp, imagesp);
+}
+
+XcursorBool
+XcursorFileSaveImages (FILE *file, const XcursorImages *images)
+{
+ XcursorComments *comments = XcursorCommentsCreate (0);
+ XcursorFile f;
+ XcursorBool ret;
+ if (!comments)
+ return 0;
+ _XcursorStdioFileInitialize (file, &f);
+ ret = XcursorXcFileSave (&f, comments, images) && fflush (file) != EOF;
+ XcursorCommentsDestroy (comments);
+ return ret;
+}
+
+XcursorBool
+XcursorFileSave (FILE * file,
+ const XcursorComments *comments,
+ const XcursorImages *images)
+{
+ XcursorFile f;
+
+ _XcursorStdioFileInitialize (file, &f);
+ return XcursorXcFileSave (&f, comments, images) && fflush (file) != EOF;
+}
+
+XcursorImage *
+XcursorFilenameLoadImage (const char *file, int size)
+{
+ FILE *f;
+ XcursorImage *image;
+
+ f = fopen (file, "r");
+ if (!f)
+ return 0;
+ image = XcursorFileLoadImage (f, size);
+ fclose (f);
+ return image;
+}
+
+XcursorImages *
+XcursorFilenameLoadImages (const char *file, int size)
+{
+ FILE *f;
+ XcursorImages *images;
+
+ f = fopen (file, "r");
+ if (!f)
+ return 0;
+ images = XcursorFileLoadImages (f, size);
+ fclose (f);
+ return images;
+}
+
+XcursorImages *
+XcursorFilenameLoadAllImages (const char *file)
+{
+ FILE *f;
+ XcursorImages *images;
+
+ f = fopen (file, "r");
+ if (!f)
+ return 0;
+ images = XcursorFileLoadAllImages (f);
+ fclose (f);
+ return images;
+}
+
+XcursorBool
+XcursorFilenameLoad (const char *file,
+ XcursorComments **commentsp,
+ XcursorImages **imagesp)
+{
+ FILE *f;
+ XcursorBool ret;
+
+ f = fopen (file, "r");
+ if (!f)
+ return 0;
+ ret = XcursorFileLoad (f, commentsp, imagesp);
+ fclose (f);
+ return ret;
+}
+
+XcursorBool
+XcursorFilenameSaveImages (const char *file, const XcursorImages *images)
+{
+ FILE *f;
+ XcursorBool ret;
+
+ f = fopen (file, "w");
+ if (!f)
+ return 0;
+ ret = XcursorFileSaveImages (f, images);
+ return fclose (f) != EOF && ret;
+}
+
+XcursorBool
+XcursorFilenameSave (const char *file,
+ const XcursorComments *comments,
+ const XcursorImages *images)
+{
+ FILE *f;
+ XcursorBool ret;
+
+ f = fopen (file, "w");
+ if (!f)
+ return 0;
+ ret = XcursorFileSave (f, comments, images);
+ return fclose (f) != EOF && ret;
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 21:52:41 +0000