1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0""

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Helper class by which a plugin can communicate with the associated dataform.

    15 *

    16 */

    17 #include "cpitemdatahelper.h"

    18 #include <QList>

    19 #include <hbdataform.h>

    20 #include <hbdataformmodelitem.h>

    21 #include <hbdataformviewitem.h>

    22 #include <hbdataformmodel.h>

    23 

    24 /*!

    25 \internal

    26 */

    27 class CpItemDataHelperPrivate

    28 {

    29 public:

    30     /*!

    31     \internal

    32     */

    33     class ItemConnection

    34     {

    35     public:

    36         ItemConnection(HbDataFormModelItem *item,

    37             const char *signal,

    38             QObject *receiver,

    39             const char *method) :

    40             mItem(item),mSignal(signal),

    41             mReceiver(receiver),mMethod(method)

    42         {

    43         }

    44 

    45         bool operator == (const ItemConnection &other)

    46         {

    47             return mItem     == other.mItem &&

    48                    mSignal   == other.mSignal &&

    49                    mReceiver == other.mReceiver &&

    50                    mMethod   == other.mMethod;

    51         }

    52 

    53         HbDataFormModelItem *mItem;

    54         QString mSignal;

    55         QObject *mReceiver;

    56         QString mMethod;

    57     };

    58 

    59     class FormConnection

    60     {

    61     public:

    62         FormConnection(const char *signal,

    63             QObject *receiver,

    64             const char *method) :

    65             mSignal(signal),mReceiver(receiver),mMethod(method)

    66         {

    67         }

    68 

    69         bool operator == (const FormConnection &other)

    70         {

    71             return mSignal   == other.mSignal &&

    72                    mReceiver == other.mReceiver &&

    73                    mMethod   == other.mMethod;

    74         }

    75         QString mSignal;

    76         QObject *mReceiver;

    77         QString mMethod;

    78     };

    79 

    80 	CpItemDataHelperPrivate(HbDataForm *form /*= 0*/)

    81         : mDataForm(form)

    82 	{

    83 	}

    84 

    85 	~CpItemDataHelperPrivate()

    86 	{

    87 	}

    88 

    89 	void addConnection(HbDataFormModelItem *item,

    90 		const char *signal,

    91 		QObject *receiver,

    92 		const char *method)

    93 	{

    94         if (mDataForm) {

    95             mDataForm->addConnection(item,signal,receiver,method);

    96         }

    97         else {

    98             mItemConnections.append(ItemConnection(item,signal,receiver,method));

    99         }

   100 	}

   101 

   102 	void removeConnection(HbDataFormModelItem *item,

   103 		const char *signal,

   104 		QObject *receiver,

   105 		const char *method)

   106 	{

   107         if (mDataForm) {

   108             mDataForm->removeConnection(item,signal,receiver,method);

   109         } 

   110         else {

   111             mItemConnections.removeAll(ItemConnection(item,signal,receiver,method));

   112         }

   113 	}

   114 

   115     void connectToForm(const char *signal,

   116         QObject *receiver,

   117         const char *method)

   118     {

   119         if (mDataForm) {

   120             QObject::connect(mDataForm,signal,receiver,method);

   121         }

   122         else {

   123             mFormConnections.append(FormConnection(signal,receiver,method));

   124         }

   125     }

   126 

   127     void disconnectFromForm(const char *signal,

   128         QObject *receiver,

   129         const char *method)

   130     {

   131         if (mDataForm) {

   132             QObject::disconnect(mDataForm,signal,receiver,method);

   133         }

   134         else {

   135             mFormConnections.removeAll(FormConnection(signal,receiver,method));

   136         }

   137     }

   138 

   139     void addItemPrototype(HbAbstractViewItem *prototype)

   140     {

   141         if (prototype) {

   142             if (mDataForm) {

   143                 QList<HbAbstractViewItem *> protoTypeList = mDataForm->itemPrototypes();

   144                 protoTypeList.append(prototype);

   145                 mDataForm->setItemPrototypes(protoTypeList);	

   146             }

   147             else {

   148                 mItemPrototypes.append(prototype);

   149             }

   150         }

   151     }

   152 

   153 	void bindToForm(HbDataForm *form)

   154 	{

   155         mDataForm = form;

   156 

   157         if (mDataForm) {

   158             foreach(const ItemConnection &connection,mItemConnections) {

   159                 mDataForm->addConnection(connection.mItem,connection.mSignal.toAscii(),

   160                     connection.mReceiver,connection.mMethod.toAscii());

   161             }

   162             mItemConnections.clear();

   163 

   164             foreach(const FormConnection &connection,mFormConnections) {

   165                 QObject::connect(mDataForm,connection.mSignal.toAscii(),

   166                     connection.mReceiver,connection.mMethod.toAscii());

   167             }

   168             mFormConnections.clear();

   169 

   170             if (!mItemPrototypes.isEmpty()) {

   171                 QList<HbAbstractViewItem *> protoTypeList = mDataForm->itemPrototypes();

   172                 protoTypeList.append(mItemPrototypes);

   173                 mDataForm->setItemPrototypes(protoTypeList);	

   174             }

   175             mItemPrototypes.clear();

   176         }

   177 	}

   178 

   179     HbWidget *widgetFromModelIndex(const QModelIndex &index)

   180     {

   181         if (mDataForm) {

   182             HbDataFormViewItem *viewItem = qobject_cast<HbDataFormViewItem *>

   183                                                     (mDataForm->itemByIndex(index));

   184             if (viewItem) {

   185                 return viewItem->dataItemContentWidget();

   186             }

   187         }

   188         return 0;

   189     }

   190     

   191     HbDataFormModelItem *modelItemFromModelIndex(const QModelIndex &index)

   192     {

   193         if (mDataForm) {

   194             HbDataFormModel *dataFormModel = 

   195                     qobject_cast<HbDataFormModel*>(mDataForm->model());

   196             if (dataFormModel) {

   197                 return dataFormModel->itemFromIndex(index);

   198             }

   199         }

   200         return 0;

   201     }

   202 

   203 public:

   204     HbDataForm *mDataForm;

   205     QList<ItemConnection> mItemConnections;

   206     QList<FormConnection> mFormConnections;

   207     QList<HbAbstractViewItem*> mItemPrototypes;

   208 };

   209 

   210 

   211 /*!

   212     \class CpItemDataHelper

   213     \brief The CpItemDataHelper class is a helper class to help controlpanel plugins to comminicate with the associated dataform,

   214     such as connecting slots to inner widgets of setting items, add item prototypes.

   215 	 And add prototypes to dataform.

   216  */

   217 

   218 

   219 /*!

   220     Constructor of CpItemDataHelper.

   221  */

   222 CpItemDataHelper::CpItemDataHelper(HbDataForm *form/* = 0*/)

   223 : d(new CpItemDataHelperPrivate(form))

   224 {

   225 }

   226 

   227 

   228 /*!

   229     Destructor of CpItemDataHelper.

   230  */

   231 CpItemDataHelper::~CpItemDataHelper()

   232 {

   233     delete d;

   234 }

   235 

   236 /*!

   237     Connect a slot to inner widget's signal of setting item.

   238  */

   239 void CpItemDataHelper::addConnection(HbDataFormModelItem *item,

   240 									 const char *signal,

   241 									 QObject *receiver,

   242 									 const char *method)

   243 {

   244 	d->addConnection(item,signal,receiver,method);

   245 }

   246 

   247 /*!

   248     Disconnect a slot to inner widget's signal of setting item.

   249  */

   250 void CpItemDataHelper::removeConnection(HbDataFormModelItem *item,

   251 										const char *signal,

   252 										QObject *receiver,

   253 										const char *method)

   254 {

   255 	d->removeConnection(item,signal,receiver,method);

   256 }

   257 

   258 /*!

   259     Connect slot to data form.

   260 */

   261 void CpItemDataHelper::connectToForm(const char *signal,

   262                                      QObject *receiver,

   263                                      const char *method)

   264 {

   265     d->connectToForm(signal,receiver,method);

   266 }

   267 

   268 /*!

   269     Disconnect slot from data form.

   270 */

   271 void CpItemDataHelper::disconnectFromForm(const char *signal,

   272                                           QObject *receiver,

   273                                           const char *method)

   274 {

   275     d->disconnectFromForm(signal,receiver,method);

   276 }

   277 

   278 

   279 /*!

   280     Add a prototype to data form, to create custom widget for a custom setting item.

   281  */

   282 void CpItemDataHelper::addItemPrototype(HbAbstractViewItem *prototype)

   283 {

   284 	d->addItemPrototype(prototype);

   285 }

   286 

   287 /*!

   288     Bind the connections and prototypes to a data form.

   289  */

   290 void CpItemDataHelper::bindToForm(HbDataForm *form)

   291 {

   292 	d->bindToForm(form);

   293 }

   294 

   295 

   296 /*!

   297     Get the HbWidget instance from data form.

   298 */

   299 HbWidget *CpItemDataHelper::widgetFromModelIndex(const QModelIndex &index)

   300 {

   301     return d->widgetFromModelIndex(index);

   302 }

   303 

   304 /*!

   305     Get the HbDataFormModelItem with a QModelIndex from associated data form's model.

   306 */

   307 HbDataFormModelItem *CpItemDataHelper::modelItemFromModelIndex(const QModelIndex &index)

   308 {

   309     return d->modelItemFromModelIndex(index);

   310 }

   311 

   312 //End of File