rom/graphics/text.c

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