/*

* 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  "mglxmetadatadialogobserver.h"

#include  <StringLoader.h>

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

#include  <ExifModify.h>                          // For CExifModify 

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

#include  <mpxmediadrmdefs.h>

#include  <eikfrlb.h>                             // For marquee  

#include  <eikfrlbd.h>                            // For marquee

#include  <glxmetadatadialog.rsg>

#include  <glxscreenfurniture.h>

#include  <glxdetailsboundcommand.hrh>

#include  <glxcommandhandleraddtocontainer.h>     // For CGlxCommandHandlerAddToContainer

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

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

#include  <glxtextentrypopup.h>

#include  <glxuistd.h>

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

#include  <glxattributeretriever.h>               // CGlxAttributeReteiver

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

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

#include  <glxuiutilities.rsg>                    

#include  <glxfilterfactory.h>

#include  <glxlog.h>

#include  <glxtracer.h>

#include <glxgeneraluiutilities.h>

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( 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, aResetToolbarObs);

    CleanupStack::PushL(self);

    self->ConstructL(aRect, aUri);

    return self;

    }

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

// CGlxMetadataContainer

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

//

CGlxMetadataContainer::CGlxMetadataContainer(

        MGlxMetadataDialogObserver& aDialogObserver,

        MToolbarResetObserver& aResetToolbarObs) :

    iDialogObesrver(aDialogObserver), iResetToolbarObs(aResetToolbarObs)

    {

    // No implementation

    }

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

// CGlxMetadataContainer::ConstructL

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

//

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

        const TDesC& aUri)

    {

    TRACER("CGlxMetadataContainer::ConstructL");

    //media's uri

    iUri = aUri.AllocL();

    //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;

    //Flag to indicate rename command is started

    iRenameStarted = 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(iUri)

		{

		delete iUri;

		iUri = NULL;

		}

	}

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

// 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:

            {

            settingItem = new (ELeave) CAknTextSettingItem(aResourceId,

                    iTagSetter);

            break;

            }

        case EAlbumsItem:

            {

            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()

    {

    TRACER("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::IsLocationItem

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

TBool CGlxMetadataContainer::IsLocationItem()

    {

    TRACER("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()

    {

    TRACER("CGlxMetadataContainer::HandleListboxChangesL");

    //dont Edit Item's details if medialist is empty

    //OR Rename command is in progress

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

        {

        GLX_LOG_INFO("MediaList empty or Rename command started");

        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);

                }

			else

				{

				CAknSettingItem* settingsitem = (*SettingItemArray())[index]; 

			    GlxGeneralUiUtilities::ShowInfoNoteL(settingsitem->SettingTextL(),ETrue);

				}

            break;

            }

        case EDurationItem:

            {

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

            if (iVideo)

                {

                break;

                }

            }

        case EResolutionItem:

        	{

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

			if (!iVideo || !iItemMediaList->Item(0).IsDrmProtected())

				{

				break;

				}

			}

        case ElicenseItem:

            {

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

            if (item.IsDrmProtected())

                {

                //Create DRM utility

                CGlxDRMUtility* drmUtility = CGlxDRMUtility::InstanceL();

                CleanupClosePushL(*drmUtility);

                // check if rights have expired

                TBool expired = EFalse;

                expired = !drmUtility->ItemRightsValidityCheckL(item.Uri(),

                        EMPXImage == item.Category());

                if (expired)

                    {

                    drmUtility->ShowRightsInfoL(item.Uri());

                    }

                else

                    {

                    drmUtility->ShowDRMDetailsPaneL(item.Uri());

                    }

                CleanupStack::PopAndDestroy(drmUtility);

                }

            }

            break;

        default:

            {

            break;

            }

        }

    }

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

// CGlxMetadataContainer::CreateMediaListForSelectedItemL

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

void CGlxMetadataContainer::CreateMediaListForSelectedItemL( )

    {

    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 = 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);

    }

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