/*

* Copyright (c) 2009 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:     

*

*/

#ifndef HGVGMEDIAWALLRENDERER_H_

#define HGVGMEDIAWALLRENDERER_H_

// INCLUDES

#include <e32base.h>

#include <VG/openvg.h>

#include <ganes/HgVgMediaWall.h>

/**

 * Helper abstract base class for drawing mediawall.

 */

NONSHARABLE_CLASS(CHgVgMediaWallRenderer) : public CBase

    {

public:

    /**

     * Factory method for constructing new MediaWallRenderer-Object

     */

    static CHgVgMediaWallRenderer* NewL(TInt aMaxQuads, const TRect& aWindowRect, 

            const TRect& aFrontRect, TReal aZOffset);

    /**

     * Destructor

     */

    virtual ~CHgVgMediaWallRenderer();

private:

    CHgVgMediaWallRenderer(const TRect& aWindowRect, 

            const TRect& aFrontRect, TReal aZOffset);

    void ConstructL(TInt aMaxQuads);

public:

    /**

     * Draws the mediawall.

     * 

     * @param aItems items to draw.

     * @param aSelectedIndex index of the selected item.

     * @param aViewPosition views position

     * @param aAnimationAlpha alpha from going from 0-1 during animation states.

     * @param aState current state of the animation.

     * @param aSelectionAnimationType type of the selection animation to use

     */

    void Draw(RPointerArray<CHgVgItem>& aItems,

            TInt aSelectedIndex, TReal aNextIndex,

            TReal aViewPosition,

            TReal aAnimationAlpha,

            CHgVgMediaWall::THgVgAnimationState aAnimationState, 

            CHgVgMediaWall::THgVgOpeningAnimationType aSelectionAnimationType, 

            CHgVgMediaWall::THgVgMediaWallStyle aStyle, 

            TReal aStartIndex, 

            TReal aSpringVelocity);

    /**

     * 

     */

    void DrawGrid(

            TInt aRowCount,

            RPointerArray<CHgVgItem>& aItems,

            TReal aViewX, TReal aViewY,

            TInt aCurItem, 

            TInt aPrevItem,

            TReal aAnimationAlpha,

            CHgVgMediaWall::THgVgAnimationState aAnimationState, 

            TInt aPickedItem, 

            CHgVgMediaWall::THgVgOpeningAnimationType aAnimationType);

    /**

     * Sets default icon for rendering items with no icons.

     * Ownership of the icon is not transfered.

     * 

     * @param aIcon reference to CGulIcon-object

     */

    void SetDefaultIconL(const CGulIcon& aIcon);

    /**

     * Sets Camera position modifier to use in rendering.

     * 

     * @param aCameraPosition camera position

     */

    void SetCameraPosition(TReal aX, TReal aY, TReal aZ);

    /**

     * Sets camera rotation modifiers to use in rendering.

     * 

     * @param aAngle angle in radians.

     */

    void SetCameraRotation(TReal aAngle);

    /**

     * Gets ItemIndex of a quad at pointer position.

     * NOTE: This is only valid after drawing.

     * 

     * @param aPointerPosition position of the pointer

     * @return ItemIndex or KErrNotFound if nothings if no hit.

     */

    TInt GetItemIndex(const TPoint& aPointerPosition) const;

    /**

     * This should be called by the client. When skin change event is triggered.

     * This rebuilds all renderers skin related internal resources.

     */

    void HandleSkinChange();

    /**

     * 

     */

    TReal GetWorldSpaceRowHeight() const;

    /**

     * 

     */

    void SetReflections(TBool aEnabled);

    /**

     * 

     */

    TBool ReflectionsEnabled() const;

    /**

     * 

     */

    TSize ImageSize() const;

    /**

     * 

     */

    void SetFlippedRect(const TRect& aFlippedRect);

    /*

     * 

     */

    void SetFlipAngle(TReal aAngle);

    /**

     * 

     */

    void EnableBlurOnFlip(TBool aEnabled, TReal aBlurX, TReal aBlurY);

    /**

     * 

     */

    void SetOffset(const TPoint& aOffset);

    /**

     * 

     */

    void EnableFlipXY(TBool aEnabled);

    /**

     * 

     */

    void EnableLandscapeMode(TBool enabled);

private:

    class TQuad

        {

    public:

        // quads world-space position

        VGfloat iX;

        VGfloat iY;

        VGfloat iZ;

        // quads angle

        VGfloat iAngle;

        // image used to draw this quad

        VGImage iImage;

        // transform constructed in TransformQuads for rendering

        VGfloat iTM[9];

        // transformed 2d points

        VGfloat iPoints[2*4];

        // index from CHgVgItem

        TInt iItemIndex;

        // flag indicating iImage is not valid, uses iDefaultImage then.

        TBool iNoImage;

        //

        VGfloat iAlpha;

        VGfloat iMirroredPoints[2*4];

        VGfloat iMirroredTM[9];

        TBool iFlipped;

        };

    /**

     * 

     */

    void GetGroundColorFromSkin(VGfloat* aColor);

    /**

     * Transforms quads

     */

    void TransformQuads(TInt aNumVisibleQuads, TBool aMirrored, 

            VGfloat aFov, CHgVgMediaWall::THgVgOpeningAnimationType aOpeningAnimationType);

    /**

     * Sorts quads by z from iQuads to sorted quads.

     */

    void SortQuadsL(TInt aNumVisibleNumQuads);

    /**

     * Draws quads using VG

     */

    void DrawQuads(TBool aDrawMirrored);

    /**

     * Draws one quad using OpenVG

     */

    void DrawQuad(TQuad* q, TBool aDrawMirrored);

    /**

     * Setups quads into their positions/orientations, after this they can by transformed

     * and rendered.

     */

    TInt SetupQuads(RPointerArray<CHgVgItem>& aItems,

            TInt aSelectedIndex, TReal aNextIndex,

            VGfloat aViewPosition,

            VGfloat aAnimationAlpha,

            CHgVgMediaWall::THgVgAnimationState aState, 

            CHgVgMediaWall::THgVgOpeningAnimationType aAnimationType, 

            TReal aStartIndex, 

            TReal aSpringVelocity);

    /**

     * Setups quads for grid mediawall style.

     */

    void SetupQuadsToRow(

            TInt aRow,

            TInt aRowCount,

            TInt& aItemsOnScreen,

            RPointerArray<CHgVgItem>& aItems,

            TReal aViewX, TReal aViewY,

            TInt aCurItem, TInt aPrevItem, 

            TReal aAnimationAlpha,

            CHgVgMediaWall::THgVgAnimationState aAnimationState, 

            TInt aPickedItem, 

            CHgVgMediaWall::THgVgOpeningAnimationType aAnimationType);

    /**

     * Applies flip animation to a quad.

     */

    void ApplyOpeningAnimation(CHgVgMediaWallRenderer::TQuad* aQuad, 

            TReal aAnimationAlpha, TReal aZNear, CHgVgMediaWall::THgVgMediaWallStyle aMediaWallStyle, 

            CHgVgMediaWall::THgVgOpeningAnimationType aAnimationStyle);

    /**

     * Creates path and paint for ground.

     */

    void CreateGround();

    /**

     * Draws ground.

     * @param aWidth width of the ground.

     * @param aHeight height of the ground.

     */

    void DrawGround(TInt aWidth, TInt aHeight);

    /**

     * 

     */

    void TransformAndDraw(TInt itemsOnScreen, 

            CHgVgMediaWall::THgVgOpeningAnimationType aOpeningAnimationType);

    /**

     * 

     */

    void AdjustSettingsBasedOnRects(const TRect& aFrontRect, 

            TReal aZOffset);

    /**

     * 

     */

    VGfloat GetZInWorldSpaceBasedOnWidth(VGfloat aWidth);

    /**

     * 

     */

    void UpdateBlurChildImage(VGImage aImage);

private: 

    VGint iMaxQuads;

    TRect iRect;    

    VGfloat iCameraX;

    VGfloat iCameraY;

    VGfloat iCameraZ;

    VGfloat iCameraRotation;

    VGImage iDefaultImage;

    RPointerArray<TQuad> iQuads;

    RPointerArray<TQuad> iSortedQuads;

    VGPaint iGroundPaint;

    VGPath iGroundPath;     

    VGfloat iSelectedQuadStartX;

    VGfloat iSelectedQuadStartY;

    TBool iReflectionsEnabled;

    TSize iImageSize;

    VGfloat iCameraBaseX;

    VGfloat iCameraBaseY;

    VGfloat iCameraBaseZ;

    VGfloat iFlippedX;

    VGfloat iFlippedY;

    VGfloat iFlippedZ;

    // Which item is the front item in coverflow

    TInt iSelectedItemIndex;

    // Ending position of the left album stack

    TReal iLeftStackEndX;

    // Ending position of the right album stack

    TReal iRightStackStartX;

    // Z-coordinate of the frontmost album

    TReal iZNear;

    // Z-coordinate of the albums on the back

    TReal iZFar;

    // Space between albums in stacks

    TReal iSpaceBetween;    

    // How much to zoom when fast swiped

    TReal iFov;

    // angle to flip the item around X-axis in flip opening animation

    TReal iFlipAngle;

    VGImage iBlurImage;

    VGfloat iBlurAlpha;

    VGfloat iBlurDeviationX;

    VGfloat iBlurDeviationY;

    VGfloat iFlippedWidth;

    VGfloat iFlippedHeight;

    VGint iBlurImageWidth;

    VGint iBlurImageHeight;

    VGImage iChildBlurImage;

    TPoint iOffset;

    TBool iFlipXY;

    TBool iLandscape;

    };

#endif /* HGVGMEDIAWALLRENDERER */