gfxlibinterfaces.h

Go to the documentation of this file.

 
#pragma once
#undef CreateFont
#include <adtfdisplaytoolboxgraphics/color_intf.h>
#include <adtfdisplaytoolboxgraphics/image_intf.h>
#include <adtfdisplaytoolboxgraphics/rect_intf.h>
#include <adtfdisplaytoolboxgraphics/vector3_intf.h>
#include <adtf_utils.h>
#include <adtf_ucom3.h>
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{
 
#define COORDS_NONE     0x00
 
#define COORDS_SCREEN   0x01
 
#define COORDS_LOGICAL  0x02
 
namespace dengar
{
 
 
class IGraphicsFlags
{
public:
    enum
    {
            DEVICE_GDI = 0x0001,
            DEVICE_QT = 0x0002,
            DEVICE_SWT = 0x0004,
            DEVICE_X11 = 0x0008,
            DEVICE_SDL = 0x0010,
        // ---------------------------------------------------------------------
            SUPPORT_OPENGL = 0x0100,
            FULLSCREEN_MODE = 0x0200,
            SUPPORT_ADTF25 = 0x0400
    };
};
 
class IFont
{
public:
    typedef enum
    {
            STYLE_Default,
            STYLE_Antialiased,
            STYLE_Mono
    } tStyle;
 
public:
 
    virtual ~IFont()
    {}
 
    virtual tResult Release() = 0;
 
    virtual tInt GetHeight() const = 0;
 
    virtual tBool MeasureText(const tChar* str, tInt& nWidth, tInt& nHeight) const = 0;
};
 
class ITexture
{
public:
    typedef enum
    {
            MODE_BilinearFiltered,
            MODE_NearestPixel
    } tTextureMode;
 
public:
 
    virtual ~ITexture()
    {}
 
    virtual tResult Release() = 0;
 
    virtual tResult SetMode(tInt nMode) = 0;
 
    virtual tVoid MakeCurrent() = 0;
 
    virtual tResult Copy(IImage* pSource) = 0;
 
    virtual tInt GetWidth() const = 0;
 
    virtual tInt GetHeight() const = 0;
 
    virtual tInt GetBitsPerPixel() const = 0;
 
    virtual tInt GetPhysicalWidth() const = 0;
 
    virtual tInt GetPhysicalHeight() const = 0;
};
 
class IGraphicsMode
{
public:
 
    typedef enum
    {
            MODE_DrawPoints,
            MODE_DrawLines,
            MODE_DrawLineStrip,
            MODE_DrawLineLoop,
            MODE_DrawTriangles,
            MODE_DrawTriangleStrip,
            MODE_DrawTriangleFan,
            MODE_DrawQuads,
            MODE_DrawQuadStrip,
            MODE_DrawPolygon
    } tMode;
 
    typedef enum
    {
            FEATURE_AlphaBlending,
            FEATURE_Antialiasing,
            FEATURE_Lighting,
            FEATURE_DepthBuffer,
            FEATURE_BackFaceCulling,
            FEATURE_CommandLists,
            FEATURE_HardwareAcceleration
    } tFeature;
 
public:
 
    virtual ~IGraphicsMode()
    {}
 
    virtual tBool IsSupported(tFeature nFeatureId) const = 0;
 
    virtual tVoid EnableAlpha(tBool bAdditiveMode = tFalse) const = 0;
 
    virtual tVoid DisableAlpha() const = 0;
 
    virtual tVoid EnableAntialiasing() const = 0;
 
    virtual tVoid DisableAntialiasing() const = 0;
 
    virtual tVoid EnableLighting() const = 0;
 
    virtual tVoid DisableLighting() const = 0;
 
    virtual tVoid EnableDepthBuffer() const = 0;
 
    virtual tVoid DisableDepthBuffer() const = 0;
 
    virtual tVoid EnableBackFaceCulling() const = 0;
 
    virtual tVoid DisableBackFaceCulling() const = 0;
 
    virtual tVoid LineWidth(tFloat64 fWidth) = 0;
 
    virtual tVoid LinePattern(tUInt16 ui16Pattern, tInt nFactor = 1) = 0;
 
    virtual tVoid Color(const IColor* col) = 0;
 
    virtual tVoid Color(tInt nRed, tInt nGreen, tInt nBlue, tInt nAlpha = 255) = 0;
 
    virtual tVoid Color(tUInt8 nRed, tUInt8 nGreen, tUInt8 nBlue, tUInt8 nAlpha = 255) = 0;
 
    virtual tVoid Color(tFloat64 fRed, tFloat64 fGreen, tFloat64 fBlue, tFloat64 fAlpha = 1.0) = 0;
 
    virtual tVoid BgColor(const IColor* col) = 0;
 
    virtual tVoid BgColor(tInt nRed, tInt nGreen, tInt nBlue, tInt nAlpha = 0) = 0;
 
    virtual tVoid BgColor(tUInt8 nRed, tUInt8 nGreen, tUInt8 nBlue, tUInt8 nAlpha = 0) = 0;
 
    virtual tVoid BgColor(tFloat64 fRed, tFloat64 fGreen, tFloat64 fBlue, tFloat64 fAlpha = 0.0) = 0;
 
 
    virtual tVoid Begin(tMode eMode) = 0;
 
    virtual tVoid Coord(tInt x, tInt y) = 0;
 
    virtual tVoid Coord(tFloat32 x, tFloat32 y) = 0;
 
    virtual tVoid Coord(IPoint* pt) = 0;
 
    virtual tVoid Coord(IPoint** ppPoints, tInt nCount) = 0;
 
    virtual tVoid CoordTexture(tFloat32 u, tFloat32 v) = 0;
 
    virtual tVoid End() = 0;
};
 
class IScene;
 
class ICanvas : public IGraphicsMode, public ucom::ant::IObject
{
public:
    ADTF_IID(ICanvas, "canvas.adtf_disptb.iid");
 
    virtual tResult Create(tInt nWidth, tInt nHeight, tInt nBitsPerPixel) = 0;
 
    virtual tVoid PushMatrix() = 0;
 
    virtual tVoid PopMatrix() = 0;
 
    virtual tVoid Translate(tFloat fx, tFloat fy, tFloat fz) = 0;
 
    virtual tVoid Scale(tFloat fx, tFloat fy, tFloat fz) = 0;
 
    virtual tVoid Rotate(tFloat fangle, tFloat fx, tFloat fy, tFloat fz) = 0;
 
    virtual tInt GetWidth() const = 0;
 
    virtual tInt GetHeight() const = 0;
 
    virtual tInt GetBitsPerPixel() const = 0;
 
    virtual tVoid SetMapping(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) = 0;
 
    virtual tVoid ClearMapping() = 0;
 
    virtual tInt MapPixelX(tFloat32 x) = 0;
 
    virtual tInt MapPixelY(tFloat32 y) = 0;
 
    virtual tInt MapPixelX(tInt x) = 0;
 
    virtual tInt MapPixelY(tInt y) = 0;
 
    virtual tFloat32 UnmapPixelX(tInt x) = 0;
 
    virtual tFloat32 UnmapPixelY(tInt y) = 0;
 
    virtual tVoid Clear() = 0;
 
    virtual tResult CreateTexture(IImage* pImage, ITexture*& pTexture) = 0;
 
    virtual tVoid DrawTexture(ITexture* pTexture, tFloat32 vPoints[8]) = 0;
 
    virtual tVoid DrawPixel(tInt x, tInt y) = 0;
 
    virtual tVoid DrawLine(tInt x1, tInt y1, tInt x2, tInt y2) = 0;
 
    virtual tVoid DrawRect(tInt x1, tInt y1, tInt x2, tInt y2) = 0;
 
    virtual tVoid DrawCircle(tInt x1, tInt y1, tInt x2, tInt y2) = 0;
 
    virtual tVoid DrawCircleSegment(tInt x1, tInt y1, tInt x2, tInt y2, tFloat64 fDegreeStart, tFloat64 fDegreeEnd,
                                    tBool bNormalizeRect = tFalse) = 0;
 
    virtual tVoid FillRect(tInt x1, tInt y1, tInt x2, tInt y2) = 0;
 
    virtual tVoid FillCircle(tInt x1, tInt y1, tInt x2, tInt y2) = 0;
 
    virtual tVoid FillCircleSegment(tInt x1, tInt y1, tInt x2, tInt y2, tFloat64 fDegreeStart, tFloat64 fDegreeEnd,
                                    tBool bNormalizeRect = tFalse) = 0;
 
    virtual tVoid DrawPixel(tFloat32 x, tFloat32 y) = 0;
 
    virtual tVoid DrawLine(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) = 0;
 
    virtual tVoid DrawRect(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) = 0;
 
    virtual tVoid DrawCircle(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) = 0;
 
    virtual tVoid
    DrawCircleSegment(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2, tFloat64 fDegreeStart, tFloat64 fDegreeEnd,
                      tBool bNormalizeRect = tFalse) = 0;
 
    virtual tVoid FillRect(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) = 0;
 
    virtual tVoid FillCircle(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2) = 0;
 
    virtual tVoid
    FillCircleSegment(tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2, tFloat64 fDegreeStart, tFloat64 fDegreeEnd,
                      tBool bNormalizeRect = tFalse) = 0;
 
    virtual tVoid DrawPixel(IPoint* pt) = 0;
 
    virtual tVoid
    DrawLine(IPoint* ptStart, IPoint* ptEnd) = 0;
 
    virtual tVoid DrawRect(IRect* rect) = 0;
 
    virtual tVoid DrawPolygon(IPoint** ppPoints, tInt nCount) = 0;
 
    virtual tVoid DrawCircle(IRect* rect) = 0;
 
    virtual tVoid
    DrawCircleSegment(IRect* rect, tFloat64 fDegreeStart, tFloat64 fDegreeEnd) = 0;
 
    virtual tVoid FillRect(IRect* rect) = 0;
 
    virtual tVoid FillPolygon(IPoint** ppPoints, tInt nCount) = 0;
 
    virtual tVoid FillCircle(IRect* rect) = 0;
 
    virtual tVoid
    FillCircleSegment(IRect* rect, tFloat64 fDegreeStart, tFloat64 fDegreeEnd) = 0;
 
    virtual IFont* CreateFont(const char* strName, tInt nHeight,
                              IFont::tStyle eFontStyle = IFont::STYLE_Default) = 0;
 
    virtual tVoid SetFontAngle(tFloat64 fAngle) = 0;
 
    // * Returns the font angle
    // * @return angle of the font
    // */
    virtual tFloat64 GetFontAngle() = 0;
 
    // * Sets the current font for drawing operations
    // * @param  [in]  pFont    Pointer to font instance
    // * @return  void
    // */
    virtual tVoid Font(IFont* pFont) = 0;
 
    // * Sets an text to a given position
    // * @param [in] x x position of the text
    // * @param [in] y y position of the text
    // * @param [in] fmt format string the format follows the printf specification
    // * @param [in] ... unspecified parameters described in the format string
    // * @return  void
    // */
    virtual tVoid OutputText(tInt x, tInt y, const tChar* fmt, ...) = 0;
 
    // * Sets an text to a given position
    // * @param [in] x x position of the text
    // * @param [in] y y position of the text
    // * @param [in] fmt format string the format follows the printf specification
    // * @param [in] ... unspecified parameters described in the format string
    // * @return  void
    // */
    virtual tVoid OutputText(tFloat32 x, tFloat32 y, const tChar* fmt, ...) = 0;
 
    virtual ITexture* CreateTexture(const tBitmapFormat* psFormat, tInt nMode = 0) = 0;
 
    virtual tVoid Texture(ITexture* pTexture) = 0;
 
    virtual tVoid Blit(ITexture* pTexture, tInt x, tInt y, tInt nWidth, tInt nHeight) = 0;
 
    virtual tVoid Blit(IImage* pImage, tInt x, tInt y, tInt nWidth, tInt nHeight) = 0;
 
    virtual tVoid Capture(IImage** ppImage, tInt x, tInt y, tInt nWidth, tInt nHeight) = 0;
 
    virtual IScene* BeginScene() = 0;
 
    virtual tVoid EndScene() = 0;
 
    virtual tVoid SetFlag(tUInt32 nFlag, tInt32 nValue) = 0;
 
    virtual tInt32 GetFlag(tUInt32 nFlag) = 0;
 
    virtual tResult PushFlags() = 0;
 
    virtual tResult PopFlags() = 0;
 
    virtual tVoid ResetFlags() = 0;
 
    virtual tVoid DrawEllipse(tInt iOriginX,
                              tInt iOriginY,
                              tInt iWidth,
                              tInt iHeight,
                              tInt iAngle) = 0;
 
    virtual tVoid DrawEllipse(tFloat32 f32OriginX,
                              tFloat32 f32OriginY,
                              tFloat32 f32Width,
                              tFloat32 f32Height,
                              tFloat32 f32Angle) = 0;
 
 
    virtual tVoid FillEllipse(tInt iOriginX, tInt iOriginY, tInt iWidth, tInt iHeight, tInt iAngle) = 0;
 
    virtual tVoid FillEllipse(tFloat32 f32OriginX,
                              tFloat32 f32OriginY,
                              tFloat32 f32Width,
                              tFloat32 f32Height,
                              tFloat32 f32Angle) = 0;
};
 
 
class IUIEventHandler
{
public:
    typedef enum
    {
            EC_MouseLDown = 1,
 
            EC_MouseLUp = 2,
 
            EC_MouseLDblClk = 3,
 
            EC_MouseRDown = 4,
 
            EC_MouseRUp = 5,
 
            EC_MouseRDblClk = 6,
 
            EC_MouseMDown = 7,
 
            EC_MouseMUp = 8,
 
            EC_MouseMDblClk = 9,
 
            EC_MouseMove = 10,
 
            EC_MouseWheel = 11,
 
            EC_KeyDown = 12,
        //EC_KeyDown          = adtf::IKeyEventHandler::EC_KeyDown,
 
            EC_KeyUp = 13,
        //EC_KeyUp            = adtf::IKeyEventHandler::EC_KeyUp,
 
            EC_KeyInput = 14
        //EC_KeyInput         = adtf::IKeyEventHandler::EC_KeyInput
 
    } tControlEventCode;
 
    typedef enum
    {
        MS_LeftButtonDown = 0x1,
        MS_RightButtonDown = 0x2,
        MS_MiddleButtonDown = 0x4,
        MS_CtrlKeyDown = 0x8
    } tMouseState;
 
    typedef enum
    {
        KS_CtrlKeyDown = 0x1,
        KS_AltKeyDown = 0x2,
        KS_ShiftKeyDown = 0x4
        /*KS_CtrlKeyDown      = adtf::IKeyEventHandler::KS_CtrlKeyDown,
        KS_AltKeyDown       = adtf::IKeyEventHandler::KS_AltKeyDown,
        KS_ShiftKeyDown     = adtf::IKeyEventHandler::KS_ShiftKeyDown*/
    } tKeyState;
 
    typedef enum
    {
            KEY_ESCAPE = 0x01000000,
            KEY_TAB = 0x01000001,
            KEY_BACKSPACE = 0x01000003,
            KEY_RETURN = 0x01000004,
            KEY_INSERT = 0x01000006,
            KEY_DELETE = 0x01000007,
            KEY_PRINT = 0x01000009,
            KEY_HOME = 0x01000010,
            KEY_END = 0x01000011,
            KEY_LEFT = 0x01000012,
            KEY_UP = 0x01000013,
            KEY_RIGHT = 0x01000014,
            KEY_DOWN = 0x01000015,
            KEY_PAGEUP = 0x01000016,
            KEY_PAGEDOWN = 0x01000017,
            KEY_SPACE = 0x20,
            KEY_NUMLOCK = 0x01000025,
 
            KEY_F1 = 0x01000030,
            KEY_F2 = 0x01000031,
            KEY_F3 = 0x01000032,
            KEY_F4 = 0x01000033,
            KEY_F5 = 0x01000034,
            KEY_F6 = 0x01000035,
            KEY_F7 = 0x01000036,
            KEY_F8 = 0x01000037,
            KEY_F9 = 0x01000038,
            KEY_F10 = 0x01000039,
            KEY_F11 = 0x0100003a,
            KEY_F12 = 0x0100003b,
 
            KEY_PLUS = 0x2b,
            KEY_COMMA = 0x2c,
            KEY_MINUS = 0x2d,
        KEY_PERIOD = 0x2e,
 
        KEY_0 = 0x30,
        KEY_1 = 0x31,
        KEY_2 = 0x32,
        KEY_3 = 0x33,
        KEY_4 = 0x34,
        KEY_5 = 0x35,
        KEY_6 = 0x36,
        KEY_7 = 0x37,
        KEY_8 = 0x38,
        KEY_9 = 0x39,
 
        KEY_A = 0x41,
        KEY_B = 0x42,
        KEY_C = 0x43,
        KEY_D = 0x44,
        KEY_E = 0x45,
        KEY_F = 0x46,
        KEY_G = 0x47,
        KEY_H = 0x48,
        KEY_I = 0x49,
        KEY_J = 0x4a,
        KEY_K = 0x4b,
        KEY_L = 0x4c,
        KEY_M = 0x4d,
        KEY_N = 0x4e,
        KEY_O = 0x4f,
        KEY_P = 0x50,
        KEY_Q = 0x51,
        KEY_R = 0x52,
        KEY_S = 0x53,
        KEY_T = 0x54,
        KEY_U = 0x55,
        KEY_V = 0x56,
        KEY_W = 0x57,
        KEY_X = 0x58,
        KEY_Y = 0x59,
        KEY_Z = 0x5a,
 
        KEY_SHIFT = 0x01000020,
        KEY_CTRL = 0x01000021,
        KEY_ALT = 0x01000023
 
        /*///the escape key.
        KEY_ESCAPE       = adtf::IKeyEventHandler::KEY_ESCAPE,
        KEY_TAB          = adtf::IKeyEventHandler::KEY_TAB,
        KEY_BACKSPACE    = adtf::IKeyEventHandler::KEY_BACKSPACE,
        KEY_RETURN       = adtf::IKeyEventHandler::KEY_RETURN,
        KEY_INSERT       = adtf::IKeyEventHandler::KEY_INSERT,
        KEY_DELETE       = adtf::IKeyEventHandler::KEY_DELETE,
        KEY_PRINT        = adtf::IKeyEventHandler::KEY_PRINT,
        KEY_HOME         = adtf::IKeyEventHandler::KEY_HOME,
        KEY_END          = adtf::IKeyEventHandler::KEY_END,
        KEY_LEFT         = adtf::IKeyEventHandler::KEY_LEFT,
        KEY_UP           = adtf::IKeyEventHandler::KEY_UP,
        KEY_RIGHT        = adtf::IKeyEventHandler::KEY_RIGHT,
        KEY_DOWN         = adtf::IKeyEventHandler::KEY_DOWN,
        KEY_PAGEUP       = adtf::IKeyEventHandler::KEY_PAGEUP,
        KEY_PAGEDOWN     = adtf::IKeyEventHandler::KEY_PAGEDOWN,
        KEY_SPACE        = adtf::IKeyEventHandler::KEY_SPACE,
        KEY_NUMLOCK      = adtf::IKeyEventHandler::KEY_NUMLOCK,
 
        KEY_F1           = adtf::IKeyEventHandler::KEY_F1,
        KEY_F2           = adtf::IKeyEventHandler::KEY_F2,
        KEY_F3           = adtf::IKeyEventHandler::KEY_F3,
        KEY_F4           = adtf::IKeyEventHandler::KEY_F4,
        KEY_F5           = adtf::IKeyEventHandler::KEY_F5,
        KEY_F6           = adtf::IKeyEventHandler::KEY_F6,
        KEY_F7           = adtf::IKeyEventHandler::KEY_F7,
        KEY_F8           = adtf::IKeyEventHandler::KEY_F8,
        KEY_F9           = adtf::IKeyEventHandler::KEY_F9,
        KEY_F10          = adtf::IKeyEventHandler::KEY_F10,
        KEY_F11          = adtf::IKeyEventHandler::KEY_F11,
        KEY_F12          = adtf::IKeyEventHandler::KEY_F12,
 
        KEY_PLUS         = adtf::IKeyEventHandler::KEY_PLUS,
        KEY_COMMA        = adtf::IKeyEventHandler::KEY_COMMA,
        KEY_MINUS        = adtf::IKeyEventHandler::KEY_MINUS,
        KEY_PERIOD       = adtf::IKeyEventHandler::KEY_PERIOD,
 
        KEY_0            = adtf::IKeyEventHandler::KEY_0,
        KEY_1            = adtf::IKeyEventHandler::KEY_1,
        KEY_2            = adtf::IKeyEventHandler::KEY_2,
        KEY_3            = adtf::IKeyEventHandler::KEY_3,
        KEY_4            = adtf::IKeyEventHandler::KEY_4,
        KEY_5            = adtf::IKeyEventHandler::KEY_5,
        KEY_6            = adtf::IKeyEventHandler::KEY_6,
        KEY_7            = adtf::IKeyEventHandler::KEY_7,
        KEY_8            = adtf::IKeyEventHandler::KEY_8,
        KEY_9            = adtf::IKeyEventHandler::KEY_9,
 
        KEY_A            = adtf::IKeyEventHandler::KEY_A,
        KEY_B            = adtf::IKeyEventHandler::KEY_B,
        KEY_C            = adtf::IKeyEventHandler::KEY_C,
        KEY_D            = adtf::IKeyEventHandler::KEY_D,
        KEY_E            = adtf::IKeyEventHandler::KEY_E,
        KEY_F            = adtf::IKeyEventHandler::KEY_F,
        KEY_G            = adtf::IKeyEventHandler::KEY_G,
        KEY_H            = adtf::IKeyEventHandler::KEY_H,
        KEY_I            = adtf::IKeyEventHandler::KEY_I,
        KEY_J            = adtf::IKeyEventHandler::KEY_J,
        KEY_K            = adtf::IKeyEventHandler::KEY_K,
        KEY_L            = adtf::IKeyEventHandler::KEY_L,
        KEY_M            = adtf::IKeyEventHandler::KEY_M,
        KEY_N            = adtf::IKeyEventHandler::KEY_N,
        KEY_O            = adtf::IKeyEventHandler::KEY_O,
        KEY_P            = adtf::IKeyEventHandler::KEY_P,
        KEY_Q            = adtf::IKeyEventHandler::KEY_Q,
        KEY_R            = adtf::IKeyEventHandler::KEY_R,
        KEY_S            = adtf::IKeyEventHandler::KEY_S,
        KEY_T            = adtf::IKeyEventHandler::KEY_T,
        KEY_U            = adtf::IKeyEventHandler::KEY_U,
        KEY_V            = adtf::IKeyEventHandler::KEY_V,
        KEY_W            = adtf::IKeyEventHandler::KEY_W,
        KEY_X            = adtf::IKeyEventHandler::KEY_X,
        KEY_Y            = adtf::IKeyEventHandler::KEY_Y,
        KEY_Z            = adtf::IKeyEventHandler::KEY_Z,
 
        KEY_SHIFT        = adtf::IKeyEventHandler::KEY_SHIFT,
        KEY_CTRL         = adtf::IKeyEventHandler::KEY_CTRL,
        KEY_ALT          = adtf::IKeyEventHandler::KEY_ALT*/
    } tKey;
 
public:
    virtual tResult OnCreate(tHandle hCanvas, tInt nLeft, tInt nTop, tInt nRight, tInt nBottom) = 0;
 
    virtual tResult OnPaint(tHandle hCanvas, tInt nLeft, tInt nTop, tInt nRight, tInt nBottom) = 0;
 
    virtual tResult OnSize(tHandle hCanvas, tInt nLeft, tInt nTop, tInt nRight, tInt nBottom) = 0;
 
    virtual tResult OnIconify(tHandle hCanvas, tBool bIconified) = 0;
 
    virtual tResult OnTimer(tHandle hCanvas) = 0;
 
    virtual tResult OnIdle(tHandle hCanvas) = 0;
 
    virtual tResult OnDestroy() = 0;
 
    virtual tResult OnControlEvent(tControlEventCode eCode,
                                   tInt nParam1 = 0,
                                   tInt nParam2 = 0,
                                   tInt nFlags = 0,
                                   tVoid* pEventData = nullptr) = 0;
};
 
#define ADTF_VIEWPORT_INTERNAL_CLASS         "class"
#define ADTF_VIEWPORT_INTERNAL_TITLEWINDOW   "titlewindow"
#define ADTF_VIEWPORT_INTERNAL_PARENT_SETTER "parentset"
 
 
}
enum tCanvasFlags
{
 
        CANVAS_FLAG_TEXT_FLIP_HORIZONTALLY = 1,
 
        CANVAS_FLAG_TEXT_BASELINE_ON_TOP = 2,
 
        CANVAS_FLAG_TEXT_SCALE_WITH_COORDINATE_SYSTEM = 4,
 
        CANVAS_FLAG_TEXT_ROTATE_WITH_COORDINATE_SYSTEM = 8
};
 
using dengar::IGraphicsFlags;
using dengar::IFont;
using dengar::ITexture;
using dengar::ITexture;
using dengar::IGraphicsMode;
using dengar::IScene;
using dengar::ICanvas;
using dengar::IUIEventHandler;
 
}
 
}
 
}