]> icculus.org git repositories - taylor/freespace2.git/blob - src/fonttool/fontkern.cpp
merge updated toolset
[taylor/freespace2.git] / src / fonttool / fontkern.cpp
1 /*
2  * Copyright (C) Volition, Inc. 1999.  All rights reserved.
3  *
4  * All source code herein is the property of Volition, Inc. You may not sell 
5  * or otherwise commercially exploit the source or things you created based on
6  * the source.
7  */
8
9 /*
10  * $Logfile: /Freespace2/code/Fonttool/FontKern.cpp $
11  * $Revision$
12  * $Date$
13  * $Author$
14  *
15  * Tool for interactively kerning fonts
16  *
17  * $Log$
18  * Revision 1.4  2006/04/26 19:38:36  taylor
19  * fix some minor fonttool compile errors
20  *
21  * Revision 1.3  2003/01/30 20:03:48  relnev
22  * various files ported needed for fonttool.  There is a bug where on exit it segfaults in SDL_GL_SwapBuffers, I'm probably missing something (don't know what) but it works fine otherwise (Taylor Richards)
23  *
24  * Revision 1.2  2002/06/09 04:41:16  relnev
25  * added copyright header
26  *
27  * Revision 1.1.1.1  2002/05/03 03:28:08  root
28  * Initial import.
29  *
30  * 
31  * 6     5/19/99 4:07p Dave
32  * Moved versioning code into a nice isolated common place. Fixed up
33  * updating code on the pxo screen. Fixed several stub problems.
34  * 
35  * 5     12/18/98 1:14a Dave
36  * Rough 1024x768 support for Direct3D. Proper detection and usage through
37  * the launcher.
38  * 
39  * 4     12/02/98 9:58a Dave
40  * Got fonttool working under glide/direct3d.
41  * 
42  * 3     11/30/98 1:09p Dave
43  * 
44  * 2     10/24/98 5:15p Dave
45  * 
46  * 1     10/24/98 4:58p Dave
47  * 
48  * 14    5/06/98 5:30p John
49  * Removed unused cfilearchiver.  Removed/replaced some unused/little used
50  * graphics functions, namely gradient_h and _v and pixel_sp.   Put in new
51  * DirectX header files and libs that fixed the Direct3D alpha blending
52  * problems.
53  * 
54  * 13    4/13/98 10:11a John
55  * Made timer functions thread safe.  Made timer_init be called in all
56  * projects.
57  * 
58  * 12    3/10/98 4:18p John
59  * Cleaned up graphics lib.  Took out most unused gr functions.   Made D3D
60  * & Glide have popups and print screen.  Took out all >8bpp software
61  * support.  Made Fred zbuffer.  Made zbuffer allocate dynamically to
62  * support Fred.  Made zbuffering key off of functions rather than one
63  * global variable.
64  * 
65  * 11    3/05/98 11:15p Hoffoss
66  * Changed non-game key checking to use game_check_key() instead of
67  * game_poll().
68  * 
69  * 10    10/30/97 4:56p John
70  * Fixed up font stuff to build.  Fixed bug where it didn't show the last
71  * 3 characters in kerning table.
72  * 
73  * 9     9/03/97 4:32p John
74  * changed bmpman to only accept ani and pcx's.  made passing .pcx or .ani
75  * to bm_load functions not needed.   Made bmpman keep track of palettes
76  * for bitmaps not mapped into game palettes.
77  * 
78  * 8     6/06/97 6:47p John
79  * Fixed bug
80  * 
81  * 7     6/06/97 4:41p John
82  * Fixed alpha colors to be smoothly integrated into gr_set_color_fast
83  * code.
84  * 
85  * 6     6/06/97 11:10a John
86  * made scrolling kern pair box.
87  * 
88  * 5     6/06/97 9:21a John
89  * added some kerning pairs
90  * 
91  * 4     6/06/97 9:18a John
92  * Added capital hamburger.    
93  * 
94  * 3     6/05/97 5:00p John
95  * used fonttool.pcx
96  * 
97  * 2     6/05/97 4:53p John
98  * First rev of new antialiased font stuff.
99  * 
100  * 1     6/02/97 4:04p John
101  *
102  * $NoKeywords: $
103  */
104
105 #ifndef PLAT_UNIX
106 #include <windows.h>
107 #endif
108 #include <stdlib.h>
109 #include <stdio.h>
110 #include <time.h>
111 #ifndef PLAT_UNIX
112 #include <io.h>
113 #include <conio.h>
114 #endif
115
116 #include "pstypes.h"
117 #include "osapi.h"
118 #include "cfile.h"
119 #include "2d.h"
120 #include "key.h"
121 #include "mouse.h"
122 #include "palman.h"
123 #include "timer.h"
124 #include "bmpman.h"
125 #include "osregistry.h"
126 #include "cmdline.h"
127
128 #include "fonttool.h"
129
130 const char *SampleText = "This is some sample text that is here to\n" \
131 "Show you how the antialiasing will\n"  \
132 "look over different color backgrounds\n" \
133 "KERN PAIRS: VaWaVeWeVAV-LyT.T,TyTvTcYe\n";
134
135 static void myexit(int value)
136 {
137 #ifdef WIN32
138         getch();
139 #endif
140         exit(value);
141 }
142
143 int game_check_key()
144 {
145         return key_inkey();
146 }
147
148 int game_poll()
149 {
150         return key_inkey();
151 }
152
153 int os_done = 0;
154
155 void os_close()
156 {
157         os_done = 1;
158 }
159
160 int fonttool_get_kerning( font *fnt, int c1, int c2, int *pairnum )
161 {
162         int i;
163
164         int l1 = c1 - fnt->first_ascii;
165         int l2 = c2 - fnt->first_ascii;
166
167         for (i=0; i<fnt->num_kern_pairs; i++ )  {
168                 if ( (fnt->kern_data[i].c1 == l1) && (fnt->kern_data[i].c2 == l2) )     {
169                         if (pairnum) *pairnum = i;
170                         return fnt->kern_data[i].offset;
171                 }
172         }
173         return 0;
174 }
175
176 void fonttool_resync_kerning( font *fnt )
177 {
178         int i;
179
180         // update all the font into
181         for (i=0; i<fnt->num_chars; i++ )       {
182                 fnt->char_data[i].kerning_entry = -1;
183         }
184
185         for (i=0; i<fnt->num_kern_pairs; i++ )  {
186                 int c = fnt->kern_data[i].c1;
187                 if ( fnt->char_data[c].kerning_entry == -1 )
188                         fnt->char_data[c].kerning_entry = (short)i;
189         }
190 }
191
192 void fonttool_remove_kern_pair( font *fnt, int index )
193 {
194         // not found, add it
195         int i, n, new_num_pairs;
196
197         new_num_pairs = fnt->num_kern_pairs - 1;
198
199         if ( new_num_pairs < 1 )        {
200                 fonttool_remove_kerning(fnt);
201                 return;
202         }
203
204         font_kernpair *new_kern_data = (font_kernpair *)malloc( new_num_pairs*sizeof(font_kernpair) );
205         if (!new_kern_data)     {
206                 printf( "Out of memory!\n" );
207                 myexit(1);
208         }
209
210
211         n=0;
212         for (i=0; i<fnt->num_kern_pairs; i++ )  {
213                 if ( i != index )       {
214                         new_kern_data[n] = fnt->kern_data[i];
215                         n++;
216                 }
217         }
218
219         if ( fnt->kern_data ) free( fnt->kern_data );
220         fnt->kern_data = new_kern_data;
221         fnt->kern_data_size = sizeof(font_kernpair)*new_num_pairs;
222         fnt->num_kern_pairs = new_num_pairs;
223
224         fonttool_resync_kerning(fnt);
225
226         mprintf(( "Font has %d kern pairs\n", fnt->num_kern_pairs ));
227 }
228
229 void fonttool_set_kerning( font *fnt, int c1, int c2, int dist )
230 {
231         int i;
232
233         int l1 = c1 - fnt->first_ascii;
234         int l2 = c2 - fnt->first_ascii;
235
236         for (i=0; i<fnt->num_kern_pairs; i++ )  {
237                 if ( (fnt->kern_data[i].c1 == l1) && (fnt->kern_data[i].c2 == l2) )     {
238                         fnt->kern_data[i].offset = (signed char)dist;
239                         if ( dist == 0 )        {
240                                 fonttool_remove_kern_pair( fnt, i );                            
241                         }
242                         return;
243                 }
244         }
245         if ( dist == 0 )        return;
246
247         // not found, add it
248         int new_num_pairs;
249
250         new_num_pairs = fnt->num_kern_pairs+1;
251
252         font_kernpair *new_kern_data = (font_kernpair *)malloc( new_num_pairs*sizeof(font_kernpair) );
253         if (!new_kern_data)     {
254                 printf( "Out of memory!\n" );
255                 myexit(1);
256         }
257
258
259         int n=0;
260         uint newcode = l1*256+l2;
261
262         for (i=0; i<fnt->num_kern_pairs; i++ )  {
263                 uint code = fnt->kern_data[i].c1*256 + fnt->kern_data[i].c2;
264                 if ( code < newcode )   {
265                         new_kern_data[n] = fnt->kern_data[i];
266                         n++;
267                 } else {
268                         break;
269                 }
270         }
271
272
273         new_kern_data[n].c1 = (char)l1;
274         new_kern_data[n].c2 = (char)l2;
275         new_kern_data[n].offset = (signed char)dist;
276         n++;
277
278         
279         for (; i<fnt->num_kern_pairs; i++ )     {
280                 new_kern_data[n] = fnt->kern_data[i];
281                 n++;
282         }
283
284
285         if ( fnt->kern_data ) free( fnt->kern_data );
286         fnt->kern_data = new_kern_data;
287         fnt->kern_data_size +=  sizeof(font_kernpair);
288         fnt->num_kern_pairs++;
289
290         fonttool_resync_kerning(fnt);
291
292         mprintf(( "Font has %d kern pairs\n", fnt->num_kern_pairs ));
293
294 }
295
296
297 void fonttool_remove_kerning( font *fnt )
298 {
299         int i;
300
301         for (i=0; i<fnt->num_chars; i++ )       {
302                 fnt->char_data[i].kerning_entry = -1;
303         }
304
305         fnt->kern_data_size = 0;
306         if (fnt->kern_data)
307                 free( fnt->kern_data );
308         fnt->kern_data = NULL;
309         fnt->num_kern_pairs = 0;
310 }
311
312
313 void fonttool_edit_kerning(char *fname1, char *extras_dir)
314 {
315         int i, k,x;
316         int done;
317         int bkg;
318         font KernFont, tmpfont;
319         int alpha = 16;
320         int cr=16, cb=16, cg=16;
321         int c1 = 'b', c2 = 'u';
322         char kerntext[128];
323         int current_pair = -1;
324         int first_item = 0;
325         int current_item = 0;
326         int num_items_displayed = 1;
327         int last_good_pair = -1;
328         color ac;
329         
330         printf( "Editing kerning data for %s\n", fname1 );
331         fonttool_read( fname1, &KernFont );
332
333         timer_init();
334
335         // setup the fred exe directory so CFILE can init properly
336         //char *c = GetCommandLine();
337         //SDL_assert(c != NULL);
338         //char *tok = strtok(c, " ");
339         //SDL_assert(tok != NULL);      
340
341         cfile_init(extras_dir);
342
343         os_init( "FontTool", "FontTool - Kerning Table Editor" );
344
345         // always run this thing in a window
346         Cmdline_fullscreen = 0;
347         Cmdline_window = 1;
348
349         gr_init(GR_640, GR_OPENGL);
350
351         gr_set_palette("none",NULL);
352
353         char fonttool_pcx[128];
354         sprintf(fonttool_pcx, "src%sfonttool%sfonttool", DIR_SEPARATOR_STR, DIR_SEPARATOR_STR);
355
356         bkg = bm_load( fonttool_pcx );
357
358         if ( bkg < 0 )  {
359                 printf("Error loading FontTool\n" );
360                 myexit(1);
361         }
362         palette_use_bm_palette(bkg);
363
364         key_init();
365         mouse_init();
366
367         gr_init_alphacolor( &ac, cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD );
368         
369
370         {
371                 extern font *Current_font;
372                 Current_font = &KernFont;
373         }
374
375         done = 0;
376         while (!done)   {
377                 
378                 os_poll();
379                 k = key_inkey();
380                 switch(k)       {               
381                 case SDLK_F5:
382                         fonttool_read( fname1, &tmpfont );
383                         fonttool_copy_kern( &tmpfont, &KernFont );
384                         break;
385
386                 case SDLK_F6:
387                         fonttool_remove_kerning( &KernFont );
388                         break;
389
390                 case SDLK_F10:
391                         fonttool_dump( fname1, &KernFont );
392                         done=1;
393                         break;
394
395                 case SDLK_COMMA:
396                         if ( alpha > 1 )        {
397                                 alpha--;
398                                 gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
399                         }
400                         break;
401
402                 case SDLK_PERIOD:
403                         if ( alpha < 17 )       {
404                                 alpha++;
405                                 gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
406                         }
407                         break;
408
409                 case SDLK_r:
410                         if ( cr == 16 ) cr = 1; else cr = 16;
411                         gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
412                         break;
413
414                 case SDLK_g:
415                         if ( cg == 16 ) cg = 1; else cg = 16;
416                         gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
417                         break;
418
419                 case SDLK_b:
420                         if ( cb == 16 ) cb = 1; else cb = 16;
421                         gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
422                         break;
423
424                 case SDLK_KP_6:
425                         x = fonttool_get_kerning( &KernFont, c1, c2, NULL );
426                         fonttool_set_kerning( &KernFont, c1, c2, x+1 );
427                         break;
428
429                 case SDLK_KP_4:
430                         x = fonttool_get_kerning( &KernFont, c1, c2, NULL );
431                         fonttool_set_kerning( &KernFont, c1, c2, x-1 );
432                         break;
433
434                 case SDLK_KP_5:
435                         fonttool_set_kerning( &KernFont, c1, c2, 0 );
436                         break;
437
438                 case SDLK_KP_7:
439                         if ( c1 < KernFont.first_ascii + KernFont.num_chars-1 ) c1++;
440                         break;
441
442                 case SDLK_KP_1:
443                         if ( c1 > KernFont.first_ascii ) c1--;
444                         break;
445
446                 case SDLK_KP_9:
447                         if ( c2 < KernFont.first_ascii + KernFont.num_chars-1 ) c2++;
448                         mprintf(( "C2 = %d\n", c2 ));
449                         break;
450
451                 case SDLK_KP_3:
452                         if ( c2 > KernFont.first_ascii ) c2--;
453                         mprintf(( "C2 = %d\n", c2 ));
454                         break;
455
456                 case SDLK_KP_2:
457                         if ( current_pair < 0 ) 
458                                 current_pair = last_good_pair;
459                         else 
460                                 current_pair++;
461                         if ( current_pair >= KernFont.num_kern_pairs )  {
462                                 current_pair = KernFont.num_kern_pairs-1;
463                         }
464                         if ( (current_pair < KernFont.num_kern_pairs) && (current_pair > -1) )  {
465                                 c1 = KernFont.kern_data[current_pair].c1 + KernFont.first_ascii;
466                                 c2 = KernFont.kern_data[current_pair].c2 + KernFont.first_ascii;
467                         }
468                         break;
469
470                 case SDLK_KP_8:
471                         if ( current_pair < 0 ) 
472                                 current_pair = last_good_pair;
473                         else
474                                 current_pair--;
475                         if ( current_pair < 0 ) {
476                                 current_pair = 0;
477                         }
478                         if ( (current_pair < KernFont.num_kern_pairs) && (current_pair > -1) )  {
479                                 c1 = KernFont.kern_data[current_pair].c1 + KernFont.first_ascii;
480                                 c2 = KernFont.kern_data[current_pair].c2 + KernFont.first_ascii;
481                         }
482                         break;
483
484                 case SDLK_ESCAPE:
485                         done=1;
486                         break;
487                 }
488
489                 if ( current_pair >= KernFont.num_kern_pairs )  {
490                         current_pair = -1;
491                 }
492
493                 int tmpp=-1;
494                 fonttool_get_kerning( &KernFont, c1, c2, &tmpp );
495
496                 if ( tmpp != -1 )       {
497                         current_pair = tmpp;
498                 } else  {
499                         if ( current_pair > -1 )
500                                 last_good_pair = current_pair;
501                         current_pair = -1;
502                 }
503         
504                 gr_reset_clip();
505                 gr_set_bitmap(bkg);
506                 gr_bitmap(0,0);
507                 gr_set_color_fast(&ac);
508
509                 sprintf( kerntext, "%c (%d)", c1, c1 );
510                 gr_string( 240, 210, kerntext );
511                 sprintf( kerntext, "%c (%d)", c2, c2 );
512                 gr_string( 340, 210, kerntext );
513
514                 sprintf( kerntext, "Ham%c%crger", c1, c2 );
515                 gr_string( 0x8000, 240, kerntext );
516
517                 sprintf( kerntext, "HAM%c%cRGER", c1, c2 );
518                 gr_string( 0x8000, 270, kerntext );
519
520                 sprintf( kerntext, "Offset: %d pixels", fonttool_get_kerning( &KernFont, c1, c2, NULL ) );
521                 gr_string( 0x8000, 300, kerntext );
522
523                 {
524                         int tw, th;
525                         gr_get_string_size( &tw, &th, kerntext );
526
527                         gr_string( 0x8000, 360, SampleText );
528                         gr_string( 20, 360+th+20, SampleText );
529                 }
530
531                 int x = 5, y = 200;
532                 int widest = 0;
533
534                  //= ( 330 - 200 ) / KernFont.h;
535                 int num_items = KernFont.num_kern_pairs;
536
537                 if ( current_pair > -1 )
538                         current_item = current_pair;
539
540                 if (current_item <0 )
541                         current_item = 0;
542
543                 if (current_item >= num_items )
544                         current_item = num_items-1;
545
546                 if (current_item<first_item)
547                         first_item = current_item;
548
549                 if (current_item>=(first_item+num_items_displayed))
550                         first_item = current_item-num_items_displayed+1;
551
552                 if (num_items <= num_items_displayed )  
553                         first_item = 0;
554
555                 int stop = first_item+num_items_displayed;
556                 if (stop>num_items) stop = num_items;
557
558                 int n = 0;
559                 for (i=first_item; i<stop; i++ )        {
560                         int tw, th;
561
562                         sprintf( kerntext, "%c%c", KernFont.kern_data[i].c1 + KernFont.first_ascii, KernFont.kern_data[i].c2 + KernFont.first_ascii );
563                         if ( i==current_pair )  {
564                                 gr_set_color( 255, 0, 0 );
565                                 //hud_tri( i2fl(x),i2fl(y), i2fl(x+6), i2fl(y+5), i2fl(x), i2fl(y+8) );
566                                 
567                                 int x1 = x;
568                                 int y1 = y;
569                                 int x2 = x+6;
570                                 int y2 = y+5;
571                                 int x3 = x;
572                                 int y3 = y+8;
573         
574                                 gr_line(x1,y1,x2,y2);
575                                 gr_line(x2,y2,x3,y3);
576                                 gr_line(x3,y3,x1,y1);
577
578                                 gr_set_color_fast(&ac);
579                         }
580                         gr_string( x+8, y, kerntext );
581                         n++;
582                         gr_get_string_size( &tw, &th, kerntext );
583                         tw += 8;
584                         if ( tw > widest )
585                                 widest = tw;
586                         y += KernFont.h;
587                         if ( y > 330 ) {
588                                 y = 200;
589                                 x += widest + 5;
590                                 if ( x > 150 ) {
591                                         num_items_displayed=n;
592                                         break;
593                                 }
594                                 widest = 0;
595                         }
596                 }
597                 if (i==stop)
598                         num_items_displayed++;
599
600                 if (num_items_displayed < 1 )
601                         num_items_displayed = 1;
602
603                 if (num_items_displayed > num_items )
604                         num_items_displayed = num_items;
605
606                 //mprintf(( "Num items = %d\n", num_items_displayed ));
607
608
609                 gr_flip();
610
611                 // sleep a little bit, don't need high framerate here
612                 SDL_Delay(10);
613         }
614
615         // cleanup
616         if (bkg > -1) {
617                 bm_unload(bkg);
618         }
619
620
621         exit(0);
622 }
623