da/d70/G4OpenGLQtViewer_8hh_source.html

//

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

// * License and Disclaimer                                           *

// *                                                                  *

// * The  Geant4 software  is  copyright of the Copyright Holders  of *

// * the Geant4 Collaboration.  It is provided  under  the terms  and *

// * conditions of the Geant4 Software License,  included in the file *

// * LICENSE and available at  http://cern.ch/geant4/license .  These *

// * include a list of copyright holders.                             *

// *                                                                  *

// * Neither the authors of this software system, nor their employing *

// * institutes,nor the agencies providing financial support for this *

// * work  make  any representation or  warranty, express or implied, *

// * regarding  this  software system or assume any liability for its *

// * use.  Please see the license in the file  LICENSE  and URL above *

// * for the full disclaimer and the limitation of liability.         *

// *                                                                  *

// * This  code  implementation is the result of  the  scientific and *

// * technical work of the GEANT4 collaboration.                      *

// * By using,  copying,  modifying or  distributing the software (or *

// * any work based  on the software)  you  agree  to acknowledge its *

// * use  in  resulting  scientific  publications,  and indicate your *

// * acceptance of all terms of the Geant4 Software license.          *

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

//

//

//

//

// G4OpenGLQtViewer : Class to provide WindowsNT specific

//                       functionality for OpenGL in GEANT4

//

// 30/06/2014 : M.Kelsey : Change QPixmap objects to pointers


#if defined (G4VIS_BUILD_OPENGLQT_DRIVER) || defined (G4VIS_USE_OPENGLQT)


#ifndef G4OPENGLQTVIEWER_HH

#define G4OPENGLQTVIEWER_HH


#include "globals.hh"


#include "G4OpenGLViewer.hh"

#include "G4PhysicalVolumeModel.hh"

#include "G4AutoLock.hh"


#include <qobject.h>

#include <qpoint.h>

#include <qpixmap.h>


class G4OpenGLSceneHandler;

class G4UImanager;

class G4Text;

class G4UIcommand;


class QGLWidget;

class QDialog;

class QTextEdit;

class QContextMenuEvent;

class QMenu;

class QImage;

class QAction;

class QTabWidget;

class QMouseEvent;

class QKeyEvent;

class QWheelEvent;

class QProcess;

class QTime;

class QVBoxLayout;

class QPushButton;

class QSlider;

class QTreeWidgetItem;

class QTreeWidget;

class QColor;

class G4OpenGLSceneHandler;

class G4OpenGLQtMovieDialog;

class QLineEdit;

#if QT_VERSION < 0x050600

class QSignalMapper;

#endif

class G4UIQt;

class QTableWidget;

class QTableWidgetItem;

class QScrollArea;

class QSplitter;


class G4OpenGLQtViewer: public QObject, virtual public G4OpenGLViewer {


  Q_OBJECT


    typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;

    typedef std::vector<PVNodeID> PVPath;


public:

  G4OpenGLQtViewer (G4OpenGLSceneHandler& scene);

  virtual ~G4OpenGLQtViewer ();

#ifdef G4MULTITHREADED

  // In MT mode these functions are called in the following order for each run:

  // Called on the master thread before starting the vis sub-thread.

  virtual void DoneWithMasterThread ();

  // Called on the master thread after starting the vis sub-thread.

  virtual void MovingToVisSubThread ();

  // Called on the vis sub-thread when waiting for events.

  virtual void SwitchToVisSubThread ();

  // Called on the vis sub-thread when all events have been processed.

  virtual void DoneWithVisSubThread ();

  // Called on the vis sub-thread when all events have been processed.

  // virtual void MovingToMasterThread ();  Not used in G4OpenGLQtViewer.

  // Called on the master thread after the vis sub-thread has terminated.

  virtual void SwitchToMasterThread ();

#endif


private:

  G4OpenGLQtViewer (const G4OpenGLQtViewer&);

  G4OpenGLQtViewer& operator= (const G4OpenGLQtViewer&);

public:

  virtual void updateQWidget()=0;

  void updateSceneTreeWidget();

  void updateViewerPropertiesTableWidget();

  void updatePickInfosWidget(int, int);

  QString setEncoderPath(QString path);

  QString getEncoderPath();

  QString setTempFolderPath(QString path);

  QString getTempFolderPath();

