ModelEditorEvents.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2013 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_MODELEDITOREVENTS_HH_
#define GAZEBO_GUI_MODEL_MODELEDITOREVENTS_HH_

#include <map>
#include <string>
#include <sdf/sdf.hh>

#include "gazebo/common/Event.hh"

#include "gazebo/util/system.hh"

namespace gazebo
{
  namespace gui
  {
    namespace model
    {
      class GZ_GUI_VISIBLE Events
      {
        public: template<typename T>
            static event::ConnectionPtr ConnectFinishModel(T _subscriber)
          { return finishModel.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectSaveModelEditor(T _subscriber)
          { return saveModelEditor.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectSaveAsModelEditor(T _subscriber)
          { return saveAsModelEditor.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectNewModelEditor(T _subscriber)
          { return newModelEditor.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectExitModelEditor(T _subscriber)
          { return exitModelEditor.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectModelChanged(T _subscriber)
          { return modelChanged.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectModelNameChanged(T _subscriber)
          { return modelNameChanged.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr
            ConnectModelPropertiesChanged(T _subscriber)
          { return modelPropertiesChanged.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectSaveModel(T _subscriber)
          { return saveModel.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectNewModel(T _subscriber)
          { return newModel.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectRequestNestedModelRemoval(
            T _subscriber)
          { return requestNestedModelRemoval.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectRequestNestedModelInsertion(
            T _subscriber)
          { return requestNestedModelInsertion.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectRequestLinkScale(
            T _subscriber)
          { return requestLinkScale.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectRequestLinkMove(
            T _subscriber)
          { return requestLinkMove.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectRequestNestedModelMove(
            T _subscriber)
          { return requestNestedModelMove.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr
            ConnectNestedModelInserted(T _subscriber)
          { return nestedModelInserted.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectLinkInserted(T _subscriber)
          { return linkInserted.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectJointInserted(T _subscriber)
          { return jointInserted.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectJointChanged(T _subscriber)
          { return jointChanged.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectNestedModelRemoved(T _subscriber)
          { return nestedModelRemoved.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectRequestLinkInsertion(
            T _subscriber)
          { return requestLinkInsertion.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectRequestLinkRemoval(
            T _subscriber)
          { return requestLinkRemoval.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectLinkRemoved(T _subscriber)
          { return linkRemoved.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectRequestJointRemoval(
            T _subscriber)
          { return requestJointRemoval.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectRequestJointInsertion(
            T _subscriber)
          { return requestJointInsertion.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectJointRemoved(T _subscriber)
          { return jointRemoved.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectOpenLinkInspector(T _subscriber)
          { return openLinkInspector.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectOpenModelPluginInspector(
            T _subscriber)
          { return openModelPluginInspector.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectOpenJointInspector(T _subscriber)
          { return openJointInspector.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectJointNameChanged(T _subscriber)
          { return jointNameChanged.Connect(_subscriber); }

        public: template<typename T> static event::ConnectionPtr
            ConnectShowLinkContextMenu(T _subscriber)
          { return showLinkContextMenu.Connect(_subscriber); }

        public: template<typename T> static event::ConnectionPtr
            ConnectShowJointContextMenu(T _subscriber)
          { return showJointContextMenu.Connect(_subscriber); }

        public: template<typename T> static event::ConnectionPtr
            ConnectShowModelPluginContextMenu(T _subscriber)
          { return showModelPluginContextMenu.Connect(_subscriber); }

        public: template<typename T> static event::ConnectionPtr
            ConnectSetSelectedEntity(T _subscriber)
          { return setSelectedEntity.Connect(_subscriber); }

        public: template<typename T> static event::ConnectionPtr
            ConnectSetSelectedJoint(T _subscriber)
          { return setSelectedJoint.Connect(_subscriber); }

        public: template<typename T> static event::ConnectionPtr
            ConnectSetSelectedModelPlugin(T _subscriber)
          { return setSelectedModelPlugin.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectModelPluginInserted(
            T _subscriber)
          { return modelPluginInserted.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectModelPluginRemoved(
            T _subscriber)
          { return modelPluginRemoved.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectRequestModelPluginRemoval(
            T _subscriber)
          { return requestModelPluginRemoval.Connect(_subscriber); }

        public: template<typename T>
            static event::ConnectionPtr ConnectRequestModelPluginInsertion(
            T _subscriber)
          { return requestModelPluginInsertion.Connect(_subscriber); }

        public: static event::EventT<void ()> finishModel;

        public: static event::EventT<bool ()> saveModelEditor;

        public: static event::EventT<bool ()> saveAsModelEditor;

        public: static event::EventT<void ()> newModelEditor;

        public: static event::EventT<void ()> exitModelEditor;

        public: static event::EventT<void ()> modelChanged;

        public: static event::EventT<void (std::string)> modelNameChanged;

        // The properties are: is_static, auto_disable.
        public: static event::EventT<void (bool, bool)> modelPropertiesChanged;

        public: static event::EventT<void (std::string)> saveModel;

        public: static event::EventT<void ()> newModel;

        public: static event::EventT<void (std::string)> nestedModelInserted;

        public: static event::EventT<void (std::string)> linkInserted;

        public: static event::EventT<void (std::string)> nestedModelRemoved;

        public: static event::EventT<void (std::string)> linkRemoved;

        public: static event::EventT<void (sdf::ElementPtr)>
            requestLinkInsertion;

        public: static event::EventT<void (std::string)>
            requestNestedModelRemoval;

        public: static event::EventT<void (sdf::ElementPtr)>
            requestNestedModelInsertion;

        public: static event::EventT<void (std::string)> requestLinkRemoval;

        public: static event::EventT<void (std::string)> requestJointRemoval;

        public: static event::EventT<void (sdf::ElementPtr, std::string)>
            requestJointInsertion;

        public: static event::EventT<void (std::string, std::string,
            std::string, std::string, std::string)> jointInserted;

        public: static event::EventT<void (std::string)> jointRemoved;

        public: static event::EventT<void (std::string, std::string,
            std::string, std::string, std::string)> jointChanged;

        public: static event::EventT<void (std::string)> openLinkInspector;

        public: static event::EventT<void (std::string)> openJointInspector;

        public: static event::EventT<void (std::string)>
            openModelPluginInspector;

        public: static event::EventT<void (std::string, std::string)>
            jointNameChanged;

        public: static event::EventT<void (std::string)> showLinkContextMenu;

        public: static event::EventT<void (std::string)> showJointContextMenu;

        public: static event::EventT<void (std::string)>
            showModelPluginContextMenu;

        public: static event::EventT<void (std::string, bool)>
            setSelectedEntity;

        public: static event::EventT<void (std::string, bool)> setSelectedJoint;

        public: static event::EventT<void (std::string, bool)>
            setSelectedModelPlugin;

        public: static event::EventT<void (std::string)> modelPluginInserted;

        public: static event::EventT<void (std::string)> modelPluginRemoved;

        public: static event::EventT<void (std::string, bool)>
            requestModelPluginRemoval;

        public: static event::EventT<void (std::string, std::string,
            std::string, bool)> requestModelPluginInsertion;

        public: static event::EventT<void (std::string,
            std::map<std::string, ignition::math::Vector3d>)> requestLinkScale;

        public: static event::EventT<void (std::string, ignition::math::Pose3d)>
            requestLinkMove;

        public: static event::EventT<void (std::string, ignition::math::Pose3d)>
            requestNestedModelMove;
      };
    }
  }
}
#endif