Geant4 11.3.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Slots | Public Member Functions | Protected Slots | Protected Member Functions | Protected Attributes | List of all members
G4OpenGLQtViewer Class Referenceabstract

#include <G4OpenGLQtViewer.hh>

+ Inheritance diagram for G4OpenGLQtViewer:

Public Slots

void startPauseVideo ()
 

Public Member Functions

 G4OpenGLQtViewer (G4OpenGLSceneHandler &scene)
 
virtual ~G4OpenGLQtViewer ()
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
 
virtual G4bool ReadyToDraw ()
 
virtual void updateQWidget ()=0
 
void updateSceneTreeWidget ()
 
void updateViewerPropertiesTableWidget ()
 
void updatePickInfosWidget (int, int)
 
QString setEncoderPath (QString path)
 
QString getEncoderPath ()
 
QString setTempFolderPath (QString path)
 
QString getTempFolderPath ()
 
QString setSaveFileName (QString path)
 
QString getSaveFileName ()
 
bool isRecording ()
 
bool isStopped ()
 
bool isPaused ()
 
bool isEncoding ()
 
bool isWaiting ()
 
bool isFailed ()
 
void setWaiting ()
 
bool isBadEncoder ()
 
bool isBadOutput ()
 
bool isBadTmp ()
 
bool isSuccess ()
 
void setBadTmp ()
 
void setBadOutput ()
 
void setBadEncoder ()
 
bool isReadyToEncode ()
 
void resetRecording ()
 
void encodeVideo ()
 
void stopVideo ()
 
void saveVideo ()
 
bool generateMpegEncoderParameters ()
 
void displayRecordingStatus ()
 
void DrawText (const G4Text &)
 
void ResetView ()
 
void addPVSceneTreeElement (const G4String &model, G4PhysicalVolumeModel *pPVModel, int currentPVPOIndex)
 
void addNonPVSceneTreeElement (const G4String &model, int currentPVPOIndex, const std::string &modelDescription, const G4Visible &visible)
 
bool isTouchableVisible (int POindex)
 
void clearTreeWidget ()
 
bool exportImage (std::string name="", int width=-1, int height=-1)
 
void G4MousePressEvent (QMouseEvent *event)
 
void G4wheelEvent (QWheelEvent *event)
 
void G4keyPressEvent (QKeyEvent *event)
 
void G4keyReleaseEvent (QKeyEvent *event)
 
void G4MouseDoubleClickEvent ()
 
void G4MouseReleaseEvent (QMouseEvent *evnt)
 
void G4MouseMoveEvent (QMouseEvent *event)
 
- Public Member Functions inherited from G4OpenGLViewer
virtual void ClearView ()
 
void ClearViewWithoutFlush ()
 
bool setExportImageFormat (std::string format, bool quiet=false)
 
- Public Member Functions inherited from G4VViewer
 G4VViewer (G4VSceneHandler &, G4int id, const G4String &name="")
 
virtual ~G4VViewer ()
 
virtual void Initialise ()
 
virtual void DrawView ()=0
 
void RefreshView ()
 
virtual void ShowView ()
 
std::vector< G4ThreeVector > ComputeFlyThrough (G4Vector3D *)
 
virtual void DoneWithMasterThread ()
 
virtual void MovingToVisSubThread ()
 
virtual void SwitchToVisSubThread ()
 
virtual void DoneWithVisSubThread ()
 
virtual void MovingToMasterThread ()
 
virtual void SwitchToMasterThread ()
 
void InsertModelInSceneTree (G4VModel *)
 
const G4SceneTreeItem & GetSceneTree ()
 
G4SceneTreeItem & AccessSceneTree ()
 
void UpdateGUISceneTree ()
 
const G4String & GetName () const
 
const G4String & GetShortName () const
 
void SetName (const G4String &)
 
G4int GetViewId () const
 
G4VSceneHandler * GetSceneHandler () const
 
const G4ViewParameters & GetViewParameters () const
 
const G4ViewParameters & GetDefaultViewParameters () const
 
G4double GetKernelVisitElapsedTimeSeconds () const
 
void SetViewParameters (const G4ViewParameters &vp)
 
void SetDefaultViewParameters (const G4ViewParameters &vp)
 
const G4VisAttributes * GetApplicableVisAttributes (const G4VisAttributes *) const
 
void SetNeedKernelVisit (G4bool need)
 
void NeedKernelVisit ()
 
void ProcessView ()
 

Protected Slots

void updateToolbarAndMouseContextMenu ()
 

Protected Member Functions

void CreateGLQtContext ()
 
virtual void CreateMainWindow (G4QGLWidgetType *, const QString &)
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
 
void G4manageContextMenuEvent (QContextMenuEvent *e)
 
void rotateQtScene (float, float)
 
void rotateQtSceneToggle (float, float)
 
void moveScene (float, float, float, bool)
 
void FinishView ()
 
void updateKeyModifierState (const Qt::KeyboardModifiers &)
 
void displaySceneTreeComponent ()
 
G4Colour getColorForPoIndex (int poIndex)
 
const std::vector< G4ModelingParameters::VisAttributesModifier > * GetPrivateVisAttributesModifiers () const
 
bool isCurrentWidget ()
 
void savePPMToTemp ()
 
- Protected Member Functions inherited from G4OpenGLViewer
 G4OpenGLViewer (G4OpenGLSceneHandler &scene)
 
virtual ~G4OpenGLViewer ()
 
virtual void SetView ()
 
void ChangePointSize (G4double size)
 
void ChangeLineWidth (G4double width)
 
void HaloingFirstPass ()
 
void HaloingSecondPass ()
 
void HLRFirstPass ()
 
void HLRSecondPass ()
 
void HLRThirdPass ()
 
void InitializeGLView ()
 
void ResizeGLView ()
 
void ResizeWindow (unsigned int, unsigned int)
 
virtual G4String Pick (GLdouble x, GLdouble y)
 
const std::vector< G4OpenGLViewerPickMap * > & GetPickDetails (GLdouble x, GLdouble y)
 
virtual void CreateFontLists ()
 
void rotateScene (G4double dx, G4double dy)
 
void rotateSceneToggle (G4double dx, G4double dy)
 
void setExportSize (G4int, G4int)
 
bool setExportFilename (G4String name, G4bool inc=true)
 
std::string getRealPrintFilename ()
 
unsigned int getWinWidth () const
 
unsigned int getWinHeight () const
 
G4bool sizeHasChanged ()
 
GLdouble getSceneNearWidth ()
 
GLdouble getSceneFarWidth ()
 
GLdouble getSceneDepth ()
 
void addExportImageFormat (std::string format)
 
G4bool isGl2psWriting ()
 
G4bool isFramebufferReady ()
 
void g4GluPickMatrix (GLdouble x, GLdouble y, GLdouble width, GLdouble height, GLint viewport[4])
 
void g4GluLookAt (GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz)
 
void g4GlOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)
 
void g4GlFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)
 
bool IsGettingPickInfos () const
 
- Protected Member Functions inherited from G4VViewer
void SetTouchable (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath)
 
void TouchableSetVisibility (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, G4bool visibility)
 
void TouchableSetColour (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, const G4Colour &)
 

Protected Attributes

G4UIQt * fUiQt
 
QWidget * fGLWidget
 
int fRecordFrameNumber
 
bool fHasToRepaint
 
bool fUpdateGLLock
 
bool fQGLWidgetInitialiseCompleted
 
bool fPaintEventLock
 
bool fMouseOnSceneTree
 
- Protected Attributes inherited from G4OpenGLViewer
G4bool fPrintColour
 
G4bool fVectoredPs
 
G4OpenGLSceneHandler & fOpenGLSceneHandler
 
G4Colour background
 
G4bool transparency_enabled
 
G4bool antialiasing_enabled
 
G4bool haloing_enabled
 
G4gl2ps * fGL2PSAction
 
G4double fRot_sens
 
G4double fPan_sens
 
unsigned int fWinSize_x
 
unsigned int fWinSize_y
 
std::vector< std::string > fExportImageFormatVector
 
std::string fDefaultExportImageFormat
 
std::string fExportImageFormat
 
int fExportFilenameIndex
 
G4int fPrintSizeX
 
G4int fPrintSizeY
 
- Protected Attributes inherited from G4VViewer
G4VSceneHandler & fSceneHandler
 
G4int fViewId
 
G4String fName
 
G4String fShortName
 
G4ViewParameters fVP
 
G4ViewParameters fDefaultVP
 
G4double fKernelVisitElapsedTimeSeconds = 999.
 
G4SceneTreeItem fSceneTree
 
G4bool fNeedKernelVisit
 

Additional Inherited Members

- Public Attributes inherited from G4VViewer
const G4int fMaxNTouchables = 10000
 
G4bool fCurtailDescent = false
 

Detailed Description

Definition at line 89 of file G4OpenGLQtViewer.hh.

Constructor & Destructor Documentation

◆ G4OpenGLQtViewer()

G4OpenGLQtViewer::G4OpenGLQtViewer ( G4OpenGLSceneHandler & scene)

Definition at line 212 of file G4OpenGLQtViewer.cc.

215 :G4VViewer (scene, -1)
216 ,G4OpenGLViewer (scene)
217 ,fUiQt(NULL)
218 ,fGLWidget(NULL)
219 ,fRecordFrameNumber(0)
220 ,fMouseOnSceneTree(false)
221 ,fContextMenu(0)
222 ,fLastPickPoint(-1,-1)
223 ,fDeltaDepth(0.01)
224 ,fDeltaZoom(0.05)
225 ,fHoldKeyEvent(false)
226 ,fHoldMoveEvent(false)
227 ,fHoldRotateEvent(false)
228 ,fAutoMove(false)
229 ,fEncoderPath("")
230 ,fTempFolderPath("")
231 ,fMovieTempFolderPath("")
232 ,fSaveFileName("")
233 ,fParameterFileName("ppmtompeg_encode_parameter_file.par")
234 ,fMovieParametersDialog(NULL)
235 ,fRecordingStep(WAIT)
236 ,fProcess(NULL)
237 ,fNbMaxFramesPerSec(100)
238 ,fNbMaxAnglePerSec(360)
239 ,fLaunchSpinDelay(100)
240 ,fUISceneTreeWidget(NULL)
241 ,fUIViewerPropertiesWidget(NULL)
242 ,fUIPickInfosWidget(NULL)
243 ,fNoKeyPress(true)
244 ,fAltKeyPress(false)
245 ,fControlKeyPress(false)
246 ,fShiftKeyPress(false)
247 ,fBatchMode(false)
248 ,fCheckSceneTreeComponentSignalLock(false)
249 ,fViewerPropertiesTableWidgetIsInit(false)
250 ,fSceneTreeComponentTreeWidget(NULL)
251 ,fSceneTreeWidget(NULL)
252 ,fPVRootNodeCreate(false)
253 ,fFilterOutput(NULL)
254 ,fNbRotation(0)
255 ,fTimeRotation(0)
256 ,fTouchableVolumes("Touchables")
257 ,fShortcutsDialog(NULL)
258 ,fViewerPropertiesTableWidget(NULL)
259 ,fPickInfosWidget(NULL)
260 ,fPickInfosScrollArea(NULL)
261 ,fTreeWidgetInfosIgnoredCommands(0)
262 ,fSceneTreeDepthSlider(NULL)
263 ,fSceneTreeDepth(1)
264 ,fModelShortNameItem(NULL)
265 ,fMaxPOindexInserted(-1)
266 ,fTreeIconOpen(NULL)
267 ,fTreeIconClosed(NULL)
268 ,fLastExportSliderValue(80)
269 ,fLastHighlightColor(G4Color(0,0,0,0))
270 ,fLastHighlightName(0)
271 ,fIsDeleting(false)
272{
273 // launch Qt if not
274 if (QCoreApplication::instance () == NULL) {
275 fBatchMode = true;
276 }
277 G4Qt::getInstance ();
278
279 fLastPos3 = QPoint(-1,-1);
280 fLastPos2 = QPoint(-1,-1);
281 fLastPos1 = QPoint(-1,-1);
282
283 initMovieParameters();
284
285#if (QT_VERSION < QT_VERSION_CHECK(5, 14, 0))
286 fLastEventTime = new QTime();
287#else
288 fLastEventTime = new QElapsedTimer();
289#endif
290 // Set default path and format
291 fFileSavePath = QDir::currentPath();
292
293 // add available export format
294 QList<QByteArray> formats = QImageWriter::supportedImageFormats ();
295 for (int i = 0; i < formats.size(); ++i) {
296 addExportImageFormat(formats.at(i).data());
297 }
298
299 const char * const icon1[]={
300 /* columns rows colors chars-per-pixel */
301 "20 20 34 1",
302 " c None",
303 ". c #7C7C7C7C7C7C",
304 "X c #7D7D7D7D7D7D",
305 "o c #828282828282",
306 "O c #838383838383",
307 "+ c #848484848484",
308 "@ c #858585858585",
309 "# c #878787878787",
310 "$ c #888888888888",
311 "% c #8B8B8B8B8B8B",
312 "& c #8C8C8C8C8C8C",
313 "* c #8F8F8F8F8F8F",
314 "= c #909090909090",
315 "- c #919191919191",
316 "; c #999999999999",
317 ": c #9D9D9D9D9D9D",
318 "> c #A2A2A2A2A2A2",
319 ", c #A3A3A3A3A3A3",
320 "< c #A5A5A5A5A5A5",
321 "1 c #A6A6A6A6A6A6",
322 "2 c #B3B3B3B3B3B3",
323 "3 c #B6B6B6B6B6B6",
324 "4 c #C2C2C2C2C2C2",
325 "5 c #C6C6C6C6C6C6",
326 "6 c #CACACACACACA",
327 "7 c #CFCFCFCFCFCF",
328 "8 c #D0D0D0D0D0D0",
329 "9 c #D4D4D4D4D4D4",
330 "0 c #D7D7D7D7D7D7",
331 "q c #DEDEDEDEDEDE",
332 "w c #E0E0E0E0E0E0",
333 "e c #E7E7E7E7E7E7",
334 "r c #F4F4F4F4F4F4",
335 "t c #F7F7F7F7F7F7",
336 " ",
337 " ",
338 " ",
339 " ",
340 " ",
341 " ",
342 " =========> ",
343 " 7&X+++Oo<e ",
344 " 2o+@@+-8 ",
345 " w;.#@+3 ",
346 " 4$o@:q ",
347 " r1X%5 ",
348 " 9*,t ",
349 " 60 ",
350 " ",
351 " ",
352 " ",
353 " ",
354 " ",
355 " "
356 };
357 const char * const icon2[]={
358 "20 20 68 1",
359 " c None",
360 ". c #5F5F10102323",
361 "X c #40405F5F1010",
362 "o c #696963632E2E",
363 "O c #101019194C4C",
364 "+ c #101023237070",
365 "@ c #70702D2D6363",
366 "# c #73732D2D6464",
367 "$ c #79792E2E6767",
368 "% c #19194C4C5353",
369 "& c #2D2D63636161",
370 "* c #2E2E61617070",
371 "= c #6F6F6E6E4343",
372 "- c #707065655F5F",
373 "; c #727279795454",
374 ": c #535341417070",
375 "> c #797954547979",
376 ", c #434361617474",
377 "< c #414170707070",
378 "1 c #686869696363",
379 "2 c #6C6C69696363",
380 "3 c #656567676F6F",
381 "4 c #69696F6F6E6E",
382 "5 c #747465656767",
383 "6 c #757562626C6C",
384 "7 c #70706C6C6969",
385 "8 c #616174746565",
386 "9 c #656573736969",
387 "0 c #616174746969",
388 "q c #707075756262",
389 "w c #797970706565",
390 "e c #636361617474",
391 "r c #67676F6F7272",
392 "t c #727261617070",
393 "y c #616170707070",
394 "u c #6F6F72727979",
395 "i c #67676E6ED1D1",
396 "p c #808080808080",
397 "a c #828282828282",
398 "s c #838383838383",
399 "d c #848484848484",
400 "f c #858585858585",
401 "g c #868686868686",
402 "h c #888888888888",
403 "j c #8A8A8A8A8A8A",
404 "k c #8D8D8D8D8D8D",
405 "l c #8F8F8F8F8F8F",
406 "z c #909090909090",
407 "x c #949494949494",
408 "c c #9C9C9C9C9C9C",
409 "v c #9F9F9F9F9F9F",
410 "b c #A2A2A2A2A2A2",
411 "n c #AEAEAEAEAEAE",
412 "m c #B7B7B7B7B7B7",
413 "M c #C7C7C7C7C7C7",
414 "N c #C9C9C9C9C9C9",
415 "B c #D1D1D1D1D1D1",
416 "V c #D4D4D4D4D4D4",
417 "C c #D9D9D9D9D9D9",
418 "Z c #E0E0E0E0E0E0",
419 "A c #E2E2E2E2E2E2",
420 "S c #EEEEEEEEEEEE",
421 "D c #F0F0F0F0F0F0",
422 "F c #F5F5F5F5F5F5",
423 "G c #F6F6F6F6F6F6",
424 "H c #F9F9F9F9F9F9",
425 "J c #FCFCFCFCFCFC",
426 "K c #FDFDFDFDFDFD",
427 " ",
428 " ",
429 " ",
430 " ",
431 " ",
432 " bC ",
433 " zjnD ",
434 " ldjjMK ",
435 " zdhdjcA ",
436 " zddhdddVK ",
437 " zghdalBH ",
438 " zghamSK ",
439 " lubZH ",
440 " xMF ",
441 " G ",
442 " ",
443 " ",
444 " ",
445 " ",
446 " ",
447
448 };
449
450 const char * const search[] = {
451 /* columns rows colors chars-per-pixel */
452 "19 19 8 1",
453 " c #5C5C5C",
454 ". c #7D7D7D",
455 "X c #9B9B9B",
456 "o c #C3C3C3",
457 "O c None",
458 "+ c #000000",
459 "@ c #000000",
460 "# c None",
461 /* pixels */
462 "OOOOOOOOOOOOOOOOOOO",
463 "OOOOOOOOOOOOOOOOOOO",
464 "OOOOOOOo. .oOOOOOO",
465 "OOOOOOX XOOOOO",
466 "OOOOOo XOOX oOOOO",
467 "OOOOO. XOOOOX .OOOO",
468 "OOOOO OOOOOO OOOO",
469 "OOOOO OOOOOO OOOO",
470 "OOOOO. XOOOOo .OOOO",
471 "OOOOOo oOOo oOOOO",
472 "OOOOOOX XOOOO",
473 "OOOOOOOo. . XOOO",
474 "OOOOOOOOOOOOO. XOO",
475 "OOOOOOOOOOOOOO. XOO",
476 "OOOOOOOOOOOOOOOoOOO",
477 "OOOOOOOOOOOOOOOOOOO",
478 "OOOOOOOOOOOOOOOOOOO",
479 "OOOOOOOOOOOOOOOOOOO",
480 "OOOOOOOOOOOOOOOOOOO"
481 };
482
483 fSearchIcon = new QPixmap(search);
484 fTreeIconOpen = new QPixmap(icon1);
485 fTreeIconClosed = new QPixmap(icon2);
486
487}
G4Color
G4Colour G4Color
Definition G4Color.hh:41
G4OpenGLViewer::G4OpenGLViewer
G4OpenGLViewer(G4OpenGLSceneHandler &scene)
Definition G4OpenGLViewer.cc:58
G4OpenGLViewer::addExportImageFormat
void addExportImageFormat(std::string format)
Definition G4OpenGLViewer.cc:1243
G4Qt::getInstance
static G4Qt * getInstance()
Definition G4Qt.cc:51
G4VViewer::G4VViewer
G4VViewer(G4VSceneHandler &, G4int id, const G4String &name="")
Definition G4VViewer.cc:49

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