  QString setSaveFileName(QString path);

  QString getSaveFileName();

  bool isRecording();

  bool isStopped();

  bool isPaused();

  bool isEncoding();

  bool isWaiting();

  bool isFailed();

  void setWaiting();

  bool isBadEncoder();

  bool isBadOutput();

  bool isBadTmp();

  bool isSuccess();

  void setBadTmp();

  void setBadOutput();

  void setBadEncoder();

  bool isReadyToEncode();

  void resetRecording();

  void encodeVideo();

  void stopVideo();

  void saveVideo();

  bool generateMpegEncoderParameters();

  void displayRecordingStatus();

  void DrawText(const G4Text&);

  void ResetView ();

  void addPVSceneTreeElement(const G4String& model,

                             G4PhysicalVolumeModel* pPVModel,

                             int currentPVPOIndex);

  void addNonPVSceneTreeElement(const G4String& model,

                                int currentPVPOIndex,

                                const std::string& modelDescription,

                                const G4Visible& visible);

  bool isTouchableVisible(int POindex);

  void clearTreeWidget();

  bool exportImage(std::string name="", int width=-1, int height=-1);


public:

  void G4MousePressEvent(QMouseEvent *event);

  void G4wheelEvent (QWheelEvent * event);

  void G4keyPressEvent (QKeyEvent * event);

  void G4keyReleaseEvent (QKeyEvent * event);

  void G4MouseDoubleClickEvent();

  void G4MouseReleaseEvent(QMouseEvent *evnt);

  void G4MouseMoveEvent(QMouseEvent *event);


protected:

  void CreateGLQtContext ();

  virtual void CreateMainWindow (QGLWidget*,const QString&);

  void G4manageContextMenuEvent(QContextMenuEvent *e);

  void rotateQtScene(float, float);

  void rotateQtSceneToggle(float, float);

  void moveScene(float, float, float,bool);

  void FinishView();

  void updateKeyModifierState(const Qt::KeyboardModifiers&);

  void displaySceneTreeComponent();

  G4Colour getColorForPoIndex(int poIndex);


  // So that privately accumulated vis attributes modifiers may be

  // concatenated with the standard vis attributes modifiers for commands

  // such as /vis/viewer/set/all and /vis/viewer/save...

  const std::vector<G4ModelingParameters::VisAttributesModifier>*

  GetPrivateVisAttributesModifiers() const;

  bool isCurrentWidget();


protected:

  QWidget* fGLWidget;

  void savePPMToTemp();

  int fRecordFrameNumber;


  bool fHasToRepaint;

  bool fUpdateGLLock;

  bool fQGLWidgetInitialiseCompleted;

  bool fPaintEventLock;


  // Flag to indicate that action was initiated by interaction (mouse

  // click) on the scene tree.  It is used and reset in

  // G4OpenGLStoredQtViewer::CompareForKernelVisit to prevent rebuild

  // in this case.

  bool fMouseOnSceneTree;


private:

  enum RECORDING_STEP {WAIT,START,PAUSE,CONTINUE,STOP,READY_TO_ENCODE,ENCODING,FAILED,SUCCESS,BAD_ENCODER,BAD_OUTPUT,BAD_TMP,SAVE};


  void createPopupMenu();

  void createRadioAction(QAction *,QAction *, const std::string&,unsigned int a=1);

  void rescaleImage(int, int);

  bool printPDF(const std::string,int,QImage);

  void showMovieParametersDialog();

  void initMovieParameters();

  QString createTempFolder();

  QString removeTempFolder();

  void setRecordingStatus(RECORDING_STEP);

  void setRecordingInfos(const QString&);

  QString getProcessErrorMsg();

  QWidget* getParentWidget();

  bool parseAndInsertInSceneTree(QTreeWidgetItem *,

                                  G4PhysicalVolumeModel* pPVModel,

                                 unsigned int fullPathIndex,

                                 const QString& parentRoot,

                                 unsigned int currentIndex,

                                 int currentPVPOIndex);

  void setCheckComponent(QTreeWidgetItem* item,bool check);

  void createSceneTreeComponent();

  void createSceneTreeWidget();

  void createViewerPropertiesWidget();

  void createPickInfosWidget();

  bool parseAndCheckVisibility(QTreeWidgetItem * treeNode,int POindex);

