QtBaseViewer.hh

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
\*===========================================================================*/





//=============================================================================
//
//  CLASS QtBaseViewer
//
//=============================================================================

#ifndef ACG_QTBASEVIEWER_HH
#define ACG_QTBASEVIEWER_HH

//== INCLUDES =================================================================


#include "../Scenegraph/DrawModes.hh"
#include "../Config/ACGDefines.hh"
#include "../Math/VectorT.hh"
#include "../Math/GLMatrixT.hh"
#include "../Scenegraph/PickTarget.hh"
#include "../GL/gl.hh"

#include <QBoxLayout>
#include <QtNetwork/QUdpSocket>
#include <QWheelEvent>
#include <QKeyEvent>
#include <QDropEvent>
#include <QContextMenuEvent>
#include <QDragEnterEvent>
#include <QMouseEvent>
#include <QAction>
#include <QSize>
#include <QMap>
#include <QString>
#include <QMenu>
#include <QToolBar>
#include <QTime>

#include <vector>
#include <string>


//== FORWARDDECLARATIONS ======================================================


class QPushButton;
class QToolButton;
class QStatusBar;
class QSplitter;
class QTimer;
class QImage;
class QSocketNotifier;
class QGraphicsWidget;
class QGraphicsGridLayout;
class QGLFormat;
class QGLWidget;

//== NAMESPACES ===============================================================

namespace ACG {
class GLState;
namespace SceneGraph {
class BaseNode;
}
namespace QtWidgets {


//== FORWARDDECLARATIONS ======================================================


class QtWheel;
class QtGLGraphicsScene;
class QtGLGraphicsView;
class QtSceneGraphDialog;
class QtShiftPopupMenu;

//== CLASS DEFINITION =========================================================


class ACGDLLEXPORT QtBaseViewer : public QWidget
{
Q_OBJECT

//-------------------------------------------------------------- public methods
public:

  enum Options {
    Nothing=0,

    ShowPrivateStatusBar=1,

    ShowToolBar=2,

    ShowPickButton=4,
    ShowLassoButton=8,
    ShowQuestionButton=0x10,

    ShowWheelX=0x20,
    ShowWheelY=0x40,
    ShowWheelZ=0x80,

    ShowWheels=0xe0,

    DefaultOptions = 0xffff & (~ShowPrivateStatusBar)
  };




  //--------------------------------------------------- constructor / destructor

  QtBaseViewer( QWidget* _parent=0,
                const char* _name=0,
                QStatusBar *_statusBar=0,
                const QGLFormat* _format=0,
                const QtBaseViewer* _share=0,
                Options _options=DefaultOptions );

  virtual ~QtBaseViewer();





  //------------------------------------------------------------- public methods

  virtual QSize sizeHint () const;

  QStatusBar* statusBar() { return statusbar_; }
  void setStatusBar(QStatusBar* _sb);

  void applyOptions(int _options);
  int options() const { return options_; }


  virtual void makeCurrent();
  virtual void swapBuffers();


  GLState& glState() { return *glstate_; }


  void backgroundColor(const Vec4f& _color);
  Vec4f backgroundColor();


  virtual void lockUpdate();
  virtual void unlockUpdate();
  virtual void unlockAndUpdate();
  bool isUpdateLocked() const { return updateLocked_; }


  void lockProjectionUpdate( void ) { projectionUpdateLocked_ = true; }

  void unlockProjectionUpdate( void ) { projectionUpdateLocked_ = false; }

  bool animation() const { return animation_; }
  void animation(bool _b);

  void trackMouse(bool _track);

  void enablePopupMenu(bool _enable);






  SceneGraph::BaseNode* sceneGraph() { return sceneGraphRoot_; }
  const SceneGraph::BaseNode* sceneGraph() const { return sceneGraphRoot_; }
  void sceneGraph(SceneGraph::BaseNode* _root);

  enum NavigationMode {
    NORMAL_NAVIGATION,     
    FIRSTPERSON_NAVIGATION  
  };

  enum ProjectionMode {
    ORTHOGRAPHIC_PROJECTION, 
    PERSPECTIVE_PROJECTION   
  };

