rom/graphics/intregions.c

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