rom/graphics/text.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$        $Log
   4
   5     Desc: Graphics function Text()
   6     Lang: english
   7 */
   8 #include "graphics_intern.h"
   9 #include <graphics/rastport.h>
  10 #include <string.h>
  11 #include <proto/cybergraphics.h>
  12 #include <aros/macros.h>
  13 #include <aros/debug.h>
  14
  15 #include "gfxfuncsupport.h"
  16
  17 void BltTemplateBasedText(struct RastPort *rp, CONST_STRPTR text, ULONG len,
  18                           struct GfxBase *GfxBase);
  19
  20 void BltTemplateAlphaBasedText(struct RastPort *rp, CONST_STRPTR text, ULONG len,
  21                                struct GfxBase *GfxBase);
  22
  23 void ColorFontBasedText(struct RastPort *rp, CONST_STRPTR text, ULONG len,
  24                         struct GfxBase *GfxBase);
  25
  26 /*****************************************************************************
  27
  28     NAME */
  29 #include <graphics/rastport.h>
  30 #include <proto/graphics.h>
  31
  32         AROS_LH3(void, Text,
  33
  34 /*  SYNOPSIS */
  35         AROS_LHA(struct RastPort *, rp, A1),
  36         AROS_LHA(CONST_STRPTR     , string, A0),
  37         AROS_LHA(ULONG            , count, D0),
  38
  39 /*  LOCATION */
  40         struct GfxBase *, GfxBase, 10, Graphics)
  41
  42 /*  FUNCTION
  43         Write text to the rastport at the current position.
  44         The current position is updated to a position after the text.
  45
  46     INPUTS
  47         rp     - RastPort
  48         string - string to print
  49         count  - number of characters to print
  50
  51     RESULT
  52
  53     NOTES
  54
  55     EXAMPLE
  56
  57     BUGS
  58
  59     SEE ALSO
  60
  61     INTERNALS
  62
  63     HISTORY
  64         29-10-95    digulla automatically created from
  65                             graphics_lib.fd and clib/graphics_protos.h
  66
  67 *****************************************************************************/
  68 {
  69     AROS_LIBFUNC_INIT
  70
  71     if (count)
  72     {
  73         struct ColorTextFont *ctf = (struct ColorTextFont *)rp->Font;
  74         BOOL                  antialias;
  75         BOOL                  colorfont;
  76
  77         antialias = (ctf->ctf_TF.tf_Style & FSF_COLORFONT) &&
  78                     ((ctf->ctf_Flags & CT_COLORMASK) == CT_ANTIALIAS) &&
  79                     (GetBitMapAttr(rp->BitMap, BMA_DEPTH) >= 15);
  80
  81         colorfont = (ctf->ctf_TF.tf_Style & FSF_COLORFONT) &&
  82                     (((ctf->ctf_Flags & CT_COLORMASK) == CT_COLORFONT) || ((ctf->ctf_Flags & CT_COLORMASK) == CT_GREYFONT));
  83
  84         if (antialias)
  85         {
  86             BltTemplateAlphaBasedText(rp, string, count, GfxBase);
  87         }
  88         else if (colorfont)
  89         {
  90             ColorFontBasedText(rp, string, count, GfxBase);
  91         }
  92         else
  93         {
  94             BltTemplateBasedText(rp, string, count, GfxBase);
  95         }
  96     }
  97
  98     AROS_LIBFUNC_EXIT
  99
 100 } /* Text */
 101
 102 /***************************************************************************/
 103
 104 void BltTemplateBasedText(struct RastPort *rp, CONST_STRPTR text, ULONG len,
 105                           struct GfxBase *GfxBase)
 106 {
 107     struct TextExtent    te;
 108     struct TextFont     *tf;
 109     WORD                 raswidth, raswidth16, raswidth_bpr, rasheight, x, y, gx;
 110     UBYTE               *raster;
 111     BOOL                 is_bold, is_italic;
 112
 113     TextExtent(rp, text, len, &te);
 114
 115     raswidth  = te.te_Extent.MaxX - te.te_Extent.MinX + 1;
 116     rasheight = te.te_Extent.MaxY - te.te_Extent.MinY + 1;
 117
 118     raswidth16 = (raswidth + 15) & ~15;
 119     raswidth_bpr = raswidth16 / 8;
 120
 121     if ((raster = AllocRaster(raswidth, rasheight)))
 122     {
 123         memset(raster, 0, RASSIZE(raswidth, rasheight));
 124
 125         tf = rp->Font;
 126
 127         x = -te.te_Extent.MinX;
 128
 129         is_bold   = (rp->AlgoStyle & FSF_BOLD) != 0;
 130         is_italic = (rp->AlgoStyle & FSF_ITALIC) != 0;
 131
 132         while(len--)
 133         {
 134             UBYTE c = *text++;
 135             ULONG idx;
 136             ULONG charloc;
 137             UWORD glyphwidth, glyphpos, bold;
 138             UBYTE *glyphdata;
 139             UBYTE *dst;
 140             ULONG srcmask;
 141             ULONG dstmask;
 142
 143             if (c < tf->tf_LoChar || c > tf->tf_HiChar)
 144             {
 145                 idx = NUMCHARS(tf) - 1;
 146             }
 147             else
 148             {
 149                 idx = c - tf->tf_LoChar;
 150             }
 151
 152             charloc = ((ULONG *)tf->tf_CharLoc)[idx];
 153
 154             glyphwidth = charloc & 0xFFFF;
 155             glyphpos = charloc >> 16;
 156
 157             if (tf->tf_CharKern)
 158             {
 159                 x += ((WORD *)tf->tf_CharKern)[idx];
 160             }
 161
 162
 163             for(bold = 0; bold <= is_bold; bold++)
 164             {
 165                 WORD wx;
 166                 WORD italicshift, italiccheck = 0;
 167
 168                 if (is_italic)
 169                 {
 170                     italiccheck = tf->tf_Baseline;
 171                     italicshift = italiccheck / 2;
 172                 }
 173                 else
 174                 {
 175                     italicshift = 0;
 176                 }
 177
 178                 wx = x + italicshift + (bold ? tf->tf_BoldSmear : 0);
 179
 180                 glyphdata = ((UBYTE *)tf->tf_CharData) + glyphpos / 8;
 181                 dst = raster + wx / 8;
 182
 183                 for(y = 0; y < rasheight; y++)
 184                 {
 185                     UBYTE *glyphdatax = glyphdata;
 186                     UBYTE *dstx = dst;
 187                     UBYTE srcdata;
 188
 189                     srcmask = 0x80 >> (glyphpos & 7);
 190                     dstmask = 0x80 >> (wx & 7);
 191
 192                     srcdata = *glyphdatax;
 193
 194                     for(gx = 0; gx < glyphwidth; gx++)
 195                     {
 196                         if (srcdata & srcmask)
 197                         {
 198                             *dstx |= dstmask;
 199                         }
 200
 201                         if (dstmask == 0x1)
 202                         {
 203                             dstmask = 0x80;
 204                             dstx++;
 205                         }
 206                         else
 207                         {
 208                             dstmask >>= 1;
 209                         }
 210
 211                         if (srcmask == 0x1)
 212                         {
 213                             srcmask = 0x80;
 214                             glyphdatax++;
 215                             srcdata =*glyphdatax;
 216                         }
 217                         else
 218                         {
 219                             srcmask >>= 1;
 220                         }
 221
 222                     } /* for(gx = 0; gx < glyphwidth; gx++) */
 223
 224                     glyphdata += tf->tf_Modulo;
 225                     dst += raswidth_bpr;
 226
 227                     if (is_italic)
 228                     {
 229                         italiccheck--;
 230                         if (italiccheck & 1)
 231                         {
 232                             italicshift--;
 233
 234                             wx--;
 235                             if ((wx & 7) == 7) dst--;
 236
 237                         }
 238                     }
 239
 240                 } /* for(y = 0; y < rasheight; y++) */
 241
 242             } /* for(bold = 0; bold < ((rp->AlgoStyle & FSF_BOLD) ? 2 : 1); bold++) */
 243
 244             if (tf->tf_CharSpace)
 245             {
 246                 x += ((WORD *)tf->tf_CharSpace)[idx];
 247             }
 248             else
 249             {
 250                 x += tf->tf_XSize;
 251             }
 252
 253             x += rp->TxSpacing;
 254
 255         } /* while(len--) */
 256
 257         if (rp->AlgoStyle & FSF_UNDERLINED)
 258         {
 259             UBYTE *dst;
 260             ULONG prev_word, act_word = 0, next_word, word;
 261             WORD count;
 262             LONG underline;
 263
 264             underline = rp->TxBaseline + 1;
 265             if (underline < rasheight - 1) underline++;
 266
 267             if (underline < rasheight)
 268             {
 269                 dst = raster + underline * (LONG)raswidth_bpr;
 270                 next_word = *(UWORD *)dst;
 271             #if !AROS_BIG_ENDIAN
 272                 next_word = AROS_WORD2BE(next_word);
 273             #endif
 274                 count  = raswidth16 / 16;
 275
 276                 while(count--)
 277                 {
 278                     prev_word = act_word;
 279                     act_word = next_word;
 280                     if (count > 1)
 281                     {
 282                         next_word = ((UWORD *)dst)[1];
 283
 284                     #if !AROS_BIG_ENDIAN
 285                         next_word = AROS_WORD2BE(next_word);
 286                     #endif
 287                     }
 288                     else
 289                     {
 290                         next_word = 0;
 291                     }
 292                     word = ((act_word << 1) & 0xFFFF) + (next_word >> 15);
 293                     word |= (act_word >> 1) + ((prev_word << 15) & 0xFFFF);
 294                     word &= ~act_word;
 295
 296                     word = 0xFFFF &~ word;
 297             #if !AROS_BIG_ENDIAN
 298                     word = AROS_BE2WORD(word);
 299             #endif
 300
 301                     *(UWORD *)dst = word;
 302                     dst += 2;
 303
 304                 } /* while(count--) */
 305
 306             } /* if (underline < rasheight) */
 307
 308         } /* if (rp->AlgoStyle & FSF_UNDERLINED) */
 309
 310         BltTemplate(raster,
 311                     0,
 312                     raswidth_bpr,
 313                     rp,
 314                     rp->cp_x + te.te_Extent.MinX,
 315                     rp->cp_y - rp->TxBaseline,
 316                     raswidth,
 317                     rasheight);
 318
 319         FreeRaster(raster, raswidth, rasheight);
 320
 321     } /* if ((raster = AllocRaster(raswidth, rasheight))) */
 322
 323     Move(rp, rp->cp_x + te.te_Width, rp->cp_y);
 324
 325 }
 326
 327 /***************************************************************************/
 328
 329 void BltTemplateAlphaBasedText(struct RastPort *rp, CONST_STRPTR text, ULONG len,
 330                                struct GfxBase *GfxBase)
 331 {
 332     struct TextExtent    te;
 333     struct TextFont     *tf;
 334     WORD                 raswidth, raswidth_bpr, rasheight, x, y, gx;
 335     UBYTE               *raster;
 336     BOOL                 is_bold, is_italic;
 337
 338     /* CyberGfxBase is placed inside GfxBase, so it's static */
 339     if (!CyberGfxBase)
 340         CyberGfxBase = OpenLibrary("cybergraphics.library", 0);
 341     if (!CyberGfxBase)
 342         return;
 343
 344     TextExtent(rp, text, len, &te);
 345
 346     raswidth  = te.te_Extent.MaxX - te.te_Extent.MinX + 1;
 347     rasheight = te.te_Extent.MaxY - te.te_Extent.MinY + 1;
 348
 349     raswidth_bpr = raswidth;
 350
 351     if ((raster = AllocVec(raswidth * rasheight, MEMF_CLEAR)))
 352     {
 353         tf = rp->Font;
 354
 355         x = -te.te_Extent.MinX;
 356
 357         is_bold   = (rp->AlgoStyle & FSF_BOLD) != 0;
 358         is_italic = (rp->AlgoStyle & FSF_ITALIC) != 0;
 359
 360         while(len--)
 361         {
 362             UBYTE c = *text++;
 363             ULONG idx;
 364             ULONG charloc;
 365             UWORD glyphwidth, glyphpos, bold;
 366             UBYTE *glyphdata;
 367             UBYTE *dst;
 368
 369             if (c < tf->tf_LoChar || c > tf->tf_HiChar)
 370             {
 371                 idx = NUMCHARS(tf) - 1;
 372             }
 373             else
 374             {
 375                 idx = c - tf->tf_LoChar;
 376             }
 377
 378             charloc = ((ULONG *)tf->tf_CharLoc)[idx];
 379
 380             glyphwidth = charloc & 0xFFFF;
 381             glyphpos = charloc >> 16;
 382
 383             if (tf->tf_CharKern)
 384             {
 385                 x += ((WORD *)tf->tf_CharKern)[idx];
 386             }
 387
 388
 389             for(bold = 0; bold <= is_bold; bold++)
 390             {
 391                 WORD wx;
 392                 WORD italicshift, italiccheck = 0;
 393
 394                 if (is_italic)
 395                 {
 396                     italiccheck = tf->tf_Baseline;
 397                     italicshift = italiccheck / 2;
 398                 }
 399                 else
 400                 {
 401                     italicshift = 0;
 402                 }
 403
 404                 wx = x + italicshift + (bold ? tf->tf_BoldSmear : 0);
 405
 406                 glyphdata = ((UBYTE *)((struct ColorTextFont *)tf)->ctf_CharData[0]) + glyphpos;
 407                 dst = raster + wx;
 408
 409                 for(y = 0; y < rasheight; y++)
 410                 {
 411                     UBYTE *glyphdatax = glyphdata;
 412                     UBYTE *dstx = dst;
 413
 414                     for(gx = 0; gx < glyphwidth; gx++)
 415                     {
 416                         UWORD old = *dstx;
 417
 418                         old += *glyphdatax++;
 419                         if (old > 255) old = 255;
 420                         *dstx++ = old;
 421                     }
 422
 423                     glyphdata += tf->tf_Modulo * 8;
 424                     dst += raswidth_bpr;
 425
 426                     if (is_italic)
 427                     {
 428                         italiccheck--;
 429                         if (italiccheck & 1)
 430                         {
 431                             italicshift--;
 432                             dst--;
 433                         }
 434                     }
 435
 436                 } /* for(y = 0; y < rasheight; y++) */
 437
 438             } /* for(bold = 0; bold < ((rp->AlgoStyle & FSF_BOLD) ? 2 : 1); bold++) */
 439
 440             if (tf->tf_CharSpace)
 441             {
 442                 x += ((WORD *)tf->tf_CharSpace)[idx];
 443             }
 444             else
 445             {
 446                 x += tf->tf_XSize;
 447             }
 448
 449             x += rp->TxSpacing;
 450
 451         } /* while(len--) */
 452
 453         if (rp->AlgoStyle & FSF_UNDERLINED)
 454         {
 455             UBYTE *dst;
 456             UBYTE prev_byte, act_byte = 0, next_byte;
 457             WORD count;
 458             LONG underline;
 459
 460             underline = rp->TxBaseline + 1;
 461             if (underline < rasheight - 1) underline++;
 462
 463             if (underline < rasheight)
 464             {
 465                 dst = raster + underline * (LONG)raswidth_bpr;
 466                 count  = raswidth;
 467
 468                 next_byte = *dst;
 469
 470                 while(count--)
 471                 {
 472                     prev_byte = act_byte;
 473                     act_byte = next_byte;
 474                     if (count > 1)
 475                     {
 476                         next_byte = dst[1];
 477                     }
 478                     else
 479                     {
 480                         next_byte = 0;
 481                     }
 482
 483                     *dst++ = (act_byte || (!prev_byte && !next_byte)) ? 255 : 0;
 484
 485                 } /* while(count--) */
 486
 487             } /* if (underline < rasheight) */
 488
 489         } /* if (rp->AlgoStyle & FSF_UNDERLINED) */
 490
 491         BltTemplateAlpha(raster,
 492                          0,
 493                          raswidth_bpr,
 494                          rp,
 495                          rp->cp_x + te.te_Extent.MinX,
 496                          rp->cp_y - rp->TxBaseline,
 497                          raswidth,
 498                          rasheight);
 499
 500         FreeVec(raster);
 501
 502     } /* if ((raster = AllocVec(raswidth * rasheight, MEMF_CLEAR))) */
 503
 504     Move(rp, rp->cp_x + te.te_Width, rp->cp_y);
 505
 506 }
 507
 508 /***************************************************************************/
 509
 510 void ColorFontBasedText(struct RastPort *rp, CONST_STRPTR text, ULONG len,
 511                         struct GfxBase *GfxBase)
 512 {
 513     struct TextExtent    te;
 514     struct TextFont     *tf;
 515     WORD                 raswidth, raswidth_bpr, rasheight, x, y, gx;
 516     UBYTE               *raster, *chunky;
 517     BOOL                 is_bold, is_italic;
 518
 519     tf = rp->Font;
 520     if (!ExtendFont(tf, NULL)) return;
 521
 522     chunky = ((struct TextFontExtension_intern *)(tf->tf_Extension))->hash->chunky_colorfont;
 523
 524     TextExtent(rp, text, len, &te);
 525
 526     if ((rp->DrawMode & ~INVERSVID) == JAM2)
 527     {
 528         ULONG             old_drmd = GetDrMd(rp);
 529
 530         SetDrMd(rp, old_drmd ^ INVERSVID);
 531         RectFill(rp, rp->cp_x + te.te_Extent.MinX,
 532                      rp->cp_y + te.te_Extent.MinY,
 533                      rp->cp_x + te.te_Extent.MaxX,
 534                      rp->cp_y + te.te_Extent.MaxY);
 535         SetDrMd(rp, old_drmd);
 536     }
 537
 538
 539     raswidth  = te.te_Extent.MaxX - te.te_Extent.MinX + 1;
 540     rasheight = te.te_Extent.MaxY - te.te_Extent.MinY + 1;
 541
 542     raswidth_bpr = raswidth;
 543
 544     if ((raster = AllocVec(raswidth * rasheight, MEMF_CLEAR)))
 545     {
 546         x = -te.te_Extent.MinX;
 547
 548         is_bold   = (rp->AlgoStyle & FSF_BOLD) != 0;
 549         is_italic = (rp->AlgoStyle & FSF_ITALIC) != 0;
 550
 551         while(len--)
 552         {
 553             UBYTE c = *text++;
 554             ULONG idx;
 555             ULONG charloc;
 556             UWORD glyphwidth, glyphpos, bold;
 557             UBYTE *glyphdata;
 558             UBYTE *dst;
 559
 560             if (c < tf->tf_LoChar || c > tf->tf_HiChar)
 561             {
 562                 idx = NUMCHARS(tf) - 1;
 563             }
 564             else
 565             {
 566                 idx = c - tf->tf_LoChar;
 567             }
 568
 569             charloc = ((ULONG *)tf->tf_CharLoc)[idx];
 570
 571             glyphwidth = charloc & 0xFFFF;
 572             glyphpos = charloc >> 16;
 573
 574             if (tf->tf_CharKern)
 575             {
 576                 x += ((WORD *)tf->tf_CharKern)[idx];
 577             }
 578
 579
 580             for(bold = 0; bold <= is_bold; bold++)
 581             {
 582                 WORD wx;
 583                 WORD italicshift, italiccheck = 0;
 584
 585                 if (is_italic)
 586                 {
 587                     italiccheck = tf->tf_Baseline;
 588                     italicshift = italiccheck / 2;
 589                 }
 590                 else
 591                 {
 592                     italicshift = 0;
 593                 }
 594
 595                 wx = x + italicshift + (bold ? tf->tf_BoldSmear : 0);
 596
 597                 glyphdata = chunky + glyphpos;
 598                 dst = raster + wx;
 599
 600                 for(y = 0; y < rasheight; y++)
 601                 {
 602                     UBYTE *glyphdatax = glyphdata;
 603                     UBYTE *dstx = dst;
 604
 605                     for(gx = 0; gx < glyphwidth; gx++)
 606                     {
 607                         UBYTE p = *glyphdatax++;
 608
 609                         if (p || !bold) *dstx = p;
 610
 611                         dstx++;
 612                     }
 613
 614                     glyphdata += tf->tf_Modulo * 8;
 615                     dst += raswidth_bpr;
 616
 617                     if (is_italic)
 618                     {
 619                         italiccheck--;
 620                         if (italiccheck & 1)
 621                         {
 622                             italicshift--;
 623                             dst--;
 624                         }
 625                     }
 626
 627                 } /* for(y = 0; y < rasheight; y++) */
 628
 629             } /* for(bold = 0; bold < ((rp->AlgoStyle & FSF_BOLD) ? 2 : 1); bold++) */
 630
 631             if (tf->tf_CharSpace)
 632             {
 633                 x += ((WORD *)tf->tf_CharSpace)[idx];
 634             }
 635             else
 636             {
 637                 x += tf->tf_XSize;
 638             }
 639
 640             x += rp->TxSpacing;
 641
 642         } /* while(len--) */
 643
 644 #if 0
 645         if (rp->AlgoStyle & FSF_UNDERLINED)
 646         {
 647             UBYTE *dst;
 648             UBYTE prev_byte, act_byte = 0, next_byte;
 649             WORD count;
 650             LONG underline;
 651
 652             underline = rp->TxBaseline + 1;
 653             if (underline < rasheight - 1) underline++;
 654
 655             if (underline < rasheight)
 656             {
 657                 dst = raster + underline * (LONG)raswidth_bpr;
 658                 count  = raswidth;
 659
 660                 next_byte = *dst;
 661
 662                 while(count--)
 663                 {
 664                     prev_byte = act_byte;
 665                     act_byte = next_byte;
 666                     if (count > 1)
 667                     {
 668                         next_byte = dst[1];
 669                     }
 670                     else
 671                     {
 672                         next_byte = 0;
 673                     }
 674
 675                     *dst++ = (act_byte || (!prev_byte && !next_byte)) ? 255 : 0;
 676
 677                 } /* while(count--) */
 678
 679             } /* if (underline < rasheight) */
 680
 681         } /* if (rp->AlgoStyle & FSF_UNDERLINED) */
 682
 683 #endif
 684
 685         {
 686             HIDDT_PixelLUT  pixlut;
 687             HIDDT_Pixel     pixtab[256];
 688
 689             pixlut.entries = AROS_PALETTE_SIZE;
 690             pixlut.pixels  = IS_HIDD_BM(rp->BitMap) ? HIDD_BM_PIXTAB(rp->BitMap) : NULL;
 691
 692             if ((rp->Flags & RPF_REMAP_COLORFONTS) &&
 693                 (CTF(tf)->ctf_ColorFontColors) &&
 694                 ((CTF(tf)->ctf_Flags & CT_COLORMASK) != CT_GREYFONT) && /* <-- FIX/CHECK/SUPPORT CT_GREYFONT) */
 695                 IS_HIDD_BM(rp->BitMap) &&
 696                 (GetBitMapAttr(rp->BitMap, BMA_DEPTH) > 8))
 697             {
 698                 UWORD *colortable = CTF(tf)->ctf_ColorFontColors->cfc_ColorTable;
 699                 WORD   i;
 700
 701                 for(i = 0; i < CTF(tf)->ctf_ColorFontColors->cfc_Count; i++)
 702                 {
 703                     UWORD rgb12 = *colortable++;
 704                     HIDDT_Color col;
 705
 706                     col.red   = ((rgb12 >> 8) & 0x0F) * 0x1111;
 707                     col.green = ((rgb12 >> 4) & 0x0F) * 0x1111;
 708                     col.blue  = ((rgb12 >> 0) & 0x0F) * 0x1111;
 709
 710                     pixtab[i] = HIDD_BM_MapColor(HIDD_BM_OBJ(rp->BitMap), &col);
 711                 }
 712
 713                 pixlut.pixels = pixtab;
 714             }
 715
 716             write_transp_pixels_8(rp, raster,raswidth_bpr,
 717                                   rp->cp_x + te.te_Extent.MinX,
 718                                   rp->cp_y - rp->TxBaseline,
 719                                   rp->cp_x + te.te_Extent.MinX + raswidth - 1,
 720                                   rp->cp_y - rp->TxBaseline + rasheight - 1,
 721                                   &pixlut, 0, TRUE, GfxBase);
 722
 723         }
 724
 725         FreeVec(raster);
 726
 727     } /* if ((raster = AllocVec(raswidth * rasheight, MEMF_CLEAR))) */
 728
 729     Move(rp, rp->cp_x + te.te_Width, rp->cp_y);
 730
 731 }
 732