  void projectionMode(ProjectionMode _p);
  ProjectionMode projectionMode() const { return projectionMode_; }

  void navigationMode(NavigationMode _n);
  NavigationMode navigationMode() const { return navigationMode_; }

  void setScenePos( const ACG::Vec3d& _center, double _radius, const bool _setCenter = true );

  void setSceneCenter( const ACG::Vec3d& _center );
  
  const ACG::Vec3d& scene_center() const { return scene_center_; }
  double scene_radius() const { return scene_radius_; }
  
  void setSceneRadius(double radius) { scene_radius_ = radius; }
  
  void viewingDirection( const ACG::Vec3d& _dir, const ACG::Vec3d& _up );
  
  void setFovy( double _fovy );

  enum ActionMode {
    // examine geometry, get transformations from mouse events
    ExamineMode,
    PickingMode,
    // same as picking, but emit signalMouseEventIdentify()
    QuestionMode,
    // Ligh rotation mode
    LightMode
  };


  void actionMode(ActionMode);

  ActionMode lastActionMode(){ return lastActionMode_; };

  ActionMode actionMode() const { return actionMode_; }


 enum FaceOrientation {
    CCW_ORIENTATION, 
    CW_ORIENTATION   
  };

  void faceOrientation(FaceOrientation);
  FaceOrientation faceOrientation() const { return faceOrientation_; }

  void backFaceCulling( bool _b );
  bool backFaceCulling() const { return backFaceCulling_; }

  void twoSidedLighting( bool _b );
  bool twoSidedLighting() const { return twoSidedLighting_; }

  enum NormalsMode {
    DONT_TOUCH_NORMALS,
    NORMALIZE_NORMALS
  };

  void normalsMode(NormalsMode _mode);
  NormalsMode normalsMode() const { return normalsMode_; }


  GLMatrixd& light_matrix() { return light_matrix_; }
  void rotate_lights(Vec3d& _axis, double _angle);
  void update_lights();


  void copyToImage( QImage& _image, GLenum _buffer=GL_BACK) {
    copyToImage(_image, 0, 0, glWidth(), glHeight(), _buffer);
  }

  void copyToImage( QImage& _image,
                    unsigned int _left,  unsigned int _top,
                    unsigned int _width, unsigned int _height,
                    GLenum _buffer );


  unsigned int glWidth() const;
  unsigned int glHeight() const;
  QSize glSize() const;
  QPoint glMapFromGlobal( const QPoint& _pos ) const;
  QPoint glMapToGlobal( const QPoint& _pos ) const;


  void drawMode(ACG::SceneGraph::DrawModes::DrawMode _mode)
  {
    curDrawMode_=_mode;
    updatePopupMenu();
  }

  ACG::SceneGraph::DrawModes::DrawMode drawMode() { return curDrawMode_; }

  void encodeView(QString& _view);
  bool decodeView(const QString& _view);

  void initModelviewMatrix();

  // get all Mouse & Key Events for GlWidget
  void grabGLArea();

  // undo grabbing GLArea
  void releaseGLArea();

  void drawBlendedObjects(bool _status) { blending_ = _status; }

  void translate(const Vec3d& trans);

  void rotate(const Vec3d& axis, double angle)
  { rotate(axis, angle, trackball_center_); }

  void rotate(const Vec3d& axis, double angle, const Vec3d& _center);

  QMenu * getPickMenu() { return pickMenu_; };
  QMenu * getFuncMenu() { return funcMenu_; };
  QMenu * getDrawMenu() { return drawMenu_; };

  QToolBar* getToolBar();

  QToolBar* removeToolBar();
  
  void moveForward();
  
  void moveBack();
  
  void strafeLeft();
  
  void strafeRight();

//---------------------------------------------------------------- public slots
public slots:

  virtual void drawNow();
  virtual void updateGL();

  virtual void setHome();
  virtual void home();
  virtual void viewAll();
  virtual void flyTo(const QPoint& _pos, bool _move_back);
  virtual void flyTo(const QPoint& _pos) { flyTo(_pos,false); }
  virtual void flyFrom(const QPoint& _pos) { flyTo(_pos,true); }

