notify other GUI plugins of added/removed entities via GUI events

include/ignition/gazebo/gui/GuiEvents.hh

@@ -18,6 +18,7 @@
 #define IGNITION_GAZEBO_GUI_GUIEVENTS_HH_
 
 #include <QEvent>
+#include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ -99,6 +100,41 @@ namespace events
     private: bool fromUser{false};
   };
 
+  /// \brief Event that contains newly created and removed entities
+  class AddedRemovedEntities : public QEvent
+  {
+    /// \brief Constructor
+    /// \param[in] _newEntities Set of newly created entities
+    /// \param[in] _removedEntities Set of recently removed entities
+    public: AddedRemovedEntities(const std::set<Entity> &_newEntities,
+                const std::set<Entity> &_removedEntities)
+        : QEvent(kType), newEntities(_newEntities),
+          removedEntities(_removedEntities)
+    {
+    }
+
+    /// \brief Get the set of newly created entities
+    public: const std::set<Entity> &NewEntities() const
+    {
+      return this->newEntities;
+    }
+
+    /// \brief Get the set of recently removed entities
+    public: const std::set<Entity> &RemovedEntities() const
+    {
+      return this->removedEntities;
+    }
+
+    /// \brief Unique type for this event.
+    static const QEvent::Type kType = QEvent::Type(QEvent::User + 3);
+
+    /// \brief Set of newly created entities
+    private: std::set<Entity> newEntities;
+
+    /// \brief Set of recently removed entities
+    private: std::set<Entity> removedEntities;
+  };
+
   /// \brief True if a transform control is currently active (translate /
   /// rotate / scale). False if we're in selection mode.
   class TransformControlModeActive : public QEvent

src/gui/plugins/entity_tree/EntityTree.cc

@@ -18,6 +18,8 @@
 #include "EntityTree.hh"
 
 #include <iostream>
+#include <mutex>
+#include <set>
 #include <vector>
 
 #include <ignition/common/Console.hh>
@@ -54,6 +56,16 @@ namespace ignition::gazebo
 
     /// \brief World entity
     public: Entity worldEntity{kNullEntity};
+
+    /// \brief List of new entities from a gui event
+    public: std::set<Entity> newEntities;
+
+    /// \brief List of removed entities from a gui event
+    public: std::set<Entity> removedEntities;
+
+    /// \brief Mutex to protect gui event and system upate call race conditions
+    /// for newEntities and removedEntities
+    public: std::mutex newRemovedEntityMutex;
   };
 }
 
@@ -100,11 +112,12 @@ QString entityType(Entity _entity,
 /////////////////////////////////////////////////
 TreeModel::TreeModel() : QStandardItemModel()
 {
+  qRegisterMetaType<Entity>("Entity");
 }
 
 /////////////////////////////////////////////////
-void TreeModel::AddEntity(unsigned int _entity, const QString &_entityName,
-    unsigned int _parentEntity, const QString &_type)
+void TreeModel::AddEntity(Entity _entity, const QString &_entityName,
+    Entity _parentEntity, const QString &_type)
 {
   IGN_PROFILE_THREAD_NAME("Qt thread");
   IGN_PROFILE("TreeModel::AddEntity");
@@ -165,7 +178,7 @@ void TreeModel::AddEntity(unsigned int _entity, const QString &_entityName,
 }
 
 /////////////////////////////////////////////////
-void TreeModel::RemoveEntity(unsigned int _entity)
+void TreeModel::RemoveEntity(Entity _entity)
 {
   IGN_PROFILE("TreeModel::RemoveEntity");
   QStandardItem *item{nullptr};
@@ -247,7 +260,7 @@ QString TreeModel::ScopedName(const QModelIndex &_index) const
 }
 
 /////////////////////////////////////////////////
-unsigned int TreeModel::EntityId(const QModelIndex &_index) const
+Entity TreeModel::EntityId(const QModelIndex &_index) const
 {
   Entity entity{kNullEntity};
   QStandardItem *item = this->itemFromIndex(_index);
@@ -329,9 +342,9 @@ void EntityTree::Update(const UpdateInfo &, EntityComponentManager &_ecm)
 
       QMetaObject::invokeMethod(&this->dataPtr->treeModel, "AddEntity",
           Qt::QueuedConnection,
-          Q_ARG(unsigned int, _entity),
+          Q_ARG(Entity, _entity),
           Q_ARG(QString, QString::fromStdString(_name->Data())),
-          Q_ARG(unsigned int, parentEntity),
+          Q_ARG(Entity, parentEntity),
           Q_ARG(QString, entityType(_entity, _ecm)));
       return true;
     });
@@ -359,9 +372,9 @@ void EntityTree::Update(const UpdateInfo &, EntityComponentManager &_ecm)
 
       QMetaObject::invokeMethod(&this->dataPtr->treeModel, "AddEntity",
           Qt::QueuedConnection,
-          Q_ARG(unsigned int, _entity),
+          Q_ARG(Entity, _entity),
           Q_ARG(QString, QString::fromStdString(_name->Data())),
-          Q_ARG(unsigned int, parentEntity),
+          Q_ARG(Entity, parentEntity),
           Q_ARG(QString, entityType(_entity, _ecm)));
       return true;
     });
