/*

* 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 Metadata dialog

*

*/

#include  "glxmetadatacontainer.h"

#include  "glxustringconverter.h"        		 // converts the symbian types to UString type

#include  <AknUtils.h>

#include  <StringLoader.h>

#include  <glxmetadatadialog.rsg>

#include  <glxviewbase.rsg>

#include  <glxlog.h>

#include  <glxtracer.h>

#include  <glxscreenfurniture.h>

#include  <glxdetailsmulmodelprovider.h>  		  //Details data provider

#include  <glxdetailsboundcommand.hrh>

#include  <glxcommandhandleraddtocontainer.h>     // For CGlxCommandHandlerAddToContainer

#include  <glxcommandhandlers.hrh>                // for command handler id

#include  <glxcommandfactory.h>                   //for command factory

#include  <mpxcommandgeneraldefs.h>               // Content ID identifying general category of content provided

#include  "mglxmetadatadialogobserver.h"

#include  <glxtextentrypopup.h>    

#include  <glxcollectionpluginall.hrh>

#include  <glxuistd.h>

#include  <glxcollectionplugintags.hrh>       	  // tag collection plugin uid

#include  <glxthumbnailattributeinfo.h>           // KGlxMediaIdThumbnail

#include  <glxattributeretriever.h>               // CGlxAttributeReteiver

#include  <aknQueryControl.h>

#include  <glxdrmutility.h>                       //For launching DRM details pane

#include  <glxgeneraluiutilities.h>               // General utilties class definition

#include  <ExifModify.h>    

#include  <glxuiutilities.rsg>                    //For CExifModify

#include  <mpxmediadrmdefs.h>

#include  <glxfilterfactory.h>

#include  <caf/manager.h>						  //For Filesystem

//marquee

#include <eikfrlb.h>

#include <eikfrlbd.h>

const TInt KMaxMediaPopupTitleLength = 0x100;

const TInt KMediaListId  			 = 0x2000D248;

const TInt KOffsets					 = 50;

const TInt KMarqueeLoopCount         = 3;

const TInt KMarqueeScrollAmount      = 20;

const TInt KMarqueeScrollDelay       = 1000000;

const TInt KMarqueeScrollInterval    = 200000;

_LIT( KGlxTextSetter, "");

_LIT( KGlxComma, ",");

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

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

// NewL

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

//	

CGlxMetadataContainer* CGlxMetadataContainer::NewL( const TRect& aRect,

                                                    MGlxMetadataDialogObserver& aDialogObserver,

                                                    const TDesC& item,MToolbarResetObserver& aResetToolbarObs)

	{

	TRACER("CGlxMetadataContainer::NewL");	

	CGlxMetadataContainer* self = CGlxMetadataContainer::NewLC( aRect,

                                                                aDialogObserver,item,aResetToolbarObs);

	CleanupStack::Pop(self);

	return self;

	}

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

// NewLC

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

//	

CGlxMetadataContainer* CGlxMetadataContainer::NewLC( const TRect& aRect,

													 MGlxMetadataDialogObserver&  aDialogObserver,

													 const TDesC& aUri,MToolbarResetObserver& aResetToolbarObs)

	{

	TRACER("CGlxMetadataContainer::NewLC");	

	CGlxMetadataContainer* self = new(ELeave) CGlxMetadataContainer(aDialogObserver,aUri,aResetToolbarObs);

	CleanupStack::PushL(self);

	self->ConstructL( aRect);

	return self;

	}

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

// CGlxMetadataContainer

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

//	

CGlxMetadataContainer::CGlxMetadataContainer(MGlxMetadataDialogObserver& aDialogObserver,

                                              const TDesC& aUri,MToolbarResetObserver& aResetToolbarObs)

					  :iDialogObesrver ( aDialogObserver ),iUri(aUri),iResetToolbarObs(aResetToolbarObs)

    {

    // No implementation

    }

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

// CGlxMetadataContainer::ConstructL

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

//	

void CGlxMetadataContainer::ConstructL( const TRect& /*aRect*/ )

	{	

	//Creating the RBuf texts for all the items except tags & albums

	//which would be updated as whne the item is edited

	iTextSetter.CreateL(KMaxFileName);

	//RBuf text which would be updated as when a tag is edited for the item.

	iTagSetter.CreateL(KMaxFileName);

	//RBuf text which would be updated as when a album is edited for the item.

	iAlbumSetter.CreateL(KMaxFileName);

	//Create medialist filtered by uri - iUri

	CreateMediaListForSelectedItemL();

	//Setting the iVideo flag to EFalse initially	

	iVideo = EFalse;

	//Setting the iMarquee flag to EFalse initially

    iMarquee = EFalse;

    //check when Remove location information is selected.

    iLocationinfo = EFalse;

	//Creating a CGlxMetadataAsyncUpdate object

	iAsyncRequest = CGlxMetadataAsyncUpdate::NewL(*this);

	//Initializing to NULL

	iModifiedUri = NULL;	

	//Flag to check if rename is completed successfully.

	iRenameCompleted = EFalse;

	}

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

