#include <QEventLoop>

#include <glxcommandhandlers.hrh>

GlxAlbumSelectionPopup::GlxAlbumSelectionPopup() 

    : mPopupDlg( 0 ), 

      mSelectionModel( 0 ),

      mEventLoop( 0 ),

      mResult( false )

{

}

GlxAlbumSelectionPopup::~GlxAlbumSelectionPopup()

{

}

QModelIndexList GlxAlbumSelectionPopup::GetSelectionList(GlxAlbumModel *model, bool *ok) 

{

    // Create a popup

    HbDialog popup;

    QEventLoop eventLoop;

    mEventLoop = &eventLoop;

    popup.setPreferredHeight( KListPrefferedHeight );

    // Set dismiss policy that determines what tap events will cause the popup

    // to be dismissed

    popup.setDismissPolicy(HbDialog::NoDismiss);

    // Set timeout to zero to wait user to either click Ok or Cancel

    popup.setTimeout(HbDialog::NoTimeout);

    popup.setHeadingWidget( new HbLabel("Select Album") );      

    mPopupDlg = &popup;

    HbListView *listview = new HbListView();

    listview->setSelectionMode(HbAbstractItemView::MultiSelection);

    listview->setModel(model);

    mSelectionModel = listview->selectionModel() ;

    connect( mSelectionModel, SIGNAL( selectionChanged( const QItemSelection &, const QItemSelection& ) ), this, SLOT( changeButtonText() ) );

    HbAction *primary = new HbAction( "New" );

    popup.addAction( primary ) ;

    HbAction *secondary = new HbAction( GLX_BUTTON_CANCEL );

    popup.addAction( secondary );

    popup.setContentWidget( listview ); //ownership transfer

    listview->show();

    popup.open( this, SLOT( dialogClosed( HbAction* ) ) ); 

    eventLoop.exec( );

    mEventLoop = 0 ;

    if ( ok ) {

        *ok = mResult ;

    }

    QModelIndexList selectedIndexes = mSelectionModel->selectedIndexes();       

    disconnect( mSelectionModel, SIGNAL( selectionChanged( const QItemSelection &, const QItemSelection& ) ), this, SLOT( changeButtonText() ) );

    delete primary;

    delete secondary;

    return selectedIndexes;

}

void GlxAlbumSelectionPopup::changeButtonText()

{

    if ( mSelectionModel->selectedIndexes().count() ) {

        mPopupDlg->actions().first()->setText( GLX_BUTTON_OK );

    else {

        mPopupDlg->actions().first()->setText("New");

    }    

}

void GlxAlbumSelectionPopup::dialogClosed(HbAction *action)

{

    HbDialog *dlg = static_cast<HbDialog*>(sender());

    if( action == dlg->actions().first() ) {

        mResult = true ;

    }

    else {

        mResult = false ;

    }

    if ( mEventLoop && mEventLoop->isRunning( ) ) {

        mEventLoop->exit( 0 );

    }

}

CMPXCommand* GlxCommandHandlerAddToContainer::CreateCommandL(TInt aCommandId,

    CMPXCommand* command = NULL;

    if(aCommandId == EGlxCmdAddToFav)

           CMPXCollectionPath* targetCollection = CMPXCollectionPath::NewL();

           CleanupStack::PushL(targetCollection);

           // The target collection has to be appeneded with the albums plugin id

           targetCollection->AppendL(KGlxCollectionPluginAlbumsImplementationUid);

           // The target collection has also to be appeneded with the the relation id.

           // appending another level into the albums to get favourites and 1 is the relation id of albums

           targetCollection->AppendL( TMPXItemId(KGlxCollectionFavoritesId) );

           targetCollection->Set( 0 );

           CMPXCollectionPath* sourceItems = aMediaList.PathLC( NGlxListDefs::EPathFocusOrSelection );

           command = TGlxCommandFactory::AddToContainerCommandLC(

               *sourceItems, *targetCollection);

           CleanupStack::Pop(command); 

           CleanupStack::PopAndDestroy(sourceItems);

           CleanupStack::PopAndDestroy(targetCollection);

            CMPXCollectionPath* sourceItems = aMediaList.PathLC(

            NGlxListDefs::EPathFocusOrSelection);

            bool ok = false;

            //create target medialist

            CMPXCollectionPath* path = CMPXCollectionPath::NewL();

            CleanupStack::PushL(path);

            path->AppendL(KGlxCollectionPluginAlbumsImplementationUid);

            CMPXFilter* filter =

            TGlxFilterFactory::CreateCameraAlbumExclusionFilterL();

            CleanupStack::PushL(filter);

            // Create the media list

            MGlxMediaList* targetMediaList = MGlxMediaList::InstanceL(*path,

                    TGlxHierarchyId(KSelectionPopupListHierarchy), filter); //todo take actual hierarchy 

            CleanupStack::PopAndDestroy(filter);

            CleanupStack::PopAndDestroy(path);

            //create target model

            GlxModelParm modelParm(KGlxCollectionPluginAlbumsImplementationUid,

                    KSelectionPopupListHierarchy, EGlxFilterExcludeCamera);

            GlxAlbumModel *albumMediaModel = new GlxAlbumModel(modelParm);

            albumMediaModel->setData(QModelIndex(), (int) GlxContextSelectionList,

                    GlxContextRole);

            GlxAlbumSelectionPopup popupWidget;

            QModelIndexList modelList = popupWidget.GetSelectionList(albumMediaModel, &ok);

            if(ok && modelList.count() == 0)

            {

                createNewMedia();

                ok = false;        

            }    

            OstTraceExt2( TRACE_NORMAL, GLXCOMMANDHANDLERADDTOCONTAINER_CREATECOMMANDL, "GlxCommandHandlerAddToContainer::CreateCommandL;ok=%d;newMedia=%d", ok, mNewMediaAdded );

            if (ok || mNewMediaAdded)

                {

                int count = modelList.count();

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

                    {

                    albumMediaModel->setData(modelList[i], modelList[i].row(),

                            GlxSelectedIndexRole);

                    }

                if (!mNewMediaAdded)

                    {

                    CMPXCollectionPath* targetContainers = targetMediaList->PathLC(

                            NGlxListDefs::EPathFocusOrSelection);

                    CleanupStack::Pop(targetContainers);

                    delete mTargetContainers;

                    mTargetContainers = NULL;

                    mTargetContainers = targetContainers;

                    }

                command = TGlxCommandFactory::AddToContainerCommandLC(*sourceItems,

                        *mTargetContainers);

                CleanupStack::Pop(command);

                mNewMediaAdded = false;

                }

            else

                {

                MGlxMediaList::UnmarkAllL(aMediaList);

                }

            MGlxMediaList::UnmarkAllL(*targetMediaList);

            targetMediaList->Close();

            CleanupStack::PopAndDestroy(sourceItems);

            delete albumMediaModel;

void GlxCommandHandlerAddToContainer::createNewMedia() const