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