// ~CGlxMetadataContainer

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

//	

CGlxMetadataContainer::~CGlxMetadataContainer()

	{

	TRACER("CGlxMetadataContainer::~CGlxMetadataContainer");

	if( iItemMediaList ) 

		{

		iItemMediaList->RemoveContext(iMainListAttributecontext);

		iItemMediaList->RemoveMediaListObserver(this);

		iItemMediaList->Close();

		iItemMediaList = NULL;  

		} 

    if ( iTagMediaList ) 

		{

		iTagMediaList->RemoveContext(iTagContext);

		iTagMediaList->RemoveMediaListObserver(this); 

		iTagMediaList->Close();

		iTagMediaList = NULL;

		}

    if ( iAlbumMediaList ) 

		{

		iAlbumMediaList->RemoveContext(iAlbumContext);

		iAlbumMediaList->RemoveMediaListObserver(this); 

		iAlbumMediaList->Close();

		iAlbumMediaList = NULL;

		}

    if( iTagContext )

		{

        delete iTagContext;

        iTagContext = NULL;

		}    

    if( iAlbumContext )

		{

        delete iAlbumContext;

        iAlbumContext = NULL;

		}

    if( iMainListAttributecontext )

        {

        delete iMainListAttributecontext;

        iMainListAttributecontext = NULL;

        }       

    if( IsVisible() )

	    {

	    MakeVisible(EFalse);

	    }

    iTextSetter.Close();

    iTagSetter.Close();

    iAlbumSetter.Close();

    if(iAsyncRequest) 	

	    {

    	delete iAsyncRequest;

	    }

	if(iModifiedUri)

		{

		delete iModifiedUri;

		}

	}

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

// CGlxMetadataContainer::MediaList

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

MGlxMediaList& CGlxMetadataContainer::MediaList()

    {

    //returns the active medialist.

    return *iItemMediaList;    

    }

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

// CGlxMetadataContainer::CreateSettingItemL

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

CAknSettingItem* CGlxMetadataContainer::CreateSettingItemL(TInt aResourceId)

    {

    TRACER("CGlxMetadataContainer::CreateSettingItemL");      

    CAknSettingItem* settingItem = NULL; // No need to push onto cleanup stack

	iTextSetter.Zero();

    //Creating a empty Settings list box which will  be populated with metadata in handleattributeavailable

    switch(aResourceId)

        {

        case ENameItem:

        case EDateAndTimeItem:

        case EDescriptionItem:

            {

            settingItem = new (ELeave) CAknTextSettingItem( 

                                             aResourceId, iTextSetter );

            break;          

            }

        case ETagsItem:

            {

             iTagSetter.Copy(KGlxTextSetter);

             settingItem = new (ELeave) CAknTextSettingItem(

                                                             aResourceId, iTagSetter );

            break;          

            }

        case EAlbumsItem:

            {            

            iAlbumSetter.Copy(KGlxTextSetter);

            settingItem = new (ELeave) CAknTextSettingItem( 

                                                  aResourceId, iAlbumSetter );

            break;          

            }

        case ELocationItem:

        case ESizeItem:            

        case EResolutionItem:

            {

            settingItem = new (ELeave) CAknTextSettingItem( 

                                                  aResourceId, iTextSetter );

            break;          

            }            

        case EDurationItem:

        case ElicenseItem:

            {

              settingItem = new (ELeave) CAknTextSettingItem( 

                                                         aResourceId, iTextSetter );

							//Hide the item until we get the attributes

							//where in we check for the usage rights.                                                                                                            

              settingItem->SetHidden(ETrue);

              //Required to refresh the listbox when any items visiblity is changed

              this->HandleChangeInItemArrayOrVisibilityL();

             }

            break;

        default:

            {

            break;    

            }

        }

    return settingItem;

    }

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

// CGlxMetadataContainer::IsItemModifiable

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