◆ ~G4OpenGLQtViewer()

G4OpenGLQtViewer::~G4OpenGLQtViewer ( )
virtual

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

Definition at line 490 of file G4OpenGLQtViewer.cc.

494{
495 fIsDeleting = true;
496
497 // remove scene tree from layout
498 // Delete all the existing buttons in the layout
499 QLayoutItem *wItem;
500 if (fSceneTreeWidget != NULL) {
501 if (fSceneTreeWidget->layout() != NULL) {
502 while ((wItem = fSceneTreeWidget->layout()->takeAt(0)) != 0) {
503 delete wItem->widget();
504 delete wItem;
505 }
506 }
507 }
508
509 // Delete the open/close icons
510 delete fTreeIconOpen;
511 delete fTreeIconClosed;
512
513#if QT_VERSION < 0x060000
514 G4cout <<removeTempFolder().toStdString().c_str() <<G4endl; //G.Barrand: with Qt6, it crashes at exit if the viewer is in a detached dialog window.
515#endif
516
517}
G4endl
#define G4endl
Definition G4ios.hh:67
G4cout
G4GLOB_DLL std::ostream G4cout

Member Function Documentation

◆ addNonPVSceneTreeElement()

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

Definition at line 3351 of file G4OpenGLQtViewer.cc.

3356 {
3357
3358 QString modelShortName = getModelShortName(model);
3359 G4Colour color;
3360
3361 // Special case for text
3362 try {
3363 const G4Text& g4Text = dynamic_cast<const G4Text&>(visible);
3364 color = fSceneHandler.GetTextColour(g4Text);
3365 }
3366 catch (const std::bad_cast&) {
3367 color = fSceneHandler.GetColour();
3368 }
3369
3370 // Special case for marker
3371 try {
3372 const G4VMarker& g4Marker = dynamic_cast<const G4VMarker&>(visible);
3373 if (g4Marker.GetInfo() != "") {
3374 modelShortName = g4Marker.GetInfo();
3375 }
3376 }
3377 catch (const std::bad_cast&) {}
3378
3379 if (modelShortName == "") {
3380 return ;
3381 }
3382 // try to init it
3383 if (fSceneTreeComponentTreeWidget == NULL) {
3384 createSceneTreeComponent();
3385 }
3386
3387 // if no UI
3388 if (fSceneTreeComponentTreeWidget == NULL) {
3389 return;
3390 }
3391
3392 fSceneTreeComponentTreeWidget->blockSignals(true);
3393
3394 // Create the "Model" node if not
3395
3396 QList<QTreeWidgetItem *> resItem;
3397 resItem = fSceneTreeComponentTreeWidget->findItems (modelShortName, Qt::MatchExactly, 0 );
3398 QTreeWidgetItem * currentItem = NULL;
3399 const PVPath tmpFullPath;
3400
3401 if (resItem.empty()) {
3402 currentItem = createTreeWidgetItem(tmpFullPath,
3403 modelShortName,
3404 0, // currentPVCopyNb
3405 -1, // currentPVPOIndex
3406 "",
3407 Qt::Checked,
3408 NULL,
3409 color);
3410 } else {
3411 currentItem = resItem.first();
3412 }
3413
3414 // Is this volume already in the tree AND PO is not the same?
3415 const QList<QTreeWidgetItem *>&
3416 resItems = fSceneTreeComponentTreeWidget->findItems (QString(modelDescription.c_str()), Qt::MatchFixedString| Qt::MatchCaseSensitive|Qt::MatchRecursive, 0 );
3417
3418 bool alreadyPresent = false;
3419 for (int i = 0; i < resItems.size(); ++i) {
3420 if (currentPOIndex == resItems.at(i)->data(0,Qt::UserRole).toInt()) {
3421 alreadyPresent = true;
3422 }
3423 }
3424 if (!alreadyPresent) {
3425 createTreeWidgetItem(tmpFullPath,
3426 modelShortName,
3427 0, // currentPVCopyNb
3428 currentPOIndex,
3429 "",
3430 Qt::Checked,
3431 currentItem,
3432 color);
3433 }
3434 fSceneTreeComponentTreeWidget->blockSignals(false);
3435
3436}
G4VViewer::fSceneHandler
G4VSceneHandler & fSceneHandler
Definition G4VViewer.hh:253
G4Visible::GetInfo
virtual const G4String & GetInfo() const

Referenced by G4OpenGLStoredQtSceneHandler::ExtraPOProcessing().

◆ addPVSceneTreeElement()

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

Definition at line 2883 of file G4OpenGLQtViewer.cc.

2883 {
2884
2885 const QString& modelShortName = getModelShortName(model);
2886
2887 if (modelShortName == "") {
2888 return ;
2889 }
2890 // try to init it
2891 if (fSceneTreeComponentTreeWidget == NULL) {
2892 createSceneTreeComponent();
2893 }
2894
2895 // if no UI
2896 if (fSceneTreeComponentTreeWidget == NULL) {
2897 return;
2898 }
2899
2900 fSceneTreeComponentTreeWidget->blockSignals(true);
2901
2902 // Create the "volume" node if not
2903 // if (fSceneTreeComponentTreeWidget->topLevelItemCount () == 0) {
2904 if (!fPVRootNodeCreate) {
2905 const G4Colour& color = fSceneHandler.GetColour();
2906
2907 fModelShortNameItem = createTreeWidgetItem(pPVModel->GetFullPVPath(),
2908 modelShortName,
2909 0, // currentPVCopyNb
2910 -1, // currentPVPOIndex
2911 "",
2912 Qt::Checked,
2913 NULL,
2914 color);
2915 fPVRootNodeCreate = true;
2916 }
2917
2918 bool added = parseAndInsertInSceneTree(fModelShortNameItem,pPVModel,0,modelShortName,0,currentPOIndex);
2919 if (!added) {
2920 }
2921
2922 fSceneTreeComponentTreeWidget->blockSignals(false);
2923
2924}
G4PhysicalVolumeModel::GetFullPVPath
const std::vector< G4PhysicalVolumeNodeID > & GetFullPVPath() const
Definition G4PhysicalVolumeModel.hh:210

Referenced by G4OpenGLStoredQtSceneHandler::ExtraPOProcessing().

◆ clearTreeWidget()

void G4OpenGLQtViewer::clearTreeWidget ( )

Definition at line 3857 of file G4OpenGLQtViewer.cc.

3857 {
3858 // be careful about calling this twice
3859
3860 if (fSceneTreeComponentTreeWidget) {
3861
3862 if (fSceneTreeComponentTreeWidget->topLevelItemCount () > 0) {
3863
3864 fPVRootNodeCreate = false;
3865
3866 // reset all old
3867 fOldPositivePoIndexSceneTreeWidgetQuickMap.clear();
3868 fOldNullPoIndexSceneTreeWidgetQuickVector.clear();
3869 fOldTreeItemModels.clear();
3870
3871 // Clone everything
3872 for (int b =0; b <fSceneTreeComponentTreeWidget->topLevelItemCount();b++) {
3873 // All tree widgets are in :
3874 // then we could get the old POindex and get
3875 // .visible/Hidden
3876 // .Check/Uncheck
3877 // .selected
3878 // .colour status from std::map
3879
3880 // clone top level items
3881 int poIndex = fSceneTreeComponentTreeWidget->topLevelItem(b)->data(0,Qt::UserRole).toInt();
3882 if (poIndex != -1) {
3883 fOldPositivePoIndexSceneTreeWidgetQuickMap.insert(std::pair <int, QTreeWidgetItem*> (poIndex,cloneWidgetItem(fSceneTreeComponentTreeWidget->topLevelItem(b))));
3884 } else {
3885 fOldNullPoIndexSceneTreeWidgetQuickVector.push_back(cloneWidgetItem(fSceneTreeComponentTreeWidget->topLevelItem(b)));
3886 }
3887
3888 // clone leaves
3889 cloneSceneTree(fSceneTreeComponentTreeWidget->topLevelItem(b));
3890 }
3891 // delete all elements
3892
3893 fOldTreeItemModels.insert(fTreeItemModels.begin(), fTreeItemModels.end());
3894
3895 // all is copy, then clear scene tree
3896 int tmp2 = fSceneTreeComponentTreeWidget->topLevelItemCount();
3897 while (tmp2 > 0) {
3898 delete fSceneTreeComponentTreeWidget->takeTopLevelItem (0);
3899 tmp2 = fSceneTreeComponentTreeWidget->topLevelItemCount();
3900 }
3901 fPositivePoIndexSceneTreeWidgetQuickMap.clear();
3902
3903 // put correct value in paramaters
3904 fOldLastSceneTreeWidgetAskForIterator = fOldPositivePoIndexSceneTreeWidgetQuickMap.begin();
3905 fOldLastSceneTreeWidgetAskForIteratorEnd = fOldPositivePoIndexSceneTreeWidgetQuickMap.end();
3906 fSceneTreeDepth = 1;
3907 fModelShortNameItem = NULL;
3908 fMaxPOindexInserted = -1;
3909
3910 }
3911 }
3912}

Referenced by G4OpenGLStoredQtSceneHandler::SetScene().

◆ CreateGLQtContext()

void G4OpenGLQtViewer::CreateGLQtContext ( )
protected

◆ CreateMainWindow()

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

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

Definition at line 104 of file G4OpenGLQtViewer.cc.

