SubphraseGenerator.h

//=========================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//=========================================================================
#ifndef smtk_view_SubphraseGenerator_h
#define smtk_view_SubphraseGenerator_h
 
#include "smtk/view/DescriptivePhrase.h"
 
namespace smtk
{
namespace model
{
class Group;
}
 
namespace view
{
 
class SMTKCORE_EXPORT SubphraseGenerator : smtkEnableSharedPtr(SubphraseGenerator)
{
public:
  static std::string getType(const smtk::view::ConfigurationPtr& viewSpec);
  static SubphraseGeneratorPtr create(
    const std::string& typeName,
    const smtk::view::ManagerPtr& manager);
 
  smtkTypeMacroBase(smtk::view::SubphraseGenerator);
  smtkCreateMacro(smtk::view::SubphraseGenerator);
  SubphraseGenerator();
  virtual ~SubphraseGenerator() = default;
 
  using Path = std::vector<int>;
  using PhrasesByPath = std::multimap<Path, DescriptivePhrasePtr>;
 
  virtual DescriptivePhrases subphrases(DescriptivePhrase::Ptr src);
 
  virtual bool hasChildren(const DescriptivePhrase& src) const;
 
  virtual smtk::resource::PersistentObjectSet parentObjects(
    const smtk::resource::PersistentObjectPtr& obj) const;
 
  bool setModel(PhraseModelPtr model);
 
  PhraseModelPtr model() const { return m_model.lock(); }
 
  virtual DescriptivePhrasePtr createSubPhrase(
    const smtk::resource::PersistentObjectPtr& obj,
    const DescriptivePhrasePtr& parent,
    Path& childPath);
 
  virtual void subphrasesForCreatedObjects(
    const smtk::resource::PersistentObjectArray& objects,
    const DescriptivePhrasePtr& localRoot,
    PhrasesByPath& resultingPhrases);
 
  virtual int directLimit() const;
  virtual bool setDirectLimit(int val);
 
  virtual bool shouldOmitProperty(
    DescriptivePhrase::Ptr parent,
    smtk::resource::PropertyType ptype,
    const std::string& pname) const;
 
  virtual void setSkipProperties(bool val);
  virtual bool skipProperties() const;
 
  virtual void setSkipAttributes(bool val);
  virtual bool skipAttributes() const;
 
  ManagerPtr manager() const { return m_manager.lock(); }
  friend Manager;
 
protected:
  virtual Path indexOfObjectInParent(
    const smtk::resource::PersistentObjectPtr& obj,
    const smtk::view::DescriptivePhrasePtr& parent,
    const Path& parentPath);
 
  virtual int findResourceLocation(
    smtk::resource::ResourcePtr rsrc,
    const DescriptivePhrase::Ptr& root) const;
  virtual bool findSortedLocation(
    Path& pathOut,
    smtk::attribute::AttributePtr attr,
    DescriptivePhrase::Ptr& phr,
    const DescriptivePhrase::Ptr& parent) const;
  virtual bool findSortedLocation(
    Path& pathOut,
    smtk::model::EntityPtr entity,
    DescriptivePhrase::Ptr& phr,
    const DescriptivePhrase::Ptr& parent) const;
  virtual bool findSortedLocation(
    Path& pathOut,
    smtk::mesh::ComponentPtr comp,
    DescriptivePhrase::Ptr& phr,
    const DescriptivePhrase::Ptr& parent) const;
 
  bool resourceHasChildren(const smtk::resource::ResourcePtr& rsrc) const;
  bool modelEntityHasChildren(const smtk::model::EntityPtr& entity) const;
 
  void componentsOfResource(
    DescriptivePhrase::Ptr src,
    smtk::resource::ResourcePtr rsrc,
    DescriptivePhrases& result);
  void itemsOfAttribute(
    DescriptivePhrase::Ptr src,
    smtk::attribute::AttributePtr att,
    DescriptivePhrases& result);
  void childrenOfModelEntity(
    DescriptivePhrase::Ptr src,
    smtk::model::EntityPtr modelEntity,
    DescriptivePhrases& result);
 
  void freeSubmodelsOfModel(
    DescriptivePhrase::Ptr src,
    const smtk::model::Model& mod,
    DescriptivePhrases& result);
  void freeGroupsOfModel(
    DescriptivePhrase::Ptr src,
    const smtk::model::Model& mod,
    DescriptivePhrases& result);
  void freeCellsOfModel(
    DescriptivePhrase::Ptr src,
    const smtk::model::Model& mod,
    DescriptivePhrases& result);
  void freeAuxiliaryGeometriesOfModel(
    DescriptivePhrase::Ptr src,
    const smtk::model::Model& mod,
    DescriptivePhrases& result);
 
  void instancesOfModelEntity(
    DescriptivePhrase::Ptr src,
    const smtk::model::EntityRef& ent,
    DescriptivePhrases& result);
  /*
  void attributesOfModelEntity(
    DescriptivePhrase::Ptr src, const smtk::model::EntityRef& ent, DescriptivePhrases& result);
    */
 
