/*

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

//system includes

#include <AknUtils.h>                   //for AknUtils

#include <lbsposition.h> 

#include <akntitle.h>

#include <coeaui.h>

#include <data_caging_path_literals.hrh>// KDC_APP_RESOURCE_DIR	

#include <eikmenub.h>                   // for CEikMenuBar

#include <StringLoader.h>

#include <akntoolbar.h>

#include <glxcommandhandleraddtocontainer.h>         // For CGlxCommandHandlerAddToContainer

#include <aknphysics.h> // For Kinetic Scrolling

#include <eikdialogext.h>

//User includes

#include <glxmetadatadialog.rsg>

#include <glxresourceutilities.h>

#include <glxlog.h>

#include <glxtracer.h>

#include <glxcollectionpluginall.hrh>

#include <glxfilterfactory.h>               // for TGlxFilterFactory

#include <glxuiutility.h>

#include <glxcommandhandlers.hrh>

#include <hlplch.h>						// for HlpLauncher

#include <photos.hlp.hrh>

#include <glxgallery.hrh>

#include <glxdetailsboundcommand.hrh>

#include <glxscreenfurniture.h>

#include <glxuiutilities.rsg>

#include <glxpanic.h>                    // For Panics

#include <glxresourceutilities.h>                // for CGlxResourceUtilities

#include "glxmetadatacommandhandler.h"

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

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

// NewL

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

//

EXPORT_C CGlxMetadataDialog* CGlxMetadataDialog::NewL(const TDesC& aUri)

    {

    TRACER("CGlxMetadataDialog::NewL");

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CGlxMetadataDialog::CGlxMetadataDialog(const TDesC& aUri) :

    iUri(aUri)

    {

    }

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

// ConstructL

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

//

void CGlxMetadataDialog::ConstructL()

	{

    TRACER("CGlxMetadataDialog::ConstructL");

    // Load dialog's resource file

    InitResourceL();

    iStatusPaneAvailable = EFalse;

    // set the title to the dialog, Note that avkon dialogs do not support

    // setting the title in the status pane so we need to do it the hard way

    // get status pane

    CEikStatusPane* statusPane = iEikonEnv->AppUiFactory()->StatusPane();

    if (statusPane && statusPane->IsVisible())

        {

        iStatusPaneAvailable = ETrue;

        }

    // make the toolbar disabled

    SetDetailsDlgToolbarVisibility(EFalse);

    // do we have status pane

    if (statusPane)

        {

        GLX_LOG_INFO1("GLX_UMP::CGlxMetadataDialog::ConstructL::STATUS PANE = %d",statusPane->IsVisible());

        // load the title text

        HBufC* text = StringLoader::LoadL(R_GLX_METADATA_VIEW_TITLE_DETAILS,

                iEikonEnv);

        SetTitleL(*text);

        if (text)

            {

            delete text;

            }

        iAvkonAppUi->StatusPane()->MakeVisible(ETrue);

        }

    iUiUtility = CGlxUiUtility::UtilityL();

    TFileName uiutilitiesrscfile;

    uiutilitiesrscfile.Append(

            CGlxResourceUtilities::GetUiUtilitiesResourceFilenameL());

    iAddToTag = CGlxCommandHandlerAddToContainer::NewL(this, EGlxCmdAddTag,

            EFalse, uiutilitiesrscfile);

    iAddToAlbum = CGlxCommandHandlerAddToContainer::NewL(this,

            EGlxCmdAddToAlbum, EFalse, uiutilitiesrscfile);

    // Call the base class' two-phased constructor

    CAknDialog::ConstructL(R_METADATA_MENUBAR);

    // Instantiate the command handler

    iMetadataCmdHandler = CGlxMetadataCommandHandler::NewL(this);

    //steps to find kinetic scroll threshold value

    CAknPhysics* physics = CAknPhysics::NewL(*this, NULL);

    CleanupStack::PushL(physics);

    iKineticDragThreshold = physics->DragThreshold();

    CleanupStack::PopAndDestroy(physics);

    physics = NULL;

    }

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

// ~CGlxMetadataDialog

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

//

CGlxMetadataDialog::~CGlxMetadataDialog()

	{

    TRACER("CGlxMetadataDialog::~CGlxMetadataDialog");

    //To Disable the status pane if the dialog is launched from fullscreenview	

    if (!iStatusPaneAvailable && iAvkonAppUi)

        {

        iAvkonAppUi->StatusPane()->MakeVisible(EFalse);

        }

    TRAP_IGNORE(SetPreviousTitleL());

    delete iPreviousTitle;

    delete iMetadataCmdHandler;

    // Restore the Toolbar as it was in the Calling application

    SetDetailsDlgToolbarVisibility(ETrue);

    // If details launched from FullScreen View, while moving back,

    // all the UI components should be hidden. Hence processing this command here.

    if (iAvkonAppUi)

        {

        TRAP_IGNORE(iAvkonAppUi->ProcessCommandL(EGlxCmdResetView));

        }

    if (iAddToTag)

        {

        delete iAddToTag;

        }

    if (iAddToAlbum)

        {

        delete iAddToAlbum;

        }

    if (iUiUtility)

        {

        iUiUtility->Close();

        }

    if (iResourceOffset)

        {

        CCoeEnv::Static()->DeleteResourceFile(iResourceOffset);

        }

    }

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

// SetDetailsDlgToolbarVisibility()

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

void CGlxMetadataDialog::SetDetailsDlgToolbarVisibility(TBool aVisible)

    {

    TRACER("CGlxMetadataDialog::SetDetailsDlgToolbarVisibility");

    HandleToolbarResetting(aVisible);

    CAknToolbar* currentPopupToolbar = iAvkonAppUi->CurrentPopupToolbar();

    if(currentPopupToolbar)

        {

        currentPopupToolbar->SetToolbarVisibility(aVisible);

        currentPopupToolbar->MakeVisible( aVisible ); 

        }

    }

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

// ExecuteLD

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

//

EXPORT_C TInt CGlxMetadataDialog::ExecuteLD()

	{

	TRACER("CGlxMetadataDialog::ExecuteLD");	 

	return CAknDialog::ExecuteLD( R_METADATA_DIALOG );

	}

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

// MediaList.

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

//

 MGlxMediaList& CGlxMetadataDialog::MediaList()

    {

    TRACER("CGlxMetadataDialog::MediaList");    

    // return the refernce of media list

    return iContainer->MediaList();

    }

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

// ProcessCommandL

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

//

void CGlxMetadataDialog::ProcessCommandL( TInt aCommandId )

	{

    TRACER("CGlxMetadataDialog::ProcessCommandL");

    // hide menu bar

    iMenuBar->StopDisplayingMenuBar();

    switch (aCommandId)

        {

        case EAknSoftkeyEdit:

        case EAknSoftkeyCancel:

        case EAknSoftkeySelect:

        case EAknSoftkeyOk:

            {

            TryExitL(aCommandId);

            break;

            }

        case EAknCmdHelp:

            {

            TCoeHelpContext helpContext;

            helpContext.iMajor = TUid::Uid(KGlxGalleryApplicationUid);

            helpContext.iContext.Copy(LGAL_HLP_DETAILS_VIEW);

            const TInt KListSz = 1;

            CArrayFix<TCoeHelpContext>* contextList =

                    new (ELeave) CArrayFixFlat<TCoeHelpContext> (KListSz);

            CleanupStack::PushL(contextList);

            contextList->AppendL(helpContext);

            HlpLauncher::LaunchHelpApplicationL(iEikonEnv->WsSession(),

                    contextList);

            CleanupStack::Pop(contextList);

            break;

            }

        case KGlxDeleteBoundMenuCommandId:

            {

            //Event passed on to container to handle	

            //Delete the location information of the data.	  

            iContainer->RemoveLocationL();

            break;

            }

        case KGlxEditBoundMenuCommandId:

        case KGlxViewBoundMenuCommandId:

            {

            //To edit the details - forward the event to container to edit

            //Both edit and view details command are handled in the same function based on the item.	

            iContainer->HandleListboxChangesL();

            break;

            }

        case EGlxCmdAiwBase:

            {

            // pass aCommandId to command handler

            iMetadataCmdHandler->DoExecuteL(aCommandId, MediaList());

            }

        default:

            break;

        }

    }

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

// CGlxMetadataDialog::CreateCustomControlL

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

SEikControlInfo CGlxMetadataDialog::CreateCustomControlL(TInt 

                                                                aControlType)

    {

    TRACER("CGlxMetadataDialog::CreateCustomControlL");

    // create control info, no flags or trailer text set

    SEikControlInfo controlInfo;

    controlInfo.iControl        = NULL;

    controlInfo.iTrailerTextId  = 0;

    controlInfo.iFlags          = 0;

    if (aControlType == EMetaDataDialogListBox)

        {

        iContainer = CGlxMetadataContainer::NewL(iAvkonAppUi->ClientRect(),

		                                         *this, iUri, *this);        

        controlInfo.iControl = iContainer; // giving ownership   

        }

    return controlInfo; // returns ownership of ItemList

    }

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

// CGlxMetadataDialog::OfferKeyEventL

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

//

TKeyResponse CGlxMetadataDialog::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                                TEventCode aType )

	{

    TRACER("CGlxMetadataDialog::OfferKeyEventL");

    TKeyResponse response = EKeyWasNotConsumed;

    switch (aKeyEvent.iCode)

        {

        case EKeyUpArrow:

        case EKeyDownArrow:

            {

            if (!iUiUtility->IsPenSupported())

                {

                iContainer->ChangeMskL();

                }

            iContainer->EnableMarqueingL();

            break;

            }

        default:

            break;

        }

    if (response == EKeyWasNotConsumed)

        {

        // container didn't consume the key so try the base class

        // this is crucial as platform uses a key event to dismiss dialog

        // when a view changes to another. the base class also consumes all

        // the keys we dont want to handle automatically as this is a 

        // blocking dialog

        response = CAknDialog::OfferKeyEventL(aKeyEvent, aType);

        }

    return response;

    }

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

// CGlxMetadataDialog::DynInitMenuPaneL

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

//

void CGlxMetadataDialog::DynInitMenuPaneL( TInt aMenuId, CEikMenuPane* aMenuPane )

    {

    TRACER("CGlxMetadataDialog::DynInitMenuPaneL");

    iMetadataCmdHandler->PreDynInitMenuPaneL(aMenuId);

    iMetadataCmdHandler->DynInitMenuPaneL(aMenuId,aMenuPane,EFalse);   

    //To enable/diable the options based on the item selected.

    iContainer->ViewDynInitMenuPaneL(aMenuId, aMenuPane);

    }

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

// OkToExitL

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

//

TBool CGlxMetadataDialog::OkToExitL( TInt aKeycode )

	{

	TRACER("CGlxMetadataDialog::OkToExitL");

	TBool retVal = EFalse;

	switch (aKeycode)

		{

		case EAknSoftkeySelect:

		case EAknSoftkeyOk:

			{

			break;

			}

		case EAknSoftkeyOptions: 

			{

			// display menu only

			// show the option menu that can have mutiselect options

			iMenuBar->SetMenuType( CEikMenuBar::EMenuOptions );

			retVal = CAknDialog::OkToExitL( aKeycode );

			break;

			}

		case EAknSoftkeyBack:

		case EAknSoftkeyCancel: 

			{

			retVal = ETrue;

			break;

			}

		case EAknSoftkeyEdit:

			{

			if(!iUiUtility->IsPenSupported())

				{

				iContainer->HandleListboxChangesL();

				}

			else

			    {

				HandleViewCommandL(aKeycode);

				}

			break;

			}            

		default :

			break;

		}

	return retVal;

	}

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

// CGlxMetadataDialog::InitResourceL

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

//

void CGlxMetadataDialog::InitResourceL()    

	{

	TRACER("CGlxMetadataDialog::InitResourceL");

	_LIT(KGlxMetadataDialogResource,"glxmetadatadialog.rsc");

	//add resource file

	TParse parse;

	parse.Set(KGlxMetadataDialogResource, &KDC_APP_RESOURCE_DIR, NULL);

	TFileName resourceFile;

	resourceFile.Append(parse.FullName()); 

	CGlxResourceUtilities::GetResourceFilenameL(resourceFile);  

	iResourceOffset = CCoeEnv::Static()->AddResourceFileL(resourceFile);

	}  

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

// CGlxMetadataDialog::HandleViewCommandL

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

//    

TBool CGlxMetadataDialog::HandleViewCommandL( TInt /*aCommand*/ )

	{

	TRACER("CGlxMetadataDialog::HandleViewCommandL");

	return EFalse;

	}

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

