qglviewer.h

Go to the documentation of this file.

/****************************************************************************

 This file is part of the QGLViewer library
 Copyright (C) 2002-2004  Gilles Debunne (Gilles.Debunne@imag.fr)
 Version 1.3.5 Release 8. Packaged on Monday December 22, 2003.

 http://www-imagis.imag.fr/Membres/Gilles.Debunne/CODE/QGLViewer

 libQGLViewer is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 libQGLViewer is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with libQGLViewer; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*****************************************************************************/

#ifndef QGLVIEWER_QGLVIEWER_H
#define QGLVIEWER_QGLVIEWER_H

#include <qgl.h>
#include "camera.h"

class QGLVIEWER_EXPORT QGLViewer : public QGLWidget
{
  Q_OBJECT        // must include this if you use Qt signals/slots
  
// #ifndef DOXYGEN
  // Q_PROPERTY(QString snapshotFilename READ snapshotFilename WRITE setSnapshotFilename)
// #endif
    
public:
  QGLViewer(QWidget* parent=NULL, const char* name=0,
        const QGLWidget* shareWidget=0, WFlags flags=0);
  
  QGLViewer(const QGLFormat& format, QWidget* parent=0,const char* name=0,
        const QGLWidget* shareWidget=0, WFlags flags=0);

  virtual ~QGLViewer();

public:
  qglviewer::Vec backgroundColor() const { return backgroundColor_; };
  void getBackgroundColor(float& r, float& g, float& b) const;
  qglviewer::Vec foregroundColor() const { return foregroundColor_; };
  void getForegroundColor(float& r, float& g, float& b) const;
public slots:
  void setBackgroundColor(const qglviewer::Vec& color) { backgroundColor_ = color; glClearColor(color.x, color.y, color.z, 1.0); };
  void setBackgroundColor(float r, float g, float b) { setBackgroundColor(qglviewer::Vec(r, g ,b)); };
  void setBackgroundColor(const QColor &c) { setBackgroundColor(c.red(), c.green(), c.blue()); };
  void setForegroundColor(const qglviewer::Vec& color) { foregroundColor_ = color; };
  void setForegroundColor(float r, float g, float b) { setForegroundColor(qglviewer::Vec(r, g ,b)); };;
  void setForegroundColor(const QColor &c) { setForegroundColor(c.red(), c.green(), c.blue()); };
  
public:
  bool axisIsDrawn() const { return drawAxis_; };
public slots:
  void setDrawAxis(bool f=true) { drawAxis_ = f; emit axisDrawn(f); if (initializationStage_==3) updateGL(); };
  void toggleDrawAxis() { setDrawAxis(!drawAxis_); };

public:
  bool gridIsDrawn() const { return drawGrid_; };
public slots:
  void setDrawGrid(bool f=true) { drawGrid_ = f; emit gridDrawn(f); if (initializationStage_==3) updateGL(); };
  void toggleDrawGrid() { setDrawGrid(!drawGrid_); };

public:
  bool fpsIsDisplayed() const { return displayFPS_; };
public slots:
  void setDisplayFPS(bool f=true) { displayFPS_ = f; emit fpsDisplayed(f); if (initializationStage_==3) updateGL(); };
  void toggleDisplayFPS() { setDisplayFPS(!displayFPS_); };

public:
  bool zBufferIsDisplayed() const { return displayZBuffer_; };
public slots:
  void setDisplayZBuffer(bool f=true) { displayZBuffer_ = f; emit zBufferDisplayed(f); if (initializationStage_==3) updateGL(); };
  void toggleDisplayZBuffer() { setDisplayZBuffer(!displayZBuffer_); };
  
public:
  bool textIsEnabled() const { return enableText_; };
public slots:
  void setEnableText(bool f=true) { enableText_ = f; emit textEnabled(f); if (initializationStage_==3) updateGL(); };
  void toggleEnableText() { setEnableText(!enableText_); };

public:
  bool cameraPathIsEdited() const { return camera()->cameraPathIsEdited(); };
public slots:
  void editCameraPath(bool edit=true) { camera()->editCameraPath(edit); emit cameraPathEdited(edit); if (initializationStage_==3) updateGL(); };
  void toggleCameraPathEditor() { editCameraPath(!camera()->cameraPathIsEdited()); };


public:
  float aspectRatio() const { return static_cast<float>(width())/static_cast<float>(height()); };
public slots:

public:
  float sceneRadius() const { return camera()->sceneRadius(); };
public slots:
  void setSceneRadius(float r) { camera()->setSceneRadius(r); };

public:
  qglviewer::Vec sceneCenter() const { return camera()->sceneCenter(); };
  void getSceneCenter(float& x, float& y, float& z) const;
public slots:
  void setSceneCenter(const qglviewer::Vec& sc) { camera()->setSceneCenter(sc); };
  void setSceneCenter(float x, float y, float z) { setSceneCenter(qglviewer::Vec(x,y,z)); };
  void setSceneBoundingBox(const qglviewer::Vec& m, const qglviewer::Vec& M) { camera()->setSceneBoundingBox(m,M); };

