/*

* Copyright (c) 2006-2007 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:   Definition file for CHuiGc (graphics context) class.

*

*/

#ifndef __HUIGC_H__

#define __HUIGC_H__

#include <e32base.h>

#include <gdi.h>

#include <uiacceltk/HuiRealPoint.h>

#include <uiacceltk/HuiRealSize.h>

#include <uiacceltk/HuiRealRect.h>

/* Forward declarations. */

class CHuiTexture;

class THuiFont;

class THuiImage;

class CHuiMesh;

class CHuiTextMesh;

class CHuiCurvePath;

class CHuiTransformation;

class MHuiMappingFunction;

const TInt KHuiGcClipRegionGranularity = 10;

/** Point on a weighted path. */

struct THuiPathPoint

    {

    /** Position of the point. */

    TPoint iPoint;

    /** Weight of the point. */

    TReal32 iWeight;

    inline THuiPathPoint(const TPoint& aPoint, const TReal32& aWeight)

        : iPoint(aPoint), iWeight(aWeight) {}

    };

/** Weighted path. */

typedef RArray<THuiPathPoint> THuiWeightedPath;

/** Horizontal alignment. */

enum THuiAlignHorizontal

    {

    EHuiAlignHLeft,

    EHuiAlignHCenter,

    EHuiAlignHRight,

   /** Alignment that follows the directionality of the UI language. This is converted to left or

        right alignment internally. e.g. into right-aligned for Arabic */

    EHuiAlignHLocale,

    /** Alignment that is opposite to the directionality of the UI language. This is 

        converted to left or right alignment internally. e.g. into left-aligned for Arabic */

    EHuiAlignHLocaleMirrored,

    /** Alignment is text content dependent according to Unicode paragraph alignment rules. 

         This is converted to left or right alignment according to text content. 

         Where used in an editable context, the cursor alignment when empty comes from current input language.

         This should not be used in a non-textual context, but if used, behaves like EHuiAlignHLocale. */

    EHuiAlignHBidirectionalText,

    /** Alignment is text content dependent according to Unicode paragraph alignment rules, but then reversed. 

         This is converted to left or right alignment according to text content. 

         Where used in an editable context, the cursor alignment when empty is opposite to current input language.

         This should not be used in a non-textual context, but if used, behaves like EHuiAlignHLocaleMirrored. */

    EHuiAlignHBidirectionalTextMirrored

    };

/** Vertical alignment. */

enum THuiAlignVertical

    {

    EHuiAlignVTop,

    EHuiAlignVCenter,

    EHuiAlignVBottom

    };

/** Texture matrices. */

enum THuiGcMatrix

    {

    /** Modelview matrix. */

    EHuiGcMatrixModel,

    /** Projection matrix. */

    EHuiGcMatrixProjection,

    /** Texture matrix. */

    EHuiGcMatrixTexture

    };

/** Rendering quality. */

enum THuiQuality

    {

    /** Accurate quality ensures the best visual quality. */

    EHuiQualityAccurate,

    /** Fastest rendering speed in exchange for lower quality. */

    EHuiQualityFast

    };

/** Polygon draw mode */

enum THuiFillMode

    {

    EHuiNoFill,

    EHuiFillNonZero,

    EHuiFillEvenOdd

    };

/**

 * CHuiGc is a graphics context that is used for storing the state of the

 * drawing tools. The graphics context provides a number of relatively

 * low-level drawing routines.

 *

 * @todo  Check which exports are truly useful to applications.

 *

 */

