GfxWrapeGML.h

/*
* Copyright (C) TES Electronic Solutions GmbH,
* All Rights Reserved.
* Contact: info@guiliani.de
*
* This file is part of the Guiliani HMI framework
* for the development of graphical user interfaces on embedded systems.
*/
 
#ifndef GFXWRAPEGML__H_
#define GFXWRAPEGML__H_
 
#include "GfxWrap.h"
#include "eGML_Config.h"
#include "eGML_Platform.h"
#include "eGML_Bitmap.h"
 
class eGML;
class eImg_Bitmap;
class eGML_Screen;
class eGML_Bitmap;
class CDCWrap;
 
 
class CGfxWrapeGML : public CGfxWrap
{
public:
    static eC_Bool CreateInstance(CGfxEnv* pkGfxEnv);
 
    virtual eC_Value SetLineWidth(const eC_Value& vWidth);
 
    virtual eC_Bool Refresh(const RefreshCall_t eRefreshCallType);
 
    virtual void CreateScreen();
 
    virtual void DestroyScreen();
 
    eGML_Screen* GetScreen(void);
 
    eGML_Bitmap* GetRenderBitmap();
 
    void SetRenderBitmap(eGML_Bitmap* pRenderBitmap);
 
    void SetTargetLayer(const eC_UInt& uiLayerID);
 
    virtual eC_UInt GetVirtualScreenWidth();
    virtual eC_UInt GetVirtualScreenHeight();
    virtual eC_UInt GetPhysicalScreenWidth();
    virtual eC_UInt GetPhysicalScreenHeight();
 
    virtual void SetForegroundColorImpl(
        const eC_UByte &ubRed,
        const eC_UByte &ubGreen,
        const eC_UByte &ubBlue,
        const eC_UByte &ubAlpha = 255);
 
    virtual void Line(const eC_Value& vX1, const eC_Value& vY1, const eC_Value& vX2, const eC_Value& vY2);
 
    virtual void Rect(const eC_Value& vX1, const eC_Value& vY1, const eC_Value& vX2, const eC_Value& vY2);
 
    virtual void FilledRect(const eC_Value& vX1, const eC_Value& vY1, const eC_Value& vX2, const eC_Value& vY2);
 
    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 void Polygon(
        eC_Value* pvPoints,
        const eC_UInt& uiCount,
        const eC_Bool& bFilled);
 
    virtual void SetCliprect(const CGUIRect &NewAbsClipRect);
 
    virtual eImg_Bitmap* GetImage(const ImageResource_t &eID);
 
    virtual eC_Bool ImageExists(const ImageResource_t eID) const;
 
    void SetSubpixelEnabled(const eC_Bool bEnabled);
 
    void SetBlitFlags(eC_Flag uiFlags);
 
    eC_Flag GetBlitFlags() const;
 
    virtual void SetOptimizedBlit(const eC_Bool& bOptimizedBlit);
 
    virtual void SetFilteredBlit(const eC_Bool& bFilteredBlit);
 
    virtual eC_Bool DrawToScreen();
 
protected:
    virtual eC_Bool SetNOFImagesImpl(const eC_UInt uiNOFImages);
 
    virtual void LoadImgImpl(const eC_String &psPath, const ImageResource_t &eID);
 
    virtual void LoadImgImpl(
        void* pkMemory,
        const eC_UInt& uiWidth,
        const eC_UInt& uiHeight,
        const eC_UInt& eImageType,
        const ImageResource_t &eID);
 
    virtual void UnloadImg(const ImageResource_t &eID);
 
