gz/gui/GuiEvents.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2020 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 GZ_GUI_GUIEVENTS_HH_
#define GZ_GUI_GUIEVENTS_HH_
 
#include <QEvent>
#include <string>
#include <utility>
#include <vector>
#include <gz/math/Vector3.hh>
 
namespace ignition
{
  namespace gui
  {
    namespace events
    {
 
      class Render : public QEvent
      {
        public: Render()
            : QEvent(kType)
        {
        }
        static const QEvent::Type kType = QEvent::Type(QEvent::MaxUser);
      };
 
      class SnapIntervals : public QEvent
      {
        public: SnapIntervals(
                    const math::Vector3d &_xyz,
                    const math::Vector3d &_rpy,
                    const math::Vector3d &_scale)
        : QEvent(kType), xyz(_xyz), rpy(_rpy), scale(_scale)
        {
        }
 
        public: math::Vector3d Position() const
        {
          return this->xyz;
        }
 
        public: math::Vector3d Rotation() const
        {
          return this->rpy;
        }
 
        public: math::Vector3d Scale() const
        {
          return this->scale;
        }
 
        static const QEvent::Type kType = QEvent::Type(QEvent::MaxUser - 1);
 
        private: math::Vector3d xyz;
 
        private: math::Vector3d rpy;
 
        private: math::Vector3d scale;
      };
 
      class SpawnFromDescription : public QEvent
      {
        public: explicit SpawnFromDescription(const std::string &_description)
            : QEvent(kType), description(_description)
        {
        }
 
        static const QEvent::Type kType = QEvent::Type(QEvent::MaxUser - 2);
 
        public: const std::string &Description() const
        {
          return this->description;
        }
 
        std::string description;
      };
 
      class SpawnFromPath : public QEvent
      {
        public: explicit SpawnFromPath(const std::string &_filePath)
            : QEvent(kType), filePath(_filePath)
        {
        }
 
        static const QEvent::Type kType = QEvent::Type(QEvent::MaxUser - 3);
 
        public: const std::string &FilePath() const
        {
          return this->filePath;
        }
 
        std::string filePath;
      };
 
      class HoverToScene : public QEvent
      {
        public: explicit HoverToScene(const math::Vector3d &_point)
            : QEvent(kType), point(_point)
        {
        }
 
        static const QEvent::Type kType = QEvent::Type(QEvent::MaxUser - 4);
 
        public: math::Vector3d Point() const
        {
          return this->point;
        }
 
        private: math::Vector3d point;
      };
 
      class LeftClickToScene : public QEvent
      {
        public: explicit LeftClickToScene(const math::Vector3d &_point)
            : QEvent(kType), point(_point)
        {
        }
 
        static const QEvent::Type kType = QEvent::Type(QEvent::MaxUser - 5);
 
        public: math::Vector3d Point() const
        {
          return this->point;
        }
 
        private: math::Vector3d point;
      };
 
      class RightClickToScene : public QEvent
      {
        public: explicit RightClickToScene(const math::Vector3d &_point)
            : QEvent(kType), point(_point)
        {
        }
 
        static const QEvent::Type kType = QEvent::Type(QEvent::MaxUser - 6);
 
        public: math::Vector3d Point() const
        {
          return this->point;
        }
 
        private: math::Vector3d point;
      };
 
      class DropdownMenuEnabled : public QEvent
      {
        public: explicit DropdownMenuEnabled(bool _menuEnabled)
            : QEvent(kType), menuEnabled(_menuEnabled)
        {
        }
 
        static const QEvent::Type kType = QEvent::Type(QEvent::MaxUser - 7);
 
        public: bool MenuEnabled() const
        {
          return this->menuEnabled;
        }
 
        private: bool menuEnabled;
      };
    }
  }
}
 
#endif  // GZ_GUI_GUIEVENTS_HH_