TBool CGlxMetadataContainer::IsItemModifiable()

    {

    //Only items like name , description, tag and albums are modifiable

    //The check is for the items from ENameItem(0) tille ETagsItem(4)

    if(ListBox()->CurrentItemIndex()<=ETagsItem)

        {

        return EFalse;

        }

    //return ETrue to dim the item

    return ETrue;

    }

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

// CGlxMetadataContainer::IsLicenseItem

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

TBool CGlxMetadataContainer::IsLicenseItem()

    {

    //Checks the item for DRMProtection.

    //if item is a video item index should be ELicense else check for EDuration Item.

    //because License Item index would become EDuration as the duration item is hidden in case of inage file.

    if((!iVideo && ListBox()->CurrentItemIndex()== EDurationItem) 

            || (ListBox()->CurrentItemIndex()== ElicenseItem))

        {

        return EFalse;

        }

    return ETrue;

    }

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

// CGlxMetadataContainer::IsLocationItem

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

TBool CGlxMetadataContainer::IsLocationItem()

    {

    //if its location item - enable the delete option

    if (iItemMediaList->Count() && ListBox()->CurrentItemIndex()

            == ELocationItem)

        {

        const TGlxMedia& item = iItemMediaList->Item(0);

        TCoordinate coordinate;

        if (item.GetCoordinate(coordinate))

            {

            return EFalse;

            }

        return ETrue;

        }

    //return ETrue to dim the item

    return ETrue;

    }

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

// CGlxMetadataContainer::HandleListBoxEventL

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

void CGlxMetadataContainer::HandleListBoxEventL(CEikListBox*  /*aListBox*/,

                                                    TListBoxEvent aEventType)

    {

    GLX_LOG_INFO("CGlxMetadataContainer::HandleListBoxEventL");         

    if ((aEventType == EEventEnterKeyPressed) || 

        (aEventType == EEventEditingStarted) ||

        (aEventType == EEventItemSingleClicked))

        {

        //handle edit functionality if items when useer selects via touch

        HandleListboxChangesL();

        }

    }

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

// CGlxMetadataContainer::HandleListboxChangesL

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

void CGlxMetadataContainer::HandleListboxChangesL()

    {

    if(iItemMediaList->Count() == 0)

    	{

    	return;

    	}

    TInt index = ListBox()->CurrentItemIndex();

    switch(index)

        {

        case ENameItem:        

        case EDescriptionItem:

            {

            SetNameDescriptionL(index);

            break;

            }

        case ETagsItem:

			{

			//Set the focus of the item	

			iItemMediaList->SetFocusL(NGlxListDefs::EAbsolute,0);

			//Launch add to container commandhandler via dialog observer.

			iDialogObesrver.AddTagL();

			break;         

			}

        case EAlbumsItem:

			{

			//Set the focus of the item	

			iItemMediaList->SetFocusL(NGlxListDefs::EAbsolute,0);

			//Launch add to container commandhandler via dialog observer.

			iDialogObesrver.AddAlbumL();

			break;          

			}

		case ELocationItem:

			{

			// Get the Media Item

			const TGlxMedia& media = iItemMediaList->Item(0);    

			// Test to see if the Coordinate is Present

			TCoordinate coordinate;

			if( !media.GetCoordinate(coordinate) )

				{

				HBufC *noLocationBuf = StringLoader::LoadLC(R_GLX_METADATA_NOTE_INFO_NO_LOCATION);

				GlxGeneralUiUtilities::ShowInfoNoteL(*noLocationBuf,ETrue);

				CleanupStack::PopAndDestroy(noLocationBuf);

				}

			break;

			}

        case EDurationItem:

			{

			//This is condition is useful when the license item is selected for a image file

			if(iVideo)

				{

				break;

				}

			}

        case ElicenseItem:

			{

			//Create DRM utility

			CGlxDRMUtility* drmUtility = CGlxDRMUtility::InstanceL();

			CleanupClosePushL(*drmUtility);

			drmUtility->ShowDRMDetailsPaneL(iItemMediaList->Item(0).Uri());

			CleanupStack::PopAndDestroy(drmUtility);

			}  

			break;

        default:

			{

			break;    

			}

        }

    }

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

// CGlxMetadataContainer::CreateMediaListForSelectedItemL

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