110{
111
112 if(fGLWidget) return; //Done.
113
114 fGLWidget = glWidget ;
115
116#if QT_VERSION < 0x060000
117 ResizeWindow(fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
118#else
119 ResizeWindow(glWidget->devicePixelRatio()*fVP.GetWindowSizeHintX(),glWidget->devicePixelRatio()*fVP.GetWindowSizeHintY());
120#endif
121
122 // FIXME L.Garnier 9/11/09 Has to be check !!!
123 // Qt UI with Qt Vis
124 // Qt UI with X Vis
125 // X UI with Qt Vis
126 // X UI with X Vis
127 // Ne marche pas avec un UIBatch !! (ecran blanc)
128
129 // return false if G4UIQt was not launch
130
131 G4UImanager* UI = G4UImanager::GetUIpointer();
132 if (UI == NULL) return;
133
134 if (! static_cast<G4UIQt*> (UI->GetG4UIWindow())) {
135 // NO UI, should be batch mode
136 fBatchMode = true;
137 return;
138 }
139 fUiQt = static_cast<G4UIQt*> (UI->GetG4UIWindow());
140
141 bool isTabbedView = false;
142 if ( fUiQt) {
143 if (!fBatchMode) {
144 G4Qt* interactorManager = G4Qt::getInstance ();
145 if (!interactorManager->IsExternalApp()) {
146 // INIT size
147 fWinSize_x = fVP.GetWindowSizeHintX();
148 fWinSize_y = fVP.GetWindowSizeHintY();
149
150 isTabbedView = fUiQt->AddTabWidget((QWidget*)fGLWidget,name);
151 QObject::connect(fUiQt->GetViewerTabWidget(),
152 SIGNAL(currentChanged(int)),
153 this,
154 SLOT(currentTabActivated(int)));
155
156#if QT_VERSION < 0x060000
157#else
158 createViewerPropertiesWidget();
159#endif
160
161 }
162 createSceneTreeWidget();
163 // activate them
164 }
165 }
166
167 if (!isTabbedView) { // we have to do a dialog
168
169 QWidget *glDialogWidget = getParentWidget();
170 if (glDialogWidget == NULL) {
171 return;
172 }
173 glWidget->setParent(glDialogWidget);
174 QHBoxLayout *mainLayout = new QHBoxLayout();
175
176 mainLayout->setContentsMargins(0,0,0,0);
177 mainLayout->setSpacing(0);
178 mainLayout->addWidget(fGLWidget);
179 if (fGLWidget->inherits("QMainWindow")) {
180 fGLWidget->setWindowTitle( name);
181 }
182 glDialogWidget->setLayout(mainLayout);
183
184
185 //useful for MACOSX, we have to compt the menuBar height
186#if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
187 G4int offset = QGuiApplication::primaryScreen()->availableGeometry().height()
188 - QGuiApplication::screenAt(QPoint(20,20))->availableGeometry().height();
189#else
190 G4int offset = QApplication::desktop()->height()
191 - QApplication::desktop()->availableGeometry().height();
192#endif
193
194 G4int YPos= fVP.GetWindowAbsoluteLocationHintY(QGuiApplication::primaryScreen()->availableGeometry().height());
195 if (fVP.GetWindowAbsoluteLocationHintY(QGuiApplication::primaryScreen()->availableGeometry().height())< offset) {
196 YPos = offset;
197 }
198 glDialogWidget->resize(getWinWidth(), getWinHeight());
199 glDialogWidget->move(fVP.GetWindowAbsoluteLocationHintX(QGuiApplication::primaryScreen()->availableGeometry().width()),YPos);
200 glDialogWidget->show();
201 }
202
203 if(!fGLWidget) return;
204
205 if (!fContextMenu)
206 createPopupMenu();
207
208}
offset
G4ThreadLocal T * G4GeomSplitter< T >::offset
Definition G4GeomSplitter.hh:183
G4int
int G4int
Definition G4Types.hh:85
G4OpenGLViewer::fWinSize_y
unsigned int fWinSize_y
Definition G4OpenGLViewer.hh:197
G4OpenGLViewer::getWinHeight
unsigned int getWinHeight() const
Definition G4OpenGLViewer.cc:932
G4OpenGLViewer::ResizeWindow
void ResizeWindow(unsigned int, unsigned int)
Definition G4OpenGLViewer.cc:181
G4OpenGLViewer::getWinWidth
unsigned int getWinWidth() const
Definition G4OpenGLViewer.cc:928
G4OpenGLViewer::fWinSize_x
unsigned int fWinSize_x
Definition G4OpenGLViewer.hh:196
G4Qt::IsExternalApp
bool IsExternalApp()
Definition G4Qt.cc:183
G4UImanager::GetG4UIWindow
G4UIsession * GetG4UIWindow() const
Definition G4UImanager.hh:178
G4UImanager::GetUIpointer
static G4UImanager * GetUIpointer()
Definition G4UImanager.cc:76
G4VViewer::fVP
G4ViewParameters fVP
Definition G4VViewer.hh:257

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

◆ displayRecordingStatus()

void G4OpenGLQtViewer::displayRecordingStatus ( )

Definition at line 1785 of file G4OpenGLQtViewer.cc.

1785 {
1786
1787 QString txtStatus = "";
1788 if (fRecordingStep == WAIT) {
1789 txtStatus = "Waiting to start...";
1790 fRecordFrameNumber = 0; // reset the frame number
1791 } else if (fRecordingStep == START) {
1792 txtStatus = "Start Recording...";
1793 } else if (fRecordingStep == PAUSE) {
1794 txtStatus = "Pause Recording...";
1795 } else if (fRecordingStep == CONTINUE) {
1796 txtStatus = "Continue Recording...";
1797 } else if (fRecordingStep == STOP) {
1798 txtStatus = "Stop Recording...";
1799 } else if (fRecordingStep == READY_TO_ENCODE) {
1800 txtStatus = "Ready to Encode...";
1801 } else if (fRecordingStep == ENCODING) {
1802 txtStatus = "Encoding...";
1803 } else if (fRecordingStep == FAILED) {
1804 txtStatus = "Failed to encode...";
1805 } else if ((fRecordingStep == BAD_ENCODER)
1806 || (fRecordingStep == BAD_OUTPUT)
1807 || (fRecordingStep == BAD_TMP)) {
1808 txtStatus = "Correct above errors first";
1809 } else if (fRecordingStep == SUCCESS) {
1810 txtStatus = "File encoded successfully";
1811 } else {
1812 }
1813
1814 if (fMovieParametersDialog) {
1815 fMovieParametersDialog->setRecordingStatus(txtStatus);
1816 } else {
1817 G4cout << txtStatus.toStdString().c_str() << G4endl;
1818 }
1819 setRecordingInfos("");
1820}

Referenced by setBadEncoder(), setBadOutput(), setBadTmp(), and setWaiting().

◆ displaySceneTreeComponent()

void G4OpenGLQtViewer::displaySceneTreeComponent ( )
protected

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

Definition at line 4087 of file G4OpenGLQtViewer.cc.

4087 {
4088 // no UI
4089 if (fUISceneTreeWidget == NULL) {
4090 return;
4091 }
4092 if (fSceneTreeComponentTreeWidget == NULL) {
4093 return;
4094 }
4095
4096 // sort tree items
4097 fSceneTreeComponentTreeWidget->sortItems (0, Qt::AscendingOrder );
4098
4099 return;
4100}

◆ DrawText()

void G4OpenGLQtViewer::DrawText ( const G4Text & g4text)
virtual

Reimplemented from G4OpenGLViewer.

Definition at line 2797 of file G4OpenGLQtViewer.cc.

2798{
2799 auto* qGLW = dynamic_cast<G4QGLWidgetType*> (fGLWidget) ;
2800 if (! qGLW) {
2801 return;
2802 }
2803 if (isGl2psWriting()) {
2804
2805 G4OpenGLViewer::DrawText(g4text);
2806
2807 } else {
2808
2809 if (!fGLWidget) return;
2810
2811 if (!G4Threading::IsMasterThread()) return;
2812
2813 G4VSceneHandler::MarkerSizeType sizeType;
2814 G4double size = fSceneHandler.GetMarkerSize(g4text,sizeType);
2815
2816 QFont font = QFont();
2817 font.setPointSizeF(size);
2818
2819 const G4Colour& c = fSceneHandler.GetTextColour(g4text);
2820
2821 G4Point3D position = g4text.GetPosition();
2822
2823 const G4String& textString = g4text.GetText();
2824 const char* textCString = textString.c_str();
2825
2826 // Calculate move for centre and right adjustment
2827 QFontMetrics f(font);
2828 G4double span = f.boundingRect(textCString).width();
2829
2830 G4double xmove = 0.;
2831 G4double ymove = 0.;
2832
2833 switch (g4text.GetLayout()) {
2834 case G4Text::left: break;
2835 case G4Text::centre: xmove -= span / 2.; break;
2836 case G4Text::right: xmove -= span;
2837 }
2838
2839 //Add offsets
2840 xmove += g4text.GetXOffset();
2841 ymove += g4text.GetYOffset();
2842
2843#if QT_VERSION < 0x060000
2844 glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha());
2845 glRasterPos3d(position.x(),position.y(),position.z());
2846 // xmove, ymove in pixels - or are they?
2847#ifdef __APPLE__
2848 const G4double fudgeFactor = 2.;
2849#else
2850 const G4double fudgeFactor = 1.;
2851#endif
2852 xmove *= fudgeFactor;
2853 ymove *= fudgeFactor;
2854 qGLW->renderText
2855 ((position.x()+(2*xmove)/getWinWidth()),
2856 (position.y()+(2*ymove)/getWinHeight()),
2857 position.z(),
2858 textCString,
2859 font);
2860#else
2861 QColor color((int)(c.GetRed()*255),
2862 (int)(c.GetGreen()*255),
2863 (int)(c.GetBlue()*255),
2864 (int)(c.GetAlpha()*255));
2865 render_text(*qGLW,
2866 position.x(),position.y(),position.z(),
2867 xmove,ymove,
2868 font,color,textCString);
2869#endif
2870 }
2871}
G4QGLWidgetType
QOpenGLWidget G4QGLWidgetType
Definition G4OpenGLQtViewer.hh:58
G4Point3D
HepGeom::Point3D< G4double > G4Point3D
Definition G4Point3D.hh:34
G4double
double G4double
Definition G4Types.hh:83
G4Colour::GetBlue
G4double GetBlue() const
Definition G4Colour.hh:172
G4Colour::GetAlpha
G4double GetAlpha() const
Definition G4Colour.hh:173
G4Colour::GetRed
G4double GetRed() const
Definition G4Colour.hh:170
G4Colour::GetGreen
G4double GetGreen() const
Definition G4Colour.hh:171
G4OpenGLViewer::DrawText
virtual void DrawText(const G4Text &)
Definition G4OpenGLViewer.cc:704
G4OpenGLViewer::isGl2psWriting
G4bool isGl2psWriting()
Definition G4OpenGLViewer.cc:666
G4Text::GetLayout
Layout GetLayout() const
G4Text::GetYOffset
G4double GetYOffset() const
G4Text::GetXOffset
G4double GetXOffset() const
G4Text::GetText
G4String GetText() const
G4Text::centre
@ centre
Definition G4Text.hh:76
G4Text::right
@ right
Definition G4Text.hh:76
G4Text::left
@ left
Definition G4Text.hh:76
G4VMarker::GetPosition
G4Point3D GetPosition() const
G4Threading::IsMasterThread
G4bool IsMasterThread()
Definition G4Threading.cc:124

◆ encodeVideo()

void G4OpenGLQtViewer::encodeVideo ( )

Definition at line 2314 of file G4OpenGLQtViewer.cc.

2315{
2316 if ((getEncoderPath() != "") && (getSaveFileName() != "")) {
2317 setRecordingStatus(ENCODING);
2318
2319 fProcess = new QProcess();
2320 QObject ::connect(fProcess,SIGNAL(finished ( int,QProcess::ExitStatus)),
2321 this,SLOT(processEncodeFinished()));
2322 QObject ::connect(fProcess,SIGNAL(readyReadStandardOutput ()),
2323 this,SLOT(processEncodeStdout()));
2324#if (QT_VERSION < QT_VERSION_CHECK(5, 10, 0))
2325 fProcess->setReadChannelMode(QProcess::MergedChannels);
2326#else
2327 fProcess->setProcessChannelMode(QProcess::MergedChannels);
2328#endif
2329 fProcess->start (fEncoderPath, QStringList(fMovieTempFolderPath+fParameterFileName));
2330 }
2331}

Referenced by saveVideo().

◆ exportImage()

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

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 2120 of file G4OpenGLQtViewer.cc.

2120 {
2121
2122 auto* qGLW = dynamic_cast<G4QGLWidgetType*> (fGLWidget) ;
2123 if (! qGLW) {
2124 return false;
2125 }
2126 // If there is already an extention
2127 bool increaseFileNumber = true;
2128 // if
2129 if (name.size() != name.substr(name.find_last_of(".") + 1).size()) {
2130 increaseFileNumber = false;
2131 }
2132 if (! setExportFilename(name,increaseFileNumber)) {
2133 return false;
2134 }
2135 if ((width !=-1) && (height != -1)) {
2136 setExportSize(width, height);
2137 }
2138 // first, try to do it with generic function
2139 if (G4OpenGLViewer::exportImage(name, width, height)) {
2140 return true;
2141
2142 // Then try Qt saving functions
2143 } else {
2144 QImage image;
2145#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
2146 image = qGLW->grabFrameBuffer();
2147#else
2148 image = qGLW->grabFramebuffer();
2149#endif
2150
2151 bool res = image.save(QString(getRealPrintFilename().c_str()),0,fLastExportSliderValue);
2152
2153 if (!res) {
2154 G4cerr << "Error saving file... " << getRealPrintFilename().c_str() << G4endl;
2155 return false;
2156 } else {
2157 G4cout << "File " << getRealPrintFilename().c_str() << " size: " << fGLWidget->width() << "x" << fGLWidget->height() << " has been saved " << G4endl;
2158 fExportFilenameIndex++;
2159 }
2160 }
2161 return true;
2162}
G4cerr
G4GLOB_DLL std::ostream G4cerr
G4OpenGLViewer::setExportFilename
bool setExportFilename(G4String name, G4bool inc=true)
Definition G4OpenGLViewer.cc:989
G4OpenGLViewer::setExportSize
void setExportSize(G4int, G4int)
Definition G4OpenGLViewer.cc:978
G4OpenGLViewer::exportImage
virtual bool exportImage(std::string name="", int width=-1, int height=-1)
Definition G4OpenGLViewer.cc:773
G4OpenGLViewer::getRealPrintFilename
std::string getRealPrintFilename()
Definition G4OpenGLViewer.cc:1021
G4InuclParticleNames::name
const char * name(G4int ptype)
Definition G4InuclParticleNames.hh:76

◆ FinishView()

void G4OpenGLQtViewer::FinishView ( void )
protectedvirtual

Reimplemented from G4VViewer.

Definition at line 1192 of file G4OpenGLQtViewer.cc.

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

◆ G4keyPressEvent()

void G4OpenGLQtViewer::G4keyPressEvent ( QKeyEvent * event)

Definition at line 1548 of file G4OpenGLQtViewer.cc.

