#include <G4OpenGLStoredQtViewer.hh>

Inheritance diagram for G4OpenGLStoredQtViewer:

Public Slots
void	startPauseVideo ()

Public Member Functions
void	addNonPVSceneTreeElement (const G4String &model, int currentPVPOIndex, const std::string &modelDescription, const G4Visible &visible)

void	addPVSceneTreeElement (const G4String &model, G4PhysicalVolumeModel *pPVModel, int currentPVPOIndex)

void	clearTreeWidget ()

void	ClearView ()

void	ClearViewWithoutFlush ()

std::vector< G4ThreeVector >	ComputeFlyThrough (G4Vector3D *)

void	displayRecordingStatus ()

void	DisplayTimePOColourModification (G4Colour &, size_t)

void	DrawText (const G4Text &)

void	DrawView ()

void	encodeVideo ()

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

void	G4keyPressEvent (QKeyEvent *event)

void	G4keyReleaseEvent (QKeyEvent *event)

void	G4MouseDoubleClickEvent ()

void	G4MouseMoveEvent (QMouseEvent *event)

void	G4MousePressEvent (QMouseEvent *event)

void	G4MouseReleaseEvent (QMouseEvent *evnt)

	G4OpenGLStoredQtViewer (G4OpenGLStoredSceneHandler &scene, const G4String &name="")

void	G4wheelEvent (QWheelEvent *event)

bool	generateMpegEncoderParameters ()

const G4VisAttributes *	GetApplicableVisAttributes (const G4VisAttributes *) const

const G4ViewParameters &	GetDefaultViewParameters () const

QString	getEncoderPath ()

const G4String &	GetName () const

QString	getSaveFileName ()

G4VSceneHandler *	GetSceneHandler () const

const G4String &	GetShortName () const

QString	getTempFolderPath ()

G4int	GetViewId () const

const G4ViewParameters &	GetViewParameters () const

void	Initialise ()

void	initializeGL ()

bool	isBadEncoder ()

bool	isBadOutput ()

bool	isBadTmp ()

bool	isEncoding ()

bool	isFailed ()

bool	isPaused ()

bool	isReadyToEncode ()

bool	isRecording ()

bool	isStopped ()

bool	isSuccess ()

bool	isTouchableVisible (int POindex)

bool	isWaiting ()

void	NeedKernelVisit ()

void	paintGL ()

void	ProcessView ()

void	RefreshView ()

void	resetRecording ()

void	ResetView ()

void	resizeGL (int width, int height)

void	saveVideo ()

void	setBadEncoder ()

void	setBadOutput ()

void	setBadTmp ()

void	SetDefaultViewParameters (const G4ViewParameters &vp)

QString	setEncoderPath (QString path)

bool	setExportImageFormat (std::string format, bool quiet=false)

void	SetName (const G4String &)

void	SetNeedKernelVisit (G4bool need)

QString	setSaveFileName (QString path)

QString	setTempFolderPath (QString path)

void	SetViewParameters (const G4ViewParameters &vp)

void	setWaiting ()

void	ShowView ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

void	stopVideo ()

void	updatePickInfosWidget (int, int)

void	updateQWidget ()

void	updateSceneTreeWidget ()

void	updateViewerPropertiesTableWidget ()

	~G4OpenGLStoredQtViewer ()

Protected Slots
void	updateToolbarAndMouseContextMenu ()

Protected Member Functions
void	addExportImageFormat (std::string format)

void	AddPrimitiveForASingleFrame (const G4Circle &circle)

void	AddPrimitiveForASingleFrame (const G4Text &text)

void	ChangeLineWidth (G4double width)

void	ChangePointSize (G4double size)

G4bool	CompareForKernelVisit (G4ViewParameters &)

void	contextMenuEvent (QContextMenuEvent *e)

virtual void	CreateFontLists ()

void	CreateGLQtContext ()

virtual void	CreateMainWindow (QGLWidget *, const QString &)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

void	displaySceneTreeComponent ()

void	DrawDisplayLists ()

void	FinishView ()

void	g4GlFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)

void	g4GlOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)

void	g4GluLookAt (GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz)

void	g4GluPickMatrix (GLdouble x, GLdouble y, GLdouble width, GLdouble height, GLint viewport[4])

void	G4manageContextMenuEvent (QContextMenuEvent *e)

G4Colour	getColorForPoIndex (int poIndex)

const std::vector< G4OpenGLViewerPickMap * > &	GetPickDetails (GLdouble x, GLdouble y)

const std::vector< G4ModelingParameters::VisAttributesModifier > *	GetPrivateVisAttributesModifiers () const

std::string	getRealPrintFilename ()

GLdouble	getSceneDepth ()

GLdouble	getSceneFarWidth ()

GLdouble	getSceneNearWidth ()

unsigned int	getWinHeight () const

unsigned int	getWinWidth () const

void	HaloingFirstPass ()

void	HaloingSecondPass ()

void	HLRFirstPass ()

void	HLRSecondPass ()

void	HLRThirdPass ()

void	InitializeGLView ()

bool	isCurrentWidget ()

G4bool	isFramebufferReady ()

G4bool	isGl2psWriting ()

void	KernelVisitDecision ()

void	keyPressEvent (QKeyEvent *event)

void	keyReleaseEvent (QKeyEvent *event)

void	mouseDoubleClickEvent (QMouseEvent *event)

void	mouseMoveEvent (QMouseEvent *event)

void	mousePressEvent (QMouseEvent *event)

void	mouseReleaseEvent (QMouseEvent *event)

void	moveScene (float, float, float, bool)

void	paintEvent (QPaintEvent *event)

virtual G4String	Pick (GLdouble x, GLdouble y)

G4bool	POSelected (size_t POListIndex)

void	ResizeGLView ()

void	ResizeWindow (unsigned int, unsigned int)

void	rotateQtScene (float, float)

void	rotateQtSceneToggle (float, float)

void	rotateScene (G4double dx, G4double dy)

void	rotateSceneToggle (G4double dx, G4double dy)

void	savePPMToTemp ()

bool	setExportFilename (G4String name, G4bool inc=true)

void	setExportSize (G4int, G4int)

void	SetTouchable (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath)

void	SetView ()

void	showEvent (QShowEvent *event)

G4bool	sizeHasChanged ()

G4bool	TOSelected (size_t TOListIndex)

void	TouchableSetColour (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, const G4Colour &)

void	TouchableSetVisibility (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, G4bool visibility)

void	updateKeyModifierState (const Qt::KeyboardModifiers &)

void	wheelEvent (QWheelEvent *event)

Protected Attributes
G4bool	antialiasing_enabled

G4Colour	background

std::string	fDefaultExportImageFormat

G4ViewParameters	fDefaultVP

G4bool	fDepthTestEnable

int	fExportFilenameIndex

std::string	fExportImageFormat

std::vector< std::string >	fExportImageFormatVector

G4OpenGLStoredSceneHandler &	fG4OpenGLStoredSceneHandler

G4OpenGL2PSAction *	fGL2PSAction

QWidget *	fGLWidget

bool	fHasToRepaint

G4ViewParameters	fLastVP

bool	fMouseOnSceneTree

G4String	fName

G4bool	fNeedKernelVisit

G4Colour	fOldDisplayListColor

G4OpenGLSceneHandler &	fOpenGLSceneHandler

bool	fPaintEventLock

G4double	fPan_sens

G4bool	fPrintColour

G4int	fPrintSizeX

G4int	fPrintSizeY

bool	fQGLWidgetInitialiseCompleted

int	fRecordFrameNumber

G4double	fRot_sens

G4VSceneHandler &	fSceneHandler

G4String	fShortName

bool	fUpdateGLLock

G4bool	fVectoredPs

G4int	fViewId

G4ViewParameters	fVP

unsigned int	fWinSize_x

unsigned int	fWinSize_y

G4bool	haloing_enabled

G4bool	transparency_enabled

Private Types
typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID	PVNodeID

typedef std::vector< PVNodeID >	PVPath

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

Private Slots
void	actionChangeBackgroundColor ()

void	actionChangeDefaultColor ()

void	actionChangeTextColor ()

void	actionMovieParameters ()

void	actionSaveImage ()

void	changeColorAndTransparency (QTreeWidgetItem *item, int val)

void	changeDepthInSceneTree (int)

void	changeSearchSelection ()

void	currentTabActivated (int)

void	processEncodeFinished ()

void	processEncodeStdout ()

void	processLookForFinished ()

void	sceneTreeComponentItemChanged (QTreeWidgetItem *item, int id)

void	sceneTreeComponentSelected ()

void	showShortcuts ()

void	tableWidgetViewerSetItemChanged (QTableWidgetItem *)

void	toggleAntialiasing (bool)

void	toggleAux (bool)

void	toggleFullScreen (bool)

void	toggleHaloing (bool)

void	toggleHiddenMarkers (bool)

void	toggleMouseAction (int)

void	togglePicking ()

void	toggleProjection (bool)

void	toggleSceneTreeComponentPickingCout (int)

void	toggleSurfaceAction (int)

void	toggleTransparency (bool)

Private Member Functions
void	changeColorAndTransparency (GLuint index, G4Color color)

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

void	changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement (QTreeWidgetItem *subItem)

void	changeQColorForTreeWidgetItem (QTreeWidgetItem *item, const QColor &)

void	clearSceneTreeSelection (QTreeWidgetItem *)

void	clearTreeWidgetElements (QTreeWidgetItem *item)

void	cloneSceneTree (QTreeWidgetItem *rootItem)

QTreeWidgetItem *	cloneWidgetItem (QTreeWidgetItem *item)

void	ComputeView ()

void	createPickInfosWidget ()

void	createPopupMenu ()

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

void	createSceneTreeComponent ()

void	createSceneTreeWidget ()

QString	createTempFolder ()

QTreeWidgetItem *	createTreeWidgetItem (const PVPath &fullPath, const QString &name, int copyNb, int POIndex, const QString &logicalName, Qt::CheckState state, QTreeWidgetItem *treeNode, const G4Colour &color)

void	createViewerPropertiesWidget ()

QString	GetCommandParameterList (const G4UIcommand *aCommand)

QString	getModelShortName (const G4String &modelShortName)

QTreeWidgetItem *	getOldTreeWidgetItem (int POindex)

QWidget *	getParentWidget ()

QString	getProcessErrorMsg ()

G4int	getRealExportHeight ()

G4int	getRealExportWidth ()

QTreeWidgetItem *	getTreeWidgetItem (int POindex)

GLubyte *	grabPixels (int inColor, unsigned int width, unsigned int height)

void	initMovieParameters ()

bool	isPVVolume (QTreeWidgetItem *item)

bool	isSameSceneTreeElement (QTreeWidgetItem parentOldItem, QTreeWidgetItem parentNewItem)

bool	parseAndCheckVisibility (QTreeWidgetItem *treeNode, int POindex)

bool	parseAndInsertInSceneTree (QTreeWidgetItem , G4PhysicalVolumeModel pPVModel, unsigned int fullPathIndex, const QString &parentRoot, unsigned int currentIndex, int currentPVPOIndex)

std::string	parseSceneTreeAndSaveState ()

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

bool	printGl2PS ()

bool	printNonVectoredEPS ()

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

bool	printVectoredEPS ()

QString	removeTempFolder ()

void	rescaleImage (int, int)

void	rotateSceneInViewDirection (G4double dx, G4double dy)

void	rotateSceneThetaPhi (G4double dx, G4double dy)

void	setCheckComponent (QTreeWidgetItem *item, bool check)

void	setRecordingInfos (const QString &)

void	setRecordingStatus (RECORDING_STEP)

void	showMovieParametersDialog ()

void	updatePositivePoIndexSceneTreeWidgetQuickMap (int POindex, QTreeWidgetItem *item)

Private Attributes
bool	fAltKeyPress

bool	fAutoMove

bool	fBatchMode

bool	fCheckSceneTreeComponentSignalLock

QMenu *	fContextMenu

bool	fControlKeyPress

G4String	fDefaultExportFilename

G4double	fDeltaDepth

G4double	fDeltaZoom

QAction *	fDrawingLineRemoval

QAction *	fDrawingLineSurfaceRemoval

QAction *	fDrawingSurfaceRemoval

QAction *	fDrawingWireframe

QString	fEncoderPath

G4String	fExportFilename

QString	fFileSavePath

QLineEdit *	fFilterOutput

QAction *	fFullScreenOff

QAction *	fFullScreenOn

int	fGl2psDefaultLineWith

int	fGl2psDefaultPointSize

bool	fGlViewInitialized

bool	fHoldKeyEvent

bool	fHoldMoveEvent

bool	fHoldRotateEvent

bool	fIsDeleting

bool	fIsGettingPickInfos

QTime *	fLastEventTime

int	fLastExportSliderValue

G4Color	fLastHighlightColor

GLuint	fLastHighlightName

QPoint	fLastPickPoint

QPoint	fLastPos1

QPoint	fLastPos2

QPoint	fLastPos3

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

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

int	fLaunchSpinDelay

int	fMaxPOindexInserted

QTreeWidgetItem *	fModelShortNameItem

QAction *	fMouseMoveAction

QAction *	fMousePickAction

QAction *	fMouseRotateAction

QAction *	fMouseZoomInAction

QAction *	fMouseZoomOutAction

G4OpenGLQtMovieDialog *	fMovieParametersDialog

QString	fMovieTempFolderPath

float	fNbMaxAnglePerSec

int	fNbMaxFramesPerSec

int	fNbRotation

bool	fNoKeyPress

int	fNumber

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

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

std::vector< QTreeWidgetItem * >	fOldNullPoIndexSceneTreeWidgetQuickVector

std::map< int, QTreeWidgetItem * >	fOldPositivePoIndexSceneTreeWidgetQuickMap

std::map< int, PVPath >	fOldTreeItemModels

std::map< int, QColor >	fOldVisAttrColorMap

QString	fParameterFileName

QScrollArea *	fPickInfosScrollArea

QWidget *	fPickInfosWidget

G4float	fPointSize

std::map< int, QTreeWidgetItem * >	fPositivePoIndexSceneTreeWidgetQuickMap

QProcess *	fProcess

QAction *	fProjectionOrtho

QAction *	fProjectionPerspective

bool	fPVRootNodeCreate

RECORDING_STEP	fRecordingStep

QString	fSaveFileName

QPushButton *	fSceneTreeButtonApply

QTreeWidget *	fSceneTreeComponentTreeWidget

unsigned int	fSceneTreeDepth

QSlider *	fSceneTreeDepthSlider

QWidget *	fSceneTreeWidget

QPixmap *	fSearchIcon

bool	fShiftKeyPress

QDialog *	fShortcutsDialog

QTextEdit *	fShortcutsDialogInfos

QSignalMapper *	fSignalMapperMouse

QSignalMapper *	fSignalMapperPicking

QSignalMapper *	fSignalMapperSurface

G4bool	fSizeHasChanged

int	fSpinningDelay

QString	fTempFolderPath

int	fTimeRotation

QString	fTouchableVolumes

QPixmap *	fTreeIconClosed

QPixmap *	fTreeIconOpen

std::map< int, PVPath >	fTreeItemModels

int	fTreeWidgetInfosIgnoredCommands

QWidget *	fUIPickInfosWidget

G4UIQt *	fUiQt

QWidget *	fUISceneTreeWidget

QWidget *	fUIViewerPropertiesWidget

QTableWidget *	fViewerPropertiesTableWidget

bool	fViewerPropertiesTableWidgetIsInit

G4AutoLock *	lWaitForVisSubThreadQtOpenGLContextInitialized

G4AutoLock *	lWaitForVisSubThreadQtOpenGLContextMoved

Detailed Description

Definition at line 45 of file G4OpenGLStoredQtViewer.hh.

Member Typedef Documentation

◆ PVNodeID

typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID G4OpenGLQtViewer::PVNodeID

privateinherited

Definition at line 88 of file G4OpenGLQtViewer.hh.

◆ PVPath

typedef std::vector<PVNodeID> G4OpenGLQtViewer::PVPath

privateinherited

Definition at line 89 of file G4OpenGLQtViewer.hh.

Member Enumeration Documentation

◆ RECORDING_STEP

enum G4OpenGLQtViewer::RECORDING_STEP

privateinherited

Enumerator
WAIT
START
PAUSE
CONTINUE
STOP
READY_TO_ENCODE
ENCODING
FAILED
SUCCESS
BAD_ENCODER
BAD_OUTPUT
BAD_TMP
SAVE

Definition at line 203 of file G4OpenGLQtViewer.hh.

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

G4OpenGLQtViewer::FAILED

@ FAILED

Definition: G4OpenGLQtViewer.hh:203

G4OpenGLQtViewer::START

@ START

Definition: G4OpenGLQtViewer.hh:203

G4OpenGLQtViewer::SUCCESS

@ SUCCESS

Definition: G4OpenGLQtViewer.hh:203

G4OpenGLQtViewer::STOP

@ STOP

Definition: G4OpenGLQtViewer.hh:203

G4OpenGLQtViewer::BAD_ENCODER

@ BAD_ENCODER

Definition: G4OpenGLQtViewer.hh:203

G4OpenGLQtViewer::CONTINUE

@ CONTINUE

Definition: G4OpenGLQtViewer.hh:203

G4OpenGLQtViewer::READY_TO_ENCODE

@ READY_TO_ENCODE

Definition: G4OpenGLQtViewer.hh:203

G4OpenGLQtViewer::PAUSE

@ PAUSE

Definition: G4OpenGLQtViewer.hh:203

G4OpenGLQtViewer::BAD_TMP

@ BAD_TMP

Definition: G4OpenGLQtViewer.hh:203

G4OpenGLQtViewer::ENCODING

@ ENCODING

Definition: G4OpenGLQtViewer.hh:203

G4OpenGLQtViewer::WAIT

@ WAIT

Definition: G4OpenGLQtViewer.hh:203

G4OpenGLQtViewer::BAD_OUTPUT

@ BAD_OUTPUT

Definition: G4OpenGLQtViewer.hh:203

G4OpenGLQtViewer::SAVE

@ SAVE

Definition: G4OpenGLQtViewer.hh:203

Constructor & Destructor Documentation

◆ G4OpenGLStoredQtViewer()

G4OpenGLStoredQtViewer::G4OpenGLStoredQtViewer	(	G4OpenGLStoredSceneHandler &	scene,
		const G4String &	name = `""`
	)

Definition at line 43 of file G4OpenGLStoredQtViewer.cc.

                       :
  G4VViewer (sceneHandler, sceneHandler.IncrementViewCount (), name),
  G4OpenGLViewer (sceneHandler),
  G4OpenGLQtViewer (sceneHandler),
  G4OpenGLStoredViewer (sceneHandler),             // FIXME : gerer le pb du parent !
  QGLWidget()
{
  if (fViewId < 0) return;  // In case error in base class instantiation.
 
  fQGLWidgetInitialiseCompleted = false;
 
    // Indicates that the widget has no background, i.e. when the widget receives paint events, the background is not automatically repainted. Note: Unlike WA_OpaquePaintEvent, newly exposed areas are never filled with the background (e.g., after showing a window for the first time the user can see "through" it until the application processes the paint events). This flag is set or cleared by the widget's author.
  QGLWidget::setAttribute (Qt::WA_NoSystemBackground);
 
  setFocusPolicy(Qt::StrongFocus); // enable keybord events
  fHasToRepaint = false;
  fPaintEventLock = false;
  fUpdateGLLock = false;
}

References G4OpenGLQtViewer::fHasToRepaint, G4OpenGLQtViewer::fPaintEventLock, G4OpenGLQtViewer::fQGLWidgetInitialiseCompleted, G4OpenGLQtViewer::fUpdateGLLock, and G4VViewer::fViewId.

◆ ~G4OpenGLStoredQtViewer()

G4OpenGLStoredQtViewer::~G4OpenGLStoredQtViewer ( )

Definition at line 65 of file G4OpenGLStoredQtViewer.cc.

                                                {
  //  makeCurrent();  // Not sure why this - commented out 12-Apr-2021 JA
  // this is connect to the Dialog for deleting it properly
  // when close event.
  //   ((QDialog*)window())->reject();
}

Member Function Documentation

◆ actionChangeBackgroundColor

void G4OpenGLQtViewer::actionChangeBackgroundColor ( )

privateslotinherited

Definition at line 1164 of file G4OpenGLQtViewer.cc.

                                                   {
 
  //   //I need to revisit the kernel if the background colour changes and
  //   //hidden line removal is enabled, because hlr drawing utilises the
  //   //background colour in its drawing...
  //   // (Note added by JA 13/9/2005) Background now handled in view
  //   // parameters.  A kernel visit is triggered on change of background.
 
#if QT_VERSION < 0x040500
  bool a;
  const QColor color = QColor(QColorDialog::getRgba (QColor(Qt::black).rgba(),&a,fGLWidget));
#else
  const QColor color =
    QColorDialog::getColor(Qt::black,
                           fGLWidget,
                           " Get background color and transparency",
                           QColorDialog::ShowAlphaChannel);
#endif
  if (color.isValid()) {
    G4Colour colour(((G4double)color.red())/255,
                    ((G4double)color.green())/255,
                    ((G4double)color.blue())/255,
                    ((G4double)color.alpha())/255);
    fVP.SetBackgroundColour(colour);
 
    updateToolbarAndMouseContextMenu();
    updateQWidget();
  }
}

References G4OpenGLQtViewer::fGLWidget, G4VViewer::fVP, G4ViewParameters::SetBackgroundColour(), G4OpenGLQtViewer::updateQWidget(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ actionChangeDefaultColor

void G4OpenGLQtViewer::actionChangeDefaultColor ( )

privateslotinherited

Definition at line 1219 of file G4OpenGLQtViewer.cc.

                                                {
 
#if QT_VERSION < 0x040500
  bool a;
  const QColor color = QColor(QColorDialog::getRgba (QColor(Qt::white).rgba(),&a,fGLWidget));
#else
  const QColor& color =
    QColorDialog::getColor(Qt::white,
                           fGLWidget,
                           " Get default color and transparency",
                           QColorDialog::ShowAlphaChannel);
#endif
  if (color.isValid()) {
    G4Colour colour(((G4double)color.red())/255,
                    ((G4double)color.green())/255,
                    ((G4double)color.blue())/255,
                    ((G4double)color.alpha())/255);
 
    fVP.SetDefaultColour(colour);
 
    updateToolbarAndMouseContextMenu();
    updateQWidget();
  }
}

References G4OpenGLQtViewer::fGLWidget, G4VViewer::fVP, G4ViewParameters::SetDefaultColour(), G4OpenGLQtViewer::updateQWidget(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ actionChangeTextColor

void G4OpenGLQtViewer::actionChangeTextColor ( )

privateslotinherited

Definition at line 1194 of file G4OpenGLQtViewer.cc.

                                             {
 
#if QT_VERSION < 0x040500
  bool a;
  const QColor color = QColor(QColorDialog::getRgba (QColor(Qt::yellow).rgba(),&a,fGLWidget));
#else
  const QColor& color =
    QColorDialog::getColor(Qt::yellow,
                           fGLWidget,
                           " Get text color and transparency",
                           QColorDialog::ShowAlphaChannel);
#endif
  if (color.isValid()) {
    G4Colour colour(((G4double)color.red())/255,
                    ((G4double)color.green())/255,
                    ((G4double)color.blue())/255,
                    ((G4double)color.alpha())/255);
 
    fVP.SetDefaultTextColour(colour);
 
    updateToolbarAndMouseContextMenu();
    updateQWidget();
  }
}

References G4OpenGLQtViewer::fGLWidget, G4VViewer::fVP, G4ViewParameters::SetDefaultTextColour(), G4OpenGLQtViewer::updateQWidget(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ actionMovieParameters

void G4OpenGLQtViewer::actionMovieParameters ( )

privateslotinherited

Definition at line 1245 of file G4OpenGLQtViewer.cc.

                                             {
  showMovieParametersDialog();
}

References G4OpenGLQtViewer::showMovieParametersDialog().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ actionSaveImage

void G4OpenGLQtViewer::actionSaveImage ( )

privateslotinherited

Definition at line 1094 of file G4OpenGLQtViewer.cc.

                                       {
  QString filters;
  for (unsigned int i = 0; i < fExportImageFormatVector.size(); ++i) {
    filters += QString("*.") + fExportImageFormatVector.at(i).c_str() + ";;";
  }
 
  QString* selectedFormat = new QString(fDefaultExportImageFormat.c_str());
  QString qFilename;
  qFilename =  QFileDialog::getSaveFileName ( fGLWidget,
                                         tr("Save as ..."),
                                         fFileSavePath,
                                         filters,
                                         selectedFormat );
 
 
  std::string name = qFilename.toStdString().c_str();
 
  // bmp jpg jpeg png ppm xbm xpm
  if (name.empty()) {
    return;
  }
 
  fFileSavePath = QFileInfo(qFilename).path();
 
  std::string format = selectedFormat->toLower().toStdString().c_str();
 
  // set the format to current
  fExportImageFormat = format.substr(format.find_last_of(".") + 1);
 
  std::string filename = name;
  std::string extension = "";
  if (name.find_last_of(".") != std::string::npos) {
    filename = name.substr(0,name.find_last_of(".") + 1);
    extension = name.substr(name.find_last_of(".") + 1);
  } else {
    extension = fExportImageFormat;
  }
 
  filename+= "."+ extension;
 
  if (!setExportFilename(filename.c_str(),0)) {
    return;
  }
 
  G4OpenGLQtExportDialog* exportDialog= new G4OpenGLQtExportDialog(fGLWidget,format.c_str(),fGLWidget->height(),fGLWidget->width());
  if(  exportDialog->exec()) {
 
    if ((exportDialog->getWidth() !=fGLWidget->width()) ||
        (exportDialog->getHeight() !=fGLWidget->height())) {
      setExportSize(exportDialog->getWidth(),exportDialog->getHeight());
 
    }
    if (fExportImageFormat == "eps") {
      fVectoredPs = exportDialog->getVectorEPS();
    } else if (fExportImageFormat == "ps") {
      fVectoredPs = true;
    }
    fLastExportSliderValue = exportDialog->getSliderValue();
 
    if (exportImage(filename)) {
      // set the default format to current
      fDefaultExportImageFormat = format;
    }
  } else { // cancel selected
    return;
  }
 
}

References G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::fDefaultExportImageFormat, G4OpenGLViewer::fExportImageFormat, G4OpenGLViewer::fExportImageFormatVector, G4OpenGLQtViewer::fFileSavePath, G4OpenGLQtViewer::fGLWidget, G4OpenGLQtViewer::fLastExportSliderValue, G4OpenGLViewer::fVectoredPs, G4OpenGLQtExportDialog::getHeight(), G4OpenGLQtExportDialog::getSliderValue(), G4OpenGLQtExportDialog::getVectorEPS(), G4OpenGLQtExportDialog::getWidth(), G4InuclParticleNames::name(), G4OpenGLViewer::setExportFilename(), and G4OpenGLViewer::setExportSize().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ addExportImageFormat()

void G4OpenGLViewer::addExportImageFormat ( std::string format )

protectedinherited

Definition at line 1288 of file G4OpenGLViewer.cc.

                                                          {
  fExportImageFormatVector.push_back(format);
}

References G4OpenGLViewer::fExportImageFormatVector.

Referenced by G4OpenGLQtViewer::G4OpenGLQtViewer(), and G4OpenGLViewer::G4OpenGLViewer().

◆ addNonPVSceneTreeElement()

void G4OpenGLQtViewer::addNonPVSceneTreeElement	(	const G4String &	model,
		int	currentPVPOIndex,
		const std::string &	modelDescription,
		const G4Visible &	visible
	)

inherited

Definition at line 3344 of file G4OpenGLQtViewer.cc.

  {
 
  QString modelShortName = getModelShortName(model);
  G4Colour color;
 
  // Special case for text
  try {
    const G4Text& g4Text = dynamic_cast<const G4Text&>(visible);
    color = fSceneHandler.GetTextColour(g4Text);
  }
  catch (const std::bad_cast&) {
    color = fSceneHandler.GetColour();
  }
 
  // Special case for marker
  try {
    const G4VMarker& g4Marker = dynamic_cast<const G4VMarker&>(visible);
    if (g4Marker.GetInfo() != "") {
      modelShortName = g4Marker.GetInfo();
    }
  }
  catch (const std::bad_cast&) {}
 
  if (modelShortName == "") {
    return ;
  }
  // try to init it
  if (fSceneTreeComponentTreeWidget == NULL) {
    createSceneTreeComponent();
  }
 
  // if no UI
  if (fSceneTreeComponentTreeWidget == NULL) {
    return;
  }
 
  fSceneTreeComponentTreeWidget->blockSignals(true);
 
  // Create the "Model" node if not
 
  QList<QTreeWidgetItem *> resItem;
  resItem =  fSceneTreeComponentTreeWidget->findItems (modelShortName, Qt::MatchExactly, 0 );
  QTreeWidgetItem * currentItem = NULL;
  const PVPath tmpFullPath;
 
  if (resItem.empty()) {
    currentItem = createTreeWidgetItem(tmpFullPath,
                                       modelShortName,
                                       0, // currentPVCopyNb
                                       -1, // currentPVPOIndex
                                       "",
                                       Qt::Checked,
                                       NULL,
                                       color);
  } else {
    currentItem = resItem.first();
  }
 
  // Is this volume already in the tree AND PO is not the same?
  const QList<QTreeWidgetItem *>&
  resItems =  fSceneTreeComponentTreeWidget->findItems (QString(modelDescription.c_str()), Qt::MatchFixedString| Qt::MatchCaseSensitive|Qt::MatchRecursive, 0 );
 
  bool alreadyPresent = false;
  for (int i = 0; i < resItems.size(); ++i) {
    if (currentPOIndex == resItems.at(i)->data(0,Qt::UserRole).toInt()) {
      alreadyPresent = true;
    }
  }
  if (!alreadyPresent) {
    createTreeWidgetItem(tmpFullPath,
                         modelShortName,
                         0, // currentPVCopyNb
                         currentPOIndex,
                         "",
                         Qt::Checked,
                         currentItem,
                         color);
  }
  fSceneTreeComponentTreeWidget->blockSignals(false);
 
}

References G4OpenGLQtViewer::createSceneTreeComponent(), G4OpenGLQtViewer::createTreeWidgetItem(), G4VViewer::fSceneHandler, G4OpenGLQtViewer::fSceneTreeComponentTreeWidget, G4VSceneHandler::GetColour(), G4VMarker::GetInfo(), G4OpenGLQtViewer::getModelShortName(), and G4VSceneHandler::GetTextColour().

Referenced by G4OpenGLStoredQtSceneHandler::ExtraPOProcessing().

◆ AddPrimitiveForASingleFrame() [1/2]

void G4OpenGLStoredViewer::AddPrimitiveForASingleFrame ( const G4Circle & circle )

protectedinherited

Definition at line 485 of file G4OpenGLStoredViewer.cc.

{
  // We don't want this to get into a display list or a TODL or a PODL so
  // use the fMemoryForDisplayLists flag.
  G4bool memoryForDisplayListsKeep = fG4OpenGLStoredSceneHandler.fMemoryForDisplayLists;
  fG4OpenGLStoredSceneHandler.fMemoryForDisplayLists = false;
  fG4OpenGLStoredSceneHandler.G4OpenGLStoredSceneHandler::AddPrimitive(circle);
  fG4OpenGLStoredSceneHandler.fMemoryForDisplayLists = memoryForDisplayListsKeep;
}

References G4OpenGLStoredViewer::fG4OpenGLStoredSceneHandler, and G4OpenGLStoredSceneHandler::fMemoryForDisplayLists.

◆ AddPrimitiveForASingleFrame() [2/2]

void G4OpenGLStoredViewer::AddPrimitiveForASingleFrame ( const G4Text & text )

protectedinherited

Definition at line 475 of file G4OpenGLStoredViewer.cc.

{
  // We don't want this to get into a display list or a TODL or a PODL so
  // use the fMemoryForDisplayLists flag.
  G4bool memoryForDisplayListsKeep = fG4OpenGLStoredSceneHandler.fMemoryForDisplayLists;
  fG4OpenGLStoredSceneHandler.fMemoryForDisplayLists = false;
  fG4OpenGLStoredSceneHandler.G4OpenGLStoredSceneHandler::AddPrimitive(text);
  fG4OpenGLStoredSceneHandler.fMemoryForDisplayLists = memoryForDisplayListsKeep;
}

References G4OpenGLStoredViewer::fG4OpenGLStoredSceneHandler, and G4OpenGLStoredSceneHandler::fMemoryForDisplayLists.

Referenced by G4OpenGLStoredViewer::DrawDisplayLists().

◆ addPVSceneTreeElement()

void G4OpenGLQtViewer::addPVSceneTreeElement	(	const G4String &	model,
		G4PhysicalVolumeModel *	pPVModel,
		int	currentPVPOIndex
	)

inherited

Definition at line 2876 of file G4OpenGLQtViewer.cc.

                                                                                                                       {
 
  const QString& modelShortName = getModelShortName(model);
 
  if (modelShortName == "") {
    return ;
  }
  // try to init it
  if (fSceneTreeComponentTreeWidget == NULL) {
    createSceneTreeComponent();
  }
 
  // if no UI
  if (fSceneTreeComponentTreeWidget == NULL) {
    return;
  }
 
  fSceneTreeComponentTreeWidget->blockSignals(true);
 
  // Create the "volume" node if not
  //  if (fSceneTreeComponentTreeWidget->topLevelItemCount () == 0) {
  if (!fPVRootNodeCreate) {
    const G4Colour& color = fSceneHandler.GetColour();
 
    fModelShortNameItem = createTreeWidgetItem(pPVModel->GetFullPVPath(),
                                               modelShortName,
                                               0, // currentPVCopyNb
                                               -1, // currentPVPOIndex
                                               "",
                                               Qt::Checked,
                                               NULL,
                                               color);
    fPVRootNodeCreate = true;
  }
 
  bool added = parseAndInsertInSceneTree(fModelShortNameItem,pPVModel,0,modelShortName,0,currentPOIndex);
  if (!added) {
  }
 
  fSceneTreeComponentTreeWidget->blockSignals(false);
 
}

References G4OpenGLQtViewer::createSceneTreeComponent(), G4OpenGLQtViewer::createTreeWidgetItem(), G4OpenGLQtViewer::fModelShortNameItem, G4OpenGLQtViewer::fPVRootNodeCreate, G4VViewer::fSceneHandler, G4OpenGLQtViewer::fSceneTreeComponentTreeWidget, G4VSceneHandler::GetColour(), G4PhysicalVolumeModel::GetFullPVPath(), G4OpenGLQtViewer::getModelShortName(), and G4OpenGLQtViewer::parseAndInsertInSceneTree().

Referenced by G4OpenGLStoredQtSceneHandler::ExtraPOProcessing().

◆ changeColorAndTransparency() [1/2]

void G4OpenGLQtViewer::changeColorAndTransparency	(	GLuint	index,
		G4Color	color
	)

privateinherited

Definition at line 3643 of file G4OpenGLQtViewer.cc.

                                                                             {
 
  // change vis attributes to set new colour
  G4int iPO = index;
  if (iPO >= 0 && fTreeItemModels.find(iPO) != fTreeItemModels.end()) {
    const PVPath& fullPath = fTreeItemModels[iPO];
    // If a physical volume
    if (fullPath.size()) {
      SetTouchable(fullPath);
      TouchableSetColour(fullPath, color);
      fMouseOnSceneTree = true;
    }
  }
}

References G4OpenGLQtViewer::fMouseOnSceneTree, G4OpenGLQtViewer::fTreeItemModels, G4VViewer::SetTouchable(), and G4VViewer::TouchableSetColour().

Referenced by G4OpenGLQtViewer::changeColorAndTransparency(), G4OpenGLQtViewer::createSceneTreeComponent(), and G4OpenGLQtViewer::updatePickInfosWidget().

◆ changeColorAndTransparency [2/2]

void G4OpenGLQtViewer::changeColorAndTransparency	(	QTreeWidgetItem *	item,
		int	val
	)

privateslotinherited

Definition at line 3612 of file G4OpenGLQtViewer.cc.

                                                                           {
 
  if (item == NULL) {
    return;
  }
  const QColor& old = QColor(item->data(2,Qt::UserRole).value<QColor>());
 
#if QT_VERSION < 0x040500
  bool a;
  const QColor& color = QColor(QColorDialog::getRgba (old.rgba(),&a,fSceneTreeComponentTreeWidget));
#else
  const QColor& color = QColorDialog::getColor(old,
                                        fSceneTreeComponentTreeWidget,
                                        " Get color and transparency",
                                        QColorDialog::ShowAlphaChannel);
#endif
 
  if (color.isValid()) {
 
    changeColorAndTransparency(item->data(0,Qt::UserRole).toInt(),
                               G4Colour (((G4double)color.red())/255,
                                         ((G4double)color.green())/255,
                                         ((G4double)color.blue())/255,
                                         ((G4double)color.alpha())/255));
 
    // set scene tree parameters
    changeQColorForTreeWidgetItem(item,color);
  }
}

References G4OpenGLQtViewer::changeColorAndTransparency(), G4OpenGLQtViewer::changeQColorForTreeWidgetItem(), and G4OpenGLQtViewer::fSceneTreeComponentTreeWidget.

◆ changeDepthInSceneTree

void G4OpenGLQtViewer::changeDepthInSceneTree ( int val )

privateslotinherited

Definition at line 3575 of file G4OpenGLQtViewer.cc.

                                                     {
 
  // If no scene tree (Immediate viewer)
  if (fSceneTreeComponentTreeWidget == NULL) {
    return;
  }
 
  // max depth :   fSceneTreeDepth
  // val is between 0 and 1
  // 0  .1  .2  .3  .4  .5  .6  .7  .8  .9  1
  // 1      1.4          2
  // 1         2         3         4
 
  // Get the depth :
  double depth = 1 + ((double)val)/1000 * ((double)fSceneTreeDepth+1);
 
  // lock update on scene tree items
  fCheckSceneTreeComponentSignalLock = true;
 
  // Disable redraw each time !
  G4bool currentAutoRefresh = fVP.IsAutoRefresh();
  fVP.SetAutoRefresh(false);
 
  for (int b=0;b<fSceneTreeComponentTreeWidget->topLevelItemCount();b++) {
    changeDepthOnSceneTreeItem(depth,1.,fSceneTreeComponentTreeWidget->topLevelItem(b));
  }
 
  // Enable redraw !
  fVP.SetAutoRefresh(currentAutoRefresh);
  updateQWidget();
 
  // unlock update on scene tree items
  fCheckSceneTreeComponentSignalLock = false;
 
}

References G4OpenGLQtViewer::changeDepthOnSceneTreeItem(), G4OpenGLQtViewer::fCheckSceneTreeComponentSignalLock, G4OpenGLQtViewer::fSceneTreeComponentTreeWidget, G4OpenGLQtViewer::fSceneTreeDepth, G4VViewer::fVP, G4ViewParameters::IsAutoRefresh(), G4ViewParameters::SetAutoRefresh(), and G4OpenGLQtViewer::updateQWidget().

Referenced by G4OpenGLQtViewer::createSceneTreeComponent().

◆ changeDepthOnSceneTreeItem()

void G4OpenGLQtViewer::changeDepthOnSceneTreeItem	(	double	lookForDepth,
		double	currentDepth,
		QTreeWidgetItem *	item
	)

privateinherited

Definition at line 3794 of file G4OpenGLQtViewer.cc.

  {
  double transparencyLevel = 0.;
 
  // look for a 2.2 depth and we are at level 3
  // -> Set all theses items to Opaque
  // ONLY if it is a PV volume !
  if (isPVVolume(item)) {
    if ((lookForDepth-currentDepth) < 0) {
      item->setCheckState(0,Qt::Checked);
      updatePositivePoIndexSceneTreeWidgetQuickMap(item->data(0,Qt::UserRole).toInt(),item);
      transparencyLevel = 1;
    } else if ((lookForDepth-currentDepth) > 1 ){
      item->setCheckState(0,Qt::Unchecked);
      updatePositivePoIndexSceneTreeWidgetQuickMap(item->data(0,Qt::UserRole).toInt(),item);
      transparencyLevel = 0;
    } else {
      item->setCheckState(0,Qt::Checked);
      updatePositivePoIndexSceneTreeWidgetQuickMap(item->data(0,Qt::UserRole).toInt(),item);
      transparencyLevel = 1-(lookForDepth-currentDepth);
    }
  }
 
  if (item->data(0,Qt::UserRole).toInt() >= 0) {
    const G4Colour& color = getColorForPoIndex(item->data(0,Qt::UserRole).toInt());
 
    // We are less depper (ex:tree depth:2) than lookForDepth (ex:3.1)
    // -> Have to hide this level ONLY if it was not hidden before
 
    // Not on a top level item case
    // Do not set if it was already set
 
    // Should add them all the time in case of an older command has change transparency
    // before. Should be checked in changeDepthInSceneTree for duplicated commands
    // Do not change transparency if not visible by humain (and avoid precision value
    // problems..)
    if (((color.GetAlpha()-transparencyLevel) >  0.000001) ||
        ((color.GetAlpha()-transparencyLevel) < -0.000001))  {
      if ((item->text(3) != "")) {
        // FIXME : Should not test this here because of transparent
        // volume that will came after and with a different alpha level
        // Good thing to do is to check and suppress doubles in changeDepthInSceneTree
        // and then check if last (transparents volumes) has to change alpha
 
        changeQColorForTreeWidgetItem(item,QColor((int)(color.GetRed()*255),
                                                  (int)(color.GetGreen()*255),
                                                  (int)(color.GetBlue()*255),
                                                  (int)(transparencyLevel*255)));
      }
    }
  }
 
  for (int b=0;b< item->childCount();b++) {
    changeDepthOnSceneTreeItem(lookForDepth,currentDepth+1,item->child(b));
  }
}

References G4OpenGLQtViewer::changeDepthOnSceneTreeItem(), G4OpenGLQtViewer::changeQColorForTreeWidgetItem(), G4Colour::GetAlpha(), G4Colour::GetBlue(), G4OpenGLQtViewer::getColorForPoIndex(), G4Colour::GetGreen(), G4Colour::GetRed(), G4OpenGLQtViewer::isPVVolume(), and G4OpenGLQtViewer::updatePositivePoIndexSceneTreeWidgetQuickMap().

Referenced by G4OpenGLQtViewer::changeDepthInSceneTree(), and G4OpenGLQtViewer::changeDepthOnSceneTreeItem().

◆ ChangeLineWidth()

void G4OpenGLViewer::ChangeLineWidth ( G4double width )

protectedinherited

Change LineSize on gl2ps if needed

Definition at line 810 of file G4OpenGLViewer.cc.

                                                   {
 
  if (isGl2psWriting()) {
    fGL2PSAction->setLineWidth(int(width));
  } else {
    glLineWidth (width);
  }
}

References G4OpenGLViewer::fGL2PSAction, G4OpenGLViewer::isGl2psWriting(), and G4OpenGL2PSAction::setLineWidth().

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLViewer::HaloingFirstPass(), and G4OpenGLViewer::HaloingSecondPass().

◆ changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement()

void G4OpenGLQtViewer::changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement ( QTreeWidgetItem * subItem )

privateinherited

Definition at line 3180 of file G4OpenGLQtViewer.cc.

{
  // Check if object with the same POIndex is the same in old tree
  QTreeWidgetItem* oldItem = NULL;
 
  QTreeWidgetItem* foundItem = getOldTreeWidgetItem(subItem->data(0,Qt::UserRole).toInt());
 
  if (foundItem != NULL) {
    if (isSameSceneTreeElement(foundItem,subItem)) {
      oldItem = foundItem;
    }
  }
  if (foundItem == NULL) {  // PO should have change, parse all
 
    // POindex > 0
    std::map <int, QTreeWidgetItem*>::const_iterator i;
    i = fOldPositivePoIndexSceneTreeWidgetQuickMap.begin();
    while (i != fOldPositivePoIndexSceneTreeWidgetQuickMap.end()) {
      if (isSameSceneTreeElement(i->second,subItem)) {
        oldItem = i->second;
        i = fOldPositivePoIndexSceneTreeWidgetQuickMap.end();
      } else {
        i++;
      }
    }
    // POindex == 0 ?
    if (oldItem == NULL) {
      unsigned int a = 0;
      while (a < fOldNullPoIndexSceneTreeWidgetQuickVector.size()) {
        if (isSameSceneTreeElement(fOldNullPoIndexSceneTreeWidgetQuickVector[a],subItem)) {
          oldItem = fOldNullPoIndexSceneTreeWidgetQuickVector[a];
          a = fOldNullPoIndexSceneTreeWidgetQuickVector.size();
        } else {
          a++;
        }
      }
    }
  }
 
  // if found : retore old state
  if (oldItem != NULL) {
    subItem->setFlags(oldItem->flags());   // flags
    subItem->setCheckState(0,oldItem->checkState(0)); // check state
    subItem->setSelected(oldItem->isSelected());  // selected
    subItem->setExpanded(oldItem->isExpanded ());  // expand
 
    // change color
    // when we call this function, the color in the item is the one of vis Attr
 
    std::map <int, QTreeWidgetItem* >::iterator it;
 
    // getOldPO
    int oldPOIndex = oldItem->data(0,Qt::UserRole).toInt();
    it = fOldPositivePoIndexSceneTreeWidgetQuickMap.find(oldPOIndex);
    QColor color;
 
    // get old Vis Attr Color
    std::map <int, QColor >::iterator itVis;
    itVis = fOldVisAttrColorMap.find(oldPOIndex);
 
    QColor oldVisAttrColor;
    const QColor& newVisAttrColor = subItem->data(2,Qt::UserRole).value<QColor>();
 
    bool visAttrChange = false;
    // if old vis attr color found
    if (itVis != fOldVisAttrColorMap.end()) {
      oldVisAttrColor = itVis->second;
      if (oldVisAttrColor != newVisAttrColor) {
        visAttrChange = true;
      }
    } else {
      visAttrChange = true;
    }
 
    if (visAttrChange) {
      fOldVisAttrColorMap.insert(std::pair <int, QColor > (subItem->data(0,Qt::UserRole).toInt(),newVisAttrColor) );
 
    } else { // if no changes, get old PO value
      // if old PO found
      if (it != fOldPositivePoIndexSceneTreeWidgetQuickMap.end()) {
        color = (it->second)->data(2,Qt::UserRole).value<QColor>();
      } else {
        color = oldItem->data(2,Qt::UserRole).value<QColor>();
      }
      changeQColorForTreeWidgetItem(subItem,color);
    }
  }
 
  return;
}

References G4OpenGLQtViewer::changeQColorForTreeWidgetItem(), G4OpenGLQtViewer::fOldNullPoIndexSceneTreeWidgetQuickVector, G4OpenGLQtViewer::fOldPositivePoIndexSceneTreeWidgetQuickMap, G4OpenGLQtViewer::fOldVisAttrColorMap, G4OpenGLQtViewer::getOldTreeWidgetItem(), and G4OpenGLQtViewer::isSameSceneTreeElement().

Referenced by G4OpenGLQtViewer::createTreeWidgetItem().

◆ ChangePointSize()

void G4OpenGLViewer::ChangePointSize ( G4double size )

protectedinherited

Change PointSize on gl2ps if needed

Definition at line 798 of file G4OpenGLViewer.cc.

                                                  {
 
  if (isGl2psWriting()) {
    fGL2PSAction->setPointSize(int(size));
  } else {
    glPointSize (size);
  }
}

References G4OpenGLViewer::fGL2PSAction, G4OpenGLViewer::isGl2psWriting(), and G4OpenGL2PSAction::setPointSize().

Referenced by G4OpenGLSceneHandler::AddPrimitive().

◆ changeQColorForTreeWidgetItem()

void G4OpenGLQtViewer::changeQColorForTreeWidgetItem	(	QTreeWidgetItem *	item,
		const QColor &	qc
	)

privateinherited

Definition at line 3985 of file G4OpenGLQtViewer.cc.

                                                                                           {
 
  int POIndex = item->data(0,Qt::UserRole).toInt();
  updatePositivePoIndexSceneTreeWidgetQuickMap(POIndex,item );
 
  QPixmap pixmap = QPixmap(QSize(16, 16));
  if (item->data(0,Qt::UserRole).toInt() != -1) {
    pixmap.fill (qc);
  } else {
    pixmap.fill (QColor(255,255,255,255));
  }
  QPainter painter(&pixmap);
  painter.setPen(Qt::black);
  painter.drawRect(0,0,15,15); // Draw contour
 
  item->setIcon(0,pixmap);
  item->setData(2,Qt::UserRole,qc);
}

References G4OpenGLQtViewer::updatePositivePoIndexSceneTreeWidgetQuickMap().

Referenced by G4OpenGLQtViewer::changeColorAndTransparency(), G4OpenGLQtViewer::changeDepthOnSceneTreeItem(), G4OpenGLQtViewer::changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement(), G4OpenGLQtViewer::createTreeWidgetItem(), and G4OpenGLQtViewer::parseAndInsertInSceneTree().

◆ changeSearchSelection

void G4OpenGLQtViewer::changeSearchSelection ( )

privateslotinherited

Definition at line 3740 of file G4OpenGLQtViewer.cc.

{
  const QString& searchText = fFilterOutput->text();
  if (fSceneTreeComponentTreeWidget == NULL) {
    return;
  }
 
  // unselect all
  for (int a=0; a<fSceneTreeComponentTreeWidget->topLevelItemCount(); a++) {
    fSceneTreeComponentTreeWidget->topLevelItem(a)->setExpanded(false);
    fSceneTreeComponentTreeWidget->topLevelItem(a)->setSelected(false);
    clearSceneTreeSelection(fSceneTreeComponentTreeWidget->topLevelItem(a));
  }
 
  QList<QTreeWidgetItem *> itemList = fSceneTreeComponentTreeWidget->findItems (searchText,Qt::MatchContains | Qt::MatchRecursive,0);
 
  for (int i = 0; i < itemList.size(); ++i) {
    QTreeWidgetItem* expandParentItem = itemList.at(i);
    while (expandParentItem->parent() != NULL) {
      expandParentItem->parent()->setExpanded(true);
      expandParentItem = expandParentItem->parent();
    }
    itemList.at(i)->setSelected(true);
  }
 
}

References G4OpenGLQtViewer::clearSceneTreeSelection(), G4OpenGLQtViewer::fFilterOutput, and G4OpenGLQtViewer::fSceneTreeComponentTreeWidget.

Referenced by G4OpenGLQtViewer::createSceneTreeComponent().

◆ clearSceneTreeSelection()

void G4OpenGLQtViewer::clearSceneTreeSelection ( QTreeWidgetItem * item )

privateinherited

Definition at line 3768 of file G4OpenGLQtViewer.cc.

                                                                    {
  for (int a=0; a<item->childCount(); a++) {
    item->child(a)->setSelected(false);
    item->child(a)->setExpanded(false);
    clearSceneTreeSelection(item->child(a));
  }
 
}

References G4OpenGLQtViewer::clearSceneTreeSelection().

Referenced by G4OpenGLQtViewer::changeSearchSelection(), and G4OpenGLQtViewer::clearSceneTreeSelection().

◆ clearTreeWidget()

void G4OpenGLQtViewer::clearTreeWidget ( )

inherited

Definition at line 3855 of file G4OpenGLQtViewer.cc.

                                      {
  // be careful about calling this twice
 
  if (fSceneTreeComponentTreeWidget) {
 
    if (fSceneTreeComponentTreeWidget->topLevelItemCount () > 0) {
 
      fPVRootNodeCreate = false;
 
      // reset all old
      fOldPositivePoIndexSceneTreeWidgetQuickMap.clear();
      fOldNullPoIndexSceneTreeWidgetQuickVector.clear();
      fOldTreeItemModels.clear();
 
      // Clone everything
      for (int b =0; b <fSceneTreeComponentTreeWidget->topLevelItemCount();b++) {
        // All tree widgets are in :
        // then we could get the old POindex and get
        // .visible/Hidden
        // .Check/Uncheck
        // .selected
        // .colour status from std::map
 
        // clone top level items
        int poIndex = fSceneTreeComponentTreeWidget->topLevelItem(b)->data(0,Qt::UserRole).toInt();
        if (poIndex != -1) {
          fOldPositivePoIndexSceneTreeWidgetQuickMap.insert(std::pair <int, QTreeWidgetItem*> (poIndex,cloneWidgetItem(fSceneTreeComponentTreeWidget->topLevelItem(b))));
        } else {
          fOldNullPoIndexSceneTreeWidgetQuickVector.push_back(cloneWidgetItem(fSceneTreeComponentTreeWidget->topLevelItem(b)));
        }
 
        // clone leaves
        cloneSceneTree(fSceneTreeComponentTreeWidget->topLevelItem(b));
      }
      // delete all elements
 
      fOldTreeItemModels.insert(fTreeItemModels.begin(), fTreeItemModels.end());
 
      // all is copy, then clear scene tree
      int tmp2 = fSceneTreeComponentTreeWidget->topLevelItemCount();
      while (tmp2 > 0) {
        delete fSceneTreeComponentTreeWidget->takeTopLevelItem (0);
        tmp2 = fSceneTreeComponentTreeWidget->topLevelItemCount();
      }
      fPositivePoIndexSceneTreeWidgetQuickMap.clear();
 
      // put correct value in paramaters
      fOldLastSceneTreeWidgetAskForIterator = fOldPositivePoIndexSceneTreeWidgetQuickMap.begin();
      fOldLastSceneTreeWidgetAskForIteratorEnd = fOldPositivePoIndexSceneTreeWidgetQuickMap.end();
      fSceneTreeDepth = 1;
      fModelShortNameItem = NULL;
      fMaxPOindexInserted = -1;
 
    }
  }
}

Referenced by G4OpenGLStoredQtSceneHandler::ClearStore(), and G4OpenGLStoredQtSceneHandler::SetScene().

◆ clearTreeWidgetElements()

void G4OpenGLQtViewer::clearTreeWidgetElements ( QTreeWidgetItem * item )

privateinherited

◆ ClearView()

void G4OpenGLViewer::ClearView ( void )

virtualinherited

Implements G4VViewer.

Definition at line 203 of file G4OpenGLViewer.cc.

                                {
  ClearViewWithoutFlush();
 
  if(!isFramebufferReady()) {
    return;
  }
 
  glFlush();
}

References G4OpenGLViewer::ClearViewWithoutFlush(), and G4OpenGLViewer::isFramebufferReady().

◆ ClearViewWithoutFlush()

void G4OpenGLViewer::ClearViewWithoutFlush ( )

inherited

Definition at line 214 of file G4OpenGLViewer.cc.

                                            {
  // Ready for clear ?
  // See : http://lists.apple.com/archives/mac-opengl/2012/Jul/msg00038.html
  if(!isFramebufferReady()) {
    return;
  }
  
  glClearColor (background.GetRed(),
                background.GetGreen(),
                background.GetBlue(),
                1.);
  glClearDepth (1.0);
  //Below line does not compile with Mesa includes.
  //glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glClear (GL_COLOR_BUFFER_BIT);
  glClear (GL_DEPTH_BUFFER_BIT);
  glClear (GL_STENCIL_BUFFER_BIT);
}

References G4OpenGLViewer::background, G4Colour::GetBlue(), G4Colour::GetGreen(), G4Colour::GetRed(), and G4OpenGLViewer::isFramebufferReady().

Referenced by G4OpenGLViewer::ClearView().

◆ cloneSceneTree()

void G4OpenGLQtViewer::cloneSceneTree ( QTreeWidgetItem * rootItem )

privateinherited

Clone the current tree in order to get a snapshot of old version

Definition at line 3945 of file G4OpenGLQtViewer.cc.

  {
 
  for (int b=0;b< rootItem->childCount();b++) {
 
    QTreeWidgetItem *child = rootItem->child(b);
 
    // clone top level items
    int poIndex = child->data(0,Qt::UserRole).toInt();
    if (poIndex != -1) {
      fOldPositivePoIndexSceneTreeWidgetQuickMap.insert(std::pair <int, QTreeWidgetItem*> (poIndex,cloneWidgetItem(child)));
    } else {
      fOldNullPoIndexSceneTreeWidgetQuickVector.push_back(cloneWidgetItem(child));
    }
    cloneSceneTree(child);
  }
}

References G4OpenGLQtViewer::cloneSceneTree(), G4OpenGLQtViewer::cloneWidgetItem(), G4OpenGLQtViewer::fOldNullPoIndexSceneTreeWidgetQuickVector, and G4OpenGLQtViewer::fOldPositivePoIndexSceneTreeWidgetQuickMap.

Referenced by G4OpenGLQtViewer::clearTreeWidget(), and G4OpenGLQtViewer::cloneSceneTree().

◆ cloneWidgetItem()

QTreeWidgetItem * G4OpenGLQtViewer::cloneWidgetItem ( QTreeWidgetItem * item )

privateinherited

Clone :

Open/close
Visible/hidden
Selected

Definition at line 3919 of file G4OpenGLQtViewer.cc.

                                                                         {
 
  QTreeWidgetItem* cloneItem = new QTreeWidgetItem();
 
  // Clone what is create createTreeWidgetItem step
 
  cloneItem->setText(0,item->text(0));
  cloneItem->setData(1,Qt::UserRole,item->data(1,Qt::UserRole).toInt());
  cloneItem->setText(2,item->text(2));
  cloneItem->setData(0, Qt::UserRole,item->data(0,Qt::UserRole).toInt());
  cloneItem->setText(3,item->text(3));
  cloneItem->setFlags(item->flags());
  cloneItem->setToolTip(0,item->toolTip(0));
  cloneItem->setCheckState(0,item->checkState(0));
  cloneItem->setSelected(item->isSelected());
  cloneItem->setExpanded(item->isExpanded ());
 
  cloneItem->setData(2,Qt::UserRole,item->data(2,Qt::UserRole).value<QColor>());
 
  return cloneItem;
}

Referenced by G4OpenGLQtViewer::clearTreeWidget(), and G4OpenGLQtViewer::cloneSceneTree().

◆ CompareForKernelVisit()

G4bool G4OpenGLStoredQtViewer::CompareForKernelVisit ( G4ViewParameters & lastVP )

protectedvirtual

Reimplemented from G4OpenGLStoredViewer.

Definition at line 108 of file G4OpenGLStoredQtViewer.cc.

{
  // Identical to G4OpenGLStoredViewer::CompareForKernelVisit except
  // for checking of VisAttributesModifiers, because
  // G4OpenGLStoredQtViewer keeps track of its own touchable
  // modifiers (fTreeItemModels, etc.).
  if (
      (lastVP.GetDrawingStyle ()    != fVP.GetDrawingStyle ())    ||
      (lastVP.GetNumberOfCloudPoints()  != fVP.GetNumberOfCloudPoints())  ||
      (lastVP.IsAuxEdgeVisible ()   != fVP.IsAuxEdgeVisible ())   ||
      (lastVP.IsCulling ()          != fVP.IsCulling ())          ||
      (lastVP.IsCullingInvisible () != fVP.IsCullingInvisible ()) ||
      (lastVP.IsDensityCulling ()   != fVP.IsDensityCulling ())   ||
      (lastVP.IsCullingCovered ()   != fVP.IsCullingCovered ())   ||
      (lastVP.GetCBDAlgorithmNumber() !=
       fVP.GetCBDAlgorithmNumber())                               ||
      // Note: Section and Cutaway can reveal back-facing faces. If
      // backface culling is implemented, the image can look strange because
      // the back-facing faces are not there. For the moment, we have disabled
      // (commented out) backface culling (it seems not to affect performance -
      // in fact, performance seems to improve), so there is no problem.
      (lastVP.IsSection ()          != fVP.IsSection ())          ||
      // Section (DCUT) is NOT implemented locally so we need to visit the kernel.
      // (lastVP.IsCutaway ()          != fVP.IsCutaway ())          ||
      // Cutaways are implemented locally so we do not need to visit the kernel.
      (lastVP.IsExplode ()          != fVP.IsExplode ())          ||
      (lastVP.GetNoOfSides ()       != fVP.GetNoOfSides ())       ||
      (lastVP.GetGlobalMarkerScale()    != fVP.GetGlobalMarkerScale())    ||
      (lastVP.GetGlobalLineWidthScale() != fVP.GetGlobalLineWidthScale()) ||
      (lastVP.IsMarkerNotHidden ()  != fVP.IsMarkerNotHidden ())  ||
      (lastVP.GetDefaultVisAttributes()->GetColour() !=
       fVP.GetDefaultVisAttributes()->GetColour())                ||
      (lastVP.GetDefaultTextVisAttributes()->GetColour() !=
       fVP.GetDefaultTextVisAttributes()->GetColour())            ||
      (lastVP.GetBackgroundColour ()!= fVP.GetBackgroundColour ())||
      (lastVP.IsPicking ()          != fVP.IsPicking ())          ||
      (lastVP.IsSpecialMeshRendering() != fVP.IsSpecialMeshRendering()))
    return true;
 
  // Don't check VisAttributesModifiers if this comparison has been
  // initiated by a mouse interaction on the scene tree.
  if (fMouseOnSceneTree) {
    // Reset the flag.
    fMouseOnSceneTree = false;
  } else {
    // Not initiated by a mouse so compare for kernel visit.
    if (lastVP.GetVisAttributesModifiers() != fVP.GetVisAttributesModifiers()) {
      return true;
    }
  }
 
  if (lastVP.IsDensityCulling () &&
      (lastVP.GetVisibleDensity () != fVP.GetVisibleDensity ()))
    return true;
 
//  /**************************************************************
//   If section (DCUT) is implemented locally, comment this out.
  if (lastVP.IsSection () &&
      (lastVP.GetSectionPlane () != fVP.GetSectionPlane ()))
    return true;
//   ***************************************************************/
 
  /**************************************************************
   If cutaways are implemented locally, comment this out.
   if (lastVP.IsCutaway ()) {
   if (lastVP.GetCutawayPlanes ().size () !=
   fVP.GetCutawayPlanes ().size ()) return true;
   for (size_t i = 0; i < lastVP.GetCutawayPlanes().size(); ++i)
   if (lastVP.GetCutawayPlanes()[i] != fVP.GetCutawayPlanes()[i])
   return true;
   }
   ***************************************************************/
 
  if (lastVP.GetCBDAlgorithmNumber() > 0) {
    if (lastVP.GetCBDParameters().size() != fVP.GetCBDParameters().size()) return true;
    else if (lastVP.GetCBDParameters() != fVP.GetCBDParameters()) return true;
  }
 
  if (lastVP.IsExplode () &&
      (lastVP.GetExplodeFactor () != fVP.GetExplodeFactor ()))
    return true;
 
  if (lastVP.IsSpecialMeshRendering() &&
      (lastVP.GetSpecialMeshVolumes() != fVP.GetSpecialMeshVolumes()))
    return true;
 
  return false;
}

◆ ComputeFlyThrough()

std::vector< G4ThreeVector > G4VViewer::ComputeFlyThrough ( G4Vector3D * )

inherited

Definition at line 215 of file G4VViewer.cc.

{
    enum CurveType {
        Bezier,
        G4SplineTest};
    
    // Choose a curve type (for testing)
//    int myCurveType = Bezier;
 
    // number if step points
    int stepPoints = 500;
 
    
    G4Spline spline;
 
    
    // At the moment we don't use the aVect parameters, but build it here :
    // Good step points for exampleB5
    spline.AddSplinePoint(G4Vector3D(0,1000,-14000));
    spline.AddSplinePoint(G4Vector3D(0,1000,0));
    spline.AddSplinePoint(G4Vector3D(-4000,1000,4000));
 
    
    std::vector <G4ThreeVector> viewVect;
 
//    if(myCurveType == Bezier) {
 
        
        // Draw the spline
        
        for (int i = 0; i < stepPoints; i++) {
            float t = (float)i / (float)stepPoints;
            G4Vector3D cameraPosition = spline.GetInterpolatedSplinePoint(t);
            //        G4Vector3D targetPoint = spline.GetInterpolatedSplinePoint(t);
            
            //        viewParam->SetViewAndLights(G4ThreeVector (cameraPosition.x(), cameraPosition.y(), cameraPosition.z()));
            //        viewParam->SetCurrentTargetPoint(targetPoint);
            G4cout << "FLY CR("<< i << "):" << cameraPosition << G4endl;
            viewVect.push_back(G4ThreeVector (cameraPosition.x(), cameraPosition.y(), cameraPosition.z()));
        }
        
//    } else if (myCurveType == G4SplineTest) {
        /*
         This method is a inspire from a Bezier curve. The problem of the Bezier curve is that the path does not go straight between two waypoints.
         This method add "stay straight" parameter which could be between 0 and 1 where the pass will follow exactly the line between the waypoints
         Ex : stay straight = 50%
         m1 = 3*(P1+P0)/2
         
         Ex : stay straight = 0%
         m1 = (P1+P0)/2
         
         P1
         /  \
         /    \
         a--x--b
         /  °  °  \
         / °      ° \
         m1           m2
         /              \
         /                \
         /                  \
         /                    \
         P0                     P2
         
         */
//        G4Vector3D a;
//        G4Vector3D b;
//        G4Vector3D m1;
//        G4Vector3D m2;
//        G4Vector3D P0;
//        G4Vector3D P1;
//        G4Vector3D P2;
//        G4double stayStraight = 0;
//        G4double bezierSpeed = 0.4; // Spend 40% time in bezier curve (time between m1-m2 is 40% of time between P0-P1)
//        
//        G4Vector3D firstPoint;
//        G4Vector3D lastPoint;
//        
//        float nbBezierSteps = (stepPoints * bezierSpeed*(1-stayStraight)) * (2./spline.GetNumPoints());
//        float nbFirstSteps = ((stepPoints/2-nbBezierSteps/2) /(1+stayStraight)) * (2./spline.GetNumPoints());
//        
//        // First points
//        firstPoint = spline.GetPoint(0);
//        lastPoint = (firstPoint + spline.GetPoint(1))/2;
//        
//        for( float j=0; j<1; j+= 1/nbFirstSteps) {
//            G4ThreeVector pt = firstPoint + (lastPoint - firstPoint) * j;
//            viewVect.push_back(pt);
//            G4cout << "FLY Bezier A1("<< viewVect.size()<< "):" << pt << G4endl;
//        }
//        
//        for (int i = 0; i < spline.GetNumPoints()-2; i++) {
//            P0 = spline.GetPoint(i);
//            P1 = spline.GetPoint(i+1);
//            P2 = spline.GetPoint(i+2);
//            
//            m1 = P1 - (P1-P0)*(1-stayStraight)/2;
//            m2 = P1 + (P2-P1)*(1-stayStraight)/2;
//            
//            // We have to get straight path from (middile of P0-P1) to (middile of P0-P1 + (dist P0-P1) * stayStraight/2)
//            if (stayStraight >0) {
//                
//                firstPoint = (P0 + P1)/2;
//                lastPoint = (P0 + P1)/2 + (P1-P0)*stayStraight/2;
//                
//                for( float j=0; j<1; j+= 1/(nbFirstSteps*stayStraight)) {
//                    G4ThreeVector pt = firstPoint + (lastPoint - firstPoint)* j;
//                    viewVect.push_back(pt);
//                    G4cout << "FLY Bezier A2("<< viewVect.size()<< "):" << pt << G4endl;
//                }
//            }
//            // Compute Bezier curve
//            for( float delta = 0 ; delta < 1 ; delta += 1/nbBezierSteps)
//            {
//                // The Green Line
//                a = m1 + ( (P1 - m1) * delta );
//                b = P1 + ( (m2 - P1) * delta );
//                
//                // Final point
//                G4ThreeVector pt = a + ((b-a) * delta );
//                viewVect.push_back(pt);
//                G4cout << "FLY Bezier("<< viewVect.size()<< "):" << pt << G4endl;
//            }
//            
//            // We have to get straight path
//            if (stayStraight >0) {
//                firstPoint = (P1 + P2)/2 - (P2-P1)*stayStraight/2;
//                lastPoint = (P1 + P2)/2;
//                
//                for( float j=0; j<1; j+= 1/(nbFirstSteps*stayStraight)) {
//                    G4ThreeVector pt = firstPoint + (lastPoint - firstPoint)* j;
//                    viewVect.push_back(pt);
//                    G4cout << "FLY Bezier B1("<< viewVect.size()<< "):" << pt << G4endl;
//                }
//            }
//        }
//        
//        // last points
//        firstPoint = spline.GetPoint(spline.GetNumPoints()-2);
//        lastPoint = spline.GetPoint(spline.GetNumPoints()-1);
//        for( float j=1; j>0; j-= 1/nbFirstSteps) {
//            G4ThreeVector pt = lastPoint - ((lastPoint-firstPoint)*((1-stayStraight)/2) * j );
//            viewVect.push_back(pt);
//            G4cout << "FLY Bezier B2("<< viewVect.size()<< "):" << pt << G4endl;
//        }
//    }
    return viewVect;
}

References G4VViewer::G4Spline::AddSplinePoint(), G4cout, G4endl, G4VViewer::G4Spline::GetInterpolatedSplinePoint(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

◆ ComputeView()

void G4OpenGLStoredQtViewer::ComputeView ( )

private

Definition at line 211 of file G4OpenGLStoredQtViewer.cc.

                                          {
 
  makeCurrent();
  G4ViewParameters::DrawingStyle dstyle = GetViewParameters().GetDrawingStyle();
 
  //Make sure current viewer is attached and clean...
 
  //See if things have changed from last time and remake if necessary...
  // The fNeedKernelVisit flag might have been set by the user in
  // /vis/viewer/rebuild, but if not, make decision and set flag only
  // if necessary...
  if (!fNeedKernelVisit) {
    KernelVisitDecision ();
  }
  fLastVP = fVP;
  G4bool kernelVisitWasNeeded = fNeedKernelVisit; // Keep (ProcessView resets).
  ProcessView ();
   
  if (kernelVisitWasNeeded) {
    displaySceneTreeComponent();
  }
 
  if(dstyle!=G4ViewParameters::hlr &&
     haloing_enabled) {
 
    HaloingFirstPass ();
    DrawDisplayLists ();
    glFlush ();
 
    HaloingSecondPass ();
 
    DrawDisplayLists ();
    FinishView ();
 
  } else {
     
    // If kernel visit was needed, drawing and FinishView will already
    // have been done, so...
    if (!kernelVisitWasNeeded) {
      DrawDisplayLists ();
      FinishView ();
    } else {
      // However, union cutaways are implemented in DrawDisplayLists, so make
      // an extra pass...
      if (fVP.IsCutaway() &&
          fVP.GetCutawayMode() == G4ViewParameters::cutawayUnion) {
        ClearView();
        DrawDisplayLists ();
        FinishView ();
      } else { // ADD TO AVOID KernelVisit=1 and nothing to display
        DrawDisplayLists ();
        FinishView ();
      }
    }
  }
 
  if (isRecording()) {
    savePPMToTemp();
  }
 
  fHasToRepaint = true;
}

References G4OpenGLViewer::ClearView(), G4ViewParameters::cutawayUnion, G4OpenGLQtViewer::displaySceneTreeComponent(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLQtViewer::fHasToRepaint, G4OpenGLQtViewer::FinishView(), G4OpenGLStoredViewer::fLastVP, G4VViewer::fNeedKernelVisit, G4VViewer::fVP, G4ViewParameters::GetCutawayMode(), G4ViewParameters::GetDrawingStyle(), G4VViewer::GetViewParameters(), G4OpenGLViewer::haloing_enabled, G4OpenGLViewer::HaloingFirstPass(), G4OpenGLViewer::HaloingSecondPass(), G4ViewParameters::hlr, G4ViewParameters::IsCutaway(), G4OpenGLQtViewer::isRecording(), G4OpenGLStoredViewer::KernelVisitDecision(), G4VViewer::ProcessView(), and G4OpenGLQtViewer::savePPMToTemp().

Referenced by paintGL().

◆ contextMenuEvent()

void G4OpenGLStoredQtViewer::contextMenuEvent ( QContextMenuEvent * e )

protected

Definition at line 405 of file G4OpenGLStoredQtViewer.cc.

{
  G4manageContextMenuEvent(e);
}

References G4OpenGLQtViewer::G4manageContextMenuEvent().

◆ CreateFontLists()

virtual void G4OpenGLViewer::CreateFontLists ( )

inlineprotectedvirtualinherited

Reimplemented in G4OpenGLXViewer.

Definition at line 148 of file G4OpenGLViewer.hh.

148{}

Referenced by G4OpenGLImmediateWin32Viewer::Initialise(), G4OpenGLImmediateXmViewer::Initialise(), G4OpenGLStoredWin32Viewer::Initialise(), and G4OpenGLStoredXmViewer::Initialise().

◆ CreateGLQtContext()

void G4OpenGLQtViewer::CreateGLQtContext ( )

protectedinherited

◆ CreateMainWindow()

void G4OpenGLQtViewer::CreateMainWindow	(	QGLWidget *	glWidget,
		const QString &	name
	)

protectedvirtualinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 114 of file G4OpenGLQtViewer.cc.

{
 
  if(fGLWidget) return; //Done.
 
  fGLWidget = glWidget ;
  //  fGLWidget->makeCurrent();
 
  G4Qt* interactorManager = G4Qt::getInstance ();
 
  ResizeWindow(fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
 
  // FIXME L.Garnier 9/11/09 Has to be check !!!
  // Qt UI with Qt Vis
  // Qt UI with X Vis
  // X UI with Qt Vis
  // X UI with X Vis
  // Ne marche pas avec un UIBatch !! (ecran blanc)
 
  // return false if G4UIQt was not launch
 
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if (UI == NULL) return;
 
  if (! static_cast<G4UIQt*> (UI->GetG4UIWindow())) {
    // NO UI, should be batch mode
    fBatchMode = true;
    return;
  }
  fUiQt = static_cast<G4UIQt*> (UI->GetG4UIWindow());
 
  bool isTabbedView = false;
  if ( fUiQt) {
    if (!fBatchMode) {
      if (!interactorManager->IsExternalApp()) {
        // INIT size
        fWinSize_x = fVP.GetWindowSizeHintX();
        fWinSize_y = fVP.GetWindowSizeHintY();
 
        isTabbedView = fUiQt->AddTabWidget((QWidget*)fGLWidget,name);
        QObject::connect(fUiQt->GetViewerTabWidget(),
                         SIGNAL(currentChanged(int)),
                         this,
                         SLOT(currentTabActivated(int)));
 
 
      }
      createSceneTreeWidget();
      // activate them
    }
  }
 
  if (!isTabbedView) { // we have to do a dialog
 
    QWidget *glDialogWidget = getParentWidget();
    if (glDialogWidget == NULL) {
      return;
    }
    glWidget->setParent(glDialogWidget);
    QHBoxLayout *mainLayout = new QHBoxLayout();
 
    mainLayout->setMargin(0);
    mainLayout->setSpacing(0);
    mainLayout->addWidget(fGLWidget);
    if (fGLWidget->inherits("QMainWindow")) {
      fGLWidget->setWindowTitle( name);
    }
    glDialogWidget->setLayout(mainLayout);
 
 
    //useful for MACOSX, we have to compt the menuBar height
#if QT_VERSION >= 0x050a00
      G4int offset = QApplication::desktop()->height()
          - QGuiApplication::screenAt(QPoint(20,20))->availableGeometry().height();
#else
      G4int offset = QApplication::desktop()->height()
          - QApplication::desktop()->availableGeometry().height();
#endif
 
    G4int YPos= fVP.GetWindowAbsoluteLocationHintY(QApplication::desktop()->height());
    if (fVP.GetWindowAbsoluteLocationHintY(QApplication::desktop()->height())< offset) {
      YPos = offset;
    }
    glDialogWidget->resize(getWinWidth(), getWinHeight());
    glDialogWidget->move(fVP.GetWindowAbsoluteLocationHintX(QApplication::desktop()->width()),YPos);
    glDialogWidget->show();
  }
 
  if(!fGLWidget) return;
 
  if (!fContextMenu)
    createPopupMenu();
 
}

References G4UIQt::AddTabWidget(), g4zmq::connect(), G4OpenGLQtViewer::createPopupMenu(), G4OpenGLQtViewer::createSceneTreeWidget(), G4OpenGLQtViewer::currentTabActivated(), G4OpenGLQtViewer::fBatchMode, G4OpenGLQtViewer::fContextMenu, G4OpenGLQtViewer::fGLWidget, G4OpenGLQtViewer::fUiQt, G4VViewer::fVP, G4OpenGLViewer::fWinSize_x, G4OpenGLViewer::fWinSize_y, G4UImanager::GetG4UIWindow(), G4Qt::getInstance(), G4OpenGLQtViewer::getParentWidget(), G4UImanager::GetUIpointer(), G4UIQt::GetViewerTabWidget(), G4ViewParameters::GetWindowAbsoluteLocationHintX(), G4ViewParameters::GetWindowAbsoluteLocationHintY(), G4ViewParameters::GetWindowSizeHintX(), G4ViewParameters::GetWindowSizeHintY(), G4OpenGLViewer::getWinHeight(), G4OpenGLViewer::getWinWidth(), G4Qt::IsExternalApp(), G4InuclParticleNames::name(), and G4OpenGLViewer::ResizeWindow().

Referenced by G4OpenGLImmediateQtViewer::Initialise(), and Initialise().

◆ createPickInfosWidget()

void G4OpenGLQtViewer::createPickInfosWidget ( )

privateinherited

Definition at line 2709 of file G4OpenGLQtViewer.cc.

                                            {
 
  // Get the pointer to the Pick infos widget
  fUIPickInfosWidget = fUiQt->GetPickInfosWidget();
 
  if (!fUIPickInfosWidget) {
    return;
  }
 
  // remove previous widgets
  QLayoutItem * wItem;
  if (fUIPickInfosWidget->layout()->count()) {
    while ((wItem = fUIPickInfosWidget->layout()->takeAt(0)) != 0) {
      delete wItem->widget();
      delete wItem;
    }
  }
 
  QGroupBox *groupBox = new QGroupBox("");
  QVBoxLayout *vbox = new QVBoxLayout;
 
  // add picking infos
  QWidget *pickingInfoWidget = new QWidget();
  QHBoxLayout *pickingInfoLayout = new QHBoxLayout();
 
  pickingInfoWidget->setStyleSheet ("padding-left: 0px; border:0px;");
  pickingInfoWidget->setLayout(pickingInfoLayout);
 
  vbox->addWidget(pickingInfoWidget);
  // add picking content
 
  fPickInfosScrollArea = new QScrollArea();
  fPickInfosScrollArea->setWidgetResizable(true);
 
 
  fPickInfosWidget = new QWidget();
  fPickInfosWidget->setStyleSheet ("padding: 0px ");
 
  QVBoxLayout* vLayout = new QVBoxLayout();
  fPickInfosWidget->setLayout (vLayout);
  fPickInfosScrollArea->setWidget(fPickInfosWidget);
 
  QSizePolicy vPolicy = fPickInfosWidget->sizePolicy();
  vPolicy.setVerticalStretch(4);
  vbox->addWidget(fPickInfosScrollArea);
  pickingInfoLayout->setContentsMargins(0,0,0,0);
  vLayout->setContentsMargins(0,0,0,0);
  vbox->setContentsMargins(1,1,1,1);
 
  groupBox->setLayout(vbox);
  fUIPickInfosWidget->layout()->addWidget(groupBox);
 
  updatePickInfosWidget(fLastPickPoint.x(),fLastPickPoint.y());
}

References G4OpenGLQtViewer::fLastPickPoint, G4OpenGLQtViewer::fPickInfosScrollArea, G4OpenGLQtViewer::fPickInfosWidget, G4OpenGLQtViewer::fUIPickInfosWidget, G4OpenGLQtViewer::fUiQt, G4UIQt::GetPickInfosWidget(), and G4OpenGLQtViewer::updatePickInfosWidget().

Referenced by G4OpenGLQtViewer::currentTabActivated(), and G4OpenGLQtViewer::updatePickInfosWidget().

◆ createPopupMenu()

void G4OpenGLQtViewer::createPopupMenu ( )

privateinherited

Definition at line 544 of file G4OpenGLQtViewer.cc.

                                          {
 
  fContextMenu = new QMenu("All");
 
  QMenu *mMouseAction = fContextMenu->addMenu("&Mouse actions");
 
#if QT_VERSION < 0x050600
  fMouseRotateAction = mMouseAction->addAction("Rotate", fSignalMapperMouse, SLOT(map()));
  fMouseMoveAction = mMouseAction->addAction("Move", fSignalMapperMouse, SLOT(map()));
  fMousePickAction = mMouseAction->addAction("Pick", fSignalMapperMouse, SLOT(map()));
  fMouseZoomOutAction = mMouseAction->addAction("Zoom out", fSignalMapperMouse, SLOT(map()));
  fMouseZoomInAction = mMouseAction->addAction("Zoom in", fSignalMapperMouse, SLOT(map()));
#else
  fMouseRotateAction = mMouseAction->addAction("Rotate", this, [this](){ this->toggleMouseAction(1); });
  fMouseMoveAction = mMouseAction->addAction("Move", this, [this](){ this->toggleMouseAction(2); });
  fMousePickAction = mMouseAction->addAction("Pick", this, [this](){ this->toggleMouseAction(3); });
  fMouseZoomOutAction = mMouseAction->addAction("Zoom out", this, [this](){ this->toggleMouseAction(4); });
  fMouseZoomInAction = mMouseAction->addAction("Zoom in", this, [this](){ this->toggleMouseAction(5); });
#endif
  QAction *shortcutsAction = mMouseAction->addAction("Show shortcuts");
 
  fMouseRotateAction->setCheckable(true);
  fMouseMoveAction->setCheckable(true);
  fMousePickAction->setCheckable(true);
  fMouseZoomOutAction->setCheckable(true);
  fMouseZoomInAction->setCheckable(true);
  shortcutsAction->setCheckable(false);
 
#if QT_VERSION < 0x050600
  connect(fSignalMapperMouse, SIGNAL(mapped(int)),this, SLOT(toggleMouseAction(int)));
  fSignalMapperMouse->setMapping(fMouseRotateAction,1);
  fSignalMapperMouse->setMapping(fMouseMoveAction,2);
  fSignalMapperMouse->setMapping(fMousePickAction,3);
  fSignalMapperMouse->setMapping(fMouseZoomOutAction,4);
  fSignalMapperMouse->setMapping(fMouseZoomInAction,5);
#endif
 
  QObject::connect(shortcutsAction,
                    SIGNAL(triggered(bool)),
                    this,
                    SLOT(showShortcuts()));
 
  // === Style Menu ===
  QMenu *mStyle = fContextMenu->addMenu("&Style");
 
  QMenu *mProjection = mStyle->addMenu("&Projection");
 
#if QT_VERSION < 0x050600
  fProjectionOrtho = mProjection->addAction("Orthographic", fSignalMapperSurface, SLOT(map()));
  fProjectionPerspective = mProjection->addAction("Perspective", fSignalMapperSurface, SLOT(map()));
 
 // INIT mProjection
  if (fVP.GetFieldHalfAngle() == 0) {
    createRadioAction(fProjectionOrtho, fProjectionPerspective,SLOT(toggleProjection(bool)),1);
  } else {
    createRadioAction(fProjectionOrtho, fProjectionPerspective,SLOT(toggleProjection(bool)),2);
  }
#else
  // no more radioAction, not realy useful and could be confusing to use context menu and icon at the same time
  fProjectionOrtho = mProjection->addAction("Orthographic", this, [this](){ this->toggleProjection(1); });
  fProjectionPerspective = mProjection->addAction("Perspective", this, [this](){ this->toggleProjection(2); });
#endif
  // === Drawing Menu ===
  QMenu *mDrawing = mStyle->addMenu("&Drawing");
 
#if QT_VERSION < 0x050600
  fDrawingWireframe = mDrawing->addAction("Wireframe", fSignalMapperSurface, SLOT(map()));
 
  fDrawingLineRemoval = mDrawing->addAction("Hidden line removal", fSignalMapperSurface, SLOT(map()));
 
  fDrawingSurfaceRemoval = mDrawing->addAction("Hidden Surface removal", fSignalMapperSurface, SLOT(map()));
 
  fDrawingLineSurfaceRemoval = mDrawing->addAction("Hidden line and surface removal", fSignalMapperSurface, SLOT(map()));
#endif
 
#if QT_VERSION < 0x050600
  connect(fSignalMapperSurface, SIGNAL(mapped(int)),this, SLOT(toggleSurfaceAction(int)));
  fSignalMapperSurface->setMapping(fDrawingWireframe,1);
  fSignalMapperSurface->setMapping(fDrawingLineRemoval,2);
  fSignalMapperSurface->setMapping(fDrawingSurfaceRemoval,3);
  fSignalMapperSurface->setMapping(fDrawingLineSurfaceRemoval,4);
#else
  fDrawingWireframe = mDrawing->addAction("Wireframe", this, [this](){ this->toggleSurfaceAction(1); });
  fDrawingLineRemoval = mDrawing->addAction("Hidden line removal", this, [this](){ this->toggleSurfaceAction(2); });
  fDrawingSurfaceRemoval = mDrawing->addAction("Hidden Surface removal", this, [this](){ this->toggleSurfaceAction(3); });
  fDrawingLineSurfaceRemoval = mDrawing->addAction("Hidden line and surface removal", this, [this](){ this->toggleSurfaceAction(4); });
#endif
 
  fDrawingWireframe->setCheckable(true);
  fDrawingLineRemoval->setCheckable(true);
  fDrawingSurfaceRemoval->setCheckable(true);
  fDrawingLineSurfaceRemoval->setCheckable(true);
 
  // Background Color
 
  QAction *backgroundColorChooser ;
  // === Action Menu ===
  backgroundColorChooser = mStyle->addAction("Background color");
  QObject ::connect(backgroundColorChooser,
                    SIGNAL(triggered()),
                    this,
                    SLOT(actionChangeBackgroundColor()));
 
  // Text Color
 
  QAction *textColorChooser ;
  // === Action Menu ===
  textColorChooser = mStyle->addAction("Text color");
  QObject ::connect(textColorChooser,
                    SIGNAL(triggered()),
                    this,
                    SLOT(actionChangeTextColor()));
 
  // Default Color
 
  QAction *defaultColorChooser ;
  // === Action Menu ===
  defaultColorChooser = mStyle->addAction("Default color");
  QObject ::connect(defaultColorChooser,
                    SIGNAL(triggered()),
                    this,
                    SLOT(actionChangeDefaultColor()));
 
 
  // === Action Menu ===
  QMenu *mActions = fContextMenu->addMenu("&Actions");
  QAction *createEPS = mActions->addAction("Save as ...");
  QObject ::connect(createEPS,
                    SIGNAL(triggered()),
                    this,
                    SLOT(actionSaveImage()));
 
  // === Action Menu ===
  QAction *movieParameters = mActions->addAction("Save as movie...");
  QObject ::connect(movieParameters,
                    SIGNAL(triggered()),
                    this,
                    SLOT(actionMovieParameters()));
 
 
 
 
  // === Special Menu ===
  QMenu *mSpecial = fContextMenu->addMenu("S&pecial");
  QMenu *mTransparency = mSpecial->addMenu("Transparency");
  QAction *transparencyOn = mTransparency->addAction("On");
  QAction *transparencyOff = mTransparency->addAction("Off");
 
  if (transparency_enabled == false) {
    createRadioAction(transparencyOn,transparencyOff,SLOT(toggleTransparency(bool)),2);
  } else if (transparency_enabled == true) {
    createRadioAction(transparencyOn,transparencyOff,SLOT(toggleTransparency(bool)),1);
  } else {
    mSpecial->clear();
  }
 
 
  QMenu *mAntialiasing = mSpecial->addMenu("Antialiasing");
  QAction *antialiasingOn = mAntialiasing->addAction("On");
  QAction *antialiasingOff = mAntialiasing->addAction("Off");
 
  if (antialiasing_enabled == false) {
    createRadioAction(antialiasingOn,antialiasingOff,SLOT(toggleAntialiasing(bool)),2);
  } else if (antialiasing_enabled == true) {
    createRadioAction(antialiasingOn,antialiasingOff,SLOT(toggleAntialiasing(bool)),1);
  } else {
    mAntialiasing->clear();
  }
 
  QMenu *mHaloing = mSpecial->addMenu("Haloing");
  QAction *haloingOn = mHaloing->addAction("On");
  QAction *haloingOff = mHaloing->addAction("Off");
  if (haloing_enabled == false) {
    createRadioAction(haloingOn,haloingOff,SLOT(toggleHaloing(bool)),2);
  } else if (haloing_enabled == true) {
    createRadioAction(haloingOn,haloingOff,SLOT(toggleHaloing(bool)),1);
  } else {
    mHaloing->clear();
  }
 
  QMenu *mAux = mSpecial->addMenu("Auxiliary edges");
  QAction *auxOn = mAux->addAction("On");
  QAction *auxOff = mAux->addAction("Off");
  if (!fVP.IsAuxEdgeVisible()) {
    createRadioAction(auxOn,auxOff,SLOT(toggleAux(bool)),2);
  } else {
    createRadioAction(auxOn,auxOff,SLOT(toggleAux(bool)),1);
  }
 
 
  QMenu *mHiddenMarkers = mSpecial->addMenu("Hidden markers");
  QAction *hiddenMarkersOn = mHiddenMarkers->addAction("On");
  QAction *hiddenMarkersOff = mHiddenMarkers->addAction("Off");
  if (fVP.IsMarkerNotHidden()) {
    createRadioAction(hiddenMarkersOn,hiddenMarkersOff,SLOT(toggleHiddenMarkers(bool)),2);
  } else {
    createRadioAction(hiddenMarkersOn,hiddenMarkersOff,SLOT(toggleHiddenMarkers(bool)),1);
  }
 
 
 
  QMenu *mFullScreen = mSpecial->addMenu("&Full screen");
  fFullScreenOn = mFullScreen->addAction("On");
  fFullScreenOff = mFullScreen->addAction("Off");
  createRadioAction(fFullScreenOn,fFullScreenOff,SLOT(toggleFullScreen(bool)),2);
 
  // INIT All
  updateToolbarAndMouseContextMenu();
}

Referenced by G4OpenGLQtViewer::CreateMainWindow(), and G4OpenGLQtViewer::G4manageContextMenuEvent().

◆ createRadioAction()

void G4OpenGLQtViewer::createRadioAction	(	QAction *	action1,
		QAction *	action2,
		const std::string &	method,
		unsigned int	nCheck = `1`
	)

privateinherited

Create a radio button menu. The two menu will be connected. When click on one, eatch state will be invert and callback method will be called.

Parameters

action1	first action to connect
action2	second action to connect
method	callback method
nCheck	1 : first action will be set true. 2 : second action will be set true

Definition at line 781 of file G4OpenGLQtViewer.cc.

                                                                                                                       {
 
  action1->setCheckable(true);
  action2->setCheckable(true);
 
  if (nCheck ==1)
    action1->setChecked (true);
  else
    action2->setChecked (true);
 
  QObject ::connect(action1, SIGNAL(triggered(bool)),action2, SLOT(toggle()));
  QObject ::connect(action2, SIGNAL(triggered(bool)),action1, SLOT(toggle()));
 
  QObject ::connect(action1, SIGNAL(toggled(bool)),this, method.c_str());
 
}

References g4zmq::connect().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ createSceneTreeComponent()

void G4OpenGLQtViewer::createSceneTreeComponent ( )

privateinherited

Definition at line 2566 of file G4OpenGLQtViewer.cc.

                                               {
 
  QLayout* vLayout = fSceneTreeWidget->layout();
 
  // Search line
  QWidget* coutButtonWidget = new QWidget();
  QHBoxLayout* layoutCoutTBButtons = new QHBoxLayout();
 
  fFilterOutput = new QLineEdit();
  fFilterOutput->setToolTip("Filter output by...");
  fFilterOutput->setStyleSheet ("padding: 0px ");
 
  QPixmap* searchIcon = fUiQt->getSearchIcon();
#if QT_VERSION > 0x050100
  fFilterOutput->addAction(*searchIcon,QLineEdit::TrailingPosition);
  fFilterOutput->setStyleSheet ("border-radius:7px;");
#else
  QPushButton *coutTBFilterButton = new QPushButton();
  coutTBFilterButton->setIcon(*searchIcon);
  coutTBFilterButton->setStyleSheet ("padding-left: 0px; border:0px;");
  fFilterOutput->setStyleSheet ("padding-right: 0px;");
#endif
  layoutCoutTBButtons->addWidget(fFilterOutput);
 
#if QT_VERSION <= 0x050100
  layoutCoutTBButtons->addWidget(coutTBFilterButton);
#endif
 
  coutButtonWidget->setLayout(layoutCoutTBButtons);
  vLayout->addWidget(coutButtonWidget);
 
  // reduce margins
  vLayout->setContentsMargins(0,0,0,0);
 
 
  fSceneTreeComponentTreeWidget = new QTreeWidget();
  fSceneTreeComponentTreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
  fSceneTreeComponentTreeWidget->setHeaderLabel ("Scene tree : "+QString(GetName().data()));
  fSceneTreeComponentTreeWidget->setColumnHidden (1,true);  // copy number
  fSceneTreeComponentTreeWidget->setColumnHidden (2,true);  // PO index
  fSceneTreeComponentTreeWidget->setColumnHidden (3,true);  // Informations
  //   data(0) : POindex
  //   data(1) : copy number
  //   data(2) : g4color
 
  vLayout->addWidget(fSceneTreeComponentTreeWidget);
 
  connect(fSceneTreeComponentTreeWidget,SIGNAL(itemChanged(QTreeWidgetItem*, int)),SLOT(sceneTreeComponentItemChanged(QTreeWidgetItem*, int)));
  connect(fSceneTreeComponentTreeWidget,SIGNAL(itemSelectionChanged ()),SLOT(sceneTreeComponentSelected()));
  connect(fSceneTreeComponentTreeWidget,SIGNAL(itemDoubleClicked ( QTreeWidgetItem*, int)),SLOT(changeColorAndTransparency( QTreeWidgetItem*, int)));
 
 
  // Depth slider
  QWidget *helpWidget = new QWidget();
  QHBoxLayout *helpLayout = new QHBoxLayout();
 
  QWidget* depthWidget = new QWidget();
  QWidget *showBox = new QWidget(depthWidget);
  QHBoxLayout *showBoxLayout = new QHBoxLayout();
 
  // reduce margins
  showBoxLayout->setContentsMargins(5,5,5,5);
 
  QLabel *zero = new QLabel();
  zero->setText("Show all");
  QLabel *one = new QLabel();
  one->setText("Hide all");
  fSceneTreeDepthSlider = new QSlider ( Qt::Horizontal);
  fSceneTreeDepthSlider->setMaximum (1000);
  fSceneTreeDepthSlider->setMinimum (0);
  fSceneTreeDepthSlider->setTickPosition(QSlider::TicksAbove);
  // set a minimum size
  fSceneTreeDepthSlider->setMinimumWidth (40);
 
  showBoxLayout->addWidget(zero);
  showBoxLayout->addWidget(fSceneTreeDepthSlider);
  showBoxLayout->addWidget(one);
 
  showBox->setLayout(showBoxLayout);
 
  helpLayout->addWidget(showBox);
  helpWidget->setLayout(helpLayout);
  helpLayout->setContentsMargins(0,0,0,0);
 
  vLayout->addWidget(helpWidget);
 
  connect( fSceneTreeDepthSlider, SIGNAL( valueChanged(int) ), this, SLOT( changeDepthInSceneTree(int) ) );
  connect( fFilterOutput, SIGNAL( textEdited ( const QString &) ), this, SLOT(changeSearchSelection()));
  fTreeItemModels.clear();
 
  fPVRootNodeCreate = false;
 
  fMaxPOindexInserted = -1;
 
 
}

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), G4OpenGLQtViewer::addPVSceneTreeElement(), and G4OpenGLQtViewer::createSceneTreeWidget().

◆ createSceneTreeWidget()

void G4OpenGLQtViewer::createSceneTreeWidget ( )

privateinherited

Definition at line 2516 of file G4OpenGLQtViewer.cc.

                                             {
  fUISceneTreeWidget = fUiQt->GetSceneTreeWidget();
 
  if (!fUISceneTreeWidget) {
    return;
  }
 
  // do not remove previous widgets, hide them!
  QLayoutItem * wItem;
  bool found = false;
  if (fUISceneTreeWidget->layout()->count() ) {
    for(int idx = 0; idx < fUISceneTreeWidget->layout()->count(); idx++){
      wItem = fUISceneTreeWidget->layout()->itemAt(idx);
      if (fSceneTreeWidget) {
        if(dynamic_cast<QWidget *>(wItem->widget())) {
          if (wItem->widget()->windowTitle() == fSceneTreeWidget->windowTitle()) {
            wItem->widget()->show();
            found = true;
          } else {
            wItem->widget()->hide();
          }
        }
      } else {
        wItem->widget()->hide();
      }
    }
  }
 
  if (!found) {
    // initialize scene tree / viewer properties / picking
    fSceneTreeWidget = new QWidget();
    QVBoxLayout* layoutSceneTree = new QVBoxLayout();
    fSceneTreeWidget->setStyleSheet ("padding: 0px ");
 
    fSceneTreeWidget->setLayout(layoutSceneTree);
    fSceneTreeWidget->layout()->setContentsMargins(5,5,5,5);
    fSceneTreeWidget->setWindowTitle(QString(GetName().data()));
 
    if (fUISceneTreeWidget != NULL) {
      fUISceneTreeWidget->layout()->addWidget(fSceneTreeWidget);
    }
 
    // not available for Immediate mode
    if (dynamic_cast<G4OpenGLStoredQtViewer*> (this)) {
      createSceneTreeComponent();
    }
  }
}

References G4OpenGLQtViewer::createSceneTreeComponent(), G4OpenGLQtViewer::fSceneTreeWidget, G4OpenGLQtViewer::fUiQt, G4OpenGLQtViewer::fUISceneTreeWidget, G4VViewer::GetName(), and G4UIQt::GetSceneTreeWidget().

Referenced by G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::currentTabActivated(), and G4OpenGLQtViewer::updateSceneTreeWidget().

◆ createTempFolder()

QString G4OpenGLQtViewer::createTempFolder ( )

privateinherited

Create a Qt_temp folder in the temp folder given The temp folder will be like this /tmp/QtMovie_12-02-2008_12_12_58/

Returns: "" if success. Error message if not.

Definition at line 2122 of file G4OpenGLQtViewer.cc.

                                           {
  fMovieTempFolderPath = "";
  //check
  QString tmp = setTempFolderPath(fTempFolderPath);
  if (tmp != "") {
    return tmp;
  }
  QString sep = QString(QDir::separator());
  QString path = sep+"QtMovie_"+QDateTime::currentDateTime ().toString("dd-MM-yyyy_hh-mm-ss")+sep;
  QDir *d = new QDir(QDir::cleanPath(fTempFolderPath));
  // check if it is already present
  if (d->exists(path)) {
    return "Folder "+path+" already exists.Please remove it first";
  }
  if (d->mkdir(fTempFolderPath+path)) {
    fMovieTempFolderPath = fTempFolderPath+path;
    return "";
  }
  return "Can't create "+fTempFolderPath+path;
}

References G4OpenGLQtViewer::fMovieTempFolderPath, G4OpenGLQtViewer::fTempFolderPath, and G4OpenGLQtViewer::setTempFolderPath().

Referenced by G4OpenGLQtViewer::startPauseVideo().

◆ createTreeWidgetItem()

QTreeWidgetItem * G4OpenGLQtViewer::createTreeWidgetItem	(	const PVPath &	fullPath,
		const QString &	name,
		int	copyNb,
		int	POIndex,
		const QString &	logicalName,
		Qt::CheckState	state,
		QTreeWidgetItem *	parentTreeNode,
		const G4Colour &	color
	)

privateinherited

if treeNode is NULL, then add this treeNode to the TreeWidget

Returns: the inserted item

Definition at line 2924 of file G4OpenGLQtViewer.cc.

  {
 
  // Set depth
  if (fullPath.size() > fSceneTreeDepth) {
    fSceneTreeDepth = fullPath.size();
    // Change slider value
    if (fSceneTreeDepthSlider) {
      fSceneTreeDepthSlider->setTickInterval(1000/(fSceneTreeDepth+1));
    }
  }
  QTreeWidgetItem * newItem = NULL;
  if (parentTreeNode == NULL) {
    newItem = new QTreeWidgetItem();
    fSceneTreeComponentTreeWidget->addTopLevelItem(newItem);
  } else {
    newItem = new QTreeWidgetItem(parentTreeNode);
    fSceneTreeComponentTreeWidget->addTopLevelItem(parentTreeNode);
  }
 
 
  newItem->setText(0,name);
  newItem->setData(1,Qt::UserRole,copyNb);
  newItem->setText(2,QString::number(POIndex));
  newItem->setData(0, Qt::UserRole, POIndex);
  newItem->setText(3,logicalName);
  newItem->setFlags(newItem->flags()|Qt::ItemIsUserCheckable);
  newItem->setCheckState(0,state);
  newItem->setExpanded(true);
  updatePositivePoIndexSceneTreeWidgetQuickMap(POIndex,newItem);
 
  changeQColorForTreeWidgetItem(newItem,QColor((int)(color.GetRed()*255),
                                               (int)(color.GetGreen()*255),
                                               (int)(color.GetBlue()*255),
                                               (int)(color.GetAlpha()*255)));
 
  // If invisible
  if ((state == Qt::Unchecked) && (POIndex == -1)) {
    newItem->setForeground (0, QBrush( Qt::gray) );
 
    // Set a tootip
    newItem->setToolTip (0,QString(
                                   "This node exists in the geometry but has not been\n")+
                         "drawn, perhaps because it has been set invisible. It \n"+
                         "cannot be made visible with a click on the button.\n"+
                         "To see it, change the visibility, for example, with \n"+
                         "/vis/geometry/set/visibility " + logicalName + " 0 true\n"+
                         "and rebuild the view with /vis/viewer/rebuild.\n"+
                         "Click here will only show/hide all child components");
  } else {
    // Set a tootip
    newItem->setToolTip (0,QString("double-click to change the color"));
  }
 
  // special case: if alpha=0, it is a totally transparent objet,
  // then, do not redraw it
  if (color.GetAlpha() == 0) {
    state = Qt::Unchecked;
    newItem->setCheckState(0,state);
    updatePositivePoIndexSceneTreeWidgetQuickMap(POIndex,newItem);
  }
 
  fTreeItemModels.insert(std::pair <int, PVPath > (POIndex,fullPath) );
 
  // Check last status of this item and change if necessary
  // open/close/hidden/visible/selected
  changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement(newItem);
  return newItem;
}

References G4OpenGLQtViewer::changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement(), G4OpenGLQtViewer::changeQColorForTreeWidgetItem(), G4OpenGLQtViewer::fSceneTreeComponentTreeWidget, G4OpenGLQtViewer::fSceneTreeDepth, G4OpenGLQtViewer::fSceneTreeDepthSlider, G4OpenGLQtViewer::fTreeItemModels, G4Colour::GetAlpha(), G4Colour::GetBlue(), G4Colour::GetGreen(), G4Colour::GetRed(), gray, G4InuclParticleNames::name(), and G4OpenGLQtViewer::updatePositivePoIndexSceneTreeWidgetQuickMap().

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), G4OpenGLQtViewer::addPVSceneTreeElement(), and G4OpenGLQtViewer::parseAndInsertInSceneTree().

◆ createViewerPropertiesWidget()

void G4OpenGLQtViewer::createViewerPropertiesWidget ( )

privateinherited

Definition at line 2664 of file G4OpenGLQtViewer.cc.

                                                    {
 
  // Get the pointer to the Viewer Properties widget
  fUIViewerPropertiesWidget = fUiQt->GetViewerPropertiesWidget();
 
  if (!fUIViewerPropertiesWidget) {
    return;
  }
 
  // remove previous widgets
  QLayoutItem * wItem;
  if (fUIViewerPropertiesWidget->layout()->count()) {
    while ((wItem = fUIViewerPropertiesWidget->layout()->takeAt(0)) != 0) {
      delete wItem->widget();
      delete wItem;
    }
  }
 
  // add properties
  QGroupBox *groupBox = new QGroupBox();
  groupBox->setTitle(GetName().data());
  QVBoxLayout *vbox = new QVBoxLayout;
 
  // add properties content
  fViewerPropertiesTableWidget = new QTableWidget();
 
  QSizePolicy vPolicy = fViewerPropertiesTableWidget->sizePolicy();
  vPolicy.setVerticalStretch(4);
 
  vbox->addWidget(fViewerPropertiesTableWidget);
  groupBox->setLayout(vbox);
  fUIViewerPropertiesWidget->layout()->addWidget(groupBox);
 
  connect(fViewerPropertiesTableWidget, SIGNAL(itemChanged(QTableWidgetItem*)),this, SLOT(tableWidgetViewerSetItemChanged(QTableWidgetItem *)));
 
  updateViewerPropertiesTableWidget();
 
  QDialog* dial = static_cast<QDialog*> (fUIViewerPropertiesWidget->parent());
  if (dial) {
    // change name
    dial->setWindowTitle(QString("Viewer properties - ")+GetName());
  }
}

References g4zmq::connect(), G4OpenGLQtViewer::fUiQt, G4OpenGLQtViewer::fUIViewerPropertiesWidget, G4OpenGLQtViewer::fViewerPropertiesTableWidget, G4VViewer::GetName(), G4UIQt::GetViewerPropertiesWidget(), G4OpenGLQtViewer::tableWidgetViewerSetItemChanged(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

Referenced by G4OpenGLQtViewer::currentTabActivated(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ currentTabActivated

void G4OpenGLQtViewer::currentTabActivated ( int currentTab )

privateslotinherited

Definition at line 4712 of file G4OpenGLQtViewer.cc.

                                                         {
  if (fUiQt->GetViewerTabWidget()->tabText(currentTab) == GetName())  {
    createViewerPropertiesWidget();
    createPickInfosWidget();
    createSceneTreeWidget();
  }
}

References G4OpenGLQtViewer::createPickInfosWidget(), G4OpenGLQtViewer::createSceneTreeWidget(), G4OpenGLQtViewer::createViewerPropertiesWidget(), G4OpenGLQtViewer::fUiQt, G4VViewer::GetName(), and G4UIQt::GetViewerTabWidget().

Referenced by G4OpenGLQtViewer::CreateMainWindow().

◆ displayRecordingStatus()

void G4OpenGLQtViewer::displayRecordingStatus ( )

inherited

Definition at line 1850 of file G4OpenGLQtViewer.cc.

                                              {
 
  QString txtStatus = "";
  if (fRecordingStep == WAIT) {
    txtStatus  = "Waiting to start...";
    fRecordFrameNumber = 0; // reset the frame number
  } else if (fRecordingStep == START) {
    txtStatus  = "Start Recording...";
  } else if (fRecordingStep == PAUSE) {
    txtStatus  = "Pause Recording...";
  } else if (fRecordingStep == CONTINUE) {
    txtStatus  = "Continue Recording...";
  } else if (fRecordingStep == STOP) {
    txtStatus  = "Stop Recording...";
  } else if (fRecordingStep == READY_TO_ENCODE) {
    txtStatus  = "Ready to Encode...";
  } else if (fRecordingStep == ENCODING) {
    txtStatus  = "Encoding...";
  } else if (fRecordingStep == FAILED) {
    txtStatus  = "Failed to encode...";
  } else if ((fRecordingStep == BAD_ENCODER)
             || (fRecordingStep == BAD_OUTPUT)
             || (fRecordingStep == BAD_TMP)) {
    txtStatus  = "Correct above errors first";
  } else if (fRecordingStep == SUCCESS) {
    txtStatus  = "File encoded successfully";
  } else {
  }
 
  if (fMovieParametersDialog) {
    fMovieParametersDialog->setRecordingStatus(txtStatus);
  } else {
    G4cout << txtStatus.toStdString().c_str() << G4endl;
  }
  setRecordingInfos("");
}

Referenced by G4OpenGLQtViewer::setBadEncoder(), G4OpenGLQtViewer::setBadOutput(), G4OpenGLQtViewer::setBadTmp(), G4OpenGLQtViewer::setRecordingStatus(), G4OpenGLQtViewer::setWaiting(), and G4OpenGLQtViewer::showMovieParametersDialog().

◆ displaySceneTreeComponent()

void G4OpenGLQtViewer::displaySceneTreeComponent ( )

protectedinherited

Should replace actual tree by the one in this class and update tree

Definition at line 4085 of file G4OpenGLQtViewer.cc.

                                                 {
  // no UI
  if (fUISceneTreeWidget == NULL) {
    return;
  }
  if (fSceneTreeComponentTreeWidget == NULL) {
    return;
  }
 
  // sort tree items
  fSceneTreeComponentTreeWidget->sortItems (0, Qt::AscendingOrder );
 
  return;
}

References G4OpenGLQtViewer::fSceneTreeComponentTreeWidget, and G4OpenGLQtViewer::fUISceneTreeWidget.

Referenced by ComputeView().

◆ DisplayTimePOColourModification()

void G4OpenGLStoredQtViewer::DisplayTimePOColourModification	(	G4Colour &	c,
		size_t	poIndex
	)

virtual

Reimplemented from G4OpenGLStoredViewer.

Definition at line 451 of file G4OpenGLStoredQtViewer.cc.

                {
  c = getColorForPoIndex(poIndex);
}

References G4OpenGLQtViewer::getColorForPoIndex().

◆ DrawDisplayLists()

void G4OpenGLStoredViewer::DrawDisplayLists ( )

protectedinherited

Definition at line 147 of file G4OpenGLStoredViewer.cc.

                                             {
  
  // We moved these from G4OpenGLViewer to G4ViewParamaters. To avoid
  // editing many lines below we introduce these convenient aliases.
#define CONVENIENT_DOUBLE_ALIAS(q) const G4double& f##q = fVP.Get##q();
#define CONVENIENT_BOOL_ALIAS(q) const G4bool& f##q = fVP.Is##q();
  CONVENIENT_DOUBLE_ALIAS(StartTime)
  CONVENIENT_DOUBLE_ALIAS(EndTime)
  CONVENIENT_DOUBLE_ALIAS(FadeFactor)
  CONVENIENT_BOOL_ALIAS(DisplayHeadTime)
  CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeX)
  CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeY)
  CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeSize)
  CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeRed)
  CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeGreen)
  CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeBlue)
  CONVENIENT_BOOL_ALIAS(DisplayLightFront)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontX)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontY)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontZ)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontT)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontRed)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontGreen)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontBlue)
 
  const G4Planes& cutaways = fVP.GetCutawayPlanes();
  G4bool cutawayUnion = fVP.IsCutaway() &&
  fVP.GetCutawayMode() == G4ViewParameters::cutawayUnion;
  const size_t nCutaways = cutawayUnion? cutaways.size(): 1;
  G4int iPass = 1;
  G4bool secondPassForTransparencyRequested = false;
  G4bool thirdPassForNonHiddenMarkersRequested = false;
  fDepthTestEnable = true;
  glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LEQUAL);
  do {
    for (size_t iCutaway = 0; iCutaway < nCutaways; ++iCutaway) {
      
      if (cutawayUnion) {
        double a[4];
        a[0] = cutaways[iCutaway].a();
        a[1] = cutaways[iCutaway].b();
        a[2] = cutaways[iCutaway].c();
        a[3] = cutaways[iCutaway].d();
        glClipPlane (GL_CLIP_PLANE2, a);
        glEnable (GL_CLIP_PLANE2);
      }
      
      G4bool isPicking = fVP.IsPicking();
      
      for (size_t iPO = 0;
           iPO < fG4OpenGLStoredSceneHandler.fPOList.size(); ++iPO) {
        if (POSelected(iPO)) {
          G4OpenGLStoredSceneHandler::PO& po =
          fG4OpenGLStoredSceneHandler.fPOList[iPO];
          G4Colour c = po.fColour;
          DisplayTimePOColourModification(c,iPO);
          const G4bool isTransparent = c.GetAlpha() < 1.;
          if ( iPass == 1) {
            if (isTransparent && transparency_enabled) {
              secondPassForTransparencyRequested = true;
              continue;
            }
            if (po.fMarkerOrPolyline && fVP.IsMarkerNotHidden()) {
              thirdPassForNonHiddenMarkersRequested = true;
              continue;
            }
          } else if (iPass == 2) {  // Second pass for transparency.
            if (!isTransparent) {
              continue;
            }
          } else {  // Third pass for non-hidden markers
            if (!po.fMarkerOrPolyline) {
              continue;
            }
          }
          if (isPicking) glLoadName(po.fPickName);
          if (transparency_enabled) {
            glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha());
          } else {
            glColor3d(c.GetRed(),c.GetGreen(),c.GetBlue());
          }
          if (po.fMarkerOrPolyline && fVP.IsMarkerNotHidden()) {
            if (fDepthTestEnable !=false) {
              glDisable (GL_DEPTH_TEST);
              fDepthTestEnable = false;
            }
          } else {
            if (fDepthTestEnable !=true) {
              glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LEQUAL);
              fDepthTestEnable = true;
            }
          }
          if (po.fpG4TextPlus) {
            if (po.fpG4TextPlus->fProcessing2D) {
              glMatrixMode (GL_PROJECTION);
              glPushMatrix();
              glLoadIdentity();
              g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
              glMatrixMode (GL_MODELVIEW);
              glPushMatrix();
              glLoadIdentity();
              G4OpenGLTransform3D oglt (po.fTransform);
              glMultMatrixd (oglt.GetGLMatrix ());
              // This text is from a PODL. We don't want to create a new PODL.
              AddPrimitiveForASingleFrame(po.fpG4TextPlus->fG4Text);
            } else {
              glPushMatrix();
              G4OpenGLTransform3D oglt (po.fTransform);
              glMultMatrixd (oglt.GetGLMatrix ());
              // This text is from a PODL. We don't want to create a new PODL.
              AddPrimitiveForASingleFrame(po.fpG4TextPlus->fG4Text);
              glPopMatrix();
            }
            
            if (po.fpG4TextPlus->fProcessing2D) {
              glMatrixMode (GL_PROJECTION);
              glPopMatrix();
              glMatrixMode (GL_MODELVIEW);
              glPopMatrix();
            }
          } else {
            glPushMatrix();
            G4OpenGLTransform3D oglt (po.fTransform);
            glMultMatrixd (oglt.GetGLMatrix ());
            glCallList (po.fDisplayListId);
            glPopMatrix();
          }
        }
      }
      
      G4Transform3D lastMatrixTransform;
      G4bool first = true;
 
      for (size_t iTO = 0;
           iTO < fG4OpenGLStoredSceneHandler.fTOList.size(); ++iTO) {
        if (TOSelected(iTO)) {
          G4OpenGLStoredSceneHandler::TO& to =
          fG4OpenGLStoredSceneHandler.fTOList[iTO];
          const G4Colour& c = to.fColour;
          const G4bool isTransparent = c.GetAlpha() < 1.;
          if ( iPass == 1) {
            if (isTransparent && transparency_enabled) {
              secondPassForTransparencyRequested = true;
              continue;
            }
            if (to.fMarkerOrPolyline && fVP.IsMarkerNotHidden()) {
              thirdPassForNonHiddenMarkersRequested = true;
              continue;
            }
          } else if (iPass == 2) {  // Second pass for transparency.
            if (!isTransparent) {
              continue;
            }
          } else {  // Third pass for non-hidden markers
            if (!to.fMarkerOrPolyline) {
              continue;
            }
          }
          if (to.fMarkerOrPolyline && fVP.IsMarkerNotHidden()) {
            if (fDepthTestEnable !=false) {
              glDisable (GL_DEPTH_TEST);
              fDepthTestEnable = false;
            }
          } else {
            if (fDepthTestEnable !=true) {
              glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LEQUAL);
              fDepthTestEnable = true;
            }
          }
          if (to.fEndTime >= fStartTime && to.fStartTime <= fEndTime) {
            if (fVP.IsPicking()) glLoadName(to.fPickName);
            if (to.fpG4TextPlus) {
              if (to.fpG4TextPlus->fProcessing2D) {
                glMatrixMode (GL_PROJECTION);
                glPushMatrix();
                glLoadIdentity();
                g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
                glMatrixMode (GL_MODELVIEW);
                glPushMatrix();
                glLoadIdentity();
              }
              G4OpenGLTransform3D oglt (to.fTransform);
              glMultMatrixd (oglt.GetGLMatrix ());
              // This text is from a TODL. We don't want to create a new TODL.
              AddPrimitiveForASingleFrame(to.fpG4TextPlus->fG4Text);
              if (to.fpG4TextPlus->fProcessing2D) {
                glMatrixMode (GL_PROJECTION);
                glPopMatrix();
                glMatrixMode (GL_MODELVIEW);
                glPopMatrix();
              }
            } else {
              if (to.fTransform != lastMatrixTransform) {
                if (! first) {
                  glPopMatrix();
                }
                first = false;
                glPushMatrix();
                G4OpenGLTransform3D oglt (to.fTransform);
                glMultMatrixd (oglt.GetGLMatrix ());
              }
              const G4Colour& cc = to.fColour;
              if (fFadeFactor > 0. && to.fEndTime < fEndTime) {
                // Brightness scaling factor
                G4double bsf = 1. - fFadeFactor *
                ((fEndTime - to.fEndTime) / (fEndTime - fStartTime));
                const G4Colour& bg = fVP.GetBackgroundColour();
                if (transparency_enabled) {
                  glColor4d
                  (bsf * cc.GetRed() + (1. - bsf) * bg.GetRed(),
                   bsf * cc.GetGreen() + (1. - bsf) * bg.GetGreen(),
                   bsf * cc.GetBlue() + (1. - bsf) * bg.GetBlue(),
                   bsf * cc.GetAlpha() + (1. - bsf) * bg.GetAlpha());
                } else {
                  glColor3d
                  (bsf * cc.GetRed() + (1. - bsf) * bg.GetRed(),
                   bsf * cc.GetGreen() + (1. - bsf) * bg.GetGreen(),
                   bsf * cc.GetBlue() + (1. - bsf) * bg.GetBlue());
                }
              } else {
                if (transparency_enabled) {
                  glColor4d(cc.GetRed(),cc.GetGreen(),cc.GetBlue(),cc.GetAlpha());
                } else {
                  glColor3d(cc.GetRed(),cc.GetGreen(),cc.GetBlue());
                }
              }
              glCallList (to.fDisplayListId);
            }
            if (to.fTransform != lastMatrixTransform) {
              lastMatrixTransform = to.fTransform;
            }
          }
        }
      }
      if (! first) {
        glPopMatrix();
      }
      
      if (cutawayUnion) glDisable (GL_CLIP_PLANE2);
    }  // iCutaway
    
    if (iPass == 2) secondPassForTransparencyRequested = false;  // Done.
    if (iPass == 3) thirdPassForNonHiddenMarkersRequested = false;  // Done.
    
    if (secondPassForTransparencyRequested) iPass = 2;
    else if (thirdPassForNonHiddenMarkersRequested) iPass = 3;
    else break;
    
  } while (true);
  
  // Display time at "head" of time range, which is fEndTime...
  if (fDisplayHeadTime && fEndTime < G4VisAttributes::fVeryLongTime) {
    glMatrixMode (GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
    glMatrixMode (GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    G4Text headTimeText(G4BestUnit(fEndTime,"Time"),
                        G4Point3D(fDisplayHeadTimeX, fDisplayHeadTimeY, 0.));
    headTimeText.SetScreenSize(fDisplayHeadTimeSize);
    G4VisAttributes visAtts (G4Colour
                             (fDisplayHeadTimeRed,
                              fDisplayHeadTimeGreen,
                              fDisplayHeadTimeBlue));
    headTimeText.SetVisAttributes(&visAtts);
    AddPrimitiveForASingleFrame(headTimeText);
    glMatrixMode (GL_PROJECTION);
    glPopMatrix();
    glMatrixMode (GL_MODELVIEW);
    glPopMatrix();
  }
  
  // Display light front...
  if (fDisplayLightFront && fEndTime < G4VisAttributes::fVeryLongTime) {
    G4double lightFrontRadius = (fEndTime - fDisplayLightFrontT) * c_light;
    if (lightFrontRadius > 0.) {
      G4Point3D lightFrontCentre(fDisplayLightFrontX, fDisplayLightFrontY, fDisplayLightFrontZ);
      G4Point3D circleCentre = lightFrontCentre;
      G4double circleRadius = lightFrontRadius;
      if (fVP.GetFieldHalfAngle() > 0.) {
        // Perspective view.  Find horizon centre and radius...
        G4Point3D targetPoint = fSceneHandler.GetScene()->GetStandardTargetPoint() +
        fVP.GetCurrentTargetPoint();
        G4double sceneRadius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
        if(sceneRadius <= 0.) sceneRadius = 1.;
        G4double cameraDistance = fVP.GetCameraDistance(sceneRadius);
        G4Point3D cameraPosition = targetPoint + cameraDistance * fVP.GetViewpointDirection().unit();
        G4Vector3D lightFrontToCameraDirection = cameraPosition - lightFrontCentre;
        G4double lightFrontCentreDistance = lightFrontToCameraDirection.mag();
        /*
         G4cout << "cameraPosition: " << cameraPosition
         << ", lightFrontCentre: " << lightFrontCentre
         << ", lightFrontRadius: " << lightFrontRadius
         << ", lightFrontCentreDistance: " << lightFrontCentreDistance
         << ", dot: " << lightFrontToCameraDirection * fVP.GetViewpointDirection()
         << G4endl;
         */
        if (lightFrontToCameraDirection * fVP.GetViewpointDirection() > 0. && lightFrontRadius < lightFrontCentreDistance) {
          // Light front in front of camera...
          G4double sineHorizonAngle = lightFrontRadius / lightFrontCentreDistance;
          circleCentre = lightFrontCentre + (lightFrontRadius * sineHorizonAngle) * lightFrontToCameraDirection.unit();
          circleRadius = lightFrontRadius * std::sqrt(1. - std::pow(sineHorizonAngle, 2));
          /*
           G4cout << "sineHorizonAngle: " << sineHorizonAngle
           << ", circleCentre: " << circleCentre
           << ", circleRadius: " << circleRadius
           << G4endl;
           */
        } else {
          circleRadius = -1.;
        }
      }
      if (circleRadius > 0.) {
        G4Circle lightFront(circleCentre);
        lightFront.SetWorldRadius(circleRadius);
        G4VisAttributes visAtts(G4Colour
         (fDisplayLightFrontRed,
          fDisplayLightFrontGreen,
          fDisplayLightFrontBlue));
        lightFront.SetVisAttributes(visAtts);
        AddPrimitiveForASingleFrame(lightFront);
      }
    }
  }
}

Referenced by ComputeView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), and G4OpenGLStoredXViewer::DrawView().

◆ DrawText()

void G4OpenGLQtViewer::DrawText ( const G4Text & g4text )

virtualinherited

Reimplemented from G4OpenGLViewer.

Definition at line 2795 of file G4OpenGLQtViewer.cc.

{
  QGLWidget* qGLW = dynamic_cast<QGLWidget*> (fGLWidget) ;
  if (! qGLW) {
    return;
  }
  if (isGl2psWriting()) {
 
    G4OpenGLViewer::DrawText(g4text);
 
  } else {
 
    if (!fGLWidget) return;
 
#ifdef G4MULTITHREADED
    if (G4Threading::G4GetThreadId() != G4Threading::MASTER_ID) return;
#endif
 
    G4VSceneHandler::MarkerSizeType sizeType;
    G4double size = fSceneHandler.GetMarkerSize(g4text,sizeType);
 
    QFont font = QFont();
    font.setPointSizeF(size);
 
    const G4Colour& c = fSceneHandler.GetTextColour(g4text);
    glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha());
 
    G4Point3D position = g4text.GetPosition();
 
    const G4String& textString = g4text.GetText();
    const char* textCString = textString.c_str();
 
    glRasterPos3d(position.x(),position.y(),position.z());
 
    // Calculate move for centre and right adjustment
    QFontMetrics* f = new QFontMetrics (font);
#if QT_VERSION > 0x050110
    G4double span = f->boundingRect(textCString).width();
#else
    G4double span = f->width(textCString);
#endif
    G4double xmove = 0., ymove = 0.;
    switch (g4text.GetLayout()) {
    case G4Text::left: break;
    case G4Text::centre: xmove -= span / 2.; break;
    case G4Text::right: xmove -= span;
    }
 
    //Add offsets
    xmove += g4text.GetXOffset();
    ymove += g4text.GetYOffset();
 
    // xmove, ymove in pixels - or are they?
#ifdef __APPLE__
    const G4double fudgeFactor = 2.;
#else
    const G4double fudgeFactor = 1.;
#endif
    xmove *= fudgeFactor;
    ymove *= fudgeFactor;
 
    qGLW->renderText
      ((position.x()+(2*xmove)/getWinWidth()),
       (position.y()+(2*ymove)/getWinHeight()),
       position.z(),
       textCString,
       font);
 
  }
}

References G4Text::centre, G4OpenGLViewer::DrawText(), G4OpenGLQtViewer::fGLWidget, G4VViewer::fSceneHandler, G4Threading::G4GetThreadId(), G4Colour::GetAlpha(), G4Colour::GetBlue(), G4Colour::GetGreen(), G4Text::GetLayout(), G4VSceneHandler::GetMarkerSize(), G4VMarker::GetPosition(), G4Colour::GetRed(), G4Text::GetText(), G4VSceneHandler::GetTextColour(), G4OpenGLViewer::getWinHeight(), G4OpenGLViewer::getWinWidth(), G4Text::GetXOffset(), G4Text::GetYOffset(), G4OpenGLViewer::isGl2psWriting(), G4Text::left, G4Threading::MASTER_ID, and G4Text::right.

◆ DrawView()

void G4OpenGLStoredQtViewer::DrawView ( )

virtual

Implements G4VViewer.

Definition at line 207 of file G4OpenGLStoredQtViewer.cc.

                                       {
  updateQWidget();
}

References updateQWidget().

◆ encodeVideo()

void G4OpenGLQtViewer::encodeVideo ( )

inherited

Definition at line 2377 of file G4OpenGLQtViewer.cc.

{
  if ((getEncoderPath() != "") && (getSaveFileName() != "")) {
    setRecordingStatus(ENCODING);
 
    fProcess = new QProcess();
#if QT_VERSION > 0x040100
    QObject ::connect(fProcess,SIGNAL(finished ( int,QProcess::ExitStatus)),
                      this,SLOT(processEncodeFinished()));
    QObject ::connect(fProcess,SIGNAL(readyReadStandardOutput ()),
                      this,SLOT(processEncodeStdout()));
#else
    QObject ::connect(fProcess,SIGNAL(finished ( int)),
                      this,SLOT(processEncodeFinished()));
    QObject ::connect(fProcess,SIGNAL(readyReadStandardOutput ()),
                      this,SLOT(processEncodeStdout()));
#endif
#if QT_VERSION < 0x050a00
    fProcess->setReadChannelMode(QProcess::MergedChannels);
#else
    fProcess->setProcessChannelMode(QProcess::MergedChannels);
#endif
    fProcess->start (fEncoderPath, QStringList(fMovieTempFolderPath+fParameterFileName));
  }
}

References g4zmq::connect(), G4OpenGLQtViewer::fEncoderPath, G4OpenGLQtViewer::fMovieTempFolderPath, G4OpenGLQtViewer::fParameterFileName, G4OpenGLQtViewer::fProcess, G4OpenGLQtViewer::getEncoderPath(), G4OpenGLQtViewer::getSaveFileName(), G4OpenGLQtViewer::processEncodeFinished(), G4OpenGLQtViewer::processEncodeStdout(), and G4OpenGLQtViewer::setRecordingStatus().

Referenced by G4OpenGLQtViewer::saveVideo().

◆ exportImage()

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

virtualinherited

Export image. Try to get the format according to the file extention. If not present, the last one choosen by /vis/ogl/set/exportFormat If not, will take the default format : eps Best format actually available is pdf (vectored and allow transparency) If name is not set, it will take the default name value given by /vis/ogl/set/printFilename

Reimplemented from G4OpenGLViewer.

Definition at line 2187 of file G4OpenGLQtViewer.cc.

                                                                        {
 
  QGLWidget* qGLW = dynamic_cast<QGLWidget*> (fGLWidget) ;
  if (! qGLW) {
    return false;
  }
  // If there is already an extention
  bool increaseFileNumber = true;
  // if
  if (name.size() != name.substr(name.find_last_of(".") + 1).size()) {
    increaseFileNumber = false;
  }
  if (! setExportFilename(name,increaseFileNumber)) {
    return false;
  }
  if ((width !=-1) && (height != -1)) {
    setExportSize(width, height);
  }
  // first, try to do it with generic function
  if (G4OpenGLViewer::exportImage(name, width, height)) {
    return true;
 
  // Then try Qt saving functions
  } else {
    QImage image;
    image = qGLW->grabFrameBuffer();
 
    bool res = image.save(QString(getRealPrintFilename().c_str()),0,fLastExportSliderValue);
 
    if (!res) {
      G4cerr << "Error saving file... " << getRealPrintFilename().c_str() << G4endl;
      return false;
    } else {
      G4cout << "File " << getRealPrintFilename().c_str() << " size: " << fGLWidget->width() << "x" << fGLWidget->height() << " has been saved " << G4endl;
      fExportFilenameIndex++;
    }
  }
  return true;
}

References G4OpenGLViewer::exportImage(), G4OpenGLViewer::fExportFilenameIndex, G4OpenGLQtViewer::fGLWidget, G4OpenGLQtViewer::fLastExportSliderValue, G4cerr, G4cout, G4endl, G4OpenGLViewer::getRealPrintFilename(), G4InuclParticleNames::name(), G4OpenGLViewer::setExportFilename(), and G4OpenGLViewer::setExportSize().

Referenced by G4OpenGLQtViewer::actionSaveImage().

◆ FinishView()

void G4OpenGLQtViewer::FinishView ( void )

protectedvirtualinherited

Reimplemented from G4VViewer.

Definition at line 1266 of file G4OpenGLQtViewer.cc.

{
 /* From Apple doc:
  CGLFlushDrawable : Copies the back buffer of a double-buffered context to the front buffer.
  If the backing store attribute is set to false, the buffers can be exchanged rather than copied
 */
  glFlush ();
 
  // L. Garnier 10/2009 : Not necessary and cause problems on mac OS X 10.6
  //  fGLWidget->swapBuffers ();
}

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), and ComputeView().

◆ g4GlFrustum()

void G4OpenGLViewer::g4GlFrustum	(	GLdouble	left,
		GLdouble	right,
		GLdouble	bottom,
		GLdouble	top,
		GLdouble	near,
		GLdouble	far
	)

protectedinherited

Definition at line 1467 of file G4OpenGLViewer.cc.

                                                                                                                             {
  //  glFrustum (left, right, bottom, top, near, far);
  
  GLdouble deltaX = right - left;
  GLdouble deltaY = top - bottom;
  GLdouble deltaZ = zFar - zNear;
  
  GLdouble a = 2.0f * zNear / deltaX;
  GLdouble b = 2.0f * zNear / deltaY;
  GLdouble c = (right + left) / deltaX;
  GLdouble d = (top + bottom) / deltaY;
  GLdouble e = -(zFar + zNear) / (zFar - zNear);
  GLdouble f = -2.0f * zFar * zNear / deltaZ;
  
  GLdouble proj[16] = {
    a, 0, 0, 0,
    0, b, 0, 0,
    c, d, e, -1.0f,
    0, 0, f, 0
  };
  
  glMultMatrixd(proj);
  
}

Referenced by G4OpenGLViewer::SetView().

◆ g4GlOrtho()

void G4OpenGLViewer::g4GlOrtho	(	GLdouble	left,
		GLdouble	right,
		GLdouble	bottom,
		GLdouble	top,
		GLdouble	near,
		GLdouble	far
	)

protectedinherited

Definition at line 1445 of file G4OpenGLViewer.cc.

                                                                                                                           {
  //  glOrtho (left, right, bottom, top, near, far);
  
  GLdouble a = 2.0 / (right - left);
  GLdouble b = 2.0 / (top - bottom);
  GLdouble c = -2.0 / (zFar - zNear);
  
  GLdouble tx = - (right + left)/(right - left);
  GLdouble ty = - (top + bottom)/(top - bottom);
  GLdouble tz = - (zFar + zNear)/(zFar - zNear);
  
  GLdouble ortho[16] = {
    a, 0, 0, 0,
    0, b, 0, 0,
    0, 0, c, 0,
    tx, ty, tz, 1
  };
  glMultMatrixd(ortho);
  
}

Referenced by G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLImmediateSceneHandler::BeginPrimitives2D(), G4OpenGLStoredViewer::DrawDisplayLists(), and G4OpenGLViewer::SetView().

◆ g4GluLookAt()

void G4OpenGLViewer::g4GluLookAt	(	GLdouble	eyex,
		GLdouble	eyey,
		GLdouble	eyez,
		GLdouble	centerx,
		GLdouble	centery,
		GLdouble	centerz,
		GLdouble	upx,
		GLdouble	upy,
		GLdouble	upz
	)

protectedinherited

Definition at line 1365 of file G4OpenGLViewer.cc.

{
    GLdouble mat[16];
    GLdouble x[3], y[3], z[3];
    GLdouble mag;
  
    /* Make rotation matrix */
  
    /* Z vector */
    z[0] = eyex - centerx;
    z[1] = eyey - centery;
    z[2] = eyez - centerz;
    mag = std::sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
    if (mag) {          /* mpichler, 19950515 */
        z[0] /= mag;
        z[1] /= mag;
        z[2] /= mag;
    }
  
    /* Y vector */
    y[0] = upx;
    y[1] = upy;
    y[2] = upz;
  
    /* X vector = Y cross Z */
    x[0] = y[1] * z[2] - y[2] * z[1];
    x[1] = -y[0] * z[2] + y[2] * z[0];
    x[2] = y[0] * z[1] - y[1] * z[0];
  
    /* Recompute Y = Z cross X */
    y[0] = z[1] * x[2] - z[2] * x[1];
    y[1] = -z[0] * x[2] + z[2] * x[0];
    y[2] = z[0] * x[1] - z[1] * x[0];
  
    /* mpichler, 19950515 */
    /* cross product gives area of parallelogram, which is < 1.0 for
     * non-perpendicular unit-length vectors; so normalize x, y here
     */
  
    mag = std::sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
    if (mag) {
        x[0] /= mag;
        x[1] /= mag;
        x[2] /= mag;
    }
  
    mag = std::sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
    if (mag) {
        y[0] /= mag;
        y[1] /= mag;
        y[2] /= mag;
    }
  
#define M(row,col)  mat[col*4+row]
    M(0, 0) = x[0];
    M(0, 1) = x[1];
    M(0, 2) = x[2];
    M(0, 3) = 0.0;
    M(1, 0) = y[0];
    M(1, 1) = y[1];
    M(1, 2) = y[2];
    M(1, 3) = 0.0;
    M(2, 0) = z[0];
    M(2, 1) = z[1];
    M(2, 2) = z[2];
    M(2, 3) = 0.0;
    M(3, 0) = 0.0;
    M(3, 1) = 0.0;
    M(3, 2) = 0.0;
    M(3, 3) = 1.0;
#undef M
    glMultMatrixd(mat);
  
    /* Translate Eye to Origin */
    glTranslated(-eyex, -eyey, -eyez);
}

References M.

Referenced by G4OpenGLViewer::SetView().

◆ g4GluPickMatrix()

void G4OpenGLViewer::g4GluPickMatrix	(	GLdouble	x,
		GLdouble	y,
		GLdouble	width,
		GLdouble	height,
		GLint	viewport[4]
	)

protectedinherited

Definition at line 1323 of file G4OpenGLViewer.cc.

  {
    GLdouble mat[16];
    GLdouble sx, sy;
    GLdouble tx, ty;
    
    sx = viewport[2] / width;
    sy = viewport[3] / height;
    tx = (viewport[2] + 2.0 * (viewport[0] - x)) / width;
    ty = (viewport[3] + 2.0 * (viewport[1] - y)) / height;
    
#define M(row, col) mat[col*4+row]
    M(0, 0) = sx;
    M(0, 1) = 0.0;
    M(0, 2) = 0.0;
    M(0, 3) = tx;
    M(1, 0) = 0.0;
    M(1, 1) = sy;
    M(1, 2) = 0.0;
    M(1, 3) = ty;
    M(2, 0) = 0.0;
    M(2, 1) = 0.0;
    M(2, 2) = 1.0;
    M(2, 3) = 0.0;
    M(3, 0) = 0.0;
    M(3, 1) = 0.0;
    M(3, 2) = 0.0;
    M(3, 3) = 1.0;
#undef M
    
    glMultMatrixd(mat);
}

References M.

Referenced by G4OpenGLViewer::GetPickDetails().

◆ G4keyPressEvent()

void G4OpenGLQtViewer::G4keyPressEvent ( QKeyEvent * event )

inherited

Definition at line 1613 of file G4OpenGLQtViewer.cc.

{
  if (fHoldKeyEvent)
    return;
 
  fHoldKeyEvent = true;
 
 
  // with no modifiers
  updateKeyModifierState(evnt->modifiers());
  if ((fNoKeyPress) || (evnt->modifiers() == Qt::KeypadModifier )) {
    if (evnt->key() == Qt::Key_Down) { // go down
      moveScene(0,1,0,false);
    }
    else if (evnt->key() == Qt::Key_Up) {  // go up
      moveScene(0,-1,0,false);
    }
    if (evnt->key() == Qt::Key_Left) { // go left
      moveScene(-1,0,0,false);
    }
    else if (evnt->key() == Qt::Key_Right) { // go right
      moveScene(1,0,0,false);
    }
    if (evnt->key() == Qt::Key_Minus) { // go backward
      moveScene(0,0,1,false);
    }
    else if (evnt->key() == Qt::Key_Plus) { // go forward
      moveScene(0,0,-1,false);
    }
    // escaped from full screen
    if (evnt->key() == Qt::Key_Escape) {
      toggleFullScreen(false);
    }
  }
  // several case here : If return is pressed, in every case -> display the movie parameters dialog
  // If one parameter is wrong -> put it in red (only save filenam could be wrong..)
  // If encoder not found-> does nothing.Only display a message in status box
  // If all ok-> generate parameter file
  // If ok -> put encoder button enabled
 
  if ((evnt->key() == Qt::Key_Return) || (evnt->key() == Qt::Key_Enter)){ // end of video
    stopVideo();
  }
  if (evnt->key() == Qt::Key_Space){ // start/pause of video
    startPauseVideo();
  }
 
  // H : Return Home view
  if (evnt->key() == Qt::Key_H){ // go Home
    ResetView();
 
    updateQWidget();
  }
 
  // Shift Modifier
  if (fShiftKeyPress) {
    fGLWidget->setCursor(QCursor(Qt::SizeAllCursor));
 
    if (evnt->key() == Qt::Key_Down) { // rotate phi
      rotateQtScene(0,-fRot_sens);
    }
    else if (evnt->key() == Qt::Key_Up) { // rotate phi
      rotateQtScene(0,fRot_sens);
    }
    if (evnt->key() == Qt::Key_Left) { // rotate theta
      rotateQtScene(fRot_sens,0);
    }
    else if (evnt->key() == Qt::Key_Right) { // rotate theta
      rotateQtScene(-fRot_sens,0);
    }
    if (evnt->key() == Qt::Key_Plus) { // go forward  ("Plus" imply
      // "Shift" on Mac French keyboard
      moveScene(0,0,-1,false);
    }
 
    // Alt Modifier
  }
  if ((fAltKeyPress)) {
    fGLWidget->setCursor(QCursor(Qt::ClosedHandCursor));
 
    if (evnt->key() == Qt::Key_Down) { // rotate phi
      rotateQtSceneToggle(0,-fRot_sens);
    }
    else if (evnt->key() == Qt::Key_Up) { // rotate phi
      rotateQtSceneToggle(0,fRot_sens);
    }
    if (evnt->key() == Qt::Key_Left) { // rotate theta
      rotateQtSceneToggle(fRot_sens,0);
    }
    else if (evnt->key() == Qt::Key_Right) { // rotate theta
      rotateQtSceneToggle(-fRot_sens,0);
    }
 
    // Rotatio +/-
    if (evnt->key() == Qt::Key_Plus) {
      fRot_sens = fRot_sens/0.7;
      G4cout << "Auto-rotation set to : " << fRot_sens << G4endl;
    }
    else if (evnt->key() == Qt::Key_Minus) {
      fRot_sens = fRot_sens*0.7;
      G4cout << "Auto-rotation set to : " << fRot_sens << G4endl;
    }
 
    // Control Modifier OR Command on MAC
  }
  if ((fControlKeyPress)) {
    if (evnt->key() == Qt::Key_Plus) {
      fVP.SetZoomFactor(fVP.GetZoomFactor()*(1+fDeltaZoom));
      updateQWidget();
    }
    else if (evnt->key() == Qt::Key_Minus) {
      fVP.SetZoomFactor(fVP.GetZoomFactor()*(1-fDeltaZoom));
      updateQWidget();
    }
  }
 
  fHoldKeyEvent = false;
}

References G4OpenGLQtViewer::fAltKeyPress, G4OpenGLQtViewer::fControlKeyPress, G4OpenGLQtViewer::fDeltaZoom, G4OpenGLQtViewer::fGLWidget, G4OpenGLQtViewer::fHoldKeyEvent, G4OpenGLQtViewer::fNoKeyPress, G4OpenGLViewer::fRot_sens, G4OpenGLQtViewer::fShiftKeyPress, G4VViewer::fVP, G4cout, G4endl, G4ViewParameters::GetZoomFactor(), G4OpenGLQtViewer::moveScene(), G4OpenGLQtViewer::ResetView(), G4OpenGLQtViewer::rotateQtScene(), G4OpenGLQtViewer::rotateQtSceneToggle(), G4ViewParameters::SetZoomFactor(), G4OpenGLQtViewer::startPauseVideo(), G4OpenGLQtViewer::stopVideo(), G4OpenGLQtViewer::toggleFullScreen(), G4OpenGLQtViewer::updateKeyModifierState(), and G4OpenGLQtViewer::updateQWidget().

Referenced by G4OpenGLImmediateQtViewer::keyPressEvent(), and keyPressEvent().

◆ G4keyReleaseEvent()

void G4OpenGLQtViewer::G4keyReleaseEvent ( QKeyEvent * event )

inherited

Definition at line 1733 of file G4OpenGLQtViewer.cc.

{
  fGLWidget->setCursor(QCursor(Qt::ArrowCursor));
}

References G4OpenGLQtViewer::fGLWidget.

Referenced by G4OpenGLImmediateQtViewer::keyReleaseEvent(), and keyReleaseEvent().

◆ G4manageContextMenuEvent()

void G4OpenGLQtViewer::G4manageContextMenuEvent ( QContextMenuEvent * e )

protectedinherited

Definition at line 754 of file G4OpenGLQtViewer.cc.

{
  if (!fGLWidget) {
    G4cerr << "Visualization window not defined, please choose one before" << G4endl;
  } else {
 
    if (!fContextMenu)
      createPopupMenu();
 
    // launch menu
    if ( fContextMenu ) {
      fContextMenu->exec( e->globalPos() );
      //    delete fContextMenu;
    }
  }
  e->accept();
}

References G4OpenGLQtViewer::createPopupMenu(), G4OpenGLQtViewer::fContextMenu, G4OpenGLQtViewer::fGLWidget, G4cerr, and G4endl.

Referenced by G4OpenGLImmediateQtViewer::contextMenuEvent(), and contextMenuEvent().

◆ G4MouseDoubleClickEvent()

void G4OpenGLQtViewer::G4MouseDoubleClickEvent ( )

inherited

Definition at line 1435 of file G4OpenGLQtViewer.cc.

{
  fGLWidget->setMouseTracking(true);
}

References G4OpenGLQtViewer::fGLWidget.

Referenced by G4OpenGLImmediateQtViewer::mouseDoubleClickEvent(), and mouseDoubleClickEvent().

◆ G4MouseMoveEvent()

void G4OpenGLQtViewer::G4MouseMoveEvent ( QMouseEvent * evnt )

inherited

Parameters

pos_x	mouse x position
pos_y	mouse y position
mButtons	mouse button active
mAutoMove	true: apply this move till another evnt came, false :one time move

Definition at line 1448 of file G4OpenGLQtViewer.cc.

{
 
  Qt::MouseButtons mButtons = evnt->buttons();
 
  updateKeyModifierState(evnt->modifiers());
 
  if (fAutoMove) {
    return;
  }
 
  fLastPos3 = fLastPos2;
  fLastPos2 = fLastPos1;
  fLastPos1 = QPoint(evnt->x(), evnt->y());
 
  int deltaX = fLastPos2.x()-fLastPos1.x();
  int deltaY = fLastPos2.y()-fLastPos1.y();
 
  bool move = false;
  if (fUiQt != NULL) {
    if (fUiQt->IsIconMoveSelected()) {  // move
      move = true;
    }
  }
  if (!move) {  // rotate, pick, zoom...
    if (mButtons & Qt::LeftButton) {
      if (fNoKeyPress) {
        rotateQtScene(((float)deltaX),((float)deltaY));
      } else if (fAltKeyPress) {
        rotateQtSceneToggle(((float)deltaX),((float)deltaY));
      } else if (fShiftKeyPress) {
        unsigned int sizeWin;
        sizeWin = getWinWidth();
        if (getWinHeight() < getWinWidth()) {
          sizeWin = getWinHeight();
        }
 
        // L.Garnier : 08/2010 100 is the good value, but don't ask me why !
        float factor = ((float)100/(float)sizeWin) ;
        moveScene(-(float)deltaX*factor,-(float)deltaY*factor,0,false);
      } else if (fControlKeyPress) {
        fVP.SetZoomFactor(fVP.GetZoomFactor()*(1+((float)deltaY)));
      }
    }
  } else if (move) {  // move
    if (mButtons & Qt::LeftButton) {
      moveScene(-(float)deltaX,-(float)deltaY,0,true);
    }
  }
 
  fLastEventTime->start();
}

Referenced by G4OpenGLImmediateQtViewer::mouseMoveEvent(), and mouseMoveEvent().

◆ G4MousePressEvent()

void G4OpenGLQtViewer::G4MousePressEvent ( QMouseEvent * evnt )

inherited

Save the current mouse press point

Parameters

p	mouse click point

Definition at line 1282 of file G4OpenGLQtViewer.cc.

{
  if (evnt->button() == Qt::RightButton) {
    return;
  }
  if ((evnt->button() & Qt::LeftButton) && (! (evnt->modifiers() & Qt::ControlModifier ))){
    fGLWidget->setMouseTracking(true);
    fAutoMove = false; // stop automove
    fLastPos1 = evnt->pos();
    fLastPos2 = fLastPos1;
    fLastPos3 = fLastPos2;
    fLastEventTime->start();
    if (fUiQt != NULL) {
 
      if (fUiQt->IsIconZoomInSelected()) {  // zoomIn
        // Move click point to center of OGL
 
        float deltaX = ((float)getWinWidth()/2-evnt->pos().x());
        float deltaY = ((float)getWinHeight()/2-evnt->pos().y());
 
        G4double coefTrans = 0;
        coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinWidth());
        if (getWinHeight() <getWinWidth()) {
          coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinHeight());
        }
        fVP.IncrementPan(-deltaX*coefTrans,deltaY*coefTrans,0);
        fVP.SetZoomFactor(1.5 * fVP.GetZoomFactor());
 
        updateQWidget();
 
      } else if (fUiQt->IsIconZoomOutSelected()) {  // zoomOut
        // Move click point to center of OGL
        moveScene(((float)getWinWidth()/2-evnt->pos().x()),((float)getWinHeight()/2-evnt->pos().y()),0,true);
 
        fVP.SetZoomFactor(0.75 * fVP.GetZoomFactor());
        updateQWidget();
 
      } else if (fUiQt->IsIconRotateSelected() ) {
 
        if (fShiftKeyPress) { // move
          fGLWidget->setCursor(QCursor(Qt::SizeAllCursor));
 
        } else {  // rotate
          fGLWidget->setCursor(QCursor(Qt::ClosedHandCursor));
        }
      } else if (fUiQt->IsIconMoveSelected()) {
        fGLWidget->setCursor(QCursor(Qt::SizeAllCursor));
      } else if (fUiQt->IsIconPickSelected()) {
        fGLWidget->setCursor(QCursor(Qt::PointingHandCursor));
      }
    }
  }
}

Referenced by G4OpenGLImmediateQtViewer::mousePressEvent(), and mousePressEvent().

◆ G4MouseReleaseEvent()

void G4OpenGLQtViewer::G4MouseReleaseEvent ( QMouseEvent * evnt )

inherited

Definition at line 1338 of file G4OpenGLQtViewer.cc.

{
  GLint viewport[4];
  glGetIntegerv(GL_VIEWPORT, viewport);
 
  // factorX == factorY
  double factorX =  ((double)viewport[2]/fGLWidget->width());
  double factorY =  ((double)viewport[3]/fGLWidget->height());
  fSpinningDelay = fLastEventTime->elapsed();
  QPoint delta = (fLastPos3-fLastPos1)*factorX;
 
  // reset cursor state
  fGLWidget->setCursor(QCursor(Qt::ArrowCursor));
 
  if (fVP.IsPicking()){  // pick
    if ((delta.x() != 0) || (delta.y() != 0)) {
      return;
    }
    updatePickInfosWidget(evnt->pos().x()*factorX,evnt->pos().y()*factorY);
 
  } else if (fSpinningDelay < fLaunchSpinDelay ) {
    if ((delta.x() == 0) && (delta.y() == 0)) {
      return;
    }
 
    fAutoMove = true;
#if QT_VERSION < 0x050e00
    QTime lastMoveTime;
#else
    QElapsedTimer lastMoveTime;
#endif
    lastMoveTime.start();
    // try to addapt speed move/rotate looking to drawing speed
    float correctionFactor = 5;
    while (fAutoMove) {
      if ( lastMoveTime.elapsed() >= (int)(1000/fNbMaxFramesPerSec)) {
        float lTime = 1000/lastMoveTime.elapsed();
        if (((((float)delta.x())/correctionFactor)*lTime > fNbMaxAnglePerSec) ||
            ((((float)delta.x())/correctionFactor)*lTime < -fNbMaxAnglePerSec) ) {
          correctionFactor = (float)delta.x()*(lTime/fNbMaxAnglePerSec);
          if (delta.x() <0 ) {
            correctionFactor = -correctionFactor;
          }
        }
        if (((((float)delta.y())/correctionFactor)*lTime > fNbMaxAnglePerSec) ||
            ((((float)delta.y())/correctionFactor)*lTime < -fNbMaxAnglePerSec) ) {
          correctionFactor = (float)delta.y()*(lTime/fNbMaxAnglePerSec);
          if (delta.y() <0 ) {
            correctionFactor = -correctionFactor;
          }
        }
 
        // Check Qt Versions for META Keys
 
        // Click and move mouse to rotate volume
        // ALT + Click and move mouse to rotate volume (View Direction)
        // SHIFT + Click and move camera point of view
        // CTRL + Click and zoom mouse to zoom in/out
 
        lastMoveTime.start();
 
        bool rotate = false;
        bool move = false;
 
        if (fUiQt != NULL) {
          if (fUiQt->IsIconRotateSelected()) {  // rotate
            rotate = true;
          } else if (fUiQt->IsIconMoveSelected()) {  // move
            move = true;
          }
        } else {
          rotate = true;
        }
        // prevent from closing widget when rotating (cause a crash)
        if (fIsDeleting) {
          return;
        }
 
        if (rotate) {  // rotate
          if (fNoKeyPress) {
            rotateQtScene(((float)delta.x())/correctionFactor,((float)delta.y())/correctionFactor);
          } else if (fAltKeyPress) {
            rotateQtSceneToggle(((float)delta.x())/correctionFactor,((float)delta.y())/correctionFactor);
          }
 
        } else if (move) {  // move
          moveScene(-((float)delta.x())/correctionFactor,-((float)delta.y())/correctionFactor,0,true);
        }
      }
      ((QApplication*)G4Qt::getInstance ())->processEvents();
    }
  }
  fGLWidget->setMouseTracking(false);
 
}

Referenced by G4OpenGLImmediateQtViewer::mouseReleaseEvent(), and mouseReleaseEvent().

◆ G4wheelEvent()

void G4OpenGLQtViewer::G4wheelEvent ( QWheelEvent * event )

inherited

Definition at line 1600 of file G4OpenGLQtViewer.cc.

{
#if QT_VERSION < 0x050F00
  // Before Qt5.15
  fVP.SetZoomFactor(fVP.GetZoomFactor()+(fVP.GetZoomFactor()*(evnt->delta())/1200));
#else
  // Qt5.15 and beyond
  fVP.SetZoomFactor(fVP.GetZoomFactor()+(fVP.GetZoomFactor()*(evnt->angleDelta().y())/1200));
#endif
  updateQWidget();
}

References G4VViewer::fVP, G4ViewParameters::GetZoomFactor(), G4ViewParameters::SetZoomFactor(), and G4OpenGLQtViewer::updateQWidget().

Referenced by G4OpenGLImmediateQtViewer::wheelEvent(), and wheelEvent().

◆ generateMpegEncoderParameters()

bool G4OpenGLQtViewer::generateMpegEncoderParameters ( )

inherited

Definition at line 2227 of file G4OpenGLQtViewer.cc.

                                                      {
 
  // save the parameter file
  FILE* fp;
  fp = fopen (QString(fMovieTempFolderPath+fParameterFileName).toStdString().c_str(), "w");
 
  if (fp == NULL) {
    setRecordingInfos("Generation of parameter file failed");
    return false;
  }
 
  fprintf (fp,"# Pattern affects speed, quality and compression. See the User's Guide\n");
  fprintf (fp,"# for more info.\n");
  fprintf (fp,"\n");
  fprintf (fp,"PATTERN      I\n");
  fprintf (fp,"OUTPUT       %s\n",getSaveFileName().toStdString().c_str());
  fprintf (fp,"\n");
  fprintf (fp,"# You must specify the type of the input files.  The choices are:\n");
  fprintf (fp,"#    YUV, PPM, JMOVIE, Y, JPEG, PNM\n");
  fprintf (fp,"#    (must be upper case)\n");
  fprintf (fp,"#\n");
  fprintf (fp,"BASE_FILE_FORMAT PPM\n");
  fprintf (fp,"\n");
  fprintf (fp,"\n");
  fprintf (fp,"# If you are using YUV, there are different supported file formats.\n");
  fprintf (fp,"# EYUV or UCB are the same as previous versions of this encoder.\n");
  fprintf (fp,"# (All the Y's, then U's then V's, in 4:2:0 subsampling.)\n");
  fprintf (fp,"# Other formats, such as Abekas, Phillips, or a general format are\n");
  fprintf (fp,"# permissible, the general format is a string of Y's, U's, and V's\n");
  fprintf (fp,"# to specify the file order.\n");
  fprintf (fp,"\n");
  fprintf (fp,"INPUT_FORMAT UCB\n");
  fprintf (fp,"\n");
  fprintf (fp,"# the conversion statement\n");
  fprintf (fp,"#\n");
  fprintf (fp,"# Each occurrence of '*' will be replaced by the input file\n");
  fprintf (fp,"#\n");
  fprintf (fp,"# e.g., if you have a bunch of GIF files, then this might be:\n");
  fprintf (fp,"#    INPUT_CONVERT   giftoppm *\n");
  fprintf (fp,"#\n");
  fprintf (fp,"# e.g., if you have a bunch of files like a.Y a.U a.V, etc., then:\n");
  fprintf (fp,"#    INPUT_CONVERT   cat *.Y *.U *.V\n");
  fprintf (fp,"#\n");
  fprintf (fp,"# e.g., if you are grabbing from laser disc you might have something like\n");
  fprintf (fp,"#    INPUT_CONVERT   goto frame *; grabppm\n");
  fprintf (fp,"# 'INPUT_CONVERT *' means the files are already in the base file format\n");
  fprintf (fp,"#\n");
  fprintf (fp,"INPUT_CONVERT    * \n");
  fprintf (fp,"\n");
  fprintf (fp,"# number of frames in a GOP.\n");
  fprintf (fp,"#\n");
  fprintf (fp,"# since each GOP must have at least one I-frame, the encoder will find the\n");
  fprintf (fp,"# the first I-frame after GOP_SIZE frames to start the next GOP\n");
  fprintf (fp,"#\n");
  fprintf (fp,"# later, will add more flexible GOP signalling\n");
  fprintf (fp,"#\n");
  fprintf (fp,"GOP_SIZE 1\n");
  fprintf (fp,"\n");
  fprintf (fp,"# number of slices in a frame\n");
  fprintf (fp,"#\n");
  fprintf (fp,"# 1 is a good number.  another possibility is the number of macroblock rows\n");
  fprintf (fp,"# (which is the height divided by 16)\n");
  fprintf (fp,"#\n");
  fprintf (fp,"SLICES_PER_FRAME 1\n");
  fprintf (fp,"PIXEL HALF");
  fprintf (fp,"\n");
  fprintf (fp,"# directory to get all input files from (makes this file easier to read)\n");
  fprintf (fp,"INPUT_DIR    %s\n",fMovieTempFolderPath.toStdString().c_str());
  fprintf (fp,"\n");
  fprintf (fp,"# There are a bunch of ways to specify the input files.\n");
  fprintf (fp,"# from a simple one-per-line listing, to the following \n");
  fprintf (fp,"# way of numbering them.  See the manual for more information.\n");
  fprintf (fp,"INPUT\n");
  fprintf (fp,"# '*' is replaced by the numbers 01, 02, 03, 04\n");
  fprintf (fp,"# if I instead do [01-11], it would be 01, 02, ..., 09, 10, 11\n");
  fprintf (fp,"# if I instead do [1-11], it would be 1, 2, 3, ..., 9, 10, 11\n");
  fprintf (fp,"# if I instead do [1-11+3], it would be 1, 4, 7, 10\n");
  fprintf (fp,"# the program assumes none of your input files has a name ending in ']'\n");
  fprintf (fp,"# if you do, too bad!!!\n");
  fprintf (fp,"#\n");
  fprintf (fp,"#\n");
  fprintf (fp,"Test*.ppm    [0-%d]\n",fRecordFrameNumber-1);
  fprintf (fp,"# can have more files here if you want...there is no limit on the number\n");
  fprintf (fp,"# of files\n");
  fprintf (fp,"END_INPUT\n");
  fprintf (fp,"\n");
  fprintf (fp,"\n");
  fprintf (fp,"\n");
  fprintf (fp,"# Many of the remaining options have to do with the motion search and qscale\n");
  fprintf (fp,"\n");
  fprintf (fp,"# FULL or HALF -- must be upper case\n");
  fprintf (fp,"# Should be FULL for computer generated images\n");
  fprintf (fp,"PIXEL        FULL\n");
  fprintf (fp,"\n");
  fprintf (fp,"# means +/- this many pixels for both P and B frame searches\n");
  fprintf (fp,"# specify two numbers if you wish to serc different ranges in the two.\n");
  fprintf (fp,"RANGE        10\n");
  fprintf (fp,"\n");
  fprintf (fp,"# The two search algorithm parameters below mostly affect speed,\n");
  fprintf (fp,"# with some affect on compression and almost none on quality.\n");
  fprintf (fp,"\n");
  fprintf (fp,"# this must be one of {EXHAUSTIVE, SUBSAMPLE, LOGARITHMIC}\n");
  fprintf (fp,"PSEARCH_ALG  LOGARITHMIC\n");
  fprintf (fp,"\n");
  fprintf (fp,"# this must be one of {SIMPLE, CROSS2, EXHAUSTIVE}\n");
  fprintf (fp,"#\n");
  fprintf (fp,"# note that EXHAUSTIVE is really, really, really slow\n");
  fprintf (fp,"#\n");
  fprintf (fp,"BSEARCH_ALG  SIMPLE\n");
  fprintf (fp,"\n");
  fprintf (fp,"#\n");
  fprintf (fp,"# these specify the q-scale for I, P, and B frames\n");
  fprintf (fp,"# (values must be between 1 and 31)\n");
  fprintf (fp,"# These are the Qscale values for the entire frame in variable bit-rate\n");
  fprintf (fp,"# mode, and starting points (but not important) for constant bit rate\n");
  fprintf (fp,"#\n");
  fprintf (fp,"\n");
  fprintf (fp,"# Qscale (Quantization scale) affects quality and compression,\n");
  fprintf (fp,"# but has very little effect on speed.\n");
  fprintf (fp,"\n");
  fprintf (fp,"IQSCALE      4\n");
  fprintf (fp,"PQSCALE      5\n");
  fprintf (fp,"BQSCALE      12\n");
  fprintf (fp,"\n");
  fprintf (fp,"# this must be ORIGINAL or DECODED\n");
  fprintf (fp,"REFERENCE_FRAME  ORIGINAL\n");
  fprintf (fp,"\n");
  fprintf (fp,"# for parallel parameters see parallel.param in the examples subdirectory\n");
  fprintf (fp,"\n");
  fprintf (fp,"# if you want constant bit-rate mode, specify it as follows (number is bits/sec):\n");
  fprintf (fp,"#BIT_RATE  1000000\n");
  fprintf (fp,"\n");
  fprintf (fp,"# To specify the buffer size (327680 is default, measused in bits, for 16bit words)\n");
  fprintf (fp,"BUFFER_SIZE 327680\n");
  fprintf (fp,"\n");
  fprintf (fp,"# The frame rate is the number of frames/second (legal values:\n");
  fprintf (fp,"# 23.976, 24, 25, 29.97, 30, 50 ,59.94, 60\n");
  fprintf (fp,"FRAME_RATE 30\n");
  fprintf (fp,"\n");
  fprintf (fp,"# There are many more options, see the users manual for examples....\n");
  fprintf (fp,"# ASPECT_RATIO, USER_DATA, GAMMA, IQTABLE, etc.\n");
  fprintf (fp,"\n");
  fprintf (fp,"\n");
  fclose (fp);
 
  setRecordingInfos("Parameter file "+fParameterFileName+" generated in "+fMovieTempFolderPath);
  setRecordingStatus(READY_TO_ENCODE);
  return true;
}

References G4OpenGLQtViewer::fMovieTempFolderPath, G4OpenGLQtViewer::fParameterFileName, G4OpenGLQtViewer::fRecordFrameNumber, G4OpenGLQtViewer::getSaveFileName(), G4OpenGLQtViewer::READY_TO_ENCODE, G4OpenGLQtViewer::setRecordingInfos(), and G4OpenGLQtViewer::setRecordingStatus().

Referenced by G4OpenGLQtViewer::saveVideo().

◆ GetApplicableVisAttributes()

const G4VisAttributes * G4VViewer::GetApplicableVisAttributes ( const G4VisAttributes * ) const

inherited

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4VtkSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4OpenInventorSceneHandler::AddProperties(), G4HepRepFileSceneHandler::AddSolid(), G4VSceneHandler::AddSolidT(), G4VSceneHandler::AddSolidWithAuxiliaryEdges(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4VSceneHandler::GetColour(), and G4GMocrenFileSceneHandler::IsVisible().

◆ getColorForPoIndex()

G4Colour G4OpenGLQtViewer::getColorForPoIndex ( int poIndex )

protectedinherited

Definition at line 3659 of file G4OpenGLQtViewer.cc.

                                                         {
  // FIXME 09/2014 : Could be optimize by searching in a tab instead of item->data
  QTreeWidgetItem* item = getTreeWidgetItem(poIndex);
 
  if (item != NULL) {
 
    const QColor& color = item->data(2,Qt::UserRole).value<QColor>();
    G4Colour g4c(((G4double)color.red())/255,
                 ((G4double)color.green())/255,
                 ((G4double)color.blue())/255,
                 ((G4double)color.alpha())/255);
 
    return g4c;
  }
  return G4Colour();
}

References G4OpenGLQtViewer::getTreeWidgetItem().

Referenced by G4OpenGLQtViewer::changeDepthOnSceneTreeItem(), DisplayTimePOColourModification(), and G4OpenGLQtViewer::updatePickInfosWidget().

◆ GetCommandParameterList()

QString G4OpenGLQtViewer::GetCommandParameterList ( const G4UIcommand * aCommand )

privateinherited

Build the parameter list parameters in a QString
Reimplement partialy the G4UIparameter.cc

Parameters

aCommand : command to list parameters

See also: G4UIparameter::List(); G4UIcommand::List()

Returns: the command list parameters, or "" if nothing

Definition at line 4755 of file G4OpenGLQtViewer.cc.

{
  G4int n_parameterEntry = aCommand->GetParameterEntries();
  QString txt;
 
  if( n_parameterEntry > 0 ) {
    G4UIparameter *param;
 
    // Re-implementation of G4UIparameter.cc
 
    for( G4int i_thParameter=0; i_thParameter<n_parameterEntry; i_thParameter++ ) {
      param = aCommand->GetParameter(i_thParameter);
      txt += "\nParameter : " + QString((char*)(param->GetParameterName()).data()) + "\n";
      if( ! param->GetParameterGuidance().empty() )
        txt += QString((char*)(param->GetParameterGuidance()).data())+ "\n" ;
      txt += " Parameter type  : " + QString(QChar(param->GetParameterType())) + "\n";
      if(param->IsOmittable()){
        txt += " Omittable       : True\n";
      } else {
        txt += " Omittable       : False\n";
      }
      if( param->GetCurrentAsDefault() ) {
        txt += " Default value   : taken from the current value\n";
      } else if( ! param->GetDefaultValue().empty() ) {
        txt += " Default value   : " + QString((char*)(param->GetDefaultValue()).data())+ "\n";
      }
      if( ! param->GetParameterRange().empty() ) {
        txt += " Parameter range : " + QString((char*)(param->GetParameterRange()).data())+ "\n";
      }
      if( ! param->GetParameterCandidates().empty() ) {
        txt += " Candidates      : " + QString((char*)(param->GetParameterCandidates()).data())+ "\n";
      }
    }
  }
  return txt;
}

References G4UIparameter::GetCurrentAsDefault(), G4UIparameter::GetDefaultValue(), G4UIcommand::GetParameter(), G4UIparameter::GetParameterCandidates(), G4UIcommand::GetParameterEntries(), G4UIparameter::GetParameterGuidance(), G4UIparameter::GetParameterName(), G4UIparameter::GetParameterRange(), G4UIparameter::GetParameterType(), and G4UIparameter::IsOmittable().

Referenced by G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetDefaultViewParameters()

const G4ViewParameters & G4VViewer::GetDefaultViewParameters ( ) const

inherited

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ getEncoderPath()

QString G4OpenGLQtViewer::getEncoderPath ( )

inherited

Returns: encoder path or "" if it does not exist

Definition at line 1918 of file G4OpenGLQtViewer.cc.

                                         {
  return fEncoderPath;
}

References G4OpenGLQtViewer::fEncoderPath.

Referenced by G4OpenGLQtMovieDialog::checkEncoderSwParameters(), G4OpenGLQtViewer::encodeVideo(), G4OpenGLQtMovieDialog::G4OpenGLQtMovieDialog(), and G4OpenGLQtViewer::showMovieParametersDialog().

◆ getModelShortName()

QString G4OpenGLQtViewer::getModelShortName ( const G4String & model )

privateinherited

Get the short name for a given label

Definition at line 3435 of file G4OpenGLQtViewer.cc.

                                                                 {
 
  QString modelShortName = model.data();
  if (modelShortName.mid(0,modelShortName.indexOf(" ")) == "G4PhysicalVolumeModel") {
    modelShortName = fTouchableVolumes;
  } else {
    if (modelShortName.mid(0,2) == "G4") {
      modelShortName = modelShortName.mid(2);
    }
    if (modelShortName.indexOf("Model") != -1) {
      modelShortName = modelShortName.mid(0,modelShortName.indexOf("Model"));
    }
  }
  return modelShortName;
}

References G4OpenGLQtViewer::fTouchableVolumes.

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), and G4OpenGLQtViewer::addPVSceneTreeElement().

◆ GetName()

const G4String & G4VViewer::GetName ( ) const

inherited

◆ getOldTreeWidgetItem()

QTreeWidgetItem * G4OpenGLQtViewer::getOldTreeWidgetItem ( int POindex )

privateinherited

Returns: the corresponding item if existing in the old tree Look into fOldPositivePoIndexSceneTreeWidgetQuickMap

Definition at line 4043 of file G4OpenGLQtViewer.cc.

                                                                  {
 
 
  // -1 is not a visible item
  if (POindex == -1) {
    return NULL;
  }
 
  if (fOldPositivePoIndexSceneTreeWidgetQuickMap.size() == 0){
    return NULL;
  }
 
  // Should be call only once by item addition
  // Prevent to get out the std::map
  if (fOldLastSceneTreeWidgetAskForIterator != fOldLastSceneTreeWidgetAskForIteratorEnd) {
    fOldLastSceneTreeWidgetAskForIterator++;
  }
 
  if (fOldLastSceneTreeWidgetAskForIterator != fOldPositivePoIndexSceneTreeWidgetQuickMap.end()) {
    if (POindex == fOldLastSceneTreeWidgetAskForIterator->first) {
      if (fOldLastSceneTreeWidgetAskForIterator->second != NULL) {
        return fOldLastSceneTreeWidgetAskForIterator->second;
      }
    }
  }
 
  // if not, use the "find" algorithm
  fOldLastSceneTreeWidgetAskForIterator = fOldPositivePoIndexSceneTreeWidgetQuickMap.find(POindex);
  fOldLastSceneTreeWidgetAskForIteratorEnd = fOldPositivePoIndexSceneTreeWidgetQuickMap.end();
 
  if (fOldLastSceneTreeWidgetAskForIterator != fOldPositivePoIndexSceneTreeWidgetQuickMap.end()) {
    return fOldLastSceneTreeWidgetAskForIterator->second;
  }
  return NULL;
}

References G4OpenGLQtViewer::fOldLastSceneTreeWidgetAskForIterator, G4OpenGLQtViewer::fOldLastSceneTreeWidgetAskForIteratorEnd, and G4OpenGLQtViewer::fOldPositivePoIndexSceneTreeWidgetQuickMap.

Referenced by G4OpenGLQtViewer::changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement().

◆ getParentWidget()

QWidget * G4OpenGLQtViewer::getParentWidget ( )

privateinherited

Definition at line 2480 of file G4OpenGLQtViewer.cc.

{
  // launch Qt if not
  G4Qt* interactorManager = G4Qt::getInstance ();
  // G4UImanager* UI =
  // G4UImanager::GetUIpointer();
 
  bool found = false;
  QDialog* dialog = NULL;
  // create window
  if (((QApplication*)interactorManager->GetMainInteractor())) {
    // look for the main window
    QWidgetList wl = QApplication::allWidgets();
    QWidget *widget = NULL;
    for (int i=0; i < wl.size(); i++) {
      widget = wl.at(i);
      if ((found== false) && (widget->inherits("QMainWindow"))) {
        dialog = new QDialog(widget,Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowMinMaxButtonsHint);
        found = true;
      }
    }
 
    if (found==false) {
      dialog = new QDialog();
    }
  } else {
    dialog= new QDialog();
  }
  if (found) {
    return dialog;
  } else {
    return NULL;
  }
}

References G4Qt::getInstance(), and G4VInteractorManager::GetMainInteractor().

Referenced by G4OpenGLQtViewer::CreateMainWindow().

◆ GetPickDetails()

const std::vector< G4OpenGLViewerPickMap * > & G4OpenGLViewer::GetPickDetails	(	GLdouble	x,
		GLdouble	y
	)

protectedinherited

Definition at line 488 of file G4OpenGLViewer.cc.

{
  static std::vector < G4OpenGLViewerPickMap* > pickMapVector;
  for (auto pickMap: pickMapVector) {
    delete pickMap;
  }
  pickMapVector.clear();
  
  const G4int BUFSIZE = 512;
  GLuint selectBuffer[BUFSIZE];
  glSelectBuffer(BUFSIZE, selectBuffer);
  glRenderMode(GL_SELECT);
  glInitNames();
  glPushName(0);
  glMatrixMode(GL_PROJECTION);
  G4double currentProjectionMatrix[16];
  glGetDoublev(GL_PROJECTION_MATRIX, currentProjectionMatrix);
  glPushMatrix();
  glLoadIdentity();
  GLint viewport[4];
  glGetIntegerv(GL_VIEWPORT, viewport);
/*  G4cout
  << "viewport, x,y: "
  << viewport[0] << ',' << viewport[1] << ',' << viewport[2] << ',' << viewport[3]
  << ", " << x << ',' << y
  << G4endl;
*/
  fIsGettingPickInfos = true;
  // Define 5x5 pixel pick area
  g4GluPickMatrix(x, viewport[3] - y, 5., 5., viewport);
  glMultMatrixd(currentProjectionMatrix);
  glMatrixMode(GL_MODELVIEW);
  DrawView();
  GLint hits = glRenderMode(GL_RENDER);
  fIsGettingPickInfos = false;
  if (hits < 0) {
    G4cout << "Too many hits.  Zoom in to reduce overlaps." << G4endl;
    goto restoreMatrices;
  }
  if (hits > 0) {
    GLuint* p = selectBuffer;
    for (GLint i = 0; i < hits; ++i) {
      GLuint nnames = *p++;
      // This bit of debug code or...
      //GLuint zmin = *p++;
      //GLuint zmax = *p++;
      //G4cout << "Hit " << i << ": " << nnames << " names"
      //       << "\nzmin: " << zmin << ", zmax: " << zmax << G4endl;
      // ...just increment the pointer
      p++;
      p++;
      for (GLuint j = 0; j < nnames; ++j) {
        GLuint name = *p++;
    std::map<GLuint, G4AttHolder*>::iterator iter =
      fOpenGLSceneHandler.fPickMap.find(name);
    if (iter != fOpenGLSceneHandler.fPickMap.end()) {
      G4AttHolder* attHolder = iter->second;
      if(attHolder && attHolder->GetAttDefs().size()) {
        for (size_t iAtt = 0;
         iAtt < attHolder->GetAttDefs().size(); ++iAtt) {
              std::ostringstream oss;
          oss << G4AttCheck(attHolder->GetAttValues()[iAtt],
                                attHolder->GetAttDefs()[iAtt]);
              G4OpenGLViewerPickMap* pickMap = new G4OpenGLViewerPickMap();
//              G4cout
//              << "i,j, attHolder->GetAttDefs().size(): "
//              << i << ',' << j
//              << ", " << attHolder->GetAttDefs().size()
//              << G4endl;
//              G4cout << "G4OpenGLViewer::GetPickDetails: " << oss.str() << G4endl;
              pickMap->addAttributes(oss.str());
              pickMap->setHitNumber(i);
              pickMap->setSubHitNumber(j);
              pickMap->setPickName(name);
              pickMapVector.push_back(pickMap);
            }
          }
        }
      }
    }
  }
 
restoreMatrices:
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
 
  return pickMapVector;
}

References G4OpenGLViewerPickMap::addAttributes(), BUFSIZE, G4VViewer::DrawView(), G4OpenGLViewer::fIsGettingPickInfos, G4OpenGLViewer::fOpenGLSceneHandler, G4OpenGLSceneHandler::fPickMap, G4cout, G4endl, G4OpenGLViewer::g4GluPickMatrix(), G4AttHolder::GetAttDefs(), G4AttHolder::GetAttValues(), G4InuclParticleNames::name(), G4OpenGLViewerPickMap::setHitNumber(), G4OpenGLViewerPickMap::setPickName(), and G4OpenGLViewerPickMap::setSubHitNumber().

Referenced by G4OpenGLViewer::Pick(), and G4OpenGLQtViewer::updatePickInfosWidget().

◆ GetPrivateVisAttributesModifiers()

const std::vector< G4ModelingParameters::VisAttributesModifier > * G4OpenGLQtViewer::GetPrivateVisAttributesModifiers ( ) const

protectedvirtualinherited

Reimplemented from G4VViewer.

Definition at line 3678 of file G4OpenGLQtViewer.cc.

{
  static std::vector<G4ModelingParameters::VisAttributesModifier>
  privateVisAttributesModifiers;
 
  privateVisAttributesModifiers.clear();
 
// I don't think we need this.  (JA Sep 2016).
//  // For each modified touchable...
//  std::map<int,PVPath>::const_iterator i;
//  for (i = fTreeItemModels.begin();
//       i != fTreeItemModels.end();
//       ++i) {
//
//    // How do I know if it's been modified or not?
//
//    int iPO = i->first;
//    const PVPath& fullPath = i->second;
//
//    // If a physical volume
//    if (fullPath.size()) {
//
//      //    const G4bool& visibilityChanged = ???
//      //    const G4bool& visibility = ???
//      //    const G4bool& colourChanged = ???
//      //    const QColor& colour = ???
//      //    G4Colour g4colour(((G4double)colour.red())/255,
//      //                      ((G4double)colour.green())/255,
//      //                      ((G4double)colour.blue())/255,
//      //                      ((G4double)colour.alpha())/255);
//      // Next 4 lines are for testing, to be replaced by the above...
//      G4bool visibilityChanged = true;
//      G4bool visibility = true;
//      G4bool colourChanged = true;
//      G4Colour g4colour(G4Colour::Red());
//
//      // Instantiate a working copy of a G4VisAttributes object...
//      G4VisAttributes workingVisAtts;
//      // ...and use it to create vis attribute modifiers...
//      if (visibilityChanged) {
//        workingVisAtts.SetVisibility(visibility);
//        privateVisAttributesModifiers.push_back
//        (G4ModelingParameters::VisAttributesModifier
//         (workingVisAtts,
//          G4ModelingParameters::VASVisibility,
//          fullPath));
//      }
//      if (colourChanged) {
//        workingVisAtts.SetColour(g4colour);
//        privateVisAttributesModifiers.push_back
//        (G4ModelingParameters::VisAttributesModifier
//         (workingVisAtts,
//          G4ModelingParameters::VASColour,
//          fullPath));
//      }
//    }
//  }
 
  return &privateVisAttributesModifiers;
}

◆ getProcessErrorMsg()

QString G4OpenGLQtViewer::getProcessErrorMsg ( )

privateinherited

Definition at line 2449 of file G4OpenGLQtViewer.cc.

{
  QString txt = "";
  if (fProcess->exitCode() != 0) {
    switch (fProcess->error()) {
    case QProcess::FailedToStart:
      txt = "The process failed to start. Either the invoked program is missing, or you may have insufficient permissions to invoke the program.\n";
      break;
    case QProcess::Crashed:
      txt = "The process crashed some time after starting successfully.\n";
      break;
    case QProcess::Timedout:
      txt = "The last waitFor...() function timed out. The state of QProcess is unchanged, and you can try calling waitFor...() again.\n";
      break;
    case QProcess::WriteError:
      txt = "An error occurred when attempting to write to the process. For example, the process may not be running, or it may have closed its input channel.\n";
      break;
    case QProcess::ReadError:
      txt = "An error occurred when attempting to read from the process. For example, the process may not be running.\n";
      break;
    case QProcess::UnknownError:
      txt = "An unknown error occurred. This is the default return value of error().\n";
      break;
    }
  }
  return txt;
}

References G4OpenGLQtViewer::fProcess.

Referenced by G4OpenGLQtViewer::processEncodeFinished(), and G4OpenGLQtViewer::processLookForFinished().

◆ getRealExportHeight()

G4int G4OpenGLViewer::getRealExportHeight ( )

privateinherited

Definition at line 1004 of file G4OpenGLViewer.cc.

                                          {
  if (fPrintSizeY == -1) {
    return fWinSize_y;
  }
  GLint dims[2];
  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
 
  // L.Garnier 01-2010: Some problems with mac 10.6
  if ((dims[0] !=0 ) && (dims[1] !=0)) {
    if (fPrintSizeY > dims[1]){
      return dims[1];
    }
  }
  if (fPrintSizeY < -1){
    return 0;
  }
  return fPrintSizeY;
}

References G4OpenGLViewer::fPrintSizeY, and G4OpenGLViewer::fWinSize_y.

Referenced by G4OpenGLViewer::exportImage(), G4OpenGLViewer::printGl2PS(), and G4OpenGLViewer::printNonVectoredEPS().

◆ getRealExportWidth()

G4int G4OpenGLViewer::getRealExportWidth ( )

privateinherited

Definition at line 985 of file G4OpenGLViewer.cc.

                                         {
  if (fPrintSizeX == -1) {
    return fWinSize_x;
  }
  GLint dims[2];
  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
 
  // L.Garnier 01-2010: Some problems with mac 10.6
  if ((dims[0] !=0 ) && (dims[1] !=0)) {
    if (fPrintSizeX > dims[0]){
      return dims[0];
    }
  }
  if (fPrintSizeX < -1){
    return 0;
  }
  return fPrintSizeX;
}

References G4OpenGLViewer::fPrintSizeX, and G4OpenGLViewer::fWinSize_x.

Referenced by G4OpenGLViewer::exportImage(), G4OpenGLViewer::printGl2PS(), and G4OpenGLViewer::printNonVectoredEPS().

◆ getRealPrintFilename()

std::string G4OpenGLViewer::getRealPrintFilename ( )

protectedinherited

Definition at line 1066 of file G4OpenGLViewer.cc.

                                               {
  std::string temp = fExportFilename;
  if (fExportFilenameIndex != -1) {
    temp += std::string("_");
    std::ostringstream os;
    os << std::setw(4) << std::setfill('0') << fExportFilenameIndex;
    std::string nb_str = os.str();
    temp += nb_str;
  }
  temp += "."+fExportImageFormat;
  return temp;
}

References G4OpenGLViewer::fExportFilename, G4OpenGLViewer::fExportFilenameIndex, and G4OpenGLViewer::fExportImageFormat.

Referenced by G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::exportImage(), G4OpenGLXmViewer::misc_callback(), G4OpenGLViewer::printGl2PS(), G4OpenGLViewer::printNonVectoredEPS(), and G4OpenGLViewer::setExportFilename().

◆ getSaveFileName()

QString G4OpenGLQtViewer::getSaveFileName ( )

inherited

Returns: the save file path

Definition at line 2114 of file G4OpenGLQtViewer.cc.

                                          {
  return fSaveFileName ;
}

References G4OpenGLQtViewer::fSaveFileName.

Referenced by G4OpenGLQtMovieDialog::checkSaveFileNameParameters(), G4OpenGLQtViewer::encodeVideo(), and G4OpenGLQtViewer::generateMpegEncoderParameters().

◆ getSceneDepth()

GLdouble G4OpenGLViewer::getSceneDepth ( )

protectedinherited

Definition at line 1111 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return 0;
  }
  const G4Point3D targetPoint
    = fSceneHandler.GetScene()->GetStandardTargetPoint()
    + fVP.GetCurrentTargetPoint ();
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
  if(radius<=0.) radius = 1.;
  const G4double cameraDistance = fVP.GetCameraDistance (radius);
  const GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
  return fVP.GetFarDistance  (cameraDistance, pnear, radius)- pnear;
}

References G4VViewer::fSceneHandler, G4VViewer::fVP, G4ViewParameters::GetCameraDistance(), G4ViewParameters::GetCurrentTargetPoint(), G4Scene::GetExtent(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetFarDistance(), G4ViewParameters::GetNearDistance(), G4VSceneHandler::GetScene(), and G4Scene::GetStandardTargetPoint().

Referenced by G4OpenGLQtViewer::moveScene().

◆ getSceneFarWidth()

GLdouble G4OpenGLViewer::getSceneFarWidth ( )

protectedinherited

Definition at line 1094 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return 0;
  }
  const G4Point3D targetPoint
    = fSceneHandler.GetScene()->GetStandardTargetPoint()
    + fVP.GetCurrentTargetPoint ();
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
  if(radius<=0.) radius = 1.;
  const G4double cameraDistance = fVP.GetCameraDistance (radius);
  const GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
  const GLdouble pfar    = fVP.GetFarDistance  (cameraDistance, pnear, radius);
  return 2 * fVP.GetFrontHalfHeight (pfar, radius);
}

References G4VViewer::fSceneHandler, G4VViewer::fVP, G4ViewParameters::GetCameraDistance(), G4ViewParameters::GetCurrentTargetPoint(), G4Scene::GetExtent(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetFarDistance(), G4ViewParameters::GetFrontHalfHeight(), G4ViewParameters::GetNearDistance(), G4VSceneHandler::GetScene(), and G4Scene::GetStandardTargetPoint().

◆ GetSceneHandler()

G4VSceneHandler * G4VViewer::GetSceneHandler ( ) const

inherited

Referenced by G4OpenGLXmViewer::actions_callback(), G4OpenGLXmViewer::left_right_pan_callback(), G4OpenGLXmViewer::misc_callback(), G4VVisCommand::RefreshIfRequired(), G4OpenGLXmViewer::ResetView(), G4OpenGLViewerMessenger::SetNewValue(), G4VisCommandViewerCentreOn::SetNewValue(), G4VisCommandViewerClearTransients::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), G4VisCommandViewerRebuild::SetNewValue(), G4VisCommandViewerSave::SetNewValue(), G4VisCommandViewerUpdate::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLWin32Viewer::SetShift(), and G4OpenGLXmViewer::up_down_pan_callback().

◆ getSceneNearWidth()

GLdouble G4OpenGLViewer::getSceneNearWidth ( )

protectedinherited

Definition at line 1079 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return 0;
  }
  const G4Point3D targetPoint
    = fSceneHandler.GetScene()->GetStandardTargetPoint()
    + fVP.GetCurrentTargetPoint ();
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
  if(radius<=0.) radius = 1.;
  const G4double cameraDistance = fVP.GetCameraDistance (radius);
  const GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
  return 2 * fVP.GetFrontHalfHeight (pnear, radius);
}

References G4VViewer::fSceneHandler, G4VViewer::fVP, G4ViewParameters::GetCameraDistance(), G4ViewParameters::GetCurrentTargetPoint(), G4Scene::GetExtent(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetFrontHalfHeight(), G4ViewParameters::GetNearDistance(), G4VSceneHandler::GetScene(), and G4Scene::GetStandardTargetPoint().

Referenced by G4OpenGLQtViewer::G4MousePressEvent(), and G4OpenGLQtViewer::moveScene().

◆ GetShortName()

const G4String & G4VViewer::GetShortName ( ) const

inherited

Referenced by G4OpenGLViewer::G4OpenGLViewer().

◆ getTempFolderPath()

QString G4OpenGLQtViewer::getTempFolderPath ( )

inherited

Returns: the temp folder path or "" if it does not exist

Definition at line 2080 of file G4OpenGLQtViewer.cc.

                                            {
  return fTempFolderPath;
}

References G4OpenGLQtViewer::fTempFolderPath.

Referenced by G4OpenGLQtMovieDialog::checkTempFolderParameters(), G4OpenGLQtMovieDialog::G4OpenGLQtMovieDialog(), and G4OpenGLQtViewer::startPauseVideo().

◆ getTreeWidgetItem()

QTreeWidgetItem * G4OpenGLQtViewer::getTreeWidgetItem ( int POindex )

privateinherited

Returns: the corresponding item if existing. Look into fPositivePoIndexSceneTreeWidgetQuickMap

Definition at line 4010 of file G4OpenGLQtViewer.cc.

                                                               {
 
  // -1 is not a visible item
  if (POindex == -1) {
    return NULL;
  }
 
  if (fPositivePoIndexSceneTreeWidgetQuickMap.size() == 0){
    return NULL;
  }
 
  if (fLastSceneTreeWidgetAskForIterator != fLastSceneTreeWidgetAskForIteratorEnd) {
    if (POindex == fLastSceneTreeWidgetAskForIterator->first) {
      if (fLastSceneTreeWidgetAskForIterator->second != NULL) {
        return fLastSceneTreeWidgetAskForIterator->second;
      }
    }
  }
 
  // if not, use the "find" algorithm
  fLastSceneTreeWidgetAskForIterator = fPositivePoIndexSceneTreeWidgetQuickMap.find(POindex);
  fLastSceneTreeWidgetAskForIteratorEnd = fPositivePoIndexSceneTreeWidgetQuickMap.end();
 
  if (fLastSceneTreeWidgetAskForIterator != fPositivePoIndexSceneTreeWidgetQuickMap.end()) {
    return fLastSceneTreeWidgetAskForIterator->second;
  }
  return NULL;
}

References G4OpenGLQtViewer::fLastSceneTreeWidgetAskForIterator, G4OpenGLQtViewer::fLastSceneTreeWidgetAskForIteratorEnd, and G4OpenGLQtViewer::fPositivePoIndexSceneTreeWidgetQuickMap.

Referenced by G4OpenGLQtViewer::getColorForPoIndex(), and G4OpenGLQtViewer::isTouchableVisible().

◆ GetViewId()

G4int G4VViewer::GetViewId ( ) const

inherited

Referenced by G4RayTracer::CreateViewer(), G4RayTracerX::CreateViewer(), G4HepRepFile::CreateViewer(), G4Qt3D::CreateViewer(), G4ToolsSGQtGLES::CreateViewer(), G4ToolsSGWindowsGLES::CreateViewer(), G4ToolsSGX11GLES::CreateViewer(), G4ToolsSGXtGLES::CreateViewer(), G4Vtk::CreateViewer(), and G4VtkQt::CreateViewer().

◆ GetViewParameters()

const G4ViewParameters & G4VViewer::GetViewParameters ( ) const

inherited

◆ getWinHeight()

unsigned int G4OpenGLViewer::getWinHeight ( ) const

protectedinherited

Definition at line 977 of file G4OpenGLViewer.cc.

                                               {
  return fWinSize_y;
}

References G4OpenGLViewer::fWinSize_y.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::DrawText(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::moveScene(), G4OpenGLImmediateQtViewer::paintGL(), and paintGL().

◆ getWinWidth()

unsigned int G4OpenGLViewer::getWinWidth ( ) const

protectedinherited

Definition at line 973 of file G4OpenGLViewer.cc.

                                              {
  return fWinSize_x;
}

References G4OpenGLViewer::fWinSize_x.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::DrawText(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::moveScene(), G4OpenGLImmediateQtViewer::paintGL(), and paintGL().

◆ grabPixels()

GLubyte * G4OpenGLViewer::grabPixels	(	int	inColor,
		unsigned int	width,
		unsigned int	height
	)

privateinherited

Definition at line 578 of file G4OpenGLViewer.cc.

                                                       {
  
  GLubyte* buffer;
  GLint swapbytes, lsbfirst, rowlength;
  GLint skiprows, skippixels, alignment;
  GLenum format;
  int size;
 
  if (inColor) {
    format = GL_RGB;
    size = width*height*3;
  } else {
    format = GL_LUMINANCE;
    size = width*height*1;
  }
 
  buffer = new GLubyte[size];
  if (buffer == NULL)
    return NULL;
 
  glGetIntegerv (GL_UNPACK_SWAP_BYTES, &swapbytes);
  glGetIntegerv (GL_UNPACK_LSB_FIRST, &lsbfirst);
  glGetIntegerv (GL_UNPACK_ROW_LENGTH, &rowlength);
 
  glGetIntegerv (GL_UNPACK_SKIP_ROWS, &skiprows);
  glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &skippixels);
  glGetIntegerv (GL_UNPACK_ALIGNMENT, &alignment);
 
  glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
  glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
  glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
 
  glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
  glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
 
  glReadBuffer(GL_FRONT);
  glReadPixels (0, 0, (GLsizei)width, (GLsizei)height, format, GL_UNSIGNED_BYTE, (GLvoid*) buffer);
 
  glPixelStorei (GL_UNPACK_SWAP_BYTES, swapbytes);
  glPixelStorei (GL_UNPACK_LSB_FIRST, lsbfirst);
  glPixelStorei (GL_UNPACK_ROW_LENGTH, rowlength);
  
  glPixelStorei (GL_UNPACK_SKIP_ROWS, skiprows);
  glPixelStorei (GL_UNPACK_SKIP_PIXELS, skippixels);
  glPixelStorei (GL_UNPACK_ALIGNMENT, alignment);
  
  return buffer;
}

References buffer.

Referenced by G4OpenGLViewer::printNonVectoredEPS().

◆ HaloingFirstPass()

void G4OpenGLViewer::HaloingFirstPass ( )

protectedinherited

Definition at line 441 of file G4OpenGLViewer.cc.

                                       {
  
  //To perform haloing, first Draw all information to the depth buffer
  //alone, using a chunky line width, and then Draw all info again, to
  //the colour buffer, setting a thinner line width an the depth testing 
  //function to less than or equal, so if two lines cross, the one 
  //passing behind the other will not pass the depth test, and so not
  //get rendered either side of the infront line for a short distance.
 
  //First, disable writing to the colo(u)r buffer...
  glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
  //Now enable writing to the depth buffer...
  glDepthMask (GL_TRUE);
  glDepthFunc (GL_LESS);
  glClearDepth (1.0);
 
  //Finally, set the line width to something wide...
  ChangeLineWidth(3.0);
 
}

References G4OpenGLViewer::ChangeLineWidth().

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), ComputeView(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), and G4OpenGLStoredXViewer::DrawView().

◆ HaloingSecondPass()

void G4OpenGLViewer::HaloingSecondPass ( )

protectedinherited

Definition at line 463 of file G4OpenGLViewer.cc.

                                        {
 
  //And finally, turn the colour buffer back on with a sesible line width...
  glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  glDepthFunc (GL_LEQUAL);
  ChangeLineWidth(1.0);
 
}

References G4OpenGLViewer::ChangeLineWidth().

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), ComputeView(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), and G4OpenGLStoredXViewer::DrawView().

◆ HLRFirstPass()

void G4OpenGLViewer::HLRFirstPass ( )

protectedinherited

◆ HLRSecondPass()

void G4OpenGLViewer::HLRSecondPass ( )

protectedinherited

◆ HLRThirdPass()

void G4OpenGLViewer::HLRThirdPass ( )

protectedinherited

◆ Initialise()

void G4OpenGLStoredQtViewer::Initialise ( )

virtual

Reimplemented from G4VViewer.

Definition at line 72 of file G4OpenGLStoredQtViewer.cc.

                                        {
  makeCurrent();
 
  fQGLWidgetInitialiseCompleted = false;
  CreateMainWindow (this,QString(GetName()));
 
  glDrawBuffer (GL_BACK);
 
   // set the good tab active
  if (QGLWidget::parentWidget()) {
    QTabWidget *parentTab = dynamic_cast<QTabWidget*> (QGLWidget::parentWidget()->parent()) ;
    if (parentTab) {
      parentTab->setCurrentIndex(parentTab->count()-1);
    }
  }
  
  fQGLWidgetInitialiseCompleted = true;
}

References G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::fQGLWidgetInitialiseCompleted, and G4VViewer::GetName().

◆ initializeGL()

void G4OpenGLStoredQtViewer::initializeGL ( )

Definition at line 91 of file G4OpenGLStoredQtViewer.cc.

                                           {
 
  InitializeGLView ();
 
  if (fSceneHandler.GetScene() == 0) {
    fHasToRepaint =false;
  } else {
    fHasToRepaint =true;
  }
  
   // Set the component visible
  //   setVisible(true) ;
 
  // Set jpg as default export format for Qt viewer
  setExportImageFormat("jpg");
}

References G4OpenGLQtViewer::fHasToRepaint, G4VViewer::fSceneHandler, G4VSceneHandler::GetScene(), G4OpenGLViewer::InitializeGLView(), and G4OpenGLViewer::setExportImageFormat().

◆ InitializeGLView()

void G4OpenGLViewer::InitializeGLView ( )

protectedinherited

Definition at line 127 of file G4OpenGLViewer.cc.

{
#ifdef G4OPENGL_VERSION_2
  if (fVboDrawer) {
    
    // First, load a simple shader
    fShaderProgram = glCreateProgram();
    Shader vertexShader = glCreateShader(GL_VERTEX_SHADER);
    const char * vSrc = fVboDrawer->getVertexShaderSrc();
    glShaderSource(vertexShader, 1, &vSrc, NULL);
    glCompileShader(vertexShader);
    glAttachShader(fShaderProgram, vertexShader);
    
    Shader fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    const char * fSrc = fVboDrawer->getFragmentShaderSrc();
    glShaderSource(fragmentShader, 1, &fSrc, NULL);
    glCompileShader(fragmentShader);
    
    glAttachShader(fShaderProgram, fragmentShader);
    glLinkProgram(fShaderProgram);
    glUseProgram(fShaderProgram);
    
    //   UniformLocation uColor = getUniformLocation(fShaderProgram, "uColor");
    //   uniform4fv(uColor, [0.0, 0.3, 0.0, 1.0]);
    
    // Extract the references to the attributes from the shader.
    
    fVertexPositionAttribute =
    glGetAttribLocation(fShaderProgram, "aVertexPosition");
    
    
    glEnableVertexAttribArray(fVertexPositionAttribute);
    
    // Extract the references the uniforms from the shader
    fpMatrixUniform  = glGetUniformLocation(fShaderProgram, "uPMatrix");
    fcMatrixUniform  = glGetUniformLocation(fShaderProgram, "uCMatrix");
    fmvMatrixUniform = glGetUniformLocation(fShaderProgram, "uMVMatrix");
    fnMatrixUniform  = glGetUniformLocation(fShaderProgram, "uNMatrix");
    ftMatrixUniform  = glGetUniformLocation(fShaderProgram, "uTMatrix");
    
    /*    glUniformMatrix4fv(fcMatrixUniform, 1, 0, identity);
     glUniformMatrix4fv(fpMatrixUniform, 1, 0, identity);
     glUniformMatrix4fv(ftMatrixUniform, 1, 0, identity);
     glUniformMatrix4fv(fmvMatrixUniform, 1, 0, identity);
     */
    // We have to set that in order to avoid calls on opengl commands before all is ready
    fGlViewInitialized = true;
  }
#endif
  
  if (fWinSize_x == 0) {
    fWinSize_x = fVP.GetWindowSizeHintX();
  }
  if (fWinSize_y == 0) {
    fWinSize_y = fVP.GetWindowSizeHintY();
  }
 
  glClearColor (0.0, 0.0, 0.0, 0.0);
  glClearDepth (1.0);
#ifndef G4OPENGL_VERSION_2
  glDisable (GL_LINE_SMOOTH);
  glDisable (GL_POLYGON_SMOOTH);
#endif
 
// clear the buffers and window?
  ClearView ();
  FinishView ();
  
  glDepthFunc (GL_LEQUAL);
  glDepthMask (GL_TRUE);
  
  glEnable (GL_BLEND);
  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  
}

References G4OpenGLViewer::ClearView(), G4OpenGLViewer::fGlViewInitialized, G4VViewer::FinishView(), G4VViewer::fVP, G4OpenGLViewer::fWinSize_x, G4OpenGLViewer::fWinSize_y, G4ViewParameters::GetWindowSizeHintX(), and G4ViewParameters::GetWindowSizeHintY().

Referenced by G4OpenGLImmediateXmViewer::Initialise(), G4OpenGLImmediateXViewer::Initialise(), G4OpenGLStoredXmViewer::Initialise(), G4OpenGLStoredXViewer::Initialise(), G4OpenGLImmediateQtViewer::initializeGL(), and initializeGL().

◆ initMovieParameters()

void G4OpenGLQtViewer::initMovieParameters ( )

privateinherited

Init the movie parameters. Temp dir and encoder path

Definition at line 1898 of file G4OpenGLQtViewer.cc.

                                           {
  //init encoder
 
  //look for encoderPath
  fProcess = new QProcess();
 
  QObject ::connect(fProcess,SIGNAL(finished ( int)),
                    this,SLOT(processLookForFinished()));
  fProcess->setProcessChannelMode(QProcess::MergedChannels);
#if QT_VERSION < 0x050F00
  // Before Qt5.15
  fProcess->start ("which ppmtompeg");
#else
  // Qt5.15 and beyond
  fProcess->start ("which ppmtompeg", QStringList());
#endif
}

References g4zmq::connect(), G4OpenGLQtViewer::fProcess, and G4OpenGLQtViewer::processLookForFinished().

Referenced by G4OpenGLQtViewer::G4OpenGLQtViewer().

◆ isBadEncoder()

bool G4OpenGLQtViewer::isBadEncoder ( )

inherited

Definition at line 2001 of file G4OpenGLQtViewer.cc.

                                   {
  if (fRecordingStep == BAD_ENCODER) {
    return true;
  }
  return false;
}

References G4OpenGLQtViewer::BAD_ENCODER, and G4OpenGLQtViewer::fRecordingStep.

Referenced by G4OpenGLQtMovieDialog::setRecordingStatus().

◆ isBadOutput()

bool G4OpenGLQtViewer::isBadOutput ( )

inherited

Definition at line 2013 of file G4OpenGLQtViewer.cc.

                                  {
  if (fRecordingStep == BAD_OUTPUT) {
    return true;
  }
  return false;
}

References G4OpenGLQtViewer::BAD_OUTPUT, and G4OpenGLQtViewer::fRecordingStep.

Referenced by G4OpenGLQtMovieDialog::setRecordingStatus().

◆ isBadTmp()

bool G4OpenGLQtViewer::isBadTmp ( )

inherited

Definition at line 2007 of file G4OpenGLQtViewer.cc.

                               {
  if (fRecordingStep == BAD_TMP) {
    return true;
  }
  return false;
}

References G4OpenGLQtViewer::BAD_TMP, and G4OpenGLQtViewer::fRecordingStep.

Referenced by G4OpenGLQtMovieDialog::setRecordingStatus().

◆ isCurrentWidget()

bool G4OpenGLQtViewer::isCurrentWidget ( )

protectedinherited

Definition at line 4736 of file G4OpenGLQtViewer.cc.

                                      {
  G4Qt* interactorManager = G4Qt::getInstance ();
  if (!interactorManager->IsExternalApp()) {
 
    // Prevent from repainting a hidden tab (the current tab name has to be the one of th GL viewer)
    if ( GetName() != fUiQt->GetViewerTabWidget()->tabText(fUiQt->GetViewerTabWidget()->currentIndex()).toStdString().c_str()) {
      return false;
    }
  }
  return true;
}

References G4OpenGLQtViewer::fUiQt, G4Qt::getInstance(), G4VViewer::GetName(), G4UIQt::GetViewerTabWidget(), and G4Qt::IsExternalApp().

Referenced by G4OpenGLQtViewer::updatePickInfosWidget(), G4OpenGLImmediateQtViewer::updateQWidget(), updateQWidget(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ isEncoding()

bool G4OpenGLQtViewer::isEncoding ( )

inherited

Definition at line 1966 of file G4OpenGLQtViewer.cc.

                                 {
  if (fRecordingStep == ENCODING) {
    return true;
  }
  return false;
}

References G4OpenGLQtViewer::fRecordingStep.

◆ isFailed()

bool G4OpenGLQtViewer::isFailed ( )

inherited

Definition at line 1987 of file G4OpenGLQtViewer.cc.

                               {
  if (fRecordingStep == FAILED) {
    return true;
  }
  return false;
}

References G4OpenGLQtViewer::FAILED, and G4OpenGLQtViewer::fRecordingStep.

Referenced by G4OpenGLQtMovieDialog::setRecordingStatus().

◆ isFramebufferReady()

G4bool G4OpenGLViewer::isFramebufferReady ( )

protectedinherited

Definition at line 730 of file G4OpenGLViewer.cc.

                                          {
  bool check = false;
#ifdef G4VIS_BUILD_OPENGLQT_DRIVER
  check = true;
#endif
#ifdef G4VIS_BUILD_OPENGLX_DRIVER
  check = false;
#endif
#ifdef G4VIS_BUILD_OPENGLXM_DRIVER
  check = false;
#endif
#ifdef G4VIS_BUILD_OPENGLWIN32_DRIVER
  check = false;
#endif
 
#if GL_ARB_framebuffer_object
  if (check) {
//    if ( glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_UNDEFINED) {
//      return false;
//    }
  }
#endif
    return true;
}

Referenced by G4OpenGLViewer::ClearView(), G4OpenGLViewer::ClearViewWithoutFlush(), G4OpenGLImmediateQtViewer::paintEvent(), and paintEvent().

◆ isGl2psWriting()

bool G4OpenGLViewer::isGl2psWriting ( )

protectedinherited

Return if gl2ps is currently writing

Definition at line 720 of file G4OpenGLViewer.cc.

                                    {
 
  if (!fGL2PSAction) return false;
  if (fGL2PSAction->fileWritingEnabled()) {
    return true;
  }
  return false;
}

References G4OpenGLViewer::fGL2PSAction, and G4OpenGL2PSAction::fileWritingEnabled().

Referenced by G4OpenGLViewer::ChangeLineWidth(), G4OpenGLViewer::ChangePointSize(), G4OpenGLQtViewer::DrawText(), G4OpenGLViewer::DrawText(), and G4OpenGLXViewer::DrawText().

◆ isPaused()

bool G4OpenGLQtViewer::isPaused ( )

inherited

Definition at line 1959 of file G4OpenGLQtViewer.cc.

                               {
  if (fRecordingStep == PAUSE) {
    return true;
  }
  return false;
}

References G4OpenGLQtViewer::fRecordingStep, and G4OpenGLQtViewer::PAUSE.

Referenced by G4OpenGLQtMovieDialog::save(), and G4OpenGLQtMovieDialog::setRecordingStatus().

◆ isPVVolume()

bool G4OpenGLQtViewer::isPVVolume ( QTreeWidgetItem * item )

privateinherited

Definition at line 3778 of file G4OpenGLQtViewer.cc.

                                                       {
  QTreeWidgetItem* sParent = item;
  while (sParent->parent() != NULL) {
    sParent = sParent->parent();
  }
  if (sParent->text(0) != fTouchableVolumes) {
    return false;
  }
  // item is the "Touchable" node
  if (item->text(0) == fTouchableVolumes) {
    return false;
  }
  return true;
}

References G4OpenGLQtViewer::fTouchableVolumes.

Referenced by G4OpenGLQtViewer::changeDepthOnSceneTreeItem().

◆ isReadyToEncode()

bool G4OpenGLQtViewer::isReadyToEncode ( )

inherited

Definition at line 2039 of file G4OpenGLQtViewer.cc.

                                      {
  if (fRecordingStep == READY_TO_ENCODE) {
    return true;
  }
  return false;
}

References G4OpenGLQtViewer::fRecordingStep, and G4OpenGLQtViewer::READY_TO_ENCODE.

Referenced by G4OpenGLQtMovieDialog::checkEncoderSwParameters().

◆ isRecording()

bool G4OpenGLQtViewer::isRecording ( )

inherited

Definition at line 1952 of file G4OpenGLQtViewer.cc.

                                  {
  if ((fRecordingStep == START) || (fRecordingStep == CONTINUE)) {
    return true;
  }
  return false;
}

References G4OpenGLQtViewer::CONTINUE, G4OpenGLQtViewer::fRecordingStep, and G4OpenGLQtViewer::START.

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), ComputeView(), G4OpenGLQtMovieDialog::save(), and G4OpenGLQtMovieDialog::setRecordingStatus().

◆ isSameSceneTreeElement()

bool G4OpenGLQtViewer::isSameSceneTreeElement	(	QTreeWidgetItem *	parentOldItem,
		QTreeWidgetItem *	parentNewItem
	)

privateinherited

Definition at line 3278 of file G4OpenGLQtViewer.cc.

  {
 
  int newPO = -1;
  int oldPO = -1;
 
  int newCpNumber = -1;
  int oldCpNumber = -1;
 
  bool firstWhile = true;
 
  while ((parentOldItem != NULL) && (parentNewItem != NULL)) {
 
    // check transform, optimize getting data(..,..) that consume lot of time
    if (!firstWhile) {
      oldPO = parentOldItem->data(0,Qt::UserRole).toInt();
      newPO = parentNewItem->data(0,Qt::UserRole).toInt();
    }
    firstWhile = false;
 
    if ((oldPO >= 0) &&
        (newPO >= 0)) {
      const PVPath& oldFullPath = fOldTreeItemModels[oldPO];
      const PVPath& newFullPath = fTreeItemModels[newPO];
      if ((oldFullPath.size() > 0) &&
          (newFullPath.size() > 0)) {
        if (oldFullPath.size() != newFullPath.size()) {
          return false;
        }
        if (oldFullPath.at(oldFullPath.size()-1).GetTransform () == newFullPath.at(newFullPath.size()-1).GetTransform ()) {
          newCpNumber = newFullPath.at(newFullPath.size()-1).GetCopyNo();
          oldCpNumber = oldFullPath.at(oldFullPath.size()-1).GetCopyNo();
          // ok
        } else {
          return false;
        }
      }
    }
 
    // Check copy Number
    if (oldCpNumber == -1) {
      oldCpNumber = parentOldItem->data(1,Qt::UserRole).toInt();
    }
    if (newCpNumber == -1) {
      newCpNumber = parentNewItem->data(1,Qt::UserRole).toInt();
    }
    if ((oldCpNumber != newCpNumber) ||
        // Check name
        (parentOldItem->text(0) != parentNewItem->text(0)) ) {
      // try to optimize
      return false;
    } else if ((parentOldItem->text(0) != parentNewItem->text(0)) || // Logical Name
               (parentOldItem->text(3) != parentNewItem->text(3))) {   // Check logical name
      return false;
    } else {
      parentOldItem = parentOldItem->parent();
      parentNewItem = parentNewItem->parent();
    }
  } // end while
 
  return true;
}

References G4OpenGLQtViewer::fOldTreeItemModels, and G4OpenGLQtViewer::fTreeItemModels.

Referenced by G4OpenGLQtViewer::changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement().

◆ isStopped()

bool G4OpenGLQtViewer::isStopped ( )

inherited

Definition at line 1980 of file G4OpenGLQtViewer.cc.

                                {
  if (fRecordingStep == STOP) {
    return true;
  }
  return false;
}

References G4OpenGLQtViewer::fRecordingStep, and G4OpenGLQtViewer::STOP.

Referenced by G4OpenGLQtMovieDialog::save(), and G4OpenGLQtMovieDialog::setRecordingStatus().

◆ isSuccess()

bool G4OpenGLQtViewer::isSuccess ( )

inherited

Definition at line 1994 of file G4OpenGLQtViewer.cc.

                                {
  if (fRecordingStep == SUCCESS) {
    return true;
  }
  return false;
}

References G4OpenGLQtViewer::fRecordingStep, and G4OpenGLQtViewer::SUCCESS.

Referenced by G4OpenGLQtMovieDialog::setRecordingStatus().

◆ isTouchableVisible()

bool G4OpenGLQtViewer::isTouchableVisible ( int POindex )

inherited

Definition at line 3453 of file G4OpenGLQtViewer.cc.

                                                    {
 
  // If no scene tree (Immediate viewer)
  if (fSceneTreeComponentTreeWidget == NULL) {
    return false;
  }
 
  // should be the next one
  // Prevent to get out the std::map
  if (fLastSceneTreeWidgetAskForIterator != fLastSceneTreeWidgetAskForIteratorEnd) {
    fLastSceneTreeWidgetAskForIterator++;
  }
  QTreeWidgetItem* item = getTreeWidgetItem(POindex);
 
  if (item != NULL) {
    if ( item->checkState(0) == Qt::Checked) {
      return true;
    }
  }
  return false;
}

References G4OpenGLQtViewer::fLastSceneTreeWidgetAskForIterator, G4OpenGLQtViewer::fLastSceneTreeWidgetAskForIteratorEnd, G4OpenGLQtViewer::fSceneTreeComponentTreeWidget, and G4OpenGLQtViewer::getTreeWidgetItem().

Referenced by POSelected().

◆ isWaiting()

bool G4OpenGLQtViewer::isWaiting ( )

inherited

Definition at line 1973 of file G4OpenGLQtViewer.cc.

                                {
  if (fRecordingStep == WAIT) {
    return true;
  }
  return false;
}

References G4OpenGLQtViewer::fRecordingStep, and G4OpenGLQtViewer::WAIT.

Referenced by G4OpenGLQtMovieDialog::setRecordingStatus().

◆ KernelVisitDecision()

void G4OpenGLStoredViewer::KernelVisitDecision ( )

protectedinherited

Definition at line 56 of file G4OpenGLStoredViewer.cc.

                                                {
  
  // If there's a significant difference with the last view parameters
  // of either the scene handler or this viewer, trigger a rebuild.
  
  if (!fG4OpenGLStoredSceneHandler.fTopPODL ||
      CompareForKernelVisit(fLastVP)) {
    NeedKernelVisit ();
  }
}

References G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::fG4OpenGLStoredSceneHandler, G4OpenGLStoredViewer::fLastVP, G4OpenGLStoredSceneHandler::fTopPODL, and G4VViewer::NeedKernelVisit().

Referenced by ComputeView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), and G4OpenGLStoredXViewer::DrawView().

◆ keyPressEvent()

void G4OpenGLStoredQtViewer::keyPressEvent ( QKeyEvent * event )

protected

Definition at line 363 of file G4OpenGLStoredQtViewer.cc.

{
  G4keyPressEvent(event);
}

References G4OpenGLQtViewer::G4keyPressEvent().

◆ keyReleaseEvent()

void G4OpenGLStoredQtViewer::keyReleaseEvent ( QKeyEvent * event )

protected

Definition at line 368 of file G4OpenGLStoredQtViewer.cc.

{
  G4keyReleaseEvent(event);
}

References G4OpenGLQtViewer::G4keyReleaseEvent().

◆ mouseDoubleClickEvent()

void G4OpenGLStoredQtViewer::mouseDoubleClickEvent ( QMouseEvent * event )

protected

This function was build in order to make a zoom on double clic event. It was think to build a rubberband on the zoom area, but never work fine

Definition at line 389 of file G4OpenGLStoredQtViewer.cc.

{
  G4MouseDoubleClickEvent();
}

References G4OpenGLQtViewer::G4MouseDoubleClickEvent().

◆ mouseMoveEvent()

void G4OpenGLStoredQtViewer::mouseMoveEvent ( QMouseEvent * event )

protected

Definition at line 399 of file G4OpenGLStoredQtViewer.cc.

{
  G4MouseMoveEvent(event);
}

References G4OpenGLQtViewer::G4MouseMoveEvent().

◆ mousePressEvent()

void G4OpenGLStoredQtViewer::mousePressEvent ( QMouseEvent * event )

protected

Definition at line 358 of file G4OpenGLStoredQtViewer.cc.

{
  G4MousePressEvent(event);
}

References G4OpenGLQtViewer::G4MousePressEvent().

◆ mouseReleaseEvent()

void G4OpenGLStoredQtViewer::mouseReleaseEvent ( QMouseEvent * event )

protected

Definition at line 394 of file G4OpenGLStoredQtViewer.cc.

{
  G4MouseReleaseEvent(event);
}

References G4OpenGLQtViewer::G4MouseReleaseEvent().

◆ moveScene()

void G4OpenGLQtViewer::moveScene	(	float	dx,
		float	dy,
		float	dz,
		bool	mouseMove
	)

protectedinherited

Move the scene of dx, dy, dz values.

Parameters

dx	delta mouse x position
dy	delta mouse y position
mouseMove	: true if event comes from a mouse move, false if event comes from key action

Definition at line 1509 of file G4OpenGLQtViewer.cc.

{
  if (fHoldMoveEvent)
    return;
  fHoldMoveEvent = true;
 
  G4double coefTrans = 0;
  GLdouble coefDepth = 0;
  if(mouseMove) {
    coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinWidth());
    if (getWinHeight() <getWinWidth()) {
      coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinHeight());
    }
  } else {
    coefTrans = getSceneNearWidth()*fPan_sens;
    coefDepth = getSceneDepth()*fDeltaDepth;
  }
  fVP.IncrementPan(-dx*coefTrans,dy*coefTrans,dz*coefDepth);
 
  updateQWidget();
  if (fAutoMove)
    ((QApplication*)G4Qt::getInstance ())->processEvents();
 
  fHoldMoveEvent = false;
}

References G4OpenGLQtViewer::fAutoMove, G4OpenGLQtViewer::fDeltaDepth, G4OpenGLQtViewer::fHoldMoveEvent, G4OpenGLViewer::fPan_sens, G4VViewer::fVP, G4Qt::getInstance(), G4OpenGLViewer::getSceneDepth(), G4OpenGLViewer::getSceneNearWidth(), G4OpenGLViewer::getWinHeight(), G4OpenGLViewer::getWinWidth(), G4ViewParameters::IncrementPan(), and G4OpenGLQtViewer::updateQWidget().

Referenced by G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), and G4OpenGLQtViewer::G4MouseReleaseEvent().

◆ NeedKernelVisit()

void G4VViewer::NeedKernelVisit ( )

inherited

Definition at line 78 of file G4VViewer.cc.

                                 {
 
  fNeedKernelVisit = true;
 
  // At one time I thought we'd better notify all viewers.  But I guess
  // each viewer can take care of itself, so the following code is
  // redundant (but keep it commented out for now).   (John Allison)
  // Notify all viewers that a kernel visit is required.
  // const G4ViewerList& viewerList = fSceneHandler.GetViewerList ();
  // G4ViewerListConstIterator i;
  // for (i = viewerList.begin(); i != viewerList.end(); i++) {
  //   (*i) -> SetNeedKernelVisit ();
  // }
  // ??...but, there's a problem in OpenGL Stored which seems to
  // require *all* viewers to revisit the kernel, so...
  //  const G4ViewerList& viewerList = fSceneHandler.GetViewerList ();
  //  G4ViewerListConstIterator i;
  //  for (i = viewerList.begin(); i != viewerList.end(); i++) {
  //    (*i) -> SetNeedKernelVisit (true);
  //  }
  // Feb 2005 - commented out.  Let's fix OpenGL if necessary.
}

References G4VViewer::fNeedKernelVisit.

◆ paintEvent()

void G4OpenGLStoredQtViewer::paintEvent ( QPaintEvent * event )

protected

Definition at line 343 of file G4OpenGLStoredQtViewer.cc.

                                                     {
  if (! fQGLWidgetInitialiseCompleted) {
    return;
  }
  // Force a repaint next time if the FRAMEBUFFER is not READY
  fHasToRepaint = isFramebufferReady();
  if ( fHasToRepaint) {
    // Will really update the widget by calling CGLFlushDrawable
    // The widget's rendering context will become the current context and initializeGL()
    // will be called if it hasn't already been called.
    // Copies the back buffer of a double-buffered context to the front buffer.
    updateGL();
  }
}

References G4OpenGLQtViewer::fHasToRepaint, G4OpenGLQtViewer::fQGLWidgetInitialiseCompleted, and G4OpenGLViewer::isFramebufferReady().

◆ paintGL()

void G4OpenGLStoredQtViewer::paintGL ( )

Definition at line 295 of file G4OpenGLStoredQtViewer.cc.

{
  updateToolbarAndMouseContextMenu();
 
  if (fPaintEventLock) {
//    return ;
  }
  fPaintEventLock = true;
  if ((getWinWidth() == 0) && (getWinHeight() == 0)) {
    return;
  }
 
  if (!fQGLWidgetInitialiseCompleted) {
    fPaintEventLock = false;
    return;
  }
  // DO NOT RESIZE IF SIZE HAS NOT CHANGE :
  //    WHEN CLICK ON THE FRAME FOR EXAMPLE
  //    EXECEPT WHEN MOUSE MOVE EVENT
  if ( !fHasToRepaint) {
    // L. Garnier : Trap to get the size with mac OSX 10.6 and Qt 4.6(devel)
    // Tested on Qt4.5 on mac, 4.4 on windows, 4.5 on unbuntu
    int sw = 0;
    int sh = 0;
    if (!isMaximized() && !isFullScreen()) {
      sw = normalGeometry().width();
      sh = normalGeometry().height();
    } else {
      sw = frameGeometry().width();
      sh = frameGeometry().height();
    }
    if ((getWinWidth() == (unsigned int)sw) &&(getWinHeight() == (unsigned int)sh)) {
      return;
    }
  }
  // Ensure that we really draw the BACK buffer
  glDrawBuffer (GL_BACK);
 
  SetView();
  
  ClearView (); //ok, put the background correct
  ComputeView();
 
  fHasToRepaint = false;
 
  fPaintEventLock = false;
}

References G4OpenGLViewer::ClearView(), ComputeView(), G4OpenGLQtViewer::fHasToRepaint, G4OpenGLQtViewer::fPaintEventLock, G4OpenGLQtViewer::fQGLWidgetInitialiseCompleted, G4OpenGLViewer::getWinHeight(), G4OpenGLViewer::getWinWidth(), G4OpenGLViewer::SetView(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ parseAndCheckVisibility()

bool G4OpenGLQtViewer::parseAndCheckVisibility	(	QTreeWidgetItem *	treeNode,
		int	POindex
	)

privateinherited

Definition at line 3476 of file G4OpenGLQtViewer.cc.

                                                                                    {
  bool isFound = false;
  for (int i = 0; i < treeNode->childCount() ; ++i) {
 
    if (treeNode->child(i)->data(0,Qt::UserRole).toInt() == POindex) {
      if (treeNode->child(i)->checkState(0) == Qt::Checked) {
        return true;
      }
    }
    isFound = parseAndCheckVisibility(treeNode->child(i),POindex);
    if (isFound) {
      return true;
    }
  } // end for
  return false;
}

References G4OpenGLQtViewer::parseAndCheckVisibility().

Referenced by G4OpenGLQtViewer::parseAndCheckVisibility().

◆ parseAndInsertInSceneTree()

bool G4OpenGLQtViewer::parseAndInsertInSceneTree	(	QTreeWidgetItem *	parentItem,
		G4PhysicalVolumeModel *	pPVModel,
		unsigned int	fullPathIndex,
		const QString &	parentRoot,
		unsigned int	currentIndex,
		int	currentPVPOIndex
	)

privateinherited

Definition at line 3015 of file G4OpenGLQtViewer.cc.

  {
 
  if (parentItem == NULL) {
    return false;
  }
 
  const PVPath& fullPath = pPVModel->GetFullPVPath();
 
  std::ostringstream oss;
  oss << fullPath.at(fullPathIndex).GetCopyNo();
  std::string currentPVName = G4String(fullPath.at(fullPathIndex).GetPhysicalVolume()->GetName()+" ["+oss.str()+"]").data();
 
  int currentPVCopyNb = fullPath.at(fullPathIndex).GetCopyNo();
 
  const G4Colour& color = fSceneHandler.GetColour();
 
  // look in all children in order to get if their is already a
  // child corresponding:
  // - if so, go into this child
  // - if not : create it as invisible
 
  // Realy quick check if the POindex is already there
  QTreeWidgetItem* subItem = NULL;
  QList<QTreeWidgetItem *> parentItemList;
 
 
  // first of all, very quick check if it was not the same as last one
 
  // Check only if it is a transparent object
  // If it is the last item and it is not transparent -> nothing to look for,
  // simply add it.
  if ((currentIndexInTreeSceneHandler == (fullPath.size()-1)) && ((color.GetAlpha() == 1.))) {
  } else {
    QString lookForString = QString(currentPVName.c_str());
    for (int i = 0;i < parentItem->childCount(); i++ ) {
      if (parentItem->child(i)->text(0) == lookForString) {
        parentItemList.push_back(parentItem->child(i));
      }
    }
  }
 
  for (int i = 0; i < parentItemList.size(); ++i) {
    const std::string& parentItemName = parentItemList.at(i)->text(0).toStdString();
    int parentItemCopyNb = parentItemList.at(i)->data(1,Qt::UserRole).toInt();
    int parentItemPOIndex = parentItemList.at(i)->data(0,Qt::UserRole).toInt();
 
    // if already inside
    // -> return true
    // special case, do not have to deal with hierarchy except for PhysicalVolume
 
 
    /* Physical Volume AND copy number equal AND  name equal */
    if (((parentRoot == fTouchableVolumes) &&  (currentPVCopyNb == parentItemCopyNb)
         && (currentPVName == parentItemName))        ||
        /* NOT a Physical Volume AND  copy number equal */
        ((parentRoot != fTouchableVolumes) && (currentPVCopyNb == parentItemCopyNb)
         /*AND  name equal AND  PO index equal*/
         && (currentPVName == parentItemName) && (currentPVPOIndex == parentItemPOIndex) )) {
 
      // then check for the Transform3D
      bool sameTransform = true;
      if (parentItemPOIndex >= 0) {
        const PVPath& fullPathTmp = fTreeItemModels[parentItemPOIndex];
        if (fullPathTmp.size() > 0) {
          if (fullPathTmp.at(fullPathTmp.size()-1).GetTransform () == pPVModel->GetTransformation ()) {
            sameTransform = true;
          } else {
            sameTransform = false;
          }
        }
      }
 
      // Same transformation, then try to change the PO index
      if (sameTransform == true) {
        // already exist in the tree, is it a transparent object ?
        // If so, then have to change the PO index ONLY if it is the last
        // and then change the state ONLY if POIndex has change
        // If not, then go deaper
 
        // last element
        if (currentIndexInTreeSceneHandler == (fullPath.size()-1)) {
 
          parentItemList.at(i)->setText(2,QString::number(currentPVPOIndex));
          parentItemList.at(i)->setData(0, Qt::UserRole,currentPVPOIndex);
 
          fTreeItemModels.insert(std::pair <int, PVPath >(currentPVPOIndex,fullPath) );
 
          // Then remove tooltip and special font
          QFont f = QFont();
          parentItemList.at(i)->setFont (0,f);
 
          // set foreground
          parentItemList.at(i)->setForeground (0,QBrush());
 
          // Set a tootip
          parentItemList.at(i)->setToolTip (0,"");
 
          changeQColorForTreeWidgetItem(parentItemList.at(i),QColor((int)(color.GetRed()*255),
                                                                    (int)(color.GetGreen()*255),
                                                                    (int)(color.GetBlue()*255),
                                                                    (int)(color.GetAlpha()*255)));
 
          // set check only if there is something to display
          if (color.GetAlpha() > 0) {
            parentItemList.at(i)->setCheckState(0,Qt::Checked);
            updatePositivePoIndexSceneTreeWidgetQuickMap(currentPVPOIndex,parentItemList.at(i));
          }
          return false;
        } else {
          subItem = parentItemList.at(i);
        }
 
        // Exists but not the end of path, then forget get it
      } else if (currentIndexInTreeSceneHandler < (fullPath.size()-1))  {
        subItem = parentItemList.at(i);
      }
    }
 
  } // end for
 
  // if it the last, then add it and set it checked
  if (currentIndexInTreeSceneHandler == (fullPath.size()-1)) {
    /* subItem =*/ createTreeWidgetItem(fullPath,
                                   QString(currentPVName.c_str()),
                                   currentPVCopyNb,
                                   currentPVPOIndex,
                                   QString(fullPath.at(fullPathIndex).GetPhysicalVolume()->GetLogicalVolume()->GetName().data()),
                                   Qt::Checked,
                                   parentItem,
                                   color);
 
    if (currentPVPOIndex > fMaxPOindexInserted) {
      fMaxPOindexInserted = currentPVPOIndex;
    }
 
  } else {
 
    // if no child found, then this child is create and marked as invisible, then go inside
    if (subItem == NULL) {
 
      if (currentIndexInTreeSceneHandler < (fullPath.size()-1))  {
        subItem = createTreeWidgetItem(fullPath,
                                       QString(currentPVName.c_str()),
                                       currentPVCopyNb,
                                       -1,
                                       QString(fullPath.at(fullPathIndex).GetPhysicalVolume()->GetLogicalVolume()->GetName().data()),
                                       Qt::Unchecked,
                                       parentItem,
                                       color);
      }
    }
 
    return parseAndInsertInSceneTree(subItem,pPVModel,fullPathIndex+1,parentRoot,currentIndexInTreeSceneHandler+1,currentPVPOIndex);
  }
  return true;
}

References G4OpenGLQtViewer::changeQColorForTreeWidgetItem(), G4OpenGLQtViewer::createTreeWidgetItem(), G4OpenGLQtViewer::fMaxPOindexInserted, G4VViewer::fSceneHandler, G4OpenGLQtViewer::fTouchableVolumes, G4OpenGLQtViewer::fTreeItemModels, G4Colour::GetAlpha(), G4Colour::GetBlue(), G4VSceneHandler::GetColour(), G4PhysicalVolumeModel::GetFullPVPath(), G4Colour::GetGreen(), G4Colour::GetRed(), G4PhysicalVolumeModel::GetTransformation(), G4OpenGLQtViewer::parseAndInsertInSceneTree(), and G4OpenGLQtViewer::updatePositivePoIndexSceneTreeWidgetQuickMap().

Referenced by G4OpenGLQtViewer::addPVSceneTreeElement(), and G4OpenGLQtViewer::parseAndInsertInSceneTree().

◆ parseSceneTreeAndSaveState()

std::string G4OpenGLQtViewer::parseSceneTreeAndSaveState ( )

privateinherited

Definition at line 3494 of file G4OpenGLQtViewer.cc.

                                                      {
  std::string commandLine = "";
  for (int b=0;b<fSceneTreeComponentTreeWidget->topLevelItemCount();b++) {
    commandLine += parseSceneTreeElementAndSaveState(fSceneTreeComponentTreeWidget->topLevelItem(b),1)+"\n";
  }
  if (commandLine != "") {
    commandLine = std::string("# Disable auto refresh and quieten vis messages whilst scene and\n") +
    "# trajectories are established:\n" +
    "/vis/viewer/set/autoRefresh false\n" +
    "/vis/verbose errors" +
    commandLine +
    "# Re-establish auto refreshing and verbosity:\n" +
    "/vis/viewer/set/autoRefresh true\n" +
    "/vis/verbose confirmations\n";
  }
  return commandLine;
}

References G4OpenGLQtViewer::fSceneTreeComponentTreeWidget, and G4OpenGLQtViewer::parseSceneTreeElementAndSaveState().

◆ parseSceneTreeElementAndSaveState()

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

privateinherited

Definition at line 3513 of file G4OpenGLQtViewer.cc.

                                                                                                      {
  // parse current item
  std::string str( level, ' ' );
  std::string commandLine = "\n#"+ str + "PV Name: " + item->text(0).toStdString();
 
  if (item->text(3) != "") {
    commandLine += " LV Name: "+item->text(3).toStdString()+"\n";
    // save check state
    commandLine += "/vis/geometry/set/visibility " + item->text(3).toStdString() + " ! "; // let default value for depth
    if (item->checkState(0) == Qt::Checked) {
      commandLine += "1";
    }
    if (item->checkState(0) == Qt::Unchecked) {
      commandLine += "0";
    }
    commandLine +="\n";
 
    // save color
    const QColor& c = item->data(2,Qt::UserRole).value<QColor>();
    std::stringstream red;
    red << ((double)c.red())/255;
    std::stringstream green;
    green << (double)c.green()/255;
    std::stringstream blue;
    blue << ((double)c.blue())/255;
    std::stringstream alpha;
    alpha << ((double)c.alpha())/255;
 
    commandLine += "/vis/geometry/set/colour " + item->text(3).toStdString() + " ! " + red.str() + " " + green.str() + " " + blue.str() + " " + alpha.str()+"\n";
 
  } else {
    commandLine += "\n";
  }
 
  // parse childs
  for (int b=0;b< item->childCount();b++) {
    commandLine += parseSceneTreeElementAndSaveState(item->child(b),level+1);
  }
 
  return commandLine;
}

References alpha, and G4OpenGLQtViewer::parseSceneTreeElementAndSaveState().

Referenced by G4OpenGLQtViewer::parseSceneTreeAndSaveState(), and G4OpenGLQtViewer::parseSceneTreeElementAndSaveState().

◆ Pick()

G4String G4OpenGLViewer::Pick	(	GLdouble	x,
		GLdouble	y
	)

protectedvirtualinherited

Definition at line 472 of file G4OpenGLViewer.cc.

{
  const std::vector < G4OpenGLViewerPickMap* > & pickMap = GetPickDetails(x,y);
  G4String txt = "";
  if (pickMap.size() == 0) {
//        txt += "No hits recorded.";;
  } else {
    for (unsigned int a=0; a < pickMap.size(); a++) {
      if (pickMap[a]->getAttributes().size() > 0) {
        txt += pickMap[a]->print();
      }
    }
  }
  return txt;
}

References G4OpenGLViewer::GetPickDetails().

Referenced by G4OpenGLXViewer::ShowView().

◆ POSelected()

G4bool G4OpenGLStoredQtViewer::POSelected ( size_t POListIndex )

protectedvirtual

Reimplemented from G4OpenGLStoredViewer.

Definition at line 197 of file G4OpenGLStoredQtViewer.cc.

{
  return isTouchableVisible(POListIndex);
}

References G4OpenGLQtViewer::isTouchableVisible().

◆ printGl2PS()

bool G4OpenGLViewer::printGl2PS ( )

privateinherited

Definition at line 886 of file G4OpenGLViewer.cc.

                                {
 
  int width = getRealExportWidth();
  int height = getRealExportHeight();
  bool res = true;
 
  // no need to redraw at each new primitive for printgl2PS
  G4OpenGLSceneHandler& oglSceneHandler = dynamic_cast<G4OpenGLSceneHandler&>(fSceneHandler);
  G4OpenGLSceneHandler::FlushAction originalFlushAction = oglSceneHandler.GetFlushAction();
  oglSceneHandler.SetFlushAction(G4OpenGLSceneHandler::never);
 
  if (!fGL2PSAction) return false;
 
  fGL2PSAction->setFileName(getRealPrintFilename().c_str());
  // try to resize
  int X = fWinSize_x;
  int Y = fWinSize_y;
 
  fWinSize_x = width;
  fWinSize_y = height;
  // Laurent G. 16/03/10 : Not the good way to do. 
  // We should draw in a new offscreen context instead of
  // resizing and drawing in current window...
  // This should be solve when we will do an offscreen method
  // to render OpenGL
  // See : 
  // http://developer.apple.com/Mac/library/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_offscreen/opengl_offscreen.html
  // http://www.songho.ca/opengl/gl_fbo.html
 
   ResizeGLView();
   bool extendBuffer = true;
   bool endWriteAction = false;
   bool beginWriteAction = true;
   bool filePointerOk = true;
   while ((extendBuffer) && (! endWriteAction) && (filePointerOk)) {
     
     beginWriteAction = fGL2PSAction->enableFileWriting();
     // 3 cases :
     // - true
     // - false && ! fGL2PSAction->fileWritingEnabled() => bad file name
     // - false && fGL2PSAction->fileWritingEnabled() => buffer size problem ?
 
     filePointerOk = fGL2PSAction->fileWritingEnabled();
       
     if (beginWriteAction) {
       
       // Set the viewport
       // By default, we choose the line width (trajectories...)
       fGL2PSAction->setLineWidth(fGl2psDefaultLineWith);
       // By default, we choose the point size (markers...)
       fGL2PSAction->setPointSize(fGl2psDefaultPointSize);
       
       DrawView ();
       endWriteAction = fGL2PSAction->disableFileWriting();
     }
     if (filePointerOk) {
       if ((! endWriteAction) || (! beginWriteAction)) {
         extendBuffer = fGL2PSAction->extendBufferSize();
       }
     }
   }
   fGL2PSAction->resetBufferSizeParameters();
 
   if (!extendBuffer ) {
     G4cerr << "ERROR: gl2ps buffer size is not big enough to print this geometry. Try to extend it. No output produced"<< G4endl;
     res = false;
   }
   if (!beginWriteAction ) {
     G4cerr << "ERROR: saving file "<<getRealPrintFilename().c_str()<<". Check read/write access. No output produced" << G4endl;
     res = false;
   }
   if (!endWriteAction ) {
     G4cerr << "gl2ps error. No output produced" << G4endl;
     res = false;
   }
  fWinSize_x = X;
  fWinSize_y = Y;
 
  oglSceneHandler.SetFlushAction(originalFlushAction);
 
  // Reset for next time (useful is size change)
  //  fPrintSizeX = 0;
  //  fPrintSizeY = 0;
 
  return res;
}

References G4OpenGL2PSAction::disableFileWriting(), G4VViewer::DrawView(), G4OpenGL2PSAction::enableFileWriting(), G4OpenGL2PSAction::extendBufferSize(), G4OpenGLViewer::fGL2PSAction, G4OpenGLViewer::fGl2psDefaultLineWith, G4OpenGLViewer::fGl2psDefaultPointSize, G4OpenGL2PSAction::fileWritingEnabled(), G4VViewer::fSceneHandler, G4OpenGLViewer::fWinSize_x, G4OpenGLViewer::fWinSize_y, G4cerr, G4endl, G4OpenGLSceneHandler::GetFlushAction(), G4OpenGLViewer::getRealExportHeight(), G4OpenGLViewer::getRealExportWidth(), G4OpenGLViewer::getRealPrintFilename(), G4OpenGLSceneHandler::never, G4OpenGL2PSAction::resetBufferSizeParameters(), G4OpenGLViewer::ResizeGLView(), G4OpenGL2PSAction::setFileName(), G4OpenGLSceneHandler::SetFlushAction(), G4OpenGL2PSAction::setLineWidth(), G4OpenGL2PSAction::setPointSize(), and Y().

Referenced by G4OpenGLViewer::printVectoredEPS().

◆ printNonVectoredEPS()

bool G4OpenGLViewer::printNonVectoredEPS ( )

privateinherited

Definition at line 633 of file G4OpenGLViewer.cc.

                                          {
 
  int width = getRealExportWidth();
  int height = getRealExportHeight();
 
  FILE* fp;
  GLubyte* pixels;
  GLubyte* curpix;
  int components, pos, i;
 
  pixels = grabPixels (fPrintColour, width, height);
 
  if (pixels == NULL) {
      G4cerr << "Failed to get pixels from OpenGl viewport" << G4endl;
    return false;
  }
  if (fPrintColour) {
    components = 3;
  } else {
    components = 1;
  }
  std::string name = getRealPrintFilename();
  fp = fopen (name.c_str(), "w");
  if (fp == NULL) {
    G4cerr << "Can't open filename " << name.c_str() << G4endl;
    return false;
  }
  
  fprintf (fp, "%%!PS-Adobe-2.0 EPSF-1.2\n");
  fprintf (fp, "%%%%Title: %s\n", name.c_str());
  fprintf (fp, "%%%%Creator: OpenGL pixmap render output\n");
  fprintf (fp, "%%%%BoundingBox: 0 0 %d %d\n", width, height);
  fprintf (fp, "%%%%EndComments\n");
  fprintf (fp, "gsave\n");
  fprintf (fp, "/bwproc {\n");
  fprintf (fp, "    rgbproc\n");
  fprintf (fp, "    dup length 3 idiv string 0 3 0 \n");
  fprintf (fp, "    5 -1 roll {\n");
  fprintf (fp, "    add 2 1 roll 1 sub dup 0 eq\n");
  fprintf (fp, "    { pop 3 idiv 3 -1 roll dup 4 -1 roll dup\n");
  fprintf (fp, "       3 1 roll 5 -1 roll } put 1 add 3 0 \n");
  fprintf (fp, "    { 2 1 roll } ifelse\n");
  fprintf (fp, "    }forall\n");
  fprintf (fp, "    pop pop pop\n");
  fprintf (fp, "} def\n");
  fprintf (fp, "systemdict /colorimage known not {\n");
  fprintf (fp, "   /colorimage {\n");
  fprintf (fp, "       pop\n");
  fprintf (fp, "       pop\n");
  fprintf (fp, "       /rgbproc exch def\n");
  fprintf (fp, "       { bwproc } image\n");
  fprintf (fp, "   }  def\n");
  fprintf (fp, "} if\n");
  fprintf (fp, "/picstr %d string def\n", width * components);
  fprintf (fp, "%d %d scale\n", width, height);
  fprintf (fp, "%d %d %d\n", width, height, 8);
  fprintf (fp, "[%d 0 0 %d 0 0]\n", width, height);
  fprintf (fp, "{currentfile picstr readhexstring pop}\n");
  fprintf (fp, "false %d\n", components);
  fprintf (fp, "colorimage\n");
  
  curpix = (GLubyte*) pixels;
  pos = 0;
  for (i = width*height*components; i>0; i--) {
    fprintf (fp, "%02hx ", (unsigned short)(*(curpix++)));
    if (++pos >= 32) {
      fprintf (fp, "\n");
      pos = 0; 
    }
  }
  if (pos)
    fprintf (fp, "\n");
 
  fprintf (fp, "grestore\n");
  fprintf (fp, "showpage\n");
  delete [] pixels;
  fclose (fp);
 
  // Reset for next time (useful is size change)
  //  fPrintSizeX = -1;
  //  fPrintSizeY = -1;
 
  return true;
}

References G4OpenGLViewer::fPrintColour, G4cerr, G4endl, G4OpenGLViewer::getRealExportHeight(), G4OpenGLViewer::getRealExportWidth(), G4OpenGLViewer::getRealPrintFilename(), G4OpenGLViewer::grabPixels(), G4InuclParticleNames::name(), and pos.

Referenced by G4OpenGLViewer::exportImage().

◆ printPDF()

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

privateinherited

◆ printVectoredEPS()

bool G4OpenGLViewer::printVectoredEPS ( )

privateinherited

Definition at line 629 of file G4OpenGLViewer.cc.

                                      {
  return printGl2PS();
}

References G4OpenGLViewer::printGl2PS().

Referenced by G4OpenGLViewer::exportImage().

◆ processEncodeFinished

void G4OpenGLQtViewer::processEncodeFinished ( )

privateslotinherited

Definition at line 2414 of file G4OpenGLQtViewer.cc.

{
 
  QString txt = "";
  txt = getProcessErrorMsg();
  if (txt == "") {
    setRecordingStatus(SUCCESS);
  } else {
    setRecordingStatus(FAILED);
  }
  //  setRecordingInfos(txt+removeTempFolder());
}

References G4OpenGLQtViewer::FAILED, G4OpenGLQtViewer::getProcessErrorMsg(), G4OpenGLQtViewer::setRecordingStatus(), and G4OpenGLQtViewer::SUCCESS.

Referenced by G4OpenGLQtViewer::encodeVideo().

◆ processEncodeStdout

void G4OpenGLQtViewer::processEncodeStdout ( )

privateslotinherited

Definition at line 2405 of file G4OpenGLQtViewer.cc.

{
  QString tmp = fProcess->readAllStandardOutput ().data();
  int start = tmp.lastIndexOf("ESTIMATED TIME");
  tmp = tmp.mid(start,tmp.indexOf("\n",start)-start);
  setRecordingInfos(tmp);
}

References G4OpenGLQtViewer::fProcess, and G4OpenGLQtViewer::setRecordingInfos().

Referenced by G4OpenGLQtViewer::encodeVideo().

◆ processLookForFinished

void G4OpenGLQtViewer::processLookForFinished ( )

privateslotinherited

Definition at line 2428 of file G4OpenGLQtViewer.cc.

{
 
  QString txt = getProcessErrorMsg();
  if (txt != "") {
    fEncoderPath = "";
  } else {
    fEncoderPath = QString(fProcess->readAllStandardOutput ().data()).trimmed();
    // if not found, return "not found"
    if (fEncoderPath.contains(" ")) {
      fEncoderPath = "";
    } else if (!fEncoderPath.contains("ppmtompeg")) {
      fEncoderPath = "";
    }
    setEncoderPath(fEncoderPath);
  }
  // init temp folder
  setTempFolderPath(QDir::temp ().absolutePath ());
}

References G4OpenGLQtViewer::fEncoderPath, G4OpenGLQtViewer::fProcess, G4OpenGLQtViewer::getProcessErrorMsg(), G4OpenGLQtViewer::setEncoderPath(), and G4OpenGLQtViewer::setTempFolderPath().

Referenced by G4OpenGLQtViewer::initMovieParameters().

◆ ProcessView()

void G4VViewer::ProcessView ( )

inherited

Definition at line 105 of file G4VViewer.cc.

{
  // If the scene has changed, or if the concrete viewer has decided
  // that it necessary to visit the kernel, perhaps because the view
  // parameters have changed significantly (this should be done in the
  // concrete viewer's DrawView)...
  if (fNeedKernelVisit) {
    // Reset flag.  This must be done before ProcessScene to prevent
    // recursive calls when recomputing transients...
    fNeedKernelVisit = false;
    fSceneHandler.ClearStore ();
    fSceneHandler.ProcessScene ();
  }
}

References G4VSceneHandler::ClearStore(), G4VViewer::fNeedKernelVisit, G4VViewer::fSceneHandler, and G4VSceneHandler::ProcessScene().

◆ RefreshView()

void G4VViewer::RefreshView ( )

inherited

Referenced by G4VisManager::EndOfRun(), G4VVisCommand::InterpolateViews(), and G4VisCommandViewerInterpolate::SetNewValue().

◆ removeTempFolder()

QString G4OpenGLQtViewer::removeTempFolder ( )

privateinherited

Remove the Qt_temp folder in the temp folder

Definition at line 2145 of file G4OpenGLQtViewer.cc.

                                           {
  // remove files in Qt_temp folder
  if (fMovieTempFolderPath == "") {
    return "";
  }
  QDir *d = new QDir(QDir::cleanPath(fMovieTempFolderPath));
  if (!d->exists()) {
    return "";  // already remove
  }
 
  d->setFilter( QDir::Files );
  QStringList subDirList = d->entryList();
  int res = true;
  QString error = "";
  for (QStringList::ConstIterator it = subDirList.begin() ;(it != subDirList.end()) ; it++) {
    const QString currentFile = *it;
    if (!d->remove(currentFile)) {
      res = false;
      QString file = fMovieTempFolderPath+currentFile;
      error +="Removing file failed : "+file;
    } else {
    }
  }
  if (res) {
    if (d->rmdir(fMovieTempFolderPath)) {
      fMovieTempFolderPath = "";
      return "";
    } else {
      return "Dir "+fMovieTempFolderPath+" should be empty, but could not remove it";
    }
 
  }
  return "Could not remove "+fMovieTempFolderPath+" because of the following errors :"+error;
}

References error, geant4_check_module_cycles::file, and G4OpenGLQtViewer::fMovieTempFolderPath.

Referenced by G4OpenGLQtViewer::startPauseVideo(), and G4OpenGLQtViewer::~G4OpenGLQtViewer().

◆ rescaleImage()

void G4OpenGLQtViewer::rescaleImage	(	int	,
		int
	)

privateinherited

This is the benning of a rescale function. It does nothing for the moment

Parameters

aWidth	: new width
aHeight	: new height

Definition at line 1580 of file G4OpenGLQtViewer.cc.

 {
  //  GLfloat* feedback_buffer;
  //  GLint returned;
  //  FILE* file;
 
  //   feedback_buffer = new GLfloat[size];
  //   glFeedbackBuffer (size, GL_3D_COLOR, feedback_buffer);
  //   glRenderMode (GL_FEEDBACK);
 
  //   DrawView();
  //   returned = glRenderMode (GL_RENDER);
 
}

◆ resetRecording()

void G4OpenGLQtViewer::resetRecording ( )

inherited

Definition at line 2046 of file G4OpenGLQtViewer.cc.

                                      {
  setRecordingStatus(WAIT);
}

References G4OpenGLQtViewer::setRecordingStatus(), and G4OpenGLQtViewer::WAIT.

Referenced by G4OpenGLQtMovieDialog::resetRecording(), G4OpenGLQtViewer::savePPMToTemp(), and G4OpenGLQtViewer::stopVideo().

◆ ResetView()

void G4OpenGLQtViewer::ResetView ( )

virtualinherited

Reimplemented from G4VViewer.

Definition at line 2867 of file G4OpenGLQtViewer.cc.

                                  {
  G4OpenGLViewer::ResetView();
  fDeltaDepth = 0.01;
  fDeltaZoom = 0.05;
}

References G4OpenGLQtViewer::fDeltaDepth, G4OpenGLQtViewer::fDeltaZoom, and G4OpenGLViewer::ResetView().

Referenced by G4OpenGLQtViewer::G4keyPressEvent().

◆ resizeGL()

void G4OpenGLStoredQtViewer::resizeGL	(	int	aWidth,
		int	aHeight
	)

Lors du resize de la fenetre, on doit non pas redessiner le detecteur, mais aussi les evenements

Definition at line 278 of file G4OpenGLStoredQtViewer.cc.

{  
  // Set new size, it will be update when next Repaint()->SetView() called
  if ((aWidth > 0) && (aHeight > 0)) {
    ResizeWindow(aWidth,aHeight);
    fHasToRepaint = sizeHasChanged();
  }
}

References G4OpenGLQtViewer::fHasToRepaint, G4OpenGLViewer::ResizeWindow(), and G4OpenGLViewer::sizeHasChanged().

◆ ResizeGLView()

void G4OpenGLViewer::ResizeGLView ( )

protectedinherited

Set the viewport of the scene MAXIMUM SIZE is : GLint dims[2]; glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);

Definition at line 250 of file G4OpenGLViewer.cc.

{
  // Check size
  GLint dims[2];
  dims[0] = 0;
  dims[1] = 0;
 
  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
 
  if ((dims[0] !=0 ) && (dims[1] !=0)) {
 
    if (fWinSize_x > (unsigned)dims[0]) {
      G4cerr << "Try to resize view greater than max X viewport dimension. Desired size "<<fWinSize_x <<" is resize to "<<  dims[0] << G4endl;
      fWinSize_x = dims[0];
    }
    if (fWinSize_y > (unsigned)dims[1]) {
      G4cerr << "Try to resize view greater than max Y viewport dimension. Desired size "<<fWinSize_y <<" is resize to "<<  dims[1] << G4endl;
      fWinSize_y = dims[1];
    }
  }
    
  glViewport(0, 0, fWinSize_x,fWinSize_y);   
 
 
}

References G4OpenGLViewer::fWinSize_x, G4OpenGLViewer::fWinSize_y, G4cerr, and G4endl.

Referenced by G4OpenGLViewer::printGl2PS(), and G4OpenGLViewer::SetView().

◆ ResizeWindow()

void G4OpenGLViewer::ResizeWindow	(	unsigned int	aWidth,
		unsigned int	aHeight
	)

protectedinherited

Definition at line 234 of file G4OpenGLViewer.cc.

                                                                           {
  if ((fWinSize_x != aWidth) || (fWinSize_y != aHeight)) {
    fWinSize_x = aWidth;
    fWinSize_y = aHeight;
    fSizeHasChanged = true;
  } else {
    fSizeHasChanged = false;
  }
}

References G4OpenGLViewer::fSizeHasChanged, G4OpenGLViewer::fWinSize_x, and G4OpenGLViewer::fWinSize_y.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLXmViewer::expose_callback(), G4OpenGLImmediateQtViewer::resizeGL(), and resizeGL().

◆ rotateQtScene()

void G4OpenGLQtViewer::rotateQtScene	(	float	dx,
		float	dy
	)

protectedinherited

Parameters

dx	delta mouse x position
dy	delta mouse y position

Definition at line 1541 of file G4OpenGLQtViewer.cc.

{
  if (fHoldRotateEvent)
    return;
  fHoldRotateEvent = true;
 
  rotateScene(dx,dy);
 
  updateQWidget();
 
  fHoldRotateEvent = false;
}

References G4OpenGLQtViewer::fHoldRotateEvent, G4OpenGLViewer::rotateScene(), and G4OpenGLQtViewer::updateQWidget().

Referenced by G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLQtViewer::G4MouseMoveEvent(), and G4OpenGLQtViewer::G4MouseReleaseEvent().

◆ rotateQtSceneToggle()

void G4OpenGLQtViewer::rotateQtSceneToggle	(	float	dx,
		float	dy
	)

protectedinherited

Parameters

dx	delta mouse x position
dy	delta mouse y position

Definition at line 1559 of file G4OpenGLQtViewer.cc.

{
  if (fHoldRotateEvent)
    return;
  fHoldRotateEvent = true;
 
  rotateSceneToggle(dx,dy);
 
  updateQWidget();
 
  fHoldRotateEvent = false;
}

References G4OpenGLQtViewer::fHoldRotateEvent, G4OpenGLViewer::rotateSceneToggle(), and G4OpenGLQtViewer::updateQWidget().

Referenced by G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLQtViewer::G4MouseMoveEvent(), and G4OpenGLQtViewer::G4MouseReleaseEvent().

◆ rotateScene()

void G4OpenGLViewer::rotateScene	(	G4double	dx,
		G4double	dy
	)

protectedinherited

Definition at line 1128 of file G4OpenGLViewer.cc.

{
  if (fVP.GetRotationStyle() == G4ViewParameters::freeRotation) {
    rotateSceneInViewDirection(dx,dy);
  } else {
    if( dx != 0) {
      rotateSceneThetaPhi(dx,0);
    }
    if( dy != 0) {
      rotateSceneThetaPhi(0,dy);
    }
  }
}

References G4ViewParameters::freeRotation, G4VViewer::fVP, G4ViewParameters::GetRotationStyle(), G4OpenGLViewer::rotateSceneInViewDirection(), and G4OpenGLViewer::rotateSceneThetaPhi().

Referenced by G4OpenGLXmViewer::rotate_in_phi(), G4OpenGLXmViewer::rotate_in_theta(), and G4OpenGLQtViewer::rotateQtScene().

◆ rotateSceneInViewDirection()

void G4OpenGLViewer::rotateSceneInViewDirection	(	G4double	dx,
		G4double	dy
	)

privateinherited

Definition at line 1241 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return;
  }
 
  G4Vector3D vp;
  G4Vector3D up;
  
  G4Vector3D xprime;
  G4Vector3D yprime;
  G4Vector3D zprime;
  
  G4Vector3D new_vp;
  G4Vector3D new_up;
  
  G4Vector3D a1;
  G4Vector3D a2;
  G4Vector3D delta;
  G4Vector3D viewPoint;
 
  dx = dx/100;
  dy = dy/100;
 
  //phi spin stuff here
  
  vp = fVP.GetViewpointDirection ().unit();
  up = fVP.GetUpVector ().unit();
 
  G4Vector3D zPrimeVector = G4Vector3D(up.y()*vp.z()-up.z()*vp.y(),
                             up.z()*vp.x()-up.x()*vp.z(),
                             up.x()*vp.y()-up.y()*vp.x());
 
  viewPoint = vp/fRot_sens + (zPrimeVector*dx - up*dy) ;
  new_up = G4Vector3D(viewPoint.y()*zPrimeVector.z()-viewPoint.z()*zPrimeVector.y(),
                       viewPoint.z()*zPrimeVector.x()-viewPoint.x()*zPrimeVector.z(),
                       viewPoint.x()*zPrimeVector.y()-viewPoint.y()*zPrimeVector.x());
 
  G4Vector3D new_upUnit = new_up.unit();
  
  
 
   fVP.SetUpVector(new_upUnit);
   fVP.SetViewAndLights (viewPoint);
}

References G4OpenGLViewer::fRot_sens, G4VViewer::fSceneHandler, G4VViewer::fVP, G4VSceneHandler::GetScene(), G4ViewParameters::GetUpVector(), G4ViewParameters::GetViewpointDirection(), G4ViewParameters::SetUpVector(), G4ViewParameters::SetViewAndLights(), HepGeom::BasicVector3D< T >::unit(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

Referenced by G4OpenGLViewer::rotateScene(), and G4OpenGLViewer::rotateSceneToggle().

◆ rotateSceneThetaPhi()

void G4OpenGLViewer::rotateSceneThetaPhi	(	G4double	dx,
		G4double	dy
	)

privateinherited

Definition at line 1157 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return;
  }
 
  G4Vector3D vp;
  G4Vector3D up;
  
  G4Vector3D xprime;
  G4Vector3D yprime;
  G4Vector3D zprime;
  
  G4double delta_alpha;
  G4double delta_theta;
  
  G4Vector3D new_vp;
  G4Vector3D new_up;
  
  G4double cosalpha;
  G4double sinalpha;
  
  G4Vector3D a1;
  G4Vector3D a2;
  G4Vector3D delta;
  G4Vector3D viewPoint;
 
    
  //phi spin stuff here
  
  vp = fVP.GetViewpointDirection ().unit ();
  up = fVP.GetUpVector ().unit ();
  
  yprime = (up.cross(vp)).unit();
  zprime = (vp.cross(yprime)).unit();
  
  if (fVP.GetLightsMoveWithCamera()) {
    delta_alpha = dy * fRot_sens;
    delta_theta = -dx * fRot_sens;
  } else {
    delta_alpha = -dy * fRot_sens;
    delta_theta = dx * fRot_sens;
  }    
  
  delta_alpha *= CLHEP::deg;
  delta_theta *= CLHEP::deg;
  
  new_vp = std::cos(delta_alpha) * vp + std::sin(delta_alpha) * zprime;
  
  // to avoid z rotation flipping
  // to allow more than 360∞ rotation
 
  if (fVP.GetLightsMoveWithCamera()) {
    new_up = (new_vp.cross(yprime)).unit();
    if (new_vp.z()*vp.z() <0) {
      new_up.set(new_up.x(),-new_up.y(),new_up.z());
    }
  } else {
    new_up = up;
    if (new_vp.z()*vp.z() <0) {
      new_up.set(new_up.x(),-new_up.y(),new_up.z());
    }
  }
  fVP.SetUpVector(new_up);
  // Rotates by fixed azimuthal angle delta_theta.
  
  cosalpha = new_up.dot (new_vp.unit());
  sinalpha = std::sqrt (1. - std::pow (cosalpha, 2));
  yprime = (new_up.cross (new_vp.unit())).unit ();
  xprime = yprime.cross (new_up);
  // Projection of vp on plane perpendicular to up...
  a1 = sinalpha * xprime;
  // Required new projection...
  a2 = sinalpha * (std::cos (delta_theta) * xprime + std::sin (delta_theta) * yprime);
  // Required Increment vector...
  delta = a2 - a1;
  // So new viewpoint is...
  viewPoint = new_vp.unit() + delta;
  
  fVP.SetViewAndLights (viewPoint);
}

References HepGeom::BasicVector3D< T >::cross(), CLHEP::deg, HepGeom::BasicVector3D< T >::dot(), G4OpenGLViewer::fRot_sens, G4VViewer::fSceneHandler, G4VViewer::fVP, G4ViewParameters::GetLightsMoveWithCamera(), G4VSceneHandler::GetScene(), G4ViewParameters::GetUpVector(), G4ViewParameters::GetViewpointDirection(), HepGeom::BasicVector3D< T >::set(), G4ViewParameters::SetUpVector(), G4ViewParameters::SetViewAndLights(), HepGeom::BasicVector3D< T >::unit(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

Referenced by G4OpenGLViewer::rotateScene(), and G4OpenGLViewer::rotateSceneToggle().

◆ rotateSceneToggle()

void G4OpenGLViewer::rotateSceneToggle	(	G4double	dx,
		G4double	dy
	)

protectedinherited

Definition at line 1143 of file G4OpenGLViewer.cc.

{
  if (fVP.GetRotationStyle() != G4ViewParameters::freeRotation) {
    rotateSceneInViewDirection(dx,dy);
  } else {
    if( dx != 0) {
      rotateSceneThetaPhi(dx,0);
    }
    if( dy != 0) {
      rotateSceneThetaPhi(0,dy);
    }
  }
}

References G4ViewParameters::freeRotation, G4VViewer::fVP, G4ViewParameters::GetRotationStyle(), G4OpenGLViewer::rotateSceneInViewDirection(), and G4OpenGLViewer::rotateSceneThetaPhi().

Referenced by G4OpenGLQtViewer::rotateQtSceneToggle().

◆ savePPMToTemp()

void G4OpenGLQtViewer::savePPMToTemp ( )

protectedinherited

Definition at line 1066 of file G4OpenGLQtViewer.cc.

                                     {
  if (fMovieTempFolderPath == "") {
    return;
  }
  QGLWidget* qGLW = dynamic_cast<QGLWidget*> (fGLWidget) ;
  if (! qGLW) {
    return;
  }
  QString fileName ="Test"+QString::number(fRecordFrameNumber)+".ppm";
  QString filePath =fMovieTempFolderPath+fileName;
 
  QImage image;
  image = qGLW->grabFrameBuffer();
  bool res = false;
 
  res = image.save(filePath,0);
  if (res == false) {
    resetRecording();
    setRecordingInfos("Can't save tmp file "+filePath);
    return;
  }
 
  setRecordingInfos("File "+fileName+" saved");
  fRecordFrameNumber++;
}

References G4OpenGLQtViewer::fGLWidget, G4OpenGLQtViewer::fMovieTempFolderPath, G4OpenGLQtViewer::fRecordFrameNumber, G4OpenGLQtViewer::resetRecording(), and G4OpenGLQtViewer::setRecordingInfos().

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), and ComputeView().

◆ saveVideo()

void G4OpenGLQtViewer::saveVideo ( )

inherited

Stop the video. Check all parameters and enable encoder button if all is ok.

Definition at line 1787 of file G4OpenGLQtViewer.cc.

                                 {
 
  // if encoder parameter is wrong, display parameters dialog and return
  if (!fMovieParametersDialog) {
    showMovieParametersDialog();
  }
 
  fMovieParametersDialog->checkEncoderSwParameters();
  fMovieParametersDialog->checkSaveFileNameParameters();
 
  if (fRecordingStep == STOP) {
    setRecordingStatus(SAVE);
    generateMpegEncoderParameters();
    encodeVideo();
  }
}

References G4OpenGLQtMovieDialog::checkEncoderSwParameters(), G4OpenGLQtMovieDialog::checkSaveFileNameParameters(), G4OpenGLQtViewer::encodeVideo(), G4OpenGLQtViewer::fMovieParametersDialog, G4OpenGLQtViewer::fRecordingStep, G4OpenGLQtViewer::generateMpegEncoderParameters(), G4OpenGLQtViewer::SAVE, G4OpenGLQtViewer::setRecordingStatus(), G4OpenGLQtViewer::showMovieParametersDialog(), and G4OpenGLQtViewer::STOP.

Referenced by G4OpenGLQtMovieDialog::save().

◆ sceneTreeComponentItemChanged

void G4OpenGLQtViewer::sceneTreeComponentItemChanged	(	QTreeWidgetItem *	item,
		int	id
	)

privateslotinherited

Definition at line 3556 of file G4OpenGLQtViewer.cc.

                                                                               {
 
  if (fCheckSceneTreeComponentSignalLock == false) {
    fCheckSceneTreeComponentSignalLock = true;
    G4bool checked = false;
    if (item->checkState(0) == Qt::Checked) {
      checked = true;
    }
    setCheckComponent(item,checked);
    updateQWidget();
 
    fCheckSceneTreeComponentSignalLock = false;
  }
}

References G4OpenGLQtViewer::fCheckSceneTreeComponentSignalLock, G4OpenGLQtViewer::setCheckComponent(), and G4OpenGLQtViewer::updateQWidget().

Referenced by G4OpenGLQtViewer::createSceneTreeComponent().

◆ sceneTreeComponentSelected

void G4OpenGLQtViewer::sceneTreeComponentSelected ( )

privateslotinherited

Definition at line 3572 of file G4OpenGLQtViewer.cc.

3572 {

3573}

Referenced by G4OpenGLQtViewer::createSceneTreeComponent().

◆ setBadEncoder()

void G4OpenGLQtViewer::setBadEncoder ( )

inherited

Definition at line 2020 of file G4OpenGLQtViewer.cc.

                                    {
  fRecordingStep = BAD_ENCODER;
  displayRecordingStatus();
}

References G4OpenGLQtViewer::BAD_ENCODER, G4OpenGLQtViewer::displayRecordingStatus(), and G4OpenGLQtViewer::fRecordingStep.

◆ setBadOutput()

void G4OpenGLQtViewer::setBadOutput ( )

inherited

Definition at line 2028 of file G4OpenGLQtViewer.cc.

                                   {
  fRecordingStep = BAD_OUTPUT;
  displayRecordingStatus();
}

References G4OpenGLQtViewer::BAD_OUTPUT, G4OpenGLQtViewer::displayRecordingStatus(), and G4OpenGLQtViewer::fRecordingStep.

◆ setBadTmp()

void G4OpenGLQtViewer::setBadTmp ( )

inherited

Definition at line 2024 of file G4OpenGLQtViewer.cc.

                                {
  fRecordingStep = BAD_TMP;
  displayRecordingStatus();
}

References G4OpenGLQtViewer::BAD_TMP, G4OpenGLQtViewer::displayRecordingStatus(), and G4OpenGLQtViewer::fRecordingStep.

◆ setCheckComponent()

void G4OpenGLQtViewer::setCheckComponent	(	QTreeWidgetItem *	item,
		bool	check
	)

privateinherited

Definition at line 2767 of file G4OpenGLQtViewer.cc.

{
  if (item) {
 
    const PVPath& fullPath = fTreeItemModels[item->data(0,Qt::UserRole).toInt()];
    // If a physical volume
    if (fullPath.size() > 0) {
      SetTouchable(fullPath);
      TouchableSetVisibility(fullPath, check);
      fMouseOnSceneTree = true;
    }
  }
 
  if (item != NULL) {
    if (check) {
      item->setCheckState(0,Qt::Checked);
    } else {
      item->setCheckState(0,Qt::Unchecked);
    }
    updatePositivePoIndexSceneTreeWidgetQuickMap(item->data(0,Qt::UserRole).toInt(),item);
    int nChildCount = item->childCount();
    for (int i = 0; i < nChildCount; i++) {
      setCheckComponent(item->child(i),check);
    }
  }
}

References G4OpenGLQtViewer::fMouseOnSceneTree, G4OpenGLQtViewer::fTreeItemModels, G4OpenGLQtViewer::setCheckComponent(), G4VViewer::SetTouchable(), G4VViewer::TouchableSetVisibility(), and G4OpenGLQtViewer::updatePositivePoIndexSceneTreeWidgetQuickMap().

Referenced by G4OpenGLQtViewer::sceneTreeComponentItemChanged(), and G4OpenGLQtViewer::setCheckComponent().

◆ SetDefaultViewParameters()

void G4VViewer::SetDefaultViewParameters ( const G4ViewParameters & vp )

inherited

◆ setEncoderPath()

QString G4OpenGLQtViewer::setEncoderPath ( QString path )

inherited

set the new encoder path

Returns: "" if correct. The error otherwise

Definition at line 1927 of file G4OpenGLQtViewer.cc.

                                                     {
  if (path == "") {
    return "ppmtompeg is needed to encode in video format. It is available here: http://netpbm.sourceforge.net ";
  }
 
  path =  QDir::cleanPath(path);
  QFileInfo *f = new QFileInfo(path);
  if (!f->exists()) {
    return "File does not exist";
  } else if (f->isDir()) {
    return "This is a directory";
  } else if (!f->isExecutable()) {
    return "File exist but is not executable";
  } else if (!f->isFile()) {
    return "This is not a file";
  }
  fEncoderPath = path;
 
  if (fRecordingStep == BAD_ENCODER) {
    setRecordingStatus(STOP);
  }
  return "";
}

References G4OpenGLQtViewer::BAD_ENCODER, G4OpenGLQtViewer::fEncoderPath, G4OpenGLQtViewer::fRecordingStep, G4OpenGLQtViewer::setRecordingStatus(), and G4OpenGLQtViewer::STOP.

Referenced by G4OpenGLQtMovieDialog::checkEncoderSwParameters(), and G4OpenGLQtViewer::processLookForFinished().

◆ setExportFilename()

bool G4OpenGLViewer::setExportFilename	(	G4String	name,
		G4bool	inc = `true`
	)

protectedinherited

If name is "" or "!", filename and extension will have the default value. If name is "toto.png", set the name to "toto" and the format to "png". No incremented suffix is added. If name is "toto", set the name to "toto" and the format to default (or current format if specify). If name is the same as previous, do not reset incremented suffix.

Definition at line 1034 of file G4OpenGLViewer.cc.

                                                               {
  if (name == "!") {
    name = "";
  }
 
  if (inc) {
    if ((name != "") && (fExportFilename != name)) {
      fExportFilenameIndex=0;
    }
  } else {
    fExportFilenameIndex=-1;
  }
 
  if (name.size() == 0) {
    name = getRealPrintFilename().c_str();
  } else {
    // guess format by extention
    std::string extension = name.substr(name.find_last_of(".") + 1);
    // If there is a dot in the name the above might find rubbish, so...
    if (extension.size() >= 3 && extension.size() <= 4) {  // Possible extension
      if (setExportImageFormat(extension, false)) {  // Extension found
        fExportFilename = name.substr(0,name.find_last_of("."));
      } else {  // No viable extension found
        return false;
      }
    } else {  // Assume name is already the required without-extension part
        fExportFilename = name;
    }
  }
  return true;
}

References G4OpenGLViewer::fExportFilename, G4OpenGLViewer::fExportFilenameIndex, G4OpenGLViewer::getRealPrintFilename(), G4InuclParticleNames::name(), and G4OpenGLViewer::setExportImageFormat().

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::exportImage(), and G4OpenGLViewerMessenger::SetNewValue().

◆ setExportImageFormat()

bool G4OpenGLViewer::setExportImageFormat	(	std::string	format,
		bool	quiet = `false`
	)

inherited

Definition at line 1292 of file G4OpenGLViewer.cc.

                                                                      {
  bool found = false;
  std::string list;
  for (unsigned int a=0; a<fExportImageFormatVector.size(); a++) {
    list +=fExportImageFormatVector.at(a) + " ";
 
    if (fExportImageFormatVector.at(a) == format) {
      if (! quiet) {
        G4cout << " Changing export format to \"" << format << "\"" << G4endl;
      }
      if (format != fExportImageFormat) {
        fExportFilenameIndex = 0;
        fExportImageFormat = format;
      }
      return true;
    }
  }
  if (! found) {
    if (format.size() == 0) {
      G4cout << " Current formats availables are : " << list << G4endl;
    } else {
      G4cerr << " Format \"" << format << "\" is not available for the selected viewer. Current formats availables are : " << list << G4endl;
    }
  }
  return false;
}

References G4OpenGLViewer::fExportFilenameIndex, G4OpenGLViewer::fExportImageFormat, G4OpenGLViewer::fExportImageFormatVector, G4cerr, G4cout, and G4endl.

Referenced by G4OpenGLViewer::exportImage(), G4OpenGLImmediateQtViewer::initializeGL(), initializeGL(), G4OpenGLViewer::setExportFilename(), and G4OpenGLViewerMessenger::SetNewValue().

◆ setExportSize()

void G4OpenGLViewer::setExportSize	(	G4int	X,
		G4int	Y
	)

protectedinherited

Definition at line 1023 of file G4OpenGLViewer.cc.

                                                   {
  fPrintSizeX = X;
  fPrintSizeY = Y;
}

References G4OpenGLViewer::fPrintSizeX, G4OpenGLViewer::fPrintSizeY, and Y().

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::exportImage(), and G4OpenGLViewerMessenger::SetNewValue().

◆ SetName()

void G4VViewer::SetName ( const G4String & name )

inherited

Definition at line 72 of file G4VViewer.cc.

                                             {
  fName = name;
  fShortName = fName.substr(0, fName.find (' '));
  G4StrUtil::strip(fShortName);
}

References G4VViewer::fName, G4VViewer::fShortName, G4InuclParticleNames::name(), and G4StrUtil::strip().

◆ SetNeedKernelVisit()

void G4VViewer::SetNeedKernelVisit ( G4bool need )

inherited

Referenced by G4OpenGLXmViewer::aux_edge_callback(), G4OpenGLQtViewer::toggleAux(), G4OpenGLQtViewer::toggleTransparency(), and G4OpenGLXmViewer::transparency_callback().

◆ setRecordingInfos()

void G4OpenGLQtViewer::setRecordingInfos ( const QString & txt )

privateinherited

Definition at line 1888 of file G4OpenGLQtViewer.cc.

                                                           {
  if (fMovieParametersDialog) {
    fMovieParametersDialog->setRecordingInfos(txt);
  } else {
    G4cout << txt.toStdString().c_str() << G4endl;
  }
}

References G4OpenGLQtViewer::fMovieParametersDialog, G4cout, G4endl, and G4OpenGLQtMovieDialog::setRecordingInfos().

Referenced by G4OpenGLQtViewer::displayRecordingStatus(), G4OpenGLQtViewer::generateMpegEncoderParameters(), G4OpenGLQtViewer::processEncodeStdout(), G4OpenGLQtViewer::savePPMToTemp(), G4OpenGLQtViewer::showMovieParametersDialog(), G4OpenGLQtViewer::startPauseVideo(), and G4OpenGLQtViewer::stopVideo().

◆ setRecordingStatus()

void G4OpenGLQtViewer::setRecordingStatus ( RECORDING_STEP step )

privateinherited

Definition at line 1843 of file G4OpenGLQtViewer.cc.

                                                             {
 
  fRecordingStep = step;
  displayRecordingStatus();
}

References G4OpenGLQtViewer::displayRecordingStatus(), and G4OpenGLQtViewer::fRecordingStep.

Referenced by G4OpenGLQtViewer::encodeVideo(), G4OpenGLQtViewer::generateMpegEncoderParameters(), G4OpenGLQtViewer::processEncodeFinished(), G4OpenGLQtViewer::resetRecording(), G4OpenGLQtViewer::saveVideo(), G4OpenGLQtViewer::setEncoderPath(), G4OpenGLQtViewer::setSaveFileName(), G4OpenGLQtViewer::setTempFolderPath(), G4OpenGLQtViewer::startPauseVideo(), and G4OpenGLQtViewer::stopVideo().

◆ setSaveFileName()

QString G4OpenGLQtViewer::setSaveFileName ( QString path )

inherited

set the save file name path

Returns: "" if correct. The error otherwise

Definition at line 2088 of file G4OpenGLQtViewer.cc.

                                                      {
 
  if (path == "") {
    return "Path does not exist";
  }
 
  QFileInfo *file = new QFileInfo(path);
  QDir dir = file->dir();
  path =  QDir::cleanPath(path);
  if (file->exists()) {
    return "File already exist, please choose a new one";
  } else if (!dir.exists()) {
    return "Dir does not exist";
  } else if (!dir.isReadable()) {
    return path +" is read protected";
  }
 
  if (fRecordingStep == BAD_OUTPUT) {
    setRecordingStatus(STOP);
  }
  fSaveFileName = path;
  return "";
}

References G4OpenGLQtViewer::BAD_OUTPUT, geant4_check_module_cycles::file, G4OpenGLQtViewer::fRecordingStep, G4OpenGLQtViewer::fSaveFileName, G4OpenGLQtViewer::setRecordingStatus(), and G4OpenGLQtViewer::STOP.

Referenced by G4OpenGLQtMovieDialog::checkSaveFileNameParameters().

◆ setTempFolderPath()

QString G4OpenGLQtViewer::setTempFolderPath ( QString path )

inherited

set the temp folder path

Returns: "" if correct. The error otherwise

Definition at line 2054 of file G4OpenGLQtViewer.cc.

                                                        {
 
  if (path == "") {
    return "Path does not exist";
  }
  path =  QDir::cleanPath(path);
  QFileInfo *d = new QFileInfo(path);
  if (!d->exists()) {
    return "Path does not exist";
  } else if (!d->isDir()) {
    return "This is not a directory";
  } else if (!d->isReadable()) {
    return path +" is read protected";
  } else if (!d->isWritable()) {
    return path +" is write protected";
  }
 
  if (fRecordingStep == BAD_TMP) {
    setRecordingStatus(WAIT);
  }
  fTempFolderPath = path;
  return "";
}

References G4OpenGLQtViewer::BAD_TMP, G4OpenGLQtViewer::fRecordingStep, G4OpenGLQtViewer::fTempFolderPath, G4OpenGLQtViewer::setRecordingStatus(), and G4OpenGLQtViewer::WAIT.

Referenced by G4OpenGLQtMovieDialog::checkTempFolderParameters(), G4OpenGLQtViewer::createTempFolder(), and G4OpenGLQtViewer::processLookForFinished().

◆ SetTouchable()

void G4VViewer::SetTouchable ( const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > & fullPath )

protectedinherited

Definition at line 124 of file G4VViewer.cc.

{
  // Set the touchable for /vis/touchable/set/... commands.
  std::ostringstream oss;
  const auto& pvStore = G4PhysicalVolumeStore::GetInstance();
  for (const auto& pvNodeId: fullPath) {
    const auto& pv = pvNodeId.GetPhysicalVolume();
    auto iterator = find(pvStore->begin(),pvStore->end(),pv);
    if (iterator == pvStore->end()) {
      G4ExceptionDescription ed;
      ed << "Volume no longer in physical volume store.";
      G4Exception("G4VViewer::SetTouchable", "visman0501", JustWarning, ed);
    } else {
      oss
      << ' ' << pvNodeId.GetPhysicalVolume()->GetName()
      << ' ' << pvNodeId.GetCopyNo();
    }
  }
  G4UImanager::GetUIpointer()->ApplyCommand("/vis/set/touchable" + oss.str());
}

References G4UImanager::ApplyCommand(), G4Exception(), G4PhysicalVolumeStore::GetInstance(), G4UImanager::GetUIpointer(), and JustWarning.

Referenced by G4OpenGLQtViewer::changeColorAndTransparency(), and G4OpenGLQtViewer::setCheckComponent().

◆ SetView()

void G4OpenGLViewer::SetView ( )

protectedvirtualinherited

Implements G4VViewer.

Reimplemented in G4OpenGLWin32Viewer, and G4OpenGLXViewer.

Definition at line 277 of file G4OpenGLViewer.cc.

                              {
  // if getting pick infos, should not resize the view.
  if (fIsGettingPickInfos) return;
  
  if (!fSceneHandler.GetScene()) {
    return;
  }
  // Calculates view representation based on extent of object being
  // viewed and (initial) viewpoint.  (Note: it can change later due
  // to user interaction via visualization system's GUI.)
  
  // Lighting.
  GLfloat lightPosition [4];
  lightPosition [0] = fVP.GetActualLightpointDirection().x();
  lightPosition [1] = fVP.GetActualLightpointDirection().y();
  lightPosition [2] = fVP.GetActualLightpointDirection().z();
  lightPosition [3] = 0.;
  // Light position is "true" light direction, so must come after gluLookAt.
  GLfloat ambient [] = { 0.2f, 0.2f, 0.2f, 1.f};
  GLfloat diffuse [] = { 0.8f, 0.8f, 0.8f, 1.f};
  glEnable (GL_LIGHT0);
  glLightfv (GL_LIGHT0, GL_AMBIENT, ambient);
  glLightfv (GL_LIGHT0, GL_DIFFUSE, diffuse);
  
  G4double ratioX = 1;
  G4double ratioY = 1;
  if (fWinSize_y > fWinSize_x) {
    ratioX = ((G4double)fWinSize_y) / ((G4double)fWinSize_x);
  }
  if (fWinSize_x > fWinSize_y) {
    ratioY = ((G4double)fWinSize_x) / ((G4double)fWinSize_y);
  }
  
  // Get radius of scene, etc.
  // Note that this procedure properly takes into account zoom, dolly and pan.
  const G4Point3D targetPoint
    = fSceneHandler.GetScene()->GetStandardTargetPoint()
    + fVP.GetCurrentTargetPoint ();
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
  if(radius<=0.) radius = 1.;
  const G4double cameraDistance = fVP.GetCameraDistance (radius);
  const G4Point3D cameraPosition =
    targetPoint + cameraDistance * fVP.GetViewpointDirection().unit();
  const GLdouble pnear  = fVP.GetNearDistance (cameraDistance, radius);
  const GLdouble pfar   = fVP.GetFarDistance  (cameraDistance, pnear, radius);
  const GLdouble right  = fVP.GetFrontHalfHeight (pnear, radius) * ratioY;
  const GLdouble left   = -right;
  const GLdouble top    = fVP.GetFrontHalfHeight (pnear, radius) * ratioX;
  const GLdouble bottom = -top;
  
  // FIXME
  ResizeGLView();
  //SHOULD SetWindowsSizeHint()...
 
  glMatrixMode (GL_PROJECTION); // set up Frustum.
  glLoadIdentity();
 
  const G4Vector3D scaleFactor = fVP.GetScaleFactor();
  glScaled(scaleFactor.x(),scaleFactor.y(),scaleFactor.z());
  
  if (fVP.GetFieldHalfAngle() == 0.) {
    g4GlOrtho (left, right, bottom, top, pnear, pfar);
  }
  else {
    g4GlFrustum (left, right, bottom, top, pnear, pfar);
  }  
 
  glMatrixMode (GL_MODELVIEW); // apply further transformations to scene.
  glLoadIdentity();
  
  const G4Normal3D& upVector = fVP.GetUpVector ();  
  G4Point3D gltarget;
  if (cameraDistance > 1.e-6 * radius) {
    gltarget = targetPoint;
  }
  else {
    gltarget = targetPoint - radius * fVP.GetViewpointDirection().unit();
  }
 
  const G4Point3D& pCamera = cameraPosition;  // An alias for brevity.
 
  g4GluLookAt (pCamera.x(),  pCamera.y(),  pCamera.z(),       // Viewpoint.
             gltarget.x(), gltarget.y(), gltarget.z(),      // Target point.
             upVector.x(), upVector.y(), upVector.z());     // Up vector.
  // Light position is "true" light direction, so must come after gluLookAt.
  glLightfv (GL_LIGHT0, GL_POSITION, lightPosition);
 
  // The idea is to use back-to-back clipping planes.  This can cut an object
  // down to just a few pixels, which can make it difficult to see.  So, for
  // now, comment this out and use the generic (Boolean) method, via
  // G4VSolid* G4OpenGLSceneHandler::CreateSectionSolid ()
  // { return G4VSceneHandler::CreateSectionSolid(); }
//  if (fVP.IsSection () ) {  // pair of back to back clip planes.
//    const G4Plane3D& sp = fVP.GetSectionPlane ();
//    double sArray[4];
//    sArray[0] = sp.a();
//    sArray[1] = sp.b();
//    sArray[2] = sp.c();
//    sArray[3] = sp.d() + radius * 1.e-05;
//    glClipPlane (GL_CLIP_PLANE0, sArray);
//    glEnable (GL_CLIP_PLANE0);
//    sArray[0] = -sp.a();
//    sArray[1] = -sp.b();
//    sArray[2] = -sp.c();
//    sArray[3] = -sp.d() + radius * 1.e-05;
//    glClipPlane (GL_CLIP_PLANE1, sArray);
//    glEnable (GL_CLIP_PLANE1);
//  } else {
//    glDisable (GL_CLIP_PLANE0);
//    glDisable (GL_CLIP_PLANE1);
//  }
 
  // What we call intersection of cutaways is easy in OpenGL.  You
  // just keep cutting.  Unions are more tricky - you have to have
  // multiple passes and this is handled in
  // G4OpenGLImmediate/StoredViewer::ProcessView.
  const G4Planes& cutaways = fVP.GetCutawayPlanes();
  size_t nPlanes = cutaways.size();
  if (fVP.IsCutaway() &&
      fVP.GetCutawayMode() == G4ViewParameters::cutawayIntersection &&
      nPlanes > 0) {
    double a[4];
    a[0] = cutaways[0].a();
    a[1] = cutaways[0].b();
    a[2] = cutaways[0].c();
    a[3] = cutaways[0].d();
    glClipPlane (GL_CLIP_PLANE2, a);
    glEnable (GL_CLIP_PLANE2);
    if (nPlanes > 1) {
      a[0] = cutaways[1].a();
      a[1] = cutaways[1].b();
      a[2] = cutaways[1].c();
      a[3] = cutaways[1].d();
      glClipPlane (GL_CLIP_PLANE3, a);
      glEnable (GL_CLIP_PLANE3);
    }
    if (nPlanes > 2) {
      a[0] = cutaways[2].a();
      a[1] = cutaways[2].b();
      a[2] = cutaways[2].c();
      a[3] = cutaways[2].d();
      glClipPlane (GL_CLIP_PLANE4, a);
      glEnable (GL_CLIP_PLANE4);
    }
  } else {
    glDisable (GL_CLIP_PLANE2);
    glDisable (GL_CLIP_PLANE3);
    glDisable (GL_CLIP_PLANE4);
  }
 
  // Background.
  background = fVP.GetBackgroundColour ();
 
}

Referenced by G4OpenGLImmediateQtViewer::paintGL(), paintGL(), G4OpenGLWin32Viewer::SetView(), and G4OpenGLXViewer::SetView().

◆ SetViewParameters()

void G4VViewer::SetViewParameters ( const G4ViewParameters & vp )

inherited

Definition at line 120 of file G4VViewer.cc.

                                                             {
  fVP = vp;
}

References G4VViewer::fVP.

Referenced by G4VVisCommand::InterpolateViews(), G4VisCommandDrawView::SetNewValue(), G4VisCommandViewerCreate::SetNewValue(), G4VisCommandViewerInterpolate::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenInventorViewer::SetReducedWireFrame(), G4OpenInventorViewer::SetSolid(), G4VVisCommand::SetViewParameters(), and G4OpenInventorViewer::SetWireFrame().

◆ setWaiting()

void G4OpenGLQtViewer::setWaiting ( )

inherited

Definition at line 2033 of file G4OpenGLQtViewer.cc.

                                 {
  fRecordingStep = WAIT;
  displayRecordingStatus();
}

References G4OpenGLQtViewer::displayRecordingStatus(), G4OpenGLQtViewer::fRecordingStep, and G4OpenGLQtViewer::WAIT.

◆ showEvent()

void G4OpenGLStoredQtViewer::showEvent ( QShowEvent * event )

protected

Definition at line 378 of file G4OpenGLStoredQtViewer.cc.

{
  if (fQGLWidgetInitialiseCompleted) {
    fHasToRepaint = true;
  }
}

References G4OpenGLQtViewer::fHasToRepaint, and G4OpenGLQtViewer::fQGLWidgetInitialiseCompleted.

◆ showMovieParametersDialog()

void G4OpenGLQtViewer::showMovieParametersDialog ( )

privateinherited

Definition at line 1250 of file G4OpenGLQtViewer.cc.

                                                 {
  if (!fMovieParametersDialog) {
    fMovieParametersDialog= new G4OpenGLQtMovieDialog(this,fGLWidget);
    displayRecordingStatus();
    fMovieParametersDialog->checkEncoderSwParameters();
    fMovieParametersDialog->checkSaveFileNameParameters();
    fMovieParametersDialog->checkTempFolderParameters();
    if (getEncoderPath() == "") {
      setRecordingInfos("ppmtompeg is needed to encode in video format. It is available here: http://netpbm.sourceforge.net ");
    }
  }
  fMovieParametersDialog->show();
}

References G4OpenGLQtMovieDialog::checkEncoderSwParameters(), G4OpenGLQtMovieDialog::checkSaveFileNameParameters(), G4OpenGLQtMovieDialog::checkTempFolderParameters(), G4OpenGLQtViewer::displayRecordingStatus(), G4OpenGLQtViewer::fGLWidget, G4OpenGLQtViewer::fMovieParametersDialog, G4OpenGLQtViewer::getEncoderPath(), and G4OpenGLQtViewer::setRecordingInfos().

Referenced by G4OpenGLQtViewer::actionMovieParameters(), G4OpenGLQtViewer::saveVideo(), G4OpenGLQtViewer::startPauseVideo(), and G4OpenGLQtViewer::stopVideo().

◆ showShortcuts

void G4OpenGLQtViewer::showShortcuts ( )

privateslotinherited

Show shortcuts for this mouse action

Definition at line 803 of file G4OpenGLQtViewer.cc.

                                     {
  G4String text;
 
  text = "========= Mouse Shortcuts =========\n";
  if (fUiQt != NULL) {
    if (fUiQt->IsIconRotateSelected()) {  // rotate
      text += "Click and move mouse to rotate volume \n";
      text += "ALT + Click and move mouse to rotate volume (Toggle View/Theta-Phi Direction) \n";
      text += "CTRL + Click and move mouse to zoom in/out \n";
      text += "SHIFT + Click and move mouse to change camera point of view \n";
    } else  if (fUiQt->IsIconMoveSelected()) { //move
      text += "Move camera point of view with mouse \n";
    } else  if (fUiQt->IsIconPickSelected()) { //pick
      text += "Click and pick \n";
    }
  } else {
    text += "Click and move mouse to rotate volume \n";
    text += "ALT + Click and move mouse to rotate volume (Toggle View/Theta-Phi Direction) \n";
    text += "CTRL + Click and zoom mouse to zoom in/out \n";
    text += "SHIFT + Click and zoommove camera point of view \n";
  }
  text += "========= Move Shortcuts ========= \n";
  text += "Press left/right arrows to move volume left/right \n";
  text += "Press up/down arrows to move volume up/down \n";
  text += "Press '+'/'-' to move volume toward/forward \n";
  text += "\n";
  text += "========= Rotation (Theta/Phi) Shortcuts ========= \n";
  text += "Press SHIFT + left/right arrows to rotate volume left/right \n";
  text += "Press SHIFT + up/down arrows to rotate volume up/down \n";
  text += "\n";
  text += "========= Rotation (View Direction) Shortcuts ========= \n";
  text += "Press ALT + left/right to rotate volume around vertical direction \n";
  text += "Press ALT + up/down to rotate volume around horizontal direction \n";
  text += "\n";
  text += "========= Zoom View ========= \n";
  text += "Press CTRL + '+'/'-' to zoom into volume \n";
  text += "\n";
  text += "========= Misc ========= \n";
  text += "Press ALT +/- to slow/speed rotation/move \n";
  text += "Press H to reset view \n";
  text += "Press Esc to exit FullScreen \n";
  text += "\n";
  text += "========= Video ========= \n";
  text += "In video mode : \n";
  text += " Press SPACE to Start/Pause video recording \n";
  text += " Press RETURN to Stop video recording \n";
  text += "\n";
 
  G4cout << text;
 
  if (  fShortcutsDialog == NULL) {
    fShortcutsDialog = new QDialog();
    fShortcutsDialogInfos = new QTextEdit() ;
    QVBoxLayout *mainLayout = new QVBoxLayout;
    mainLayout->addWidget(fShortcutsDialogInfos);
    fShortcutsDialog->setLayout(mainLayout);
    fShortcutsDialog->setWindowTitle(tr("Shortcuts"));
  }
 
  fShortcutsDialogInfos->setPlainText(text.data());
  fShortcutsDialog->show();
}

References G4OpenGLQtViewer::fShortcutsDialog, G4OpenGLQtViewer::fShortcutsDialogInfos, G4OpenGLQtViewer::fUiQt, G4cout, G4UIQt::IsIconMoveSelected(), G4UIQt::IsIconPickSelected(), and G4UIQt::IsIconRotateSelected().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ ShowView()

void G4OpenGLStoredQtViewer::ShowView ( void )

virtual

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Reimplemented from G4VViewer.

Definition at line 432 of file G4OpenGLStoredQtViewer.cc.

{
  //  glFlush ();  // Tentativley offered by JA 29/04/16.
  
  // Some X servers fail to draw all trajectories, particularly Mac
  // XQuartz.  Revisit this at a future date.  Meanwhile, issue an
  // extra...
  //  ClearView();  // Necessary?  JA 29/04/16 
  //  DrawView();   // Necessary?  JA 29/04/16
  activateWindow();
  //  glFlush(); // NO NEED and as drawView will already cause a flush
  // that could do a double flush
  
}

◆ sizeHasChanged()

G4bool G4OpenGLViewer::sizeHasChanged ( )

protectedinherited

Definition at line 981 of file G4OpenGLViewer.cc.

                                      {
  return fSizeHasChanged;
}

References G4OpenGLViewer::fSizeHasChanged.

Referenced by G4OpenGLImmediateQtViewer::resizeGL(), and resizeGL().

◆ startPauseVideo

void G4OpenGLQtViewer::startPauseVideo ( )

slotinherited

Start/Pause the video..

Definition at line 1807 of file G4OpenGLQtViewer.cc.

                                       {
 
  // first time, if temp parameter is wrong, display parameters dialog and return
 
  if ( fRecordingStep == WAIT) {
    if ( fRecordFrameNumber == 0) {
      if (getTempFolderPath() == "") { // BAD_OUTPUT
        showMovieParametersDialog();
        setRecordingInfos("You should specified the temp folder in order to make movie");
        return;
      } else  {
        // remove temp folder if it was create
        QString tmp = removeTempFolder();
        if (tmp !="") {
          setRecordingInfos(tmp);
          return;
        }
        tmp = createTempFolder();
        if (tmp != "") {
          setRecordingInfos("Can't create temp folder."+tmp);
          return;
        }
      }
    }
  }
  if (fRecordingStep == WAIT) {
    setRecordingStatus(START);
  } else if (fRecordingStep == START) {
    setRecordingStatus(PAUSE);
  } else if (fRecordingStep == PAUSE) {
    setRecordingStatus(CONTINUE);
  } else if (fRecordingStep == CONTINUE) {
    setRecordingStatus(PAUSE);
  }
}

References G4OpenGLQtViewer::CONTINUE, G4OpenGLQtViewer::createTempFolder(), G4OpenGLQtViewer::fRecordFrameNumber, G4OpenGLQtViewer::fRecordingStep, G4OpenGLQtViewer::getTempFolderPath(), G4OpenGLQtViewer::PAUSE, G4OpenGLQtViewer::removeTempFolder(), G4OpenGLQtViewer::setRecordingInfos(), G4OpenGLQtViewer::setRecordingStatus(), G4OpenGLQtViewer::showMovieParametersDialog(), G4OpenGLQtViewer::START, and G4OpenGLQtViewer::WAIT.

Referenced by G4OpenGLQtViewer::G4keyPressEvent().

◆ stopVideo()

void G4OpenGLQtViewer::stopVideo ( )

inherited

Stop the video. Check all parameters and enable encoder button if all is ok.

Definition at line 1764 of file G4OpenGLQtViewer.cc.

                                 {
 
  // if encoder parameter is wrong, display parameters dialog and return
  if (!fMovieParametersDialog) {
    showMovieParametersDialog();
  }
  setRecordingStatus(STOP);
 
  if (fRecordFrameNumber >0) {
    // check parameters if they were modified (Re APPLY them...)
    if (!(fMovieParametersDialog->checkEncoderSwParameters())) {
      setRecordingStatus(BAD_ENCODER);
    }  else if (!(fMovieParametersDialog->checkSaveFileNameParameters())) {
      setRecordingStatus(BAD_OUTPUT);
    }
  } else {
    resetRecording();
    setRecordingInfos("No frame to encode.");
  }
}

References G4OpenGLQtViewer::BAD_ENCODER, G4OpenGLQtViewer::BAD_OUTPUT, G4OpenGLQtMovieDialog::checkEncoderSwParameters(), G4OpenGLQtMovieDialog::checkSaveFileNameParameters(), G4OpenGLQtViewer::fMovieParametersDialog, G4OpenGLQtViewer::fRecordFrameNumber, G4OpenGLQtViewer::resetRecording(), G4OpenGLQtViewer::setRecordingInfos(), G4OpenGLQtViewer::setRecordingStatus(), G4OpenGLQtViewer::showMovieParametersDialog(), and G4OpenGLQtViewer::STOP.

Referenced by G4OpenGLQtViewer::G4keyPressEvent(), and G4OpenGLQtMovieDialog::stopFinishClose().

◆ tableWidgetViewerSetItemChanged

void G4OpenGLQtViewer::tableWidgetViewerSetItemChanged ( QTableWidgetItem * item )

privateslotinherited

Definition at line 4721 of file G4OpenGLQtViewer.cc.

                                                                              {
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI != NULL)  {
    QTableWidgetItem* previous = fViewerPropertiesTableWidget->item(fViewerPropertiesTableWidget->row(item),0);
    if (previous) {
      fViewerPropertiesTableWidget->blockSignals(true);
      UI->ApplyCommand((std::string("/vis/viewer/set/")
                        + previous->text().toStdString()
                        + " "
                        + item->text().toStdString()).c_str());
      fViewerPropertiesTableWidget->blockSignals(false);
    }
  }
}

References G4UImanager::ApplyCommand(), G4OpenGLQtViewer::fViewerPropertiesTableWidget, and G4UImanager::GetUIpointer().

Referenced by G4OpenGLQtViewer::createViewerPropertiesWidget().

◆ toggleAntialiasing

void G4OpenGLQtViewer::toggleAntialiasing ( bool check )

privateslotinherited

SLOT Activate by a click on the antialiasing menu

Parameters

check : 1 , 0

Definition at line 968 of file G4OpenGLQtViewer.cc.

                                                    {
 
  if (!check) {
    antialiasing_enabled = false;
    glDisable (GL_LINE_SMOOTH);
    glDisable (GL_POLYGON_SMOOTH);
  } else {
    antialiasing_enabled = true;
    glEnable (GL_LINE_SMOOTH);
    glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
    glEnable (GL_POLYGON_SMOOTH);
    glHint (GL_POLYGON_SMOOTH_HINT, GL_NICEST);
  }
 
  updateToolbarAndMouseContextMenu();
  updateQWidget();
}

References G4OpenGLViewer::antialiasing_enabled, G4OpenGLQtViewer::updateQWidget(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ toggleAux

void G4OpenGLQtViewer::toggleAux ( bool check )

privateslotinherited

SLOT Activate by a click on the auxiliaire edges menu

Parameters

check : 1 , 0

Definition at line 1007 of file G4OpenGLQtViewer.cc.

                                           {
  if (check) {
    fVP.SetAuxEdgeVisible(true);
  } else {
    fVP.SetAuxEdgeVisible(false);
  }
  SetNeedKernelVisit (true);
  updateToolbarAndMouseContextMenu();
  updateQWidget();
}

References G4VViewer::fVP, G4ViewParameters::SetAuxEdgeVisible(), G4VViewer::SetNeedKernelVisit(), G4OpenGLQtViewer::updateQWidget(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ toggleFullScreen

void G4OpenGLQtViewer::toggleFullScreen ( bool check )

privateslotinherited

SLOT Activate by a click on the full screen menu

Definition at line 1059 of file G4OpenGLQtViewer.cc.

                                                  {
  if (check != fGLWidget->isFullScreen()) { //toggle
    fGLWidget->setWindowState(fGLWidget->windowState() ^ Qt::WindowFullScreen);
  }
}

References G4OpenGLQtViewer::fGLWidget.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::G4keyPressEvent().

◆ toggleHaloing

void G4OpenGLQtViewer::toggleHaloing ( bool check )

privateslotinherited

SLOT Activate by a click on the haloing menu

Parameters

check : 1 , 0

Definition at line 991 of file G4OpenGLQtViewer.cc.

                                               {
  if (check) {
    haloing_enabled = false;
  } else {
    haloing_enabled = true;
  }
 
  updateToolbarAndMouseContextMenu();
  updateQWidget();
 
}

References G4OpenGLViewer::haloing_enabled, G4OpenGLQtViewer::updateQWidget(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ toggleHiddenMarkers

void G4OpenGLQtViewer::toggleHiddenMarkers ( bool check )

privateslotinherited

SLOT Activate by a click on the hidden marker menu

Parameters

check : 1 , 0

Definition at line 1045 of file G4OpenGLQtViewer.cc.

                                                     {
  if (check) {
    fVP.SetMarkerHidden();
  } else {
    fVP.SetMarkerNotHidden();
  }
  //  SetNeedKernelVisit (true);
  updateToolbarAndMouseContextMenu();
  updateQWidget();
}

References G4VViewer::fVP, G4ViewParameters::SetMarkerHidden(), G4ViewParameters::SetMarkerNotHidden(), G4OpenGLQtViewer::updateQWidget(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ toggleMouseAction

void G4OpenGLQtViewer::toggleMouseAction ( int aAction )

privateslotinherited

Slot activated when mouse action is toggle

Parameters

aAction : 1 rotate, 2 move, 3 pick, 4 zoom out, 5 zoom in

See also: G4OpenGLStoredQtViewer::DrawView; G4XXXStoredViewer::CompareForKernelVisit

Definition at line 874 of file G4OpenGLQtViewer.cc.

                                                    {
 
  if (aAction == 1) {
    fUiQt->SetIconRotateSelected();
  } else  if (aAction == 2) {
    fUiQt->SetIconMoveSelected();
  } else  if (aAction == 3) {
    togglePicking();
  } else  if (aAction == 4) {
    fUiQt->SetIconZoomOutSelected();
  } else  if (aAction == 5) {
    fUiQt->SetIconZoomInSelected();
  }
 
  updateQWidget();
  updateToolbarAndMouseContextMenu();
}

References G4OpenGLQtViewer::fUiQt, G4UIQt::SetIconMoveSelected(), G4UIQt::SetIconRotateSelected(), G4UIQt::SetIconZoomInSelected(), G4UIQt::SetIconZoomOutSelected(), G4OpenGLQtViewer::togglePicking(), G4OpenGLQtViewer::updateQWidget(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ togglePicking

void G4OpenGLQtViewer::togglePicking ( )

privateslotinherited

Definition at line 1019 of file G4OpenGLQtViewer.cc.

                                     {
  // FIXME : Not the good way to do, we should handle the multiple cases of Icon/ContextMenu and CheckBox in a better way
  if (fUiQt) {
    if (!fVP.IsPicking()) {
      fUiQt->SetIconPickSelected();
    } else {
      fUiQt->SetIconRotateSelected();
    }
  }
 
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI != NULL)  {
    if (!fVP.IsPicking()) {
      UI->ApplyCommand(std::string("/vis/viewer/set/picking true"));
    } else {
      UI->ApplyCommand(std::string("/vis/viewer/set/picking false"));
    }
  }
 
}

References G4UImanager::ApplyCommand(), G4OpenGLQtViewer::fUiQt, G4VViewer::fVP, G4UImanager::GetUIpointer(), G4ViewParameters::IsPicking(), G4UIQt::SetIconPickSelected(), and G4UIQt::SetIconRotateSelected().

Referenced by G4OpenGLQtViewer::toggleMouseAction().

◆ toggleProjection

void G4OpenGLQtViewer::toggleProjection ( bool check )

privateslotinherited

SLOT Activate by a click on the projection menu Warning : When G4OpenGLStoredQtViewer::DrawView() method call, KernelVisitDecision () will be call and will set the fNeedKernelVisit to 1. See G4XXXStoredViewer::CompareForKernelVisit for explanations. It will cause a redraw of the view

Parameters

check : 1 orthographic, 2 perspective

See also: G4OpenGLStoredQtViewer::DrawView; G4XXXStoredViewer::CompareForKernelVisit

Definition at line 936 of file G4OpenGLQtViewer.cc.

                                                  {
 
  if (check == 1) {
    fVP.SetOrthogonalProjection ();
  } else {
    fVP.SetPerspectiveProjection();
  }
  updateToolbarAndMouseContextMenu();
  updateQWidget();
}

References G4VViewer::fVP, G4ViewParameters::SetOrthogonalProjection(), G4ViewParameters::SetPerspectiveProjection(), G4OpenGLQtViewer::updateQWidget(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ toggleSceneTreeComponentPickingCout

void G4OpenGLQtViewer::toggleSceneTreeComponentPickingCout ( int pickItem )

privateslotinherited

Definition at line 4682 of file G4OpenGLQtViewer.cc.

                                                                       {
 
  QWidget* w;
  // close other items, it could take too much space
 
  for (int a=0; a<fPickInfosWidget->layout()->count(); a++) {
    w = fPickInfosWidget->layout()->itemAt(a)->widget();
    QTextEdit* ed = dynamic_cast<QTextEdit*>(w);
    QPushButton* button;
    if (ed) {
      if (a == pickItem) {
        w->setVisible(!w->isVisible());
      } else {
        w->setVisible(false);
      }
      if (a >= 1) {
        button = dynamic_cast<QPushButton*>(fPickInfosWidget->layout()->itemAt(a-1)->widget());
        if (button) {
          if (button->isVisible()) {
            button->setIcon(*fTreeIconOpen);
          } else {
            button->setIcon(*fTreeIconClosed);
          }
        }
      }
    }
  }
}

References G4OpenGLQtViewer::fPickInfosWidget, G4OpenGLQtViewer::fTreeIconClosed, and G4OpenGLQtViewer::fTreeIconOpen.

Referenced by G4OpenGLQtViewer::updatePickInfosWidget().

◆ toggleSurfaceAction

void G4OpenGLQtViewer::toggleSurfaceAction ( int aAction )

privateslotinherited

Slot activated when drawing menu is toggle Warning : When G4OpenGLStoredQtViewer::DrawView() method call, KernelVisitDecision () will be call and will set the fNeedKernelVisit to 1. See G4XXXStoredViewer::CompareForKernelVisit for explanations. It will cause a redraw of the view

Parameters

aAction : 1 wireframe, 2 line removal, 3 surface removal, 4 line & surface removal

See also: G4OpenGLStoredQtViewer::DrawView; G4XXXStoredViewer::CompareForKernelVisit

Definition at line 903 of file G4OpenGLQtViewer.cc.

                                                      {
 
  G4ViewParameters::DrawingStyle d_style = G4ViewParameters::wireframe;
 
  if (aAction ==1) {
    d_style = G4ViewParameters::wireframe;
 
  } else  if (aAction ==2) {
    d_style = G4ViewParameters::hlr;
 
  } else  if (aAction ==3) {
    d_style = G4ViewParameters::hsr;
 
  } else  if (aAction ==4) {
    d_style = G4ViewParameters::hlhsr;
  }
  fVP.SetDrawingStyle(d_style);
 
  updateToolbarAndMouseContextMenu();
  updateQWidget();
}

References G4VViewer::fVP, G4ViewParameters::hlhsr, G4ViewParameters::hlr, G4ViewParameters::hsr, G4ViewParameters::SetDrawingStyle(), G4OpenGLQtViewer::updateQWidget(), G4OpenGLQtViewer::updateToolbarAndMouseContextMenu(), and G4ViewParameters::wireframe.

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ toggleTransparency

void G4OpenGLQtViewer::toggleTransparency ( bool check )

privateslotinherited

SLOT Activate by a click on the transparency menu

Parameters

check : 1 , 0

Definition at line 952 of file G4OpenGLQtViewer.cc.

                                                    {
 
  if (check) {
    transparency_enabled = true;
  } else {
    transparency_enabled = false;
  }
  SetNeedKernelVisit (true);
  updateToolbarAndMouseContextMenu();
  updateQWidget();
}

References G4VViewer::SetNeedKernelVisit(), G4OpenGLViewer::transparency_enabled, G4OpenGLQtViewer::updateQWidget(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ TOSelected()

G4bool G4OpenGLStoredQtViewer::TOSelected ( size_t TOListIndex )

protectedvirtual

Reimplemented from G4OpenGLStoredViewer.

Definition at line 202 of file G4OpenGLStoredQtViewer.cc.

{
  return true;
}

◆ TouchableSetColour()

void G4VViewer::TouchableSetColour	(	const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &	fullPath,
		const G4Colour &	colour
	)

protectedinherited

Definition at line 180 of file G4VViewer.cc.

{
  // Changes the Vis Attribute Modifiers WITHOUT triggering a rebuild.
 
  std::ostringstream oss;
  oss << "/vis/touchable/set/colour "
  << colour.GetRed() << ' ' << colour.GetGreen()
  << ' ' << colour.GetBlue() << ' ' << colour.GetAlpha();
 
  // The following is equivalent to
  //  G4UImanager::GetUIpointer()->ApplyCommand(oss.str());
  // (assuming the touchable has already been set), but avoids view rebuild.
 
  // Instantiate a working copy of a G4VisAttributes object...
  G4VisAttributes workingVisAtts;
  // and set the colour.
  workingVisAtts.SetColour(colour);
 
  fVP.AddVisAttributesModifier
  (G4ModelingParameters::VisAttributesModifier
   (workingVisAtts,
    G4ModelingParameters::VASColour,
    G4PhysicalVolumeModel::GetPVNameCopyNoPath(fullPath)));
  // G4ModelingParameters::VASColour (VAS = Vis Attribute Signifier)
  // signifies that it is the colour that should be picked out
  // and merged with the touchable's normal vis attributes.
 
  // Record on G4cout (with #) for information.
  if (G4UImanager::GetUIpointer()->GetVerboseLevel() >= 2) {
    G4cout << "# " << oss.str() << G4endl;
  }
}

References G4ViewParameters::AddVisAttributesModifier(), G4VViewer::fVP, G4cout, G4endl, G4Colour::GetAlpha(), G4Colour::GetBlue(), G4Colour::GetGreen(), G4PhysicalVolumeModel::GetPVNameCopyNoPath(), G4Colour::GetRed(), G4UImanager::GetUIpointer(), G4VisAttributes::SetColour(), and G4ModelingParameters::VASColour.

Referenced by G4OpenGLQtViewer::changeColorAndTransparency().

◆ TouchableSetVisibility()

void G4VViewer::TouchableSetVisibility	(	const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &	fullPath,
		G4bool	visibility
	)

protectedinherited

Definition at line 146 of file G4VViewer.cc.

{
  // Changes the Vis Attribute Modifiers WITHOUT triggering a rebuild.
 
  std::ostringstream oss;
  oss << "/vis/touchable/set/visibility ";
  if (visibiity) oss << "true"; else oss << "false";
 
  // The following is equivalent to
  //  G4UImanager::GetUIpointer()->ApplyCommand(oss.str());
  // (assuming the touchable has already been set), but avoids view rebuild.
 
  // Instantiate a working copy of a G4VisAttributes object...
  G4VisAttributes workingVisAtts;
  // and set the visibility.
  workingVisAtts.SetVisibility(visibiity);
 
  fVP.AddVisAttributesModifier
  (G4ModelingParameters::VisAttributesModifier
   (workingVisAtts,
    G4ModelingParameters::VASVisibility,
    G4PhysicalVolumeModel::GetPVNameCopyNoPath(fullPath)));
  // G4ModelingParameters::VASVisibility (VAS = Vis Attribute Signifier)
  // signifies that it is the visibility that should be picked out
  // and merged with the touchable's normal vis attributes.
 
  // Record on G4cout (with #) for information.
  if (G4UImanager::GetUIpointer()->GetVerboseLevel() >= 2) {
    G4cout << "# " << oss.str() << G4endl;
  }
}

References G4ViewParameters::AddVisAttributesModifier(), G4VViewer::fVP, G4cout, G4endl, G4PhysicalVolumeModel::GetPVNameCopyNoPath(), G4UImanager::GetUIpointer(), G4VisAttributes::SetVisibility(), and G4ModelingParameters::VASVisibility.

Referenced by G4OpenGLQtViewer::setCheckComponent().

◆ updateKeyModifierState()

void G4OpenGLQtViewer::updateKeyModifierState ( const Qt::KeyboardModifiers & modifier )

protectedinherited

Definition at line 1739 of file G4OpenGLQtViewer.cc.

                                                                                  {
  // Check Qt Versions for META Keys
 
  fNoKeyPress = true;
  fAltKeyPress = false;
  fShiftKeyPress = false;
  fControlKeyPress = false;
 
  if (modifier & Qt::AltModifier ) {
    fAltKeyPress = true;
    fNoKeyPress = false;
  }
  if (modifier & Qt::ShiftModifier ) {
    fShiftKeyPress = true;
    fNoKeyPress = false;
  }
  if (modifier & Qt::ControlModifier ) {
    fControlKeyPress = true;
    fNoKeyPress = false;
  }
}

References G4OpenGLQtViewer::fAltKeyPress, G4OpenGLQtViewer::fControlKeyPress, G4OpenGLQtViewer::fNoKeyPress, and G4OpenGLQtViewer::fShiftKeyPress.

Referenced by G4OpenGLQtViewer::G4keyPressEvent(), and G4OpenGLQtViewer::G4MouseMoveEvent().

◆ updatePickInfosWidget()

void G4OpenGLQtViewer::updatePickInfosWidget	(	int	aX,
		int	aY
	)

inherited

Update the pick infos component widget

Definition at line 4527 of file G4OpenGLQtViewer.cc.

                                                           {
  fLastPickPoint = QPoint(aX,aY);
 
  if (!isCurrentWidget()) {
    return;
  }
  // Ensure case where closing a UI tab close the widget
  if (!fPickInfosWidget) {
    createPickInfosWidget();
  }
 
  const std::vector < G4OpenGLViewerPickMap* > & pickMapVector = GetPickDetails(aX,aY);
 
  // remove all previous widgets
  if (fPickInfosWidget) {
    QLayoutItem * wItem;
    if (fPickInfosWidget->layout()->count()) {
      while ((wItem = fPickInfosWidget->layout()->takeAt(0)) != 0) {
        delete wItem->widget();
        delete wItem;
      }
    }
  } else {
    // Ensure case where closing a UI tab close the widget
    if (!fPickInfosWidget) {
      createPickInfosWidget();
    }
  }
 
  // Create a new signalMapper
#if QT_VERSION < 0x050600
  delete fSignalMapperPicking;
  fSignalMapperPicking = new QSignalMapper(this);
#endif
 
  // parse all pick results
  G4int nPickedObjectsWithAttributes = 0;
  for (unsigned int a=0; a< pickMapVector.size(); a++) {
    const auto& pickMap = pickMapVector[a];
    // Add a box inside the pick viewer box
    std::ostringstream label;
    std::ostringstream content;
    std::string txt = pickMap->getAttributes()[0].data();
    if (pickMapVector[a]->getAttributes().size()) {
      ++nPickedObjectsWithAttributes;
 
      std::size_t pos1 = txt.find(':');
      std::string storeKey = txt.substr(0,pos1);
 
      if (storeKey == "G4PhysicalVolumeModel") {
 
        label << "Volume:";
        std::size_t pos2 = txt.find(':',pos1+1);
        std::size_t pos3 = txt.find('\n',pos2+1);
        label << txt.substr(pos2+1,pos3-pos2-1);
 
      } else if (storeKey == "G4TrajectoriesModel") {
 
        label << "Trajectory:";
        std::size_t pos2 = txt.find(':',pos1+1);
        std::size_t pos3 = txt.find('\n',pos2+1);
        label << " Run:" << txt.substr(pos2+1,pos3-pos2-1);
        std::size_t pos4 = txt.find(':',pos3+1);
        std::size_t pos5 = txt.find('\n',pos4+1);
        label << ", Event:" << txt.substr(pos4+1,pos5-pos4-1);
 
      } else {
 
        label << "Hit number:" << a << ", PickName: " << pickMap->getPickName();
 
      }
 
      // Accumulate all content with the same pickname
      content << pickMap->print().data();
      G4int thisPickName = pickMap->getPickName();
      while (++a < pickMapVector.size()) {
        const auto& a_pickMap = pickMapVector[a];
        if (a_pickMap->getPickName() == thisPickName) {
          content << a_pickMap->print().data();
        } else {
          a--;
          break;
        }
      }
 
      QPushButton* pickCoutButton = new QPushButton(label.str().c_str());
      pickCoutButton->setStyleSheet ("text-align: left; padding: 1px; border: 0px;");
      pickCoutButton->setIcon(*fTreeIconClosed);
      fPickInfosWidget->layout()->addWidget(pickCoutButton);
 
      QStringList newStr;
 
      // Add to stringList
      newStr = QStringList(QString(content.str().c_str()).trimmed());
 
      QTextEdit* ed = new QTextEdit();
      ed->setReadOnly(true);
      fPickInfosWidget->layout()->addWidget(ed);
      ed->setVisible((false));
      ed->append(newStr.join(""));
 
#if QT_VERSION < 0x050600
      connect(pickCoutButton, SIGNAL(clicked()), fSignalMapperPicking, SLOT(map()));
      fSignalMapperPicking->setMapping(pickCoutButton,fPickInfosWidget->layout()->count()-1);
#else
      std::cout << pickCoutButton->text().toStdString() << " "<< fPickInfosWidget->layout()->count()-1<< std::endl;
      int tmp = fPickInfosWidget->layout()->count()-1;
      connect(pickCoutButton, &QPushButton::clicked , [this, tmp](){ this->toggleSceneTreeComponentPickingCout(tmp);});
#endif
    }
  }
#if QT_VERSION < 0x050600
  connect(fSignalMapperPicking, SIGNAL(mapped(int)),this, SLOT(toggleSceneTreeComponentPickingCout(int)));
#endif
 
  // add a label to push everything up!
  QLabel * pushUp = new QLabel("");
  QSizePolicy vPolicy = QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
  vPolicy.setVerticalStretch(10);
  pushUp->setSizePolicy(vPolicy);
  fPickInfosWidget->layout()->addWidget(pushUp);
 
  // highlight the first one :
 
  // first un-highlight the last selected
  changeColorAndTransparency(fLastHighlightName,fLastHighlightColor);
 
  if (pickMapVector.size() > 0 ) {
    // get the new one
    fLastHighlightName = pickMapVector[0]->getPickName();
    fLastHighlightColor = getColorForPoIndex(fLastHighlightName);
    // set the new one
    changeColorAndTransparency(fLastHighlightName,G4Color(1,1,1,1));
 
    updateQWidget();
  }
  QDialog* dial = static_cast<QDialog*> (fUIPickInfosWidget->parent());
  if (dial) {
    // change name
    std::ostringstream oss;
    if (nPickedObjectsWithAttributes == 0) {
      oss << "No object";
    } else if (nPickedObjectsWithAttributes == 1) {
      oss << "1 object";
    } else {
      oss << nPickedObjectsWithAttributes << " objects";
    }
    oss << " selected - " << GetName();
    dial->setWindowTitle(oss.str().c_str());
  }
  // set picking cout visible
  fPickInfosScrollArea->setVisible(true);
}

Referenced by G4OpenGLQtViewer::createPickInfosWidget(), and G4OpenGLQtViewer::G4MouseReleaseEvent().

◆ updatePositivePoIndexSceneTreeWidgetQuickMap()

void G4OpenGLQtViewer::updatePositivePoIndexSceneTreeWidgetQuickMap	(	int	POindex,
		QTreeWidgetItem *	item
	)

privateinherited

Update the quick scene tree visibility map (used by parseAndCheckVisibility)

Definition at line 3968 of file G4OpenGLQtViewer.cc.

                                                                                                      {
 
   // Check state
   std::map <int, QTreeWidgetItem*>::iterator i;
   i = fPositivePoIndexSceneTreeWidgetQuickMap.find(POindex);
 
   if (i == fPositivePoIndexSceneTreeWidgetQuickMap.end()) {
     fPositivePoIndexSceneTreeWidgetQuickMap.insert(std::pair <int, QTreeWidgetItem*> (POindex,item) );
     fLastSceneTreeWidgetAskForIterator = fPositivePoIndexSceneTreeWidgetQuickMap.end();
     fLastSceneTreeWidgetAskForIteratorEnd = fPositivePoIndexSceneTreeWidgetQuickMap.end();
   } else {
     i->second = item;
   }
 }

References G4OpenGLQtViewer::fLastSceneTreeWidgetAskForIterator, G4OpenGLQtViewer::fLastSceneTreeWidgetAskForIteratorEnd, and G4OpenGLQtViewer::fPositivePoIndexSceneTreeWidgetQuickMap.

Referenced by G4OpenGLQtViewer::changeDepthOnSceneTreeItem(), G4OpenGLQtViewer::changeQColorForTreeWidgetItem(), G4OpenGLQtViewer::createTreeWidgetItem(), G4OpenGLQtViewer::parseAndInsertInSceneTree(), and G4OpenGLQtViewer::setCheckComponent().

◆ updateQWidget()

void G4OpenGLStoredQtViewer::updateQWidget ( )

virtual

Implements G4OpenGLQtViewer.

Definition at line 410 of file G4OpenGLStoredQtViewer.cc.

                                           {
  if (fUpdateGLLock) {
    return;
  }
  
  if (! isCurrentWidget()){
    return;
  }
 
  fUpdateGLLock = true;
  fHasToRepaint= true;
  // Will really update the widget by calling CGLFlushDrawable
  // The widget's rendering context will become the current context and initializeGL()
  // will be called if it hasn't already been called.
  // Copies the back buffer of a double-buffered context to the front buffer.
  repaint(); // will read scene tree state
  // updateGL() // From J.Allison picking branch
  updateViewerPropertiesTableWidget();
  updateSceneTreeWidget();
  fUpdateGLLock = false;
}

References G4OpenGLQtViewer::fHasToRepaint, G4OpenGLQtViewer::fUpdateGLLock, G4OpenGLQtViewer::isCurrentWidget(), G4OpenGLQtViewer::updateSceneTreeWidget(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

Referenced by DrawView().

◆ updateSceneTreeWidget()

void G4OpenGLQtViewer::updateSceneTreeWidget ( )

inherited

Update the scene tree widget

Definition at line 4208 of file G4OpenGLQtViewer.cc.

                                             {
  // Ensure case where closing a UI tab close the widget
  if (!fSceneTreeWidget) {
    createSceneTreeWidget();
  }
}

References G4OpenGLQtViewer::createSceneTreeWidget(), and G4OpenGLQtViewer::fSceneTreeWidget.

Referenced by G4OpenGLImmediateQtViewer::updateQWidget(), and updateQWidget().

◆ updateToolbarAndMouseContextMenu

void G4OpenGLQtViewer::updateToolbarAndMouseContextMenu ( )

protectedslotinherited

Update the toolbar Icons/Mouse context menu

Change ortho/perspective
Change surface style
Change cursor style

Definition at line 4107 of file G4OpenGLQtViewer.cc.

                                                       {
   if (fBatchMode) {
     return;
   }
 
  G4ViewParameters::DrawingStyle
  d_style = fVP.GetDrawingStyle();
 
  // Surface style
  if (d_style == G4ViewParameters::wireframe) {
    if (fUiQt) fUiQt->SetIconWireframeSelected();
    if (fContextMenu) {
      fDrawingWireframe->setChecked(true);
      fDrawingLineRemoval->setChecked(false);
      fDrawingSurfaceRemoval->setChecked(false);
      fDrawingLineSurfaceRemoval->setChecked(false);
    }
  } else if (d_style == G4ViewParameters::hlr) {
    if (fUiQt) fUiQt->SetIconHLRSelected();
    if (fContextMenu) {
      fDrawingLineRemoval->setChecked(true);
      fDrawingWireframe->setChecked(false);
      fDrawingSurfaceRemoval->setChecked(false);
      fDrawingLineSurfaceRemoval->setChecked(false);
    }
  } else if (d_style == G4ViewParameters::hsr) {
    if (fUiQt) fUiQt->SetIconSolidSelected();
    if (fContextMenu) {
      fDrawingSurfaceRemoval->setChecked(true);
      fDrawingWireframe->setChecked(false);
      fDrawingLineRemoval->setChecked(false);
      fDrawingLineSurfaceRemoval->setChecked(false);
    }
  } else if (d_style == G4ViewParameters::hlhsr) {
    if (fUiQt) fUiQt->SetIconHLHSRSelected();
    if (fContextMenu) {
      fDrawingLineSurfaceRemoval->setChecked(true);
      fDrawingWireframe->setChecked(false);
      fDrawingLineRemoval->setChecked(false);
      fDrawingSurfaceRemoval->setChecked(false);
      fDrawingLineSurfaceRemoval->setChecked(false);
    }
  }
 
 
  // projection style
  G4double d_proj = fVP.GetFieldHalfAngle () ;
  if (d_proj == 0.) { // ortho
    if (fUiQt) fUiQt->SetIconOrthoSelected();
    if (fContextMenu) {
      fProjectionOrtho->setChecked(true);
      fProjectionPerspective->setChecked(false);
    }
  } else {
    if (fUiQt) fUiQt->SetIconPerspectiveSelected();
      if (fContextMenu) {
        fProjectionPerspective->setChecked(true);
        fProjectionOrtho->setChecked(false);
      }
  }
 
 
  // mouse style : They are controlled by UI !
  if (fUiQt && fContextMenu) {
    if (fUiQt->IsIconPickSelected()) {
      fMousePickAction->setChecked(true);
      fMouseZoomOutAction->setChecked(false);
      fMouseZoomInAction->setChecked(false);
      fMouseRotateAction->setChecked(false);
      fMouseMoveAction->setChecked(false);
    } else if (fUiQt->IsIconZoomOutSelected()) {
      fMouseZoomOutAction->setChecked(true);
      fMousePickAction->setChecked(false);
      fMouseZoomInAction->setChecked(false);
      fMouseRotateAction->setChecked(false);
      fMouseMoveAction->setChecked(false);
    } else if (fUiQt->IsIconZoomInSelected()) {
      fMouseZoomInAction->setChecked(true);
      fMousePickAction->setChecked(false);
      fMouseZoomOutAction->setChecked(false);
      fMouseRotateAction->setChecked(false);
      fMouseMoveAction->setChecked(false);
    } else if (fUiQt->IsIconRotateSelected()) {
      fMouseRotateAction->setChecked(true);
      fMousePickAction->setChecked(false);
      fMouseZoomOutAction->setChecked(false);
      fMouseZoomInAction->setChecked(false);
      fMouseMoveAction->setChecked(false);
    } else if (fUiQt->IsIconMoveSelected()) {
      fMouseMoveAction->setChecked(true);
      fMousePickAction->setChecked(false);
      fMouseZoomOutAction->setChecked(false);
      fMouseZoomInAction->setChecked(false);
      fMouseRotateAction->setChecked(false);
    }
  }
}

◆ updateViewerPropertiesTableWidget()

void G4OpenGLQtViewer::updateViewerPropertiesTableWidget ( )

inherited

Update the viewer properties component widget Clear it only if the number of command is less than the previous table widget row count

Definition at line 4220 of file G4OpenGLQtViewer.cc.

                                                         {
 
  if (!isCurrentWidget()) {
    return;
  }
 
  // Ensure case where closing a UI tab close the widget
  if (!fViewerPropertiesTableWidget) {
    createViewerPropertiesWidget();
  }
  int treeWidgetInfosIgnoredCommands = 0;
  G4UImanager* UI = G4UImanager::GetUIpointer();
  G4UIcommandTree * commandTreeTop = UI->GetTree();
  G4UIcommandTree* path = commandTreeTop->FindCommandTree("/vis/viewer/set/");
 
  if (!path) {
    return;
  }
 
  // clear old table
  if ((path->GetCommandEntry()-fTreeWidgetInfosIgnoredCommands) != fViewerPropertiesTableWidget->rowCount()) {
    fViewerPropertiesTableWidget->clear();
  }
 
  fViewerPropertiesTableWidget->blockSignals(true);
  // TODO : Could be optimized by comparing current command to old commands. That should not change so much
 
  fViewerPropertiesTableWidget->setColumnCount (2);
  fViewerPropertiesTableWidget->setRowCount (path->GetCommandEntry()-fTreeWidgetInfosIgnoredCommands);
  fViewerPropertiesTableWidget->setHorizontalHeaderLabels(QStringList() << tr("Property")
                                                        << tr("Value"));
  fViewerPropertiesTableWidget->verticalHeader()->setVisible(false);
  fViewerPropertiesTableWidget->setAlternatingRowColors (true);
 
  // For the moment, we do only command that have a "set" command in UI
 
  for (int a=0;a<path->GetCommandEntry();a++) {
    G4UIcommand* commandTmp = path->GetCommand(a+1);
 
    // get current parameters
    QString params = "";
 
    if(commandTmp->GetCommandName() == "autoRefresh") {
      if (fVP.IsAutoRefresh()) {
        params = "True";
      } else {
        params = "False";
      }
    } else if(commandTmp->GetCommandName() == "auxiliaryEdge") {
      if (fVP.IsAuxEdgeVisible()) {
        params = "True";
      } else {
        params = "False";
      }
    } else if(commandTmp->GetCommandName() == "background") {
      params = QString().number(fVP.GetBackgroundColour().GetRed()) + "  "+
      QString().number(fVP.GetBackgroundColour().GetGreen()) + "  "+
      QString().number(fVP.GetBackgroundColour().GetBlue()) + "  "+
      QString().number(fVP.GetBackgroundColour().GetAlpha());
 
    } else if(commandTmp->GetCommandName() == "culling") {
      params = QString().number(fVP. IsCulling ());
    } else if(commandTmp->GetCommandName() == "cutawayMode") {
      if (fVP.GetCutawayMode() == G4ViewParameters::cutawayUnion) {
        params = "union";
      } else {
        params = "intersection";
      }
 
    } else if(commandTmp->GetCommandName() == "defaultColour") {
      params = QString().number(fVP.GetDefaultVisAttributes()->GetColor().GetRed()) + "  "+
      QString().number(fVP.GetDefaultVisAttributes()->GetColor().GetGreen()) + "  "+
      QString().number(fVP.GetDefaultVisAttributes()->GetColor().GetBlue()) + "  "+
      QString().number(fVP.GetDefaultVisAttributes()->GetColor().GetAlpha());
 
    } else if(commandTmp->GetCommandName() == "defaultTextColour") {
      params = QString().number(fVP.GetDefaultTextVisAttributes()->GetColor().GetRed()) + "  "+
      QString().number(fVP.GetDefaultTextVisAttributes()->GetColor().GetGreen()) + "  "+
      QString().number(fVP.GetDefaultTextVisAttributes()->GetColor().GetBlue()) + "  "+
      QString().number(fVP.GetDefaultTextVisAttributes()->GetColor().GetAlpha());
 
    } else if(commandTmp->GetCommandName() == "edge") {
      G4ViewParameters::DrawingStyle existingStyle = fVP.GetDrawingStyle();
      params = "False";
      if (existingStyle == G4ViewParameters::hsr) {
        params = "True";
      }
 
    } else if(commandTmp->GetCommandName() == "explodeFactor") {
      params = QString().number(fVP.GetExplodeFactor()) +  "  " + QString(G4String(G4BestUnit(fVP.GetExplodeFactor(),"Length")).data());
 
    } else if(commandTmp->GetCommandName() == "globalLineWidthScale") {
      params = QString().number(fVP.GetGlobalLineWidthScale());
 
    } else if(commandTmp->GetCommandName() == "globalMarkerScale") {
      params = QString().number(fVP.GetGlobalMarkerScale());
 
    } else if(commandTmp->GetCommandName() == "hiddenEdge") {
      G4ViewParameters::DrawingStyle style = fVP.GetDrawingStyle();
      if ((style == G4ViewParameters::hlr) ||
          (style == G4ViewParameters::hlhsr)) {
        params = "True";
      } else {
        params = "False";
      }
 
    } else if(commandTmp->GetCommandName() == "hiddenMarker") {
      if (fVP.IsMarkerNotHidden()) {
        params = "False";
      } else {
        params = "True";
      }
 
    } else if(commandTmp->GetCommandName() == "lightsMove") {
      if (fVP.GetLightsMoveWithCamera()) {
        params = "camera";
      } else {
        params = "object";
      }
    } else if(commandTmp->GetCommandName() == "lightsThetaPhi") {
      G4Vector3D direction = fVP.GetLightpointDirection();
      // degree
      params = QString().number(direction.theta()/CLHEP::degree)+ "  "+ QString().number(direction.phi()/CLHEP::degree)+"  deg";
      if (commandTmp->GetParameterEntries() == 3) {
        if (commandTmp->GetParameter(2)->GetDefaultValue() != "deg") {
          params = QString().number(direction.theta())+ "  "+ QString().number(direction.phi())+" "+commandTmp->GetParameter(2)->GetDefaultValue().data();
        }
      }
    } else if(commandTmp->GetCommandName() == "lightsVector") {
     params = QString().number(fVP.GetLightpointDirection().x()) + "  "+
      QString().number(fVP.GetLightpointDirection().y()) + "  "+
      QString().number(fVP.GetLightpointDirection().z());
 
    } else if(commandTmp->GetCommandName() == "lineSegmentsPerCircle") {
      params = QString().number(fVP.GetNoOfSides());
 
    } else if(commandTmp->GetCommandName() == "picking") {
      if (fVP.IsPicking()) {
        params = "True";
      } else {
        params = "False";
      }
 
    } else if(commandTmp->GetCommandName() == "projection") {
      if (fVP.GetFieldHalfAngle() == 0.) {
        params = "orthogonal";
      } else {
        params = QString("perspective ") + QString().number(fVP.GetFieldHalfAngle()/CLHEP::degree) + " deg";
      }
 
    } else if(commandTmp->GetCommandName() == "rotationStyle") {
      if (fVP.GetRotationStyle() == G4ViewParameters::constrainUpDirection) {
        params = "constrainUpDirection";
      } else {
        params = "freeRotation";
      }
 
    } else if(commandTmp->GetCommandName() == "sectionPlane") {
      if (fVP.IsSection()) {
        params =  QString("on ") +
        G4String(G4BestUnit(fVP.GetSectionPlane().point(),"Length")).data()+
        QString().number(fVP.GetSectionPlane().normal().x())
        + " " + QString().number(fVP.GetSectionPlane().normal().y())
        + " " + QString().number(fVP.GetSectionPlane().normal().z());
      } else {
        params = "off";
      }
 
    } else if(commandTmp->GetCommandName() == "style") {
      if (fVP.GetDrawingStyle() == G4ViewParameters::wireframe || fVP.GetDrawingStyle() == G4ViewParameters::hlr) {
         params = "wireframe";
      } else {
        params = "surface";
      }
 
 
    } else if(commandTmp->GetCommandName() == "targetPoint") {
      G4Point3D point = fVP.GetCurrentTargetPoint();
      if (fSceneHandler.GetScene()) {
        G4String b = G4BestUnit(fSceneHandler.GetScene()->GetStandardTargetPoint() + fVP.GetCurrentTargetPoint(),"Length");
        params = b.data();
      }
    } else if(commandTmp->GetCommandName() == "upThetaPhi") {
      G4Vector3D up = fVP.GetUpVector();
      // degree
      params = QString().number(up.theta()/CLHEP::degree)+ "  "+ QString().number(up.phi()/CLHEP::degree)+"  deg";
      if (commandTmp->GetParameterEntries() == 3) {
        if (commandTmp->GetParameter(2)->GetDefaultValue() != "deg") {
          params = QString().number(up.theta())+ "  "+ QString().number(up.phi())+" "+commandTmp->GetParameter(2)->GetDefaultValue().data();
        }
      }
    } else if(commandTmp->GetCommandName() == "upVector") {
      G4Vector3D up = fVP.GetUpVector();
      params = QString().number(up.x())+ "  "+ QString().number(up.y())+"  "+QString().number(up.z())+ "  ";
 
    } else if(commandTmp->GetCommandName() == "viewpointThetaPhi") {
      G4Vector3D direction = fVP.GetViewpointDirection();
      // degree
      params = QString().number(direction.theta()/CLHEP::degree)+ "  "+ QString().number(direction.phi()/CLHEP::degree)+"  deg";
      if (commandTmp->GetParameterEntries() == 3) {
        if (commandTmp->GetParameter(2)->GetDefaultValue() != "deg") {
          params = QString().number(direction.theta())+ "  "+ QString().number(direction.phi())+" "+commandTmp->GetParameter(2)->GetDefaultValue().data();
        }
      }
    } else if(commandTmp->GetCommandName() == "viewpointVector") {
      G4Vector3D direction = fVP.GetViewpointDirection();
      params = QString().number(direction.x())+ "  "+ QString().number(direction.y())+" "+QString().number(direction.z());
    } else {
      // No help
    }
 
    /* DO NOT DISPLAY COMMANDS WITHOUT ANY PARAMETERS SET
    if (params == "") {
      // TODO : display default parameters // should not be editable ?
 
      for( G4int i_thParameter=0; i_thParameter<commandTmp->GetParameterEntries(); i_thParameter++ ) {
        commandParam = commandTmp->GetParameter(i_thParameter);
 
        if (QString(QChar(commandParam->GetParameterType())) == "b") {
          if (commandParam->GetDefaultValue().data()) {
            params += "True";
          } else {
            params += "False";
          }
        } else {
          params += QString((char*)(commandParam->GetDefaultValue()).data());
        }
        if (i_thParameter<commandTmp->GetParameterEntries()-1) {
          params += " ";
        }
      }
    }
    */
 
    if (params != "") {
 
      QTableWidgetItem *nameItem;
      QTableWidgetItem *paramItem;
 
      // already present ?
      QList<QTableWidgetItem *> list = fViewerPropertiesTableWidget->findItems (commandTmp->GetCommandName().data(),Qt::MatchExactly);
      if (list.size() == 1) {
        nameItem = list.first();
        paramItem = fViewerPropertiesTableWidget->item(nameItem->row(),1);
 
      } else {
        nameItem = new QTableWidgetItem();
        paramItem = new QTableWidgetItem();
        fViewerPropertiesTableWidget->setItem(a-treeWidgetInfosIgnoredCommands, 0, nameItem);
        fViewerPropertiesTableWidget->setItem(a-treeWidgetInfosIgnoredCommands, 1, paramItem);
 
        // Set Guidance
        QString guidance;
        G4int n_guidanceEntry = commandTmp->GetGuidanceEntries();
        for( G4int i_thGuidance=0; i_thGuidance < n_guidanceEntry; i_thGuidance++ ) {
          guidance += QString((char*)(commandTmp->GetGuidanceLine(i_thGuidance)).data()) + "\n";
        }
 
        nameItem->setToolTip(guidance);
        paramItem->setToolTip(GetCommandParameterList(commandTmp));
 
        fViewerPropertiesTableWidget->setRowHeight(a-treeWidgetInfosIgnoredCommands,15);
      }
 
      // set current name and parameters
      nameItem->setText(commandTmp->GetCommandName().data());
      paramItem->setText(params);
 
      nameItem->setFlags(Qt::NoItemFlags);
      nameItem->setForeground(QBrush());
 
    } else {
      treeWidgetInfosIgnoredCommands++;
    }
  }
  // remove empty content row
  for (int i=0; i<treeWidgetInfosIgnoredCommands; i++) {
    fViewerPropertiesTableWidget->removeRow (fViewerPropertiesTableWidget->rowCount() - 1);
  }
 
  // The resize should done only at creation
  if (!fViewerPropertiesTableWidgetIsInit) {
    fViewerPropertiesTableWidgetIsInit = true;
 
    fViewerPropertiesTableWidget->resizeColumnsToContents();
 
    int x = fViewerPropertiesTableWidget->horizontalHeader()->length();
    int y = fViewerPropertiesTableWidget->verticalHeader()->length()+ fViewerPropertiesTableWidget->horizontalHeader()->sizeHint().height() + 2;
 
    //  fViewerPropertiesTableWidget->verticalHeader()->setResizeMode(QHeaderView::ResizeToContents);
    //  fViewerPropertiesTableWidget->horizontalHeader()->setResizeMode(QHeaderView::ResizeToContents);
 
    // resize to fit content
    QDialog* dial = static_cast<QDialog*> (fUIViewerPropertiesWidget->parent());
    if (dial) {
      dial->resize(x+56,y+46); // more or less (margins) ...
    }
  }
  fViewerPropertiesTableWidget->blockSignals(false);
 
  fTreeWidgetInfosIgnoredCommands = treeWidgetInfosIgnoredCommands;
}

Referenced by G4OpenGLQtViewer::createViewerPropertiesWidget(), G4OpenGLImmediateQtViewer::updateQWidget(), and updateQWidget().

◆ wheelEvent()

void G4OpenGLStoredQtViewer::wheelEvent ( QWheelEvent * event )

protected

Definition at line 373 of file G4OpenGLStoredQtViewer.cc.

{
  G4wheelEvent(event);
}

References G4OpenGLQtViewer::G4wheelEvent().

Field Documentation

◆ antialiasing_enabled

G4bool G4OpenGLViewer::antialiasing_enabled

protectedinherited

Definition at line 201 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::antialias_callback(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::toggleAntialiasing().

◆ background

G4Colour G4OpenGLViewer::background

protectedinherited

Definition at line 198 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::ClearViewWithoutFlush(), G4OpenGLXmViewer::CreateMainWindow(), and G4OpenGLViewer::SetView().

◆ fAltKeyPress

bool G4OpenGLQtViewer::fAltKeyPress

privateinherited

Definition at line 323 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MouseReleaseEvent(), and G4OpenGLQtViewer::updateKeyModifierState().

◆ fAutoMove

bool G4OpenGLQtViewer::fAutoMove

privateinherited

Definition at line 288 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::G4MouseReleaseEvent(), and G4OpenGLQtViewer::moveScene().

◆ fBatchMode

bool G4OpenGLQtViewer::fBatchMode

privateinherited

Definition at line 326 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::G4OpenGLQtViewer(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fCheckSceneTreeComponentSignalLock

bool G4OpenGLQtViewer::fCheckSceneTreeComponentSignalLock

privateinherited

Definition at line 327 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::changeDepthInSceneTree(), and G4OpenGLQtViewer::sceneTreeComponentItemChanged().

◆ fContextMenu

QMenu* G4OpenGLQtViewer::fContextMenu

privateinherited

Definition at line 272 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::createPopupMenu(), G4OpenGLQtViewer::G4manageContextMenuEvent(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fControlKeyPress

bool G4OpenGLQtViewer::fControlKeyPress

privateinherited

Definition at line 324 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLQtViewer::G4MouseMoveEvent(), and G4OpenGLQtViewer::updateKeyModifierState().

◆ fDefaultExportFilename

G4String G4OpenGLViewer::fDefaultExportFilename

privateinherited

Definition at line 220 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::G4OpenGLViewer().

◆ fDefaultExportImageFormat

std::string G4OpenGLViewer::fDefaultExportImageFormat

protectedinherited

Definition at line 210 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage().

◆ fDefaultVP

G4ViewParameters G4VViewer::fDefaultVP

protectedinherited

Definition at line 220 of file G4VViewer.hh.

Referenced by G4ASCIITreeViewer::G4ASCIITreeViewer(), G4HepRepFileViewer::G4HepRepFileViewer(), G4OpenGLStoredViewer::G4OpenGLStoredViewer(), G4OpenGLViewer::G4OpenGLViewer(), G4OpenInventorViewer::G4OpenInventorViewer(), G4VtkViewer::G4VtkViewer(), G4VViewer::G4VViewer(), G4Qt3DViewer::Initialise(), G4RayTracerXViewer::Initialise(), and G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise().

◆ fDeltaDepth

G4double G4OpenGLQtViewer::fDeltaDepth

privateinherited

Definition at line 279 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::moveScene(), and G4OpenGLQtViewer::ResetView().

◆ fDeltaZoom

G4double G4OpenGLQtViewer::fDeltaZoom

privateinherited

Definition at line 281 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4keyPressEvent(), and G4OpenGLQtViewer::ResetView().

◆ fDepthTestEnable

G4bool G4OpenGLStoredViewer::fDepthTestEnable

protectedinherited

Definition at line 70 of file G4OpenGLStoredViewer.hh.

Referenced by G4OpenGLStoredViewer::DrawDisplayLists().

◆ fDrawingLineRemoval

QAction* G4OpenGLQtViewer::fDrawingLineRemoval

privateinherited

Definition at line 302 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fDrawingLineSurfaceRemoval

QAction* G4OpenGLQtViewer::fDrawingLineSurfaceRemoval

privateinherited

Definition at line 304 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fDrawingSurfaceRemoval

QAction* G4OpenGLQtViewer::fDrawingSurfaceRemoval

privateinherited

Definition at line 303 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fDrawingWireframe

QAction* G4OpenGLQtViewer::fDrawingWireframe

privateinherited

Definition at line 301 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fEncoderPath

QString G4OpenGLQtViewer::fEncoderPath

privateinherited

Definition at line 289 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::encodeVideo(), G4OpenGLQtViewer::getEncoderPath(), G4OpenGLQtViewer::processLookForFinished(), and G4OpenGLQtViewer::setEncoderPath().

◆ fExportFilename

G4String G4OpenGLViewer::fExportFilename

privateinherited

Definition at line 219 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::G4OpenGLViewer(), G4OpenGLViewer::getRealPrintFilename(), and G4OpenGLViewer::setExportFilename().

◆ fExportFilenameIndex

int G4OpenGLViewer::fExportFilenameIndex

protectedinherited

Definition at line 212 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::exportImage(), G4OpenGLViewer::getRealPrintFilename(), G4OpenGLViewer::setExportFilename(), and G4OpenGLViewer::setExportImageFormat().

◆ fExportImageFormat

std::string G4OpenGLViewer::fExportImageFormat

protectedinherited

Definition at line 211 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLViewer::exportImage(), G4OpenGLViewer::getRealPrintFilename(), and G4OpenGLViewer::setExportImageFormat().

◆ fExportImageFormatVector

std::vector< std::string > G4OpenGLViewer::fExportImageFormatVector

protectedinherited

Definition at line 209 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLViewer::addExportImageFormat(), and G4OpenGLViewer::setExportImageFormat().

◆ fFileSavePath

QString G4OpenGLQtViewer::fFileSavePath

privateinherited

Definition at line 334 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage(), and G4OpenGLQtViewer::G4OpenGLQtViewer().

◆ fFilterOutput

QLineEdit* G4OpenGLQtViewer::fFilterOutput

privateinherited

Definition at line 333 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::changeSearchSelection(), and G4OpenGLQtViewer::createSceneTreeComponent().

◆ fFullScreenOff

QAction* G4OpenGLQtViewer::fFullScreenOff

privateinherited

Definition at line 300 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ fFullScreenOn

QAction* G4OpenGLQtViewer::fFullScreenOn

privateinherited

Definition at line 299 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu().

◆ fG4OpenGLStoredSceneHandler

G4OpenGLStoredSceneHandler& G4OpenGLStoredViewer::fG4OpenGLStoredSceneHandler

protectedinherited

Definition at line 62 of file G4OpenGLStoredViewer.hh.

Referenced by G4OpenGLStoredViewer::AddPrimitiveForASingleFrame(), G4OpenGLStoredViewer::DrawDisplayLists(), and G4OpenGLStoredViewer::KernelVisitDecision().

◆ fGL2PSAction

G4OpenGL2PSAction* G4OpenGLViewer::fGL2PSAction

protectedinherited

Definition at line 203 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::ChangeLineWidth(), G4OpenGLViewer::ChangePointSize(), G4OpenGLViewer::exportImage(), G4OpenGLViewer::G4OpenGLViewer(), G4OpenGLViewer::isGl2psWriting(), G4OpenGLViewer::printGl2PS(), and G4OpenGLViewer::~G4OpenGLViewer().

◆ fGl2psDefaultLineWith

int G4OpenGLViewer::fGl2psDefaultLineWith

privateinherited

Definition at line 222 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::printGl2PS().

◆ fGl2psDefaultPointSize

int G4OpenGLViewer::fGl2psDefaultPointSize

privateinherited

Definition at line 223 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::printGl2PS().

◆ fGlViewInitialized

bool G4OpenGLViewer::fGlViewInitialized

privateinherited

Definition at line 224 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::InitializeGLView().

◆ fGLWidget

QWidget* G4OpenGLQtViewer::fGLWidget

protectedinherited

Definition at line 187 of file G4OpenGLQtViewer.hh.

◆ fHasToRepaint

bool G4OpenGLQtViewer::fHasToRepaint

protectedinherited

Definition at line 191 of file G4OpenGLQtViewer.hh.

◆ fHoldKeyEvent

bool G4OpenGLQtViewer::fHoldKeyEvent

privateinherited

Definition at line 283 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4keyPressEvent().

◆ fHoldMoveEvent

bool G4OpenGLQtViewer::fHoldMoveEvent

privateinherited

Definition at line 285 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::moveScene().

◆ fHoldRotateEvent

bool G4OpenGLQtViewer::fHoldRotateEvent

privateinherited

Definition at line 287 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::rotateQtScene(), and G4OpenGLQtViewer::rotateQtSceneToggle().

◆ fIsDeleting

bool G4OpenGLQtViewer::fIsDeleting

privateinherited

Definition at line 383 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4MouseReleaseEvent(), and G4OpenGLQtViewer::~G4OpenGLQtViewer().

◆ fIsGettingPickInfos

bool G4OpenGLViewer::fIsGettingPickInfos

privateinherited

Definition at line 241 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::GetPickDetails(), and G4OpenGLViewer::SetView().

◆ fLastEventTime

QTime* G4OpenGLQtViewer::fLastEventTime

privateinherited

Definition at line 311 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::G4MouseReleaseEvent(), and G4OpenGLQtViewer::G4OpenGLQtViewer().

◆ fLastExportSliderValue

int G4OpenGLQtViewer::fLastExportSliderValue

privateinherited

Definition at line 380 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage(), and G4OpenGLQtViewer::exportImage().

◆ fLastHighlightColor

G4Color G4OpenGLQtViewer::fLastHighlightColor

privateinherited

Definition at line 381 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::updatePickInfosWidget().

◆ fLastHighlightName

GLuint G4OpenGLQtViewer::fLastHighlightName

privateinherited

Definition at line 382 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::updatePickInfosWidget().

◆ fLastPickPoint

QPoint G4OpenGLQtViewer::fLastPickPoint

privateinherited

Definition at line 276 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPickInfosWidget(), and G4OpenGLQtViewer::updatePickInfosWidget().

◆ fLastPos1

QPoint G4OpenGLQtViewer::fLastPos1

privateinherited

Definition at line 273 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::G4MouseReleaseEvent(), and G4OpenGLQtViewer::G4OpenGLQtViewer().

◆ fLastPos2

QPoint G4OpenGLQtViewer::fLastPos2

privateinherited

Definition at line 274 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), and G4OpenGLQtViewer::G4OpenGLQtViewer().

◆ fLastPos3

QPoint G4OpenGLQtViewer::fLastPos3

privateinherited

Definition at line 275 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::G4MouseReleaseEvent(), and G4OpenGLQtViewer::G4OpenGLQtViewer().

◆ fLastSceneTreeWidgetAskForIterator

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

privateinherited

Definition at line 368 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::getTreeWidgetItem(), G4OpenGLQtViewer::isTouchableVisible(), and G4OpenGLQtViewer::updatePositivePoIndexSceneTreeWidgetQuickMap().

◆ fLastSceneTreeWidgetAskForIteratorEnd

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

privateinherited

Definition at line 369 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::getTreeWidgetItem(), G4OpenGLQtViewer::isTouchableVisible(), and G4OpenGLQtViewer::updatePositivePoIndexSceneTreeWidgetQuickMap().

◆ fLastVP

G4ViewParameters G4OpenGLStoredViewer::fLastVP

protectedinherited

Definition at line 64 of file G4OpenGLStoredViewer.hh.

Referenced by ComputeView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4OpenGLStoredViewer::G4OpenGLStoredViewer(), and G4OpenGLStoredViewer::KernelVisitDecision().

◆ fLaunchSpinDelay

int G4OpenGLQtViewer::fLaunchSpinDelay

privateinherited

Definition at line 318 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4MouseReleaseEvent().

◆ fMaxPOindexInserted

int G4OpenGLQtViewer::fMaxPOindexInserted

privateinherited

Definition at line 360 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::clearTreeWidget(), G4OpenGLQtViewer::createSceneTreeComponent(), and G4OpenGLQtViewer::parseAndInsertInSceneTree().

◆ fModelShortNameItem

QTreeWidgetItem* G4OpenGLQtViewer::fModelShortNameItem

privateinherited

Definition at line 358 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::addPVSceneTreeElement(), and G4OpenGLQtViewer::clearTreeWidget().

◆ fMouseMoveAction

QAction* G4OpenGLQtViewer::fMouseMoveAction

privateinherited

Definition at line 295 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fMouseOnSceneTree

bool G4OpenGLQtViewer::fMouseOnSceneTree

protectedinherited

Definition at line 200 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::changeColorAndTransparency(), CompareForKernelVisit(), and G4OpenGLQtViewer::setCheckComponent().

◆ fMousePickAction

QAction* G4OpenGLQtViewer::fMousePickAction

privateinherited

Definition at line 296 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fMouseRotateAction

QAction* G4OpenGLQtViewer::fMouseRotateAction

privateinherited

Definition at line 294 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fMouseZoomInAction

QAction* G4OpenGLQtViewer::fMouseZoomInAction

privateinherited

Definition at line 297 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fMouseZoomOutAction

QAction* G4OpenGLQtViewer::fMouseZoomOutAction

privateinherited

Definition at line 298 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fMovieParametersDialog

G4OpenGLQtMovieDialog* G4OpenGLQtViewer::fMovieParametersDialog

privateinherited

Definition at line 307 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::displayRecordingStatus(), G4OpenGLQtViewer::saveVideo(), G4OpenGLQtViewer::setRecordingInfos(), G4OpenGLQtViewer::showMovieParametersDialog(), and G4OpenGLQtViewer::stopVideo().

◆ fMovieTempFolderPath

QString G4OpenGLQtViewer::fMovieTempFolderPath

privateinherited

Definition at line 291 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createTempFolder(), G4OpenGLQtViewer::encodeVideo(), G4OpenGLQtViewer::generateMpegEncoderParameters(), G4OpenGLQtViewer::removeTempFolder(), and G4OpenGLQtViewer::savePPMToTemp().

◆ fName

G4String G4VViewer::fName

protectedinherited

Definition at line 217 of file G4VViewer.hh.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLViewer::DrawText(), G4OpenGLXViewer::DrawText(), G4OpenInventorQtViewer::G4OpenInventorQtViewer(), G4OpenInventorWinViewer::G4OpenInventorWinViewer(), G4OpenInventorXtExtendedViewer::G4OpenInventorXtExtendedViewer(), G4OpenInventorXtViewer::G4OpenInventorXtViewer(), G4VViewer::G4VViewer(), G4OpenGLXmViewer::GetXmConnection(), G4OpenInventorQtViewer::Initialise(), G4OpenInventorWinViewer::Initialise(), G4OpenInventorXtExtendedViewer::Initialise(), G4OpenInventorXtViewer::Initialise(), G4Qt3DViewer::Initialise(), G4RayTracerXViewer::Initialise(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise(), G4VViewer::SetName(), and G4Qt3DViewer::SetView().

◆ fNbMaxAnglePerSec

float G4OpenGLQtViewer::fNbMaxAnglePerSec

privateinherited

Definition at line 317 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4MouseReleaseEvent().

◆ fNbMaxFramesPerSec

int G4OpenGLQtViewer::fNbMaxFramesPerSec

privateinherited

Definition at line 316 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4MouseReleaseEvent().

◆ fNbRotation

int G4OpenGLQtViewer::fNbRotation

privateinherited

Definition at line 335 of file G4OpenGLQtViewer.hh.

◆ fNeedKernelVisit

G4bool G4VViewer::fNeedKernelVisit

protectedinherited

Definition at line 224 of file G4VViewer.hh.

Referenced by ComputeView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4OpenInventorViewer::DrawView(), G4Qt3DViewer::DrawView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::DrawView(), G4VViewer::NeedKernelVisit(), and G4VViewer::ProcessView().

◆ fNoKeyPress

bool G4OpenGLQtViewer::fNoKeyPress

privateinherited

Definition at line 322 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MouseReleaseEvent(), and G4OpenGLQtViewer::updateKeyModifierState().

◆ fNumber

int G4OpenGLQtViewer::fNumber

privateinherited

Definition at line 359 of file G4OpenGLQtViewer.hh.

◆ fOldDisplayListColor

G4Colour G4OpenGLStoredViewer::fOldDisplayListColor

protectedinherited

Definition at line 71 of file G4OpenGLStoredViewer.hh.

◆ fOldLastSceneTreeWidgetAskForIterator

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

privateinherited

Definition at line 372 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::clearTreeWidget(), and G4OpenGLQtViewer::getOldTreeWidgetItem().

◆ fOldLastSceneTreeWidgetAskForIteratorEnd

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

privateinherited

Definition at line 373 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::clearTreeWidget(), and G4OpenGLQtViewer::getOldTreeWidgetItem().

◆ fOldNullPoIndexSceneTreeWidgetQuickVector

std::vector<QTreeWidgetItem*> G4OpenGLQtViewer::fOldNullPoIndexSceneTreeWidgetQuickVector

privateinherited

Definition at line 353 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement(), G4OpenGLQtViewer::clearTreeWidget(), and G4OpenGLQtViewer::cloneSceneTree().

◆ fOldPositivePoIndexSceneTreeWidgetQuickMap

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

privateinherited

Definition at line 352 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement(), G4OpenGLQtViewer::clearTreeWidget(), G4OpenGLQtViewer::cloneSceneTree(), and G4OpenGLQtViewer::getOldTreeWidgetItem().

◆ fOldTreeItemModels

std::map<int, PVPath > G4OpenGLQtViewer::fOldTreeItemModels

privateinherited

Definition at line 347 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::clearTreeWidget(), and G4OpenGLQtViewer::isSameSceneTreeElement().

◆ fOldVisAttrColorMap

std::map<int, QColor> G4OpenGLQtViewer::fOldVisAttrColorMap

privateinherited

Definition at line 355 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement().

◆ fOpenGLSceneHandler

G4OpenGLSceneHandler& G4OpenGLViewer::fOpenGLSceneHandler

protectedinherited

Definition at line 197 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::GetPickDetails().

◆ fPaintEventLock

bool G4OpenGLQtViewer::fPaintEventLock

protectedinherited

Definition at line 194 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLImmediateQtViewer::G4OpenGLImmediateQtViewer(), G4OpenGLStoredQtViewer(), G4OpenGLImmediateQtViewer::paintGL(), and paintGL().

◆ fPan_sens

G4double G4OpenGLViewer::fPan_sens

protectedinherited

Definition at line 206 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::actions_callback(), G4OpenGLXmViewer::left_right_pan_callback(), G4OpenGLQtViewer::moveScene(), G4OpenGLViewer::ResetView(), G4OpenGLXmViewer::ResetView(), G4OpenGLXmViewer::set_pan_sens_callback(), G4OpenGLXmViewer::up_down_pan_callback(), and G4OpenGLXmViewer::UpdateControlPanel().

◆ fParameterFileName

QString G4OpenGLQtViewer::fParameterFileName

privateinherited

Definition at line 293 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::encodeVideo(), and G4OpenGLQtViewer::generateMpegEncoderParameters().

◆ fPickInfosScrollArea

QScrollArea* G4OpenGLQtViewer::fPickInfosScrollArea

privateinherited

Definition at line 341 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPickInfosWidget(), and G4OpenGLQtViewer::updatePickInfosWidget().

◆ fPickInfosWidget

QWidget* G4OpenGLQtViewer::fPickInfosWidget

privateinherited

Definition at line 340 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPickInfosWidget(), G4OpenGLQtViewer::toggleSceneTreeComponentPickingCout(), and G4OpenGLQtViewer::updatePickInfosWidget().

◆ fPointSize

G4float G4OpenGLViewer::fPointSize

privateinherited

Definition at line 218 of file G4OpenGLViewer.hh.

◆ fPositivePoIndexSceneTreeWidgetQuickMap

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

privateinherited

Definition at line 350 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::clearTreeWidget(), G4OpenGLQtViewer::getTreeWidgetItem(), and G4OpenGLQtViewer::updatePositivePoIndexSceneTreeWidgetQuickMap().

◆ fPrintColour

G4bool G4OpenGLViewer::fPrintColour

protectedinherited

Definition at line 194 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::misc_callback(), G4OpenGLViewer::printNonVectoredEPS(), G4OpenGLXmViewer::set_print_colour_callback(), and G4OpenGLXmViewer::set_print_style_callback().

◆ fPrintSizeX

G4int G4OpenGLViewer::fPrintSizeX

protectedinherited

Definition at line 213 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::getRealExportWidth(), and G4OpenGLViewer::setExportSize().

◆ fPrintSizeY

G4int G4OpenGLViewer::fPrintSizeY

protectedinherited

Definition at line 214 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::getRealExportHeight(), and G4OpenGLViewer::setExportSize().

◆ fProcess

QProcess* G4OpenGLQtViewer::fProcess

privateinherited

Definition at line 309 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::encodeVideo(), G4OpenGLQtViewer::getProcessErrorMsg(), G4OpenGLQtViewer::initMovieParameters(), G4OpenGLQtViewer::processEncodeStdout(), and G4OpenGLQtViewer::processLookForFinished().

◆ fProjectionOrtho

QAction* G4OpenGLQtViewer::fProjectionOrtho

privateinherited

Definition at line 305 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fProjectionPerspective

QAction* G4OpenGLQtViewer::fProjectionPerspective

privateinherited

Definition at line 306 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

◆ fPVRootNodeCreate

bool G4OpenGLQtViewer::fPVRootNodeCreate

privateinherited

Definition at line 332 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::addPVSceneTreeElement(), G4OpenGLQtViewer::clearTreeWidget(), and G4OpenGLQtViewer::createSceneTreeComponent().

◆ fQGLWidgetInitialiseCompleted

bool G4OpenGLQtViewer::fQGLWidgetInitialiseCompleted

protectedinherited

Definition at line 193 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLImmediateQtViewer::G4OpenGLImmediateQtViewer(), G4OpenGLStoredQtViewer(), G4OpenGLImmediateQtViewer::Initialise(), Initialise(), G4OpenGLImmediateQtViewer::paintEvent(), paintEvent(), G4OpenGLImmediateQtViewer::paintGL(), paintGL(), G4OpenGLImmediateQtViewer::showEvent(), and showEvent().

◆ fRecordFrameNumber

int G4OpenGLQtViewer::fRecordFrameNumber

protectedinherited

Definition at line 189 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::displayRecordingStatus(), G4OpenGLQtViewer::generateMpegEncoderParameters(), G4OpenGLQtViewer::savePPMToTemp(), G4OpenGLQtViewer::startPauseVideo(), and G4OpenGLQtViewer::stopVideo().

◆ fRecordingStep

RECORDING_STEP G4OpenGLQtViewer::fRecordingStep

privateinherited

◆ fRot_sens

G4double G4OpenGLViewer::fRot_sens

protectedinherited

Definition at line 205 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::actions_callback(), G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLViewer::ResetView(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), G4OpenGLXmViewer::set_rot_sens_callback(), and G4OpenGLXmViewer::UpdateControlPanel().

◆ fSaveFileName

QString G4OpenGLQtViewer::fSaveFileName

privateinherited

Definition at line 292 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::getSaveFileName(), and G4OpenGLQtViewer::setSaveFileName().

◆ fSceneHandler

G4VSceneHandler& G4VViewer::fSceneHandler

protectedinherited

Definition at line 215 of file G4VViewer.hh.

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), G4OpenGLQtViewer::addPVSceneTreeElement(), G4VtkViewer::ClearView(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLQtViewer::DrawText(), G4OpenGLViewer::DrawText(), G4OpenGLXViewer::DrawText(), G4VtkViewer::FinishView(), G4VViewer::G4VViewer(), G4OpenGLViewer::getSceneDepth(), G4OpenGLViewer::getSceneFarWidth(), G4OpenGLViewer::getSceneNearWidth(), G4OpenGLImmediateQtViewer::initializeGL(), initializeGL(), G4OpenGLQtViewer::parseAndInsertInSceneTree(), G4OpenGLViewer::printGl2PS(), G4VViewer::ProcessView(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), G4OpenGLViewer::SetView(), G4OpenInventorViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), G4VtkViewer::SetView(), G4VtkViewer::ShowView(), G4OpenGLQtViewer::updateViewerPropertiesTableWidget(), and G4VViewer::~G4VViewer().

◆ fSceneTreeButtonApply

QPushButton* G4OpenGLQtViewer::fSceneTreeButtonApply

privateinherited

Definition at line 343 of file G4OpenGLQtViewer.hh.

◆ fSceneTreeComponentTreeWidget

QTreeWidget* G4OpenGLQtViewer::fSceneTreeComponentTreeWidget

privateinherited

Definition at line 329 of file G4OpenGLQtViewer.hh.

◆ fSceneTreeDepth

unsigned int G4OpenGLQtViewer::fSceneTreeDepth

privateinherited

Definition at line 357 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::changeDepthInSceneTree(), G4OpenGLQtViewer::clearTreeWidget(), and G4OpenGLQtViewer::createTreeWidgetItem().

◆ fSceneTreeDepthSlider

QSlider* G4OpenGLQtViewer::fSceneTreeDepthSlider

privateinherited

Definition at line 345 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createSceneTreeComponent(), and G4OpenGLQtViewer::createTreeWidgetItem().

◆ fSceneTreeWidget

QWidget* G4OpenGLQtViewer::fSceneTreeWidget

privateinherited

Definition at line 331 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createSceneTreeComponent(), G4OpenGLQtViewer::createSceneTreeWidget(), G4OpenGLQtViewer::updateSceneTreeWidget(), and G4OpenGLQtViewer::~G4OpenGLQtViewer().

◆ fSearchIcon

QPixmap* G4OpenGLQtViewer::fSearchIcon

privateinherited

Definition at line 378 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4OpenGLQtViewer().

◆ fShiftKeyPress

bool G4OpenGLQtViewer::fShiftKeyPress

privateinherited

Definition at line 325 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), and G4OpenGLQtViewer::updateKeyModifierState().

◆ fShortcutsDialog

QDialog* G4OpenGLQtViewer::fShortcutsDialog

privateinherited

Definition at line 338 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::showShortcuts().

◆ fShortcutsDialogInfos

QTextEdit* G4OpenGLQtViewer::fShortcutsDialogInfos

privateinherited

Definition at line 344 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::showShortcuts().

◆ fShortName

G4String G4VViewer::fShortName

protectedinherited

Definition at line 218 of file G4VViewer.hh.

Referenced by G4RayTracerViewer::DrawView(), G4VViewer::G4VViewer(), and G4VViewer::SetName().

◆ fSignalMapperMouse

QSignalMapper* G4OpenGLQtViewer::fSignalMapperMouse

privateinherited

Definition at line 363 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::G4OpenGLQtViewer().

◆ fSignalMapperPicking

QSignalMapper* G4OpenGLQtViewer::fSignalMapperPicking

privateinherited

Definition at line 365 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::updatePickInfosWidget().

◆ fSignalMapperSurface

QSignalMapper* G4OpenGLQtViewer::fSignalMapperSurface

privateinherited

Definition at line 364 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::G4OpenGLQtViewer().

◆ fSizeHasChanged

G4bool G4OpenGLViewer::fSizeHasChanged

privateinherited

Definition at line 221 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::ResizeWindow(), and G4OpenGLViewer::sizeHasChanged().

◆ fSpinningDelay

int G4OpenGLQtViewer::fSpinningDelay

privateinherited

Definition at line 315 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4MouseReleaseEvent().

◆ fTempFolderPath

QString G4OpenGLQtViewer::fTempFolderPath

privateinherited

Definition at line 290 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createTempFolder(), G4OpenGLQtViewer::getTempFolderPath(), and G4OpenGLQtViewer::setTempFolderPath().

◆ fTimeRotation

int G4OpenGLQtViewer::fTimeRotation

privateinherited

Definition at line 336 of file G4OpenGLQtViewer.hh.

◆ fTouchableVolumes

QString G4OpenGLQtViewer::fTouchableVolumes

privateinherited

Definition at line 337 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::getModelShortName(), G4OpenGLQtViewer::isPVVolume(), and G4OpenGLQtViewer::parseAndInsertInSceneTree().

◆ fTreeIconClosed

QPixmap* G4OpenGLQtViewer::fTreeIconClosed

privateinherited

Definition at line 377 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4OpenGLQtViewer(), G4OpenGLQtViewer::toggleSceneTreeComponentPickingCout(), G4OpenGLQtViewer::updatePickInfosWidget(), and G4OpenGLQtViewer::~G4OpenGLQtViewer().

◆ fTreeIconOpen

QPixmap* G4OpenGLQtViewer::fTreeIconOpen

privateinherited

Definition at line 376 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4OpenGLQtViewer(), G4OpenGLQtViewer::toggleSceneTreeComponentPickingCout(), and G4OpenGLQtViewer::~G4OpenGLQtViewer().

◆ fTreeItemModels

std::map<int, PVPath > G4OpenGLQtViewer::fTreeItemModels

privateinherited

Definition at line 346 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::changeColorAndTransparency(), G4OpenGLQtViewer::clearTreeWidget(), G4OpenGLQtViewer::createSceneTreeComponent(), G4OpenGLQtViewer::createTreeWidgetItem(), G4OpenGLQtViewer::isSameSceneTreeElement(), G4OpenGLQtViewer::parseAndInsertInSceneTree(), and G4OpenGLQtViewer::setCheckComponent().

◆ fTreeWidgetInfosIgnoredCommands

int G4OpenGLQtViewer::fTreeWidgetInfosIgnoredCommands

privateinherited

Definition at line 342 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ fUIPickInfosWidget

QWidget* G4OpenGLQtViewer::fUIPickInfosWidget

privateinherited

Definition at line 321 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createPickInfosWidget(), and G4OpenGLQtViewer::updatePickInfosWidget().

◆ fUiQt

G4UIQt* G4OpenGLQtViewer::fUiQt

privateinherited

Definition at line 361 of file G4OpenGLQtViewer.hh.

◆ fUISceneTreeWidget

QWidget* G4OpenGLQtViewer::fUISceneTreeWidget

privateinherited

Definition at line 319 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createSceneTreeWidget(), and G4OpenGLQtViewer::displaySceneTreeComponent().

◆ fUIViewerPropertiesWidget

QWidget* G4OpenGLQtViewer::fUIViewerPropertiesWidget

privateinherited

Definition at line 320 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createViewerPropertiesWidget(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ fUpdateGLLock

bool G4OpenGLQtViewer::fUpdateGLLock

protectedinherited

Definition at line 192 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLImmediateQtViewer::G4OpenGLImmediateQtViewer(), G4OpenGLStoredQtViewer(), G4OpenGLImmediateQtViewer::updateQWidget(), and updateQWidget().

◆ fVectoredPs

G4bool G4OpenGLViewer::fVectoredPs

protectedinherited

Definition at line 195 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLViewer::exportImage(), G4OpenGLXmViewer::misc_callback(), G4OpenGLXmViewer::set_print_style_callback(), and G4OpenGLViewerMessenger::SetNewValue().

◆ fViewerPropertiesTableWidget

QTableWidget* G4OpenGLQtViewer::fViewerPropertiesTableWidget

privateinherited

Definition at line 339 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::createViewerPropertiesWidget(), G4OpenGLQtViewer::tableWidgetViewerSetItemChanged(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ fViewerPropertiesTableWidgetIsInit

bool G4OpenGLQtViewer::fViewerPropertiesTableWidgetIsInit

privateinherited

Definition at line 328 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ fViewId

G4int G4VViewer::fViewId

protectedinherited

Definition at line 216 of file G4VViewer.hh.

Referenced by G4OpenGLXmViewer::actions_callback(), G4OpenGLXViewer::CreateGLXContext(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLImmediateQtViewer::G4OpenGLImmediateQtViewer(), G4OpenGLImmediateWin32Viewer::G4OpenGLImmediateWin32Viewer(), G4OpenGLImmediateXmViewer::G4OpenGLImmediateXmViewer(), G4OpenGLImmediateXViewer::G4OpenGLImmediateXViewer(), G4OpenGLStoredQtViewer(), G4OpenGLStoredWin32Viewer::G4OpenGLStoredWin32Viewer(), G4OpenGLStoredXmViewer::G4OpenGLStoredXmViewer(), G4OpenGLStoredXViewer::G4OpenGLStoredXViewer(), G4OpenGLXmViewer::G4OpenGLXmViewer(), G4OpenGLXViewer::G4OpenGLXViewer(), G4RayTracerViewer::G4RayTracerViewer(), G4VViewer::G4VViewer(), G4OpenGLXViewer::GetXConnection(), G4OpenGLXmViewer::GetXmConnection(), G4Qt3DViewer::Initialise(), G4RayTracerXViewer::Initialise(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise(), G4OpenGLXmViewer::misc_callback(), G4OpenGLWin32Viewer::~G4OpenGLWin32Viewer(), and G4OpenGLXViewer::~G4OpenGLXViewer().

◆ fVP

G4ViewParameters G4VViewer::fVP

protectedinherited

Definition at line 219 of file G4VViewer.hh.

◆ fWinSize_x

unsigned int G4OpenGLViewer::fWinSize_x

protectedinherited

Definition at line 207 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLViewer::getRealExportWidth(), G4OpenGLViewer::getWinWidth(), G4OpenGLViewer::InitializeGLView(), G4OpenGLViewer::printGl2PS(), G4OpenGLViewer::ResizeGLView(), G4OpenGLViewer::ResizeWindow(), and G4OpenGLViewer::SetView().

◆ fWinSize_y

unsigned int G4OpenGLViewer::fWinSize_y

protectedinherited

Definition at line 208 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLViewer::getRealExportHeight(), G4OpenGLViewer::getWinHeight(), G4OpenGLViewer::InitializeGLView(), G4OpenGLViewer::printGl2PS(), G4OpenGLViewer::ResizeGLView(), G4OpenGLViewer::ResizeWindow(), and G4OpenGLViewer::SetView().

◆ haloing_enabled

G4bool G4OpenGLViewer::haloing_enabled

protectedinherited

Definition at line 202 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), ComputeView(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLQtViewer::createPopupMenu(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4OpenGLXmViewer::haloing_callback(), and G4OpenGLQtViewer::toggleHaloing().

◆ lWaitForVisSubThreadQtOpenGLContextInitialized

G4AutoLock* G4OpenGLQtViewer::lWaitForVisSubThreadQtOpenGLContextInitialized

privateinherited

Definition at line 391 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4OpenGLQtViewer(), and G4OpenGLQtViewer::~G4OpenGLQtViewer().

◆ lWaitForVisSubThreadQtOpenGLContextMoved

G4AutoLock* G4OpenGLQtViewer::lWaitForVisSubThreadQtOpenGLContextMoved

privateinherited

Definition at line 392 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLQtViewer::G4OpenGLQtViewer(), and G4OpenGLQtViewer::~G4OpenGLQtViewer().

◆ transparency_enabled

G4bool G4OpenGLViewer::transparency_enabled

protectedinherited

Definition at line 200 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLQtViewer::createPopupMenu(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLViewerMessenger::SetNewValue(), G4OpenGLQtViewer::toggleTransparency(), and G4OpenGLXmViewer::transparency_callback().

The documentation for this class was generated from the following files:

source/visualization/OpenGL/include/G4OpenGLStoredQtViewer.hh
source/visualization/OpenGL/src/G4OpenGLStoredQtViewer.cc

Public Slots

Public Member Functions

Protected Slots

Protected Member Functions

Protected Attributes

Private Types

Private Slots

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ PVNodeID

◆ PVPath

Member Enumeration Documentation

◆ RECORDING_STEP

Constructor & Destructor Documentation

◆ G4OpenGLStoredQtViewer()

◆ ~G4OpenGLStoredQtViewer()

Member Function Documentation

◆ actionChangeBackgroundColor

◆ actionChangeDefaultColor

◆ actionChangeTextColor

◆ actionMovieParameters

◆ actionSaveImage

◆ addExportImageFormat()

◆ addNonPVSceneTreeElement()

◆ AddPrimitiveForASingleFrame() [1/2]

◆ AddPrimitiveForASingleFrame() [2/2]

◆ addPVSceneTreeElement()

◆ changeColorAndTransparency() [1/2]

◆ changeColorAndTransparency [2/2]

◆ changeDepthInSceneTree

◆ changeDepthOnSceneTreeItem()

◆ ChangeLineWidth()

◆ changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement()

◆ ChangePointSize()

◆ changeQColorForTreeWidgetItem()

◆ changeSearchSelection

◆ clearSceneTreeSelection()

◆ clearTreeWidget()

◆ clearTreeWidgetElements()

◆ ClearView()

◆ ClearViewWithoutFlush()

◆ cloneSceneTree()

◆ cloneWidgetItem()

◆ CompareForKernelVisit()

◆ ComputeFlyThrough()

◆ ComputeView()

◆ contextMenuEvent()

◆ CreateFontLists()

◆ CreateGLQtContext()

◆ CreateMainWindow()

◆ createPickInfosWidget()

◆ createPopupMenu()

◆ createRadioAction()

◆ createSceneTreeComponent()

◆ createSceneTreeWidget()

◆ createTempFolder()

◆ createTreeWidgetItem()

◆ createViewerPropertiesWidget()

◆ currentTabActivated

◆ displayRecordingStatus()

◆ displaySceneTreeComponent()

◆ DisplayTimePOColourModification()

◆ DrawDisplayLists()

◆ DrawText()

◆ DrawView()

◆ encodeVideo()

◆ exportImage()

◆ FinishView()

◆ g4GlFrustum()

◆ g4GlOrtho()

◆ g4GluLookAt()

◆ g4GluPickMatrix()

◆ G4keyPressEvent()

◆ G4keyReleaseEvent()

◆ G4manageContextMenuEvent()

◆ G4MouseDoubleClickEvent()

◆ G4MouseMoveEvent()

◆ G4MousePressEvent()