also don't translate selection in ComboSelect; fixes #34991
[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 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 fatal( str )
136          char *str;
137 {
138   printf("Fatal error: %s\n", str );
139   exit(1);
140 }
141
142 z2xim *lookup_xim_color( color )
143          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 *lookup_xpm_color( color )
160          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 up8( i )
179          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 vga_imagesize( w, h )
191          int w, 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 *decode_byte( dest, b, w )
204          unsigned char *dest, *b;
205          int w;
206 {
207   int i, j;
208   unsigned char byte, bit;
209
210   for( i=7; w > 0; --i, --w )
211         {
212           byte = 0;
213
214           /* 1 bit from each plane */
215           for( j=0; j<4; ++j )
216                 {
217                   bit = b[j];
218                   bit &= (1 << i);
219                   bit >>= i;
220                   bit <<= 3-j;
221                   byte |= bit;
222                 }
223
224           *(dest++) = byte;
225         }
226
227   return dest;
228 }
229
230 /*
231    W is width of image in PIXELS.
232    SRC is in packed pixel format.
233    DEST is filled with 1 BYTE per PIXEL.
234 */
235 unsigned char *decode_line( dest, src, w )
236          unsigned char *dest, *src;
237          int w;
238 {
239   unsigned int w8;
240   unsigned int bpp;
241   unsigned char b[4];
242   int i;
243   unsigned char *p;
244
245   p = src;
246   w8 = up8( w );
247
248   /* 4 planes, bpp BYTES per plane */
249   /* Planes are MSB -> LSB */
250   bpp = w8 >> 3;
251
252   while( w > 0 )
253         {
254           for( i=0; i<4; ++i )
255                 b[i] = p[i*bpp];
256
257           if ( w > 8 )
258                 dest = decode_byte( dest, b, 8 );
259           else
260                 dest = decode_byte( dest, b, w );
261
262           w -= 8;
263           ++p;
264         }
265
266   return (src + bpp * 4);
267 }
268
269 int write_xim_header( fp, w, h )
270          FILE *fp;
271          int w, h;
272 {
273   fputc( w, fp );
274   fputc( h, fp );
275   
276   return 0;
277 }
278
279 int write_xpm_header( fp, w, h )
280          FILE *fp;
281          int w, h;
282 {
283   int i;
284   z2xpm *cv;
285
286   fprintf(fp, "/* XPM */\n");
287   fprintf(fp, "/* This file was automatically generated from the file %s\n",
288           src_name );
289   fprintf(fp, "using the program ``zic2xpm''.\n");
290   fprintf(fp, "\n    %s\n    %s\n    %s\n    %s\n    %s\n    %s */\n",
291           "NOTICE: The piece images distributed with ZIICS are",
292           "    copyrighted works of their original creators.  Images",
293           "    converted with zic2xpm may not be redistributed without",
294           "    the permission of the copyright holders.  Do not contact",
295           "    the authors of zic2xpm or of ZIICS itself to request",
296           "    permission.");
297   fprintf( fp, "static char * image_name[] = {\n" );
298   fprintf( fp, "\"%d %d %d 1\",\n", h, w, NR_ZIICS_COLORS );
299
300   cv = z2xpm_tab;
301
302   for( i=0; i<NR_ZIICS_COLORS; ++i, ++cv )
303         {
304           fprintf( fp, "\"%c\tc %s s %s\",\n", cv->xchar,
305                           cv->cdefault, cv->csym );
306         }
307
308   return 0;
309 }
310
311 void create_piece_xim( outname, fpin, W, H )
312          char *outname;
313          FILE *fpin;
314          int W, H;
315 {
316   FILE *fpout;
317   int w, h, i, j, c;
318   unsigned char *lump, *p, *line;
319   long size;
320   z2xim *ent;
321   
322   fpout = fopen( outname, "wb" );
323   if ( !fpout )
324         fatal( "Can't create output file.");
325
326   /* Header is two ints -- Width then Height, x86 format */
327   c = fgetc( fpin );
328   w = (fgetc(fpin) << 8) | c;
329
330   c = fgetc( fpin );
331   h = (fgetc(fpin) << 8) | c;
332   
333   ++w; ++h;
334
335   if ( w != W || h != H )
336         fatal( "Bad header." );   
337
338   size = vga_imagesize( w, h ) - 4;
339   lump = (unsigned char*)malloc( size );
340   line = (unsigned char*)malloc( w );
341
342   if ( !lump || !line )
343         fatal( "Out of memory." );
344
345   fread( lump, 1, size, fpin );
346
347   /* Write XIM header */
348   write_xim_header( fpout, w, h );
349
350   p = lump;
351   
352   /* Write XIM data */
353   for( i=0; i<h; ++i )
354         {
355           p = decode_line( line, p, w );
356           
357           for( j=0; j<w; ++j )
358                 {
359                   ent = lookup_xim_color( line[j] );
360                   fputc( ent->xval, fpout );
361                 }
362         }
363   
364   free( lump );
365   free( line );
366   fclose( fpout );
367 }
368
369 void create_piece_xpm( outname, fpin, W, H )
370          char *outname;
371          FILE *fpin;
372          int W, H;
373 {
374   FILE *fpout;
375   int w, h, i, j, c;
376   unsigned char *lump, *p, *line;
377   long size;
378   z2xpm *cv;
379   
380   fpout = fopen( outname, "wb" );
381   if ( !fpout )
382         fatal( "Can't create output file.");
383
384   /* Header is two ints -- Width then Height, x86 format */
385   c = fgetc( fpin );
386   w = (fgetc(fpin) << 8) | c;
387
388   c = fgetc( fpin );
389   h = (fgetc(fpin) << 8) | c;
390   
391   ++w; ++h;
392
393   if ( w != W || h != H )
394         fatal( "Bad header." );   
395
396   size = vga_imagesize( w, h ) - 4;
397   lump = (unsigned char*)malloc( size );
398   line = (unsigned char*)malloc( w );
399
400   if ( !lump || !line )
401         fatal( "Out of memory." );
402
403   fread( lump, 1, size, fpin );
404
405   /* Write XPM header */
406   write_xpm_header( fpout, w, h );
407
408   p = lump;
409   
410   /* Write XPM data */
411   for( i=0; i<h; ++i )
412         {
413           p = decode_line( line, p, w );
414           
415           fprintf( fpout, "\"" );
416           for( j=0; j<w; ++j )
417                 {
418                   cv = lookup_xpm_color( line[j] );
419                   fprintf( fpout, "%c", cv->xchar );
420                 }
421           fprintf( fpout, "\",\n" );
422         }
423
424   fprintf( fpout, "};\n" );
425   
426   free( lump );
427   free( line );
428   fclose( fpout );
429 }
430
431 /* The order of the pieces in the ZIICS piece file (from SHOWSETS.PAS) */
432 char *pieces = "prkqbn";
433 char *pname[] = { "Pawn", "Rook", "King", "Queen", "Bishop", "Knight" };
434
435 /* The suborder - Light/Light, Light/Dark, etc. */
436 char *prefixes[] = { "ll", "ld", "dl", "dd" };
437
438 int process_file_xim( filename )
439          char *filename;
440 {
441   int w, h, piece, kind, c;
442   int nr_pieces = 6;
443   int nr_kinds = 4;
444   FILE *fp;
445   char buf[BUFLEN];
446
447   src_name = filename;
448   
449   fp = fopen( filename, "rb" );
450   if ( !fp )
451         fatal( "Can't open input file." );
452   
453   /* Header is two ints -- Width then Height, x86 format */
454   c = fgetc( fp );
455   w = (fgetc(fp) << 8) | c;
456
457   c = fgetc( fp );
458   h = (fgetc(fp) << 8) | c;
459   
460   ++w; ++h;
461
462   if ( w != h )
463         {
464           printf("ERROR: Can only convert square pieces.\n");
465           printf("       (This set is %dx%d)\n", w, h );
466           exit(1);
467         }
468
469   printf("Creating XIM files...\n");
470   printf("File: %s, W=%d, H=%d\n", filename, w, h );
471   fseek( fp, 0, SEEK_SET );
472   
473   /* Write .XIM files */
474   for( piece = 0; piece < nr_pieces; ++piece )
475         {
476           printf("%s ", pname[piece] );
477           
478           for( kind = 0; kind < nr_kinds; ++kind )
479                 {
480                   printf( "." );
481                   /* Form output filename -- <piece><kind><size>.xim */
482                   snprintf(buf, BUFLEN, "%c%s%d.xim", pieces[piece], prefixes[kind], w);
483                   create_piece_xim( buf, fp, w, h );
484                 }
485           printf("\n");
486         }
487
488   /* Write the light & dark squares */
489   snprintf( buf, BUFLEN, "lsq%d.xim", w );
490   printf("Light Square" );
491   create_piece_xim( buf, fp, w, h );
492
493   snprintf( buf, BUFLEN, "dsq%d.xim", w );
494   printf("\nDark Square" );
495   create_piece_xim( buf, fp, w, h );  
496   printf("\n");
497   
498   printf("Successfully converted!!\n" );
499
500   fclose( fp );
501   
502   return 0;
503 }
504
505 int process_file_xpm( filename )
506          char *filename;
507 {
508   int w, h, piece, kind, c;
509   int nr_pieces = 6;
510   int nr_kinds = 4;
511   FILE *fp;
512   char buf[BUFLEN];
513
514   src_name = filename;
515   
516   fp = fopen( filename, "rb" );
517   if ( !fp )
518         fatal( "Can't open input file." );
519   
520   /* Header is two ints -- Width then Height, x86 format */
521   c = fgetc( fp );
522   w = (fgetc(fp) << 8) | c;
523
524   c = fgetc( fp );
525   h = (fgetc(fp) << 8) | c;
526   
527   ++w; ++h;
528
529   if ( w != h )
530         {
531           printf("ERROR: Can only convert square pieces.\n");
532           printf("       (This set is %dx%d)\n", w, h );
533           exit(1);
534         }
535   
536   printf("Creating XPM files...\n");
537   printf("File: %s, W=%d, H=%d\n", filename, w, h );
538   fseek( fp, 0, SEEK_SET );
539   
540   /* Write .XPM files */
541   for( piece = 0; piece < nr_pieces; ++piece )
542         {
543           printf("%s ", pname[piece] );
544           
545           for( kind = 0; kind < nr_kinds; ++kind )
546                 {
547                   printf( "." );
548                   /* Form output filename -- <piece><kind><size>.xpm */
549                   snprintf(buf, BUFLEN, "%c%s%d.xpm", pieces[piece], prefixes[kind], w);
550                   create_piece_xpm( buf, fp, w, h );
551                 }
552           printf("\n");
553         }
554
555   /* Write the light & dark squares */
556   snprintf( buf, BUFLEN, "lsq%d.xpm", w );
557   printf("Light Square" );
558   create_piece_xpm( buf, fp, w, h );
559
560   snprintf( buf, BUFLEN, "dsq%d.xpm", w );
561   printf("\nDark Square" );
562   create_piece_xpm( buf, fp, w, h );  
563   printf("\n");
564   
565   printf("Successfully converted!!\n" );
566
567   fclose( fp );
568   
569   return 0;
570 }
571
572 int main( argc, argv )
573          int argc;
574          char *argv[];
575 {
576   int i;
577   
578   if ( argc < 2 )
579         {
580           printf("ZIC2XPM 2.01 - by Frank McIngvale (frankm@hiwaay.net)\n");
581           printf("Copyright (C) 1996 Free Software Foundation, Inc.\n\n");
582           printf("Usage: zic2xpm file1 [file2 ...]\n\n");
583           printf("  Splits each file (ZIICS piece files) into 26 XPM & XIM files\n");
584           printf("  suitable for use in XBoard 3.5 or later.\n");
585           printf("\n* ZIICS is a copyrighted work of Andy McFarland (Zek on ICC) *\n");
586           return 1;
587         }
588
589
590   setbuf( stdout, NULL );
591   
592   for( i=1; i<argc; ++i )
593         {
594           process_file_xpm( argv[i] );
595           process_file_xim( argv[i] );
596         }
597   
598   fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n%s\n",
599           "NOTICE: The piece images distributed with ZIICS are",
600           "    copyrighted works of their original creators.  Images",
601           "    converted with zic2xpm may not be redistributed without",
602           "    the permission of the copyright holders.  Do not contact",
603           "    the authors of zic2xpm or of ZIICS itself to request",
604           "    permission.");
605   return 0;
606 }