1549{
1550 if (fHoldKeyEvent)
1551 return;
1552
1553 fHoldKeyEvent = true;
1554
1555
1556 // with no modifiers
1557 updateKeyModifierState(evnt->modifiers());
1558 if ((fNoKeyPress) || (evnt->modifiers() == Qt::KeypadModifier )) {
1559 if (evnt->key() == Qt::Key_Down) { // go down
1560 moveScene(0,1,0,false);
1561 }
1562 else if (evnt->key() == Qt::Key_Up) { // go up
1563 moveScene(0,-1,0,false);
1564 }
1565 if (evnt->key() == Qt::Key_Left) { // go left
1566 moveScene(-1,0,0,false);
1567 }
1568 else if (evnt->key() == Qt::Key_Right) { // go right
1569 moveScene(1,0,0,false);
1570 }
1571 if (evnt->key() == Qt::Key_Minus) { // go backward
1572 moveScene(0,0,1,false);
1573 }
1574 else if (evnt->key() == Qt::Key_Plus) { // go forward
1575 moveScene(0,0,-1,false);
1576 }
1577 // escaped from full screen
1578 if (evnt->key() == Qt::Key_Escape) {
1579 toggleFullScreen(false);
1580 }
1581 }
1582 // several case here : If return is pressed, in every case -> display the movie parameters dialog
1583 // If one parameter is wrong -> put it in red (only save filenam could be wrong..)
1584 // If encoder not found-> does nothing.Only display a message in status box
1585 // If all ok-> generate parameter file
1586 // If ok -> put encoder button enabled
1587
1588 if ((evnt->key() == Qt::Key_Return) || (evnt->key() == Qt::Key_Enter)){ // end of video
1589 stopVideo();
1590 }
1591 if (evnt->key() == Qt::Key_Space){ // start/pause of video
1592 startPauseVideo();
1593 }
1594
1595 // H : Return Home view
1596 if (evnt->key() == Qt::Key_H){ // go Home
1597 ResetView();
1598
1599 updateQWidget();
1600 }
1601
1602 // Shift Modifier
1603 if (fShiftKeyPress) {
1604 fGLWidget->setCursor(QCursor(Qt::SizeAllCursor));
1605
1606 if (evnt->key() == Qt::Key_Down) { // rotate phi
1607 rotateQtScene(0,-fRot_sens);
1608 }
1609 else if (evnt->key() == Qt::Key_Up) { // rotate phi
1610 rotateQtScene(0,fRot_sens);
1611 }
1612 if (evnt->key() == Qt::Key_Left) { // rotate theta
1613 rotateQtScene(fRot_sens,0);
1614 }
1615 else if (evnt->key() == Qt::Key_Right) { // rotate theta
1616 rotateQtScene(-fRot_sens,0);
1617 }
1618 if (evnt->key() == Qt::Key_Plus) { // go forward ("Plus" imply
1619 // "Shift" on Mac French keyboard
1620 moveScene(0,0,-1,false);
1621 }
1622
1623 // Alt Modifier
1624 }
1625 if ((fAltKeyPress)) {
1626 fGLWidget->setCursor(QCursor(Qt::ClosedHandCursor));
1627
1628 if (evnt->key() == Qt::Key_Down) { // rotate phi
1629 rotateQtSceneToggle(0,-fRot_sens);
1630 }
1631 else if (evnt->key() == Qt::Key_Up) { // rotate phi
1632 rotateQtSceneToggle(0,fRot_sens);
1633 }
1634 if (evnt->key() == Qt::Key_Left) { // rotate theta
1635 rotateQtSceneToggle(fRot_sens,0);
1636 }
1637 else if (evnt->key() == Qt::Key_Right) { // rotate theta
1638 rotateQtSceneToggle(-fRot_sens,0);
1639 }
1640
1641 // Rotatio +/-
1642 if (evnt->key() == Qt::Key_Plus) {
1643 fRot_sens = fRot_sens/0.7;
1644 G4cout << "Auto-rotation set to : " << fRot_sens << G4endl;
1645 }
1646 else if (evnt->key() == Qt::Key_Minus) {
1647 fRot_sens = fRot_sens*0.7;
1648 G4cout << "Auto-rotation set to : " << fRot_sens << G4endl;
1649 }
1650
1651 // Control Modifier OR Command on MAC
1652 }
1653 if ((fControlKeyPress)) {
1654 if (evnt->key() == Qt::Key_Plus) {
1655 fVP.SetZoomFactor(fVP.GetZoomFactor()*(1+fDeltaZoom));
1656 updateQWidget();
1657 }
1658 else if (evnt->key() == Qt::Key_Minus) {
1659 fVP.SetZoomFactor(fVP.GetZoomFactor()*(1-fDeltaZoom));
1660 updateQWidget();
1661 }
1662 }
1663
1664 fHoldKeyEvent = false;
1665}
G4OpenGLQtViewer::rotateQtSceneToggle
void rotateQtSceneToggle(float, float)
Definition G4OpenGLQtViewer.cc:1496
G4OpenGLQtViewer::moveScene
void moveScene(float, float, float, bool)
Definition G4OpenGLQtViewer.cc:1446
G4OpenGLQtViewer::rotateQtScene
void rotateQtScene(float, float)
Definition G4OpenGLQtViewer.cc:1478
G4OpenGLQtViewer::updateKeyModifierState
void updateKeyModifierState(const Qt::KeyboardModifiers &)
Definition G4OpenGLQtViewer.cc:1674
G4OpenGLQtViewer::updateQWidget
virtual void updateQWidget()=0

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

◆ G4keyReleaseEvent()

void G4OpenGLQtViewer::G4keyReleaseEvent ( QKeyEvent * event)

Definition at line 1668 of file G4OpenGLQtViewer.cc.

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

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

◆ G4manageContextMenuEvent()

void G4OpenGLQtViewer::G4manageContextMenuEvent ( QContextMenuEvent * e)
protected

Definition at line 694 of file G4OpenGLQtViewer.cc.

695{
696 if (!fGLWidget) {
697 G4cerr << "Visualization window not defined, please choose one before" << G4endl;
698 } else {
699
700 if (!fContextMenu)
701 createPopupMenu();
702
703 // launch menu
704 if ( fContextMenu ) {
705 fContextMenu->exec( e->globalPos() );
706 // delete fContextMenu;
707 }
708 }
709 e->accept();
710}

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

◆ G4MouseDoubleClickEvent()

void G4OpenGLQtViewer::G4MouseDoubleClickEvent ( )

Definition at line 1367 of file G4OpenGLQtViewer.cc.

1368{
1369 fGLWidget->setMouseTracking(true);
1370}

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

◆ G4MouseMoveEvent()

void G4OpenGLQtViewer::G4MouseMoveEvent ( QMouseEvent * evnt)
Parameters
pos_xmouse x position
pos_ymouse y position
mButtonsmouse button active
mAutoMovetrue: apply this move till another evnt came, false :one time move

Definition at line 1380 of file G4OpenGLQtViewer.cc.

1381{
1382
1383 Qt::MouseButtons mButtons = evnt->buttons();
1384
1385 updateKeyModifierState(evnt->modifiers());
1386
1387 if (fAutoMove) {
1388 return;
1389 }
1390
1391 fLastPos3 = fLastPos2;
1392 fLastPos2 = fLastPos1;
1393
1394#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
1395 fLastPos1 = QPoint(evnt->x(), evnt->y());
1396#else
1397 fLastPos1 = QPoint(evnt->position().x(), evnt->position().y());
1398#endif
1399
1400 int deltaX = fLastPos2.x()-fLastPos1.x();
1401 int deltaY = fLastPos2.y()-fLastPos1.y();
1402
1403 bool move = false;
1404 if (fUiQt != NULL) {
1405 if (fUiQt->IsIconMoveSelected()) { // move
1406 move = true;
1407 }
1408 }
1409 if (!move) { // rotate, pick, zoom...
1410 if (mButtons & Qt::LeftButton) {
1411 if (fNoKeyPress) {
1412 rotateQtScene(((float)deltaX),((float)deltaY));
1413 } else if (fAltKeyPress) {
1414 rotateQtSceneToggle(((float)deltaX),((float)deltaY));
1415 } else if (fShiftKeyPress) {
1416 unsigned int sizeWin;
1417 sizeWin = getWinWidth();
1418 if (getWinHeight() < getWinWidth()) {
1419 sizeWin = getWinHeight();
1420 }
1421
1422 // L.Garnier : 08/2010 100 is the good value, but don't ask me why !
1423 float factor = ((float)100/(float)sizeWin) ;
1424 moveScene(-(float)deltaX*factor,-(float)deltaY*factor,0,false);
1425 } else if (fControlKeyPress) {
1426 fVP.SetZoomFactor(fVP.GetZoomFactor()*(1+((float)deltaY)));
1427 }
1428 }
1429 } else if (move) { // move
1430 if (mButtons & Qt::LeftButton) {
1431 moveScene(-(float)deltaX,-(float)deltaY,0,true);
1432 }
1433 }
1434
1435 fLastEventTime->start();
1436}

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

◆ G4MousePressEvent()

void G4OpenGLQtViewer::G4MousePressEvent ( QMouseEvent * evnt)

Save the current mouse press point

Parameters
pmouse click point

Definition at line 1208 of file G4OpenGLQtViewer.cc.

1209{
1210 if (evnt->button() == Qt::RightButton) {
1211 return;
1212 }
1213 if ((evnt->button() & Qt::LeftButton) && (! (evnt->modifiers() & Qt::ControlModifier ))){
1214 fGLWidget->setMouseTracking(true);
1215 fAutoMove = false; // stop automove
1216 fLastPos1 = evnt->pos();
1217 fLastPos2 = fLastPos1;
1218 fLastPos3 = fLastPos2;
1219 fLastEventTime->start();
1220 if (fUiQt != NULL) {
1221
1222 if (fUiQt->IsIconZoomInSelected()) { // zoomIn
1223 // Move click point to center of OGL
1224
1225 float deltaX = ((float)getWinWidth()/2-evnt->pos().x());
1226 float deltaY = ((float)getWinHeight()/2-evnt->pos().y());
1227
1228 G4double coefTrans = 0;
1229 coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinWidth());
1230 if (getWinHeight() <getWinWidth()) {
1231 coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinHeight());
1232 }
1233 fVP.IncrementPan(-deltaX*coefTrans,deltaY*coefTrans,0);
1234 fVP.SetZoomFactor(1.5 * fVP.GetZoomFactor());
1235
1236 updateQWidget();
1237
1238 } else if (fUiQt->IsIconZoomOutSelected()) { // zoomOut
1239 // Move click point to center of OGL
1240 moveScene(((float)getWinWidth()/2-evnt->pos().x()),((float)getWinHeight()/2-evnt->pos().y()),0,true);
1241
1242 fVP.SetZoomFactor(0.75 * fVP.GetZoomFactor());
1243 updateQWidget();
1244
1245 } else if (fUiQt->IsIconRotateSelected() ) {
1246
1247 if (fShiftKeyPress) { // move
1248 fGLWidget->setCursor(QCursor(Qt::SizeAllCursor));
1249
1250 } else { // rotate
1251 fGLWidget->setCursor(QCursor(Qt::ClosedHandCursor));
1252 }
1253 } else if (fUiQt->IsIconMoveSelected()) {
1254 fGLWidget->setCursor(QCursor(Qt::SizeAllCursor));
1255 } else if (fUiQt->IsIconPickSelected()) {
1256 fGLWidget->setCursor(QCursor(Qt::PointingHandCursor));
1257 }
1258 }
1259 }
1260}
G4OpenGLViewer::getSceneNearWidth
GLdouble getSceneNearWidth()
Definition G4OpenGLViewer.cc:1034

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

◆ G4MouseReleaseEvent()

void G4OpenGLQtViewer::G4MouseReleaseEvent ( QMouseEvent * evnt)

Definition at line 1264 of file G4OpenGLQtViewer.cc.

1265{
1266#if QT_VERSION < 0x060000
1267#else
1268 {auto* qGLW = dynamic_cast<G4QGLWidgetType*> (fGLWidget) ;
1269 if (qGLW) qGLW->makeCurrent();}
1270 ResizeGLView();
1271#endif
1272 GLint viewport[4];
1273 glGetIntegerv(GL_VIEWPORT, viewport);
1274
1275 // factorX == factorY
1276 double factorX = ((double)viewport[2]/fGLWidget->width());
1277 double factorY = ((double)viewport[3]/fGLWidget->height());
1278 fSpinningDelay = (int)fLastEventTime->elapsed();
1279 QPoint delta = (fLastPos3-fLastPos1)*factorX;
1280
1281 // reset cursor state
1282 fGLWidget->setCursor(QCursor(Qt::ArrowCursor));
1283
1284 if (fVP.IsPicking()){ // pick
1285 if ((delta.x() != 0) || (delta.y() != 0)) {
1286 return;
1287 }
1288 updatePickInfosWidget(evnt->pos().x()*factorX,evnt->pos().y()*factorY);
1289
1290 } else if (fSpinningDelay < fLaunchSpinDelay ) {
1291 if ((delta.x() == 0) && (delta.y() == 0)) {
1292 return;
1293 }
1294
1295 fAutoMove = true;
1296#if (QT_VERSION < QT_VERSION_CHECK(5, 14, 0))
1297 QTime lastMoveTime;
1298#else
1299 QElapsedTimer lastMoveTime;
1300#endif
1301 lastMoveTime.start();
1302 // try to addapt speed move/rotate looking to drawing speed
1303 float correctionFactor = 5;
1304 while (fAutoMove) {
1305 if ( lastMoveTime.elapsed() >= (int)(1000/fNbMaxFramesPerSec)) {
1306 float lTime = 1000.0f/lastMoveTime.elapsed();
1307 if (((((float)delta.x())/correctionFactor)*lTime > fNbMaxAnglePerSec) ||
1308 ((((float)delta.x())/correctionFactor)*lTime < -fNbMaxAnglePerSec) ) {
1309 correctionFactor = (float)delta.x()*(lTime/fNbMaxAnglePerSec);
1310 if (delta.x() <0 ) {
1311 correctionFactor = -correctionFactor;
1312 }
1313 }
1314 if (((((float)delta.y())/correctionFactor)*lTime > fNbMaxAnglePerSec) ||
1315 ((((float)delta.y())/correctionFactor)*lTime < -fNbMaxAnglePerSec) ) {
1316 correctionFactor = (float)delta.y()*(lTime/fNbMaxAnglePerSec);
1317 if (delta.y() <0 ) {
1318 correctionFactor = -correctionFactor;
1319 }
1320 }
1321
1322 // Check Qt Versions for META Keys
1323
1324 // Click and move mouse to rotate volume
1325 // ALT + Click and move mouse to rotate volume (View Direction)
1326 // SHIFT + Click and move camera point of view
1327 // CTRL + Click and zoom mouse to zoom in/out
1328
1329 lastMoveTime.start();
1330
1331 bool rotate = false;
1332 bool move = false;
1333
1334 if (fUiQt != NULL) {
1335 if (fUiQt->IsIconRotateSelected()) { // rotate
1336 rotate = true;
1337 } else if (fUiQt->IsIconMoveSelected()) { // move
1338 move = true;
1339 }
1340 } else {
1341 rotate = true;
1342 }
1343 // prevent from closing widget when rotating (cause a crash)
1344 if (fIsDeleting) {
1345 return;
1346 }
1347
1348 if (rotate) { // rotate
1349 if (fNoKeyPress) {
1350 rotateQtScene(((float)delta.x())/correctionFactor,((float)delta.y())/correctionFactor);
1351 } else if (fAltKeyPress) {
1352 rotateQtSceneToggle(((float)delta.x())/correctionFactor,((float)delta.y())/correctionFactor);
1353 }
1354
1355 } else if (move) { // move
1356 moveScene(-((float)delta.x())/correctionFactor,-((float)delta.y())/correctionFactor,0,true);
1357 }
1358 }
1359 ((QApplication*)G4Qt::getInstance ())->processEvents();
1360 }
1361 }
1362 fGLWidget->setMouseTracking(false);
1363
1364}
G4OpenGLQtViewer::updatePickInfosWidget
void updatePickInfosWidget(int, int)
Definition G4OpenGLQtViewer.cc:4530

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

◆ G4wheelEvent()

void G4OpenGLQtViewer::G4wheelEvent ( QWheelEvent * event)

Definition at line 1537 of file G4OpenGLQtViewer.cc.

1538{
1539#if (QT_VERSION < QT_VERSION_CHECK(5, 15, 0))
1540 fVP.SetZoomFactor(fVP.GetZoomFactor()+(fVP.GetZoomFactor()*(evnt->delta())/1200));
1541#else
1542 fVP.SetZoomFactor(fVP.GetZoomFactor()+(fVP.GetZoomFactor()*(evnt->angleDelta().y())/1200));
1543#endif
1544 updateQWidget();
1545}

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

◆ generateMpegEncoderParameters()

bool G4OpenGLQtViewer::generateMpegEncoderParameters ( )

Definition at line 2164 of file G4OpenGLQtViewer.cc.

