/*

* Copyright (c) 2008-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:    Item visual container

*

*/

/**

 * @internal reviewed 04/07/2007 by M Byrne

 */

#include "glxitemvisual.h"

#include <alf/alfanchorlayout.h>

#include <alf/alfcontrol.h>

#include <alf/alfdecklayout.h>

#include <AknUtils.h>

#include <alf/alfimagevisual.h>

#include <alf/alfimagebrush.h>

#include <alf/alfdisplay.h>

#include <alf/alfenv.h>

#include <alf/alftexture.h>

#include <mpxmediageneraldefs.h>

#include <imageconversion.h>

#include <glxlog.h>

#include <glxtracer.h>

#include <glxassert.h>

#include <glxuiutility.h>

#include <glxmedia.h>

#include <glxmediageneraldefs.h>

#include <glxtexturemanager.h>

#include <glxthumbnailattributeinfo.h>

#include <mglxmedialist.h>

#include <glxthumbnailutility.h>

#include <alf/alftransformation.h>

#include "mglxvisualobjectstatusobserver.h"

#include "mglxvisualobjectlayoutrefreshobserver.h"

const TInt KGlxOpacityFadeDuration = 400;

const TInt KGlxForegroundAnchorOrdinal = 2;

// -----------------------------------------------------------------------------

// Constructor. Inlined to save a few bits of rom

// -----------------------------------------------------------------------------

inline CGlxVisualObject::CGlxVisualObject( MGlxMediaList& aMediaList)

    : iMediaList( aMediaList )

    {

    // No implementation

    }

// -----------------------------------------------------------------------------

// NewLC

// -----------------------------------------------------------------------------

CGlxVisualObject* CGlxVisualObject::NewLC( 

            MGlxVisualObjectParameterFactory& aFactory,MGlxMediaList& aMediaList)

    {

    TRACER("CGlxVisualObject::NewLC");

    CGlxVisualObject* self = new ( ELeave ) CGlxVisualObject( aMediaList);

    CleanupStack::PushL( self );

    self->ConstructL( aFactory );

    return self;

    }

// -----------------------------------------------------------------------------

// Destructor

// -----------------------------------------------------------------------------

CGlxVisualObject::~CGlxVisualObject()

    {

    TRACER("CGlxVisualObject::~CGlxVisualObject");

    iForegroundIconAnchors.Close();

    iBackgroundIconAnchors.Close();

    while ( iZoomTiles.Count() )

        {

        RemoveZoomTile(0);

        }

    iZoomTiles.Close();

	if ( iUiUtility && iImageValid )

        {

        // Clean up the texture from the texture manager

        iUiUtility->GlxTextureManager().RemoveTexture( iImage.Texture() );

        }

    if ( iVisual )

        {

        iVisual->RemoveAndDestroyAllD();

        }

        delete iAnimatedTexture;

    if ( iUiUtility )

        {

        iUiUtility->Close();

        }

    iObservers.Close();

    }

// -----------------------------------------------------------------------------

// ConstructL

// -----------------------------------------------------------------------------

void CGlxVisualObject::ConstructL( MGlxVisualObjectParameterFactory& aFactory) 

    {

    TRACER("CGlxVisualObject::ConstructL");

    iUiUtility = CGlxUiUtility::UtilityL();

    // create the visual with parents layout

    iVisual = CAlfAnchorLayout::AddNewL(aFactory.VisualOwner(),

                                        aFactory.Layout());

    iVisual->EnableTransformationL();

    // create background underlay anchor layout 

    //to act as a black screen and avoid overlapping images                                      

    iBackgroundOverlayVisual = 

        CAlfImageVisual::AddNewL( aFactory.VisualOwner(), iVisual); 

    CAlfTexture& backgroundTexture = 

    	iUiUtility->GlxTextureManager().CreateFlatColourTextureL(KRgbBlack);

    iBackgroundOverlayVisual->SetClipping(ETrue);	

    iBackgroundOverlayVisual->SetImage(TAlfImage(backgroundTexture));	

    // create main visual

    iMainVisual = 

        CAlfAnchorLayout::AddNewL( aFactory.VisualOwner(), iVisual );    

    // create the child image visual

    iImageVisual = 

        CAlfImageVisual::AddNewL( aFactory.VisualOwner(), iMainVisual );

    //iImageVisual->SetScaleMode( aFactory.ThumbnailScaleMode() );

	iImageVisual->SetScaleMode(CAlfImageVisual::EScaleNormal);

    // Turn on clipping only if cover-mode has been chosen

    iImageVisual->SetClipping(ETrue);

	User::LeaveIfError( iMainVisual->SetRelativeAnchorRect(

  	0, EAlfAnchorOriginLeft, EAlfAnchorOriginTop, TAlfRealPoint(),

	 EAlfAnchorOriginRight, EAlfAnchorOriginBottom, TAlfRealPoint() ) );

	// get screen size

	SetVisible(EFalse);

	TSize screenSize = iUiUtility->DisplaySize();

    RefreshLayout( screenSize );	

    }

