scalos/libraries/scalosgfx/scalosgfx.c

   1 // scalosgfx.c
   2 // $Date$
   3 // $Revision$
   4
   5
   6 #include <exec/types.h>
   7 #include <exec/memory.h>
   8 #include <exec/semaphores.h>
   9 #include <exec/libraries.h>
  10 #include <exec/execbase.h>
  11 #include <exec/lists.h>
  12 #include <exec/resident.h>
  13 #include <dos/dos.h>
  14 #include <dos/dostags.h>
  15 #include <graphics/gfxbase.h>
  16 #include <scalos/scalos.h>
  17 #include <scalos/scalosgfx.h>
  18
  19 #include <clib/alib_protos.h>
  20
  21 #include <proto/dos.h>
  22 #include <proto/exec.h>
  23 #include <proto/intuition.h>
  24 #include <proto/utility.h>
  25 #include <proto/scalosgfx.h>
  26
  27 #include <string.h>
  28
  29 #include "scalosgfx_base.h"
  30 #include "scalosgfx.h"
  31 #include <defs.h>
  32 #include <Year.h>
  33
  34 //----------------------------------------------------------------------------
  35
  36 #define IS_NOT_EVEN(len)                ((len) & 1)
  37 #define EVEN(len)                       (((len) + 1) & ~1)
  38 #define MAGIC_PREFS_LIST_ENTRY_LIST     ((UWORD) -1)
  39
  40 #define min(a,b)                        ((a) < (b) ? (a) : (b))
  41
  42 #ifdef __amigaos4__
  43 #define ExtLib(base) ((struct ExtendedLibrary *)((ULONG)base + ((struct Library *)base)->lib_PosSize))
  44 #define IScalosGfx ((struct ScaosGfxIFace *)ExtLib(ScalosGfxBase)->MainIFace)
  45 #endif
  46
  47 //----------------------------------------------------------------------------
  48
  49
  50 //----------------------------------------------------------------------------
  51
  52 // Standard library functions
  53
  54 //----------------------------------------------------------------------------
  55
  56 #if !defined(__AROS__)
  57 struct ExecBase *SysBase;
  58 #endif
  59 struct IntuitionBase *IntuitionBase;
  60 T_UTILITYBASE UtilityBase;
  61 struct DosLibrary * DOSBase;
  62 struct Library *CyberGfxBase;
  63 struct GfxBase *GfxBase;
  64 struct Library *LayersBase;
  65 #ifdef __amigaos4__
  66 struct Library *NewlibBase;
  67 struct Interface *INewlib;
  68 struct GraphicsIFace *IGraphics;
  69 struct ExecIFace *IExec;
  70 struct IntuitionIFace *IIntuition;
  71 struct UtilityIFace *IUtility;
  72 struct DOSIFace *IDOS;
  73 struct CyberGfxIFace *ICyberGfx;
  74 struct LayersIFace *ILayers;
  75 #endif
  76
  77 //----------------------------------------------------------------------------
  78
  79 char ALIGNED libName[] = "scalosgfx.library";
  80 char ALIGNED libIdString[] = "$VER: scalosgfx.library "
  81         STR(LIB_VERSION) "." STR(LIB_REVISION)
  82         " (29 Jul 2008 19:29:17) "
  83         COMPILER_STRING
  84         " ©2006" CURRENTYEAR " The Scalos Team";
  85
  86 //----------------------------------------------------------------------------
  87
  88
  89 BOOL ScalosGfxInit(struct ScalosGfxBase *ScalosGfxBase)
  90 {
  91         d1(kprintf("%s/%ld:   START ScalosGfxBase=%08lx  procName=<%s>\n", __FUNC__, __LINE__, \
  92                 ScalosGfxBase, FindTask(NULL)->tc_Node.ln_Name));
  93
  94         NewList(&ScalosGfxBase->sgb_PrefsList);
  95
  96         InitSemaphore(&ScalosGfxBase->sgb_MemPoolSemaphore);
  97         InitSemaphore(&ScalosGfxBase->sgb_PrefsListSem);
  98
  99         d1(kprintf("%s/%ld: END Success\n", __FUNC__, __LINE__));
 100
 101         return TRUE;    // Success
 102 }
 103
 104 //-----------------------------------------------------------------------------
 105
 106 BOOL ScalosGfxOpen(struct ScalosGfxBase *ScalosGfxBase)
 107 {
 108         BOOL Success = FALSE;
 109
 110         d1(kprintf("%s/%ld:   START ScalosGfxBase=%08lx  procName=<%s>\n", __FUNC__, __LINE__, \
 111                 ScalosGfxBase, FindTask(NULL)->tc_Node.ln_Name));
 112
 113         do      {
 114                 IntuitionBase = (APTR) OpenLibrary( "intuition.library", 39 );
 115 #ifdef __amigaos4__
 116                 if (IntuitionBase)
 117                         {
 118                         IIntuition = (APTR) GetInterface((struct Library *)IntuitionBase, "main", 1, NULL);
 119                         if (!IIntuition)
 120                                 {
 121                                 CloseLibrary((struct Library *)IntuitionBase);
 122                                 IntuitionBase = NULL;
 123                                 }
 124                         }
 125 #endif
 126                 if (NULL == IntuitionBase)
 127                         break;
 128
 129                 UtilityBase = (APTR) OpenLibrary( "utility.library", 39 );
 130 #ifdef __amigaos4__
 131                 if (UtilityBase)
 132                         {
 133                         IUtility = (APTR) GetInterface((struct Library *)UtilityBase, "main", 1, NULL);
 134                         if (!IUtility)
 135                                 {
 136                                 CloseLibrary((struct Library *)UtilityBase);
 137                                 UtilityBase = NULL;
 138                                 }
 139                         }
 140 #endif
 141                 if (NULL == UtilityBase)
 142                         break;
 143
 144                 GfxBase = (struct GfxBase *) OpenLibrary(GRAPHICSNAME, 39);
 145 #ifdef __amigaos4__
 146                 if (GfxBase != NULL)
 147                         {
 148                         IGraphics = (struct GraphicsIFace *)GetInterface((struct Library *)GfxBase, "main", 1, NULL);
 149                         if (IGraphics == NULL)
 150                                 {
 151                                 CloseLibrary((struct Library *)GfxBase);
 152                                 GfxBase = NULL;
 153                                 }
 154                         }
 155 #endif
 156                 d1(kprintf("%s/%ld: GfxBase=%08lx\n", __FUNC__, __LINE__, GfxBase));
 157                 if (NULL == GfxBase)
 158                         return 0;
 159
 160                 CyberGfxBase = (APTR) OpenLibrary( "cybergraphics.library", 40);
 161 #ifdef __amigaos4__
 162                 if (CyberGfxBase)
 163                         {
 164                         ICyberGfx = (APTR) GetInterface((struct Library *)CyberGfxBase, "main", 1, NULL);
 165                         if (!ICyberGfx)
 166                                 {
 167                                 CloseLibrary(CyberGfxBase);
 168                                 CyberGfxBase = NULL;
 169                                 }
 170                         }
 171 #endif
 172                 // CyberGfxBase may be NULL
 173
 174                 DOSBase = (APTR) OpenLibrary( "dos.library", 39 );
 175 #ifdef __amigaos4__
 176                 if (DOSBase)
 177                         {
 178                         IDOS = (APTR) GetInterface((struct Library *)DOSBase, "main", 1, NULL);
 179                         if (!IDOS)
 180                                 {
 181                                 CloseLibrary((struct Library *)DOSBase);
 182                                 DOSBase = NULL;
 183                                 }
 184                         }
 185 #endif
 186                 if (NULL == DOSBase)
 187                         break;
 188
 189                 LayersBase = OpenLibrary( "layers.library", 39 );
 190 #ifdef __amigaos4__
 191                 if (LayersBase)
 192                         {
 193                         ILayers = (APTR) GetInterface(LayersBase, "main", 1, NULL);
 194                         if (!ILayers)
 195                                 {
 196                                 CloseLibrary(LayersBase);
 197                                 LayersBase = NULL;
 198                                 }
 199                         }
 200 #endif
 201                 if (NULL == LayersBase)
 202                         break;
 203
 204 #ifdef __amigaos4__
 205                 NewlibBase = OpenLibrary("newlib.library", 0);
 206                 if (NULL == NewlibBase)
 207                         break;
 208                 INewlib = GetInterface(NewlibBase, "main", 1, NULL);
 209                 if (NULL == INewlib)
 210                         break;
 211 #endif
 212
 213                 ScalosGfxBase->sgb_MemPool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR, 8192, 256);
 214                 if (NULL == ScalosGfxBase->sgb_MemPool)
 215                         break;
 216
 217                 Success = TRUE;
 218                 } while (0);
 219
 220         d1(kprintf("%s/%ld: END Success=%ld\n", __FUNC__, __LINE__, Success));
 221
 222         return Success;
 223 }
 224
 225 //-----------------------------------------------------------------------------
 226
 227 void ScalosGfxCleanup(struct ScalosGfxBase *ScalosGfxBase)
 228 {
 229         d1(kprintf("%s/%ld:\n", __FUNC__, __LINE__));
 230
 231         if (CyberGfxBase)
 232                 {
 233 #ifdef __amigaos4__
 234                 DropInterface((struct Interface *)ICyberGfx);
 235 #endif
 236                 CloseLibrary(CyberGfxBase);
 237                 CyberGfxBase = NULL;
 238                 }
 239         if (NULL != GfxBase)
 240                 {
 241 #ifdef __amigaos4__
 242                 DropInterface((struct Interface *)IGraphics);
 243 #endif
 244                 CloseLibrary((struct Library *) GfxBase);
 245                 GfxBase = NULL;
 246                 }
 247         if (UtilityBase)
 248                 {
 249 #ifdef __amigaos4__
 250                 DropInterface((struct Interface *)IUtility);
 251 #endif
 252                 CloseLibrary((struct Library *) UtilityBase);
 253                 UtilityBase = NULL;
 254                 }
 255         if (IntuitionBase)
 256                 {
 257 #ifdef __amigaos4__
 258                 DropInterface((struct Interface *)IIntuition);
 259 #endif
 260                 CloseLibrary((struct Library *) IntuitionBase);
 261                 IntuitionBase = NULL;
 262                 }
 263         if (DOSBase)
 264                 {
 265 #ifdef __amigaos4__
 266                 DropInterface((struct Interface *)IDOS);
 267 #endif
 268                 CloseLibrary((struct Library *) DOSBase);
 269                 DOSBase = NULL;
 270                 }
 271         if (LayersBase)
 272                 {
 273 #ifdef __amigaos4__
 274                 DropInterface((struct Interface *)ILayers);
 275 #endif
 276                 CloseLibrary(LayersBase);
 277                 LayersBase = NULL;
 278                 }
 279 #ifdef __amigaos4__
 280         if (INewlib)
 281                 {
 282                 DropInterface(INewlib);
 283                 INewlib = NULL;
 284                 }
 285         if (NewlibBase)
 286                 {
 287                 CloseLibrary(NewlibBase);
 288                 NewlibBase = NULL;
 289                 }
 290 #endif
 291         if (ScalosGfxBase->sgb_MemPool)
 292                 {
 293                 DeletePool(ScalosGfxBase->sgb_MemPool);
 294                 ScalosGfxBase->sgb_MemPool = NULL;
 295                 }
 296         d1(kprintf("%s/%ld:\n", __FUNC__, __LINE__));
 297 }
 298
 299 //-----------------------------------------------------------------------------
 300
 301 LIBFUNC_P1(struct ScalosBitMapAndColor *, LIBScalosGfxCreateEmptySAC,
 302         A6, struct ScalosGfxBase *, ScalosGfxBase)
 303 {
 304         return AllocEmptySAC(ScalosGfxBase);
 305 }
 306 LIBFUNC_END
 307
 308 //-----------------------------------------------------------------------------
 309
 310 LIBFUNC_P6(struct ScalosBitMapAndColor *, LIBScalosGfxCreateSAC,
 311         D0, ULONG, width,
 312         D1, ULONG, height,
 313         D2, ULONG, depth,
 314         A0, struct BitMap *, friendBM,
 315         A1, struct TagItem *, tagList,
 316         A6, struct ScalosGfxBase *, ScalosGfxBase)
 317 {
 318         (void) tagList;
 319
 320         return AllocSAC(width, height, depth, friendBM, tagList, ScalosGfxBase);
 321 }
 322 LIBFUNC_END
 323
 324 //-----------------------------------------------------------------------------
 325
 326 LIBFUNC_P2(VOID, LIBScalosGfxFreeSAC,
 327         A0, struct ScalosBitMapAndColor *, sac,
 328         A6, struct ScalosGfxBase *, ScalosGfxBase)
 329 {
 330         FreeSAC(sac, ScalosGfxBase);
 331 }
 332 LIBFUNC_END
 333
 334 //-----------------------------------------------------------------------------
 335
 336 LIBFUNC_P4(struct gfxARGB *, LIBScalosGfxCreateARGB,
 337         D0, ULONG, width,
 338         D1, ULONG, height,
 339         A0, struct TagItem *, tagList,
 340         A6, struct ScalosGfxBase *, ScalosGfxBase)
 341 {
 342         (void) tagList;
 343
 344         return AllocARGB(width, height, ScalosGfxBase);
 345 }
 346 LIBFUNC_END
 347
 348 //-----------------------------------------------------------------------------
 349
 350 LIBFUNC_P2(VOID, LIBScalosGfxFreeARGB,
 351         A0, struct gfxARGB **, argb,
 352         A6, struct ScalosGfxBase *, ScalosGfxBase)
 353 {
 354         FreeARGB(argb, ScalosGfxBase);
 355 }
 356 LIBFUNC_END
 357
 358 //-----------------------------------------------------------------------------
 359
 360 LIBFUNC_P3(VOID, LIBScalosGfxARGBSetAlpha,
 361         A0, struct ARGBHeader *, argbh,
 362         D0, UBYTE, alpha,
 363         A6, struct ScalosGfxBase *, ScalosGfxBase)
 364 {
 365         (void) ScalosGfxBase;
 366
 367         ARGBSetAlpha(argbh->argb_ImageData,
 368                 argbh->argb_Width, argbh->argb_Height, alpha);
 369 }
 370 LIBFUNC_END
 371
 372 //-----------------------------------------------------------------------------
 373
 374 LIBFUNC_P3(VOID, LIBScalosGfxARGBSetAlphaMask,
 375         A0, struct ARGBHeader *, argbh,
 376         A1, PLANEPTR, maskPlane,
 377         A6, struct ScalosGfxBase *, ScalosGfxBase)
 378 {
 379         (void) ScalosGfxBase;
 380
 381         ARGBSetAlphaFromMask(argbh, maskPlane);
 382 }
 383 LIBFUNC_END
 384
 385 //-----------------------------------------------------------------------------
 386
 387 LIBFUNC_P7(struct gfxARGB *, LIBScalosGfxCreateARGBFromBitMap,
 388         A0, struct BitMap *,bm,
 389         D0, ULONG, width,
 390         D1, ULONG, height,
 391         D2, ULONG, numberOfColors,
 392         A1, const ULONG *, colorTable,
 393         A2, PLANEPTR, maskPlane,
 394         A6, struct ScalosGfxBase *, ScalosGfxBase)
 395 {
 396         return CreateARGBFromBitMap(bm, width, height,
 397                 numberOfColors, colorTable, maskPlane, ScalosGfxBase);
 398 }
 399 LIBFUNC_END
 400
 401 //-----------------------------------------------------------------------------
 402
 403 LIBFUNC_P4(VOID, LIBScalosGfxFillARGBFromBitMap,
 404         A0, struct ARGBHeader *, argbh,
 405         A1, struct BitMap *, srcBM,
 406         A2, PLANEPTR, maskPlane,
 407         A6, struct ScalosGfxBase *, ScalosGfxBase)
 408 {
 409         (void) ScalosGfxBase;
 410
 411         FillARGBFromBitMap(argbh, srcBM, maskPlane);
 412 }
 413 LIBFUNC_END
 414
 415 //-----------------------------------------------------------------------------
 416
 417 LIBFUNC_P5(VOID, LIBScalosGfxWriteARGBToBitMap,
 418         A0, struct ARGBHeader *, argbh,
 419         A1, struct BitMap *, bm,
 420         D0, ULONG, numberOfColors,
 421         A2, const ULONG *, colorTable,
 422         A6, struct ScalosGfxBase *, ScalosGfxBase)
 423 {
 424         (void) ScalosGfxBase;
 425
 426         WriteARGBToBitMap(argbh->argb_ImageData, bm,
 427                 argbh->argb_Width, argbh->argb_Height,
 428                 numberOfColors, colorTable, ScalosGfxBase);
 429 }
 430 LIBFUNC_END
 431
 432 //-----------------------------------------------------------------------------
 433
 434 LIBFUNC_P4(struct ScalosBitMapAndColor *, LIBScalosGfxMedianCut,
 435         A0, struct ARGBHeader *, argbh,
 436         D0, ULONG, depth,
 437         A1, struct TagItem *, tagList,
 438         A6, struct ScalosGfxBase *, ScalosGfxBase)
 439 {
 440         ULONG flags;
 441         BOOL floyd;
 442         struct BitMap *friendBM;
 443         ULONG ReservedColors;
 444         ULONG NewColors;
 445         struct ScalosBitMapAndColor *sac = NULL;
 446
 447         d1(KPrintF(__FILE__ "/%s/%ld:  START  tagList=%08lx\n", __FUNC__, __LINE__, tagList));
 448
 449         flags = GetTagData(SCALOSGFX_MedianCutFlags, 0, tagList);
 450         floyd = flags & SCALOSGFXFLAGF_MedianCut_FloydSteinberg;
 451         ReservedColors = GetTagData(SCALOSGFX_MedianCutReservedColors, 0, tagList);
 452         friendBM = (struct BitMap *) GetTagData(SCALOSGFX_MedianCutFriendBitMap, (ULONG)NULL, tagList);
 453
 454         d1(KPrintF(__FILE__ "/%s/%ld:  flags=%08lx  ReservedColors=%lu\n", __FUNC__, __LINE__, flags, ReservedColors));
 455
 456         NewColors = 1 << depth;
 457
 458         do      {
 459                 NewColors += ReservedColors;
 460                 if (NewColors > 256)
 461                         break;
 462
 463                 // adjst depth for reserved colors
 464                 while (NewColors > (1 << depth))
 465                         depth++;
 466
 467                 d1(KPrintF("%s/%ld:  NewColors=%lu  depth=%lu  ReservedColors=%lu\n", \
 468                         __FUNC__, __LINE__, NewColors, depth, ReservedColors));
 469
 470                 sac = MedianCut(argbh, depth, NewColors, floyd, friendBM, ScalosGfxBase);
 471                 } while (0);
 472
 473         return sac;
 474 }
 475 LIBFUNC_END
 476
 477 //-----------------------------------------------------------------------------
 478
 479 LIBFUNC_P5(struct gfxARGB *, LIBScalosGfxScaleARGBArray,
 480         A0, const struct ARGBHeader *, src,
 481         A1, ULONG *, destWidth,
 482         A2, ULONG *, destHeight,
 483         A3, struct TagItem *, tagList,
 484         A6, struct ScalosGfxBase *, ScalosGfxBase)
 485 {
 486         ULONG flags;
 487
 488         flags = GetTagData(SCALOSGFX_ScaleARGBArrayFlags, 0, tagList);
 489
 490         return ScaleARGBArray(src, destWidth, destHeight, flags, ScalosGfxBase);
 491 }
 492 LIBFUNC_END
 493
 494 //-----------------------------------------------------------------------------
 495
 496 LIBFUNC_P3(struct BitMap *, LIBScalosGfxScaleBitMap,
 497         A0, struct ScaleBitMapArg *, sbma,
 498         A1, struct TagItem *, tagList,
 499         A6, struct ScalosGfxBase *, ScalosGfxBase)
 500 {
 501         (void) tagList;
 502
 503         return ScaleBitMap(sbma->sbma_SourceBM,
 504                 sbma->sbma_SourceWidth,
 505                 sbma->sbma_SourceHeight,
 506                 sbma->sbma_DestWidth,
 507                 sbma->sbma_DestHeight,
 508                 sbma->sbma_NumberOfColors,
 509                 sbma->sbma_ColorTable,
 510                 sbma->sbma_Flags,
 511                 sbma->sbma_ScreenBM,
 512                 ScalosGfxBase);
 513 }
 514 LIBFUNC_END
 515
 516 //-----------------------------------------------------------------------------
 517
 518 LIBFUNC_P5(VOID, LIBScalosGfxCalculateScaleAspect,
 519         D0, ULONG, sourceWidth,
 520         D1, ULONG, sourceHeight,
 521         A0, ULONG *, destWidth,
 522         A1, ULONG *, destHeight,
 523         A6, struct ScalosGfxBase *, ScalosGfxBase)
 524 {
 525         (void) ScalosGfxBase;
 526
 527         CalculateScaleAspect(sourceWidth, sourceHeight, destWidth, destHeight);
 528 }
 529 LIBFUNC_END
 530
 531 //-----------------------------------------------------------------------------
 532
 533 LIBFUNC_P9(VOID, LIBScalosGfxBlitARGB,
 534         A0, struct ARGBHeader *, DestARGB,
 535         A1, const struct ARGBHeader *, SrcARGB,
 536         D0, LONG, DestLeft,
 537         D1, LONG, DestTop,
 538         D2, LONG, SrcLeft,
 539         D3, LONG, SrcTop,
 540         D4, LONG, Width,
 541         D5, LONG, Height,
 542         A6, struct ScalosGfxBase *, ScalosGfxBase)
 543 {
 544         (void) ScalosGfxBase;
 545
 546         BlitARGB(DestARGB, SrcARGB, DestLeft, DestTop,
 547                 SrcLeft, SrcTop, Width, Height);
 548 }
 549 LIBFUNC_END
 550
 551 //-----------------------------------------------------------------------------
 552
 553 // Fill a rectangle with a given ARGB color.
 554
 555 LIBFUNC_P7(VOID, LIBScalosGfxFillRectARGB,
 556         A0, struct ARGBHeader *, DestARGB,
 557         A1, const struct gfxARGB *, fillARGB,
 558         D0, LONG, left,
 559         D1, LONG, top,
 560         D2, LONG, width,
 561         D3, LONG, height,
 562         A6, struct ScalosGfxBase *, ScalosGfxBase)
 563 {
 564         (void) ScalosGfxBase;
 565
 566         FillARGB(DestARGB, fillARGB, left, top, width, height);
 567 }
 568 LIBFUNC_END
 569
 570 //-----------------------------------------------------------------------------
 571
 572 // Fill entire ARGB with given ARGB color
 573
 574 LIBFUNC_P3(VOID, LIBScalosGfxSetARGB,
 575         A0, struct ARGBHeader *, DestARGB,
 576         A1, const struct gfxARGB *, fillARGB,
 577         A6, struct ScalosGfxBase *, ScalosGfxBase)
 578 {
 579         (void) ScalosGfxBase;
 580
 581         SetARGB(DestARGB, fillARGB);
 582 }
 583 LIBFUNC_END
 584
 585 //-----------------------------------------------------------------------------
 586
 587 // replace ColorMap in sac by given new one
 588
 589 LIBFUNC_P4(BOOL, LIBScalosGfxNewColorMap,
 590         A0, struct ScalosBitMapAndColor *, sac,
 591         A1, const ULONG *, colorMap,
 592         D0, ULONG, colorEntries,
 593         A6, struct ScalosGfxBase *, ScalosGfxBase)
 594 {
 595         (void) ScalosGfxBase;
 596
 597         return SetNewSacColorMap(sac, colorMap, colorEntries, ScalosGfxBase);
 598 }
 599 LIBFUNC_END
 600
 601 //-----------------------------------------------------------------------------
 602
 603 LIBFUNC_P8(VOID, LIBScalosGfxARGBRectMult,
 604         A0, struct RastPort *, rp,
 605         A1, const struct ARGB *, numerator,
 606         A2, const struct ARGB *, denominator,
 607         D0, WORD, xMin,
 608         D1, WORD, yMin,
 609         D2, WORD, xMax,
 610         D3, WORD, yMax,
 611         A6, struct ScalosGfxBase *, ScalosGfxBase)
 612 {
 613         ARGBRectMult(rp, *numerator, *denominator,
 614                 xMin, yMin,
 615                 xMax, yMax,
 616                 ScalosGfxBase);
 617 }
 618 LIBFUNC_END
 619
 620 //-----------------------------------------------------------------------------
 621
 622 LIBFUNC_P9(VOID, LIBScalosGfxBlitARGBAlpha,
 623         A0, struct RastPort *, rp,
 624         A1, const struct ARGBHeader *, srcH,
 625         D0, ULONG, destLeft,
 626         D1, ULONG, destTop,
 627         D2, ULONG, srcLeft,
 628         D3, ULONG, srcTop,
 629         D4, ULONG, width,
 630         D5, ULONG, height,
 631         A6, struct ScalosGfxBase *, ScalosGfxBase)
 632 {
 633         BlitARGBAlpha(rp, srcH,
 634                 destLeft, destTop,
 635                 srcLeft, srcTop,
 636                 width, height,
 637                 ScalosGfxBase);
 638 }
 639 LIBFUNC_END
 640
 641 //-----------------------------------------------------------------------------
 642
 643 LIBFUNC_P7(VOID, LIBScalosGfxBlitARGBAlphaTagList,
 644         A0, struct RastPort *, rp,
 645         A1, const struct ARGBHeader *, srcH,
 646         D0, ULONG, destLeft,
 647         D1, ULONG, destTop,
 648         A3, const struct IBox *, srcSize,
 649         A2, struct TagItem *, tagList,
 650         A6, struct ScalosGfxBase *, ScalosGfxBase)
 651 {
 652         const struct ARGB KDefault = { 255, 0, 0, 0 };
 653         const struct ARGB *K;
 654         ULONG Trans;
 655         ULONG NoAlpha;
 656
 657         K = (const struct ARGB *) GetTagData(SCALOSGFX_BlitARGBHilight, (ULONG) NULL, tagList);
 658         Trans = GetTagData(SCALOSGFX_BlitARGBTransparency, 255, tagList);
 659         NoAlpha = GetTagData(SCALOSGFX_BlitARGBNoAlpha, FALSE, tagList);
 660
 661         if (NoAlpha)
 662                 {
 663                 if (NULL == K)
 664                         K = &KDefault;
 665
 666                 d1(KPrintF("%s/%ld:  Red=%ld  Green=%ld  Blue=%ld  Trans=%lu\n", __FUNC__, __LINE__, K->Red, K->Green, K->Blue, Trans));
 667
 668                 BlitARGBKT(rp, srcH,
 669                         destLeft, destTop,
 670                         srcSize->Left, srcSize->Top,
 671                         srcSize->Width, srcSize->Height,
 672                         K, Trans,
 673                         ScalosGfxBase);
 674                 }
 675         else if (K || 255 != Trans)
 676                 {
 677                 d1(KPrintF("%s/%ld:  Red=%ld  Green=%ld  Blue=%ld  Trans=%lu\n", __FUNC__, __LINE__, K->Red, K->Green, K->Blue, Trans));
 678                 BlitARGBAlphaKT(rp, srcH,
 679                         destLeft, destTop,
 680                         srcSize->Left, srcSize->Top,
 681                         srcSize->Width, srcSize->Height,
 682                         K, Trans,
 683                         ScalosGfxBase);
 684                 }
 685         else
 686                 {
 687                 BlitARGBAlpha(rp, srcH,
 688                         destLeft, destTop,
 689                         srcSize->Left, srcSize->Top,
 690                         srcSize->Width, srcSize->Height,
 691                         ScalosGfxBase);
 692                 }
 693 }
 694 LIBFUNC_END
 695
 696 //-----------------------------------------------------------------------------
 697
 698 LIBFUNC_P8(VOID, LIBScalosGfxBlitIcon,
 699         A0, struct RastPort *, rpBackground,
 700         A1, struct RastPort *, rpIcon,
 701         D0, ULONG, left,
 702         D1, ULONG, top,
 703         D2, ULONG, width,
 704         D3, ULONG, height,
 705         A2, struct TagItem *, tagList,
 706         A6, struct ScalosGfxBase *, ScalosGfxBase)
 707 {
 708         const struct ARGB *K;
 709         const UBYTE *Alpha;
 710         ULONG Trans;
 711
 712         K = (const struct ARGB *) GetTagData(SCALOSGFX_BlitIconHilight, (ULONG) NULL, tagList);
 713         Alpha = (const UBYTE *) GetTagData(SCALOSGFX_BlitIconAlpha, (ULONG) NULL, tagList);
 714         Trans = GetTagData(SCALOSGFX_BlitIconTransparency, 255, tagList);
 715
 716         if (Alpha)
 717                 {
 718                 if (K)
 719                         {
 720                         BlitTransparentAlphaK(rpBackground, rpIcon,
 721                                 left, top, width, height,
 722                                 K, Alpha, ScalosGfxBase);
 723                         }
 724                 else
 725                         {
 726                         BlitTransparentAlpha(rpBackground, rpIcon,
 727                                 left, top, width, height,
 728                                 Trans, Alpha, ScalosGfxBase);
 729                         }
 730                 }
 731         else
 732                 {
 733                 if (K)
 734                         {
 735                         BlitTransparentK(rpBackground, rpIcon,
 736                                 left, top, width, height,
 737                                 K, ScalosGfxBase);
 738                         }
 739                 else
 740                         {
 741                         BlitTransparent(rpBackground, rpIcon,
 742                                 left, top, width, height,
 743                                 Trans, ScalosGfxBase);
 744                         }
 745                 }
 746 }
 747 LIBFUNC_END
 748
 749 //-----------------------------------------------------------------------------
 750
 751 LIBFUNC_P9(BOOL, LIBScalosGfxDrawGradient,
 752         A0, struct ARGBHeader *, dest,
 753         D0, LONG, left,
 754         D1, LONG, top,
 755         D2, LONG, width,
 756         D3, LONG, height,
 757         A1, struct gfxARGB *, start,
 758         A2, struct gfxARGB *, stop,
 759         D4, ULONG, gradType,
 760         A6, struct ScalosGfxBase *, ScalosGfxBase)
 761 {
 762         return ScaDrawGradient(dest, left, top, width, height, start, stop,  gradType, ScalosGfxBase);
 763 }
 764 LIBFUNC_END
 765
 766 //-----------------------------------------------------------------------------
 767
 768 LIBFUNC_P9(BOOL, LIBScalosGfxDrawGradientRastPort,
 769         A0, struct RastPort *, rp,
 770         D0, LONG, left,
 771         D1, LONG, top,
 772         D2, LONG, width,
 773         D3, LONG, height,
 774         A1, struct gfxARGB *, start,
 775         A2, struct gfxARGB *, stop,
 776         D4, ULONG, gradType,
 777         A6, struct ScalosGfxBase *, ScalosGfxBase)
 778 {
 779         return DrawGradientRastPort(rp, left, top, width, height, start, stop,  gradType, ScalosGfxBase);
 780 }
 781 LIBFUNC_END
 782
 783 //-----------------------------------------------------------------------------
 784
 785 LIBFUNC_P7(VOID, LIBScalosGfxDrawLine,
 786         A0, struct ARGBHeader *, dest,
 787         D0, LONG, fromX,
 788         D1, LONG, fromY,
 789         D2, LONG, toX,
 790         D3, LONG, toY,
 791         A1, const struct gfxARGB *, lineColor,
 792         A6, struct ScalosGfxBase *, ScalosGfxBase)
 793 {
 794         (void) ScalosGfxBase;
 795
 796         DrawLine(dest, fromX, fromY, toX, toY, *lineColor);
 797 }
 798 LIBFUNC_END
 799
 800 //-----------------------------------------------------------------------------
 801
 802 LIBFUNC_P7(VOID, LIBScalosGfxDrawLineRastPort,
 803         A0, struct RastPort *, rp,
 804         D0, LONG, fromX,
 805         D1, LONG, fromY,
 806         D2, LONG, toX,
 807         D3, LONG, toY,
 808         A1, const struct gfxARGB *, lineColor,
 809         A6, struct ScalosGfxBase *, ScalosGfxBase)
 810 {
 811         (void) ScalosGfxBase;
 812
 813         DrawLineRastPort(rp, fromX, fromY, toX, toY, *lineColor);
 814 }
 815 LIBFUNC_END
 816
 817 //-----------------------------------------------------------------------------
 818
 819 LIBFUNC_P9(VOID, LIBScalosGfxDrawEllipse,
 820         A0, struct ARGBHeader *, dest,
 821         D0, LONG, xCenter,
 822         D1, LONG, yCenter,
 823         D2, LONG, radiusX,
 824         D3, LONG, radiusY,
 825         D4, WORD, segment,
 826         A1, const struct gfxARGB *, color1,
 827         A2, const struct gfxARGB *, color2,
 828         A6, struct ScalosGfxBase *, ScalosGfxBase)
 829 {
 830         (void) ScalosGfxBase;
 831
 832         DrawARGBEllipse(dest, xCenter, yCenter, radiusX, radiusY,
 833                 segment, *color1, *color2);
 834 }
 835 LIBFUNC_END
 836
 837 //-----------------------------------------------------------------------------
 838
 839 LIBFUNC_P9(VOID, LIBScalosGfxDrawEllipseRastPort,
 840         A0, struct RastPort *, rp,
 841         D0, LONG, xCenter,
 842         D1, LONG, yCenter,
 843         D2, LONG, radiusX,
 844         D3, LONG, radiusY,
 845         D4, WORD, segment,
 846         A1, const struct gfxARGB *, color1,
 847         A2, const struct gfxARGB *, color2,
 848         A6, struct ScalosGfxBase *, ScalosGfxBase)
 849 {
 850         (void) ScalosGfxBase;
 851
 852         DrawARGBEllipseRastPort(rp, xCenter, yCenter, radiusX, radiusY,
 853                 segment, *color1, *color2);
 854 }
 855 LIBFUNC_END
 856
 857 //-----------------------------------------------------------------------------
 858
 859 APTR ScalosGfxAllocVecPooled(struct ScalosGfxBase *ScalosGfxBase, ULONG Size)
 860 {
 861         APTR ptr;
 862
 863         if (ScalosGfxBase->sgb_MemPool)
 864                 {
 865                 ObtainSemaphore(&ScalosGfxBase->sgb_MemPoolSemaphore);
 866                 ptr = AllocPooled(ScalosGfxBase->sgb_MemPool, Size + sizeof(size_t));
 867                 ReleaseSemaphore(&ScalosGfxBase->sgb_MemPoolSemaphore);
 868                 if (ptr)
 869                         {
 870                         size_t *sptr = (size_t *) ptr;
 871
 872                         sptr[0] = Size;
 873
 874                         d1(kprintf("%s/%ld:  MemPool=%08lx  Size=%lu  mem=%08lx\n", __FUNC__, __LINE__, ScalosGfxBase->sgb_MemPool, Size, &sptr[1]));
 875                         return (APTR)(&sptr[1]);
 876                         }
 877                 }
 878
 879         d1(kprintf("%s/%ld:  MemPool=%08lx  Size=%lu\n", __FUNC__, __LINE__, ScalosGfxBase->sgb_MemPool, Size));
 880
 881         return NULL;
 882 }
 883
 884 //-----------------------------------------------------------------------------
 885
 886 void ScalosGfxFreeVecPooled(struct ScalosGfxBase *ScalosGfxBase, APTR mem)
 887 {
 888         d1(kprintf("%s/%ld:  MemPool=%08lx  mem=%08lx\n", __FUNC__, __LINE__, ScalosGfxBase->sgb_MemPool, mem));
 889         if (ScalosGfxBase->sgb_MemPool && mem)
 890                 {
 891                 size_t size;
 892                 size_t *sptr = (size_t *) mem;
 893
 894                 mem = &sptr[-1];
 895                 size = sptr[-1];
 896
 897                 ObtainSemaphore(&ScalosGfxBase->sgb_MemPoolSemaphore);
 898                 FreePooled(ScalosGfxBase->sgb_MemPool, mem, size + sizeof(size_t));
 899                 ReleaseSemaphore(&ScalosGfxBase->sgb_MemPoolSemaphore);
 900                 }
 901 }
 902
 903 //-----------------------------------------------------------------------------
 904
 905 #if !defined(__SASC) && !defined(__amigaos4__)
 906 void exit(int x)
 907 {
 908    (void) x;
 909    while (1)
 910           ;
 911 }
 912
 913 #endif /* !defined(__SASC) */
 914
 915 //-----------------------------------------------------------------------------
 916
 917 #if defined(__SASC)
 918 void _XCEXIT(long x)
 919 {
 920 }
 921 #endif /* defined(__SASC) */
 922
 923 //-----------------------------------------------------------------------------
 924
 925 #if defined(__AROS__)
 926
 927 #include "aros/symbolsets.h"
 928
 929 ADD2INITLIB(ScalosGfxInit, 0);
 930 ADD2EXPUNGELIB(ScalosGfxCleanup, 0);
 931 ADD2OPENLIB(ScalosGfxOpen, 0);
 932
 933 #endif
 934
 935 //-----------------------------------------------------------------------------