2164 {
2165
2166 // save the parameter file
2167 FILE* fp;
2168 fp = fopen (QString(fMovieTempFolderPath+fParameterFileName).toStdString().c_str(), "w");
2169
2170 if (fp == NULL) {
2171 setRecordingInfos("Generation of parameter file failed");
2172 return false;
2173 }
2174
2175 fprintf (fp,"# Pattern affects speed, quality and compression. See the User's Guide\n");
2176 fprintf (fp,"# for more info.\n");
2177 fprintf (fp,"\n");
2178 fprintf (fp,"PATTERN I\n");
2179 fprintf (fp,"OUTPUT %s\n",getSaveFileName().toStdString().c_str());
2180 fprintf (fp,"\n");
2181 fprintf (fp,"# You must specify the type of the input files. The choices are:\n");
2182 fprintf (fp,"# YUV, PPM, JMOVIE, Y, JPEG, PNM\n");
2183 fprintf (fp,"# (must be upper case)\n");
2184 fprintf (fp,"#\n");
2185 fprintf (fp,"BASE_FILE_FORMAT PPM\n");
2186 fprintf (fp,"\n");
2187 fprintf (fp,"\n");
2188 fprintf (fp,"# If you are using YUV, there are different supported file formats.\n");
2189 fprintf (fp,"# EYUV or UCB are the same as previous versions of this encoder.\n");
2190 fprintf (fp,"# (All the Y's, then U's then V's, in 4:2:0 subsampling.)\n");
2191 fprintf (fp,"# Other formats, such as Abekas, Phillips, or a general format are\n");
2192 fprintf (fp,"# permissible, the general format is a string of Y's, U's, and V's\n");
2193 fprintf (fp,"# to specify the file order.\n");
2194 fprintf (fp,"\n");
2195 fprintf (fp,"INPUT_FORMAT UCB\n");
2196 fprintf (fp,"\n");
2197 fprintf (fp,"# the conversion statement\n");
2198 fprintf (fp,"#\n");
2199 fprintf (fp,"# Each occurrence of '*' will be replaced by the input file\n");
2200 fprintf (fp,"#\n");
2201 fprintf (fp,"# e.g., if you have a bunch of GIF files, then this might be:\n");
2202 fprintf (fp,"# INPUT_CONVERT giftoppm *\n");
2203 fprintf (fp,"#\n");
2204 fprintf (fp,"# e.g., if you have a bunch of files like a.Y a.U a.V, etc., then:\n");
2205 fprintf (fp,"# INPUT_CONVERT cat *.Y *.U *.V\n");
2206 fprintf (fp,"#\n");
2207 fprintf (fp,"# e.g., if you are grabbing from laser disc you might have something like\n");
2208 fprintf (fp,"# INPUT_CONVERT goto frame *; grabppm\n");
2209 fprintf (fp,"# 'INPUT_CONVERT *' means the files are already in the base file format\n");
2210 fprintf (fp,"#\n");
2211 fprintf (fp,"INPUT_CONVERT * \n");
2212 fprintf (fp,"\n");
2213 fprintf (fp,"# number of frames in a GOP.\n");
2214 fprintf (fp,"#\n");
2215 fprintf (fp,"# since each GOP must have at least one I-frame, the encoder will find the\n");
2216 fprintf (fp,"# the first I-frame after GOP_SIZE frames to start the next GOP\n");
2217 fprintf (fp,"#\n");
2218 fprintf (fp,"# later, will add more flexible GOP signalling\n");
2219 fprintf (fp,"#\n");
2220 fprintf (fp,"GOP_SIZE 1\n");
2221 fprintf (fp,"\n");
2222 fprintf (fp,"# number of slices in a frame\n");
2223 fprintf (fp,"#\n");
2224 fprintf (fp,"# 1 is a good number. another possibility is the number of macroblock rows\n");
2225 fprintf (fp,"# (which is the height divided by 16)\n");
2226 fprintf (fp,"#\n");
2227 fprintf (fp,"SLICES_PER_FRAME 1\n");
2228 fprintf (fp,"PIXEL HALF");
2229 fprintf (fp,"\n");
2230 fprintf (fp,"# directory to get all input files from (makes this file easier to read)\n");
2231 fprintf (fp,"INPUT_DIR %s\n",fMovieTempFolderPath.toStdString().c_str());
2232 fprintf (fp,"\n");
2233 fprintf (fp,"# There are a bunch of ways to specify the input files.\n");
2234 fprintf (fp,"# from a simple one-per-line listing, to the following \n");
2235 fprintf (fp,"# way of numbering them. See the manual for more information.\n");
2236 fprintf (fp,"INPUT\n");
2237 fprintf (fp,"# '*' is replaced by the numbers 01, 02, 03, 04\n");
2238 fprintf (fp,"# if I instead do [01-11], it would be 01, 02, ..., 09, 10, 11\n");
2239 fprintf (fp,"# if I instead do [1-11], it would be 1, 2, 3, ..., 9, 10, 11\n");
2240 fprintf (fp,"# if I instead do [1-11+3], it would be 1, 4, 7, 10\n");
2241 fprintf (fp,"# the program assumes none of your input files has a name ending in ']'\n");
2242 fprintf (fp,"# if you do, too bad!!!\n");
2243 fprintf (fp,"#\n");
2244 fprintf (fp,"#\n");
2245 fprintf (fp,"Test*.ppm [0-%d]\n",fRecordFrameNumber-1);
2246 fprintf (fp,"# can have more files here if you want...there is no limit on the number\n");
2247 fprintf (fp,"# of files\n");
2248 fprintf (fp,"END_INPUT\n");
2249 fprintf (fp,"\n");
2250 fprintf (fp,"\n");
2251 fprintf (fp,"\n");
2252 fprintf (fp,"# Many of the remaining options have to do with the motion search and qscale\n");
2253 fprintf (fp,"\n");
2254 fprintf (fp,"# FULL or HALF -- must be upper case\n");
2255 fprintf (fp,"# Should be FULL for computer generated images\n");
2256 fprintf (fp,"PIXEL FULL\n");
2257 fprintf (fp,"\n");
2258 fprintf (fp,"# means +/- this many pixels for both P and B frame searches\n");
2259 fprintf (fp,"# specify two numbers if you wish to serc different ranges in the two.\n");
2260 fprintf (fp,"RANGE 10\n");
2261 fprintf (fp,"\n");
2262 fprintf (fp,"# The two search algorithm parameters below mostly affect speed,\n");
2263 fprintf (fp,"# with some affect on compression and almost none on quality.\n");
2264 fprintf (fp,"\n");
2265 fprintf (fp,"# this must be one of {EXHAUSTIVE, SUBSAMPLE, LOGARITHMIC}\n");
2266 fprintf (fp,"PSEARCH_ALG LOGARITHMIC\n");
2267 fprintf (fp,"\n");
2268 fprintf (fp,"# this must be one of {SIMPLE, CROSS2, EXHAUSTIVE}\n");
2269 fprintf (fp,"#\n");
2270 fprintf (fp,"# note that EXHAUSTIVE is really, really, really slow\n");
2271 fprintf (fp,"#\n");
2272 fprintf (fp,"BSEARCH_ALG SIMPLE\n");
2273 fprintf (fp,"\n");
2274 fprintf (fp,"#\n");
2275 fprintf (fp,"# these specify the q-scale for I, P, and B frames\n");
2276 fprintf (fp,"# (values must be between 1 and 31)\n");
2277 fprintf (fp,"# These are the Qscale values for the entire frame in variable bit-rate\n");
2278 fprintf (fp,"# mode, and starting points (but not important) for constant bit rate\n");
2279 fprintf (fp,"#\n");
2280 fprintf (fp,"\n");
2281 fprintf (fp,"# Qscale (Quantization scale) affects quality and compression,\n");
2282 fprintf (fp,"# but has very little effect on speed.\n");
2283 fprintf (fp,"\n");
2284 fprintf (fp,"IQSCALE 4\n");
2285 fprintf (fp,"PQSCALE 5\n");
2286 fprintf (fp,"BQSCALE 12\n");
2287 fprintf (fp,"\n");
2288 fprintf (fp,"# this must be ORIGINAL or DECODED\n");
2289 fprintf (fp,"REFERENCE_FRAME ORIGINAL\n");
2290 fprintf (fp,"\n");
2291 fprintf (fp,"# for parallel parameters see parallel.param in the examples subdirectory\n");
2292 fprintf (fp,"\n");
2293 fprintf (fp,"# if you want constant bit-rate mode, specify it as follows (number is bits/sec):\n");
2294 fprintf (fp,"#BIT_RATE 1000000\n");
2295 fprintf (fp,"\n");
2296 fprintf (fp,"# To specify the buffer size (327680 is default, measused in bits, for 16bit words)\n");
2297 fprintf (fp,"BUFFER_SIZE 327680\n");
2298 fprintf (fp,"\n");
2299 fprintf (fp,"# The frame rate is the number of frames/second (legal values:\n");
2300 fprintf (fp,"# 23.976, 24, 25, 29.97, 30, 50 ,59.94, 60\n");
2301 fprintf (fp,"FRAME_RATE 30\n");
2302 fprintf (fp,"\n");
2303 fprintf (fp,"# There are many more options, see the users manual for examples....\n");
2304 fprintf (fp,"# ASPECT_RATIO, USER_DATA, GAMMA, IQTABLE, etc.\n");
2305 fprintf (fp,"\n");
2306 fprintf (fp,"\n");
2307 fclose (fp);
2308
2309 setRecordingInfos("Parameter file "+fParameterFileName+" generated in "+fMovieTempFolderPath);
2310 setRecordingStatus(READY_TO_ENCODE);
2311 return true;
2312}

Referenced by saveVideo().

◆ getColorForPoIndex()

G4Colour G4OpenGLQtViewer::getColorForPoIndex ( int poIndex)
protected

Definition at line 3661 of file G4OpenGLQtViewer.cc.

3661 {
3662 // FIXME 09/2014 : Could be optimize by searching in a tab instead of item->data
3663 QTreeWidgetItem* item = getTreeWidgetItem(poIndex);
3664
3665 if (item != NULL) {
3666
3667 const QColor& color = item->data(2,Qt::UserRole).value<QColor>();
3668 G4Colour g4c(((G4double)color.red())/255,
3669 ((G4double)color.green())/255,
3670 ((G4double)color.blue())/255,
3671 ((G4double)color.alpha())/255);
3672
3673 return g4c;
3674 }
3675 return G4Colour();
3676}

Referenced by G4OpenGLStoredQtViewer::DisplayTimePOColourModification(), and updatePickInfosWidget().

◆ getEncoderPath()

QString G4OpenGLQtViewer::getEncoderPath ( )
Returns
encoder path or "" if it does not exist

Definition at line 1851 of file G4OpenGLQtViewer.cc.

1851 {
1852 return fEncoderPath;
1853}

Referenced by encodeVideo().

◆ GetPrivateVisAttributesModifiers()

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

Reimplemented from G4VViewer.

Definition at line 3680 of file G4OpenGLQtViewer.cc.

3681{
3682 static std::vector<G4ModelingParameters::VisAttributesModifier>
3683 privateVisAttributesModifiers;
3684
3685 privateVisAttributesModifiers.clear();
3686
3687// I don't think we need this. (JA Sep 2016).
3688// // For each modified touchable...
3689// std::map<int,PVPath>::const_iterator i;
3690// for (i = fTreeItemModels.begin();
3691// i != fTreeItemModels.end();
3692// ++i) {
3693//
3694// // How do I know if it's been modified or not?
3695//
3696// int iPO = i->first;
3697// const PVPath& fullPath = i->second;
3698//
3699// // If a physical volume
3700// if (fullPath.size()) {
3701//
3702// // const G4bool& visibilityChanged = ???
3703// // const G4bool& visibility = ???
3704// // const G4bool& colourChanged = ???
3705// // const QColor& colour = ???
3706// // G4Colour g4colour(((G4double)colour.red())/255,
3707// // ((G4double)colour.green())/255,
3708// // ((G4double)colour.blue())/255,
3709// // ((G4double)colour.alpha())/255);
3710// // Next 4 lines are for testing, to be replaced by the above...
3711// G4bool visibilityChanged = true;
3712// G4bool visibility = true;
3713// G4bool colourChanged = true;
3714// G4Colour g4colour(G4Colour::Red());
3715//
3716// // Instantiate a working copy of a G4VisAttributes object...
3717// G4VisAttributes workingVisAtts;
3718// // ...and use it to create vis attribute modifiers...
3719// if (visibilityChanged) {
3720// workingVisAtts.SetVisibility(visibility);
3721// privateVisAttributesModifiers.push_back
3722// (G4ModelingParameters::VisAttributesModifier
3723// (workingVisAtts,
3724// G4ModelingParameters::VASVisibility,
3725// fullPath));
3726// }
3727// if (colourChanged) {
3728// workingVisAtts.SetColour(g4colour);
3729// privateVisAttributesModifiers.push_back
3730// (G4ModelingParameters::VisAttributesModifier
3731// (workingVisAtts,
3732// G4ModelingParameters::VASColour,
3733// fullPath));
3734// }
3735// }
3736// }
3737
3738 return &privateVisAttributesModifiers;
3739}

◆ getSaveFileName()

QString G4OpenGLQtViewer::getSaveFileName ( )
Returns
the save file path

Definition at line 2047 of file G4OpenGLQtViewer.cc.

2047 {
2048 return fSaveFileName ;
2049}

Referenced by encodeVideo(), and generateMpegEncoderParameters().

◆ getTempFolderPath()

QString G4OpenGLQtViewer::getTempFolderPath ( )
Returns
the temp folder path or "" if it does not exist

Definition at line 2013 of file G4OpenGLQtViewer.cc.

2013 {
2014 return fTempFolderPath;
2015}

Referenced by startPauseVideo().

◆ isBadEncoder()

bool G4OpenGLQtViewer::isBadEncoder ( )

Definition at line 1934 of file G4OpenGLQtViewer.cc.

1934 {
1935 if (fRecordingStep == BAD_ENCODER) {
1936 return true;
1937 }
1938 return false;
1939}

◆ isBadOutput()

bool G4OpenGLQtViewer::isBadOutput ( )

Definition at line 1946 of file G4OpenGLQtViewer.cc.

1946 {
1947 if (fRecordingStep == BAD_OUTPUT) {
1948 return true;
1949 }
1950 return false;
1951}

◆ isBadTmp()

bool G4OpenGLQtViewer::isBadTmp ( )

Definition at line 1940 of file G4OpenGLQtViewer.cc.

1940 {
1941 if (fRecordingStep == BAD_TMP) {
1942 return true;
1943 }
1944 return false;
1945}

◆ isCurrentWidget()

bool G4OpenGLQtViewer::isCurrentWidget ( )
protected

Definition at line 4731 of file G4OpenGLQtViewer.cc.

4731 {
4732 G4Qt* interactorManager = G4Qt::getInstance ();
4733 if (!interactorManager->IsExternalApp()) {
4734
4735 // Prevent from repainting a hidden tab (the current tab name has to be the one of th GL viewer)
4736 if ( GetName() != fUiQt->GetViewerTabWidget()->tabText(fUiQt->GetViewerTabWidget()->currentIndex()).toStdString().c_str()) {
4737 return false;
4738 }
4739 }
4740 return true;
4741}
G4VViewer::GetName
const G4String & GetName() const

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

◆ isEncoding()

bool G4OpenGLQtViewer::isEncoding ( )

Definition at line 1899 of file G4OpenGLQtViewer.cc.

1899 {
1900 if (fRecordingStep == ENCODING) {
1901 return true;
1902 }
1903 return false;
1904}

◆ isFailed()

bool G4OpenGLQtViewer::isFailed ( )

Definition at line 1920 of file G4OpenGLQtViewer.cc.

1920 {
1921 if (fRecordingStep == FAILED) {
1922 return true;
1923 }
1924 return false;
1925}

◆ isPaused()

bool G4OpenGLQtViewer::isPaused ( )

Definition at line 1892 of file G4OpenGLQtViewer.cc.

