1 /*

     2 * ====================================================

     3 *  Name        : viewfutedataform.cpp

     4 *  Part of     : fute/listdemo

     5 *  Description : Settings for listdemo, treedemo, griddemo

     6 *  Version     : %version: 1 %

     7 *

     8 *  Copyright (c) 2009 Nokia.  All rights reserved.

     9 *  This material, including documentation and any related computer

    10 *  programs, is protected by copyright controlled by Nokia.  All

    11 *  rights are reserved.  Copying, including reproducing, storing,

    12 *  adapting or translating, any or all of this material requires the

    13 *  prior written consent of Nokia.  This material also contains

    14 *  confidential information which may not be disclosed to others

    15 *  without the prior written consent of Nokia.

    16 * ====================================================

    17 */

    18 

    19 #include "viewfutedataform.h"

    20 #include <hbdataformmodel.h>

    21 #include <hbabstractviewitem.h>

    22 #include <hblistviewitem.h>

    23 #include <hblistview.h>

    24 #include <hbtreeview.h>

    25 #include <hbgridview.h>

    26 #include <hbscrollbar.h>

    27 #include <hbframebackground.h>

    28 #include <hbaction.h>

    29 #include <hbmenu.h>

    30 #include <hblineedit.h>

    31 #include <hbinputeditorinterface.h>

    32 #include <hblistwidgetitem.h>

    33 #include <hbabstractitemview.h>

    34 #include <hbindexfeedback.h>

    35 

    36 #include <QStandardItem>

    37 #include <QGraphicsScene>

    38 #include <QAbstractItemView>

    39 

    40 Q_DECLARE_METATYPE(QList<int>)

    41 

    42 // Settings

    43 const QStringList TextStyles = (QStringList() << "Primary" << "Secondary");

    44 const QStringList CustomWidgets = (QStringList() << "Empty" << "Zoom slider" << "Volume Slider" << "Progress bar"  << "Button" << "Text Editor" );

    45 const QStringList OnOff = (QStringList() << "On" << "Off");

    46 const QStringList LaunchInPopups = (QStringList() << "Launch into popup" << "Launch into view") ;

    47 const QStringList SelectionModes = (QStringList() << "Single selection" << "Multiple selection" << "No selection");

    48 const QStringList ScrollModes = (QStringList() << "Pan" << "Pan with follow on");

    49 const QStringList GraphicsSizes = (QStringList() << "Small icon" << "Medium icon" << "Large icon" << "Thumbnail" << "Wide thumbnail");

    50 const QStringList LandscapeModes = (QStringList() << "Normal" << "Stretched");

    51 const QStringList OrientationTypes  = (QStringList() << "Portrait" << "Landscape");

    52 const QStringList ScrollHints  = (QStringList() << "Just visible" << "At top" << "At bottom" << "At center" );

    53 const QStringList IndexFeedbackPolicies = (QStringList() << "None" << "One Char" << "Three Char" << "String" << "detatch" );

    54 const QStringList IconLoadPolicies = (QStringList() << "Synchronous" << "Asynchronous when scrolling" << "Asynchronous" );

    55 

    56 // Add item

    57 const QStringList LeftColumnWidgets = (QStringList() << "Empty" << "Icon");

    58 const QStringList RightColumnWidgets = (QStringList() << "Empty" << "Icon");

    59 const QStringList ItemBackgrounds = (QStringList() << "None" << "Red" << "Green" << "Blue" << "Bitmap" << "Frame");

    60 const QStringList ItemTypes = (QStringList() << "Normal" << "Separator");

    61 const QStringList AnimationList = (QStringList() << "Appear" << "Disappear" << "TouchDown");

    62 

    63 const QStringList KConvenienceIcons = (QStringList() 

    64     << ":/demo/list1"

    65 );

    66 

    67 ViewFuteDataForm::ViewFuteDataForm( HbAbstractItemView &view,

    68                                    QGraphicsItem *parent):

    69   HbDataForm(parent),

    70   activity(None),

    71   view(&view),

    72   item(0),

    73   mIndexFeedback(0)

    74 {

    75     settingsFormModel = new HbDataFormModel();

    76     initialise();

    77 }

    78 

    79 ViewFuteDataForm::~ViewFuteDataForm()

    80 {

    81     delete settingsFormModel;

    82 }

    83 

    84 void ViewFuteDataForm::populateSettings()

    85 {

    86     activity = Settings;

    87     settingsFormModel->clear();

    88 

    89     counter += populateCustomSettingsItem(-1);

    90 

    91     //populateLaunchInPopup();

    92     //counter += populateCustomSettingsItem(LaunchInPopup);

    93 

    94     populateSelectionMode();

    95     counter += populateCustomSettingsItem(SelectionMode);

    96 

    97     populateScrollHint();

    98     counter += populateCustomSettingsItem(ScrollHint);

    99 

   100     populateRecycling();

   101     counter += populateCustomSettingsItem(Recycling);

   102 

   103     populateArrangeMode();

   104     counter += populateCustomSettingsItem(ArrangeMode);

   105 

   106     populateUniformItem();

   107     counter += populateCustomSettingsItem(UniformItem);

   108 

   109     populateFrame();

   110     counter += populateCustomSettingsItem(Frame);

   111 

   112     populateRichText();

   113     counter += populateCustomSettingsItem(RichText);

   114 

   115     populateScrollingStyle();

   116     counter += populateCustomSettingsItem(ScrollingStyle);

   117 

   118     populateInteractiveScrollBar();

   119     counter += populateCustomSettingsItem(InteractiveScrollBar);

   120 

   121     populateClampingStyle();

   122     counter += populateCustomSettingsItem(ClampingStyle);

   123 

   124     populateFrictionEnabled();

   125     counter += populateCustomSettingsItem(FrictionEnabled);

   126 

   127     populateGraphicsSize();

   128     counter += populateCustomSettingsItem(GraphicsSize);

   129 

   130     populateStretchingStyle();

   131     counter += populateCustomSettingsItem(StretchingStyle);

   132 

   133     populateMaximumRowCount();

   134     counter += populateCustomSettingsItem(MaximumRowCount);

   135 

   136     populateMinimumRowCount();

   137     counter += populateCustomSettingsItem(MinimumRowCount);

   138 

   139     //populateMirroring();

   140     //counter += populateCustomSettingsItem(Mirroring);

   141 

   142     populateIndexFeedbackPolicy();

   143     counter += populateCustomSettingsItem(IndexFeedbackPolicy);

   144 /*

   145     populateEnabledAnimations();

   146     counter += populateCustomSettingsItem(Animations);

   147 */

   148     populatePixmapCacheEnabled();

   149     counter += populateCustomSettingsItem(PixmapCache);

   150 

   151     populateIconLoadPolicy();

   152     counter += populateCustomSettingsItem(IconLoadPolicy);

   153 

   154     setModel(settingsFormModel);

   155 }

   156 

   157 void ViewFuteDataForm::setInputData(    Activity    action,

   158                                         int         item, 

   159                                         QVariant    data)

   160 {

   161     if (    item < 0

   162         ||  action == None

   163         ||  (   (   action == Settings

   164                 &&  item >= SettingsIndexLast) 

   165             ||  (   action == AddItem

   166             &&  item >= AddItemIndexLast))) {

   167         return;

   168     }

   169 

   170     if (action == Settings) {

   171         settingsData[item] = data;

   172         data.isValid();

   173     }

   174     else if (action == AddItem) {

   175         addItemData[item] = data;

   176     }

   177 }

   178 

   179 

   180 int ViewFuteDataForm::populateCustomSettingsItem(int previousItem)

   181 {

   182     Q_UNUSED(previousItem);

   183     return 0;

   184 }

   185 

   186 void ViewFuteDataForm::initialise()

   187 {

   188     settingsFormModel->clear();

   189     counter=0;

   190     for (int i=0; i< SettingsIndexLast; i++) {

   191         settingsIndexes[i] = -1;

   192     }

   193     for (int i=0; i< AddItemIndexLast; i++) {

   194         addItemIndexes[i] = -1;

   195     }

   196     for (int i=0; i< SettingsIndexLast; i++) {

   197         settingsData[i] = QVariant();

   198     }

   199     for (int i=0; i< AddItemIndexLast; i++) {

   200         addItemData[i] = QVariant();

   201     }

   202 }

   203 

   204 int ViewFuteDataForm::nextIndex() const

   205 {

   206     return counter;

   207 }

   208 

   209 ViewFuteDataForm::Activity ViewFuteDataForm::action() const

   210 {

   211     return activity;

   212 }

   213 

   214 

   215 HbDataFormModel *ViewFuteDataForm::dataModel() const

   216 {

   217     return settingsFormModel;

   218 }

   219 

   220 void ViewFuteDataForm::populateGraphicsSize()

   221 {

   222     HbListViewItem *prototype = qobject_cast<HbListViewItem *>(view->itemPrototypes().first());

   223     if ( prototype ) {

   224         settingsIndexes[GraphicsSize] = counter++;

   225         

   226         HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   227             QString("Graphics size:"));

   228 

   229         item->setContentWidgetData("items", GraphicsSizes);

   230 

   231         HbListViewItem::GraphicsSize graphicsSize = prototype->graphicsSize();

   232         if (graphicsSize == HbListViewItem::SmallIcon) {

   233             item->setContentWidgetData("selected", 0);

   234         } else if (graphicsSize == HbListViewItem::MediumIcon) {

   235             item->setContentWidgetData("selected", 1);

   236         } else if (graphicsSize == HbListViewItem::LargeIcon) {

   237             item->setContentWidgetData("selected", 2);

   238         } else if (graphicsSize == HbListViewItem::Thumbnail) {

   239             item->setContentWidgetData("selected", 3);

   240         } else {

   241             item->setContentWidgetData("selected", 4);

   242         }

   243     }

   244 }

   245 

   246 void ViewFuteDataForm::populateStretchingStyle()

   247 {

   248     HbListViewItem *prototype = qobject_cast<HbListViewItem *>(view->itemPrototypes().first());

   249     if ( prototype ) {

   250         settingsIndexes[StretchingStyle] = counter++;       

   251 

   252         HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, 

   253             QString("Landscape mode:"));

   254 

   255         item->setContentWidgetData("items", LandscapeModes);

   256         if (prototype->stretchingStyle() == HbListViewItem::StretchLandscape) {

   257             item->setContentWidgetData("selected", 1);

   258         } else {

   259             item->setContentWidgetData("selected", 0);

   260         }

   261     }

   262 }

   263 

   264 void ViewFuteDataForm::populateMaximumRowCount()

   265 {

   266     HbListViewItem *prototype = qobject_cast<HbListViewItem *>(view->itemPrototypes().first());

   267     if ( prototype ) {

   268         settingsIndexes[MaximumRowCount] = counter++;

   269 

   270         HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(HbDataFormModelItem::SliderItem, 

   271             QString("Max secondary text rows:"));  

   272 

   273         int maximum = 0;

   274         int minimum = 0;

   275         prototype->getSecondaryTextRowCount(minimum, maximum);

   276 

   277         item->setContentWidgetData("value", maximum);

   278         item->setContentWidgetData("maximum", 10);

   279         item->setContentWidgetData("minimum", 1);

   280         item->setContentWidgetData("tickPosition", Hb::SliderTicksBelow);

   281         item->setContentWidgetData("majorTickInterval",1);

   282 

   283         // does not work

   284         /*QStringList values;

   285         values << "1" << "2" << "3" << "4" << "5" << "6" << "7" << "8" << "9" << "10"; 

   286         item->setContentWidgetData("majorTickLabels",values);*/

   287     }

   288 }

   289 

   290 void ViewFuteDataForm::populateMinimumRowCount()

   291 {

   292     HbListViewItem *prototype = qobject_cast<HbListViewItem *>(view->itemPrototypes().first());

   293     if ( prototype ) {

   294         settingsIndexes[MinimumRowCount] = counter++;

   295 

   296         HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(HbDataFormModelItem::SliderItem, 

   297             QString("Min secondary text rows:"));  

   298 

   299         int maximum = 0;

   300         int minimum = 0;

   301         prototype->getSecondaryTextRowCount(minimum, maximum);

   302 

   303         item->setContentWidgetData("value", minimum);

   304         item->setContentWidgetData("maximum", 10);

   305         item->setContentWidgetData("minimum", 1);

   306         item->setContentWidgetData("tickPosition", Hb::SliderTicksBelow);

   307         item->setContentWidgetData("majorTickInterval",1);

   308     }

   309 }

   310 

   311 void ViewFuteDataForm::populateFrame()

   312 {

   313     settingsIndexes[Frame] = counter++;

   314     HbAbstractViewItem *prototype = qobject_cast<HbAbstractViewItem *>(view->itemPrototypes().first());

   315     const HbFrameBackground &frameBackground = prototype->defaultFrame();

   316 

   317     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   318         HbDataFormModelItem::ToggleValueItem, QString("Default frame:"));

   319     if (frameBackground.isNull()) {

   320         item->setContentWidgetData("text", "On");

   321         item->setContentWidgetData("additionalText", "Off");

   322     } else {

   323         item->setContentWidgetData("text", "Off");

   324         item->setContentWidgetData("additionalText", "On");

   325     }

   326 }

   327 

   328 void ViewFuteDataForm::populateRecycling()

   329 {

   330     settingsIndexes[Recycling] = counter++;

   331     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   332         HbDataFormModelItem::ToggleValueItem, QString("Item recycling:"));

   333     if (view->itemRecycling()) {

   334         item->setContentWidgetData("text", "On");

   335         item->setContentWidgetData("additionalText", "Off");

   336     } else {

   337         item->setContentWidgetData("text", "Off");

   338         item->setContentWidgetData("additionalText", "On");

   339     }

   340 }

   341 

   342 void ViewFuteDataForm::populateUniformItem()

   343 {

   344     HbListView *listView = qobject_cast<HbListView *>(view);

   345     if (listView) {

   346         settingsIndexes[UniformItem] = counter++;

   347         HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   348             HbDataFormModelItem::ToggleValueItem, QString("Uniform Items:"));

   349         if (view->uniformItemSizes()) {

   350             item->setContentWidgetData("text", "On");

   351             item->setContentWidgetData("additionalText", "Off");

   352         } else {

   353             item->setContentWidgetData("text", "Off");

   354             item->setContentWidgetData("additionalText", "On");

   355         }

   356     }

   357 }

   358 

   359 void ViewFuteDataForm::populateRichText()

   360 {

   361     HbListViewItem *prototype = qobject_cast<HbListViewItem *>(view->itemPrototypes().first());

   362     if (prototype) {

   363         settingsIndexes[RichText] = counter++;

   364         HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   365             HbDataFormModelItem::ToggleValueItem, QString("Rich text support:"));

   366         if (prototype->textFormat() == Qt::RichText) {

   367             item->setContentWidgetData("text", "On");

   368             item->setContentWidgetData("additionalText", "Off");

   369         } else {

   370             item->setContentWidgetData("text", "Off");

   371             item->setContentWidgetData("additionalText", "On");

   372         }

   373     }

   374 }

   375 

   376 void ViewFuteDataForm::populateSelectionMode()

   377 {

   378     settingsIndexes[SelectionMode] = counter++;

   379     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   380         HbDataFormModelItem::RadioButtonListItem, QString("Selection mode:"));

   381     item->setContentWidgetData("items", SelectionModes);

   382     if (view->selectionMode() == HbAbstractItemView::SingleSelection) {

   383         item->setContentWidgetData("selected", 0);

   384     } else if (view->selectionMode() == HbAbstractItemView::MultiSelection) {

   385         item->setContentWidgetData("selected", 1);

   386     } else {

   387         item->setContentWidgetData("selected", 2);

   388     }

   389 }

   390 

   391 

   392 void ViewFuteDataForm::populateLaunchInPopup()

   393 {

   394     settingsIndexes[LaunchInPopup] = counter++;

   395     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   396         HbDataFormModelItem::RadioButtonListItem, QString("Launch target of next model:"));

   397     item->setContentWidgetData("items", LaunchInPopups);

   398     if (    settingsData[LaunchInPopup].isValid() 

   399         &&  settingsData[LaunchInPopup].canConvert(QVariant::Bool)

   400         &&  settingsData[LaunchInPopup].toBool()) {

   401         item->setContentWidgetData("selected", 0);

   402     } else {

   403         item->setContentWidgetData("selected", 1);

   404     }

   405 }

   406 

   407 void ViewFuteDataForm::populateArrangeMode()

   408 {

   409     HbListView *listView = qobject_cast<HbListView *>(view);

   410     if (listView) {

   411         settingsIndexes[ArrangeMode] = counter++;

   412         HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   413             HbDataFormModelItem::ToggleValueItem, QString("Arrange mode:"));

   414         if (listView->arrangeMode()) {

   415             item->setContentWidgetData("text", "On");

   416             item->setContentWidgetData("additionalText", "Off");

   417         } else {

   418             item->setContentWidgetData("text", "Off");

   419             item->setContentWidgetData("additionalText", "On");

   420         }

   421     }

   422 }

   423 

   424 void ViewFuteDataForm::populateScrollingStyle()

   425 {

   426     settingsIndexes[ScrollingStyle] = counter++;

   427     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   428         HbDataFormModelItem::RadioButtonListItem, QString("Scroll mode:"));

   429     item->setContentWidgetData("items", ScrollModes);

   430     if (view->scrollingStyle() == HbScrollArea::Pan) {

   431         item->setContentWidgetData("selected", 0);

   432     } else {

   433         item->setContentWidgetData("selected", 1);

   434     }

   435 }

   436 

   437 void ViewFuteDataForm::populateClampingStyle()

   438 {

   439     settingsIndexes[ClampingStyle] = counter++;

   440     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   441          HbDataFormModelItem::ToggleValueItem, QString("List bounce clamping:"));

   442     if (view->clampingStyle() == HbScrollArea::BounceBackClamping) {

   443         item->setContentWidgetData("text", "On");

   444         item->setContentWidgetData("additionalText", "Off");

   445     } else {

   446         item->setContentWidgetData("text", "Off");

   447         item->setContentWidgetData("additionalText", "On");

   448     }

   449 }

   450 

   451 void ViewFuteDataForm::populateInteractiveScrollBar()

   452 {

   453     settingsIndexes[InteractiveScrollBar] = counter++;

   454     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   455          HbDataFormModelItem::ToggleValueItem, QString("Interactive scrollbar:"));

   456     if (view->verticalScrollBar()->isInteractive() == true

   457         || view->horizontalScrollBar()->isInteractive() == true) {

   458         item->setContentWidgetData("text", "On");

   459         item->setContentWidgetData("additionalText", "Off");

   460     } else {

   461         item->setContentWidgetData("text", "Off");

   462         item->setContentWidgetData("additionalText", "On");

   463     }

   464 }

   465 

   466 void ViewFuteDataForm::populateFrictionEnabled()

   467 {

   468     settingsIndexes[FrictionEnabled] = counter++;

   469     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   470         HbDataFormModelItem::ToggleValueItem, QString("List scroll inertia:"));

   471     if (view->frictionEnabled()) {

   472         item->setContentWidgetData("text", "On");

   473         item->setContentWidgetData("additionalText", "Off");

   474     } else {

   475         item->setContentWidgetData("text", "Off");

   476         item->setContentWidgetData("additionalText", "On");

   477     }

   478 }

   479 

   480 void ViewFuteDataForm::populateOrientation()

   481 {

   482     settingsIndexes[Orientation] = counter++;

   483     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   484         HbDataFormModelItem::RadioButtonListItem, QString("Orientation:"));

   485     item->setContentWidgetData("items", OrientationTypes);

   486     if (    settingsData[Orientation].isValid() 

   487         &&  settingsData[Orientation].canConvert(QVariant::Int) 

   488         &&  (    settingsData[Orientation].toInt() == 0

   489             ||  settingsData[Orientation].toInt() == 1)) {

   490             item->setContentWidgetData("selected", settingsData[Orientation].toInt());

   491     } 

   492     else {

   493         item->setContentWidgetData("selected", 0);

   494     }

   495 }

   496 

   497 void ViewFuteDataForm::populateMirroring()

   498 {

   499     settingsIndexes[Mirroring] = counter++;

   500     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   501         HbDataFormModelItem::ToggleValueItem, QString("Layout mirrored:"));

   502     if (    settingsData[Mirroring].isValid() 

   503         &&  settingsData[Mirroring].canConvert(QVariant::Int)) {

   504         if (settingsData[Mirroring].toInt() == Qt::LeftToRight) {

   505             item->setContentWidgetData("text", "Off");

   506             item->setContentWidgetData("additionalText", "On");

   507         }

   508         else if (settingsData[Mirroring].toInt() == Qt::RightToLeft) {

   509             item->setContentWidgetData("text", "On");

   510             item->setContentWidgetData("additionalText", "Off");

   511         }

   512     } else {

   513         item->setContentWidgetData("text", "Off");

   514         item->setContentWidgetData("additionalText", "On");

   515     }

   516 }

   517 

   518 void ViewFuteDataForm::populateScrollHint()

   519 {

   520     settingsIndexes[ScrollHint] = counter++;

   521     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   522         HbDataFormModelItem::RadioButtonListItem, QString("Scroll-to-target stop position:"));

   523     item->setContentWidgetData("items", ScrollHints);

   524     int initialValue = 0;

   525     if (    settingsData[ScrollHint].isValid() 

   526         &&  settingsData[ScrollHint].canConvert(QVariant::Int)

   527         &&  settingsData[ScrollHint].toInt() >= 0

   528         &&  settingsData[ScrollHint].toInt() <= QAbstractItemView::PositionAtCenter) {

   529         initialValue = settingsData[ScrollHint].toInt();

   530     }

   531 

   532     item->setContentWidgetData("selected", initialValue);

   533 }

   534 

   535 void ViewFuteDataForm::populateIndexFeedbackPolicy()

   536 {

   537     if (mIndexFeedback) {

   538         settingsIndexes[IndexFeedbackPolicy] = counter++;

   539         HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   540             HbDataFormModelItem::RadioButtonListItem, QString("Index Feedback Policy:"));

   541         item->setContentWidgetData("items", IndexFeedbackPolicies);

   542         int initialValue = 0;

   543 

   544         if (! mIndexFeedback->itemView() ) {

   545             initialValue = 4;

   546         } else {

   547             initialValue = (int) mIndexFeedback->indexFeedbackPolicy();

   548         }

   549 

   550         item->setContentWidgetData("selected", initialValue);

   551     }

   552 }

   553 

   554 void ViewFuteDataForm::resolveSettingsResults()

   555 {

   556     if (!view) {

   557         return;

   558     }

   559 

   560     HbListView *listView = qobject_cast<HbListView *>(view);

   561 

   562     HbAbstractViewItem *prototype = view->itemPrototypes().first();

   563     HbListViewItem *prototypeListView = qobject_cast<HbListViewItem *>(prototype);

   564     if (prototypeListView) {

   565         prototypeListView->setGraphicsSize(getGraphicsSize());

   566         prototypeListView->setStretchingStyle(getStretchingStyle());

   567         int minBefore = 1;

   568         int maxBefore = 1;

   569         prototypeListView->getSecondaryTextRowCount(minBefore, maxBefore);

   570         if (    minBefore != 1

   571             ||  maxBefore != 1

   572             ||  getMinimumRowCount() != 1

   573             ||  getMaximumRowCount() != 1 ) {

   574             prototypeListView->setSecondaryTextRowCount(getMinimumRowCount(), getMaximumRowCount());

   575         }

   576     }

   577 

   578     HbFrameBackground frame;

   579     if (getFrame()){

   580         frame.setFrameGraphicsName(QString());

   581     } else {

   582         frame.setFrameGraphicsName(QString(""));

   583     }

   584     prototype->setDefaultFrame(frame);

   585 

   586     view->setItemRecycling(getRecycling());

   587     view->setUniformItemSizes(getUniformItem());

   588 

   589     if (prototypeListView) {

   590         prototypeListView->setTextFormat(getRichText());

   591     }

   592     view->setSelectionMode(getSelectionMode());

   593     view->setScrollingStyle(getScrollingStyle());

   594     view->setClampingStyle(getClampingStyle());

   595     view->setFrictionEnabled(getFrictionEnabled());

   596 

   597     bool interactiveScrollBar = getInteractiveScrollBar();

   598     if (view->scrollDirections() & Qt::Horizontal)

   599     {

   600         view->horizontalScrollBar()->setInteractive(interactiveScrollBar);

   601     }

   602     if (view->scrollDirections() & Qt::Vertical)

   603     {

   604         view->verticalScrollBar()->setInteractive(interactiveScrollBar);

   605     }

   606 

   607     // must be after interactive scrollbar setting

   608     if (listView) {

   609         listView->setArrangeMode(getArrangeMode());

   610     }

   611 

   612     if (mIndexFeedback) {

   613         int indexFeedbackMode = getIndexFeedbackPolicy();

   614         if (indexFeedbackMode == 4) {

   615             mIndexFeedback->setItemView(0);

   616         } else {

   617             mIndexFeedback->setItemView(view);

   618             mIndexFeedback->setIndexFeedbackPolicy((HbIndexFeedback::IndexFeedbackPolicy) indexFeedbackMode);

   619         }

   620     }

   621 

   622     view->setItemPixmapCacheEnabled(getPixmapCacheEnaled());

   623     view->setIconLoadPolicy(getIconLoadPolicy());

   624 /*

   625     if (listView) {

   626         listView->setEnabledAnimations(getEnabledAnimations());

   627     }

   628 */

   629 }

   630 

   631 HbListViewItem::GraphicsSize ViewFuteDataForm::getGraphicsSize()

   632 {

   633     HbListViewItem::GraphicsSize graphicsSize(HbListViewItem::SmallIcon);

   634 

   635     if (settingsIndexes[GraphicsSize] != -1) {

   636         if (static_cast<HbDataFormViewItem*>(itemByIndex(

   637                 settingsFormModel->index(settingsIndexes[GraphicsSize],0)))->dataItemContentWidget()->property("selected").toInt() == 1) {

   638             graphicsSize = HbListViewItem::MediumIcon;

   639         } else if (static_cast<HbDataFormViewItem*>(itemByIndex(

   640                 settingsFormModel->index(settingsIndexes[GraphicsSize],0)))->dataItemContentWidget()->property("selected").toInt() == 2) {

   641             graphicsSize = HbListViewItem::LargeIcon;

   642         } else if (static_cast<HbDataFormViewItem*>(itemByIndex(

   643                 settingsFormModel->index(settingsIndexes[GraphicsSize],0)))->dataItemContentWidget()->property("selected").toInt() == 3) {

   644             graphicsSize = HbListViewItem::Thumbnail;

   645         } else if (static_cast<HbDataFormViewItem*>(itemByIndex(

   646                 settingsFormModel->index(settingsIndexes[GraphicsSize],0)))->dataItemContentWidget()->property("selected").toInt() == 4) {

   647             graphicsSize = HbListViewItem::WideThumbnail;

   648         }

   649     } 

   650 

   651     return graphicsSize;

   652 }

   653 

   654 HbListViewItem::StretchingStyle ViewFuteDataForm::getStretchingStyle()

   655 {

   656     HbListViewItem::StretchingStyle stretchingStyle(HbListViewItem::NoStretching);

   657 

   658     if (settingsIndexes[StretchingStyle] != -1) {

   659         if (static_cast<HbDataFormViewItem*>(itemByIndex(

   660                 settingsFormModel->index(settingsIndexes[StretchingStyle],0)))->dataItemContentWidget()->property("selected").toInt() == 1) {

   661             stretchingStyle = HbListViewItem::StretchLandscape;

   662         }

   663     } 

   664      

   665     return stretchingStyle;

   666 }

   667 

   668 int ViewFuteDataForm::getMaximumRowCount()

   669 {

   670     int maximumRowCount = 0;

   671     if (settingsIndexes[MaximumRowCount] != -1) {

   672         maximumRowCount = static_cast<HbDataFormViewItem*>(itemByIndex(

   673                 settingsFormModel->index(settingsIndexes[MaximumRowCount],0)))->dataItemContentWidget()->property("value").toInt();

   674     } 

   675 

   676     return maximumRowCount;

   677 }

   678 

   679 int ViewFuteDataForm::getMinimumRowCount()

   680 {

   681     int minimumRowCount = 0;

   682     if (settingsIndexes[MinimumRowCount] != -1) {

   683         minimumRowCount = static_cast<HbDataFormViewItem*>(itemByIndex(

   684                 settingsFormModel->index(settingsIndexes[MinimumRowCount],0)))->dataItemContentWidget()->property("value").toInt();

   685     } 

   686 

   687     return minimumRowCount;

   688 }

   689 

   690 bool ViewFuteDataForm::getFrame()

   691 {

   692     if (static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[Frame],0)))->

   693         dataItemContentWidget()->property("text").toString() == "On") {

   694         return true;

   695     }

   696     return false;

   697 }

   698 

   699 bool ViewFuteDataForm::getRecycling()

   700 {

   701     if (static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[Recycling],0)))->

   702             dataItemContentWidget()->property("text").toString() == "On") {

   703         return true;

   704     }

   705     return false;

   706 }

   707 

   708 bool ViewFuteDataForm::getUniformItem()

   709 {

   710     if (settingsIndexes[UniformItem] != -1) {

   711         if (static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[UniformItem],0)))->

   712                 dataItemContentWidget()->property("text").toString() == "On") {

   713             return true;

   714         }

   715     }

   716     return false;

   717 }

   718 

   719 Qt::TextFormat ViewFuteDataForm::getRichText()

   720 {

   721     if (settingsIndexes[RichText] != -1) {

   722         if (static_cast<HbDataFormViewItem*>(itemByIndex(

   723             settingsFormModel->index(settingsIndexes[RichText],0)))->

   724                 dataItemContentWidget()->property("text").toString() == "Off") {

   725             return Qt::PlainText;

   726         } 

   727         return Qt::RichText;

   728     }

   729     return Qt::PlainText;

   730 }

   731 

   732 HbAbstractItemView::SelectionMode ViewFuteDataForm::getSelectionMode()

   733 {

   734     int value = static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[SelectionMode],0)))->

   735         dataItemContentWidget()->property("selected").toInt();

   736     if (value == 0) {

   737         return HbListView::SingleSelection;

   738     } else if (value == 1) {

   739         return HbListView::MultiSelection;

   740     } else {

   741         return HbListView::NoSelection;

   742     }

   743 }

   744 

   745 bool ViewFuteDataForm::getLaunchInPopup()

   746 {

   747     int value = static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[LaunchInPopup],0)))->

   748         dataItemContentWidget()->property("selected").toInt();

   749     if (value == 0) {

   750         return true;

   751     } else {

   752         return false;

   753     }

   754 }

   755 

   756 

   757 bool ViewFuteDataForm::getArrangeMode()

   758 {

   759     if (settingsIndexes[ArrangeMode] != -1) {

   760         if (static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[ArrangeMode],0)))->

   761                 dataItemContentWidget()->property("text").toString() == "On") {

   762             return true;

   763         } 

   764     }

   765     return false;

   766 }

   767 

   768 HbScrollArea::ScrollingStyle ViewFuteDataForm::getScrollingStyle()

   769 {

   770     int value = static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[ScrollingStyle],0)))->

   771         dataItemContentWidget()->property("selected").toInt();

   772     if (value == 0) {

   773         return HbScrollArea::Pan;

   774     } else {

   775         return HbScrollArea::PanWithFollowOn;

   776     }

   777 }

   778 

   779 HbScrollArea::ClampingStyle ViewFuteDataForm::getClampingStyle()

   780 {

   781     if (static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[ClampingStyle],0)))->

   782             dataItemContentWidget()->property("text").toString() == "On") {

   783         return HbScrollArea::BounceBackClamping;

   784     } 

   785     return HbScrollArea::StrictClamping;

   786 }

   787 

   788 bool ViewFuteDataForm::getFrictionEnabled()

   789 {

   790     if (static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[FrictionEnabled],0)))->

   791             dataItemContentWidget()->property("text").toString() == "On") {

   792         return true;

   793     } 

   794     return false;

   795 }

   796 

   797 Qt::LayoutDirection ViewFuteDataForm::getMirroring()

   798 {

   799     int value = static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[Mirroring],0)))->

   800         dataItemContentWidget()->property("selected").toInt();

   801     if (value == 1) {

   802         return Qt::RightToLeft;

   803     } 

   804     return Qt::LeftToRight;

   805 }

   806 

   807 Qt::Orientation ViewFuteDataForm::getOrientation()

   808 {

   809     int value = static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[Orientation],0)))->

   810         dataItemContentWidget()->property("selected").toInt();

   811     if (value == 0) {

   812         return Qt::Vertical;

   813     } else {

   814         return Qt::Horizontal;

   815     } 

   816 }

   817 

   818 HbAbstractItemView::ScrollHint ViewFuteDataForm::getScrollHint()

   819 {

   820     int value = static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[ScrollHint],0)))->

   821         dataItemContentWidget()->property("selected").toInt();

   822     return (HbAbstractItemView::ScrollHint)value;

   823 }

   824 

   825 int ViewFuteDataForm::getIndexFeedbackPolicy()

   826 {

   827     int value = 0;

   828     if (mIndexFeedback) {

   829         value = static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[IndexFeedbackPolicy],0)))->

   830             dataItemContentWidget()->property("selected").toInt();

   831         return value;

   832     }

   833     return value;

   834 }

   835 

   836 bool ViewFuteDataForm::getInteractiveScrollBar()

   837 {

   838     if (static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[InteractiveScrollBar],0)))->

   839             dataItemContentWidget()->property("text").toString() == "On") {

   840         return true;

   841     }

   842     return false;

   843 }

   844 

   845 HbAbstractItemView::ItemAnimations ViewFuteDataForm::getEnabledAnimations()

   846 {

   847     QVariant selectedAsVariant = static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[Animations],0)))->

   848         dataItemContentWidget()->property("selectedItems");

   849 

   850     QList<QVariant> selected = selectedAsVariant.value< QList<QVariant> >();

   851 

   852     HbAbstractItemView::ItemAnimations mask = HbAbstractItemView::None;

   853 

   854     HbListView *listView = qobject_cast<HbListView *>(view);

   855     if (listView) {

   856         if (selected.contains(0)) {

   857             mask |= HbAbstractItemView::Appear;

   858         }

   859         if (selected.contains(1)) {

   860             mask |= HbAbstractItemView::Disappear;

   861         }

   862         if (selected.contains(2)) {

   863             mask |= HbAbstractItemView::TouchDown;

   864         }

   865     } else {

   866         if (selected.contains(0)) {

   867             mask |= HbAbstractItemView::TouchDown;

   868         }

   869     }

   870     return mask;

   871 }

   872 

   873 bool ViewFuteDataForm::getPixmapCacheEnaled()

   874 {

   875     if (static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[PixmapCache],0)))->

   876             dataItemContentWidget()->property("text").toString() == "On") {

   877         return true;

   878     }

   879     return false;

   880 }

   881 

   882 HbAbstractItemView::IconLoadPolicy ViewFuteDataForm::getIconLoadPolicy()

   883 {

   884     int selection = static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(settingsIndexes[IconLoadPolicy],0)))->

   885             dataItemContentWidget()->property("selected").toInt();

   886     if ( selection == 0) {

   887         return HbAbstractItemView::LoadSynchronously;

   888     } else if (selection == 2) {

   889         return HbAbstractItemView::LoadAsynchronouslyAlways;

   890     } else {

   891         return HbAbstractItemView::LoadAsynchronouslyWhenScrolling;

   892     }

   893 }

   894 

   895 void ViewFuteDataForm::populateAddItem()

   896 {

   897     activity = AddItem;

   898     settingsFormModel->clear();

   899 

   900     populatePrimaryText();

   901     populateSecondaryText();

   902     populateThirdText();

   903     populateLeftColumn();

   904     populateRightColumn();

   905     populateType();

   906     populateBackground();

   907     populateAddItemCount();

   908 

   909     setModel(settingsFormModel);

   910 

   911     HbListView *listView = qobject_cast<HbListView *>(view);

   912     HbTreeView *treeView = qobject_cast<HbTreeView *>(view);

   913     if (listView || treeView) {

   914         HbAction *action = new HbAction(tr("Format"));

   915         connect(action, SIGNAL(triggered()), this, SLOT(formatTriggered()));

   916 

   917         if (addItemIndexes[PrimaryText] != -1) {

   918             if (qobject_cast<HbLineEdit *>(static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(addItemIndexes[PrimaryText],0)))->dataItemContentWidget())) {

   919                 HbLineEdit *editor = qobject_cast<HbLineEdit *>(static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(addItemIndexes[PrimaryText],0)))->dataItemContentWidget());

   920                 HbEditorInterface editInterface(editor);

   921                 editInterface.addAction(action);

   922             }

   923         }

   924 

   925         if (addItemIndexes[SecondaryText] != -1) {

   926             if (qobject_cast<HbLineEdit *>(static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(addItemIndexes[SecondaryText],0)))->dataItemContentWidget())) {

   927                 HbLineEdit *editor = qobject_cast<HbLineEdit *>(static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(addItemIndexes[SecondaryText],0)))->dataItemContentWidget());

   928                 HbEditorInterface editInterface2(editor);

   929                 editInterface2.addAction(action);

   930             }

   931 

   932         if (addItemIndexes[ThirdText] != -1) {

   933             if (qobject_cast<HbLineEdit *>(static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(addItemIndexes[ThirdText],0)))->dataItemContentWidget())) {

   934                 HbLineEdit *editor = qobject_cast<HbLineEdit *>(static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(addItemIndexes[ThirdText],0)))->dataItemContentWidget());

   935                 HbEditorInterface editInterface2(editor);

   936                 editInterface2.addAction(action);

   937             }

   938         }

   939         }

   940     }

   941 }

   942 

   943 void ViewFuteDataForm::populatePrimaryText()

   944 {

   945     addItemIndexes[PrimaryText] = counter++;

   946     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   947             HbDataFormModelItem::TextItem, QString("Primary text:"));

   948     if (addItemData[PrimaryText].isValid() && addItemData[PrimaryText].canConvert(QVariant::String)) {

   949         item->setContentWidgetData("text", addItemData[PrimaryText].toString());

   950     }

   951 }

   952 

   953 void ViewFuteDataForm::populateSecondaryText()

   954 {

   955     addItemIndexes[SecondaryText] = counter++;

   956     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   957         HbDataFormModelItem::TextItem, QString("Secondary text:"));

   958     if (addItemData[SecondaryText].isValid() && addItemData[SecondaryText].canConvert(QVariant::String)) {

   959         item->setContentWidgetData("text", addItemData[SecondaryText].toString());

   960     }

   961 }

   962 

   963 void ViewFuteDataForm::populateThirdText()

   964 {

   965     addItemIndexes[ThirdText] = counter++;

   966     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   967         HbDataFormModelItem::TextItem, QString("Third text:"));

   968     if (addItemData[ThirdText].isValid() && addItemData[ThirdText].canConvert(QVariant::String)) {

   969         item->setContentWidgetData("text", addItemData[ThirdText].toString());

   970     }

   971 }

   972 

   973 

   974 void ViewFuteDataForm::populateLeftColumn()

   975 {

   976     addItemIndexes[LeftColumn] = counter++;

   977     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   978         HbDataFormModelItem::RadioButtonListItem, QString("Left column widget:"));

   979     item->setContentWidgetData(QString("items"), LeftColumnWidgets);

   980     item->setContentWidgetData("selected", 0);

   981 }

   982 

   983 void ViewFuteDataForm::populateRightColumn()

   984 {

   985     addItemIndexes[RightColumn] = counter++;

   986     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

   987         HbDataFormModelItem::RadioButtonListItem, QString("Right column widget:"));

   988     item->setContentWidgetData(QString("items"), RightColumnWidgets);

   989     item->setContentWidgetData("selected", 0);

   990 }

   991 

   992 void ViewFuteDataForm::populateType()

   993 {    

   994     HbListView *listView = qobject_cast<HbListView *>(view);

   995     if (listView) {

   996         addItemIndexes[Type] = counter++;

   997         HbDataFormModelItem *item = settingsFormModel->

   998             appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, QString("Type:"));

   999         item->setContentWidgetData("items", ItemTypes);

  1000         item->setContentWidgetData("selected", 0);

  1001     }

  1002 }

  1003 

  1004 void ViewFuteDataForm::populateBackground()

  1005 {

  1006     addItemIndexes[Background] = counter++;

  1007     HbDataFormModelItem *item = settingsFormModel->

  1008         appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, QString("Background:"));

  1009     item->setContentWidgetData("items", ItemBackgrounds);

  1010     item->setContentWidgetData("selected", 0);

  1011 }

  1012 

  1013 void ViewFuteDataForm::populateAddItemCount()

  1014 {

  1015 

  1016     addItemIndexes[ItemCount] = counter++;

  1017     HbDataFormModelItem *item = settingsFormModel->

  1018         appendDataFormItem(HbDataFormModelItem::TextItem, QString("Item count:"));

  1019     if (addItemData[ItemCount].isValid() && addItemData[ItemCount].canConvert(QVariant::Int)) {

  1020         item->setContentWidgetData("text", addItemData[ItemCount].toInt());

  1021     } else {

  1022         item->setContentWidgetData("text", QString("1"));

  1023     }

  1024 }

  1025 

  1026 void ViewFuteDataForm::populateEnabledAnimations()

  1027 {    

  1028     settingsIndexes[Animations] = counter++;

  1029 

  1030     HbListView *listView = qobject_cast<HbListView *>(view);

  1031 

  1032     QStringList animations;

  1033     if (listView) {

  1034         animations << "Appear" << "Disappear";

  1035     }

  1036     animations << "TouchDown";

  1037 

  1038     QList<QVariant> selected;

  1039     if (listView) {

  1040         if (view->enabledAnimations() | HbAbstractItemView::Appear) {

  1041             selected.append(0);

  1042         }

  1043         if (view->enabledAnimations() | HbAbstractItemView::Disappear) {

  1044             selected.append(1);

  1045         }

  1046         if (view->enabledAnimations() | HbAbstractItemView::TouchDown) {

  1047             selected.append(2);

  1048         }

  1049     } else {

  1050         if (view->enabledAnimations() | HbAbstractItemView::TouchDown) {

  1051             selected.append(0);

  1052         }

  1053     }

  1054 

  1055     HbDataFormModelItem *item = settingsFormModel->

  1056         appendDataFormItem(HbDataFormModelItem::MultiselectionItem, QString("Enabled animations:"));

  1057     item->setContentWidgetData("items", animations);

  1058 

  1059     item->setContentWidgetData("selectedItems", selected);

  1060 }

  1061 

  1062 void ViewFuteDataForm::populatePixmapCacheEnabled()

  1063 {

  1064     settingsIndexes[PixmapCache] = counter++;

  1065     

  1066     HbDataFormModelItem *item = settingsFormModel->appendDataFormItem(

  1067         HbDataFormModelItem::ToggleValueItem, QString("Pixmap cache:"));

  1068     if (view->itemPixmapCacheEnabled()) {

  1069         item->setContentWidgetData("text", "On");

  1070         item->setContentWidgetData("additionalText", "Off");

  1071     } else {

  1072         item->setContentWidgetData("text", "Off");

  1073         item->setContentWidgetData("additionalText", "On");

  1074     }

  1075 }

  1076 

  1077 void ViewFuteDataForm::populateIconLoadPolicy()

  1078 {

  1079     settingsIndexes[IconLoadPolicy] = counter++;

  1080     

  1081     HbDataFormModelItem *item = settingsFormModel->

  1082         appendDataFormItem(HbDataFormModelItem::RadioButtonListItem, QString("Icon load policy:"));

  1083     item->setContentWidgetData("items", IconLoadPolicies);

  1084     switch (view->iconLoadPolicy()) {

  1085         case HbAbstractItemView::LoadSynchronously: {

  1086             item->setContentWidgetData("selected", 0);

  1087             break;

  1088         }

  1089         case HbAbstractItemView::LoadAsynchronouslyWhenScrolling: {

  1090             item->setContentWidgetData("selected", 1);

  1091             break;

  1092         }

  1093         case HbAbstractItemView::LoadAsynchronouslyAlways: {

  1094             item->setContentWidgetData("selected", 2);

  1095             break;

  1096         }

  1097         default: {

  1098             break;

  1099         }

  1100     }    

  1101 }

  1102 

  1103 QList <HbListWidgetItem *> ViewFuteDataForm::getListWidgetItems()

  1104 {

  1105     QList <HbListWidgetItem *> items;

  1106 

  1107     if (static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(addItemIndexes[PrimaryText],0)))->

  1108             dataItemContentWidget()->property("text").toString().isEmpty()

  1109      && static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(addItemIndexes[SecondaryText],0)))->

  1110             dataItemContentWidget()->property("text").toString().isEmpty()

  1111      && static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(addItemIndexes[ThirdText],0)))->

  1112             dataItemContentWidget()->property("text").toString().isEmpty()

  1113      && static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(addItemIndexes[LeftColumn],0)))->

  1114             dataItemContentWidget()->property("selected").toInt() == 0

  1115      && static_cast<HbDataFormViewItem*>(itemByIndex(settingsFormModel->index(addItemIndexes[RightColumn],0)))->

  1116             dataItemContentWidget()->property("selected").toInt() == 0) {

  1117          return items;

  1118     }

  1119 

  1120     QVariantList strings;

  1121     QVariantList icons;

  1122 

  1123     QString primaryString = getPrimaryText();

  1124     QString secondaryString = getSecondaryText();

  1125     QString thirdString = getThirdText();

  1126 

  1127 

  1128     if (!thirdString.isEmpty()) {

  1129         if (primaryString.isEmpty()) {

  1130             primaryString = " ";

  1131         }

  1132         strings.append(primaryString);

  1133 

  1134         if (!secondaryString.isEmpty()) {

  1135             strings.append(secondaryString);