Gdc2.h

Go to the documentation of this file.

#ifndef __GDC2_H_
#define __GDC2_H_

// sub-system headers
#include "LgiDefs.h"                // Xp
#include "LgiClass.h"
#include "LgiOsDefs.h"              // Platform specific
// #include "LgiOsClasses.h"            // Platform specific
#include "Progress.h"               // Xp
#include "GFile.h"                  // Platform specific
#include "GMem.h"                   // Platform specific
#include "Core.h"                   // Platform specific
#include "GContainers.h"

// Alpha Blting
#ifdef WIN32
#include "wingdi.h"
#endif
#ifndef AC_SRC_OVER
#define AC_SRC_OVER                 0
#endif
#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA                1
#endif
#include "GLibrary.h"

//              Defines

#define LGI_DEFAULT_GAMMA               1.0

#ifndef LGI_PI

#define LGI_PI                      3.141592654
#endif

#define LGI_DegToRad(i)             ((i)*LGI_PI/180)

#define LGI_RadToDeg(i)             ((i)*180/LGI_PI)

#ifdef WIN32

#define GDC_USE_ASM
#endif

#define GDC_SET                     0

#define GDC_AND                     1

#define GDC_OR                      2

#define GDC_XOR                     3

#define GDC_ALPHA                   4
#define GDC_REMAP                   5
#define GDC_MAXOP                   6
#define GDC_CACHE_SIZE              4

// Channel types
#define GDCC_MONO                   0
#define GDCC_GREY                   1
#define GDCC_INDEX                  2
#define GDCC_R                      3
#define GDCC_G                      4
#define GDCC_B                      5
#define GDCC_ALPHA                  6

// Native data formats
#define GDC_8BIT                    0
#define GDC_16BIT                   1
#define GDC_24BIT                   2
#define GDC_32BIT                   3
#define GDC_MAXFMT                  4

// Colour spaces
#define GDC_8I                      0   // 8 bit paletted
#define GDC_5R6G5B                  1   // 16 bit
#define GDC_8B8G8B                  2   // 24 bit
#define GDC_8A8R8G8B                3   // 32 bit
#define GDC_MAXSPACE                4

// Update types
#define GDC_PAL_CHANGE              0x1
#define GDC_BITS_CHANGE             0x2

// Flood fill types

#define GDC_FILL_TO_DIFFERENT       0

#define GDC_FILL_TO_BORDER          1

#define GDC_FILL_NEAR               2

// Gdc options

#define GDC_REDUCE_TYPE             0

    #define REDUCE_NONE                 0

    #define REDUCE_NEAREST              1

    #define REDUCE_HALFTONE             2

    #define REDUCE_ERROR_DIFFUSION      3

    #define REDUCE_DL1                  4

#define GDC_HALFTONE_BASE_INDEX     1

#define GDC_PALETTE_TYPE            2

    #define PALTYPE_ALLOC               0

    #define PALTYPE_RGB_CUBE            1

    #define PALTYPE_HSL                 2

#define GDC_PROMOTE_ON_LOAD         3
#define GDC_MAX_OPTION              4

//  Flags
// Surface
#define GDC_OWN_MEMORY              0x0001
#define GDC_ON_SCREEN               0x0002
#define GDC_ALPHA_CHANNEL           0x0004
#define GDC_UPDATED_PALETTE         0x0008

// BaseDC
#define GDC_OWN_APPLICATOR          0x0001
#define GDC_CACHED_APPLICATOR       0x0002
#define GDC_OWN_PALETTE             0x0004
#define GDC_DRAW_ON_ALPHA           0x0008

// Region types
#define GDC_RGN_NONE                0   // No clipping
#define GDC_RGN_SIMPLE              1   // Single rectangle
#define GDC_RGN_COMPLEX             2   // Many rectangles

// Error codes
#define GDCERR_NONE                 0
#define GDCERR_ERROR                1
#define GDCERR_CANT_SET_SCAN_WIDTH  2
#define GDC_INVALIDMODE             -1

// Font display flags
#define GDCFNT_TRANSPARENT          0x0001  // not set - SOLID
#define GDCFNT_UNDERLINE            0x0002

// Palette file types
#define GDCPAL_JASC                 1
#define GDCPAL_MICROSOFT            2

// Misc
#define BMPWIDTH(bits)              ((((bits)+31)/32)*4)


//              Typedefs

typedef uint32                      COLOUR;

typedef uint8                       ALPHA;

// colour conversion defines
// RGB colour space
#define BitWidth(bits, cropbits)    ( (((bits)+(cropbits)-1)/(cropbits)) * 4 )

#ifdef WIN32
#pragma pack(push, before_pack)
#pragma pack(1)
#endif

