/*

* 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:    Implementation of Cloud view

 *

*/

#include "glxcontainerinfobubble.h" // class header

#include <glxtexturemanager.h> // For CGlxTextureManager

#include <glxuiutility.h>   // For CGlxUiUtility

#include <glxtracer.h>					

#include <glxlog.h>					// For Logs

#include <mpxmediageneraldefs.h>	// For Attribute constants

#include <glxcollectiongeneraldefs.h> //for KGlxMediaCollectionPluginSpecificSubTitle

#include <glxthumbnailattributeinfo.h>   // for 'KGlxMediaIdThumbnail'

#include <glxthumbnailcontext.h> //for thumbnail context

#include <glxattributecontext.h>  //for attribute context

#include <glxuistd.h>

#include <glxicons.mbg>

#include <mglxmedialist.h> //for medialist

#include <data_caging_path_literals.hrh>

// INCLUDE FILES

#include "glxerrormanager.h"

const TInt KThumbnailWidth = 50;

const TInt KThumbnailHeight = 50;

// ======== MEMBER FUNCTIONS ========

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

// Destructor

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

//

CGlxContainerInfoBubble::~CGlxContainerInfoBubble()

	{

	TRACER("GLX_CLOUD::CGlxContainerInfoBubble::~CGlxContainerInfoBubble");

    if ( iTexture )

        {

        if( iUiUtility )

            {          

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

            }

        }

	if ( iTimer)

		{

		iTimer->Cancel ();//cancels any outstanding requests

		delete iTimer;

		}

	if ( iMediaTitle)

		{

		delete iMediaTitle;

		}

	if ( iMediaSubTitle)

		{

		delete iMediaSubTitle;

		}

	if ( iMediaList)

		{

		iMediaList->RemoveContext (iAttributeContext);

		iMediaList->RemoveContext (iThumbnailContext);

		iMediaList->RemoveMediaListObserver (this);

		}

	if ( iAttributeContext)

		{

		delete iAttributeContext;

		}

	if ( iThumbnailContext)

		{

		delete iThumbnailContext;

		}

	}

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

// Two-phased constructor.

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

// 

EXPORT_C CGlxContainerInfoBubble *CGlxContainerInfoBubble::NewL(MGlxMediaList

		*aMediaList, CAlfEnv &aEnv, CAlfControl &aOwnerControl)

	{

	TRACER("GLX_CLOUD::CGlxContainerInfoBubble::NewL");

	CGlxContainerInfoBubble *self = CGlxContainerInfoBubble::NewLC(aMediaList,aEnv, aOwnerControl);

	CleanupStack::Pop(self);

	return self;

	}

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

// Two-phased constructor.

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

//

EXPORT_C CGlxContainerInfoBubble *CGlxContainerInfoBubble::NewLC(MGlxMediaList

		*aMediaList, CAlfEnv &aEnv, CAlfControl &aOwnerControl)

	{

	TRACER("GLX_CLOUD::CGlxContainerInfoBubble::NewLC");

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

	CleanupStack::PushL(self);

	self->ConstructL(aEnv, aOwnerControl);

	return self;

	}

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

// ShowNow()

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

//

void CGlxContainerInfoBubble::ShowNowL()

	{

	TRACER("GLX_CLOUD::CGlxContainerInfoBubble::ShowNow");

	// if we got texture, titles and timer is complete, show the bubble

	if ( iTexture && iMediaTitle && iMediaSubTitle && iTimerComplete )

		{

		//last three items will come from medialist

		DisplayBubbleL (iPos,*iTexture, *iMediaTitle, *iMediaSubTitle); //last three items will come from medialist

		}

	}

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

// ConstructL()

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

//