@@ -373,13 +386,62 @@ void EntityTree::Update(const UpdateInfo &, EntityComponentManager &_ecm)
   {
     QMetaObject::invokeMethod(&this->dataPtr->treeModel, "RemoveEntity",
         Qt::QueuedConnection,
-        Q_ARG(unsigned int, _entity));
+        Q_ARG(Entity, _entity));
     return true;
   });
+
+  {
+    // update the entity tree with new/removed entities from gui events
+    std::lock_guard<std::mutex> lock(this->dataPtr->newRemovedEntityMutex);
+
+    for (auto entity : this->dataPtr->newEntities)
+    {
+      // make sure the entity to be added has a name and parent
+      auto nameComp = _ecm.Component<components::Name>(entity);
+      if (!nameComp)
+      {
+        ignerr << "Could not add entity [" << entity << "] to the entity tree "
+               << "because it does not have a name component.\n";
+        continue;
+      }
+      auto parentComp = _ecm.Component<components::ParentEntity>(entity);
+      if (!parentComp)
+      {
+        ignerr << "Could not add entity [" << entity << "] to the entity tree "
+               << "because it does not have a parent entity component.\n";
+        continue;
+      }
+
+      // World children are top-level
+      auto parentEntity = parentComp->Data();
+      if (this->dataPtr->worldEntity != kNullEntity &&
+          parentEntity == this->dataPtr->worldEntity)
+      {
+        parentEntity = kNullEntity;
+      }
+
+      QMetaObject::invokeMethod(&this->dataPtr->treeModel, "AddEntity",
+          Qt::QueuedConnection,
+          Q_ARG(Entity, entity),
+          Q_ARG(QString, QString::fromStdString(nameComp->Data())),
+          Q_ARG(Entity, parentEntity),
+          Q_ARG(QString, entityType(entity, _ecm)));
+    }
+
+    for (auto entity : this->dataPtr->removedEntities)
+    {
+      QMetaObject::invokeMethod(&this->dataPtr->treeModel, "RemoveEntity",
+          Qt::QueuedConnection,
+          Q_ARG(Entity, entity));
+    }
+
+    this->dataPtr->newEntities.clear();
+    this->dataPtr->removedEntities.clear();
+  }
 }
 
 /////////////////////////////////////////////////