#if defined WIN32

    #if LGI_LITTLE_ENDIAN
    #define C24R                    0
    #define C24G                    1
    #define C24B                    2
    #else
    #define C24R                    2
    #define C24G                    1
    #define C24B                    0
    #endif

    class LgiClass Pixel24
    {
    public:
        static int Size;
    
        uchar b, g, r;
        
        Pixel24 *Next() { return this + 1; }
    };

    #if LGI_LITTLE_ENDIAN
    #define C32B                    0
    #define C32G                    1
    #define C32R                    2
    #define C32A                    3
    #else
    #define C32B                    3
    #define C32G                    2
    #define C32R                    1
    #define C32A                    0
    #endif

    class LgiClass Pixel32
    {
    public:
        static int Size;

        uchar b, g, r, a;
        
        Pixel32 *Next() { return this + 1; }
    };

#elif defined LINUX

    #if LGI_LITTLE_ENDIAN
    #define C24B                    0
    #define C24G                    1
    #define C24R                    2
    #else
    #define C24B                    2
    #define C24G                    1
    #define C24R                    0
    #endif

    class LgiClass Pixel24
    {
    public:
        static int Size;

        uchar b, g, r;

        Pixel24 *Next() { return (Pixel24*) ((char*)this + Size); }
    };

    #if LGI_LITTLE_ENDIAN
    #define C32B                    0
    #define C32G                    1
    #define C32R                    2
    #define C32A                    3
    #else
    #define C32B                    3
    #define C32G                    2
    #define C32R                    1
    #define C32A                    0
    #endif

    class LgiClass Pixel32
    {
    public:
        static int Size;

        uchar b, g, r, a;

        Pixel32 *Next() { return this + 1; }
    };

#elif defined BEOS

    #if LGI_LITTLE_ENDIAN
    #define C24B                    0
    #define C24G                    1
    #define C24R                    2
    #else
    #define C24B                    2
    #define C24G                    1
    #define C24R                    0
    #endif

    class LgiClass Pixel24
    {
    public:
        static int Size;

        uchar b, g, r;

        Pixel24 *Next() { return this + 1; }
    };

    #if LGI_LITTLE_ENDIAN
    #define C32B                    0
    #define C32G                    1
    #define C32R                    2
    #define C32A                    3
    #else
    #define C32B                    3
    #define C32G                    2
    #define C32R                    1
    #define C32A                    0
    #endif

    class LgiClass Pixel32
    {
    public:
        static int Size;

        uchar b, g, r, a;

        Pixel32 *Next() { return this + 1; }
    };

#elif defined MAC

    #if LGI_LITTLE_ENDIAN
    #define C24B                    0
    #define C24G                    1
    #define C24R                    2
    #else
    #define C24B                    2
    #define C24G                    1
    #define C24R                    0
    #endif

    class LgiClass Pixel24
    {
    public:
        static int Size;

        uchar r, g, b;

        Pixel24 *Next() { return this + 1; }
    };

    #if LGI_LITTLE_ENDIAN
    #define C32B                    0
    #define C32G                    1
    #define C32R                    2
    #define C32A                    3
    #else
    #define C32B                    3
    #define C32G                    2
    #define C32R                    1
    #define C32A                    0
    #endif

    class LgiClass Pixel32
    {
    public:
        static int Size;

        uchar r, g, b, a;

        Pixel32 *Next() { return this + 1; }
    };

#endif

#define Rgb15(r, g, b)              ( ((r&0xF8)<<7) | ((g&0xF8)<<2) | ((b&0xF8)>>3))
#define Rgb32To15(c32)              ( ((c32&0xF8)>>3) | ((c32&0xF800)>>6) | ((c32&0xF80000)>>9) )
#define Rgb24To15(c24)              ( (B24(c24)>>3) | ((G24(c24)<<2)&0x3E0) | ((R24(c24)<<7)&0x7C00) )
#define Rgb16To15(c16)              ( ((c16&0xFFC0)>>1) | (c16&0x1F) )

#define R15(c15)                    ( (uchar) ((c15>>10)&0x1F) )

#define G15(c15)                    ( (uchar) ((c15>>5)&0x1F) )

#define B15(c15)                    ( (uchar) ((c15)&0x1F) )

#define Rc15(c)                     ( (((c) & 0x7C00) >> 7) | (((c) & 0x7C00) >> 12) )
#define Gc15(c)                     ( (((c) & 0x03E0) >> 2) | (((c) & 0x03E0) >> 7) )
#define Bc15(c)                     ( (((c) & 0x001F) << 3) | (((c) & 0x001F) >> 2) )

