logo

xcursorgen-nox

xcursorgen(1) without libX11/libXcursor dependency

xcursorgen.c (10631B)

    

  1. /*
  2.  * xcursorgen.c
  3.  *
  4.  * Copyright (C) 2002 Manish Singh
  5.  *
  6.  * SPDX-License-Identifier: MIT
  7.  *
  8.  * Permission to use, copy, modify, distribute, and sell this software and its
  9.  * documentation for any purpose is hereby granted without fee, provided that
  10.  * the above copyright notice appear in all copies and that both that
  11.  * copyright notice and this permission notice appear in supporting
  12.  * documentation, and that the name of Manish Singh not be used in
  13.  * advertising or publicity pertaining to distribution of the software without
  14.  * specific, written prior permission.  Manish Singh makes no
  15.  * representations about the suitability of this software for any purpose.  It
  16.  * is provided "as is" without express or implied warranty.
  17.  *
  18.  * MANISH SINGH DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  19.  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  20.  * EVENT SHALL MANISH SINGH BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  21.  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  22.  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  23.  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  24.  * PERFORMANCE OF THIS SOFTWARE.
  25.  */
  27. #define _POSIX_C_SOURCE 200809L
  29. #include "Xcursor/Xcursor.h"
  30. #include "config.h"
  32. #include <ctype.h>
  33. #include <errno.h>
  34. #include <png.h>
  35. #include <stdio.h>
  36. #include <stdlib.h>
  37. #include <string.h>
  39. static const char *ProgramName;
  41. struct flist
  42. {
  43. 	int size;
  44. 	int xhot, yhot;
  45. 	int delay;
  46. 	char *pngfile;
  47. 	struct flist *next;
  48. };
  50. static void
  51. usage(const char *name)
  52. {
  53. 	fprintf(stderr,
  54. 	        "usage: %s [-V] [--version] [-?] [--help] [-p <dir>] [--prefix <dir>] [CONFIG [OUT]]\n%s",
  55. 	        name,
  56. 	        "Generate an Xcursor file from a series of PNG images\n"
  57. 	        "\n"
  58. 	        "  -V, --version      display the version number and exit\n"
  59. 	        "  -?, --help         display this message and exit\n"
  60. 	        "  -p, --prefix <dir> find cursor images in <dir>\n"
  61. 	        "\n"
  62. 	        "With no CONFIG, or when CONFIG is -, read standard input. "
  63. 	        "Same with OUT and\n"
  64. 	        "standard output.\n");
  65. }
  67. static int
  68. read_config_file(const char *config, struct flist **list)
  69. {
  70. 	FILE *fp;
  71. 	char line[4096], pngfile[4000];
  72. 	int size, xhot, yhot, delay;
  73. 	struct flist *start = NULL, *end = NULL, *curr;
  74. 	int count = 0;
  76. 	if(strcmp(config, "-") != 0)
  77. 	{
  78. 		fp = fopen(config, "r");
  79. 		if(!fp)
  80. 		{
  81. 			*list = NULL;
  82. 			return 0;
  83. 		}
  84. 	}
  85. 	else
  86. 		fp = stdin;
  88. 	while(fgets(line, sizeof(line), fp) != NULL)
  89. 	{
  90. 		if(line[0] == '#') continue;
  92. 		switch(sscanf(line, "%d %d %d %3999s %d", &size, &xhot, &yhot, pngfile, &delay))
  93. 		{
  94. 		case 4:
  95. 			delay = 50;
  96. 			break;
  97. 		case 5:
  98. 			break;
  99. 		default:
  100. 		{
  101. 			fprintf(stderr,
  102. 			        "%s: Bad config file data on line %d of %s\n",
  103. 			        ProgramName,
  104. 			        count + 1,
  105. 			        strcmp(config, "-") ? config : "stdin");
  106. 			fclose(fp);
  107. 			return 0;
  108. 		}
  109. 		}
  111. 		curr = malloc(sizeof(struct flist));
  112. 		if(curr == NULL)
  113. 		{
  114. 			fprintf(stderr, "%s: malloc() failed: %s\n", ProgramName, strerror(errno));
  115. 			fclose(fp);
  116. 			return 0;
  117. 		}
  119. 		curr->size = size;
  120. 		curr->xhot = xhot;
  121. 		curr->yhot = yhot;
  123. 		curr->delay = delay;
  125. 		curr->pngfile = strdup(pngfile);
  126. 		if(curr->pngfile == NULL)
  127. 		{
  128. 			fprintf(stderr, "%s: strdup() failed: %s\n", ProgramName, strerror(errno));
  129. 			fclose(fp);
  130. 			free(curr);
  131. 			return 0;
  132. 		}
  134. 		curr->next = NULL;
  136. 		if(start)
  137. 		{
  138. 			end->next = curr;
  139. 			end       = curr;
  140. 		}
  141. 		else
  142. 		{
  143. 			start = curr;
  144. 			end   = curr;
  145. 		}
  147. 		count++;
  148. 	}
  150. 	fclose(fp);
  152. 	*list = start;
  153. 	return count;
  154. }
  156. #define div_255(x) (((x) + 0x80 + (((x) + 0x80) >> 8)) >> 8)
  158. static void
  159. premultiply_data(png_structp png, png_row_infop row_info, png_bytep data)
  160. {
  161. 	png_size_t i;
  163. 	for(i = 0; i < row_info->rowbytes; i += 4)
  164. 	{
  165. 		unsigned char *base = &data[i];
  166. 		unsigned char blue  = base[0];
  167. 		unsigned char green = base[1];
  168. 		unsigned char red   = base[2];
  169. 		unsigned char alpha = base[3];
  170. 		XcursorPixel p;
  172. 		red   = (unsigned char)div_255((unsigned)red * (unsigned)alpha);
  173. 		green = (unsigned char)div_255((unsigned)green * (unsigned)alpha);
  174. 		blue  = (unsigned char)div_255((unsigned)blue * (unsigned)alpha);
  175. 		p     = ((unsigned int)alpha << 24) | ((unsigned int)red << 16) | ((unsigned int)green << 8) |
  176. 		    ((unsigned int)blue << 0);
  177. 		memcpy(base, &p, sizeof(XcursorPixel));
  178. 	}
  179. }
  181. static XcursorImage *
  182. load_image(struct flist *list, const char *prefix)
  183. {
  184. 	XcursorImage *image;
  185. 	png_structp png;
  186. 	png_infop info;
  187. 	png_bytepp rows;
  188. 	FILE *fp;
  189. 	png_uint_32 i;
  190. 	png_uint_32 width, height;
  191. 	int depth, color, interlace;
  192. 	char *file;
  194. 	png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
  195. 	if(png == NULL) return NULL;
  197. 	info = png_create_info_struct(png);
  198. 	if(info == NULL)
  199. 	{
  200. 		png_destroy_read_struct(&png, NULL, NULL);
  201. 		return NULL;
  202. 	}
  204. 	if(setjmp(png_jmpbuf(png)))
  205. 	{
  206. 		png_destroy_read_struct(&png, &info, NULL);
  207. 		return NULL;
  208. 	}
  210. 	if(prefix)
  211. 	{
  212. #ifdef HAVE_ASPRINTF
  213. 		if(asprintf(&file, "%s/%s", prefix, list->pngfile) == -1)
  214. 		{
  215. 			fprintf(stderr, "%s: asprintf() failed: %s\n", ProgramName, strerror(errno));
  216. 			png_destroy_read_struct(&png, &info, NULL);
  217. 			return NULL;
  218. 		}
  219. #else
  220. 		file = malloc(strlen(prefix) + 1 + strlen(list->pngfile) + 1);
  221. 		if(file == NULL)
  222. 		{
  223. 			fprintf(stderr, "%s: malloc() failed: %s\n", ProgramName, strerror(errno));
  224. 			png_destroy_read_struct(&png, &info, NULL);
  225. 			return NULL;
  226. 		}
  227. 		strcpy(file, prefix);
  228. 		strcat(file, "/");
  229. 		strcat(file, list->pngfile);
  230. #endif
  231. 	}
  232. 	else
  233. 		file = list->pngfile;
  234. 	fp = fopen(file, "rb");
  235. 	if(prefix) free(file);
  237. 	if(fp == NULL)
  238. 	{
  239. 		png_destroy_read_struct(&png, &info, NULL);
  240. 		return NULL;
  241. 	}
  243. 	png_init_io(png, fp);
  244. 	png_read_info(png, info);
  245. 	png_get_IHDR(png, info, &width, &height, &depth, &color, &interlace, NULL, NULL);
  247. 	/* TODO: More needs to be done here maybe */
  249. 	if(color == PNG_COLOR_TYPE_PALETTE && depth <= 8) png_set_expand(png);
  251. 	if(color == PNG_COLOR_TYPE_GRAY && depth < 8) png_set_expand(png);
  253. 	if(png_get_valid(png, info, PNG_INFO_tRNS)) png_set_expand(png);
  255. 	if(depth == 16) png_set_strip_16(png);
  257. 	if(depth < 8) png_set_packing(png);
  259. 	if(color == PNG_COLOR_TYPE_GRAY || color == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png);
  261. 	if(interlace != PNG_INTERLACE_NONE) png_set_interlace_handling(png);
  263. 	png_set_bgr(png);
  264. 	png_set_filler(png, 255, PNG_FILLER_AFTER);
  266. 	png_set_read_user_transform_fn(png, premultiply_data);
  268. 	png_read_update_info(png, info);
  270. 	image = XcursorImageCreate((int)width, (int)height);
  271. 	if(image == NULL)
  272. 	{
  273. 		fprintf(stderr,
  274. 		        "%s: XcursorImageCreate() failed to create %u x %u image\n"
  275. 		        " for file %s\n",
  276. 		        ProgramName,
  277. 		        width,
  278. 		        height,
  279. 		        list->pngfile);
  280. 		fclose(fp);
  281. 		png_destroy_read_struct(&png, &info, NULL);
  282. 		return NULL;
  283. 	}
  285. 	image->size  = (XcursorDim)list->size;
  286. 	image->xhot  = (XcursorDim)list->xhot;
  287. 	image->yhot  = (XcursorDim)list->yhot;
  288. 	image->delay = (XcursorUInt)list->delay;
  290. 	rows = malloc(sizeof(png_bytep) * height);
  291. 	if(rows == NULL)
  292. 	{
  293. 		fclose(fp);
  294. 		png_destroy_read_struct(&png, &info, NULL);
  295. 		return NULL;
  296. 	}
  298. 	for(i = 0; i < height; i++)
  299. 		rows[i] = (png_bytep)(image->pixels + i * width);
  301. 	png_read_image(png, rows);
  302. 	png_read_end(png, info);
  304. 	free(rows);
  305. 	fclose(fp);
  306. 	png_destroy_read_struct(&png, &info, NULL);
  308. 	return image;
  309. }
  311. static int
  312. write_cursors(int count, struct flist *list, const char *filename, const char *prefix)
  313. {
  314. 	XcursorImages *cimages;
  315. 	XcursorImage *image;
  316. 	int i;
  317. 	FILE *fp;
  318. 	int ret;
  320. 	if(strcmp(filename, "-") != 0)
  321. 	{
  322. 		fp = fopen(filename, "wb");
  323. 		if(!fp) return 1;
  324. 	}
  325. 	else
  326. 		fp = stdout;
  328. 	cimages = XcursorImagesCreate(count);
  330. 	cimages->nimage = count;
  332. 	for(i = 0; i < count; i++, list = list->next)
  333. 	{
  334. 		image = load_image(list, prefix);
  335. 		if(image == NULL)
  336. 		{
  337. 			fprintf(stderr, "%s: PNG error while reading %s\n", ProgramName, list->pngfile);
  338. 			fclose(fp);
  339. 			return 1;
  340. 		}
  342. 		cimages->images[i] = image;
  343. 	}
  345. 	ret = XcursorFileSaveImages(fp, cimages);
  347. 	fclose(fp);
  349. 	return ret ? 0 : 1;
  350. }
  352. #if 0
  353. static int
  354. check_image(char *image)
  355. {
  356.     unsigned int width, height;
  357.     unsigned char *data;
  358.     int x_hot, y_hot;
  359.     unsigned char hash[XCURSOR_BITMAP_HASH_SIZE];
  360.     int i;
  362.     if (XReadBitmapFileData(image, &width, &height, &data, &x_hot, &y_hot)
  363.         != BitmapSuccess) {
  364.         fprintf(stderr, "%s: Can't open bitmap file \"%s\"\n", ProgramName,
  365.                 image);
  366.         return 1;
  367.     }
  368.     else {
  369.         XImage ximage = {
  370.             .width              = (int) width,
  371.             .height             = (int) height,
  372.             .depth              = 1,
  373.             .bits_per_pixel     = 1,
  374.             .xoffset            = 0,
  375.             .format             = XYPixmap,
  376.             .data               = (char *) data,
  377.             .byte_order         = LSBFirst,
  378.             .bitmap_unit        = 8,
  379.             .bitmap_bit_order   = LSBFirst,
  380.             .bitmap_pad         = 8,
  381.             .bytes_per_line     = (width + 7) / 8
  382.         };
  383.         XcursorImageHash(&ximage, hash);
  384.     }
  385.     printf("%s: ", image);
  386.     for (i = 0; i < XCURSOR_BITMAP_HASH_SIZE; i++)
  387.         printf("%02x", hash[i]);
  388.     printf("\n");
  389.     return 0;
  390. }
  391. #endif
  393. int
  394. main(int argc, char *argv[])
  395. {
  396. 	struct flist *list;
  397. 	int count;
  398. 	const char *in = NULL, *out = NULL;
  399. 	const char *prefix = NULL;
  400. 	int i;
  402. 	ProgramName = argv[0];
  404. 	for(i = 1; i < argc; i++)
  405. 	{
  406. 		if(strcmp(argv[i], "-V") == 0 || strcmp(argv[i], "--version") == 0)
  407. 		{
  408. 			printf("xcursorgen version %s\n", PACKAGE_VERSION);
  409. 			return 0;
  410. 		}
  412. 		if(strcmp(argv[i], "-?") == 0 || strcmp(argv[i], "--help") == 0)
  413. 		{
  414. 			usage(argv[0]);
  415. 			return 0;
  416. 		}
  417. #if 0
  418.         if (strcmp(argv[i], "-image") == 0) {
  419.             int ret = 0;
  421.             while (argv[++i]) {
  422.                 if (check_image(argv[i]))
  423.                     ret = i;
  424.             }
  425.             return ret;
  426.         }
  427. #endif
  428. 		if(strcmp(argv[i], "-p") == 0 || strcmp(argv[i], "--prefix") == 0)
  429. 		{
  430. 			i++;
  431. 			if(argv[i] == NULL)
  432. 			{
  433. 				fprintf(stderr, "%s: %s requires an argument\n", argv[0], argv[i - 1]);
  434. 				usage(argv[0]);
  435. 				return 1;
  436. 			}
  437. 			prefix = argv[i];
  438. 			continue;
  439. 		}
  441. 		if(!in)
  442. 			in = argv[i];
  443. 		else if(!out)
  444. 			out = argv[i];
  445. 		else
  446. 		{
  447. 			fprintf(stderr, "%s: unexpected argument '%s'\n", argv[0], argv[i]);
  448. 			usage(argv[0]);
  449. 			return 1;
  450. 		}
  451. 	}
  453. 	if(!in) in = "-";
  454. 	if(!out) out = "-";
  456. 	count = read_config_file(in, &list);
  457. 	if(count == 0)
  458. 	{
  459. 		fprintf(
  460. 		    stderr, "%s: Error reading config file %s\n", argv[0], strcmp(in, "-") ? in : "from stdin");
  461. 		return 1;
  462. 	}
  464. 	return write_cursors(count, list, out, prefix);
  465. }