MainWindow.hh

Go to the documentation of this file.

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

#include <map>
#include <string>
#include <vector>
#include <list>

#include <boost/thread/mutex.hpp>

#include "gazebo/gazebo_config.h"
#include "gazebo/gui/qt.h"
#include "gazebo/gui/DataLogger.hh"
#include "gazebo/common/Event.hh"
#include "gazebo/msgs/MessageTypes.hh"
#include "gazebo/transport/TransportTypes.hh"
#include "gazebo/util/system.hh"

#ifdef HAVE_OCULUS
#include "gazebo/gui/OculusWindow.hh"
#endif

namespace gazebo
{
  namespace gui
  {
    class RenderWidget;
    class ToolsWidget;
    class ModelListWidget;
    class Editor;
    class SpaceNav;

    class GAZEBO_VISIBLE MainWindow : public QMainWindow
    {
      Q_OBJECT

      public: MainWindow();
      public: virtual ~MainWindow();

      public: void Load();
      public: void Init();

      public: unsigned int GetEntityId(const std::string &_name);
      public: bool HasEntityName(const std::string &_name);

      public: void AddToLeftColumn(const std::string &_name, QWidget *_widget);

      public: void ShowLeftColumnWidget(const std::string &_name = "default");

      public: RenderWidget *GetRenderWidget() const;

      public: bool IsPaused() const;

      public slots: void Play();

      public slots: void Pause();

      public: void SetLeftPaneVisibility(bool _on);

      public: void AddMenu(QMenu *_menu);

      public: void ShowMenuBar(QMenuBar *_bar = NULL);

      public: QAction *CloneAction(QAction *_action, QObject *_parent);

      public: Editor *GetEditor(const std::string &_name) const;

      signals: void AddPlugins();

      signals: void Close();

      protected: void closeEvent(QCloseEvent *_event);

      private: void OnGUI(ConstGUIPtr &_msg);

      private slots: void ItemSelected(QTreeWidgetItem *, int);
      private slots: void New();
      private slots: void Open();
      private slots: void Import();
      private slots: void Save();
      private slots: void SaveAs();

      private slots: void SaveINI();

      private slots: void Clone();

      private slots: void About();
      private slots: void Step();
      private slots: void Arrow();

      private slots: void Translate();

      private slots: void Rotate();

      private slots: void Scale();

      private slots: void Align();

      private slots: void Snap();

      private slots: void CreateBox();
      private slots: void CreateSphere();
      private slots: void CreateCylinder();
      private slots: void CreateMesh();
      private slots: void CreatePointLight();
      private slots: void CreateSpotLight();
      private slots: void CreateDirectionalLight();

      private slots: void CaptureScreenshot();

      private slots: void InsertModel();

      private slots: void ShowGrid();

      private slots: void ShowOrigin();

      private slots: void ShowCollisions();

      private slots: void ShowJoints();

      private slots: void ShowContacts();

      private slots: void ShowCOM();

      private slots: void ShowInertia();

      private slots: void ShowLinkFrame();

      private slots: void FullScreen();

      private slots: void ShowToolbars();

      private slots: void FPS();
      private slots: void Orbit();
      private slots: void ViewOculus();
      private slots: void OnResetModelOnly();
      private slots: void OnResetWorld();
      private slots: void SetTransparent();
      private slots: void SetWireframe();

      private slots: void ShowGUIOverlays();

      private slots: void DataLogger();

      private slots: void OnDataLoggerClosed();

      private slots: void SelectTopic();

      private slots: void Diagnostics();

      private slots: void OnAddPlugins();

      private slots: void OnEditorGroup(QAction *_action);

      private: void OnFullScreen(bool _value);

      private: void OnShowToolbars(bool _value);

      private: void OnMoveMode(bool _mode);

      private: void CreateActions();

      private: void DeleteActions();

      private: void CreateMenus();

      private: void CreateMenuBar();

      private: void CreateEditors();

      private: void OnModel(ConstModelPtr &_msg);

      private: void OnLight(ConstLightPtr &_msg);

      private: void OnResponse(ConstResponsePtr &_msg);
      private: void OnWorldModify(ConstWorldModifyPtr &_msg);
      private: void OnManipMode(const std::string &_mode);
      private: void OnSetSelectedEntity(const std::string &_name,
                                        const std::string &_mode);

      private: void OnInputStepSizeChanged(int _value);

      private: void OnFollow(const std::string &_modelName);

      private: void CreateDisabledIcon(const std::string &_pixmap,
                   QAction *_act);

      private: QToolBar *playToolbar;

      private: RenderWidget *renderWidget;
      private: ToolsWidget *toolsWidget;
      private: ModelListWidget *modelListWidget;

      private: transport::NodePtr node;
      private: transport::PublisherPtr worldControlPub;
      private: transport::PublisherPtr serverControlPub;
      private: transport::PublisherPtr requestPub;
      private: transport::PublisherPtr scenePub;
      private: transport::SubscriberPtr responseSub;
      private: transport::SubscriberPtr guiSub;
      private: transport::SubscriberPtr newEntitySub, statsSub;
      private: transport::SubscriberPtr worldModSub;

      private: transport::SubscriberPtr lightSub;

      private: QDockWidget *toolsDock;

      private: std::vector<event::ConnectionPtr> connections;

      // A map that associates physics_id's with entity names
      private: std::map<std::string, unsigned int> entities;

      private: msgs::Request *requestMsg;

      private: QTabWidget *tabWidget;

      private: QMenuBar *menuBar;

      private: QMenu *editMenu;

      private: QHBoxLayout *menuLayout;

      private: QStackedWidget *leftColumn;

      private: std::map<std::string, int> leftColumnStack;

      private: std::string saveFilename;

      private: int inputStepSize;

      private: std::map<std::string, Editor *> editors;

      private: std::vector<QActionGroup *> alignActionGroups;

      private: SpaceNav *spacenav;

#ifdef HAVE_OCULUS
      private: gui::OculusWindow *oculusWindow;
#endif

      private: std::vector<boost::shared_ptr<msgs::Plugin const> > pluginMsgs;

      private: boost::mutex pluginLoadMutex;

      private: QSplitter *splitter;

      private: gui::DataLogger *dataLogger;
    };
  }
}
#endif