#define Rgb16(r, g, b)              ( ((r&0xF8)<<8) | ((g&0xFC)<<3) | ((b&0xF8)>>3))
#define Rgb32To16(c32)              ( ((c32&0xF8)>>3) | ((c32&0xFC00)>>5) | ((c32&0xF80000)>>8) )
#define Rgb24To16(c24)              ( (B24(c24)>>3) | ((G24(c24)<<3)&0x7E0) | ((R24(c24)<<8)&0xF800) )
#define Rgb15To16(c15)              ( ((c15&0x7FE0)<<1) | (c15&0x1F) )

#define R16(c16)                    ( (uchar) ((c16>>11)&0x1F) )

#define G16(c16)                    ( (uchar) ((c16>>5)&0x3F) )

#define B16(c16)                    ( (uchar) ((c16)&0x1F) )

#define Rc16(c)                     ( (((c) & 0xF800) >> 8) | (((c) & 0xF800) >> 13) )
#define Gc16(c)                     ( (((c) & 0x07E0) >> 3) | (((c) & 0x07E0) >> 9) )
#define Bc16(c)                     ( (((c) & 0x001F) << 3) | (((c) & 0x001F) >> 2) )

#define R24(c24)                    ( ((c24)>>(C24R*8)) & 0xff )

#define G24(c24)                    ( ((c24)>>(C24G*8)) & 0xff  )

#define B24(c24)                    ( ((c24)>>(C24B*8)) & 0xff  )

#define Rgb24(r, g, b)              ( (((r)&0xFF) << (C24R*8)) | (((g)&0xFF) << (C24G*8)) | (((b)&0xFF) << (C24B*8)) )
#define Rgb32To24(c32)              Rgb24(R32(c32), G32(c32), B32(c32))
#define Rgb15To24(c15)              ( ((c15&0x7C00)>>7) | ((c15&0x3E0)<<6) | ((c15&0x1F)<<19) )
#define Rgb16To24(c16)              ( ((c16&0xF800)>>8) | ((c16&0x7E0)<<5) | ((c16&0x1F)<<19) )

// 32
//              31              24 23              16 15              8  7               0
//              |-|-|-|-|-|-|-|-|  |-|-|-|-|-|-|-|-|  |-|-|-|-|-|-|-|-|  |-|-|-|-|-|-|-|-|
// Windows      |---- alpha ----|  |----- red -----|  |---- green ----|  |----- blue ----|
// Linux        |----- blue ----|  |---- green ----|  |----- red -----|  |---- alpha ----|

#define R32(c32)                    ( (uchar) (c32 >> (C32R*8)) )

#define G32(c32)                    ( (uchar) (c32 >> (C32G*8)) )

#define B32(c32)                    ( (uchar) (c32 >> (C32B*8)) )

#define A32(c32)                    ( (uchar) (c32 >> (C32A*8)) )

#define RgbPreMul(c, a)             ( Div255Lut[(c)*a] )
#define Rgb32(r, g, b)              ( (((r)&0xFF)<<(C32R*8)) | (((g)&0xFF)<<(C32G*8)) | (((b)&0xFF)<<(C32B*8)) | (0xFF<<(C32A*8)) )
#define Rgba32(r, g, b, a)          ( (((r)&0xFF)<<(C32R*8)) | (((g)&0xFF)<<(C32G*8)) | (((b)&0xFF)<<(C32B*8)) | (((a)&0xFF)<<(C32A*8)) )
#define Rgbpa32(r, g, b, a)         ( (RgbPreMul(r, a)<<(C32R*8)) | (RgbPreMul(g, a)<<(C32G*8)) | (RgbPreMul(b, a)<<(C32B*8)) | ((a&0xFF)<<(C32A*8)) )
#define Rgb24To32(c24)              Rgba32( R24(c24), G24(c24), B24(c24), 255 )
#define Rgb15To32(c15)              ( ((c15&0x7C00)<<9) | ((c15&0x3E0)<<6) | ((c15&0x1F)<<3) | (0xFF<<(C32A*8)) )
#define Rgb16To32(c16)              ( ((c16&0xF800)<<8) | ((c16&0x7E0)<<5) | ((c16&0x1F)<<3) | (0xFF<<(C32A*8)) )

// HLS colour Space
#define Hls32(h, l, s)              ( ((h)<<16) | ((l)<<8) | (s) )
#define H32(c)                      ( ((c)>>16)&0xFFFF )
#define L32(c)                      ( ((c)>>8)&0xFF )
#define S32(c)                      ( (c)&0xFF )
#define HUE_UNDEFINED               1024
#define HlsIsUndefined(Hls)         (H32(Hls) == HUE_UNDEFINED)