  virtual void flyTo(const Vec3d& _position,
                               const Vec3d& _center,
                               double       _time = 1000.0);

  virtual void examineMode() { actionMode(ExamineMode); }
  virtual void lightMode() { actionMode(LightMode); }
  virtual void questionMode() { actionMode(QuestionMode); }

  virtual void perspectiveProjection();
  virtual void orthographicProjection();
  virtual void toggleProjectionMode();
  virtual void toggleNavigationMode();
  
  signals:
    
    void projectionModeChanged( bool _ortho );
    void navigationModeChanged( bool _normal );  

  public slots:
    
  virtual void showSceneGraphDialog();

  virtual void setView( const GLMatrixd& _modelview,
                        const GLMatrixd& _inverse_modelview );

  void actionBackground();
  void actionCopyView();
  void actionPasteView();
  void actionPasteDropSize();
  void actionSynchronize();
  void actionAnimation();
  void actionBackfaceCulling();
  void actionTwoSidedLighting();
  void actionSynchronize(bool _enable);
  void actionAnimation(bool _enable);
  void actionBackfaceCulling(bool _enable);
  void actionTwoSidedLighting(bool _enable);

  void actionDrawMenu( QAction * _action );
  void actionPickMenu( QAction * _action );




//-------------------------------------------------------------- public signals
signals:

  void signalInitializeGL();

  void signalMouseEvent(QMouseEvent*, const std::string&);

  void signalMouseEvent(QMouseEvent*);

  void signalWheelEvent(QWheelEvent*, const std::string&);

  void signalMouseEventIdentify( QMouseEvent* );


  void signalSetView( const GLMatrixd& _modelview,
                      const GLMatrixd& _inverse_modelview );
  void signalSceneGraphChanged(ACG::SceneGraph::BaseNode* _root);
  void signalNodeChanged(ACG::SceneGraph::BaseNode* _node);
  void signalActionModeChanged(ACG::QtWidgets::QtBaseViewer::ActionMode _m);
  void signalDrawScene(ACG::GLState* _state);


  signals:

  void signalCustomContextMenuRequested ( const QPoint & );


//----------------------------------------------------------- protected methods
protected:

  friend class QtGLGraphicsScene;
  friend class QtGLGraphicsView;

  virtual void initializeGL();
  virtual void paintGL();
  virtual void resizeGL(int _w, int _h);


  virtual void glMousePressEvent(QMouseEvent* _event);
  virtual void glMouseDoubleClickEvent(QMouseEvent* _event);
  virtual void glMouseMoveEvent(QMouseEvent* _event);
  virtual void glMouseReleaseEvent(QMouseEvent* _event);
  virtual void glMouseWheelEvent(QWheelEvent* _event);
  virtual void glContextMenuEvent(QContextMenuEvent* _event);


  virtual void viewMouseEvent( QMouseEvent* _event) = 0;
  virtual void viewWheelEvent(QWheelEvent* _event) = 0;

  virtual void lightMouseEvent( QMouseEvent* /* _event */ ) {}


  protected:


  void updateProjectionMatrix();
  void updatePickMenu();



//------------------------------------------------------------- protected slots
protected slots:

  virtual void sceneRectChanged(const QRectF & rect);

  virtual void slotWheelX(double _dAngle);
  virtual void slotWheelY(double _dAngle);
  virtual void slotWheelZ(double _dist);

  virtual void slotNodeChanged(ACG::SceneGraph::BaseNode* _node);

  virtual void cleanupEventFilter()
  { removeEventFilter( sender());}



//--------------------------------------------------------------- private slots
private slots:

  void hidePopupMenus();

//----------------------------------------------------------- private functions
private:

  // IDs for \c funcMenu_
  enum FuncMenuID {
    M_CopyView=0x100,
    M_PasteView,
    M_PasteDropSize,
    M_Animation,
    M_BackfaceCulling,
    M_TwoSidedLighting,
    M_Background,
    M_Snapshot,
    M_SnapshotName,
    M_SnapshotSavesView,
    M_Synchronize
  };

  QtBaseViewer(const QtBaseViewer&);
  QtBaseViewer& operator=(const QtBaseViewer&);