void CGlxContainerInfoBubble::ConstructL(CAlfEnv &aEnv, CAlfControl

&aOwnerControl)

	{

	TRACER("GLX_CLOUD::CGlxContainerInfoBubble::ConstructL");

	CGlxInfoBubble::BaseConstructL (aOwnerControl, aEnv);

	iTimer = CGlxBubbleTimer::NewL (this);

	//medialist code

	iAttributeContext = CGlxDefaultAttributeContext::NewL ();

	iAttributeContext->AddAttributeL (KMPXMediaGeneralTitle);

	iAttributeContext->AddAttributeL (KGlxMediaCollectionPluginSpecificSubTitle);

	iThumbnailContext = CGlxDefaultThumbnailContext::NewL ();

	iThumbnailContext->SetDefaultSpec (50, 50);

	iThumbnailContext->SetRangeOffsets (5, 5);

	iAttributeContext->SetRangeOffsets (10, 10);

	iMediaList->AddContextL (iAttributeContext, 

	                            KGlxFetchContextPriorityCloudViewInfoBubble );

	iMediaList->AddMediaListObserverL ( this);

	iMediaList->AddContextL (iThumbnailContext, 

	                            KGlxFetchContextPriorityCloudViewInfoBubble );  

	TInt listCount = iMediaList->Count ();

	GLX_LOG_INFO1("GLX_CLOUD ::CGlxContainerInfoBubble::ConstructL iMediaList->FocusIndex  %d ", iMediaList->FocusIndex ());

	GLX_LOG_INFO1("GLX_CLOUD ::CGlxContainerInfoBubble::ConstructL MedialistCount  %d ",listCount);

	if ( listCount)

		{

		SetAttributesL ();

		}

	}

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

// SetAttributes()

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

//

void CGlxContainerInfoBubble::SetAttributesL()

	{

	TRACER("GLX_CLOUD::CGlxContainerInfoBubble::SetAttributes()");

    // Set the attribute context here for fetching the list data		

    TSize size(KThumbnailWidth, KThumbnailHeight);	

	TMPXAttribute attrThumbnail(KGlxMediaIdThumbnail

	    ,GlxFullThumbnailAttributeId (ETrue, size.iWidth, size.iHeight)); 

	TGlxMedia media = iMediaList->Item (iMediaList->FocusIndex());

	TGlxIdSpaceId IdSpaceId = iMediaList->IdSpaceId(iMediaList->FocusIndex());

	// Get the Title, ignore return value

	GetMediaTitleL( media);

	// Get the subtitle, ignore return value

	GetMediaSubTitleL( media);

	//Get the thumbnail, ignore return value

	GetMediaThumbNailL( media, IdSpaceId, size, attrThumbnail );

	ShowNowL();

	}

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

// SetAttributes()

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

//

void CGlxContainerInfoBubble::SetAttributesL(

    const RArray<TMPXAttribute>& aAttributes,

    const TInt& aAttributescount )

	{

    TRACER("GLX_CLOUD::CGlxContainerInfoBubble::SetAttributesL");

    // Set the attribute context here for fetching the list data

    TSize size(KThumbnailWidth, KThumbnailHeight);	

	TMPXAttribute attrThumbnail(KGlxMediaIdThumbnail,

		GlxFullThumbnailAttributeId (ETrue, size.iWidth, size.iHeight)); 

    const TGlxMedia media = iMediaList->Item (iMediaList->FocusIndex());

	TGlxIdSpaceId IdSpaceId = iMediaList->IdSpaceId(iMediaList->FocusIndex());	

	TBool updateBubble = EFalse;

	// Loop untill it checks for all the avialable attributes

	for (TInt i = aAttributescount - 1; i >= 0 ; i--)

	    {

	    //Get the Title if the fetched attribute is MediaTitle

	    if ( aAttributes[i] == KMPXMediaGeneralTitle )

	        {

            // update bubble if we changed the title

	        updateBubble = GetMediaTitleL(media);

	        }

	    //Get the SubTitle if the fetched attribute is MediaSubTitle

    	else if ( aAttributes[i] == KGlxMediaCollectionPluginSpecificSubTitle)

	        {

            // update bubble if we changed the subtitle

	        updateBubble = GetMediaSubTitleL(media);

    	    }

    	//Get the ThumbNail if the fetched attribute is MediaThumbNail   

    	else if ( (attrThumbnail.ContentId() == aAttributes[i].ContentId())

    	     && (attrThumbnail.AttributeId() == aAttributes[i].AttributeId() ) )

	        {

            // update bubble if thumbnail changed

	        updateBubble = 

	            GetMediaThumbNailL( media, IdSpaceId, size, attrThumbnail );

   	        }

	     } 

	if ( updateBubble )

	    {

	    ShowNowL();

	    }

	}

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