// -----------------------------------------------------------------------------

// SetScaleMode

// -----------------------------------------------------------------------------

//

EXPORT_C void CGlxVisualObject::SetScaleMode(CAlfImageVisual::TScaleMode aMode)

    {

    TRACER("CGlxVisualObject::SetScaleMode");

    iImageVisual->SetScaleMode(aMode);

    }

// -----------------------------------------------------------------------------

// Reset state of the object as if it had just been constructed

// -----------------------------------------------------------------------------

//

void CGlxVisualObject::Reset() 

    {

    TRACER("CGlxVisualObject::Reset");

    SetVisible(EFalse);

    StopAnimation();

    iAnimateWhenAttributesAvailable = EFalse;

    iUiUtility->GlxTextureManager().RemoveTexture(iImage.Texture());

    }

// -----------------------------------------------------------------------------

// Remove and delete all child visuals of the layout

// @param aLayout layout to reset

// -----------------------------------------------------------------------------

//	

void CGlxVisualObject::ResetLayout( CAlfVisual& /*aVisual*/ )

    {

    //to be used when layouts are back

    // until no visuals left

    }

// -----------------------------------------------------------------------------

// Visual

// -----------------------------------------------------------------------------

CAlfVisual* CGlxVisualObject::Visual()

	{

	TRACER("CGlxVisualObject::Visual");

	return iVisual;

	}

// -----------------------------------------------------------------------------

// SetVisible

// -----------------------------------------------------------------------------

void CGlxVisualObject::SetVisible( TBool aVisible )

    {

    TRACER("CGlxVisualObject::SetVisible");

    if(aVisible)

	    {

	    iVisual->SetOpacity(  TAlfTimedValue(1.0 , 0 ));	

	    }

    else

	    {

	    iVisual->SetOpacity( TAlfTimedValue(0.0, 0 ));	

	    }

    }

// -----------------------------------------------------------------------------

// SetIndex

// -----------------------------------------------------------------------------

void CGlxVisualObject::SetIndex( TInt aIndex )

	{

	TRACER("CGlxVisualObject::SetIndex");

	GLX_LOG_INFO1("CGlxVisualObject::SetIndex %d",aIndex);

	iIndex = aIndex;

	}

// -----------------------------------------------------------------------------

// SetImage

// -----------------------------------------------------------------------------

void CGlxVisualObject::SetImage( TAlfImage aImage )

	{

	TRACER("CGlxVisualObject::SetImage");

	iImageVisual->SetImage( aImage );

	iImage = aImage;

	iImageValid = ETrue;

	}

// -----------------------------------------------------------------------------

// Image

// -----------------------------------------------------------------------------

TAlfImage CGlxVisualObject::Image()

	{

	TRACER("CGlxVisualObject::Image");

	return iImage;

	}

// -----------------------------------------------------------------------------

// RefreshLayout

// the visual list has requested us to refresh the layout

// -----------------------------------------------------------------------------

void CGlxVisualObject::RefreshLayout( TSize /*aScreenSize*/ )

	{

	TRACER("CGlxVisualObject::RefreshLayout");

    // get texture manager

    CGlxTextureManager& textureMgr = iUiUtility->GlxTextureManager();

    // get new size, note that this is synchronous c/s call

	TSize visSize = Visual()->Size().ValueNow().AsSize();

	// check if visual size has changed since last time

	if( visSize != iVisSize )

	    {

	    // store size

	    iVisSize = visSize;

	    // get the media id and id space id for this index

	    TGlxMedia item = iMediaList.Item( iIndex );

	    TGlxIdSpaceId idspace = iMediaList.IdSpaceId( iIndex );

        // check if there was a better thumbnail available

        if( textureMgr.TextureNeedsUpdating( item, idspace, visSize ) )

            {

            // need to update the texture

            TRAP_IGNORE(CAlfTexture& texture = 

                textureMgr.CreateThumbnailTextureL( 

                    item, idspace, visSize, this );

            // set the new texture in place

        	SetImage( TAlfImage( texture ) ));

            }

        // update positions of overlay icons            

        UpdateIconAnchors( Image().Texture(), visSize );             

	    }

	}

