Fix clock clicking with GtkEventBox
[xboard.git] / zic2xpm.c
1 /*
2         zic2xpm.c
3
4         Program to convert pieces from ZIICS format to XPM & XIM format.
5         (C version)  By Frank McIngvale <frankm@hiwaay.net>.
6
7         Copyright (C) 1996, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
8
9         NOTICE: The piece images distributed with ZIICS are
10             copyrighted works of their original creators.  Images 
11             converted with zic2xpm may not be redistributed without
12             the permission of the copyright holders.  Do not contact
13             the authors of zic2xpm or of ZIICS itself to request
14             permission. 
15
16         NOTICE:  The format of the ZIICS piece file was gleaned from
17             SHOWSETS.PAS, a part of ZIICS.  Thanks to Andy McFarland
18             (Zek on ICC) for making this source available!  ZIICS is a 
19             completely separate and copyrighted work of Andy
20             McFarland.  Use and distribution of ZIICS falls under the
21             ZIICS license, NOT the GNU General Public License.
22
23         NOTICE: The format of the VGA imageblocks was determined
24             by experimentation, and without access to any
25             of Borland Inc.'s BGI library source code.
26
27
28             GNU XBoard is free software: you can redistribute it
29             and/or modify it under the terms of the GNU General Public
30             License as published by the Free Software Foundation,
31             either version 3 of the License, or (at your option) any
32             later version.
33             
34             GNU XBoard is distributed in the hope that it will be
35             useful, but WITHOUT ANY WARRANTY; without even the implied
36             warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
37             PURPOSE. See the GNU General Public License for more
38             details.
39             
40             You should have received a copy of the GNU General Public
41             License along with this program. If not, see
42             http://www.gnu.org/licenses/.
43
44
45         ** If you find a bug in zic2xpm.c, please report it to me,
46            Frank McIngvale (frankm@hiwaay.net) so that I may fix it. **
47 */
48
49 /*
50         Usage: zic2xpm file1 [file2 ...]
51
52         We split the ZIICS file(s) into 24 XPM & 24 XIM files with names:
53
54         <piece><type><size>.(xpm|xim).
55
56         Where:
57                 piece = p, n, b, r, q, k
58                 type = ll, ld, dl, dd
59                 size = Piece size.
60
61         Plus 4 files for the light & dark squares.
62         
63         This means that you can extract multiple SIZES in one directory
64         without name clashes. Extracting two sets of the SAME
65         size in a directory will cause the second to overwrite
66         the first.
67 */
68
69 /*
70    Technical note: Yes, this file is huge. I made it by cramming
71                    `zic2xpm' and `zic2xim' together. This should
72                    be less confusing to use, though.
73 */
74
75 #include "config.h"
76 #include <stdio.h>
77 #if STDC_HEADERS
78 #include <stdlib.h>
79 #endif
80
81 #ifndef SEEK_SET
82 #define SEEK_SET 0
83 #endif
84
85 /*
86    XIM file format:
87
88    width        byte
89    height       byte
90
91    Data (1 byte per pixel, row major)
92 */
93
94 /*
95    Map colors from ZIICS -> XIM :
96
97    0    0       Dark piece
98    2    1       Dark square
99    15   2       Light piece
100    14   3       Light square
101 */
102
103 typedef struct {
104   int zval;             /* ZIICS value */
105   int xval;             /* XIM value */
106 } z2xim;
107
108 /* Associate VGA color with XPM color/sym */
109
110 typedef struct {
111   int cval;             /* VGA pixel value */
112   char xchar;   /* XPM character for this color */
113   char *csym;   /* Symbolic name */
114   char *cdefault; /* Default color */
115 } z2xpm;
116
117 #define NR_ZIICS_COLORS 4
118 #define BUFLEN 100
119
120 /* SHOWSETS.PAS (from ZIICS) states that images may only
121    use color numbers 0, 2, 14, and 15 */
122
123 z2xim z2xim_tab[NR_ZIICS_COLORS] = {
124   { 0, 0 },
125   { 2, 1 },
126   { 15, 2 },
127   { 14, 3 } };
128
129 z2xpm z2xpm_tab[NR_ZIICS_COLORS] = {
130   { 15, 'X', "light_piece", "white" },
131   { 0, ' ', "dark_piece", "black" },
132   { 14, '*', "light_square", "gray" },
133   { 2, '.', "dark_square", "green" } };
134
135 void
136 fatal (char *str)
137 {
138   printf("Fatal error: %s\n", str );
139   exit(1);
140 }
141
142 z2xim *
143 lookup_xim_color (int color)
144 {
145   int i;
146
147   for( i=0; i<NR_ZIICS_COLORS; ++i )
148         {
149           if ( z2xim_tab[i].zval == color )
150                 return (z2xim_tab + i);
151         }
152
153   fatal("Illegal color in image.");
154
155   /* NOT REACHED */
156   return NULL;                                  /* Make compiler happy */
157 }
158
159 z2xpm *
160 lookup_xpm_color (int color)
161 {
162   int i;
163
164   for( i=0; i<NR_ZIICS_COLORS; ++i )
165         {
166           if ( z2xpm_tab[i].cval == color )
167                 return (z2xpm_tab + i);
168         }
169
170   fatal("Illegal color in image.");
171
172   /* NOT REACHED */
173   return NULL;                                  /* Make compiler happy */
174 }
175
176 char *src_name;
177
178 int
179 up8 (int i)
180 {
181   int r;
182
183   r = i % 8;
184   if ( r == 0 )
185         return i;
186
187   return i + 8 - r;
188 }
189
190 unsigned int
191 vga_imagesize (int w, int h)
192 {
193   int w8;
194   unsigned int s;
195
196   w8 = up8( w );
197
198   s = 4 + w8/2 * h + 2;
199
200   return s;
201 }
202
203 unsigned char *
204 decode_byte (unsigned char *dest, unsigned char *b, int w)
205 {
206   int i, j;
207   unsigned char byte, bit;
208
209   for( i=7; w > 0; --i, --w )
210         {
211           byte = 0;
212
213           /* 1 bit from each plane */
214           for( j=0; j<4; ++j )
215                 {
216                   bit = b[j];
217                   bit &= (1 << i);
218                   bit >>= i;
219                   bit <<= 3-j;
220                   byte |= bit;
221                 }
222
223           *(dest++) = byte;
224         }
225
226   return dest;
227 }
228
229 /*
230    W is width of image in PIXELS.
231    SRC is in packed pixel format.
232    DEST is filled with 1 BYTE per PIXEL.
233 */
234 unsigned char *
235 decode_line (unsigned char *dest, unsigned char *src, int w)
236 {
237   unsigned int w8;
238   unsigned int bpp;
239   unsigned char b[4];
240   int i;
241   unsigned char *p;
242
243   p = src;
244   w8 = up8( w );
245
246   /* 4 planes, bpp BYTES per plane */
247   /* Planes are MSB -> LSB */
248   bpp = w8 >> 3;
249
250   while( w > 0 )
251         {
252           for( i=0; i<4; ++i )
253                 b[i] = p[i*bpp];
254
255           if ( w > 8 )
256                 dest = decode_byte( dest, b, 8 );
257           else
258                 dest = decode_byte( dest, b, w );
259
260           w -= 8;
261           ++p;
262         }
263
264   return (src + bpp * 4);
265 }
266
267 int
268 write_xim_header (FILE *fp, int w, int h)
269 {
270   fputc( w, fp );
271   fputc( h, fp );
272   
273   return 0;
274 }
275
276 int
277 write_xpm_header (FILE *fp, int w, int h)
278 {
279   int i;
280   z2xpm *cv;
281
282   fprintf(fp, "/* XPM */\n");
283   fprintf(fp, "/* This file was automatically generated from the file %s\n",
284           src_name );
285   fprintf(fp, "using the program ``zic2xpm''.\n");
286   fprintf(fp, "\n    %s\n    %s\n    %s\n    %s\n    %s\n    %s */\n",
287           "NOTICE: The piece images distributed with ZIICS are",
288           "    copyrighted works of their original creators.  Images",
289           "    converted with zic2xpm may not be redistributed without",
290           "    the permission of the copyright holders.  Do not contact",
291           "    the authors of zic2xpm or of ZIICS itself to request",
292           "    permission.");
293   fprintf( fp, "static char * image_name[] = {\n" );
294   fprintf( fp, "\"%d %d %d 1\",\n", h, w, NR_ZIICS_COLORS );
295
296   cv = z2xpm_tab;
297
298   for( i=0; i<NR_ZIICS_COLORS; ++i, ++cv )
299         {
300           fprintf( fp, "\"%c\tc %s s %s\",\n", cv->xchar,
301                           cv->cdefault, cv->csym );
302         }
303
304   return 0;
305 }
306
307 void
308 create_piece_xim (char *outname, FILE *fpin, int W, int H)
309 {
310   FILE *fpout;
311   int w, h, i, j, c;
312   unsigned char *lump, *p, *line;
313   long size;
314   z2xim *ent;
315   
316   fpout = fopen( outname, "wb" );
317   if ( !fpout )
318         fatal( "Can't create output file.");
319
320   /* Header is two ints -- Width then Height, x86 format */
321   c = fgetc( fpin );
322   w = (fgetc(fpin) << 8) | c;
323
324   c = fgetc( fpin );
325   h = (fgetc(fpin) << 8) | c;
326   
327   ++w; ++h;
328
329   if ( w != W || h != H )
330         fatal( "Bad header." );   
331
332   size = vga_imagesize( w, h ) - 4;
333   lump = (unsigned char*)malloc( size );
334   line = (unsigned char*)malloc( w );
335
336   if ( !lump || !line )
337         fatal( "Out of memory." );
338
339   fread( lump, 1, size, fpin );
340
341   /* Write XIM header */
342   write_xim_header( fpout, w, h );
343
344   p = lump;
345   
346   /* Write XIM data */
347   for( i=0; i<h; ++i )
348         {
349           p = decode_line( line, p, w );
350           
351           for( j=0; j<w; ++j )
352                 {
353                   ent = lookup_xim_color( line[j] );
354                   fputc( ent->xval, fpout );
355                 }
356         }
357   
358   free( lump );
359   free( line );
360   fclose( fpout );
361 }
362
363 void
364 create_piece_xpm (char *outname, FILE *fpin, int W, int H)
365 {
366   FILE *fpout;
367   int w, h, i, j, c;
368   unsigned char *lump, *p, *line;
369   long size;
370   z2xpm *cv;
371   
372   fpout = fopen( outname, "wb" );
373   if ( !fpout )
374         fatal( "Can't create output file.");
375
376   /* Header is two ints -- Width then Height, x86 format */
377   c = fgetc( fpin );
378   w = (fgetc(fpin) << 8) | c;
379
380   c = fgetc( fpin );
381   h = (fgetc(fpin) << 8) | c;
382   
383   ++w; ++h;
384
385   if ( w != W || h != H )
386         fatal( "Bad header." );   
387
388   size = vga_imagesize( w, h ) - 4;
389   lump = (unsigned char*)malloc( size );
390   line = (unsigned char*)malloc( w );
391
392   if ( !lump || !line )
393         fatal( "Out of memory." );
394
395   fread( lump, 1, size, fpin );
396
397   /* Write XPM header */
398   write_xpm_header( fpout, w, h );
399
400   p = lump;
401   
402   /* Write XPM data */
403   for( i=0; i<h; ++i )
404         {
405           p = decode_line( line, p, w );
406           
407           fprintf( fpout, "\"" );
408           for( j=0; j<w; ++j )
409                 {
410                   cv = lookup_xpm_color( line[j] );
411                   fprintf( fpout, "%c", cv->xchar );
412                 }
413           fprintf( fpout, "\",\n" );
414         }
415
416   fprintf( fpout, "};\n" );
417   
418   free( lump );
419   free( line );
420   fclose( fpout );
421 }
422
423 /* The order of the pieces in the ZIICS piece file (from SHOWSETS.PAS) */
424 char *pieces = "prkqbn";
425 char *pname[] = { "Pawn", "Rook", "King", "Queen", "Bishop", "Knight" };
426
427 /* The suborder - Light/Light, Light/Dark, etc. */
428 char *prefixes[] = { "ll", "ld", "dl", "dd" };
429
430 int
431 process_file_xim (char *filename)
432 {
433   int w, h, piece, kind, c;
434   int nr_pieces = 6;
435   int nr_kinds = 4;
436   FILE *fp;
437   char buf[BUFLEN];
438
439   src_name = filename;
440   
441   fp = fopen( filename, "rb" );
442   if ( !fp )
443         fatal( "Can't open input file." );
444   
445   /* Header is two ints -- Width then Height, x86 format */
446   c = fgetc( fp );
447   w = (fgetc(fp) << 8) | c;
448
449   c = fgetc( fp );
450   h = (fgetc(fp) << 8) | c;
451   
452   ++w; ++h;
453
454   if ( w != h )
455         {
456           printf("ERROR: Can only convert square pieces.\n");
457           printf("       (This set is %dx%d)\n", w, h );
458           exit(1);
459         }
460
461   printf("Creating XIM files...\n");
462   printf("File: %s, W=%d, H=%d\n", filename, w, h );
463   fseek( fp, 0, SEEK_SET );
464   
465   /* Write .XIM files */
466   for( piece = 0; piece < nr_pieces; ++piece )
467         {
468           printf("%s ", pname[piece] );
469           
470           for( kind = 0; kind < nr_kinds; ++kind )
471                 {
472                   printf( "." );
473                   /* Form output filename -- <piece><kind><size>.xim */
474                   snprintf(buf, BUFLEN, "%c%s%d.xim", pieces[piece], prefixes[kind], w);
475                   create_piece_xim( buf, fp, w, h );
476                 }
477           printf("\n");
478         }
479
480   /* Write the light & dark squares */
481   snprintf( buf, BUFLEN, "lsq%d.xim", w );
482   printf("Light Square" );
483   create_piece_xim( buf, fp, w, h );
484
485   snprintf( buf, BUFLEN, "dsq%d.xim", w );
486   printf("\nDark Square" );
487   create_piece_xim( buf, fp, w, h );  
488   printf("\n");
489   
490   printf("Successfully converted!!\n" );
491
492   fclose( fp );
493   
494   return 0;
495 }
496
497 int
498 process_file_xpm (char *filename)
499 {
500   int w, h, piece, kind, c;
501   int nr_pieces = 6;
502   int nr_kinds = 4;
503   FILE *fp;
504   char buf[BUFLEN];
505
506   src_name = filename;
507   
508   fp = fopen( filename, "rb" );
509   if ( !fp )
510         fatal( "Can't open input file." );
511   
512   /* Header is two ints -- Width then Height, x86 format */
513   c = fgetc( fp );
514   w = (fgetc(fp) << 8) | c;
515
516   c = fgetc( fp );
517   h = (fgetc(fp) << 8) | c;
518   
519   ++w; ++h;
520
521   if ( w != h )
522         {
523           printf("ERROR: Can only convert square pieces.\n");
524           printf("       (This set is %dx%d)\n", w, h );
525           exit(1);
526         }
527   
528   printf("Creating XPM files...\n");
529   printf("File: %s, W=%d, H=%d\n", filename, w, h );
530   fseek( fp, 0, SEEK_SET );
531   
532   /* Write .XPM files */
533   for( piece = 0; piece < nr_pieces; ++piece )
534         {
535           printf("%s ", pname[piece] );
536           
537           for( kind = 0; kind < nr_kinds; ++kind )
538                 {
539                   printf( "." );
540                   /* Form output filename -- <piece><kind><size>.xpm */
541                   snprintf(buf, BUFLEN, "%c%s%d.xpm", pieces[piece], prefixes[kind], w);
542                   create_piece_xpm( buf, fp, w, h );
543                 }
544           printf("\n");
545         }
546
547   /* Write the light & dark squares */
548   snprintf( buf, BUFLEN, "lsq%d.xpm", w );
549   printf("Light Square" );
550   create_piece_xpm( buf, fp, w, h );
551
552   snprintf( buf, BUFLEN, "dsq%d.xpm", w );
553   printf("\nDark Square" );
554   create_piece_xpm( buf, fp, w, h );  
555   printf("\n");
556   
557   printf("Successfully converted!!\n" );
558
559   fclose( fp );
560   
561   return 0;
562 }
563
564 int
565 main (int argc, char **argv)
566 {
567   int i;
568   
569   if ( argc < 2 )
570         {
571           printf("ZIC2XPM 2.01 - by Frank McIngvale (frankm@hiwaay.net)\n");
572           printf("Copyright (C) 1996 Free Software Foundation, Inc.\n\n");
573           printf("Usage: zic2xpm file1 [file2 ...]\n\n");
574           printf("  Splits each file (ZIICS piece files) into 26 XPM & XIM files\n");
575           printf("  suitable for use in XBoard 3.5 or later.\n");
576           printf("\n* ZIICS is a copyrighted work of Andy McFarland (Zek on ICC) *\n");
577           return 1;
578         }
579
580
581   setbuf( stdout, NULL );
582   
583   for( i=1; i<argc; ++i )
584         {
585           process_file_xpm( argv[i] );
586           process_file_xim( argv[i] );
587         }
588   
589   fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n%s\n",
590           "NOTICE: The piece images distributed with ZIICS are",
591           "    copyrighted works of their original creators.  Images",
592           "    converted with zic2xpm may not be redistributed without",
593           "    the permission of the copyright holders.  Do not contact",
594           "    the authors of zic2xpm or of ZIICS itself to request",
595           "    permission.");
596   return 0;
597 }