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