/*

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

    {

    }

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

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

    }

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

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

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

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

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

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

    {

    switch (aEventType)

        {

        case EEventItemClicked:

        case EEventItemSingleClicked:

            {

                {

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

                    {

                    }

                }

            break;

            }

        default:

        }

    }

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

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

    {

        }

    }

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

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

        {

            {

			TFileName uiutilitiesrscfile;

			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.

        iMediaList->Close();

        }

    delete iAttributeContext;

    delete iSelectMediaPopupTitle;

    delete iNewMediaItemTitle;

    }

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

// CGlxMediaSelectionPopup::HandleItemAddedL()

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

//

void CGlxMediaSelectionPopup::HandleItemAddedL(TInt aStartIndex,