rom/hyperlayers/changelayervisibility.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 "basicfuncs.h"
  15
  16 /*****************************************************************************
  17
  18     NAME */
  19 #include <proto/layers.h>
  20         AROS_LH2(LONG, ChangeLayerVisibility,
  21
  22 /*  SYNOPSIS */
  23         AROS_LHA(struct Layer *, l      , A0),
  24         AROS_LHA(int           , visible, D0),
  25
  26 /*  LOCATION */
  27         struct LayersBase *, LayersBase, 39, Layers)
  28
  29 /*  FUNCTION
  30        Makes the given layer visible or invisible.
  31        If it is a simple refresh layer it will loose all its
  32        cliprects and therefore rendering will go into the void.
  33
  34     INPUTS
  35        L       - pointer to layer
  36        visible - TRUE or FALSE
  37
  38     RESULT
  39        TRUE  - layer was changed to new state
  40        FALSE - layer could not be changed to new state
  41
  42     NOTES
  43
  44     EXAMPLE
  45
  46     BUGS
  47
  48     SEE ALSO
  49
  50     INTERNALS
  51
  52     HISTORY
  53
  54 *****************************************************************************/
  55 {
  56   AROS_LIBFUNC_INIT
  57   AROS_LIBBASE_EXT_DECL(struct LayersBase *,LayersBase)
  58
  59   struct Layer * _l, * lparent;
  60   struct Region r;
  61   InitRegion(&r);
  62
  63   if (l->visible == visible)
  64     return TRUE;
  65
  66   LockLayers(l->LayerInfo);
  67
  68   l->visible = visible;
  69
  70   if (TRUE == visible)
  71   {
  72     /*
  73      * Make the layer visible
  74      * Back up all layers behind this layer.
  75      */
  76     lparent = l->parent;
  77     _l = l->back;
  78     while (1)
  79     {
  80       if (IS_VISIBLE(_l) && DO_OVERLAP(&l->visibleshape->bounds, &_l->shape->bounds))
  81         _BackupPartsOfLayer(_l, l->visibleshape, 0, FALSE, LayersBase);
  82       else
  83         ClearRegionRegion(l->visibleshape, _l->VisibleRegion);
  84
  85       if (_l == lparent)
  86       {
  87         if (IS_VISIBLE(_l) || (NULL == lparent->parent))
  88           break;
  89         else
  90           lparent = lparent->parent;
  91       }
  92       _l = _l->back;
  93     }
  94
  95     /*
  96      * For the layer to become visible I must recalculate its
  97      * visible area. Search the first visible layer in front of
  98      * it and used that one's VisbleRegion minus its visibleshape.
  99      */
 100     ClearRegion(l->VisibleRegion);
 101     _l = l->front;
 102     while (1)
 103     {
 104       if (NULL == _l)
 105       {
 106         /*
 107          * It's like the top layer since all others are invisible
 108          */
 109         SetRegion(l->LayerInfo->check_lp->shape, &r);
 110         break;
 111       }
 112
 113       if (IS_VISIBLE(_l))
 114       {
 115         SetRegion(_l->VisibleRegion, &r);
 116         ClearRegionRegion(_l->visibleshape, &r);
 117         break;
 118       }
 119
 120       _l = _l->front;
 121
 122     }
 123
 124     /*
 125      * Let me show the layer in its full beauty...
 126      */
 127     _ShowPartsOfLayer(l, &r, LayersBase);
 128
 129     if (IS_SIMPLEREFRESH(l))
 130     {
 131       /*
 132        * Add the whole visible area of the layer to the
 133        * damage list since for those kind of layers
 134        * nothing was backed up.
 135        */
 136       SetRegion(l->shape, l->DamageList);
 137       AndRegionRegion(l->VisibleRegion, l->DamageList);
 138       /*
 139        * Since the Damagelist is relative to the layer I have to make
 140        * some adjustments to the coordinates here.
 141        */
 142       _TranslateRect(&l->DamageList->bounds,
 143                      -l->bounds.MinX,
 144                      -l->bounds.MinY);
 145       l->Flags |= LAYERREFRESH;
 146     }
 147   }
 148   else
 149   {
 150     /*
 151      * Make the layer invisible
 152      */
 153     struct Region clearr;
 154     InitRegion(&clearr);
 155
 156     l->Flags &= ~LAYERREFRESH;
 157     ClearRegion(l->DamageList);
 158
 159     SetRegion(l->VisibleRegion, &r);
 160
 161     SetRegion(l->visibleshape, &clearr);
 162     _BackupPartsOfLayer(l, &clearr, 0, FALSE, LayersBase);
 163
 164     /*
 165      * Walk through all the layers behind this layer and
 166      * make them (more) visible...
 167      */
 168     lparent = l->parent;
 169     _l = l->back;
 170     while (1)
 171     {
 172       if (IS_VISIBLE(_l) && DO_OVERLAP(&l->visibleshape->bounds, &_l->visibleshape->bounds))
 173       {
 174         ClearRegion(_l->VisibleRegion);
 175         _ShowPartsOfLayer(_l, &r, LayersBase);
 176       }
 177       else
 178         SetRegion(&r, _l->VisibleRegion);
 179
 180       if (IS_VISIBLE(_l) || IS_ROOTLAYER(_l))
 181         AndRegionRegion(_l->VisibleRegion, &clearr);
 182
 183       if (_l == lparent)
 184       {
 185         if (IS_VISIBLE(_l) || (NULL == lparent->parent))
 186           break;
 187         else
 188           lparent = lparent->parent;
 189       }
 190
 191       /*
 192        * Take the shape of the current layer out of
 193        * the visible region that will be applied to the
 194        * layer behind this one.
 195        */
 196       if (IS_VISIBLE(_l))
 197         ClearRegionRegion(_l->visibleshape, &r);
 198
 199       _l = _l->back;
 200     }
 201
 202     if (!IS_EMPTYREGION(&clearr))
 203     {
 204       if (lparent &&
 205           (IS_SIMPLEREFRESH(lparent) || IS_ROOTLAYER(lparent)))
 206         _BackFillRegion(lparent, &clearr, FALSE, LayersBase);
 207     }
 208
 209
 210     ClearRegion(&clearr);
 211   }
 212
 213   ClearRegion(&r);
 214   UnlockLayers(l->LayerInfo);
 215
 216   return TRUE;
 217
 218   AROS_LIBFUNC_EXIT
 219 } /* ChangeLayerVisibility */