  QTreeWidgetItem* createTreeWidgetItem(const PVPath& fullPath,

                                     const QString& name,

                                     int copyNb,

                                     int POIndex,

                                     const QString& logicalName,

                                     Qt::CheckState state,

                                     QTreeWidgetItem * treeNode,

                                     const G4Colour& color);

  QString getModelShortName(const G4String& modelShortName);

  void cloneSceneTree(QTreeWidgetItem* rootItem);

  void changeDepthOnSceneTreeItem(double lookForDepth,double currentDepth,QTreeWidgetItem* item);

  void updatePositivePoIndexSceneTreeWidgetQuickMap(int POindex,QTreeWidgetItem* item);

  void changeQColorForTreeWidgetItem(QTreeWidgetItem* item, const QColor&);


  bool isSameSceneTreeElement(QTreeWidgetItem* parentOldItem,QTreeWidgetItem* parentNewItem);

  void changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement(QTreeWidgetItem* subItem);

  bool isPVVolume(QTreeWidgetItem* item);

  QTreeWidgetItem* cloneWidgetItem(QTreeWidgetItem* item);

  void clearSceneTreeSelection(QTreeWidgetItem*);

  void clearTreeWidgetElements(QTreeWidgetItem* item);


  // Get the tree wigdet item for POindex if exists

  QTreeWidgetItem* getTreeWidgetItem(int POindex);


  // Get the old tree wigdet item for POindex if exists

  QTreeWidgetItem* getOldTreeWidgetItem(int POindex);


// parse the scene tree and return a string of status that can be saved

  std::string parseSceneTreeAndSaveState();


  std::string parseSceneTreeElementAndSaveState(QTreeWidgetItem* item, unsigned int level);

  QString GetCommandParameterList (const G4UIcommand *aCommand);

  void changeColorAndTransparency(GLuint index, G4Color color);


#ifdef G4MULTITHREADED

  inline void SetQGLContextVisSubThread(QThread *th) {

    fQGLContextVisSubThread = th;

  }

  inline void SetQGLContextMainThread(QThread *th) {

    fQGLContextMainThread = th;

  }

#endif


  QMenu *fContextMenu;

  QPoint fLastPos1;

  QPoint fLastPos2;

  QPoint fLastPos3;

  QPoint fLastPickPoint;


  // delta of depth move. This delta is put in % of the scene view

  G4double fDeltaDepth;

  // delta of zoom move. This delta is put in % of the scene view

  G4double fDeltaZoom;

  // To ensure key event are keep one by one

  bool fHoldKeyEvent;

  // To ensure move event are keep one by one

  bool fHoldMoveEvent;

  // To ensure rotate event are keep one by one

  bool fHoldRotateEvent;

  bool fAutoMove;

  QString fEncoderPath;

  QString fTempFolderPath;

  QString fMovieTempFolderPath;

  QString fSaveFileName;

  QString fParameterFileName;

  QAction *fMouseRotateAction;

  QAction *fMouseMoveAction;

  QAction *fMousePickAction;

  QAction *fMouseZoomInAction;

  QAction *fMouseZoomOutAction;

  QAction *fFullScreenOn;

  QAction *fFullScreenOff;

  QAction *fDrawingWireframe;

  QAction *fDrawingLineRemoval;

  QAction *fDrawingSurfaceRemoval;

  QAction *fDrawingLineSurfaceRemoval;

  QAction *fProjectionOrtho;

  QAction *fProjectionPerspective;

  G4OpenGLQtMovieDialog* fMovieParametersDialog;

  RECORDING_STEP fRecordingStep;

  QProcess *fProcess;

  QTime *fLastEventTime;

  int fSpinningDelay;

  int fNbMaxFramesPerSec;

  float fNbMaxAnglePerSec;

  int fLaunchSpinDelay;

  QWidget* fUISceneTreeWidget;

  QWidget* fUIViewerPropertiesWidget;

  QWidget* fUIPickInfosWidget;

  bool fNoKeyPress;

  bool fAltKeyPress;

  bool fControlKeyPress;

  bool fShiftKeyPress;

  bool fBatchMode;

  bool fCheckSceneTreeComponentSignalLock;

  bool fViewerPropertiesTableWidgetIsInit;

  QTreeWidget* fSceneTreeComponentTreeWidget;