1892 {
1893 if (fRecordingStep == PAUSE) {
1894 return true;
1895 }
1896 return false;
1897}

◆ isReadyToEncode()

bool G4OpenGLQtViewer::isReadyToEncode ( )

Definition at line 1972 of file G4OpenGLQtViewer.cc.

1972 {
1973 if (fRecordingStep == READY_TO_ENCODE) {
1974 return true;
1975 }
1976 return false;
1977}

◆ isRecording()

bool G4OpenGLQtViewer::isRecording ( )

Definition at line 1885 of file G4OpenGLQtViewer.cc.

1885 {
1886 if ((fRecordingStep == START) || (fRecordingStep == CONTINUE)) {
1887 return true;
1888 }
1889 return false;
1890}

◆ isStopped()

bool G4OpenGLQtViewer::isStopped ( )

Definition at line 1913 of file G4OpenGLQtViewer.cc.

1913 {
1914 if (fRecordingStep == STOP) {
1915 return true;
1916 }
1917 return false;
1918}

◆ isSuccess()

bool G4OpenGLQtViewer::isSuccess ( )

Definition at line 1927 of file G4OpenGLQtViewer.cc.

1927 {
1928 if (fRecordingStep == SUCCESS) {
1929 return true;
1930 }
1931 return false;
1932}

◆ isTouchableVisible()

bool G4OpenGLQtViewer::isTouchableVisible ( int POindex)

Definition at line 3460 of file G4OpenGLQtViewer.cc.

3460 {
3461
3462 // If no scene tree (Immediate viewer)
3463 if (fSceneTreeComponentTreeWidget == NULL) {
3464 return false;
3465 }
3466
3467 // should be the next one
3468 // Prevent to get out the std::map
3469 if (fLastSceneTreeWidgetAskForIterator != fLastSceneTreeWidgetAskForIteratorEnd) {
3470 fLastSceneTreeWidgetAskForIterator++;
3471 }
3472 QTreeWidgetItem* item = getTreeWidgetItem(POindex);
3473
3474 if (item != NULL) {
3475 if ( item->checkState(0) == Qt::Checked) {
3476 return true;
3477 }
3478 }
3479 return false;
3480}

Referenced by G4OpenGLStoredQtViewer::POSelected().

◆ isWaiting()

bool G4OpenGLQtViewer::isWaiting ( )

Definition at line 1906 of file G4OpenGLQtViewer.cc.

1906 {
1907 if (fRecordingStep == WAIT) {
1908 return true;
1909 }
1910 return false;
1911}

◆ moveScene()

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

Move the scene of dx, dy, dz values.

Parameters
dxdelta mouse x position
dydelta mouse y position
mouseMove: true if event comes from a mouse move, false if event comes from key action

Definition at line 1446 of file G4OpenGLQtViewer.cc.

1447{
1448 if (fHoldMoveEvent)
1449 return;
1450 fHoldMoveEvent = true;
1451
1452 G4double coefTrans = 0;
1453 GLdouble coefDepth = 0;
1454 if(mouseMove) {
1455 coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinWidth());
1456 if (getWinHeight() <getWinWidth()) {
1457 coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinHeight());
1458 }
1459 } else {
1460 coefTrans = getSceneNearWidth()*fPan_sens;
1461 coefDepth = getSceneDepth()*fDeltaDepth;
1462 }
1463 fVP.IncrementPan(-dx*coefTrans,dy*coefTrans,dz*coefDepth);
1464
1465 updateQWidget();
1466 if (fAutoMove)
1467 ((QApplication*)G4Qt::getInstance ())->processEvents();
1468
1469 fHoldMoveEvent = false;
1470}
G4OpenGLViewer::getSceneDepth
GLdouble getSceneDepth()
Definition G4OpenGLViewer.cc:1066

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

◆ ReadyToDraw()

G4bool G4OpenGLQtViewer::ReadyToDraw ( )
virtual

Reimplemented from G4VViewer.

Definition at line 519 of file G4OpenGLQtViewer.cc.

519 {
520#if QT_VERSION < 0x060000
521 return true;
522#else
523 if(!fGLWidget) return false;
524 auto* qGLW = dynamic_cast<G4QGLWidgetType*>(fGLWidget);
525 if (!qGLW) return false;
526 return qGLW->isValid();
527#endif
528}

◆ resetRecording()

void G4OpenGLQtViewer::resetRecording ( )

Definition at line 1979 of file G4OpenGLQtViewer.cc.

1979 {
1980 setRecordingStatus(WAIT);
1981}

Referenced by savePPMToTemp(), and stopVideo().

◆ ResetView()

void G4OpenGLQtViewer::ResetView ( )
virtual

Reimplemented from G4OpenGLViewer.

Definition at line 2874 of file G4OpenGLQtViewer.cc.

2874 {
2875 G4OpenGLViewer::ResetView();
2876 fDeltaDepth = 0.01;
2877 fDeltaZoom = 0.05;
2878}
G4OpenGLViewer::ResetView
virtual void ResetView()
Definition G4OpenGLViewer.cc:380

Referenced by G4keyPressEvent().

◆ rotateQtScene()

void G4OpenGLQtViewer::rotateQtScene ( float dx,
float dy )
protected
Parameters
dxdelta mouse x position
dydelta mouse y position

Definition at line 1478 of file G4OpenGLQtViewer.cc.

1479{
1480 if (fHoldRotateEvent)
1481 return;
1482 fHoldRotateEvent = true;
1483
1484 rotateScene(dx,dy);
1485
1486 updateQWidget();
1487
1488 fHoldRotateEvent = false;
1489}
G4OpenGLViewer::rotateScene
void rotateScene(G4double dx, G4double dy)
Definition G4OpenGLViewer.cc:1083

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

◆ rotateQtSceneToggle()

void G4OpenGLQtViewer::rotateQtSceneToggle ( float dx,
float dy )
protected
Parameters
dxdelta mouse x position
dydelta mouse y position

Definition at line 1496 of file G4OpenGLQtViewer.cc.

1497{
1498 if (fHoldRotateEvent)
1499 return;
1500 fHoldRotateEvent = true;
1501
1502 rotateSceneToggle(dx,dy);
1503
1504 updateQWidget();
1505
1506 fHoldRotateEvent = false;
1507}
G4OpenGLViewer::rotateSceneToggle
void rotateSceneToggle(G4double dx, G4double dy)
Definition G4OpenGLViewer.cc:1098

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

◆ savePPMToTemp()

void G4OpenGLQtViewer::savePPMToTemp ( )
protected

Definition at line 1006 of file G4OpenGLQtViewer.cc.

1006 {
1007 if (fMovieTempFolderPath == "") {
1008 return;
1009 }
1010 auto qGLW = dynamic_cast<G4QGLWidgetType*> (fGLWidget) ;
1011 if (! qGLW) {
1012 return;
1013 }
1014 QString fileName ="Test"+QString::number(fRecordFrameNumber)+".ppm";
1015 QString filePath =fMovieTempFolderPath+fileName;
1016
1017 QImage image;
1018#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
1019 image = qGLW->grabFrameBuffer();
1020#else
1021 image = qGLW->grabFramebuffer();
1022#endif
1023 bool res = false;
1024
1025 res = image.save(filePath,0);
1026 if (res == false) {
1027 resetRecording();
1028 setRecordingInfos("Can't save tmp file "+filePath);
1029 return;
1030 }
1031
1032 setRecordingInfos("File "+fileName+" saved");
1033 fRecordFrameNumber++;
1034}

◆ saveVideo()

void G4OpenGLQtViewer::saveVideo ( )

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

Definition at line 1722 of file G4OpenGLQtViewer.cc.

1722 {
1723
1724 // if encoder parameter is wrong, display parameters dialog and return
1725 if (!fMovieParametersDialog) {
1726 showMovieParametersDialog();
1727 }
1728
1729 fMovieParametersDialog->checkEncoderSwParameters();
1730 fMovieParametersDialog->checkSaveFileNameParameters();
1731
1732 if (fRecordingStep == STOP) {
1733 setRecordingStatus(SAVE);
1734 generateMpegEncoderParameters();
1735 encodeVideo();
1736 }
1737}

◆ setBadEncoder()

void G4OpenGLQtViewer::setBadEncoder ( )

Definition at line 1953 of file G4OpenGLQtViewer.cc.

1953 {
1954 fRecordingStep = BAD_ENCODER;
1955 displayRecordingStatus();
1956}

◆ setBadOutput()

void G4OpenGLQtViewer::setBadOutput ( )

Definition at line 1961 of file G4OpenGLQtViewer.cc.

1961 {
1962 fRecordingStep = BAD_OUTPUT;
1963 displayRecordingStatus();
1964}

◆ setBadTmp()

void G4OpenGLQtViewer::setBadTmp ( )

Definition at line 1957 of file G4OpenGLQtViewer.cc.

1957 {
1958 fRecordingStep = BAD_TMP;
1959 displayRecordingStatus();
1960}

◆ setEncoderPath()

QString G4OpenGLQtViewer::setEncoderPath ( QString path)

set the new encoder path

Returns
"" if correct. The error otherwise

Definition at line 1860 of file G4OpenGLQtViewer.cc.

1860 {
1861 if (path == "") {
1862 return "ppmtompeg is needed to encode in video format. It is available here: http://netpbm.sourceforge.net ";
1863 }
1864
1865 path = QDir::cleanPath(path);
1866 QFileInfo *f = new QFileInfo(path);
1867 if (!f->exists()) {
1868 return "File does not exist";
1869 } else if (f->isDir()) {
1870 return "This is a directory";
1871 } else if (!f->isExecutable()) {
1872 return "File exist but is not executable";
1873 } else if (!f->isFile()) {
1874 return "This is not a file";
1875 }
1876 fEncoderPath = path;
1877
1878 if (fRecordingStep == BAD_ENCODER) {
1879 setRecordingStatus(STOP);
1880 }
1881 return "";
1882}

◆ setSaveFileName()

QString G4OpenGLQtViewer::setSaveFileName ( QString path)

set the save file name path

Returns
"" if correct. The error otherwise

Definition at line 2021 of file G4OpenGLQtViewer.cc.

2021 {
2022
2023 if (path == "") {
2024 return "Path does not exist";
2025 }
2026
2027 QFileInfo *file = new QFileInfo(path);
2028 QDir dir = file->dir();
2029 path = QDir::cleanPath(path);
2030 if (file->exists()) {
2031 return "File already exist, please choose a new one";
2032 } else if (!dir.exists()) {
2033 return "Dir does not exist";
2034 } else if (!dir.isReadable()) {
2035 return path +" is read protected";
2036 }
2037
2038 if (fRecordingStep == BAD_OUTPUT) {
2039 setRecordingStatus(STOP);
2040 }
2041 fSaveFileName = path;
2042 return "";
2043}

◆ setTempFolderPath()

QString G4OpenGLQtViewer::setTempFolderPath ( QString path)

set the temp folder path

Returns
"" if correct. The error otherwise

Definition at line 1987 of file G4OpenGLQtViewer.cc.

1987 {
1988
1989 if (path == "") {
1990 return "Path does not exist";
1991 }
1992 path = QDir::cleanPath(path);
1993 QFileInfo *d = new QFileInfo(path);
1994 if (!d->exists()) {
1995 return "Path does not exist";
1996 } else if (!d->isDir()) {
1997 return "This is not a directory";
1998 } else if (!d->isReadable()) {
1999 return path +" is read protected";
2000 } else if (!d->isWritable()) {
2001 return path +" is write protected";
2002 }
2003
2004 if (fRecordingStep == BAD_TMP) {
2005 setRecordingStatus(WAIT);
2006 }
2007 fTempFolderPath = path;
2008 return "";
2009}

◆ setWaiting()

void G4OpenGLQtViewer::setWaiting ( )

Definition at line 1966 of file G4OpenGLQtViewer.cc.

1966 {
1967 fRecordingStep = WAIT;
1968 displayRecordingStatus();
1969}

◆ startPauseVideo

void G4OpenGLQtViewer::startPauseVideo ( )
slot

Start/Pause the video..

Definition at line 1742 of file G4OpenGLQtViewer.cc.

1742 {
1743
1744 // first time, if temp parameter is wrong, display parameters dialog and return
1745
1746 if ( fRecordingStep == WAIT) {
1747 if ( fRecordFrameNumber == 0) {
1748 if (getTempFolderPath() == "") { // BAD_OUTPUT
1749 showMovieParametersDialog();
1750 setRecordingInfos("You should specified the temp folder in order to make movie");
1751 return;
1752 } else {
1753 // remove temp folder if it was create
1754 QString tmp = removeTempFolder();
1755 if (tmp !="") {
1756 setRecordingInfos(tmp);
1757 return;
1758 }
1759 tmp = createTempFolder();
1760 if (tmp != "") {
1761 setRecordingInfos("Can't create temp folder."+tmp);
1762 return;
1763 }
1764 }
1765 }
1766 }
1767 if (fRecordingStep == WAIT) {
1768 setRecordingStatus(START);
1769 } else if (fRecordingStep == START) {
1770 setRecordingStatus(PAUSE);
1771 } else if (fRecordingStep == PAUSE) {
1772 setRecordingStatus(CONTINUE);
1773 } else if (fRecordingStep == CONTINUE) {
1774 setRecordingStatus(PAUSE);
1775 }
1776}

Referenced by G4keyPressEvent().

◆ stopVideo()

void G4OpenGLQtViewer::stopVideo ( )

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

Definition at line 1699 of file G4OpenGLQtViewer.cc.

1699 {
1700
1701 // if encoder parameter is wrong, display parameters dialog and return
1702 if (!fMovieParametersDialog) {
1703 showMovieParametersDialog();
1704 }
1705 setRecordingStatus(STOP);
1706
1707 if (fRecordFrameNumber >0) {
1708 // check parameters if they were modified (Re APPLY them...)
1709 if (!(fMovieParametersDialog->checkEncoderSwParameters())) {
1710 setRecordingStatus(BAD_ENCODER);
1711 } else if (!(fMovieParametersDialog->checkSaveFileNameParameters())) {
1712 setRecordingStatus(BAD_OUTPUT);
1713 }
1714 } else {
1715 resetRecording();
1716 setRecordingInfos("No frame to encode.");
1717 }
1718}

Referenced by G4keyPressEvent().

◆ updateKeyModifierState()

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

Definition at line 1674 of file G4OpenGLQtViewer.cc.

1674 {
1675 // Check Qt Versions for META Keys
1676
1677 fNoKeyPress = true;
1678 fAltKeyPress = false;
1679 fShiftKeyPress = false;
1680 fControlKeyPress = false;
1681
1682 if (modifier & Qt::AltModifier ) {
1683 fAltKeyPress = true;
1684 fNoKeyPress = false;
1685 }
1686 if (modifier & Qt::ShiftModifier ) {
1687 fShiftKeyPress = true;
1688 fNoKeyPress = false;
1689 }
1690 if (modifier & Qt::ControlModifier ) {
1691 fControlKeyPress = true;
1692 fNoKeyPress = false;
1693 }
1694}

Referenced by G4keyPressEvent(), and G4MouseMoveEvent().

◆ updatePickInfosWidget()

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

Update the pick infos component widget

Definition at line 4530 of file G4OpenGLQtViewer.cc.

