rom/hyperlayers/movesizelayer.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8
   9 #include <aros/libcall.h>
  10 #include <aros/debug.h>
  11 #include <proto/layers.h>
  12 #include <proto/exec.h>
  13 #include <proto/graphics.h>
  14 #include <proto/utility.h>
  15 #include <exec/memory.h>
  16 #include <graphics/rastport.h>
  17 #include <graphics/clip.h>
  18
  19 #include "layers_intern.h"
  20 #include "basicfuncs.h"
  21
  22 /*****************************************************************************
  23
  24     NAME */
  25
  26         AROS_LH5(LONG, MoveSizeLayer,
  27
  28 /*  SYNOPSIS */
  29         AROS_LHA(struct Layer *, l , A0),
  30         AROS_LHA(LONG          , dx, D0),
  31         AROS_LHA(LONG          , dy, D1),
  32         AROS_LHA(LONG          , dw, D2),
  33         AROS_LHA(LONG          , dh, D3),
  34
  35 /*  LOCATION */
  36         struct LayersBase *, LayersBase, 30, Layers)
  37
  38 /*  FUNCTION
  39         Moves and resizes the layer in one step. Collects damage lists
  40         for those layers that become visible and are simple layers.
  41         If the layer to be moved is becoming larger the additional
  42         areas are added to a damagelist if it is a non-superbitmap
  43         layer. Refresh is also triggered for this layer.
  44
  45     INPUTS
  46         l     - pointer to layer to be moved
  47         dx    - delta to add to current x position
  48         dy    - delta to add to current y position
  49         dw    - delta to add to current width
  50         dw    - delta to add to current height
  51
  52     RESULT
  53         result - TRUE if everything went right
  54                  FALSE if an error occurred (out of memory)
  55
  56     NOTES
  57
  58     EXAMPLE
  59
  60     BUGS
  61
  62     SEE ALSO
  63
  64     INTERNALS
  65
  66 *****************************************************************************/
  67 {
  68   AROS_LIBFUNC_INIT
  69
  70   struct Layer * first, *_l, *lparent;
  71   struct Region * newshape, * oldshape, r, rtmp, cutnewshape;
  72   struct Region *clipregion, *olddamage = NULL;
  73   struct Rectangle rectw, recth;
  74
  75   InitRegion(&r);
  76   InitRegion(&rtmp);
  77   InitRegion(&cutnewshape);
  78
  79   LockLayers(l->LayerInfo);
  80
  81   clipregion = _InternalInstallClipRegion(l, NULL, 0, 0, LayersBase);
  82
  83   /* There's a little problem with CopyClipRectsToClipRects(). It
  84      may call the backfill hook for the whole DamageList region.
  85      Layers should never do this. It should call backfill hook only
  86      for *new* damage, a layer operation causes. But not for those
  87      areas which were part of the damage already before the layer
  88      operation. Otherwise those latter areas might end up being
  89      backfilled multiple times -> flickering. As fixing CopyClipRects-
  90      ToClipRects() seems kinda complicated, I use a little trick: Set
  91      a flag which tells the layer's backfillhook calling function not to do
  92      that. Before executing the movesizelayer operation I backup the old
  93      damage region, and after executing of movesizelayer operation is done
  94      I can use it to find out what areas were added to the damageregion.
  95      I'll clear that special layer flag, and call the backfill hook for the
  96      new damage areas. (stegerg) */
  97
  98   if (IS_SIMPLEREFRESH(l))
  99   {
 100     olddamage = NewRegion();
 101     if (olddamage)
 102     {
 103       OrRegionRegion(l->DamageList, olddamage);
 104       _TranslateRect(&olddamage->bounds, l->bounds.MinX, l->bounds.MinY);
 105       AndRegionRegion(l->VisibleRegion, olddamage);
 106       AndRegionRegion(l->visibleshape, olddamage);
 107       _TranslateRect(&olddamage->bounds, -l->bounds.MinX, -l->bounds.MinY);
 108
 109       IL(l)->intflags |= INTFLAG_AVOID_BACKFILL;
 110     }
 111   }
 112
 113   /*
 114    * First Create the new region of the layer:
 115    * adjust its size and position.
 116    */
 117
 118
 119   /* First create newshape with 0,0 origin, because l->shaperegion is in layer coords */
 120
 121   newshape = NewRectRegion(0,
 122                            0,
 123                            l->bounds.MaxX - l->bounds.MinX + dw,
 124                            l->bounds.MaxY - l->bounds.MinY + dh);
 125
 126   if (IL(l)->shapehook)
 127   {
 128     struct ShapeHookMsg msg;
 129     struct Rectangle NewBounds;
 130
 131     if ((dx || dy) && (dw || dh))
 132     {
 133         msg.Action = SHAPEHOOKACTION_MOVESIZELAYER;
 134     }
 135     else if (dx || dy)
 136     {
 137         msg.Action = SHAPEHOOKACTION_MOVELAYER;
 138     }
 139     else
 140     {
 141         msg.Action = SHAPEHOOKACTION_SIZELAYER;
 142     }
 143
 144     msg.NewShape  = l->shaperegion;
 145     msg.OldShape  = l->shaperegion;
 146     msg.NewBounds = &NewBounds;
 147     msg.OldBounds = &l->bounds;
 148
 149     NewBounds.MinX = l->bounds.MinX + dx;
 150     NewBounds.MinY = l->bounds.MinY + dy;
 151     NewBounds.MaxX = l->bounds.MaxX + dx + dw;
 152     NewBounds.MaxY = l->bounds.MaxY + dy + dh;
 153
 154     if (CallHookPkt(IL(l)->shapehook, l, &msg))
 155         l->shaperegion = msg.NewShape;
 156   }
 157
 158   if (l->shaperegion)
 159     AndRegionRegion(l->shaperegion, newshape);
 160
 161   /* Now make newshape relative to old(!!) layer screen coords */
 162   _TranslateRect(&newshape->bounds, l->bounds.MinX+dx, l->bounds.MinY+dy);
 163
 164   /* rectw and recth are now only needed for backfilling if layer got bigger -> see end of func */
 165
 166   if (dw > 0)
 167   {
 168     rectw.MinX = dx+l->bounds.MaxX+1;
 169     rectw.MinY = dy+l->bounds.MinY;
 170     rectw.MaxX = rectw.MinX + dw - 1;
 171     rectw.MaxY = dy+l->bounds.MaxY+dh;
 172   }
 173
 174   if (dh > 0)
 175   {
 176     recth.MinX = dx+l->bounds.MinX;
 177     recth.MinY = dy+l->bounds.MaxY + 1;
 178     recth.MaxX = dx+l->bounds.MaxX+dw;
 179     recth.MaxY = recth.MinY + dh - 1;
 180   }
 181
 182   SetRegion(newshape, &cutnewshape);
 183   AndRegionRegion(l->parent->visibleshape, &cutnewshape);
 184
 185   first = GetFirstFamilyMember(l);
 186   /*
 187    * Must make a copy of the VisibleRegion of the first visible layer here
 188    * and NOT later!
 189    */
 190   _l = first;
 191   while (1)
 192   {
 193     if (IS_VISIBLE(_l))
 194     {
 195       SetRegion(_l->VisibleRegion, &r);
 196       break;
 197     }
 198
 199     if (l == _l)
 200       break;
 201
 202     _l = _l->back;
 203   }
 204 //kprintf("%s called for layer %p, first = %p!\n",__FUNCTION__,l,first);
 205
 206   /*
 207    * First back up parts of layers that are behind the layer
 208    * family. Only need to do this if layer is moving or
 209    * getting bigger in size. Only need to visit those layers
 210    * that overlap with the new shape of the layer.
 211    */
 212
 213
 214   lparent = l->parent;
 215   _l = l->back;
 216
 217 #if 0
 218 kprintf("\t\t%s: Backing up parts of layers that are behind the layer!\n",
 219         __FUNCTION__);
 220 #endif
 221   while (1)
 222   {
 223     if (IS_VISIBLE(_l) && DO_OVERLAP(&cutnewshape.bounds, &_l->shape->bounds))
 224       _BackupPartsOfLayer(_l, &cutnewshape, 0, FALSE, LayersBase);
 225     else
 226       ClearRegionRegion(&cutnewshape, _l->VisibleRegion);
 227
 228     if (_l == lparent)
 229     {
 230       if (IS_VISIBLE(_l) || (NULL == lparent->parent))
 231         break;
 232       else
 233         lparent = lparent->parent;
 234     }
 235     _l = _l->back;
 236   }
 237
 238    SetRegion(&cutnewshape, l->visibleshape);
 239   ClearRegion(&cutnewshape);
 240
 241   /*
 242    * Now I need to move the layer and all its familiy to the new
 243    * location.
 244    */
 245   oldshape = l->shape;
 246   l->shape = newshape;
 247
 248   _l = l;
 249
 250   while (1)
 251   {
 252     struct ClipRect * cr;
 253
 254 #if 0
 255 kprintf("\t\t%s: BACKING up parts of THE LAYER TO BE MOVED!\n",
 256         __FUNCTION__);
 257 #endif
 258
 259     if (1/* IS_VISIBLE(_l) */)
 260     {
 261       ClearRegion(_l->VisibleRegion);
 262       _BackupPartsOfLayer(_l, _l->shape, dx, TRUE, LayersBase);
 263     }
 264     /*
 265      * Effectively move the layer...
 266      */
 267     _TranslateRect(&_l->bounds, dx, dy);
 268
 269
 270     /*
 271      * ...and also its cliprects.
 272      */
 273     cr = _l->ClipRect;
 274     while (cr)
 275     {
 276       _TranslateRect(&cr->bounds, dx, dy);
 277       cr = cr->Next;
 278     }
 279
 280     cr = _l->_cliprects;
 281     while (cr)
 282     {
 283       _TranslateRect(&cr->bounds, dx, dy);
 284       cr = cr->Next;
 285     }
 286
 287     if (l != _l)
 288     {
 289       _TranslateRect(&_l->shape->bounds, dx, dy);
 290
 291       /*
 292        * Also calculate the visible shape!
 293        */
 294       SetRegion(_l->shape, _l->visibleshape);
 295       AndRegionRegion(_l->parent->visibleshape, _l->visibleshape);
 296     }
 297
 298     if (_l == first)
 299       break;
 300
 301     _l = _l->front;
 302   }
 303
 304   l->bounds.MaxX += dw;
 305   l->bounds.MaxY += dh;
 306   l->Width  += dw;
 307   l->Height += dh;
 308
 309
 310   /*
 311    * Now make them visible again.
 312    */
 313   _l = first;
 314
 315   while (1)
 316   {
 317     if (IS_VISIBLE(_l))
 318     {
 319 #if 0
 320 kprintf("\t\t%s: SHOWING parts of THE LAYER TO BE MOVED (children)!\n",
 321         __FUNCTION__);
 322 #endif
 323       ClearRegion(_l->VisibleRegion);
 324       _ShowPartsOfLayer(_l, &r, LayersBase);
 325
 326       if (l == _l)
 327         break;
 328
 329       ClearRegionRegion(_l->visibleshape, &r);
 330     }
 331
 332     if (l == _l)
 333       break;
 334
 335     _l = _l->back;
 336   }
 337
 338   /*
 339    * Now make those parts of the layers after l up to and including
 340    * its parent visible.
 341    */
 342   SetRegion(l->VisibleRegion, &r);
 343   ClearRegionRegion(l->visibleshape, &r);
 344   _l = l->back;
 345   lparent = l->parent;
 346
 347   while (1)
 348   {
 349 #if 0
 350 kprintf("\t\t%s: SHOWING parts of the layers behind the layer to be moved!\n",
 351         __FUNCTION__);
 352 #endif
 353     if (IS_VISIBLE(_l) &&
 354        (  DO_OVERLAP(&l->visibleshape->bounds, &_l->shape->bounds) ||
 355           DO_OVERLAP(   &oldshape->bounds, &_l->shape->bounds) ))
 356     {
 357       ClearRegion(_l->VisibleRegion);
 358       _ShowPartsOfLayer(_l, &r, LayersBase);
 359     }
 360     else
 361       SetRegion(&r, _l->VisibleRegion);
 362
 363     if (IS_VISIBLE(_l) || IS_ROOTLAYER(_l))
 364       AndRegionRegion(_l->VisibleRegion, oldshape);
 365
 366 #if 0
 367     if (IS_ROOTLAYER(_l))
 368       kprintf("root reached! %p\n",_l);
 369 #endif
 370
 371     if (_l == lparent)
 372     {
 373       if (IS_VISIBLE(_l) || (NULL == lparent->parent))
 374         break;
 375       else
 376         lparent = lparent->parent;
 377     }
 378
 379     if (IS_VISIBLE(_l))
 380       ClearRegionRegion(_l->visibleshape, &r);
 381
 382     _l = _l->back;
 383   }
 384
 385   ClearRegion(&rtmp);
 386
 387   /*
 388    * Now I need to clear the old layer at its previous place..
 389    * But I may only clear those parts where no layer has become
 390    * visible in the meantime.
 391    */
 392   if (!IS_EMPTYREGION(oldshape))
 393   {
 394     if (lparent && IS_ROOTLAYER(lparent))
 395       _BackFillRegion(l->parent, oldshape, TRUE, LayersBase);
 396   }
 397
 398   DisposeRegion(oldshape);
 399
 400   /*
 401    * If the size of the layer became larger clear the
 402    * new area where it is visible.
 403    */
 404   if ((dw > 0 || dh > 0) && !IS_SUPERREFRESH(l))
 405   {
 406     ClearRegion(&r);
 407     if (dw > 0)
 408       OrRectRegion(&r, &rectw);
 409
 410     if (dh > 0)
 411       OrRectRegion(&r, &recth);
 412
 413     _BackFillRegion(l, &r, TRUE, LayersBase);
 414   }
 415
 416   ClearRegion(&r);
 417
 418   if (olddamage)
 419   {
 420     struct Region *newdamage = NewRegion();
 421
 422     IL(l)->intflags &= ~INTFLAG_AVOID_BACKFILL;
 423     if (newdamage)
 424     {
 425       OrRegionRegion(l->DamageList, newdamage);
 426       ClearRegionRegion(olddamage, newdamage);
 427       _TranslateRect(&newdamage->bounds, l->bounds.MinX, l->bounds.MinY);
 428       _BackFillRegion(l, newdamage, FALSE, LayersBase);
 429
 430       DisposeRegion(newdamage);
 431     }
 432     DisposeRegion(olddamage);
 433   }
 434
 435   if (clipregion)
 436     _InternalInstallClipRegion(l, clipregion, 0, 0, LayersBase);
 437
 438   UnlockLayers(l->LayerInfo);
 439
 440   return TRUE;
 441
 442   AROS_LIBFUNC_EXIT
 443 } /* MoveSizeLayer */