/**************************************************************
$Id$
**************************************************************/

#ifndef OBJGFX40_H
#define OBJGFX40_H

#include "ogTypes.h"
#include "ogPixelFmt.h"

#ifndef __UBIXOS_KERNEL__
#include <stdlib.h> // for NULL, true, false
#endif

#define ogVERSION 4.0;

class ogPixelFmt;

extern const uInt32 OG_MASKS[32];

#if 0
typedef 
  class ogPixelFmt {
   public:
    uInt8 BPP;
    uInt8 redFieldPosition;
    uInt8 greenFieldPosition;
    uInt8 blueFieldPosition;
    uInt8 alphaFieldPosition;
    uInt8 redMaskSize;
    uInt8 greenMaskSize;
    uInt8 blueMaskSize;
    uInt8 alphaMaskSize;
    uInt8 reserved[7];
             ogPixelFmt(uInt8, uInt8, uInt8, uInt8, uInt8, 
                        uInt8, uInt8, uInt8, uInt8);
    virtual ~ogPixelFmt(void) {};
  };
// Default pixel formats
const ogPixelFmt OG_NULL_PIXFMT      = { 0, 0,0,0,0,0,0,0,0, {0,0,0,0,0,0}};
const ogPixelFmt OG_PIXFMT_8BPP      = { 8, 0,0,0,0,0,0,0,0, {0,0,0,0,0,0}};
const ogPixelFmt OG_PIXFMT_15BPP     = {15, 10,5,0,15,5,5,5,1, {0,0,0,0,0,0}};
const ogPixelFmt OG_PIXFMT_16BPP     = {16, 11,5,0,0,5,6,5,0, {0,0,0,0,0,0}};
const ogPixelFmt OG_PIXFMT_24BPP     = {24, 16,8,0,0,8,8,8,0, {0,0,0,0,0,0}};
const ogPixelFmt OG_PIXFMT_32BPP     = {32, 16,8,0,24,8,8,8,8, {0,0,0,0,0,0}};
const ogPixelFmt OG_MAC_PIXFMT_16BPP = {16, 8,4,0,12,4,4,4,4, {0,0,0,0,0,0}};
#endif

#if 0
class 
  ogAttributes(uInt32 transparentColour = 0, 
                 uInt32 defaultAlpha = 255,
                 bool antiAlias = true,
                 bool blending = false);
#endif        

class ogAttributes {
 public:
  uInt32 transparentColor;
  uInt32 defaultAlpha;
  bool   antiAlias;
  bool   blending;
  ogAttributes():transparentColor(0), 
                 defaultAlpha(255),
                 antiAlias(true),
                 blending(false) { } 
  ogAttributes & operator=( ogAttributes const & copy ) {
    transparentColor = copy.transparentColor;
    defaultAlpha = copy.defaultAlpha;
    antiAlias = copy.antiAlias;
    blending = copy.blending;
    return * this;
  } // operator =
}; // ogAttributes

class ogSurface {
#ifdef __UBIXOS_KERNEL__
 public:
#else
 protected:
#endif
  float        version;
  void       * buffer;
  ogSurface  * owner;
  uInt32     * lineOfs;
  ogRGBA8    * pal;
  ogAttributes*attributes;

  uInt32       xRes, yRes;
  uInt32       maxX, maxY;
  uInt32       bSize;       // buffer size (in bytes)
  uInt32       lSize;       // LineOfs size (in bytes)

  uInt32       BPP;         // bits per pixel
  uInt32       bytesPerPix;
  uInt32       pixFmtID;

  uInt32       redFieldPosition;
  uInt32       greenFieldPosition;
  uInt32       blueFieldPosition;
  uInt32       alphaFieldPosition;

  uInt32       redShifter;
  uInt32       greenShifter;
  uInt32       blueShifter;
  uInt32       alphaShifter;
  uInt32       alphaMasker;
  ogErrorCode  lastError;
  ogDataState  dataState;

