~ejungwoo/geant4/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.          *

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

 //

 //

 // $Id: G4OpenGLQtViewer.hh 108601 2018-02-26 10:03:17Z gcosmo $

 //

 //

 // G4OpenGLQtViewer : Class to provide WindowsNT specific

 //                       functionality for OpenGL in GEANT4

 //

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


 #ifdef G4VIS_BUILD_OPENGLQT_DRIVER


 #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;

 class QSignalMapper;

 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;

   bool hasPendingEvents();

   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;

   QSignalMapper *fSignalMapperMouse;

   QSignalMapper *fSignalMapperSurface;

   QSignalMapper *fSignalMapperPicking;


   // 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

name
const XML_Char * name
Definition: expat.h:151

ENCODING
struct encoding ENCODING
Definition: xmltok.h:126

a
std::vector< ExP01TrackerHit * > a
Definition: ExP01Classes.hh:33

G4Colour
Definition: G4Colour.hh:83

G4String
Definition: examples/extended/parallel/TopC/ParN02/AnnotatedFiles/G4String.hh:45

G4PhysicalVolumeModel.hh

G4PhysicalVolumeModel
Definition: G4PhysicalVolumeModel.hh:82

G4Visible
Definition: G4Visible.hh:48

G4AutoLock.hh

G4UImanager
Definition: G4UImanager.hh:58

G4double
double G4double
Definition: G4Types.hh:76

width
#define width

G4Text
Definition: G4Text.hh:73

JA::PVPath
std::vector< PVNodeID > PVPath
Definition: G4XXXSGSceneHandler.hh:46

G4TemplateAutoLock
Definition: G4AutoLock.hh:276

globals.hh

G4UIcommand
Definition: G4UIcommand.hh:51

JA::PVNodeID
G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID
Definition: G4XXXSGSceneHandler.hh:45

G4PhysicalVolumeModel::G4PhysicalVolumeNodeID
Definition: G4PhysicalVolumeModel.hh:90

G4OpenGLViewer.hh

START
Definition: G4InterpolationScheme.hh:39

e
Float_t e
Definition: extended/medical/dna/range/plot.C:35

model
const XML_Char XML_Content * model
Definition: expat.h:151