    virtual void BlitImgExtImpl(
        const ImageResource_t &eID,
        const eC_UInt &uiSrcX, const eC_UInt &uiSrcY,
        const eC_UInt &uiSrcWidth, const eC_UInt &uiSrcHeight,
        const eC_Value& vDestX, const eC_Value& vDestY,
        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 BlitImgExtImpl(const CGUIImageData& kImageData, const eC_Value& vAbsDestX, const eC_Value& vAbsDestY);
 
    virtual eC_UInt GetImgWidthImpl(const ImageResource_t &eID) const;
    virtual eC_UInt GetImgHeightImpl(const ImageResource_t &eID) const;
 
    virtual eC_UInt GetImageSize(const ImageResource_t& eID) const;
 
    void SetDefault2DView();
 
    virtual void InitMainLayer();
 
    CGfxWrapeGML(CGfxEnv* pkGfxEnv);
 
    virtual ~CGfxWrapeGML(void);
 
protected:
    typedef struct
    {
        eC_UInt uiID;           
        eC_UInt uiScreenCount;  
        eGML_Screen* pkScreen;  
    } ScreenConfig_t;
 
    eGML* m_pkEGML; 
    eGML_Bitmap* m_pkRenderBitmap;  
    ScreenConfig_t* m_pkScreens; 
 
    eC_UInt m_uiNumberOfScreens; 
    eC_Int m_iMainLayerIndex; 
 
    eC_Bool m_bSubpixelEnabled;
 
    eC_TArray <eImg_Bitmap*> m_pImage;
 
    eC_Flag m_uiBlitFlags;  
 
private:
    class CModifyableBitmap : public eGML_Bitmap
    {
    public:
        CModifyableBitmap(eC_UInt uiWidth, eC_UInt uiHeight, eC_UByte ubBitmapBufferType) :
            eGML_Bitmap(uiWidth, uiHeight, ubBitmapBufferType)
        {
        }
 
        ~CModifyableBitmap()
        {
        }
 
        void SetNewBitmapData(eC_UInt eFormat, eC_UInt uiWidth, eC_UInt uiHeight, eC_UByte ubBitmapBufferType, void *pBitmapBuffer)
        {
            m_uiType = eFormat;
            m_uiWidth = uiWidth;
            m_uiHeight = uiHeight;
            m_ubBBT = ubBitmapBufferType;
            m_pkData = pBitmapBuffer;
 
            // pitch depends on bitmap format
            switch (eFormat)
            {
                case eGML::BM_ALPHA1:
                    m_uiPitch = (uiWidth + 7) & ~0x07;
                    break;
                case eGML::BM_ALPHA8:
                    m_uiPitch = uiWidth;
                    break;
                case eGML::BM_RGB565:
                case eGML::BM_RGB555:
                    m_uiPitch = uiWidth * 2;
                    break;
                case eGML::BM_RGB32:
                case eGML::BM_ARGB32:
                    m_uiPitch = uiWidth * 4;
                    break;
                default:
                    GUILOG(GUI_TRACE_ERROR, "Unknown bitmap format. Failed to determine pitch.\n");
                    break;
            }
        }
 
        virtual void * Lock()
        {
            // Dummy implementation of pure-virtual function in base-class
            return NULL;
        }
 
        virtual void Unlock(eC_UInt uiX1 = 0, eC_UInt uiY1 = 0, eC_UInt uiX2 = 0, eC_UInt uiY2 = 0)
        {
            // Dummy implementation of pure-virtual function in base-class
        }
 
        virtual void DrawLine(const eGML_Vector2 &kStart, const eGML_Vector2 &kEnd, eGML_Color kColor, eC_Flag ulFlags, eC_Value vStartWidth, eC_Value vEndWidth = 0)
        {
            // Dummy implementation of pure-virtual function in base-class
        }
 
        virtual void DrawPolygon(const eGML_Coord2D *pkVertices, eC_UInt uiCount, eGML_Color kColor, eC_Flag ulFlags)
        {
            // Dummy implementation of pure-virtual function in base-class
        }
 
        virtual void Clear(eGML_Color clColor)
        {
            // Dummy implementation of pure-virtual function in base-class
        }
 
        virtual void FillRect(eC_UInt uiWidth, eC_UInt uiHeight, eC_Int iX1, eC_Int iY1, eGML_Color clColor, eC_Flag ulFlags = 0)
        {
            // Dummy implementation of pure-virtual function in base-class
        }
    };
 
private:
    virtual CGUIBitmapPlane* CreateGfxDependentBitmap(
        GUIBitmapPlaneID_t uiNewBitmapID,
        const CGUIObject& rkParentObject,
        const eC_Value& vWidth,
        const eC_Value& vHeight);
 
    eC_Bool Init(void);
    eC_Bool DeInit(void);
 
    eC_UInt GetBitmapFormat(const CGUICommonEnums::ImageType_t& ePixFormat) const;
 
    void CreateScreen(
        const eC_UInt& uiIndex, const eC_UInt& uiLayerID,
        const eC_Enum& eBitmapFormat,
        const eC_UInt& uiWidth, const eC_UInt& uiHeight,
        const eC_UInt& ubBufferCount,
        void** pkBuffers);
 
    void MergeLayer(const eC_UInt& uiScreenIndex);
 
    CGfxWrapeGML(const CGfxWrapeGML& kSource);
 
    CGfxWrapeGML& operator=(const CGfxWrapeGML& kSource);
 
private:
    CModifyableBitmap* m_pkModifyableGlyphBitmap;
};
 
#endif