2d/font.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 #ifdef HAVE_CONFIG_H
  15 #include <conf.h>
  16 #endif
  17
  18 #include <stdarg.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include <fcntl.h>
  24 #include <unistd.h>
  25
  26 #include "pa_enabl.h"                   //$$POLY_ACC
  27 #include "u_mem.h"
  28
  29 #include "gr.h"
  30 #include "grdef.h"
  31 #include "error.h"
  32
  33 #include "cfile.h"
  34 #include "mono.h"
  35 #include "byteswap.h"
  36 #include "bitmap.h"
  37
  38 #if defined(POLY_ACC)
  39 #include "poly_acc.h"
  40 #endif
  41
  42 #define MAX_OPEN_FONTS  50
  43 #define FILENAME_LEN            13
  44
  45 typedef struct openfont {
  46         char filename[FILENAME_LEN];
  47         grs_font *ptr;
  48 } openfont;
  49
  50 //list of open fonts, for use (for now) for palette remapping
  51 openfont open_font[MAX_OPEN_FONTS];
  52
  53 #define FONT        grd_curcanv->cv_font
  54 #define FG_COLOR    grd_curcanv->cv_font_fg_color
  55 #define BG_COLOR    grd_curcanv->cv_font_bg_color
  56 #define FWIDTH       FONT->ft_w
  57 #define FHEIGHT      FONT->ft_h
  58 #define FBASELINE    FONT->ft_baseline
  59 #define FFLAGS       FONT->ft_flags
  60 #define FMINCHAR     FONT->ft_minchar
  61 #define FMAXCHAR     FONT->ft_maxchar
  62 #define FDATA        FONT->ft_data
  63 #define FCHARS       FONT->ft_chars
  64 #define FWIDTHS      FONT->ft_widths
  65
  66 #define BITS_TO_BYTES(x)    (((x)+7)>>3)
  67
  68 int gr_internal_string_clipped(int x, int y, char *s );
  69 int gr_internal_string_clipped_m(int x, int y, char *s );
  70
  71 ubyte *find_kern_entry(grs_font *font,ubyte first,ubyte second)
  72 {
  73         ubyte *p=font->ft_kerndata;
  74
  75         while (*p!=255)
  76                 if (p[0]==first && p[1]==second)
  77                         return p;
  78                 else p+=3;
  79
  80         return NULL;
  81
  82 }
  83
  84 //takes the character AFTER being offset into font
  85 #define INFONT(_c) ((_c >= 0) && (_c <= FMAXCHAR-FMINCHAR))
  86
  87 //takes the character BEFORE being offset into current font
  88 void get_char_width(ubyte c,ubyte c2,int *width,int *spacing)
  89 {
  90         int letter;
  91
  92         letter = c-FMINCHAR;
  93
  94         if (!INFONT(letter)) {                          //not in font, draw as space
  95                 *width=0;
  96                 if (FFLAGS & FT_PROPORTIONAL)
  97                         *spacing = FWIDTH/2;
  98                 else
  99                         *spacing = FWIDTH;
 100                 return;
 101         }
 102
 103         if (FFLAGS & FT_PROPORTIONAL)
 104                 *width = FWIDTHS[letter];
 105         else
 106                 *width = FWIDTH;
 107
 108         *spacing = *width;
 109
 110         if (FFLAGS & FT_KERNED)  {
 111                 ubyte *p;
 112
 113                 if (!(c2==0 || c2=='\n')) {
 114                         int letter2;
 115
 116                         letter2 = c2-FMINCHAR;
 117
 118                         if (INFONT(letter2)) {
 119
 120                                 p = find_kern_entry(FONT,letter,letter2);
 121
 122                                 if (p)
 123                                         *spacing = p[2];
 124                         }
 125                 }
 126         }
 127 }
 128
 129 int get_centered_x(char *s)
 130 {
 131         int w,w2,s2;
 132
 133         for (w=0;*s!=0 && *s!='\n';s++) {
 134                 get_char_width(s[0],s[1],&w2,&s2);
 135                 w += s2;
 136         }
 137
 138         return ((grd_curcanv->cv_bitmap.bm_w - w) / 2);
 139 }
 140
 141
 142 int gr_internal_string0(int x, int y, char *s )
 143 {
 144         unsigned char * fp;
 145         ubyte * text_ptr, * next_row, * text_ptr1;
 146         int r, BitMask, i, bits, width, spacing, letter, underline;
 147         int     skip_lines = 0;
 148
 149         unsigned int VideoOffset, VideoOffset1;
 150
 151         bits=0;
 152
 153         VideoOffset1 = y * ROWSIZE + x;
 154
 155         next_row = s;
 156
 157         while (next_row != NULL )
 158         {
 159                 text_ptr1 = next_row;
 160                 next_row = NULL;
 161
 162                 if (x==0x8000) {                        //centered
 163                         int xx = get_centered_x(text_ptr1);
 164                         VideoOffset1 = y * ROWSIZE + xx;
 165                 }
 166
 167                 for (r=0; r<FHEIGHT; r++)
 168                 {
 169
 170                         text_ptr = text_ptr1;
 171
 172                         VideoOffset = VideoOffset1;
 173
 174                         while (*text_ptr)
 175                         {
 176                                 if (*text_ptr == '\n' )
 177                                 {
 178                                         next_row = &text_ptr[1];
 179                                         break;
 180                                 }
 181
 182                                 if (*text_ptr == CC_COLOR) {
 183                                         FG_COLOR = *(text_ptr+1);
 184                                         text_ptr += 2;
 185                                         continue;
 186                                 }
 187
 188                                 if (*text_ptr == CC_LSPACING) {
 189                                         skip_lines = *(text_ptr+1) - '0';
 190                                         text_ptr += 2;
 191                                         continue;
 192                                 }
 193
 194                                 underline = 0;
 195                                 if (*text_ptr == CC_UNDERLINE )
 196                                 {
 197                                         if ((r==FBASELINE+2) || (r==FBASELINE+3))
 198                                                 underline = 1;
 199                                         text_ptr++;
 200                                 }
 201
 202                                 get_char_width(text_ptr[0],text_ptr[1],&width,&spacing);
 203
 204                                 letter = *text_ptr-FMINCHAR;
 205
 206                                 if (!INFONT(letter)) {  //not in font, draw as space
 207                                         VideoOffset += spacing;
 208                                         text_ptr++;
 209                                         continue;
 210                                 }
 211
 212                                 if (FFLAGS & FT_PROPORTIONAL)
 213                                         fp = FCHARS[letter];
 214                                 else
 215                                         fp = FDATA + letter * BITS_TO_BYTES(width)*FHEIGHT;
 216
 217                                 if (underline)
 218                                         for (i=0; i< width; i++ )
 219                                                 DATA[VideoOffset++] = FG_COLOR;
 220                                 else
 221                                 {
 222                                         fp += BITS_TO_BYTES(width)*r;
 223
 224                                         BitMask = 0;
 225
 226                                         for (i=0; i< width; i++ )
 227                                         {
 228                                                 if (BitMask==0) {
 229                                                         bits = *fp++;
 230                                                         BitMask = 0x80;
 231                                                 }
 232
 233                                                 if (bits & BitMask)
 234                                                         DATA[VideoOffset++] = FG_COLOR;
 235                                                 else
 236                                                         DATA[VideoOffset++] = BG_COLOR;
 237                                                 BitMask >>= 1;
 238                                         }
 239                                 }
 240
 241                                 VideoOffset += spacing-width;           //for kerning
 242
 243                                 text_ptr++;
 244                         }
 245
 246                         VideoOffset1 += ROWSIZE; y++;
 247                 }
 248
 249                 y += skip_lines;
 250                 VideoOffset1 += ROWSIZE * skip_lines;
 251                 skip_lines = 0;
 252         }
 253         return 0;
 254 }
 255
 256 int gr_internal_string0m(int x, int y, char *s )
 257 {
 258         unsigned char * fp;
 259         ubyte * text_ptr, * next_row, * text_ptr1;
 260         int r, BitMask, i, bits, width, spacing, letter, underline;
 261         int     skip_lines = 0;
 262
 263         unsigned int VideoOffset, VideoOffset1;
 264
 265         bits=0;
 266
 267         VideoOffset1 = y * ROWSIZE + x;
 268
 269         next_row = s;
 270
 271         while (next_row != NULL )
 272         {
 273                 text_ptr1 = next_row;
 274                 next_row = NULL;
 275
 276                 if (x==0x8000) {                        //centered
 277                         int xx = get_centered_x(text_ptr1);
 278                         VideoOffset1 = y * ROWSIZE + xx;
 279                 }
 280
 281                 for (r=0; r<FHEIGHT; r++)
 282                 {
 283
 284                         text_ptr = text_ptr1;
 285
 286                         VideoOffset = VideoOffset1;
 287
 288                         while (*text_ptr)
 289                         {
 290                                 if (*text_ptr == '\n' )
 291                                 {
 292                                         next_row = &text_ptr[1];
 293                                         break;
 294                                 }
 295
 296                                 if (*text_ptr == CC_COLOR) {
 297                                         FG_COLOR = *(text_ptr+1);
 298                                         text_ptr += 2;
 299                                         continue;
 300                                 }
 301
 302                                 if (*text_ptr == CC_LSPACING) {
 303                                         skip_lines = *(text_ptr+1) - '0';
 304                                         text_ptr += 2;
 305                                         continue;
 306                                 }
 307
 308                                 underline = 0;
 309                                 if (*text_ptr == CC_UNDERLINE )
 310                                 {
 311                                         if ((r==FBASELINE+2) || (r==FBASELINE+3))
 312                                                 underline = 1;
 313                                         text_ptr++;
 314                                 }
 315
 316                                 get_char_width(text_ptr[0],text_ptr[1],&width,&spacing);
 317
 318                                 letter = *text_ptr-FMINCHAR;
 319
 320                                 if (!INFONT(letter)) {  //not in font, draw as space
 321                                         VideoOffset += spacing;
 322                                         text_ptr++;
 323                                         continue;
 324                                 }
 325
 326                                 if (FFLAGS & FT_PROPORTIONAL)
 327                                         fp = FCHARS[letter];
 328                                 else
 329                                         fp = FDATA + letter * BITS_TO_BYTES(width)*FHEIGHT;
 330
 331                                 if (underline)
 332                                         for (i=0; i< width; i++ )
 333                                                 DATA[VideoOffset++] = FG_COLOR;
 334                                 else
 335                                 {
 336                                         fp += BITS_TO_BYTES(width)*r;
 337
 338                                         BitMask = 0;
 339
 340                                         for (i=0; i< width; i++ )
 341                                         {
 342                                                 if (BitMask==0) {
 343                                                         bits = *fp++;
 344                                                         BitMask = 0x80;
 345                                                 }
 346
 347                                                 if (bits & BitMask)
 348                                                         DATA[VideoOffset++] = FG_COLOR;
 349                                                 else
 350                                                         VideoOffset++;
 351                                                 BitMask >>= 1;
 352                                         }
 353                                 }
 354                                 text_ptr++;
 355
 356                                 VideoOffset += spacing-width;
 357                         }
 358
 359                         VideoOffset1 += ROWSIZE; y++;
 360                 }
 361                 y += skip_lines;
 362                 VideoOffset1 += ROWSIZE * skip_lines;
 363                 skip_lines = 0;
 364         }
 365         return 0;
 366 }
 367
 368 #ifdef __ENV_MSDOS__
 369 int gr_internal_string2(int x, int y, char *s )
 370 {
 371         unsigned char * fp;
 372         char * text_ptr, * next_row, * text_ptr1;
 373         int r, BitMask, i, bits, width, spacing, letter, underline;
 374         int page_switched, skip_lines = 0;
 375
 376         unsigned int VideoOffset, VideoOffset1;
 377
 378         VideoOffset1 = (unsigned int)DATA + y * ROWSIZE + x;
 379
 380         gr_vesa_setpage(VideoOffset1 >> 16);
 381
 382         VideoOffset1 &= 0xFFFF;
 383
 384         next_row = s;
 385
 386         while (next_row != NULL )
 387         {
 388                 text_ptr1 = next_row;
 389                 next_row = NULL;
 390
 391                 if (x==0x8000) {                        //centered
 392                         int xx = get_centered_x(text_ptr1);
 393                         VideoOffset1 = y * ROWSIZE + xx;
 394                         gr_vesa_setpage(VideoOffset1 >> 16);
 395                         VideoOffset1 &= 0xFFFF;
 396                 }
 397
 398                 for (r=0; r<FHEIGHT; r++)
 399                 {
 400                         text_ptr = text_ptr1;
 401
 402                         VideoOffset = VideoOffset1;
 403
 404                         page_switched = 0;
 405
 406                         while (*text_ptr)
 407                         {
 408                                 if (*text_ptr == '\n' )
 409                                 {
 410                                         next_row = &text_ptr[1];
 411                                         break;
 412                                 }
 413
 414                                 if (*text_ptr == CC_COLOR) {
 415                                         FG_COLOR = *(text_ptr+1);
 416                                         text_ptr += 2;
 417                                         continue;
 418                                 }
 419
 420                                 if (*text_ptr == CC_LSPACING) {
 421                                         skip_lines = *(text_ptr+1) - '0';
 422                                         text_ptr += 2;
 423                                         continue;
 424                                 }
 425
 426                                 underline = 0;
 427                                 if (*text_ptr == CC_UNDERLINE )
 428                                 {
 429                                         if ((r==FBASELINE+2) || (r==FBASELINE+3))
 430                                                 underline = 1;
 431                                         text_ptr++;
 432                                 }
 433
 434                                 get_char_width(text_ptr[0],text_ptr[1],&width,&spacing);
 435
 436                                 Assert(width==spacing);         //no kerning support here
 437
 438                                 letter = *text_ptr-FMINCHAR;
 439
 440                                 if (!INFONT(letter)) {  //not in font, draw as space
 441                                         VideoOffset += spacing;
 442                                         text_ptr++;
 443                                         continue;
 444                                 }
 445
 446                                 if (FFLAGS & FT_PROPORTIONAL)
 447                                         fp = FCHARS[letter];
 448                                 else
 449                                         fp = FDATA + letter * BITS_TO_BYTES(width)*FHEIGHT;
 450
 451                                 if (underline)
 452                                 {
 453                                         if ( VideoOffset+width > 0xFFFF )
 454                                         {
 455                                                 for (i=0; i< width; i++ )
 456                                                 {
 457                                                         gr_video_memory[VideoOffset++] = FG_COLOR;
 458
 459                                                         if (VideoOffset > 0xFFFF )
 460                                                         {
 461                                                                 VideoOffset -= 0xFFFF + 1;
 462                                                                 page_switched = 1;
 463                                                                 gr_vesa_incpage();
 464                                                         }
 465                                                 }
 466                                         }
 467                                         else
 468                                         {
 469                                                 for (i=0; i< width; i++ )
 470                                                         gr_video_memory[VideoOffset++] = FG_COLOR;
 471                                         }
 472                                 }
 473                                 else
 474                                 {
 475                                         // fp -- dword
 476                                         // VideoOffset
 477                                         // width
 478
 479                                         fp += BITS_TO_BYTES(width)*r;
 480
 481                                         BitMask = 0;
 482
 483                                         if ( VideoOffset+width > 0xFFFF )
 484                                         {
 485                                                 for (i=0; i< width; i++ )
 486                                                 {
 487                                                         if (BitMask==0) {
 488                                                                 bits = *fp++;
 489                                                                 BitMask = 0x80;
 490                                                         }
 491
 492                                                         if (bits & BitMask)
 493                                                                 gr_video_memory[VideoOffset++] = FG_COLOR;
 494                                                         else
 495                                                                 gr_video_memory[VideoOffset++] = BG_COLOR;
 496
 497                                                         BitMask >>= 1;
 498
 499                                                         if (VideoOffset > 0xFFFF )
 500                                                         {
 501                                                                 VideoOffset -= 0xFFFF + 1;
 502                                                                 page_switched = 1;
 503                                                                 gr_vesa_incpage();
 504                                                         }
 505
 506                                                 }
 507                                         } else {
 508
 509                                                 if (width == 8 )
 510                                                 {
 511                                                         bits = *fp++;
 512
 513                                                         if (bits & 0x80) gr_video_memory[VideoOffset+0] = FG_COLOR;
 514                                                         else gr_video_memory[VideoOffset+0] = BG_COLOR;
 515
 516                                                         if (bits & 0x40) gr_video_memory[VideoOffset+1] = FG_COLOR;
 517                                                         else gr_video_memory[VideoOffset+1] = BG_COLOR;
 518
 519                                                         if (bits & 0x20) gr_video_memory[VideoOffset+2] = FG_COLOR;
 520                                                         else gr_video_memory[VideoOffset+2] = BG_COLOR;
 521
 522                                                         if (bits & 0x10) gr_video_memory[VideoOffset+3] = FG_COLOR;
 523                                                         else gr_video_memory[VideoOffset+3] = BG_COLOR;
 524
 525                                                         if (bits & 0x08) gr_video_memory[VideoOffset+4] = FG_COLOR;
 526                                                         else gr_video_memory[VideoOffset+4] = BG_COLOR;
 527
 528                                                         if (bits & 0x04) gr_video_memory[VideoOffset+5] = FG_COLOR;
 529                                                         else gr_video_memory[VideoOffset+5] = BG_COLOR;
 530
 531                                                         if (bits & 0x02) gr_video_memory[VideoOffset+6] = FG_COLOR;
 532                                                         else gr_video_memory[VideoOffset+6] = BG_COLOR;
 533
 534                                                         if (bits & 0x01) gr_video_memory[VideoOffset+7] = FG_COLOR;
 535                                                         else gr_video_memory[VideoOffset+7] = BG_COLOR;
 536
 537                                                         VideoOffset += 8;
 538                                                 } else {
 539                                                         for (i=0; i< width/2 ; i++ )
 540                                                         {
 541                                                                 if (BitMask==0) {
 542                                                                         bits = *fp++;
 543                                                                         BitMask = 0x80;
 544                                                                 }
 545
 546                                                                 if (bits & BitMask)
 547                                                                         gr_video_memory[VideoOffset++] = FG_COLOR;
 548                                                                 else
 549                                                                         gr_video_memory[VideoOffset++] = BG_COLOR;
 550                                                                 BitMask >>= 1;
 551
 552
 553                                                                 // Unroll twice
 554
 555                                                                 if (BitMask==0) {
 556                                                                         bits = *fp++;
 557                                                                         BitMask = 0x80;
 558                                                                 }
 559
 560                                                                 if (bits & BitMask)
 561                                                                         gr_video_memory[VideoOffset++] = FG_COLOR;
 562                                                                 else
 563                                                                         gr_video_memory[VideoOffset++] = BG_COLOR;
 564                                                                 BitMask >>= 1;
 565                                                         }
 566                                                 }
 567                                         }
 568                                 }
 569                                 text_ptr++;
 570                         }
 571
 572                         y ++;
 573                         VideoOffset1 += ROWSIZE;
 574
 575                         if (VideoOffset1 > 0xFFFF ) {
 576                                 VideoOffset1 -= 0xFFFF + 1;
 577                                 if (!page_switched)
 578                                         gr_vesa_incpage();
 579                         }
 580                 }
 581
 582                 y += skip_lines;
 583                 VideoOffset1 += ROWSIZE * skip_lines;
 584                 skip_lines = 0;
 585         }
 586         return 0;
 587 }
 588
 589 int gr_internal_string2m(int x, int y, char *s )
 590 {
 591         unsigned char * fp;
 592         char * text_ptr, * next_row, * text_ptr1;
 593         int r, BitMask, i, bits, width, spacing, letter, underline;
 594         int page_switched, skip_lines = 0;
 595
 596         unsigned int VideoOffset, VideoOffset1;
 597
 598         VideoOffset1 = (unsigned int)DATA + y * ROWSIZE + x;
 599
 600         gr_vesa_setpage(VideoOffset1 >> 16);
 601
 602         VideoOffset1 &= 0xFFFF;
 603
 604         next_row = s;
 605
 606         while (next_row != NULL )
 607         {
 608                 text_ptr1 = next_row;
 609                 next_row = NULL;
 610
 611                 if (x==0x8000) {                        //centered
 612                         int xx = get_centered_x(text_ptr1);
 613                         VideoOffset1 = y * ROWSIZE + xx;
 614                         gr_vesa_setpage(VideoOffset1 >> 16);
 615                         VideoOffset1 &= 0xFFFF;
 616                 }
 617
 618                 for (r=0; r<FHEIGHT; r++)
 619                 {
 620                         text_ptr = text_ptr1;
 621
 622                         VideoOffset = VideoOffset1;
 623
 624                         page_switched = 0;
 625
 626                         while (*text_ptr)
 627                         {
 628                                 if (*text_ptr == '\n' )
 629                                 {
 630                                         next_row = &text_ptr[1];
 631                                         break;
 632                                 }
 633
 634                                 if (*text_ptr == CC_COLOR) {
 635                                         FG_COLOR = *(text_ptr+1);
 636                                         text_ptr += 2;
 637                                         continue;
 638                                 }
 639
 640                                 if (*text_ptr == CC_LSPACING) {
 641                                         skip_lines = *(text_ptr+1) - '0';
 642                                         text_ptr += 2;
 643                                         continue;
 644                                 }
 645
 646                                 underline = 0;
 647                                 if (*text_ptr == CC_UNDERLINE )
 648                                 {
 649                                         if ((r==FBASELINE+2) || (r==FBASELINE+3))
 650                                                 underline = 1;
 651                                         text_ptr++;
 652                                 }
 653
 654                                 get_char_width(text_ptr[0],text_ptr[1],&width,&spacing);
 655
 656                                 letter = *text_ptr-FMINCHAR;
 657
 658                                 if (!INFONT(letter)) {  //not in font, draw as space
 659                                         VideoOffset += width;
 660                                         text_ptr++;
 661                                         continue;
 662                                 }
 663
 664                                 if (FFLAGS & FT_PROPORTIONAL)
 665                                         fp = FCHARS[letter];
 666                                 else
 667                                         fp = FDATA + letter * BITS_TO_BYTES(width)*FHEIGHT;
 668
 669                                 if (underline)
 670                                 {
 671                                         if ( VideoOffset+width > 0xFFFF )
 672                                         {
 673                                                 for (i=0; i< width; i++ )
 674                                                 {
 675                                                         gr_video_memory[VideoOffset++] = FG_COLOR;
 676
 677                                                         if (VideoOffset > 0xFFFF )
 678                                                         {
 679                                                                 VideoOffset -= 0xFFFF + 1;
 680                                                                 page_switched = 1;
 681                                                                 gr_vesa_incpage();
 682                                                         }
 683                                                 }
 684                                         }
 685                                         else
 686                                         {
 687                                                 for (i=0; i< width; i++ )
 688                                                         gr_video_memory[VideoOffset++] = FG_COLOR;
 689                                         }
 690                                 }
 691                                 else
 692                                 {
 693                                         fp += BITS_TO_BYTES(width)*r;
 694
 695                                         BitMask = 0;
 696
 697                                         if ( VideoOffset+width > 0xFFFF )
 698                                         {
 699                                                 for (i=0; i< width; i++ )
 700                                                 {
 701                                                         if (BitMask==0) {
 702                                                                 bits = *fp++;
 703                                                                 BitMask = 0x80;
 704                                                         }
 705
 706                                                         if (bits & BitMask)
 707                                                                 gr_video_memory[VideoOffset++] = FG_COLOR;
 708                                                         else
 709                                                                 VideoOffset++;
 710
 711                                                         BitMask >>= 1;
 712
 713                                                         if (VideoOffset > 0xFFFF )
 714                                                         {
 715                                                                 VideoOffset -= 0xFFFF + 1;
 716                                                                 page_switched = 1;
 717                                                                 gr_vesa_incpage();
 718                                                         }
 719
 720                                                 }
 721                                         } else {
 722                                                 for (i=0; i< width; i++ )
 723                                                 {
 724                                                         if (BitMask==0) {
 725                                                                 bits = *fp++;
 726                                                                 BitMask = 0x80;
 727                                                         }
 728
 729                                                         if (bits & BitMask)
 730                                                                 gr_video_memory[VideoOffset++] = FG_COLOR;
 731                                                         else
 732                                                                 VideoOffset++;;
 733                                                         BitMask >>= 1;
 734                                                 }
 735                                         }
 736                                 }
 737                                 text_ptr++;
 738
 739                                 VideoOffset += spacing-width;
 740                         }
 741
 742                         y ++;
 743                         VideoOffset1 += ROWSIZE;
 744
 745                         if (VideoOffset1 > 0xFFFF ) {
 746                                 VideoOffset1 -= 0xFFFF + 1;
 747                                 if (!page_switched)
 748                                         gr_vesa_incpage();
 749                         }
 750                 }
 751
 752                 y += skip_lines;
 753                 VideoOffset1 += ROWSIZE * skip_lines;
 754                 skip_lines = 0;
 755         }
 756         return 0;
 757 }
 758
 759 #endif // __ENV_MSDOS__
 760
 761 #if defined(POLY_ACC)
 762 int gr_internal_string5(int x, int y, char *s )
 763 {
 764         unsigned char * fp;
 765         ubyte * text_ptr, * next_row, * text_ptr1;
 766         int r, BitMask, i, bits, width, spacing, letter, underline;
 767         int     skip_lines = 0;
 768
 769         unsigned int VideoOffset, VideoOffset1;
 770
 771     pa_flush();
 772     VideoOffset1 = y * ROWSIZE + x * PA_BPP;
 773
 774         next_row = s;
 775
 776         while (next_row != NULL )
 777         {
 778                 text_ptr1 = next_row;
 779                 next_row = NULL;
 780
 781                 if (x==0x8000) {                        //centered
 782                         int xx = get_centered_x(text_ptr1);
 783             VideoOffset1 = y * ROWSIZE + xx * PA_BPP;
 784                 }
 785
 786                 for (r=0; r<FHEIGHT; r++)
 787                 {
 788
 789                         text_ptr = text_ptr1;
 790
 791                         VideoOffset = VideoOffset1;
 792
 793                         while (*text_ptr)
 794                         {
 795                                 if (*text_ptr == '\n' )
 796                                 {
 797                                         next_row = &text_ptr[1];
 798                                         break;
 799                                 }
 800
 801                                 if (*text_ptr == CC_COLOR) {
 802                                         FG_COLOR = *(text_ptr+1);
 803                                         text_ptr += 2;
 804                                         continue;
 805                                 }
 806
 807                                 if (*text_ptr == CC_LSPACING) {
 808                                         skip_lines = *(text_ptr+1) - '0';
 809                                         text_ptr += 2;
 810                                         continue;
 811                                 }
 812
 813                                 underline = 0;
 814                                 if (*text_ptr == CC_UNDERLINE )
 815                                 {
 816                                         if ((r==FBASELINE+2) || (r==FBASELINE+3))
 817                                                 underline = 1;
 818                                         text_ptr++;
 819                                 }
 820
 821                                 get_char_width(text_ptr[0],text_ptr[1],&width,&spacing);
 822
 823                                 letter = *text_ptr-FMINCHAR;
 824
 825                                 if (!INFONT(letter)) {  //not in font, draw as space
 826                     VideoOffset += spacing * PA_BPP;
 827                                         text_ptr++;
 828                                         continue;
 829                                 }
 830
 831                                 if (FFLAGS & FT_PROPORTIONAL)
 832                                         fp = FCHARS[letter];
 833                                 else
 834                                         fp = FDATA + letter * BITS_TO_BYTES(width)*FHEIGHT;
 835
 836                                 if (underline)
 837                                         for (i=0; i< width; i++ )
 838                     {    *(short *)(DATA + VideoOffset) = pa_clut[FG_COLOR]; VideoOffset += PA_BPP; }
 839                                 else
 840                                 {
 841                                         fp += BITS_TO_BYTES(width)*r;
 842
 843                                         BitMask = 0;
 844
 845                                         for (i=0; i< width; i++ )
 846                                         {
 847                                                 if (BitMask==0) {
 848                                                         bits = *fp++;
 849                                                         BitMask = 0x80;
 850                                                 }
 851
 852                                                 if (bits & BitMask)
 853                         {    *(short *)(DATA + VideoOffset) = pa_clut[FG_COLOR]; VideoOffset += PA_BPP; }
 854                         else
 855                         {    *(short *)(DATA + VideoOffset) = pa_clut[BG_COLOR]; VideoOffset += PA_BPP; }
 856                         BitMask >>= 1;
 857                                         }
 858                                 }
 859
 860                 VideoOffset += PA_BPP * (spacing-width);       //for kerning
 861
 862                                 text_ptr++;
 863                         }
 864
 865                         VideoOffset1 += ROWSIZE; y++;
 866                 }
 867
 868                 y += skip_lines;
 869                 VideoOffset1 += ROWSIZE * skip_lines;
 870                 skip_lines = 0;
 871         }
 872         return 0;
 873 }
 874
 875 int gr_internal_string5m(int x, int y, char *s )
 876 {
 877         unsigned char * fp;
 878         ubyte * text_ptr, * next_row, * text_ptr1;
 879         int r, BitMask, i, bits, width, spacing, letter, underline;
 880         int     skip_lines = 0;
 881
 882         unsigned int VideoOffset, VideoOffset1;
 883
 884     pa_flush();
 885     VideoOffset1 = y * ROWSIZE + x * PA_BPP;
 886
 887         next_row = s;
 888
 889         while (next_row != NULL )
 890         {
 891                 text_ptr1 = next_row;
 892                 next_row = NULL;
 893
 894                 if (x==0x8000) {                        //centered
 895                         int xx = get_centered_x(text_ptr1);
 896             VideoOffset1 = y * ROWSIZE + xx * PA_BPP;
 897                 }
 898
 899                 for (r=0; r<FHEIGHT; r++)
 900                 {
 901
 902                         text_ptr = text_ptr1;
 903
 904                         VideoOffset = VideoOffset1;
 905
 906                         while (*text_ptr)
 907                         {
 908                                 if (*text_ptr == '\n' )
 909                                 {
 910                                         next_row = &text_ptr[1];
 911                                         break;
 912                                 }
 913
 914                                 if (*text_ptr == CC_COLOR) {
 915                                         FG_COLOR = *(text_ptr+1);
 916                                         text_ptr += 2;
 917                                         continue;
 918                                 }
 919
 920                                 if (*text_ptr == CC_LSPACING) {
 921                                         skip_lines = *(text_ptr+1) - '0';
 922                                         text_ptr += 2;
 923                                         continue;
 924                                 }
 925
 926                                 underline = 0;
 927                                 if (*text_ptr == CC_UNDERLINE )
 928                                 {
 929                                         if ((r==FBASELINE+2) || (r==FBASELINE+3))
 930                                                 underline = 1;
 931                                         text_ptr++;
 932                                 }
 933
 934                                 get_char_width(text_ptr[0],text_ptr[1],&width,&spacing);
 935
 936                                 letter = *text_ptr-FMINCHAR;
 937
 938                                 if (!INFONT(letter)) {  //not in font, draw as space
 939                     VideoOffset += spacing * PA_BPP;
 940                                         text_ptr++;
 941                                         continue;
 942                                 }
 943
 944                                 if (FFLAGS & FT_PROPORTIONAL)
 945                                         fp = FCHARS[letter];
 946                                 else
 947                                         fp = FDATA + letter * BITS_TO_BYTES(width)*FHEIGHT;
 948
 949                                 if (underline)
 950                                         for (i=0; i< width; i++ )
 951                     {    *(short *)(DATA + VideoOffset) = pa_clut[FG_COLOR]; VideoOffset += PA_BPP; }
 952                 else
 953                                 {
 954                                         fp += BITS_TO_BYTES(width)*r;
 955
 956                                         BitMask = 0;
 957
 958                                         for (i=0; i< width; i++ )
 959                                         {
 960                                                 if (BitMask==0) {
 961                                                         bits = *fp++;
 962                                                         BitMask = 0x80;
 963                                                 }
 964
 965                                                 if (bits & BitMask)
 966                         {    *(short *)(DATA + VideoOffset) = pa_clut[FG_COLOR]; VideoOffset += PA_BPP; }
 967                         else
 968                             VideoOffset += PA_BPP;
 969                                                 BitMask >>= 1;
 970                                         }
 971                                 }
 972                                 text_ptr++;
 973
 974                 VideoOffset += PA_BPP * (spacing-width);
 975                         }
 976
 977                         VideoOffset1 += ROWSIZE; y++;
 978                 }
 979                 y += skip_lines;
 980                 VideoOffset1 += ROWSIZE * skip_lines;
 981                 skip_lines = 0;
 982         }
 983         return 0;
 984 }
 985 #endif
 986
 987 //a bitmap for the character
 988 grs_bitmap char_bm = {
 989                                 0,0,0,0,                                                //x,y,w,h
 990                                 BM_LINEAR,                                      //type
 991                                 BM_FLAG_TRANSPARENT,            //flags
 992                                 0,                                                              //rowsize
 993                                 NULL,                                                   //data
 994                                 0                                                               //selector
 995 };
 996
 997 int gr_internal_color_string(int x, int y, char *s )
 998 {
 999         unsigned char * fp;
1000         ubyte * text_ptr, * next_row, * text_ptr1;
1001         int width, spacing,letter;
1002         int xx,yy;
1003
1004         char_bm.bm_h = FHEIGHT;         //set height for chars of this font
1005
1006         next_row = s;
1007
1008         yy = y;
1009
1010
1011         while (next_row != NULL)
1012         {
1013                 text_ptr1 = next_row;
1014                 next_row = NULL;
1015
1016                 text_ptr = text_ptr1;
1017
1018                 xx = x;
1019
1020                 if (xx==0x8000)                 //centered
1021                         xx = get_centered_x(text_ptr);
1022
1023                 while (*text_ptr)
1024                 {
1025                         if (*text_ptr == '\n' )
1026                         {
1027                                 next_row = &text_ptr[1];
1028                                 yy += FHEIGHT;
1029                                 break;
1030                         }
1031
1032                         letter = *text_ptr-FMINCHAR;
1033
1034                         get_char_width(text_ptr[0],text_ptr[1],&width,&spacing);
1035
1036                         if (!INFONT(letter)) {  //not in font, draw as space
1037                                 xx += spacing;
1038                                 text_ptr++;
1039                                 continue;
1040                         }
1041
1042                         if (FFLAGS & FT_PROPORTIONAL)
1043                                 fp = FCHARS[letter];
1044                         else
1045                                 fp = FDATA + letter * BITS_TO_BYTES(width)*FHEIGHT;
1046
1047                         char_bm.bm_w = char_bm.bm_rowsize = width;
1048
1049                         char_bm.bm_data = fp;
1050                         gr_bitmapm(xx,yy,&char_bm);
1051
1052                         xx += spacing;
1053
1054                         text_ptr++;
1055                 }
1056
1057         }
1058         return 0;
1059 }
1060
1061 int gr_string(int x, int y, char *s )
1062 {
1063         int w, h, aw;
1064         int clipped=0;
1065
1066         Assert(FONT != NULL);
1067
1068         if ( x == 0x8000 )      {
1069                 if ( y<0 ) clipped |= 1;
1070                 gr_get_string_size(s, &w, &h, &aw );
1071                 // for x, since this will be centered, only look at
1072                 // width.
1073                 if ( w > grd_curcanv->cv_bitmap.bm_w ) clipped |= 1;
1074                 if ( (y+h) > grd_curcanv->cv_bitmap.bm_h ) clipped |= 1;
1075
1076                 if ( (y+h) < 0 ) clipped |= 2;
1077                 if ( y > grd_curcanv->cv_bitmap.bm_h ) clipped |= 2;
1078
1079         } else {
1080                 if ( (x<0) || (y<0) ) clipped |= 1;
1081                 gr_get_string_size(s, &w, &h, &aw );
1082                 if ( (x+w) > grd_curcanv->cv_bitmap.bm_w ) clipped |= 1;
1083                 if ( (y+h) > grd_curcanv->cv_bitmap.bm_h ) clipped |= 1;
1084                 if ( (x+w) < 0 ) clipped |= 2;
1085                 if ( (y+h) < 0 ) clipped |= 2;
1086                 if ( x > grd_curcanv->cv_bitmap.bm_w ) clipped |= 2;
1087                 if ( y > grd_curcanv->cv_bitmap.bm_h ) clipped |= 2;
1088         }
1089
1090         if ( !clipped )
1091                 return gr_ustring(x, y, s );
1092
1093         if ( clipped & 2 )      {
1094                 // Completely clipped...
1095                 mprintf( (1, "Text '%s' at (%d,%d) is off screen!\n", s, x, y ));
1096                 return 0;
1097         }
1098
1099         if ( clipped & 1 )      {
1100                 // Partially clipped...
1101                 //mprintf( (0, "Text '%s' at (%d,%d) is getting clipped!\n", s, x, y ));
1102         }
1103
1104         // Partially clipped...
1105
1106         if (FFLAGS & FT_COLOR)
1107                 return gr_internal_color_string( x, y, s);
1108
1109         if ( BG_COLOR == -1)
1110                 return gr_internal_string_clipped_m( x, y, s );
1111
1112         return gr_internal_string_clipped( x, y, s );
1113 }
1114
1115 int gr_ustring(int x, int y, char *s )
1116 {
1117         if (FFLAGS & FT_COLOR) {
1118
1119                 return gr_internal_color_string(x,y,s);
1120
1121         }
1122         else
1123                 switch( TYPE )
1124                 {
1125                 case BM_LINEAR:
1126                         if ( BG_COLOR == -1)
1127                                 return gr_internal_string0m(x,y,s);
1128                         else
1129                                 return gr_internal_string0(x,y,s);
1130 #ifdef __ENV_MSDOS__
1131                 case BM_SVGA:
1132                         if ( BG_COLOR == -1)
1133                                 return gr_internal_string2m(x,y,s);
1134                         else
1135                                 return gr_internal_string2(x,y,s);
1136 #endif // __ENV_MSDOS__
1137 #if defined(POLY_ACC)
1138         case BM_LINEAR15:
1139                         if ( BG_COLOR == -1)
1140                 return gr_internal_string5m(x,y,s);
1141                         else
1142                 return gr_internal_string5(x,y,s);
1143 #endif
1144         }
1145
1146         return 0;
1147 }
1148
1149
1150 void gr_get_string_size(char *s, int *string_width, int *string_height, int *average_width )
1151 {
1152         int i = 0, longest_width = 0;
1153         int width,spacing;
1154
1155         *string_height = FHEIGHT;
1156         *string_width = 0;
1157         *average_width = FWIDTH;
1158
1159         if (s != NULL )
1160         {
1161                 *string_width = 0;
1162                 while (*s)
1163                 {
1164 //                      if (*s == CC_UNDERLINE)
1165 //                              s++;
1166                         while (*s == '\n')
1167                         {
1168                                 s++;
1169                                 *string_height += FHEIGHT;
1170                                 *string_width = 0;
1171                         }
1172
1173                         if (*s == 0) break;
1174
1175                         //      1 = next byte specifies color, so skip the 1 and the color value
1176                         if (*s == CC_COLOR)
1177                                 s += 2;
1178                         else if (*s == CC_LSPACING) {
1179                                 *string_height += *(s+1)-'0';
1180                                 s += 2;
1181                         } else {
1182                                 get_char_width(s[0],s[1],&width,&spacing);
1183                                 *string_width += spacing;
1184                                 if (*string_width > longest_width)
1185                                         longest_width = *string_width;
1186                                 i++;
1187                                 s++;
1188                         }
1189                 }
1190         }
1191         *string_width = longest_width;
1192 }
1193
1194
1195 int gr_uprintf( int x, int y, char * format, ... )
1196 {
1197         char buffer[1000];
1198         va_list args;
1199
1200         va_start(args, format );
1201         vsprintf(buffer,format,args);
1202         return gr_ustring( x, y, buffer );
1203 }
1204
1205 int gr_printf( int x, int y, char * format, ... )
1206 {
1207         char buffer[1000];
1208         va_list args;
1209
1210         va_start(args, format );
1211         vsprintf(buffer,format,args);
1212         return gr_string( x, y, buffer );
1213 }
1214
1215 void gr_close_font( grs_font * font )
1216 {
1217         if (font)
1218         {
1219                 int fontnum;
1220
1221                 //find font in list
1222                 for (fontnum=0;fontnum<MAX_OPEN_FONTS && open_font[fontnum].ptr!=font;fontnum++);
1223                 Assert(fontnum<MAX_OPEN_FONTS); //did we find slot?
1224
1225                 open_font[fontnum].ptr = NULL;
1226
1227                 if ( font->ft_chars )
1228                         d_free( font->ft_chars );
1229                 d_free( font );
1230
1231         }
1232 }
1233
1234 //remap (by re-reading) all the color fonts
1235 void gr_remap_color_fonts()
1236 {
1237         int fontnum;
1238
1239         for (fontnum=0;fontnum<MAX_OPEN_FONTS;fontnum++) {
1240                 grs_font *font;
1241
1242                 font = open_font[fontnum].ptr;
1243
1244                 if (font && (font->ft_flags & FT_COLOR))
1245                         gr_remap_font(font,open_font[fontnum].filename);
1246         }
1247 }
1248
1249 void build_colormap_good( ubyte * palette, ubyte * colormap, int * freq );
1250 void decode_data_asm(ubyte *data, int num_pixels, ubyte * colormap, int * count );
1251 #ifdef __WATCOMC__
1252 #pragma aux decode_data_asm parm [esi] [ecx] [edi] [ebx] modify exact [esi edi eax ebx ecx] = \
1253 "again_ddn:"                                                    \
1254         "xor    eax,eax"                                \
1255         "mov    al,[esi]"                       \
1256         "inc    dword ptr [ebx+eax*4]"          \
1257         "mov    al,[edi+eax]"           \
1258         "mov    [esi],al"                       \
1259         "inc    esi"                                    \
1260         "dec    ecx"                                    \
1261         "jne    again_ddn"
1262
1263 #endif
1264
1265 grs_font * gr_init_font( char * fontname )
1266 {
1267         static int first_time=1;
1268         grs_font *font;
1269         int i,fontnum;
1270         unsigned char * ptr;
1271         int nchars;
1272         CFILE *fontfile;
1273         char file_id[4];
1274         int datasize;           //size up to (but not including) palette
1275
1276         if (first_time) {
1277                 int i;
1278                 for (i=0;i<MAX_OPEN_FONTS;i++)
1279                         open_font[i].ptr = NULL;
1280                 first_time=0;
1281         }
1282
1283         //find free font slot
1284         for (fontnum=0;fontnum<MAX_OPEN_FONTS && open_font[fontnum].ptr!=NULL;fontnum++);
1285         Assert(fontnum<MAX_OPEN_FONTS); //did we find one?
1286
1287         strncpy(open_font[fontnum].filename,fontname,FILENAME_LEN);
1288
1289         fontfile = cfopen(fontname, "rb");
1290
1291         if (!fontfile)
1292                 Error( "Can't open font file %s", fontname );
1293
1294         cfread( file_id, 1, 4, fontfile );
1295         datasize = cfile_read_int(fontfile);
1296
1297
1298         if ((file_id[0] != 'P') ||
1299             (file_id[1] != 'S') ||
1300             (file_id[2] != 'F') ||
1301             (file_id[3] != 'N'))
1302                 Error( "File %s is not a font file", fontname );
1303
1304         font = (grs_font *) d_malloc(datasize);
1305
1306         open_font[fontnum].ptr = font;
1307
1308         cfread(font,1,datasize,fontfile);
1309
1310 #ifdef MACINTOSH
1311 // gotta translate those endian things
1312
1313         font->ft_w = SWAPSHORT(font->ft_w);
1314         font->ft_h = SWAPSHORT(font->ft_h);
1315         font->ft_flags = SWAPSHORT(font->ft_flags);
1316         font->ft_bytewidth = SWAPSHORT(font->ft_bytewidth);
1317         font->ft_data = (ubyte *)SWAPINT((int)(font->ft_data));
1318         font->ft_chars = (ubyte **)SWAPINT((int)(font->ft_chars));
1319         font->ft_widths = (short *)SWAPINT((int)(font->ft_widths));
1320         font->ft_kerndata = (ubyte *)SWAPINT((int)(font->ft_kerndata));
1321 #endif
1322
1323         nchars = font->ft_maxchar-font->ft_minchar+1;
1324
1325         if (font->ft_flags & FT_PROPORTIONAL) {
1326
1327                 font->ft_widths = (short *) (((int) font->ft_widths) + ((ubyte *) font));
1328
1329 #ifdef MACINTOSH
1330                 for (i = 0; i < nchars; i++)
1331                         font->ft_widths[i] = SWAPSHORT(font->ft_widths[i]);
1332 #endif
1333
1334                 font->ft_data = ((int) font->ft_data) + ((ubyte *) font);
1335
1336                 font->ft_chars = (unsigned char **)d_malloc( nchars * sizeof(unsigned char *));
1337
1338                 ptr = font->ft_data;
1339
1340                 for (i=0; i< nchars; i++ ) {
1341                         font->ft_chars[i] = ptr;
1342                         if (font->ft_flags & FT_COLOR)
1343                                 ptr += font->ft_widths[i] * font->ft_h;
1344                         else
1345                                 ptr += BITS_TO_BYTES(font->ft_widths[i]) * font->ft_h;
1346                 }
1347
1348         } else  {
1349
1350                 font->ft_data = ((unsigned char *) font) + sizeof(*font);
1351
1352                 font->ft_chars  = NULL;
1353                 font->ft_widths = NULL;
1354
1355                 ptr = font->ft_data + (nchars * font->ft_w * font->ft_h);
1356         }
1357
1358         if (font->ft_flags & FT_KERNED)
1359                 font->ft_kerndata = ((int) font->ft_kerndata) + ((ubyte *) font);
1360
1361
1362         if (font->ft_flags & FT_COLOR) {                //remap palette
1363                 ubyte palette[256*3];
1364                 ubyte colormap[256];
1365                 int freq[256];
1366
1367                 cfread(palette,3,256,fontfile);         //read the palette
1368
1369 #ifdef MACINTOSH                        // swap the first and last palette entries (black and white)
1370                 {
1371                         int i;
1372                         ubyte c;
1373
1374                         for (i = 0; i < 3; i++) {
1375                                 c = palette[i];
1376                                 palette[i] = palette[765+i];
1377                                 palette[765+i] = c;
1378                         }
1379
1380 //  we also need to swap the data entries as well.  black is white and white is black
1381
1382                         for (i = 0; i < ptr-font->ft_data; i++) {
1383                                 if (font->ft_data[i] == 0)
1384                                         font->ft_data[i] = 255;
1385                                 else if (font->ft_data[i] == 255)
1386                                         font->ft_data[i] = 0;
1387                         }
1388
1389                 }
1390 #endif
1391
1392                 build_colormap_good( (ubyte *)&palette, colormap, freq );
1393
1394                 colormap[TRANSPARENCY_COLOR] = TRANSPARENCY_COLOR;              // chaged from colormap[255] = 255 to this for macintosh
1395
1396                 decode_data_asm(font->ft_data, ptr-font->ft_data, colormap, freq );
1397
1398         }
1399
1400         cfclose(fontfile);
1401
1402         //set curcanv vars
1403
1404         FONT        = font;
1405         FG_COLOR    = 0;
1406         BG_COLOR    = 0;
1407
1408         return font;
1409
1410 }
1411
1412 //remap a font by re-reading its data & palette
1413 void gr_remap_font( grs_font *font, char * fontname )
1414 {
1415         int i;
1416         int nchars;
1417         CFILE *fontfile;
1418         char file_id[4];
1419         int datasize;           //size up to (but not including) palette
1420         int data_ofs,data_len;
1421
1422         if (! (font->ft_flags & FT_COLOR))
1423                 return;
1424
1425         fontfile = cfopen(fontname, "rb");
1426
1427         if (!fontfile)
1428                 Error( "Can't open font file %s", fontname );
1429
1430         cfread( file_id, 1, 4, fontfile );
1431         datasize = cfile_read_int(fontfile);
1432
1433
1434         if ((file_id[0] != 'P') ||
1435             (file_id[1] != 'S') ||
1436             (file_id[2] != 'F') ||
1437             (file_id[3] != 'N'))
1438                 Error( "File %s is not a font file", fontname );
1439
1440         nchars = font->ft_maxchar-font->ft_minchar+1;
1441
1442         //compute data length
1443         data_len = 0;
1444         if (font->ft_flags & FT_PROPORTIONAL) {
1445
1446                 for (i=0; i< nchars; i++ ) {
1447                         if (font->ft_flags & FT_COLOR)
1448                                 data_len += font->ft_widths[i] * font->ft_h;
1449                         else
1450                                 data_len += BITS_TO_BYTES(font->ft_widths[i]) * font->ft_h;
1451                 }
1452
1453         } else
1454                 data_len = nchars * font->ft_w * font->ft_h;
1455
1456         data_ofs = font->ft_data - ((ubyte *) font);
1457
1458         cfseek(fontfile,data_ofs,SEEK_CUR);
1459         cfread(font->ft_data,1,data_len,fontfile);              //read raw data
1460
1461         if (font->ft_flags & FT_COLOR) {                //remap palette
1462                 ubyte palette[256*3];
1463                 ubyte colormap[256];
1464                 int freq[256];
1465
1466                 cfseek(fontfile,-sizeof(palette),SEEK_END);
1467
1468                 cfread(palette,3,256,fontfile);         //read the palette
1469
1470 #ifdef MACINTOSH                        // swap the first and last palette entries (black and white)
1471                 {
1472                         int i;
1473                         ubyte c;
1474
1475                         for (i = 0; i < 3; i++) {
1476                                 c = palette[i];
1477                                 palette[i] = palette[765+i];
1478                                 palette[765+i] = c;
1479                         }
1480
1481 //  we also need to swap the data entries as well.  black is white and white is black
1482
1483                         for (i = 0; i < data_len; i++) {
1484                                 if (font->ft_data[i] == 0)
1485                                         font->ft_data[i] = 255;
1486                                 else if (font->ft_data[i] == 255)
1487                                         font->ft_data[i] = 0;
1488                         }
1489
1490                 }
1491 #endif
1492
1493                 build_colormap_good( (ubyte *)&palette, colormap, freq );
1494
1495                 colormap[TRANSPARENCY_COLOR] = TRANSPARENCY_COLOR;      // changed from         colormap[255] = 255;
1496
1497                 decode_data_asm(font->ft_data, data_len, colormap, freq );
1498
1499
1500         }
1501
1502         cfclose(fontfile);
1503 }
1504
1505
1506 void gr_set_fontcolor( int fg, int bg )
1507 {
1508         FG_COLOR    = fg;
1509         BG_COLOR    = bg;
1510 }
1511
1512 void gr_set_curfont( grs_font * new )
1513 {
1514         FONT = new;
1515 }
1516
1517
1518 int gr_internal_string_clipped(int x, int y, char *s )
1519 {
1520         unsigned char * fp;
1521         char * text_ptr, * next_row, * text_ptr1;
1522         int r, BitMask, i, bits, width, spacing, letter, underline;
1523         int x1 = x, last_x;
1524
1525         bits=0;
1526
1527         next_row = s;
1528
1529         while (next_row != NULL )
1530         {
1531                 text_ptr1 = next_row;
1532                 next_row = NULL;
1533
1534                 x = x1;
1535                 if (x==0x8000)                  //centered
1536                         x = get_centered_x(text_ptr1);
1537
1538                 last_x = x;
1539
1540                 for (r=0; r<FHEIGHT; r++)       {
1541                         text_ptr = text_ptr1;
1542                         x = last_x;
1543
1544                         while (*text_ptr)       {
1545                                 if (*text_ptr == '\n' ) {
1546                                         next_row = &text_ptr[1];
1547                                         break;
1548                                 }
1549
1550                                 if (*text_ptr == CC_COLOR) {
1551                                         FG_COLOR = *(text_ptr+1);
1552                                         text_ptr += 2;
1553                                         continue;
1554                                 }
1555
1556                                 if (*text_ptr == CC_LSPACING) {
1557                                         Int3(); //      Warning: skip lines not supported for clipped strings.
1558                                         text_ptr += 2;
1559                                         continue;
1560                                 }
1561
1562                                 underline = 0;
1563                                 if (*text_ptr == CC_UNDERLINE ) {
1564                                         if ((r==FBASELINE+2) || (r==FBASELINE+3))
1565                                                 underline = 1;
1566                                         text_ptr++;
1567                                 }
1568
1569                                 get_char_width(text_ptr[0],text_ptr[1],&width,&spacing);
1570
1571                                 letter = *text_ptr-FMINCHAR;
1572
1573                                 if (!INFONT(letter)) {  //not in font, draw as space
1574                                         x += spacing;
1575                                         text_ptr++;
1576                                         continue;
1577                                 }
1578
1579                                 if (FFLAGS & FT_PROPORTIONAL)
1580                                         fp = FCHARS[letter];
1581                                 else
1582                                         fp = FDATA + letter * BITS_TO_BYTES(width)*FHEIGHT;
1583
1584                                 if (underline)  {
1585                                         for (i=0; i< width; i++ )       {
1586                                                 gr_setcolor(FG_COLOR);
1587                                                 gr_pixel( x++, y );
1588                                         }
1589                                 } else {
1590                                         fp += BITS_TO_BYTES(width)*r;
1591
1592                                         BitMask = 0;
1593
1594                                         for (i=0; i< width; i++ )       {
1595                                                 if (BitMask==0) {
1596                                                         bits = *fp++;
1597                                                         BitMask = 0x80;
1598                                                 }
1599                                                 if (bits & BitMask)
1600                                                         gr_setcolor(FG_COLOR);
1601                                                 else
1602                                                         gr_setcolor(BG_COLOR);
1603                                                 gr_pixel( x++, y );
1604                                                 BitMask >>= 1;
1605                                         }
1606                                 }
1607
1608                                 x += spacing-width;             //for kerning
1609
1610                                 text_ptr++;
1611                         }
1612                         y++;
1613                 }
1614         }
1615         return 0;
1616 }
1617
1618 int gr_internal_string_clipped_m(int x, int y, char *s )
1619 {
1620         unsigned char * fp;
1621         char * text_ptr, * next_row, * text_ptr1;
1622         int r, BitMask, i, bits, width, spacing, letter, underline;
1623         int x1 = x, last_x;
1624
1625         bits=0;
1626
1627         next_row = s;
1628
1629         while (next_row != NULL )
1630         {
1631                 text_ptr1 = next_row;
1632                 next_row = NULL;
1633
1634                 x = x1;
1635                 if (x==0x8000)                  //centered
1636                         x = get_centered_x(text_ptr1);
1637
1638                 last_x = x;
1639
1640                 for (r=0; r<FHEIGHT; r++)       {
1641                         x = last_x;
1642
1643                         text_ptr = text_ptr1;
1644
1645                         while (*text_ptr)       {
1646                                 if (*text_ptr == '\n' ) {
1647                                         next_row = &text_ptr[1];
1648                                         break;
1649                                 }
1650
1651                                 if (*text_ptr == CC_COLOR) {
1652                                         FG_COLOR = *(text_ptr+1);
1653                                         text_ptr += 2;
1654                                         continue;
1655                                 }
1656
1657                                 if (*text_ptr == CC_LSPACING) {
1658                                         Int3(); //      Warning: skip lines not supported for clipped strings.
1659                                         text_ptr += 2;
1660                                         continue;
1661                                 }
1662
1663                                 underline = 0;
1664                                 if (*text_ptr == CC_UNDERLINE ) {
1665                                         if ((r==FBASELINE+2) || (r==FBASELINE+3))
1666                                                 underline = 1;
1667                                         text_ptr++;
1668                                 }
1669
1670                                 get_char_width(text_ptr[0],text_ptr[1],&width,&spacing);
1671
1672                                 letter = *text_ptr-FMINCHAR;
1673
1674                                 if (!INFONT(letter)) {  //not in font, draw as space
1675                                         x += spacing;
1676                                         text_ptr++;
1677                                         continue;
1678                                 }
1679
1680                                 if (FFLAGS & FT_PROPORTIONAL)
1681                                         fp = FCHARS[letter];
1682                                 else
1683                                         fp = FDATA + letter * BITS_TO_BYTES(width)*FHEIGHT;
1684
1685                                 if (underline)  {
1686                                         for (i=0; i< width; i++ )       {
1687                                                 gr_setcolor(FG_COLOR);
1688                                                 gr_pixel( x++, y );
1689                                         }
1690                                 } else {
1691                                         fp += BITS_TO_BYTES(width)*r;
1692
1693                                         BitMask = 0;
1694
1695                                         for (i=0; i< width; i++ )       {
1696                                                 if (BitMask==0) {
1697                                                         bits = *fp++;
1698                                                         BitMask = 0x80;
1699                                                 }
1700                                                 if (bits & BitMask)     {
1701                                                         gr_setcolor(FG_COLOR);
1702                                                         gr_pixel( x++, y );
1703                                                 } else {
1704                                                         x++;
1705                                                 }
1706                                                 BitMask >>= 1;
1707                                         }
1708                                 }
1709
1710                                 x += spacing-width;             //for kerning
1711
1712                                 text_ptr++;
1713                         }
1714                         y++;
1715                 }
1716         }
1717         return 0;
1718 }