scalos/libraries/popupmenu/pmtopography.c

   1 //
   2 // pmtopography.h
   3 //
   4 // PopupMenu Library - Topographical Menu Map
   5 //
   6 // Copyright (C)2000 Henrik Isaksson <henrik@boing.nu>
   7 // All Rights Reserved.
   8 //
   9 // $Date$
  10 // $Revision$
  11 //
  12
  13 #include "pmpriv.h"
  14 #include "pmtopography.h"
  15
  16 #include <exec/lists.h>
  17 #include <exec/memory.h>
  18 #include <proto/exec.h>
  19 #include <clib/alib_protos.h>
  20
  21
  22 static BOOL PM_MapShadowPart(PMTRList *top, PMSRList *delta,
  23         const PMSR *shrect, WORD l, WORD t, UWORD ss,
  24         UWORD direction, UBYTE Type);
  25
  26
  27 //
  28 // PM_AddTopographicRegion - add a rectangular region of height h to the topographic map.
  29 //
  30 BOOL PM_AddTopographicRegion(PMTRList *lst, WORD l, WORD t, WORD r, WORD b, WORD h)
  31 {
  32         PMTR rect, *tmprect;
  33         PMTR *worknode, *nextnode;
  34         BOOL fail=FALSE;
  35
  36         rect.Left=l;
  37         rect.Top=t;
  38         rect.Right=r;
  39         rect.Bottom=b;
  40         rect.Height=h;
  41         rect.n.Length=sizeof(PMTR);
  42
  43         d1(KPrintF("Adding topographic region: %ld %ld %ld %ld, height: %ld\n", l, t, r, b, h));
  44
  45         //
  46         // Step 1: Remove all parts in l that would overlap rect.
  47         //
  48         worknode = (PMTR *)(lst->mlh_Head); /* First node */
  49         while ((nextnode = (PMTR *)PM_NextNode(worknode)))
  50                 {
  51                 if (PM_RegionOverlap(worknode, &rect))
  52                         {
  53                         PM_UnlinkRegion(lst, worknode);
  54                         PM_SubTopographicRects(lst, worknode, &rect);
  55                         PM_FreeTopographicNode(worknode);
  56                         }
  57                 worknode = nextnode;
  58                 }
  59
  60         //
  61         // Step 2: Add rect to l.
  62         //
  63         tmprect=PM_CopyTopographicNode(&rect);
  64         if (tmprect)
  65                 {
  66                 PM_AddRegionToList(lst, tmprect);
  67                 }
  68         else
  69                 fail = TRUE;
  70
  71         return (BOOL) !fail;
  72 }
  73
  74 //
  75 // PM_CopyTopographicNode - copy a PMTopographicRect, or allocate a new if A is NULL.
  76 //
  77 PMTR *PM_CopyTopographicNode(PMTR *A)
  78 {
  79         PMTR *newnode;
  80
  81         newnode=(PMTR *) AllocVec(sizeof(PMTR), MEMF_ANY);
  82         if (newnode && A)
  83                 *newnode = *A;
  84
  85         return newnode;
  86 }
  87
  88 //
  89 // PM_SubTopographicRects - like PM_SubRects but preserves height
  90 //
  91 BOOL PM_SubTopographicRects(PMTRList *dest, PMTR *worknode, PMTR *rect)
  92 {
  93         PMTR tmprect, *rectptr;
  94         BOOL fail = FALSE;
  95
  96         tmprect.Height = worknode->Height;
  97
  98         tmprect.Left = worknode->Left;
  99         tmprect.Right = worknode->Right;
 100
 101         tmprect.n.Length = sizeof(tmprect);
 102
 103         if (rect->Top>worknode->Top && rect->Top<worknode->Bottom)
 104                 {
 105                 tmprect.Top = worknode->Top;
 106                 tmprect.Bottom = rect->Top;
 107
 108                 rectptr = PM_CopyTopographicNode(&tmprect);
 109                 if (rectptr)
 110                         PM_AddToList((PMDList *)dest, (PMNode *)rectptr);
 111                 else
 112                         fail = TRUE;
 113                 }
 114
 115         if (rect->Bottom>worknode->Top && rect->Bottom<worknode->Bottom)
 116                 {
 117                 tmprect.Top = rect->Bottom;
 118                 tmprect.Bottom = worknode->Bottom;
 119
 120                 rectptr = PM_CopyTopographicNode(&tmprect);
 121                 if (rectptr)
 122                         PM_AddToList((PMDList *)dest, (PMNode *)rectptr);
 123                 else
 124                         fail = TRUE;
 125                 }
 126
 127         tmprect.Top = MAX(rect->Top, worknode->Top);
 128         tmprect.Bottom = MIN(rect->Bottom, worknode->Bottom);
 129
 130         if (rect->Left>worknode->Left && rect->Left<worknode->Right)
 131                 {
 132                 tmprect.Left = worknode->Left;
 133                 tmprect.Right = rect->Left;
 134
 135                 rectptr = PM_CopyTopographicNode(&tmprect);
 136                 if (rectptr)
 137                         PM_AddToList((PMDList *)dest, (PMNode *)rectptr);
 138                 else
 139                         fail = TRUE;
 140                 }
 141
 142         if (rect->Right>worknode->Left && rect->Right<worknode->Right)
 143                 {
 144                 tmprect.Left = rect->Right;
 145                 tmprect.Right = worknode->Right;
 146
 147                 rectptr = PM_CopyTopographicNode(&tmprect);
 148                 if (rectptr)
 149                         PM_AddShadowToList((PMDList *)dest, (PMNode *)rectptr);
 150                 else
 151                         fail = TRUE;
 152                 }
 153
 154         return (BOOL) !fail;
 155 }
 156
 157 //
 158 // PM_MapShadow
 159 //
 160 BOOL PM_MapShadow(PMTRList *top, PMSRList *delta,
 161     WORD l, WORD t, WORD r, WORD b,
 162     UWORD menulevel, UWORD direction)
 163 {
 164         PMSR shrect;
 165         BOOL Success = TRUE;
 166         UWORD ss;
 167
 168         shrect.Left = l;
 169         shrect.Top = t;
 170         shrect.Right = r;
 171         shrect.Bottom = b;
 172
 173         //
 174         // The five following calls will create shadows for a lightsource
 175         // positioned somewhere near the top left corner of the screen.
 176         //
 177         // +------------+
 178         // |            |--+
 179         // |            |4 |
 180         // |            |--+
 181         // |            |  |
 182         // |            |1 |
 183         // |            |  |
 184         // |            |  |
 185         // +-+-+--------+--+
 186         //   |5|   2    |3 |
 187         //   +-+--------+--+
 188         //
 189
 190         // Shadow size
 191         ss = menulevel * 2 + 8;
 192
 193         d1(KPrintF("%s/%s/%ld: left=%ld  top=%ld  right=%ld  bottom=%ld\n", __FILE__, __FUNC__, __LINE__, l, t, r, b));
 194
 195         if (direction & PMSHADOW_HORIZ)
 196                 {
 197                 shrect.Right = l + ss;
 198                 }
 199
 200         if (direction & PMSHADOW_VERT)
 201                 {
 202                 shrect.Bottom = t + ss;
 203                 }
 204
 205         if ((PMSHADOW_HORIZ | PMSHADOW_VERT) == direction)
 206                 {
 207                 // bottom right corner
 208                 // Shadow 3
 209                 d1(KPrintF("%s/%s/%ld: Shadow 3\n", __FILE__, __FUNC__, __LINE__));
 210                 Success = PM_MapShadowPart(top, delta, &shrect, l, t, ss, direction, SHADOWFLAG_BOTTOM | SHADOWFLAG_RIGHT);
 211                 }
 212         else if (direction & PMSHADOW_HORIZ)
 213                 {
 214                 d1(KPrintF("%s/%s/%ld: PMSHADOW_HORIZ\n", __FILE__, __FUNC__, __LINE__));
 215                 // Shadow 4
 216                 shrect.Top = t;
 217                 shrect.Bottom = t + ss;
 218                 Success = PM_MapShadowPart(top, delta, &shrect, l, t, ss, direction, SHADOWFLAG_RIGHT | SHADOWFLAG_TOP);
 219
 220                 if (Success)
 221                         {
 222                         // Shadow 1
 223                         shrect.Top = t + ss;
 224                         shrect.Bottom = b;
 225                         Success = PM_MapShadowPart(top, delta, &shrect, l, t, ss, direction, SHADOWFLAG_RIGHT);
 226                         }
 227                 }
 228         else if (direction & PMSHADOW_VERT)
 229                 {
 230                 d1(KPrintF("%s/%s/%ld: PMSHADOW_VERT\n", __FILE__, __FUNC__, __LINE__));
 231                 // Shadow 5
 232                 shrect.Left = l;
 233                 shrect.Right = l + ss;
 234                 Success = PM_MapShadowPart(top, delta, &shrect, l, t, ss, direction, SHADOWFLAG_BOTTOM | SHADOWFLAG_LEFT);
 235
 236                 if (Success)
 237                         {
 238                         // Shadow 2
 239                         shrect.Left = l + ss;
 240                         shrect.Right = r;
 241                         Success = PM_MapShadowPart(top, delta, &shrect, l, t, ss, direction, SHADOWFLAG_BOTTOM);
 242                         }
 243                 }
 244
 245         return Success;
 246 }
 247
 248
 249 static BOOL PM_MapShadowPart(PMTRList *top, PMSRList *delta,
 250         const PMSR *shrect, WORD l, WORD t, UWORD ss,
 251         UWORD direction, UBYTE Type)
 252 {
 253         PMTR *topnode, *nexttopnode;
 254         BOOL Success = TRUE;
 255
 256         d1(KPrintF("%s/%s/%ld: Left=%ld  Top=%ld  Right=%ld  Bottom=%ld\n", \
 257                 __FILE__, __FUNC__, __LINE__, shrect->Left, shrect->Top, shrect->Right, shrect->Bottom));
 258
 259         topnode = (PMTR *)(top->mlh_Head); /* First node */
 260         while ((nexttopnode = (PMTR *)PM_NextNode(topnode)))
 261                 {
 262                 PMSR rect, *newnode;
 263                 UWORD dx, dy;
 264
 265                 dx = dy = 0;
 266
 267                 d1(KPrintF("Mapping shadow to region: %ld %ld %ld %ld, height: %ld\n", \
 268                         topnode->Left, topnode->Top, topnode->Right, topnode->Bottom, topnode->Height));
 269
 270                 if (direction & PMSHADOW_HORIZ)
 271                         dx = topnode->Height * 2;
 272                 if (direction & PMSHADOW_VERT)
 273                         dy = topnode->Height * 2;
 274
 275                 rect.pmsr_Type = Type;
 276
 277                 rect.Left = MAX(shrect->Left, topnode->Left);
 278                 rect.Right = MIN(shrect->Right-dx, topnode->Right);
 279                 rect.Top = MAX(shrect->Top, topnode->Top);
 280                 rect.Bottom = MIN(shrect->Bottom-dy, topnode->Bottom);
 281                 rect.n.Length = sizeof(PMSR);
 282 #if 0
 283                 if (direction & PMSHADOW_LEFT)
 284                         {
 285                         if (rect.Left < l + ss - (topnode->Height * 2))
 286                                 rect.Left = l + ss - (topnode->Height * 2);
 287                         }
 288
 289                 if (direction & PMSHADOW_TOP)
 290                         {
 291                         if (rect.Top < t+ss-(topnode->Height*2))
 292                                 rect.Top = t+ss-(topnode->Height*2);
 293                         }
 294 #endif
 295                 d1(KPrintF("%s/%s/%ld: Left=%ld  Top=%ld  RIght=%ld  Bottom=%ld\n", \
 296                         __FILE__, __FUNC__, __LINE__, rect.Left, rect.Top, rect.Right, rect.Bottom));
 297                 if (rect.Right > rect.Left && rect.Bottom > rect.Top)
 298                         {
 299                         newnode = PM_CopyShadowNode(&rect);
 300                         if (newnode)
 301                                 {
 302                                 AddHead((struct List *)delta, (struct Node *)newnode);
 303                                 }
 304                         else
 305                                 {
 306                                 Success = FALSE;
 307                                 }
 308                         }
 309
 310                 topnode = nexttopnode;
 311                 }
 312
 313         return Success;
 314 }