// GetMediaTitle()

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

TBool CGlxContainerInfoBubble::GetMediaTitleL(const TGlxMedia& aMedia)

    {

    TRACER("GLX_CLOUD::CGlxContainerInfoBubble::GetMediaTitleL");

    // get current title

    const TDesC& title = aMedia.Title();

    // if we dont have a title

   	if( !iMediaTitle )

   	    {

   	    // we dont have a title so get the title

		iMediaTitle = title.AllocL();

		return ETrue;

	    }

    // if we have a title, but its different than new one (tag renamed)

    else if( iMediaTitle->Compare( title ) )

        {

        // allocate the new title

        HBufC* tempTitle = title.AllocL();

        // got new title so release old

        delete iMediaTitle;

        // assign new in place of old

        iMediaTitle = tempTitle;

        // did change title

        return ETrue;

        }

    return EFalse;

    }

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

// GetMediaSubTitle()

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

TBool CGlxContainerInfoBubble::GetMediaSubTitleL(const TGlxMedia& aMedia)

    {

    TRACER("GLX_CLOUD::CGlxContainerInfoBubble::GetMediaSubTitleL");

    // get current subtitle

    const TDesC& title = aMedia.SubTitle();

    // if we dont have a subtitle

    if( !iMediaSubTitle )

        {

        // we dont have a subtitle so get the title

        iMediaSubTitle = title.AllocL();

        return ETrue;

        }

    // if we have a subtitle, but its different than new one (count changed)

    else if( iMediaSubTitle->Compare( title ) )

        {

        // allocate the new subtitle

        HBufC* tempTitle = title.AllocL();

        // got new so release old

        delete iMediaSubTitle;

        // assign new in place of old

        iMediaSubTitle = tempTitle;

        // did change subtitle

        return ETrue;

        }

    return EFalse;

    }

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

// GetMediaThumbNailL()

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

//

TBool CGlxContainerInfoBubble::GetMediaThumbNailL(const TGlxMedia& aMedia,

    TGlxIdSpaceId& aIdSpaceId,TSize& aSize, 

    TMPXAttribute& aAttrThumbnail)

    {

    TRACER("GLX_CLOUD ::CGlxContainerInfoBubble::SetAttributesL Thumbnail available");

    //Get the thumbnail

    if ( aMedia.ThumbnailAttribute( aAttrThumbnail ) )

        {

        // take the address of the created texture

        iTexture = &( CreateThumbnailTextureL( aMedia, aIdSpaceId, aSize ) );

        return ETrue;

        }

    //If there is an error in thumbnail attribute i.e the thumbnail is broken then create broken thumbnail

    else if (GlxErrorManager::HasAttributeErrorL(aMedia.Properties(), KGlxMediaIdThumbnail) != KErrNone )

        {

        // create 'default' icon

        TFileName resFile(KDC_APP_BITMAP_DIR);

        resFile.Append(KGlxIconsFilename);

        TSize iconSize( KThumbnailWidth, KThumbnailHeight );    

        //Create the texture for broken thumbnail

        iTexture = &(iUiUtility->GlxTextureManager().CreateIconTextureL(

            EMbmGlxiconsQgn_prop_image_corrupted, resFile, iconSize ) );

        return ETrue;

        }

    return EFalse;

    }

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

// TimerCompleteL()

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

//

