rom/hyperlayers/createlayertaglist.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/libcall.h>
   7 #include <graphics/clip.h>
   8 #include <graphics/layers.h>
   9 #include <intuition/extensions.h>
  10 #include <utility/tagitem.h>
  11 #include <proto/exec.h>
  12 #include <proto/utility.h>
  13 #include <proto/graphics.h>
  14 #include <proto/layers.h>
  15
  16 #include "basicfuncs.h"
  17 #include "layers_intern.h"
  18
  19 /*
  20  * LA_InFrontOf and LA_Behind are intentionally left
  21  * because they allow to implement AmigaOS4-compatible functionality.
  22  */
  23 struct Layer *CreateLayerTagList(struct Layer_Info *li, struct BitMap *bm, LONG x0, LONG y0,
  24                                  LONG x1, LONG y1, LONG flags, int priority, struct TagItem *tagList,
  25                                  struct LayersBase *LayersBase)
  26 {
  27   struct BitMap * superbitmap = NULL;
  28   struct Hook * hook = NULL, *shapehook = NULL;
  29   APTR win = 0;
  30   int visible = TRUE;
  31   struct Layer * behind = NULL, * infrontof = NULL, * parent = NULL;
  32   struct Layer * l;
  33   struct Region * layershape = NULL, *shape;
  34   struct TagItem *tag, *tstate = tagList;
  35
  36   while((tag = NextTagItem(&tstate)))
  37   {
  38     switch (tag->ti_Tag)
  39     {
  40     case LA_BackfillHook:
  41         hook = (struct Hook *)tag->ti_Data;
  42         break;
  43
  44     case LA_SuperBitMap:
  45         superbitmap = (struct BitMap *)tag->ti_Data;
  46         break;
  47
  48     case LA_ChildOf:
  49         parent = (struct Layer *)tag->ti_Data;
  50         break;
  51
  52     case LA_InFrontOf:
  53         infrontof = (struct Layer *)tag->ti_Data;
  54         break;
  55
  56     case LA_Behind:
  57         behind = (struct Layer *)tag->ti_Data;
  58         break;
  59
  60     case LA_Hidden:
  61         visible = !tag->ti_Data;
  62         break;
  63
  64     case LA_ShapeRegion:
  65         layershape = (struct Region *)tag->ti_Data;
  66         break;
  67
  68     case LA_ShapeHook:
  69         shapehook = (struct Hook *)tag->ti_Data;
  70         break;
  71
  72     case LA_WindowPtr:
  73         win = (APTR)tag->ti_Data;
  74         break;
  75
  76     }
  77
  78   } /* while((tag = NextTagItem(&tstate))) */
  79
  80   if ((flags & LAYERSUPER) && (NULL == superbitmap))
  81     return NULL;
  82
  83   if (!parent)
  84   {
  85     parent = li->check_lp;
  86     if (!parent)
  87     {
  88       /* Root layer not yet installed */
  89
  90       if (priority != ROOTPRIORITY) /* avoid endless recursion */
  91       {
  92         struct TagItem tags[] =
  93         {
  94             {LA_Hidden, TRUE            },
  95             {TAG_DONE                   }
  96         };
  97
  98         if (!(CreateLayerTagList(li,
  99                                  bm,
 100                                  0,
 101                                  0,
 102                                  GetBitMapAttr(bm, BMA_WIDTH) - 1,
 103                                  GetBitMapAttr(bm, BMA_HEIGHT) - 1,
 104                                  0,
 105                                  ROOTPRIORITY,
 106                                  tags,
 107                                  LayersBase)))
 108         {
 109           li->check_lp = NULL;
 110           return NULL;
 111         }
 112
 113         parent = li->check_lp;
 114       }
 115     }
 116   }
 117
 118   /*
 119    * User gives coordinates reltive to parent.
 120    * Adjust the shape to the absolute coordinates
 121    * If this is the root layer, I don't have to
 122    * do anything. I recognize the root layer if there
 123    * is no parent.
 124    */
 125
 126   if (infrontof && infrontof->priority > priority)
 127     return NULL;
 128
 129   if (behind && behind->priority < priority)
 130     return NULL;
 131
 132   /* First create the shape region relative to nothing, that is 0,0 origin */
 133
 134   shape = NewRectRegion(0, 0, x1 - x0, y1 - y0);
 135   if (!shape)
 136     return NULL;
 137
 138   if (shapehook)
 139   {
 140         struct ShapeHookMsg msg;
 141         struct Rectangle NewBounds, OldBounds;
 142
 143         msg.NewShape  = layershape;
 144         msg.OldShape  = layershape;
 145         msg.NewBounds = &NewBounds;
 146         msg.OldBounds = &OldBounds;
 147
 148         NewBounds.MinX = x0;
 149         NewBounds.MinY = y0;
 150         NewBounds.MaxX = x1;
 151         NewBounds.MaxY = y1;
 152         OldBounds.MinX = 0;
 153         OldBounds.MinY = 0;
 154         OldBounds.MaxX = 0;
 155         OldBounds.MaxY = 0;
 156
 157         if (CallHookPkt(shapehook, NULL, &msg))
 158             layershape = msg.NewShape;
 159   }
 160
 161   if (layershape) if (!AndRegionRegion(layershape, shape))
 162   {
 163     DisposeRegion(shape);
 164     return NULL;
 165   }
 166
 167   if (parent)
 168   {
 169     /* Convert from parent layer relative coords to screen relative coords */
 170
 171     x0 += parent->bounds.MinX;
 172     y0 += parent->bounds.MinY;
 173     x1 += parent->bounds.MinX;
 174     y1 += parent->bounds.MinY;
 175   }
 176
 177   /* Make shape region relative to screen */
 178   _TranslateRect(&shape->bounds, x0, y0);
 179
 180   l  = AllocMem(sizeof(struct IntLayer), MEMF_CLEAR|MEMF_PUBLIC);
 181   if (l)
 182   {
 183     IL(l)->shapehook = shapehook;
 184     l->Window = win;
 185     l->shaperegion = layershape;
 186     l->rp = &IL(l)->rp;
 187
 188     InitRastPort(l->rp);
 189     l->rp->Layer = l;
 190     l->rp->BitMap = bm;
 191
 192     l->Flags = (WORD) flags;
 193     l->LayerInfo = li;
 194
 195     l->SuperBitMap = superbitmap;
 196     l->BackFill = hook;
 197     l->priority = priority;
 198
 199     InitSemaphore(&l->Lock);
 200
 201     l->shape = shape;
 202     l->bounds.MinX = x0;
 203     l->bounds.MaxX = x1;
 204     l->bounds.MinY = y0;
 205     l->bounds.MaxY = y1;
 206     l->Width  = x1 - x0 + 1;
 207     l->Height = y1 - y0 + 1;
 208
 209     LockLayer(0, l);
 210
 211     if (NULL == (l->DamageList = NewRegion()))
 212       goto failexit;
 213     if (NULL == (l->VisibleRegion = NewRegion()))
 214       goto failexit;
 215     if (NULL == (l->visibleshape = NewRegion()))
 216       goto failexit;
 217
 218     l->visible = visible;
 219
 220     if (NULL == li->check_lp)
 221       li->check_lp = l;
 222
 223     l->parent = parent;
 224
 225     if (parent)
 226       l->nesting = parent->nesting+1;
 227     else
 228       l->nesting = 0;
 229
 230     LockLayers(li);
 231
 232
 233     /*
 234      * If neither a layer in front or behind is
 235      * given the search for the place according to
 236      * the priority and insert it there. I
 237      * determine behind or infrontof here!
 238      */
 239     if (NULL != li->top_layer)
 240     {
 241       if (!infrontof && !behind)
 242       {
 243         int end = FALSE;
 244         struct Layer * lastgood;
 245         infrontof = parent;
 246
 247         do
 248         {
 249           lastgood = infrontof;
 250           infrontof = infrontof->front;
 251           if (NULL == infrontof)
 252           {
 253             infrontof = lastgood;
 254             break;
 255           }
 256           if (infrontof->parent != l->parent)
 257           {
 258             infrontof = lastgood;
 259             break;
 260           }
 261           while (infrontof->nesting >= l->nesting)
 262           {
 263             lastgood = infrontof;
 264             infrontof = infrontof->front;
 265             if (NULL == infrontof ||
 266                 infrontof->priority > l->priority)
 267             {
 268               infrontof = lastgood;
 269               end = TRUE;
 270               break;
 271             }
 272           }
 273
 274
 275         }
 276         while (FALSE == end);
 277
 278       }
 279     }
 280
 281     if (infrontof || (NULL == behind))
 282     {
 283       if (NULL == infrontof)
 284         infrontof = li->top_layer;
 285
 286       if (li->top_layer == infrontof)
 287       {
 288         li->top_layer = l;
 289         l->front  = NULL;
 290         l->back   = infrontof;
 291         if (NULL != infrontof)
 292           infrontof->front = l;
 293       }
 294       else
 295       {
 296         l->front = infrontof->front;
 297         l->back  = infrontof;
 298         infrontof->front->back = l;
 299         infrontof->front = l;
 300       }
 301     }
 302     else if (behind)
 303     {
 304       l->front = behind;
 305       l->back  = behind->back;
 306       if (l->back)
 307         l->back->front = l;
 308       behind->back = l;
 309     }
 310
 311
 312
 313     SetRegion(l->shape, l->visibleshape);
 314     if (l->parent)
 315       AndRegionRegion(l->parent->shape, l->visibleshape);
 316
 317
 318     if (IS_VISIBLE(l))
 319     {
 320       /*
 321        * layer is to be visible
 322        */
 323       struct Layer * _l = l->back;
 324       struct Layer * lparent = l->parent;
 325
 326       /*
 327        * Does this layer have a layer in front of it?
 328        * If yes, then take that layer's VisibleRegion and
 329        * cut out that layer's shape. This is then the
 330        * VisibleRegion of my layer.
 331        */
 332       if (l->front)
 333       {
 334         SetRegion(l->front->VisibleRegion, l->VisibleRegion);
 335         ClearRegionRegion(l->front->visibleshape, l->VisibleRegion);
 336       }
 337       else
 338         SetRegion(li->check_lp->shape, l->VisibleRegion);
 339
 340
 341       /*
 342        * First tell all layers behind this layer to
 343        * back up their parts that the new layer will
 344        * be hiding.
 345        */
 346       while (1)
 347       {
 348         if (IS_VISIBLE(_l) && DO_OVERLAP(&l->shape->bounds, &_l->shape->bounds))
 349           _BackupPartsOfLayer(_l, l->visibleshape, 0, FALSE, LayersBase);
 350         else
 351           ClearRegionRegion(l->visibleshape, _l->VisibleRegion);
 352
 353         if (_l == lparent)
 354         {
 355           if (IS_VISIBLE(_l) || (NULL == lparent->parent))
 356             break;
 357           else
 358             lparent = lparent->parent;
 359         }
 360         _l = _l->back;
 361       }
 362
 363     }
 364     /*
 365      * Show the layer according to its visible area
 366      * This function creates the cliprects in the area
 367      * of the layer.
 368      * This also works for invisible layers since their Visible
 369      * Region is non existent.
 370      */
 371     if (!IS_ROOTLAYER(l))
 372       _ShowLayer(l, LayersBase);
 373   }
 374   else
 375     goto failexit;
 376
 377   UnlockLayers(li);
 378
 379   return l;
 380
 381 failexit:
 382   if (l)
 383   {
 384     if (l->VisibleRegion)
 385       DisposeRegion(l->VisibleRegion);
 386     if (l->DamageList)
 387       DisposeRegion(l->DamageList);
 388     if (l->visibleshape)
 389       DisposeRegion(l->visibleshape);
 390     FreeMem(l, sizeof(struct IntLayer));
 391   }
 392
 393   return NULL;
 394 } /* CreateBehindHookLayer */