ConfigWidget.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_CONFIGWIDGET_HH_
#define _GAZEBO_GUI_CONFIGWIDGET_HH_

#include <map>
#include <memory>
#include <string>
#include <vector>

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

#include "gazebo/gui/qt.h"
#include "gazebo/util/system.hh"

namespace google
{
  namespace protobuf
  {
    class Message;
    class Reflection;
    class FieldDescriptor;
  }
}

namespace gazebo
{
  namespace gui
  {
    class ConfigWidgetPrivate;
    class GroupWidget;


    class GZ_GUI_VISIBLE ConfigChildWidget : public QFrame
    {
      Q_OBJECT

      public: ConfigChildWidget() : groupWidget(NULL) {}

      public: std::string key;

      public: std::string scopedName;

      public: std::vector<QWidget *> widgets;

      public: std::map<QWidget *, QLabel *> mapWidgetToUnit;

      public: GroupWidget *groupWidget;
    };

    class GZ_GUI_VISIBLE GeometryConfigWidget : public ConfigChildWidget
    {
      Q_OBJECT

      public: QStackedWidget *geomDimensionWidget;

      public: QWidget *geomLengthSpinBox;

      public: QWidget *geomLengthLabel;

      public: QWidget *geomLengthUnitLabel;

      public: QWidget *geomFilenameLineEdit;

      public: QWidget *geomFilenameLabel;

      public: QWidget *geomFilenameButton;

      private slots: void OnGeometryTypeChanged(const QString &_text);

      private slots: void OnGeometrySizeChanged(const double _value);

      private slots: void OnSelectFile();

      Q_SIGNALS: void GeometryChanged();
    };

    class GZ_GUI_VISIBLE DensityConfigWidget : public ConfigChildWidget
    {
      Q_OBJECT

      public: DensityConfigWidget();

      public: void SetDensity(const double _density);

      public: double Density() const;

      private slots: void OnComboBoxChanged(const QString &_text);

      private slots: void OnSpinBoxChanged(const QString &_text);

      Q_SIGNALS: void DensityValueChanged(const double &_value);

      public: QComboBox *comboBox;

      public: QDoubleSpinBox *spinBox;

      private: double density;
    };

    class GZ_GUI_VISIBLE EnumConfigWidget : public ConfigChildWidget
    {
      Q_OBJECT

      Q_SIGNALS: void EnumValueChanged(const QString &_value);

      private slots: void EnumChanged(const QString &_value);
    };

    class GZ_GUI_VISIBLE GroupWidget : public QWidget
    {
      Q_OBJECT

      public: QWidget *childWidget;

      private slots: void Toggle(bool _checked);
    };

    class GZ_GUI_VISIBLE ConfigWidget : public QWidget
    {
      Q_OBJECT

      public: ConfigWidget();

      public: ~ConfigWidget();

      public: void Load(const google::protobuf::Message *_msg);

      public: google::protobuf::Message *Msg();

      public: static std::string HumanReadableKey(const std::string &_key);

      public: std::string UnitFromKey(const std::string &_key,
          const std::string &_jointType = "") const;

      public: void RangeFromKey(const std::string &_key,
          double &_min, double &_max) const;

      public: void SetWidgetVisible(const std::string &_name, bool _visible);

      public: bool WidgetVisible(const std::string &_name) const;

      public: void SetWidgetReadOnly(const std::string &_name, bool _readOnly);

      public: bool WidgetReadOnly(const std::string &_name) const;

      public: void UpdateFromMsg(const google::protobuf::Message *_msg);

      public: bool SetIntWidgetValue(const std::string &_name, int _value);

      public: bool SetUIntWidgetValue(const std::string &_name, unsigned int
          _value);

      public: bool SetDoubleWidgetValue(const std::string &_name,
          double _value);

      public: bool SetBoolWidgetValue(const std::string &_name, bool _value);

      public: bool SetStringWidgetValue(const std::string &_name,
          const std::string &_value);

      public: bool SetVector3dWidgetValue(const std::string &_name,
          const ignition::math::Vector3d &_value);

      public: bool SetColorWidgetValue(const std::string &_name,
          const ignition::math::Color &_value);

      public: bool SetPoseWidgetValue(const std::string &_name,
          const ignition::math::Pose3d &_value);

