ModelEditorEvents.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2013-2016 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 <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: static void DisconnectFinishModel(
            event::ConnectionPtr _subscriber)
          { finishModel.Disconnect(_subscriber); }

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

        public: static void DisconnectSaveModelEditor(
            event::ConnectionPtr _subscriber)
          { saveModelEditor.Disconnect(_subscriber); }

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

        public: static void DisconnectSaveAsModelEditor(
            event::ConnectionPtr _subscriber)
          { saveAsModelEditor.Disconnect(_subscriber); }

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

        public: static void DisconnectNewModelEditor(
              event::ConnectionPtr _subscriber)
          { newModelEditor.Disconnect(_subscriber); }

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

        public: static void DisconnectExitModelEditor(
            event::ConnectionPtr _subscriber)
          { exitModelEditor.Disconnect(_subscriber); }

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

        public: static void DisconnectModelChanged(
            event::ConnectionPtr _subscriber)
          { modelChanged.Disconnect(_subscriber); }

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

        public: static void DisconnectModelNameChanged(
            event::ConnectionPtr _subscriber)
          { modelNameChanged.Disconnect(_subscriber); }

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

        public: static void DisconnectModelPropertiesChanged(
            event::ConnectionPtr _subscriber)
          { modelPropertiesChanged.Disconnect(_subscriber); }

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

        public: static void DisconnectSaveModel(
            event::ConnectionPtr _subscriber)
          { saveModel.Disconnect(_subscriber); }

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

        public: static void DisconnectNewModel(
            event::ConnectionPtr _subscriber)
          { newModel.Disconnect(_subscriber); }

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

        public: static void DisconnectRequestNestedModelRemoval(
            event::ConnectionPtr _subscriber)
          { requestNestedModelRemoval.Disconnect(_subscriber); }

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

        public: static void DisconnectRequestNestedModelInsertion(
            event::ConnectionPtr _subscriber)
          { requestNestedModelInsertion.Disconnect(_subscriber); }

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

        public: static void DisconnectNestedModelInserted(
            event::ConnectionPtr _subscriber)
          { nestedModelInserted.Disconnect(_subscriber); }

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

        public: static void DisconnectLinkInserted(
            event::ConnectionPtr _subscriber)
          { linkInserted.Disconnect(_subscriber); }

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

        public: static void DisconnectJointInserted(
            event::ConnectionPtr _subscriber)
          { jointInserted.Disconnect(_subscriber); }

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

        public: static void DisconnectJointChanged(
            event::ConnectionPtr _subscriber)
          { jointChanged.Disconnect(_subscriber); }

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

        public: static void DisconnectNestedModelRemoved(
            event::ConnectionPtr _subscriber)
          { nestedModelRemoved.Disconnect(_subscriber); }

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

        public: static void DisconnectRequestLinkInsertion(
            event::ConnectionPtr _subscriber)
          { requestLinkInsertion.Disconnect(_subscriber); }

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

        public: static void DisconnectRequestLinkRemoval(
            event::ConnectionPtr _subscriber)
          { requestLinkRemoval.Disconnect(_subscriber); }

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

        public: static void DisconnectLinkRemoved(
            event::ConnectionPtr _subscriber)
          { linkRemoved.Disconnect(_subscriber); }

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

        public: static void DisconnectRequestJointRemoval(
            event::ConnectionPtr _subscriber)
          { requestJointRemoval.Disconnect(_subscriber); }

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

        public: static void DisconnectRequestJointInsertion(
            event::ConnectionPtr _subscriber)
          { requestJointInsertion.Disconnect(_subscriber); }

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

        public: static void DisconnectJointRemoved(
            event::ConnectionPtr _subscriber)
          { jointRemoved.Disconnect(_subscriber); }

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

        public: static void DisconnectOpenLinkInspector(
            event::ConnectionPtr _subscriber)
          { openLinkInspector.Disconnect(_subscriber); }

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

        public: static void DisconnectOpenModelPluginInspector(
            event::ConnectionPtr _subscriber)
          { openModelPluginInspector.Disconnect(_subscriber); }

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

        public: static void DisconnectOpenJointInspector(
            event::ConnectionPtr _subscriber)
          { openJointInspector.Disconnect(_subscriber); }

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

        public: static void DisconnectJointNameChanged(
            event::ConnectionPtr _subscriber)
          { jointNameChanged.Disconnect(_subscriber); }

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

        public: static void DisconnectShowLinkContextMenu(
            event::ConnectionPtr _subscriber)
          { showLinkContextMenu.Disconnect(_subscriber); }

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

        public: static void DisconnectShowJointContextMenu(
            event::ConnectionPtr _subscriber)
          { showJointContextMenu.Disconnect(_subscriber); }

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

        public: static void DisconnectShowModelPluginContextMenu(
            event::ConnectionPtr _subscriber)
          { showModelPluginContextMenu.Disconnect(_subscriber); }

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

        public: static void DisconnectSetSelectedLink(
            event::ConnectionPtr _subscriber)
          { setSelectedLink.Disconnect(_subscriber); }

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

        public: static void DisconnectSetSelectedJoint(
            event::ConnectionPtr _subscriber)
          { setSelectedJoint.Disconnect(_subscriber); }

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

        public: static void DisconnectSetSelectedModelPlugin(
            event::ConnectionPtr _subscriber)
          { setSelectedModelPlugin.Disconnect(_subscriber); }

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

        public: static void DisconnectModelPluginInserted(
            event::ConnectionPtr _subscriber)
          { modelPluginInserted.Disconnect(_subscriber); }

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

        public: static void DisconnectModelPluginRemoved(
            event::ConnectionPtr _subscriber)
          { modelPluginRemoved.Disconnect(_subscriber); }

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

        public: static void DisconnectRequestModelPluginRemoval(
            event::ConnectionPtr _subscriber)
          { requestModelPluginRemoval.Disconnect(_subscriber); }

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

        public: static void DisconnectRequestModelPluginInsertion(
            event::ConnectionPtr _subscriber)
          { requestModelPluginInsertion.Disconnect(_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)> setSelectedLink;

        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)>
            requestModelPluginRemoval;

        public: static event::EventT<void (std::string, std::string,
            std::string)> requestModelPluginInsertion;
      };
    }
  }
}
#endif