[TiMOB-14158] Changed ListView class names to TableView

src/tibb/NativeControlObject.cpp

@@ -187,7 +187,7 @@ NativeControlObject::NativeControlObject(TiObject* tiObject, NATIVE_TYPE objType
     layoutNode_.onLayout = onPostLayout;
     layoutNode_.data = this;
 
-    if (objType == N_TYPE_VIEW || objType == N_TYPE_WEBVIEW || objType == N_TYPE_LIST_VIEW || objType == N_TYPE_SCROLL_VIEW || objType == N_TYPE_SCROLLABLE_VIEW ||
+    if (objType == N_TYPE_VIEW || objType == N_TYPE_WEBVIEW || objType == N_TYPE_TABLE_VIEW || objType == N_TYPE_SCROLL_VIEW || objType == N_TYPE_SCROLLABLE_VIEW ||
     		objType == N_TYPE_WINDOW || objType == N_TYPE_MAPVIEW || objType == N_TYPE_TEXT_AREA) {
 		layoutNode_.properties.defaultWidthType = Fill;
 		layoutNode_.properties.defaultHeightType  = Fill;
@@ -212,7 +212,7 @@ NativeControlObject::NativeControlObject(TiObject* tiObject, NATIVE_TYPE objType
 
     }
 
-    if (objType == N_TYPE_LIST_ITEM) {
+    if (objType == N_TYPE_TABLE_VIEW_ROW) {
         layoutNode_.properties.width.valueType = Fill;
         layoutNode_.properties.height.valueType = Defer;
     }

src/tibb/NativeObject.h

@@ -34,8 +34,8 @@ enum NATIVE_TYPE
     , N_TYPE_GESTURE
     , N_TYPE_IMAGEVIEW
     , N_TYPE_LABEL
-    , N_TYPE_LIST_VIEW
-    , N_TYPE_LIST_ITEM
+    , N_TYPE_TABLE_VIEW
+    , N_TYPE_TABLE_VIEW_ROW
     , N_TYPE_LOGGER
     , N_TYPE_PROGRESSBAR
     , N_TYPE_SLIDER

src/tibb/NativeObjectFactory.cpp

@@ -20,8 +20,8 @@
 #include "NativeGestureObject.h"
 #include "NativeImageViewObject.h"
 #include "NativeLabelObject.h"
-#include "NativeListItemObject.h"
-#include "NativeListViewObject.h"
+#include "NativeTableViewRowObject.h"
+#include "NativeTableViewObject.h"
 #include "NativeLoggerObject.h"
 #include "NativeProgressBarObject.h"
 #include "NativeTabObject.h"
@@ -141,12 +141,12 @@ NativeObject* NativeObjectFactory::createNativeObject(int type, TiObject* tiObj)
         obj = NativeDropDownObject::createDropDown(tiObj);
         break;
 
-    case N_TYPE_LIST_VIEW:
-        obj = NativeListViewObject::createListView(tiObj);
+    case N_TYPE_TABLE_VIEW:
+        obj = NativeTableViewObject::createTableView(tiObj);
         break;
 
-    case N_TYPE_LIST_ITEM:
-        obj = new NativeListItemObject(tiObj);
+    case N_TYPE_TABLE_VIEW_ROW:
+        obj = new NativeTableViewRowObject(tiObj);
         break;
 
     case N_TYPE_TAB:

src/tibb/NativeListViewObject.cpp → src/tibb/NativeTableViewObject.cpp

@@ -5,16 +5,16 @@
  * Please see the LICENSE included with this distribution for details.
  */
 
-#include "NativeListViewObject.h"
+#include "NativeTableViewObject.h"
 
 #include <bb/cascades/ArrayDataModel>
 #include <bb/cascades/ListView>
 
-#include "NativeListItemObject.h"
-#include "NativeListViewObject.h"
-#include "TableView/BasicListItem.h"
-#include "TableView/CustomListItem.h"
-#include "TableView/ListItemData.h"
+#include "NativeTableViewRowObject.h"
+#include "NativeTableViewObject.h"
+#include "TableView/BasicTableViewRow.h"
+#include "TableView/CustomTableViewRow.h"
+#include "TableView/TableViewRowData.h"
 #include "TiEventContainerFactory.h"
 #include "TiObject.h"
 #include "TiProxy.h"
@@ -23,35 +23,35 @@
 using namespace bb::cascades;
 using namespace titanium;
 
-NativeListViewObject::NativeListViewObject(TiObject* tiObject)
-    : NativeControlObject(tiObject, N_TYPE_LIST_VIEW)
+NativeTableViewObject::NativeTableViewObject(TiObject* tiObject)
+    : NativeControlObject(tiObject, N_TYPE_TABLE_VIEW)
 {
-    listView_ = NULL;
+    tableView_ = NULL;
 }
 
-NativeListViewObject::~NativeListViewObject()
+NativeTableViewObject::~NativeTableViewObject()
 {
 }
 
-NativeListViewObject* NativeListViewObject::createListView(TiObject* tiObject)
+NativeTableViewObject* NativeTableViewObject::createTableView(TiObject* tiObject)
 {
-    return new NativeListViewObject(tiObject);
+    return new NativeTableViewObject(tiObject);
 }
 
-int NativeListViewObject::initialize()
+int NativeTableViewObject::initialize()
 {
-    listView_ = bb::cascades::ListView::create();
-    setControl(listView_);
-    listView_->setDataModel(new ArrayDataModel());
+    tableView_ = bb::cascades::ListView::create();
+    setControl(tableView_);
+    tableView_->setDataModel(new ArrayDataModel());
 
-    ListViewItemFactory* factory = new ListViewItemFactory(this);
-    listView_->setListItemProvider(factory);
-    listView_->setListItemTypeMapper(factory);
+    TableViewRowFactory* factory = new TableViewRowFactory(this);
+    tableView_->setListItemProvider(factory);
+    tableView_->setListItemTypeMapper(factory);
 
     return NATIVE_ERROR_OK;
 }
 
-int NativeListViewObject::setData(TiObject* obj)
+int NativeTableViewObject::setData(TiObject* obj)
 {
     HandleScope scope;
 
@@ -60,7 +60,7 @@ int NativeListViewObject::setData(TiObject* obj)
         return NATIVE_ERROR_INVALID_ARG;
     }
 
-    ArrayDataModel* model = static_cast<ArrayDataModel*>(listView_->dataModel());
+    ArrayDataModel* model = static_cast<ArrayDataModel*>(tableView_->dataModel());
 
     Handle<Array> data = Handle<Array>::Cast(value);
     uint32_t length = data->Length();
@@ -93,82 +93,82 @@ int NativeListViewObject::setData(TiObject* obj)
         }
 
         NativeObject* native = itemObject->getNativeObject();
-        if (native->getObjectType() != N_TYPE_LIST_ITEM) {
+        if (native->getObjectType() != N_TYPE_TABLE_VIEW_ROW) {
             // Only allow row objects as table data.
             return NATIVE_ERROR_INVALID_ARG;
         }
 
-        NativeListItemObject* listItem = static_cast<NativeListItemObject*>(native);
+        NativeTableViewRowObject* listItem = static_cast<NativeTableViewRowObject*>(native);
         model->append(listItem->data());
     }
 
     return NATIVE_ERROR_OK;
 }
 
-NATIVE_TYPE NativeListViewObject::getObjectType() const
+NATIVE_TYPE NativeTableViewObject::getObjectType() const
 {
-    return N_TYPE_LIST_VIEW;
+    return N_TYPE_TABLE_VIEW;
 }
 
-NAHANDLE NativeListViewObject::getNativeHandle() const
+NAHANDLE NativeTableViewObject::getNativeHandle() const
 {
-    return listView_;
+    return tableView_;
 }
 
-QVariant NativeListViewObject::getListViewElementFromIndex(QVariantList var)
+QVariant NativeTableViewObject::getTableViewElementFromIndex(QVariantList var)
 {
-    bb::cascades::DataModel* dataM = listView_->dataModel();
+    bb::cascades::DataModel* dataM = tableView_->dataModel();
     QVariant property = dataM->data(var);
     return property;
 }
 
-int NativeListViewObject::scrollToIndex(int index)
+int NativeTableViewObject::scrollToIndex(int index)
 {
     QVariant variant(index);
     QVariantList scroll;
     scroll.append(variant);
-    listView_->scrollToItem(scroll);
+    tableView_->scrollToItem(scroll);
     return NATIVE_ERROR_OK;
 }
 
-void NativeListViewObject::setupEvents(TiEventContainerFactory* containerFactory)
+void NativeTableViewObject::setupEvents(TiEventContainerFactory* containerFactory)
 {
     NativeControlObject::setupEvents(containerFactory);
     TiEventContainer* eventClicked = containerFactory->createEventContainer();
     eventClicked->setDataProperty("type", tetCLICK);
-    events_.insert(tetCLICK, EventPairSmartPtr(eventClicked, new ListViewEventHandler(eventClicked, this)));
-    QObject::connect(listView_, SIGNAL(triggered(QVariantList)), events_[tetCLICK]->handler(), SLOT(triggered(QVariantList)));
+    events_.insert(tetCLICK, EventPairSmartPtr(eventClicked, new TableViewEventHandler(eventClicked, this)));
+    QObject::connect(tableView_, SIGNAL(triggered(QVariantList)), events_[tetCLICK]->handler(), SLOT(triggered(QVariantList)));
 }
 
-/*********** ListViewItemFactory class *************/
-bb::cascades::VisualNode* ListViewItemFactory::createItem(bb::cascades::ListView*, const QString& type)
+/*********** TableViewRowFactory class *************/
+bb::cascades::VisualNode* TableViewRowFactory::createItem(bb::cascades::ListView*, const QString& type)
 {
     if (type == "custom") {
-        return new CustomListItem(listView_->layout());
+        return new CustomTableViewRow(tableView_->layout());
     }
-    return new BasicListItem();
+    return new BasicTableViewRow();
 }
 
-void ListViewItemFactory::updateItem(bb::cascades::ListView*, bb::cascades::VisualNode* listItem, const QString&,
+void TableViewRowFactory::updateItem(bb::cascades::ListView*, bb::cascades::VisualNode* listItem, const QString&,
                                      const QVariantList&, const QVariant& data)
 {
     Q_ASSERT(data.canConvert<QObject*>());
-    AbstractListItem* item = static_cast<AbstractListItem*>(listItem);
+    AbstractTableViewRow* item = static_cast<AbstractTableViewRow*>(listItem);
     item->setData(data.value<QObject*>());
 }
 
-QString ListViewItemFactory::itemType(const QVariant &data, const QVariantList &indexPat)
+QString TableViewRowFactory::itemType(const QVariant &data, const QVariantList &indexPat)
 {
     Q_ASSERT(data.canConvert<QObject*>());
     return data.value<QObject*>()->property("dataType").toString();
 }
 
-/*********** ListViewEventHandler class *************/
-void ListViewEventHandler::triggered(QVariantList var)
+/*********** TableViewEventHandler class *************/
+void TableViewEventHandler::triggered(QVariantList var)
 {
     int index = var[0].toInt();
-    QVariant data = owner_->getListViewElementFromIndex(var);
-    ListItemData* itemData = static_cast<ListItemData*>(data.value<QObject*>());
+    QVariant data = owner_->getTableViewElementFromIndex(var);
+    TableViewRowData* itemData = static_cast<TableViewRowData*>(data.value<QObject*>());
     Handle<Value> row = itemData->row()->getValue();
 
     eventContainer_->setDataProperty("index", index);

src/tibb/NativeListViewObject.h → src/tibb/NativeTableViewObject.h

@@ -5,14 +5,14 @@
  * Please see the LICENSE included with this distribution for details.
  */
 
-#ifndef NATIVELISTVIEWOBJECT_H_
-#define NATIVELISTVIEWOBJECT_H_
+#ifndef NATIVETABLEVIEWOBJECT_H_
+#define NATIVETABLEVIEWOBJECT_H_
 
 #include "NativeControlObject.h"
 #include <QObject>
 
 /*
- * NativeListView
+ * NativeTableView
  *
  * UI: TableView control
  */
@@ -32,38 +32,38 @@ class VisualNode;
 
 class TiEventContainer;
 class TiCascadesEventHandler;
-class ListViewEventHandler;
+class TableViewEventHandler;
 
-class NativeListViewObject : public NativeControlObject
+class NativeTableViewObject : public NativeControlObject
 {
 public:
-    static NativeListViewObject* createListView(TiObject* tiObject);
+    static NativeTableViewObject* createTableView(TiObject* tiObject);
     virtual NATIVE_TYPE getObjectType() const;
     virtual int setData(TiObject* obj);
     virtual int initialize();
-    virtual QVariant getListViewElementFromIndex(QVariantList var);
+    virtual QVariant getTableViewElementFromIndex(QVariantList var);
     virtual NAHANDLE getNativeHandle() const;
     virtual int scrollToIndex(int index);
 
 protected:
-    virtual ~NativeListViewObject();
+    virtual ~NativeTableViewObject();
     virtual void setupEvents(TiEventContainerFactory* containerFactory);
 
 private:
-    explicit NativeListViewObject(TiObject* tiObject);
+    explicit NativeTableViewObject(TiObject* tiObject);
     //Not copy-constructible; Not assignable.
-    NativeListViewObject(const NativeListViewObject& obj);
-    NativeListViewObject& operator=(const NativeListViewObject& obj);
+    NativeTableViewObject(const NativeTableViewObject& obj);
+    NativeTableViewObject& operator=(const NativeTableViewObject& obj);
 
-    bb::cascades::ListView* listView_;
+    bb::cascades::ListView* tableView_;
 };
 
-class ListViewItemFactory : public bb::cascades::ListItemProvider,
+class TableViewRowFactory : public bb::cascades::ListItemProvider,
                             public bb::cascades::ListItemTypeMapper
 {
 public:
-    ListViewItemFactory(NativeListViewObject* listView)
-      : listView_(listView) {
+    TableViewRowFactory(NativeTableViewObject* tableView)
+      : tableView_(tableView) {
     }
 
     bb::cascades::VisualNode* createItem(bb::cascades::ListView* list, const QString& type);
@@ -73,31 +73,31 @@ class ListViewItemFactory : public bb::cascades::ListItemProvider,
     QString itemType(const QVariant &data, const QVariantList &indexPat);
 
 private:
-    NativeListViewObject* listView_;
+    NativeTableViewObject* tableView_;
 };
 
 //Event handler for button object
-class ListViewEventHandler : public QObject
+class TableViewEventHandler : public QObject
 {
     Q_OBJECT
 public:
-    explicit ListViewEventHandler(TiEventContainer* eventContainer, NativeListViewObject* owner)
+    explicit TableViewEventHandler(TiEventContainer* eventContainer, NativeTableViewObject* owner)
     {
         eventContainer_ = eventContainer;
         owner_ = owner;
     }
-    virtual ~ListViewEventHandler() {}
+    virtual ~TableViewEventHandler() {}
 
 public slots:
     void triggered(QVariantList var);
 
 private:
     TiEventContainer* eventContainer_;
-    NativeListViewObject* owner_;
+    NativeTableViewObject* owner_;
 
     // Disable copy ctor & assignment operator
-    ListViewEventHandler(const ListViewEventHandler& eHandler);
-    ListViewEventHandler& operator=(const ListViewEventHandler& eHandler);
+    TableViewEventHandler(const TableViewEventHandler& eHandler);
+    TableViewEventHandler& operator=(const TableViewEventHandler& eHandler);
 };
 
-#endif /* NATIVELISTVIEWOBJECT_H_ */
+#endif /* NATIVETABLEVIEWOBJECT_H_ */