GfxWrapVG.h

#ifndef GFXWRAPVG_H
#define GFXWRAPVG_H
 
#include "openvg.h"
#include "vgu.h"//utility-lib
 
#include <EGL/egl.h>
#include <vector>
#include "SVGShape.h"
 
#include "GfxWrap.h"
#include "GUIImageData.h"
#include "GUIImageLoader.h"
 
#ifdef GUILIANI_EGL13_COMPATIBILITY_WORKAROUND
#undef EGL_DEFAULT_DISPLAY
#define EGL_DEFAULT_DISPLAY     ((EGLNativeDisplayType)0)
typedef EGLNativeWindowType     NativeWindowType;
typedef EGLNativeDisplayType    NativeDisplayType;
#endif
class CGUIImageDataVG : public CGUIImageData
{
public:
    CGUIImageDataVG();
    ~CGUIImageDataVG();
    inline void SetImgHandle(const VGImage uiImgHandle)   {m_uiImageHandle = uiImgHandle;}
    inline VGImage GetImgHandle()                       const {return m_uiImageHandle;}
 
    std::vector<VGPath>  m_auiSvgPathHandles; 
    std::vector<VGPaint> m_auiSvgFillPaintHandles; 
    std::vector<VGPaint> m_auiSvgStrokePaintHandles; 
 
private:
    CGUIImageDataVG(const CGUIImageDataVG& kSource);
 
    CGUIImageData& operator=(const CGUIImageDataVG& kSource);
 
    VGImage         m_uiImageHandle;
};
 
class CGfxWrapVG : public CGfxWrap
{
    public:
 
    static eC_Bool CreateInstance(const NativeWindowType& hWindowType = 0,
                                  const NativeDisplayType& hDisplayType = EGL_DEFAULT_DISPLAY);
 
    virtual void CreateScreen(const eC_UInt &uiWidth, const eC_UInt &uiHeight);
    
    virtual void CreateScreen();
 
    virtual void SetCliprect(const CGUIRect& rkNewClipRect);
 
protected:
    CGfxWrapVG();
    CGfxWrapVG(const NativeWindowType& hWindowType,
                const NativeDisplayType& hDisplayType);
 
    virtual ~CGfxWrapVG();
 
    virtual eC_Bool Refresh(const RefreshCall_t eRefreshCallType);
 
    virtual eC_UInt GetVirtualScreenWidth();
    virtual eC_UInt GetVirtualScreenHeight();
 
    virtual eC_UInt GetPhysicalScreenWidth()    {return m_uiScreenWidth;}
    virtual eC_UInt GetPhysicalScreenHeight()   {return m_uiScreenHeight;}
 
    virtual void Line(
        const eC_Value &vAbsX1, const eC_Value &vAbsY1,
        const eC_Value &vAbsX2, const eC_Value &vAbsY2);
 
    virtual void Rect(
        const eC_Value &vAbsX1, const eC_Value &vAbsY1,
        const eC_Value &vAbsX2, const eC_Value &vAbsY2);
 
    virtual void FilledRect(
        const eC_Value &vAbsX1, const eC_Value &vAbsY1,
        const eC_Value &vAbsX2, const eC_Value &vAbsY2);
 
    virtual void Ellipse(
        const eC_Value &vAbsX1, const eC_Value &vAbsY1,
        const eC_Value &vAbsX2, const eC_Value &vAbsY2,
        const eC_Bool &bFilled);
 
    virtual void Arc(
        const eC_Value &vX1, const eC_Value &vY1,
        const eC_Value &vX2, const eC_Value &vY2,
        const eC_Value& vStartAngle, const eC_Value& vEndAngle,
        const eC_Value& vRotationAngle,
        const eC_Bool &bFilled);
 
    virtual void Ring(
        const eC_Value& vX1,
        const eC_Value& vY1,
        const eC_Value& vX2,
        const eC_Value& vY2,
        const eC_Value& vRingWidth,
        const eC_Value& vStartAngle,
        const eC_Value& vEndAngle,
        const eC_Value& vRotationAngle,
        const eC_Bool & bFilled);
 
    virtual eC_Value SetLineWidth(const eC_Value& vWidth);
 
    virtual eC_Bool ImageExists(ImageResource_t eID) const;
    virtual eC_Bool SetNOFImagesImpl(const eC_UInt uiNOFImages);
    virtual void LoadImgImpl(const eC_String& kPath, const ImageResource_t& eImageID);
    
    virtual void LoadImgImpl(
        void* pkMemory,
        const eC_UInt& uiWidth,
        const eC_UInt& uiHeight,
        const CGUICommonEnums::ImageType_t& eImageType,
        const ImageResource_t &eID);
        
    virtual void UnloadImg(const ImageResource_t &eImageID);
    virtual eC_UInt GetImageSize(const ImageResource_t& eImageID) const;
    virtual eC_UInt GetImgWidthImpl(const ImageResource_t& eImageID) const;
    virtual eC_UInt GetImgHeightImpl(const ImageResource_t& eImageID) const;
 
    virtual void BlitImgExtImpl(const ImageResource_t&,
        const eC_UInt &uiAbsSrcX, const eC_UInt &uiAbsSrcY,
        const eC_UInt &uiSrcWidth, const eC_UInt &uiSrcHeight,
        const eC_Value &vAbsDestX, const eC_Value &vAbsDestY,
        const eC_Value &vDestWidth, const eC_Value &vDestHeight,
        const eC_UByte &ubAlpha = 255,
        const eC_Value &vAngle = eC_FromFloat(0),
        const eC_Value &vRotCenterX = eC_FromFloat(0.5), const eC_Value &vRotCenterY = eC_FromFloat(0.5));
 
    virtual void SetForegroundColorImpl(
        const eC_UByte &ubRed,
        const eC_UByte &ubGreen,
        const eC_UByte &ubBlue,
        const eC_UByte &ubAlpha = 255);
 
    eC_Bool CheckVGError(const eC_String &kCallingMethod);
 
    eC_Bool CheckEGLError(const eC_String &kCallingMethod);
 
    void CreateSVGImage(const eC_UInt& uiCurImage);
 
    void CreateBitmapImage(const eC_UInt& uiCurImage);
 
    void RenderSVG(const eC_UInt& uiCurImage);
 
    void GetPathFromShape(const CSVGShape& kShape, VGPath& uiPathHandle);
 
    void GetPaintFromShape(CSVGShape& kShape, VGPaint& uiPaintHandle, eC_Bool bIsStroke);
 
    void ConstructGradient(CGradient& kGradient, VGPaint& uiPaintHandle);
 
    virtual eC_Bool Init(void);
 
    virtual eC_Bool DeInit(void);
 
    NativeDisplayType m_hDisplayType;
 
    NativeWindowType m_hWindowType;
 
    EGLDisplay m_display; 
    EGLSurface m_windowSurface; 
 
    EGLConfig m_screenConfig; 
    EGLContext m_screenContext; 
 
    EGLConfig m_offScreenConfig; 
    EGLContext m_offScreenContext; 
 
    eC_TArray<CGUIImageDataVG*> m_pkImages; 
    
private:
    eC_Value m_vRed;        
    eC_Value m_vGreen;      
    eC_Value m_vBlue;       
    eC_Value m_vAlpha;      
 
    VGPaint m_strokePaint;  
    VGPaint m_fillPaint;    
 
    VGPath m_uiPrimStrokeHandle; 
    VGPath m_uiPrimFillHandle;  
};
 
#endif // GFXWRAPVG_H