Commit a317a101 authored by Bob Obara's avatar Bob Obara Committed by Kitware Robot

Merge topic 'removingAttRef'

8a39355d ENH: Removing AttRefItem, MeshSelectionItem, and MeshItem Support
Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
Acked-by: John Tourtellott's avatarJohn Tourtellott <john.tourtellott@kitware.com>
Merge-request: !1745
parents b6aa293b 8a39355d
......@@ -46,14 +46,8 @@ std::shared_ptr<HandlerItemDef> HandlerItemDef::create(const int type)
return std::make_shared<HandlerFile>();
case Item::DirectoryType:
return std::make_shared<HandlerDirectory>();
case Item::MeshSelectionType:
return std::make_shared<HandlerMeshSelection>();
case Item::MeshEntityType:
return std::make_shared<HandlerMeshEntity>();
case Item::DateTimeType:
return std::make_shared<HandlerDateTime>();
case Item::AttributeRefType:
return std::make_shared<HandlerRef>();
case Item::ComponentType:
return std::make_shared<HandlerComponent>();
case Item::ResourceType:
......
......@@ -13,9 +13,6 @@
#include "smtk/attribute/DateTimeItemDefinition.h"
#include "smtk/attribute/DirectoryItemDefinition.h"
#include "smtk/attribute/FileItemDefinition.h"
#include "smtk/attribute/MeshItemDefinition.h"
#include "smtk/attribute/MeshSelectionItemDefinition.h"
#include "smtk/attribute/RefItemDefinition.h"
#include "smtk/attribute/ResourceItemDefinition.h"
#include "smtk/attribute/VoidItemDefinition.h"
......@@ -41,55 +38,6 @@ smtk::attribute::ItemDefinitionPtr HandlerVoid::createItemDef_impl(const std::st
return smtk::attribute::VoidItemDefinition::New(name);
}
////////////////////////////////////////////////////////////////////////////////
HandlerRef::HandlerRef()
: Ui(new Ui::ItemDefRefForm)
{
}
HandlerRef::~HandlerRef() = default;
bool HandlerRef::initialize_impl(QWidget* parent)
{
this->Ui->setupUi(parent);
QObject::connect(this->Ui->cbCommonLabel, SIGNAL(toggled(bool)), this->Ui->leCommonLabel,
SLOT(setEnabled(bool)));
if (this->ItemDef)
{
const auto item = std::static_pointer_cast<smtk::attribute::RefItemDefinition>(this->ItemDef);
this->Ui->leNumReqValues->setText(QString::number(item->numberOfRequiredValues()));
const bool useCommonLabel = item->usingCommonLabel();
this->Ui->cbCommonLabel->setChecked(useCommonLabel);
this->Ui->leCommonLabel->setVisible(useCommonLabel);
this->Ui->leCommonLabel->setText(QString::fromStdString(item->valueLabel(0)));
}
return true;
}
// -----------------------------------------------------------------------------
smtk::attribute::ItemDefinitionPtr HandlerRef::updateItemDef_impl()
{
auto item = std::static_pointer_cast<smtk::attribute::RefItemDefinition>(this->ItemDef);
item->setNumberOfRequiredValues(static_cast<size_t>(this->Ui->leNumReqValues->text().toInt()));
if (this->Ui->cbCommonLabel->isChecked())
{
item->setCommonValueLabel(this->Ui->leCommonLabel->text().toStdString());
}
return this->ItemDef;
}
// -----------------------------------------------------------------------------
smtk::attribute::ItemDefinitionPtr HandlerRef::createItemDef_impl(const std::string& name)
{
return smtk::attribute::RefItemDefinition::New(name);
}
////////////////////////////////////////////////////////////////////////////////
bool HandlerFile::initialize_impl(QWidget* parent)
{
......@@ -166,44 +114,6 @@ smtk::attribute::ItemDefinitionPtr HandlerResource::createItemDef_impl(const std
return smtk::attribute::ResourceItemDefinition::New(name);
}
////////////////////////////////////////////////////////////////////////////////
bool HandlerMeshSelection::initialize_impl(QWidget* parent)
{
parent->hide();
return true;
}
// -----------------------------------------------------------------------------
smtk::attribute::ItemDefinitionPtr HandlerMeshSelection::updateItemDef_impl()
{
return this->ItemDef;
}
// -----------------------------------------------------------------------------
smtk::attribute::ItemDefinitionPtr HandlerMeshSelection::createItemDef_impl(const std::string& name)
{
return smtk::attribute::MeshSelectionItemDefinition::New(name);
}
////////////////////////////////////////////////////////////////////////////////
bool HandlerMeshEntity::initialize_impl(QWidget* parent)
{
parent->hide();
return true;
}
// -----------------------------------------------------------------------------
smtk::attribute::ItemDefinitionPtr HandlerMeshEntity::updateItemDef_impl()
{
return this->ItemDef;
}
// -----------------------------------------------------------------------------
smtk::attribute::ItemDefinitionPtr HandlerMeshEntity::createItemDef_impl(const std::string& name)
{
return smtk::attribute::MeshItemDefinition::New(name);
}
////////////////////////////////////////////////////////////////////////////////
bool HandlerDateTime::initialize_impl(QWidget* parent)
{
......
......@@ -35,26 +35,6 @@ namespace Ui
class ItemDefRefForm;
}
/**
* \brief Generates a custom UI for a RefItemDefinition instance.
*/
class HandlerRef : public HandlerItemDef
{
public:
HandlerRef();
~HandlerRef();
private:
HandlerRef(const HandlerRef&) = delete;
void operator=(const HandlerRef&) = delete;
smtk::attribute::ItemDefinitionPtr createItemDef_impl(const std::string& name) override;
smtk::attribute::ItemDefinitionPtr updateItemDef_impl() override;
bool initialize_impl(QWidget* parent) override;
std::unique_ptr<Ui::ItemDefRefForm> Ui;
};
////////////////////////////////////////////////////////////////////////////////
/**
* \brief Generates a custom UI for a FileItemDefinition instance.
......@@ -133,44 +113,6 @@ private:
bool initialize_impl(QWidget* parent) override;
};
////////////////////////////////////////////////////////////////////////////////
/**
* \brief Generates a custom UI for a MeshSelectionItemDef instance.
*/
class HandlerMeshSelection : public HandlerItemDef
{
public:
HandlerMeshSelection() = default;
~HandlerMeshSelection() = default;
private:
HandlerMeshSelection(const HandlerMeshSelection&) = delete;
void operator=(const HandlerMeshSelection&) = delete;
smtk::attribute::ItemDefinitionPtr createItemDef_impl(const std::string& name) override;
smtk::attribute::ItemDefinitionPtr updateItemDef_impl() override;
bool initialize_impl(QWidget* parent) override;
};
////////////////////////////////////////////////////////////////////////////////
/**
* \brief Generates a custom UI for a MeshEntityItemDef instance.
*/
class HandlerMeshEntity : public HandlerItemDef
{
public:
HandlerMeshEntity() = default;
~HandlerMeshEntity() = default;
private:
HandlerMeshEntity(const HandlerMeshEntity&) = delete;
void operator=(const HandlerMeshEntity&) = delete;
smtk::attribute::ItemDefinitionPtr createItemDef_impl(const std::string& name) override;
smtk::attribute::ItemDefinitionPtr updateItemDef_impl() override;
bool initialize_impl(QWidget* parent) override;
};
////////////////////////////////////////////////////////////////////////////////
/**
* \brief Generates a custom UI for a DateTimeItemDef instance.
......
## Attribute Resource Changes
### Removal of Redundant Item/ItemDefinition Classes
#### RefItem and RefItemDefinition
With the addition of ComponentItem (which can refer to a component of a resource) there is no longer a need for RefItem (which can only refer to an attribute). To update existing code to remove RefItems and their Definition you need to simply do the following:
Assume you wanted to reference attributes that are derived from a definition called base. In the original code you might have:
```
auto oldRefDefinition =
attDef->addItemDefinition<smtk::attribute::RefItemDefinitionPtr>("BaseDefItem");
oldRefDefinition->setAttributeDefinition(base);
```
In the updated code you would have:
```
auto compDef =
attDef->addItemDefinition<smtk::attribute::ComponentItemDefinitionPtr>("BaseDefItem");
std::string attQuery = resource.createAttributeQuery(base);
compDef->setAcceptsEntries(smtk::common::typeName<smtk::attribute::Resource>(), attQuery, true);
```
Note that SMTK's XML and JSON I/O classes will convert RefItem and RefItem definitions into their equivalent ComponentItem and ComponentItemDefinition forms.
##### Change in Copying Behavior
When copying an AttRef item or definition, there was an option to copy the item or definition being referenced. This was required since AttRefItemDefinition held a pointer to the referenced definition and likewise an AttRefItem held a pointer to the item being referenced. Since ComponentItemDefinitions do not have this requirement, copying a ComponentItemDefinition ***does not*** copy the corresponding definition. Likewise a copied ComponentItem will refer to the same component has the original item instead of providing an option to make a copy of the referenced component and have the copied item refer to it.
#### MeshSelectionItem and MeshSelectionItemDefinition
This item was a stop gap for returning parts of a model's tessellation which is now handled using the selection process. There is no conversion for the item and its definition.
#### MeshItem and MeshItemDefinition
As with AttRefItem and AttRefItemDefiniiton, there is no longer a need for MeshItem (which can only refer to a mesh entity). To update existing code to remove MeshItems and their Definition you need to simply do the following:
```
auto oldMeshDefinition =
attDef->addItemDefinition<smtk::attribute::MeshItemDefinitionPtr>("MeshItem");
```
In the updated code you would have:
```
auto compDef =
meshDef->addItemDefinition<smtk::attribute::ComponentItemDefinitionPtr>("MeshItem");
compDef->setAcceptsEntries(smtk::common::typeName<smtk::mesh::Resource>(), "meshset", true);
```
### attribute::ItemDefinition::passCategoryCheck
attribute::ItemDefinition now has methods to compare its categories with a user provided set (or with respects to a single category). If the input set of categories is empty then the method will always return true. If the input set is not empty but the item's set of categories is then the method returns false. Else the result will depend on the Definition's categoryCheckMode.
......@@ -32,6 +73,7 @@ The following API have been added/changed to support this feature:
### Other Changes
* Added a static method attribute::Resource::createAttributeQuery that will return an appropriate string for querying attributes based on a specific definition.
* FileSystemItem::ValueAsString() now returns "" when the item is not set.
* When Attribute::Attribute(...) no longer creates the attribute's items. This is now done using the new Attribute::build() method - this allows Items to access the attribute's shared pointer when they are constructed.
* ReferenceItem now unsets it's values when being deleted so the corresponding links are removed from the resource.
......
......@@ -2,3 +2,80 @@
### smtk::io::Logger is now thread-safe
The class now does a mutex lock when modifying or accessing its records or its underlying stream. Care must be taking when redirecting the logger's stream to avoid deadlocks. For example using smtk::extension::qtEmittingStringBuffer, you should make sure to use Qt::QueuedConnection when doing a QObject::connect to the buffer's flush signal. See smtk/extension/qt/cxx/testing/UnitTestEmittingStringBuffer.{h,cxx} for an example.
### New Attribute Resource and SBT formats (4.0)
We have now create version 4.0 for both attribute SBT and attribute SMTK files. This will now be the default in terms of writing out attribute information. SMTK will still support reading in Versions 1, 2, and 3.
#### Defining and using Unique Roles for ComponentItems
##### To add unique roles 10 and 20 for an Attribute Resource:
```
<?xml version="1.0" encoding="utf-8" ?>
<SMTK_AttributeResource Version="4">
<!-- Category & Analysis specifications -->
<Categories>
<Cat>Enclosure Radiation</Cat>
<Cat>Fluid Flow</Cat>
<Cat>Heat Transfer</Cat>
<Cat>Induction Heating</Cat>
<Cat>Solid Mechanics</Cat>
</Categories>
<Analyses>
<Analysis Type="Heat Transfer">
<Cat>Heat Transfer</Cat>
</Analysis>
<Analysis Type="Enclosure Radiation" BaseType="Heat Transfer">
<Cat>Enclosure Radiation</Cat>
</Analysis>
<Analysis Type="Induction Heating" BaseType="Heat Transfer">
<Cat>Induction Heating</Cat>
</Analysis>
<Analysis Type="Fluid Flow">
<Cat>Fluid Flow</Cat>
</Analysis>
<Analysis Type="Solid Mechanics">
<Cat>Solid Mechanics</Cat>
</Analysis>
</Analyses>
<UniqueRoles>
<Role ID="10"/>
<Role ID="20"/>
</UniqueRoles>
```
##### Defining the role for a ComponentItemDefinition
```
<Component Name="uniqueTest" Label="Unique Test" Role="10">
<Categories>
<Cat>Heat Transfer</Cat>
</Categories>
<Accepts>
<Resource Name="smtk::model::Resource" Filter="face"/>
</Accepts>
</Component>
```
### Specifying Category Checking Options for ItemDefinitions
In the example below, Items created from Item Definition s1 will pass their category checks if either category a or b is included in the input set of categories. In the case of Item Definition s2, the corresponding Items will pass their checks if the input set contains both a and b.
```
<ItemDefinitions>
<String Name="s1" CategoryCheckMode="Any">
<Categories>
<Cat>b</Cat>
<Cat>c</Cat>
</Categories>
</String>
<String Name="s2" CategoryCheckMode="All">
<Categories>
<Cat>a</Cat>
<Cat>b</Cat>
</Categories>
</String>
</ItemDefinitions>
```
#### Changes
* ValueItem's expressions are now saved using ComponentItem format to reflect the fact that AttRefItems are no longer supported.
* MeshItems and MeshSelections are no longer supported in XML and JSON
......@@ -29,3 +29,10 @@ Note that
Operations are now used to translate VTK/ParaView selections
into SMTK selections. See the user guide for details.
This change was made to support mesh and instance subset selections.
## Operators
### Deprecated Operatiors
These ParaView operators are no longer supported:
* smtkSaveModelView
* smtkExportModelView
......@@ -65,14 +65,8 @@ class IntItem;
class IntItemDefinition;
class Item;
class ItemDefinition;
class MeshItem;
class MeshItemDefinition;
class MeshSelectionItem;
class MeshSelectionItemDefinition;
class ModelEntityItem;
class ModelEntityItemDefinition;
class RefItem;
class RefItemDefinition;
class ReferenceItem;
class ReferenceItemDefinition;
class ResourceItem;
......@@ -350,9 +344,6 @@ typedef smtk::shared_ptr<smtk::attribute::Attribute> AttributePtr;
typedef smtk::weak_ptr<smtk::attribute::Attribute> WeakAttributePtr;
typedef std::vector<smtk::attribute::AttributePtr> Attributes;
typedef smtk::shared_ptr<smtk::attribute::RefItem> RefItemPtr;
typedef smtk::shared_ptr<smtk::attribute::RefItemDefinition> RefItemDefinitionPtr;
typedef smtk::shared_ptr<smtk::attribute::Item> ItemPtr;
typedef smtk::shared_ptr<const smtk::attribute::Item> ConstItemPtr;
typedef smtk::weak_ptr<smtk::attribute::Item> WeakItemPtr;
......@@ -380,11 +371,6 @@ typedef smtk::shared_ptr<smtk::attribute::IntItem> IntItemPtr;
typedef smtk::shared_ptr<smtk::attribute::IntItemDefinition> IntItemDefinitionPtr;
typedef smtk::shared_ptr<smtk::attribute::StringItem> StringItemPtr;
typedef smtk::shared_ptr<smtk::attribute::StringItemDefinition> StringItemDefinitionPtr;
typedef smtk::shared_ptr<smtk::attribute::MeshItem> MeshItemPtr;
typedef smtk::shared_ptr<smtk::attribute::MeshItemDefinition> MeshItemDefinitionPtr;
typedef smtk::shared_ptr<smtk::attribute::MeshSelectionItem> MeshSelectionItemPtr;
typedef smtk::shared_ptr<smtk::attribute::MeshSelectionItemDefinition>
MeshSelectionItemDefinitionPtr;
typedef smtk::shared_ptr<smtk::attribute::ModelEntityItem> ModelEntityItemPtr;
typedef smtk::shared_ptr<const smtk::attribute::ModelEntityItemDefinition>
ConstModelEntityItemDefinitionPtr;
......@@ -417,11 +403,6 @@ typedef smtk::shared_ptr<const smtk::attribute::IntItem> ConstIntItemPtr;
typedef smtk::shared_ptr<const smtk::attribute::IntItemDefinition> ConstIntItemDefinitionPtr;
typedef smtk::shared_ptr<const smtk::attribute::StringItem> ConstStringItemPtr;
typedef smtk::shared_ptr<const smtk::attribute::StringItemDefinition> ConstStringItemDefinitionPtr;
typedef smtk::shared_ptr<const smtk::attribute::MeshItem> ConstMeshItemPtr;
typedef smtk::shared_ptr<const smtk::attribute::MeshItemDefinition> ConstMeshItemDefinitionPtr;
typedef smtk::shared_ptr<const smtk::attribute::MeshSelectionItem> ConstMeshSelectionItemPtr;
typedef smtk::shared_ptr<const smtk::attribute::MeshSelectionItemDefinition>
ConstMeshSelectionItemDefinitionPtr;
typedef smtk::shared_ptr<const smtk::attribute::ModelEntityItem> ConstModelEntityItemPtr;
typedef smtk::shared_ptr<const smtk::attribute::ModelEntityItemDefinition>
ConstModelEntityItemDefinitionPtr;
......@@ -436,8 +417,6 @@ typedef smtk::shared_ptr<const smtk::attribute::ComponentItemDefinition>
ConstComponentItemDefinitionPtr;
typedef smtk::shared_ptr<const smtk::attribute::VoidItem> ConstVoidItemPtr;
typedef smtk::shared_ptr<const smtk::attribute::VoidItemDefinition> ConstVoidItemDefinitionPtr;
typedef smtk::shared_ptr<const smtk::attribute::RefItem> ConstRefItemPtr;
typedef smtk::shared_ptr<const smtk::attribute::RefItemDefinition> ConstRefItemDefinitionPtr;
typedef smtk::shared_ptr<smtk::attribute::Resource> ResourcePtr;
typedef smtk::shared_ptr<const smtk::attribute::Resource> ConstResourcePtr;
......
......@@ -18,11 +18,8 @@
#include "smtk/attribute/GroupItem.h"
#include "smtk/attribute/IntItem.h"
#include "smtk/attribute/Item.h"
#include "smtk/attribute/MeshItem.h"
#include "smtk/attribute/MeshSelectionItem.h"
#include "smtk/attribute/ModelEntityItem.h"
#include "smtk/attribute/ModelEntityItemDefinition.h"
#include "smtk/attribute/RefItem.h"
#include "smtk/attribute/Resource.h"
#include "smtk/attribute/ResourceItem.h"
#include "smtk/attribute/StringItem.h"
......@@ -77,16 +74,6 @@ Attribute::Attribute(const std::string& myName, const smtk::attribute::Definitio
Attribute::~Attribute()
{
m_aboutToBeDeleted = true;
// Clear all references to the attribute
std::map<smtk::attribute::RefItem*, std::set<std::size_t> >::iterator it;
for (it = m_references.begin(); it != m_references.end(); it++)
{
std::set<std::size_t>::iterator sit;
for (sit = it->second.begin(); sit != it->second.end(); sit++)
{
it->first->unset(*sit);
}
}
// Detatch the association item
if (m_associatedObjects)
{
......@@ -118,19 +105,6 @@ void Attribute::removeAllItems()
m_items.clear();
}
void Attribute::references(std::vector<smtk::attribute::ItemPtr>& list) const
{
list.clear();
std::map<smtk::attribute::RefItem*, std::set<std::size_t> >::const_iterator it;
for (it = m_references.begin(); it != m_references.end(); it++)
{
if (it->second.size())
{
list.push_back(it->first->shared_from_this());
}
}
}
const double* Attribute::color() const
{
if (m_isColorSet)
......@@ -785,15 +759,6 @@ smtk::attribute::ConstGroupItemPtr Attribute::findGroup(const std::string& nameS
return smtk::dynamic_pointer_cast<const GroupItem>(this->find(nameStr));
}
smtk::attribute::RefItemPtr Attribute::findRef(const std::string& nameStr)
{
return smtk::dynamic_pointer_cast<RefItem>(this->find(nameStr));
}
smtk::attribute::ConstRefItemPtr Attribute::findRef(const std::string& nameStr) const
{
return smtk::dynamic_pointer_cast<const RefItem>(this->find(nameStr));
}
smtk::attribute::ModelEntityItemPtr Attribute::findModelEntity(const std::string& nameStr)
{
return smtk::dynamic_pointer_cast<ModelEntityItem>(this->find(nameStr));
......@@ -813,25 +778,6 @@ smtk::attribute::ConstVoidItemPtr Attribute::findVoid(const std::string& nameStr
return smtk::dynamic_pointer_cast<const VoidItem>(this->find(nameStr));
}
smtk::attribute::MeshSelectionItemPtr Attribute::findMeshSelection(const std::string& nameStr)
{
return smtk::dynamic_pointer_cast<MeshSelectionItem>(this->find(nameStr));
}
smtk::attribute::ConstMeshSelectionItemPtr Attribute::findMeshSelection(
const std::string& nameStr) const
{
return smtk::dynamic_pointer_cast<const MeshSelectionItem>(this->find(nameStr));
}
smtk::attribute::MeshItemPtr Attribute::findMesh(const std::string& nameStr)
{
return smtk::dynamic_pointer_cast<MeshItem>(this->find(nameStr));
}
smtk::attribute::ConstMeshItemPtr Attribute::findMesh(const std::string& nameStr) const
{
return smtk::dynamic_pointer_cast<const MeshItem>(this->find(nameStr));
}
smtk::attribute::DateTimeItemPtr Attribute::findDateTime(const std::string& nameStr)
{
return smtk::dynamic_pointer_cast<DateTimeItem>(this->find(nameStr));
......
......@@ -35,7 +35,6 @@ class Model;
namespace attribute
{
class RefItem;
class Item;
class Resource;
......@@ -46,7 +45,6 @@ class SMTKCORE_EXPORT Attribute : public resource::Component
{
friend class smtk::attribute::Definition;
friend class smtk::attribute::Resource;
friend class smtk::attribute::RefItem;
public:
smtkTypeMacro(smtk::attribute::Attribute);
......@@ -184,9 +182,6 @@ public:
GroupItemPtr findGroup(const std::string& name);
ConstGroupItemPtr findGroup(const std::string& name) const;
RefItemPtr findRef(const std::string& name);
ConstRefItemPtr findRef(const std::string& name) const;
ModelEntityItemPtr findModelEntity(const std::string& name);
ConstModelEntityItemPtr findModelEntity(const std::string& name) const;
......@@ -207,8 +202,6 @@ public:
ComponentItemPtr findComponent(const std::string& name);
ConstComponentItemPtr findComponent(const std::string& name) const;
void references(std::vector<smtk::attribute::ItemPtr>& list) const;
ConstReferenceItemPtr associatedObjects() const { return m_associatedObjects; }
ReferenceItemPtr associatedObjects() { return m_associatedObjects; }
......@@ -252,11 +245,6 @@ public:
*/
bool removeExpungedEntities(const smtk::model::EntityRefs& expungedEnts);
MeshSelectionItemPtr findMeshSelection(const std::string& name);
ConstMeshSelectionItemPtr findMeshSelection(const std::string& name) const;
MeshItemPtr findMesh(const std::string& name);
ConstMeshItemPtr findMesh(const std::string& name) const;
// These methods only applies to Attributes whose
// definition returns true for isNodal()
bool appliesToBoundaryNodes() const { return m_appliesToBoundaryNodes; }
......@@ -310,23 +298,10 @@ protected:
void addItem(smtk::attribute::ItemPtr& iPtr) { m_items.push_back(iPtr); }
void setName(const std::string& newname) { m_name = newname; }
void addReference(smtk::attribute::RefItem* attRefItem, std::size_t pos)
{
m_references[attRefItem].insert(pos);
}
// This removes a specific ref item
void removeReference(smtk::attribute::RefItem* attRefItem, std::size_t pos)
{
m_references[attRefItem].erase(pos);
}
// This removes all references to a specific Ref Item
void removeReference(smtk::attribute::RefItem* attRefItem) { m_references.erase(attRefItem); }
std::string m_name;
std::vector<smtk::attribute::ItemPtr> m_items;
ReferenceItemPtr m_associatedObjects;
smtk::attribute::DefinitionPtr m_definition;
std::map<smtk::attribute::RefItem*, std::set<std::size_t> > m_references;
bool m_appliesToBoundaryNodes;
bool m_appliesToInteriorNodes;
bool m_isColorSet;
......
......@@ -21,18 +21,12 @@ set(jsonAttributeHeaders
json/jsonIntItemDefinition.h
json/jsonItem.h
json/jsonItemDefinition.h
json/jsonMeshItem.h
json/jsonMeshItemDefinition.h
json/jsonMeshSelectionItem.h
json/jsonMeshSelectionItemDefinition.h
json/jsonModelEntityItem.h
json/jsonModelEntityItemDefinition.h
json/jsonStringItem.h
json/jsonStringItemDefinition.h
json/jsonReferenceItem.h
json/jsonReferenceItemDefinition.h
json/jsonRefItem.h
json/jsonRefItemDefinition.h
json/jsonResourceItem.h
json/jsonResourceItemDefinition.h
json/jsonValueItem.h
......@@ -64,20 +58,14 @@ set(jsonAttributeSrcs
json/jsonIntItemDefinition.cxx
json/jsonItem.cxx
json/jsonItemDefinition.cxx
json/jsonMeshItem.cxx
json/jsonMeshItemDefinition.cxx
json/jsonMeshSelectionItem.cxx
json/jsonMeshSelectionItemDefinition.cxx
json/jsonModelEntityItem.cxx
json/jsonModelEntityItemDefinition.cxx
json/jsonStringItem.cxx
json/jsonStringItemDefinition.cxx
json/jsonReferenceItem.cxx
json/jsonReferenceItemDefinition.cxx
json/jsonRefItem.cxx
json/jsonResourceItem.cxx
json/jsonResourceItemDefinition.cxx
json/jsonRefItemDefinition.cxx
json/jsonValueItem.cxx
json/jsonValueItemDefinition.cxx
json/jsonVoidItem.cxx
......@@ -109,17 +97,11 @@ set(attributeHeaders
IntItemDefinition.h
Item.h
ItemDefinition.h
MeshItem.h
MeshItemDefinition.h
MeshSelectionItem.h
MeshSelectionItemDefinition.h
ModelEntityItem.h
ModelEntityItemDefinition.h
PathGrammar.h
ReferenceItem.h
ReferenceItemDefinition.h
RefItem.h
RefItemDefinition.h
Registrar.h
ResourceItem.h
ResourceItemDefinition.h
......@@ -168,14 +150,8 @@ set(attributeSrcs
IntItemDefinition.cxx
Item.cxx
ItemDefinition.cxx
MeshItem.cxx
MeshItemDefinition.cxx
MeshSelectionItem.cxx
MeshSelectionItemDefinition.cxx
ModelEntityItem.cxx
ModelEntityItemDefinition.cxx
RefItem.cxx
RefItemDefinition.cxx
ReferenceItem.cxx
ReferenceItemDefinition.cxx
Registrar.cxx
......
......@@ -64,7 +64,7 @@ public:
/**
* @brief visitChildren Invoke a function on each (or, if \a findInActiveChildren
* is true, each active) child item. If a subclass presents children items(ValueItem,
* Group, RefItem, ...) then this function should be overriden.
* Group, ...) then this function should be overriden.
* @param visitor a lambda function which would be applied on children items
* @param activeChildren a flag indicating whether it should be applied to active children only or not
*/
......
......@@ -12,7 +12,6 @@
#include "smtk/attribute/Attribute.h"
#include "smtk/attribute/GroupItem.h"
#include "smtk/attribute/ItemDefinition.h"
#include "smtk/attribute/RefItem.h"
#include "smtk/attribute/ValueItem.h"
#include <iostream>
using namespace smtk::attribute;
......@@ -258,8 +257,6 @@ std::string Item::type2String(Item::Type t)
return "Void";