Selection.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_Selection_h
#define smtk_view_Selection_h
 
#include "smtk/CoreExports.h"
#include "smtk/PublicPointerDefs.h"
#include "smtk/SharedFromThis.h"
 
#include "smtk/resource/Component.h"
#include "smtk/view/SelectionAction.h"
#include "smtk/view/SelectionObserver.h"
 
#include <functional>
#include <map>
#include <set>
 
namespace smtk
{
namespace view
{
 
class SMTKCORE_EXPORT Selection : smtkEnableSharedPtr(Selection)
{
public:
  using Observer = SelectionObserver;
  using Observers = SelectionObservers;
  using Component = smtk::resource::Component;
  using Object = smtk::resource::PersistentObject;
 
  smtkTypeMacroBase(Selection);
  smtkCreateMacro(Selection);
 
  Selection(const Selection&) = delete;
  Selection& operator=(const Selection&) = delete;
 
  static Ptr instance();
 
  using SelectionMap = std::map<Object::Ptr, int>;
 
  using SelectionFilter = std::function<bool(Object::Ptr, int, SelectionMap&)>;
 
  virtual ~Selection();
 
  bool registerSelectionSource(std::string name) { return m_selectionSources.insert(name).second; }
 
  bool unregisterSelectionSource(std::string name) { return (m_selectionSources.erase(name) > 0); }
 
  const std::set<std::string>& getSelectionSources() const { return m_selectionSources; }
 
  void getSelectionSources(std::set<std::string>& selectionSources) const
  {
    selectionSources = m_selectionSources;
  }
 
  bool
  registerSelectionValue(const std::string& valueLabel, int value, bool valueMustBeUnique = true);
  bool unregisterSelectionValue(const std::string& valueLabel)
  {
    return m_selectionValueLabels.erase(valueLabel) > 0;
  }
  bool unregisterSelectionValue(int value);
  const std::map<std::string, int>& selectionValueLabels() const { return m_selectionValueLabels; }
  int selectionValueFromLabel(const std::string& label) const;
  int findOrCreateLabeledValue(const std::string& label);
 
  template<typename T>
  bool modifySelection(
    const T& objects,
    const std::string& source,
    int value,
    SelectionAction action = SelectionAction::DEFAULT,
    bool bitwise = false,
    bool postponeNotification = false);
 
  bool resetSelectionBits(const std::string& source, int value);
 
  bool setDefaultAction(const SelectionAction& action);
 
  SelectionAction defaultAction() const { return m_defaultAction; }
 
  void setDefaultActionToReplace() { m_defaultAction = SelectionAction::FILTERED_REPLACE; }
 
  void setDefaultActionToAddition() { m_defaultAction = SelectionAction::FILTERED_ADD; }
 
  void setDefaultActionToSubtraction() { m_defaultAction = SelectionAction::FILTERED_SUBTRACT; }
 
  void visitSelection(std::function<void(Object::Ptr, int)> visitor)
  {
    for (const auto& entry : m_selection)
    {
      visitor(entry.first, entry.second);
    }
  }
  SelectionMap& currentSelection(SelectionMap& selection) const;
  const SelectionMap& currentSelection() const { return m_selection; }
  template<typename T>
  T& currentSelectionByValue(T& selection, int value, bool exactMatch = true) const;
  template<typename T>
  T& currentSelectionByValue(T& selection, const std::string& valueLabel, bool exactMatch = true)
    const;
 
  template<typename T>
  T currentSelectionByValueAs(int value, bool exactMatch = true) const
  {
    T result;
    return this->currentSelectionByValue(result, value, exactMatch);
  }
  template<typename T>
  T currentSelectionByValueAs(const std::string& valueLabel, bool exactMatch = true) const
  {
    T result;
    return this->currentSelectionByValue(result, valueLabel, exactMatch);
  }
 
  Observers& observers() { return m_observers; }
  const Observers& observers() const { return m_observers; }
 