  // create widgets
  void createWidgets(const QGLFormat* _format,QStatusBar* _sb,
                     const QtBaseViewer* _share);

  /* Recursively draws each node in the scene graph.
      Called by paintGL(). */
  void drawScene();
  // helper called by drawScene().
  void drawScene_mono();
  // helper called by drawScene() when stereo viewing is active.
  void drawScene_stereo();

  // helper to check openGL support
  bool hasOpenGL();

  // updates popup menu with the available draw modes
  void updatePopupMenu();

//-------------------------------------------------------------- protected data
protected:


  // scene center and radius
  Vec3d                        scene_center_, trackball_center_;
  double                       scene_radius_, trackball_radius_;


  // projection stuff
  GLdouble                     orthoWidth_;
  GLdouble                     near_, far_, fovy_;


  // scenegraph
  GLState                     *glstate_;


  // helper
  bool                         isRotating_;


  // current status bar, guaranteed to be !=0
  QStatusBar* statusbar_;



//---------------------------------------------------------------- private data
private:


  // data stored for home view
  Vec3d                        home_center_;
  double                       home_radius_;
  GLMatrixd                    home_modelview_,
                               home_inverse_modelview_;
  double                       homeOrthoWidth_;


  // matrix for rotating light position
  GLMatrixd                    light_matrix_;


  // modi
  NormalsMode                  normalsMode_;
  FaceOrientation              faceOrientation_;
  ProjectionMode               projectionMode_;
  NavigationMode               navigationMode_;
  
  ActionMode                   actionMode_, lastActionMode_;
  bool                         backFaceCulling_;
  bool                         twoSidedLighting_;
  bool                         animation_;

  // helper
  bool                         trackMouse_;
  bool                         popupEnabled_;
  bool                         glareaGrabbed_;
  double                       frame_time_;


  QMenu * pickMenu_;
  QMenu * funcMenu_;
  QMenu * drawMenu_;

  // scenegraph stuff
  SceneGraph::BaseNode*        sceneGraphRoot_;

  ACG::SceneGraph::DrawModes::DrawMode curDrawMode_,
                                       availDrawModes_;

  bool                         updateLocked_;
  bool                         projectionUpdateLocked_;
  bool                         blending_;


  // widget showing the scenegraph
  QtSceneGraphDialog*          sceneGraphDialog_;



  // options
  Options options_;
  // gl widget used as drawing area to paint the graphics scene
  QGLWidget* glWidget_;
  // graphics scene used to paint gl context and widgets
  QtGLGraphicsScene* glScene_;
  // graphics view that holds the gl scene
  QtGLGraphicsView* glView_;

  // Base graphics widget for wheels in the scene
  QGraphicsWidget* glBase_;
  // Base graphics widget layout
  QGraphicsGridLayout* glBaseLayout_;

  // private status bar, 0 if status bar is provided externally
  QStatusBar* privateStatusBar_;

  // Layout for the basic widget ( viewer + wheels )
  QGridLayout* glLayout_;

  // tool bar
  QToolBar    * buttonBar_;

  // set pick mode
  QToolButton* pickButton_;
  // set move mode
  QToolButton* moveButton_;
  // set light mode
  QToolButton* lightButton_;
  // set question mode
  QToolButton* questionButton_;
  // change projection mode (perspective/orthographic)
  QToolButton* projectionButton_;
  // go to home() position
  QToolButton* homeButton_;
  // setHome()
  QToolButton* setHomeButton_;
  // viewAll()
  QToolButton* viewAllButton_;
  // show sceneGraphDialog_
  QToolButton* sceneGraphButton_;
  // enable/disable stereo viewing
  QToolButton* stereoButton_;

  // rotate around x-axis
  QtWheel* wheelX_;
  // rotate around y-axis
  QtWheel* wheelY_;
  // translate along z-axis
  QtWheel* wheelZ_;

  // all actions
  QMap< QString, QAction * > action_;

  // vector of current draw mode actions
  std::vector< QAction * > drawMenuActions_;

  // Used to calculate the time passed between redraws
  QTime redrawTime_;
  
  //===========================================================================
  //===========================================================================
  signals:
    void viewUpdated();
    
    void viewChanged();  
    
