/*
* 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 of CHuiCanvasGc
*
*/



#ifndef __HUICANVASGC_H__
#define __HUICANVASGC_H__


#include <e32base.h>
#include <uiacceltk/HuiVisual.h>
#include <uiacceltk/HuiGc.h>
#include <uiacceltk/HuiDisplay.h>
#include <uiacceltk/HuiTexture.h>

const TInt KHuiCanvasGcRegionGranularity = 10;

struct THuiRealLine
    {
    THuiRealLine(){}
    THuiRealLine(const THuiRealPoint& aStart, const THuiRealPoint& aEnd):iStart(aStart),iEnd(aEnd){}

    THuiRealPoint iStart;
    THuiRealPoint iEnd;    

	private:
    TInt iSpare1;
    TInt iSpare2;
    };

enum THuiCanvasClipMode
    {
    /** Clipping is disabled */
    EHuiCanvasClipModeNone,
    
    /** Normal clipping, clipping is set immediately when clip methods are called */
    EHuiCanvasClipModeNormal,
    
    /** Delayed clipping, clipping is actually set just before every CHuiCanvasGc draw operation and only if really needed */
    EHuiCanvasClipModeDelayed            
    };

enum THuiCanvasDrawMode
    {
    /** Drawing is done by blending */
    EHuiCanvasDrawModeBlend,

    /** Drawing is done by writing alpha values directly without blending */
    EHuiCanvasDrawModeNormal            
    };

/* Forward declarations. */    
class CHuiCanvasRenderBuffer;
class CHuiCanvasVisual;
class MHuiTexture;
class CHuiTexture;