4530 {
4531 fLastPickPoint = QPoint(aX,aY);
4532
4533 if (!isCurrentWidget()) {
4534 return;
4535 }
4536 // Ensure case where closing a UI tab close the widget
4537 if (!fPickInfosWidget) {
4538 createPickInfosWidget();
4539 }
4540
4541#if QT_VERSION < 0x060000
4542#else
4543 {auto* qGLW = dynamic_cast<G4QGLWidgetType*> (fGLWidget) ;
4544 if (qGLW) qGLW->makeCurrent();}
4545 ResizeGLView();
4546#endif
4547 const std::vector < G4OpenGLViewerPickMap* > & pickMapVector = GetPickDetails(aX,aY);
4548
4549 // remove all previous widgets
4550 if (fPickInfosWidget) {
4551 QLayoutItem * wItem;
4552 if (fPickInfosWidget->layout()->count()) {
4553 while ((wItem = fPickInfosWidget->layout()->takeAt(0)) != 0) {
4554 delete wItem->widget();
4555 delete wItem;
4556 }
4557 }
4558 } else {
4559 // Ensure case where closing a UI tab close the widget
4560 if (!fPickInfosWidget) {
4561 createPickInfosWidget();
4562 }
4563 }
4564
4565 // parse all pick results
4566 G4int nPickedObjectsWithAttributes = 0;
4567 for (unsigned int a=0; a< pickMapVector.size(); a++) {
4568 const auto& pickMap = pickMapVector[a];
4569 // Add a box inside the pick viewer box
4570 std::ostringstream label;
4571 std::ostringstream content;
4572 std::string txt = pickMap->getAttributes()[0].data();
4573 if (pickMapVector[a]->getAttributes().size()) {
4574 ++nPickedObjectsWithAttributes;
4575
4576 std::size_t pos1 = txt.find(':');
4577 std::string storeKey = txt.substr(0,pos1);
4578
4579 if (storeKey == "G4PhysicalVolumeModel") {
4580
4581 label << "Volume:";
4582 std::size_t pos2 = txt.find(':',pos1+1);
4583 std::size_t pos3 = txt.find('\n',pos2+1);
4584 label << txt.substr(pos2+1,pos3-pos2-1);
4585
4586 } else if (storeKey == "G4TrajectoriesModel") {
4587
4588 label << "Trajectory:";
4589 std::size_t pos2 = txt.find(':',pos1+1);
4590 std::size_t pos3 = txt.find('\n',pos2+1);
4591 label << " Run:" << txt.substr(pos2+1,pos3-pos2-1);
4592 std::size_t pos4 = txt.find(':',pos3+1);
4593 std::size_t pos5 = txt.find('\n',pos4+1);
4594 label << ", Event:" << txt.substr(pos4+1,pos5-pos4-1);
4595
4596 } else {
4597
4598 label << "Hit number:" << a << ", PickName: " << pickMap->getPickName();
4599
4600 }
4601
4602 // Accumulate all content with the same pickname
4603 content << pickMap->print().data();
4604 G4int thisPickName = pickMap->getPickName();
4605 while (++a < pickMapVector.size()) {
4606 const auto& a_pickMap = pickMapVector[a];
4607 if (a_pickMap->getPickName() == thisPickName) {
4608 content << a_pickMap->print().data();
4609 } else {
4610 a--;
4611 break;
4612 }
4613 }
4614
4615 QPushButton* pickCoutButton = new QPushButton(label.str().c_str());
4616 pickCoutButton->setStyleSheet ("text-align: left; padding: 1px; border: 0px;");
4617 pickCoutButton->setIcon(*fTreeIconClosed);
4618 fPickInfosWidget->layout()->addWidget(pickCoutButton);
4619
4620 QStringList newStr;
4621
4622 // Add to stringList
4623 newStr = QStringList(QString(content.str().c_str()).trimmed());
4624
4625 QTextEdit* ed = new QTextEdit();
4626 ed->setReadOnly(true);
4627 fPickInfosWidget->layout()->addWidget(ed);
4628 ed->setVisible((false));
4629 ed->append(newStr.join(""));
4630
4631 std::cout << pickCoutButton->text().toStdString() << " "<< fPickInfosWidget->layout()->count()-1<< std::endl;
4632 int tmp = fPickInfosWidget->layout()->count()-1;
4633 connect(pickCoutButton, &QPushButton::clicked , [this, tmp](){ this->toggleSceneTreeComponentPickingCout(tmp);});
4634 }
4635 }
4636
4637 // add a label to push everything up!
4638 QLabel * pushUp = new QLabel("");
4639 QSizePolicy vPolicy = QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
4640 vPolicy.setVerticalStretch(10);
4641 pushUp->setSizePolicy(vPolicy);
4642 fPickInfosWidget->layout()->addWidget(pushUp);
4643
4644 // highlight the first one :
4645
4646 // first un-highlight the last selected
4647 changeColorAndTransparency(fLastHighlightName,fLastHighlightColor);
4648
4649 if (pickMapVector.size() > 0 ) {
4650 // get the new one
4651 fLastHighlightName = pickMapVector[0]->getPickName();
4652 fLastHighlightColor = getColorForPoIndex(fLastHighlightName);
4653 // set the new one
4654 changeColorAndTransparency(fLastHighlightName,G4Color(1,1,1,1));
4655
4656 updateQWidget();
4657 }
4658 QDialog* dial = static_cast<QDialog*> (fUIPickInfosWidget->parent());
4659 if (dial) {
4660 // change name
4661 std::ostringstream oss;
4662 if (nPickedObjectsWithAttributes == 0) {
4663 oss << "No object";
4664 } else if (nPickedObjectsWithAttributes == 1) {
4665 oss << "1 object";
4666 } else {
4667 oss << nPickedObjectsWithAttributes << " objects";
4668 }
4669 oss << " selected - " << GetName();
4670 dial->setWindowTitle(oss.str().c_str());
4671 }
4672 // set picking cout visible
4673 fPickInfosScrollArea->setVisible(true);
4674}
G4OpenGLQtViewer::getColorForPoIndex
G4Colour getColorForPoIndex(int poIndex)
Definition G4OpenGLQtViewer.cc:3661
G4OpenGLViewer::GetPickDetails
const std::vector< G4OpenGLViewerPickMap * > & GetPickDetails(GLdouble x, GLdouble y)
Definition G4OpenGLViewer.cc:434

Referenced by G4MouseReleaseEvent().

◆ updateQWidget()

virtual void G4OpenGLQtViewer::updateQWidget ( )
pure virtual

Implemented in G4OpenGLImmediateQtViewer, and G4OpenGLStoredQtViewer.

Referenced by G4keyPressEvent(), G4MousePressEvent(), G4wheelEvent(), moveScene(), rotateQtScene(), rotateQtSceneToggle(), and updatePickInfosWidget().

◆ updateSceneTreeWidget()

void G4OpenGLQtViewer::updateSceneTreeWidget ( )

Update the scene tree widget

Definition at line 4211 of file G4OpenGLQtViewer.cc.

4211 {
4212 // Ensure case where closing a UI tab close the widget
4213 if (!fSceneTreeWidget) {
4214 createSceneTreeWidget();
4215 }
4216}

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

◆ updateToolbarAndMouseContextMenu

void G4OpenGLQtViewer::updateToolbarAndMouseContextMenu ( )
protectedslot

Update the toolbar Icons/Mouse context menu

  • Change ortho/perspective
  • Change surface style
  • Change cursor style

Definition at line 4109 of file G4OpenGLQtViewer.cc.

4109 {
4110 if (fBatchMode) {
4111 return;
4112 }
4113
4114 G4ViewParameters::DrawingStyle
4115 d_style = fVP.GetDrawingStyle();
4116
4117 // Surface style
4118 if (d_style == G4ViewParameters::wireframe) {
4119 if (fUiQt) fUiQt->SetIconWireframeSelected();
4120 if (fContextMenu) {
4121 fDrawingWireframe->setChecked(true);
4122 fDrawingLineRemoval->setChecked(false);
4123 fDrawingSurfaceRemoval->setChecked(false);
4124 fDrawingLineSurfaceRemoval->setChecked(false);
4125 }
4126 } else if (d_style == G4ViewParameters::hlr) {
4127 if (fUiQt) fUiQt->SetIconHLRSelected();
4128 if (fContextMenu) {
4129 fDrawingLineRemoval->setChecked(true);
4130 fDrawingWireframe->setChecked(false);
4131 fDrawingSurfaceRemoval->setChecked(false);
4132 fDrawingLineSurfaceRemoval->setChecked(false);
4133 }
4134 } else if (d_style == G4ViewParameters::hsr) {
4135 if (fUiQt) fUiQt->SetIconSolidSelected();
4136 if (fContextMenu) {
4137 fDrawingSurfaceRemoval->setChecked(true);
4138 fDrawingWireframe->setChecked(false);
4139 fDrawingLineRemoval->setChecked(false);
4140 fDrawingLineSurfaceRemoval->setChecked(false);
4141 }
4142 } else if (d_style == G4ViewParameters::hlhsr) {
4143 if (fUiQt) fUiQt->SetIconHLHSRSelected();
4144 if (fContextMenu) {
4145 fDrawingLineSurfaceRemoval->setChecked(true);
4146 fDrawingWireframe->setChecked(false);
4147 fDrawingLineRemoval->setChecked(false);
4148 fDrawingSurfaceRemoval->setChecked(false);
4149 fDrawingLineSurfaceRemoval->setChecked(false);
4150 }
4151 }
4152
4153
4154 // projection style
4155 G4double d_proj = fVP.GetFieldHalfAngle () ;
4156 if (d_proj == 0.) { // ortho
4157 if (fUiQt) fUiQt->SetIconOrthoSelected();
4158 if (fContextMenu) {
4159 fProjectionOrtho->setChecked(true);
4160 fProjectionPerspective->setChecked(false);
4161 }
4162 } else {
4163 if (fUiQt) fUiQt->SetIconPerspectiveSelected();
4164 if (fContextMenu) {
4165 fProjectionPerspective->setChecked(true);
4166 fProjectionOrtho->setChecked(false);
4167 }
4168 }
4169
4170
4171 // mouse style : They are controlled by UI !
4172 if (fUiQt && fContextMenu) {
4173 if (fUiQt->IsIconPickSelected()) {
4174 fMousePickAction->setChecked(true);
4175 fMouseZoomOutAction->setChecked(false);
4176 fMouseZoomInAction->setChecked(false);
4177 fMouseRotateAction->setChecked(false);
4178 fMouseMoveAction->setChecked(false);
4179 } else if (fUiQt->IsIconZoomOutSelected()) {
4180 fMouseZoomOutAction->setChecked(true);
4181 fMousePickAction->setChecked(false);
4182 fMouseZoomInAction->setChecked(false);
4183 fMouseRotateAction->setChecked(false);
4184 fMouseMoveAction->setChecked(false);
4185 } else if (fUiQt->IsIconZoomInSelected()) {
4186 fMouseZoomInAction->setChecked(true);
4187 fMousePickAction->setChecked(false);
4188 fMouseZoomOutAction->setChecked(false);
4189 fMouseRotateAction->setChecked(false);
4190 fMouseMoveAction->setChecked(false);
4191 } else if (fUiQt->IsIconRotateSelected()) {
4192 fMouseRotateAction->setChecked(true);
4193 fMousePickAction->setChecked(false);
4194 fMouseZoomOutAction->setChecked(false);
4195 fMouseZoomInAction->setChecked(false);
4196 fMouseMoveAction->setChecked(false);
4197 } else if (fUiQt->IsIconMoveSelected()) {
4198 fMouseMoveAction->setChecked(true);
4199 fMousePickAction->setChecked(false);
4200 fMouseZoomOutAction->setChecked(false);
4201 fMouseZoomInAction->setChecked(false);
4202 fMouseRotateAction->setChecked(false);
4203 }
4204 }
4205}

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

◆ updateViewerPropertiesTableWidget()

void G4OpenGLQtViewer::updateViewerPropertiesTableWidget ( )

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 4223 of file G4OpenGLQtViewer.cc.

