rom/hyperlayers/sortlayercr.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8 #include <graphics/clip.h>
   9 #include <aros/libcall.h>
  10 #include <aros/asmcall.h>
  11
  12 #define DEBUG 0
  13 #include <aros/debug.h>
  14 #undef kprintf
  15
  16 AROS_UFP2(BOOL, _SLCR_CompFunc_Down,
  17     AROS_UFPA(struct ClipRect *, cr1, A0),
  18     AROS_UFPA(struct ClipRect *, cr2, A1));
  19 AROS_UFP2(BOOL, _SLCR_CompFunc_Up,
  20     AROS_UFPA(struct ClipRect *, cr1, A0),
  21     AROS_UFPA(struct ClipRect *, cr2, A1));
  22 AROS_UFP2(BOOL, _SLCR_CompFunc_Right,
  23     AROS_UFPA(struct ClipRect *, cr1, A0),
  24     AROS_UFPA(struct ClipRect *, cr2, A1));
  25 AROS_UFP2(BOOL, _SLCR_CompFunc_Left,
  26     AROS_UFPA(struct ClipRect *, cr1, A0),
  27     AROS_UFPA(struct ClipRect *, cr2, A1));
  28 AROS_UFP2(BOOL, _SLCR_CompFunc_RightDown,
  29     AROS_UFPA(struct ClipRect *, cr1, A0),
  30     AROS_UFPA(struct ClipRect *, cr2, A1));
  31 AROS_UFP2(BOOL, _SLCR_CompFunc_RightUp,
  32     AROS_UFPA(struct ClipRect *, cr1, A0),
  33     AROS_UFPA(struct ClipRect *, cr2, A1));
  34 AROS_UFP2(BOOL, _SLCR_CompFunc_LeftDown,
  35     AROS_UFPA(struct ClipRect *, cr1, A0),
  36     AROS_UFPA(struct ClipRect *, cr2, A1));
  37 AROS_UFP2(BOOL, _SLCR_CompFunc_LeftUp,
  38     AROS_UFPA(struct ClipRect *, cr1, A0),
  39     AROS_UFPA(struct ClipRect *, cr2, A1));
  40
  41 void _SLCR_SortClipRects(struct Layer *layer,
  42 AROS_UFP2(BOOL, (*CompFunc),
  43     AROS_UFPA(struct ClipRect *, cr1, A0),
  44     AROS_UFPA(struct ClipRect *, cr2, A1))
  45 );
  46
  47 /*****************************************************************************
  48
  49     NAME */
  50 #include <proto/layers.h>
  51 #include "layers_intern.h"
  52
  53         AROS_LH3(void, SortLayerCR,
  54
  55 /*  SYNOPSIS */
  56         AROS_LHA(struct Layer *, layer, A0),
  57         AROS_LHA(LONG          , dx,    D0),
  58         AROS_LHA(LONG          , dy,    D1),
  59
  60 /*  LOCATION */
  61         struct LayersBase *, LayersBase, 35, Layers)
  62
  63 /*  FUNCTION
  64         Sorts the list of ClipRects associated with the given layer.
  65         The direction of the sort is indicated by dx and dy.
  66
  67     INPUTS
  68         layer -- the layer with the ClipRect list to sort
  69         dx -- the left/right ordering
  70         dy -- the up/down ordering
  71
  72     RESULT
  73         The layer->ClipRect pointer now points to a sorted list of ClipRects.
  74
  75     NOTES
  76
  77     EXAMPLE
  78
  79     BUGS
  80
  81     SEE ALSO
  82
  83     INTERNALS
  84         Implemented as an InsertSort on a singly linked list.
  85
  86     HISTORY
  87         27-11-96    digulla automatically created from
  88                             layers_lib.fd and clib/layers_protos.h
  89
  90 *****************************************************************************/
  91 {
  92     AROS_LIBFUNC_INIT
  93     AROS_LIBBASE_EXT_DECL(struct LayersBase *,LayersBase)
  94
  95     D(bug("SortLayerCR(layer @ $%lx, dx %ld, dy %ld)\n", layer, dx, dy));
  96
  97     if(dy > 0)
  98     {
  99         _SLCR_SortClipRects(layer, _SLCR_CompFunc_Down);
 100
 101         if (dx > 0)
 102             _SLCR_SortClipRects(layer, _SLCR_CompFunc_RightDown);
 103         else
 104         if (dx < 0)
 105             _SLCR_SortClipRects(layer, _SLCR_CompFunc_LeftDown);
 106     }
 107     else
 108     if (dy < 0)
 109     {
 110         _SLCR_SortClipRects(layer, _SLCR_CompFunc_Up);
 111
 112         if (dx > 0)
 113             _SLCR_SortClipRects(layer, _SLCR_CompFunc_RightUp);
 114         else
 115         if (dx < 0)
 116             _SLCR_SortClipRects(layer, _SLCR_CompFunc_LeftUp);
 117     }
 118     else
 119     {
 120         if (dx > 0)
 121             _SLCR_SortClipRects(layer, _SLCR_CompFunc_Right);
 122         else
 123         if (dx < 0)
 124             _SLCR_SortClipRects(layer, _SLCR_CompFunc_Left);
 125     }
 126
 127     AROS_LIBFUNC_EXIT
 128 } /* SortLayerCR */
 129
 130 AROS_UFH2(BOOL, _SLCR_CompFunc_Down,
 131     AROS_UFHA(struct ClipRect *, cr1, A0),
 132     AROS_UFHA(struct ClipRect *, cr2, A1))
 133 {
 134     AROS_USERFUNC_INIT
 135     return (BOOL)(cr1->bounds.MinY <= cr2->bounds.MinY);
 136     AROS_USERFUNC_EXIT
 137 }
 138
 139 AROS_UFH2(BOOL, _SLCR_CompFunc_Up,
 140     AROS_UFHA(struct ClipRect *, cr1, A0),
 141     AROS_UFHA(struct ClipRect *, cr2, A1))
 142 {
 143     AROS_USERFUNC_INIT
 144     return (BOOL)(cr1->bounds.MaxY >= cr2->bounds.MaxY);
 145     AROS_USERFUNC_EXIT
 146 }
 147
 148 AROS_UFH2(BOOL, _SLCR_CompFunc_Right,
 149     AROS_UFHA(struct ClipRect *, cr1, A0),
 150     AROS_UFHA(struct ClipRect *, cr2, A1))
 151 {
 152     AROS_USERFUNC_INIT
 153     return (BOOL)(cr1->bounds.MinX <= cr2->bounds.MinX);
 154     AROS_USERFUNC_EXIT
 155 }
 156
 157 AROS_UFH2(BOOL, _SLCR_CompFunc_Left,
 158     AROS_UFHA(struct ClipRect *, cr1, A0),
 159     AROS_UFHA(struct ClipRect *, cr2, A1))
 160 {
 161     AROS_USERFUNC_INIT
 162     return (BOOL)(cr1->bounds.MaxX >= cr2->bounds.MaxX);
 163     AROS_USERFUNC_EXIT
 164 }
 165
 166 AROS_UFH2(BOOL, _SLCR_CompFunc_RightDown,
 167     AROS_UFHA(struct ClipRect *, cr1, A0),
 168     AROS_UFHA(struct ClipRect *, cr2, A1))
 169 {
 170     AROS_USERFUNC_INIT
 171     if(cr1->bounds.MinY > cr2->bounds.MaxY) return 0;
 172     return (BOOL)(cr1->bounds.MinX <= cr2->bounds.MaxX);
 173     AROS_USERFUNC_EXIT
 174 }
 175
 176 AROS_UFH2(BOOL, _SLCR_CompFunc_RightUp,
 177     AROS_UFHA(struct ClipRect *, cr1, A0),
 178     AROS_UFHA(struct ClipRect *, cr2, A1))
 179 {
 180     AROS_USERFUNC_INIT
 181     if(cr1->bounds.MaxY < cr2->bounds.MinY) return 0;
 182     return (BOOL)(cr1->bounds.MinX <= cr2->bounds.MaxX);
 183     AROS_USERFUNC_EXIT
 184 }
 185
 186 AROS_UFH2(BOOL, _SLCR_CompFunc_LeftDown,
 187     AROS_UFHA(struct ClipRect *, cr1, A0),
 188     AROS_UFHA(struct ClipRect *, cr2, A1))
 189 {
 190     AROS_USERFUNC_INIT
 191     if(cr1->bounds.MinY > cr2->bounds.MaxY) return 0;
 192     return (BOOL)(cr1->bounds.MaxX >= cr2->bounds.MinX);
 193     AROS_USERFUNC_EXIT
 194 }
 195
 196 AROS_UFH2(BOOL, _SLCR_CompFunc_LeftUp,
 197     AROS_UFHA(struct ClipRect *, cr1, A0),
 198     AROS_UFHA(struct ClipRect *, cr2, A1))
 199 {
 200     AROS_USERFUNC_INIT
 201     if(cr1->bounds.MaxY < cr2->bounds.MinY) return 0;
 202     return (BOOL)(cr1->bounds.MaxX >= cr2->bounds.MinX);
 203     AROS_USERFUNC_EXIT
 204 }
 205
 206 void _SLCR_SortClipRects(struct Layer *layer,
 207 AROS_UFP2(BOOL, (*CompFunc),
 208     AROS_UFPA(struct ClipRect *, cr1, A0),
 209     AROS_UFPA(struct ClipRect *, cr2, A1))
 210 )
 211 {
 212
 213     struct ClipRect *CurCR;
 214     struct ClipRect *NextCR;
 215     struct ClipRect **CRptr;
 216     struct ClipRect *FirstCR;
 217
 218     if(!layer->ClipRect)
 219         return;
 220
 221     FirstCR = NULL;
 222
 223     for(CurCR = layer->ClipRect, CRptr = &FirstCR; ; )
 224     {
 225         NextCR = CurCR->Next;
 226         CurCR->Next = *CRptr;
 227         *CRptr = CurCR;
 228
 229         if(!NextCR)
 230             break;
 231
 232         for(CurCR = NextCR, CRptr = &FirstCR; ; )
 233         {
 234             if(!(NextCR = *CRptr))
 235                 break;
 236
 237             if(AROS_UFC2(BOOL, (*CompFunc),
 238                          AROS_UFCA(struct ClipRect *, CurCR, A0),
 239                          AROS_UFCA(struct ClipRect *, NextCR, A1)))
 240
 241                 break;
 242
 243             CRptr = &NextCR->Next;
 244         }
 245     }
 246
 247     layer->ClipRect = FirstCR;
 248
 249     return;
 250 }