void CGlxMetadataContainer::CreateMediaListForSelectedItemL(TBool aIsRename)

    {

    TRACER("CGlxMetadataContainer::CreateMediaListForSelectedItemL");

    //create the collection path for the medialist to be created

    CMPXCollectionPath* path = CMPXCollectionPath::NewL();

    CleanupStack::PushL( path );

    //set the all collection path as the details dialog can be launched from any of the grid views and filter with URI

    path->AppendL(KGlxCollectionPluginAllImplementationUid);

    //create the filter with the URI

    CMPXFilter* filter = NULL;

    if(aIsRename)

	    {

	    //create the filter with the modified URI after Rename happens

	    filter = TGlxFilterFactory::CreateURIFilterL(iModifiedUri->Des());

	    }

	else

		{

		filter  = TGlxFilterFactory::CreateURIFilterL(iUri);

		}

    CleanupStack::PushL( filter );

    //create the medialist   

    iItemMediaList = MGlxMediaList::InstanceL(*path,TGlxHierarchyId(KMediaListId),filter);   

    //Add the attributes which are required to be displayed.

    iMainListAttributecontext = new (ELeave) CGlxAttributeContext(&iSelectionIterator);

    iMainListAttributecontext->AddAttributeL(KMPXMediaDrmProtected);

    iMainListAttributecontext->AddAttributeL(KMPXMediaGeneralCategory);

    iMainListAttributecontext->AddAttributeL(KMPXMediaGeneralSize);

    iMainListAttributecontext->AddAttributeL(KGlxMediaGeneralDimensions); 

    iMainListAttributecontext->AddAttributeL(KMPXMediaGeneralTitle);

    iMainListAttributecontext->AddAttributeL(KMPXMediaGeneralDate);

    iMainListAttributecontext->AddAttributeL(KMPXMediaGeneralComment); 

    iMainListAttributecontext->AddAttributeL(KGlxMediaGeneralLocation);

    iMainListAttributecontext->AddAttributeL(KMPXMediaGeneralDuration);    

    iMainListAttributecontext->AddAttributeL(KMPXMediaGeneralUri);

    //Add Context so that we get the handleattributes call once the medialist is populated with above mentioned attributes.

    iItemMediaList->AddContextL( iMainListAttributecontext,

            KGlxFetchContextPriorityBlocking );

    //add to observer for callbacks.

    iItemMediaList->AddMediaListObserverL(this);

    CleanupStack::PopAndDestroy( filter );

    CleanupStack::PopAndDestroy( path ); 

    }

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

// CGlxMetadataContainer::CreateTagsMediaList

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

void CGlxMetadataContainer::CreateTagsMediaListL()

    {

    TRACER("CGlxMetadataContainer::CreateTagsMediaListL");

    	//create the collection path for the medialist to be created

      CMPXCollectionPath* path = CMPXCollectionPath::NewL();

      CleanupStack::PushL( path );

      //Set the Tags collection for the particular item

      path->AppendL(KGlxTagCollectionPluginImplementationUid);

      //get the media item for which we require the tags collection

      TGlxMedia item = iItemMediaList->Item(0);            

      //create the medialist filter with media ID

      CMPXFilter* filter1  = 

              TGlxFilterFactory::CreateExcludeContainersWithoutItemFilterL(item.Id());

      CleanupStack::PushL(filter1);

      //set the array order as required, here its alphabetical

      TGlxFilterProperties filterProperty;

      filterProperty.iSortOrder = EGlxFilterSortOrderAlphabetical;

      filterProperty.iSortDirection = EGlxFilterSortDirectionAscending;

      //combine the filter with filterProperty

      CMPXFilter* filter  = TGlxFilterFactory::CreateCombinedFilterL( filterProperty,

                                                                      filter1,

                                                                      EFalse);

      CleanupStack::PushL(filter); 

      //create the medialist to get the tags array.

      iTagMediaList = MGlxMediaList::InstanceL(*path,TGlxHierarchyId(KMediaListId),filter);

      //add the attribute KMPXMediaGeneralTitle to the context to get the tag name

      iTagContext = CGlxDefaultAttributeContext::NewL();

      iTagContext->AddAttributeL(KMPXMediaGeneralTitle); 

      iTagContext->SetRangeOffsets(KOffsets,KOffsets);

      //Add Context so that we get the handleattributes call once the medialist is populated with tags.

      iTagMediaList->AddContextL( iTagContext,

                                      KGlxFetchContextPriorityUMPViewTagPane );

			//add to observer for callbacks.                                      

      iTagMediaList->AddMediaListObserverL(this);

      CleanupStack::PopAndDestroy(filter);

      CleanupStack::PopAndDestroy(filter1);

      CleanupStack::PopAndDestroy(path);

    }

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

// CGlxMetadataContainer::CreateAlbumsMediaListL

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

void CGlxMetadataContainer::CreateAlbumsMediaListL()