mirrors/wayland
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wayland/wayland.git synced 2026-04-25 06:46:34 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

cursor: drop whitespace before parens in function calls

Browse source 
This is in line with the rest of the Wayland code style.

Signed-off-by: Simon Ser <contact@emersion.fr>
This commit is contained in:
Simon Ser 2022-04-17 17:10:53 +02:00
parent 13d4ae01cb
commit 5f5f1da691
2 changed files with 127 additions and 127 deletions
Download patch file Download diff file Expand all files Collapse all files

248
cursor/xcursor.c
View file

@ -181,7 +181,7 @@ typedef struct _XcursorComments {
*/ */
static XcursorImage * static XcursorImage *
XcursorImageCreate (int width, int height) XcursorImageCreate(int width, int height)
{ {
XcursorImage *image; XcursorImage *image;
@ -190,8 +190,8 @@ XcursorImageCreate (int width, int height)
if (width > XCURSOR_IMAGE_MAX_SIZE || height > XCURSOR_IMAGE_MAX_SIZE) if (width > XCURSOR_IMAGE_MAX_SIZE || height > XCURSOR_IMAGE_MAX_SIZE)
return NULL; return NULL;
image = malloc (sizeof (XcursorImage) + image = malloc(sizeof(XcursorImage) +
width * height * sizeof (uint32_t)); width * height * sizeof(uint32_t));
if (!image) if (!image)
return NULL; return NULL;
image->version = XCURSOR_IMAGE_VERSION; image->version = XCURSOR_IMAGE_VERSION;
@ -204,18 +204,18 @@ XcursorImageCreate (int width, int height)
} }
static void static void
XcursorImageDestroy (XcursorImage *image) XcursorImageDestroy(XcursorImage *image)
{ {
free (image); free(image);
} }
static XcursorImages * static XcursorImages *
XcursorImagesCreate (int size) XcursorImagesCreate(int size)
{ {
XcursorImages *images; XcursorImages *images;
images = malloc (sizeof (XcursorImages) + images = malloc(sizeof(XcursorImages) +
size * sizeof (XcursorImage *)); size * sizeof(XcursorImage *));
if (!images) if (!images)
return NULL; return NULL;
images->nimage = 0; images->nimage = 0;
@ -225,7 +225,7 @@ XcursorImagesCreate (int size)
} }
void void
XcursorImagesDestroy (XcursorImages *images) XcursorImagesDestroy(XcursorImages *images)
{ {
int n; int n;
@ -233,40 +233,40 @@ XcursorImagesDestroy (XcursorImages *images)
return; return;
for (n = 0; n < images->nimage; n++) for (n = 0; n < images->nimage; n++)
XcursorImageDestroy (images->images[n]); XcursorImageDestroy(images->images[n]);
if (images->name) if (images->name)
free (images->name); free(images->name);
free (images); free(images);
} }
static void static void
XcursorImagesSetName (XcursorImages *images, const char *name) XcursorImagesSetName(XcursorImages *images, const char *name)
{ {
char *new; char *new;
if (!images || !name) if (!images || !name)
return; return;
new = malloc (strlen (name) + 1); new = malloc(strlen(name) + 1);
if (!new) if (!new)
return; return;
strcpy (new, name); strcpy(new, name);
if (images->name) if (images->name)
free (images->name); free(images->name);
images->name = new; images->name = new;
} }
static bool static bool
_XcursorReadUInt (XcursorFile *file, uint32_t *u) _XcursorReadUInt(XcursorFile *file, uint32_t *u)
{ {
unsigned char bytes[4]; unsigned char bytes[4];
if (!file || !u) if (!file || !u)
return false; return false;
if ((*file->read) (file, bytes, 4) != 4) if ((*file->read)(file, bytes, 4) != 4)
return false; return false;
*u = ((uint32_t)(bytes[0]) << 0) | *u = ((uint32_t)(bytes[0]) << 0) |
@ -277,20 +277,20 @@ _XcursorReadUInt (XcursorFile *file, uint32_t *u)
} }
static void static void
_XcursorFileHeaderDestroy (XcursorFileHeader *fileHeader) _XcursorFileHeaderDestroy(XcursorFileHeader *fileHeader)
{ {
free (fileHeader); free(fileHeader);
} }
static XcursorFileHeader * static XcursorFileHeader *
_XcursorFileHeaderCreate (uint32_t ntoc) _XcursorFileHeaderCreate(uint32_t ntoc)
{ {
XcursorFileHeader *fileHeader; XcursorFileHeader *fileHeader;
if (ntoc > 0x10000) if (ntoc > 0x10000)
return NULL; return NULL;
fileHeader = malloc (sizeof (XcursorFileHeader) + fileHeader = malloc(sizeof(XcursorFileHeader) +
ntoc * sizeof (XcursorFileToc)); ntoc * sizeof(XcursorFileToc));
if (!fileHeader) if (!fileHeader)
return NULL; return NULL;
fileHeader->magic = XCURSOR_MAGIC; fileHeader->magic = XCURSOR_MAGIC;
@ -302,7 +302,7 @@ _XcursorFileHeaderCreate (uint32_t ntoc)
} }
static XcursorFileHeader * static XcursorFileHeader *
_XcursorReadFileHeader (XcursorFile *file) _XcursorReadFileHeader(XcursorFile *file)
{ {
XcursorFileHeader head, *fileHeader; XcursorFileHeader head, *fileHeader;
uint32_t skip; uint32_t skip;
@ -311,21 +311,21 @@ _XcursorReadFileHeader (XcursorFile *file)
if (!file) if (!file)
return NULL; return NULL;
if (!_XcursorReadUInt (file, &head.magic)) if (!_XcursorReadUInt(file, &head.magic))
return NULL; return NULL;
if (head.magic != XCURSOR_MAGIC) if (head.magic != XCURSOR_MAGIC)
return NULL; return NULL;
if (!_XcursorReadUInt (file, &head.header)) if (!_XcursorReadUInt(file, &head.header))
return NULL; return NULL;
if (!_XcursorReadUInt (file, &head.version)) if (!_XcursorReadUInt(file, &head.version))
return NULL; return NULL;
if (!_XcursorReadUInt (file, &head.ntoc)) if (!_XcursorReadUInt(file, &head.ntoc))
return NULL; return NULL;
skip = head.header - XCURSOR_FILE_HEADER_LEN; skip = head.header - XCURSOR_FILE_HEADER_LEN;
if (skip) if (skip)
if ((*file->seek) (file, skip, SEEK_CUR) == EOF) if ((*file->seek)(file, skip, SEEK_CUR) == EOF)
return NULL; return NULL;
fileHeader = _XcursorFileHeaderCreate (head.ntoc); fileHeader = _XcursorFileHeaderCreate(head.ntoc);
if (!fileHeader) if (!fileHeader)
return NULL; return NULL;
fileHeader->magic = head.magic; fileHeader->magic = head.magic;
@ -334,49 +334,49 @@ _XcursorReadFileHeader (XcursorFile *file)
fileHeader->ntoc = head.ntoc; fileHeader->ntoc = head.ntoc;
for (n = 0; n < fileHeader->ntoc; n++) for (n = 0; n < fileHeader->ntoc; n++)
{ {
if (!_XcursorReadUInt (file, &fileHeader->tocs[n].type)) if (!_XcursorReadUInt(file, &fileHeader->tocs[n].type))
break; break;
if (!_XcursorReadUInt (file, &fileHeader->tocs[n].subtype)) if (!_XcursorReadUInt(file, &fileHeader->tocs[n].subtype))
break; break;
if (!_XcursorReadUInt (file, &fileHeader->tocs[n].position)) if (!_XcursorReadUInt(file, &fileHeader->tocs[n].position))
break; break;
} }
if (n != fileHeader->ntoc) if (n != fileHeader->ntoc)
{ {
_XcursorFileHeaderDestroy (fileHeader); _XcursorFileHeaderDestroy(fileHeader);
return NULL; return NULL;
} }
return fileHeader; return fileHeader;
} }
static bool static bool
_XcursorSeekToToc (XcursorFile *file, _XcursorSeekToToc(XcursorFile *file,
XcursorFileHeader *fileHeader, XcursorFileHeader *fileHeader,
int toc) int toc)
{ {
if (!file || !fileHeader || \ if (!file || !fileHeader || \
(*file->seek) (file, fileHeader->tocs[toc].position, SEEK_SET) == EOF) (*file->seek)(file, fileHeader->tocs[toc].position, SEEK_SET) == EOF)
return false; return false;
return true; return true;
} }
static bool static bool
_XcursorFileReadChunkHeader (XcursorFile *file, _XcursorFileReadChunkHeader(XcursorFile *file,
XcursorFileHeader *fileHeader, XcursorFileHeader *fileHeader,
int toc, int toc,
XcursorChunkHeader *chunkHeader) XcursorChunkHeader *chunkHeader)
{ {
if (!file || !fileHeader || !chunkHeader) if (!file || !fileHeader || !chunkHeader)
return false; return false;
if (!_XcursorSeekToToc (file, fileHeader, toc)) if (!_XcursorSeekToToc(file, fileHeader, toc))
return false; return false;
if (!_XcursorReadUInt (file, &chunkHeader->header)) if (!_XcursorReadUInt(file, &chunkHeader->header))
return false; return false;
if (!_XcursorReadUInt (file, &chunkHeader->type)) if (!_XcursorReadUInt(file, &chunkHeader->type))
return false; return false;
if (!_XcursorReadUInt (file, &chunkHeader->subtype)) if (!_XcursorReadUInt(file, &chunkHeader->subtype))
return false; return false;
if (!_XcursorReadUInt (file, &chunkHeader->version)) if (!_XcursorReadUInt(file, &chunkHeader->version))
return false; return false;
/* sanity check */ /* sanity check */
if (chunkHeader->type != fileHeader->tocs[toc].type || if (chunkHeader->type != fileHeader->tocs[toc].type ||
@ -388,7 +388,7 @@ _XcursorFileReadChunkHeader (XcursorFile *file,
#define dist(a,b) ((a) > (b) ? (a) - (b) : (b) - (a)) #define dist(a,b) ((a) > (b) ? (a) - (b) : (b) - (a))
static uint32_t static uint32_t
_XcursorFindBestSize (XcursorFileHeader *fileHeader, _XcursorFindBestSize(XcursorFileHeader *fileHeader,
uint32_t size, uint32_t size,
int *nsizesp) int *nsizesp)
{ {
@ -405,7 +405,7 @@ _XcursorFindBestSize (XcursorFileHeader *fileHeader,
if (fileHeader->tocs[n].type != XCURSOR_IMAGE_TYPE) if (fileHeader->tocs[n].type != XCURSOR_IMAGE_TYPE)
continue; continue;
thisSize = fileHeader->tocs[n].subtype; thisSize = fileHeader->tocs[n].subtype;
if (!bestSize || dist (thisSize, size) < dist (bestSize, size)) if (!bestSize || dist(thisSize, size) < dist(bestSize, size))
{ {
bestSize = thisSize; bestSize = thisSize;
nsizes = 1; nsizes = 1;
@ -418,9 +418,9 @@ _XcursorFindBestSize (XcursorFileHeader *fileHeader,
} }
static int static int
_XcursorFindImageToc (XcursorFileHeader *fileHeader, _XcursorFindImageToc(XcursorFileHeader *fileHeader,
uint32_t size, uint32_t size,
int count) int count)
{ {
unsigned int toc; unsigned int toc;
uint32_t thisSize; uint32_t thisSize;
@ -445,7 +445,7 @@ _XcursorFindImageToc (XcursorFileHeader *fileHeader,
} }
static XcursorImage * static XcursorImage *
_XcursorReadImage (XcursorFile *file, _XcursorReadImage(XcursorFile *file,
XcursorFileHeader *fileHeader, XcursorFileHeader *fileHeader,
int toc) int toc)
{ {
@ -458,17 +458,17 @@ _XcursorReadImage (XcursorFile *file,
if (!file || !fileHeader) if (!file || !fileHeader)
return NULL; return NULL;
if (!_XcursorFileReadChunkHeader (file, fileHeader, toc, &chunkHeader)) if (!_XcursorFileReadChunkHeader(file, fileHeader, toc, &chunkHeader))
return NULL; return NULL;
if (!_XcursorReadUInt (file, &head.width)) if (!_XcursorReadUInt(file, &head.width))
return NULL; return NULL;
if (!_XcursorReadUInt (file, &head.height)) if (!_XcursorReadUInt(file, &head.height))
return NULL; return NULL;
if (!_XcursorReadUInt (file, &head.xhot)) if (!_XcursorReadUInt(file, &head.xhot))
return NULL; return NULL;
if (!_XcursorReadUInt (file, &head.yhot)) if (!_XcursorReadUInt(file, &head.yhot))
return NULL; return NULL;
if (!_XcursorReadUInt (file, &head.delay)) if (!_XcursorReadUInt(file, &head.delay))
return NULL; return NULL;
/* sanity check data */ /* sanity check data */
if (head.width > XCURSOR_IMAGE_MAX_SIZE || if (head.width > XCURSOR_IMAGE_MAX_SIZE ||
@ -480,7 +480,7 @@ _XcursorReadImage (XcursorFile *file,
return NULL; return NULL;
/* Create the image and initialize it */ /* Create the image and initialize it */
image = XcursorImageCreate (head.width, head.height); image = XcursorImageCreate(head.width, head.height);
if (image == NULL) if (image == NULL)
return NULL; return NULL;
if (chunkHeader.version < image->version) if (chunkHeader.version < image->version)
@ -493,9 +493,9 @@ _XcursorReadImage (XcursorFile *file,
p = image->pixels; p = image->pixels;
while (n--) while (n--)
{ {
if (!_XcursorReadUInt (file, p)) if (!_XcursorReadUInt(file, p))
{ {
XcursorImageDestroy (image); XcursorImageDestroy(image);
return NULL; return NULL;
} }
p++; p++;
@ -504,7 +504,7 @@ _XcursorReadImage (XcursorFile *file,
} }
static XcursorImages * static XcursorImages *
XcursorXcFileLoadImages (XcursorFile *file, int size) XcursorXcFileLoadImages(XcursorFile *file, int size)
{ {
XcursorFileHeader *fileHeader; XcursorFileHeader *fileHeader;
uint32_t bestSize; uint32_t bestSize;
@ -515,64 +515,64 @@ XcursorXcFileLoadImages (XcursorFile *file, int size)
if (!file || size < 0) if (!file || size < 0)
return NULL; return NULL;
fileHeader = _XcursorReadFileHeader (file); fileHeader = _XcursorReadFileHeader(file);
if (!fileHeader) if (!fileHeader)
return NULL; return NULL;
bestSize = _XcursorFindBestSize (fileHeader, (uint32_t) size, &nsize); bestSize = _XcursorFindBestSize(fileHeader, (uint32_t) size, &nsize);
if (!bestSize) if (!bestSize)
{ {
_XcursorFileHeaderDestroy (fileHeader); _XcursorFileHeaderDestroy(fileHeader);
return NULL; return NULL;
} }
images = XcursorImagesCreate (nsize); images = XcursorImagesCreate(nsize);
if (!images) if (!images)
{ {
_XcursorFileHeaderDestroy (fileHeader); _XcursorFileHeaderDestroy(fileHeader);
return NULL; return NULL;
} }
for (n = 0; n < nsize; n++) for (n = 0; n < nsize; n++)
{ {
toc = _XcursorFindImageToc (fileHeader, bestSize, n); toc = _XcursorFindImageToc(fileHeader, bestSize, n);
if (toc < 0) if (toc < 0)
break; break;
images->images[images->nimage] = _XcursorReadImage (file, fileHeader, images->images[images->nimage] = _XcursorReadImage(file, fileHeader,
toc); toc);
if (!images->images[images->nimage]) if (!images->images[images->nimage])
break; break;
images->nimage++; images->nimage++;
} }
_XcursorFileHeaderDestroy (fileHeader); _XcursorFileHeaderDestroy(fileHeader);
if (images->nimage != nsize) if (images->nimage != nsize)
{ {
XcursorImagesDestroy (images); XcursorImagesDestroy(images);
images = NULL; images = NULL;
} }
return images; return images;
} }
static int static int
_XcursorStdioFileRead (XcursorFile *file, unsigned char *buf, int len) _XcursorStdioFileRead(XcursorFile *file, unsigned char *buf, int len)
{ {
FILE *f = file->closure; FILE *f = file->closure;
return fread (buf, 1, len, f); return fread(buf, 1, len, f);
} }
static int static int
_XcursorStdioFileWrite (XcursorFile *file, unsigned char *buf, int len) _XcursorStdioFileWrite(XcursorFile *file, unsigned char *buf, int len)
{ {
FILE *f = file->closure; FILE *f = file->closure;
return fwrite (buf, 1, len, f); return fwrite(buf, 1, len, f);
} }
static int static int
_XcursorStdioFileSeek (XcursorFile *file, long offset, int whence) _XcursorStdioFileSeek(XcursorFile *file, long offset, int whence)
{ {
FILE *f = file->closure; FILE *f = file->closure;
return fseek (f, offset, whence); return fseek(f, offset, whence);
} }
static void static void
_XcursorStdioFileInitialize (FILE *stdfile, XcursorFile *file) _XcursorStdioFileInitialize(FILE *stdfile, XcursorFile *file)
{ {
file->closure = stdfile; file->closure = stdfile;
file->read = _XcursorStdioFileRead; file->read = _XcursorStdioFileRead;
@ -581,15 +581,15 @@ _XcursorStdioFileInitialize (FILE *stdfile, XcursorFile *file)
} }
static XcursorImages * static XcursorImages *
XcursorFileLoadImages (FILE *file, int size) XcursorFileLoadImages(FILE *file, int size)
{ {
XcursorFile f; XcursorFile f;
if (!file) if (!file)
return NULL; return NULL;
_XcursorStdioFileInitialize (file, &f); _XcursorStdioFileInitialize(file, &f);
return XcursorXcFileLoadImages (&f, size); return XcursorXcFileLoadImages(&f, size);
} }
/* /*
@ -617,59 +617,59 @@ XcursorFileLoadImages (FILE *file, int size)
* and must be freed by the caller. * and must be freed by the caller.
*/ */
static char * static char *
XcursorLibraryPath (void) XcursorLibraryPath(void)
{ {
const char *env_var; const char *env_var;
char *path = NULL; char *path = NULL;
int pathlen = 0; int pathlen = 0;
env_var = getenv ("XCURSOR_PATH"); env_var = getenv("XCURSOR_PATH");
if (env_var) if (env_var)
{ {
path = strdup (env_var); path = strdup(env_var);
} }
else else
{ {
env_var = getenv ("XDG_DATA_HOME"); env_var = getenv("XDG_DATA_HOME");
if (env_var) { if (env_var) {
pathlen = strlen (env_var) + strlen (CURSORDIR ":" XCURSORPATH) + 1; pathlen = strlen(env_var) + strlen(CURSORDIR ":" XCURSORPATH) + 1;
path = malloc (pathlen); path = malloc(pathlen);
snprintf (path, pathlen, "%s%s", env_var, snprintf(path, pathlen, "%s%s", env_var,
CURSORDIR ":" XCURSORPATH); CURSORDIR ":" XCURSORPATH);
} }
else else
{ {
path = strdup (XDG_DATA_HOME_FALLBACK CURSORDIR ":" XCURSORPATH); path = strdup(XDG_DATA_HOME_FALLBACK CURSORDIR ":" XCURSORPATH);
} }
} }
return path; return path;
} }
static void static void
_XcursorAddPathElt (char *path, const char *elt, int len) _XcursorAddPathElt(char *path, const char *elt, int len)
{ {
int pathlen = strlen (path); int pathlen = strlen(path);
/* append / if the path doesn't currently have one */ /* append / if the path doesn't currently have one */
if (path[0] == '\0' || path[pathlen - 1] != '/') if (path[0] == '\0' || path[pathlen - 1] != '/')
{ {
strcat (path, "/"); strcat(path, "/");
pathlen++; pathlen++;
} }
if (len == -1) if (len == -1)
len = strlen (elt); len = strlen(elt);
/* strip leading slashes */ /* strip leading slashes */
while (len && elt[0] == '/') while (len && elt[0] == '/')
{ {
elt++; elt++;
len--; len--;
} }
strncpy (path + pathlen, elt, len); strncpy(path + pathlen, elt, len);
path[pathlen + len] = '\0'; path[pathlen + len] = '\0';
} }
static char * static char *
_XcursorBuildThemeDir (const char *dir, const char *theme) _XcursorBuildThemeDir(const char *dir, const char *theme)
{ {
const char *colon; const char *colon;
const char *tcolon; const char *tcolon;
@ -683,15 +683,15 @@ _XcursorBuildThemeDir (const char *dir, const char *theme)
if (!dir || !theme) if (!dir || !theme)
return NULL; return NULL;
colon = strchr (dir, ':'); colon = strchr(dir, ':');
if (!colon) if (!colon)
colon = dir + strlen (dir); colon = dir + strlen(dir);
dirlen = colon - dir; dirlen = colon - dir;
tcolon = strchr (theme, ':'); tcolon = strchr(theme, ':');
if (!tcolon) if (!tcolon)
tcolon = theme + strlen (theme); tcolon = theme + strlen(theme);
themelen = tcolon - theme; themelen = tcolon - theme;
@ -699,10 +699,10 @@ _XcursorBuildThemeDir (const char *dir, const char *theme)
homelen = 0; homelen = 0;
if (*dir == '~') if (*dir == '~')
{ {
home = getenv ("HOME"); home = getenv("HOME");
if (!home) if (!home)
return NULL; return NULL;
homelen = strlen (home); homelen = strlen(home);
dir++; dir++;
dirlen--; dirlen--;
} }
@ -713,40 +713,40 @@ _XcursorBuildThemeDir (const char *dir, const char *theme)
*/ */
len = 1 + homelen + 1 + dirlen + 1 + themelen + 1; len = 1 + homelen + 1 + dirlen + 1 + themelen + 1;
full = malloc (len); full = malloc(len);
if (!full) if (!full)
return NULL; return NULL;
full[0] = '\0'; full[0] = '\0';
if (home) if (home)
_XcursorAddPathElt (full, home, -1); _XcursorAddPathElt(full, home, -1);
_XcursorAddPathElt (full, dir, dirlen); _XcursorAddPathElt(full, dir, dirlen);
_XcursorAddPathElt (full, theme, themelen); _XcursorAddPathElt(full, theme, themelen);
return full; return full;
} }
static char * static char *
_XcursorBuildFullname (const char *dir, const char *subdir, const char *file) _XcursorBuildFullname(const char *dir, const char *subdir, const char *file)
{ {
char *full; char *full;
if (!dir || !subdir || !file) if (!dir || !subdir || !file)
return NULL; return NULL;
full = malloc (strlen (dir) + 1 + strlen (subdir) + 1 + strlen (file) + 1); full = malloc(strlen(dir) + 1 + strlen(subdir) + 1 + strlen(file) + 1);
if (!full) if (!full)
return NULL; return NULL;
full[0] = '\0'; full[0] = '\0';
_XcursorAddPathElt (full, dir, -1); _XcursorAddPathElt(full, dir, -1);
_XcursorAddPathElt (full, subdir, -1); _XcursorAddPathElt(full, subdir, -1);
_XcursorAddPathElt (full, file, -1); _XcursorAddPathElt(full, file, -1);
return full; return full;
} }
static const char * static const char *
_XcursorNextPath (const char *path) _XcursorNextPath(const char *path)
{ {
char *colon = strchr (path, ':'); char *colon = strchr(path, ':');
if (!colon) if (!colon)
return NULL; return NULL;
@ -757,7 +757,7 @@ _XcursorNextPath (const char *path)
#define XcursorSep(c) ((c) == ';' || (c) == ',') #define XcursorSep(c) ((c) == ';' || (c) == ',')
static char * static char *
_XcursorThemeInherits (const char *full) _XcursorThemeInherits(const char *full)
{ {
char line[8192]; char line[8192];
char *result = NULL; char *result = NULL;
@ -766,12 +766,12 @@ _XcursorThemeInherits (const char *full)
if (!full) if (!full)
return NULL; return NULL;
f = fopen (full, "r"); f = fopen(full, "r");
if (f) if (f)
{ {
while (fgets (line, sizeof (line), f)) while (fgets(line, sizeof(line), f))
{ {
if (!strncmp (line, "Inherits", 8)) if (!strncmp(line, "Inherits", 8))
{ {
char *l = line + 8; char *l = line + 8;
char *r; char *r;
@ -779,13 +779,13 @@ _XcursorThemeInherits (const char *full)
if (*l != '=') continue; if (*l != '=') continue;
l++; l++;
while (*l == ' ') l++; while (*l == ' ') l++;
result = malloc (strlen (l) + 1); result = malloc(strlen(l) + 1);
if (result) if (result)
{ {
r = result; r = result;
while (*l) while (*l)
{ {
while (XcursorSep(*l) || XcursorWhite (*l)) l++; while (XcursorSep(*l) || XcursorWhite(*l)) l++;
if (!*l) if (!*l)
break; break;
if (r != result) if (r != result)
@ -799,7 +799,7 @@ _XcursorThemeInherits (const char *full)
break; break;
} }
} }
fclose (f); fclose(f);
} }
return result; return result;
} }
@ -842,7 +842,7 @@ load_all_cursors_from_dir(const char *path, int size,
load_callback(images, user_data); load_callback(images, user_data);
} }
fclose (f); fclose(f);
free(full); free(full);
} }
@ -914,5 +914,5 @@ xcursor_load_theme(const char *theme, int size,
if (inherits) if (inherits)
free(inherits); free(inherits);
free (xcursor_path); free(xcursor_path);
} }

6
cursor/xcursor.h
View file

@ -49,10 +49,10 @@ typedef struct _XcursorImages {
} XcursorImages; } XcursorImages;
void void
XcursorImagesDestroy (XcursorImages *images); XcursorImagesDestroy(XcursorImages *images);
void void
xcursor_load_theme(const char *theme, int size, xcursor_load_theme(const char *theme, int size,
void (*load_callback)(XcursorImages *, void *), void (*load_callback)(XcursorImages *, void *),
void *user_data); void *user_data);
#endif #endif