]> git.saurik.com Git - wxWidgets.git/blob - src/xpm/misc.c
automtn.cpp removed for Borland compilation
[wxWidgets.git] / src / xpm / misc.c
1 /*
2 * Copyright (C) 1989-94 GROUPE BULL
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to
6 * deal in the Software without restriction, including without limitation the
7 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
8 * sell copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20 *
21 * Except as contained in this notice, the name of GROUPE BULL shall not be
22 * used in advertising or otherwise to promote the sale, use or other dealings
23 * in this Software without prior written authorization from GROUPE BULL.
24 */
25
26 /*****************************************************************************\
27 * misc.c: *
28 * *
29 * XPM library *
30 * Miscellaneous utilities *
31 * *
32 * Developed by Arnaud Le Hors *
33 \*****************************************************************************/
34
35 /*
36 * The code related to FOR_MSW has been added by
37 * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
38 */
39
40 #include "xpm34p.h"
41 #ifdef VMS
42 #include "sys$library:stat.h"
43 #include "sys$library:fcntl.h"
44 #else
45 #include <sys/types.h>
46 #include <sys/stat.h>
47 #include <fcntl.h>
48 #include <stdio.h>
49 #ifdef FOR_MSW
50 #include <io.h>
51 #else
52 #include <unistd.h>
53 #endif
54 #endif
55
56 /* 3.2 backward compatibility code */
57 LFUNC(CreateOldColorTable, int, (XpmColor *ct, int ncolors,
58 XpmColor ***oldct));
59
60 LFUNC(FreeOldColorTable, void, (XpmColor **colorTable, int ncolors));
61
62 /*
63 * Create a colortable compatible with the old style colortable
64 */
65 static int
66 CreateOldColorTable(XpmColor *ct, int ncolors, XpmColor ***oldct)
67 {
68 XpmColor **colorTable, **color;
69 int a;
70
71 colorTable = (XpmColor **) XpmMalloc(ncolors * sizeof(XpmColor *));
72 if (!colorTable) {
73 *oldct = NULL;
74 return (XpmNoMemory);
75 }
76 for (a = 0, color = colorTable; a < ncolors; a++, color++, ct++)
77 *color = ct;
78 *oldct = colorTable;
79 return (XpmSuccess);
80 }
81
82 static void
83 FreeOldColorTable(XpmColor **colorTable, int ncolors)
84 {
85 int a, b;
86 XpmColor **color;
87 char **sptr;
88
89 if (colorTable) {
90 for (a = 0, color = colorTable; a < ncolors; a++, color++) {
91 for (b = 0, sptr = (char **) *color; b <= NKEYS; b++, sptr++)
92 if (*sptr)
93 XpmFree(*sptr);
94 }
95 XpmFree(*colorTable);
96 XpmFree(colorTable);
97 }
98 }
99
100 /* end 3.2 bc */
101
102
103 /*
104 * Free the computed color table
105 */
106 void
107 xpmFreeColorTable(XpmColor *colorTable, int ncolors)
108 {
109 int a, b;
110 XpmColor *color;
111 char **sptr;
112
113 if (colorTable) {
114 for (a = 0, color = colorTable; a < ncolors; a++, color++) {
115 for (b = 0, sptr = (char **) color; b <= NKEYS; b++, sptr++)
116 if (*sptr)
117 XpmFree(*sptr);
118 }
119 XpmFree(colorTable);
120 }
121 }
122
123 /*
124 * Free array of extensions
125 */
126 void
127 XpmFreeExtensions(XpmExtension *extensions, int nextensions)
128 {
129 unsigned int i, j, nlines;
130 XpmExtension *ext;
131 char **sptr;
132
133 if (extensions) {
134 for (i = 0, ext = extensions; i < nextensions; i++, ext++) {
135 if (ext->name)
136 XpmFree(ext->name);
137 nlines = ext->nlines;
138 for (j = 0, sptr = ext->lines; j < nlines; j++, sptr++)
139 if (*sptr)
140 XpmFree(*sptr);
141 if (ext->lines)
142 XpmFree(ext->lines);
143 }
144 XpmFree(extensions);
145 }
146 }
147
148
149 /*
150 * Return the XpmAttributes structure size
151 */
152
153 int
154 XpmAttributesSize()
155 {
156 return sizeof(XpmAttributes);
157 }
158
159 /*
160 * Init returned data to free safely later on
161 */
162 void
163 xpmInitAttributes(XpmAttributes *attributes)
164 {
165 if (attributes) {
166 attributes->pixels = NULL;
167 attributes->npixels = 0;
168 attributes->colorTable = NULL;
169 attributes->ncolors = 0;
170 /* 3.2 backward compatibility code */
171 attributes->hints_cmt = NULL;
172 attributes->colors_cmt = NULL;
173 attributes->pixels_cmt = NULL;
174 /* end 3.2 bc */
175 attributes->extensions = NULL;
176 attributes->nextensions = 0;
177 }
178 }
179
180 /*
181 * Fill in the XpmAttributes with the XpmImage and the XpmInfo
182 */
183 void
184 xpmSetAttributes(XpmAttributes *attributes, XpmImage *image, XpmInfo *info)
185 {
186 if (attributes->valuemask & XpmReturnColorTable) {
187 attributes->colorTable = image->colorTable;
188 attributes->ncolors = image->ncolors;
189
190 /* avoid deletion of copied data */
191 image->ncolors = 0;
192 image->colorTable = NULL;
193 }
194 /* 3.2 backward compatibility code */
195 else if (attributes->valuemask & XpmReturnInfos) {
196 int ErrorStatus;
197
198 ErrorStatus = CreateOldColorTable(image->colorTable, image->ncolors,
199 (XpmColor ***)
200 &attributes->colorTable);
201
202 /* if error just say we can't return requested data */
203 if (ErrorStatus != XpmSuccess) {
204 attributes->valuemask &= ~XpmReturnInfos;
205 if (!(attributes->valuemask & XpmReturnPixels)) {
206 XpmFree(attributes->pixels);
207 attributes->pixels = NULL;
208 attributes->npixels = 0;
209 }
210 attributes->ncolors = 0;
211 } else {
212 attributes->ncolors = image->ncolors;
213 attributes->hints_cmt = info->hints_cmt;
214 attributes->colors_cmt = info->colors_cmt;
215 attributes->pixels_cmt = info->pixels_cmt;
216
217 /* avoid deletion of copied data */
218 image->ncolors = 0;
219 image->colorTable = NULL;
220 info->hints_cmt = NULL;
221 info->colors_cmt = NULL;
222 info->pixels_cmt = NULL;
223 }
224 }
225 /* end 3.2 bc */
226 if (attributes->valuemask & XpmReturnExtensions) {
227 attributes->extensions = info->extensions;
228 attributes->nextensions = info->nextensions;
229
230 /* avoid deletion of copied data */
231 info->extensions = NULL;
232 info->nextensions = 0;
233 }
234 if (info->valuemask & XpmHotspot) {
235 attributes->valuemask |= XpmHotspot;
236 attributes->x_hotspot = info->x_hotspot;
237 attributes->y_hotspot = info->y_hotspot;
238 }
239 attributes->valuemask |= XpmCharsPerPixel;
240 attributes->cpp = image->cpp;
241 attributes->valuemask |= XpmSize;
242 attributes->width = image->width;
243 attributes->height = image->height;
244 }
245
246 /*
247 * Free the XpmAttributes structure members
248 * but the structure itself
249 */
250 void
251 XpmFreeAttributes(XpmAttributes *attributes)
252 {
253 if (attributes->valuemask & XpmReturnPixels && attributes->npixels) {
254 XpmFree(attributes->pixels);
255 attributes->pixels = NULL;
256 attributes->npixels = 0;
257 }
258 if (attributes->valuemask & XpmReturnColorTable) {
259 xpmFreeColorTable(attributes->colorTable, attributes->ncolors);
260 attributes->colorTable = NULL;
261 attributes->ncolors = 0;
262 }
263 /* 3.2 backward compatibility code */
264 else if (attributes->valuemask & XpmInfos) {
265 if (attributes->colorTable) {
266 FreeOldColorTable((XpmColor **) attributes->colorTable,
267 attributes->ncolors);
268 attributes->colorTable = NULL;
269 attributes->ncolors = 0;
270 }
271 if (attributes->hints_cmt) {
272 XpmFree(attributes->hints_cmt);
273 attributes->hints_cmt = NULL;
274 }
275 if (attributes->colors_cmt) {
276 XpmFree(attributes->colors_cmt);
277 attributes->colors_cmt = NULL;
278 }
279 if (attributes->pixels_cmt) {
280 XpmFree(attributes->pixels_cmt);
281 attributes->pixels_cmt = NULL;
282 }
283 if (attributes->pixels) {
284 XpmFree(attributes->pixels);
285 attributes->pixels = NULL;
286 attributes->npixels = 0;
287 }
288 }
289 /* end 3.2 bc */
290 if (attributes->valuemask & XpmReturnExtensions
291 && attributes->nextensions) {
292 XpmFreeExtensions(attributes->extensions, attributes->nextensions);
293 attributes->extensions = NULL;
294 attributes->nextensions = 0;
295 }
296 attributes->valuemask = 0;
297 }
298
299 /*
300 * Init returned data to free safely later on
301 */
302 void
303 xpmInitXpmImage(XpmImage *image)
304 {
305 image->ncolors = 0;
306 image->colorTable = NULL;
307 image->data = NULL;
308 }
309
310 /*
311 * Free the XpmImage data which have been allocated
312 */
313 void
314 XpmFreeXpmImage(XpmImage *image)
315 {
316 if (image->colorTable)
317 xpmFreeColorTable(image->colorTable, image->ncolors);
318 XpmFree(image->data);
319 image->data = NULL;
320 }
321
322 /*
323 * Init returned data to free safely later on
324 */
325 void
326 xpmInitXpmInfo(XpmInfo *info)
327 {
328 if (info) {
329 info->hints_cmt = NULL;
330 info->colors_cmt = NULL;
331 info->pixels_cmt = NULL;
332 info->extensions = NULL;
333 info->nextensions = 0;
334 }
335 }
336
337 /*
338 * Free the XpmInfo data which have been allocated
339 */
340 void
341 XpmFreeXpmInfo(XpmInfo *info)
342 {
343 if (info) {
344 if (info->valuemask & XpmComments) {
345 if (info->hints_cmt) {
346 XpmFree(info->hints_cmt);
347 info->hints_cmt = NULL;
348 }
349 if (info->colors_cmt) {
350 XpmFree(info->colors_cmt);
351 info->colors_cmt = NULL;
352 }
353 if (info->pixels_cmt) {
354 XpmFree(info->pixels_cmt);
355 info->pixels_cmt = NULL;
356 }
357 }
358 if (info->valuemask & XpmReturnExtensions && info->nextensions) {
359 XpmFreeExtensions(info->extensions, info->nextensions);
360 info->extensions = NULL;
361 info->nextensions = 0;
362 }
363 info->valuemask = 0;
364 }
365 }
366
367 /*
368 * Set the XpmInfo valuemask to retrieve required info
369 */
370 void
371 xpmSetInfoMask(XpmInfo *info, XpmAttributes *attributes)
372 {
373 info->valuemask = 0;
374 if (attributes->valuemask & XpmReturnInfos)
375 info->valuemask |= XpmReturnComments;
376 if (attributes->valuemask & XpmReturnExtensions)
377 info->valuemask |= XpmReturnExtensions;
378 }
379
380 /*
381 * Fill in the XpmInfo with the XpmAttributes
382 */
383 void
384 xpmSetInfo(XpmInfo *info, XpmAttributes *attributes)
385 {
386 info->valuemask = 0;
387 if (attributes->valuemask & XpmInfos) {
388 info->valuemask |= XpmComments | XpmColorTable;
389 info->hints_cmt = attributes->hints_cmt;
390 info->colors_cmt = attributes->colors_cmt;
391 info->pixels_cmt = attributes->pixels_cmt;
392 }
393 if (attributes->valuemask & XpmExtensions) {
394 info->valuemask |= XpmExtensions;
395 info->extensions = attributes->extensions;
396 info->nextensions = attributes->nextensions;
397 }
398 if (attributes->valuemask & XpmHotspot) {
399 info->valuemask |= XpmHotspot;
400 info->x_hotspot = attributes->x_hotspot;
401 info->y_hotspot = attributes->y_hotspot;
402 }
403 }
404
405
406 #ifdef NEED_STRDUP
407 /*
408 * in case strdup is not provided by the system here is one
409 * which does the trick
410 */
411 char *
412 strdup(char *s1)
413 {
414 char *s2;
415 int l = strlen(s1) + 1;
416
417 if (s2 = (char *) XpmMalloc(l))
418 strncpy(s2, s1, l);
419 return s2;
420 }
421
422 #endif
423
424 unsigned int
425 atoui(register char *p, unsigned int l, unsigned int *ui_return)
426 {
427 register unsigned int n, i;
428
429 n = 0;
430 for (i = 0; i < l; i++)
431 if (*p >= '0' && *p <= '9')
432 n = n * 10 + *p++ - '0';
433 else
434 break;
435
436 if (i != 0 && i == l) {
437 *ui_return = n;
438 return 1;
439 } else
440 return 0;
441 }
442
443
444 /*
445 * File / Buffer utilities
446 */
447 int
448 XpmReadFileToBuffer(char *filename, char **buffer_return)
449 {
450 int fd, fcheck, len;
451 char *ptr;
452 struct stat stats;
453 FILE *fp;
454
455 *buffer_return = NULL;
456
457 fd = open(filename, O_RDONLY);
458 if (fd < 0)
459 return XpmOpenFailed;
460
461 if (fstat(fd, &stats)) {
462 close(fd);
463 return XpmOpenFailed;
464 }
465 fp = fdopen(fd, "r");
466 if (!fp) {
467 close(fd);
468 return XpmOpenFailed;
469 }
470 len = (int) stats.st_size;
471 ptr = (char *) XpmMalloc(len + 1);
472 if (!ptr) {
473 fclose(fp);
474 return XpmNoMemory;
475 }
476 fcheck = fread(ptr, len, 1, fp);
477 fclose(fp);
478 if (fcheck != 1) {
479 XpmFree(ptr);
480 return XpmOpenFailed;
481 }
482 ptr[len] = '\0';
483 *buffer_return = ptr;
484 return XpmSuccess;
485 }
486
487 int
488 XpmWriteFileFromBuffer(char *filename, char *buffer)
489 {
490 int fcheck, len;
491 FILE *fp = fopen(filename, "w");
492
493 if (!fp)
494 return XpmOpenFailed;
495
496 len = strlen(buffer);
497 fcheck = fwrite(buffer, len, 1, fp);
498 fclose(fp);
499 if (fcheck != 1)
500 return XpmOpenFailed;
501
502 return XpmSuccess;
503 }
504
505
506 /*
507 * Small utility function
508 */
509 char *
510 XpmGetErrorString(int errcode)
511 {
512 switch (errcode) {
513 case XpmColorError:
514 return ("XpmColorError");
515 case XpmSuccess:
516 return ("XpmSuccess");
517 case XpmOpenFailed:
518 return ("XpmOpenFailed");
519 case XpmFileInvalid:
520 return ("XpmFileInvalid");
521 case XpmNoMemory:
522 return ("XpmNoMemory");
523 case XpmColorFailed:
524 return ("XpmColorFailed");
525 default:
526 return ("Invalid XpmError");
527 }
528 }
529
530 /*
531 * The following function provides a way to figure out if the linked library is
532 * newer or older than the one with which a program has been first compiled.
533 */
534 int
535 XpmLibraryVersion()
536 {
537 return XpmIncludeVersion;
538 }
539
540
541 #ifndef FOR_MSW
542 void
543 xpmCreatePixmapFromImage(Display *display, Drawable d, XImage *ximage, Pixmap *pixmap_return)
544 {
545 GC gc;
546
547 *pixmap_return = XCreatePixmap(display, d, ximage->width,
548 ximage->height, ximage->depth);
549 gc = XCreateGC(display, *pixmap_return, 0, NULL);
550
551 XPutImage(display, *pixmap_return, gc, ximage, 0, 0, 0, 0,
552 ximage->width, ximage->height);
553
554 XFreeGC(display, gc);
555 }
556
557 void
558 xpmCreateImageFromPixmap(Display *display, Pixmap pixmap, XImage **ximage_return, unsigned int *width, unsigned int *height)
559 {
560 unsigned int dum;
561 int dummy;
562 Window win;
563
564 if (*width == 0 && *height == 0)
565 XGetGeometry(display, pixmap, &win, &dummy, &dummy,
566 width, height, &dum, &dum);
567
568 *ximage_return = XGetImage(display, pixmap, 0, 0, *width, *height,
569 AllPlanes, ZPixmap);
570 }
571
572 #endif /* FOR_MSW */