Merge branch '130-ctkVTKDataSetArrayComboBox-mask-for-arrays-with-different-semantics'. Closes #130

* 130-ctkVTKDataSetArrayComboBox-mask-for-arrays-with-different-semantics:
  Type of attribute array contains in ctkVTKDataSetModel can be configured. See #130

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

@@ -25,15 +25,16 @@
 
 // CTK includes
 #include "ctkVTKDataSetArrayComboBox.h"
+#include "ctkVTKDataSetModel.h"
 
 // VTK includes
 #include <vtkCellData.h>
 #include <vtkFloatArray.h>
 #include <vtkIntArray.h>
+#include <vtkNew.h>
 #include <vtkPointData.h>
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
-#include <vtkSmartPointer.h>
 
 // STD includes
 #include <iostream>
@@ -43,17 +44,19 @@ int ctkVTKDataSetArrayComboBoxTest1(int argc, char * argv [] )
 {
   QApplication app(argc, argv);
 
-  vtkSmartPointer<vtkPolyData> dataSet =
-      vtkSmartPointer<vtkPolyData>::New();
-  vtkSmartPointer<vtkIntArray> ints = vtkSmartPointer<vtkIntArray>::New();
+  vtkNew<vtkPolyData> dataSet;
+
+  vtkNew<vtkIntArray> ints;
   ints->SetName("Ints");
-  dataSet->GetPointData()->AddArray(ints);
-  vtkSmartPointer<vtkFloatArray> floats= vtkSmartPointer<vtkFloatArray>::New();
+  dataSet->GetPointData()->AddArray(ints.GetPointer());
+
+  vtkNew<vtkFloatArray> floats;
   floats->SetName("Floats");
-  dataSet->GetCellData()->AddArray(floats);
-  
+  dataSet->GetCellData()->AddArray(floats.GetPointer());
+
   ctkVTKDataSetArrayComboBox comboBox;
-  comboBox.setDataSet(dataSet);
+  comboBox.dataSetModel()->setAttributeTypes(ctkVTKDataSetModel::AllAttribute);
+  comboBox.setDataSet(dataSet.GetPointer());
   comboBox.show();
 
   if (argc < 2 || QString(argv[1]) != "-I")

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

@@ -31,31 +31,267 @@
 #include <vtkCellData.h>
 #include <vtkFloatArray.h>
 #include <vtkIntArray.h>
+#include <vtkNew.h>
 #include <vtkPointData.h>
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
-#include <vtkSmartPointer.h>
 
 // STD includes
 #include <iostream>
 
+namespace
+{
+//-----------------------------------------------------------------------------
+bool checkItems(int line, const QList<vtkDataArray*>& expectedAttributeArrays, ctkVTKDataSetModel* dataSetModel)
+{
+  foreach(vtkDataArray* expectedDataArray, expectedAttributeArrays)
+    {
+
+    QList<QStandardItem*> items = dataSetModel->findItems(expectedDataArray->GetName());
+    if(items.count() != 1)
+      {
+      std::cerr << "Line " << line << " - Problem with number of item matching name:" << expectedDataArray->GetName() << "\n"
+                   "\tExpected count: 1\n"
+                   "\tCurrent count: " << items.count() << "\n";
+      return false;
+      }
+    vtkDataArray * 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"
+                   "\tExpected: " << expectedDataArray << "\n"
+                   "\tCurrent: " << currentDataArray << "\n";
+      return false;
+      }
+    }
+  return true;
+}
+}
+
 //-----------------------------------------------------------------------------
 int ctkVTKDataSetModelTest1(int argc, char * argv [] )
 {
   QApplication app(argc, argv);
 
-  vtkSmartPointer<vtkPolyData> dataSet =
-      vtkSmartPointer<vtkPolyData>::New();
-  vtkSmartPointer<vtkIntArray> ints = vtkSmartPointer<vtkIntArray>::New();
-  ints->SetName("Ints");
-  dataSet->GetPointData()->AddArray(ints);
-  vtkSmartPointer<vtkFloatArray> floats= vtkSmartPointer<vtkFloatArray>::New();
-  floats->SetName("Floats");
-  dataSet->GetCellData()->AddArray(floats);
-  
+  vtkNew<vtkPolyData> dataSet;
+
+  vtkNew<vtkIntArray> ints;
+  {
+    ints->SetName("Ints");
+    int added = dataSet->GetPointData()->AddArray(ints.GetPointer());
+    if (added == -1)
+      {
+      std::cerr << "Line " << __LINE__ << " - Failed to add Ints array";
+      return EXIT_FAILURE;
+      }
+  }
+
+  vtkNew<vtkFloatArray> floats;
+  {
+    floats->SetName("Floats");
+    int added = dataSet->GetCellData()->AddArray(floats.GetPointer());
+    if (added == -1)
+      {
+      std::cerr << "Line " << __LINE__ << " - Failed to add Floats array";
+      return EXIT_FAILURE;
+      }
+  }
+
+  vtkNew<vtkFloatArray> scalars;
+  {
+    scalars->SetName("Scalars");
+    scalars->SetNumberOfComponents(0);
+    int added = dataSet->GetPointData()->SetScalars(scalars.GetPointer());
+    if (added == -1)
+      {
+      std::cerr << "Line " << __LINE__ << " - Failed to add Scalars array";
+      return EXIT_FAILURE;
+      }
+  }
+
+  vtkNew<vtkFloatArray> vectors;
+  {
+    vectors->SetNumberOfComponents(3);
+    vectors->SetName("Vectors");
+    int added = dataSet->GetPointData()->SetVectors(vectors.GetPointer());
+    if (added == -1)
+      {
+      std::cerr << "Line " << __LINE__ << " - Failed to add Vectors array";
+      return EXIT_FAILURE;
+      }
+  }
+
+  vtkNew<vtkFloatArray> normals;
+  {
+    normals->SetNumberOfComponents(3);
+    normals->SetName("Normals");
+    int added = dataSet->GetPointData()->SetNormals(normals.GetPointer());
+    if (added == -1)
+      {
+      std::cerr << "Line " << __LINE__ << " - Failed to add Normals array";
+      return EXIT_FAILURE;
+      }
+  }
+
+  vtkNew<vtkFloatArray> tcoords;
+  {
+    tcoords->SetNumberOfComponents(3);
+    tcoords->SetName("Tcoords");
+    int added = dataSet->GetPointData()->SetTCoords(tcoords.GetPointer());
+    if (added == -1)
+      {
+      std::cerr << "Line " << __LINE__ << " - Failed to add Tcoords array";
+      return EXIT_FAILURE;
+      }
+  }
+
+  vtkNew<vtkFloatArray> tensors;
+  {
+    tensors->SetNumberOfComponents(9);
+    tensors->SetName("Tensors");
+    int added = dataSet->GetPointData()->SetTensors(tensors.GetPointer());
+    if (added == -1)
+      {
+      std::cerr << "Line " << __LINE__ << " - Failed to add Tensors array";
+      return EXIT_FAILURE;
+      }
+  }
+
+  vtkNew<vtkFloatArray> globalids;
+  {
+    globalids->SetNumberOfComponents(1);
+    globalids->SetName("GlobalIDs");
+    int added = dataSet->GetPointData()->SetGlobalIds(globalids.GetPointer());
+    if (added == -1)
+      {
+      std::cerr << "Line " << __LINE__ << " - Failed to add GlobalIDs array";
+      return EXIT_FAILURE;
+      }
+  }
+
+  vtkNew<vtkFloatArray> pedigreeids;
+  {
+    pedigreeids->SetNumberOfComponents(1);
+    pedigreeids->SetName("PedigreeIDs");
+    int added = dataSet->GetPointData()->SetPedigreeIds(pedigreeids.GetPointer());
+    if (added == -1)
+      {
+      std::cerr << "Line " << __LINE__ << " - Failed to add PedigreeIDs array";
+      return EXIT_FAILURE;
+      }
+  }
+
   ctkVTKDataSetModel dataSetModel;
-  dataSetModel.setDataSet(dataSet);
-  
+  dataSetModel.setDataSet(dataSet.GetPointer());
+
+  QList<vtkDataArray*> notAttributeArrays;
+  notAttributeArrays << ints.GetPointer() << floats.GetPointer();
+
+  if (!checkItems(__LINE__, notAttributeArrays, &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::ScalarsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << scalars.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::ScalarsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << scalars.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::VectorsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << vectors.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::VectorsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << vectors.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::VectorsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << vectors.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NormalsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << normals.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::NormalsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << normals.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::TCoordsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << tcoords.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::TCoordsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << tcoords.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::TensorsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << tensors.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::TensorsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << tensors.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::GlobalIDsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << globalids.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::GlobalIDsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << globalids.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::PedigreeIDsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << pedigreeids.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::NoAttribute | ctkVTKDataSetModel::PedigreeIDsAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays << pedigreeids.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
+  dataSetModel.setAttributeTypes(ctkVTKDataSetModel::AllAttribute);
+  if (!checkItems(__LINE__, QList<vtkDataArray*>() << notAttributeArrays
+                  << scalars.GetPointer() << vectors.GetPointer()
+                  << normals.GetPointer() << tcoords.GetPointer()
+                  << tensors.GetPointer() << globalids.GetPointer()
+                  << pedigreeids.GetPointer(), &dataSetModel))
+    {
+    return EXIT_FAILURE;
+    }
+
   QComboBox comboBox;
   comboBox.setModel(&dataSetModel);
   comboBox.show();

Libs/Visualization/VTK/Widgets/ctkVTKDataSetArrayComboBox.cpp

@@ -23,7 +23,6 @@
 
 // CTK includes
 #include "ctkVTKDataSetArrayComboBox.h"
-#include "ctkVTKDataSetModel.h"
 
 // VTK includes
 #include <vtkDataArray.h>
@@ -38,7 +37,7 @@ public:
   ctkVTKDataSetArrayComboBoxPrivate(ctkVTKDataSetArrayComboBox& object);
   void init();
   ctkVTKDataSetModel* dataSetModel()const;
-  
+
   int indexFromArrayName(const QString& dataArrayName)const;
   int indexFromArray(vtkDataArray* dataArray)const;
   vtkDataArray* arrayFromIndex(int index)const;
@@ -143,6 +142,24 @@ vtkDataSet* ctkVTKDataSetArrayComboBox::dataSet()const
 }
 
 // --------------------------------------------------------------------------
+ctkVTKDataSetModel::AttributeTypes ctkVTKDataSetArrayComboBox::attributeTypes()const
+{
+  return this->dataSetModel()->attributeTypes();
+}
+
+// --------------------------------------------------------------------------
+void ctkVTKDataSetArrayComboBox::setAttributeTypes(const ctkVTKDataSetModel::AttributeTypes& attributeTypes)
+{
+  this->dataSetModel()->setAttributeTypes(attributeTypes);
+}
+
+// --------------------------------------------------------------------------
+ctkVTKDataSetModel* ctkVTKDataSetArrayComboBox::dataSetModel()const
+{
+  return qobject_cast<ctkVTKDataSetModel*>(this->model());
+}
+
+// --------------------------------------------------------------------------
 void ctkVTKDataSetArrayComboBox::setCurrentArray(vtkDataArray* dataArray)
 {
   Q_D(ctkVTKDataSetArrayComboBox);

Libs/Visualization/VTK/Widgets/ctkVTKDataSetArrayComboBox.h

@@ -26,6 +26,7 @@
 
 // CTK includes
 #include "ctkVisualizationVTKWidgetsExport.h"
+#include "ctkVTKDataSetModel.h"
 class ctkVTKDataSetArrayComboBoxPrivate;
 
 class vtkDataArray;
@@ -37,19 +38,25 @@ class vtkDataSet;
 class CTK_VISUALIZATION_VTK_WIDGETS_EXPORT ctkVTKDataSetArrayComboBox : public QComboBox
 {
   Q_OBJECT
-  
+  Q_PROPERTY(ctkVTKDataSetModel::AttributeTypes attributeTypes READ attributeTypes WRITE setAttributeTypes)
+
 public:
   /// Superclass typedef
   typedef QComboBox Superclass;
-  
+
   /// Constructors
   explicit ctkVTKDataSetArrayComboBox(QWidget* parent = 0);
   virtual ~ctkVTKDataSetArrayComboBox();
-  
+
   vtkDataArray* currentArray()const;
   QString currentArrayName()const;
   vtkDataSet* dataSet()const;
 
+  ctkVTKDataSetModel::AttributeTypes attributeTypes()const;
+  void setAttributeTypes(const ctkVTKDataSetModel::AttributeTypes& attributeTypes);
+
+  ctkVTKDataSetModel* dataSetModel()const;
+
 public Q_SLOTS:
   void setDataSet(vtkDataSet* dataSet);
   /// The array must exist in the dataset

Libs/Visualization/VTK/Widgets/ctkVTKDataSetModel.cpp

@@ -42,8 +42,12 @@ public:
   void init();
   //void listenDataArrayModifiedEvent();
 
+  static QList<vtkDataArray*> attributeArrayToInsert(const ctkVTKDataSetModel::AttributeTypes& attributeType,
+                                                     vtkDataSetAttributes * dataSetAttributes);
+
   vtkSmartPointer<vtkDataSet> DataSet;
   bool ListenDataArrayModifiedEvent;
+  ctkVTKDataSetModel::AttributeTypes AttributeType;
 };
 
 
@@ -52,6 +56,7 @@ ctkVTKDataSetModelPrivate::ctkVTKDataSetModelPrivate(ctkVTKDataSetModel& object)
   : q_ptr(&object)
 {
   this->ListenDataArrayModifiedEvent = false;
+  this->AttributeType = ctkVTKDataSetModel::AllAttribute;
 }
 
 //------------------------------------------------------------------------------
@@ -64,7 +69,7 @@ void ctkVTKDataSetModelPrivate::init()
 {
   Q_Q(ctkVTKDataSetModel);
   q->setColumnCount(1);
-  
+
   QObject::connect(q, SIGNAL(itemChanged(QStandardItem*)),
                    q, SLOT(onItemChanged(QStandardItem*)));
 }
@@ -88,7 +93,46 @@ void ctkVTKDataSetModelPrivate::listenDataArrayModifiedEvent()
 */
 
 //------------------------------------------------------------------------------
+QList<vtkDataArray*> ctkVTKDataSetModelPrivate::attributeArrayToInsert(
+    const ctkVTKDataSetModel::AttributeTypes& attributeType,
+    vtkDataSetAttributes * dataSetAttributes)
+{
+  QList<vtkDataArray*> attributeArraysToInsert;
+  for (int p = 0; p < dataSetAttributes->GetNumberOfArrays(); ++p)
+    {
+    vtkDataArray * dataArray = dataSetAttributes->GetArray(p);
+
+    bool isAttributeArray = false;
+    vtkDataArray* attributeArrays[vtkDataSetAttributes::NUM_ATTRIBUTES];
+    for(int attributeId = 0; attributeId < vtkDataSetAttributes::NUM_ATTRIBUTES; ++attributeId)
+      {
+      attributeArrays[attributeId] = dataSetAttributes->GetAttribute(attributeId);
+      if (!isAttributeArray && attributeArrays[attributeId] == dataArray)
+        {
+        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]))
+        || (attributeType & ctkVTKDataSetModel::NoAttribute && !isAttributeArray)
+        )
+      {
+      attributeArraysToInsert << dataSetAttributes->GetArray(p);
+      }
+    }
+  return attributeArraysToInsert;
+}
+
+//------------------------------------------------------------------------------
 // ctkVTKDataSetModel
+
 //------------------------------------------------------------------------------
 ctkVTKDataSetModel::ctkVTKDataSetModel(QObject *_parent)
   : QStandardItemModel(_parent)
@@ -134,6 +178,25 @@ vtkDataSet* ctkVTKDataSetModel::dataSet()const
 }
 
 //------------------------------------------------------------------------------