// Look up tables
#define Div255Lut                   (GdcDevice::GetInst()->GetDiv255())

LgiFunc COLOUR RgbToHls(COLOUR Rgb24);
LgiFunc COLOUR HlsToRgb(COLOUR Hsl32);

#ifdef WIN32
#pragma pack(pop, before_pack)
#endif

//              Classes
class GFilter;
class GSurface;

#include "GRect.h"
#include "GFont.h"

class LgiClass GdcPt2
{
public:
    int x, y;

    GdcPt2(int Ix = 0, int Iy = 0)
    {
        x = Ix;
        y = Iy;
    }

    GdcPt2(const GdcPt2 &p)
    {
        x = p.x;
        y = p.y;
    }

    bool Inside(GRect &r)
    {
        return  (x >= r.x1) AND
                (x <= r.x2) AND
                (y >= r.y1) AND
                (y <= r.y2);
    }
};

class LgiClass GdcPt3
{
public:
    int x, y, z;
};

#ifdef WIN32
#pragma pack(push, before_pack)
#pragma pack(1)
#endif

class LgiClass GdcRGB
{
public:
    uchar R, G, B;
    #ifndef MAC
    uchar Flags;
    #endif

    void Set(uchar r, uchar g, uchar b, uchar f = 0)
    {
        R = r;
        G = g;
        B = b;
        #ifndef MAC
        Flags = f;
        #endif
    }
};

#ifdef WIN32
#pragma pack(pop, before_pack)
#endif

class LgiClass GPalette
{
protected:
    #ifdef WIN32
    HPALETTE    hPal;
    LOGPALETTE  *Data;
    #else
    int         Size;
    GdcRGB      *Data;
    #endif
    uchar *Lut;

public:
    GPalette();
    virtual ~GPalette();

    #ifdef WIN32
    HPALETTE Handle() { return hPal; }
    #endif

    GPalette(GPalette *pPal);   
    GPalette(uchar *pPal, int s = 256);
    void Set(GPalette *pPal);
    void Set(uchar *pPal, int s = 256);

    int GetSize();
    GdcRGB *operator [](int i);
    bool Update();
    bool SetSize(int s = 256);
    void SwapRAndB();
    int MatchRgb(COLOUR Rgb);
    void CreateCube();
    void CreateGreyScale();
    bool Load(GFile &F);
    bool Save(GFile &F, int Format);
    uchar *MakeLut(int Bits = 16);

    bool operator ==(GPalette &p);
    bool operator !=(GPalette &p);
};

class LgiClass GBmpMem
{
public:
    uchar *Base;
    int x, y, Bits, Line;
    int Flags;

    GBmpMem();
    ~GBmpMem();
};


#define GAPP_ALPHA_A            1
#define GAPP_ALPHA_PAL          2
#define GAPP_BACKGROUND         3
#define GAPP_ANGLE              4
#define GAPP_BOUNDS             5

class LgiClass GApplicator
{
protected:
    GBmpMem *Dest;
    GBmpMem *Alpha;
    GPalette *Pal;
    int Op;

public:
    COLOUR c;               // main colour

    GApplicator() { c = 0; }
    GApplicator(COLOUR Colour) { c = Colour; }
    virtual ~GApplicator() { }

    virtual int GetVar(int Var) { return 0; }
    virtual int SetVar(int Var, int Value) { return 0; }

    void SetOp(int o) { Op = o; }
    int GetOp() { return Op; }
    int GetBits() { return (Dest) ? Dest->Bits : 0; }
    int GetFlags() { return (Dest) ? Dest->Flags : 0; }
    GPalette *GetPal() { return Pal; }

    virtual bool SetSurface(GBmpMem *d, GPalette *p = 0, GBmpMem *a = 0) = 0; // sets Dest, returns FALSE on error
    virtual void SetPtr(int x, int y) = 0;          // calculates Ptr from x, y
    virtual void IncX() = 0;
    virtual void IncY() = 0;
    virtual void IncPtr(int X, int Y) = 0;

    virtual void Set() = 0;
    virtual COLOUR Get() = 0;
    virtual void VLine(int height) = 0;
    virtual void Rectangle(int x, int y) = 0;
    virtual bool Blt(GBmpMem *Src, GPalette *SPal, GBmpMem *SrcAlpha = 0) = 0;
};

class LgiClass GApplicatorFactory
{
public:
    static List<GApplicatorFactory> Factories;

public:
    GApplicatorFactory();
    virtual ~GApplicatorFactory();

    static GApplicator *NewApp(int Bits, int Op);
    virtual GApplicator *Create(int Bits, int Op) { return NULL; }
};

