Merge branch 'add-vtkStringArray-support'

* add-vtkStringArray-support:
  Add vtkStringArray and vtkVariantArray support in ctkVTKDataSetModel

Libs/Visualization/VTK/Widgets/Testing/Cpp/ctkVTKDataSetModelTest1.cpp

@@ -35,6 +35,7 @@
 #include <vtkPointData.h>
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
+#include <vtkStringArray.h>
 
 // STD includes
 #include <iostream>
@@ -42,9 +43,9 @@
 namespace
 {
 //-----------------------------------------------------------------------------
-bool checkItems(int line, const QList<vtkDataArray*>& expectedAttributeArrays, ctkVTKDataSetModel* dataSetModel)
+bool checkItems(int line, const QList<vtkAbstractArray*>& expectedAttributeArrays, ctkVTKDataSetModel* dataSetModel)
 {
-  foreach(vtkDataArray* expectedDataArray, expectedAttributeArrays)
+  foreach(vtkAbstractArray* expectedDataArray, expectedAttributeArrays)
     {
 
     QList<QStandardItem*> items = dataSetModel->findItems(expectedDataArray->GetName());
@@ -55,7 +56,7 @@ bool checkItems(int line, const QList<vtkDataArray*>& expectedAttributeArrays, c
                    "\tCurrent count: " << items.count() << "\n";
       return false;
       }
-    vtkDataArray * currentDataArray = dataSetModel->arrayFromItem(items.at(0));
+    vtkAbstractArray * currentDataArray = dataSetModel->arrayFromItem(items.at(0));
     if (currentDataArray != expectedDataArray)
       {
       std::cerr << "Line " << line << " - Problem with model - Incorrect array associated with item name:" << expectedDataArray->GetName() << "\n"
@@ -97,6 +98,17 @@ int ctkVTKDataSetModelTest1(int argc, char * argv [] )
       }
   }
 
+  vtkNew<vtkStringArray> strings;
+  {
+    strings->SetName("Strings");
+    int added = dataSet->GetCellData()->AddArray(strings.GetPointer());
+    if (added == -1)
+      {
+      std::cerr << "Line " << __LINE__ << " - Failed to add Strings array";
+      return EXIT_FAILURE;
+      }
+  }
+
   vtkNew<vtkFloatArray> scalars;
   {
     scalars->SetName("Scalars");
@@ -184,7 +196,7 @@ int ctkVTKDataSetModelTest1(int argc, char * argv [] )
   ctkVTKDataSetModel dataSetModel;
   dataSetModel.setDataSet(dataSet.GetPointer());
 
-  QList<vtkDataArray*> notAttributeArrays;
+  QList<vtkAbstractArray*> notAttributeArrays;
   notAttributeArrays << ints.GetPointer() << floats.GetPointer();
 
   if (!checkItems(__LINE__, notAttributeArrays, &dataSetModel))
@@ -193,97 +205,97 @@ int ctkVTKDataSetModelTest1(int argc, char * argv [] )
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::ScalarsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << scalars.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << scalars.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::ScalarsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << scalars.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << notAttributeArrays << scalars.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::VectorsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << vectors.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << vectors.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::VectorsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << vectors.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << vectors.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::VectorsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << vectors.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << notAttributeArrays << vectors.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NormalsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << normals.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << normals.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::NormalsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << normals.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << notAttributeArrays << normals.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::TCoordsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << tcoords.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << tcoords.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::TCoordsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << tcoords.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << notAttributeArrays << tcoords.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::TensorsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << tensors.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << tensors.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::TensorsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << tensors.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << notAttributeArrays << tensors.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::GlobalIDsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << globalids.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << globalids.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::GlobalIDsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << globalids.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << notAttributeArrays << globalids.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::PedigreeIDsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << pedigreeids.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << pedigreeids.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::PedigreeIDsAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << pedigreeids.GetPointer(), &dataSetModel))
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << notAttributeArrays << pedigreeids.GetPointer(), &dataSetModel))
     {
     return EXIT_FAILURE;
     }
 
   dataSetModel.setAttributeTypes(ctkVTKDataSetModel::AllAttribute);
