GuiEvents.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012 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_GUIEVENTS_HH_
#define GAZEBO_GUI_GUIEVENTS_HH_

#include <string>
#include <ignition/math/Pose3.hh>
#include <ignition/math/Vector3.hh>

#include "gazebo/common/Event.hh"
#include "gazebo/msgs/msgs.hh"
#include "gazebo/util/system.hh"

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

      public: static void DisconnectCreateEntity(
                  event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { createEntity.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectMoveMode(event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { moveMode.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectManipMode(event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              {manipMode.Disconnect(_subscriber->Id());}

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

      public: static void DisconnectAlignMode(event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              {alignMode.Disconnect(_subscriber->Id());}

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

      public: static void DisconnectFullScreen(event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { fullScreen.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectShowToolbars(event::ConnectionPtr
          _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { showToolbars.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectFPS(event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { fps.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectOrbit(event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { orbit.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectKeyPress(event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { keyPress.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectLightUpdate(
                  event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { lightUpdate.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectModelUpdate(
                  event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { modelUpdate.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectInputStepSize(
              event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { inputStepSize.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectFollow(
              event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { follow.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectEditModel(
              event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { editModel.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectWindowMode(
              event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { windowMode.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectMainWindowReady(
              event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { mainWindowReady.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectLeftPaneVisibility(
              event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { leftPaneVisibility.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectScaleEntity(
              event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { scaleEntity.Disconnect(_subscriber->Id()); }

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

      public: static void DisconnectMoveEntity(
              event::ConnectionPtr _subscriber)
              GAZEBO_DEPRECATED(8.0)
              { moveEntity.Disconnect(_subscriber->Id()); }

      public: static event::EventT<void (bool)>  moveMode;

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

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

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

      public: static event::EventT<void (const msgs::Model &)> modelUpdate;

      public: static event::EventT<void (const msgs::Light &)> lightUpdate;

      public: static event::EventT<void (bool)> fullScreen;

      public: static event::EventT<void (bool)> showToolbars;

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

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

      public: static event::EventT<void (const std::string &)> follow;

      public: static event::EventT<void (const std::string &)> editModel;

      public: static event::EventT<void (const std::string &)> windowMode;

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

      public: static event::EventT<void (int)> inputStepSize;

      public: static event::EventT<void (bool)> leftPaneVisibility;

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

      public: static event::EventT<void (const std::string &,
          const ignition::math::Vector3d &)> scaleEntity;

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