#define OrgX(x)         x -= OriginX
#define OrgY(y)         y -= OriginY
#define OrgXy(x, y)     x -= OriginX; y -= OriginY
#define OrgPt(p)        p.x -= OriginX; p.y -= OriginY
#define OrgRgn(r)       r.Offset(-OriginX, -OriginY)

class LgiClass GDeviceContext
{
    friend class GFilter;
    friend class GSurface;

protected:
    int             Flags;
    int             PrevOp;
    GRect           Clip;
    GBmpMem         *pMem;
    GSurface        *pAlphaDC;
    GPalette        *pPalette;
    GApplicator     *pApp;
    GApplicator     *pAppCache[GDC_CACHE_SIZE];
    int             OriginX, OriginY;

    // Protected functions
    GApplicator     *CreateApplicator(int Op = GDC_SET, int Bits = 0);

public:
    GDeviceContext();
    virtual ~GDeviceContext();

    virtual bool Create(int x, int y, int Bits, int LineLen = 0, bool KeepData = false) { return false; }
    virtual void Update(int Flags) {}

    // Alpha channel
    
    virtual bool IsAlpha() { return pAlphaDC != 0; }
    virtual bool IsAlpha(bool b);
    bool DrawOnAlpha() { return ((Flags & GDC_DRAW_ON_ALPHA) != 0); }
    bool DrawOnAlpha(bool Draw);
    GSurface *AlphaDC() { return pAlphaDC; }

    // Applicator
    virtual bool Applicator(GApplicator *pApp);
    virtual GApplicator *Applicator();

    // Palette
    virtual GPalette *Palette();
    virtual void Palette(GPalette *pPal, bool bOwnIt = true);

    // Clip region
    virtual GRect ClipRgn(GRect *Rgn);
    virtual GRect ClipRgn();

    virtual COLOUR Colour() { return pApp->c; }
    virtual COLOUR Colour
    (
        COLOUR c,
        int Bits = 0
    );
    virtual int Op() { return (pApp) ? pApp->GetOp() : 0; }
    virtual int Op(int Op);
    virtual int X() { return (pMem) ? pMem->x : 0; }
    virtual int Y() { return (pMem) ? pMem->y : 0; }
    virtual int DpiX() { return 100; }
    virtual int DpiY() { return 100; }
    virtual int GetBits() { return (pMem) ? pMem->Bits : 0; }
    virtual int PixelSize() { return GetBits() == 24 ? Pixel24::Size : GetBits() >> 3; }
    virtual int GetFlags() { return Flags; }
    virtual bool IsScreen() { return (pApp) ? (pApp->GetFlags() & GDC_ON_SCREEN) != 0 : 0; }
    virtual bool IsPrint() { return false; }
    virtual uchar *operator[](int y) { return (pMem AND y>=0 AND y<pMem->y) ? pMem->Base + (pMem->Line * y) : 0; }

    virtual void GetOrigin(int &x, int &y) { x = OriginX; y = OriginY; }
    virtual void SetOrigin(int x, int y) { OriginX = x; OriginY = y; }
};

class LgiClass GSurface : public GDeviceContext
{
    #if defined BEOS || defined LINUX
    friend class GView;
    friend class GWindow;
    #endif

protected:
    uint32      LineBits;
    uint32      LineMask;
    uint32      LineReset;

    #ifdef WIN32
    HDC         hDC;
    HBITMAP     hBmp;
    #endif

public:
    GSurface();
    GSurface(GSurface *pDC);

    // Win32
    #if defined WIN32

    virtual HDC StartDC() { return hDC; }
    virtual void EndDC() {}
    HBITMAP GetBitmap() { return hBmp; }
    HDC Handle() { return hDC; }
    
    #else
    
    virtual OsPainter Handle() { return 0; }
    virtual OsBitmap GetBitmap() { return 0; }
    virtual void SetClient(GRect *c) { }

    #endif
    
    #ifdef MAC
    virtual CGColorSpaceRef GetColourSpace() { return 0; }
    #endif

    // Pixel
    
    virtual void Set(int x, int y);
    virtual COLOUR Get(int x, int y);

    // Line

    virtual void HLine(int x1, int x2, int y);
    virtual void VLine(int x, int y1, int y2);
    virtual void Line(int x1, int y1, int x2, int y2);
    
    virtual uint LineStyle(uint32 Bits, uint32 Reset = 0x80000000)
    {
        uint32 B = LineBits;
        LineBits = Bits;
        LineMask = LineReset = Reset;
        return B;
    }
    virtual uint LineStyle() { return LineBits; }

    // Curve

