rom/hyperlayers/changelayershape.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8 #include <proto/exec.h>
   9 #include <exec/types.h>
  10 #include <exec/memory.h>
  11 #include <layers_intern.h>
  12 #include <aros/libcall.h>
  13 #include <proto/graphics.h>
  14 #include <proto/utility.h>
  15 #include <utility/hooks.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, 41, 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            AROS_UFC4(struct Region *, callback,
  39                AROS_UFCA(struct Hook   *          , hook       , A0),
  40                AROS_UFCA(struct Layer  *          , l          , A2),
  41                AROS_UFCA(struct ScaleLayerParam * , arg        , A1));
  42
  43
  44     INPUTS
  45        L        - pointer to layer
  46        newshape - pointer to a region that comprises the new shape
  47                   of the layer. May be NULL if callback is provided.
  48        callback - pointer to a callback hook. May be NULL if newshape
  49                   is given.
  50
  51     RESULT
  52        Pointer to the previously installed region.
  53
  54     NOTES
  55
  56     EXAMPLE
  57
  58     BUGS
  59
  60     SEE ALSO
  61
  62     INTERNALS
  63
  64     HISTORY
  65
  66 *****************************************************************************/
  67 {
  68   AROS_LIBFUNC_INIT
  69   AROS_LIBBASE_EXT_DECL(struct LayersBase *,LayersBase)
  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 ChangeLayerShapeMsg clsm;
 107       clsm.newshape = newshape;
 108       clsm.cliprect = l->ClipRect;
 109       clsm.shape    = l->shape;
 110       /*
 111        * call the callback to the user to give me a new shape
 112        * The user can manipulate the cliprects of the layer
 113        * l and can have a look at the current shape.
 114        */
 115       l->shaperegion = (struct Region *)CallHookPkt(callback, l, &clsm);
 116     }
 117     else
 118     {
 119       /*
 120        * The user passed me the new shape but no callback.
 121        */
 122       l->shaperegion = newshape;
 123     }
 124
 125     DisposeRegion(l->shape);
 126     /*
 127      * At this point l->shaperegion holds the layer that is to be
 128      * installed. Let's cut it down to the actually visible part.
 129      */
 130
 131     l->shape = NewRectRegion(0,0,l->Width-1,l->Height-1);
 132
 133     if (l->shaperegion)
 134       AndRegionRegion(l->shaperegion, l->shape);
 135
 136     _TranslateRect(&l->shape->bounds, l->bounds.MinX, l->bounds.MinY);
 137
 138     SetRegion(l->shape, l->visibleshape);
 139     AndRegionRegion(l->parent->visibleshape, l->visibleshape);
 140
 141     if (IS_VISIBLE(l))
 142     {
 143       /*
 144        * Let me backup parts of the layers that are behind the
 145        * layer l and the layers that are its family.
 146        */
 147
 148       lparent = l->parent;
 149       _l = lfirst;
 150
 151       while (1)
 152       {
 153         if ((l != _l))
 154         {
 155           if(IS_VISIBLE(_l) && DO_OVERLAP(&l->visibleshape->bounds, &_l->visibleshape->bounds))
 156             _BackupPartsOfLayer(_l, l->visibleshape, 0, FALSE, LayersBase);
 157         }
 158
 159         if (_l == lparent)
 160         {
 161           if (IS_VISIBLE(_l) || (NULL == lparent->parent))
 162             break;
 163           else
 164             lparent = lparent->parent;
 165         }
 166
 167         _l = _l->back;
 168       } /* while (1) */
 169
 170
 171       /*
 172        * Make the new layer and its family visible
 173        * Since the parent might have become bigger more
 174        * of the children might become visible...
 175        */
 176       _l = lfirst;
 177       lparent = l->parent;
 178
 179       while (1)
 180       {
 181         if (IS_VISIBLE(_l) &&
 182             (DO_OVERLAP(&cutnewshape.bounds, &_l->visibleshape->bounds) ||
 183              DO_OVERLAP(&cutoldshape.bounds, &_l->visibleshape->bounds)))
 184         {
 185           ClearRegion(_l->VisibleRegion);
 186           _ShowPartsOfLayer(_l, &r, LayersBase);
 187         }
 188         else
 189           SetRegion(&r, _l->VisibleRegion);
 190
 191
 192         if ((TRUE == behind_l) && (IS_VISIBLE(_l) || IS_ROOTLAYER(_l)))
 193           AndRegionRegion(_l->VisibleRegion, &cutoldshape);
 194
 195         if (_l == lparent)
 196         {
 197           if (IS_VISIBLE(_l) || (NULL == lparent->parent))
 198             break;
 199           else
 200             lparent = lparent->parent;
 201         }
 202
 203          if (l == _l)
 204           behind_l = TRUE;
 205
 206         if (FALSE == behind_l)
 207         {
 208           SetRegion(_l->shape, _l->visibleshape);
 209           AndRegionRegion(_l->parent->visibleshape, _l->visibleshape);
 210         }
 211
 212         if (IS_VISIBLE(_l))
 213           ClearRegionRegion(_l->visibleshape, &r);
 214
 215         _l = _l->back;
 216       } /* while(1) */
 217
 218       ClearRegion(&rtmp);
 219       ClearRegion(&r);
 220
 221       if (!IS_EMPTYREGION(&cutoldshape))
 222       {
 223         if (lparent &&
 224             (IS_SIMPLEREFRESH(lparent) || IS_ROOTLAYER(lparent)))
 225               _BackFillRegion(l->parent, &cutoldshape, TRUE, LayersBase);
 226       }
 227
 228       ClearRegion(&cutoldshape);
 229
 230     } /* if (IS_VISIBLE(l)) */
 231
 232     ClearRegion(&cutnewshape);
 233
 234   }
 235
 236   UnlockLayers(l->LayerInfo);
 237
 238   return returnshape;
 239
 240   AROS_LIBFUNC_EXIT
 241 } /* ChangeLayerShape */