// -----------------------------------------------------------------------------

// HandleAttributesAvailableL

// -----------------------------------------------------------------------------

//

void CGlxVisualObject::HandleAttributesAvailableL(

    const TGlxIdSpaceId& aIdSpaceId, const TGlxMedia& aItem,

    const RArray<TMPXAttribute>& aAttributes)

    {

    TRACER("CGlxVisualObject::HandleAttributesAvailableL");

    TBool animate = ( EHasDefaultIcon == Status() );

    // get texture manager

    CGlxTextureManager& textureMgr = iUiUtility->GlxTextureManager();

    // get new size, note that this is synchronous c/s call          

    TSize visSize = iUiUtility->DisplaySize();

    // check if there was a better thumbnail available

    if( textureMgr.TextureNeedsUpdating( aItem, aIdSpaceId, visSize ) )

        {

        // need to update the texture

        CAlfTexture& texture = 

            textureMgr.CreateThumbnailTextureL( 

                aItem, aIdSpaceId, visSize, this );

        // set the new texture in place

    	SetImage( TAlfImage( texture ) );

        // update positions of overlay icons 

        UpdateIconAnchors( Image().Texture(), visSize );             

        if ( animate && iObserver )

            {

            iObserver->ThumbnailLoadedL( *this );

            }

        }

    if ( iAnimateWhenAttributesAvailable )

        {

        TryAnimateL(aItem);

        }

    }

// -----------------------------------------------------------------------------

// StartAnimation

// -----------------------------------------------------------------------------

void CGlxVisualObject::StartAnimation( CAlfTexture& aAnimatedTexture )

    {

    TRACER("CGlxVisualObject::StartAnimation");

    // if we have an old texture

    if ( iAnimatedTexture )

        {

        // release the old texture

        iUiUtility->GlxTextureManager().RemoveTexture( *iAnimatedTexture );

        iAnimatedTexture = NULL;

        }

    // store the texture pointer so that we can stop it without a 

    // reference to the texture

    iAnimatedTexture = &aAnimatedTexture;

    // start the animation

    aAnimatedTexture.StartAnimation();

    // set the image to the visual

    iImageVisual->SetImage( TAlfImage( aAnimatedTexture ) );

    }

// -----------------------------------------------------------------------------

// StopAnimation

// -----------------------------------------------------------------------------

void CGlxVisualObject::StopAnimation()

    {

    TRACER("CGlxVisualObject::StopAnimation");

    if ( iAnimatedTexture )

        {

        iImageVisual->SetImage( iImage );

        // stop the animation

        iAnimatedTexture->StopAnimation();

        // release the texture

        iUiUtility->GlxTextureManager().RemoveTexture( *iAnimatedTexture );

        iAnimatedTexture = NULL;

        }

    }

// -----------------------------------------------------------------------------

// SetAnimateWhenAttributesAvailable

// -----------------------------------------------------------------------------

void CGlxVisualObject::SetAnimateWhenAttributesAvailable(TBool aFlag)

    {

    TRACER("CGlxVisualObject::SetAnimateWhenAttributesAvailable");

    iAnimateWhenAttributesAvailable = aFlag;

    }

// -----------------------------------------------------------------------------

// TryAnimateL

// -----------------------------------------------------------------------------

//

void CGlxVisualObject::TryAnimateL(const TGlxMedia& aItem)

    {

    TRACER("CGlxVisualObject::TryAnimateL");

    TInt frameCount = 0;

    TSize mediaItemSize( KErrNotFound, KErrNotFound );

    aItem.GetDimensions( mediaItemSize );

    if ( aItem.GetFrameCount( frameCount ) )

        {

        const TDesC& uri = aItem.Uri();

        if (frameCount > 1 && uri.Length() > 0)

            {

            // create the animated texture from the URI

    		CAlfTexture& animTexture =

    		   iUiUtility->GlxTextureManager().CreateAnimatedGifTextureL( uri, mediaItemSize );

            StartAnimation( animTexture );

    		}

        SetAnimateWhenAttributesAvailable(EFalse);

		}

    else

        {

        SetAnimateWhenAttributesAvailable(ETrue);

        }

    }

// -----------------------------------------------------------------------------

// RemoveOldZoomTiles

// -----------------------------------------------------------------------------

//