class CHuiCanvasGc : public CBase
    {
public:
    enum TClipRectVisibility
        {
        EFullyOutside,
        EFullyInside,
        EPartialOverlap,
        EUnknown
        };

	/**
	 * Constructor.
	 */
	IMPORT_C CHuiCanvasGc();

	/**
	 * Destructor.
	 */ 
	IMPORT_C ~CHuiCanvasGc();

    /** General */
    IMPORT_C virtual void SetGc( CHuiGc& aGc );
    IMPORT_C virtual void SetVisual(const CHuiCanvasVisual& aVisual);

    /** Clipping ops */
    IMPORT_C void SetClippingMode(THuiCanvasClipMode aClipMode);
	IMPORT_C void Clip(const TRect& aClipRect);
	IMPORT_C void ClipRegion(const TRegion& aClipRegion);
	IMPORT_C void CancelClipping();

    /** Drawing ops. Although these are virtual, render specific code is typically at DoDrawXXX method overrides */
    IMPORT_C virtual void DrawImage(const CHuiTexture& aImage, const THuiRealRect& aDestinationRect);
    IMPORT_C virtual void DrawImage(const CHuiTexture& aImage, const THuiRealRect& aDestinationRect, const THuiRealRect& aSourceRect);
    IMPORT_C virtual void DrawImage(const CHuiTexture& aImage, const THuiRealRect& aDestinationRect, const THuiRealRect& aSourceRect, CHuiGc::TStretchMode aStretchMode);
    IMPORT_C virtual void DrawImage(const CHuiCanvasRenderBuffer& aImage, const THuiRealPoint& aDestinationPoint);
    IMPORT_C virtual void DrawText(const CHuiTextMesh& aTextMesh, const THuiRealRect& aDestinationRect);    
    IMPORT_C virtual void DrawLines(RArray<THuiRealLine>& aLines);    
    IMPORT_C virtual void DrawEllipse(const THuiRealRect& aDestinationRect);
	IMPORT_C virtual void DrawPoints(RArray<THuiRealPoint>& aPoints);
	IMPORT_C virtual void DrawPolygon(RArray<THuiRealPoint>& aPoints);
	IMPORT_C virtual void DrawRects(RArray<THuiRealRect>& aRects);
	IMPORT_C virtual void DrawPie(const THuiRealRect& aDestinationRect, const THuiRealPoint& aStart, const THuiRealPoint& aEnd);
	IMPORT_C virtual void DrawArc(const THuiRealRect& aDestinationRect, const THuiRealPoint& aStart, const THuiRealPoint& aEnd);
	IMPORT_C virtual void DrawRoundRect(const THuiRealRect& aDestinationRect, const THuiRealSize& aSize);

    /** Setters */
    IMPORT_C virtual void SetTextStyle(TInt aStyleId);
    IMPORT_C virtual void SetPenColor(const TRgb& aColor);
  	IMPORT_C virtual void SetPenWidth(const TReal32& aWidth);
  	IMPORT_C virtual void SetOpacity(const TReal32& aOpacity);
  	IMPORT_C virtual void SetPolygonDrawMode(THuiFillMode aPolygonDrawMode);
    IMPORT_C virtual void SetPolygonFillTexture(CHuiTexture* aTexture);
    IMPORT_C virtual void SetPolygonFillTextureOrigin(const TPoint& aOrigin);
	IMPORT_C virtual void SetTextAlign(THuiAlignHorizontal aAlignHorizontal, THuiAlignVertical aAlignVertical);
	IMPORT_C virtual void SetDefaults();
    IMPORT_C virtual void SetDrawMode(THuiCanvasDrawMode aDrawMode);
	    
    /** Transformations */
    IMPORT_C virtual void LoadIdentity();
	IMPORT_C virtual void Translate(const TReal32& aX, const TReal32& aY, const TReal32& aZ);
	IMPORT_C virtual void Scale(const TReal32& aX, const TReal32& aY, const TReal32& aZ);
	IMPORT_C virtual void Rotate(const TReal32& aAngle, const TReal32& aX, const TReal32& aY, const TReal32& aZ);
    IMPORT_C virtual void PushTransformationMatrix();
    IMPORT_C virtual void PopTransformationMatrix();

    /** Getters */
    IMPORT_C virtual TInt TextStyle() const;
    IMPORT_C virtual TInt TextVerticalAlign() const;
    IMPORT_C virtual TInt TextHorizontalAlign() const;
    IMPORT_C virtual TReal32 PenWidth() const;
  	IMPORT_C virtual THuiFillMode PolygonDrawMode() const;
    IMPORT_C virtual CHuiTexture* PolygonFillTexture() const;
    IMPORT_C virtual TPoint PolygonFillTextureOrigin() const;
  	
  	/** Background drawing */
  	IMPORT_C virtual void Clear(const THuiRealRect& aRect);
  	IMPORT_C virtual void ClearWithSkinBackground(const THuiRealRect& aRect);
  	IMPORT_C virtual void ClearWithBackgroundItems(const THuiRealRect& aRect, const RArray<THuiDisplayBackgroundItem>& aItems);

  	/** Render buffer handling */
    IMPORT_C virtual CHuiCanvasRenderBuffer* CreateRenderBufferL(const TSize& aSize);
    IMPORT_C virtual void ClearRenderBuffer( CHuiCanvasRenderBuffer& aImage, const TRect & aRect );

    /** Misc */
    IMPORT_C void EnableBlendingIfNeeded(const CHuiTexture* aTexture = NULL);
    
    /** Misc getters */
    CHuiCanvasVisual* Visual() const;
    TRgb PenColor() const;
    TReal32 Opacity() const;
    CHuiGc* Gc() const;
    THuiCanvasDrawMode DrawMode() const;

    /** Clipping helpers */
    TClipRectVisibility IsClipped(const TRegion& aTestedRegion, const TRegion& aClippingRegion) const;

    /** Restores gc state (partially) */
    void RestoreState() const;
    
    /** Restores gc state (uses gc state dirty flags (if renderer supports) to avoid unnecessary restore ops */
    IMPORT_C virtual void RestoreFlaggedState() const;
    
    /** 
     * Enables (or disables) effective opacity, which means that visuals effective opacity is 
     * used to calculate real pen opacity. By default effective opacity is enabled.
     * */
    void EnableEffectiveOpacity(TBool aEnable);

protected:

    /** Misc clipping related methods */
    IMPORT_C virtual TInt MaxNumberOfClipRects() const;
    IMPORT_C TClipRectVisibility EnableDelayedClippingIfNeeded(const THuiRealRect& aUpdatedRect);
    IMPORT_C TClipRectVisibility EnableDelayedClippingIfNeeded(const RArray<THuiRealPoint>& aUpdatedPoints);
    IMPORT_C TClipRectVisibility EnableDelayedClippingIfNeeded(const RArray<THuiRealLine>& aUpdatedLines);
    IMPORT_C TClipRectVisibility EnableDelayedClippingIfNeeded(const RArray<THuiRealRect>& aUpdatedRects);    
    IMPORT_C void DisableDelayedClippingIfNeeded();
    IMPORT_C TBool ClipNext();

    /** Drawing ops steup/cleanup helpers */
    IMPORT_C void Setup();
    IMPORT_C void Cleanup();

    /** Clipping helpers */
    TClipRectVisibility IsClipped(const TRect& aRect) const;
    TClipRectVisibility IsClipped(const TPoint& aPoint) const;

    TClipRectVisibility IsClipped(const TRect& aRect, const TRegion& aClippingRegion) const;
    TClipRectVisibility IsClipped(const TPoint& aPoint, const TRegion& aClippingRegion) const;
    
    /** Drawing ops implementations, render specific code typically overrides these */
    IMPORT_C virtual void DoDrawRects(RArray<THuiRealRect>& aRects);
    IMPORT_C virtual void DoDrawLines(RArray<THuiRealLine>& aLines);
    IMPORT_C virtual void DoDrawArc(const THuiRealRect& aDestinationRect, const THuiRealPoint& aStart, const THuiRealPoint& aEnd);
    IMPORT_C virtual void DoDrawRoundRect(const THuiRealRect& aDestinationRect, const THuiRealSize& aSize);
    IMPORT_C virtual void DoDrawPolygon(RArray<THuiRealPoint>& aPoints);        
	IMPORT_C virtual void DoDrawPoints(RArray<THuiRealPoint>& aPoints);
    IMPORT_C virtual void DoDrawPie(const THuiRealRect& aDestinationRect, const THuiRealPoint& aStart, const THuiRealPoint& aEnd);    
    IMPORT_C virtual void DoDrawRenderBuffer(const CHuiCanvasRenderBuffer& aImage, const THuiRealPoint& aDestinationPoint);
    IMPORT_C virtual void DoClearRenderBuffer( CHuiCanvasRenderBuffer& aImage, const TRect & aRect );
    
protected:
 
    /** General attributes */    
    CHuiGc* iGc;
    CHuiCanvasVisual* iVisual;

    /** Drawing attributes */    
    TRgb    iPenColor;
    TReal32 iPenWidth;
    TReal32 iOpacity;
    THuiFillMode    iPolygonDrawMode;
    THuiAlignVertical iVerticalTextAlign;
    THuiAlignHorizontal iHorizontalTextAlign;
    TInt iTextStyleId;
    THuiCanvasDrawMode iDrawMode;
    
    /** Clipping attributes */    
    RRegionBuf<KHuiCanvasGcRegionGranularity> iClippingRegion;
    THuiCanvasClipMode iClipMode;

    /** Delayed clipping attributes */    
    RRegionBuf<KHuiCanvasGcRegionGranularity> iDelayedClipRegion;
    TInt  iDelayedClipCount;
    TBool iDelayedClipRectPushed;
    TClipRectVisibility iDelayedClipVisibility;
    
    /** Setup/cleanup attributes */    
    TRgb iOldPencolor;
    TInt iOldPenAlpha;    

    /** Temp region */    
    mutable RRegionBuf<KHuiCanvasGcRegionGranularity> iTempRegion;
    mutable RRegionBuf<KHuiCanvasGcRegionGranularity> iTempRegion2;
    
    /** Flag to decide wheter pen alpha is to be multiplied with visual effective opacity */    
    TBool iEffectiveOpacityEnabled;
    
    /** Polygon fill texture, NOT owned */
    CHuiTexture* iPolygonFillTexture;
    TPoint iPolygonFillTextureOrigin;
    };

#endif