  //===========================================================================
  //===========================================================================

  public slots:

    virtual void toggleStereoMode();

    virtual void setStereoMode(bool _b);

  public:
    void setEyeDistance(double _distance);

    double eyeDistance( );

    void setFocalDistance(double _distance);

    double focalDistance( );

  private:
    // stereo stuff
    bool                         stereo_;
    double                       eyeDist_, focalDist_;


  //===========================================================================
  //===========================================================================

  signals:
    void signalKeyPressEvent(QKeyEvent*);

  public:
    void disableKeyHandling(bool _state );

    bool keyHandlingState();

  protected:

    virtual void glKeyPressEvent(QKeyEvent*);

    virtual void glKeyReleaseEvent(QKeyEvent* _event);

    virtual bool viewKeyPressEvent(QKeyEvent* _event) = 0;

  private:
    bool disableKeyHandling_;

  //===========================================================================
  //===========================================================================

  protected:

    virtual void startDrag();
    virtual void glDragEnterEvent(QDragEnterEvent* _event);
    virtual void glDropEvent(QDropEvent* _event);

  public:
    void setExternalDrag( bool _external ) { externalDrag_ = _external; };

  signals:
    void startDragEvent( QMouseEvent* _event );

    void dragEnterEvent(QDragEnterEvent* _event);

    void dropEvent( QDropEvent* _event );

  private:

    bool externalDrag_;

  //===========================================================================
  //===========================================================================

  public:
    void sync_connect(const QtBaseViewer*);

    void sync_disconnect(const QtBaseViewer*);

    virtual void setSynchronization(bool _b);

    bool add_sync_host(const QString& _name);
    void add_sync_host(QHostAddress& _adr);

    bool synchronization();

  private slots:

    void sync_receive();
    void sync_send(const GLMatrixd& _modelview,
        const GLMatrixd& _inverse_modelview);

  private:
    bool                         synchronized_;

    bool                         skipNextSync_;

    QUdpSocket *                 socket_;

    std::vector<QHostAddress>    sync_hosts_;

  //===========================================================================
  //===========================================================================

  public slots:
    virtual void snapshotBaseFileName(const QString& _fname);

    virtual void snapshot();

    void actionSnapshot();

    void actionSnapshotName();

    void actionSnapshotSavesView();

  private:

    QString                      snapshotName_;
    int                          snapshotCounter_;
    QImage*                      snapshot_;

  //===========================================================================
  //===========================================================================
  public:
    bool pick( SceneGraph::PickTarget _pickTarget,
               const QPoint& _mousePos,
               unsigned int& _nodeIdx,
               unsigned int& _targetIdx,
               Vec3d* _hitPointPtr=0 );

    bool fast_pick( const QPoint&  _mousePos,
                    Vec3d&         _hitPoint );

    void addPickMode(const std::string& _name,
                     bool               _mouse_tracking = false,
                     int                _pos            = -1,
                     bool               _visible        = true,
                     QCursor            _cursor         = Qt::ArrowCursor );

    void clearPickModes();

    const std::string& pickMode() const;

    void pickMode(const std::string& _name);

    void pickMode( int _id );

    void renderPicking(bool _renderPicking, ACG::SceneGraph::PickTarget _mode);

  public slots:

    virtual void pickingMode();

    void setPickModeCursor(const std::string& _name, QCursor _cursor);

    void setPickModeMouseTracking(const std::string& _name, bool _mouseTracking);

  signals:
    void signalPickModeChanged(const std::string&);

  private:

    struct PickMode
    {
      PickMode(const std::string& _n, bool _t, bool _v, QCursor _c) :
               name(_n), tracking(_t), visible(_v), cursor(_c) {}

      std::string  name;

      bool         tracking;

      bool         visible;

      QCursor      cursor;
    };

    std::vector<PickMode>  pick_modes_;

    std::string            pick_mode_name_;

    int                    pick_mode_idx_;

    bool renderPicking_;

    ACG::SceneGraph::PickTarget pickRendererMode_;

};


//=============================================================================
} // namespace QtWidgets
} // namespace ACG
//=============================================================================
#endif // ACG_QTBASEVIEWER_HH defined
//=============================================================================