GfxWrapDave.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 GFXWRAPDAVE__H_
#define GFXWRAPDAVE__H_
 
#include "GfxWrap.h"
 
#include "DAVETypes.h"
#include "DAVEScreen.h"
 
#include "GUIImageLoader.h"
#include "GUIImageDataDAVE.h"
 
#include "GUILayerConfig.h"
 
// Dave driver
#include "dave_base.h"
#include "dave_driver.h"
 
// If BSP supports TES own Device driver, then use it
 
 
 
class CGfxWrapDAVE : public CGfxWrap
{
public:
    static eC_Bool CreateInstance(
        CGfxEnv* pkGfxEnv,
        const eC_UInt& uiWorkingMemorySize = 64000);
 
    virtual void CreateScreen();
 
    virtual void DestroyScreen();
 
    virtual eC_Bool Refresh(const RefreshCall_t eRefreshCallType);
 
    virtual void SetForegroundColorImpl(const eC_UByte &ubRed, const eC_UByte &ubGreen, const eC_UByte &ubBlue, const eC_UByte &ubAlpha = 255);
    virtual eC_Value SetLineWidth(const eC_Value& vWidth);
    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& vX1, const eC_Value& vY1,
        const eC_Value& vX2, const eC_Value& vY2,
        const eC_Bool &bFilled = true);
 
    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 &NewClipRect);
 
    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 {return 0;}
 
    virtual void RefreshImage(const ImageResource_t& eID, void* pkMemory);
 
    void SetAlpha(eC_UByte ubAlpha);
 
    void CheckDAVEError();
 
    virtual eC_Bool DrawToBitmap(GUIBitmapPlaneID_t uiBitmapID);
    virtual eC_Bool DrawToScreen();
 
    virtual void SetTargetLayer(const eC_UInt& uiLayerID);
 
    d2_device* GetDaveDevice();
 
    virtual eC_UInt GetVirtualScreenWidth();
    virtual eC_UInt GetVirtualScreenHeight();
 
    virtual eC_UInt GetPhysicalScreenWidth();
    virtual eC_UInt GetPhysicalScreenHeight();
 
    static eC_UInt GetD1PixelFormat(const CGUICommonEnums::ImageType_t& ePixFormat);
 
    static eC_UInt GetD2PixelFormat(const CGUICommonEnums::ImageType_t& ePixFormat);
 
    virtual eC_Bool SupportCompressedFonts() const { return true; }
 
    virtual void LoadGlyphData(
        CGUIImageData* pkImageData,
        const eC_UInt& uiGlyphWidth,
        const eC_UInt& uiGlyphHeight,
        eC_UByte* pkGlyphBitmap);
 
    virtual void UnloadGlyphData(CGUIImageData* pkImageData);
 
protected:
    void InitScreens();
 
    void StartRenderBuffer();
 
    void EndRenderBuffer();
 
    virtual void LoadImgImpl(const eC_String& kPath, 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 eC_Bool LoadImgRAW(eC_File* pkImageFile, CGUIImageDataDAVE& kImageData);
 
    virtual eC_Bool LoadImgRLE(eC_File* pkImageFile, CGUIImageDataDAVE& kImageData);
 
    virtual eC_Bool LoadImgDecoder(const eC_String& kPath, const eC_UInt& uiImageIndex);
 
    virtual void UnloadImg(const ImageResource_t &eID);
 
    virtual eC_Bool ImageExists(const ImageResource_t eID) const;
 
    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_Bool SetNOFImagesImpl(const eC_UInt uiNOFImages);
 
    CGfxWrapDAVE(CGfxEnv* pkGfxEnv, const eC_UInt& uiWorkingMemorySize);
 
    virtual ~CGfxWrapDAVE(void);
 
protected:
    typedef struct
    {
        eC_UInt uiID; 
        CDAVEScreen* pScreen; 
    } ScreenConfig_t;
 
protected:
    ScreenConfig_t* m_pkScreens;
 
    eC_UInt m_uiNumberOfScreens;
 
    eC_Int  m_iD1Mode;
    eC_Int  m_iD2Mode;
    d2_device* m_pkD2Handle;
    d1_device* m_pkD1Handle;
 
    d2_context *m_pkD2Context;
    eC_TArray<CGUIImageDataDAVE*> m_pkImages;
 
    eC_Bool m_bSeperatedMemory;
 
    dc_handle m_dc_handle;
 
    eC_Bool m_bFrameStarted;
    d2_renderbuffer* m_pkRenderBuffer;
};
#endif