/*

* Copyright (c) 2006-2008 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:   Defines CHuiVg10Gc, an OpenVG 1.0 version of the HUITK

*                graphics context.

*

*/

#ifndef __HUIVG10GC_H__

#define __HUIVG10GC_H__

#include <e32def.h>

#include <VG/openvg.h>

#include <VG/vgu.h>

#include <e32cmn.h>

#include "uiacceltk/HuiGc.h"

#include "uiacceltk/HuiRealPoint.h"

#include "uiacceltk/HuiRealSize.h"

#include "uiacceltk/HuiRealRect.h"

#include "uiacceltk/HuiSegmentedTexture.h"

#include "HuiMatrixStack.h"

/* Forward declarations. */

#ifdef __NVG

class MNVGIcon;

class CNvgEngine;

#endif

/**

 * CHuiVg10Gc implements an OpenVG 1.0 version of the HUITK

 * graphics context.

 */

NONSHARABLE_CLASS(CHuiVg10Gc) : public CHuiGc

    {

    friend class CHuiVg10CurvePath;

public:

    /* Constructors and destructor. */

    /**

     * Constructs a new graphics context.

     */

    static CHuiVg10Gc* NewL();

    /**

     * Constructs a new graphics context and leaves it on the cleanup stack.

     */

    static CHuiVg10Gc* NewLC();

    /**

     * Destructor.

     */

    virtual ~CHuiVg10Gc();

    /* Methods. */

    virtual void Push(THuiGcMatrix aStack);

    virtual void Pop(THuiGcMatrix aStack);

    virtual void Multiply(THuiGcMatrix aStack, TReal32 aMatrix[16]);

    virtual void LoadIdentity(THuiGcMatrix aStack);

    virtual void Translate(THuiGcMatrix aStack,

                           TReal32 aX, TReal32 aY, TReal32 aZ) __SOFTFP;

    virtual void Scale(THuiGcMatrix aStack,

                       TReal32 aX, TReal32 aY, TReal32 aZ) __SOFTFP;

    virtual void Rotate(THuiGcMatrix aStack, TReal32 aAngle,

                         TReal32 aX, TReal32 aY, TReal32 aZ) __SOFTFP;

    virtual void Shear(THuiGcMatrix aStack,

                       TReal32 aX, TReal32 aY, TReal32 aZ) __SOFTFP;

    virtual void InitState();

    /**

     * Selects the default data arrays.

     */

    void RestoreState() const;

    /**

     * Restores OpenVg state according to flags set up in the render plugin

     */

    void RestoreFlaggedState() const;

    /**

     * Updates the projection matrix without changing any settings.

     */

    void UpdateProjection();

    /**

     * Returns the number of available texture units.

     *

     * @return  Number of units (at least 1).

     */

    TInt TextureUnits() const;

    /**

     * Sets the number of active texture units.

     *

     * @param aTextureUnitCount  Number of units to activate (e.g., 2 => 0,1)

     */

    void SetTextureUnits(TInt aTextureUnitCount);

    /**

     * Enable a feature.

     */

    void Enable(TFeature aFeature, TBool aDoEnable = ETrue);

    /**

     * Changes the blending mode.

     */

    void SetBlendMode(TBlendMode aBlendMode);

    /**

     * Changes the texture mode.

     *

     * @param aTextureMode  Texturing mode.

     * @param aParam        Parameter for the texturing.

     */

    void SetTextureMode(TTextureMode aTextureMode, TReal32 aParam = 0) __SOFTFP;

    /**

     * Sets the strength of dimming fog. In order to have effect, enable the

     * Fog feature.

     *

     * @param aColor   Color of dimming.

     * @param aAmount  Amout of dimming (0...1).

     */

    void SetDimmingFog(const TRgb& aColor, TReal32 aAmount) __SOFTFP;

    /**

     * Clear using the current pen color.

     */

    void Clear();

    /**

     * Clear the depth buffer.

     */

    void ClearDepth();

    /**

     * Clear both color and depth buffer

     */

    void ClearColorAndDepth();

	/**

	 * Do initialization of new frame.

	 * Called by CHuiDisplay when starting to render new frame.

	 * Graphics context can do renderer specific state initializations here.

	 */

	void InitNewFrame();

    /**

     * Apply a clipping rectangle to the current clipping region.

     *

     * @param aClipRect  Clipping rectangle.

     */

    virtual void Clip(const TRect& aClipRect);

    /**

     * Apply a clipping region to the current clipping region.

     *

     * @param aRegion  Clipping region.

     */

    virtual void Clip(const TRegion& aRegion);

    /**

     * Replace the current clipping rectangle.

     *

     * @param aClipRect  Clipping rectangle in display coordinates.

     */

    virtual void SetClip(const TRect& aClipRect);

    /**

     * Replace the current clipping region.

     *

     * @param aRegion  List of Clipping rectangles.

     */

    virtual void SetClipRegion(const TRegion& aRegion);

    /**

     * Cancel an applied clipping rectangle or region.

     */

    virtual void CancelClipping();

    /**

     * Draws a single line of text using the current pen color, font, and

     * alignment mode.

     *

     * @param aTextMesh  Text string.

     * @param aBounds    Bounding box for the text.

     * @param aShadow    Darkness of text shadow.

     */

    void DrawText(const CHuiTextMesh& aTextMesh,

                  const THuiRealRect& aBounds,

                  TReal32 aShadow = 0) __SOFTFP;

    /**

     * Draws a rectangle with the current graphics context parameters.

     *

     * @param aRect  Rectangle to draw.

     */

    void DrawRect(const TRect& aRect);

    /**

     * Draws a solid line of uniform thickness with the current graphics context parameters.

     *

     * @param aStart     Start of line.

     * @param aEnd       End of line.     

     * @param aThickness Thickness of line in pixels.

     */

    void DrawLine(const TPoint& aStart, const TPoint& aEnd, const TInt aThickness);

    /**

     * Draws a solid or unfilled round rectangle.

     *

     * @param aDestinationRect     Start of line.

     * @param aSize       	Arc size. 

	 * @param aDrawMode		THuiFillMode 

     * @param aThickness 	Thickness of border line in pixels.

     */

    void DrawRoundRect(const TRect& aDestinationRect, const THuiRealSize& aSize, THuiFillMode aDrawMode, const TInt aThickness);

    /**

     * Draws a stretched image.

     *

     * @param aMode        Stretch mode: horizontal or vertical.

     * @param aImage       Image.

     * @param aRect        Rectangle to fill.

     * @param aStartWidth

     * @param aEndWidth

     */

    void DrawStretchImage(TStretchMode aMode,

                          const THuiImage& aImage, const THuiRealRect& aRect,

                          TInt aStartWidth, TInt aEndWidth);

    /**

     * Draws edges with a color or using a texture.

     *

     * @param aOuterRect         The outer edge of the borders.

     * @param aLeftBorderWidth   The visible width of the left border, 

     * 							 the width is assumed to be pixel units 

     * 							 inside from the respective edge 

     * 							 border. Use 0.0 for no left border.

     * @param aRightBorderWidth  The visible width of the right border, 

     * 							 the width is assumed to be pixel units 

     * 							 inside from the respective edge 

     * 							 border. Use 0.0 for no right border.

     * @param aTopBorderWidth    The visible height of the top border, 

     * 							 the height is assumed to be pixel units 

     * 							 inside from the respective edge 

     * 							 border. Use 0.0 for no border.

     * @param aBottomBorderWidth The visible height of the bottom border, 

     * 							 the height is assumed to be pixel units 

     * 							 inside from the respective edge 

     * 							 border. Use 0.0 for no border.

     * @param aBorderMode		 Border drawing mode, defines how the

     * 							 image is streched to the borders.

     * 							 aImage needs to be 

     * 							 defined in order to this modes to be

     * 					         effective.

     * 

     * @param aImage			 The image to be used to draw borders,

     * 							 according to the border drawing mode.

     * 							 If left NULL will use the current pen 

     * 							 color to draw single-color borders.

     */

    void DrawBorders(const TRect& aOuterRect, 

                     TReal32 aLeftBorderWidth,

                     TReal32 aRightBorderWidth, 

                     TReal32 aTopBorderHeight,

                     TReal32 aBottomBorderHeight, 

                     TBorderMode aBorderMode,

                     const THuiImage* aImage) __SOFTFP;

    /**

     * Draws a path from the beginning to aPos.

     *

     * @param aPath      Weighted path.

     * @param aOrigin    Offset.

     * @param aStartPos  Start position on the path.

     * @param aEndPos    End position on the path.

     * @param aAlphaFunction  Function for determining alpha values.

     * @param aWidthFunction  Function for determining line thickness.

     */

    void DrawPath(const CHuiCurvePath& aPath,

                  const TPoint& aOrigin,

                  TReal32 aStartPos,

                  TReal32 aEndPos,

                  MHuiMappingFunction* aAlphaFunction = 0,

                  MHuiMappingFunction* aWidthFunction = 0) __SOFTFP;

    void DrawMesh(const CHuiMesh& aMesh, const THuiImage* aImage = 0,

                  const THuiImage* aSecondaryImage = 0,

                  TReal32 aSecondaryAlpha = 0.0) __SOFTFP;

    void DrawArc(const TPoint& aOrigin, const TSize& aRadius,

                 TReal32 aStart, TReal32 aEnd, TInt aAnglePerSegment,

                 TReal32 aWidth, const THuiImage& aImage,

                 TReal32 (*aAlphaFunc)(TReal32)=0, TBool aAbsoluteAngleParm=EFalse) __SOFTFP;

    void DrawGradient(TGradientType aType, const TRect& aRect,

                      const TRgb& aStartColor, const TRgb& aEndColor,

                      TReal32 aStartOpacity = 1.0,

                      TReal32 aEndOpacity = 1.0,

                      const THuiRealRect* aTexCoords = 0) __SOFTFP;

    void DrawPolygon(RArray<THuiRealPoint>& aPoints);                      

    void DrawEllipse(const TRect& aRect, THuiFillMode aDrawMode, const TInt aThickness);                      

    /**

     * Sets a depth offset. The depth offset is used when drawing overlaid

     * surfaces with the same Z coordinates. Normally the depth offset is

     * always zero.

     *

     * @param aOffset  Offset units.

     */

    void SetDepthOffset(TInt aOffset);

    /**

     * Makes a screen capture of the graphics context's current content.

     * The data is returned in an array of raw pixel data of size:

     * aSize.Width() * aSize.Height() * 4.

     *

     * @return  Rgba8888 raw bitmap data of the screen's contents.

     *          Caller must pop and destroy the returned buffer.

     */

    TUint8* CaptureLC(TSize& aSize) const;

    /**

     * Transforms a dirty rectangle. Implementing this method in

     * inherited classes is optional (if e.g. dirty rects aren't supported)

     *

     * @param aRect  Rectangle to transform.

     */

    void TransformDirtyRect(THuiRealRect& aRect);

    /*

     * Implemented.

     */

    virtual void UpdateColor(TReal32 aAlphaFactor = 1.0f) __SOFTFP;

public: // new

    /**

     * Sets the rule by which a polygon should be filled

     * Fill rule is useful while filling self-intersecting polygons.

     *

     * @param aFillMode Polygon filling mode, which will be mapped to

     *  openVg Fill_Rule.

     */

    void SetFillRule( THuiFillMode aFillMode );

    /*

     * Ownership is not transferred.

     */

    void SetPaintPattern(CHuiTexture* aTexture, const TPoint& aTextureOrigin);

    void DrawArc(const TRect& aRect, THuiFillMode aDrawMode, const TInt aThickness, TReal32 aStart, TReal32 aEnd, TBool aIsPie);

protected:

    /* Constructors. */

    /**

     * Constructor.

     */

    CHuiVg10Gc();

    /**

     * Second-phase constructor.

     */

    void ConstructL();

    /* Methods. */

    /**

     * Draw the image.

     *

     * @param aImage    Image to draw.

     * @param aTopLeft  Coordinates of the top left corner.

     * @param aSize     Size of the image.

     */

    void DoDrawImage(const THuiImage& aImage, const THuiRealPoint& aTopLeft,

                     const THuiRealSize& aSize);

    /**

     * Draws two images simultaneously. Requires at least two texture units.

     *

     * Segment count must match and sizes must match if using multiple segments.

     * Otherwise nothing is drawn.

     *

     * @param aImage    Image to draw.

     * @param aImage2   Secondary image to draw.

     * @param aTopLeft  Coordinates for the top left corner.

     * @param aSize     Size of the image.

     */

    void DoDrawImages(const THuiImage& aImage,

                      const THuiImage& aImage2,

                      const THuiRealPoint& aTopLeft,

                      const THuiRealSize& aSize);

    CHuiMatrixStack* MatrixStack(THuiGcMatrix aMatrix);

    void SetQuality(THuiQuality aQuality);

private:

    /** 

     *  Synchronize a specific OpenVG matrix with the main matrix.

     */

    void UpdateMatrix(VGMatrixMode aMatrix);

    /**

     *  Makes sure the latest transformation matrix is used for client-side calculation.

     */

    void UpdateClientMatrix();

    /**

     *  Draw a cropped and possibly scaled portion of an image onto the screen.

     * 

     *  @param aTexture     Texture to draw

     *  @param aSourceRect  Source rectangle

     *  @param aDestRect    Destination rectangle

     */

    void DrawCroppedTexture(const MHuiSegmentedTexture& aTexture, 

                            const THuiRealRect& aSourceRect, 

                            const THuiRealRect& aDestRect);

    /**

     *  Draw a possibly cropped or scaled portion of an image onto the screen.

     * 

     *  @param aTexture     Texture to draw

     *  @param aSourceRect  Source rectangle

     *  @param aDestRect    Destination rectangle

     */

    void DrawTexture(const MHuiSegmentedTexture& aTexture, 

                     const THuiRealRect& aSourceRect, 

                     const THuiRealRect& aDestRect);

    /**

     * DrawBorders implementation for EBorderImage

     * border drawing mode.

     * @see CHuiGc::DrawBorders()

     */

    void DrawBorderImages(const TRect& aOuterRect, 

                          TReal32 aBorderWidth,

                          TReal32 aBorderHeight, 

                          THuiRealPoint aOffset,

                          const THuiImage* aImage);

    /**

     * DrawBorders implementation for EBorderFixedCorners

     * border drawing mode.

     * @see CHuiGc::DrawBorders()

     */

    void DrawBorderFixedCorners(const TRect& aOuterRect, 

                                TReal32 aLeftBorderWidth,

                                TReal32 aRightBorderWidth, 

                                TReal32 aTopBorderHeight,

                                TReal32 aBottomBorderHeight, 

                                const THuiImage* aImage);

    void CreateVgObjectsL();

#ifdef __NVG

    /**

     * Draws the icon from NVG data using the NVGDecoder. Does the parsing of the icon header as well

     * 

     * @param aNVGData              Extended bitmap data in NVG buffer format to be drawn

     * @param aIconCmds             Extended bitmap data in VG Object Cached format to be drawn

     * @param aImageSize            Size of the image

     * @param aIgnoreAspectRatio    Ignore aspect ratio defined in the icon's header

     */

    void DrawNVG(HBufC8* aNVGData, MNVGIcon* aIconCmds, const TSize& aImageSize, TBool aIgnoreAspectRatio);

#endif

    void UsePaintPattern();

    void DiscardPaintPattern();

private:

    /** Matrix characteristics */

    enum TMatrixFlags

        {

        EMatrixFlagsRotation = 0x1,

        };

    /** Model view matrix stack */

    CHuiMatrixStack* iMatrixStack;

    typedef RArray<TUint> RMatrixFlagsStack;

    /** Stack for storing additional information about the matrices */

    RMatrixFlagsStack iMatrixFlagsStack;

    /** Flags for the current matrix */

    TUint iMatrixFlags;

    /** Rendering state */

	TBool iStateScissorTest;

	TRect iScissorRect;