4223 {
4224
4225 if (!isCurrentWidget()) {
4226 return;
4227 }
4228
4229 // Ensure case where closing a UI tab close the widget
4230 if (!fViewerPropertiesTableWidget) {
4231 createViewerPropertiesWidget();
4232 }
4233 int treeWidgetInfosIgnoredCommands = 0;
4234 G4UImanager* UI = G4UImanager::GetUIpointer();
4235 G4UIcommandTree * commandTreeTop = UI->GetTree();
4236 G4UIcommandTree* path = commandTreeTop->FindCommandTree("/vis/viewer/set/");
4237
4238 if (!path) {
4239 return;
4240 }
4241
4242 // clear old table
4243 if ((path->GetCommandEntry()-fTreeWidgetInfosIgnoredCommands) != fViewerPropertiesTableWidget->rowCount()) {
4244 fViewerPropertiesTableWidget->clear();
4245 }
4246
4247 fViewerPropertiesTableWidget->blockSignals(true);
4248 // TODO : Could be optimized by comparing current command to old commands. That should not change so much
4249
4250 fViewerPropertiesTableWidget->setColumnCount (2);
4251 fViewerPropertiesTableWidget->setRowCount (path->GetCommandEntry()-fTreeWidgetInfosIgnoredCommands);
4252 fViewerPropertiesTableWidget->setHorizontalHeaderLabels(QStringList() << tr("Property")
4253 << tr("Value"));
4254 fViewerPropertiesTableWidget->verticalHeader()->setVisible(false);
4255 fViewerPropertiesTableWidget->setAlternatingRowColors (true);
4256
4257 // For the moment, we do only command that have a "set" command in UI
4258
4259 for (int a=0;a<path->GetCommandEntry();a++) {
4260 G4UIcommand* commandTmp = path->GetCommand(a+1);
4261
4262 // get current parameters
4263 QString params = "";
4264
4265 if(commandTmp->GetCommandName() == "autoRefresh") {
4266 if (fVP.IsAutoRefresh()) {
4267 params = "True";
4268 } else {
4269 params = "False";
4270 }
4271 } else if(commandTmp->GetCommandName() == "auxiliaryEdge") {
4272 if (fVP.IsAuxEdgeVisible()) {
4273 params = "True";
4274 } else {
4275 params = "False";
4276 }
4277 } else if(commandTmp->GetCommandName() == "background") {
4278 params = QString().number(fVP.GetBackgroundColour().GetRed()) + " "+
4279 QString().number(fVP.GetBackgroundColour().GetGreen()) + " "+
4280 QString().number(fVP.GetBackgroundColour().GetBlue()) + " "+
4281 QString().number(fVP.GetBackgroundColour().GetAlpha());
4282
4283 } else if(commandTmp->GetCommandName() == "culling") {
4284 params = QString().number(fVP. IsCulling ());
4285 } else if(commandTmp->GetCommandName() == "cutawayMode") {
4286 if (fVP.GetCutawayMode() == G4ViewParameters::cutawayUnion) {
4287 params = "union";
4288 } else {
4289 params = "intersection";
4290 }
4291
4292 } else if(commandTmp->GetCommandName() == "defaultColour") {
4293 params = QString().number(fVP.GetDefaultVisAttributes()->GetColor().GetRed()) + " "+
4294 QString().number(fVP.GetDefaultVisAttributes()->GetColor().GetGreen()) + " "+
4295 QString().number(fVP.GetDefaultVisAttributes()->GetColor().GetBlue()) + " "+
4296 QString().number(fVP.GetDefaultVisAttributes()->GetColor().GetAlpha());
4297
4298 } else if(commandTmp->GetCommandName() == "defaultTextColour") {
4299 params = QString().number(fVP.GetDefaultTextVisAttributes()->GetColor().GetRed()) + " "+
4300 QString().number(fVP.GetDefaultTextVisAttributes()->GetColor().GetGreen()) + " "+
4301 QString().number(fVP.GetDefaultTextVisAttributes()->GetColor().GetBlue()) + " "+
4302 QString().number(fVP.GetDefaultTextVisAttributes()->GetColor().GetAlpha());
4303
4304 } else if(commandTmp->GetCommandName() == "edge") {
4305 G4ViewParameters::DrawingStyle existingStyle = fVP.GetDrawingStyle();
4306 params = "False";
4307 if (existingStyle == G4ViewParameters::hsr) {
4308 params = "True";
4309 }
4310
4311 } else if(commandTmp->GetCommandName() == "explodeFactor") {
4312 params = QString().number(fVP.GetExplodeFactor()) + " " + QString(G4String(G4BestUnit(fVP.GetExplodeFactor(),"Length")).data());
4313
4314 } else if(commandTmp->GetCommandName() == "globalLineWidthScale") {
4315 params = QString().number(fVP.GetGlobalLineWidthScale());
4316
4317 } else if(commandTmp->GetCommandName() == "globalMarkerScale") {
4318 params = QString().number(fVP.GetGlobalMarkerScale());
4319
4320 } else if(commandTmp->GetCommandName() == "hiddenEdge") {
4321 G4ViewParameters::DrawingStyle style = fVP.GetDrawingStyle();
4322 if ((style == G4ViewParameters::hlr) ||
4323 (style == G4ViewParameters::hlhsr)) {
4324 params = "True";
4325 } else {
4326 params = "False";
4327 }
4328
4329 } else if(commandTmp->GetCommandName() == "hiddenMarker") {
4330 if (fVP.IsMarkerNotHidden()) {
4331 params = "False";
4332 } else {
4333 params = "True";
4334 }
4335
4336 } else if(commandTmp->GetCommandName() == "lightsMove") {
4337 if (fVP.GetLightsMoveWithCamera()) {
4338 params = "camera";
4339 } else {
4340 params = "object";
4341 }
4342 } else if(commandTmp->GetCommandName() == "lightsThetaPhi") {
4343 G4Vector3D direction = fVP.GetLightpointDirection();
4344 // degree
4345 params = QString().number(direction.theta()/CLHEP::degree)+ " "+ QString().number(direction.phi()/CLHEP::degree)+" deg";
4346 if (commandTmp->GetParameterEntries() == 3) {
4347 if (commandTmp->GetParameter(2)->GetDefaultValue() != "deg") {
4348 params = QString().number(direction.theta())+ " "+ QString().number(direction.phi())+" "+commandTmp->GetParameter(2)->GetDefaultValue().data();
4349 }
4350 }
4351 } else if(commandTmp->GetCommandName() == "lightsVector") {
4352 params = QString().number(fVP.GetLightpointDirection().x()) + " "+
4353 QString().number(fVP.GetLightpointDirection().y()) + " "+
4354 QString().number(fVP.GetLightpointDirection().z());
4355
4356 } else if(commandTmp->GetCommandName() == "lineSegmentsPerCircle") {
4357 params = QString().number(fVP.GetNoOfSides());
4358
4359 } else if(commandTmp->GetCommandName() == "picking") {
4360 if (fVP.IsPicking()) {
4361 params = "True";
4362 } else {
4363 params = "False";
4364 }
4365
4366 } else if(commandTmp->GetCommandName() == "projection") {
4367 if (fVP.GetFieldHalfAngle() == 0.) {
4368 params = "orthogonal";
4369 } else {
4370 params = QString("perspective ") + QString().number(fVP.GetFieldHalfAngle()/CLHEP::degree) + " deg";
4371 }
4372
4373 } else if(commandTmp->GetCommandName() == "rotationStyle") {
4374 if (fVP.GetRotationStyle() == G4ViewParameters::constrainUpDirection) {
4375 params = "constrainUpDirection";
4376 } else {
4377 params = "freeRotation";
4378 }
4379
4380 } else if(commandTmp->GetCommandName() == "sectionPlane") {
4381 if (fVP.IsSection()) {
4382 params = QString("on ") +
4383 G4String(G4BestUnit(fVP.GetSectionPlane().point(),"Length")).data()+
4384 QString().number(fVP.GetSectionPlane().normal().x())
4385 + " " + QString().number(fVP.GetSectionPlane().normal().y())
4386 + " " + QString().number(fVP.GetSectionPlane().normal().z());
4387 } else {
4388 params = "off";
4389 }
4390
4391 } else if(commandTmp->GetCommandName() == "style") {
4392 if (fVP.GetDrawingStyle() == G4ViewParameters::wireframe || fVP.GetDrawingStyle() == G4ViewParameters::hlr) {
4393 params = "wireframe";
4394 } else {
4395 params = "surface";
4396 }
4397
4398
4399 } else if(commandTmp->GetCommandName() == "targetPoint") {
4400 G4Point3D point = fVP.GetCurrentTargetPoint();
4401 if (fSceneHandler.GetScene()) {
4402 G4String b = G4BestUnit(fSceneHandler.GetScene()->GetStandardTargetPoint() + fVP.GetCurrentTargetPoint(),"Length");
4403 params = b.data();
4404 }
4405 } else if(commandTmp->GetCommandName() == "upThetaPhi") {
4406 G4Vector3D up = fVP.GetUpVector();
4407 // degree
4408 params = QString().number(up.theta()/CLHEP::degree)+ " "+ QString().number(up.phi()/CLHEP::degree)+" deg";
4409 if (commandTmp->GetParameterEntries() == 3) {
4410 if (commandTmp->GetParameter(2)->GetDefaultValue() != "deg") {
4411 params = QString().number(up.theta())+ " "+ QString().number(up.phi())+" "+commandTmp->GetParameter(2)->GetDefaultValue().data();
4412 }
4413 }
4414 } else if(commandTmp->GetCommandName() == "upVector") {
4415 G4Vector3D up = fVP.GetUpVector();
4416 params = QString().number(up.x())+ " "+ QString().number(up.y())+" "+QString().number(up.z())+ " ";
4417
4418 } else if(commandTmp->GetCommandName() == "viewpointThetaPhi") {
4419 G4Vector3D direction = fVP.GetViewpointDirection();
4420 // degree
4421 params = QString().number(direction.theta()/CLHEP::degree)+ " "+ QString().number(direction.phi()/CLHEP::degree)+" deg";
4422 if (commandTmp->GetParameterEntries() == 3) {
4423 if (commandTmp->GetParameter(2)->GetDefaultValue() != "deg") {
4424 params = QString().number(direction.theta())+ " "+ QString().number(direction.phi())+" "+commandTmp->GetParameter(2)->GetDefaultValue().data();
4425 }
4426 }
4427 } else if(commandTmp->GetCommandName() == "viewpointVector") {
4428 G4Vector3D direction = fVP.GetViewpointDirection();
4429 params = QString().number(direction.x())+ " "+ QString().number(direction.y())+" "+QString().number(direction.z());
4430 } else {
4431 // No help
4432 }
4433
4434 /* DO NOT DISPLAY COMMANDS WITHOUT ANY PARAMETERS SET
4435 if (params == "") {
4436 // TODO : display default parameters // should not be editable ?
4437
4438 for( G4int i_thParameter=0; i_thParameter<commandTmp->GetParameterEntries(); i_thParameter++ ) {
4439 commandParam = commandTmp->GetParameter(i_thParameter);
4440
4441 if (QString(QChar(commandParam->GetParameterType())) == "b") {
4442 if (commandParam->GetDefaultValue().data()) {
4443 params += "True";
4444 } else {
4445 params += "False";
4446 }
4447 } else {
4448 params += QString((char*)(commandParam->GetDefaultValue()).data());
4449 }
4450 if (i_thParameter<commandTmp->GetParameterEntries()-1) {
4451 params += " ";
4452 }
4453 }
4454 }
4455 */
4456
4457 if (params != "") {
4458
4459 QTableWidgetItem *nameItem;
4460 QTableWidgetItem *paramItem;
4461
4462 // already present ?
4463 QList<QTableWidgetItem *> list = fViewerPropertiesTableWidget->findItems (commandTmp->GetCommandName().data(),Qt::MatchExactly);
4464 if (list.size() == 1) {
4465 nameItem = list.first();
4466 paramItem = fViewerPropertiesTableWidget->item(nameItem->row(),1);
4467
4468 } else {
4469 nameItem = new QTableWidgetItem();
4470 paramItem = new QTableWidgetItem();
4471 fViewerPropertiesTableWidget->setItem(a-treeWidgetInfosIgnoredCommands, 0, nameItem);
4472 fViewerPropertiesTableWidget->setItem(a-treeWidgetInfosIgnoredCommands, 1, paramItem);
4473
4474 // Set Guidance
4475 QString guidance;
4476 G4int n_guidanceEntry = (G4int)commandTmp->GetGuidanceEntries();
4477 for( G4int i_thGuidance=0; i_thGuidance < n_guidanceEntry; i_thGuidance++ ) {
4478 guidance += QString((char*)(commandTmp->GetGuidanceLine(i_thGuidance)).data()) + "\n";
4479 }
4480
4481 nameItem->setToolTip(guidance);
4482 paramItem->setToolTip(GetCommandParameterList(commandTmp));
4483
4484 fViewerPropertiesTableWidget->setRowHeight(a-treeWidgetInfosIgnoredCommands,15);
4485 }
4486
4487 // set current name and parameters
4488 nameItem->setText(commandTmp->GetCommandName().data());
4489 paramItem->setText(params);
4490
4491 nameItem->setFlags(Qt::NoItemFlags);
4492 nameItem->setForeground(QBrush());
4493
4494 } else {
4495 treeWidgetInfosIgnoredCommands++;
4496 }
4497 }
4498 // remove empty content row
4499 for (int i=0; i<treeWidgetInfosIgnoredCommands; i++) {
4500 fViewerPropertiesTableWidget->removeRow (fViewerPropertiesTableWidget->rowCount() - 1);
4501 }
4502
4503 // The resize should done only at creation
4504 if (!fViewerPropertiesTableWidgetIsInit) {
4505 fViewerPropertiesTableWidgetIsInit = true;
4506
4507 fViewerPropertiesTableWidget->resizeColumnsToContents();
4508
4509 int x = fViewerPropertiesTableWidget->horizontalHeader()->length();
4510 int y = fViewerPropertiesTableWidget->verticalHeader()->length()+ fViewerPropertiesTableWidget->horizontalHeader()->sizeHint().height() + 2;
4511
4512 // fViewerPropertiesTableWidget->verticalHeader()->setResizeMode(QHeaderView::ResizeToContents);
4513 // fViewerPropertiesTableWidget->horizontalHeader()->setResizeMode(QHeaderView::ResizeToContents);
4514
4515 // resize to fit content
4516 QDialog* dial = static_cast<QDialog*> (fUIViewerPropertiesWidget->parent());
4517 if (dial) {
4518 dial->resize(x+56,y+46); // more or less (margins) ...
4519 }
4520 }
4521 fViewerPropertiesTableWidget->blockSignals(false);
4522
4523 fTreeWidgetInfosIgnoredCommands = treeWidgetInfosIgnoredCommands;
4524}
G4BestUnit
#define G4BestUnit(a, b)
Definition G4SteppingVerbose.cc:46
G4Vector3D
HepGeom::Vector3D< G4double > G4Vector3D
Definition G4Vector3D.hh:34
G4UIcommandTree::GetCommandEntry
G4int GetCommandEntry() const
Definition G4UIcommandTree.hh:73
G4UIcommandTree::GetCommand
G4UIcommand * GetCommand(G4int i)
Definition G4UIcommandTree.hh:76
G4UIcommandTree::FindCommandTree
G4UIcommandTree * FindCommandTree(const char *commandPath)
Definition G4UIcommandTree.cc:246
G4UIcommand::GetParameterEntries
std::size_t GetParameterEntries() const
Definition G4UIcommand.hh:127
G4UIcommand::GetGuidanceLine
const G4String & GetGuidanceLine(G4int i) const
Definition G4UIcommand.hh:124
G4UIcommand::GetParameter
G4UIparameter * GetParameter(G4int i) const
Definition G4UIcommand.hh:128
G4UIcommand::GetGuidanceEntries
std::size_t GetGuidanceEntries() const
Definition G4UIcommand.hh:123
G4UIcommand::GetCommandName
const G4String & GetCommandName() const
Definition G4UIcommand.hh:126
G4UImanager::GetTree
G4UIcommandTree * GetTree() const
Definition G4UImanager.hh:176
G4UIparameter::GetDefaultValue
const G4String & GetDefaultValue() const
Definition G4UIparameter.hh:78

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

Member Data Documentation

◆ fGLWidget

QWidget* G4OpenGLQtViewer::fGLWidget
protected

Definition at line 204 of file G4OpenGLQtViewer.hh.

Referenced by CreateMainWindow(), DrawText(), exportImage(), G4keyPressEvent(), G4keyReleaseEvent(), G4manageContextMenuEvent(), G4MouseDoubleClickEvent(), G4MousePressEvent(), G4MouseReleaseEvent(), G4OpenGLQtViewer(), ReadyToDraw(), savePPMToTemp(), and updatePickInfosWidget().

◆ fHasToRepaint

bool G4OpenGLQtViewer::fHasToRepaint
protected

Definition at line 209 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLImmediateQtViewer::G4OpenGLImmediateQtViewer(), G4OpenGLStoredQtViewer::G4OpenGLStoredQtViewer(), G4OpenGLImmediateQtViewer::initializeGL(), G4OpenGLStoredQtViewer::initializeGL(), G4OpenGLImmediateQtViewer::paintEvent(), G4OpenGLStoredQtViewer::paintEvent(), G4OpenGLImmediateQtViewer::paintGL(), G4OpenGLStoredQtViewer::paintGL(), G4OpenGLImmediateQtViewer::resizeGL(), G4OpenGLStoredQtViewer::resizeGL(), G4OpenGLImmediateQtViewer::showEvent(), G4OpenGLStoredQtViewer::showEvent(), G4OpenGLImmediateQtViewer::ShowView(), G4OpenGLImmediateQtViewer::updateQWidget(), and G4OpenGLStoredQtViewer::updateQWidget().

◆ fMouseOnSceneTree

bool G4OpenGLQtViewer::fMouseOnSceneTree
protected

Definition at line 219 of file G4OpenGLQtViewer.hh.

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), and G4OpenGLQtViewer().

◆ fPaintEventLock

bool G4OpenGLQtViewer::fPaintEventLock
protected

Definition at line 212 of file G4OpenGLQtViewer.hh.

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

◆ fQGLWidgetInitialiseCompleted

bool G4OpenGLQtViewer::fQGLWidgetInitialiseCompleted
protected

Definition at line 211 of file G4OpenGLQtViewer.hh.

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

◆ fRecordFrameNumber

int G4OpenGLQtViewer::fRecordFrameNumber
protected

Definition at line 206 of file G4OpenGLQtViewer.hh.

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

◆ fUiQt

G4UIQt* G4OpenGLQtViewer::fUiQt
protected

Definition at line 203 of file G4OpenGLQtViewer.hh.

Referenced by CreateMainWindow(), G4MouseMoveEvent(), G4MousePressEvent(), G4MouseReleaseEvent(), G4OpenGLQtViewer(), isCurrentWidget(), and updateToolbarAndMouseContextMenu().

◆ fUpdateGLLock

bool G4OpenGLQtViewer::fUpdateGLLock
protected

Definition at line 210 of file G4OpenGLQtViewer.hh.

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

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