    virtual void Circle(double cx, double cy, double radius);
    virtual void FilledCircle(double cx, double cy, double radius);
    virtual void Arc(double cx, double cy, double radius, double start, double end);
    virtual void FilledArc(double cx, double cy, double radius, double start, double end);
    virtual void Ellipse(double cx, double cy, double x, double y);
    virtual void FilledEllipse(double cx, double cy, double x, double y);

    // Rectangular

    virtual void Box(int x1, int y1, int x2, int y2);
    virtual void Box
    (
        GRect *a = NULL
    );
    virtual void Rectangle(int x1, int y1, int x2, int y2);
    virtual void Rectangle
    (
        GRect *a = NULL
    );
    virtual void Blt
    (
        int x,
        int y,
        GSurface *Src,
        GRect *a = NULL
    );
    virtual void StretchBlt(GRect *d, GSurface *Src, GRect *s);

    // Other

    virtual void Polygon(int Points, GdcPt2 *Data);
    virtual void Bezier(int Threshold, GdcPt2 *Pt);
    virtual void FloodFill
    (
        int x,
        int y,
        int Mode,
        COLOUR Border = 0,
        GRect *Bounds = NULL
    );
};

class LgiClass GScreenDC : public GSurface
{
    class GScreenPrivate *d;

public:
    GScreenDC();
    virtual ~GScreenDC();

    // OS Sepcific
    #if defined WIN32

        GScreenDC(HWND hwnd);
        GScreenDC(HDC hdc, HWND hwnd, bool Release = false);
        GScreenDC(HBITMAP hBmp, int Sx, int Sy);

        bool Create(HDC hdc);
        void SetSize(int x, int y);

    #else

        GScreenDC(OsView view, void *Param = 0);
        #ifdef MAC
        GScreenDC(OsWindow view, void *Param = 0);
        #endif

        OsPainter Handle();
        int GetFlags();
        void SetClient(GRect *c);

    #endif

    // Properties
    void GetOrigin(int &x, int &y);
    void SetOrigin(int x, int y);

    GRect ClipRgn();
    GRect ClipRgn(GRect *Rgn);

    COLOUR Colour();
    COLOUR Colour(COLOUR c, int Bits = 0);

    int Op();
    int Op(int Op);

    int X();
    int Y();

    GPalette *Palette();
    void Palette(GPalette *pPal, bool bOwnIt = true);

    uint LineStyle();
    uint LineStyle(uint Bits, uint32 Reset = 0x80000000);

    int GetBits();
    bool IsScreen();
    uchar *operator[](int y) { return NULL; }

    // Primitives
    void Set(int x, int y);
    COLOUR Get(int x, int y);
    void HLine(int x1, int x2, int y);
    void VLine(int x, int y1, int y2);
    void Line(int x1, int y1, int x2, int y2);
    void Circle(double cx, double cy, double radius);
    void FilledCircle(double cx, double cy, double radius);
    void Arc(double cx, double cy, double radius, double start, double end);
    void FilledArc(double cx, double cy, double radius, double start, double end);
    void Ellipse(double cx, double cy, double x, double y);
    void FilledEllipse(double cx, double cy, double x, double y);
    void Box(int x1, int y1, int x2, int y2);
    void Box(GRect *a);
    void Rectangle(int x1, int y1, int x2, int y2);
    void Rectangle(GRect *a = NULL);
    void Blt(int x, int y, GSurface *Src, GRect *a = NULL);
    void StretchBlt(GRect *d, GSurface *Src, GRect *s = NULL);
    void Polygon(int Points, GdcPt2 *Data);
    void Bezier(int Threshold, GdcPt2 *Pt);
    void FloodFill(int x, int y, int Mode, COLOUR Border = 0, GRect *Bounds = NULL);
};

#ifdef MAC
class CGImg
{
    class CGImgPriv *d;

public:
    CGImg(int x, int y, int Bits, int Line, uchar *data, uchar *palette, GRect *r);
    ~CGImg();
    
    operator CGImageRef();
};
#endif

class LgiClass GMemDC : public GSurface
{
protected:
    class GMemDCPrivate *d;

    #if defined WIN32
    PBITMAPINFO GetInfo();
    #endif

public:
    GMemDC
    (
        int x = 0,
        int y = 0,
        int bits = 0
    );
    GMemDC(GSurface *pDC);
    virtual ~GMemDC();

    #if defined WIN32
    
        HDC StartDC();
        void EndDC();
        void Update(int Flags);
        void UpsideDown(bool upsidedown);
        
        // need this to tell the HDC about the
        // new clipping region
        GRect ClipRgn(GRect *Rgn);

    #else

        OsBitmap GetBitmap();
        bool IsScreen() { return false; }
        GRect ClipRgn() { return Clip; }

