/*

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

*

*/

/*

 * glximgvwrmetadatacontainer.cpp

 *

 *  Created on: Oct 22, 2009

 *      Author: sourbasu

 */

#include  "glximgvwrmetadatacontainer.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  <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 <glxcollectionpluginimageviewer.hrh>

//marquee

#include <eikfrlb.h>

#include <eikfrlbd.h>

const TInt KMaxMediaPopupTitleLength = 0x100;

const TInt KMediaListId              = 0x2000D248;

const TInt KMarqueeLoopCount         = 3;

const TInt KMarqueeScrollAmount      = 20;

const TInt KMarqueeScrollDelay       = 1000000;

const TInt KMarqueeScrollInterval    = 200000;

_LIT( KGlxTextSetter, "");

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

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

// NewL

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

//  

CGlxImgVwrMetadataContainer* CGlxImgVwrMetadataContainer::NewL( const TRect& aRect,const TDesC& item)

    {

    TRACER("CGlxImgVwrMetadataContainer::NewL");  

    CGlxImgVwrMetadataContainer* self = CGlxImgVwrMetadataContainer::NewLC( aRect,item);

    CleanupStack::Pop(self);

    return self;

    }

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

// NewLC

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

//  

CGlxImgVwrMetadataContainer* CGlxImgVwrMetadataContainer::NewLC( const TRect& aRect,const TDesC& aUri)

    {

    TRACER("CGlxImgVwrMetadataContainer::NewLC"); 

    CGlxImgVwrMetadataContainer* self = new(ELeave) CGlxImgVwrMetadataContainer(aUri);

    CleanupStack::PushL(self);

    self->ConstructL( aRect);

    return self;

    }

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

// CGlxImgVwrMetadataContainer

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

//  

CGlxImgVwrMetadataContainer::CGlxImgVwrMetadataContainer(const TDesC& aUri)

:iUri(aUri)

        {

        // No implementation

        }

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

// CGlxImgVwrMetadataContainer::ConstructL

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

//  

void CGlxImgVwrMetadataContainer::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);

    CreateMediaListForSelectedItemL();

    }

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

// ~CGlxImgVwrMetadataContainer

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

//  

CGlxImgVwrMetadataContainer::~CGlxImgVwrMetadataContainer()

    {

    TRACER("CGlxImgVwrMetadataContainer::~CGlxImgVwrMetadataContainer");

    if( iItemMediaList ) 

        {

        iItemMediaList->RemoveContext(iMainListAttributecontext);

        iItemMediaList->RemoveMediaListObserver(this);

        iItemMediaList->Close();

        iItemMediaList = NULL;  

        } 

    if( iMainListAttributecontext )

        {

        delete iMainListAttributecontext;

        iMainListAttributecontext = NULL;

        }

    if( IsVisible() )

        {

        MakeVisible(EFalse);

        }

    iTextSetter.Close();

    }

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

// CGlxImgVwrMetadataContainer::MediaList

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

MGlxMediaList& CGlxImgVwrMetadataContainer::MediaList()

    {

    //returns the active medialist.

    return *iItemMediaList;    

    }

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

// CGlxImgVwrMetadataContainer::CreateSettingItemL

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

CAknSettingItem* CGlxImgVwrMetadataContainer::CreateSettingItemL(TInt aResourceId)

    {

    TRACER("CGlxImgVwrMetadataContainer::CreateSettingItemL");      

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

    iTextSetter.Copy(KGlxTextSetter);  

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

    switch(aResourceId)

        {

        case EImgVwrNameItem:

        case EImgVwrDateAndTimeItem:

        case EImgVwrDescriptionItem:

            {

            settingItem = new (ELeave) CAknTextSettingItem( 

                    aResourceId, iTextSetter );

            break;          

            }

        case EImgVwrSizeItem:            

        case EImgVwrResolutionItem:

            {

            settingItem = new (ELeave) CAknTextSettingItem( 

                    aResourceId, iTextSetter );

            break;          

            }            

        case EImgVwrlicenseItem:

            {

            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;

    }

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

// CGlxImgVwrMetadataContainer::IsItemModifiable

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

TBool CGlxImgVwrMetadataContainer::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;

    }

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

// CGlxImgVwrMetadataContainer::HandleListBoxEventL

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

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

        TListBoxEvent aEventType)

    {

    GLX_LOG_INFO("CGlxImgVwrMetadataContainer::HandleListBoxEventL");         

    if ((aEventType == EEventEnterKeyPressed) || 

            (aEventType == EEventEditingStarted) ||

            (aEventType == EEventItemDoubleClicked))

        {

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

        HandleListboxChangesL();

        }

    }

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

