rom/hyperlayers/movesizelayer.c

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