// CGlxMetadataDialog::PostLayoutDynInitL

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

//

void CGlxMetadataDialog::PostLayoutDynInitL()

    {

    TRACER("CGlxMetadataDialog::PostLayoutDynInitL");

    if (!iUiUtility->IsPenSupported())

        {

        iUiUtility->ScreenFurniture()->ModifySoftkeyIdL(

                CEikButtonGroupContainer::EMiddleSoftkeyPosition,

                EAknSoftkeyEdit, R_GLX_METADATA_MSK_EDIT);

        }

    }

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

// CGlxMetadataDialog::HandlePointerEventL

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

//

void CGlxMetadataDialog::HandlePointerEventL(

    const TPointerEvent& aPointerEvent)

	{

    TRACER("CGlxMetadataDialog::HandlePointerEventL");

    //This has to be called first, as base class implementation sets the flag 

    // of settings dialog with EDisableMarquee 

    CCoeControl::HandlePointerEventL(aPointerEvent);

    //After the above call we can call our implementation to reset the marque 

    // flag and start marqueeing if needed

    if (aPointerEvent.iType == TPointerEvent::EButton1Down

            || aPointerEvent.iType == TPointerEvent::EButton2Down

            || aPointerEvent.iType == TPointerEvent::EButton3Down

            || aPointerEvent.iType == TPointerEvent::EDrag)

        {

        if (aPointerEvent.iType != TPointerEvent::EDrag)

            {

            iViewDragged = EFalse;

            }

        if (aPointerEvent.iType == TPointerEvent::EDrag)

            {

            TInt delta = iPrev.iY - aPointerEvent.iPosition.iY;

            //Check for physics threshold, if not more than threshold, we can

            //still continue marqueeing

            TInt deltaAbs = delta < 0 ? -delta : delta;

            if (!iViewDragged && deltaAbs >= iKineticDragThreshold)

                {

                iViewDragged = ETrue;

                }

            }

        //This has to done at every above mentioned event, since the  

        //disable marquee flag is set by base implementation, forcing 

        //us the need to reset it everytime.

        if (!iViewDragged)

            {

            iContainer->EnableMarqueingL();

            }

        }

    //record positions unless it is drag event

    if (aPointerEvent.iType != TPointerEvent::EDrag)

        {

        iPrev = aPointerEvent.iPosition;

        }

    }

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

// CGlxMetadataDialog::OnLocationEditL

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

//

void  CGlxMetadataDialog::OnLocationEditL()   

	{

	TRACER("CGlxMetadataDialog::OnLocationEditL");

	OkToExitL( EAknSoftkeyOptions );

	}

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

// CGlxMetadataDialog::AddTagL

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

//

void CGlxMetadataDialog::AddTagL()

    {

    TRACER("CGlxMetadataDialog::AddTagL");    

    iAddToTag->ExecuteL(EGlxCmdAddTag);

    }

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

// CGlxMetadataDialog::AddAlbumL

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

//

void CGlxMetadataDialog::AddAlbumL()

    {

    TRACER("CGlxMetadataDialog::AddAlbumL");