/*

* 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:    Generic selection popup class

*

*/

/**

 * @internal reviewed 06/06/2007 by Dave Schofield

 * @internal reviewed 13/07/2007 by Aki Vanhatalo

 */

// INCLUDE FILES

#include "glxmediaselectionpopup.h"

#include <data_caging_path_literals.hrh>// for KDC_APP_RESOURCE_DIR

#include <aknconsts.h>

#include <AknIconArray.h>

#include <aknlists.h>	

#include <AknQueryDialog.h>

#include <avkon.mbg>

#include <bautils.h>

#include <eikclbd.h>

#include <glxattributecontext.h>

#include <glxattributeretriever.h>

#include <glxcollectiongeneraldefs.h>

#include <glxcommoncommandhandlers.rsg>

#include <glxfetchcontextremover.h>

#include <glxgeneraluiutilities.h>

#include <glxlog.h>

#include <glxtracer.h>

#include <glxresourceutilities.h>                // for CGlxResourceUtilities

#include <glxuistd.h>

#include <mpxcollectionmessage.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <StringLoader.h>

#include <glxuiutility.h>

#include "glxcommandhandlernewmedia.h"

_LIT(KUnselectedIconIndex, "1\t");

_LIT(KAlbumIconIndex, "2\t");

_LIT(KBlankIconIndex, "3\t"); // No icon

_LIT(KGlxCommonCommandHandlerResource, "glxcommoncommandhandlers.rsc");

const TInt KMediaSelectionPopupMediaListHierarchyId = 0x2000A77A;

const TInt KIconArrayGranularity = 2;

const TInt KNewItemId = 12345;

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

// Constructor

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

//   

EXPORT_C CGlxMediaListAdaptor::CGlxMediaListAdaptor(

        const MGlxMediaList* aMediaList, TBool aMultiSelection) :

    iMediaList(aMediaList), iMultiSelection(aMultiSelection),

			iStaticItemSelected(EFalse)

    {

    }

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

// CGlxMediaListAdaptor::SetEnabled()

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

//   

void CGlxMediaListAdaptor::SetEnabled(TBool aEnabled)

    {

    TRACER("CGlxMediaListAdaptor::SetEnabled");

    iEnabled = aEnabled;

    }

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

// CGlxMediaListAdaptor::MediaList()

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

//   

const MGlxMediaList* CGlxMediaListAdaptor::MediaList()

    {

    TRACER("CGlxMediaListAdaptor::MediaList");

    return iMediaList;

    }

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

// CGlxMediaListAdaptor::MultiSelectionEnabled()

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

//   

TBool CGlxMediaListAdaptor::MultiSelectionEnabled()

    {

    return iMultiSelection;

    }

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

// CGlxMediaListAdaptor::MdcaCount()

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

//   

EXPORT_C TInt CGlxMediaListAdaptor::MdcaCount() const

    {

    TRACER("CGlxMediaListAdaptor::MdcaCount");

    __ASSERT_DEBUG(iMediaList, Panic(EGlxPanicNullPointer));

    if (iEnabled)

        {

        return iMediaList->Count();

        }

    else

        {

        return 0;

        }

    }

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

// CGlxMediaListAdaptor::MdcaPoint()

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

//   

EXPORT_C TPtrC CGlxMediaListAdaptor::MdcaPoint(TInt aIndex) const

    {

    TRACER("CGlxMediaListAdaptor::MdcaPoint");

    const TGlxMedia& item = iMediaList->Item(aIndex);

    TPtrC title = item.Title();

    if (item.IsStatic() || title.Length() == 0)

        {

        // The item is a static item or the item's title length is 0

        iCurrentTitleString = KBlankIconIndex;

        }

    else

        {

        if (iMultiSelection)

            {

            iCurrentTitleString = KUnselectedIconIndex;

            }

        else

            {

            iCurrentTitleString = KAlbumIconIndex;

            }

        }

    // iCurrentTitleString contains a tab character

    iCurrentTitleString.Append(title.Left(KMaxTitleStringLength

            - iCurrentTitleString.Length()));

    return TPtrC(iCurrentTitleString);

    }

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

// CGlxMediaListAdaptor::IsStaticItemSelected

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

TBool CGlxMediaListAdaptor::IsStaticItemSelected()

	{

	TRACER("CGlxMediaListAdaptor::IsStaticItemSelected");

	return iStaticItemSelected;

	}

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

// CGlxMediaListAdaptor::SetStaticItemSelected

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

void CGlxMediaListAdaptor::SetStaticItemSelected(TBool aSelected)

	{

	TRACER("CGlxMediaListAdaptor::SetStaticItemSelected");

	iStaticItemSelected = aSelected;

	}

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

// CGlxSingleGraphicPopupMenuStyleList::NewL

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

CGlxSingleGraphicPopupMenuStyleList* CGlxSingleGraphicPopupMenuStyleList::NewL(

		CEikListBox* aListBox, TInt aCbaResource,

		AknPopupLayouts::TAknPopupLayouts aType)

	{

	TRACER("CGlxSingleGraphicPopupMenuStyleList::NewL");

	CGlxSingleGraphicPopupMenuStyleList* self =

		new (ELeave) CGlxSingleGraphicPopupMenuStyleList;

	CleanupStack::PushL(self);

	self->ConstructL(aListBox, aCbaResource, aType);

	CleanupStack::Pop(self);

	return self;

	}

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