// CGlxImgVwrMetadataContainer::HandleListboxChangesL

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

void CGlxImgVwrMetadataContainer::HandleListboxChangesL()

    {

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

    switch(index)

        {

        case EImgVwrNameItem:        

        case EImgVwrDescriptionItem:

            {

            SetNameDescriptionL(index);

            break;

            }          

        case EImgVwrlicenseItem:

            {

            //Create DRM utility

            CGlxDRMUtility* drmUtility = CGlxDRMUtility::InstanceL();

            CleanupClosePushL(*drmUtility);

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

            CleanupStack::PopAndDestroy(drmUtility);

            }  

            break;

        default:

            {

            break;    

            }

        }

    }

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

// CGlxImgVwrMetadataContainer::ViewDynInitMenuPaneL

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

// 

void CGlxImgVwrMetadataContainer::ViewDynInitMenuPaneL(TInt aMenuId, CEikMenuPane* aMenuPane)

    {

    if( aMenuId == R_METADATA_MENU )

            {

            //Set dim the options based on the utem selected

            //Viewdetails option will be availble only for the license item

            aMenuPane->SetItemDimmed(KGlxViewBoundMenuCommandId,IsLicenseItem());

            }

    }

//Medialist callbacks.    

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

// CGlxImgVwrMetadataContainer::HandleAttributesAvailableL

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

//

void CGlxImgVwrMetadataContainer::HandleAttributesAvailableL( TInt /*aItemIndex*/, 

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

    {

    TRACER("CGlxMetadataContainer::HandleAttributesAvailableL()");

    //generic medialist for the item for all the attributes required other than tags and albums.

    TInt x = aAttributes.Count();

    if(aList == iItemMediaList)

        {

        // Loop untill it checks for all the avialable attributes

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

            {

            //set attributes to the items in the container

            SetAttributesL(aAttributes[i]);                   

            }

        }

    }

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

// HandleItemAddedL

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

// 

void CGlxImgVwrMetadataContainer::HandleItemAddedL( TInt /*aStartIndex*/, TInt /*aEndIndex*/, 

        MGlxMediaList* aList )

    {

    if(!iMarquee)

        {

            EnableMarqueingL();

        }

    SetDurationLIicenseItemVisibilityL();

    if(aList == iItemMediaList)

        {

        if(iItemMediaList->Count())

            {

            TGlxMedia item = iItemMediaList->Item(0);

            CGlxUStringConverter* stringConverter = CGlxUStringConverter::NewL();

            CleanupStack::PushL(stringConverter );

            for(TInt index = 0; index <= 4; index++)

                {

                HBufC* string = NULL;               

                if(index == EImgVwrSizeItem)

                    {

                    stringConverter->AsStringL(item,

                            KMPXMediaGeneralSize,0, string );              

                    }

                else if(index == EImgVwrNameItem)

                    {

                    stringConverter->AsStringL(item,

                            KMPXMediaGeneralTitle,0, string );

                    }

                else if(index == EImgVwrDateAndTimeItem)

                    {  

                    stringConverter->AsStringL( item, 

                            KMPXMediaGeneralDate,

                            R_QTN_DATE_USUAL_WITH_ZERO,string );

                    }

                else if(index == EImgVwrDescriptionItem)

                    {

                    stringConverter->AsStringL(item,

                            KMPXMediaGeneralComment,0, string ); 

                    }

                else if(index == EImgVwrResolutionItem)

                    {

                    stringConverter->AsStringL(item,

                            KGlxMediaGeneralDimensions,0, string );

                    }    

                else 

                    {

                    //no implementation

                    } 

                if(string)

                    {

                    iTextSetter.Copy(KGlxTextSetter);

                    iTextSetter.Append(*string);

                    }

                EditItemL(index,EFalse);                 

                delete string;

                string = NULL;

                }

            CleanupStack::PopAndDestroy(stringConverter );

            }   

        }

    }

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

// EnableMarqueingL

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

//  

void CGlxImgVwrMetadataContainer::EnableMarqueingL()

    {

    TRACER("CGlxImgVwrMetadataContainer::EnableMarqueingL()");    

    iMarquee = ETrue;

    ListBox()->UseLogicalToVisualConversion(ETrue);

    ListBox()->ItemDrawer()->ColumnData()->SetMarqueeParams (KMarqueeLoopCount,

            KMarqueeScrollAmount, KMarqueeScrollDelay, KMarqueeScrollInterval);

    ListBox()->ItemDrawer()->ColumnData()->EnableMarqueeL(ETrue);

    }    

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

// HandleCommandCompleteL

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

// 

void CGlxImgVwrMetadataContainer::HandleCommandCompleteL(TAny* aSessionId, 

        CMPXCommand* /*aCommandResult*/, TInt aError, MGlxMediaList* aList)

    {

    TRACER("CGlxImgVwrMetadataContainer::HandleCommandCompleteL()");

    }

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

// HandleItemRemoved

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

//  

void CGlxImgVwrMetadataContainer::HandleItemRemovedL(  TInt /*aStartIndex*/, TInt /*aEndIndex*/, 

        MGlxMediaList* /*aList*/  )

    {

    TRACER("CGlxImgVwrMetadataContainer::HandleItemRemovedL()");    

    }    

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

// HandleFocusChangedL

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

//  

void CGlxImgVwrMetadataContainer::HandleFocusChangedL( NGlxListDefs::

        TFocusChangeType /*aType*/, TInt /*aNewIndex*/, TInt /*aOldIndex*/, 

        MGlxMediaList* /*aList*/ )

    {

    TRACER("CGlxImgVwrMetadataContainer::HandleFocusChangedL()");

    }

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

// HandleItemSelected

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

//  

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

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

    {

    TRACER("CGlxImgVwrMetadataContainer::HandleItemSelectedL");

    }

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

// HandleMessageL

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

//    

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

        MGlxMediaList* /*aList*/ )

    {

    TRACER("CGlxImgVwrMetadataContainer::HandleMessageL()");

    }

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

