GfxWrapNull.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 GFXWRAPNULL__H_
#define GFXWRAPNULL__H_
 
#include "GfxWrap.h"
 
#include "GUIImageLoader.h"
#include "GUIImageData.h"
 
 
class CGfxWrapNull : public CGfxWrap
{
public:
    static void CreateInstance()
    {
        if (!CGUIComponentManager::GetInstance().HasGfxWrap())
        {
            CGfxWrapNull* pkGfxWrap = new CGfxWrapNull();
            CGUIComponentManager::GetInstance().SetGfxWrap(pkGfxWrap);
        }
    }
 
    virtual eC_Bool Refresh(const RefreshCall_t eRefreshCallType)
    {
        return true;
    }
 
    virtual eC_UInt GetVirtualScreenWidth()
    {
        return m_uiScreenWidth;
    }
 
    virtual eC_UInt GetVirtualScreenHeight()
    {
        return m_uiScreenHeight;
    }
 
    virtual void SetCliprect(const CGUIRect &NewAbsClipRect)
    {
        CGfxWrap::SetCliprect(NewAbsClipRect);
    }
 
    virtual void SetForegroundColorImpl(
        const eC_UByte &ubRed,
        const eC_UByte &ubGreen,
        const eC_UByte &ubBlue,
        const eC_UByte &ubAlpha = 255)
    {
        m_uiColor = UINT_FROM_ARGB(ubAlpha, ubRed, ubGreen, ubBlue);
    }
 
    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& vWidth,
        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 BlitImgExtImpl(
        const ImageResource_t &eID,
        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 BlitImgExtImpl(const CGUIImageData& kImageData, const eC_Value& vAbsX, const eC_Value& vAbsY) {}
 
    virtual void LoadImgImpl(const eC_String& kPath, const ImageResource_t& eImageID)
    {
        eC_UInt uiCurImage = MAP_IMGID_TO_ARRAY(eImageID);
        m_pkImages[uiCurImage] = new CGUIImageData();
        m_pkImages[uiCurImage]->SetImageType(GetScreenFormat());
 
        // Loads an image to the current bound ID
        if (!GETIMGLOADER.LoadImg(*m_pkImages[uiCurImage], kPath)) // could not load image from file pointer
        {
            GUILOG(GUI_TRACE_ERROR, "CGfxWrapGL::LoadImgImpl: Problem loading the image from file:\nFilename: '" + kPath + "'.\n");
        }
    }
 
    virtual void LoadImgImpl(
        void* pkMemory,
        const eC_UInt& uiWidth,
        const eC_UInt& uiHeight,
        const eC_UInt& eImageType,
        const ImageResource_t& eImageID)
    {
        eC_UInt uiCurImage = MAP_IMGID_TO_ARRAY(eImageID);
        m_pkImages[uiCurImage] = new CGUIImageData();
        m_pkImages[uiCurImage]->SetImageType((CGUICommonEnums::ImageType_t)eImageType);
        m_pkImages[uiCurImage]->SetData((eC_UByte*)pkMemory);
        m_pkImages[uiCurImage]->SetWidth(uiWidth);
        m_pkImages[uiCurImage]->SetHeight(uiHeight);
        m_pkImages[uiCurImage]->SetMemoryType(CGUIImageData::MT_MANAGED_EXTERNAL);
    }
 
    virtual void UnloadImg(const ImageResource_t& eImageID)
    {
        // Get image ID
        eC_UInt uiCurImage = MAP_IMGID_TO_ARRAY(eImageID);
 
        // return if there is no matching image for the given image ID
        if (uiCurImage >= m_uiNOFImages || m_pkImages[uiCurImage] == NULL)
            return;
 
        delete m_pkImages[uiCurImage];
        m_pkImages[uiCurImage] = NULL;
    }
 
    virtual eC_Bool ImageExists(const ImageResource_t eID) const
    {
        eC_UInt uiCurImage = MAP_IMGID_TO_ARRAY(eID);
        if (uiCurImage >= m_uiNOFImages)
            return false;
 
        return m_pkImages[uiCurImage] != NULL;
    }
 
    virtual eC_UInt GetImgWidthImpl(const ImageResource_t &eImageID) const
    {
        //Map ImageIDs to 0-m_uiNOFImages
        eC_UInt uiCurImage = MAP_IMGID_TO_ARRAY(eImageID);
        if (uiCurImage >= m_uiNOFImages || m_pkImages[uiCurImage] == NULL)
            return 0;
        return m_pkImages[uiCurImage]->GetWidth();
    }
 
    virtual eC_UInt GetImgHeightImpl(const ImageResource_t &eImageID) const
    {
        //Map ImageIDs to 0-m_uiNOFImages
        eC_UInt uiCurImage = MAP_IMGID_TO_ARRAY(eImageID);
        if (uiCurImage >= m_uiNOFImages || m_pkImages[uiCurImage] == NULL)
            return 0;
        return m_pkImages[uiCurImage]->GetHeight();
    }
 
    virtual eC_UInt GetImageSize(const ImageResource_t& eID) const
    {
        eC_UInt uiCurImage = MAP_IMGID_TO_ARRAY(eID);
        if (uiCurImage >= m_uiNOFImages)
        {
            GUILOG(GUI_TRACE_ERROR, "CGfxWrapNULL::GetImageSize: Illegal image ID (" + eC_String(eID) + ") supplied.\n");
            return 0;
        }
 
        if (!ImageExists(eID))
            return 0;
 
        return m_pkImages[uiCurImage]->GetWidth() * m_pkImages[uiCurImage]->GetHeight() * m_pkImages[uiCurImage]->GetBytePerPixel();
    }
 
    virtual eC_UInt GetPhysicalScreenWidth()
    {
        return m_uiScreenWidth;
    }
 
    virtual eC_UInt GetPhysicalScreenHeight()
    {
        return m_uiScreenHeight;
    }
 
protected:
    virtual eC_Bool SetNOFImagesImpl(const eC_UInt uiNOFImages)
    {
        if (uiNOFImages > m_uiNOFImages)
        {
            eC_UInt uiNOFNewImages = uiNOFImages - m_uiNOFImages;
            m_uiNOFImages = uiNOFImages;
 
            // Resize internal array of images
            // ATTENTION: Resizing the Array only works with simple data types
            // such as pointers or the basic data types (int, float, char...)
            m_pkImages.SetQuantity(uiNOFImages, true);
 
            // initialize newly created images
            for (eC_UInt ui = 1; ui <= uiNOFNewImages; ui++)
            {
                m_pkImages[uiNOFImages - ui] = NULL;
            }
            return true;
        }
        return false;
    }
 
private:
    CGfxWrapNull()
    {
        GUILOG(GUI_TRACE_WARNING, "------------------------\n");
        GUILOG(GUI_TRACE_WARNING, "|  GfxWrapNull chosen  |\n");
        GUILOG(GUI_TRACE_WARNING, "------------------------\n");
 
        m_pkImages.SetQuantity(0, false);
 
        Init();
    }
 
    virtual ~CGfxWrapNull()
    {
        m_pkImages.SetQuantity(0, false);
    }
 
    void Init()
    {
        SetDoubleBufferingEnforcesFlipping(true);
        SetScreenFormat(CGUICommonEnums::ARGB_8888);
 
        m_pkImages.SetQuantity(m_uiNOFImages, false);
        for (eC_UInt i = 0; i < m_uiNOFImages; i++)
        {
            m_pkImages[i] = NULL;
        }
    }
 
    CGfxWrapNull(const CGfxWrapNull& kSource);
 
    CGfxWrapNull& operator=(const CGfxWrapNull& kSource);
 
private:
    eC_TArray<CGUIImageData*> m_pkImages;
};
#endif