  void showEntireScene() { camera()->showEntireScene(); if (initializationStage_==3) updateGL(); };
public:
  void setSceneBoundingBox(const float m[3], const float M[3]) { setSceneBoundingBox(qglviewer::Vec(m),qglviewer::Vec(M)); };
  float currentFPS() { return f_p_s_; };

public:
  qglviewer::Camera* camera() const { return camera_; };

  qglviewer::ManipulatedFrame* manipulatedFrame() const { return manipulatedFrame_; };
  
public slots:
  void setCamera(qglviewer::Camera* const c);
  void setManipulatedFrame(qglviewer::ManipulatedFrame* fr);

  
public:
  bool isFullScreen() const { return fullScreen_; };
  bool displaysInStereo() const { return stereo_; }  
public slots:
  void setFullScreen(bool fs=true);
  void toggleFullScreen();
  void setStereoDisplay(bool s=true);
  void toggleStereoDisplay()        { setStereoDisplay(!stereo_); };
  virtual void toggleCameraMode();

  
public:
  void drawAxis(float scale=1.0f);
  void drawGrid() { glCallList(GridDL_); };

  virtual void startScreenCoordinatesSystem(bool upward = false) const;
  virtual void stopScreenCoordinatesSystem() const;

protected:
  virtual void drawLight(GLenum light, float scale = 1.0f) const;
  virtual void displayFPS();
  virtual void displayZBuffer() const;
  
  void drawText(int x, int y, const QString& text, const QFont& fnt=QFont());
  void draw3DText(const qglviewer::Vec& pos, const qglviewer::Vec& normal, const QString& string, GLfloat height=0.1f);

private:
  virtual void drawVectorial() { makeCurrent(); paintGL(); };
  
#ifndef DOXYGEN // Hidden
  friend void drawVectorial(void* param);
#endif


  
public:
  qglviewer::MouseGrabber* mouseGrabber() const { return mouseGrabber_; };

public slots:
  void setMouseGrabber(qglviewer::MouseGrabber* mg);


public:  
  const QString& snapshotFilename() const { return snapshotFilename_; };
  const QString& snapshotFormat() const { return snapshotFormat_; };
  int snapshotCounter() const { return snapshotCounter_; };
  
public slots:
  // Qt 2.3 does not support double default value parameters
  // Uncomment the following line (and comment the next one) with Qt 2.3
  // void saveSnapshot(bool automatic, bool overwrite);
  void saveSnapshot(bool automatic=false, bool overwrite=false);
  
  void setSnapshotFilename(const QString& n);
  void setSnapshotFormat(const QString& f) { snapshotFormat_ = f; };
  void setSnapshotCounter(const int c) { snapshotCounter_ = c; };

public:
  bool animationIsStarted() const { return animationStarted_; };
  int animationPeriod() const { return animationPeriod_; };

public slots:
  void setAnimationPeriod(int msecs) { animationPeriod_ = msecs; };
  virtual void startAnimation(int msecs = -1);
  virtual void stopAnimation();
  void toggleAnimationMode() { if (animationIsStarted()) stopAnimation(); else startAnimation(); };
protected:
  virtual void animate() { emit animateNeeded(); };

public:
signals:
  void viewerInitialized();

  void drawNeeded();

  void animateNeeded();

  void helpRequired();

  void axisDrawn(bool on);
  void gridDrawn(bool on);
  void fpsDisplayed(bool on);
  void zBufferDisplayed(bool on);
  void textEnabled(bool on);
  void cameraPathEdited(bool on);
  void stereoChanged(bool on);
  void pointSelected(const QMouseEvent* e);
                                                      
public:
  virtual QString helpString() const { return QString::null; };
public slots:
  virtual void help();
  
public:
  virtual QString mouseBindingsString() const;
  virtual QString shortcutBindingsString() const;

protected:
  virtual void resizeGL( int w, int h );

