rom/graphics/text.c

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