  void setFilter(const SelectionFilter& fn, bool refilterSelection = true);
 
  bool configureItem(
    const std::shared_ptr<smtk::attribute::ReferenceItem>& item,
    int value,
    bool exactMatch = false,
    bool clearItem = true) const;
 
protected:
  Selection();
 
  bool performAction(
    smtk::resource::PersistentObjectPtr comp,
    int value,
    SelectionAction action,
    SelectionMap& suggested,
    bool bitwise);
  bool refilter(const std::string& source);
 
  SelectionAction m_defaultAction{ SelectionAction::FILTERED_REPLACE };
  //smtk::model::BitFlags m_modelEntityMask;
  bool m_meshSetMask;
  std::set<std::string> m_selectionSources;
  std::map<std::string, int> m_selectionValueLabels;
  SelectionMap m_selection;
  Observers m_observers;
  SelectionFilter m_filter;
};
 
template<typename T>
T& Selection::currentSelectionByValue(T& selection, int value, bool exactMatch) const
{
  if (exactMatch)
  {
    for (const auto& entry : m_selection)
    {
      if ((entry.second & value) == value)
      {
        auto entryT = std::dynamic_pointer_cast<typename T::value_type::element_type>(entry.first);
        if (entryT)
        {
          selection.insert(selection.end(), entryT);
        }
      }
    }
  }
  else
  {
    for (const auto& entry : m_selection)
    {
      if (entry.second & value)
      {
        auto entryT = std::dynamic_pointer_cast<typename T::value_type::element_type>(entry.first);
        if (entryT)
        {
          selection.insert(selection.end(), entryT);
        }
      }
    }
  }
  return selection;
}
 
template<typename T>
T& Selection::currentSelectionByValue(T& selection, const std::string& valueLabel, bool exactMatch)
  const
{
  int val = this->selectionValueFromLabel(valueLabel);
  return this->currentSelectionByValue(selection, val, exactMatch);
}
 
template<typename T>
bool Selection::modifySelection(
  const T& objects,
  const std::string& source,
  int value,
  SelectionAction action,
  bool bitwise,
  bool postponeNotification)
{
  bool modified = false;
  SelectionMap suggestions;
  if (action == SelectionAction::DEFAULT)
  {
    action = this->defaultAction();
  }
  if (
    !bitwise &&
    (action == SelectionAction::FILTERED_REPLACE || action == SelectionAction::UNFILTERED_REPLACE))
  {
    modified = !m_selection.empty();
    m_selection.clear();
  }
  else if (
    bitwise &&
    (action == SelectionAction::FILTERED_REPLACE || action == SelectionAction::UNFILTERED_REPLACE))
  {
    // Remove unmatched objects from existing selection
    int mask = ~value;
    smtk::resource::PersistentObjectSet willErase;
    for (auto& entry : m_selection)
    {
      auto it = std::find(objects.begin(), objects.end(), entry.first);
      // std::cout << "  " << entry.first->id() << "  " << (it == objects.end() ? "not in obj" : "in obj") << " " << entry.second << " " << (entry.second & mask);
      if ((it == objects.end() && ((entry.second & mask) == 0)) || value == 0)
      {
        willErase.insert(entry.first);
        // std::cout << "    erase obj\n";
      }
      else if (it == objects.end() && ((entry.second & mask) != 0))
      {
        entry.second &= mask;
        modified = true;
      }
      else
      {
        // std::cout << "    keep  obj\n";
      }
    }
    // std::cout << "---\n";
    if (!willErase.empty())
    {
      modified = true;
      for (const auto& key : willErase)
      {
        m_selection.erase(key);
      }
    }
  }
  for (const auto& object : objects)
  {
    modified |= this->performAction(object, value, action, suggestions, bitwise);
  }
  if (modified && !postponeNotification)
  {
    this->observers()(source, shared_from_this());
  }
  return modified;
}
 
} // namespace view
} // namespace smtk
 
#endif