// CGlxSingleGraphicPopupMenuStyleList::HandleListBoxEventL()

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

//

void CGlxSingleGraphicPopupMenuStyleList::HandleListBoxEventL(

		CEikListBox *aListBox, TListBoxEvent aEventType)

    {

    TRACER("CGlxSingleGraphicPopupMenuStyleList::HandleListBoxEventL");

    CAknSingleGraphicPopupMenuStyleListBox* listBox =

			static_cast<CAknSingleGraphicPopupMenuStyleListBox*> (aListBox);

    CGlxMediaListAdaptor

			* mediaListAdaptor =

					static_cast<CGlxMediaListAdaptor*> (listBox->Model()->ItemTextArray());

    TBool staticItemSelected = EFalse;

    TInt currItemIndx = listBox->View()->CurrentItemIndex();

    switch (aEventType)

        {

        case EEventItemClicked:

        case EEventItemSingleClicked:

            {

            if (mediaListAdaptor->MultiSelectionEnabled() && currItemIndx >= 0)

                {

                const TGlxMedia& item = mediaListAdaptor->MediaList()->Item(

						currItemIndx);

                //Check if media item is user-defined or static

                staticItemSelected = item.IsStatic();

                mediaListAdaptor->SetStaticItemSelected(staticItemSelected);

                if (!staticItemSelected)

                    {

					//Mark or UnMark the user-defined item

                    TBool isMarked = listBox->View()->ItemIsSelected(currItemIndx);

                    (isMarked == (TBool) ETrue) ? (listBox->View()->DeselectItem(

							currItemIndx))

							: (listBox->View()->SelectItemL(currItemIndx));

                    }

                //Show Command Set based on selected items

                TInt selectCount = listBox->View()->SelectionIndexes()->Count();

				CEikButtonGroupContainer* cbaContainer = ButtonGroupContainer();

				//Show 'OK' only if a static item or more than

				//1 user-defined item is selected

				if(staticItemSelected || selectCount)

					{

					cbaContainer->SetCommandSetL(R_GLX_SOFTKEYS_OK_CANCEL);

					}

				else

					{

					cbaContainer->SetCommandSetL(R_AVKON_SOFTKEYS_CANCEL);

					}

				cbaContainer->DrawDeferred();

                }

            listBox->DrawDeferred();

            //Forward for default processing, if static item is selected(i.e. For Tags)

			//or if List Box's Multiple selection is Disabled(i.e. For Albums)

			if (staticItemSelected

					|| (!mediaListAdaptor->MultiSelectionEnabled()))

				{

				CAknPopupList::HandleListBoxEventL( aListBox, aEventType);

				}

			//After Scrolling, then Select "New Tag" i.e Static item is selected

			if (staticItemSelected)

				{

				ProcessCommandL(EAknSoftkeyOk);

				}

            break;

            }

        default:

        	{

        	CAknPopupList::HandleListBoxEventL( aListBox, aEventType);

        	break;

        	}

        }

    }

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

// CGlxSingleGraphicPopupMenuStyleList::HandlePointerEventL()

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

//

void CGlxSingleGraphicPopupMenuStyleList::HandlePointerEventL(

		const TPointerEvent& aPointerEvent)

    {

	TRACER("CGlxSingleGraphicPopupMenuStyleList::HandlePointerEventL");

    CAknSingleGraphicPopupMenuStyleListBox* listBox =

			static_cast<CAknSingleGraphicPopupMenuStyleListBox*> (ListBox());

	CGlxMediaListAdaptor

			* mediaListAdaptor =

					static_cast<CGlxMediaListAdaptor*> (listBox->Model()->ItemTextArray());

	//Check for MultipleSelection is Disbaled

    if ( !(mediaListAdaptor->MultiSelectionEnabled()) )

    	{

		//checking if the index has changed & has valid item available

		TInt changedItemIndex = KErrNotFound;

        TBool isItemAvailable = listBox->View()->XYPosToItemIndex(

				aPointerEvent.iPosition, changedItemIndex);

        if(isItemAvailable)

			{

			//Check if Selected item is static

			const TGlxMedia& item = mediaListAdaptor->MediaList()->Item(

					changedItemIndex);

			mediaListAdaptor->SetStaticItemSelected( item.IsStatic() );

			}

        }

    //Forward for default processing

    CAknPopupList::HandlePointerEventL( aPointerEvent);

    }

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

// Constructor

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

//  

EXPORT_C CGlxMediaSelectionPopup::CGlxMediaSelectionPopup() :

    CActive(EPriorityStandard)

    {

    TRACER("GlxMediaSelectionPopup::CGlxMediaSelectionPopup");

    CActiveScheduler::Add(this);

    }

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

// CGlxMediaSelectionPopup::RunL()

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

//  