        OsPainter Handle();

        #if defined XWIN

        Pixmap GetPixmap();
        Pixmap GetPixmapMask();

        #elif defined MAC
        
        CGColorSpaceRef GetColourSpace();
        CGImg *GetImg(GRect *Sub = 0);
        
        #endif
        
    #endif

    bool Lock();
    bool Unlock();

    #ifdef XWIN
    // Returns the scanline when the bitmap is locked. Otherwise null.
    uchar *operator[](int y);
    #endif
    
    void SetOrigin(int x, int y);

    bool Create(int x, int y, int Bits, int LineLen = 0, bool KeepData = false);
    void Blt(int x, int y, GSurface *Src, GRect *a = NULL);
    void StretchBlt(GRect *d, GSurface *Src, GRect *s = NULL);

    void HLine(int x1, int x2, int y, COLOUR a, COLOUR b);
    void VLine(int x, int y1, int y2, COLOUR a, COLOUR b);
};

class LgiClass GPrintDC
#if defined WIN32
    : public GScreenDC
#else
    : public GSurface
#endif
{
    #ifdef XWIN
    friend class PrintPainter;
    double Xc(int x);
    double Yc(int y);
    #endif

    class GPrintDCPrivate *d;

public:
    GPrintDC(void *Handle, char *PrintJobName);
    ~GPrintDC();

    bool IsPrint() { return true; }

    int X();
    int Y();
    int GetBits();

    int DpiX();

    int DpiY();

    bool StartPage();
    void EndPage();

    #if defined XWIN

    OsPainter Handle();
    COLOUR Colour();
    COLOUR Colour(COLOUR c, int Bits = 0);

    void Set(int x, int y);
    COLOUR Get(int x, int y);
    void HLine(int x1, int x2, int y);
    void VLine(int x, int y1, int y2);
    void Line(int x1, int y1, int x2, int y2);
    void Circle(double cx, double cy, double radius);
    void FilledCircle(double cx, double cy, double radius);
    void Arc(double cx, double cy, double radius, double start, double end);
    void FilledArc(double cx, double cy, double radius, double start, double end);
    void Ellipse(double cx, double cy, double x, double y);
    void FilledEllipse(double cx, double cy, double x, double y);
    void Box(int x1, int y1, int x2, int y2);
    void Box(GRect *a = NULL);
    void Rectangle(int x1, int y1, int x2, int y2);
    void Rectangle(GRect *a = NULL);
    void Blt(int x, int y, GSurface *Src, GRect *a = NULL);
    void StretchBlt(GRect *d, GSurface *Src, GRect *s);
    void Polygon(int Points, GdcPt2 *Data);
    void Bezier(int Threshold, GdcPt2 *Pt);
    void FloodFill(int x, int y, int Mode, COLOUR Border = 0, GRect *Bounds = NULL);
    
    #endif

};

class LgiClass GSprite
{
protected:
    // Dimensions
    int Sx, Sy, Bits;
    
    // Screen relation
    bool Visible;
    int PosX, PosY;
    int HotX, HotY;

    // Mode
    int DrawMode;           // See access functions for description

    // Destination DC, usually the screen
    // Don't own and must not be NULL
    GSurface *pScreen;
    
    // Internal sprite DC's
    // TODO: combine all these into one DC 3 times bigger
    GSurface *pBack;
    GSurface *pMask;
    GSurface *pColour;
    GSurface *pTemp;

    // This function gets called to update any sprite position dependent
    // graphics when the sprite moves.
    virtual void DrawOnMove(    GSurface *pDC,
                    int Nx, int Ny,
                    int Ox, int Oy) {}

public:
    GSprite();
    virtual ~GSprite();

    int X() { return Sx; }
    int Y() { return Sy; }
    int GetPosX() { return PosX; }
    int GetPosY() { return PosY; }
    int GetHotX() { return HotX; }
    int GetHotY() { return HotY; }
    int GetBits() { return Bits; }
    bool IsVisible() { return Visible; }

    void SetXY(int x, int y);

    bool Create(GSurface *pScreen, int x, int y, int Bits, uchar *Colour, uchar *Mask);
    bool CreateKey(GSurface *pScreen, int x, int y, int Bits, uchar *Colour, int Key);
    bool Create(GSurface *pScreen, GSprite *pSpr);
    bool SetSize(int x, int y, int Bits, GSurface *pScr = NULL);
    void Delete();

    int Mode() { return DrawMode; }
    int Mode(int m) { int Old = DrawMode; DrawMode = m; return Old; }
    // Mode:
    //  0 - Transparent background, AND mask, XOR colour
    //  1 - Transparent background, AND mask, OR colour
    //  3 - COPY colour