-void EntityTree::OnEntitySelectedFromQml(unsigned int _entity)
+void EntityTree::OnEntitySelectedFromQml(Entity _entity)
 {
   std::vector<Entity> entitySet {_entity};
   gui::events::EntitiesSelected event(entitySet, true);
@@ -413,7 +475,7 @@ bool EntityTree::eventFilter(QObject *_obj, QEvent *_event)
 
         QMetaObject::invokeMethod(this->PluginItem(), "onEntitySelectedFromCpp",
             Qt::QueuedConnection, Q_ARG(QVariant,
-            QVariant(static_cast<unsigned int>(entity))));
+            QVariant(static_cast<qulonglong>(entity))));
       }
     }
   }
@@ -428,6 +490,21 @@ bool EntityTree::eventFilter(QObject *_obj, QEvent *_event)
           Qt::QueuedConnection);
     }
   }
+  else if (_event->type() ==
+           ignition::gazebo::gui::events::AddedRemovedEntities::kType)
+  {
+    std::lock_guard<std::mutex> lock(this->dataPtr->newRemovedEntityMutex);
+    auto addedRemovedEvent =
+        reinterpret_cast<gui::events::AddedRemovedEntities *>(_event);
+    if (addedRemovedEvent)
+    {
+      for (auto entity : addedRemovedEvent->NewEntities())
+        this->dataPtr->newEntities.insert(entity);
+
+      for (auto entity : addedRemovedEvent->RemovedEntities())
+        this->dataPtr->removedEntities.insert(entity);
+    }
+  }
 
   // Standard event processing
   return QObject::eventFilter(_obj, _event);

src/gui/plugins/entity_tree/EntityTree.hh

@@ -22,6 +22,7 @@
 #include <memory>
 #include <vector>
 
+#include <ignition/gazebo/Entity.hh>
 #include <ignition/gazebo/gui/GuiSystem.hh>
 
 namespace ignition
@@ -50,14 +51,14 @@ namespace gazebo
     /// \param[in] _parentEntity Parent entity. By default, kNullEntity, which
     /// means it's a root entity.
     /// \param[in] _type Entity type
-    public slots: void AddEntity(unsigned int _entity,
+    public slots: void AddEntity(Entity _entity,
         const QString &_entityName,
-        unsigned int _parentEntity = kNullEntity,
+        Entity _parentEntity = kNullEntity,
         const QString &_type = QString());
 
     /// \brief Remove an entity from the tree.
     /// \param[in] _entity Entity to be removed
-    public slots: void RemoveEntity(unsigned int _entity);
+    public slots: void RemoveEntity(Entity _entity);
 
     /// \brief Get the entity type of a tree item at specified index
     /// \param[in] _index Model index
@@ -72,7 +73,7 @@ namespace gazebo
     /// \brief Get the entity ID of a tree item at specified index
     /// \param[in] _index Model index
     /// \return Entity ID
-    public: Q_INVOKABLE unsigned int EntityId(const QModelIndex &_index) const;
+    public: Q_INVOKABLE Entity EntityId(const QModelIndex &_index) const;
 
     /// \brief Keep track of which item corresponds to which entity.
     private: std::map<Entity, QStandardItem *> entityItems;
@@ -82,14 +83,14 @@ namespace gazebo
     {
       /// \brief Entity ID
       // cppcheck-suppress unusedStructMember
-      unsigned int entity;
+      Entity entity;
 
       /// \brief Entity name
       QString name;
 
       /// \brief Parent ID
       // cppcheck-suppress unusedStructMember
-      unsigned int parentEntity;
+      Entity parentEntity;
 
       /// \brief Entity type
       QString type;
@@ -123,7 +124,7 @@ namespace gazebo
     /// \brief Callback when an entity has been selected. This should be
     /// called from QML.
     /// \param[in] _entity Entity being selected.
-    public: Q_INVOKABLE void OnEntitySelectedFromQml(unsigned int _entity);
+    public: Q_INVOKABLE void OnEntitySelectedFromQml(Entity _entity);
 
     /// \brief Callback when all entities have been deselected.
     /// This should be called from QML.