rom/hyperlayers/changelayervisibility.c

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