1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (developer.feedback@nokia.com)

     6 **

     7 ** This file is part of the HbWidgets module of the UI Extensions for Mobile.

     8 **

     9 ** GNU Lesser General Public License Usage

    10 ** This file may be used under the terms of the GNU Lesser General Public

    11 ** License version 2.1 as published by the Free Software Foundation and

    12 ** appearing in the file LICENSE.LGPL included in the packaging of this file.

    13 ** Please review the following information to ensure the GNU Lesser General

    14 ** Public License version 2.1 requirements will be met:

    15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    16 **

    17 ** In addition, as a special exception, Nokia gives you certain additional

    18 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    20 **

    21 ** If you have questions regarding the use of this file, please contact

    22 ** Nokia at developer.feedback@nokia.com.

    23 **

    24 ****************************************************************************/

    25 

    26 #include <QGraphicsGridLayout>

    27 #include <qglobal.h>

    28 #include "hbabstractviewitem.h"

    29 #include "hblistdialog_p.h"

    30 #include <hblabel.h>

    31 #include <hbaction.h>

    32 #include <hblistwidget.h>

    33 #include <hblistwidgetitem.h>

    34 #include <QtDebug>

    35 

    36 HbListDialogContentWidget::HbListDialogContentWidget(HbListDialogPrivate *priv):HbWidget(),

    37 						mListView(0),d(priv)

    38 {

    39     mListView = new HbListWidget(this);

    40     HbStyle::setItemName(mListView, "list");

    41     HbStyle::setItemName(this, "this");

    42     HbAbstractItemView *view = qobject_cast<HbListWidget*>(mListView);

    43     if(view)

    44         QObject::connect(view,SIGNAL(activated(const QModelIndex&)),this,SLOT(_q_listItemSelected(QModelIndex)));

    45 

    46     HbListWidget* widget = qobject_cast<HbListWidget*>(mListView);

    47     

    48     if(widget){

    49         QObject::connect(widget,SIGNAL(activated(HbListWidgetItem *)),this,SLOT(_q_listWidgetItemSelected(HbListWidgetItem *)));

    50         widget->installEventFilter(this);

    51     }

    52 }

    53 

    54 

    55 void HbListDialogContentWidget::_q_listWidgetItemSelected(HbListWidgetItem *item)

    56 {

    57 	if(item){

    58 		HbListWidget* widget = qobject_cast<HbListWidget*>(mListView);

    59 		if(widget){

    60 			d->mSelectedIndex = widget->row(item);

    61 		}

    62 	}

    63 }

    64 

    65 

    66 void HbListDialogContentWidget::_q_listItemSelected(QModelIndex index)

    67 {

    68 	if(mListView->selectionMode()== HbAbstractItemView::NoSelection){

    69 		d->mSelectedModelIndex = index;

    70 		d->mSelectedIndex = index.row();

    71 	}

    72 	if(mListView->selectionMode()== HbAbstractItemView::SingleSelection ||

    73 	   mListView->selectionMode()== HbAbstractItemView::NoSelection){

    74 	   d->close();   

    75 	}

    76 }

    77 

    78 bool HbListDialogContentWidget::eventFilter(QObject *obj, QEvent *event)

    79 {

    80     bool accepted = false;

    81     if (obj == mListView) {

    82          switch(event->type()){

    83          case QEvent::LayoutRequest: {

    84              qreal minHeight = minimumHeight();

    85              qreal maxHeight = preferredHeight();

    86              qreal height = 0;

    87              int count = 0;

    88              QAbstractItemModel* itemModel = mListView->model();

    89              if(itemModel)

    90                  count = itemModel->rowCount();

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

    92                  HbAbstractViewItem *row = mListView->viewItem(i);

    93                  if(row)

    94                      height += row->size().rheight();

    95              }

    96              if(height > minHeight && height < maxHeight){

    97                  setPreferredHeight(height);

    98                  parentWidget()->resize(parentWidget()->preferredSize());

    99              }

   100              break;

   101          }

   102          default:

   103              break;

   104          }

   105     }

   106     return accepted;

   107 }

   108 

   109 HbListDialogPrivate::HbListDialogPrivate()

   110     :HbDialogPrivate()

   111 {

   112 	bOwnItems = false;

   113 	mSelectedIndex = -1;

   114 }

   115 

   116 

   117 HbListDialogPrivate::~HbListDialogPrivate()

   118 {

   119 	if(!bOwnItems){

   120 			Q_Q(HbListDialog);

   121 			HbListDialogContentWidget* cWidget = qobject_cast<HbListDialogContentWidget*>(q->contentWidget());

   122 			if(cWidget){

   123 				HbListWidget* widget = qobject_cast<HbListWidget*>(cWidget->mListView);

   124 				if(widget){

   125                     int nRows = 0;

   126                     QAbstractItemModel* itemModel = widget->model();

   127                     if(itemModel){

   128                         nRows = itemModel->rowCount();

   129                         while(nRows){

   130                             widget->takeItem(0);

   131                             nRows = itemModel->rowCount();

   132                         }

   133                     }

   134 				}

   135 			}

   136 	}

   137 }

   138 void HbListDialogPrivate::init()

   139 {

   140     qDebug()<<" Entering init()";

   141     Q_Q(HbListDialog);

   142 

   143     bOwnItems = false;

   144 

   145     HbListDialogContentWidget* contentWidget = new HbListDialogContentWidget(this);

   146     q->setContentWidget(contentWidget);

   147 

   148     mPrimaryAction = new HbAction(QString(q->tr("Ok")));

   149     q->setPrimaryAction(mPrimaryAction);

   150 

   151     mSecondaryAction = new HbAction(QString(q->tr("Cancel")));

   152     q->setSecondaryAction(mSecondaryAction);

   153     q->setTimeout(0);

   154     q->setModal(true);

   155 

   156     createPrimitives();

   157 }

   158 

   159 void HbListDialogPrivate::createPrimitives()

   160 {

   161 }

   162 

   163 void HbListDialogPrivate::updatePrimitives()

   164 {

   165 }

   166 

   167 

   168 void HbListDialogPrivate::setSelectionMode(HbAbstractItemView::SelectionMode mode)

   169 {

   170 	Q_Q(HbListDialog);

   171 

   172 	mSelectionMode = mode;

   173 	switch(mode)

   174 	{

   175 	case HbAbstractItemView::SingleSelection:

   176 	case HbAbstractItemView::MultiSelection:

   177 	case HbAbstractItemView::NoSelection:

   178 	{

   179 		HbListDialogContentWidget* cWidget = qobject_cast<HbListDialogContentWidget*>(q->contentWidget());

   180 		if(cWidget){

   181 			cWidget->mListView->setSelectionMode(mode);

   182 		}

   183 	}

   184 	break;

   185 	case HbAbstractItemView::ContiguousSelection:

   186 		break;

   187 	}

   188 }

   189 

   190 QList<HbListWidgetItem*> HbListDialogPrivate::widgetItems() const

   191 {

   192 	Q_Q(const HbListDialog);

   193 

   194 	QList<HbListWidgetItem*> rows;

   195 	HbListDialogContentWidget* cWidget = qobject_cast<HbListDialogContentWidget*>(q->contentWidget());

   196 	if(cWidget){

   197 		HbListWidget* widget = qobject_cast<HbListWidget*>(cWidget->mListView);

   198 		if(widget){

   199             int count = 0;

   200             QAbstractItemModel* itemModel = widget->model();

   201             if(itemModel)

   202                 count = itemModel->rowCount();

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

   204 				rows.append(widget->item(i));

   205 			}

   206 		}

   207 	}

   208 	return rows;

   209 }

   210 

   211 void HbListDialogPrivate::setCurrentRow(int row)

   212 {

   213 	Q_Q(HbListDialog);

   214 

   215 	HbListDialogContentWidget* cWidget = qobject_cast<HbListDialogContentWidget*>(q->contentWidget());

   216 	if(cWidget){

   217 		HbListWidget* widget = qobject_cast<HbListWidget*>(cWidget->mListView);

   218 		if(widget){

   219             QAbstractItemModel* itemModel = widget->model();

   220             QModelIndex index;

   221             if(itemModel){

   222                 index = itemModel->index(row,0);

   223             }

   224 		    QItemSelectionModel* selectionModel = widget->selectionModel();

   225 		    if(selectionModel){

   226                 selectionModel->select(index,QItemSelectionModel::Select);

   227 		    }

   228 		}

   229 	}

   230 }

   231 

   232 void HbListDialogPrivate::setStringItems(const QStringList &items, int current)

   233 {

   234 	Q_Q(HbListDialog);

   235 

   236 	HbListDialogContentWidget* cWidget = qobject_cast<HbListDialogContentWidget*>(q->contentWidget());

   237 	if(!cWidget) return;

   238 	

   239 	HbListWidget* widget = qobject_cast<HbListWidget*>(cWidget->mListView);

   240     int nRows = 0;

   241 

   242 	if(widget){

   243 		int count = items.size();

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

   245 			HbListWidgetItem* modelItem = new HbListWidgetItem();

   246 			QString str = items.at(i);

   247 			modelItem->setText(str);

   248 			widget->addItem(modelItem);

   249 			

   250             QAbstractItemModel* itemModel = widget->model();

   251             if(itemModel)

   252                 nRows = itemModel->rowCount();

   253 		}

   254 		if(nRows > 0){ //if addition of rows was correct.

   255             QList<int> currentRow;

   256             currentRow.append(current);

   257             setSelectedItems(currentRow);

   258 		}

   259 		

   260 	}

   261 }

   262 

   263 QStringList HbListDialogPrivate::stringItems() const

   264 {

   265 	QStringList list;

   266 	QList<HbListWidgetItem*> items = widgetItems();

   267 	int count = items.count();

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

   269                 QString text = items[i]->text();

   270                 if(!text.isEmpty()){

   271 			list += text;

   272 		}

   273 	}

   274 	return list;

   275 }

   276 

   277 int HbListDialogPrivate::currentRow()

   278 {

   279 	Q_Q(HbListDialog);

   280 

   281 	int nCurrentRow = -1;

   282 

   283 	HbListDialogContentWidget* cWidget = qobject_cast<HbListDialogContentWidget*>(q->contentWidget());

   284 	if(!cWidget) return nCurrentRow;

   285 

   286 	HbListWidget* widget = qobject_cast<HbListWidget*>(cWidget->mListView);

   287 	if(widget){

   288             QItemSelectionModel* selectionModel = widget->selectionModel();

   289             if(selectionModel){

   290                 QModelIndexList selectdList = selectionModel->selectedIndexes();

   291                 if(selectdList.count() > 0)

   292                     nCurrentRow = selectdList[0].row();

   293             }

   294 	}

   295 	return nCurrentRow;

   296 }

   297 

   298 void HbListDialogPrivate::setModel(QAbstractItemModel* model)

   299 {

   300 	Q_Q(HbListDialog);

   301 

   302 	HbListDialogContentWidget* cWidget = qobject_cast<HbListDialogContentWidget*>(q->contentWidget());

   303 	if(cWidget){

   304 		cWidget->mListView->HbListView::setModel(model); //HbListView's implementation of setModel()

   305 	}

   306 }

   307 

   308 void HbListDialogPrivate::setWidgetItems(QList<HbListWidgetItem*> &items,bool bTransferOwnership,int current)

   309 {

   310 	Q_Q(HbListDialog);

   311 

   312 	HbListDialogContentWidget* cWidget = qobject_cast<HbListDialogContentWidget*>(q->contentWidget());

   313 	if(cWidget){

   314 		HbListWidget* widget = qobject_cast<HbListWidget*>(cWidget->mListView);

   315 		if(widget){

   316 			int count = items.count();

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

   318 				widget->addItem(items[i]);

   319 			}

   320 			widget->setCurrentRow(current);

   321 			

   322 		}

   323 		bOwnItems = bTransferOwnership;

   324 	}

   325 }

   326 

   327 QAbstractItemModel* HbListDialogPrivate::model() const

   328 {

   329 	Q_Q(const HbListDialog);

   330 	

   331 	HbListDialogContentWidget* cWidget = qobject_cast<HbListDialogContentWidget*>(q->contentWidget());

   332 	if(cWidget){

   333 		return cWidget->mListView->HbListView::model(); //HbListView's implementation of model()

   334 	}

   335 	return 0;

   336 }

   337 

   338 QItemSelectionModel* HbListDialogPrivate::selectionModel() const

   339 {

   340 	Q_Q(const HbListDialog);

   341 	

   342 	HbListDialogContentWidget* cWidget = qobject_cast<HbListDialogContentWidget*>(q->contentWidget());

   343 	if(cWidget){

   344 		return cWidget->mListView->selectionModel();

   345 	}

   346 	return 0;

   347 }

   348 

   349 void HbListDialogPrivate::setSelectedItems(QList<int> items)

   350 {

   351     QItemSelectionModel *model = 0;

   352     model = selectionModel();

   353     if(model){

   354         Q_FOREACH(int i,items) {

   355                 model->select(model->model()->index(i,0),

   356                     QItemSelectionModel::Select);

   357         }

   358     }

   359 }

   360 

   361 QList<int> HbListDialogPrivate::selectedItems() const

   362 {

   363     QItemSelectionModel *model = 0;

   364     QList<int> selIndexes;

   365     model = selectionModel();

   366     if(model){

   367         QModelIndexList indexes = model->selectedIndexes();

   368         int count = indexes.count();

   369         QModelIndex index;

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

   371             index = indexes[i];

   372             selIndexes.append(index.row());

   373         }

   374     }

   375     return selIndexes;

   376 

   377 }

   378 

   379 QModelIndexList HbListDialogPrivate::selectedModelIndexes() const

   380 {

   381     QItemSelectionModel *model = 0;

   382     QModelIndexList selIndexes;

   383     model = selectionModel();

   384     if(model){

   385         selIndexes =  model->selectedIndexes();

   386     }

   387     return selIndexes;

   388 }

   389 

   390 void HbListDialogPrivate::close()

   391 {

   392 	Q_Q(HbListDialog);

   393 	q->close();

   394 }

   395