gcl.h

Go to the documentation of this file.

#pragma once
#include <adtf_base.h>
#include <adtfdisplaytoolboxgraphics/glcanvas.h>
#include <adtfdisplaytoolboxgraphics/rect.h>
#include <adtfdisplaytoolboxgraphics/gcltypes.h>
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{
 
namespace dengar
{

class IGCLProcessorEvents
{
public:
    enum tGCLProcessorEventIds
    {
        GCLPE_Clear = 0
    };

    struct tGCLProcessEvent
    {
        tUInt32 nEventId;
        tInt32 i32Param1;
        tInt32 i32Param2;
        tVoid* pvData;
        tSize szDataLength;
    };
};
 
//*************************************************************************************************
 
namespace detail
{
//*************************************************************************************************
constexpr tInt g_nGCL_ItemSize = sizeof(tUInt32);
constexpr tInt g_nGCL_CommandSize = g_nGCL_ItemSize;
constexpr tInt g_nGCL_ParamSize = g_nGCL_ItemSize;
constexpr tInt g_nGCL_ExtraSize = g_nGCL_ItemSize;
 
#define GCL_SIZE(nParams, nExtra) (1 + (nParams) + (nExtra))
#define GCL_SIZE_DYNAMIC()        (0)
 
//*************************************************************************************************
constexpr tGCLCommandDescriptor g_aGCLCommandTable[] = {
    {GCL_CMD_END, GCL_SIZE(0, 0), "end"},
    {GCL_CMD_INT, GCL_SIZE(0, 0), "int"},
    {GCL_CMD_FLOAT, GCL_SIZE(0, 0), "float"},
    {GCL_CMD_CLEAR, GCL_SIZE(0, 0), "clear"},
    {GCL_CMD_FGCOL, GCL_SIZE(1, 0), "fgcol"},
    {GCL_CMD_BGCOL, GCL_SIZE(1, 0), "bgcol"},
    {GCL_CMD_MOVETO, GCL_SIZE(2, 0), "moveto"},
    {GCL_CMD_DRAWPIXEL, GCL_SIZE(2, 0), "drawpixel"},
    {GCL_CMD_DRAWLINE, GCL_SIZE(4, 0), "drawline"},
    {GCL_CMD_LINETO, GCL_SIZE(2, 0), "lineto"},
    {GCL_CMD_DRAWRECT, GCL_SIZE(4, 0), "drawrect"},
    {GCL_CMD_FILLRECT, GCL_SIZE(4, 0), "fillrect"},
    {GCL_CMD_TEXT, GCL_SIZE_DYNAMIC(), "text"},
    {GCL_CMD_LINEWIDTH, GCL_SIZE(1, 0), "linewidth"},
    {GCL_CMD_DRAWCIRCLE, GCL_SIZE(3, 0), "drawcircle"},
    {GCL_CMD_FILLCIRCLE, GCL_SIZE(3, 0), "fillcircle"},
    {GCL_CMD_LINEPATTERN, GCL_SIZE(2, 0), "linepattern"},
    {GCL_CMD_ALPHA, GCL_SIZE(1, 0), "alpha"},
    {GCL_CMD_DRAWPOLYGON, GCL_SIZE_DYNAMIC(), "drawpolygon"},
    {GCL_CMD_FILLPOLYGON, GCL_SIZE_DYNAMIC(), "fillpolygon"},
    {GCL_CMD_TEXT_SIZE_SMALL, GCL_SIZE(0, 0), "textsizesmall"},
    {GCL_CMD_TEXT_SIZE_NORMAL, GCL_SIZE(0, 0), "textsizenormal"},
    {GCL_CMD_TEXT_SIZE_HUGE, GCL_SIZE(0, 0), "textsizehuge"},
};
} // namespace detail

class cGCLProcessor : public ucom::catwo::object<ucom::IEventSource, ucom::cEventSource>
{
    A_UTILS_D(cGCLProcessor)
 
protected:
    ICanvas* m_pCanvas; 
    tHandle m_hCanvas; 
    tBool m_bInitialized; 
 
    tInt m_nCurrentX; 
    tInt m_nCurrentY; 
    tBool m_bFormatFloat; 
 
    tFloat32 m_fScaleX; 
    tFloat32 m_fScaleY; 
 
    tBool m_bFlipRGB; 
 
    IFont* m_pSmallFont; 
    IFont* m_pNormalFont; 
    IFont* m_pHugeFont; 
 
public:
    cGCLProcessor()
    {
        m_pCanvas = NULL;
        m_hCanvas = NULL;
        m_bInitialized = tFalse;
        m_nCurrentX = 0;
        m_nCurrentY = 0;
        m_bFormatFloat = tFalse;
        m_fScaleX = 1.0f;
        m_fScaleY = 1.0f;
        m_bFlipRGB = tFalse;
        m_pSmallFont = NULL;
        m_pNormalFont = NULL;
        m_pHugeFont = NULL;
    }

    virtual ~cGCLProcessor()
    {
    }

    tResult Create()
    {
        RETURN_NOERROR;
    }

    tResult Release()
    {
        m_bInitialized = tFalse;
        RETURN_NOERROR;
    }

    tResult Process(ICanvas* pCanvas,
                    tVoid* pCommandBlock,
                    tInt nBlockSize,
                    tUInt nOrigWidth,
                    tUInt nOrigHeight,
                    cRect sTargetRect,
                    tBool bFlipRGB = tFalse)
    {
        RETURN_IF_POINTER_NULL(pCanvas);
        RETURN_IF_POINTER_NULL(pCommandBlock);
 
        m_pCanvas = pCanvas;
        m_bFlipRGB = bFlipRGB;
        return ProcessBlock(pCommandBlock, nBlockSize, nOrigWidth, nOrigHeight, sTargetRect);
    }

    tResult Process(tHandle hCanvas,
                    tVoid* pCommandBlock,
                    tInt nBlockSize,
                    tUInt nOrigWidth,
                    tUInt nOrigHeight,
                    cRect sTargetRect,
                    tBool bFlipRGB = tFalse)
    {
        RETURN_IF_POINTER_NULL(hCanvas);
        RETURN_IF_POINTER_NULL(pCommandBlock);
 
        m_hCanvas = hCanvas;
        m_bFlipRGB = bFlipRGB;
 
#ifdef WIN32
        static HPEN hPen = NULL;
 
        if (!m_bInitialized)
        {
            m_bInitialized = tTrue;
 
            hPen = CreatePen(PS_SOLID, 0, RGB(255, 0, 0));
        }
 
        HPEN hOldPen = nullptr;
        if (hPen)
        {
            hOldPen = (HPEN) SelectObject((HDC) m_hCanvas, hPen);
        }
#endif // WIN32
 
        tResult nResult = ProcessBlock(pCommandBlock, nBlockSize, nOrigWidth, nOrigHeight, sTargetRect);
 
#ifdef WIN32
        if (hOldPen)
        {
            SelectObject((HDC) m_hCanvas, hOldPen);
        }
#endif // WIN32
 
        return nResult;
    }

    tResult SetFonts(IFont* pSmallFont, IFont* pNormalFont, IFont* pHugeFont)
    {
        RETURN_IF_POINTER_NULL(pSmallFont);
        RETURN_IF_POINTER_NULL(pNormalFont);
        RETURN_IF_POINTER_NULL(pHugeFont);
 
        m_pSmallFont = pSmallFont;
        m_pNormalFont = pNormalFont;
        m_pHugeFont = pHugeFont;
        RETURN_NOERROR;
    }
 
protected:
    tResult ProcessBlock(tVoid* pCommandBlock, tInt nBlockSize, tUInt nOrigWidth, tUInt nOrigHeight, cRect sTargetRect)
    {
        RETURN_IF_POINTER_NULL(pCommandBlock);
        RETURN_IF_POINTER_NULL(m_pCanvas);
 
        tUInt32* pData = (tUInt32*) pCommandBlock;
        tUInt32* pEndOfData = pData + (nBlockSize / detail::g_nGCL_ItemSize - 1);
 
        tUInt32 nIdentifier;
        tUInt32 nMaxIdentifier = sizeof(detail::g_aGCLCommandTable) / sizeof(detail::g_aGCLCommandTable[0]);
 
        CalcScale(nOrigWidth, nOrigHeight, sTargetRect);
 
        tInt nJump;
 
        while (pData < pEndOfData)
        {
            nIdentifier = *pData;
            if (nIdentifier == GCL_CMD_END)
            {
                break;
            }
            else if (nIdentifier >= nMaxIdentifier)
            {
                RETURN_ERROR(ERR_INVALID_ARG);
            }
 
            const tGCLCommandDescriptor* pCmd = &detail::g_aGCLCommandTable[nIdentifier];
            tBool bFormatFloat = m_bFormatFloat;
 
            RETURN_IF_FAILED(ProcessCommand(pCmd, pData + 1, nJump, sTargetRect));
 
            // if this flag has changed, the scaling must be recalculated
            if (m_bFormatFloat != bFormatFloat)
            {
                CalcScale(nOrigWidth, nOrigHeight, sTargetRect);
            }
 
            if (nJump == 0)
            {
                pData += pCmd->nSize; // DWORD-aligned jumps!!
            }
            else
            {
                pData += nJump;
            }
        }
 
        m_pCanvas = NULL;
 
        RETURN_NOERROR;
    }

    tResult ProcessCommand(const tGCLCommandDescriptor* pCmd, tUInt32* pParam, tInt& nJump, cRect sTargetRect)
    {
        nJump = 0;
        ICanvas* pCanvas = m_pCanvas; // is already checked in ProcessBlock
 
        tFloat32* pFloatParam = (tFloat32*) pParam;
        tInt32* pCoordParam = (tInt32*) pParam;
 
        switch (pCmd->nId)
        {
            case GCL_CMD_END:
            {
                break;
            }
 
            case GCL_CMD_INT:
            {
                m_bFormatFloat = tFalse;
                break;
            }
 
            case GCL_CMD_FLOAT:
            {
                m_bFormatFloat = tTrue;
                break;
            }
 
            case GCL_CMD_TEXT_SIZE_SMALL:
            {
                pCanvas->Font(m_pSmallFont);
                break;
            }
            case GCL_CMD_TEXT_SIZE_NORMAL:
            {
                pCanvas->Font(m_pNormalFont);
                break;
            }
            case GCL_CMD_TEXT_SIZE_HUGE:
            {
                pCanvas->Font(m_pHugeFont);
                break;
            }
 
            case GCL_CMD_CLEAR:
            {
                pCanvas->Clear();
 
                IGCLProcessorEvents::tGCLProcessEvent sEvent;
                sEvent.nEventId = IGCLProcessorEvents::GCLPE_Clear;
                sEvent.i32Param1 = 0;
                sEvent.i32Param2 = 0;
                sEvent.pvData = pCanvas;
                sEvent.szDataLength = 0;
                FireEvent(&sEvent);
                break;
            }
 
            case GCL_CMD_FGCOL:
            {
                if (m_bFlipRGB)
                {
                    pCanvas->Color(((tUInt8*) (pParam))[2], ((tUInt8*) (pParam))[1], ((tUInt8*) (pParam))[0],
                                   ((tUInt8*) (pParam))[3]);
                }
                else
                {
                    pCanvas->Color(((tUInt8*) (pParam))[0], ((tUInt8*) (pParam))[1], ((tUInt8*) (pParam))[2],
                                   ((tUInt8*) (pParam))[3]);
                }
                break;
            }
 
            case GCL_CMD_BGCOL:
            {
                if (m_bFlipRGB)
                {
                    pCanvas->BgColor(((tUInt8*) (pParam))[2], ((tUInt8*) (pParam))[1], ((tUInt8*) (pParam))[0],
                                     ((tUInt8*) (pParam))[3]);
                }
                else
                {
                    pCanvas->BgColor(((tUInt8*) (pParam))[0], ((tUInt8*) (pParam))[1], ((tUInt8*) (pParam))[2],
                                     ((tUInt8*) (pParam))[3]);
                }
                break;
            }
 
            case GCL_CMD_ALPHA:
            {
                if (pParam[0] != 0)
                {
                    pCanvas->EnableAlpha();
                }
                else
                {
                    pCanvas->DisableAlpha();
                }
                break;
            }
 
            case GCL_CMD_MOVETO:
            {
                GetCoords(pParam, sTargetRect, m_nCurrentX, m_nCurrentY);
                break;
            }
 
            case GCL_CMD_LINETO:
            {
                tInt nParamX = 0, nParamY = 0;
                GetCoords(pParam, sTargetRect, nParamX, nParamY);
 
                pCanvas->DrawLine(m_nCurrentX, m_nCurrentY, nParamX, nParamY);
 
                m_nCurrentX = nParamX;
                m_nCurrentY = nParamY;
                break;
            }
 
            case GCL_CMD_DRAWPIXEL:
            {
                GetCoords(pParam, sTargetRect, m_nCurrentX, m_nCurrentY);
                pCanvas->DrawPixel(m_nCurrentX, m_nCurrentY);
                break;
            }
 
            case GCL_CMD_DRAWLINE:
            {
                tInt nParamX = 0, nParamY = 0;
                GetCoords(pParam, sTargetRect, nParamX, nParamY);
                GetCoords(pParam + 2, sTargetRect, m_nCurrentX, m_nCurrentY);
                pCanvas->DrawLine(nParamX, nParamY, m_nCurrentX, m_nCurrentY);
                break;
            }
 
            case GCL_CMD_DRAWRECT:
            {
                tInt nParamX = 0, nParamY = 0;
                GetCoords(pParam, sTargetRect, nParamX, nParamY);
                GetCoords(pParam + 2, sTargetRect, m_nCurrentX, m_nCurrentY);
                pCanvas->DrawRect(nParamX, nParamY, m_nCurrentX, m_nCurrentY);
                break;
            }
 
            case GCL_CMD_FILLRECT:
            {
                tInt nParamX = 0, nParamY = 0;
                GetCoords(pParam, sTargetRect, nParamX, nParamY);
                GetCoords(pParam + 2, sTargetRect, m_nCurrentX, m_nCurrentY);
                pCanvas->FillRect(nParamX, nParamY, m_nCurrentX, m_nCurrentY);
                break;
            }
 
            case GCL_CMD_TEXT:
            {
                GetCoords(pParam, sTargetRect, m_nCurrentX, m_nCurrentY);
 
                tUInt32 nTextLength = pParam[2];
 
                nJump = 4 + (nTextLength + detail::g_nGCL_ItemSize - 1) / detail::g_nGCL_ItemSize;
                tChar* strText = (tChar*) (pParam + 3);
 
                tChar* pBuffer = new tChar[nTextLength + 1];
                if (pBuffer == NULL)
                {
                    RETURN_ERROR(ERR_MEMORY);
                }
 
                adtf_util::cMemoryBlock::MemCopy(pBuffer, strText, nTextLength);
                *(pBuffer + nTextLength) = '\0';
 
                pCanvas->OutputText(m_nCurrentX, m_nCurrentY, pBuffer);
 
                delete[] pBuffer;
                break;
            }
 
            case GCL_CMD_LINEWIDTH:
            {
                tUInt32 nLineWidth = pParam[0];
                pCanvas->LineWidth(nLineWidth);
                break;
            }
 
            case GCL_CMD_LINEPATTERN:
            {
                tUInt16 nLinePattern = (tUInt16) pParam[0];
                tInt nFactor = pParam[1];
                pCanvas->LinePattern(nLinePattern, nFactor);
                break;
            }
 
            case GCL_CMD_DRAWCIRCLE:
            {
                tInt32 nRadiusX = 0;
                tInt32 nRadiusY = 0;
 
                GetCoords(pParam, sTargetRect, m_nCurrentX, m_nCurrentY);
 
                if (m_bFormatFloat)
                {
                    nRadiusY = nRadiusX = (tInt) ((pFloatParam[2] * m_fScaleX) + 0.5);
                }
                else
                {
                    nRadiusY = nRadiusX = (tInt) ((pCoordParam[2] * m_fScaleX) + 0.5);
                }
 
                // this makes the parameter the diameter and not the radius.
                pCanvas->DrawCircle((tInt) (m_nCurrentX - nRadiusX / 2), m_nCurrentY - nRadiusY / 2,
                                    m_nCurrentX + nRadiusX / 2, m_nCurrentY + nRadiusY / 2);
                break;
            }
 
            case GCL_CMD_FILLCIRCLE:
            {
                tInt32 nRadiusX = 0;
                tInt32 nRadiusY = 0;
 
                GetCoords(pParam, sTargetRect, m_nCurrentX, m_nCurrentY);
 
                if (m_bFormatFloat)
                {
                    nRadiusY = nRadiusX = (tInt) ((pFloatParam[2] * m_fScaleX) + 0.5);
                }
                else
                {
                    nRadiusY = nRadiusX = (tInt) ((pCoordParam[2] * m_fScaleX) + 0.5);
                }
                // this makes the parameter the diameter and not the radius.
                pCanvas->FillCircle((tInt) (m_nCurrentX - nRadiusX / 2), m_nCurrentY - nRadiusY / 2,
                                    m_nCurrentX + nRadiusX / 2, m_nCurrentY + nRadiusY / 2);
                break;
            }
 
            case GCL_CMD_DRAWPOLYGON:
            {
                tInt nParamCount = *pParam++;
                if (nParamCount == 0 || ((nParamCount & 1) == 1))
                {
                    RETURN_ERROR(ERR_INVALID_ARG);
                }
                nParamCount /= 2;
 
                GetCoords(pParam, sTargetRect, m_nCurrentX, m_nCurrentY);
                pParam += 2;
                tInt nStartX = m_nCurrentX;
                tInt nStartY = m_nCurrentY;
 
                for (tInt i = 1; i < nParamCount; i++)
                {
                    tInt nParamX = 0, nParamY = 0;
                    GetCoords(pParam, sTargetRect, nParamX, nParamY);
                    pCanvas->DrawLine(m_nCurrentX, m_nCurrentY, nParamX, nParamY);
                    m_nCurrentX = nParamX;
                    m_nCurrentY = nParamY;
                    pParam += 2;
                }
 
                pCanvas->DrawLine(m_nCurrentX, m_nCurrentY, nStartX, nStartY);
                nJump += nParamCount * 2 + 2;
                break;
            }
 
            case GCL_CMD_FILLPOLYGON:
            {
                tInt nParamCount = *pParam++;
                if (nParamCount == 0 || ((nParamCount & 1) == 1))
                {
                    RETURN_ERROR(ERR_INVALID_ARG);
                }
                nParamCount /= 2;
 
                std::vector<IPoint*> vPoints;
 
                for (tInt i = 0; i < nParamCount; i++)
                {
                    GetCoords(pParam, sTargetRect, m_nCurrentX, m_nCurrentY);
                    vPoints.push_back((IPoint*) new cPoint(m_nCurrentX, m_nCurrentY));
                    pParam += 2;
                }
 
                pCanvas->FillPolygon(&vPoints.at(0), static_cast<tInt>(vPoints.size()));
 
                for (tUInt i = 0; i < vPoints.size(); i++)
                {
                    vPoints[i]->Release();
                }
                nJump += nParamCount * 2 + 2;
                break;
            }
 
            default:
            {
                break;
            }
        }
 
        RETURN_NOERROR;
    }

    tResult CalcScale(tUInt nOrigWidth, tUInt nOrigHeight, const cRect& sTargetRect)
    {
        if (m_bFormatFloat)
        {
            // in float mode coordinates [0..1] have to be scaled to current viewport
            m_fScaleX = (tFloat32) (sTargetRect.m_nRight - sTargetRect.m_nLeft);
            m_fScaleY = (tFloat32) (sTargetRect.m_nBottom - sTargetRect.m_nTop);
        }
        else
        {
            if (nOrigWidth != 0 && nOrigHeight != 0)
            {
                // in int mode coordinates [0..nOrigWidth] or [0..nOrigHeight] have to be normalized by
                // original image width and height and then scaled to current viewport
                m_fScaleX = ((tFloat32) (sTargetRect.m_nRight - sTargetRect.m_nLeft)) / (tFloat32) nOrigWidth;
                m_fScaleY = ((tFloat32) (sTargetRect.m_nBottom - sTargetRect.m_nTop)) / (tFloat32) nOrigHeight;
            }
            else
            {
                m_fScaleX = 1.0f;
                m_fScaleY = 1.0f;
            }
        }
 
        RETURN_NOERROR;
    }

    tResult GetCoords(const tUInt32* pParam, const cRect& sTargetRect, tInt& x, tInt& y) const
    {
        if (m_bFormatFloat)
        {
            tFloat32* pFloatParam = (tFloat32*) pParam;
            x = (tInt) ((pFloatParam[0] * m_fScaleX) + 0.5) + sTargetRect.m_nLeft;
            y = (tInt) ((pFloatParam[1] * m_fScaleY) + 0.5) + sTargetRect.m_nTop;
        }
        else
        {
            tInt32* pCoordParam = (tInt32*) pParam;
            x = (tInt) ((pCoordParam[0] * m_fScaleX) + 0.5) + sTargetRect.m_nLeft;
            y = (tInt) ((pCoordParam[1] * m_fScaleY) + 0.5) + sTargetRect.m_nTop;
        }
        RETURN_NOERROR;
    }
};
 
} // namespace dengar
 
using dengar::IGCLProcessorEvents;
using dengar::cGCLProcessor;
} // namespace graphicslib
 
} // namespace disptb
 
} // namespace adtf
 
//*************************************************************************************************