  // This is only use to hold the old "expand" value, see file:///Developer/Documentation/Qt/html/qtreewidgetitem.html#setExpanded

  QWidget* fSceneTreeWidget;

  bool fPVRootNodeCreate;

  QLineEdit* fFilterOutput;

  QString fFileSavePath;

  int fNbRotation ;

  int fTimeRotation;

  QString fTouchableVolumes;

  QDialog* fShortcutsDialog;

  QTableWidget *fViewerPropertiesTableWidget;

  QWidget* fPickInfosWidget;

  QScrollArea* fPickInfosScrollArea;

  int fTreeWidgetInfosIgnoredCommands;

  QPushButton * fSceneTreeButtonApply;

  QTextEdit *fShortcutsDialogInfos;

  QSlider* fSceneTreeDepthSlider;

  std::map <int, PVPath > fTreeItemModels;

  std::map <int, PVPath > fOldTreeItemModels;


  // quick scene tree map

  std::map <int, QTreeWidgetItem*> fPositivePoIndexSceneTreeWidgetQuickMap;

  // old scene tree map

  std::map <int, QTreeWidgetItem*> fOldPositivePoIndexSceneTreeWidgetQuickMap;

  std::vector <QTreeWidgetItem*> fOldNullPoIndexSceneTreeWidgetQuickVector;

  // old vis attr color map

  std::map <int, QColor> fOldVisAttrColorMap;


  unsigned int fSceneTreeDepth;

  QTreeWidgetItem* fModelShortNameItem;

  int fNumber;

  int fMaxPOindexInserted;

  G4UIQt* fUiQt;

#if QT_VERSION < 0x050600

  QSignalMapper *fSignalMapperMouse;

  QSignalMapper *fSignalMapperSurface;

  QSignalMapper *fSignalMapperPicking;

#endif

  // quick map index to find next item

  std::map <int, QTreeWidgetItem*>::const_iterator fLastSceneTreeWidgetAskForIterator;

  std::map <int, QTreeWidgetItem*>::const_iterator fLastSceneTreeWidgetAskForIteratorEnd;


  // quick map index to find next item

  std::map <int, QTreeWidgetItem*>::const_iterator fOldLastSceneTreeWidgetAskForIterator;

  std::map <int, QTreeWidgetItem*>::const_iterator fOldLastSceneTreeWidgetAskForIteratorEnd;


  // icons

  QPixmap* fTreeIconOpen;

  QPixmap* fTreeIconClosed;

  QPixmap* fSearchIcon;


  int fLastExportSliderValue;

  G4Color fLastHighlightColor;

  GLuint fLastHighlightName;

  bool fIsDeleting;


#ifdef G4MULTITHREADED

  QThread* fQGLContextVisSubThread;

  QThread* fQGLContextMainThread;

#endif


  // safe to use in serial mode

  G4AutoLock* lWaitForVisSubThreadQtOpenGLContextInitialized;

  G4AutoLock* lWaitForVisSubThreadQtOpenGLContextMoved;


public Q_SLOTS :

  void startPauseVideo();


protected Q_SLOTS :

  void updateToolbarAndMouseContextMenu();


private Q_SLOTS :

  void actionSaveImage();

  void actionChangeBackgroundColor();

  void actionChangeTextColor();

  void actionChangeDefaultColor();

  void actionMovieParameters();


  void showShortcuts();

  void toggleMouseAction(int);

  void toggleSurfaceAction(int);

  void toggleProjection(bool);

  void toggleTransparency(bool);

  void toggleAntialiasing(bool);

  void toggleHaloing(bool);

  void toggleAux(bool);

  void toggleHiddenMarkers(bool);

  void toggleFullScreen(bool);

  void processEncodeFinished();

  void processLookForFinished();

  void processEncodeStdout();

  void sceneTreeComponentItemChanged(QTreeWidgetItem* item, int id);

  void toggleSceneTreeComponentPickingCout(int);

  void togglePicking();

  void currentTabActivated(int);


  // action trigger by a click on a component scene tree

  void sceneTreeComponentSelected();

  void changeDepthInSceneTree(int);

  void changeSearchSelection();

  void changeColorAndTransparency(QTreeWidgetItem* item,int val);

  void tableWidgetViewerSetItemChanged(QTableWidgetItem *);

};


#endif


#endif