rom/hyperlayers/movelayerz.c

   1 /*
   2     Copyright © 1995-2004, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8
   9 #include <exec/types.h>
  10 #include <graphics/clip.h>
  11 #include <proto/graphics.h>
  12 #include <proto/layers.h>
  13 #include "basicfuncs.h"
  14 #include "layers_intern.h"
  15
  16 int _MoveLayerBehind(struct Layer *l,
  17                      struct Layer *lfront,
  18                      LIBBASETYPEPTR LayersBase)
  19 {
  20   struct Layer * lbackold, *_l, *first;
  21   struct Region * hide = NewRegion(), show;
  22   InitRegion(&show);
  23
  24   first = GetFirstFamilyMember(l);
  25
  26   lbackold = l->back;
  27
  28   /*
  29    * Take the family out of its old place.
  30    */
  31   if (NULL != first->front)
  32     first->front->back = lbackold;
  33   else
  34     l->LayerInfo->top_layer = lbackold;
  35
  36   lbackold->front = first->front;
  37
  38   _l = lbackold;
  39   /*
  40    * Collect the additional parts that have to be hidden
  41    * on the layers that are to be moved. I need only
  42    * collect those parts of layers that have the same
  43    * parent as the layer l. Stop when I found lfront.
  44    */
  45   while (1)
  46   {
  47     /*
  48      * Must not add my own shape to the hide region...
  49      */
  50     if (_l == l)
  51       break;
  52
  53     /*
  54      * Must add EVERY shape since it will be subtracted from
  55      * the visible region
  56      */
  57     if (l->parent == _l->parent && IS_VISIBLE(_l))
  58       OrRegionRegion(_l->visibleshape, hide);
  59
  60     if (_l == lfront)
  61       break;
  62
  63     _l = _l->back;
  64   }
  65
  66   SetRegion(first->VisibleRegion, &show);
  67
  68   /*
  69    * First back up the family ... this is like moving them behind the
  70    * other layers.
  71    */
  72
  73   _l = first;
  74   while (1)
  75   {
  76     if (IS_VISIBLE(_l) && DO_OVERLAP(&_l->visibleshape->bounds, &hide->bounds))
  77       _BackupPartsOfLayer(_l, hide, 0, FALSE, LayersBase);
  78     else
  79       ClearRegionRegion(hide, _l->VisibleRegion);
  80
  81     if (_l == l)
  82       break;
  83
  84     _l = _l->back;
  85   }
  86   DisposeRegion(hide);
  87
  88   /*
  89    * Show the layers that appear now.
  90    * Start with the layer that is behind the layer l.
  91    */
  92   _l = lbackold;
  93
  94   while (1)
  95   {
  96     if (IS_VISIBLE(_l) && DO_OVERLAP(&_l->visibleshape->bounds, &show.bounds))
  97     {
  98       ClearRegion(_l->VisibleRegion);
  99       _ShowPartsOfLayer(_l, &show, LayersBase);
 100     }
 101     else
 102       SetRegion(&show, _l->VisibleRegion);
 103
 104     if (_l == lfront)
 105       break;
 106
 107     if (IS_VISIBLE(_l))
 108       ClearRegionRegion(_l->visibleshape, &show);
 109
 110     _l = _l->back;
 111   }
 112
 113   ClearRegion(&show);
 114
 115   /*
 116    * Link the family into its new place.
 117    */
 118   if (lfront->back)
 119     lfront->back->front = l;
 120   l->back = lfront->back;
 121
 122   first->front = lfront;
 123   lfront->back = first;
 124
 125   return TRUE;
 126 }
 127
 128 int _MoveLayerToFront(struct Layer * l,
 129                       struct Layer * lbehind,
 130                       LIBBASETYPEPTR LayersBase)
 131 {
 132   struct Layer * lfront, * first, * _l;
 133   struct Region r, * backupr = NULL;
 134   int backupr_allocated = FALSE;
 135
 136   InitRegion(&r);
 137
 138   first = GetFirstFamilyMember(l);
 139
 140   lfront = lbehind->front;
 141
 142   /*
 143    * Unlink the family of layers from its old place.
 144    */
 145   first->front->back = l->back;
 146   l->back->front = first->front;
 147
 148   /*
 149    * I need exactly that layers visible region later on.
 150    */
 151
 152   SetRegion(lbehind->VisibleRegion,&r);
 153
 154   /*
 155    * if the layer l is visible then I will have to backup
 156    * its visible region in all layers behind it. Otherwise
 157    * I will have to collect the visible shape of its whole
 158    * family.
 159    */
 160   if (IS_VISIBLE(l))
 161     backupr = l->visibleshape;
 162   else
 163   {
 164     _l = l;
 165     while (1)
 166     {
 167       if (IS_VISIBLE(_l))
 168       {
 169         if (NULL == backupr)
 170         {
 171           backupr = NewRegion();
 172           backupr_allocated = TRUE;
 173         }
 174         if (backupr)
 175           OrRegionRegion(_l->visibleshape, backupr);
 176       }
 177       if (_l == first)
 178         break;
 179
 180       _l = _l->front;
 181     }
 182   }
 183
 184   _l = lbehind;
 185
 186
 187   if (backupr)
 188   {
 189     /*
 190      * Now I have to move the layer family in front of layer lbehind.
 191      * Nothing changes for the layers in front of layer lbehind, but on
 192      * the layers behind (including first->front) I must back up some of
 193      * their parts that the new family might be hiding no.
 194      * Once I step on the layer that was behind the layer l
 195      * I can stop because those layers are already hidden well
 196      * enough.
 197      */
 198     do
 199     {
 200       if (IS_VISIBLE(_l) && DO_OVERLAP(&backupr->bounds, &_l->visibleshape->bounds))
 201         _BackupPartsOfLayer(_l, backupr, 0, FALSE, LayersBase);
 202       else
 203         ClearRegionRegion(backupr, _l->VisibleRegion);
 204
 205       _l = _l->back;
 206     }
 207     while (_l != l->back /* this is l->back now since the family has
 208                           been unlinked already!*/ );
 209
 210     if (TRUE == backupr_allocated)
 211       DisposeRegion(backupr);
 212
 213     /*
 214      * Now I must make the layer family of l visible
 215      * (lfirst to and including l)
 216      */
 217     _l = first;
 218
 219     while (1)
 220     {
 221       if (IS_VISIBLE(_l) && DO_OVERLAP(&_l->visibleshape->bounds, &r.bounds))
 222       {
 223         ClearRegion(_l->VisibleRegion);
 224         _ShowPartsOfLayer(_l, &r, LayersBase);
 225       }
 226       else
 227         SetRegion(&r, _l->VisibleRegion);
 228
 229       if (_l == l)
 230         break;
 231
 232       if (IS_VISIBLE(_l))
 233         ClearRegionRegion(_l->visibleshape, &r);
 234
 235       _l = _l->back;
 236     }
 237   }
 238   ClearRegion(&r);
 239
 240   /*
 241    * Link the family into its new place.
 242    * First the frontmost kid and then l.
 243    */
 244   if (NULL != lfront)
 245     lfront->back = first;
 246   else
 247     l->LayerInfo->top_layer = first;
 248
 249   first->front = lfront;
 250
 251   l->back = lbehind;
 252   lbehind->front = l;
 253
 254   return TRUE;
 255 }
 256