rom/hyperlayers/movesizelayer.c

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