  virtual void initializeGL();

  virtual void init() { emit viewerInitialized(); };

  virtual void paintGL();

  virtual void preDraw();  
  virtual void preDrawStereo(bool leftBuffer=true);
  
  virtual void draw() {};
  virtual void fastDraw();
  virtual void postDraw();
  virtual void select(const QMouseEvent* e);
  
  QWidget* rootWidget() const;
    
protected:
  virtual void mousePressEvent(QMouseEvent *);
  virtual void mouseDoubleClickEvent(QMouseEvent *);
  virtual void mouseReleaseEvent(QMouseEvent *);
  virtual void mouseMoveEvent(QMouseEvent *);
  virtual void wheelEvent(QWheelEvent *);
  virtual void timerEvent(QTimerEvent *);
  virtual void closeEvent(QCloseEvent *);

  // keyboard handler
  virtual void keyPressEvent(QKeyEvent *);

  
protected:
  enum ShortcutAction { DRAW_AXIS, DRAW_GRID, DISPLAY_FPS, DISPLAY_Z_BUFFER, ENABLE_TEXT, EXIT, SAVE_SCREENSHOT,
            CAMERA_MODE, FULL_SCREEN, STEREO, ANIMATION, HELP, EDIT_CAMERA_PATHS };
  //#CONNECTION# shortcutBindingsString

  virtual void setShortcutKey(ShortcutAction action, int key, int stateKey = -1);
  Qt::Key shortcutKey(ShortcutAction action) const;

  virtual void setShortcutStateKey(ShortcutAction action, int buttonState);
  Qt::ButtonState shortcutStateKey(ShortcutAction action) const;

  // Key Frames shortcut keys
  virtual void setKeyFrameKey(int nb, int key);
  Qt::Key keyFrameKey(int nb) const;

  virtual void setAddKeyFrameStateKey(int buttonState);
  Qt::ButtonState addKeyFrameStateKey() const;

  virtual void setPlayKeyFramePathStateKey(int buttonState);
  Qt::ButtonState playKeyFramePathStateKey() const;

  
public:
  enum MouseHandler { CAMERA, FRAME };

  enum ClickAction { NO_ACTION, ZOOM_ON_PIXEL, ZOOM_TO_FIT, SELECT, RAP_FROM_PIXEL, RAP_IS_CENTER,
             CENTER_FRAME, CENTER_SCENE, SHOW_ENTIRE_SCENE, ALIGN_FRAME, ALIGN_CAMERA };

protected:
  virtual void setMouseStateKey(MouseHandler mh, int buttonState);
  Qt::ButtonState mouseStateKey(int) const;

  void setMouseBinding(int buttonState, MouseHandler handler, qglviewer::ManipulatedFrame::MouseMotion action, bool withConstraint=true);
  qglviewer::ManipulatedFrame::MouseMotion mouseAction(int buttonState);
  int mouseHandler(int buttonState);
  Qt::ButtonState mouseButtonState(MouseHandler mh, qglviewer::ManipulatedFrame::MouseMotion ma, bool withConstraint=true);

  void setMouseBinding(int buttonState, ClickAction action, bool doubleClick=false, int buttonBefore=Qt::NoButton);
  ClickAction clickAction(int buttonState, bool doubleClick, int buttonBefore);
  void clickButtonState(ClickAction ca, Qt::ButtonState& buttonState, bool& doubleClick, Qt::ButtonState& buttonBefore);

  void setWheelBinding(int stateKey, MouseHandler handler, qglviewer::ManipulatedFrame::MouseMotion action, bool withConstraint=true);
  qglviewer::ManipulatedFrame::MouseMotion wheelAction(int buttonState);
  int wheelHandler(int buttonState);
  int wheelButtonState(MouseHandler mh, qglviewer::ManipulatedFrame::MouseMotion ma, bool withConstraint=true);


  /* XXX Modified by Aidan Lane (Feb 13, 2004), for compatibility reasons. XXX */
  GLuint AxisDL_, GridDL_, CameraDL_;
  void createDisplayLists();

  
public:
  virtual void saveToFile(const QString& fileName="");
  virtual void restoreFromFile(const QString& fileName="");
  
  virtual QDomElement domElement(const QString& name, QDomDocument& doc) const;
  virtual void initFromDOMElement(const QDomElement& de);