      public: bool SetGeometryWidgetValue(const std::string &_name,
          const std::string &_value,
          const ignition::math::Vector3d &_dimensions,
          const std::string &_uri = "");

      public: bool SetDensityWidgetValue(const std::string &_name,
          const double _value);

      public: bool SetEnumWidgetValue(const std::string &_name,
          const std::string &_value);

      public: bool AddItemEnumWidget(const std::string &_name,
          const std::string &_itemText);

      public: bool RemoveItemEnumWidget(const std::string &_name,
          const std::string &_itemText);

      public: bool ClearEnumWidget(const std::string &_name);

      public: int IntWidgetValue(const std::string &_name) const;

      public: unsigned int UIntWidgetValue(const std::string &_name) const;

      public: double DoubleWidgetValue(const std::string &_name) const;

      public: bool BoolWidgetValue(const std::string &_name) const;

      public: std::string StringWidgetValue(const std::string &_name) const;

      public: ignition::math::Vector3d Vector3dWidgetValue(
          const std::string &_name) const;

      public: ignition::math::Color ColorWidgetValue(
          const std::string &_name) const;

      public: ignition::math::Pose3d PoseWidgetValue(
          const std::string &_name) const;

      public: std::string GeometryWidgetValue(const std::string &_name,
          ignition::math::Vector3d &_dimensions, std::string &_uri) const;

      public: double DensityWidgetValue(const std::string &_name) const;

      public: std::string EnumWidgetValue(const std::string &_name) const;

      public: GroupWidget *CreateGroupWidget(const std::string &_name,
          ConfigChildWidget *_childWidget, const int _level = 0);

      public: ConfigChildWidget *CreateUIntWidget(const std::string &_key,
          const int _level = 0);

      public: ConfigChildWidget *CreateIntWidget(const std::string &_key,
          const int _level = 0);

      public: ConfigChildWidget *CreateDoubleWidget(const std::string &_key,
          const int _level = 0);

      public: ConfigChildWidget *CreateStringWidget(const std::string &_key,
          const int _level = 0, const std::string &_type = "line");

      public: ConfigChildWidget *CreateBoolWidget(const std::string &_key,
          const int _level = 0);

      public: ConfigChildWidget *CreateVector3dWidget(const std::string &_key,
          const int _level = 0);

      public: ConfigChildWidget *CreateColorWidget(const std::string &_key,
          const int _level = 0);

      public: ConfigChildWidget *CreatePoseWidget(const std::string &_key,
          const int _level = 0);

      public: ConfigChildWidget *CreateGeometryWidget(const std::string &_key,
          const int _level = 0);

      public: ConfigChildWidget *CreateEnumWidget(const std::string &_key,
          const std::vector<std::string> &_values, const int _level = 0);

      public: ConfigChildWidget *CreateDensityWidget(const std::string &_key,
          const int _level = 0);

      public: bool AddConfigChildWidget(const std::string &_name,
          ConfigChildWidget *_child);

      public: void InsertLayout(QLayout *_layout, int _pos);

      public: ConfigChildWidget *ConfigChildWidgetByName(
          const std::string &_name) const;

      public: unsigned int ConfigChildWidgetCount() const;

      public: static QString StyleSheet(const std::string &_type,
          const int _level = 0);

      public: static const std::vector<QString> bgColors;

      public: static const std::vector<QString> widgetColors;

      public: static const QString redColor;

      public: static const QString greenColor;

      public: static const QString blueColor;

      private: QWidget *Parse(google::protobuf::Message *_msg,
          bool _update = false, const std::string &_name = "",
          const int _level = 0);

      private: ignition::math::Vector3d ParseVector3d(
          const google::protobuf::Message *_msg) const;

      private: void UpdateMsg(google::protobuf::Message *_msg,
          const std::string &_name = "");

      private: void UpdateVector3dMsg(google::protobuf::Message *_msg,
          const ignition::math::Vector3d &_value);

      private: bool UpdateUIntWidget(ConfigChildWidget *_widget,
          const unsigned int _value);

      private: bool UpdateIntWidget(ConfigChildWidget *_widget,
           const int _value);

      private: bool UpdateDoubleWidget(ConfigChildWidget *_widget,
          const double _value);

      private: bool UpdateStringWidget(ConfigChildWidget *_widget,
          const std::string &_value);