void CGlxMediaSelectionPopup::RunL()

    {

    TRACER("CGlxMediaSelectionPopup::RunL");

    // The media list adaptor is enabled after the popup list is invoked

    // to ensure that the popup list is laid out correctly.

    iMediaListAdaptor->SetEnabled(ETrue);

    AddNewMediaCreationItemL();

    }

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

// CGlxMediaSelectionPopup::DoCancel()

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

//  

void CGlxMediaSelectionPopup::DoCancel()

    {

    // no implementation required

    }

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

// CGlxMediaSelectionPopup::ExecuteLD()

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

//  

EXPORT_C CMPXCollectionPath* CGlxMediaSelectionPopup::ExecuteLD(

        CMPXCollectionPath& aPath, TBool& aAccepted, TBool aMultiSelection,

        TBool aEnableContainerCreation, CMPXFilter* aFilter)

    {

    TRACER("CGlxMediaSelectionPopup::ExecuteLD");

    CleanupStack::PushL(this); // if something leaves delete 'this' object

    iEnableContainerCreation = aEnableContainerCreation;

    iCollectionId = TGlxMediaId(aPath.Id(0));

    FetchTitlesL();

    iMediaList = MGlxMediaList::InstanceL(aPath,

            KMediaSelectionPopupMediaListHierarchyId, aFilter);

    iMediaList->AddMediaListObserverL(this);

    iMediaListAdaptor = new (ELeave) CGlxMediaListAdaptor(iMediaList,

            aMultiSelection);

    SetupAttributeContextL();

    AddResourceFileL();

    ConstructPopupListL(aMultiSelection);

    InitIconsL();

    CompleteSelf(); // This will cause RunL() to be called by the active scheduler.

    // Invoke the dialog. 

    // The media list adaptor MdcaCount() method must return 0 at this point in order

    // for the popup to be displayed correctly. If MdcaCount() returns 1 then the popup will contain only

    // a single row.

    // iPopupList->ExecuteLD() starts a nested active scheduler so acvtive objects will be executed before

    // iPopupList->ExecuteLD() completes.

    aAccepted = iPopupList->ExecuteLD();

    if (iListBox->CurrentItemIndex() < 0)

        {

        // There is no current item therefore there is nothing to select

        // Fix for error ID: ERBS-7BSKFV Application crashes if user attempts to add a tag when in full screen view.

        aAccepted = EFalse;

        }

    iMediaList->RemoveMediaListObserver(this); // We no longer require any callbacks from the media list

    CMPXCollectionPath* path = NULL;

    if (aAccepted)

        {

		//Check if a static item is selected

		if (iMediaListAdaptor->IsStaticItemSelected())

            {

			TFileName uiutilitiesrscfile;

			uiutilitiesrscfile.Append(

					CGlxResourceUtilities::GetUiUtilitiesResourceFilenameL());

            CGlxCommandHandlerNewMedia* commandHandlerNewMedia =

			CGlxCommandHandlerNewMedia::NewL(this,uiutilitiesrscfile);

            TGlxMediaId newMediaId;

            TInt error = commandHandlerNewMedia->ExecuteLD(newMediaId);

            if (error == KErrNone)

                {

                path = CMPXCollectionPath::NewL(aPath);

                CleanupStack::PopAndDestroy(this);

                CleanupStack::PushL(path);

                path->AppendL(newMediaId.Value());

                CleanupStack::Pop(path);

                }

            else if (error == KErrCancel)

                {

                // The user has cancelled the popup list

                aAccepted = EFalse;

                CleanupStack::PopAndDestroy(this);

                }

            else

                {

                // The error is neither KErrNone or KErrCancel, leave.

                User::Leave(error);

                }

            }

        else

            {

            iMediaList->SetFocusL(NGlxListDefs::EAbsolute,

                    iListBox->CurrentItemIndex());

            const CListBoxView::CSelectionIndexArray* selectionIndices =

                    iListBox->SelectionIndexes();

            TInt count = selectionIndices->Count();

            for (TInt i = 0; i < count; i++)

                {

                iMediaList->SetSelectedL(selectionIndices->At(i), ETrue);

                }

            path = iMediaList->PathLC(NGlxListDefs::EPathFocusOrSelection);

            CleanupStack::Pop(path);

            CleanupStack::PopAndDestroy(this);

            }

        }

    else

        {

        CleanupStack::PopAndDestroy(this);

        }

    return path;

    }

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

// CGlxMediaSelectionPopup::ListBoxItemsChanged()

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

//  

void CGlxMediaSelectionPopup::ListBoxItemsChanged(CEikListBox* /*aListBox*/)

    {

    // Don't do anything.

    }

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

// Destructor

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

//

CGlxMediaSelectionPopup::~CGlxMediaSelectionPopup()

    {

    TRACER("CGlxMediaSelectionPopup::~CGlxMediaSelectionPopup");

    Cancel();

    delete iMediaListAdaptor;

    delete iListBox;

    if (iResourceOffset)

        {

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

        }

    if (iMediaList)

        {

        if (iAttributeContext)

            {

            iMediaList->RemoveContext(iAttributeContext);

            }

        iMediaList->RemoveMediaListObserver(this); // This is required in case ExecuteLD() left.