bgui/vectorclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * vectorclass.c
   6  *
   7  * (C) Copyright 1998 Manuel Lemos.
   8  * (C) Copyright 1996-1997 Ian J. Einman.
   9  * (C) Copyright 1993-1996 Jaba Development.
  10  * (C) Copyright 1993-1996 Jan van den Baard.
  11  * All Rights Reserved.
  12  *
  13  * $Log$
  14  * Revision 42.7  2004/06/16 20:16:48  verhaegs
  15  * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
  16  *
  17  * Revision 42.6  2003/01/18 19:10:03  chodorowski
  18  * Instead of using the _AROS or __AROS preprocessor symbols, use __AROS__.
  19  *
  20  * Revision 42.5  2000/08/08 20:57:26  chodorowski
  21  * Minor fixes to build on Amiga.
  22  *
  23  * Revision 42.4  2000/05/29 15:42:49  stegerg
  24  * fixed some "comparison is always 1 due to limited range of data type"
  25  * errors
  26  *
  27  * Revision 42.3  2000/05/29 00:40:24  bergers
  28  * Update to compile with AROS now. Should also still compile with SASC etc since I only made changes that test the define __AROS__. The compilation is still very noisy but it does the trick for the main directory. Maybe members of the BGUI team should also have a look at the compiler warnings because some could also cause problems on other systems... (Comparison always TRUE due to datatype (or something like that)). And please compile it on an Amiga to see whether it still works... Thanks.
  29  *
  30  * Revision 42.2  2000/05/15 19:27:02  stegerg
  31  * another hundreds of REG() macro replacements in func headers/protos.
  32  *
  33  * Revision 42.1  2000/05/14 23:32:48  stegerg
  34  * changed over 200 function headers which all use register
  35  * parameters (oh boy ...), because the simple REG() macro
  36  * doesn't work with AROS. And there are still hundreds
  37  * of headers left to be fixed :(
  38  *
  39  * Many of these functions would also work with stack
  40  * params, but since i have fixed every single one
  41  * I encountered up to now, I guess will have to do
  42  * the same for the rest.
  43  *
  44  * Revision 42.0  2000/05/09 22:10:34  mlemos
  45  * Bumped to revision 42.0 before handing BGUI to AROS team
  46  *
  47  * Revision 41.11  2000/05/09 19:55:23  mlemos
  48  * Merged with the branch Manuel_Lemos_fixes.
  49  *
  50  * Revision 41.10.2.1  1998/11/16 20:01:56  mlemos
  51  * Replaced AllocVec and FreeVec calls by BGUI_AllocPoolMem and
  52  * BGUI_FreePoolMem calls respectively.
  53  * Restored prior RastPort AreaInfo and TmpRas after rendering.
  54  *
  55  * Revision 41.10  1998/02/25 21:13:26  mlemos
  56  * Bumping to 41.10
  57  *
  58  * Revision 1.1  1998/02/25 17:10:00  mlemos
  59  * Ian sources
  60  *
  61  *
  62  */
  63
  64 /// Class definitions.
  65
  66 #include "include/classdefs.h"
  67
  68 /*
  69  * Object instance data.
  70  */
  71 typedef struct {
  72    struct TmpRas      vd_TmpRas;        /* TmpRas for areafill's.     */
  73    struct AreaInfo    vd_AreaInfo;      /* AreaInfo for areafill's.   */
  74    UWORD              vd_SizeX;         /* Design width.              */
  75    UWORD              vd_SizeY;         /* Design height.             */
  76    UWORD              vd_MinWidth;      /* Minimum width.             */
  77    UWORD              vd_MinHeight;     /* Minimum height.            */
  78    UWORD              vd_BuiltInType;   /* Built-in type.             */
  79    UWORD              vd_Flags;         /* Flags (see below).         */
  80    UWORD              vd_Pen;           /* Pen to use for drawing.    */
  81    UWORD              vd_DriPen;        /* DriPen to use for drawing. */
  82    struct VectorItem *vd_VectorArray;   /* The vector elements.       */
  83    PLANEPTR           vd_AreaPlane;     /* Bit-plane for areafills.   */
  84    WORD              *vd_VertexBuffer;  /* Buffer for areafills.      */
  85    UWORD              vd_PlaneWidth;    /* Width of area-plane.       */
  86    UWORD              vd_PlaneHeight;   /* Height of area-plane.      */
  87    UWORD              vd_ErasePen;      /* Pen to erase with.         */
  88    struct TmpRas     *vd_OldTmpRas;     /* TmpRas before rendering.   */
  89    struct AreaInfo   *vd_OldAreaInfo;   /* AreaInfo before rendering. */
  90 }  VD;
  91
  92 #define VDATF_AREA       (1<<0)         /* We are area filling.       */
  93
  94 ///
  95 /// Built-in images.
  96
  97 /*
  98  * Built-in GETPATH image.
  99  */
 100 STATIC struct VectorItem BuiltinGetPath[] = {
 101    { 20, 14,  VIF_SCALE                                 },
 102    {  4,  4,  VIF_MOVE | VIF_AREASTART                  },
 103    {  8,  4,  VIF_DRAW                                  },
 104    {  9,  5,  VIF_DRAW                                  },
 105    {  5,  5,  VIF_DRAW                                  },
 106    {  5,  2,  VIF_DRAW | VIF_YRELBOTTOM                 },
 107    {  4,  2,  VIF_DRAW | VIF_YRELBOTTOM                 },
 108    {  4,  4,  VIF_AREAEND                               },
 109    {  8,  4,  VIF_MOVE                                  },
 110    {  9,  2,  VIF_DRAW | VIF_XRELRIGHT                  },
 111    {  6,  2,  VIF_DRAW | VIF_XRELRIGHT                  },
 112    {  4,  4,  VIF_DRAW | VIF_XRELRIGHT                  },
 113    {  4,  2,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 114    {  4,  2,  VIF_DRAW | VIF_YRELBOTTOM                 },
 115    {  9,  5,  VIF_MOVE                                  },
 116    {  8,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 117    {  4,  6,  VIF_DRAW | VIF_XRELRIGHT | VIF_LASTITEM   },
 118 };
 119
 120 /*
 121  * Built-in GETFILE image.
 122  */
 123 STATIC struct VectorItem BuiltinGetFile[] = {
 124    { 20, 14,  VIF_SCALE                                 },
 125    {  4,  2,  VIF_MOVE | VIF_AREASTART                  },
 126    {  5,  2,  VIF_DRAW                                  },
 127    {  5,  2,  VIF_DRAW | VIF_YRELBOTTOM                 },
 128    {  4,  2,  VIF_DRAW | VIF_YRELBOTTOM                 },
 129    {  4,  2,  VIF_AREAEND                               },
 130    {  4,  2,  VIF_MOVE                                  },
 131    {  8,  2,  VIF_DRAW | VIF_XRELRIGHT                  },
 132    {  4,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 133    {  8,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 134    {  8,  2,  VIF_DRAW | VIF_XRELRIGHT                  },
 135    {  4,  2,  VIF_MOVE | VIF_YRELBOTTOM                 },
 136    {  4,  2,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 137    {  5,  6,  VIF_MOVE | VIF_XRELRIGHT | VIF_AREASTART  },
 138    {  4,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 139    {  4,  2,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 140    {  5,  2,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 141    {  5,  6,  VIF_LASTITEM | VIF_XRELRIGHT              },
 142 };
 143
 144 /*
 145  * Built-in CheckMark image.
 146  */
 147 STATIC struct VectorItem BuiltinCheckMark[] = {
 148    { 24, 11,  VIF_SCALE                                 },
 149    {  6,  5,  VIF_MOVE | VIF_AREASTART                  },
 150    {  9,  8,  VIF_DRAW                                  },
 151    { 11,  8,  VIF_DRAW                                  },
 152    {  6,  2,  VIF_DRAW | VIF_XRELRIGHT                  },
 153    {  5,  2,  VIF_DRAW | VIF_XRELRIGHT                  },
 154    {  7,  2,  VIF_DRAW | VIF_XRELRIGHT                  },
 155    { 11,  7,  VIF_DRAW                                  },
 156    { 10,  7,  VIF_DRAW                                  },
 157    {  8,  5,  VIF_DRAW                                  },
 158    {  6,  5,  VIF_LASTITEM                              },
 159 };
 160
 161 /*
 162  * Built-in RadioButton image.
 163  */
 164 STATIC struct VectorItem BuiltinRadioButton[] = {
 165    { 16,  8,  VIF_SCALE                                 },
 166    {  4,  3,  VIF_MOVE | VIF_AREASTART                  },
 167    {  6,  2,  VIF_DRAW                                  },
 168    {  6,  2,  VIF_DRAW | VIF_XRELRIGHT                  },
 169    {  4,  3,  VIF_DRAW | VIF_XRELRIGHT                  },
 170    {  4,  3,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 171    {  6,  2,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 172    {  6,  2,  VIF_DRAW | VIF_YRELBOTTOM                 },
 173    {  4,  3,  VIF_DRAW | VIF_YRELBOTTOM                 },
 174    {  4,  3,  VIF_LASTITEM                              },
 175 };
 176
 177 #ifdef __AROS__
 178 #warning A comment within a comment makes gcc puke...
 179 #if 0
 180 /*******************************************************************************
 181 /*
 182  * Built-in PopUp image.
 183  */
 184 STATIC struct VectorItem BuiltInPopUp[] = {
 185    {  44,  20,  VIF_MOVE | VIF_AREASTART },
 186    {  56,  20,  VIF_DRAW                 },
 187    {  56,  35,  VIF_DRAW                 },
 188    {  73,  35,  VIF_DRAW                 },
 189    {  50,  55,  VIF_DRAW                 },
 190    {  27,  35,  VIF_DRAW                 },
 191    {  44,  35,  VIF_DRAW                 },
 192    {  44,  20,  VIF_DRAW | VIF_AREAEND   },
 193    {  27,  70,  VIF_MOVE | VIF_AREASTART },
 194    {  73,  70,  VIF_DRAW                 },
 195    {  73,  77,  VIF_DRAW                 },
 196    {  27,  77,  VIF_DRAW | VIF_AREAEND   },
 197    {  18,  14,  VIF_MINSIZE              },
 198    { 100, 100,  VIF_SCALE | VIF_LASTITEM },
 199 };
 200
 201 /*
 202  * Built-in Cycle image.
 203  */
 204 STATIC struct VectorItem BuiltInCycle[] = {
 205    { 18, 14,  VIF_SCALE                                 },
 206    {  5,  3,  VIF_MOVE | VIF_AREASTART | VIF_YRELBOTTOM },
 207    {  6,  3,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 208    {  5,  4,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 209    {  5,  4,  VIF_DRAW                 | VIF_YRELBOTTOM },
 210    {  5,  4,  VIF_DRAW                                  },
 211    {  6,  4,  VIF_DRAW | VIF_XRELRIGHT                  },
 212    {  6,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 213    {  8,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 214    {  6,  8,  VIF_DRAW | VIF_XRELRIGHT                  },
 215    {  5,  8,  VIF_DRAW | VIF_XRELRIGHT                  },
 216    {  3,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 217    {  5,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 218    {  5,  4,  VIF_DRAW | VIF_XRELRIGHT                  },
 219    {  6,  3,  VIF_DRAW | VIF_XRELRIGHT                  },
 220    {  5,  3,  VIF_DRAW                                  },
 221    {  4,  4,  VIF_DRAW                                  },
 222    {  4,  4,  VIF_DRAW | VIF_AREAEND   | VIF_YRELBOTTOM | VIF_LASTITEM },
 223 };
 224
 225 /*
 226  * Built-in Cycle image - selected.
 227  */
 228 STATIC struct VectorItem BuiltInCycle2[] = {
 229    { 18, 14,  VIF_SCALE                                 },
 230    {  5,  3,  VIF_MOVE | VIF_XRELRIGHT | VIF_AREASTART  },
 231    {  6,  3,  VIF_DRAW                                  },
 232    {  5,  4,  VIF_DRAW                                  },
 233    {  5,  4,  VIF_DRAW | VIF_XRELRIGHT                  },
 234    {  5,  4,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 235    {  6,  4,  VIF_DRAW                 | VIF_YRELBOTTOM },
 236    {  6,  6,  VIF_DRAW                 | VIF_YRELBOTTOM },
 237    {  8,  6,  VIF_DRAW                 | VIF_YRELBOTTOM },
 238    {  6,  8,  VIF_DRAW                 | VIF_YRELBOTTOM },
 239    {  5,  8,  VIF_DRAW                 | VIF_YRELBOTTOM },
 240    {  3,  6,  VIF_DRAW                 | VIF_YRELBOTTOM },
 241    {  5,  6,  VIF_DRAW                 | VIF_YRELBOTTOM },
 242    {  5,  4,  VIF_DRAW                 | VIF_YRELBOTTOM },
 243    {  6,  3,  VIF_DRAW                 | VIF_YRELBOTTOM },
 244    {  5,  3,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 245    {  4,  4,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 246    {  4,  4,  VIF_DRAW | VIF_XRELRIGHT | VIF_AREAEND    | VIF_LASTITEM },
 247 };
 248 *****************************************************************************************/
 249 #endif
 250 #endif
 251
 252 /*
 253  * Built-in PopUp image.
 254  */
 255 STATIC struct VectorItem BuiltInPopUp[] = {
 256    { 15, 13, VIF_SCALE  },
 257    {  6,  2, VIF_MOVE | VIF_AREASTART  },
 258    {  8,  2, VIF_DRAW   },
 259    {  8,  4, VIF_DRAW   },
 260    { 10,  4, VIF_DRAW   },
 261    {  7,  7, VIF_DRAW   },
 262    {  4,  4, VIF_DRAW   },
 263    {  6,  4, VIF_DRAW   },
 264    {  6,  2, VIF_DRAW | VIF_AREAEND    },
 265    {  4,  9, VIF_MOVE | VIF_AREASTART  },
 266    { 10,  9, VIF_DRAW   },
 267    { 10, 10, VIF_DRAW   },
 268    {  4, 10, VIF_DRAW | VIF_AREAEND | VIF_LASTITEM },
 269 };
 270
 271 /*
 272  * Built-in Cycle image.
 273  */
 274 STATIC struct VectorItem BuiltInCycle[] = {
 275    { 17, 13, VIF_SCALE },
 276    {  4, 10, VIF_MOVE | VIF_AREASTART},
 277    { 10, 10, VIF_DRAW },
 278    { 11,  9, VIF_DRAW },
 279    {  4,  9, VIF_DRAW },
 280    {  4,  3, VIF_DRAW },
 281    { 10,  3, VIF_DRAW },
 282    { 10,  5, VIF_DRAW },
 283    {  8,  5, VIF_DRAW },
 284    { 10,  7, VIF_DRAW },
 285    { 11,  7, VIF_DRAW },
 286    { 13,  5, VIF_DRAW },
 287    { 11,  5, VIF_DRAW },
 288    { 11,  3, VIF_DRAW },
 289    { 10,  2, VIF_DRAW },
 290    {  4,  2, VIF_DRAW },
 291    {  3,  3, VIF_DRAW },
 292    {  3,  9, VIF_DRAW | VIF_AREAEND | VIF_LASTITEM },
 293 };
 294
 295 /*
 296  * Built-in Cycle image - selected.
 297  */
 298 STATIC struct VectorItem BuiltInCycle2[] = {
 299    { 17, 13, VIF_SCALE },
 300    { 11,  2, VIF_MOVE | VIF_AREASTART},
 301    {  5,  2, VIF_DRAW },
 302    {  4,  3, VIF_DRAW },
 303    { 11,  3, VIF_DRAW },
 304    { 11,  9, VIF_DRAW },
 305    {  5,  9, VIF_DRAW },
 306    {  5,  7, VIF_DRAW },
 307    {  7,  7, VIF_DRAW },
 308    {  5,  5, VIF_DRAW },
 309    {  4,  5, VIF_DRAW },
 310    {  2,  7, VIF_DRAW },
 311    {  4,  7, VIF_DRAW },
 312    {  4,  9, VIF_DRAW },
 313    {  5, 10, VIF_DRAW },
 314    { 11, 10, VIF_DRAW },
 315    { 12,  9, VIF_DRAW },
 316    { 12,  3, VIF_DRAW | VIF_AREAEND | VIF_LASTITEM },
 317 };
 318
 319 /*
 320  * Built-in arrow up image.
 321  */
 322 STATIC struct VectorItem BuiltInArrowUp[] = {
 323    { 16,  9,  VIF_SCALE                                 },
 324    {  3,  6,  VIF_MOVE | VIF_AREASTART                  },
 325    {  8,  2,  VIF_DRAW | VIF_XRELRIGHT                  },
 326    {  8,  2,  VIF_DRAW                                  },
 327    {  3,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 328    {  4,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 329    {  8,  3,  VIF_DRAW                                  },
 330    {  8,  3,  VIF_DRAW | VIF_XRELRIGHT                  },
 331    {  4,  6,  VIF_DRAW | VIF_LASTITEM                   },
 332 };
 333
 334 /*
 335  * Built-in arrow DOWN vector image.
 336  */
 337 STATIC struct VectorItem BuiltInArrowDown[] = {
 338    { 16,  9,  VIF_SCALE                                 },
 339    {  3,  6,  VIF_MOVE | VIF_AREASTART | VIF_YRELBOTTOM },
 340    {  8,  2,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 341    {  8,  2,  VIF_DRAW | VIF_YRELBOTTOM                 },
 342    {  3,  6,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 343    {  4,  6,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 344    {  8,  3,  VIF_DRAW | VIF_YRELBOTTOM                 },
 345    {  8,  3,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 346    {  4,  6,  VIF_DRAW | VIF_LASTITEM  | VIF_YRELBOTTOM },
 347 };
 348
 349 /*
 350  * Built-in arrow LEFT vector image.
 351  */
 352 STATIC struct VectorItem BuiltInArrowLeft[] = {
 353    { 10, 12,  VIF_SCALE                                 },
 354    {  6,  2,  VIF_MOVE | VIF_AREASTART },
 355    {  3,  6,  VIF_DRAW | VIF_YRELBOTTOM                 },
 356    {  3,  6,  VIF_DRAW                                  },
 357    {  6,  2,  VIF_DRAW | VIF_YRELBOTTOM                 },
 358    {  6,  3,  VIF_DRAW | VIF_YRELBOTTOM                 },
 359    {  4,  6,  VIF_DRAW                                  },
 360    {  4,  6,  VIF_DRAW | VIF_YRELBOTTOM                 },
 361    {  6,  3,  VIF_DRAW | VIF_LASTITEM                   },
 362 };
 363
 364 /*
 365  * Built-in arrow RIGHT vector image.
 366  */
 367 STATIC struct VectorItem BuiltInArrowRight[] = {
 368    { 10, 12,  VIF_SCALE                                 },
 369    {  6,  2,  VIF_MOVE | VIF_AREASTART | VIF_XRELRIGHT  },
 370    {  3,  6,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 371    {  3,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 372    {  6,  2,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 373    {  6,  3,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 374    {  4,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 375    {  4,  6,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 376    {  6,  3,  VIF_DRAW | VIF_LASTITEM | VIF_XRELRIGHT   },
 377 };
 378
 379 /*
 380  * Built-in GETFONT image.
 381  */
 382 STATIC struct VectorItem BuiltInGetFont[] = {
 383    {  8,  4,  VIF_MOVE | VIF_AREASTART                  },
 384    { 10,  4,  VIF_DRAW                                  },
 385    { 10,  4,  VIF_DRAW | VIF_YRELBOTTOM                 },
 386    {  8,  4,  VIF_DRAW | VIF_YRELBOTTOM                 },
 387    {  8,  4,  VIF_AREAEND                               },
 388    {  8,  4,  VIF_MOVE | VIF_AREASTART                  },
 389    { 18,  4,  VIF_DRAW                                  },
 390    { 20,  6,  VIF_DRAW                                  },
 391    { 20, 12,  VIF_DRAW                                  },
 392    { 18, 14,  VIF_DRAW                                  },
 393    { 20, 12,  VIF_DRAW | VIF_YRELBOTTOM                 },
 394    { 20,  6,  VIF_DRAW | VIF_YRELBOTTOM                 },
 395    { 18,  4,  VIF_DRAW | VIF_YRELBOTTOM                 },
 396    {  9,  4,  VIF_DRAW | VIF_YRELBOTTOM                 },
 397    {  9,  6,  VIF_DRAW | VIF_YRELBOTTOM                 },
 398    { 17,  6,  VIF_DRAW | VIF_YRELBOTTOM                 },
 399    { 18,  7,  VIF_DRAW | VIF_YRELBOTTOM                 },
 400    { 18, 12,  VIF_DRAW | VIF_YRELBOTTOM                 },
 401    { 17, 13,  VIF_DRAW | VIF_YRELBOTTOM                 },
 402    {  9, 13,  VIF_DRAW | VIF_YRELBOTTOM                 },
 403    {  9, 13,  VIF_DRAW                                  },
 404    { 17, 13,  VIF_DRAW                                  },
 405    { 18, 12,  VIF_DRAW                                  },
 406    { 18,  7,  VIF_DRAW                                  },
 407    { 17,  6,  VIF_DRAW                                  },
 408    {  9,  6,  VIF_DRAW | VIF_AREAEND                    },
 409
 410    { 24,  4,  VIF_MOVE | VIF_AREASTART                  },
 411    { 26,  4,  VIF_DRAW                                  },
 412    { 26,  4,  VIF_DRAW | VIF_YRELBOTTOM                 },
 413    { 24,  4,  VIF_DRAW | VIF_YRELBOTTOM                 },
 414    { 24,  4,  VIF_DRAW | VIF_AREAEND                    },
 415    { 25, 13,  VIF_MOVE | VIF_AREASTART                  },
 416    { 30, 13,  VIF_DRAW                                  },
 417    { 32, 13,  VIF_DRAW | VIF_YRELBOTTOM                 },
 418    { 32,  6,  VIF_DRAW | VIF_YRELBOTTOM                 },
 419    { 30,  4,  VIF_DRAW | VIF_YRELBOTTOM                 },
 420    { 25,  4,  VIF_DRAW | VIF_YRELBOTTOM                 },
 421    { 25,  6,  VIF_DRAW | VIF_YRELBOTTOM                 },
 422    { 29,  6,  VIF_DRAW | VIF_YRELBOTTOM                 },
 423    { 30,  7,  VIF_DRAW | VIF_YRELBOTTOM                 },
 424    { 30, 12,  VIF_DRAW | VIF_YRELBOTTOM                 },
 425    { 29, 13,  VIF_DRAW | VIF_YRELBOTTOM                 },
 426    { 25, 13,  VIF_DRAW | VIF_YRELBOTTOM | VIF_AREAEND   },
 427
 428    { 20, 14,  VIF_MINSIZE                               },
 429    { 40, 28,  VIF_SCALE | VIF_LASTITEM                  },
 430 };
 431
 432 /*
 433  * Built-in GETSCREEN image.
 434  */
 435 STATIC struct VectorItem BuiltInGetScreen[] = {
 436    { 20, 14,  VIF_SCALE                                 },
 437    {  4,  2,  VIF_MOVE | VIF_AREASTART                  },
 438    {  5,  2,  VIF_DRAW                                  },
 439    {  5,  2,  VIF_DRAW | VIF_YRELBOTTOM                 },
 440    {  4,  2,  VIF_DRAW | VIF_YRELBOTTOM                 },
 441    {  4,  2,  VIF_AREAEND                               },
 442    {  4,  2,  VIF_MOVE                                  },
 443    {  8,  2,  VIF_DRAW | VIF_XRELRIGHT                  },
 444    {  4,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 445    {  8,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 446    {  8,  2,  VIF_DRAW | VIF_XRELRIGHT                  },
 447    {  4,  2,  VIF_MOVE | VIF_YRELBOTTOM                 },
 448    {  4,  2,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 449    {  5,  6,  VIF_MOVE | VIF_XRELRIGHT | VIF_AREASTART  },
 450    {  4,  6,  VIF_DRAW | VIF_XRELRIGHT                  },
 451    {  4,  2,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 452    {  5,  2,  VIF_DRAW | VIF_XRELRIGHT | VIF_YRELBOTTOM },
 453    {  5,  6,  VIF_LASTITEM | VIF_XRELRIGHT              },
 454 };
 455
 456 static struct VectorItem *BuiltIn[] =
 457 {
 458    NULL,
 459    BuiltinGetPath,
 460    BuiltinGetFile,
 461    BuiltinCheckMark,
 462    BuiltInPopUp,
 463    BuiltInArrowUp,
 464    BuiltInArrowDown,
 465    BuiltInArrowLeft,
 466    BuiltInArrowRight,
 467    BuiltInCycle,
 468    BuiltInCycle2,
 469    BuiltinRadioButton,
 470    BuiltInGetFont,
 471    BuiltInGetScreen,
 472 };
 473 ///
 474
 475 /*
 476  * Deallocate the AreaFill() stuff.
 477  */
 478 //STATIC ASM VOID CleanUpArea( REG(a0) struct RastPort *rp, REG(a1) VD *vd )
 479 STATIC ASM REGFUNC2(VOID, CleanUpArea,
 480         REGPARAM(A0, struct RastPort *, rp),
 481         REGPARAM(A1, VD *, vd))
 482 {
 483    if (vd->vd_Flags & VDATF_AREA)
 484    {
 485       /*
 486        * Don't deallocate to soon.
 487        */
 488       WaitBlit();
 489
 490       rp->TmpRas=vd->vd_OldTmpRas;
 491       rp->AreaInfo=vd->vd_OldAreaInfo;
 492
 493       /*
 494        * Deallocate the buffers.
 495        */
 496       if (vd->vd_AreaPlane)
 497       {
 498          FreeRaster( vd->vd_AreaPlane, vd->vd_PlaneWidth, vd->vd_PlaneHeight );
 499          vd->vd_AreaPlane = NULL;
 500       }
 501
 502       if (vd->vd_VertexBuffer)
 503       {
 504          BGUI_FreePoolMem( vd->vd_VertexBuffer );
 505          vd->vd_VertexBuffer = NULL;
 506       }
 507
 508       vd->vd_PlaneWidth = vd->vd_PlaneHeight = 0;
 509
 510       /*
 511        * Mark us as not area filling.
 512        */
 513       vd->vd_Flags &= ~VDATF_AREA;
 514    };
 515 }
 516 REGFUNC_END
 517
 518 /*
 519  * Allocate the necessary stuff
 520  * for area filling. If this fails
 521  * the image areas are not filled.
 522  */
 523 STATIC ULONG SetupArea( struct RastPort *rp, VD *vd, struct VectorItem *vi, UWORD w, UWORD h )
 524 {
 525    UWORD              numelem = 0;
 526    struct VectorItem *vi2;
 527
 528    /*
 529     * Count the number of vector elements
 530    ** in the area fill operation.
 531    **/
 532    for (vi2 = vi; !(vi2->vi_Flags & (VIF_AREAEND|VIF_LASTITEM)); vi2++);
 533
 534    /*
 535     * Safety margins.
 536     */
 537    numelem = vi2 - vi + 2;
 538
 539    w <<= 1;
 540    h <<= 1;
 541
 542    /*
 543     * Allocate and setup the buffers etc.
 544     */
 545    if (vd->vd_VertexBuffer = (UWORD *)BGUI_AllocPoolMem(numelem * 5))
 546    {
 547       memset(vd->vd_VertexBuffer,'\0',numelem * 5);
 548       if (vd->vd_AreaPlane = AllocRaster(w, h)) {
 549          /*
 550           * Initialize structures.
 551           */
 552          InitTmpRas( &vd->vd_TmpRas, vd->vd_AreaPlane, RASSIZE( w, h ));
 553          InitArea( &vd->vd_AreaInfo, vd->vd_VertexBuffer, numelem );
 554          /*
 555           * Set them up.
 556           */
 557          vd->vd_OldTmpRas   = rp->TmpRas;
 558          rp->TmpRas         = &vd->vd_TmpRas;
 559          vd->vd_OldAreaInfo = rp->AreaInfo;
 560          rp->AreaInfo       = &vd->vd_AreaInfo;
 561          /*
 562           * Mark raster size.
 563           */
 564          vd->vd_PlaneWidth  = w;
 565          vd->vd_PlaneHeight = h;
 566          /*
 567           * Mark us as area filling.
 568           */
 569          vd->vd_Flags |= VDATF_AREA;
 570
 571          return 1;
 572       }
 573    }
 574    /*
 575     * Oops. Screw up somewhere.
 576     */
 577    CleanUpArea(rp, vd);
 578
 579    return 0;
 580 }
 581
 582 /// OM_NEW
 583 /*
 584  * Create a shiny new object.
 585  */
 586 METHOD(VectorClassNew, struct opSet *, ops)
 587 {
 588    VD       *vd;
 589    ULONG     rc;
 590
 591    /*
 592     * First we let the superclass
 593     * create a new object.
 594     */
 595    if (rc = AsmDoSuperMethodA(cl, obj, (Msg)ops))
 596    {
 597       /*
 598        * Get us the instance data.
 599        */
 600       vd = INST_DATA(cl, rc);
 601
 602       /*
 603        * Setup defaults.
 604        */
 605       vd->vd_Pen = vd->vd_DriPen = (UWORD)~0;
 606
 607       /*
 608        * Setup the object.
 609        */
 610       AsmCoerceMethod(cl, (Object *)rc, OM_SET, ops->ops_AttrList, NULL);
 611    }
 612    return rc;
 613 }
 614 METHOD_END
 615 ///
 616 /// OM_SET
 617 /*
 618  * Change one or more attrubutes.
 619  */
 620 METHOD(VectorClassSet, struct opSet *, ops)
 621 {
 622    VD                *vd = INST_DATA(cl, obj);
 623    struct TagItem    *tag, *tstate = ops->ops_AttrList;
 624    ULONG              data;
 625    BOOL               resize = FALSE;
 626    struct VectorItem *vi;
 627    ULONG              rc;
 628
 629    /*
 630     * First we let the superclass
 631     * change the attributes it
 632     * knows.
 633     */
 634    rc = AsmDoSuperMethodA(cl, obj, (Msg)ops);
 635
 636    /*
 637     * Get the attributes.
 638     */
 639    while (tag = NextTagItem(&tstate))
 640    {
 641       data = tag->ti_Data;
 642       switch (tag->ti_Tag)
 643       {
 644       case VIT_VectorArray:
 645          vd->vd_VectorArray = (struct VectorItem *)data;
 646          resize = TRUE;
 647          break;
 648
 649       case VIT_BuiltIn:
 650          vd->vd_VectorArray = BuiltIn[data];
 651          vd->vd_BuiltInType = data;
 652          resize = TRUE;
 653          break;
 654
 655       case VIT_Pen:
 656          vd->vd_Pen = data;
 657          break;
 658
 659       case VIT_DriPen:
 660          vd->vd_DriPen = data;
 661          break;
 662
 663       case IMAGE_ErasePen:
 664          vd->vd_ErasePen = data;
 665          break;
 666       };
 667    };
 668
 669    if (resize)
 670    {
 671       /*
 672        * Setup the default minimums.
 673        */
 674       vd->vd_MinWidth  = 0;
 675       vd->vd_MinHeight = 0;
 676
 677       for (vi = vd->vd_VectorArray; resize; vi++)
 678       {
 679          if (vi->vi_Flags & VIF_SCALE)
 680          {
 681             /*
 682              * Setup the design size.
 683              */
 684             vd->vd_SizeX = vi->vi_x;
 685             vd->vd_SizeY = vi->vi_y;
 686          };
 687          if (vi->vi_Flags & VIF_MINSIZE)
 688          {
 689             /*
 690              * Setup the design size.
 691              */
 692             vd->vd_MinWidth  = vi->vi_x;
 693             vd->vd_MinHeight = vi->vi_y;
 694          };
 695          if (vi->vi_Flags & VIF_LASTITEM) resize = FALSE;
 696       };
 697       if (!vd->vd_MinWidth)  vd->vd_MinWidth  = vd->vd_SizeX;
 698       if (!vd->vd_MinHeight) vd->vd_MinHeight = vd->vd_SizeY;
 699    };
 700    return rc;
 701 }
 702 METHOD_END
 703 ///
 704 /// OM_GET
 705 /*
 706  * Give an attribute value.
 707  */
 708 METHOD(VectorClassGet, struct opGet *, opg)
 709 {
 710    VD          *vd = INST_DATA( cl, obj );
 711    ULONG        rc = 1, *store = opg->opg_Storage;
 712
 713    /*
 714     * Firts we see if the attribute
 715     * they want is know to us. If not
 716     * we pass it onto the superclass.
 717     */
 718    switch (opg->opg_AttrID)
 719    {
 720    case VIT_VectorArray:   STORE vd->vd_VectorArray;  break;
 721    case VIT_BuiltIn:       STORE vd->vd_BuiltInType;  break;
 722    case VIT_Pen:           STORE vd->vd_Pen;          break;
 723    case VIT_DriPen:        STORE vd->vd_DriPen;       break;
 724    case VIT_MinWidth:      STORE vd->vd_MinWidth;     break;
 725    case VIT_MinHeight:     STORE vd->vd_MinHeight;    break;
 726    default:
 727       rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 728       break;
 729    }
 730
 731    return rc;
 732 }
 733 METHOD_END
 734 ///
 735 /// BASE_RENDER
 736 /*
 737  * Render the vector image.
 738  */
 739 METHOD(VectorClassRender, struct bmRender *, bmr)
 740 {
 741    VD                *vd = INST_DATA(cl, obj);
 742    struct VectorItem *vi = vd->vd_VectorArray;
 743    struct BaseInfo   *bi = bmr->bmr_BInfo;
 744    struct RastPort   *rp = bi->bi_RPort;
 745    ULONG              rc = 1, f;
 746    int                l, t, r, b, w, h, x, y;
 747    BOOL               go = TRUE;
 748
 749    /*
 750     * Only render if there are vector
 751     * elements to render.
 752     */
 753    if (!vi) return 1;
 754
 755    /*
 756     * Get image position and dimensions.
 757     */
 758    l = IMAGE(obj)->LeftEdge;
 759    t = IMAGE(obj)->TopEdge;
 760    w = IMAGE(obj)->Width;
 761    h = IMAGE(obj)->Height;
 762
 763    /*
 764     * Get image right and bottom edge coordinates.
 765     */
 766    r = l + w - 1;
 767    b = t + h - 1;
 768
 769    /*
 770     * Setup the correct startup-pen.
 771     */
 772    if (vd->vd_DriPen != (UWORD)~0)
 773       BSetDPenA(bi, vd->vd_DriPen);
 774    else if (vd->vd_Pen != (UWORD)~0)
 775       BSetPenA(bi, vd->vd_Pen);
 776    else
 777    {
 778       switch (bmr->bmr_Flags)
 779       {
 780       case IDS_SELECTED:
 781          BSetDPenA(bi, FILLTEXTPEN);
 782          break;
 783
 784       case IDS_INACTIVESELECTED:
 785       default:
 786          BSetDPenA(bi, TEXTPEN);
 787          break;
 788       };
 789    };
 790
 791    /*
 792     * Jam only only color.
 793     */
 794    BSetDrMd(bi, JAM1);
 795
 796    /*
 797     * Clear rp pattern.
 798     */
 799    BClearAfPt(bi);
 800    BNDRYOFF(rp);
 801
 802    /*
 803     * Loop through the vector elements.
 804     */
 805    for (; go; vi++)
 806    {
 807       f = vi->vi_Flags;
 808       x = vi->vi_x;
 809       y = vi->vi_y;
 810
 811       go = !(f & VIF_LASTITEM);
 812
 813       if (f & (VIF_SCALE|VIF_MINSIZE))
 814          continue;
 815
 816       if (f & VIF_COLOR)
 817       {
 818          BSetPenA(bi, x);
 819          if (f & VIF_BPEN) BSetPenB(bi, y);
 820          continue;
 821       };
 822       if (f & VIF_DRIPEN)
 823       {
 824          BSetDPenA(bi, x);
 825          if (f & VIF_BPEN) BSetDPenB(bi, y);
 826          continue;
 827       };
 828       if (f & VIF_DRAWMODE)
 829       {
 830          BSetDrMd(bi, x);
 831          continue;
 832       };
 833
 834       if (f & VIF_LINEPATTERN)
 835       {
 836          SetDrPt(rp, x);
 837          BSetDrMd(bi, JAM2);
 838          continue;
 839       };
 840
 841       if      (f & VIF_AOLPEN)  SetOPen(rp, x);
 842       else if (f & VIF_ENDOPEN) BNDRYOFF(rp);
 843
 844       if      (f & VIF_SHADOWPEN) BSetDPenA(bi, SHADOWPEN);
 845       else if (f & VIF_SHINEPEN)  BSetDPenA(bi, SHINEPEN);
 846       else if (f & VIF_FILLPEN)   BSetDPenA(bi, FILLPEN);
 847       else if (f & VIF_TEXTPEN)   BSetDPenA(bi, TEXTPEN);
 848
 849       /*
 850        * Do we need to setup an areafill?
 851        */
 852       if (f & VIF_AREASTART) SetupArea(rp, vd, vi, w, h);
 853
 854       /*
 855        * Calculate the X and Y coordinates.
 856        */
 857       if (vd->vd_SizeX) x = (x * w) / vd->vd_SizeX;
 858       if (vd->vd_SizeY) y = (y * h) / vd->vd_SizeY;
 859
 860       /*
 861        * Calculate X from the correct edge.
 862        */
 863       if (f & VIF_XRELRIGHT)  x = r - x;
 864       else x += l;
 865
 866       /*
 867        * Calculate Y from the correct edge.
 868        */
 869       if (f & VIF_YRELBOTTOM) y = b - y;
 870       else y += t;
 871
 872       /*
 873        * Check that the coordinates do
 874        * not go outside the bounding box.
 875        */
 876       if      (x < l) x = l;
 877       else if (x > r) x = r;
 878
 879       if      (y < t) y = t;
 880       else if (y > b) y = b;
 881
 882       /*
 883        * (Area)Move or (Area)Draw to the
 884        * coordinates.
 885        */
 886       if (f & VIF_MOVE)
 887       {
 888          if (vd->vd_Flags & VDATF_AREA) AreaMove(rp, x, y);
 889          else                           Move(rp, x, y);
 890       }
 891       else if (f & VIF_DRAW)
 892       {
 893          if (vd->vd_Flags & VDATF_AREA) AreaDraw(rp, x, y);
 894          else                           Draw(rp, x, y);
 895       }
 896
 897       /*
 898        * Are we done area filling?
 899        */
 900       if (f & (VIF_AREAEND|VIF_LASTITEM))
 901       {
 902          if (vd->vd_Flags & VDATF_AREA)
 903          {
 904             AreaEnd(rp);
 905             CleanUpArea(rp, vd);
 906          }
 907       }
 908    }
 909    /*
 910     * In case a color change or something unexpected gave us a VIF_AREAEND.
 911     */
 912    CleanUpArea(rp, vd);
 913
 914    return rc;
 915 }
 916 METHOD_END
 917 ///
 918
 919 /// Class initialization.
 920 /*
 921  * Class function array.
 922  */
 923 STATIC DPFUNC ClassFunc[] = {
 924    BASE_RENDER,            (FUNCPTR)VectorClassRender,
 925    OM_NEW,                 (FUNCPTR)VectorClassNew,
 926    OM_SET,                 (FUNCPTR)VectorClassSet,
 927    OM_GET,                 (FUNCPTR)VectorClassGet,
 928    DF_END,                 NULL
 929 };
 930
 931 /*
 932  * Simple class initialization.
 933  */
 934 makeproto Class *InitVectorClass(void)
 935 {
 936    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_IMAGE_OBJECT,
 937                          CLASS_ObjectSize,     sizeof(VD),
 938                          CLASS_DFTable,        ClassFunc,
 939                          TAG_DONE);
 940 }
 941 ///
 942