/*

* Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  SVG Implementation header file

 *

*/

#ifndef VGRENDERER_H

#define VGRENDERER_H

#include <e32std.h>

#include <e32base.h>

#include "MVGRendererImpl.h"

#include <SVGRendererId.h>

class CVGSurface;

/**

 *  CVGRenderer

 * 

 */

class CVGRenderer : public CBase

    {

public:

    /**

     * Destructor.

     */

    ~CVGRenderer();

    /*!

     * @fn          NewL()

     * @bief        Creates the renderer abstraction

     * @param       aRendererType   Type of the renderer

     * @param       aSurface        Type of the surface

     * @return      Renderer abstraction

     */

    IMPORT_C static CVGRenderer* NewL(SVGRendererId aRendererType = ESVGRendererSW, TInt aSurface = 0);

    /*!

     * @fn          NewLC()

     * @bief        Creates the renderer abstraction

     * @param       aRendererType   Type of the renderer

     * @param       aSurface        Type of the surface

     * @return      Renderer abstraction

     */

    static CVGRenderer* NewLC(SVGRendererId aRendererType = ESVGRendererSW, TInt aSurface = 0);

public:

    /*!

     * @fn          GetRendererName()

     * @bief        Retrieves the renderer implementation's version

     * @return      version of renderer implementation

     */

    TVersion GetRendererVersion()

        {

        return iImpl->GetVersion();

        }

    /*!

     * @fn          GetRendererName()

     * @bief        Retrieves the renderer implementation's name 

     * @return      name of renderer implementation

     */

    const TDesC GetRendererName()

        {

        return iImpl->GetName();

        }

    // OpenVG function calls

    void vgClear(TInt x, TInt y, TInt width, TInt height)

        {

        iImpl->vgClear(x, y, width, height);

        }

    void vgSeti(TInt type, TInt value)

        {

        iImpl->vgSeti(type, value);

        }

    TInt vgGeti(TInt type)

        {

        return iImpl->vgGeti(type);

        }    

    void vgSetf (TInt type, TReal32 value)

        {

        iImpl->vgSetf(type, value);

        }

    void vgSetfv(TInt type, TInt count, const TReal32 * values)

        {

        iImpl->vgSetfv(type, count, values);

        }

    void vgSetiv(TInt type, TInt count, const TInt * values)

        {

        iImpl->vgSetiv(type, count, values);

        }    

    void vgSetParameteri(TUint handle, TInt paramType, TInt value)

        {

        iImpl->vgSetParameteri(handle, paramType, value);

        }

    void vgSetParameterf(TUint handle, TInt paramType, TReal32 value)

        {

        iImpl->vgSetParameterf(handle, paramType, value);

        }

    void vgSetParameterfv(TUint object, TInt paramType, TInt count, const TReal32 * values)

        {

        iImpl->vgSetParameterfv(object, paramType, count, values);

        }

    void vgSetColor(TUint paint, TUint rgba)

        {

        iImpl->vgSetColor(paint, rgba);

        }

    void vgSetPaint(TUint paint, TUint paintModes)

        {

        iImpl->vgSetPaint(paint, paintModes);

        }

    TUint vgCreatePaint()

        {

        return iImpl->vgCreatePaint();

        }

    TUint vgCreatePath(TInt pathFormat, TInt datatype, TReal32 scale, TReal32 bias,

                        TInt segmentCapacityHint, TInt coordCapacityHint, TInt capabilities)

        {

        return iImpl->vgCreatePath(pathFormat, datatype, scale, bias, segmentCapacityHint, coordCapacityHint, capabilities);

        }

    void vgLoadMatrix(const TReal32 * m)

        {

        iImpl->vgLoadMatrix(m);

        }

    void vgMultMatrix(const TReal32 * m)

        {

        iImpl->vgMultMatrix(m);

        }

    void vgLoadIdentity()

        {

        iImpl->vgLoadIdentity();

        }

    void vgScale(TReal32 sx, TReal32 sy)

        {

        iImpl->vgScale(sx, sy);

        }

    void vgRotate(TReal32 angle)

        {

        iImpl->vgRotate(angle);

        }

    void vgReadPixels(void * data, TInt dataStride,TInt dataFormat,TInt sx, TInt sy,TInt width, TInt height)

        {

        iImpl->vgReadPixels(data,dataStride,dataFormat,sx,sy,width,height); 

        }   

    void vgWritePixels(const void * data, TInt dataStride, TInt dataFormat,

            TInt dx, TInt dy, TInt width, TInt height)

        {

        iImpl->vgWritePixels(data, dataStride, dataFormat, dx, dy, width, height);

        }

    void vgTranslate(TReal32 tx, TReal32 ty)

        {

        iImpl->vgTranslate(tx, ty);

        }

    void vgAppendPathData(TUint path, TInt numSegments,

                                                const TUint8 * pathSegments,

                                                const void * pathData)

        {

        iImpl->vgAppendPathData(path, numSegments, pathSegments, pathData);

        }

    void vgDrawPath(TUint path, TUint paintModes)

        {

        iImpl->vgDrawPath(path, paintModes);

        }

    void vgClearPath(TUint path, TUint capabilities)

        {

        iImpl->vgClearPath(path, capabilities);

        }

    TInt vguRect(TUint path, TReal32 x, TReal32 y,

                             TReal32 width, TReal32 height)

        {

        return iImpl->vguRect(path, x, y, width, height);

        }

    TInt vguEllipse(TUint path, TReal32 cx, TReal32 cy,

                                TReal32 width, TReal32 height)

        {

        return iImpl->vguEllipse(path, cx, cy, width, height);

        }

    TInt vguRoundRect(TUint path, TReal32 x, TReal32 y,

                                            TReal32 width, TReal32 height, TReal32 arcWidth, TReal32 arcHeight)

        {

        return iImpl->vguRoundRect(path, x, y, width, height, arcWidth, arcHeight);

        }

    TInt vguLine(TUint path, TReal32 x0, TReal32 y0, TReal32 x1, TReal32 y1)

        {

        return iImpl->vguLine(path, x0, y0, x1, y1);

        } 

    void DumpToLogFile()

        {

        return iImpl->DumpToLogFile();

        }

    void CloseLogFile()

        {

        return iImpl->CloseLogFile();

        }

    TUint vgCreateImage(TInt format, TInt width, TInt height, TInt allowedQuality)

        {

        return iImpl->vgCreateImage(format, width, height, allowedQuality);

        }

    void vgClearImage(TUint image, TInt x, TInt y, TInt width, TInt height)

        {

        return iImpl->vgClearImage(image, x, y, width, height);

        }

    void vgImageSubData(TUint image, const void * data, TInt dataStride,

            TInt dataFormat, TInt x, TInt y, TInt width, TInt height)

        {

        return iImpl->vgImageSubData(image, data, dataStride, dataFormat, x, y, width, height);

        }

    void vgGetPixels(TUint dst, TInt dx, TInt dy, TInt sx, TInt sy, TInt width, TInt height)

        {

        iImpl->vgGetPixels(dst, dx, dy, sx, sy, width, height);

        }

    void vgDrawImage(TUint image)

        {

        iImpl->vgDrawImage(image);

        }

    void vgMask(TUint mask, TInt operation, TInt x, TInt y, TInt width, TInt height)

        {

        return iImpl->vgMask(mask, operation, x, y, width, height);

        }

    void vgDestroyImage(TUint aHandle)

        {

        iImpl->vgDestroyImage(aHandle);

        }

    void vgDestroyPaint(TUint aHandle)

        {

        iImpl->vgDestroyPaint(aHandle);

        }

    void vgDestroyPath(TUint aHandle)

        {

        iImpl->vgDestroyPath(aHandle);

        }

    void ToggleReset()

        {

        iImpl->ToggleReset();

        }

    TInt vgGetError()

        {

        return iImpl->vgGetError();

        }

    void vgFlush()

        {

        iImpl->vgFlush();

        }

    /*!

     * @fn          GetCurrentSurface()

     * @bief        Retrieves the surface associated with the renderer

     * @return      Renderer surface

     */

    CVGSurface * GetCurrentSurface()

        {

        return this->iCurrentSurface;

        }

    const TPtrC8 TLVEncodedData() const

        {

        return (iImpl->TLVEncodedData());    

        }

private:

    CVGRenderer();

    /**

     * default constructor for performing 2nd stage construction

     */

    void ConstructL(SVGRendererId , TInt );

    MVGRendererImpl *   iImpl;

    CVGSurface *        iCurrentSurface;

    RLibrary            iLibrary;

    };

#endif // VGRENDERER_H