FCL/sf/app/videoplayer: comparison videocollection/videocollectionview/src/videolistselectiondialog.cpp

equal deleted inserted replaced

-:3738fe97f027
+:8aed59de29f9
 *
 * Description:   videolist selection dialog implementation
 *
 */
-#include <QGraphicsItem>
+// Version : %version: 22 %
+// INCLUDE FILES
+#include <qgraphicsitem.h>
 #include <hblabel.h>
 #include <hbcheckbox.h>
 #include <hbaction.h>
 #include <hbstackedwidget.h>
 #include <hbabstractitemview.h>
 #include "videosortfilterproxymodel.h"
 #include "videolistselectiondialog.h"
 #include "videocollectionwrapper.h"
 #include "videocollectionviewutils.h"
 #include "videocollectionclient.h"
+#include "videocollectiontrace.h"
 /**
 * global qHash function required fo creating hash values for TMPXItemId -keys
 */
 inline uint qHash(TMPXItemId key)
 // ---------------------------------------------------------------------------
 // VideoListSelectionDialog
 // ---------------------------------------------------------------------------
 //
-VideoListSelectionDialog::VideoListSelectionDialog(VideoCollectionUiLoader *uiLoader,
+VideoListSelectionDialog::VideoListSelectionDialog( VideoCollectionUiLoader *uiLoader,
-QGraphicsItem *parent) :
+QGraphicsItem *parent)
-HbDialog(parent),
+: HbDialog( parent )
-mUiLoader(uiLoader),
+, mUiLoader( uiLoader )
-mTypeOfSelection(-1),
+, mTypeOfSelection( -1 )
-mHeading(0),
+, mHeading( 0 )
-mCheckboxContainer(0),
+, mCheckboxContainer( 0 )
-mItemCount(0),
+, mItemCount( 0 )
-mCheckBox(0),
+, mCheckBox( 0 )
-mListContainer(0),
+, mListContainer( 0 )
-mForcedCheck(false),
+, mForcedCheck( false )
-mModel(0),
+, mModel( 0 )
-mListWidget(0)
+, mListWidget( 0 )
-{
+, mPrimaryAction( 0 )
+, mSecondaryAction( 0 )
+{
+	FUNC_LOG;
 setDismissPolicy(HbDialog::NoDismiss);
 setTimeout(HbDialog::NoTimeout);
 // create model for list widget
 mModel =
 VideoCollectionWrapper::instance().getModel(
-VideoCollectionWrapper::EGeneric);
+		VideoCollectionCommon::EModelTypeGeneric);
 if (mModel)
 {
 // create list widget
 mListWidget = new VideoListWidget(mUiLoader);
-if (mListWidget)
+if(mListWidget->initialize(*mModel) < 0)
 {
-if(mListWidget->initialize(*mModel) < 0)
+ERROR(-1, "VideoListSelectionDialog::VideoListSelectionDialog() failed to init list widget");
-{
+delete mListWidget;
-delete mListWidget;
+mListWidget = 0;
-mListWidget = 0;
-}
 }
 }
 }
 // ---------------------------------------------------------------------------
 // ~VideoListSelectionDialog
 // ---------------------------------------------------------------------------
 //
 VideoListSelectionDialog::~VideoListSelectionDialog()
 {
+	FUNC_LOG;
 delete mListWidget;
 }
 // ---------------------------------------------------------------------------
 // setupContent
 // ---------------------------------------------------------------------------
 //
 void VideoListSelectionDialog::setupContent(int type, TMPXItemId activeItem)
 {
+	FUNC_LOG;
+	INFO_1("VideoListSelectionDialog::setupContent() type: %d", type);
 if(type < EDeleteVideos || type > ESelectCollection)
 {
 return;
 }
 mTypeOfSelection = type;
 if(!initDialog())
 {
+ERROR(-1, "VideoListSelectionDialog::setupContent() dialog init failed.");
 return;
 }
 mSelection.clear();
 mSelectedVideos.clear();
 mSelectedAlbumId = TMPXItemId::InvalidId();
 // initDialog
 // ---------------------------------------------------------------------------
 //
 bool VideoListSelectionDialog::initDialog()
 {
+	FUNC_LOG;
 if(!mModel)
 {
-mModel = VideoCollectionWrapper::instance().getModel(VideoCollectionWrapper::EGeneric);
+mModel = VideoCollectionWrapper::instance().getModel(VideoCollectionCommon::EModelTypeGeneric);
 if (!mModel)
 {
 return false;
 }
 }
 if(!mListWidget)
 {
 mListWidget = new VideoListWidget(mUiLoader);
 if(mListWidget->initialize(*mModel) < 0)
 {
+ERROR(-1, "VideoListSelectionDialog::initDialog() failed to setup VideoListWidget.");
 delete mListWidget;
 mListWidget = 0;
 mListContainer = 0;
 return false;
 }
 }
 if(!mCheckboxContainer)
 {
 mCheckboxContainer = mUiLoader->findWidget<HbWidget>(DOCML_NAME_CHECK_CONTAINER);
 }
 if(!mItemCount)
 {
 mItemCount = mUiLoader->findWidget<HbLabel>(DOCML_NAME_LBL_SELECTION);
 mItemCount->setAlignment(Qt::AlignRight);
 }
 if(!mCheckBox)
 {
 mCheckBox = mUiLoader->findWidget<HbCheckBox >(DOCML_NAME_MARKALL);
 }
-if(!primaryAction())
+// HbDialog connects actions to finished signal by default.
-{
+if(!mPrimaryAction)
-setPrimaryAction(new HbAction(hbTrId("txt_common_button_ok"), this));
+{
-}
+mPrimaryAction = new HbAction(hbTrId("txt_common_button_ok"));
-if(!secondaryAction())
+addAction(mPrimaryAction);
-{
+}
-setSecondaryAction(new HbAction(hbTrId("txt_common_button_cancel"), this));
+if(!mSecondaryAction)
-}
+{
-if(!mListWidget || !mListContainer || !mHeading || !mCheckBox || !primaryAction() || !secondaryAction())
+mSecondaryAction = new HbAction(hbTrId("txt_common_button_cancel"));
-{
+addAction(mSecondaryAction);
+}
+if(!mListContainer || !mHeading || !mCheckBox)
+{
+ERROR(-1, "VideoListSelectionDialog::initDialog() !mListContainer || !mHeading || !mCheckBox");
 return false;
 }
 return true;
 }
 // activateSelection
 // ---------------------------------------------------------------------------
 //
 void VideoListSelectionDialog::activateSelection()
 {
+	FUNC_LOG;
 // "add to collection" and "remove from collection -selections needs
 // additional functionality for primary key
 if(mTypeOfSelection == EAddToCollection ||
 mTypeOfSelection == ERemoveFromCollection)
 {
-primaryAction()->disconnect(SIGNAL(triggered()));
+mPrimaryAction->disconnect(SIGNAL(triggered()));
-connect(primaryAction(), SIGNAL(triggered()), this, SLOT(primaryActionTriggeredSlot()));
+connect(mPrimaryAction, SIGNAL(triggered()), this, SLOT(primaryActionTriggeredSlot()));
 }
 QString headingTxt("");
 QString primaryTxt("");
 // create texts
 switch(mTypeOfSelection)
 {
 case EDeleteVideos:
 primaryTxt = hbTrId("txt_common_button_delete");
 break;
 case EAddToCollection:
 primaryTxt = hbTrId("txt_common_button_add");
 break;
 case ERemoveFromCollection:
 primaryTxt = hbTrId("txt_common_button_remove");
 break;
 case ESelectCollection:
 primaryTxt = hbTrId("txt_videos_button_new");
 break;
 default:
 break;
 }
-HbAction *primary = primaryAction();
+mPrimaryAction->setText(primaryTxt);
-primary->setText(primaryTxt);
 if(mTypeOfSelection == ESelectCollection)
 {
 headingTxt = hbTrId("txt_videos_title_select_collection");
 mCheckboxContainer->setVisible(false);
 mListWidget->setSelectionMode(-1);
 mListWidget->activate(VideoCollectionCommon::ELevelCategory);
 // need to set primaryaction disabled here in order for it
 // get correctly updated at modelReady(), where it will be enabled
 // if state would be same, no update will happen
-primary->setDisabled(true);
+mPrimaryAction->setDisabled(true);
 }
 else
 {
 headingTxt = hbTrId("txt_videos_title_select_videos");
 mListWidget->setSelectionMode(HbAbstractItemView::MultiSelection);
 mItemCount->setPlainText(tr("0/%1").arg(mModel->rowCount()));
 mCheckBox->setChecked(false);
 // need to set primaryaction enabled here in order for it
 // get correctly updated at modelReady(), where it will be disabled
 // if state would be same, no update will happen
-primary->setDisabled(false);
+mPrimaryAction->setDisabled(false);
 }
 mHeading->setPlainText(headingTxt);
 // sort to make sure dialog has correctly filtered content
 // at the same order as in view
-VideoCollectionViewUtils::sortModel(mModel, false);
+VideoCollectionViewUtils::sortModel(mModel, false, mListWidget->getLevel());
 }
 // ---------------------------------------------------------------------------
 // exec
 // ---------------------------------------------------------------------------
 //
 void VideoListSelectionDialog::exec()
 {
+	FUNC_LOG;
 // clear checkbox
 mCheckBox->setChecked(false);
 mListWidget->clearSelection();
 // show dialog
 HbDialog::open();
 }
 else
 {
+INFO("VideoListSelectionDialog::exec(): nothing to show, finishing.")
 // no items, finish right away
-finishedSlot(primaryAction());
+finishedSlot(mPrimaryAction);
 }
 }
 // ---------------------------------------------------------------------------
 // finishedSlot
 // ---------------------------------------------------------------------------
 //
 void VideoListSelectionDialog::finishedSlot(HbAction *action)
 {
+	FUNC_LOG;
 disconnectSignals();
-if(action == secondaryAction())
+if(action == mSecondaryAction)
 {
+INFO("VideoListSelectionDialog::exec(): secondary action triggered.")
 return;
 }
 QString albumName("");
 if( mTypeOfSelection == ESelectCollection )
 {
 if( mSelectedAlbumId == TMPXItemId::InvalidId())
 {
 albumName = queryNewAlbumSelected();
 if(mSelectedAlbumId == TMPXItemId::InvalidId())
 {
-// user cancelled new album creation
+// user canceled new album creation
 return;
 }
 }
 mTypeOfSelection = EAddToCollection;
+}
-}
+// Must be checked again if type was ESelectCollection
 if(mTypeOfSelection == EAddToCollection)
 {
 if(mSelectedAlbumId != TMPXItemId::InvalidId() && mSelectedVideos.count())
 {
 if(mModel->addItemsInAlbum(mSelectedAlbumId, mSelectedVideos.toList()) == 0)
 // markAllStateChanged
 // ---------------------------------------------------------------------------
 //
 void VideoListSelectionDialog::markAllStateChangedSlot(int state)
 {
+	FUNC_LOG;
 if(mForcedCheck)
 {
 return;
 }
-if( state == Qt::Checked)
+if(state == Qt::Checked)
 {
 mListWidget->selectAll();
 }
 else
 {
 // selectionChangedSlot
 // ---------------------------------------------------------------------------
 //
 void VideoListSelectionDialog::selectionChangedSlot(const QItemSelection &selected, const QItemSelection &deselected)
 {
-if(!primaryAction() || mTypeOfSelection == ESelectCollection)
+	FUNC_LOG;
-{
+if(!mPrimaryAction || mTypeOfSelection == ESelectCollection)
+{
+INFO("VideoListSelectionDialog::selectionChangedSlot(): no primary action or we are selecting collection.")
 return;
 }
 if(selected.indexes().count() > 0)
 {
 mSelection.merge(deselected, QItemSelectionModel::Deselect);
 }
 if(mSelection.indexes().count() > 0)
 {
-primaryAction()->setDisabled(false);
+mPrimaryAction->setDisabled(false);
 }
 else
 {
-primaryAction()->setDisabled(true);
+mPrimaryAction->setDisabled(true);
 }
 updateCounterSlot();
 }
 // singleItemSelectedSlot
 // ---------------------------------------------------------------------------
 //
 void VideoListSelectionDialog::singleItemSelectedSlot(const QModelIndex &index)
 {
+	FUNC_LOG;
 if(mTypeOfSelection == ESelectCollection)
 {
 if(index.isValid())
 {
 mSelectedAlbumId = mModel->getMediaIdAtIndex(index);
-primaryAction()->trigger();
+mPrimaryAction->trigger();
 }
 }
 }
 // ---------------------------------------------------------------------------
 // modelReadySlot
 // ---------------------------------------------------------------------------
 //
 void VideoListSelectionDialog::modelReadySlot()
 {
+	FUNC_LOG;
 if(mTypeOfSelection == ESelectCollection)
 {
-primaryAction()->setDisabled(false);
+mPrimaryAction->setDisabled(false);
 if(!mModel->rowCount())
 {
 // in case there are no user defined albums,
 // start input dialog right away by accepting dialog
-primaryAction()->trigger();
+INFO("VideoListSelectionDialog::selectionChangedSlot(): no albums, starting album creation.")
+mPrimaryAction->trigger();
 return;
 }
 }
 if(mTypeOfSelection != ESelectCollection)
 {
-primaryAction()->setDisabled(true);
+mPrimaryAction->setDisabled(true);
 }
 updateCounterSlot();
 }
 // ---------------------------------------------------------------------------
 // updateCounterSlot
 // ---------------------------------------------------------------------------
 //
 void VideoListSelectionDialog::updateCounterSlot()
 {
+	FUNC_LOG;
 if(!mItemCount)
 {
 return;
 }
 else
 {
 mCheckBox->setChecked(false);
 }
 mForcedCheck = false;
 }
 // ---------------------------------------------------------------------------
 // primaryActionTriggeredSlot
 // ---------------------------------------------------------------------------
 //
 void VideoListSelectionDialog::primaryActionTriggeredSlot()
 {
+	FUNC_LOG;
 // reconnect primary action
-primaryAction()->disconnect(SIGNAL(triggered()));
+mPrimaryAction->disconnect(SIGNAL(triggered()));
-connect(primaryAction(), SIGNAL(triggered()), this, SLOT(close()));
+connect(mPrimaryAction, SIGNAL(triggered()), this, SLOT(close()));
 // update video items selection here before content changes.
 int count = mSelection.indexes().count();
 TMPXItemId id = TMPXItemId::InvalidId();
 for(int i = 0; i < count; ++i)
 {
 }
 }
 if(mSelectedAlbumId != TMPXItemId::InvalidId())
 {
-primaryAction()->trigger();
+INFO("VideoListSelectionDialog::primaryActionTriggeredSlot(): closing dialog.")
+mPrimaryAction->trigger();
 return;
 }
 else if(mTypeOfSelection == EAddToCollection)
 {
+INFO("VideoListSelectionDialog::primaryActionTriggeredSlot(): activating collection selection.")
 // videos for collection selected, but collection
 // not yet selected, activate selection for it
 mTypeOfSelection = ESelectCollection;
 activateSelection();
 }
 // connectSignals
 // ---------------------------------------------------------------------------
 //
 void VideoListSelectionDialog::connectSignals()
 {
+	FUNC_LOG;
 // dialog finished
 connect(this, SIGNAL(finished(HbAction*)), this, SLOT(finishedSlot(HbAction*)));
 // selection changes
 connect(mListWidget, SIGNAL(activated(const QModelIndex&)),
 this, SLOT(singleItemSelectedSlot(const QModelIndex&)));
 connect(mListWidget->selectionModel(), SIGNAL(selectionChanged (const QItemSelection&, const QItemSelection&)),
 this, SLOT(selectionChangedSlot(const QItemSelection&, const QItemSelection &)));
 // model changes signals
 connect(mModel->sourceModel(), SIGNAL(modelReady()), this, SLOT(modelReadySlot()));
 connect(mModel->sourceModel(), SIGNAL(modelChanged()), this, SLOT(updateCounterSlot()));
 // mark all state changes
 // disconnectSignals
 // ---------------------------------------------------------------------------
 //
 void VideoListSelectionDialog::disconnectSignals()
 {
+	FUNC_LOG;
 disconnect(this, SIGNAL(finished(HbAction*)), this, SLOT(finishedSlot(HbAction*)));
 disconnect(mListWidget, SIGNAL(activated(const QModelIndex&)),
 this, SLOT(singleItemSelectedSlot(const QModelIndex&)));
 disconnect(mListWidget->selectionModel(), SIGNAL(selectionChanged (const QItemSelection&, const QItemSelection&)),
 this, SLOT(selectionChangedSlot(const QItemSelection&, const QItemSelection &)));
 // model changes signals
 disconnect(mModel->sourceModel(), SIGNAL(modelReady()), this, SLOT(modelReadySlot()));
 disconnect(mModel->sourceModel(), SIGNAL(modelChanged()), this, SLOT(updateCounterSlot()));
 // mark all state changes
 disconnect(mCheckBox, SIGNAL(stateChanged(int)), this, SLOT(markAllStateChangedSlot(int)));
 }
 // ---------------------------------------------------------------------------
 // getSelectedName
 // ---------------------------------------------------------------------------
 //
 QString VideoListSelectionDialog::getSelectedName()
 {
+	FUNC_LOG;
 QString name;
 if(mSelectedAlbumId.iId2 > KVcxMvcMediaTypeVideo)
 {
 VideoSortFilterProxyModel *model =
 VideoCollectionWrapper::instance().getModel(
-VideoCollectionWrapper::ECollections);
+		VideoCollectionCommon::EModelTypeCollections);
 if(!model)
 {
 return name;
 }
 QModelIndex index = model->indexOfId(mSelectedAlbumId);
 if(index.isValid())
 {
-name = model->data(index, Qt::DisplayRole).toStringList().first();
+name = model->data(index, VideoCollectionCommon::KeyTitle).toString();
 }
 }
 return name;
 }
 // queryNewAlbumSelected
 // ---------------------------------------------------------------------------
 //
 QString VideoListSelectionDialog::queryNewAlbumSelected()
 {
+	FUNC_LOG;
 mSelectedAlbumId = TMPXItemId::InvalidId();
 bool ok = false;
 QString label(hbTrId("txt_videos_title_enter_name"));
 QString text("");
 text = HbInputDialog::getText(label, hbTrId("txt_videos_dialog_entry_new_collection"), &ok);

changeset 36	8aed59de29f9
parent 35	3738fe97f027
child 37	4eb2df7f7cbe