git.sesse.net Git - rdpsrv/blob - Xserver/programs/Xserver/cfb/cfbpntwin.c

   1 /* $XConsortium: cfbpntwin.c,v 5.18 94/04/17 20:28:57 dpw Exp $ */
   2 /* $XFree86: xc/programs/Xserver/cfb/cfbpntwin.c,v 3.0 1996/06/29 09:05:45 dawes Exp $ */
   3 /***********************************************************
   4
   5 Copyright (c) 1987  X Consortium
   6
   7 Permission is hereby granted, free of charge, to any person obtaining a copy
   8 of this software and associated documentation files (the "Software"), to deal
   9 in the Software without restriction, including without limitation the rights
  10 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11 copies of the Software, and to permit persons to whom the Software is
  12 furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice shall be included in
  15 all copies or substantial portions of the Software.
  16
  17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  20 X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23
  24 Except as contained in this notice, the name of the X Consortium shall not be
  25 used in advertising or otherwise to promote the sale, use or other dealings
  26 in this Software without prior written authorization from the X Consortium.
  27
  28
  29 Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
  30
  31                         All Rights Reserved
  32
  33 Permission to use, copy, modify, and distribute this software and its
  34 documentation for any purpose and without fee is hereby granted,
  35 provided that the above copyright notice appear in all copies and that
  36 both that copyright notice and this permission notice appear in
  37 supporting documentation, and that the name of Digital not be
  38 used in advertising or publicity pertaining to distribution of the
  39 software without specific, written prior permission.
  40
  41 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  42 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  43 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  44 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  45 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  46 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  47 SOFTWARE.
  48
  49 ******************************************************************/
  50
  51 #include "X.h"
  52
  53 #include "windowstr.h"
  54 #include "regionstr.h"
  55 #include "pixmapstr.h"
  56 #include "scrnintstr.h"
  57
  58 #include "cfb.h"
  59 #include "cfbmskbits.h"
  60 #include "mi.h"
  61
  62 void
  63 cfbPaintWindow(pWin, pRegion, what)
  64     WindowPtr   pWin;
  65     RegionPtr   pRegion;
  66     int         what;
  67 {
  68     register cfbPrivWin *pPrivWin;
  69     WindowPtr   pBgWin;
  70
  71     pPrivWin = cfbGetWindowPrivate(pWin);
  72
  73     switch (what) {
  74     case PW_BACKGROUND:
  75         switch (pWin->backgroundState) {
  76         case None:
  77             break;
  78         case ParentRelative:
  79             do {
  80                 pWin = pWin->parent;
  81             } while (pWin->backgroundState == ParentRelative);
  82             (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion,
  83                                                              what);
  84             break;
  85         case BackgroundPixmap:
  86             if (pPrivWin->fastBackground)
  87             {
  88                 cfbFillBoxTile32 ((DrawablePtr)pWin,
  89                                   (int)REGION_NUM_RECTS(pRegion),
  90                                   REGION_RECTS(pRegion),
  91                                   pPrivWin->pRotatedBackground);
  92             }
  93             else
  94             {
  95                 cfbFillBoxTileOdd ((DrawablePtr)pWin,
  96                                    (int)REGION_NUM_RECTS(pRegion),
  97                                    REGION_RECTS(pRegion),
  98                                    pWin->background.pixmap,
  99                                    (int) pWin->drawable.x, (int) pWin->drawable.y);
 100             }
 101             break;
 102         case BackgroundPixel:
 103             cfbFillBoxSolid ((DrawablePtr)pWin,
 104                              (int)REGION_NUM_RECTS(pRegion),
 105                              REGION_RECTS(pRegion),
 106                              pWin->background.pixel);
 107             break;
 108         }
 109         break;
 110     case PW_BORDER:
 111         if (pWin->borderIsPixel)
 112         {
 113             cfbFillBoxSolid ((DrawablePtr)pWin,
 114                              (int)REGION_NUM_RECTS(pRegion),
 115                              REGION_RECTS(pRegion),
 116                              pWin->border.pixel);
 117         }
 118         else if (pPrivWin->fastBorder)
 119         {
 120             cfbFillBoxTile32 ((DrawablePtr)pWin,
 121                               (int)REGION_NUM_RECTS(pRegion),
 122                               REGION_RECTS(pRegion),
 123                               pPrivWin->pRotatedBorder);
 124         }
 125         else
 126         {
 127             for (pBgWin = pWin;
 128                  pBgWin->backgroundState == ParentRelative;
 129                  pBgWin = pBgWin->parent);
 130
 131             cfbFillBoxTileOdd ((DrawablePtr)pWin,
 132                                (int)REGION_NUM_RECTS(pRegion),
 133                                REGION_RECTS(pRegion),
 134                                pWin->border.pixmap,
 135                                (int) pBgWin->drawable.x,
 136                                (int) pBgWin->drawable.y);
 137         }
 138         break;
 139     }
 140 }
 141
 142 /*
 143  * Use the RROP macros in copy mode
 144  */
 145
 146 #define RROP GXcopy
 147 #include "cfbrrop.h"
 148
 149 #ifdef RROP_UNROLL
 150 # define Expand(left,right,leftAdjust) {\
 151     int part = nmiddle & RROP_UNROLL_MASK; \
 152     int widthStep; \
 153     widthStep = widthDst - nmiddle - leftAdjust; \
 154     nmiddle >>= RROP_UNROLL_SHIFT; \
 155     while (h--) { \
 156         left \
 157         pdst += part; \
 158         switch (part) { \
 159             RROP_UNROLL_CASE(pdst) \
 160         } \
 161         m = nmiddle; \
 162         while (m) { \
 163             pdst += RROP_UNROLL; \
 164             RROP_UNROLL_LOOP(pdst) \
 165             m--; \
 166         } \
 167         right \
 168         pdst += widthStep; \
 169     } \
 170 }
 171
 172 #else
 173 # define Expand(left, right, leftAdjust) { \
 174     int widthStep; \
 175     widthStep = widthDst - nmiddle - leftAdjust; \
 176     while (h--) { \
 177         left \
 178         m = nmiddle; \
 179         while (m--) {\
 180             RROP_SOLID(pdst); \
 181             pdst++; \
 182         } \
 183         right \
 184         pdst += widthStep; \
 185     } \
 186 }
 187 #endif
 188
 189 void
 190 cfbFillBoxSolid (pDrawable, nBox, pBox, pixel)
 191     DrawablePtr     pDrawable;
 192     int             nBox;
 193     BoxPtr          pBox;
 194     unsigned long   pixel;
 195 {
 196     unsigned long   *pdstBase;
 197     int             widthDst;
 198     register int    h;
 199     register unsigned long   rrop_xor;
 200     register unsigned long   *pdst;
 201     register unsigned long   leftMask, rightMask;
 202     int             nmiddle;
 203     register int    m;
 204     int             w;
 205 #if PSZ == 24
 206     int leftIndex, rightIndex;
 207     unsigned long piQxelArray[3], xOffset, *pdstULC; /*upper left corner*/
 208
 209     piQxelArray[0] = (pixel&0xFFFFFF) | ((pixel&0xFF)<<24);
 210     piQxelArray[1] = ((pixel&0xFFFF00)>>8) | ((pixel&0xFFFF)<<16);
 211     piQxelArray[2] = ((pixel&0xFFFFFF)<<8) | ((pixel&0xFF0000)>>16);
 212 #endif
 213
 214     cfbGetLongWidthAndPointer(pDrawable, widthDst, pdstBase);
 215
 216     rrop_xor = PFILL(pixel);
 217     for (; nBox; nBox--, pBox++)
 218     {
 219         pdst = pdstBase + pBox->y1 * widthDst;
 220         h = pBox->y2 - pBox->y1;
 221         w = pBox->x2 - pBox->x1;
 222 #if PSZ == 8
 223         if (w == 1)
 224         {
 225             register char    *pdstb = ((char *) pdst) + pBox->x1;
 226             int     incr = widthDst * PGSZB;
 227
 228             while (h--)
 229             {
 230                 *pdstb = rrop_xor;
 231                 pdstb += incr;
 232             }
 233         }
 234         else
 235         {
 236 #endif
 237 #if PSZ == 24
 238 /* _Box has x1, y1, x2, y2*/
 239           leftIndex = pBox->x1 & 3;
 240           rightIndex = ((leftIndex+w)<5)?0:(pBox->x2 &3);
 241           nmiddle = w - rightIndex;
 242           if(leftIndex){
 243               nmiddle -= (4 - leftIndex);
 244           }
 245           nmiddle >>= 2;
 246           if(nmiddle < 0)
 247             nmiddle = 0;
 248
 249           pdst = pdstBase + pBox->y1 * widthDst + ((pBox->x1*3) >> 2);
 250
 251           switch(leftIndex+w){
 252           case 4:
 253             switch(leftIndex){
 254             case 0:
 255               while(h--){
 256                 *pdst++ = piQxelArray[0];
 257                 *pdst++ = piQxelArray[1];
 258                 *pdst   = piQxelArray[2];
 259                 pdst -=2;
 260                 pdst += widthDst;
 261               }
 262               break;
 263             case 1:
 264               while(h--){
 265                 *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
 266                 *pdst++ = piQxelArray[1];
 267                 *pdst   = piQxelArray[2];
 268                 pdst -=2;
 269                 pdst += widthDst;
 270               }
 271               break;
 272             case 2:
 273               while(h--){
 274                 *pdst++ = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
 275                 *pdst-- = piQxelArray[2];
 276                 pdst += widthDst;
 277               }
 278               break;
 279             case 3:
 280               while(h--){
 281                 *pdst = ((*pdst) & 0xFF) | (piQxelArray[2] & 0xFFFFFF00);
 282                 pdst += widthDst;
 283               }
 284               break;
 285             }
 286             break;
 287           case 3:
 288             switch(leftIndex){
 289             case 0:
 290               while(h--){
 291                 *pdst++ = piQxelArray[0];
 292                 *pdst++ = piQxelArray[1];
 293                 *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
 294                 pdst--;
 295                 pdst += widthDst;
 296               }
 297               break;
 298             case 1:
 299               while(h--){
 300                 *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
 301                 *pdst++ = piQxelArray[1];
 302                 *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
 303                 pdst--;
 304                 pdst += widthDst;
 305               }
 306               break;
 307             case 2:
 308               while(h--){
 309                 *pdst++ = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
 310                 *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
 311                 pdst += widthDst;
 312               }
 313               break;
 314             }
 315             break;
 316           case 2:
 317             while(h--){
 318               if(leftIndex){
 319                 *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
 320               }
 321               else{
 322                 *pdst++ = piQxelArray[0];
 323               }
 324                 *pdst-- = ((*pdst) & 0xFFFF0000) | (piQxelArray[1] & 0xFFFF);
 325                 pdst += widthDst;
 326             }
 327             break;
 328           case 1: /*only if leftIndex = 0 and w = 1*/
 329             while(h--){
 330                 *pdst = ((*pdst) & 0xFF000000) | (piQxelArray[0] & 0xFFFFFF);
 331                 pdst += widthDst;
 332               }
 333             break;
 334           case 0: /*never*/
 335             break;
 336           default:
 337           {
 338             w = nmiddle;
 339             pdstULC = pdst;
 340 /*          maskbits (pBox->x1, w, leftMask, rightMask, nmiddle);*/
 341             while(h--){
 342               nmiddle = w;
 343               pdst = pdstULC;
 344               switch(leftIndex){
 345               case 0:
 346                 break;
 347               case 1:
 348                 *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
 349                 *pdst++ = piQxelArray[1];
 350                 *pdst++ = piQxelArray[2];
 351                 break;
 352               case 2:
 353                 *pdst++ = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
 354                 *pdst++ = piQxelArray[2];
 355                 break;
 356               case 3:
 357                 *pdst++ = ((*pdst) & 0xFF) | (piQxelArray[2] & 0xFFFFFF00);
 358                 break;
 359               }
 360               while(nmiddle--){
 361                 *pdst++ = piQxelArray[0];
 362                 *pdst++ = piQxelArray[1];
 363                 *pdst++ = piQxelArray[2];
 364               }
 365               switch(rightIndex){
 366               case 0:
 367                 break;
 368               case 1:
 369                 *pdst = ((*pdst) & 0xFF000000) | (piQxelArray[0] & 0xFFFFFF);
 370                 break;
 371               case 2:
 372                 *pdst++ = piQxelArray[0];
 373                 *pdst = ((*pdst) & 0xFFFF0000) | (piQxelArray[1] & 0xFFFF);
 374                 break;
 375               case 3:
 376                 *pdst++ = piQxelArray[0];
 377                 *pdst++ = piQxelArray[1];
 378                 *pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
 379                 break;
 380             }
 381             pdstULC += widthDst;
 382             }
 383
 384           }
 385         }
 386 #else
 387         pdst += (pBox->x1 >> PWSH);
 388         if ((pBox->x1 & PIM) + w <= PPW)
 389         {
 390             maskpartialbits(pBox->x1, w, leftMask);
 391             while (h--) {
 392                 *pdst = (*pdst & ~leftMask) | (rrop_xor & leftMask);
 393                 pdst += widthDst;
 394             }
 395         }
 396         else
 397         {
 398             maskbits (pBox->x1, w, leftMask, rightMask, nmiddle);
 399             if (leftMask)
 400             {
 401                 if (rightMask)
 402                 {
 403                     Expand (RROP_SOLID_MASK (pdst, leftMask); pdst++; ,
 404                             RROP_SOLID_MASK (pdst, rightMask); ,
 405                             1)
 406                 }
 407                 else
 408                 {
 409                     Expand (RROP_SOLID_MASK (pdst, leftMask); pdst++;,
 410                             ;,
 411                             1)
 412                 }
 413             }
 414             else
 415             {
 416                 if (rightMask)
 417                 {
 418                     Expand (;,
 419                             RROP_SOLID_MASK (pdst, rightMask);,
 420                             0)
 421                 }
 422                 else
 423                 {
 424                     Expand (;,
 425                             ;,
 426                             0)
 427                 }
 428             }
 429         }
 430 #endif
 431 #if PSZ == 8
 432         }
 433 #endif
 434     }
 435 }
 436
 437 void
 438 cfbFillBoxTile32 (pDrawable, nBox, pBox, tile)
 439     DrawablePtr     pDrawable;
 440     int             nBox;       /* number of boxes to fill */
 441     BoxPtr          pBox;       /* pointer to list of boxes to fill */
 442     PixmapPtr       tile;       /* rotated, expanded tile */
 443 {
 444     register unsigned long  rrop_xor;
 445     register unsigned long  *pdst;
 446     register int            m;
 447     unsigned long           *psrc;
 448     int                     tileHeight;
 449
 450     int                     widthDst;
 451     int                     w;
 452     int                     h;
 453     register unsigned long  leftMask;
 454     register unsigned long  rightMask;
 455     int                     nmiddle;
 456     int                     y;
 457     int                     srcy;
 458
 459     unsigned long           *pdstBase;
 460 #if PSZ == 24
 461     int                     leftIndex, rightIndex;
 462     unsigned long piQxelArray[3], xOffset, *pdstULC;
 463 #endif
 464
 465     tileHeight = tile->drawable.height;
 466     psrc = (unsigned long *)tile->devPrivate.ptr;
 467
 468     cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase);
 469
 470     while (nBox--)
 471     {
 472 #if PSZ == 24
 473         w = pBox->x2 - pBox->x1;
 474         h = pBox->y2 - pBox->y1;
 475         y = pBox->y1;
 476         leftIndex = pBox->x1 & 3;
 477 /*      rightIndex = ((leftIndex+w)<5)?0:pBox->x2 &3;*/
 478         rightIndex = pBox->x2 &3;
 479         nmiddle = w - rightIndex;
 480         if(leftIndex){
 481           nmiddle -= (4 - leftIndex);
 482         }
 483         nmiddle >>= 2;
 484         if(nmiddle < 0)
 485           nmiddle = 0;
 486
 487         pdst = pdstBase + ((pBox->x1 *3)>> 2) +  pBox->y1 * widthDst;
 488         srcy = y % tileHeight;
 489
 490 #define StepTile    piQxelArray[0] = (psrc[srcy] & 0xFFFFFF) | ((psrc[srcy] & 0xFF)<<24); \
 491                     piQxelArray[1] = (psrc[srcy] & 0xFFFF00) | ((psrc[srcy] & 0xFFFF)<<16); \
 492                     piQxelArray[2] = ((psrc[srcy] & 0xFF0000)>>16) | \
 493                                      ((psrc[srcy] & 0xFFFFFF)<<8); \
 494                     /*rrop_xor = psrc[srcy];*/ \
 495                     ++srcy; \
 496                     if (srcy == tileHeight) \
 497                         srcy = 0;
 498
 499           switch(leftIndex+w){
 500           case 4:
 501             switch(leftIndex){
 502             case 0:
 503               while(h--){
 504                   StepTile
 505                 *pdst++ = piQxelArray[0];
 506                 *pdst++ = piQxelArray[1];
 507                 *pdst   = piQxelArray[2];
 508                 pdst-=2;
 509                 pdst += widthDst;
 510               }
 511               break;
 512             case 1:
 513               while(h--){
 514                   StepTile
 515                 *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
 516                 *pdst++ = piQxelArray[1];
 517                 *pdst   = piQxelArray[2];
 518                 pdst-=2;
 519                 pdst += widthDst;
 520               }
 521               break;
 522             case 2:
 523               while(h--){
 524                   StepTile
 525                 *pdst++ = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
 526                 *pdst--   = piQxelArray[2];
 527                 pdst += widthDst;
 528               }
 529               break;
 530             case 3:
 531               while(h--){
 532                   StepTile
 533                 *pdst = ((*pdst) & 0xFF) | (piQxelArray[2] & 0xFFFFFF00);
 534                 pdst += widthDst;
 535               }
 536               break;
 537             }
 538             break;
 539           case 3:
 540             switch(leftIndex){
 541             case 0:
 542               while(h--){
 543                   StepTile
 544                 *pdst++ = piQxelArray[0];
 545                 *pdst++ = piQxelArray[1];
 546                 *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
 547                 pdst--;
 548                 pdst += widthDst;
 549               }
 550               break;
 551             case 1:
 552               while(h--){
 553                   StepTile
 554                 *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
 555                 *pdst++ = piQxelArray[1];
 556                 *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
 557                 pdst--;
 558                 pdst += widthDst;
 559               }
 560               break;
 561             case 2:
 562               while(h--){
 563                   StepTile
 564                 *pdst++ = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
 565                 *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
 566                 pdst += widthDst;
 567               }
 568               break;
 569             }
 570             break;
 571           case 2:
 572             while(h--){
 573                   StepTile
 574               if(leftIndex){
 575                 *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
 576               }
 577               else{
 578                 *pdst++ = piQxelArray[0];
 579               }
 580                 *pdst-- = ((*pdst) & 0xFFFF0000) | (piQxelArray[1] & 0xFFFF);
 581                 pdst += widthDst;
 582             }
 583             break;
 584           case 1: /*only if leftIndex = 0 and w = 1*/
 585             while(h--){
 586                   StepTile
 587                 *pdst = ((*pdst) & 0xFF000000) | (piQxelArray[0] & 0xFFFFFF);
 588                 pdst += widthDst;
 589               }
 590             break;
 591           case 0: /*never*/
 592             break;
 593           default:
 594           {
 595             w = nmiddle;
 596             pdstULC = pdst;
 597
 598             while(h--){
 599               StepTile
 600               nmiddle = w;
 601               pdst = pdstULC;
 602               switch(leftIndex){
 603               case 0:
 604                 break;
 605               case 1:
 606                 *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
 607                 *pdst++ = piQxelArray[1];
 608                 *pdst++ = piQxelArray[2];
 609                 break;
 610               case 2:
 611                 *pdst++ = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
 612                 *pdst++ = piQxelArray[2];
 613                 break;
 614               case 3:
 615                 *pdst++ = ((*pdst) & 0xFF) | (piQxelArray[2] & 0xFFFFFF00);
 616                 break;
 617               }
 618               while(nmiddle--){
 619                 *pdst++ = piQxelArray[0];
 620                 *pdst++ = piQxelArray[1];
 621                 *pdst++ = piQxelArray[2];
 622               }
 623               switch(rightIndex){
 624               case 0:
 625                 break;
 626               case 1:
 627                 *pdst = ((*pdst) & 0xFF000000) | (piQxelArray[0] & 0xFFFFFF);
 628                 break;
 629               case 2:
 630                 *pdst++ = piQxelArray[0];
 631                 *pdst = ((*pdst) & 0xFFFF0000) | (piQxelArray[1] & 0xFFFF);
 632                 break;
 633               case 3:
 634                 *pdst++ = piQxelArray[0];
 635                 *pdst++ = piQxelArray[1];
 636                 *pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
 637                 break;
 638               }
 639               pdstULC += widthDst;
 640             }
 641           }
 642           }
 643 #else
 644         w = pBox->x2 - pBox->x1;
 645         h = pBox->y2 - pBox->y1;
 646         y = pBox->y1;
 647         pdst = pdstBase + (pBox->y1 * widthDst) + (pBox->x1 >> PWSH);
 648         srcy = y % tileHeight;
 649
 650 #define StepTile    rrop_xor = psrc[srcy]; \
 651                     ++srcy; \
 652                     if (srcy == tileHeight) \
 653                         srcy = 0;
 654
 655         if ( ((pBox->x1 & PIM) + w) < PPW)
 656         {
 657             maskpartialbits(pBox->x1, w, leftMask);
 658             rightMask = ~leftMask;
 659             while (h--)
 660             {
 661                 StepTile
 662                 *pdst = (*pdst & rightMask) | (rrop_xor & leftMask);
 663                 pdst += widthDst;
 664             }
 665         }
 666         else
 667         {
 668             maskbits(pBox->x1, w, leftMask, rightMask, nmiddle);
 669
 670             if (leftMask)
 671             {
 672                 if (rightMask)
 673                 {
 674                     Expand (StepTile
 675                             RROP_SOLID_MASK(pdst, leftMask); pdst++;,
 676                             RROP_SOLID_MASK(pdst, rightMask);,
 677                             1)
 678                 }
 679                 else
 680                 {
 681                     Expand (StepTile
 682                             RROP_SOLID_MASK(pdst, leftMask); pdst++;,
 683                             ;,
 684                             1)
 685                 }
 686             }
 687             else
 688             {
 689                 if (rightMask)
 690                 {
 691                     Expand (StepTile
 692                             ,
 693                             RROP_SOLID_MASK(pdst, rightMask);,
 694                             0)
 695                 }
 696                 else
 697                 {
 698                     Expand (StepTile
 699                             ,
 700                             ;,
 701                             0)
 702                 }
 703             }
 704         }
 705 #endif
 706         pBox++;
 707     }
 708 }