rom/hyperlayers/changelayershape.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 <proto/exec.h>
  10 #include <exec/memory.h>
  11 #include <proto/graphics.h>
  12 #include <proto/utility.h>
  13 #include <utility/hooks.h>
  14
  15 #include "layers_intern.h"
  16 #include "basicfuncs.h"
  17
  18 /*****************************************************************************
  19
  20     NAME */
  21 #include <proto/layers.h>
  22         AROS_LH3(struct Region *, ChangeLayerShape,
  23
  24 /*  SYNOPSIS */
  25         AROS_LHA(struct Layer  *, l          , A0),
  26         AROS_LHA(struct Region *, newshape   , A1),
  27         AROS_LHA(struct Hook   *, callback   , A2),
  28 /*  LOCATION */
  29         struct LayersBase *, LayersBase, 37, Layers)
  30
  31 /*  FUNCTION
  32        Changes the shape of the layer on the fly.
  33        When the shape of a layer is changed the current pixel content
  34        is copied into its ClipRects so no information is lost.
  35        The user can provide a callback hook that will be
  36        called when the current layer's information is all backed up
  37        in ClipRects. The signature of the callback should look as follows:
  38
  39            AROS_UFC3(BOOL, callback,
  40                AROS_UFCA(struct Hook   *       , hook       , A0),
  41                AROS_UFCA(struct Layer  *       , l          , A2),
  42                AROS_UFCA(struct ShapeHookMsg * , arg        , A1));
  43
  44
  45     INPUTS
  46        L        - pointer to layer
  47        newshape - pointer to a region that comprises the new shape
  48                   of the layer. May be NULL if callback is provided.
  49        callback - pointer to a callback hook. May be NULL if newshape
  50                   is given.
  51
  52     RESULT
  53        Pointer to the previously installed region.
  54
  55     NOTES
  56
  57     EXAMPLE
  58
  59     BUGS
  60
  61     SEE ALSO
  62
  63     INTERNALS
  64
  65     HISTORY
  66
  67 *****************************************************************************/
  68 {
  69   AROS_LIBFUNC_INIT
  70
  71   struct Region * returnshape = NULL;
  72
  73   LockLayers(l->LayerInfo);
  74
  75   {
  76     struct Region r, cutoldshape, rtmp, cutnewshape;
  77     struct Layer * lparent, * _l, * lfirst = NULL;
  78     int behind_l = FALSE;
  79     InitRegion(&r);
  80     InitRegion(&rtmp);
  81     InitRegion(&cutoldshape);
  82     InitRegion(&cutnewshape);
  83
  84
  85     if (IS_VISIBLE(l))
  86     {
  87       /*
  88        * Backup everything that is visible right now into
  89        * cliprects.
  90        */
  91       lfirst = GetFirstFamilyMember(l);
  92       SetRegion(lfirst->VisibleRegion, &r);
  93
  94       SetRegion(l->visibleshape, &cutoldshape);
  95       _BackupPartsOfLayer(l, &cutoldshape, 0, TRUE, LayersBase);
  96     }
  97
  98     /*
  99      * Get the current layer's shape as the paramter to return
 100      * from this function.
 101      */
 102     returnshape = l->shaperegion;
 103
 104     if (NULL != callback)
 105     {
 106         struct ShapeHookMsg msg;
 107
 108         msg.Action    = SHAPEHOOKACTION_CHANGELAYERSHAPE;
 109         msg.NewShape  = l->shaperegion;
 110         msg.OldShape  = l->shaperegion;
 111         msg.NewBounds = &l->bounds;
 112         msg.OldBounds = &l->bounds;
 113
 114         /*
 115          * call the callback to the user to give me a new shape
 116          * The user can manipulate the cliprects of the layer
 117          * l and can have a look at the current shape.
 118          */
 119         if (CallHookPkt(callback, l, &msg))
 120             l->shaperegion = msg.NewShape;
 121     }
 122     else
 123     {
 124       /*
 125        * The user passed me the new shape but no callback.
 126        */
 127       l->shaperegion = newshape;
 128     }
 129
 130     DisposeRegion(l->shape);
 131     /*
 132      * At this point l->shaperegion holds the layer that is to be
 133      * installed. Let's cut it down to the actually visible part.
 134      */
 135
 136     l->shape = NewRegion();
 137     if (l->shape)
 138     {
 139         struct Rectangle r = {0, 0, l->Width - 1, l->Height - 1};
 140
 141         OrRectRegion(l->shape, &r);
 142         /* FIXME: handle error here */
 143     }
 144
 145     if (l->shaperegion)
 146       AndRegionRegion(l->shaperegion, l->shape);
 147
 148     _TranslateRect(&l->shape->bounds, l->bounds.MinX, l->bounds.MinY);
 149
 150     SetRegion(l->shape, l->visibleshape);
 151     AndRegionRegion(l->parent->visibleshape, l->visibleshape);
 152
 153     if (IS_VISIBLE(l))
 154     {
 155       /*
 156        * Let me backup parts of the layers that are behind the
 157        * layer l and the layers that are its family.
 158        */
 159
 160       lparent = l->parent;
 161       _l = lfirst;
 162
 163       while (1)
 164       {
 165         if ((l != _l))
 166         {
 167           if(IS_VISIBLE(_l) && DO_OVERLAP(&l->visibleshape->bounds, &_l->visibleshape->bounds))
 168             _BackupPartsOfLayer(_l, l->visibleshape, 0, FALSE, LayersBase);
 169         }
 170
 171         if (_l == lparent)
 172         {
 173           if (IS_VISIBLE(_l) || (NULL == lparent->parent))
 174             break;
 175           else
 176             lparent = lparent->parent;
 177         }
 178
 179         _l = _l->back;
 180       } /* while (1) */
 181
 182
 183       /*
 184        * Make the new layer and its family visible
 185        * Since the parent might have become bigger more
 186        * of the children might become visible...
 187        */
 188       _l = lfirst;
 189       lparent = l->parent;
 190
 191       while (1)
 192       {
 193         if (IS_VISIBLE(_l) &&
 194             (DO_OVERLAP(&cutnewshape.bounds, &_l->visibleshape->bounds) ||
 195              DO_OVERLAP(&cutoldshape.bounds, &_l->visibleshape->bounds)))
 196         {
 197           ClearRegion(_l->VisibleRegion);
 198           _ShowPartsOfLayer(_l, &r, LayersBase);
 199         }
 200         else
 201           SetRegion(&r, _l->VisibleRegion);
 202
 203
 204         if ((TRUE == behind_l) && (IS_VISIBLE(_l) || IS_ROOTLAYER(_l)))
 205           AndRegionRegion(_l->VisibleRegion, &cutoldshape);
 206
 207         if (_l == lparent)
 208         {
 209           if (IS_VISIBLE(_l) || (NULL == lparent->parent))
 210             break;
 211           else
 212             lparent = lparent->parent;
 213         }
 214
 215          if (l == _l)
 216           behind_l = TRUE;
 217
 218         if (FALSE == behind_l)
 219         {
 220           SetRegion(_l->shape, _l->visibleshape);
 221           AndRegionRegion(_l->parent->visibleshape, _l->visibleshape);
 222         }
 223
 224         if (IS_VISIBLE(_l))
 225           ClearRegionRegion(_l->visibleshape, &r);
 226
 227         _l = _l->back;
 228       } /* while(1) */
 229
 230       ClearRegion(&rtmp);
 231       ClearRegion(&r);
 232
 233       if (!IS_EMPTYREGION(&cutoldshape))
 234       {
 235         if (lparent &&
 236             (IS_SIMPLEREFRESH(lparent) || IS_ROOTLAYER(lparent)))
 237               _BackFillRegion(l->parent, &cutoldshape, TRUE, LayersBase);
 238       }
 239
 240       ClearRegion(&cutoldshape);
 241
 242     } /* if (IS_VISIBLE(l)) */
 243
 244     ClearRegion(&cutnewshape);
 245
 246   }
 247
 248   UnlockLayers(l->LayerInfo);
 249
 250   return returnshape;
 251
 252   AROS_LIBFUNC_EXIT
 253 } /* ChangeLayerShape */