rom/graphics/intregions.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Code for various operations on Regions and Rectangles
   6     Lang: English
   7 */
   8
   9 #include <exec/memory.h>
  10 #include <graphics/regions.h>
  11 #include <graphics/gfxbase.h>
  12 #include <proto/exec.h>
  13 #include <proto/graphics.h>
  14 #include <proto/exec.h>
  15 #include <clib/macros.h>
  16
  17 #include "graphics_intern.h"
  18 #include "intregions.h"
  19
  20 #include <aros/debug.h>
  21
  22 #if DEBUG
  23 void dumplist(struct GfxBase *GfxBase)
  24 {
  25     struct ChunkPool *Pool;
  26     int n = 0;
  27
  28     Pool = (struct ChunkPool *)GetHead(&PrivGBase(GfxBase)->ChunkPoolList);
  29
  30     while (Pool)
  31     {
  32         struct ChunkExt  *ChunkE;
  33         int m = 0;
  34
  35         kprintf("Pool N.%d - %ld Chunk Free\n", n++, Pool->NumChunkFree);
  36
  37         ChunkE = (struct ChunkExt *)GetHead(&Pool->ChunkList);
  38
  39         while (ChunkE)
  40         {
  41             kprintf("    Chunk N.%d\n", m++);
  42             ChunkE = (struct ChunkExt *)GetSucc(ChunkE);
  43         }
  44
  45         Pool = (struct ChunkPool *)GetSucc(Pool);
  46     }
  47 }
  48 #endif
  49
  50 static inline struct RegionRectangleExtChunk *__NewRegionRectangleExtChunk
  51 (
  52     struct GfxBase *GfxBase
  53 )
  54 {
  55     struct ChunkPool *Pool;
  56     struct ChunkExt  *ChunkE;
  57
  58     ObtainSemaphore(&PrivGBase(GfxBase)->regionsem);
  59
  60     Pool = (struct ChunkPool *)GetHead(&PrivGBase(GfxBase)->ChunkPoolList);
  61
  62     if (!Pool || !Pool->NumChunkFree)
  63     {
  64         int i;
  65
  66         Pool = AllocMem(sizeof(struct ChunkPool), MEMF_ANY);
  67
  68         if (!Pool)
  69         {
  70             ReleaseSemaphore(&PrivGBase(GfxBase)->regionsem);
  71
  72             return NULL;
  73         }
  74
  75         NEWLIST(&Pool->ChunkList);
  76
  77         Pool->NumChunkFree = SIZECHUNKBUF;
  78
  79         for (i = 0; i < SIZECHUNKBUF; i++)
  80         {
  81             ADDTAIL(&Pool->ChunkList, &Pool->Chunks[i]);
  82         }
  83
  84         ADDHEAD(&PrivGBase(GfxBase)->ChunkPoolList, Pool);
  85     }
  86
  87     ChunkE = (struct ChunkExt *)GetHead(&Pool->ChunkList);
  88
  89     REMOVE(ChunkE);
  90
  91     if (!--Pool->NumChunkFree)
  92     {
  93         REMOVE(Pool);
  94         ADDTAIL(&PrivGBase(GfxBase)->ChunkPoolList, Pool);
  95     }
  96
  97     ChunkE->Owner = Pool;
  98
  99     ReleaseSemaphore(&PrivGBase(GfxBase)->regionsem);
 100
 101     return &ChunkE->Chunk;
 102 }
 103
 104
 105 void __DisposeRegionRectangleExtChunk
 106 (
 107     struct RegionRectangleExtChunk *Chunk,
 108     struct GfxBase *GfxBase
 109 )
 110 {
 111     struct ChunkPool *Pool = ((struct ChunkExt *)Chunk)->Owner;
 112
 113     ObtainSemaphore(&PrivGBase(GfxBase)->regionsem);
 114
 115     REMOVE(Pool);
 116
 117     if (++Pool->NumChunkFree == SIZECHUNKBUF)
 118     {
 119         FreeMem(Pool, sizeof(struct ChunkPool));
 120     }
 121     else
 122     {
 123         ADDHEAD(&PrivGBase(GfxBase)->ChunkPoolList, Pool);
 124         ADDTAIL(&Pool->ChunkList, Chunk);
 125     }
 126
 127     ReleaseSemaphore(&PrivGBase(GfxBase)->regionsem);
 128 }
 129
 130
 131 struct RegionRectangle *_NewRegionRectangle
 132 (
 133     struct RegionRectangle **LastRectPtr,
 134     struct GfxBase *GfxBase
 135 )
 136 {
 137     struct RegionRectangleExt *RRE = RRE(*LastRectPtr);
 138
 139     if (!RRE)
 140     {
 141         struct RegionRectangleExtChunk *Chunk;
 142
 143         Chunk = _NewRegionRectangleExtChunk();
 144
 145         if (Chunk)
 146         {
 147             RRE = Chunk->Rects;
 148         }
 149
 150         if (RRE)
 151         {
 152             RRE->Counter = 0;
 153             RRE->RR.Prev = NULL;
 154             RRE->RR.Next = NULL;
 155
 156             RRE[SIZERECTBUF - 1].RR.Next = NULL; /* IMPORTANT !!! */
 157
 158             Chunk->FirstChunk = Chunk;
 159         }
 160     }
 161     else
 162     if (RRE->Counter == SIZERECTBUF - 1)
 163     {
 164         struct RegionRectangleExtChunk *Chunk;
 165
 166         Chunk = _NewRegionRectangleExtChunk();
 167
 168         if (Chunk)
 169         {
 170             Chunk->FirstChunk = Chunk(RRE)->FirstChunk;
 171             RRE = Chunk->Rects;
 172         }
 173         else
 174         {
 175             RRE = NULL;
 176         }
 177
 178         if (RRE)
 179         {
 180             RRE->Counter = 0;
 181             RRE->RR.Prev = *LastRectPtr;
 182             RRE->RR.Next = NULL;
 183             (*LastRectPtr)->Next = &RRE->RR;
 184
 185             RRE[SIZERECTBUF - 1].RR.Next = NULL; /* IMPORTANT !!! */
 186         }
 187     }
 188     else
 189     {
 190         struct RegionRectangleExt *Prev = RRE++;
 191
 192         RRE->RR.Next    = NULL;
 193         RRE->RR.Prev    = &Prev->RR;
 194         Prev->RR.Next   = &RRE->RR;
 195
 196         RRE->Counter    = Prev->Counter + 1;
 197     }
 198
 199     return *LastRectPtr = (struct RegionRectangle *)RRE;
 200 }
 201
 202
 203 void _DisposeRegionRectangleList
 204 (
 205     struct RegionRectangle *RR,
 206     struct GfxBase         *GfxBase
 207 )
 208 {
 209     struct RegionRectangleExtChunk *NextChunk;
 210
 211     if (!RR)
 212     {
 213         return;
 214     }
 215
 216     if (RR->Prev)
 217     {
 218         RR->Prev->Next = NULL;
 219     }
 220
 221     /* Is this the first rectangle in the chunk? */
 222     if (!Counter(RR))
 223     {
 224         /* If so then this chunk has to be deleted too */
 225         NextChunk = Chunk(RR);
 226     }
 227     else
 228     {
 229         /* otherwise dispose all the chunks starting from the one after this one */
 230         RR = &Chunk(RR)->Rects[SIZERECTBUF - 1].RR;
 231         NextChunk = Chunk(RR->Next);
 232         RR->Next = NULL;
 233     }
 234
 235     while (NextChunk)
 236     {
 237         struct RegionRectangleExtChunk *OldChunk = NextChunk;
 238
 239         NextChunk = Chunk(NextChunk->Rects[SIZERECTBUF - 1].RR.Next);
 240
 241         _DisposeRegionRectangleExtChunk(OldChunk);
 242     }
 243 }
 244
 245 /*
 246    Takes all the rectangles from src and linkes them with the rectangle
 247    to which *dstptr points. *dstptr at the end will hold the pointer
 248    to the LAST rectangle in the resulting list.
 249    If the system runs out of memory the function will deallocate any allocated
 250    memory and will return FALSE. TRUE, otherwise.
 251  */
 252
 253 BOOL _LinkRegionRectangleList
 254 (
 255     struct RegionRectangle  *src,
 256     struct RegionRectangle **dstptr,
 257     struct GfxBase          *GfxBase
 258 )
 259 {
 260     struct RegionRectangle *prev = *dstptr;
 261
 262     for (; src; src = src->Next)
 263     {
 264         struct RegionRectangle *new = _NewRegionRectangle(dstptr, GfxBase);
 265
 266         if (!new)
 267         {
 268             if (prev)
 269             {
 270                 _DisposeRegionRectangleList(prev->Next, GfxBase);
 271             }
 272
 273             return FALSE;
 274         }
 275
 276         new->bounds = src->bounds;
 277     }
 278
 279     return TRUE;
 280 }
 281
 282 #define ADVANCE(nextbandptr, rr)                    \
 283 {                                                   \
 284     if ((rr)->Next && MinY((rr)->Next) == MinY(rr)) \
 285         rr = (rr)->Next;                            \
 286     else                                            \
 287     {                                               \
 288         if (nextbandptr)                            \
 289             *nextbandptr = (rr)->Next;              \
 290         rr = NULL;                                  \
 291     }                                               \
 292 }
 293
 294 #define NEWREG(prevptr, rr)                     \
 295 {                                               \
 296     rr = _NewRegionRectangle(prevptr, GfxBase); \
 297     if (!rr)                                    \
 298         return FALSE;                           \
 299 }
 300
 301 #define ADDRECT(minx, maxx)    \
 302 {                              \
 303    struct RegionRectangle *rr; \
 304    NEWREG(DstPtr, rr);         \
 305                                \
 306    MinX(rr) = minx;            \
 307    MinY(rr) = MinY;            \
 308    MaxX(rr) = maxx;            \
 309    MaxY(rr) = MaxY;            \
 310 }
 311
 312 #define ADDRECTMERGE(minx, maxx)     \
 313 {                                    \
 314     if                               \
 315     (                                \
 316         !*(DstPtr) ||                \
 317         (MinY(*(DstPtr)) != MinY) || \
 318         ((minx-1) > MaxX(*DstPtr))   \
 319     )                                \
 320     {                                \
 321         ADDRECT((minx), (maxx));     \
 322     }                                \
 323     else                             \
 324     if (MaxX(*DstPtr) < maxx)        \
 325     {                                \
 326         MaxX(*DstPtr) = maxx;        \
 327     }                                \
 328 }
 329
 330 #define DOBANDCHECKS(firstlastdst, lastdst, curdst)                        \
 331 if (curdst != lastdst)                                                     \
 332 {                                                                          \
 333     if (!lastdst)                                                          \
 334     {                                                                      \
 335         firstlastdst = &Chunk(curdst)->FirstChunk->Rects[0].RR;            \
 336         DstBounds->MinY = MinY(firstlastdst);                              \
 337         DstBounds->MinX = MinX(firstlastdst);                              \
 338         DstBounds->MaxX = MaxX(curdst);                                    \
 339     }                                                                      \
 340     else                                                                   \
 341     {                                                                      \
 342         if (DstBounds->MinX > MinX(lastdst->Next))                         \
 343             DstBounds->MinX = MinX(lastdst->Next);                         \
 344         if (DstBounds->MaxX < MaxX(curdst))                                \
 345             DstBounds->MaxX = MaxX(curdst);                                \
 346                                                                            \
 347         if (MaxY(firstlastdst) == MinY(curdst) - 1)                        \
 348         {                                                                  \
 349             struct RegionRectangle *_one = firstlastdst;                   \
 350             struct RegionRectangle *_two = lastdst->Next;                  \
 351                                                                            \
 352             while (_one != lastdst->Next && _two)                          \
 353             {                                                              \
 354                 if                                                         \
 355                 (                                                          \
 356                     MinX(_one) == MinX(_two) &&                            \
 357                     MaxX(_one) == MaxX(_two)                               \
 358                 )                                                          \
 359                 {                                                          \
 360                     _one = _one->Next;                                     \
 361                     _two = _two->Next;                                     \
 362                 }                                                          \
 363                 else                                                       \
 364                 {                                                          \
 365                     break;                                                 \
 366                 }                                                          \
 367             }                                                              \
 368                                                                            \
 369             if (_one == lastdst->Next && !_two)                            \
 370             {                                                              \
 371                 LONG MaxY = MaxY(curdst);                                  \
 372                 _one = firstlastdst;                                       \
 373                 _DisposeRegionRectangleList(lastdst->Next, GfxBase);       \
 374                 while (_one)                                               \
 375                 {                                                          \
 376                     MaxY(_one) = MaxY;                                     \
 377                     _one = _one->Next;                                     \
 378                 }                                                          \
 379                                                                            \
 380                 curdst = lastdst;                                          \
 381             }                                                              \
 382             else                                                           \
 383                 firstlastdst = lastdst->Next;                              \
 384         }                                                                  \
 385         else                                                               \
 386             firstlastdst = lastdst->Next;                                  \
 387     }                                                                      \
 388     lastdst = curdst;                                                      \
 389 }
 390
 391 #if DOTEST
 392 #    define DEBUG 1
 393 #endif
 394
 395 #if DEBUG
 396 void dumprect(struct Rectangle *rec)
 397 {
 398     if (!rec)
 399     {
 400         kprintf("NULL\n");
 401         return;
 402     }
 403
 404     kprintf("(%d,%d)-(%d,%d)\n", (int)rec->MinX, (int)rec->MinY,
 405                                  (int)rec->MaxX, (int)rec->MaxY);
 406 }
 407
 408
 409 void dumpregion(struct Region *reg)
 410 {
 411     struct RegionRectangle *rr;
 412
 413     if (!reg)
 414     {
 415         kprintf("NULL\n");
 416         return;
 417     }
 418
 419     kprintf("Bounds: "); dumprect(&reg->bounds);
 420
 421     for (rr = reg->RegionRectangle; rr;)
 422     {
 423         struct RegionRectangle *rr2 = rr;
 424
 425         kprintf("    Band: MinY = %d - %p\n", (int)MinY(rr), rr);
 426         do
 427         {
 428             kprintf("\t");dumprect(Bounds(rr2));
 429             ADVANCE(&rr, rr2);
 430         } while (rr2);
 431     }
 432 }
 433
 434
 435 void dumpregionrectangles(struct RegionRectangle *rr)
 436 {
 437
 438     while (rr)
 439     {
 440         kprintf("%p (prev: %p - next: %p): ", rr, rr->Prev, rr->Next);
 441         dumprect(&rr->bounds);
 442         rr = rr->Next;
 443     }
 444 }
 445
 446
 447 void dumpband(struct RegionRectangle *rr, LONG OffX, LONG MinY, LONG MaxY)
 448 {
 449     if (rr)
 450     {
 451         while (1)
 452         {
 453             struct Rectangle r;
 454             r.MinX = MinX(rr) + OffX;
 455             r.MaxX = MaxX(rr) + OffX;
 456             r.MinY = MinY;
 457             r.MaxY = MaxY;
 458             kprintf("%p (prev: %p - next: %p): ", rr, rr->Prev, rr->Next);
 459             dumprect(&r);
 460             if (rr->Next && MinY(rr->Next) == MinY(rr)) rr = rr->Next; else break;
 461         }
 462     }
 463     else
 464         kprintf("\n");
 465 }
 466 #endif
 467
 468
 469 BOOL _OrBandBand
 470 (
 471     LONG                     OffX1,
 472     LONG                     OffX2,
 473     LONG                     MinY,
 474     LONG                     MaxY,
 475     struct RegionRectangle  *Src1,
 476     struct RegionRectangle  *Src2,
 477     struct RegionRectangle **DstPtr,
 478     struct RegionRectangle **NextSrc1Ptr,
 479     struct RegionRectangle **NextSrc2Ptr,
 480     struct GfxBase          *GfxBase
 481 )
 482 {
 483     while (Src1 && Src2)
 484     {
 485         if (MinX(Src1) + OffX1 < MinX(Src2) + OffX2)
 486         {
 487             ADDRECTMERGE(MinX(Src1) + OffX1, MaxX(Src1) + OffX1);
 488             ADVANCE(NextSrc1Ptr, Src1);
 489         }
 490         else
 491         {
 492             ADDRECTMERGE(MinX(Src2) + OffX2, MaxX(Src2) + OffX2);
 493             ADVANCE(NextSrc2Ptr, Src2);
 494         }
 495     }
 496
 497     if (Src1)
 498     {
 499         do
 500         {
 501             ADDRECTMERGE(MinX(Src1) + OffX1, MaxX(Src1) + OffX1);
 502             ADVANCE(NextSrc1Ptr, Src1);
 503         } while (Src1);
 504     }
 505     else
 506     while (Src2)
 507     {
 508         ADDRECTMERGE(MinX(Src2) + OffX2, MaxX(Src2) + OffX2);
 509         ADVANCE(NextSrc2Ptr, Src2);
 510     }
 511
 512     return TRUE;
 513 }
 514
 515
 516 BOOL _AndBandBand
 517 (
 518     LONG                     OffX1,
 519     LONG                     OffX2,
 520     LONG                     MinY,
 521     LONG                     MaxY,
 522     struct RegionRectangle  *Src1,
 523     struct RegionRectangle  *Src2,
 524     struct RegionRectangle **DstPtr,
 525     struct RegionRectangle **NextSrc1Ptr,
 526     struct RegionRectangle **NextSrc2Ptr,
 527     struct GfxBase          *GfxBase
 528 )
 529 {
 530     while (Src1 && Src2)
 531     {
 532         if (MinX(Src1) + OffX1 < MinX(Src2) + OffX2)
 533         {
 534             if (MaxX(Src1) + OffX1 >= MaxX(Src2) + OffX2)
 535             {
 536                 /* Src1 totally covers Src2 */
 537                 ADDRECT(MinX(Src2) + OffX2, MaxX(Src2) + OffX2);
 538                 ADVANCE(NextSrc2Ptr, Src2);
 539             }
 540             else
 541             {
 542                 if (MaxX(Src1) + OffX1 >= MinX(Src2) + OffX2)
 543                     /* Src1 partially covers Src2 */
 544                     ADDRECT(MinX(Src2) + OffX2, MaxX(Src1) + OffX1);
 545
 546                 ADVANCE(NextSrc1Ptr, Src1);
 547             }
 548         }
 549         else
 550         {
 551             if (MaxX(Src2) + OffX2 >= MaxX(Src1) + OffX1)
 552             {
 553                 /* Src2 totally covers Src1 */
 554                 ADDRECT(MinX(Src1) + OffX1, MaxX(Src1) + OffX1);
 555                 ADVANCE(NextSrc1Ptr, Src1);
 556             }
 557             else
 558             {
 559                 if (MaxX(Src2) + OffX2 >= MinX(Src1) + OffX1)
 560                     /* Src2 partially covers Src1 */
 561                     ADDRECT(MinX(Src1) + OffX1, MaxX(Src2) + OffX2);
 562
 563                 ADVANCE(NextSrc2Ptr, Src2);
 564             }
 565         }
 566     }
 567
 568     if (Src1)
 569     {
 570         do ADVANCE(NextSrc1Ptr, Src1) while (Src1);
 571     }
 572     else
 573     while (Src2) ADVANCE(NextSrc2Ptr, Src2);
 574
 575     return TRUE;
 576 }
 577
 578
 579 BOOL _ClearBandBand
 580 (
 581     LONG                     OffX1,
 582     LONG                     OffX2,
 583     LONG                     MinY,
 584     LONG                     MaxY,
 585     struct RegionRectangle  *Src1,
 586     struct RegionRectangle  *Src2,
 587     struct RegionRectangle **DstPtr,
 588     struct RegionRectangle **NextSrc1Ptr,
 589     struct RegionRectangle **NextSrc2Ptr,
 590     struct GfxBase          *GfxBase
 591 )
 592 {
 593     LONG MinX = 0;
 594
 595     if (Src2)
 596         MinX = MinX(Src2) + OffX2;
 597
 598     while (Src1 && Src2)
 599     {
 600         if (MaxX(Src1) + OffX1 < MinX)
 601         {
 602             /* Subtrahend doesn't overlap minuend. Just skip it */
 603             ADVANCE(NextSrc1Ptr, Src1);
 604         }
 605         else
 606         if (MinX(Src1) + OffX1 <= MinX)
 607         {
 608             /* Subtrahend precedes minuend: nuke left edge of minuend */
 609             MinX = MaxX(Src1) + OffX1 + 1;
 610
 611             if (MinX > MaxX(Src2) + OffX2)
 612             {
 613                 /*
 614                    Subtrahend completely overlaps minuend, so advance
 615                    to the next minuend and reset MinX to its left
 616                 */
 617                 ADVANCE(NextSrc2Ptr, Src2);
 618                 if (Src2)
 619                     MinX = MinX(Src2) + OffX2;
 620             }
 621             else
 622             {
 623                 /* Subtrahend doesn't extend beyond minuend, so advence to the next one */
 624                 ADVANCE(NextSrc1Ptr, Src1);
 625             }
 626         }
 627         else
 628         if (MinX(Src1) + OffX1 <= MaxX(Src2) + OffX2)
 629         {
 630             /*
 631                Subtrahend covers part of minuend.
 632                Add uncovered part of minuend to the band and jump to the next
 633                subtrahend
 634             */
 635
 636             ADDRECT(MinX, MinX(Src1) + OffX1 - 1);
 637
 638             MinX = MaxX(Src1) + OffX1 + 1;
 639
 640             if (MinX > MaxX(Src2) + OffX2)
 641             {
 642                 /*Minuend used up: advance to the next one */
 643                 ADVANCE(NextSrc2Ptr, Src2);
 644                 if (Src2)
 645                     MinX = MinX(Src2) + OffX2;
 646             }
 647             else
 648             {
 649                 /* Subtrahend used up */
 650                 ADVANCE(NextSrc1Ptr, Src1);
 651             }
 652         }
 653         else
 654         {
 655             /*
 656                Minuend used up: add any remaining piece before advancing.
 657              */
 658
 659              if (MaxX(Src2) + OffX2 >= MinX)
 660              {
 661                  ADDRECT(MinX, MaxX(Src2) + OffX2);
 662              }
 663
 664              ADVANCE(NextSrc2Ptr, Src2);
 665              if (Src2)
 666                  MinX = MinX(Src2) + OffX2;
 667         }
 668     }
 669
 670     if (Src1)
 671     {
 672         do ADVANCE(NextSrc1Ptr, Src1) while (Src1);
 673     }
 674     else
 675     while (Src2)
 676     {
 677         ADDRECT(MinX, MaxX(Src2) + OffX2);
 678         ADVANCE(NextSrc2Ptr, Src2);
 679         if (Src2)
 680         {
 681             MinX = MinX(Src2) + OffX2;
 682         }
 683     }
 684
 685     return TRUE;
 686 }
 687
 688
 689 BOOL _DoOperationBandBand
 690 (
 691     BandOperation           *Operation,
 692     LONG                     OffX1,
 693     LONG                     OffX2,
 694     LONG                     OffY1,
 695     LONG                     OffY2,
 696     struct RegionRectangle  *Src1,
 697     struct RegionRectangle  *Src2,
 698     struct RegionRectangle **DstPtr,
 699     struct Rectangle        *DstBounds,
 700     struct GfxBase          *GfxBase
 701 )
 702 {
 703     struct RegionRectangle  *Dst, *LastDst, *FirstLastDst;
 704     struct RegionRectangle **NextSrc1Ptr = (void *)~0;
 705     struct RegionRectangle **NextSrc2Ptr = (void *)~0;
 706     struct RegionRectangle  *Band1 = Src1, *Band2 = Src2;
 707
 708     BOOL res = TRUE;
 709
 710     LONG TopY1 = 0, TopY2 = 0;
 711
 712     FirstLastDst = LastDst = Dst = *DstPtr = NULL;
 713
 714     while (Src1 && Src2)
 715     {
 716         LONG MinY, MaxY;
 717
 718         if (NextSrc1Ptr)
 719         {
 720             TopY1 = MinY(Src1) + OffY1;
 721             NextSrc1Ptr = NULL;
 722         }
 723
 724         if (NextSrc2Ptr)
 725         {
 726             TopY2 = MinY(Src2) + OffY2;
 727             NextSrc2Ptr = NULL;
 728         }
 729
 730         if (TopY1 < TopY2)
 731         {
 732             MinY = TopY1;
 733             MaxY = MIN(MaxY(Src1) + OffY1, TopY2 - 1);
 734             TopY1 = MaxY + 1;
 735
 736             Band1 = Src1;
 737             Band2 = NULL;
 738         }
 739         else
 740         if (TopY2 < TopY1)
 741         {
 742             MinY = TopY2;
 743             MaxY = MIN(MaxY(Src2) + OffY2, TopY1 - 1);
 744             TopY2 = MaxY + 1;
 745
 746             Band1 = NULL;
 747             Band2 = Src2;
 748         }
 749         else
 750         {
 751             MinY = TopY1;
 752             MaxY = MIN(MaxY(Src1) + OffY1, MaxY(Src2) + OffY2);
 753             TopY1 = TopY2 = MaxY + 1;
 754
 755             Band1 = Src1;
 756             Band2 = Src2;
 757         }
 758
 759         NextSrc1Ptr = (MaxY == MaxY(Src1) + OffY1) ? &Src1 : NULL;
 760         NextSrc2Ptr = (MaxY == MaxY(Src2) + OffY2) ? &Src2 : NULL;
 761
 762         if
 763         (
 764             !Operation
 765             (
 766                 OffX1, OffX2,
 767                 MinY, MaxY,
 768                 Band1, Band2,
 769                 &Dst,
 770                 NextSrc1Ptr, NextSrc2Ptr,
 771                 GfxBase
 772             )
 773         )
 774         {
 775             res = FALSE;
 776             goto end;
 777         }
 778
 779         DOBANDCHECKS(FirstLastDst, LastDst, Dst);
 780     }
 781
 782
 783     while (Src1)
 784     {
 785         if (NextSrc1Ptr)
 786             TopY1 = MinY(Src1) + OffY1;
 787
 788         NextSrc1Ptr = (void *)~0;
 789
 790
 791         if
 792         (
 793             !Operation
 794             (
 795                 OffX1, OffX2,
 796                 TopY1, MaxY(Src1) + OffY1,
 797                 Src1, NULL,
 798                 &Dst,
 799                 &Src1, NULL,
 800                 GfxBase
 801             )
 802         )
 803         {
 804             res = FALSE;
 805             goto end;
 806         }
 807
 808         DOBANDCHECKS(FirstLastDst, LastDst, Dst);
 809     }
 810
 811     while (Src2)
 812     {
 813         if (NextSrc2Ptr)
 814             TopY2 = MinY(Src2) + OffY2;
 815
 816         NextSrc2Ptr = (void *)~0;
 817
 818         if
 819         (
 820             !Operation
 821             (
 822                 OffX1, OffX2,
 823                 TopY2, MaxY(Src2) + OffY2,
 824                 NULL, Src2,
 825                 &Dst,
 826                 NULL, &Src2,
 827                 GfxBase
 828             )
 829         )
 830         {
 831             res = FALSE;
 832             goto end;
 833         }
 834
 835         DOBANDCHECKS(FirstLastDst, LastDst, Dst);
 836     }
 837
 838 end:
 839
 840     if (Dst)
 841     {
 842         if (res)
 843         {
 844             DstBounds->MaxY = MaxY(Dst);
 845             *DstPtr = &Chunk(Dst)->FirstChunk->Rects[0].RR;
 846         }
 847         else
 848             _DisposeRegionRectangleList(&Chunk(Dst)->FirstChunk->Rects[0].RR, GfxBase);
 849     }
 850
 851     return res;
 852 }
 853
 854
 855 #if DOTEST
 856
 857 #undef GfxBase
 858 #include <proto/graphics.h>
 859
 860
 861 int main(void)
 862 {
 863     int i;
 864
 865     struct Region *R1 = NewRegion();
 866     struct Region *R2 = NewRegion();
 867
 868     for (i = 0; i < 10; i++)
 869     {
 870         int l = i*20;
 871
 872         struct Rectangle r = {l, 0, l+11, 201};
 873         OrRectRegion(R1, &r);
 874     }
 875
 876     for (i = 0; i < 10; i++)
 877     {
 878         int u = i*20;
 879
 880         struct Rectangle r = {0, u, 201, u+11};
 881         OrRectRegion(R2, &r);
 882     }
 883
 884     for (i = 0; i<100000; i++)
 885     {
 886         XorRegionRegion(R2, R1);
 887     }
 888
 889     DisposeRegion(R2);
 890     DisposeRegion(R1);
 891     return 0;
 892 }
 893
 894 #endif
 895