    void SetHotPoint(int x, int y);
    void SetVisible(bool v);
    void Move(int x, int y, bool WaitRetrace);

    void Draw(int x, int y, COLOUR Back, int Mode = 0, GSurface *pDC = NULL);
    // Mode:
    //  0 - Solid background, AND colour, XOR mask
    //  1 - Solid background, AND mask, OR colour
    //  2 - Transparent background, AND mask, OR colour
    //  3 - COPY colour

    void MoveToScreen(GSurface *Scr)
    {
        bool v = Visible;
        SetVisible(false);
        pScreen = Scr;
        SetVisible(v);
    }
    GSurface *GetMask() { return pMask; }
    GSurface *GetColour() { return pColour; }
};

class LgiClass GGlobalColour
{
    class GGlobalColourPrivate *d;

public:
    GGlobalColour();
    ~GGlobalColour();

    // Add all the colours first
    COLOUR AddColour(COLOUR c24);
    bool AddBitmap(GSurface *pDC);
    bool AddBitmap(GImageList *il);

    // Then call this
    bool MakeGlobalPalette();

    // Which will give you a palette that
    // includes everything
    GPalette *GetPalette();

    // Convert a bitmap to the global palette
    COLOUR GetColour(COLOUR c24);
    bool RemapBitmap(GSurface *pDC);
};

#ifdef WIN32
typedef int (__stdcall *MsImg32_AlphaBlend)(HDC,int,int,int,int,HDC,int,int,int,int,BLENDFUNCTION);
#endif

class LgiClass GdcDevice
{
    friend class GScreenDC;
    static GdcDevice *pInstance;
    class GdcDevicePrivate *d;
    #ifdef WIN32
    MsImg32_AlphaBlend AlphaBlend;
    #endif

public:
    GdcDevice();
    ~GdcDevice();
    static GdcDevice *GetInst() { return pInstance; }

    int GetBits();
    int X();
    int Y();

    GGlobalColour *GetGlobalColour();

    int GetOption(int Opt);
    int SetOption(int Opt, int Value);

    ulong *GetCharSquares();
    uchar *GetDiv255();

    // Palette/Colour
    void SetGamma(double Gamma);
    double GetGamma();

    // Palette
    void SetSystemPalette(int Start, int Size, GPalette *Pal);
    GPalette *GetSystemPalette();
    void SetColourPaletteType(int Type);    // Type = PALTYPE_xxx define
    COLOUR GetColour(COLOUR Rgb24, GDeviceContext *pDC = NULL);

    // Lib
    GLibrary *GetIconv();
};

class GInlineBmp
{
public:
    int X;
    int Y;
    int Bits;
    uint32 *Data;

    GSurface *Create()
    {
        GSurface *pDC = NEW(GMemDC);
        if (pDC->Create(X, Y, Bits))
        {
            int Line = X * Bits / 8;
            for (int y=0; y<Y; y++)
            {
                memcpy((*pDC)[y], ((uchar*)Data) + (y * Line), Line);
            }
        }

        return pDC;
    }
};

// file filter support
#include "GFilter.h"

// globals
#define GdcD            GdcDevice::GetInst()

LgiFunc GSurface *ConvertDC
(
    GSurface *pDC,
    int Bits
);

LgiFunc GSurface *LoadDC
(
    char *Name
);

LgiFunc bool WriteDC(char *Name, GSurface *pDC);

LgiFunc COLOUR CBit(int DstBits, COLOUR c, int SrcBits = 24, GPalette *Pal = 0);

LgiFunc COLOUR GdcMixColour(COLOUR a, COLOUR b, double HowMuchA = 0.5);

LgiFunc COLOUR GdcGreyScale(COLOUR c, int Bits = 24);

enum GColourReducePalette
{
    CR_PAL_NONE = -1,
    CR_PAL_CUBE = 0,
    CR_PAL_OPT,
    CR_PAL_FILE
};

enum GColourReduceMatch
{
    CR_MATCH_NONE = -1,
    CR_MATCH_NEAR = 0,
    CR_MATCH_HALFTONE,
    CR_MATCH_ERROR
};

class GReduceOptions
{
public:
    GColourReducePalette PalType;
    
    GColourReduceMatch MatchType;
    
    int Colours;
    
    GPalette *Palette;

    GReduceOptions()
    {
        Palette = 0;
        Colours = 256;
        PalType = CR_PAL_NONE;
        MatchType = CR_MATCH_NONE;
    }
};

LgiFunc bool GReduceBitDepth(GSurface *pDC, int Bits, GPalette *Pal = 0, GReduceOptions *Reduce = 0);

#endif

---