caf: Replace selection role with selectionLevel.

Use std::map for storage of the different selections
Started to remove the SelectionRole Enum

ApplicationCode/Commands/WellPathCommands/PointTangentManipulator/RicPointTangentManipulator.cpp

@@ -613,7 +613,7 @@ PdmUiSelectionVisualizer3d::~PdmUiSelectionVisualizer3d()
 //--------------------------------------------------------------------------------------------------
 void PdmUiSelectionVisualizer3d::onSelectionManagerSelectionChanged(int selectionLevel)
 {
-    if (selectionLevel != caf::SelectionManager::APPLICATION_GLOBAL) return;
+    if (selectionLevel != 0) return;
 
     for (auto editor: m_active3DEditors)
     {

Fwk/AppFwk/cafCommand/cafCmdSelectionChangeExec.cpp

@@ -42,20 +42,8 @@
 namespace caf
 {
 
-
-    template<>
-    void AppEnum<SelectionManager::SelectionRole>::setUp()
-    {
-        addItem(SelectionManager::APPLICATION_GLOBAL,   "APPLICATION_GLOBAL",   "APPLICATION_GLOBAL");
-        addItem(SelectionManager::CURRENT,              "CURRENT",              "CURRENT");
-        addItem(SelectionManager::UNDEFINED,            "UNDEFINED",            "UNDEFINED");
-        setDefault(SelectionManager::UNDEFINED);
-    }
-
 CAF_PDM_SOURCE_INIT(CmdSelectionChangeExecData, "CmdSelectionChangeExecData");
 
-
-
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------

Fwk/AppFwk/cafCommand/cafCmdSelectionChangeExec.h

@@ -66,7 +66,7 @@ public:
         CAF_PDM_InitField(&m_newSelection,              "newSelection",         std::vector<QString>(), "newSelection", "", "", "");
     }
 
-    PdmField< AppEnum<SelectionManager::SelectionRole> > m_selectionRole;
+    PdmField< int >                   m_selectionRole;
     PdmField< std::vector<QString> >  m_previousSelection;
     PdmField< std::vector<QString> >  m_newSelection;
 };

Fwk/AppFwk/cafProjectDataModel/cafPdmUiCore/cafPdmUiCommandSystemProxy.cpp

@@ -92,14 +92,15 @@ void PdmUiCommandSystemProxy::setUiValueToField(PdmUiFieldHandle* uiFieldHandle,
         std::vector<PdmFieldHandle*> fieldsToUpdate;
         fieldsToUpdate.push_back(editorField);
 
-        // For current selection, find all fields with same keyword
+        // For level 1 selection, find all fields with same keyword
         // Todo: Should traverse the ui ordering and find all fields with same keyword and same ownerobject type. 
-        //       Until we do, fields embedded into the proerty panel fram a different object will not work with multiselection edit
+        //       Until we do, fields embedded into the property panel from a different object will not work with multiselection edit
         //       For now we only makes sure we have same ownerobject type
         {
             std::vector<PdmUiItem*> items;
-            SelectionManager::instance()->selectedItems(items, SelectionManager::CURRENT);
+
-            //SelectionManager::instance()->selectedItems(items, SelectionManager::APPLICATION_GLOBAL);
+            int selectionLevel = 1; // = 0;
+            SelectionManager::instance()->selectedItems(items, selectionLevel);
 
             for (size_t i = 0; i < items.size(); i++)
             {

Fwk/AppFwk/cafProjectDataModel/cafPdmUiCore/cafSelectionManager.cpp

@@ -67,9 +67,13 @@ caf::NotificationCenter* SelectionManager::notificationCenter()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void SelectionManager::selectedItems(std::vector<PdmUiItem*>& items, int role /*= SelectionManager::APPLICATION_GLOBAL*/)
+void SelectionManager::selectedItems(std::vector<PdmUiItem*>& items, int selectionLevel /*= 0*/)
 {
-    std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> >& selection = m_selectionForRole[role];
+    const auto& levelSelectionPairIt = m_selectionPrLevel.find(selectionLevel);
+
+    if (levelSelectionPairIt == m_selectionPrLevel.end()) return ;
+
+    std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> >& selection = levelSelectionPairIt->second;
 
     for (size_t i = 0; i < selection.size(); i++)
     {
@@ -83,9 +87,9 @@ void SelectionManager::selectedItems(std::vector<PdmUiItem*>& items, int role /*
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void SelectionManager::setSelectedItems(const std::vector<PdmUiItem*>& items, int role /*= SelectionManager::APPLICATION_GLOBAL*/)
+void SelectionManager::setSelectedItems(const std::vector<PdmUiItem*>& items, int selectionLevel /*= 0*/)
 {
-    std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> >& selection = m_selectionForRole[role];
+    std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> >& selection = m_selectionPrLevel[selectionLevel];
     std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> > newSelection;
 
     for (size_t i = 0; i < items.size(); i++)
@@ -110,16 +114,19 @@ void SelectionManager::setSelectedItems(const std::vector<PdmUiItem*>& items, in
     if (newSelection != selection)
     {
         selection = newSelection;
-        notifySelectionChanged(role);
+        notifySelectionChanged(selectionLevel);
     }
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-PdmUiItem* SelectionManager::selectedItem(int role /*= SelectionManager::APPLICATION_GLOBAL*/)
+PdmUiItem* SelectionManager::selectedItem(int selectionLevel /*= 0*/)
 {
-    std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> >& selection = m_selectionForRole[role];
+    const auto& levelSelectionPairIt = m_selectionPrLevel.find(selectionLevel);
+    if (levelSelectionPairIt == m_selectionPrLevel.end()) return nullptr;
+     
+    std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> >& selection = levelSelectionPairIt->second;
 
     if (selection.size() == 1)
     {
@@ -135,12 +142,12 @@ PdmUiItem* SelectionManager::selectedItem(int role /*= SelectionManager::APPLICA
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void SelectionManager::setSelectedItem(PdmUiItem* item, int role /*= SelectionManager::APPLICATION_GLOBAL*/)
+void SelectionManager::setSelectedItem(PdmUiItem* item, int selectionLevel /*= 0*/)
 {
     std::vector<PdmUiItem*> singleSelection;
     singleSelection.push_back(item);
 
-    setSelectedItems(singleSelection, role);
+    setSelectedItems(singleSelection, selectionLevel);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -148,18 +155,19 @@ void SelectionManager::setSelectedItem(PdmUiItem* item, int role /*= SelectionMa
 //--------------------------------------------------------------------------------------------------
 SelectionManager::SelectionManager()
 {
-    m_selectionForRole.resize(UNDEFINED);
-
     m_activeChildArrayFieldHandle = nullptr;
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void SelectionManager::selectionAsReferences(std::vector<QString>& referenceList, int role) const
+void SelectionManager::selectionAsReferences(std::vector<QString>& referenceList, int selectionLevel /*= 0*/) const
 {
-//    const std::vector<PdmUiItem*>& selection = m_selectionForRole[role];
+    const auto& levelSelectionPairIt = m_selectionPrLevel.find(selectionLevel);
-    const std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> >& selection = m_selectionForRole[role];
+
+    if (levelSelectionPairIt == m_selectionPrLevel.end()) return;
+
+    const std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> >& selection = levelSelectionPairIt->second;
 
     for (size_t i = 0; i < selection.size(); i++)
     {
@@ -179,7 +187,7 @@ void SelectionManager::selectionAsReferences(std::vector<QString>& referenceList
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void SelectionManager::setSelectionFromReferences(const std::vector<QString>& referenceList, int role)
+void SelectionManager::setSelectionFromReferences(const std::vector<QString>& referenceList, int selectionLevel /*= 0*/)
 {
     std::vector<PdmUiItem*> uiItems;
 
@@ -198,7 +206,7 @@ void SelectionManager::setSelectionFromReferences(const std::vector<QString>& re
         }
     }
 
-    setSelectedItems(uiItems, role);
+    setSelectedItems(uiItems, selectionLevel);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -208,15 +216,17 @@ void SelectionManager::clearAll()
 {
     std::set<int> changedSelectionLevels;
 
-    for (size_t i = 0; i < m_selectionForRole.size(); i++)
+    for ( auto & levelSelectionPair :  m_selectionPrLevel)
     {
-        if ( m_selectionForRole[i].size())
+        if ( !levelSelectionPair.second.empty())
         {
-            m_selectionForRole[i].clear();
+            levelSelectionPair.second.clear();
-            changedSelectionLevels.insert((int)i);
+            changedSelectionLevels.insert(levelSelectionPair.first);
         }
     }
     
+    m_selectionPrLevel.clear();
+
     for (int level: changedSelectionLevels)
     {
         notifySelectionChanged(level); 
@@ -227,13 +237,17 @@ void SelectionManager::clearAll()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void SelectionManager::clear(int role)
+void SelectionManager::clear(int selectionLevel)
 {
-    if ( m_selectionForRole[role].size() )
+    const auto& levelSelectionPairIt = m_selectionPrLevel.find(selectionLevel);
-    {
-        m_selectionForRole[role].clear();
 
-        notifySelectionChanged(role);
+    if (levelSelectionPairIt == m_selectionPrLevel.end()) return;
+
+    if ( !levelSelectionPairIt->second.empty() )
+    {
+        m_selectionPrLevel[selectionLevel].clear();
+
+        notifySelectionChanged(selectionLevel);
     }
 }
 
@@ -253,12 +267,11 @@ void SelectionManager::notifySelectionChanged( int selectionLevel)
 //--------------------------------------------------------------------------------------------------
 void SelectionManager::removeObjectFromAllSelections(PdmObjectHandle* pdmObject)
 {
-    bool doNotifySelectionChanged = false;
     std::set<int> changedSelectionLevels;
 
-    for (size_t role = 0; role < m_selectionForRole.size(); role++)
+    for ( auto & levelSelectionPair :  m_selectionPrLevel)
     {
-        std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> >& selection = m_selectionForRole[role];
+        std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> >& selection = levelSelectionPair.second;
 
         std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> >::iterator iter = selection.begin();
         while (iter != selection.end())
@@ -270,7 +283,7 @@ void SelectionManager::removeObjectFromAllSelections(PdmObjectHandle* pdmObject)
                 {
                     iter = selection.erase(iter);
 
-                    changedSelectionLevels.insert((int)role);
+                    changedSelectionLevels.insert(levelSelectionPair.first);
                 }
                 else
                 {

Fwk/AppFwk/cafProjectDataModel/cafPdmUiCore/cafSelectionManager.h

@@ -59,10 +59,10 @@ class SelectionManager
 public:
     enum SelectionRole 
     {                       // Suggested renaming:
-        APPLICATION_GLOBAL, // FIRST_LEVEL
+        BASE_LEVEL, // BASE_LEVEL = 0,
-        CURRENT,            // SECOND_LEVEL
+        CURRENT,            // FIRST_LEVEL = 1,
-                            // THIRD_LEVEL
+                            // SECOND_LEVEL = 2,
-                            UNDEFINED
+                            UNDEFINED = -1
     };
 
 public:
@@ -77,24 +77,24 @@ public:
     void                      setPdmRootObject(PdmObjectHandle* root);
     PdmObjectHandle*          pdmRootObject() { return m_rootObject; }
 
-    PdmUiItem*                selectedItem(int role = SelectionManager::APPLICATION_GLOBAL);
+    PdmUiItem*                selectedItem(int selectionLevel = 0);
-    void                      setSelectedItem(PdmUiItem* item, int role = SelectionManager::APPLICATION_GLOBAL);
+    void                      setSelectedItem(PdmUiItem* item, int selectionLevel = 0);
 
-    void                      selectedItems(std::vector<PdmUiItem*>& items, int role = SelectionManager::APPLICATION_GLOBAL);
+    void                      selectedItems(std::vector<PdmUiItem*>& items, int selectionLevel = 0);
-    void                      setSelectedItems(const std::vector<PdmUiItem*>& items, int role = SelectionManager::APPLICATION_GLOBAL);
+    void                      setSelectedItems(const std::vector<PdmUiItem*>& items, int selectionLevel = 0);
 
-    void                      selectionAsReferences(std::vector<QString>& referenceList, int role = SelectionManager::APPLICATION_GLOBAL) const;
+    void                      selectionAsReferences(std::vector<QString>& referenceList, int selectionLevel = 0) const;
-    void                      setSelectionFromReferences(const std::vector<QString>& referenceList, int role = SelectionManager::APPLICATION_GLOBAL);
+    void                      setSelectionFromReferences(const std::vector<QString>& referenceList, int selectionLevel = 0);
 
     void                      clearAll();
-    void                      clear(int role);
+    void                      clear(int selectionLevel);
     void                      removeObjectFromAllSelections(PdmObjectHandle* pdmObject);
 
     template <typename T>
-    void objectsByType(std::vector<T*>* typedObjects, int role = SelectionManager::APPLICATION_GLOBAL)
+    void objectsByType(std::vector<T*>* typedObjects, int selectionLevel = 0)
     {
         std::vector<PdmUiItem*> items;
-        this->selectedItems(items, role);
+        this->selectedItems(items, selectionLevel);
         for (size_t i = 0; i < items.size(); i++)
         {
             T* obj = dynamic_cast<T*>(items[i]);
@@ -105,10 +105,10 @@ public:
     /// Returns the selected objects of the requested type if _all_ the selected objects are of the requested type
 
     template <typename T>
-    void objectsByTypeStrict(std::vector<T*>* typedObjects, int role = SelectionManager::APPLICATION_GLOBAL)
+    void objectsByTypeStrict(std::vector<T*>* typedObjects, int selectionLevel = 0)
     {
         std::vector<PdmUiItem*> items;
-        this->selectedItems(items, role);
+        this->selectedItems(items, selectionLevel);
         for (size_t i = 0; i < items.size(); i++)
         {
             T* obj = dynamic_cast<T*>(items[i]);
@@ -131,7 +131,7 @@ private:
     void unregisterSelectionChangedReceiver( SelectionChangedReceiver* receiver) { m_selectionReceivers.erase(receiver);}
 
 private:
-    std::vector < std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> > > m_selectionForRole;
+    std::map <int,  std::vector< std::pair<PdmPointer<PdmObjectHandle>, PdmUiItem*> > >  m_selectionPrLevel;
 
     PdmChildArrayFieldHandle*   m_activeChildArrayFieldHandle;
     PdmPointer<PdmObjectHandle> m_rootObject;