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 <io.h>
 107 #include <conio.h>
 108 #endif
 109 #include <stdlib.h>
 110 #include <stdio.h>
 111 #include <time.h>
 112
 113 #include "pstypes.h"
 114 #include "osapi.h"
 115 #include "cfile.h"
 116 #include "2d.h"
 117 #include "key.h"
 118 #include "mouse.h"
 119 #include "palman.h"
 120 #include "timer.h"
 121 #include "bmpman.h"
 122 #include "osregistry.h"
 123 #include "cmdline.h"
 124
 125 #include "fonttool.h"
 126
 127 const char *SampleText = "This is some sample text that is here to\n" \
 128 "Show you how the antialiasing will\n"  \
 129 "look over different color backgrounds\n" \
 130 "KERN PAIRS: VaWaVeWeVAV-LyT.T,TyTvTcYe\n";
 131
 132 static void myexit(int value)
 133 {
 134 #ifdef WIN32
 135         getch();
 136 #endif
 137         exit(value);
 138 }
 139
 140 int game_check_key()
 141 {
 142         return key_inkey();
 143 }
 144
 145 int game_poll()
 146 {
 147         return key_inkey();
 148 }
 149
 150 int os_done = 0;
 151
 152 void os_close()
 153 {
 154         os_done = 1;
 155 }
 156
 157 int fonttool_get_kerning( font *fnt, int c1, int c2, int *pairnum )
 158 {
 159         int i;
 160
 161         int l1 = c1 - fnt->first_ascii;
 162         int l2 = c2 - fnt->first_ascii;
 163
 164         for (i=0; i<fnt->num_kern_pairs; i++ )  {
 165                 if ( (fnt->kern_data[i].c1 == l1) && (fnt->kern_data[i].c2 == l2) )     {
 166                         if (pairnum) *pairnum = i;
 167                         return fnt->kern_data[i].offset;
 168                 }
 169         }
 170         return 0;
 171 }
 172
 173 void fonttool_resync_kerning( font *fnt )
 174 {
 175         int i;
 176
 177         // update all the font into
 178         for (i=0; i<fnt->num_chars; i++ )       {
 179                 fnt->char_data[i].kerning_entry = -1;
 180         }
 181
 182         for (i=0; i<fnt->num_kern_pairs; i++ )  {
 183                 int c = fnt->kern_data[i].c1;
 184                 if ( fnt->char_data[c].kerning_entry == -1 )
 185                         fnt->char_data[c].kerning_entry = (short)i;
 186         }
 187 }
 188
 189 void fonttool_remove_kern_pair( font *fnt, int index )
 190 {
 191         // not found, add it
 192         int i, n, new_num_pairs;
 193
 194         new_num_pairs = fnt->num_kern_pairs - 1;
 195
 196         if ( new_num_pairs < 1 )        {
 197                 fonttool_remove_kerning(fnt);
 198                 return;
 199         }
 200
 201         font_kernpair *new_kern_data = (font_kernpair *)malloc( new_num_pairs*sizeof(font_kernpair) );
 202         if (!new_kern_data)     {
 203                 printf( "Out of memory!\n" );
 204                 myexit(1);
 205         }
 206
 207
 208         n=0;
 209         for (i=0; i<fnt->num_kern_pairs; i++ )  {
 210                 if ( i != index )       {
 211                         new_kern_data[n] = fnt->kern_data[i];
 212                         n++;
 213                 }
 214         }
 215
 216         if ( fnt->kern_data ) free( fnt->kern_data );
 217         fnt->kern_data = new_kern_data;
 218         fnt->kern_data_size = sizeof(font_kernpair)*new_num_pairs;
 219         fnt->num_kern_pairs = new_num_pairs;
 220
 221         fonttool_resync_kerning(fnt);
 222
 223         mprintf(( "Font has %d kern pairs\n", fnt->num_kern_pairs ));
 224 }
 225
 226 void fonttool_set_kerning( font *fnt, int c1, int c2, int dist )
 227 {
 228         int i;
 229
 230         int l1 = c1 - fnt->first_ascii;
 231         int l2 = c2 - fnt->first_ascii;
 232
 233         for (i=0; i<fnt->num_kern_pairs; i++ )  {
 234                 if ( (fnt->kern_data[i].c1 == l1) && (fnt->kern_data[i].c2 == l2) )     {
 235                         fnt->kern_data[i].offset = (signed char)dist;
 236                         if ( dist == 0 )        {
 237                                 fonttool_remove_kern_pair( fnt, i );
 238                         }
 239                         return;
 240                 }
 241         }
 242         if ( dist == 0 )        return;
 243
 244         // not found, add it
 245         int new_num_pairs;
 246
 247         new_num_pairs = fnt->num_kern_pairs+1;
 248
 249         font_kernpair *new_kern_data = (font_kernpair *)malloc( new_num_pairs*sizeof(font_kernpair) );
 250         if (!new_kern_data)     {
 251                 printf( "Out of memory!\n" );
 252                 myexit(1);
 253         }
 254
 255
 256         int n=0;
 257         uint newcode = l1*256+l2;
 258
 259         for (i=0; i<fnt->num_kern_pairs; i++ )  {
 260                 uint code = fnt->kern_data[i].c1*256 + fnt->kern_data[i].c2;
 261                 if ( code < newcode )   {
 262                         new_kern_data[n] = fnt->kern_data[i];
 263                         n++;
 264                 } else {
 265                         break;
 266                 }
 267         }
 268
 269
 270         new_kern_data[n].c1 = (char)l1;
 271         new_kern_data[n].c2 = (char)l2;
 272         new_kern_data[n].offset = (signed char)dist;
 273         n++;
 274
 275
 276         for (; i<fnt->num_kern_pairs; i++ )     {
 277                 new_kern_data[n] = fnt->kern_data[i];
 278                 n++;
 279         }
 280
 281
 282         if ( fnt->kern_data ) free( fnt->kern_data );
 283         fnt->kern_data = new_kern_data;
 284         fnt->kern_data_size +=  sizeof(font_kernpair);
 285         fnt->num_kern_pairs++;
 286
 287         fonttool_resync_kerning(fnt);
 288
 289         mprintf(( "Font has %d kern pairs\n", fnt->num_kern_pairs ));
 290
 291 }
 292
 293
 294 void fonttool_remove_kerning( font *fnt )
 295 {
 296         int i;
 297
 298         for (i=0; i<fnt->num_chars; i++ )       {
 299                 fnt->char_data[i].kerning_entry = -1;
 300         }
 301
 302         fnt->kern_data_size = 0;
 303         if (fnt->kern_data)
 304                 free( fnt->kern_data );
 305         fnt->kern_data = NULL;
 306         fnt->num_kern_pairs = 0;
 307 }
 308
 309
 310 void fonttool_edit_kerning(char *fname1)
 311 {
 312         int i, k,x;
 313         int done;
 314         int bkg;
 315         font KernFont, tmpfont;
 316         int alpha = 16;
 317         int cr=16, cb=16, cg=16;
 318         int c1 = 'b', c2 = 'u';
 319         char kerntext[128];
 320         int current_pair = -1;
 321         int first_item = 0;
 322         int current_item = 0;
 323         int num_items_displayed = 1;
 324         int last_good_pair = -1;
 325         color ac;
 326
 327         printf( "Editing kerning data for %s\n", fname1 );
 328         fonttool_read( fname1, &KernFont );
 329
 330         timer_init();
 331
 332         // setup the fred exe directory so CFILE can init properly
 333         //char *c = GetCommandLine();
 334         //SDL_assert(c != NULL);
 335         //char *tok = strtok(c, " ");
 336         //SDL_assert(tok != NULL);
 337
 338         cfile_init();
 339
 340         os_init( "FontTool", "FontTool - Kerning Table Editor" );
 341
 342         // always run this thing in a window
 343         Cmdline_fullscreen = 0;
 344         Cmdline_window = 1;
 345
 346         gr_init();
 347
 348         gr_set_palette("none",NULL);
 349
 350         char fonttool_pcx[128];
 351         sprintf(fonttool_pcx, "src%sfonttool%sfonttool", DIR_SEPARATOR_STR, DIR_SEPARATOR_STR);
 352
 353         bkg = bm_load( fonttool_pcx );
 354
 355         if ( bkg < 0 )  {
 356                 printf("Error loading FontTool\n" );
 357                 myexit(1);
 358         }
 359         palette_use_bm_palette(bkg);
 360
 361         key_init();
 362         mouse_init();
 363
 364         gr_init_alphacolor( &ac, cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD );
 365
 366
 367         {
 368                 extern font *Current_font;
 369                 Current_font = &KernFont;
 370         }
 371
 372         done = 0;
 373         while (!done)   {
 374
 375                 os_poll();
 376                 k = key_inkey();
 377                 switch(k)       {
 378                 case SDLK_F3:
 379                         gr_toggle_fullscreen();
 380                         break;
 381
 382                 case SDLK_F5:
 383                         fonttool_read( fname1, &tmpfont );
 384                         fonttool_copy_kern( &tmpfont, &KernFont );
 385                         break;
 386
 387                 case SDLK_F6:
 388                         fonttool_remove_kerning( &KernFont );
 389                         break;
 390
 391                 case SDLK_F10:
 392                         fonttool_dump( fname1, &KernFont );
 393                         done=1;
 394                         break;
 395
 396                 case SDLK_COMMA:
 397                         if ( alpha > 1 )        {
 398                                 alpha--;
 399                                 gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
 400                         }
 401                         break;
 402
 403                 case SDLK_PERIOD:
 404                         if ( alpha < 17 )       {
 405                                 alpha++;
 406                                 gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
 407                         }
 408                         break;
 409
 410                 case SDLK_r:
 411                         if ( cr == 16 ) cr = 1; else cr = 16;
 412                         gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
 413                         break;
 414
 415                 case SDLK_g:
 416                         if ( cg == 16 ) cg = 1; else cg = 16;
 417                         gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
 418                         break;
 419
 420                 case SDLK_b:
 421                         if ( cb == 16 ) cb = 1; else cb = 16;
 422                         gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
 423                         break;
 424
 425                 case SDLK_KP_6:
 426                         x = fonttool_get_kerning( &KernFont, c1, c2, NULL );
 427                         fonttool_set_kerning( &KernFont, c1, c2, x+1 );
 428                         break;
 429
 430                 case SDLK_KP_4:
 431                         x = fonttool_get_kerning( &KernFont, c1, c2, NULL );
 432                         fonttool_set_kerning( &KernFont, c1, c2, x-1 );
 433                         break;
 434
 435                 case SDLK_KP_5:
 436                         fonttool_set_kerning( &KernFont, c1, c2, 0 );
 437                         break;
 438
 439                 case SDLK_KP_7:
 440                         if ( c1 < KernFont.first_ascii + KernFont.num_chars-1 ) c1++;
 441                         break;
 442
 443                 case SDLK_KP_1:
 444                         if ( c1 > KernFont.first_ascii ) c1--;
 445                         break;
 446
 447                 case SDLK_KP_9:
 448                         if ( c2 < KernFont.first_ascii + KernFont.num_chars-1 ) c2++;
 449                         mprintf(( "C2 = %d\n", c2 ));
 450                         break;
 451
 452                 case SDLK_KP_3:
 453                         if ( c2 > KernFont.first_ascii ) c2--;
 454                         mprintf(( "C2 = %d\n", c2 ));
 455                         break;
 456
 457                 case SDLK_KP_2:
 458                         if ( current_pair < 0 )
 459                                 current_pair = last_good_pair;
 460                         else
 461                                 current_pair++;
 462                         if ( current_pair >= KernFont.num_kern_pairs )  {
 463                                 current_pair = KernFont.num_kern_pairs-1;
 464                         }
 465                         if ( (current_pair < KernFont.num_kern_pairs) && (current_pair > -1) )  {
 466                                 c1 = KernFont.kern_data[current_pair].c1 + KernFont.first_ascii;
 467                                 c2 = KernFont.kern_data[current_pair].c2 + KernFont.first_ascii;
 468                         }
 469                         break;
 470
 471                 case SDLK_KP_8:
 472                         if ( current_pair < 0 )
 473                                 current_pair = last_good_pair;
 474                         else
 475                                 current_pair--;
 476                         if ( current_pair < 0 ) {
 477                                 current_pair = 0;
 478                         }
 479                         if ( (current_pair < KernFont.num_kern_pairs) && (current_pair > -1) )  {
 480                                 c1 = KernFont.kern_data[current_pair].c1 + KernFont.first_ascii;
 481                                 c2 = KernFont.kern_data[current_pair].c2 + KernFont.first_ascii;
 482                         }
 483                         break;
 484
 485                 case SDLK_ESCAPE:
 486                         done=1;
 487                         break;
 488                 }
 489
 490                 if ( current_pair >= KernFont.num_kern_pairs )  {
 491                         current_pair = -1;
 492                 }
 493
 494                 int tmpp=-1;
 495                 fonttool_get_kerning( &KernFont, c1, c2, &tmpp );
 496
 497                 if ( tmpp != -1 )       {
 498                         current_pair = tmpp;
 499                 } else  {
 500                         if ( current_pair > -1 )
 501                                 last_good_pair = current_pair;
 502                         current_pair = -1;
 503                 }
 504
 505                 gr_reset_clip();
 506                 gr_set_bitmap(bkg);
 507                 gr_bitmap(0,0);
 508                 gr_set_color_fast(&ac);
 509
 510                 sprintf( kerntext, "%c (%d)", c1, c1 );
 511                 gr_string( 240, 210, kerntext );
 512                 sprintf( kerntext, "%c (%d)", c2, c2 );
 513                 gr_string( 340, 210, kerntext );
 514
 515                 sprintf( kerntext, "Ham%c%crger", c1, c2 );
 516                 gr_string( 0x8000, 240, kerntext );
 517
 518                 sprintf( kerntext, "HAM%c%cRGER", c1, c2 );
 519                 gr_string( 0x8000, 270, kerntext );
 520
 521                 sprintf( kerntext, "Offset: %d pixels", fonttool_get_kerning( &KernFont, c1, c2, NULL ) );
 522                 gr_string( 0x8000, 300, kerntext );
 523
 524                 {
 525                         int tw, th;
 526                         gr_get_string_size( &tw, &th, kerntext );
 527
 528                         gr_string( 0x8000, 360, SampleText );
 529                         gr_string( 20, 360+th+20, SampleText );
 530                 }
 531
 532                 x = 5;
 533                 int y = 200;
 534                 int widest = 0;
 535
 536                  //= ( 330 - 200 ) / KernFont.h;
 537                 int num_items = KernFont.num_kern_pairs;
 538
 539                 if ( current_pair > -1 )
 540                         current_item = current_pair;
 541
 542                 if (current_item <0 )
 543                         current_item = 0;
 544
 545                 if (current_item >= num_items )
 546                         current_item = num_items-1;
 547
 548                 if (current_item<first_item)
 549                         first_item = current_item;
 550
 551                 if (current_item>=(first_item+num_items_displayed))
 552                         first_item = current_item-num_items_displayed+1;
 553
 554                 if (num_items <= num_items_displayed )
 555                         first_item = 0;
 556
 557                 int stop = first_item+num_items_displayed;
 558                 if (stop>num_items) stop = num_items;
 559
 560                 int n = 0;
 561                 for (i=first_item; i<stop; i++ )        {
 562                         int tw, th;
 563
 564                         sprintf( kerntext, "%c%c", KernFont.kern_data[i].c1 + KernFont.first_ascii, KernFont.kern_data[i].c2 + KernFont.first_ascii );
 565                         if ( i==current_pair )  {
 566                                 gr_set_color( 255, 0, 0 );
 567                                 //hud_tri( i2fl(x),i2fl(y), i2fl(x+6), i2fl(y+5), i2fl(x), i2fl(y+8) );
 568
 569                                 int x1 = x;
 570                                 int y1 = y;
 571                                 int x2 = x+6;
 572                                 int y2 = y+5;
 573                                 int x3 = x;
 574                                 int y3 = y+8;
 575
 576                                 gr_line(x1,y1,x2,y2);
 577                                 gr_line(x2,y2,x3,y3);
 578                                 gr_line(x3,y3,x1,y1);
 579
 580                                 gr_set_color_fast(&ac);
 581                         }
 582                         gr_string( x+8, y, kerntext );
 583                         n++;
 584                         gr_get_string_size( &tw, &th, kerntext );
 585                         tw += 8;
 586                         if ( tw > widest )
 587                                 widest = tw;
 588                         y += KernFont.h;
 589                         if ( y > 330 ) {
 590                                 y = 200;
 591                                 x += widest + 5;
 592                                 if ( x > 150 ) {
 593                                         num_items_displayed=n;
 594                                         break;
 595                                 }
 596                                 widest = 0;
 597                         }
 598                 }
 599                 if (i==stop)
 600                         num_items_displayed++;
 601
 602                 if (num_items_displayed < 1 )
 603                         num_items_displayed = 1;
 604
 605                 if (num_items_displayed > num_items )
 606                         num_items_displayed = num_items;
 607
 608                 //mprintf(( "Num items = %d\n", num_items_displayed ));
 609
 610
 611                 gr_flip();
 612
 613                 // sleep a little bit, don't need high framerate here
 614                 SDL_Delay(10);
 615         }
 616
 617         // cleanup
 618         if (bkg > -1) {
 619                 bm_unload(bkg);
 620         }
 621
 622
 623         exit(0);
 624 }
 625