  void cellOfModelUse(
    DescriptivePhrase::Ptr src,
    const smtk::model::UseEntity& ent,
    DescriptivePhrases& result);
  void boundingShellsOfModelUse(
    DescriptivePhrase::Ptr src,
    const smtk::model::UseEntity& ent,
    DescriptivePhrases& result);
  void toplevelShellsOfModelUse(
    DescriptivePhrase::Ptr src,
    const smtk::model::UseEntity& ent,
    DescriptivePhrases& result);
 
  void usesOfModelCell(
    DescriptivePhrase::Ptr src,
    const smtk::model::CellEntity& ent,
    DescriptivePhrases& result);
  void inclusionsOfModelCell(
    DescriptivePhrase::Ptr src,
    const smtk::model::CellEntity& ent,
    DescriptivePhrases& result);
  void boundingCellsOfModelCell(
    DescriptivePhrase::Ptr src,
    const smtk::model::CellEntity& ent,
    DescriptivePhrases& result);
 
  void usesOfModelShell(
    DescriptivePhrase::Ptr src,
    const smtk::model::ShellEntity& ent,
    DescriptivePhrases& result);
 
  void membersOfModelGroup(
    DescriptivePhrase::Ptr src,
    const smtk::model::Group& grp,
    DescriptivePhrases& result);
 
  void childrenOfModelAuxiliaryGeometry(
    DescriptivePhrase::Ptr src,
    const smtk::model::AuxiliaryGeometry& aux,
    DescriptivePhrases& result);
 
  void prototypeOfModelInstance(
    DescriptivePhrase::Ptr src,
    const smtk::model::Instance& ent,
    DescriptivePhrases& result);
 
  template<typename T>
  void PreparePath(T& result, const T& parentPath, int childIndex);
 
  template<typename T>
  int IndexFromTitle(const std::string& title, const T& phrases);
 
 
  template<typename T>
  PhraseListContentPtr addComponentPhrases(
    const T& components,
    DescriptivePhrase::Ptr parent,
    DescriptivePhrases& result,
    int mutability = static_cast<int>(smtk::view::PhraseContent::ContentType::TITLE) |
      static_cast<int>(smtk::view::PhraseContent::ContentType::COLOR),
    std::function<bool(const DescriptivePhrase::Ptr&, const DescriptivePhrase::Ptr&)> comparator =
      DescriptivePhrase::compareByTypeThenTitle);
 
  template<typename T>
  void filterModelEntityPhraseCandidates(T& ents);
 
  template<typename T>
  PhraseListContentPtr addModelEntityPhrases(
    const T& ents,
    DescriptivePhrase::Ptr parent,
    int limit,
    DescriptivePhrases& result,
    int mutability = static_cast<int>(smtk::view::PhraseContent::ContentType::TITLE) |
      static_cast<int>(smtk::view::PhraseContent::ContentType::COLOR),
    std::function<bool(const DescriptivePhrase::Ptr&, const DescriptivePhrase::Ptr&)> comparator =
      nullptr);
 
#if 0
 
  void propertiesOfComponent(
    DescriptivePhrase::Ptr src, const smtk::model::EntityPtr& ent, DescriptivePhrases& result);
  void floatPropertiesOfComponent(
    DescriptivePhrase::Ptr src, const smtk::model::EntityPtr& ent, DescriptivePhrases& result);
  void stringPropertiesOfComponent(
    DescriptivePhrase::Ptr src, const smtk::model::EntityPtr& ent, DescriptivePhrases& result);
  void integerPropertiesOfComponent(
    DescriptivePhrase::Ptr src, const smtk::model::EntityPtr& ent, DescriptivePhrases& result);
 
  void modelsOfModelSession(
    DescriptivePhrase::Ptr src, const SessionRef& sess, DescriptivePhrases& result);
 
  void meshesOfModelModel(DescriptivePhrase::Ptr src, const Model& mod, DescriptivePhrases& result);
  void meshsetsOfMesh(MeshPhrase::Ptr meshphr, DescriptivePhrases& result);
  void meshesOfMeshList(MeshListPhrase::Ptr src, DescriptivePhrases& result);
  void meshsetsOfCollectionByDim(
    MeshPhrase::Ptr meshphr, smtk::mesh::DimensionType dim, DescriptivePhrases& result);
 
  void addEntityProperties(smtk::resource::PropertyType ptype, std::set<std::string>& props,
    DescriptivePhrase::Ptr parent, DescriptivePhrases& result);
 
  template <typename T>
  void addMeshPhrases(
    const T& ents, DescriptivePhrase::Ptr parent, int limit, DescriptivePhrases& result);
#endif // 0
 
  int m_directLimit;
  bool m_skipAttributes;
  bool m_skipProperties;
  WeakPhraseModelPtr m_model;
  WeakManagerPtr m_manager;
};
 
} // namespace view
} // namespace smtk
 
#endif