-  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays
+  if (!checkItems(__LINE__, QList<vtkAbstractArray*>() << notAttributeArrays
                   << scalars.GetPointer() << vectors.GetPointer()
                   << normals.GetPointer() << tcoords.GetPointer()
                   << tensors.GetPointer() << globalids.GetPointer()

Libs/Visualization/VTK/Widgets/ctkVTKDataSetArrayComboBox.cpp

@@ -25,7 +25,7 @@
 #include "ctkVTKDataSetArrayComboBox.h"
 
 // VTK includes
-#include <vtkDataArray.h>
+#include <vtkAbstractArray.h>
 
 //-----------------------------------------------------------------------------
 class ctkVTKDataSetArrayComboBoxPrivate
@@ -39,8 +39,8 @@ public:
   ctkVTKDataSetModel* dataSetModel()const;
 
   int indexFromArrayName(const QString& dataArrayName)const;
-  int indexFromArray(vtkDataArray* dataArray)const;
-  vtkDataArray* arrayFromIndex(int index)const;
+  int indexFromArray(vtkAbstractArray* dataArray)const;
+  vtkAbstractArray* arrayFromIndex(int index)const;
   QString arrayNameFromIndex(int index)const;
 };
 
@@ -77,13 +77,13 @@ int ctkVTKDataSetArrayComboBoxPrivate::indexFromArrayName(const QString& dataArr
 }
 
 // --------------------------------------------------------------------------
-int ctkVTKDataSetArrayComboBoxPrivate::indexFromArray(vtkDataArray* dataArray)const
+int ctkVTKDataSetArrayComboBoxPrivate::indexFromArray(vtkAbstractArray* dataArray)const
 {
   return this->dataSetModel()->indexFromArray(dataArray,0).row();
 }
 
 // --------------------------------------------------------------------------
-vtkDataArray* ctkVTKDataSetArrayComboBoxPrivate::arrayFromIndex(int index)const
+vtkAbstractArray* ctkVTKDataSetArrayComboBoxPrivate::arrayFromIndex(int index)const
 {
   return this->dataSetModel()->arrayFromIndex(
     this->dataSetModel()->index(index, 0));
@@ -92,7 +92,7 @@ vtkDataArray* ctkVTKDataSetArrayComboBoxPrivate::arrayFromIndex(int index)const
 // --------------------------------------------------------------------------
 QString ctkVTKDataSetArrayComboBoxPrivate::arrayNameFromIndex(int index)const
 {
-  vtkDataArray* dataArray = this->arrayFromIndex(index);
+  vtkAbstractArray* dataArray = this->arrayFromIndex(index);
   return dataArray ? dataArray->GetName() : "";
 }
 
@@ -114,7 +114,7 @@ ctkVTKDataSetArrayComboBox::~ctkVTKDataSetArrayComboBox()
 }
 
 // --------------------------------------------------------------------------
-vtkDataArray* ctkVTKDataSetArrayComboBox::currentArray()const
+vtkAbstractArray* ctkVTKDataSetArrayComboBox::currentArray()const
 {
   Q_D(const ctkVTKDataSetArrayComboBox);
   return d->arrayFromIndex(this->currentIndex());
@@ -123,7 +123,7 @@ vtkDataArray* ctkVTKDataSetArrayComboBox::currentArray()const
 // --------------------------------------------------------------------------
 QString ctkVTKDataSetArrayComboBox::currentArrayName()const
 {
-  vtkDataArray* dataArray = this->currentArray();
+  vtkAbstractArray* dataArray = this->currentArray();
   return dataArray ? dataArray->GetName() : "";
 }
 
@@ -160,7 +160,7 @@ ctkVTKDataSetModel* ctkVTKDataSetArrayComboBox::dataSetModel()const
 }
 
 // --------------------------------------------------------------------------
-void ctkVTKDataSetArrayComboBox::setCurrentArray(vtkDataArray* dataArray)
+void ctkVTKDataSetArrayComboBox::setCurrentArray(vtkAbstractArray* dataArray)
 {
   Q_D(ctkVTKDataSetArrayComboBox);
   this->setCurrentIndex(d->indexFromArray(dataArray));

Libs/Visualization/VTK/Widgets/ctkVTKDataSetArrayComboBox.h

@@ -29,13 +29,14 @@
 #include "ctkVTKDataSetModel.h"
 class ctkVTKDataSetArrayComboBoxPrivate;
 
-class vtkDataArray;
+class vtkAbstractArray;
 class vtkDataSet;
 
 /// \ingroup Visualization_VTK_Widgets
 ///
 /// QComboBox linked to vtkDataSet field arrays
-class CTK_VISUALIZATION_VTK_WIDGETS_EXPORT ctkVTKDataSetArrayComboBox : public QComboBox
+class CTK_VISUALIZATION_VTK_WIDGETS_EXPORT ctkVTKDataSetArrayComboBox
+  : public QComboBox
 {
   Q_OBJECT
   Q_PROPERTY(ctkVTKDataSetModel::AttributeTypes attributeTypes READ attributeTypes WRITE setAttributeTypes)
@@ -48,24 +49,28 @@ public:
   explicit ctkVTKDataSetArrayComboBox(QWidget* parent = 0);
   virtual ~ctkVTKDataSetArrayComboBox();
 
-  vtkDataArray* currentArray()const;
+  vtkAbstractArray* currentArray()const;
   QString currentArrayName()const;
   vtkDataSet* dataSet()const;
 
   ctkVTKDataSetModel::AttributeTypes attributeTypes()const;
   void setAttributeTypes(const ctkVTKDataSetModel::AttributeTypes& attributeTypes);
 
+  /// Return a pointer to the model used to populate the combobox.
+  /// \sa dataSet()
   ctkVTKDataSetModel* dataSetModel()const;
 
 public Q_SLOTS:
+  /// Set the dataset to observe. It is used to as the "model" for the combobox.
+  /// \sa dataSet(), dataSetModel()
   void setDataSet(vtkDataSet* dataSet);
   /// The array must exist in the dataset
-  void setCurrentArray(vtkDataArray* dataArray);
+  void setCurrentArray(vtkAbstractArray* dataArray);
   /// the array must exist in the dataset
   void setCurrentArray(const QString& name);
 
 Q_SIGNALS:
-  void currentArrayChanged(vtkDataArray*);
+  void currentArrayChanged(vtkAbstractArray*);
   void currentArrayChanged(const QString& name);
 protected Q_SLOTS:
   void onCurrentIndexChanged(int);

Libs/Visualization/VTK/Widgets/ctkVTKDataSetModel.cpp

@@ -25,11 +25,11 @@
 #include "ctkVTKDataSetModel.h"
 
 // VTK includes
+#include <vtkAbstractArray.h>
 #include <vtkCellData.h>
-#include <vtkSmartPointer.h>
-#include <vtkDataArray.h>
 #include <vtkDataSet.h>
 #include <vtkPointData.h>
+#include <vtkSmartPointer.h>
 
 class ctkVTKDataSetModelPrivate
 {
@@ -40,13 +40,13 @@ public:
   ctkVTKDataSetModelPrivate(ctkVTKDataSetModel& object);
   virtual ~ctkVTKDataSetModelPrivate();
   void init();
-  //void listenDataArrayModifiedEvent();
+  //void listenAbstractArrayModifiedEvent();
 
-  static QList<vtkDataArray*> attributeArrayToInsert(const ctkVTKDataSetModel::AttributeTypes& attributeType,
+  static QList<vtkAbstractArray*> attributeArrayToInsert(const ctkVTKDataSetModel::AttributeTypes& attributeType,
                                                      vtkDataSetAttributes * dataSetAttributes);
 
   vtkSmartPointer<vtkDataSet> DataSet;
-  bool ListenDataArrayModifiedEvent;
+  bool ListenAbstractArrayModifiedEvent;
   ctkVTKDataSetModel::AttributeTypes AttributeType;
 };
 
@@ -55,7 +55,7 @@ public:
 ctkVTKDataSetModelPrivate::ctkVTKDataSetModelPrivate(ctkVTKDataSetModel& object)
   : q_ptr(&object)
 {
-  this->ListenDataArrayModifiedEvent = false;
+  this->ListenAbstractArrayModifiedEvent = false;
   this->AttributeType = ctkVTKDataSetModel::AllAttribute;
 }
 
@@ -75,11 +75,11 @@ void ctkVTKDataSetModelPrivate::init()
 }
 /*
 //------------------------------------------------------------------------------
-void ctkVTKDataSetModelPrivate::listenDataArrayModifiedEvent()
+void ctkVTKDataSetModelPrivate::listenAbstractArrayModifiedEvent()
 {
   Q_Q(ctkVTKDataSetModel);
   q->qvtkDisconnect(0, vtkCommand::ModifiedEvent, q, SLOT(onArrayModified(vtkObject*)));
-  if (!this->ListenDataArrayModifiedEvent)
+  if (!this->ListenAbstractArrayModifiedEvent)
     {
     return;
     }
@@ -93,38 +93,38 @@ void ctkVTKDataSetModelPrivate::listenDataArrayModifiedEvent()
 */
 
 //------------------------------------------------------------------------------
-QList<vtkDataArray*> ctkVTKDataSetModelPrivate::attributeArrayToInsert(
+QList<vtkAbstractArray*> ctkVTKDataSetModelPrivate::attributeArrayToInsert(
     const ctkVTKDataSetModel::AttributeTypes& attributeType,
     vtkDataSetAttributes * dataSetAttributes)
 {
-  QList<vtkDataArray*> attributeArraysToInsert;
+  QList<vtkAbstractArray*> attributeArraysToInsert;
   for (int p = 0; p < dataSetAttributes->GetNumberOfArrays(); ++p)
     {
-    vtkDataArray * dataArray = dataSetAttributes->GetArray(p);
+    vtkAbstractArray * array = dataSetAttributes->GetAbstractArray(p);
 
     bool isAttributeArray = false;
-    vtkDataArray* attributeArrays[vtkDataSetAttributes::NUM_ATTRIBUTES];
+    vtkAbstractArray* attributeArrays[vtkDataSetAttributes::NUM_ATTRIBUTES];
     for(int attributeId = 0; attributeId < vtkDataSetAttributes::NUM_ATTRIBUTES; ++attributeId)
       {
-      attributeArrays[attributeId] = dataSetAttributes->GetAttribute(attributeId);
-      if (!isAttributeArray && attributeArrays[attributeId] == dataArray)
+      attributeArrays[attributeId] = dataSetAttributes->GetAbstractAttribute(attributeId);
+      if (!isAttributeArray && attributeArrays[attributeId] == array)
         {
         isAttributeArray = true;
         }
       }
 
-    if ((attributeType & ctkVTKDataSetModel::ScalarsAttribute && (dataArray == attributeArrays[vtkDataSetAttributes::SCALARS]))
-        || (attributeType & ctkVTKDataSetModel::VectorsAttribute && (dataArray == attributeArrays[vtkDataSetAttributes::VECTORS]))
-        || (attributeType & ctkVTKDataSetModel::NormalsAttribute && (dataArray == attributeArrays[vtkDataSetAttributes::NORMALS]))
-        || (attributeType & ctkVTKDataSetModel::TCoordsAttribute && (dataArray == attributeArrays[vtkDataSetAttributes::TCOORDS]))
-        || (attributeType & ctkVTKDataSetModel::TensorsAttribute && (dataArray == attributeArrays[vtkDataSetAttributes::TENSORS]))
-        || (attributeType & ctkVTKDataSetModel::GlobalIDsAttribute && (dataArray == attributeArrays[vtkDataSetAttributes::GLOBALIDS]))
-        || (attributeType & ctkVTKDataSetModel::PedigreeIDsAttribute && (dataArray == attributeArrays[vtkDataSetAttributes::PEDIGREEIDS]))
-        || (attributeType & ctkVTKDataSetModel::EdgeFlagAttribute && (dataArray == attributeArrays[vtkDataSetAttributes::EDGEFLAG]))
+    if ((attributeType & ctkVTKDataSetModel::ScalarsAttribute && (array == attributeArrays[vtkDataSetAttributes::SCALARS]))
+        || (attributeType & ctkVTKDataSetModel::VectorsAttribute && (array == attributeArrays[vtkDataSetAttributes::VECTORS]))
+        || (attributeType & ctkVTKDataSetModel::NormalsAttribute && (array == attributeArrays[vtkDataSetAttributes::NORMALS]))
+        || (attributeType & ctkVTKDataSetModel::TCoordsAttribute && (array == attributeArrays[vtkDataSetAttributes::TCOORDS]))
+        || (attributeType & ctkVTKDataSetModel::TensorsAttribute && (array == attributeArrays[vtkDataSetAttributes::TENSORS]))
+        || (attributeType & ctkVTKDataSetModel::GlobalIDsAttribute && (array == attributeArrays[vtkDataSetAttributes::GLOBALIDS]))
+        || (attributeType & ctkVTKDataSetModel::PedigreeIDsAttribute && (array == attributeArrays[vtkDataSetAttributes::PEDIGREEIDS]))
+        || (attributeType & ctkVTKDataSetModel::EdgeFlagAttribute && (array == attributeArrays[vtkDataSetAttributes::EDGEFLAG]))
         || (attributeType & ctkVTKDataSetModel::NoAttribute && !isAttributeArray)
         )
       {
-      attributeArraysToInsert << dataSetAttributes->GetArray(p);
+      attributeArraysToInsert << dataSetAttributes->GetAbstractArray(p);
       }
     }
   return attributeArraysToInsert;
@@ -197,29 +197,29 @@ void ctkVTKDataSetModel::setAttributeTypes(const AttributeTypes& attributeTypes)
 }
 
 //------------------------------------------------------------------------------
-vtkDataArray* ctkVTKDataSetModel::arrayFromItem(QStandardItem* dataArrayItem)const
+vtkAbstractArray* ctkVTKDataSetModel::arrayFromItem(QStandardItem* arrayItem)const
 {
-  if (dataArrayItem == 0 || dataArrayItem == this->invisibleRootItem())
+  if (arrayItem == 0 || arrayItem == this->invisibleRootItem())
     {
     return 0;
     }
-  QVariant dataArrayPointer = dataArrayItem->data(ctkVTK::PointerRole);
-  Q_ASSERT(dataArrayPointer.isValid());
-  vtkDataArray* dataArray = static_cast<vtkDataArray*>(
-    reinterpret_cast<void *>(dataArrayPointer.toLongLong()));
-  Q_ASSERT(dataArray);
-  return dataArray;
+  QVariant arrayPointer = arrayItem->data(ctkVTK::PointerRole);
+  Q_ASSERT(arrayPointer.isValid());
+  vtkAbstractArray* array = static_cast<vtkAbstractArray*>(
+    reinterpret_cast<void *>(arrayPointer.toLongLong()));
+  Q_ASSERT(array);
+  return array;
 }
 
 //------------------------------------------------------------------------------
-QStandardItem* ctkVTKDataSetModel::itemFromArray(vtkDataArray* dataArray, int column)const
+QStandardItem* ctkVTKDataSetModel::itemFromArray(vtkAbstractArray* array, int column)const
 {
-  if (dataArray == 0)
+  if (array == 0)
     {
     return 0;
     }
   QModelIndexList indexes = this->match(this->index(-1,-1), ctkVTK::PointerRole,
-                                      reinterpret_cast<long long>(dataArray), 1,
+                                      reinterpret_cast<long long>(array), 1,
                                       Qt::MatchExactly | Qt::MatchRecursive);
   while (indexes.size())
     {
@@ -228,17 +228,17 @@ QStandardItem* ctkVTKDataSetModel::itemFromArray(vtkDataArray* dataArray, int co
       return this->itemFromIndex(indexes[0]);
       }
     indexes = this->match(indexes[0], ctkVTK::PointerRole,
-                          reinterpret_cast<long long>(dataArray), 1,
+                          reinterpret_cast<long long>(array), 1,
                           Qt::MatchExactly | Qt::MatchRecursive);
     }
   return 0;
 }
 
 //------------------------------------------------------------------------------
-QModelIndexList ctkVTKDataSetModel::indexes(vtkDataArray* dataArray)const
+QModelIndexList ctkVTKDataSetModel::indexes(vtkAbstractArray* array)const
 {
   return this->match(this->index(-1,-1), ctkVTK::PointerRole,
-                     QVariant::fromValue(reinterpret_cast<long long>(dataArray)),
+                     QVariant::fromValue(reinterpret_cast<long long>(array)),
                      -1, Qt::MatchExactly | Qt::MatchRecursive);
 }
 
@@ -283,51 +283,51 @@ void ctkVTKDataSetModel::populateDataSet()
   Q_D(ctkVTKDataSetModel);
   Q_ASSERT(d->DataSet);
 
-  QList<vtkDataArray*> attributeArrays;
+  QList<vtkAbstractArray*> attributeArrays;
   attributeArrays << ctkVTKDataSetModelPrivate::attributeArrayToInsert(d->AttributeType, d->DataSet->GetPointData());
   attributeArrays << ctkVTKDataSetModelPrivate::attributeArrayToInsert(d->AttributeType, d->DataSet->GetCellData());
-  foreach(vtkDataArray* attributeArray, attributeArrays)
+  foreach(vtkAbstractArray* attributeArray, attributeArrays)
     {
     this->insertArray(attributeArray);
     }
 }
 
 //------------------------------------------------------------------------------
-void ctkVTKDataSetModel::insertArray(vtkDataArray* dataArray)
+void ctkVTKDataSetModel::insertArray(vtkAbstractArray* array)
 {
-  this->insertArray(dataArray, this->rowCount());
+  this->insertArray(array, this->rowCount());
 }
 
 //------------------------------------------------------------------------------
-void ctkVTKDataSetModel::insertArray(vtkDataArray* dataArray, int row)
+void ctkVTKDataSetModel::insertArray(vtkAbstractArray* array, int row)
 {
   Q_D(ctkVTKDataSetModel);
-  Q_ASSERT(vtkDataArray::SafeDownCast(dataArray));
+  Q_ASSERT(vtkAbstractArray::SafeDownCast(array));
 
   QList<QStandardItem*> items;
   for (int i= 0; i < this->columnCount(); ++i)
     {
     QStandardItem* newArrayItem = new QStandardItem();
-    this->updateItemFromArray(newArrayItem, dataArray, i);
+    this->updateItemFromArray(newArrayItem, array, i);
     items.append(newArrayItem);
     }
   this->insertRow(row,items);
   // TODO: don't listen to nodes that are hidden from editors ?
-  if (d->ListenDataArrayModifiedEvent)
+  if (d->ListenAbstractArrayModifiedEvent)
     {
-    qvtkConnect(dataArray, vtkCommand::ModifiedEvent,
+    qvtkConnect(array, vtkCommand::ModifiedEvent,
                 this, SLOT(onArrayModified(vtkObject*)));
     }
 }
 
 //------------------------------------------------------------------------------
-void ctkVTKDataSetModel::updateItemFromArray(QStandardItem* item, vtkDataArray* dataArray, int column)
+void ctkVTKDataSetModel::updateItemFromArray(QStandardItem* item, vtkAbstractArray* array, int column)
 {
-  item->setData(QVariant::fromValue(reinterpret_cast<long long>(dataArray)), ctkVTK::PointerRole);
+  item->setData(QVariant::fromValue(reinterpret_cast<long long>(array)), ctkVTK::PointerRole);
   switch (column)
     {
     case 0:
-      item->setText(QString(dataArray->GetName()));
+      item->setText(QString(array->GetName()));
       break;
     default:
       Q_ASSERT(column == 0);
@@ -337,9 +337,9 @@ void ctkVTKDataSetModel::updateItemFromArray(QStandardItem* item, vtkDataArray*
 
 //------------------------------------------------------------------------------
 /*
-void ctkVTKDataSetModel::updateItemFromPointsArray(QStandardItem* item, vtkDataArray* dataArray, int column)
+void ctkVTKDataSetModel::updateItemFromPointsArray(QStandardItem* item, vtkAbstractArray* array, int column)
 {
-  this->updateItemFromArray(item, dataArray, column);
+  this->updateItemFromArray(item, array, column);
   switch (column)
     {
     case 0:
@@ -352,9 +352,9 @@ void ctkVTKDataSetModel::updateItemFromPointsArray(QStandardItem* item, vtkDataA
 }
 
 //------------------------------------------------------------------------------
-void ctkVTKDataSetModel::updateItemFromCellsArray(QStandardItem* item, vtkDataArray* dataArray, int column)
+void ctkVTKDataSetModel::updateItemFromCellsArray(QStandardItem* item, vtkAbstractArray* array, int column)
 {
-  this->updateItemFromArray(item, dataArray, column);
+  this->updateItemFromArray(item, array, column);
   switch (column)
     {
     case 0:
@@ -369,11 +369,11 @@ void ctkVTKDataSetModel::updateItemFromCellsArray(QStandardItem* item, vtkDataAr
 */
 
 //------------------------------------------------------------------------------
-void ctkVTKDataSetModel::updateArrayFromItem(vtkDataArray* dataArray, QStandardItem* item)
+void ctkVTKDataSetModel::updateArrayFromItem(vtkAbstractArray* array, QStandardItem* item)
 {
   if (item->column() == 0)
     {
-    dataArray->SetName(item->text().toLatin1());
+    array->SetName(item->text().toLatin1());
     }
 }
 
@@ -385,23 +385,23 @@ void ctkVTKDataSetModel::onDataSetModified(vtkObject* dataSet)
 }
 
 //------------------------------------------------------------------------------
-void ctkVTKDataSetModel::onArrayModified(vtkObject* array)
+void ctkVTKDataSetModel::onArrayModified(vtkObject* modifiedArray)
 {
-  vtkDataArray* dataArray = vtkDataArray::SafeDownCast(array);
-  Q_ASSERT(dataArray);
-  QModelIndexList arrayIndexes = this->indexes(dataArray);
+  vtkAbstractArray* array = vtkAbstractArray::SafeDownCast(modifiedArray);
+  Q_ASSERT(array);
+  QModelIndexList arrayIndexes = this->indexes(array);
 
   foreach (QModelIndex index, arrayIndexes)
     {
     QStandardItem* item = this->itemFromIndex(index);
-    this->updateItemFromArray(item, dataArray, item->column());
+    this->updateItemFromArray(item, array, item->column());
     }
 }
 
 //------------------------------------------------------------------------------
 void ctkVTKDataSetModel::onItemChanged(QStandardItem * item)
 {
-  vtkDataArray* dataArray = this->arrayFromItem(item);
-  Q_ASSERT(dataArray);
-  this->updateArrayFromItem(dataArray, item);
+  vtkAbstractArray* array = this->arrayFromItem(item);
+  Q_ASSERT(array);
+  this->updateArrayFromItem(array, item);
 }

Libs/Visualization/VTK/Widgets/ctkVTKDataSetModel.h

@@ -31,7 +31,7 @@
 #include "ctkVisualizationVTKWidgetsExport.h"
 
 class vtkDataSet;
-class vtkDataArray;
+class vtkAbstractArray;
 
 /// \ingroup Visualization_VTK_Widgets
 namespace ctkVTK
@@ -84,27 +84,27 @@ public:
   AttributeTypes attributeTypes()const;
   void setAttributeTypes(const AttributeTypes& attributeTypes);
 
-  /// Return the vtkDataArray associated to the index.
-  /// 0 if the index doesn't contain a vtkDataArray
-  inline vtkDataArray* arrayFromIndex(const QModelIndex& arrayIndex)const;
-  vtkDataArray* arrayFromItem(QStandardItem* nodeItem)const;
-  inline QModelIndex indexFromArray(vtkDataArray* dataArray, int column = 0)const;
-  QStandardItem* itemFromArray(vtkDataArray* dataArray, int column = 0)const;
-  QModelIndexList indexes(vtkDataArray* dataArray)const;
+  /// Return the vtkAbstractArray associated to the index.
+  /// 0 if the index doesn't contain a vtkAbstractArray
+  inline vtkAbstractArray* arrayFromIndex(const QModelIndex& arrayIndex)const;
+  vtkAbstractArray* arrayFromItem(QStandardItem* nodeItem)const;
+  inline QModelIndex indexFromArray(vtkAbstractArray* array, int column = 0)const;
+  QStandardItem* itemFromArray(vtkAbstractArray* array, int column = 0)const;
+  QModelIndexList indexes(vtkAbstractArray* array)const;
 
 protected Q_SLOTS:
   void onDataSetModified(vtkObject* dataSet);
-  void onArrayModified(vtkObject* dataArray);
+  void onArrayModified(vtkObject* array);
   void onItemChanged(QStandardItem * item);
 
 protected:
 
   ctkVTKDataSetModel(ctkVTKDataSetModelPrivate* pimpl, QObject *parent=0);
 
-  virtual void insertArray(vtkDataArray* dataArray);
-  virtual void insertArray(vtkDataArray* dataArray, int row);
-  virtual void updateItemFromArray(QStandardItem* item, vtkDataArray* dataArray, int column);
-  virtual void updateArrayFromItem(vtkDataArray* dataArray, QStandardItem* item);
+  virtual void insertArray(vtkAbstractArray* array);
+  virtual void insertArray(vtkAbstractArray* array, int row);
+  virtual void updateItemFromArray(QStandardItem* item, vtkAbstractArray* array, int column);
+  virtual void updateArrayFromItem(vtkAbstractArray* array, QStandardItem* item);
   virtual void updateDataSet();
   virtual void populateDataSet();
 
@@ -118,15 +118,15 @@ private:
 Q_DECLARE_OPERATORS_FOR_FLAGS(ctkVTKDataSetModel::AttributeTypes);
 
 // -----------------------------------------------------------------------------
-vtkDataArray* ctkVTKDataSetModel::arrayFromIndex(const QModelIndex &nodeIndex)const
+vtkAbstractArray* ctkVTKDataSetModel::arrayFromIndex(const QModelIndex &nodeIndex)const
 {
   return this->arrayFromItem(this->itemFromIndex(nodeIndex));
 }
 
 // -----------------------------------------------------------------------------
-QModelIndex ctkVTKDataSetModel::indexFromArray(vtkDataArray* dataArray, int column)const
+QModelIndex ctkVTKDataSetModel::indexFromArray(vtkAbstractArray* array, int column)const
 {
-  QStandardItem* item = this->itemFromArray(dataArray, column);
+  QStandardItem* item = this->itemFromArray(array, column);
   return item ? item->index() : QModelIndex();
 }