      private: bool UpdateBoolWidget(ConfigChildWidget *_widget,
          const bool _value);

      private: bool UpdateVector3dWidget(ConfigChildWidget *_widget,
          const ignition::math::Vector3d &_value);

      private: bool UpdateColorWidget(ConfigChildWidget *_widget,
          const ignition::math::Color &_value);

      private: bool UpdatePoseWidget(ConfigChildWidget *_widget,
          const ignition::math::Pose3d &_value);

      private: bool UpdateGeometryWidget(ConfigChildWidget *_widget,
          const std::string &_value,
          const ignition::math::Vector3d &_dimensions,
          const std::string &_uri = "");

      private: bool UpdateEnumWidget(ConfigChildWidget *_widget,
          const std::string &_value);

      private: bool UpdateDensityWidget(ConfigChildWidget *_widget,
          const double _value);

      private: int IntWidgetValue(ConfigChildWidget *_widget) const;

      private: unsigned int UIntWidgetValue(ConfigChildWidget *_widget) const;

      private: double DoubleWidgetValue(ConfigChildWidget *_widget) const;

      private: bool BoolWidgetValue(ConfigChildWidget *_widget) const;

      private: std::string StringWidgetValue(ConfigChildWidget *_widget) const;

      private: ignition::math::Vector3d Vector3dWidgetValue(
          ConfigChildWidget *_widget) const;

      private: ignition::math::Color ColorWidgetValue(
          ConfigChildWidget *_widget) const;

      private: ignition::math::Pose3d PoseWidgetValue(
          ConfigChildWidget *_widget) const;

      private: std::string GeometryWidgetValue(ConfigChildWidget *_widget,
          ignition::math::Vector3d &_dimensions, std::string &_uri) const;

      private: std::string EnumWidgetValue(ConfigChildWidget *_widget) const;

      private slots: void OnItemSelection(QTreeWidgetItem *_item,
          const int _column);

      private slots: void OnUIntValueChanged();

      private slots: void OnIntValueChanged();

      private slots: void OnDoubleValueChanged();

      private slots: void OnBoolValueChanged();

      private slots: void OnStringValueChanged();

      private slots: void OnVector3dValueChanged();

      private slots: void OnVector3dPresetChanged(const int _index);

      private slots: void OnColorValueChanged();

      private slots: void OnColorValueChanged(const QColor _value);

      private slots: void OnPoseValueChanged();

      private slots: void OnGeometryValueChanged();

      private slots: void OnGeometryValueChanged(const int _value);

      private slots: void OnEnumValueChanged(const QString &_value);

      private slots: void OnCustomColorDialog();

      Q_SIGNALS: void UIntValueChanged(const QString &_name,
          const unsigned int _value);

      Q_SIGNALS: void IntValueChanged(const QString &_name, const int _value);

      Q_SIGNALS: void DoubleValueChanged(const QString &_name,
          const double _value);

      Q_SIGNALS: void BoolValueChanged(const QString &_name,
          const bool _value);

      Q_SIGNALS: void StringValueChanged(const QString &_name,
          const std::string &_value);

      Q_SIGNALS: void Vector3dValueChanged(const QString &_name,
          const ignition::math::Vector3d &_value);

      Q_SIGNALS: void ColorValueChanged(const QString &_name,
          const ignition::math::Color &_value);

      Q_SIGNALS: void PoseValueChanged(const QString &_name,
          const ignition::math::Pose3d &_pose);

      Q_SIGNALS: void GeometryValueChanged(const std::string &_name,
          const std::string &_value,
          const ignition::math::Vector3d &_dimensions,
          const std::string &_uri);

      Q_SIGNALS: void EnumValueChanged(const QString &_name,
          const QString &_value);

      Q_SIGNALS: void DensityValueChanged(const double &_value);

      Q_SIGNALS: void MassValueChanged(const double &_value);

      private slots: void OnDensityValueChanged(const double _value);

      private slots: void OnMassValueChanged(const double _value);

      private slots: void OnGeometryChanged();

      Q_SIGNALS: void GeometryChanged();

      private: bool eventFilter(QObject *_obj, QEvent *_event);

      private: std::unique_ptr<ConfigWidgetPrivate> dataPtr;
    };
  }
}
#endif