class CHuiGc : public CBase

    {

public:

    /** Display orientation. */

    enum TOrientation

        {

        /** Normal orientation. */

        EOrientationNormal,

        /** 90 degrees counterclockwise. */

        EOrientationCCW90,

        /** 90 degrees clockwise. */

        EOrientationCW90,

        /** 180 degrees  */

        EOrientation180        

        };

    /** Rendering features. */

    enum TFeature

        {

        EFeatureTexturing,

        EFeatureBlending,

        EFeatureClipping,

        EFeatureDepthTest,

        EFeatureDepthWrite,

        EFeatureAntialias,

        EFeatureFog,

        };

    /** Blending modes. */

    enum TBlendMode

        {

        EBlendNormal,

        EBlendAdd,

        EBlendReplace

        };

    /** Texture modes. */

    enum TTextureMode

        {

        ETextureModeNormal,

        /** Interpolation between two texture units. Parameter controls how

            much interpolation is done. */

        ETextureModeInterpolate

        };

    /** Projections. */

    enum TProjection

        {

        EProjectionOrthographic,

        EProjectionPerspective

        };

    /**

     * Stretch modes.

     * @see DrawStretchImage()

     */

    enum TStretchMode

        {

        EStretchNone = 0,   ///< Does not stretch

        EStretchHorizontal, ///< Fits to horizontal width (left-right)

        EStretchVertical,   ///< Fits to vertical height

        EStretchFull		///< Stretches the image to the full area of the visual, disregarding the original aspect ratio.

        };

	/**

	 * Modes for drawing borders with images.

	 * @see DrawBorders()

	 */        

    enum TBorderMode    

	{

        /**

         * The whole image is stretched to the

         * borders so that the pixels at the center of the image are placed at the 

         * edges of the visual and the pixels at the edge of the image are placed

         * at the outer edge. 

         * 

         * For example, a round-shaped ball having red centrum

         * and white outer rim cretes a red square inner border having white

         * rounded outer border.

         */

        EBorderImage = 0,

        /**

         * Only the edge pixels of the image are used to draw the borders. The edge is 

         * defined with the (left,right,top,bottom-) border widths. The corners of the

         * image are not stretched. The center image inside the borders won't be

         * included in the border drawing.

         * 

         * This mode is used in CHuiImageBrush to draw background images to visuals 

		 * (eg. Soft key backgrounds) and texture-mapped borders to them (for example 

		 * to achieve rounded corners). 

         */

        EBorderFixedCorners

        };

    /** Gradient types. */

    enum TGradientType

        {

        EGradientLinearUp,

        EGradientLinearRight,

        EGradientLinearDown,

        EGradientLinearLeft

        };

    /**

     * Destructor.

     */

    IMPORT_C virtual ~CHuiGc();

    /* Methods. */

    /**

     * Sets the quality preference of the graphics context.

     *

     * @param aQuality  Quality setting.

     */

    IMPORT_C virtual void SetQuality(THuiQuality aQuality);

    /**

     * Determines the quality preference of the graphics context.

     *

     * @return  Quality preference.

     */

    IMPORT_C THuiQuality Quality() const;

    /**

     * Pushes the current global transformation matrix on the stack.

     */

    IMPORT_C virtual void Push(THuiGcMatrix aStack) = 0;

    /**

     * Pops a matrix from the stack.

     */

    IMPORT_C virtual void Pop(THuiGcMatrix aStack) = 0;

    /**

     * Loads an identity matrix as the current matrix.

     */

    IMPORT_C virtual void LoadIdentity(THuiGcMatrix aStack) = 0;

    /**

     * Multiplies the current matrix with another matrix.

     */

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

    /**

     * Apply a translation to given matrix stack.

     */

    IMPORT_C virtual void Translate(THuiGcMatrix aStack,

                                    TReal32 aX, TReal32 aY, TReal32 aZ) __SOFTFP = 0;

    /**

     * Apply a scale to given matrix stack.

     */

    IMPORT_C virtual void Scale(THuiGcMatrix aStack,

                                TReal32 aX, TReal32 aY, TReal32 aZ) __SOFTFP = 0;

    /**

     * Apply a rotation to given matrix stack.

     */

    IMPORT_C virtual void Rotate(THuiGcMatrix aStack, TReal32 aAngle,

                                 TReal32 aX, TReal32 aY, TReal32 aZ) __SOFTFP = 0;

    /**

     * Apply a shear to given matrix stack.

     */

    virtual void Shear(THuiGcMatrix /*aStack*/,

                                TReal32 /*aX*/, TReal32 /*aY*/, TReal32 /*aZ*/) __SOFTFP {} // cheers ;)

    /**

     * Sets the orientation of the display. This affects clipping and

     * projection.

     *

     * @param aOrientation  Orientation of the display.

     */

    IMPORT_C void SetOrientation(TOrientation aOrientation);

    /**

     * Determines the orientation of the graphics context.

     *

     * @return  Orientation.

     */

    IMPORT_C TOrientation Orientation() const;

    /**

     * Initialize the state of the context.

     */

    IMPORT_C virtual void InitState() = 0;

    /**

     * Selects the default data arrays.

     */

    IMPORT_C virtual void RestoreState() const = 0;

    IMPORT_C void SetProjection(TProjection aProjection = EProjectionOrthographic);

    IMPORT_C TProjection Projection() const;

    /**

     * Sets projection within a custom viewport.

     */

    IMPORT_C void SetProjection(TProjection aProjection, const TRect& aCustomViewport);

    /**

     * Defines an offset for the 3D frustum and updates the projection.

     */

    IMPORT_C void SetFrustumOffset(const THuiRealPoint& aFrustumOffset);

    /**

     * Determines the current frustum offset.

     */

    IMPORT_C THuiRealPoint FrustumOffset() const;

    /**

     * Updates the projection matrix without changing any settings.

     */

    IMPORT_C virtual void UpdateProjection() = 0;

    /**

     * Sets the display area of the normal orientation.

     */

    IMPORT_C void SetDisplayArea(const TRect& aDisplayArea);

    /**

     * Returns the display area. Affected by the display orientation.

     */

    IMPORT_C TRect DisplayArea() const;

    /**

     * Returns the number of available texture units.

     *

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

     */

    IMPORT_C virtual TInt TextureUnits() const = 0;

    /**

     * Sets the number of active texture units.

     *

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

     */

    IMPORT_C virtual void SetTextureUnits(TInt aTextureUnitCount) = 0;

    /**

     * Enable a feature.

     */

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

    /**

     * Disable a feature.

     */

    IMPORT_C virtual void Disable(TFeature aFeature);

    /**

     * Changes the blending mode.

     */

    IMPORT_C virtual void SetBlendMode(TBlendMode aBlendMode) = 0;

    /**

     * Changes the texture mode.

     *

     * @param aTextureMode  Texturing mode.

     * @param aParam        Parameter for the texturing.

     */

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

    /**

     * 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).

     */

    IMPORT_C virtual void SetDimmingFog(const TRgb& aColor, TReal32 aAmount) __SOFTFP = 0;

    /**

     * Clear using the current pen color.

     */

    IMPORT_C virtual void Clear() = 0;

    /**

     * Clear the depth buffer.

     */

    IMPORT_C virtual void ClearDepth() = 0;

    /**

     * Clear both color and depth buffer

     */

    IMPORT_C virtual void ClearColorAndDepth() = 0;

	/**

	 * Do initialization of new frame.

	 * Called by CHuiDisplay when starting to render new frame.

	 * Graphics context can do renderer specific state initializations here.

	 */

    IMPORT_C virtual void InitNewFrame() = 0;

    /**

     * Push the current clipping rectangle onto the clip stack.

     */

	IMPORT_C virtual void PushClip();

    /**

     * Pop a clipping rectangle off of the clip stack and activate it.

     */

    IMPORT_C virtual void PopClip();

    /**

     * Apply a clipping rectangle.

     *

     * @param aClipRect  Clipping rectangle.

     */

    IMPORT_C virtual void Clip(const TRect& aClipRect);

    /**

     * Apply a clipping region.

     *

     * @param aClipRegion  Clipping region.

     */

    IMPORT_C virtual void Clip(const TRegion& aClipRegion); 

    /**

     * Apply a clipping region.

     *

     * @param aClipRegion  Region containing clipping rectangles.

     */

	IMPORT_C virtual void SetClipRegion(const TRegion& aClipRegion);

	/**

	 * Cancel an applied clipping rectangle or region.

	 */

	IMPORT_C virtual void CancelClipping();

    /**

     * Replace the current clipping rectangle.

     *

     * @param aClipRect  Clipping rectangle in display coordinates.

     */

    IMPORT_C virtual void SetClip(const TRect& aClipRect);

    /**

     * Returns the currently active clipping rectangle.

     */

    IMPORT_C TRect ClipRect() const;

    /**

     * Returns the currently active clipping region.

     */

    const TRegion& ClipRegion() const;

    /**

     * Determines the number of pushed clipping rectangles on the clip stack.

     *

     * @return  Size of the clip stack.

     */

    IMPORT_C TInt ClipStackCount() const;

    /**

     * Sets the pen color and alpha.

     */

    IMPORT_C void SetPenColorAlpha(const TRgb& aColor);

    /**

     * Sets the pen color.

     */

    IMPORT_C void SetPenColor(const TRgb& aColor);

    /**

     * Sets the pen alpha level.

     *

     * @param aAlpha  Alpha level (0..255).

     */

    IMPORT_C void SetPenAlpha(TInt aAlpha);