void CGlxContainerInfoBubble::TimerCompleteL()

	{

	TRACER("GLX_CLOUD::CGlxContainerInfoBubble::TimerCompleteL");

	iTimerComplete =ETrue;

	TRAP_IGNORE (ShowNowL ());

	}

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

// SetFocus()

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

//

void CGlxContainerInfoBubble::SetFocus(TPoint aPos)

	{

	TRACER("GLX_CLOUD::CGlxContainerInfoBubble::SetFocus");

	DisappearBubble ();

	if ( iTexture )

	    {

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

	    ResetImage();

	    iTexture = NULL;

	    }

	iPos = aPos;

	//fetch the attributes from medialsit

	iTimerComplete =EFalse;

	iTimer->Cancel ();//cancels any outstanding requests

	if ( iMediaTitle)

		{

		delete iMediaTitle;

		iMediaTitle =NULL;

		}

	if ( iMediaSubTitle)

		{

		delete iMediaSubTitle;

		iMediaSubTitle =NULL;

		}

	TRAP_IGNORE(SetAttributesL());

	iTimer->SetDelay (1500000);//1.5 seconds delay

	}

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

// Default C++ Constructor

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

//

CGlxContainerInfoBubble::CGlxContainerInfoBubble(MGlxMediaList *aMediaList) :

	CGlxInfoBubble(), iMediaList(aMediaList)

	{

	TRACER("GLX_CLOUD::CGlxContainerInfoBubble::CGlxContainerInfoBubble");

	}

//medialist Observers

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

// HandleItemAddedL().

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

//

void CGlxContainerInfoBubble::HandleItemAddedL(TInt /*aStartIndex*/,

		TInt /*aEndIndex*/, MGlxMediaList* /*aList*/)

	{

	}

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

// HandleMediaL().

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

//

void CGlxContainerInfoBubble::HandleMediaL(

    TInt /*aListIndex*/, MGlxMediaList* /*aList*/ )

	{

	}

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

// HandleItemRemoved().

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

//

void CGlxContainerInfoBubble::HandleItemRemovedL(TInt /*aStartIndex*/,

		TInt /*aEndIndex*/, MGlxMediaList* /*aList*/)

	{

	}

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

// HandleItemModifiedL().

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

//

void CGlxContainerInfoBubble::HandleItemModifiedL(

		const RArray<TInt>& /*aItemIndexes*/, MGlxMediaList* /*aList*/)

	{

	}

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

// HandleAttributesAvailableL().

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

//

void CGlxContainerInfoBubble::HandleAttributesAvailableL(TInt aItemIndex,

		const RArray<TMPXAttribute>& aAttributes, MGlxMediaList*/* aList*/)

	{

	TRACER("GLX_CLOUD::CGlxContainerInfoBubble::HandleAttributesAvailableL");

	TInt attCount = aAttributes.Count ();

	GLX_LOG_INFO1("GLX_CLOUD ::CGlxContainerInfoBubble::HandleAttributesAvailableL  count: %d ",attCount);

	GLX_LOG_INFO1("GLX_CLOUD ::CGlxContainerInfoBubble::HandleAttributesAvailableL  Item Index: %d ", aItemIndex);

	if ( ( attCount ) && (iMediaList->FocusIndex() == aItemIndex ) )

		{

		SetAttributesL( aAttributes, attCount );

		}

	}

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

// HandleFocusChangedL().

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

//

void CGlxContainerInfoBubble::HandleFocusChangedL(

		NGlxListDefs::TFocusChangeType /*aType*/, TInt /*aNewIndex*/,

		TInt /*aOldIndex*/, MGlxMediaList* /*aList*/)

	{

	}

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

// HandleItemSelected().

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

//

void CGlxContainerInfoBubble::HandleItemSelectedL(TInt /*aIndex*/,

		TBool /*aSelected*/, MGlxMediaList* /*aList*/)

	{

	}

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

// HandleMessageL().

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

//

void CGlxContainerInfoBubble::HandleMessageL(const CMPXMessage& /*aMessage*/,

		MGlxMediaList* /*aList*/)

	{

	}

//  End of File