/*

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

    {

    }

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

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

    }

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

// CGlxSingleGraphicPopupMenuStyleListBox::IsVisible

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

// 

TBool CGlxSingleGraphicPopupMenuStyleListBox::IsVisible(TInt aItemIndex)

    {

    TRACER("CGlxSingleGraphicPopupMenuStyleListBox::IsVisible");

    return (TopItemIndex() <= aItemIndex && aItemIndex <= BottomItemIndex());

    }

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

// CGlxSingleGraphicPopupMenuStyleListBox::OfferKeyEventL()

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

//   

EXPORT_C TKeyResponse CGlxSingleGraphicPopupMenuStyleListBox::OfferKeyEventL(

        const TKeyEvent& aKeyEvent, TEventCode aType)

    {

    TRACER("CGlxSingleGraphicPopupMenuStyleListBox::OfferKeyEventL");

    __ASSERT_DEBUG(dynamic_cast< CGlxMediaListAdaptor*>(Model()->ItemTextArray()), Panic(EGlxPanicCastFailed));

    if (aKeyEvent.iCode == EKeyOK && iView)

        {

        CGlxMediaListAdaptor* mediaListAdaptor =

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

        if (mediaListAdaptor->MultiSelectionEnabled()

                && View()->CurrentItemIndex() >= 0)

            {

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

                    View()->CurrentItemIndex());

            // Reset the observer to populist

            SetListBoxObserver(iPopupList);

            if (item.IsStatic())

                {

                iListBoxFlags &= (~EMultipleSelection); // turn off multiple selection

                }

            else

                {

                iListBoxFlags |= EMultipleSelection; // turn on multiple selection

                }

            }

        }

    return CAknSingleGraphicPopupMenuStyleListBox::OfferKeyEventL(aKeyEvent,

            aType);

    }

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

// CGlxSingleGraphicPopupMenuStyleListBox::HandleListBoxEventL()

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

// 

void CGlxSingleGraphicPopupMenuStyleListBox::HandleListBoxEventL(

        CEikListBox *aListBox, TListBoxEvent aEventType)

    {

    TRACER("CGlxSingleGraphicPopupMenuStyleListBox::HandleListBoxEventL");

    switch (aEventType)

        {

        case EEventItemClicked:

        case EEventItemSingleClicked:

            {

            CGlxMediaListAdaptor

                    * mediaListAdaptor =

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

            if (mediaListAdaptor->MultiSelectionEnabled()

                    && View()->CurrentItemIndex() >= 0)

                {

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

                        View()->CurrentItemIndex());

                if (item.IsStatic())

                    {

                    // when the user marks a non-static item and then clicks on

                    // a static item without moving highlight, the control comes here.

                    iListBoxFlags &= (~EMultipleSelection); // turn off multiple selection

                    }

                else

                    {

                    iListBoxFlags |= EMultipleSelection; // turn on multiple selection

                    TBool isMarked = View()->ItemIsSelected(

                            View()->CurrentItemIndex());

                    (isMarked == (TBool) ETrue)

                                                ? (View()->DeselectItem(

                                                       View()->CurrentItemIndex()))

                                                   : (View()->SelectItemL(

                                                           View()->CurrentItemIndex()));

                    }

                }

            aListBox->DrawDeferred();

            break;

            }

        default:

            break;

        }

    }

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

// CGlxSingleGraphicPopupMenuStyleListBox::HandlePointerEventL()

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

//  

void CGlxSingleGraphicPopupMenuStyleListBox::HandlePointerEventL(

        const TPointerEvent& aPointerEvent)

    {

    TRACER("CGlxSingleGraphicPopupMenuStyleListBox::HandlePointerEventL");

    CGlxMediaListAdaptor* mediaListAdaptor =

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

    if (mediaListAdaptor->MultiSelectionEnabled())

        {

        // Need to handle the case when the highlight is on one item

        // and the user clicks on another media item. The notification 

        // of changed item index is received very late. In order to

        // handle this, checking if the index has changed.

        TInt changedItemIndex = -1;

        TInt itemIndex = View()->CurrentItemIndex();

        TBool isItemChanged = View()->XYPosToItemIndex(

                aPointerEvent.iPosition, changedItemIndex);

        if (isItemChanged)

            {

            itemIndex = changedItemIndex;

            }

        const TGlxMedia& item =

                mediaListAdaptor->MediaList()->Item(itemIndex);

        if (item.IsStatic())

            {

            // A static item is not markable. Turn off multiple selection

            // Set the listbox observer to default that is CAknPopupList 

            // object, which will process it further.

            iListBoxFlags &= (~EMultipleSelection);

            SetListBoxObserver(iPopupList);

            }

        else

            {

            // Markable object. The event is handled in HandleListBoxEventL()

            // Set the listbox observer to the current object.

            SetListBoxObserver(this);

            }

        CAknSingleGraphicPopupMenuStyleListBox::HandlePointerEventL(

                aPointerEvent);

        const CListBoxView::CSelectionIndexArray* selectionIndices =

                View()->SelectionIndexes();

        CEikButtonGroupContainer* cbaContainer =

                iPopupList->ButtonGroupContainer();

        if (selectionIndices->Count() || item.IsStatic())

            {

            cbaContainer->SetCommandSetL(R_GLX_SOFTKEYS_OK_CANCEL);

            }

        else

            {

            cbaContainer->SetCommandSetL(R_AVKON_SOFTKEYS_CANCEL);

            }

        cbaContainer->DrawDeferred();

        }

    else

        {

        CAknSingleGraphicPopupMenuStyleListBox::HandlePointerEventL(

                aPointerEvent);

        }

    }

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

// CGlxSingleGraphicPopupMenuStyleListBox::SetPopupList()

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

// 

void CGlxSingleGraphicPopupMenuStyleListBox::SetPopupList(

        CAknPopupList* aPopupList)

    {

    TRACER("CGlxSingleGraphicPopupMenuStyleListBox::SetPopupList");

    iPopupList = aPopupList;

    }

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

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

        {

        if (iMediaList->Item(iListBox->CurrentItemIndex()).IsStatic())

            {

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

        }