  public:
  static const QPtrList<QGLViewer>& QGLViewerPool() { return QGLViewerPool_; };
  static int  QGLViewerIndex(const QGLViewer* const v) { return QGLViewerPool_.find(v); };
  static void connectSignalToAllViewers(const QObject* sender, const char* signal, const char* member=SLOT(updateGL()));
  static void disconnectSignalToAllViewers(const QObject* sender, const char* signal, const char* member=SLOT(updateGL()));
  static void updateGLForAllViewers();
  static void saveToFileForAllViewers();


  public:
  virtual void setVisualHintsMask(int mask, int delay = 2000);
  virtual void drawVisualHints();
    
  public slots:
  virtual void resetVisualHints();
    
private slots:
  void delayedFullScreen() { move(prevPos_); setFullScreen(); };
  
private:
  // Copy constructor and opertor= are declared private and undefined
  // Prevents everyone from trying to use them
  QGLViewer(const QGLViewer& v);
  QGLViewer& operator=(const QGLViewer& v);

  // Set parameters to their default values. Called by the constructors.
  void defaultConstructor();

  // C a m e r a
  qglviewer::Camera* camera_;
  
  // C o l o r s
  qglviewer::Vec backgroundColor_, foregroundColor_;
  
  // D i s p l a y    f l a g s
  bool drawAxis_;   // world axis 
  bool drawGrid_;   // world XY grid
  bool displayFPS_; // Frame Per Seconds
  bool displayZBuffer_; // Grey level z-buffer
  bool enableText_; // drawText() actually draws text or not
  bool stereo_;     // stereo display
  bool fullScreen_; // full screen mode
  QPoint prevPos_;  // Previous window position, used for full screen mode

  // A n i m a t i o n    p a r a m e t e r s
  bool animationStarted_; // animation mode started
  int animationPeriod_;   // period in msecs
  int animationTimerId_;
  
  // F P S    d i s p l a y 
  QTime fpsTime_;
  unsigned int fpsCounter_;
  float f_p_s_;
  
  // M a n i p u l a t e d    f r a m e 
  qglviewer::ManipulatedFrame* manipulatedFrame_;
  bool manipulatedFrameIsACamera_;
  qglviewer::MouseGrabber* mouseGrabber_;
  bool mouseGrabberIsAManipulatedFrame_;
  bool mouseGrabberIsAManipulatedCameraFrame_;
  
  // D i s p l a y    l i s t s
  /* XXX Modified by Aidan Lane (Feb 13, 2004), for compatibility reasons. XXX */
  //GLuint AxisDL_, GridDL_, CameraDL_;
  //void createDisplayLists();

  // V i s u a l   h i n t s
  int visualHint_;

  // S h o r t c u t   k e y s 
  void setDefaultShortcutKeys();
  enum { nbShortcuts_ = 13 };
  Qt::Key         shortcutKey_[nbShortcuts_];
  Qt::ButtonState shortcutStateKey_[nbShortcuts_];

  // K e y   F r a m e s   s h o r t c u t s
  Qt::Key *keyFrameKey_;
  Qt::ButtonState addKFStateKey_, playKFStateKey_;

  // M o u s e   a c t i o n s
  struct MouseMotionPrivate {
    MouseHandler handler;
    qglviewer::ManipulatedFrame::MouseMotion action;
    bool withConstraint; 
  };

  class ClickActionPrivate {
  public:
    Qt::ButtonState buttonState;
    bool doubleClick;
    Qt::ButtonState buttonBefore;

    bool operator<(const ClickActionPrivate& cap) const
    {
      if (buttonState != cap.buttonState)
    return buttonState < cap.buttonState;
      else
    if (buttonBefore != cap.buttonBefore)
      return buttonBefore < cap.buttonBefore;
    else
      return doubleClick < cap.doubleClick;
    }
  };

  void setDefaultMouseBindings();
  void performClickAtion(ClickAction ca, const QMouseEvent* const e);
  QMap<Qt::ButtonState, MouseMotionPrivate> mouseBinding_;
  QMap<Qt::ButtonState, MouseMotionPrivate> wheelBinding_;
  QMap<ClickActionPrivate, ClickAction> clickBinding_;
  
  // S n a p s h o t s
  QString snapshotFilename_, snapshotFormat_;
  int snapshotCounter_;
  
  // Q G L V i e w e r   p o o l
  static QPtrList<QGLViewer> QGLViewerPool_;
  
  // I n t e r n a l   d e b u g
  int initializationStage_;
};

#endif // QGLVIEWER_QGLVIEWER_H

---