+ctkVTKDataSetModel::AttributeTypes ctkVTKDataSetModel::attributeTypes()const
+{
+  Q_D(const ctkVTKDataSetModel);
+  return d->AttributeType;
+}
+
+//------------------------------------------------------------------------------
+void ctkVTKDataSetModel::setAttributeTypes(const AttributeTypes& attributeTypes)
+{
+  Q_D(ctkVTKDataSetModel);
+  if (d->AttributeType == attributeTypes)
+    {
+    return;
+    }
+  d->AttributeType = attributeTypes;
+  this->updateDataSet();
+}
+
+//------------------------------------------------------------------------------
 vtkDataArray* ctkVTKDataSetModel::arrayFromItem(QStandardItem* dataArrayItem)const
 {
   if (dataArrayItem == 0 || dataArrayItem == this->invisibleRootItem())
@@ -220,14 +283,12 @@ void ctkVTKDataSetModel::populateDataSet()
   Q_D(ctkVTKDataSetModel);
   Q_ASSERT(d->DataSet);
 
-  for (int p = 0; p < d->DataSet->GetPointData()->GetNumberOfArrays(); ++p)
-    {
-    this->insertArray(d->DataSet->GetPointData()->GetArray(p));
-    }
-
-  for (int p = 0; p < d->DataSet->GetCellData()->GetNumberOfArrays(); ++p)
+  QList<vtkDataArray*> attributeArrays;
+  attributeArrays << ctkVTKDataSetModelPrivate::attributeArrayToInsert(d->AttributeType, d->DataSet->GetPointData());
+  attributeArrays << ctkVTKDataSetModelPrivate::attributeArrayToInsert(d->AttributeType, d->DataSet->GetCellData());
+  foreach(vtkDataArray* attributeArray, attributeArrays)
     {
-    this->insertArray(d->DataSet->GetCellData()->GetArray(p));
+    this->insertArray(attributeArray);
     }
 }
 

