ModelCreator.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2014 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
 
#ifndef GAZEBO_GUI_MODEL_MODELCREATOR_HH_
#define GAZEBO_GUI_MODEL_MODELCREATOR_HH_
 
#include <map>
#include <memory>
#include <mutex>
#include <string>
 
#include <ignition/math/Pose3.hh>
#include <ignition/math/Vector3.hh>
#include <sdf/sdf.hh>
 
#include "gazebo/gui/qt.h"
 
#include "gazebo/rendering/RenderTypes.hh"
 
#include "gazebo/util/system.hh"
 
namespace gazebo
{
  namespace common
  {
    class KeyEvent;
    class MouseEvent;
  }
 
  namespace gui
  {
    class JointMaker;
    class LinkData;
    class ModelPluginData;
    class NestedModelData;
 
    // Forward declare private data.
    class ModelCreatorPrivate;
 
 
    class GZ_GUI_VISIBLE ModelCreator : public QObject
    {
      Q_OBJECT
 
      public: enum EntityType
      {
        ENTITY_NONE,
        ENTITY_BOX,
        ENTITY_SPHERE,
        ENTITY_CYLINDER,
        ENTITY_MESH,
        ENTITY_POLYLINE,
        ENTITY_MODEL
      };
 
      public: enum SaveState
      {
        NEVER_SAVED,
 
        ALL_SAVED,
 
        UNSAVED_CHANGES
      };
 
      public: explicit ModelCreator(QObject *_parent = NULL);
 
      public: virtual ~ModelCreator();
 
      public: void EnableEventHandlers();
 
      public: void DisableEventHandlers();
 
      public: void SetModelName(const std::string &_modelName);
 
      public: std::string ModelName() const;
 
      public: void ModelChanged();
 
      public: bool SaveModelFiles();
 
      public: void FinishModel();
 
      public: void AddCustomLink(const EntityType _type,
          const ignition::math::Vector3d &_size = ignition::math::Vector3d::One,
          const ignition::math::Pose3d &_pose = ignition::math::Pose3d::Zero,
          const std::string &_uri = "", const unsigned int _samples = 5);
 
      public: LinkData *AddShape(const EntityType _type,
          const ignition::math::Vector3d &_size = ignition::math::Vector3d::One,
          const ignition::math::Pose3d &_pose = ignition::math::Pose3d::Zero,
          const std::string &_uri = "", const unsigned int _samples = 5);
 
      public: NestedModelData *AddModel(const sdf::ElementPtr &_sdf);
 
      public: void AddJoint(const std::string &_type);
 
      public: void RemoveEntity(const std::string &_entityName);
 
      public: void RemoveModelPlugin(const std::string &_pluginName,
          const bool _newCmd = true);
 
      public: void SetStatic(const bool _static);
 
      public: void SetAutoDisable(const bool _auto);
 
      public: void Reset();
 
      public: void Stop();
 
      public: gui::JointMaker *JointMaker() const;
 
      public: void SetSelected(const std::string &_name, const bool selected);
 
      public: void SetSelected(const rendering::VisualPtr &_entityVis,
          const bool selected);
 
      public: enum SaveState CurrentSaveState() const;
 
      public: void AddEntity(const sdf::ElementPtr &_sdf);
 
      public: void AddLink(const EntityType _type);
 
      public: void OnAddModelPlugin(const std::string &_name,
          const std::string &_filename, const std::string &_innerxml,
          const bool _newCmd = true);
 
      public: void AddModelPlugin(const sdf::ElementPtr &_pluginElem);
 
      public: ModelPluginData *ModelPlugin(const std::string &_name);
 
      public: void GenerateSDF();
 
      public slots: void ShowCollisions(const bool _show);
 
      public slots: void ShowVisuals(const bool _show);
 
      public slots: void ShowLinkFrames(const bool _show);
 
      public: ignition::math::Pose3d WorldToLocal(
          const ignition::math::Pose3d &_world) const;
 
      private: sdf::ElementPtr GenerateLinkSDF(LinkData *_link);
 
      private: void OnNew();
 
