rom/hyperlayers/changelayervisibility.c

   1 /*
   2     Copyright © 1995-2007, 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
  58   struct Layer * _l, * lparent;
  59   struct Region r;
  60   InitRegion(&r);
  61
  62   if (l->visible == visible)
  63     return TRUE;
  64
  65   LockLayers(l->LayerInfo);
  66
  67   l->visible = visible;
  68
  69   if (TRUE == visible)
  70   {
  71     /*
  72      * Make the layer visible
  73      * Back up all layers behind this layer.
  74      */
  75     lparent = l->parent;
  76     _l = l->back;
  77     while (1)
  78     {
  79       if (IS_VISIBLE(_l) && DO_OVERLAP(&l->visibleshape->bounds, &_l->shape->bounds))
  80         _BackupPartsOfLayer(_l, l->visibleshape, 0, FALSE, LayersBase);
  81       else
  82         ClearRegionRegion(l->visibleshape, _l->VisibleRegion);
  83
  84       if (_l == lparent)
  85       {
  86         if (IS_VISIBLE(_l) || (NULL == lparent->parent))
  87           break;
  88         else
  89           lparent = lparent->parent;
  90       }
  91       _l = _l->back;
  92     }
  93
  94     /*
  95      * For the layer to become visible I must recalculate its
  96      * visible area. Search the first visible layer in front of
  97      * it and used that one's VisbleRegion minus its visibleshape.
  98      */
  99     ClearRegion(l->VisibleRegion);
 100     _l = l->front;
 101     while (1)
 102     {
 103       if (NULL == _l)
 104       {
 105         /*
 106          * It's like the top layer since all others are invisible
 107          */
 108         SetRegion(l->LayerInfo->check_lp->shape, &r);
 109         break;
 110       }
 111
 112       if (IS_VISIBLE(_l))
 113       {
 114         SetRegion(_l->VisibleRegion, &r);
 115         ClearRegionRegion(_l->visibleshape, &r);
 116         break;
 117       }
 118
 119       _l = _l->front;
 120
 121     }
 122
 123     /*
 124      * Let me show the layer in its full beauty...
 125      */
 126     _ShowPartsOfLayer(l, &r, LayersBase);
 127
 128     if (IS_SIMPLEREFRESH(l))
 129     {
 130       /*
 131        * Add the whole visible area of the layer to the
 132        * damage list since for those kind of layers
 133        * nothing was backed up.
 134        */
 135       SetRegion(l->shape, l->DamageList);
 136       AndRegionRegion(l->VisibleRegion, l->DamageList);
 137       /*
 138        * Since the Damagelist is relative to the layer I have to make
 139        * some adjustments to the coordinates here.
 140        */
 141       _TranslateRect(&l->DamageList->bounds,
 142                      -l->bounds.MinX,
 143                      -l->bounds.MinY);
 144       l->Flags |= LAYERREFRESH;
 145     }
 146   }
 147   else
 148   {
 149     /*
 150      * Make the layer invisible
 151      */
 152     struct Region clearr;
 153     InitRegion(&clearr);
 154
 155     l->Flags &= ~LAYERREFRESH;
 156     ClearRegion(l->DamageList);
 157
 158     SetRegion(l->VisibleRegion, &r);
 159
 160     SetRegion(l->visibleshape, &clearr);
 161     _BackupPartsOfLayer(l, &clearr, 0, FALSE, LayersBase);
 162
 163     /*
 164      * Walk through all the layers behind this layer and
 165      * make them (more) visible...
 166      */
 167     lparent = l->parent;
 168     _l = l->back;
 169     while (1)
 170     {
 171       if (IS_VISIBLE(_l) && DO_OVERLAP(&l->visibleshape->bounds, &_l->visibleshape->bounds))
 172       {
 173         ClearRegion(_l->VisibleRegion);
 174         _ShowPartsOfLayer(_l, &r, LayersBase);
 175       }
 176       else
 177         SetRegion(&r, _l->VisibleRegion);
 178
 179       if (IS_VISIBLE(_l) || IS_ROOTLAYER(_l))
 180         AndRegionRegion(_l->VisibleRegion, &clearr);
 181
 182       if (_l == lparent)
 183       {
 184         if (IS_VISIBLE(_l) || (NULL == lparent->parent))
 185           break;
 186         else
 187           lparent = lparent->parent;
 188       }
 189
 190       /*
 191        * Take the shape of the current layer out of
 192        * the visible region that will be applied to the
 193        * layer behind this one.
 194        */
 195       if (IS_VISIBLE(_l))
 196         ClearRegionRegion(_l->visibleshape, &r);
 197
 198       _l = _l->back;
 199     }
 200
 201     if (!IS_EMPTYREGION(&clearr))
 202     {
 203       if (lparent &&
 204           (IS_SIMPLEREFRESH(lparent) || IS_ROOTLAYER(lparent)))
 205         _BackFillRegion(lparent, &clearr, FALSE, LayersBase);
 206     }
 207
 208
 209     ClearRegion(&clearr);
 210   }
 211
 212   ClearRegion(&r);
 213   UnlockLayers(l->LayerInfo);
 214
 215   return TRUE;
 216
 217   AROS_LIBFUNC_EXIT
 218 } /* ChangeLayerVisibility */