workbench/devs/monitors/Compositor/compositorclass.c

   1 /*
   2     Copyright © 2010-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   7 #if (DEBUG)
   8 #define DTOGGLE(x) x
   9 #define DMODE(x) x
  10 #define DMOVE(x) x
  11 #define DRECALC(x) x
  12 #define DREDRAWBM(x) x
  13 #define DREDRAWSCR(x) x
  14 #define DSTACK(x) x
  15 #define DUPDATE(x) x
  16 #else
  17 #define DTOGGLE(x)
  18 #define DMODE(x)
  19 #define DMOVE(x)
  20 #define DRECALC(x)
  21 #define DREDRAWBM(x)
  22 #define DREDRAWSCR(x)
  23 #define DSTACK(x)
  24 #define DUPDATE(x)
  25 #endif
  26
  27 #include <aros/debug.h>
  28
  29 #include <clib/alib_protos.h>
  30 #include <proto/exec.h>
  31 #include <proto/dos.h>
  32 #include <proto/graphics.h>
  33 #include <proto/intuition.h>
  34 #include <proto/oop.h>
  35 #include <proto/utility.h>
  36
  37 #include <graphics/view.h>
  38 #include <hidd/graphics.h>
  39
  40 #include "compositor_intern.h"
  41
  42 #define COMPOSITOR_PREFS "SYS/compositor.prefs"
  43 #define COMPOSITOR_PEFSTEMPLATE  "ABOVE/S,BELOW/S,LEFT/S,RIGHT/S,ALPHA/S"
  44
  45 #define CAPABILITY_FLAGS (COMPF_ABOVE|COMPF_BELOW|COMPF_LEFT|COMPF_RIGHT|COMPF_ALPHA)
  46
  47 enum
  48 {
  49     ARG_ABOVE = 0,
  50     ARG_BELOW,
  51     ARG_LEFT,
  52     ARG_RIGHT,
  53     ARG_ALPHA,
  54     NOOFARGS
  55 };
  56
  57
  58 #ifdef GfxBase
  59 #undef GfxBase
  60 #endif
  61 #define GfxBase compdata->GraphicsBase
  62 #ifdef IntuitionBase
  63 #undef IntuitionBase
  64 #endif
  65 #define IntuitionBase compdata->IntuitionBase
  66
  67 #define _RECT(x) x.MinX, x.MinY, x.MaxX, x.MaxY
  68
  69 #define MAX(a,b) a > b ? a : b
  70 #define MIN(a,b) a < b ? a : b
  71
  72 BOOL isRectInRegion(struct Region *region, struct Rectangle *rect)
  73 {
  74     struct RegionRectangle *rrect = region->RegionRectangle;
  75
  76     while (rrect)
  77     {
  78         if (AndRectRect(&rrect->bounds, rect, NULL))
  79             return TRUE;
  80
  81         rrect = rrect->Next;
  82     }
  83     return FALSE;
  84 }
  85
  86 static struct StackBitMapNode * HIDDCompositorFindBitMapStackNode(struct HIDDCompositorData * compdata, OOP_Object * bm)
  87 {
  88     struct StackBitMapNode * n = NULL;
  89
  90     ForeachNode(&compdata->bitmapstack, n)
  91     {
  92         if (n->bm == bm)
  93             return n;
  94     }
  95
  96     return NULL;
  97 }
  98
  99 struct Screen *HIDDCompositorFindBitMapScreen(struct HIDDCompositorData *compdata, OOP_Object *bm)
 100 {
 101     struct Screen *curScreen = NULL;
 102
 103     for (curScreen = IntuitionBase->FirstScreen; curScreen != NULL; curScreen = curScreen->NextScreen)
 104     {
 105         if (bm == HIDD_BM_OBJ(curScreen->RastPort.BitMap))
 106         return curScreen;
 107     }
 108
 109     return (struct Screen *)NULL;
 110 }
 111
 112 static VOID HIDDCompositorValidateBitMapPositionChange(OOP_Object * bm, SIPTR *newxoffset, SIPTR *newyoffset, LONG displayedwidth, LONG displayedheight)
 113 {
 114     IPTR width, height;
 115     LONG neglimit, poslimit;
 116
 117     OOP_GetAttr(bm, aHidd_BitMap_Width, &width);
 118     OOP_GetAttr(bm, aHidd_BitMap_Height, &height);
 119
 120     /* Check x position */
 121     if (width > displayedwidth)
 122     {
 123         neglimit = displayedwidth - width;
 124         poslimit = 0;
 125     }
 126     else
 127     {
 128         neglimit = 0;
 129         poslimit = displayedwidth - width;
 130     }
 131
 132     if (*(newxoffset) > poslimit)
 133         *(newxoffset) = poslimit;
 134     if (*(newxoffset) < neglimit)
 135         *(newxoffset) = neglimit;
 136
 137     /* Check y position */
 138     if (height > displayedheight)
 139         neglimit = displayedheight - height; /* Limit for scroll */
 140     else
 141         neglimit = 0;
 142     poslimit = displayedheight - 15; /* Limit for drag */
 143
 144     if (*(newyoffset) > poslimit)
 145         *(newyoffset) = poslimit;
 146     if (*(newyoffset) < neglimit)
 147         *(newyoffset) = neglimit;
 148 }
 149
 150 static VOID HIDDCompositorRecalculateVisibleRegions(struct HIDDCompositorData *compdata)
 151 {
 152     struct StackBitMapNode      *n = NULL, *tmpn;
 153     struct Region               *dispvisregion = NULL;
 154     ULONG                       oldflags = compdata->flags;
 155
 156     DRECALC(bug("[Compositor:%s] Display rect [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__, _RECT(compdata->displayrect)));
 157
 158     /*
 159      * This function assumes bitmapstack is in correct Z order:
 160      * from topmost to bottom most
 161      */
 162     if ((dispvisregion = NewRegion()) != NULL)
 163     {
 164         OrRectRegion(dispvisregion, &compdata->displayrect);
 165
 166         compdata->flags &= ~COMPSTATEF_HASALPHA;
 167         if (compdata->alpharegion)
 168         {
 169             DisposeRegion(compdata->alpharegion);
 170             compdata->alpharegion = NULL;
 171         }
 172         DRECALC(bug("[Compositor:%s] DisplayRegion @ 0x%p\n", __PRETTY_FUNCTION__, dispvisregion));
 173
 174         ForeachNodeSafe(&compdata->bitmapstack, n, tmpn)
 175         {
 176             /* Get bitmap bounding box in screen coordinates */
 177             struct Rectangle tmprect;
 178
 179             n->sbmflags &= ~STACKNODEF_VISIBLE;
 180
 181             if (n->screenregion)
 182                 ClearRegion(n->screenregion);
 183             else
 184                 n->screenregion = NewRegion();
 185
 186             if (n->screenregion)
 187             {
 188                 tmprect.MinX = n->leftedge;
 189                 tmprect.MaxX = n->leftedge + OOP_GET(n->bm, aHidd_BitMap_Width) - 1;
 190                 tmprect.MinY = n->topedge;
 191                 tmprect.MaxY = n->topedge  + OOP_GET(n->bm, aHidd_BitMap_Height) - 1;
 192
 193                 DRECALC(bug("[Compositor:%s] Screen Rect [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__, _RECT(tmprect)));
 194
 195                 OrRectRegion(n->screenregion, &tmprect); // Start with the Screen's dimensions ..
 196                 AndRegionRegion(dispvisregion, n->screenregion); // And adjust for the "Display"
 197
 198                 if (n->screenregion->RegionRectangle)
 199                 {
 200                     AndRectRect(&n->screenregion->bounds, &compdata->displayrect, &n->screenvisiblerect);
 201
 202                     if (!(n->sbmflags & COMPF_ALPHA))
 203                         ClearRectRegion(dispvisregion, &n->screenvisiblerect);
 204                     else
 205                     {
 206                         compdata->flags |= COMPSTATEF_HASALPHA;
 207                         if (!(compdata->alpharegion))
 208                             compdata->alpharegion = NewRegion();
 209
 210                         OrRectRegion(compdata->alpharegion, &n->screenvisiblerect);
 211                     }
 212
 213                     if (!(compdata->capabilities & COMPF_ABOVE) && !(n->sbmflags & COMPF_ABOVE))
 214                     {
 215                         tmprect.MinX = compdata->displayrect.MinX;
 216                         tmprect.MaxX = compdata->displayrect.MaxX;
 217                         tmprect.MinY = compdata->displayrect.MinY;
 218                         tmprect.MaxY = n->topedge - 1;
 219                         ClearRectRegion(dispvisregion, &tmprect);
 220                     }
 221                     if (!(compdata->capabilities & COMPF_BELOW) && !(n->sbmflags & COMPF_BELOW))
 222                     {
 223                         tmprect.MinX = compdata->displayrect.MinX;
 224                         tmprect.MaxX = compdata->displayrect.MaxX;
 225                         tmprect.MinY = n->topedge  + OOP_GET(n->bm, aHidd_BitMap_Height);
 226                         tmprect.MaxY = compdata->displayrect.MaxY;
 227                         ClearRectRegion(dispvisregion, &tmprect);
 228                     }
 229                     if (!(compdata->capabilities & COMPF_LEFT) && !(n->sbmflags & COMPF_LEFT))
 230                     {
 231                         tmprect.MinX = compdata->displayrect.MinX;
 232                         tmprect.MaxX = n->leftedge - 1;
 233                         tmprect.MinY = n->topedge;
 234                         tmprect.MaxY = n->topedge  + OOP_GET(n->bm, aHidd_BitMap_Height) - 1;
 235                         ClearRectRegion(dispvisregion, &tmprect);
 236                     }
 237                     if (!(compdata->capabilities & COMPF_RIGHT) && !(n->sbmflags & COMPF_RIGHT))
 238                     {
 239                         tmprect.MinX = n->leftedge + OOP_GET(n->bm, aHidd_BitMap_Width);
 240                         tmprect.MaxX = compdata->displayrect.MaxX;
 241                         tmprect.MinY = n->topedge;
 242                         tmprect.MaxY = n->topedge  + OOP_GET(n->bm, aHidd_BitMap_Height) - 1;
 243                         ClearRectRegion(dispvisregion, &tmprect);
 244                     }
 245                     n->sbmflags |= STACKNODEF_VISIBLE;
 246                 }
 247
 248                 DRECALC(bug("[Compositor:%s] HiddBitmap 0x%p, topedge %d, visible %d, [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__,
 249                             n->bm, n->topedge, (n->sbmflags & STACKNODEF_VISIBLE), _RECT(n->screenvisiblerect)));
 250             }
 251             else
 252             {
 253                 DRECALC(bug("[Compositor:%s] Failed to create Screen Region\n", __PRETTY_FUNCTION__));
 254             }
 255         }
 256         DisposeRegion(dispvisregion);
 257         if (compdata->flags != oldflags)
 258         {
 259             ULONG newflags = (~oldflags) & compdata->flags;
 260             DRECALC(bug("[Compositor:%s] Newly set flags %08x\n", __PRETTY_FUNCTION__, newflags));
 261             if ((!(newflags & COMPSTATEF_HASALPHA)) && (oldflags & COMPSTATEF_HASALPHA))
 262             {
 263                 DRECALC(bug("[Compositor:%s] Alpha removed\n", __PRETTY_FUNCTION__));
 264                 if (compdata->alpharegion)
 265                     DisposeRegion(compdata->alpharegion);
 266
 267                 if (compdata->intermedbitmap)
 268                     HIDD_Gfx_DisposeBitMap(compdata->gfx, compdata->intermedbitmap);
 269
 270                 compdata->alpharegion = NULL;
 271                 compdata->intermedbitmap = NULL;
 272             }
 273         }
 274     }
 275     else
 276     {
 277         DRECALC(bug("[Compositor:%s] Failed to create Display Region\n", __PRETTY_FUNCTION__));
 278     }
 279 }
 280
 281 static HIDDT_ModeID FindBestHiddMode(struct HIDDCompositorData *compdata, ULONG width, ULONG height, ULONG depth, ULONG *res_depth)
 282 {
 283     HIDDT_ModeID mode = vHidd_ModeID_Invalid;
 284     OOP_Object *sync, *pf;
 285     IPTR w, h, d;
 286     ULONG dw, dh, delta;
 287     ULONG found_delta  = -1;
 288     ULONG found_width  = 0;
 289     ULONG found_height = 0;
 290     ULONG found_depth  = 0;
 291     HIDDT_ModeID found_mode = vHidd_ModeID_Invalid;
 292
 293     DMODE(bug("[%s] Finding best match for mode %ux%ux%u\n", __PRETTY_FUNCTION__, width, height, depth));
 294
 295     while ((mode = HIDD_Gfx_NextModeID(compdata->gfx, mode, &sync, &pf)) != vHidd_ModeID_Invalid)
 296     {
 297         BOOL match;
 298
 299         DMODE(bug("[%s] Checking mode 0x%08X... ", __PRETTY_FUNCTION__, mode));
 300         if (OOP_GET(pf, aHidd_PixFmt_ColorModel) != vHidd_ColorModel_TrueColor)
 301         {
 302             DMODE(bug("Skipped (not truecolor)\n"));
 303             continue;
 304         }
 305
 306         OOP_GetAttr(sync, aHidd_Sync_HDisp, &w);
 307         OOP_GetAttr(sync, aHidd_Sync_VDisp, &h);
 308         OOP_GetAttr(pf, aHidd_PixFmt_Depth, &d);
 309
 310         dw = w > width  ? w - width  : w < width  ? width  - w : 1;
 311         dh = h > height ? h - height : h < height ? height - h : 1;
 312         delta = dw * dh;
 313
 314         match = FALSE;
 315         if (delta < found_delta)
 316         {
 317             /* If mode resolution is closer to the needed one, we've got a better match */
 318             found_delta  = delta;
 319             found_width  = w;
 320             found_height = h;
 321
 322             match = TRUE;
 323         }
 324         else if (delta == found_delta)
 325         {
 326             /* If resolution is the same as that of current candidate mode, we can look at depth. */
 327             if (found_depth > depth)
 328             {
 329                 /*
 330                  * Candidate mode if deeper than requested. We can supersede it with another mode
 331                  * of smaller depth, but which still matches our request.
 332                  */
 333                 if ((d < found_depth) && (d >= depth))
 334                     match = TRUE;
 335             }
 336             else if (found_depth < depth)
 337             {
 338                 /*
 339                  * We want better depth than current candidate.
 340                  * In this case anything deeper will do.
 341                  */
 342                 if (d > found_depth)
 343                     match = TRUE;
 344             }
 345         }
 346
 347         if (match)
 348         {
 349             /*
 350              * Mode with the same delta, but larger depth, may supersede
 351              * previous mode, if we prefer deeper ones.
 352              */
 353             DMODE(bug("Selected (%ldx%ldx%ld, delta = %u)", w, h, d, delta));
 354             found_depth = d;
 355             found_mode  = mode;
 356         }
 357         DMODE(bug("\n"));
 358     }
 359
 360     /* Store mode information */
 361     compdata->displayrect.MinX = 0;
 362     compdata->displayrect.MinY = 0;
 363     compdata->displayrect.MaxX = found_width  - 1;
 364     compdata->displayrect.MaxY = found_height - 1;
 365     *res_depth = found_depth;
 366
 367     return found_mode;
 368 }
 369
 370 static void UpdateDisplayMode(struct HIDDCompositorData *compdata)
 371 {
 372     struct StackBitMapNode *n;
 373     IPTR                modeid, width = 0, height = 0, depth;
 374     OOP_Object          *sync, *pf;
 375     UBYTE               comp_depth = 16;
 376     ULONG               found_depth;
 377
 378     DSTACK(bug("[Compositor] %s()\n", __PRETTY_FUNCTION__));
 379
 380     /*
 381      * Examine all bitmaps in the stack to figure out the needed depth.
 382      * We need a maximum depth of all depths in order to keep correct colors.
 383      * But not less than 16 bits, because we can't compose on a LUT screen.
 384      *
 385      * If a LUT bitmap is present in the stack (depth < 9), we request truecolor
 386      * screen for better color presentation.
 387      *
 388      * We examine bitmaps in reverse order, in this case 'sync' will hold
 389      * information about the top bitmap when we exit the loop.
 390      * Size of our composited mode needs to be as close as possible to that one.
 391      */
 392     for (n = (struct StackBitMapNode *)compdata->bitmapstack.mlh_TailPred;
 393          n->n.mln_Pred; n = (struct StackBitMapNode *)n->n.mln_Pred)
 394     {
 395         if ((!(n->sbmflags & COMPF_ALPHA)) && (n->sbmflags & STACKNODEF_DISPLAYABLE))
 396         {
 397             OOP_GetAttr(n->bm, aHidd_BitMap_ModeID, &modeid);
 398             HIDD_Gfx_GetMode(compdata->gfx, modeid, &sync, &pf);
 399
 400             if (OOP_GET(pf, aHidd_PixFmt_ColorModel) == vHidd_ColorModel_TrueColor)
 401             {
 402                 OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
 403                 if (depth > comp_depth)
 404                     comp_depth = depth;
 405             }
 406             else
 407             {
 408                 /*
 409                  * If we have a LUT bitmap on stack, we request 24-bit screen
 410                  * for better color transfer.
 411                  */
 412                 comp_depth = 24;
 413             }
 414         }
 415         else
 416         {
 417             IPTR curwidth, curheight;
 418             OOP_GetAttr(n->bm, aHidd_BitMap_Width, &curwidth);
 419             OOP_GetAttr(n->bm, aHidd_BitMap_Height, &curheight);
 420             if (curwidth > width)
 421                 width = curwidth;
 422             if (curheight > height)
 423                 height = curheight;
 424         }
 425     }
 426
 427     if (sync)
 428     {
 429         /* Get the needed size */
 430         OOP_GetAttr(sync, aHidd_Sync_HDisp, &width);
 431         OOP_GetAttr(sync, aHidd_Sync_VDisp, &height);
 432     }
 433
 434     DSTACK(bug("[%s] Prefered mode %ldx%ldx%d\n", __PRETTY_FUNCTION__, width, height, comp_depth));
 435
 436     modeid = FindBestHiddMode(compdata, width, height, comp_depth, &found_depth);
 437     DSTACK(bug("[%s] Composition Display ModeID 0x%08X [current 0x%08X]\n", __PRETTY_FUNCTION__, modeid, compdata->displaymode));
 438
 439     if (modeid != compdata->displaymode)
 440     {
 441         /* The mode is different. Need to prepare information needed for compositing */
 442         struct TagItem gctags[] =
 443         {
 444             { aHidd_GC_Foreground, 0x99999999 },
 445             { TAG_DONE           , 0          }
 446         };
 447
 448         /* Signal mode change */
 449         compdata->displaymode = modeid;
 450         compdata->displaydepth = comp_depth;
 451         compdata->modeschanged = TRUE;
 452
 453         /* Get gray foregound */
 454         if (found_depth < 24)
 455             gctags[0].ti_Data = 0x9492;
 456
 457         OOP_SetAttrs(compdata->gc, gctags);
 458     }
 459 }
 460
 461 static inline void HIDDCompositorRedrawBitmap(struct HIDDCompositorData *compdata, OOP_Object *renderTarget, struct StackBitMapNode *n, struct Rectangle *rect)
 462 {
 463     /* The given rectangle is already in screen coordinate system here */
 464     ULONG blitwidth  = rect->MaxX - rect->MinX + 1;
 465     ULONG blitheight = rect->MaxY - rect->MinY + 1;
 466
 467     DREDRAWBM(bug("[Compositor:%s] Redraw HiddBitMap 0x%p, Rect[%d, %d - %d, %d]\n", __PRETTY_FUNCTION__, n->bm,
 468                   rect->MinX, rect->MinY, rect->MaxX, rect->MaxY));
 469
 470     if (!(n->sbmflags & COMPF_ALPHA))
 471     {
 472         DREDRAWBM(bug("[Compositor:%s] Blitting %dx%d [from %d, %d]\n", __PRETTY_FUNCTION__, blitwidth, blitheight,
 473               rect->MinX - n->leftedge, rect->MinY - n->topedge));
 474
 475         HIDD_Gfx_CopyBox(compdata->gfx, n->bm,
 476                         /* Transform to source bitmap coord system */
 477                         rect->MinX - n->leftedge, rect->MinY - n->topedge,
 478                         renderTarget,
 479                         rect->MinX, rect->MinY, blitwidth, blitheight,
 480                         compdata->gc);
 481     }
 482     else
 483     {
 484         UBYTE *baseaddress;
 485         ULONG width, height, banksize, memsize;
 486         IPTR modulo;
 487
 488         DREDRAWBM(bug("[Compositor:%s] AlphaBlending %dx%d @ %d,%d to %d,%d\n", __PRETTY_FUNCTION__,
 489               blitwidth, blitheight,
 490               rect->MinX - n->leftedge, rect->MinY - n->topedge, rect->MinX, rect->MinY));
 491
 492         if (HIDD_BM_ObtainDirectAccess(n->bm, &baseaddress, &width, &height, &banksize, &memsize))
 493         {
 494             DREDRAWBM(bug("[Compositor:%s] Alpha baseaddress @ 0x%p\n", __PRETTY_FUNCTION__, baseaddress));
 495             OOP_GetAttr(n->bm, aHidd_BitMap_BytesPerRow, &modulo);
 496             HIDD_BM_PutAlphaImage(renderTarget, compdata->gfx , baseaddress + ((rect->MinY - n->topedge) * modulo) + ((rect->MinX - n->leftedge) << 2), modulo,
 497                                                 rect->MinX, rect->MinY, blitwidth, blitheight);
 498             HIDD_BM_ReleaseDirectAccess(n->bm);
 499         }
 500     }
 501 }
 502
 503 static inline void HIDDCompositorFillRect(struct HIDDCompositorData *compdata, OOP_Object *renderTarget, ULONG MinX, ULONG MinY, ULONG MaxX, ULONG MaxY)
 504 {
 505     DREDRAWSCR(bug("[Compositor:%s] Filling [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__,
 506                    MinX, MinY, MaxX, MaxY));
 507
 508     HIDD_BM_FillRect(renderTarget, compdata->gc,
 509                      MinX, MinY, MaxX, MaxY);
 510 }
 511
 512
 513 static VOID HIDDCompositorRedrawAlphaRegions(struct HIDDCompositorData *compdata, struct Rectangle *drawrect)
 514 {
 515     OOP_Object          *renderTarget = compdata->displaybitmap;
 516     struct Rectangle    alpharect;
 517     struct StackBitMapNode *n;
 518     struct BitMap       *backbm;
 519
 520     if (compdata->intermedbitmap)
 521         renderTarget = compdata->intermedbitmap;
 522
 523     DREDRAWSCR(if (drawrect){ bug("[Compositor:%s] Rect [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__, _RECT((*drawrect))); })
 524
 525     OOP_GetAttr(renderTarget, aHidd_BitMap_BMStruct, (IPTR *)&backbm);
 526
 527     // Alpha Regions are drawn in reverse order incase they overlap..
 528     for (n = (struct StackBitMapNode *)compdata->bitmapstack.mlh_TailPred;
 529         n->n.mln_Pred; n = (struct StackBitMapNode *)n->n.mln_Pred)
 530     {
 531         if ((n->sbmflags & STACKNODEF_VISIBLE) &&
 532             (n->sbmflags & COMPF_ALPHA) &&
 533             (n->screenregion))
 534         {
 535             DREDRAWSCR(bug("[Compositor:%s] Alpha Screen Region @ 0x%p HiddBitMap @ 0x%p [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__,
 536                                n->screenregion, n->bm, _RECT(n->screenvisiblerect)));
 537
 538             DREDRAWSCR(bug("[Compositor:%s] Compositing Visible Alpha Regions..\n", __PRETTY_FUNCTION__));
 539
 540             struct RegionRectangle *srrect = n->screenregion->RegionRectangle;
 541             while (srrect)
 542             {
 543                 alpharect.MinX = srrect->bounds.MinX + n->screenregion->bounds.MinX;
 544                 alpharect.MinY = srrect->bounds.MinY + n->screenregion->bounds.MinY;
 545                 alpharect.MaxX = srrect->bounds.MaxX + n->screenregion->bounds.MinX;
 546                 alpharect.MaxY = srrect->bounds.MaxY + n->screenregion->bounds.MinY;
 547
 548                 if (!(drawrect) || AndRectRect(drawrect, &alpharect, &alpharect))
 549                 {
 550                     DREDRAWSCR(bug("[Compositor:%s] Alpha-Region [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__, _RECT(alpharect)));
 551
 552                     if ((n->prealphacomphook) && (backbm != NULL))
 553                         {
 554                             struct HIDD_BackFillHookMsg preprocessmsg;
 555                             preprocessmsg.bounds = &alpharect;
 556                             preprocessmsg.offsetx = 0;
 557                             preprocessmsg.offsety = 0;
 558                             CallHookPkt(n->prealphacomphook, backbm, &preprocessmsg);
 559                         }
 560
 561                     HIDDCompositorRedrawBitmap(compdata, renderTarget, n, &alpharect);
 562                     if (renderTarget == compdata->displaybitmap)
 563                         HIDD_BM_UpdateRect(compdata->displaybitmap,
 564                            alpharect.MinX, alpharect.MinY,
 565                            alpharect.MaxX - alpharect.MinX + 1,
 566                            alpharect.MaxY - alpharect.MinY + 1);
 567                 }
 568                 srrect = srrect->Next;
 569             }
 570         }
 571     }
 572 }
 573
 574 static VOID HIDDCompositorRedrawVisibleRegions(struct HIDDCompositorData *compdata, struct Rectangle *drawrect)
 575 {
 576     OOP_Object          *renderTarget = compdata->displaybitmap;
 577     struct Region       *dispvisregion = NULL;
 578     struct Rectangle    tmprect;
 579     struct BitMap       *clearbm;
 580     struct StackBitMapNode *n;
 581
 582     DREDRAWSCR(bug("[Compositor:%s] Redrawing Display (GfxBase @ 0x%p)\n", __PRETTY_FUNCTION__, GfxBase));
 583
 584     if (!(drawrect))
 585     {
 586         /* Recalculate visible regions */
 587         HIDDCompositorRecalculateVisibleRegions(compdata);
 588     }
 589
 590     if ((compdata->flags & COMPSTATEF_HASALPHA) && (compdata->intermedbitmap))
 591         renderTarget = compdata->intermedbitmap;
 592
 593     if ((dispvisregion = NewRegion()) != NULL)
 594     {
 595         if (drawrect)
 596             OrRectRegion(dispvisregion, drawrect);
 597         else
 598             OrRectRegion(dispvisregion, &compdata->displayrect);
 599
 600         DRECALC(bug("[Compositor:%s] Display rect [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__, _RECT(compdata->displayrect)));
 601
 602         ForeachNode(&compdata->bitmapstack, n)
 603         {
 604             if ((n->sbmflags & STACKNODEF_VISIBLE) &&
 605                 (!(n->sbmflags & COMPF_ALPHA)) &&
 606                 (n->screenregion))
 607             {
 608                 DREDRAWSCR(bug("[Compositor:%s] Screen Region @ 0x%p HiddBitMap @ 0x%p [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__,
 609                                n->screenregion, n->bm, _RECT(n->screenvisiblerect)));
 610
 611                 DREDRAWSCR(bug("[Compositor:%s] Redrawing Visible Screen Regions..\n", __PRETTY_FUNCTION__));
 612                 // Render the visable regions ..
 613                 struct RegionRectangle * srrect = n->screenregion->RegionRectangle;
 614                 while (srrect)
 615                 {
 616                     tmprect.MinX = srrect->bounds.MinX + n->screenregion->bounds.MinX;
 617                     tmprect.MinY = srrect->bounds.MinY + n->screenregion->bounds.MinY;
 618                     tmprect.MaxX = srrect->bounds.MaxX + n->screenregion->bounds.MinX;
 619                     tmprect.MaxY = srrect->bounds.MaxY + n->screenregion->bounds.MinY;
 620
 621                     if (!(drawrect) || AndRectRect(drawrect, &tmprect, &tmprect))
 622                     {
 623                         DREDRAWSCR(bug("[Compositor:%s] Region [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__, _RECT(tmprect)));
 624
 625                         HIDDCompositorRedrawBitmap(compdata, renderTarget, n, &tmprect);
 626                         if (renderTarget == compdata->displaybitmap)
 627                             HIDD_BM_UpdateRect(compdata->displaybitmap,
 628                                tmprect.MinX, tmprect.MinY,
 629                                tmprect.MaxX - tmprect.MinX + 1,
 630                                tmprect.MaxY - tmprect.MinY + 1);
 631                     }
 632                     srrect = srrect->Next;
 633                 }
 634                 ClearRegionRegion(n->screenregion, dispvisregion);
 635             }
 636         }
 637         OOP_GetAttr(renderTarget, aHidd_BitMap_BMStruct, (IPTR *)&clearbm);
 638
 639         struct RegionRectangle * dispclrrect = dispvisregion->RegionRectangle;
 640         while (dispclrrect)
 641         {
 642             struct HIDD_BackFillHookMsg clearmsg;
 643
 644             tmprect.MinX = dispclrrect->bounds.MinX + dispvisregion->bounds.MinX;
 645             tmprect.MinY = dispclrrect->bounds.MinY + dispvisregion->bounds.MinY;
 646             tmprect.MaxX = dispclrrect->bounds.MaxX + dispvisregion->bounds.MinX;
 647             tmprect.MaxY = dispclrrect->bounds.MaxY + dispvisregion->bounds.MinY;
 648
 649             if (!(drawrect) || AndRectRect(drawrect, &tmprect, &tmprect))
 650             {
 651                 DREDRAWSCR(bug("[Compositor:%s] Render Display Void Region [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__, _RECT(tmprect)));
 652
 653                 if (clearbm != NULL)
 654                 {
 655                     clearmsg.bounds = &tmprect;
 656                     clearmsg.offsetx = 0;
 657                     clearmsg.offsety = 0;
 658                     CallHookPkt(compdata->backfillhook, clearbm, &clearmsg);
 659                 }
 660
 661                 if (renderTarget == compdata->displaybitmap)
 662                     HIDD_BM_UpdateRect(compdata->displaybitmap,
 663                        tmprect.MinX, tmprect.MinY,
 664                        tmprect.MaxX - tmprect.MinX + 1,
 665                        tmprect.MaxY - tmprect.MinY + 1);
 666             }
 667             dispclrrect = dispclrrect->Next;
 668         }
 669         if (compdata->flags & COMPSTATEF_HASALPHA)
 670         {
 671             HIDDCompositorRedrawAlphaRegions(compdata, drawrect);
 672         }
 673         DisposeRegion(dispvisregion);
 674     }
 675     if (renderTarget != compdata->displaybitmap)
 676     {
 677         DREDRAWSCR(bug("[Compositor:%s] Copying Alpha Intermediary BitMap\n", __PRETTY_FUNCTION__, _RECT(tmprect)));
 678         if (!(drawrect))
 679         {
 680             HIDD_Gfx_CopyBox(compdata->gfx, renderTarget,
 681                     compdata->displayrect.MinX, compdata->displayrect.MinY,
 682                     compdata->displaybitmap,
 683                     compdata->displayrect.MinX, compdata->displayrect.MinY,
 684                     compdata->displayrect.MaxX - compdata->displayrect.MinX + 1,
 685                     compdata->displayrect.MaxY - compdata->displayrect.MinY + 1,
 686                     compdata->gc);
 687             HIDD_BM_UpdateRect(compdata->displaybitmap,
 688                     compdata->displayrect.MinX, compdata->displayrect.MinY,
 689                     compdata->displayrect.MaxX - compdata->displayrect.MinX + 1,
 690                     compdata->displayrect.MaxY - compdata->displayrect.MinY + 1);
 691         }
 692         else
 693         {
 694             HIDD_Gfx_CopyBox(compdata->gfx, renderTarget,
 695                     drawrect->MinX, drawrect->MinY,
 696                     compdata->displaybitmap,
 697                     drawrect->MinX, drawrect->MinY,
 698                     drawrect->MaxX - drawrect->MinX + 1,
 699                     drawrect->MaxY - drawrect->MinY + 1,
 700                     compdata->gc);
 701             HIDD_BM_UpdateRect(compdata->displaybitmap,
 702                     drawrect->MinX, drawrect->MinY,
 703                     drawrect->MaxX - drawrect->MinX + 1,
 704                     drawrect->MaxY - drawrect->MinY + 1);
 705         }
 706     }
 707 }
 708
 709 /*
 710
 711 There are several cases that needs to be handled in this code. They are documented
 712 below. Please read it before making changes.
 713 etb     = existing topbitmap
 714 ntb     = new top bitmap
 715 sb      = screen bitmap
 716 cb      = composited bitmap
 717 fs      = covers full screen
 718 nfs     = not covers full screen
 719 mA      = mode "A"
 720 mB      = mode "B"
 721 disp()  = dispose
 722 new()   = new
 723
 724 The resulting mode is always that of screen bitmap as set in "effect" column.
 725 The composited bitmap always matches the resulting screen mode or is NULL.
 726
 727 | exiting screen situation          | change         | effect                               |
 728 | USE CASE: SWITCHING BETWEEN FULL SCREEN SCREENS - SAME MODE                               |
 729 | etb->fs, mA, sb==etb, cb==NULL    | ntb->fs, mA    | sb==ntb, cb==NULL                    |
 730 | etb->fs, mA, sb==etb, cb!=NULL    | ntb->fs, mA    | sb==ntb, cb!=NULL                    |
 731 | USE CASE: SWITCHING BETWEEN FULL SCREEN AND NOT FULL SCREEN SCREENS - SAME MODE           |
 732 | etb->fs, mA, sb==etb, cb==NULL    | ntb->nfs, mA   | new(cb), sb==cb, cb!=NULL            |
 733 | etb->fs, mA, sb==etb, cb!=NULL    | ntb->nfs, mA   | sb==cb, cb!=NULL                     |
 734 | USE CASE: SWITCHING BETWEEN NOT FULL SCREEN AND FULL SCREEN SCREENS - SAME MODE           |
 735 | etb->nfs, mA, sb==cb, cb==NULL    | NOT POSSIBLE                                          |
 736 | etb->nfs, mA, sb==cb, cb!=NULL    | ntb->fs, mA    | sb==ntb, cb!=NULL                    |
 737 | USE CASE: SWITCHING BETWEEN NOT FULL SCREEN AND NOT FULL SCREEN SCREENS - SAME MODE       |
 738 | etb->nfs, mA, sb==cb, cb==NULL    | NOT POSSIBLE                                          |
 739 | etb->nfs, mA, sb==cb, cb!=NULL    | ntb->nfs, mA   | sb==cb, cb!=NULL                     |
 740
 741
 742 | USE CASE: SWITCHING BETWEEN FULL SCREEN SCREENS - DIFFERENT MODES                         |
 743 | etb->fs, mA, sb==etb, cb==NULL    | ntb->fs, mB    | sb==ntb, cb==NULL                    |
 744 | etb->fs, mA, sb==etb, cb!=NULL    | ntb->fs, mB    | disp(cb), sb==ntb, cb==NULL          |
 745 | USE CASE: SWITCHING BETWEEN FULL SCREEN AND NOT FULL SCREEN SCREENS - DIFFERENT MODES     |
 746 | etb->fs, mA, sb==etb, cb==NULL    | ntb->nfs, mB   | new(cb), sb==cb, cb!=NULL            |
 747 | etb->fs, mA, sb==etb, cb!=NULL    | ntb->nfs, mB   | disp(cb), new(cb), sb==cb, cb!=NULL  |
 748 | USE CASE: SWITCHING BETWEEN NOT FULL SCREEN AND FULL SCREEN SCREENS - DIFFERENT MODES     |
 749 | etb->nfs, mA, sb==cb, cb==NULL    | NOT POSSIBLE                                          |
 750 | etb->nfs, mA, sb==cb, cb!=NULL    | ntb->fs, mB    | disp(cb), sb==ntb, cb==NULL          |
 751 | USE CASE: SWITCHING BETWEEN NOT FULL SCREEN AND NOT FULL SCREEN SCREENS - DIFFERENT MODES |
 752 | etb->nfs, mA, sb==cb, cb==NULL    | NOT POSSIBLE                                          |
 753 | etb->nfs, mA, sb==cb, cb!=NULL    | ntb->nfs, mB   | disp(cb), new(cb), sb==cb, cb!=NULL  |
 754
 755
 756 | USE CASE: DRAGGING SCREEN DOWN                                                            |
 757 | etb->fs, mA, sb==etb, cb==NULL    | ntb->nfs, mA   | new(cb), sb==cb                      |
 758 | etb->fs, mA, sb==etb, cb!=NULL    | ntb->nfs, mA   | sb==cb                               |
 759 | USE CASE: DRAGGING SCREEN UP                                                              |
 760 | etb->nfs, mA, sb==cb, cb!=NULL    | ntb->fs, mA    | sb==etb                              |
 761 | etb->nfs, mA, sb==cb, cb==NULL    | NOT POSSIBLE                                          |
 762
 763 Resulting rules (order matters):
 764
 765 (a) if ((cb!=NULL) && (etb->mode!=ntb->mode)) {dispose(cb), cb=NULL}
 766 (b) if ((ntb->nfs) && (cb==NULL)) new(cb)
 767 (c) if (ntb->nfs) sb=cb
 768 (d) if (ntb->fs) sb=ntb
 769
 770 Additional rule:
 771 (e) if (oldsb!=sb) modeswitch(sb)
 772
 773 02.09.2011: we don't remember sb any more because we don't handle it in any way. Instead
 774             we either have or don't have displaybitmap. If we have it, composition
 775             is on (sb = cb). If we don't have it, composition is off (sb = ntb).
 776 */
 777 static BOOL HIDDCompositorToggleCompositing(struct HIDDCompositorData *compdata, BOOL newtop)
 778 {
 779     /*
 780      * If the topbitmap covers the complete screen, show it instead of
 781      * displaybitmap. Remember that screen bitmap -> composited bitmap
 782      * mirroring has a negative impact on performance.
 783      */
 784     OOP_Object *oldcompositedbitmap = compdata->displaybitmap;
 785     struct StackBitMapNode *topnode = (struct StackBitMapNode *)compdata->bitmapstack.mlh_Head;
 786     OOP_Object *newsdispbitmap = NULL;
 787     struct BitMap *tmpBM;
 788     struct TagItem bmtags[2];
 789
 790     BOOL ok = TRUE, composit = FALSE;
 791
 792     /* (a) If mode change is needed, enforce opening a new screen */
 793     if (compdata->modeschanged)
 794     {
 795         DTOGGLE(bug("[Compositor:%s] Display Mode changed\n", __PRETTY_FUNCTION__));
 796         compdata->displaybitmap = NULL;
 797     }
 798
 799     bmtags[0].ti_Tag = BMATags_DisplayID;           bmtags[0].ti_Data = (compdata->displayid | compdata->displaymode);
 800     bmtags[1].ti_Tag = TAG_DONE;                    bmtags[1].ti_Data = TAG_DONE;
 801
 802     if ((topnode->topedge > 0) || ((compdata->displayrect.MaxY - compdata->displayrect.MinY + 1) > OOP_GET(topnode->bm, aHidd_BitMap_Height)))
 803         composit = TRUE;
 804     else if ((topnode->leftedge > 0) || ((compdata->displayrect.MaxX - compdata->displayrect.MinX + 1) > OOP_GET(topnode->bm, aHidd_BitMap_Width)))
 805         composit = TRUE;
 806     else if (topnode->sbmflags & COMPF_ALPHA)
 807         composit = TRUE;
 808
 809     if (composit)
 810     {
 811         /* (b) */
 812         if (compdata->displaybitmap == NULL)
 813         {
 814             /*
 815              * displaybitmap == NULL means we were in passthrough mode before,
 816              * or have just changed display mode - set up screen for composition.
 817              */
 818             DTOGGLE(bug("[Compositor:%s] Initialising Display-Compositor..\n", __PRETTY_FUNCTION__));
 819
 820             if (compdata->fb)
 821             {
 822                 /*
 823                  * If our display driver uses a framebuffer, we can reuse it.
 824                  * Copy its original contents back into the bitmap which it replaced,
 825                  * then change framebuffer's video mode.
 826                  * Framebuffer is the only bitmap which can change its ModeID on the fly.
 827                  */
 828                 DTOGGLE(bug("[Compositor:%s] Using Display Famebuffer HiddBitMap @ 0x%p\n", __PRETTY_FUNCTION__, compdata->fb));
 829
 830                  /* Do this comparison in order not to show the framebuffer twice */
 831                 if (oldcompositedbitmap != compdata->fb)
 832                 {
 833                     /*
 834                      * 1. It's legal to show the framebuffer itself. This causes copying
 835                      *    back old bitmap contents and detaching from it.
 836                      * 2. The result of this will always match compdata->fb.
 837                      * 3. Internally this is a simple blit operation, it can't fail.
 838                      */
 839                     DTOGGLE(bug("[Compositor:%s] Copying old Famebuffer BitMap\n", __PRETTY_FUNCTION__));
 840                     compdata->screenbitmap = HIDD_Gfx_Show(compdata->gfx, compdata->fb, fHidd_Gfx_Show_CopyBack);
 841                 }
 842
 843                 /* Switch display mode on the framebuffer. */
 844                 OOP_SetAttrsTags(compdata->fb, aHidd_BitMap_ModeID, compdata->displaymode, TAG_DONE);
 845                 /* We are now compositing on the framebuffer */
 846                 compdata->displaybitmap = compdata->fb;
 847             }
 848             else
 849             {
 850                 /*
 851                  * There's no framebuffer.
 852                  * Create a new bitmap that will be used for compositing.
 853                  */
 854
 855                 tmpBM = AllocBitMap(compdata->displayrect.MaxX - compdata->displayrect.MinX  + 1,
 856                                              compdata->displayrect.MaxY - compdata->displayrect.MinY + 1,
 857                                              compdata->displaydepth,
 858                                              BMF_DISPLAYABLE|BMF_CHECKVALUE, (struct BitMap *)bmtags);
 859                 if (tmpBM)
 860                 {
 861                     compdata->displaybitmap = HIDD_BM_OBJ(tmpBM);
 862                     DTOGGLE(bug("[Compositor:%s] Created Compositor Display BitMap @ 0x%p [HiddBitMap @ 0x%p]\n", __PRETTY_FUNCTION__, tmpBM, compdata->displaybitmap));
 863
 864                     /* Mode changed, this bitmap will be shown later */
 865                     newsdispbitmap = compdata->displaybitmap;
 866
 867                     /* NewBitMap can fail, handle this */
 868                     if (!newsdispbitmap)
 869                         ok = FALSE;
 870                 }
 871             }
 872         }
 873         else /* if (compdata->displaybitmap == NULL) */
 874         {
 875             /*
 876              * We are already in compositing mode and will stay in it.
 877              * Do not destroy our working bitmap.
 878              */
 879             oldcompositedbitmap = NULL;
 880         }
 881
 882         if ((compdata->flags & COMPSTATEF_HASALPHA) && !(compdata->intermedbitmap))
 883         {
 884             tmpBM = AllocBitMap(compdata->displayrect.MaxX - compdata->displayrect.MinX  + 1,
 885                                          compdata->displayrect.MaxY - compdata->displayrect.MinY + 1,
 886                                          compdata->displaydepth,
 887                                          BMF_CHECKVALUE, (struct BitMap *)bmtags);
 888             if (tmpBM)
 889             {
 890                 compdata->intermedbitmap = HIDD_BM_OBJ(tmpBM);
 891                 DTOGGLE(bug("[Compositor:%s] Allocated Alpha Intermediary BitMap @ 0x%p [HiddBitMap @ 0x%p]\n", __PRETTY_FUNCTION__, tmpBM, compdata->intermedbitmap));
 892             }
 893         }
 894         /*
 895          * (c) Here composition is turned on (displaybitmap != NULL).
 896          * Redraw bitmap stack - compensate possible changes
 897          */
 898         if (ok)
 899             HIDDCompositorRedrawVisibleRegions(compdata, NULL);
 900     }
 901     else if (oldcompositedbitmap || newtop)
 902     {
 903         /*
 904          * (d) Set passthrough mode and display the frontmost bitmap.
 905          * This is also triggered by 'newtop' parameter, which tells us
 906          * that frontmost bitmap has been changed, and we need to display a new one.
 907          * Old displaybitmap has been remembered in the beginning. If it's not
 908          * NULL, it will be destroyed in the end.
 909          */
 910         newsdispbitmap = compdata->topbitmap;
 911         compdata->displaybitmap = NULL;
 912     }
 913
 914     DTOGGLE(bug("[Compositor:%s] oldcompbm 0x%p, topbm 0x%p, dispbm 0x%p, newscreenbm 0x%p\n", __PRETTY_FUNCTION__,
 915             oldcompositedbitmap, compdata->topbitmap, compdata->displaybitmap, newsdispbitmap));
 916
 917     /*
 918      * (e) If the screenbitmap changed, show the new screenbitmap.
 919      * We do it after refreshing, for better visual appearance.
 920      */
 921     if (newsdispbitmap)
 922     {
 923         IPTR w, h;
 924
 925         compdata->screenbitmap = HIDD_Gfx_Show(compdata->gfx, newsdispbitmap, fHidd_Gfx_Show_CopyBack);
 926         DTOGGLE(bug("[Compositor:%s] Displayed HiddBitMap 0x%p, Show returned 0x%p\n", __PRETTY_FUNCTION__, newsdispbitmap, compdata->screenbitmap));
 927
 928         /* After Show we need Update for mirroring drivers */
 929         if (compdata->screenbitmap)
 930         {
 931             OOP_GetAttr(compdata->screenbitmap, aHidd_BitMap_Width, &w);
 932             OOP_GetAttr(compdata->screenbitmap, aHidd_BitMap_Height, &h);
 933             HIDD_BM_UpdateRect(compdata->screenbitmap, 0, 0, w, h);
 934         }
 935     }
 936
 937     /*
 938      * (a) - disposing of oldcompositingbitmap needs to happen after mode switch
 939      * since it could have been the current screenbitmap
 940      */
 941     if (oldcompositedbitmap && (oldcompositedbitmap != compdata->fb))
 942     {
 943         struct BitMap *freebm;
 944
 945         DTOGGLE(bug("[Compositor:%s] Disposing old working bitmap 0x%p\n", __PRETTY_FUNCTION__, oldcompositedbitmap));
 946
 947         OOP_GetAttr(oldcompositedbitmap, aHidd_BitMap_BMStruct, (IPTR *)&freebm);
 948         if (freebm != NULL)
 949         {
 950             FreeBitMap(freebm);
 951         }
 952         else
 953             HIDD_Gfx_DisposeBitMap(compdata->gfx, oldcompositedbitmap);
 954
 955     }
 956
 957     /* Handled */
 958     compdata->modeschanged = FALSE;
 959
 960     return ok;
 961 }
 962
 963 static VOID HIDDCompositorPurgeBitMapStack(struct HIDDCompositorData * compdata)
 964 {
 965     struct StackBitMapNode * curr, * next;
 966
 967     ForeachNodeSafe(&compdata->bitmapstack, curr, next)
 968     {
 969         if (curr->screenregion)
 970             DisposeRegion(curr->screenregion);
 971
 972         FreeMem(curr, sizeof(struct StackBitMapNode));
 973     }
 974
 975     NEWLIST(&compdata->bitmapstack);
 976 }
 977
 978 static void HIDDCompositorShowSingle(struct HIDDCompositorData *compdata, OOP_Object *bm)
 979 {
 980     /* Show the single top bitmap */
 981     compdata->topbitmap = bm;
 982     compdata->screenbitmap = HIDD_Gfx_Show(compdata->gfx, bm, fHidd_Gfx_Show_CopyBack);
 983
 984     /* Dispose working bitmap (if any) */
 985     if (compdata->displaybitmap)
 986     {
 987         /* Be careful with the framebuffer */
 988         if (compdata->displaybitmap != compdata->fb)
 989             HIDD_Gfx_DisposeBitMap(compdata->gfx, compdata->displaybitmap);
 990
 991         /* This will deactivate us */
 992         compdata->displaybitmap = NULL;
 993     }
 994 }
 995
 996 /* Emergency error recovery function */
 997 static void HIDDCompositorReset(struct HIDDCompositorData *compdata)
 998 {
 999     /* Purge bitmap stack */
1000     HIDDCompositorPurgeBitMapStack(compdata);
1001
1002     /*
1003      * Reset our internal state so that next BitMapStackChanged
1004      * causes complete reinitialization.
1005      */
1006     compdata->displaymode = vHidd_ModeID_Invalid;
1007     compdata->screenbitmap = NULL;
1008
1009     compdata->flags &= ~COMPSTATEF_HASALPHA;
1010 }
1011
1012 VOID CompositorParseConfig(struct HIDDCompositorData *compdata)
1013 {
1014     struct RDArgs *rdargs;
1015     IPTR CompArgs[NOOFARGS] = { 0 };
1016     TEXT CompConfig[1024];
1017
1018     /* use default amiga-like capabailities */
1019     compdata->capabilities = COMPF_ABOVE;
1020
1021     rdargs = AllocDosObjectTags(DOS_RDARGS, TAG_END);
1022     if (rdargs != NULL)
1023     {
1024         if (GetVar(COMPOSITOR_PREFS, CompConfig, 1024, GVF_GLOBAL_ONLY) != -1)
1025         {
1026             rdargs->RDA_Source.CS_Buffer = CompConfig;
1027             rdargs->RDA_Source.CS_Length = strlen(rdargs->RDA_Source.CS_Buffer);
1028             rdargs->RDA_DAList = (IPTR)NULL;
1029             rdargs->RDA_Buffer = NULL;
1030             rdargs->RDA_BufSiz = 0;
1031             rdargs->RDA_ExtHelp = NULL;
1032             rdargs->RDA_Flags = 0;
1033
1034             if (ReadArgs(COMPOSITOR_PEFSTEMPLATE, CompArgs, rdargs) != NULL)
1035             {
1036                 if (CompArgs[ARG_ABOVE])
1037                     compdata->capabilities |= COMPF_ABOVE;
1038                 else
1039                     compdata->capabilities &= ~COMPF_ABOVE;
1040
1041                 if (CompArgs[ARG_BELOW])
1042                     compdata->capabilities |= COMPF_BELOW;
1043                 else
1044                     compdata->capabilities &= ~COMPF_BELOW;
1045
1046                 if (CompArgs[ARG_LEFT])
1047                     compdata->capabilities |= COMPF_LEFT;
1048                 else
1049                     compdata->capabilities &= ~COMPF_LEFT;
1050
1051                 if (CompArgs[ARG_RIGHT])
1052                     compdata->capabilities |= COMPF_RIGHT;
1053                 else
1054                     compdata->capabilities &= ~COMPF_RIGHT;
1055
1056                 if (CompArgs[ARG_ALPHA])
1057                     compdata->capabilities |= COMPF_ALPHA;
1058                 else
1059                     compdata->capabilities &= ~COMPF_ALPHA;
1060
1061                 FreeArgs(rdargs);
1062             }
1063         }
1064         FreeDosObject(DOS_RDARGS, rdargs);
1065     }
1066 }
1067
1068 AROS_UFH3(void, CompositorDefaultBackFillFunc,
1069     AROS_UFHA(struct Hook *             , h,      A0),
1070     AROS_UFHA(struct BitMap *              , bm,     A2),
1071     AROS_UFHA(struct HIDD_BackFillHookMsg *  , msg,    A1))
1072 {
1073     AROS_USERFUNC_INIT
1074
1075     struct HIDDCompositorData *compdata = h->h_Data;
1076
1077     D(bug("[%s] HIDDCompositorData @ 0x%p\n", __PRETTY_FUNCTION__, compdata));
1078
1079     HIDDCompositorFillRect(compdata, HIDD_BM_OBJ(bm), msg->bounds->MinX, msg->bounds->MinY, msg->bounds->MaxX, msg->bounds->MaxY);
1080
1081     AROS_USERFUNC_EXIT
1082 }
1083
1084 /* PUBLIC METHODS */
1085 OOP_Object *METHOD(Compositor, Root, New)
1086 {
1087     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
1088
1089     if (o)
1090     {
1091         OOP_MethodID disposemid;
1092         struct HIDDCompositorData *compdata = OOP_INST_DATA(cl, o);
1093
1094         D(bug("[%s] Compositor @ 0x%p, data @ 0x%p\n", __PRETTY_FUNCTION__, o, compdata));
1095
1096         CompositorParseConfig(compdata);
1097
1098         compdata->capabilities = (ULONG)GetTagData(aHidd_Compositor_State, compdata->capabilities, msg->attrList);
1099
1100         D(bug("[%s] Compositor Capabilities: %08lx\n", __PRETTY_FUNCTION__, compdata->capabilities));
1101
1102         compdata->displaymode = vHidd_ModeID_Invalid;
1103
1104         NEWLIST(&compdata->bitmapstack);
1105
1106         compdata->defaultbackfill.h_Entry = (HOOKFUNC)AROS_ASMSYMNAME(CompositorDefaultBackFillFunc);
1107         compdata->defaultbackfill.h_Data = compdata;
1108         compdata->backfillhook = &compdata->defaultbackfill;
1109
1110         InitSemaphore(&compdata->semaphore);
1111
1112         compdata->displayid = (ULONG)GetTagData(aHidd_Compositor_DisplayID, 0, msg->attrList);
1113         compdata->gfx = (OOP_Object *)GetTagData(aHidd_Compositor_GfxHidd, 0, msg->attrList);
1114         compdata->fb  = (OOP_Object *)GetTagData(aHidd_Compositor_FrameBuffer, 0, msg->attrList);
1115
1116         D(bug("[%s] DisplayID %08lx for Gfx Driver @ 0x%p\n", __PRETTY_FUNCTION__, compdata->displayid, compdata->gfx));
1117
1118         GfxBase = (APTR)OpenLibrary("graphics.library", 41);
1119         IntuitionBase = (APTR)OpenLibrary("intuition.library", 50);
1120
1121         /* GfxHidd is mandatory */
1122         if ((compdata->GraphicsBase) && (compdata->gfx != NULL))
1123         {
1124             /* Create GC object that will be used for drawing operations */
1125             compdata->gc = HIDD_Gfx_NewGC(compdata->gfx, NULL);
1126
1127             D(bug("[%s] Compositor GC @ %p\n", __PRETTY_FUNCTION__, compdata->gc));
1128
1129             if ((compdata->gfx) && (compdata->gc))
1130                 return o;
1131         }
1132
1133         /* Creation failed */
1134         disposemid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
1135         OOP_CoerceMethod(cl, o, &disposemid);
1136     }
1137
1138     return NULL;
1139 }
1140
1141 void METHOD(Compositor, Root, Dispose)
1142 {
1143
1144     D(
1145         struct HIDDCompositorData *compdata = OOP_INST_DATA(cl, o);
1146         bug("[%s] HIDDCompositorData @ 0x%p\n", __PRETTY_FUNCTION__, compdata);
1147       )
1148
1149     OOP_DoSuperMethod(cl, o, &msg->mID);
1150 }
1151
1152 VOID METHOD(Compositor, Root, Get)
1153 {
1154     ULONG idx;
1155
1156     struct HIDDCompositorData *compdata = OOP_INST_DATA(cl, o);
1157
1158     if (IS_COMPOSITOR_ATTR(msg->attrID, idx))
1159     {
1160         switch (idx)
1161         {
1162             case aoHidd_Compositor_Capabilities:
1163             {
1164                 *msg->storage = (IPTR)CAPABILITY_FLAGS;
1165                 D(bug("[%s] Compositor Capabilities: %lx\n", __PRETTY_FUNCTION__, *msg->storage));
1166                 return;
1167             }
1168             case aoHidd_Compositor_State:
1169             {
1170                 *msg->storage = (IPTR)(compdata->capabilities & CAPABILITY_FLAGS);
1171                 D(bug("[%s] Compositor State: %lx\n", __PRETTY_FUNCTION__, compdata->capabilities));
1172                 return;
1173             }
1174             case aoHidd_Compositor_BackFillHook:
1175             {
1176                 D(bug("[%s] BackFillHook: 0x%p\n", __PRETTY_FUNCTION__, compdata->backfillhook));
1177                 *msg->storage = (IPTR)compdata->backfillhook;
1178                 return;
1179             }
1180         }
1181     }
1182     OOP_DoSuperMethod(cl, o, &msg->mID);
1183 }
1184
1185 VOID METHOD(Compositor, Root, Set)
1186 {
1187     ULONG idx;
1188
1189     struct HIDDCompositorData *compdata = OOP_INST_DATA(cl, o);
1190     struct TagItem *tag, *tstate = msg->attrList;
1191
1192     while ((tag = NextTagItem(&tstate)))
1193     {
1194         if (IS_COMPOSITOR_ATTR(tag->ti_Tag, idx))
1195         {
1196             switch (idx)
1197             {
1198                 case aoHidd_Compositor_State:
1199                 {
1200                     D(bug("[%s] Compositor Capabilities State: %lx -> ", __PRETTY_FUNCTION__, compdata->capabilities));
1201                     compdata->capabilities = (ULONG)(tag->ti_Data & CAPABILITY_FLAGS);
1202                     D(bug("%lx\n", compdata->capabilities));
1203                     break;
1204                 }
1205                 case aoHidd_Compositor_BackFillHook:
1206                 {
1207                     if (tag->ti_Data)
1208                     {
1209                         D(bug("[%s] BackFillHook: 0x%p -> 0x%p\n", __PRETTY_FUNCTION__, compdata->backfillhook, tag->ti_Data));
1210                         compdata->backfillhook = (struct Hook *)tag->ti_Data;
1211                     }
1212                     else
1213                     {
1214                         D(bug("[%s] Default BackFillHook\n", __PRETTY_FUNCTION__));
1215                         compdata->backfillhook = &compdata->defaultbackfill;
1216                     }
1217                     break;
1218                 }
1219             }
1220         }
1221     }
1222
1223     OOP_DoSuperMethod(cl, o, &msg->mID);
1224 }
1225
1226 OOP_Object *METHOD(Compositor, Hidd_Compositor, BitMapStackChanged)
1227 {
1228     struct HIDD_ViewPortData *vpdata;
1229     struct HIDDCompositorData *compdata = OOP_INST_DATA(cl, o);
1230     struct StackBitMapNode *n;
1231     struct Screen *bmScreen;
1232     OOP_Object *bmpxfmt;
1233     int bmstdfmt;
1234     BOOL newtop = FALSE;
1235     BOOL ok = TRUE;
1236
1237     DSTACK(bug("[Compositor] %s: Top bitmap: 0x%lx\n", __PRETTY_FUNCTION__, msg->data->Bitmap));
1238
1239     LOCK_COMPOSITOR_WRITE
1240
1241     /* Free all items which are already on the list */
1242     HIDDCompositorPurgeBitMapStack(compdata);
1243
1244     if (!msg->data)
1245     {
1246         UNLOCK_COMPOSITOR
1247
1248         DSTACK(bug("[Compositor] %s: No ViewPort specified\n", __PRETTY_FUNCTION__));
1249
1250         /* Blank screen */
1251         HIDDCompositorShowSingle(compdata, NULL);
1252
1253         /* We know we are inactive after this */
1254         *msg->active = FALSE;
1255         /* This can return NULL, it's okay */
1256         return compdata->screenbitmap;
1257     }
1258
1259     /* Copy bitmaps pointers to our stack */
1260     for (vpdata = msg->data; vpdata; vpdata = vpdata->Next)
1261     {
1262         n = AllocMem(sizeof(struct StackBitMapNode), MEMF_ANY | MEMF_CLEAR);
1263         if (!n)
1264         {
1265             /*
1266              * Error happened.
1267              * We need to reset own state and return NULL. graphics.library
1268              * falls back to no composition in this case.
1269              */
1270             DSTACK(bug("[Compositor] %s: Error allocating StackBitMapNode!!!\n", __PRETTY_FUNCTION__));
1271
1272             ok = FALSE;
1273             break;
1274         }
1275
1276         DSTACK(bug("[Compositor] %s: ViewPort 0x%p, offset (%d, %d)\n", __PRETTY_FUNCTION__, vpdata->vpe->ViewPort, vpdata->vpe->ViewPort->DxOffset, vpdata->vpe->ViewPort->DyOffset));
1277
1278         n->bm                   = vpdata->Bitmap;
1279         n->sbmflags             = STACKNODEF_DISPLAYABLE;
1280         n->leftedge             = vpdata->vpe->ViewPort->DxOffset;
1281         n->topedge              = vpdata->vpe->ViewPort->DyOffset;
1282
1283         n->screenregion = NewRegion();
1284
1285         if ((bmScreen = HIDDCompositorFindBitMapScreen(compdata, n->bm)) != NULL)
1286         {
1287             DSTACK(bug("[Compositor] %s: Screen @ 0x%p\n", __PRETTY_FUNCTION__, bmScreen));
1288             GetAttr(SA_CompositingFlags, (Object *)bmScreen, &n->sbmflags);
1289             DSTACK(bug("[Compositor] %s: CompositingFlags %08x\n", __PRETTY_FUNCTION__, n->sbmflags));
1290             n->sbmflags |= STACKNODEF_DISPLAYABLE;
1291             if (n->sbmflags & COMPF_ALPHA)
1292             {
1293                 GetAttr(SA_AlphaPreCompositHook, (Object *)bmScreen, (IPTR *)&n->prealphacomphook);
1294                 DSTACK(bug("[Compositor] %s: Pre-AlphaComposit Hook @ 0x%p\n", __PRETTY_FUNCTION__, n->prealphacomphook));
1295             }
1296         }
1297
1298         if (n->sbmflags & COMPF_ALPHA)
1299         {
1300             bmpxfmt = (OOP_Object *)OOP_GET(n->bm, aHidd_BitMap_PixFmt);
1301             bmstdfmt = (int)OOP_GET(bmpxfmt, aHidd_PixFmt_StdPixFmt);
1302             DSTACK(bug("[Compositor] %s: Screen BitMap PixFmt %lx @ 0x%p\n", __PRETTY_FUNCTION__, bmstdfmt, bmpxfmt));
1303
1304             switch (bmstdfmt)
1305             {
1306                 case vHidd_StdPixFmt_ARGB32:
1307                 case vHidd_StdPixFmt_BGRA32:
1308                 case vHidd_StdPixFmt_RGBA32:
1309                 case vHidd_StdPixFmt_ABGR32:
1310                 {
1311                     DSTACK(bug("[Compositor] %s: Screen BitMap has Alpha\n", __PRETTY_FUNCTION__));
1312
1313                     compdata->flags |= COMPSTATEF_HASALPHA;
1314                     break;
1315                 }
1316                 default:
1317                 {
1318                     n->sbmflags &= ~COMPF_ALPHA;
1319                     break;
1320                 }
1321             }
1322         }
1323
1324         if (!(n->sbmflags & COMPF_ALPHA))
1325         {
1326             if ((((BOOL)OOP_GET(n->bm, aHidd_BitMap_Displayable)) != TRUE))
1327                 n->sbmflags &= ~STACKNODEF_DISPLAYABLE;
1328         }
1329         AddTail((struct List *)&compdata->bitmapstack, (struct Node *)n);
1330     }
1331
1332     /* Switch mode if needed */
1333     UpdateDisplayMode(compdata);
1334
1335     if (msg->data->Bitmap != compdata->topbitmap)
1336     {
1337         /* Set the new pointer to top bitmap */
1338         compdata->topbitmap = msg->data->Bitmap;
1339         newtop = TRUE;
1340     }
1341
1342     if (ok)
1343     {
1344         /*
1345          * Validate bitmap offsets - they might not match the compositing rules taking
1346          * new displayedwidth/displayedheight values
1347          */
1348         ForeachNode(&compdata->bitmapstack, n)
1349         {
1350             HIDDCompositorValidateBitMapPositionChange(n->bm, &n->leftedge, &n->topedge,
1351                                                         compdata->displayrect.MaxX + 1, compdata->displayrect.MaxY + 1);
1352             DSTACK(bug("[Compositor] %s: Bitmap 0x%p, display size %d x %d, validated position (%ld, %ld)\n", __PRETTY_FUNCTION__,
1353                        n->bm, compdata->displayrect.MaxX + 1, compdata->displayrect.MaxY + 1,
1354                        n->leftedge, n->topedge));
1355         }
1356
1357         /* Toogle compositing based on screen positions */
1358         ok = HIDDCompositorToggleCompositing(compdata, newtop);
1359     }
1360
1361     /* Handle error */
1362     if (!ok)
1363     {
1364         HIDDCompositorReset(compdata);
1365         HIDDCompositorShowSingle(compdata, msg->data->Bitmap);
1366     }
1367
1368     UNLOCK_COMPOSITOR
1369
1370     DSTACK(bug("[%s] Done, composited bitmap 0x%p\n", __PRETTY_FUNCTION__, compdata->displaybitmap));
1371
1372     /* Tell if the composition is active */
1373     *msg->active = compdata->displaybitmap ? TRUE : FALSE;
1374     /* Return actually displayed bitmap */
1375     return compdata->screenbitmap;
1376 }
1377
1378 VOID METHOD(Compositor, Hidd_Compositor, BitMapRectChanged)
1379 {
1380     struct HIDDCompositorData *compdata = OOP_INST_DATA(cl, o);
1381     OOP_Object                *renderTarget;
1382
1383     if (compdata->displaybitmap)
1384     {
1385         /* Composition is active, handle redraw if the bitmap is on screen */
1386         struct StackBitMapNode *n;
1387
1388         DUPDATE(bug("[%s] Bitmap 0x%p\n", __PRETTY_FUNCTION__, msg->bm));
1389
1390         LOCK_COMPOSITOR_READ
1391
1392         if (compdata->intermedbitmap)
1393             renderTarget = compdata->intermedbitmap;
1394         else
1395             renderTarget = compdata->displaybitmap;
1396
1397         n = HIDDCompositorFindBitMapStackNode(compdata, msg->bm);
1398         if (n && (n->sbmflags & STACKNODEF_VISIBLE))
1399         {
1400             struct Rectangle srcrect, dstandvisrect;
1401
1402             srcrect.MinX = n->leftedge + msg->x;
1403             srcrect.MinY = n->topedge + msg->y;
1404             srcrect.MaxX = srcrect.MinX + msg->width - 1;
1405             srcrect.MaxY = srcrect.MinY + msg->height - 1;
1406             DUPDATE(bug("[%s] Bitmap rect [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__, msg->x, msg->y, msg->x + msg->width - 1, msg->y + msg->height - 1));
1407
1408             DUPDATE(bug("[%s] Screen-relative rect [%d, %d - %d, %d]\n", __PRETTY_FUNCTION__, _RECT(srcrect)));
1409
1410             struct RegionRectangle * srrect = n->screenregion->RegionRectangle;
1411             while (srrect)
1412             {
1413                 BOOL updateAlphaBmps = FALSE;
1414
1415                 dstandvisrect.MinX = srrect->bounds.MinX + n->screenregion->bounds.MinX;
1416                 dstandvisrect.MinY = srrect->bounds.MinY + n->screenregion->bounds.MinY;
1417                 dstandvisrect.MaxX = srrect->bounds.MaxX + n->screenregion->bounds.MinX;
1418                 dstandvisrect.MaxY = srrect->bounds.MaxY + n->screenregion->bounds.MinY;
1419
1420                 if (AndRectRect(&srcrect, &dstandvisrect, &dstandvisrect))
1421                 {
1422                     /* Intersection is valid. Blit. */
1423                     DUPDATE(bug("[%s] Clipped rect (%d, %d) - (%d, %d)\n", __PRETTY_FUNCTION__, _RECT(dstandvisrect)));
1424
1425                     if (!(n->sbmflags & COMPF_ALPHA))
1426                     {
1427                         if ((compdata->alpharegion) && (isRectInRegion(compdata->alpharegion, &dstandvisrect)))
1428                         {
1429                             DUPDATE(bug("[%s] ** Bitmap in Alpha Region!\n", __PRETTY_FUNCTION__));
1430                             updateAlphaBmps = TRUE;
1431                         }
1432                         HIDDCompositorRedrawBitmap(compdata, renderTarget, n, &dstandvisrect);
1433                     }
1434                     else
1435                     {
1436                         updateAlphaBmps = FALSE;
1437                         HIDDCompositorRedrawVisibleRegions(compdata, &dstandvisrect);
1438                     }
1439
1440                     if (updateAlphaBmps)
1441                         HIDDCompositorRedrawAlphaRegions(compdata, &dstandvisrect);
1442
1443                     if (renderTarget != compdata->displaybitmap)
1444                     {
1445                         HIDD_Gfx_CopyBox(compdata->gfx, renderTarget,
1446                                 dstandvisrect.MinX, dstandvisrect.MinY,
1447                                 compdata->displaybitmap,
1448                                 dstandvisrect.MinX, dstandvisrect.MinY,
1449                                 dstandvisrect.MaxX - dstandvisrect.MinX + 1,
1450                                 dstandvisrect.MaxY - dstandvisrect.MinY + 1,
1451                                 compdata->gc);
1452                     }
1453
1454                     HIDD_BM_UpdateRect(compdata->displaybitmap,
1455                                        dstandvisrect.MinX, dstandvisrect.MinY,
1456                                        dstandvisrect.MaxX - dstandvisrect.MinX + 1,
1457                                        dstandvisrect.MaxY - dstandvisrect.MinY + 1);
1458                 }
1459                 srrect = srrect->Next;
1460             }
1461         }
1462
1463         UNLOCK_COMPOSITOR
1464
1465         DUPDATE(bug("[%s] Done\n", __PRETTY_FUNCTION__));
1466     }
1467     else
1468     {
1469         /* In order to speed things up, we handle passthrough ourselves here. */
1470         HIDD_BM_UpdateRect(msg->bm, msg->x, msg->y, msg->width, msg->height);
1471     }
1472 }
1473
1474 IPTR METHOD(Compositor, Hidd_Compositor, BitMapPositionChange)
1475 {
1476     struct HIDDCompositorData *compdata = OOP_INST_DATA(cl, o);
1477     struct StackBitMapNode *n;
1478     IPTR disp_width, disp_height;
1479
1480     LOCK_COMPOSITOR_READ
1481
1482     n = HIDDCompositorFindBitMapStackNode(compdata, msg->bm);
1483     if (n)
1484     {
1485         /* The bitmap is on display. Validate against screen size */
1486         disp_width  = compdata->displayrect.MaxX + 1;
1487         disp_height = compdata->displayrect.MaxY + 1;
1488     }
1489     else
1490     {
1491         /* The bitmap is not displayed yet. Validate against its own ModeID size. */
1492         HIDDT_ModeID modeid = vHidd_ModeID_Invalid;
1493         OOP_Object *bmfriend, *sync, *pf;
1494
1495         OOP_GetAttr(msg->bm, aHidd_BitMap_ModeID, &modeid);
1496
1497         if ((modeid == vHidd_ModeID_Invalid) && (OOP_GET(msg->bm, aHidd_BitMap_Compositable)))
1498         {
1499             OOP_GetAttr(msg->bm, aHidd_BitMap_Friend, (IPTR *)&bmfriend);
1500             if (bmfriend)
1501                 OOP_GetAttr(bmfriend, aHidd_BitMap_ModeID, &modeid);
1502         }
1503
1504         if (modeid == vHidd_ModeID_Invalid)
1505         {
1506             /*
1507                 * Nondisplayable bitmaps don't scroll.
1508                 * In fact they simply can't get in here because MakeVPort() performs the validation.
1509                 * But who knows what bug can slip into someone's software...
1510                 */
1511             UNLOCK_COMPOSITOR
1512             return FALSE;
1513         }
1514
1515         HIDD_Gfx_GetMode(compdata->gfx, modeid, &sync, &pf);
1516         OOP_GetAttr(sync, aHidd_Sync_HDisp, &disp_width);
1517         OOP_GetAttr(sync, aHidd_Sync_VDisp, &disp_height);
1518     }
1519
1520     DMOVE(bug("[%s] Validating bitmap 0x%p, position (%ld, %ld), limits %ld x %ld\n", __PRETTY_FUNCTION__,
1521           msg->bm, *msg->newxoffset, *msg->newyoffset, disp_width, disp_height));
1522
1523     HIDDCompositorValidateBitMapPositionChange(msg->bm, msg->newxoffset, msg->newyoffset,
1524                                                 disp_width, disp_height);
1525
1526     DMOVE(bug("[%s] Validated position (%ld, %ld)\n", __PRETTY_FUNCTION__, *msg->newxoffset, *msg->newyoffset));
1527
1528     if (n && ((*msg->newxoffset != n->leftedge) || (*msg->newyoffset != n->topedge)))
1529     {
1530         DMOVE(bug("[%s] Old position (%ld, %ld)\n", __PRETTY_FUNCTION__, n->leftedge, n->topedge));
1531
1532         /* Reflect the change if it happened */
1533         n->leftedge = *msg->newxoffset;
1534         n->topedge  = *msg->newyoffset;
1535
1536         if (compdata->topbitmap == msg->bm)
1537         {
1538             /*
1539              * If this is the frontmost bitmap, we may want to toggle compositing,
1540              * if it starts/stops covering the whole screen at one point.
1541              * We don't need to call HIDDCompositorRedrawVisibleRegions() here because
1542              * HIDDCompositorToggleCompositing() does this itself, for improved
1543              * visual appearance.
1544              */
1545             HIDDCompositorToggleCompositing(compdata, FALSE);
1546         }
1547         else
1548             HIDDCompositorRedrawVisibleRegions(compdata, NULL);
1549     }
1550
1551     UNLOCK_COMPOSITOR
1552
1553     /* Return active state */
1554     return compdata->displaybitmap ? TRUE : FALSE;
1555 }
1556
1557 IPTR METHOD(Compositor, Hidd_Compositor, BitMapValidate)
1558 {
1559     if (IS_HIDD_BM(msg->bm))
1560         return TRUE;
1561
1562     return FALSE;
1563 }
1564
1565 IPTR METHOD(Compositor, Hidd_Compositor, BitMapEnable)
1566 {
1567     if (IS_HIDD_BM(msg->bm))
1568     {
1569         if (!(OOP_GET(HIDD_BM_OBJ(msg->bm), aHidd_BitMap_Displayable)))
1570         {
1571             struct TagItem composittags[] = {
1572                 {aHidd_BitMap_Compositable, TRUE},
1573                 {TAG_DONE            , 0    }
1574             };
1575
1576             D(bug("[GfxCompositor]: Marking BitMap 0x%lx as Compositable\n", msg->bm));
1577             OOP_SetAttrs(HIDD_BM_OBJ(msg->bm), composittags);
1578         }
1579         return TRUE;
1580     }
1581
1582     return FALSE;
1583 }
1584
1585 #define NUM_Compositor_Root_METHODS 4
1586
1587 static const struct OOP_MethodDescr Compositor_Root_descr[] =
1588 {
1589     {(OOP_MethodFunc)Compositor__Root__New, moRoot_New},
1590     {(OOP_MethodFunc)Compositor__Root__Dispose, moRoot_Dispose},
1591     {(OOP_MethodFunc)Compositor__Root__Get, moRoot_Get},
1592     {(OOP_MethodFunc)Compositor__Root__Set, moRoot_Set},
1593     {NULL, 0}
1594 };
1595
1596 #define NUM_Compositor_Hidd_Compositor_METHODS 5
1597
1598 static const struct OOP_MethodDescr Compositor_Hidd_Compositor_descr[] =
1599 {
1600     {(OOP_MethodFunc)Compositor__Hidd_Compositor__BitMapStackChanged, moHidd_Compositor_BitMapStackChanged},
1601     {(OOP_MethodFunc)Compositor__Hidd_Compositor__BitMapRectChanged, moHidd_Compositor_BitMapRectChanged},
1602     {(OOP_MethodFunc)Compositor__Hidd_Compositor__BitMapPositionChange, moHidd_Compositor_BitMapPositionChange},
1603     {(OOP_MethodFunc)Compositor__Hidd_Compositor__BitMapValidate, moHidd_Compositor_BitMapValidate},
1604     {(OOP_MethodFunc)Compositor__Hidd_Compositor__BitMapEnable, moHidd_Compositor_BitMapEnable},
1605     {NULL, 0}
1606 };
1607
1608 const struct OOP_InterfaceDescr Compositor_ifdescr[] =
1609 {
1610     {Compositor_Root_descr, IID_Root, NUM_Compositor_Root_METHODS},
1611     {Compositor_Hidd_Compositor_descr, IID_Hidd_Compositor, NUM_Compositor_Hidd_Compositor_METHODS},
1612     {NULL, NULL}
1613 };