      private: bool OnSave();
 
      private: bool OnSaveAs();
 
      private: void OnNameChanged(const std::string &_modelName);
 
      private: void OnPropertiesChanged(const bool _static,
          const bool _autoDisable);
 
      private: void OnExit();
 
      private: void RemoveNestedModelImpl(const std::string &_nestedModelName);
 
      private: void RemoveLinkImpl(const std::string &_linkName);
 
      private slots: void OnEdit(const bool _checked);
 
      private slots: void OnEditModel(const std::string &_modelName);
 
      private slots: void OnCopy();
 
      private slots: void OnPaste();
 
      private: bool OnMousePress(const common::MouseEvent &_event);
 
      private: bool OnMouseRelease(const common::MouseEvent &_event);
 
      private: bool OnMouseMove(const common::MouseEvent &_event);
 
      private: bool OnMouseDoubleClick(const common::MouseEvent &_event);
 
      private: bool OnKeyPress(const common::KeyEvent &_event);
 
      private: void OnManipMode(const std::string &_mode);
 
      private: void OnDeselectAll(const std::string &_name,
          const std::string &_mode);
 
      private: void OnSetSelectedEntity(const std::string &_name,
          const bool _selected);
 
      private: void OnSetSelectedModelPlugin(const std::string &_name,
          const bool _selected);
 
      private: LinkData *CreateLink(const rendering::VisualPtr &_visual);
 
      private: void InsertLinkFromSDF(sdf::ElementPtr _sdf);
 
      private: void InsertNestedModelFromSDF(sdf::ElementPtr _sdf);
 
      private: NestedModelData *CloneNestedModel(const std::string &_modelName);
 
      private: LinkData *CloneLink(const std::string &_linkName);
 
      private: LinkData *CreateLinkFromSDF(const sdf::ElementPtr &_linkElem,
          const rendering::VisualPtr &_parentVis);
 
      private: void OpenInspector(const std::string &_name);
 
      private: void OpenModelPluginInspector(const std::string &_name);
 
      private: virtual void CreateTheEntity();
 
      private: bool Init();
 
      private: std::string CreateModel();
 
      private: NestedModelData *CreateModelFromSDF(const sdf::ElementPtr &_sdf,
          const rendering::VisualPtr &_parentVis = NULL,
          const bool _emit = true);
 
      private: void OnAlignMode(const std::string &_axis,
          const std::string &_config, const std::string &_target,
          const bool _preview, const bool _inverted = false);
 
      private: void OnEntityScaleChanged(const std::string &_name,
          const ignition::math::Vector3d &_scale);
 
      private: void OnEntityMoved(const std::string &_name,
          const ignition::math::Pose3d &_pose, const bool _isFinal);
 
      private: void DeselectAll();
 
      private: void DeselectAllEntities();
 
      private: void DeselectAllModelPlugins();
 
      private: void OnRequestLinkScale(const std::string &_name,
          const std::map<std::string, ignition::math::Vector3d> &_scales);
 
      private: void OnRequestLinkMove(const std::string &_name,
          const ignition::math::Pose3d &_pose);
 
      private: void OnRequestNestedModelMove(const std::string &_name,
          const ignition::math::Pose3d &_pose);
 
      private: void SetModelVisible(const std::string &_name,
          const bool _visible);
 
      private: void SetModelVisible(const rendering::VisualPtr &_visual,
          const bool _visible);
 
      private: void ShowContextMenu(const std::string &_link);
 
      private: void ShowModelPluginContextMenu(const std::string &_name);
 
      private: void EmitNestedModelInsertedEvent(
          const rendering::VisualPtr &_vis) const;
 
      private slots: void OnDelete();
 
      private slots: void OnDelete(const std::string &_name);
 
      private slots: void OnOpenInspector();
 
      private slots: void OnOpenModelPluginInspector(const QString &_name);
 
      private slots: void OnRemoveModelPlugin(const QString &_name);
 
      Q_SIGNALS: void LinkAdded();
 
      private: std::unique_ptr<ModelCreatorPrivate> dataPtr;
    };
  }
}
#endif