void CGlxVisualObject::RemoveOldZoomTiles(const TGlxMedia& aItem)

    {

    TRACER("CGlxVisualObject::RemoveOldZoomTiles");

    const CGlxMedia* properties = aItem.Properties();

    TInt firstPosition = iZoomTiles.Count();

    for ( TInt i = iZoomTiles.Count() - 1; i >= 0; i-- )

        {

        if ( !(properties && properties->IsSupported(TMPXAttribute(

                        KGlxMediaIdThumbnail, iZoomTiles[i].iAttributeId))) )

            {

            RemoveZoomTile(i);

            firstPosition = i;

            }

        }

    ReanchorZoomTiles( firstPosition );

    }

// -----------------------------------------------------------------------------

// AddNewZoomTilesL

// -----------------------------------------------------------------------------

//

void CGlxVisualObject::AddNewZoomTilesL(TGlxIdSpaceId aIdSpaceId,

            const TGlxMedia& aItem, const RArray<TMPXAttribute>& aAttributes)

    {

    TRACER("CGlxVisualObject::AddNewZoomTilesL");

    // Get dimension if we don't already have it

    if ( (iDimensions.iWidth == 0 || iDimensions.iHeight == 0) )

        {

        // Ignore success/failure return, test dimension instead

        aItem.GetDimensions(iDimensions);

        }

    if ( iDimensions.iWidth == 0 || iDimensions.iHeight == 0 )

        {

        return;

        }

    TInt firstPosition = iZoomTiles.Count();

    // Check new attributes for cropped thumbnails

    TInt count = aAttributes.Count();

    for ( TInt i = 0; i < count; i++ )

        {

        TMPXAttribute attr(aAttributes[i]);

        if ( KGlxMediaIdThumbnail == attr.ContentId()

            && !GlxIsFullThumbnailAttribute( attr.AttributeId() ) )

            {

            const CGlxThumbnailAttribute* thumbnail = 

                                          aItem.ThumbnailAttribute( attr );

            if ( thumbnail )

                {

                TInt position = AddZoomTileL( aItem, attr, aIdSpaceId,

                                                thumbnail->iCroppingRect );

                if ( position < firstPosition )

                    {

                    firstPosition = position;

                    }

                }

            }

        }

    ReanchorZoomTiles( firstPosition );

    }

// -----------------------------------------------------------------------------

// RemoveZoomTile

// -----------------------------------------------------------------------------

//

void CGlxVisualObject::RemoveZoomTile(TInt aIndex)

    {

    TRACER("CGlxVisualObject::RemoveZoomTile");

    __ASSERT_ALWAYS(0 <= aIndex && aIndex < iZoomTiles.Count(),

                                            Panic(EGlxPanicIllegalArgument));

    CAlfImageVisual* visual = iZoomTiles[aIndex].iVisual;

	const TAlfImage& image = visual->Image();

	if( image.HasTexture() )

	    {

        iUiUtility->GlxTextureManager().RemoveTexture( image.Texture() );

	    }

	iVisual->Owner().Remove(visual);   // Caller gets ownership of the visual

    delete visual;

    iZoomTiles.Remove(aIndex);

    }

// ---------------------------------------------------------------------------

// AddZoomTileL

// ---------------------------------------------------------------------------

//

TInt CGlxVisualObject::AddZoomTileL(

                    const TGlxMedia& aItem, const TMPXAttribute& aAttribute,

                    TGlxIdSpaceId aIdSpaceId, const TRect& aCroppingRect )

    {

    TRACER("CGlxVisualObject::AddZoomTileL");

    // Reserve space for new tile

    iZoomTiles.ReserveL( iZoomTiles.Count() + 1 );

    // Extract zoom level field from attribute ID

    TInt zoomLevel = GlxZoomedThumbnailZoomLevel( aAttribute.AttributeId() );

    TInt position = 0;

    // Lowest zoom level goes to highest position (front)

    while ( position < iZoomTiles.Count()

            && zoomLevel < iZoomTiles[position].iZoomLevel )

        {

        position++;

        }

    CAlfImageVisual* visual = CAlfImageVisual::AddNewL(

                            static_cast<CAlfControl&>( iMainVisual->Owner() ),

                            iMainVisual );

    CleanupStack::PushL(visual);

    // Set temporary anchor to reserve space in anchors array

    TInt ordinal = iMainVisual->ChildOrdinal( iMainVisual->Count() - 1 );

    User::LeaveIfError( iMainVisual->SetRelativeAnchorRect( ordinal,

            EAlfAnchorOriginLeft, EAlfAnchorOriginTop, TAlfRealPoint(),

            EAlfAnchorOriginLeft, EAlfAnchorOriginTop, TAlfRealPoint() ) );