// HandleError

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

//

void CGlxImgVwrMetadataContainer::HandleError( TInt /*aError*/ ) 

    {

    TRACER("CGlxImgVwrMetadataContainer::HandleError()");

    TRAP_IGNORE(HandleErrorL());

    }

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

// HandleErrorL

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

//

void CGlxImgVwrMetadataContainer::HandleErrorL()

    {

    TRACER("CGlxImgVwrMetadataContainer::HandleErrorL()");

    }

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

// HandleCommandCompleteL

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

//  

void CGlxImgVwrMetadataContainer::HandleCommandCompleteL( CMPXCommand* /*aCommandResult*/, 

        TInt /*aError*/, MGlxMediaList* /*aList*/ )

    {

    TRACER("CGlxImgVwrMetadataContainer::HandleCommandCompleteL()");

    }

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

// HandleMediaL

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

//  

void CGlxImgVwrMetadataContainer::HandleMediaL( TInt /*aListIndex*/, MGlxMediaList* /*aList*/ )

    {

    TRACER("CGlxImgVwrMetadataContainer::HandleMediaL()");

    }

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

// HandleItemModifiedL

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

//  

void CGlxImgVwrMetadataContainer::HandleItemModifiedL( const RArray<TInt>& /*aItemIndexes*/,

        MGlxMediaList* /*aList*/ )

    {

    TRACER("CGlxImgVwrMetadataContainer::HandleItemModifiedL()");

    }

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

// ChangeMskL

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

//     

void CGlxImgVwrMetadataContainer::ChangeMskL()

    {

    TRACER("CGlxImgVwrMetadataContainer::ChangeMsk()");

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

    CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();               

    switch(index)

        {

        case EImgVwrNameItem:        

        case EImgVwrDescriptionItem:

            {

            uiUtility->ScreenFurniture()->ModifySoftkeyIdL(CEikButtonGroupContainer::EMiddleSoftkeyPosition,

                    EAknSoftkeyEdit,R_GLX_METADATA_MSK_EDIT);

            }        

            break;          

        case EImgVwrDateAndTimeItem:

        case EImgVwrSizeItem:

        case EImgVwrResolutionItem:

        case EImgVwrlicenseItem:

            {

            uiUtility->ScreenFurniture()->ModifySoftkeyIdL(CEikButtonGroupContainer::EMiddleSoftkeyPosition,

                    EAknSoftkeyEdit,R_GLX_METADATA_MSK_BLANK);            

            }        

            break;

        default:

            {

            break;    

            }

        }

    if ( uiUtility )

        {

        uiUtility->Close();

        }   

    }

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

// CGlxImgVwrMetadataContainer::CreateMediaListForSelectedItemL

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

void CGlxImgVwrMetadataContainer::CreateMediaListForSelectedItemL()

    {

    TRACER("CGlxMetadataContainer::CreateMediaListL");

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