  bool         ClipLine(int32&, int32&, int32&, int32&);
  void         RawLine(uInt32, uInt32, uInt32, uInt32, uInt32);
  virtual uInt32 RawGetPixel(uInt32, uInt32);
  virtual void RawSetPixel(uInt32, uInt32, uInt32);
  virtual void RawSetPixel(uInt32, uInt32, uInt8, uInt8, uInt8, uInt8);
  void         AARawLine(uInt32, uInt32, uInt32, uInt32, uInt32);
 public:
               ogSurface(void);
  virtual bool Alias(ogSurface&, uInt32, uInt32, uInt32, uInt32);
  virtual bool Avail(void);
  void         Arc(int32, int32, uInt32, uInt32, uInt32, uInt32);
  void         BSpline(uInt32, ogPoint2d*, uInt32, uInt32);
  void         Circle(int32, int32, uInt32, uInt32);
  virtual void Clear(uInt32);
  virtual bool Clone(ogSurface&);
  void         Copy(ogSurface&);
  void         CopyBuf(int32, int32,
                 ogSurface&, int32, int32, int32, int32);
  virtual void CopyLineTo(uInt32, uInt32, const void *, uInt32);
  virtual void CopyLineFrom(uInt32, uInt32, void *, uInt32);
  virtual void CopyPalette(ogSurface&);
  virtual bool Create(uInt32, uInt32, ogPixelFmt);
  void         CubicBezierCurve(int32, int32, int32, int32,
                 int32, int32, int32, int32, uInt32, uInt32);
  void         Curve(int32,int32, int32,int32, int32,int32, uInt32, uInt32);
  void         FillCircle(int32, int32, uInt32, uInt32);
  void         FillGouraudPolygon(uInt32, ogPoint2d*, ogRGBA8 *);
  void         FillPolygon(uInt32, ogPoint2d*, uInt32);
  void         FillRect(int32, int32, int32, int32, uInt32);
  void         FillTriangle(int32,int32, int32,int32, int32,int32, uInt32);
  uInt32       GetAlpha(void);
  uInt32       GetAlphaMasker(void) const { return alphaMasker; }
  uInt32       GetBPP(void) const { return BPP; }
  uInt32       GetBytesPerPix(void) const { return bytesPerPix; }
  ogDataState  GetDataState(void) const { return dataState; }
  ogErrorCode  GetLastError(void);
  uInt32       GetMaxX(void) const { return maxX; }
  uInt32       GetMaxY(void) const { return maxY; }
  void         GetPalette(ogRGBA8[]);
  void         GetPixFmt(ogPixelFmt&);
  uInt32       GetPixFmtID(void) const { return pixFmtID; }
  virtual uInt32 GetPixel(int32, int32);
  virtual void * GetPtr(uInt32, uInt32);
  uInt32       GetTransparentColor(void); 
  void         HFlip(void);
  virtual void HLine(int32, int32, int32, uInt32);
  bool         IsAntiAliasing(void);
  bool         IsBlending(void); 
  void         Line(int32, int32, int32, int32, uInt32);
  virtual bool LoadPalette(const char *);
  void         Polygon(uInt32, ogPoint2d*, uInt32);
  void         Rect(int32, int32, int32, int32, uInt32);
  uInt32       Pack(uInt8, uInt8, uInt8);
  uInt32       Pack(uInt8, uInt8, uInt8, uInt8);
  bool         SavePalette(const char *);
  void         Scale(ogSurface&);
  void         ScaleBuf(int32, int32, int32, int32,
                 ogSurface&, int32, int32, int32, int32);
  uInt32       SetAlpha(uInt32);
  bool         SetAntiAliasing(bool);
  bool         SetBlending(bool);
  virtual ogErrorCode SetLastError(ogErrorCode);
  virtual void SetPixel(int32, int32, uInt32);
  virtual void SetPixel(int32, int32, uInt8, uInt8, uInt8, uInt8);
  virtual void SetPalette(const ogRGBA8[]);
  virtual void SetPalette(uInt8, uInt8, uInt8, uInt8, uInt8);
  virtual void SetPalette(uInt8, uInt8, uInt8, uInt8);
  uInt32       SetTransparentColor(uInt32);
  void         Spline(uInt32, ogPoint2d*, uInt32, uInt32);
  void         Triangle(int32, int32, int32, int32, int32, int32, uInt32);
  void         Unpack(uInt32, uInt8&, uInt8&, uInt8&);
  void         Unpack(uInt32, uInt8&, uInt8&, uInt8&, uInt8&);
  virtual void VFlip(void);
  virtual void VLine(int32, int32, int32, uInt32);
  virtual      ~ogSurface(void);
}; // ogSurface

#endif