Libs/Visualization/VTK/Widgets/ctkVTKDataSetModel.h

@@ -50,15 +50,40 @@ class CTK_VISUALIZATION_VTK_WIDGETS_EXPORT ctkVTKDataSetModel
 {
   Q_OBJECT
   QVTK_OBJECT
+  Q_FLAGS(AttributeType AttributeTypes)
+
+  /// This property holds the type of attribute that should be listed in the model.s
+  /// By default all attributes are considered.
+  /// \sa ctkVTKDataSetModel::AllAttribute
+  Q_PROPERTY(AttributeTypes attributeTypes READ attributeTypes WRITE setAttributeTypes)
 
 public:
+  typedef ctkVTKDataSetModel Self;
   typedef QStandardItemModel Superclass;
   ctkVTKDataSetModel(QObject *parent=0);
   virtual ~ctkVTKDataSetModel();
 
+  enum AttributeType
+    {
+    NoAttribute = 0x1,
+    ScalarsAttribute = 0x2,
+    VectorsAttribute = 0x4,
+    NormalsAttribute = 0x8,
+    TCoordsAttribute = 0x10,
+    TensorsAttribute = 0x20,
+    GlobalIDsAttribute = 0x40,
+    PedigreeIDsAttribute = 0x80,
+    EdgeFlagAttribute = 0x100,
+    AllAttribute = NoAttribute | ScalarsAttribute | VectorsAttribute | NormalsAttribute | TCoordsAttribute | TensorsAttribute | GlobalIDsAttribute | PedigreeIDsAttribute | EdgeFlagAttribute
+    };
+  Q_DECLARE_FLAGS(AttributeTypes, AttributeType)
+
   virtual void setDataSet(vtkDataSet* dataSet);
   vtkDataSet* dataSet()const;
 
+  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;
@@ -90,6 +115,7 @@ private:
   Q_DECLARE_PRIVATE(ctkVTKDataSetModel);
   Q_DISABLE_COPY(ctkVTKDataSetModel);
 };
+Q_DECLARE_OPERATORS_FOR_FLAGS(ctkVTKDataSetModel::AttributeTypes);
 
 // -----------------------------------------------------------------------------
 vtkDataArray* ctkVTKDataSetModel::arrayFromIndex(const QModelIndex &nodeIndex)const