| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // G4OpenGLQtViewer : Class to provide Qt spec 26 // G4OpenGLQtViewer : Class to provide Qt specific
27 // functionality for OpenG 27 // functionality for OpenGL in GEANT4
28 // 28 //
29 // 27/06/2003 : G.Barrand : implementation (at 29 // 27/06/2003 : G.Barrand : implementation (at last !).
30 // 30/06/2014 : M.Kelsey : Change QPixmap obj 30 // 30/06/2014 : M.Kelsey : Change QPixmap objects to pointers
31 31
32 #include "G4LogicalVolumeStore.hh" 32 #include "G4LogicalVolumeStore.hh"
33 #include "G4PhysicalVolumeStore.hh" 33 #include "G4PhysicalVolumeStore.hh"
34 #include "G4VisCommandsGeometrySet.hh" 34 #include "G4VisCommandsGeometrySet.hh"
35 #include "G4PhysicalVolumeModel.hh" 35 #include "G4PhysicalVolumeModel.hh"
36 #include "G4Text.hh" 36 #include "G4Text.hh"
37 #include "G4UnitsTable.hh" 37 #include "G4UnitsTable.hh"
38 #include "G4OpenGLStoredQtViewer.hh" 38 #include "G4OpenGLStoredQtViewer.hh"
39 #include "G4Threading.hh" 39 #include "G4Threading.hh"
40 40
41 #include "G4OpenGLQtViewer.hh" 41 #include "G4OpenGLQtViewer.hh"
42 #include "G4OpenGLSceneHandler.hh" 42 #include "G4OpenGLSceneHandler.hh"
43 #include "G4OpenGLQtExportDialog.hh" 43 #include "G4OpenGLQtExportDialog.hh"
44 #include "G4OpenGLQtMovieDialog.hh" 44 #include "G4OpenGLQtMovieDialog.hh"
45 #include "G4Qt.hh" 45 #include "G4Qt.hh"
46 #include "G4UIQt.hh" 46 #include "G4UIQt.hh"
47 #include "G4UImanager.hh" 47 #include "G4UImanager.hh"
48 #include "G4UIcommandTree.hh" 48 #include "G4UIcommandTree.hh"
49 49
50 #include <CLHEP/Units/SystemOfUnits.h> 50 #include <CLHEP/Units/SystemOfUnits.h>
51 51
52 #include <typeinfo> 52 #include <typeinfo>
53 #include <mutex> 53 #include <mutex>
54 54
55 #include <qlayout.h> 55 #include <qlayout.h>
56 #include <qlabel.h> 56 #include <qlabel.h>
57 #include <qdialog.h> 57 #include <qdialog.h>
58 #include <qpushbutton.h> 58 #include <qpushbutton.h>
59 #include <qprocess.h> 59 #include <qprocess.h>
>> 60 #include <qdesktopwidget.h>
>> 61
60 #include <qmenu.h> 62 #include <qmenu.h>
61 #include <qimagewriter.h> 63 #include <qimagewriter.h>
62 64
63 #include <qtextedit.h> 65 #include <qtextedit.h>
64 #include <qtreewidget.h> 66 #include <qtreewidget.h>
65 #include <qapplication.h> 67 #include <qapplication.h>
66 #include <qmessagebox.h> 68 #include <qmessagebox.h>
67 #include <qfiledialog.h> 69 #include <qfiledialog.h>
>> 70 #include <qprinter.h>
68 #include <qdatetime.h> 71 #include <qdatetime.h>
69 #if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)) << 72 #if QT_VERSION >= 0x050e00
70 #include <qelapsedtimer.h> 73 #include <qelapsedtimer.h>
71 #endif 74 #endif
72 #if (QT_VERSION < QT_VERSION_CHECK(5, 10, 0)) <<
73 #include "qdesktopwidget.h" <<
74 #endif <<
75 #include <qpainter.h> 75 #include <qpainter.h>
>> 76 #include <qgl.h> // include <qglwidget.h>
76 #include <qdialog.h> 77 #include <qdialog.h>
77 #include <qcolordialog.h> 78 #include <qcolordialog.h>
78 #include <qevent.h> //include <qcontextmenueve 79 #include <qevent.h> //include <qcontextmenuevent.h>
79 #include <qobject.h> 80 #include <qobject.h>
80 #include <qgroupbox.h> 81 #include <qgroupbox.h>
81 #include <qcombobox.h> 82 #include <qcombobox.h>
82 #include <qlineedit.h> 83 #include <qlineedit.h>
>> 84 #if QT_VERSION < 0x050600
>> 85 #include <qsignalmapper.h>
>> 86 #else
83 #include <qscreen.h> 87 #include <qscreen.h>
>> 88 #endif
84 #include <qmainwindow.h> 89 #include <qmainwindow.h>
85 #include <qtablewidget.h> 90 #include <qtablewidget.h>
86 #include <qheaderview.h> 91 #include <qheaderview.h>
87 #include <qscrollarea.h> 92 #include <qscrollarea.h>
88 #include <qsplitter.h> 93 #include <qsplitter.h>
89 #include <qcheckbox.h> 94 #include <qcheckbox.h>
90 #include <qcursor.h> 95 #include <qcursor.h>
91 #include <qthread.h> 96 #include <qthread.h>
92 97
93 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)) <<
94 #include <QGLContext> <<
95 #else <<
96 #include <QOpenGLContext> <<
97 #endif <<
98 <<
99 #ifndef G4GMAKE 98 #ifndef G4GMAKE
100 #include "moc_G4OpenGLQtViewer.cpp" 99 #include "moc_G4OpenGLQtViewer.cpp"
101 #endif 100 #endif
102 101
>> 102 namespace
>> 103 {
>> 104 G4Mutex mWaitForVisSubThreadQtOpenGLContextMoved = G4MUTEX_INITIALIZER;
>> 105 G4Mutex mWaitForVisSubThreadQtOpenGLContextInitialized = G4MUTEX_INITIALIZER;
>> 106 // avoid unused variable warning
>> 107 #ifdef G4MULTITHREADED
>> 108 G4Condition c1_VisSubThreadQtOpenGLContextInitialized = G4CONDITION_INITIALIZER;
>> 109 G4Condition c2_VisSubThreadQtOpenGLContextMoved = G4CONDITION_INITIALIZER;
>> 110 #endif
>> 111 }
>> 112
103 ////////////////////////////////////////////// 113 //////////////////////////////////////////////////////////////////////////////
104 void G4OpenGLQtViewer::CreateMainWindow ( 114 void G4OpenGLQtViewer::CreateMainWindow (
105 G4QGLWidgetType* glWidget << 115 QGLWidget* glWidget
106 ,const QString& name 116 ,const QString& name
107 ) 117 )
108 ////////////////////////////////////////////// 118 //////////////////////////////////////////////////////////////////////////////
109 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 119 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
110 { 120 {
111 121
112 if(fGLWidget) return; //Done. 122 if(fGLWidget) return; //Done.
113 123
114 fGLWidget = glWidget ; 124 fGLWidget = glWidget ;
>> 125 // fGLWidget->makeCurrent();
>> 126
>> 127 G4Qt* interactorManager = G4Qt::getInstance ();
115 128
116 #if QT_VERSION < 0x060000 <<
117 ResizeWindow(fVP.GetWindowSizeHintX(),fVP.Ge 129 ResizeWindow(fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
118 #else <<
119 ResizeWindow(glWidget->devicePixelRatio()*fV <<
120 #endif <<
121 130
122 // FIXME L.Garnier 9/11/09 Has to be check ! 131 // FIXME L.Garnier 9/11/09 Has to be check !!!
123 // Qt UI with Qt Vis 132 // Qt UI with Qt Vis
124 // Qt UI with X Vis 133 // Qt UI with X Vis
125 // X UI with Qt Vis 134 // X UI with Qt Vis
126 // X UI with X Vis 135 // X UI with X Vis
127 // Ne marche pas avec un UIBatch !! (ecran b 136 // Ne marche pas avec un UIBatch !! (ecran blanc)
128 137
129 // return false if G4UIQt was not launch 138 // return false if G4UIQt was not launch
130 139
131 G4UImanager* UI = G4UImanager::GetUIpointer( 140 G4UImanager* UI = G4UImanager::GetUIpointer();
132 if (UI == NULL) return; 141 if (UI == NULL) return;
133 142
134 if (! static_cast<G4UIQt*> (UI->GetG4UIWindo 143 if (! static_cast<G4UIQt*> (UI->GetG4UIWindow())) {
135 // NO UI, should be batch mode 144 // NO UI, should be batch mode
136 fBatchMode = true; 145 fBatchMode = true;
137 return; 146 return;
138 } 147 }
139 fUiQt = static_cast<G4UIQt*> (UI->GetG4UIWin 148 fUiQt = static_cast<G4UIQt*> (UI->GetG4UIWindow());
140 149
141 bool isTabbedView = false; 150 bool isTabbedView = false;
142 if ( fUiQt) { 151 if ( fUiQt) {
143 if (!fBatchMode) { 152 if (!fBatchMode) {
144 G4Qt* interactorManager = G4Qt::getInsta <<
145 if (!interactorManager->IsExternalApp()) 153 if (!interactorManager->IsExternalApp()) {
146 // INIT size 154 // INIT size
147 fWinSize_x = fVP.GetWindowSizeHintX(); 155 fWinSize_x = fVP.GetWindowSizeHintX();
148 fWinSize_y = fVP.GetWindowSizeHintY(); 156 fWinSize_y = fVP.GetWindowSizeHintY();
149 157
150 isTabbedView = fUiQt->AddTabWidget((QW 158 isTabbedView = fUiQt->AddTabWidget((QWidget*)fGLWidget,name);
151 QObject::connect(fUiQt->GetViewerTabWi 159 QObject::connect(fUiQt->GetViewerTabWidget(),
152 SIGNAL(currentChanged 160 SIGNAL(currentChanged(int)),
153 this, 161 this,
154 SLOT(currentTabActiva 162 SLOT(currentTabActivated(int)));
155 163
156 #if QT_VERSION < 0x060000 <<
157 #else <<
158 createViewerPropertiesWidget(); <<
159 #endif <<
160 164
161 } 165 }
162 createSceneTreeWidget(); 166 createSceneTreeWidget();
163 // activate them 167 // activate them
164 } 168 }
165 } 169 }
166 170
167 if (!isTabbedView) { // we have to do a dial 171 if (!isTabbedView) { // we have to do a dialog
168 172
169 QWidget *glDialogWidget = getParentWidget( 173 QWidget *glDialogWidget = getParentWidget();
170 if (glDialogWidget == NULL) { 174 if (glDialogWidget == NULL) {
171 return; 175 return;
172 } 176 }
173 glWidget->setParent(glDialogWidget); 177 glWidget->setParent(glDialogWidget);
174 QHBoxLayout *mainLayout = new QHBoxLayout( 178 QHBoxLayout *mainLayout = new QHBoxLayout();
175 179
176 mainLayout->setContentsMargins(0,0,0,0); << 180 mainLayout->setMargin(0);
177 mainLayout->setSpacing(0); 181 mainLayout->setSpacing(0);
178 mainLayout->addWidget(fGLWidget); 182 mainLayout->addWidget(fGLWidget);
179 if (fGLWidget->inherits("QMainWindow")) { 183 if (fGLWidget->inherits("QMainWindow")) {
180 fGLWidget->setWindowTitle( name); 184 fGLWidget->setWindowTitle( name);
181 } 185 }
182 glDialogWidget->setLayout(mainLayout); 186 glDialogWidget->setLayout(mainLayout);
183 187
184 188
185 //useful for MACOSX, we have to compt the 189 //useful for MACOSX, we have to compt the menuBar height
186 #if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)) << 190 #if QT_VERSION >= 0x050a00
187 G4int offset = QGuiApplication::primaryS << 191 G4int offset = QApplication::desktop()->height()
188 - QGuiApplication::screenAt(QPoint(2 192 - QGuiApplication::screenAt(QPoint(20,20))->availableGeometry().height();
189 #else 193 #else
190 G4int offset = QApplication::desktop()-> 194 G4int offset = QApplication::desktop()->height()
191 - QApplication::desktop()->available 195 - QApplication::desktop()->availableGeometry().height();
192 #endif 196 #endif
193 197
194 G4int YPos= fVP.GetWindowAbsoluteLocationH << 198 G4int YPos= fVP.GetWindowAbsoluteLocationHintY(QApplication::desktop()->height());
195 if (fVP.GetWindowAbsoluteLocationHintY(QGu << 199 if (fVP.GetWindowAbsoluteLocationHintY(QApplication::desktop()->height())< offset) {
196 YPos = offset; 200 YPos = offset;
197 } 201 }
198 glDialogWidget->resize(getWinWidth(), getW 202 glDialogWidget->resize(getWinWidth(), getWinHeight());
199 glDialogWidget->move(fVP.GetWindowAbsolute << 203 glDialogWidget->move(fVP.GetWindowAbsoluteLocationHintX(QApplication::desktop()->width()),YPos);
200 glDialogWidget->show(); 204 glDialogWidget->show();
201 } 205 }
202 206
203 if(!fGLWidget) return; 207 if(!fGLWidget) return;
204 208
205 if (!fContextMenu) 209 if (!fContextMenu)
206 createPopupMenu(); 210 createPopupMenu();
207 211
208 } 212 }
209 213
210 214
211 ////////////////////////////////////////////// 215 //////////////////////////////////////////////////////////////////////////////
212 G4OpenGLQtViewer::G4OpenGLQtViewer ( 216 G4OpenGLQtViewer::G4OpenGLQtViewer (
213 G4OpenGLSceneHandler& scene 217 G4OpenGLSceneHandler& scene
214 ) 218 )
215 :G4VViewer (scene, -1) 219 :G4VViewer (scene, -1)
216 ,G4OpenGLViewer (scene) 220 ,G4OpenGLViewer (scene)
217 ,fUiQt(NULL) <<
218 ,fGLWidget(NULL) 221 ,fGLWidget(NULL)
219 ,fRecordFrameNumber(0) 222 ,fRecordFrameNumber(0)
220 ,fMouseOnSceneTree(false) 223 ,fMouseOnSceneTree(false)
221 ,fContextMenu(0) 224 ,fContextMenu(0)
222 ,fLastPickPoint(-1,-1) 225 ,fLastPickPoint(-1,-1)
223 ,fDeltaDepth(0.01) 226 ,fDeltaDepth(0.01)
224 ,fDeltaZoom(0.05) 227 ,fDeltaZoom(0.05)
225 ,fHoldKeyEvent(false) 228 ,fHoldKeyEvent(false)
226 ,fHoldMoveEvent(false) 229 ,fHoldMoveEvent(false)
227 ,fHoldRotateEvent(false) 230 ,fHoldRotateEvent(false)
228 ,fAutoMove(false) 231 ,fAutoMove(false)
229 ,fEncoderPath("") 232 ,fEncoderPath("")
230 ,fTempFolderPath("") 233 ,fTempFolderPath("")
231 ,fMovieTempFolderPath("") 234 ,fMovieTempFolderPath("")
232 ,fSaveFileName("") 235 ,fSaveFileName("")
233 ,fParameterFileName("ppmtompeg_encode_parame 236 ,fParameterFileName("ppmtompeg_encode_parameter_file.par")
234 ,fMovieParametersDialog(NULL) 237 ,fMovieParametersDialog(NULL)
235 ,fRecordingStep(WAIT) 238 ,fRecordingStep(WAIT)
236 ,fProcess(NULL) 239 ,fProcess(NULL)
237 ,fNbMaxFramesPerSec(100) 240 ,fNbMaxFramesPerSec(100)
238 ,fNbMaxAnglePerSec(360) 241 ,fNbMaxAnglePerSec(360)
239 ,fLaunchSpinDelay(100) 242 ,fLaunchSpinDelay(100)
240 ,fUISceneTreeWidget(NULL) 243 ,fUISceneTreeWidget(NULL)
241 ,fUIViewerPropertiesWidget(NULL) 244 ,fUIViewerPropertiesWidget(NULL)
242 ,fUIPickInfosWidget(NULL) 245 ,fUIPickInfosWidget(NULL)
243 ,fNoKeyPress(true) 246 ,fNoKeyPress(true)
244 ,fAltKeyPress(false) 247 ,fAltKeyPress(false)
245 ,fControlKeyPress(false) 248 ,fControlKeyPress(false)
246 ,fShiftKeyPress(false) 249 ,fShiftKeyPress(false)
247 ,fBatchMode(false) 250 ,fBatchMode(false)
248 ,fCheckSceneTreeComponentSignalLock(false) 251 ,fCheckSceneTreeComponentSignalLock(false)
249 ,fViewerPropertiesTableWidgetIsInit(false) 252 ,fViewerPropertiesTableWidgetIsInit(false)
250 ,fSceneTreeComponentTreeWidget(NULL) 253 ,fSceneTreeComponentTreeWidget(NULL)
251 ,fSceneTreeWidget(NULL) 254 ,fSceneTreeWidget(NULL)
252 ,fPVRootNodeCreate(false) 255 ,fPVRootNodeCreate(false)
253 ,fFilterOutput(NULL) 256 ,fFilterOutput(NULL)
254 ,fNbRotation(0) 257 ,fNbRotation(0)
255 ,fTimeRotation(0) 258 ,fTimeRotation(0)
256 ,fTouchableVolumes("Touchables") 259 ,fTouchableVolumes("Touchables")
257 ,fShortcutsDialog(NULL) 260 ,fShortcutsDialog(NULL)
258 ,fViewerPropertiesTableWidget(NULL) 261 ,fViewerPropertiesTableWidget(NULL)
259 ,fPickInfosWidget(NULL) 262 ,fPickInfosWidget(NULL)
260 ,fPickInfosScrollArea(NULL) 263 ,fPickInfosScrollArea(NULL)
261 ,fTreeWidgetInfosIgnoredCommands(0) 264 ,fTreeWidgetInfosIgnoredCommands(0)
262 ,fSceneTreeDepthSlider(NULL) 265 ,fSceneTreeDepthSlider(NULL)
263 ,fSceneTreeDepth(1) 266 ,fSceneTreeDepth(1)
264 ,fModelShortNameItem(NULL) 267 ,fModelShortNameItem(NULL)
265 ,fMaxPOindexInserted(-1) 268 ,fMaxPOindexInserted(-1)
>> 269 ,fUiQt(NULL)
>> 270 #if QT_VERSION < 0x050600
>> 271 ,fSignalMapperMouse(NULL)
>> 272 ,fSignalMapperSurface(NULL)
>> 273 ,fSignalMapperPicking(NULL)
>> 274 #endif
266 ,fTreeIconOpen(NULL) 275 ,fTreeIconOpen(NULL)
267 ,fTreeIconClosed(NULL) 276 ,fTreeIconClosed(NULL)
268 ,fLastExportSliderValue(80) 277 ,fLastExportSliderValue(80)
269 ,fLastHighlightColor(G4Color(0,0,0,0)) 278 ,fLastHighlightColor(G4Color(0,0,0,0))
270 ,fLastHighlightName(0) 279 ,fLastHighlightName(0)
271 ,fIsDeleting(false) 280 ,fIsDeleting(false)
272 { 281 {
>> 282 lWaitForVisSubThreadQtOpenGLContextInitialized
>> 283 = new G4AutoLock(mWaitForVisSubThreadQtOpenGLContextInitialized,
>> 284 std::defer_lock);
>> 285 lWaitForVisSubThreadQtOpenGLContextMoved
>> 286 = new G4AutoLock(mWaitForVisSubThreadQtOpenGLContextMoved,
>> 287 std::defer_lock);
>> 288
273 // launch Qt if not 289 // launch Qt if not
274 if (QCoreApplication::instance () == NULL) { 290 if (QCoreApplication::instance () == NULL) {
275 fBatchMode = true; 291 fBatchMode = true;
276 } 292 }
277 G4Qt::getInstance (); 293 G4Qt::getInstance ();
278 294
279 fLastPos3 = QPoint(-1,-1); 295 fLastPos3 = QPoint(-1,-1);
280 fLastPos2 = QPoint(-1,-1); 296 fLastPos2 = QPoint(-1,-1);
281 fLastPos1 = QPoint(-1,-1); 297 fLastPos1 = QPoint(-1,-1);
282 298
283 initMovieParameters(); 299 initMovieParameters();
284 300
285 #if (QT_VERSION < QT_VERSION_CHECK(5, 14, 0)) << 301 #if QT_VERSION < 0x050e00
286 fLastEventTime = new QTime(); 302 fLastEventTime = new QTime();
287 #else 303 #else
288 fLastEventTime = new QElapsedTimer(); 304 fLastEventTime = new QElapsedTimer();
289 #endif 305 #endif
>> 306 #if QT_VERSION < 0x050600
>> 307 fSignalMapperMouse = new QSignalMapper(this);
>> 308 fSignalMapperSurface = new QSignalMapper(this);
>> 309 #endif
290 // Set default path and format 310 // Set default path and format
291 fFileSavePath = QDir::currentPath(); 311 fFileSavePath = QDir::currentPath();
292 312
293 // add available export format 313 // add available export format
294 QList<QByteArray> formats = QImageWriter::s 314 QList<QByteArray> formats = QImageWriter::supportedImageFormats ();
295 for (int i = 0; i < formats.size(); ++i) { 315 for (int i = 0; i < formats.size(); ++i) {
296 addExportImageFormat(formats.at(i).data()) 316 addExportImageFormat(formats.at(i).data());
297 } 317 }
298 318
299 const char * const icon1[]={ 319 const char * const icon1[]={
300 /* columns rows colors chars-per-pixel */ 320 /* columns rows colors chars-per-pixel */
301 "20 20 34 1", 321 "20 20 34 1",
302 " c None", 322 " c None",
303 ". c #7C7C7C7C7C7C", 323 ". c #7C7C7C7C7C7C",
304 "X c #7D7D7D7D7D7D", 324 "X c #7D7D7D7D7D7D",
305 "o c #828282828282", 325 "o c #828282828282",
306 "O c #838383838383", 326 "O c #838383838383",
307 "+ c #848484848484", 327 "+ c #848484848484",
308 "@ c #858585858585", 328 "@ c #858585858585",
309 "# c #878787878787", 329 "# c #878787878787",
310 "$ c #888888888888", 330 "$ c #888888888888",
311 "% c #8B8B8B8B8B8B", 331 "% c #8B8B8B8B8B8B",
312 "& c #8C8C8C8C8C8C", 332 "& c #8C8C8C8C8C8C",
313 "* c #8F8F8F8F8F8F", 333 "* c #8F8F8F8F8F8F",
314 "= c #909090909090", 334 "= c #909090909090",
315 "- c #919191919191", 335 "- c #919191919191",
316 "; c #999999999999", 336 "; c #999999999999",
317 ": c #9D9D9D9D9D9D", 337 ": c #9D9D9D9D9D9D",
318 "> c #A2A2A2A2A2A2", 338 "> c #A2A2A2A2A2A2",
319 ", c #A3A3A3A3A3A3", 339 ", c #A3A3A3A3A3A3",
320 "< c #A5A5A5A5A5A5", 340 "< c #A5A5A5A5A5A5",
321 "1 c #A6A6A6A6A6A6", 341 "1 c #A6A6A6A6A6A6",
322 "2 c #B3B3B3B3B3B3", 342 "2 c #B3B3B3B3B3B3",
323 "3 c #B6B6B6B6B6B6", 343 "3 c #B6B6B6B6B6B6",
324 "4 c #C2C2C2C2C2C2", 344 "4 c #C2C2C2C2C2C2",
325 "5 c #C6C6C6C6C6C6", 345 "5 c #C6C6C6C6C6C6",
326 "6 c #CACACACACACA", 346 "6 c #CACACACACACA",
327 "7 c #CFCFCFCFCFCF", 347 "7 c #CFCFCFCFCFCF",
328 "8 c #D0D0D0D0D0D0", 348 "8 c #D0D0D0D0D0D0",
329 "9 c #D4D4D4D4D4D4", 349 "9 c #D4D4D4D4D4D4",
330 "0 c #D7D7D7D7D7D7", 350 "0 c #D7D7D7D7D7D7",
331 "q c #DEDEDEDEDEDE", 351 "q c #DEDEDEDEDEDE",
332 "w c #E0E0E0E0E0E0", 352 "w c #E0E0E0E0E0E0",
333 "e c #E7E7E7E7E7E7", 353 "e c #E7E7E7E7E7E7",
334 "r c #F4F4F4F4F4F4", 354 "r c #F4F4F4F4F4F4",
335 "t c #F7F7F7F7F7F7", 355 "t c #F7F7F7F7F7F7",
336 " ", 356 " ",
337 " ", 357 " ",
338 " ", 358 " ",
339 " ", 359 " ",
340 " ", 360 " ",
341 " ", 361 " ",
342 " =========> ", 362 " =========> ",
343 " 7&X+++Oo<e ", 363 " 7&X+++Oo<e ",
344 " 2o+@@+-8 ", 364 " 2o+@@+-8 ",
345 " w;.#@+3 ", 365 " w;.#@+3 ",
346 " 4$o@:q ", 366 " 4$o@:q ",
347 " r1X%5 ", 367 " r1X%5 ",
348 " 9*,t ", 368 " 9*,t ",
349 " 60 ", 369 " 60 ",
350 " ", 370 " ",
351 " ", 371 " ",
352 " ", 372 " ",
353 " ", 373 " ",
354 " ", 374 " ",
355 " " 375 " "
356 }; 376 };
357 const char * const icon2[]={ 377 const char * const icon2[]={
358 "20 20 68 1", 378 "20 20 68 1",
359 " c None", 379 " c None",
360 ". c #5F5F10102323", 380 ". c #5F5F10102323",
361 "X c #40405F5F1010", 381 "X c #40405F5F1010",
362 "o c #696963632E2E", 382 "o c #696963632E2E",
363 "O c #101019194C4C", 383 "O c #101019194C4C",
364 "+ c #101023237070", 384 "+ c #101023237070",
365 "@ c #70702D2D6363", 385 "@ c #70702D2D6363",
366 "# c #73732D2D6464", 386 "# c #73732D2D6464",
367 "$ c #79792E2E6767", 387 "$ c #79792E2E6767",
368 "% c #19194C4C5353", 388 "% c #19194C4C5353",
369 "& c #2D2D63636161", 389 "& c #2D2D63636161",
370 "* c #2E2E61617070", 390 "* c #2E2E61617070",
371 "= c #6F6F6E6E4343", 391 "= c #6F6F6E6E4343",
372 "- c #707065655F5F", 392 "- c #707065655F5F",
373 "; c #727279795454", 393 "; c #727279795454",
374 ": c #535341417070", 394 ": c #535341417070",
375 "> c #797954547979", 395 "> c #797954547979",
376 ", c #434361617474", 396 ", c #434361617474",
377 "< c #414170707070", 397 "< c #414170707070",
378 "1 c #686869696363", 398 "1 c #686869696363",
379 "2 c #6C6C69696363", 399 "2 c #6C6C69696363",
380 "3 c #656567676F6F", 400 "3 c #656567676F6F",
381 "4 c #69696F6F6E6E", 401 "4 c #69696F6F6E6E",
382 "5 c #747465656767", 402 "5 c #747465656767",
383 "6 c #757562626C6C", 403 "6 c #757562626C6C",
384 "7 c #70706C6C6969", 404 "7 c #70706C6C6969",
385 "8 c #616174746565", 405 "8 c #616174746565",
386 "9 c #656573736969", 406 "9 c #656573736969",
387 "0 c #616174746969", 407 "0 c #616174746969",
388 "q c #707075756262", 408 "q c #707075756262",
389 "w c #797970706565", 409 "w c #797970706565",
390 "e c #636361617474", 410 "e c #636361617474",
391 "r c #67676F6F7272", 411 "r c #67676F6F7272",
392 "t c #727261617070", 412 "t c #727261617070",
393 "y c #616170707070", 413 "y c #616170707070",
394 "u c #6F6F72727979", 414 "u c #6F6F72727979",
395 "i c #67676E6ED1D1", 415 "i c #67676E6ED1D1",
396 "p c #808080808080", 416 "p c #808080808080",
397 "a c #828282828282", 417 "a c #828282828282",
398 "s c #838383838383", 418 "s c #838383838383",
399 "d c #848484848484", 419 "d c #848484848484",
400 "f c #858585858585", 420 "f c #858585858585",
401 "g c #868686868686", 421 "g c #868686868686",
402 "h c #888888888888", 422 "h c #888888888888",
403 "j c #8A8A8A8A8A8A", 423 "j c #8A8A8A8A8A8A",
404 "k c #8D8D8D8D8D8D", 424 "k c #8D8D8D8D8D8D",
405 "l c #8F8F8F8F8F8F", 425 "l c #8F8F8F8F8F8F",
406 "z c #909090909090", 426 "z c #909090909090",
407 "x c #949494949494", 427 "x c #949494949494",
408 "c c #9C9C9C9C9C9C", 428 "c c #9C9C9C9C9C9C",
409 "v c #9F9F9F9F9F9F", 429 "v c #9F9F9F9F9F9F",
410 "b c #A2A2A2A2A2A2", 430 "b c #A2A2A2A2A2A2",
411 "n c #AEAEAEAEAEAE", 431 "n c #AEAEAEAEAEAE",
412 "m c #B7B7B7B7B7B7", 432 "m c #B7B7B7B7B7B7",
413 "M c #C7C7C7C7C7C7", 433 "M c #C7C7C7C7C7C7",
414 "N c #C9C9C9C9C9C9", 434 "N c #C9C9C9C9C9C9",
415 "B c #D1D1D1D1D1D1", 435 "B c #D1D1D1D1D1D1",
416 "V c #D4D4D4D4D4D4", 436 "V c #D4D4D4D4D4D4",
417 "C c #D9D9D9D9D9D9", 437 "C c #D9D9D9D9D9D9",
418 "Z c #E0E0E0E0E0E0", 438 "Z c #E0E0E0E0E0E0",
419 "A c #E2E2E2E2E2E2", 439 "A c #E2E2E2E2E2E2",
420 "S c #EEEEEEEEEEEE", 440 "S c #EEEEEEEEEEEE",
421 "D c #F0F0F0F0F0F0", 441 "D c #F0F0F0F0F0F0",
422 "F c #F5F5F5F5F5F5", 442 "F c #F5F5F5F5F5F5",
423 "G c #F6F6F6F6F6F6", 443 "G c #F6F6F6F6F6F6",
424 "H c #F9F9F9F9F9F9", 444 "H c #F9F9F9F9F9F9",
425 "J c #FCFCFCFCFCFC", 445 "J c #FCFCFCFCFCFC",
426 "K c #FDFDFDFDFDFD", 446 "K c #FDFDFDFDFDFD",
427 " ", 447 " ",
428 " ", 448 " ",
429 " ", 449 " ",
430 " ", 450 " ",
431 " ", 451 " ",
432 " bC ", 452 " bC ",
433 " zjnD ", 453 " zjnD ",
434 " ldjjMK ", 454 " ldjjMK ",
435 " zdhdjcA ", 455 " zdhdjcA ",
436 " zddhdddVK ", 456 " zddhdddVK ",
437 " zghdalBH ", 457 " zghdalBH ",
438 " zghamSK ", 458 " zghamSK ",
439 " lubZH ", 459 " lubZH ",
440 " xMF ", 460 " xMF ",
441 " G ", 461 " G ",
442 " ", 462 " ",
443 " ", 463 " ",
444 " ", 464 " ",
445 " ", 465 " ",
446 " ", 466 " ",
447 467
448 }; 468 };
449 469
450 const char * const search[] = { 470 const char * const search[] = {
451 /* columns rows colors chars-per-pixel */ 471 /* columns rows colors chars-per-pixel */
452 "19 19 8 1", 472 "19 19 8 1",
453 " c #5C5C5C", 473 " c #5C5C5C",
454 ". c #7D7D7D", 474 ". c #7D7D7D",
455 "X c #9B9B9B", 475 "X c #9B9B9B",
456 "o c #C3C3C3", 476 "o c #C3C3C3",
457 "O c None", 477 "O c None",
458 "+ c #000000", 478 "+ c #000000",
459 "@ c #000000", 479 "@ c #000000",
460 "# c None", 480 "# c None",
461 /* pixels */ 481 /* pixels */
462 "OOOOOOOOOOOOOOOOOOO", 482 "OOOOOOOOOOOOOOOOOOO",
463 "OOOOOOOOOOOOOOOOOOO", 483 "OOOOOOOOOOOOOOOOOOO",
464 "OOOOOOOo. .oOOOOOO", 484 "OOOOOOOo. .oOOOOOO",
465 "OOOOOOX XOOOOO", 485 "OOOOOOX XOOOOO",
466 "OOOOOo XOOX oOOOO", 486 "OOOOOo XOOX oOOOO",
467 "OOOOO. XOOOOX .OOOO", 487 "OOOOO. XOOOOX .OOOO",
468 "OOOOO OOOOOO OOOO", 488 "OOOOO OOOOOO OOOO",
469 "OOOOO OOOOOO OOOO", 489 "OOOOO OOOOOO OOOO",
470 "OOOOO. XOOOOo .OOOO", 490 "OOOOO. XOOOOo .OOOO",
471 "OOOOOo oOOo oOOOO", 491 "OOOOOo oOOo oOOOO",
472 "OOOOOOX XOOOO", 492 "OOOOOOX XOOOO",
473 "OOOOOOOo. . XOOO", 493 "OOOOOOOo. . XOOO",
474 "OOOOOOOOOOOOO. XOO", 494 "OOOOOOOOOOOOO. XOO",
475 "OOOOOOOOOOOOOO. XOO", 495 "OOOOOOOOOOOOOO. XOO",
476 "OOOOOOOOOOOOOOOoOOO", 496 "OOOOOOOOOOOOOOOoOOO",
477 "OOOOOOOOOOOOOOOOOOO", 497 "OOOOOOOOOOOOOOOOOOO",
478 "OOOOOOOOOOOOOOOOOOO", 498 "OOOOOOOOOOOOOOOOOOO",
479 "OOOOOOOOOOOOOOOOOOO", 499 "OOOOOOOOOOOOOOOOOOO",
480 "OOOOOOOOOOOOOOOOOOO" 500 "OOOOOOOOOOOOOOOOOOO"
481 }; 501 };
482 502
483 fSearchIcon = new QPixmap(search); 503 fSearchIcon = new QPixmap(search);
484 fTreeIconOpen = new QPixmap(icon1); 504 fTreeIconOpen = new QPixmap(icon1);
485 fTreeIconClosed = new QPixmap(icon2); 505 fTreeIconClosed = new QPixmap(icon2);
486 506
487 } 507 }
488 508
489 ////////////////////////////////////////////// 509 //////////////////////////////////////////////////////////////////////////////
490 G4OpenGLQtViewer::~G4OpenGLQtViewer ( 510 G4OpenGLQtViewer::~G4OpenGLQtViewer (
491 ) 511 )
492 ////////////////////////////////////////////// 512 //////////////////////////////////////////////////////////////////////////////
493 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 513 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
494 { 514 {
495 fIsDeleting = true; 515 fIsDeleting = true;
496 516
497 // remove scene tree from layout 517 // remove scene tree from layout
498 // Delete all the existing buttons in the la 518 // Delete all the existing buttons in the layout
499 QLayoutItem *wItem; 519 QLayoutItem *wItem;
500 if (fSceneTreeWidget != NULL) { 520 if (fSceneTreeWidget != NULL) {
501 if (fSceneTreeWidget->layout() != NULL) { 521 if (fSceneTreeWidget->layout() != NULL) {
502 while ((wItem = fSceneTreeWidget->layout 522 while ((wItem = fSceneTreeWidget->layout()->takeAt(0)) != 0) {
503 delete wItem->widget(); 523 delete wItem->widget();
504 delete wItem; 524 delete wItem;
505 } 525 }
506 } 526 }
507 } 527 }
508 528
509 // Delete the open/close icons 529 // Delete the open/close icons
510 delete fTreeIconOpen; 530 delete fTreeIconOpen;
511 delete fTreeIconClosed; 531 delete fTreeIconClosed;
512 532
513 #if QT_VERSION < 0x060000 << 533 G4cout <<removeTempFolder().toStdString().c_str() <<G4endl;
514 G4cout <<removeTempFolder().toStdString().c_ <<
515 #endif <<
516 534
517 } << 535 delete lWaitForVisSubThreadQtOpenGLContextInitialized;
>> 536 delete lWaitForVisSubThreadQtOpenGLContextMoved;
518 537
519 G4bool G4OpenGLQtViewer::ReadyToDraw() { <<
520 #if QT_VERSION < 0x060000 <<
521 return true; <<
522 #else <<
523 if(!fGLWidget) return false; <<
524 auto* qGLW = dynamic_cast<G4QGLWidgetType*>( <<
525 if (!qGLW) return false; <<
526 return qGLW->isValid(); <<
527 #endif <<
528 } 538 }
529 539
>> 540
530 // 541 //
531 // Create a popup menu for the widget. This 542 // Create a popup menu for the widget. This menu is activated by right-mouse click
532 // 543 //
533 void G4OpenGLQtViewer::createPopupMenu() { 544 void G4OpenGLQtViewer::createPopupMenu() {
534 545
535 fContextMenu = new QMenu("All"); 546 fContextMenu = new QMenu("All");
536 547
537 QMenu *mMouseAction = fContextMenu->addMenu( 548 QMenu *mMouseAction = fContextMenu->addMenu("&Mouse actions");
>> 549
>> 550 #if QT_VERSION < 0x050600
>> 551 fMouseRotateAction = mMouseAction->addAction("Rotate", fSignalMapperMouse, SLOT(map()));
>> 552 fMouseMoveAction = mMouseAction->addAction("Move", fSignalMapperMouse, SLOT(map()));
>> 553 fMousePickAction = mMouseAction->addAction("Pick", fSignalMapperMouse, SLOT(map()));
>> 554 fMouseZoomOutAction = mMouseAction->addAction("Zoom out", fSignalMapperMouse, SLOT(map()));
>> 555 fMouseZoomInAction = mMouseAction->addAction("Zoom in", fSignalMapperMouse, SLOT(map()));
>> 556 #else
538 fMouseRotateAction = mMouseAction->addAction 557 fMouseRotateAction = mMouseAction->addAction("Rotate", this, [this](){ this->toggleMouseAction(1); });
539 fMouseMoveAction = mMouseAction->addAction(" 558 fMouseMoveAction = mMouseAction->addAction("Move", this, [this](){ this->toggleMouseAction(2); });
540 fMousePickAction = mMouseAction->addAction(" 559 fMousePickAction = mMouseAction->addAction("Pick", this, [this](){ this->toggleMouseAction(3); });
541 fMouseZoomOutAction = mMouseAction->addActio 560 fMouseZoomOutAction = mMouseAction->addAction("Zoom out", this, [this](){ this->toggleMouseAction(4); });
542 fMouseZoomInAction = mMouseAction->addAction 561 fMouseZoomInAction = mMouseAction->addAction("Zoom in", this, [this](){ this->toggleMouseAction(5); });
>> 562 #endif
543 QAction *shortcutsAction = mMouseAction->add 563 QAction *shortcutsAction = mMouseAction->addAction("Show shortcuts");
544 564
545 fMouseRotateAction->setCheckable(true); 565 fMouseRotateAction->setCheckable(true);
546 fMouseMoveAction->setCheckable(true); 566 fMouseMoveAction->setCheckable(true);
547 fMousePickAction->setCheckable(true); 567 fMousePickAction->setCheckable(true);
548 fMouseZoomOutAction->setCheckable(true); 568 fMouseZoomOutAction->setCheckable(true);
549 fMouseZoomInAction->setCheckable(true); 569 fMouseZoomInAction->setCheckable(true);
550 shortcutsAction->setCheckable(false); 570 shortcutsAction->setCheckable(false);
551 571
>> 572 #if QT_VERSION < 0x050600
>> 573 connect(fSignalMapperMouse, SIGNAL(mapped(int)),this, SLOT(toggleMouseAction(int)));
>> 574 fSignalMapperMouse->setMapping(fMouseRotateAction,1);
>> 575 fSignalMapperMouse->setMapping(fMouseMoveAction,2);
>> 576 fSignalMapperMouse->setMapping(fMousePickAction,3);
>> 577 fSignalMapperMouse->setMapping(fMouseZoomOutAction,4);
>> 578 fSignalMapperMouse->setMapping(fMouseZoomInAction,5);
>> 579 #endif
>> 580
552 QObject::connect(shortcutsAction, 581 QObject::connect(shortcutsAction,
553 SIGNAL(triggered(bool)), 582 SIGNAL(triggered(bool)),
554 this, 583 this,
555 SLOT(showShortcuts())); 584 SLOT(showShortcuts()));
556 585
557 // === Style Menu === 586 // === Style Menu ===
558 QMenu *mStyle = fContextMenu->addMenu("&Styl 587 QMenu *mStyle = fContextMenu->addMenu("&Style");
559 588
560 QMenu *mProjection = mStyle->addMenu("&Proje 589 QMenu *mProjection = mStyle->addMenu("&Projection");
561 590
>> 591 #if QT_VERSION < 0x050600
>> 592 fProjectionOrtho = mProjection->addAction("Orthographic", fSignalMapperSurface, SLOT(map()));
>> 593 fProjectionPerspective = mProjection->addAction("Perspective", fSignalMapperSurface, SLOT(map()));
>> 594
>> 595 // INIT mProjection
>> 596 if (fVP.GetFieldHalfAngle() == 0) {
>> 597 createRadioAction(fProjectionOrtho, fProjectionPerspective,SLOT(toggleProjection(bool)),1);
>> 598 } else {
>> 599 createRadioAction(fProjectionOrtho, fProjectionPerspective,SLOT(toggleProjection(bool)),2);
>> 600 }
>> 601 #else
562 // no more radioAction, not realy useful and 602 // no more radioAction, not realy useful and could be confusing to use context menu and icon at the same time
563 fProjectionOrtho = mProjection->addAction("O 603 fProjectionOrtho = mProjection->addAction("Orthographic", this, [this](){ this->toggleProjection(true); });
564 fProjectionPerspective = mProjection->addAct 604 fProjectionPerspective = mProjection->addAction("Perspective", this, [this](){ this->toggleProjection(false); });
>> 605 #endif
565 // === Drawing Menu === 606 // === Drawing Menu ===
566 QMenu *mDrawing = mStyle->addMenu("&Drawing" 607 QMenu *mDrawing = mStyle->addMenu("&Drawing");
>> 608
>> 609 #if QT_VERSION < 0x050600
>> 610 fDrawingWireframe = mDrawing->addAction("Wireframe", fSignalMapperSurface, SLOT(map()));
>> 611
>> 612 fDrawingLineRemoval = mDrawing->addAction("Hidden line removal", fSignalMapperSurface, SLOT(map()));
>> 613
>> 614 fDrawingSurfaceRemoval = mDrawing->addAction("Hidden Surface removal", fSignalMapperSurface, SLOT(map()));
>> 615
>> 616 fDrawingLineSurfaceRemoval = mDrawing->addAction("Hidden line and surface removal", fSignalMapperSurface, SLOT(map()));
>> 617 #endif
>> 618
>> 619 #if QT_VERSION < 0x050600
>> 620 connect(fSignalMapperSurface, SIGNAL(mapped(int)),this, SLOT(toggleSurfaceAction(int)));
>> 621 fSignalMapperSurface->setMapping(fDrawingWireframe,1);
>> 622 fSignalMapperSurface->setMapping(fDrawingLineRemoval,2);
>> 623 fSignalMapperSurface->setMapping(fDrawingSurfaceRemoval,3);
>> 624 fSignalMapperSurface->setMapping(fDrawingLineSurfaceRemoval,4);
>> 625 #else
567 fDrawingWireframe = mDrawing->addAction("Wir 626 fDrawingWireframe = mDrawing->addAction("Wireframe", this, [this](){ this->toggleSurfaceAction(1); });
568 fDrawingLineRemoval = mDrawing->addAction("H 627 fDrawingLineRemoval = mDrawing->addAction("Hidden line removal", this, [this](){ this->toggleSurfaceAction(2); });
569 fDrawingSurfaceRemoval = mDrawing->addAction 628 fDrawingSurfaceRemoval = mDrawing->addAction("Hidden Surface removal", this, [this](){ this->toggleSurfaceAction(3); });
570 fDrawingLineSurfaceRemoval = mDrawing->addAc 629 fDrawingLineSurfaceRemoval = mDrawing->addAction("Hidden line and surface removal", this, [this](){ this->toggleSurfaceAction(4); });
>> 630 #endif
571 631
572 fDrawingWireframe->setCheckable(true); 632 fDrawingWireframe->setCheckable(true);
573 fDrawingLineRemoval->setCheckable(true); 633 fDrawingLineRemoval->setCheckable(true);
574 fDrawingSurfaceRemoval->setCheckable(true); 634 fDrawingSurfaceRemoval->setCheckable(true);
575 fDrawingLineSurfaceRemoval->setCheckable(tru 635 fDrawingLineSurfaceRemoval->setCheckable(true);
576 636
577 // Background Color 637 // Background Color
578 638
579 QAction *backgroundColorChooser ; 639 QAction *backgroundColorChooser ;
580 // === Action Menu === 640 // === Action Menu ===
581 backgroundColorChooser = mStyle->addAction(" 641 backgroundColorChooser = mStyle->addAction("Background color");
582 QObject ::connect(backgroundColorChooser, 642 QObject ::connect(backgroundColorChooser,
583 SIGNAL(triggered()), 643 SIGNAL(triggered()),
584 this, 644 this,
585 SLOT(actionChangeBackgroun 645 SLOT(actionChangeBackgroundColor()));
586 646
587 // Text Color 647 // Text Color
588 648
589 QAction *textColorChooser ; 649 QAction *textColorChooser ;
590 // === Action Menu === 650 // === Action Menu ===
591 textColorChooser = mStyle->addAction("Text c 651 textColorChooser = mStyle->addAction("Text color");
592 QObject ::connect(textColorChooser, 652 QObject ::connect(textColorChooser,
593 SIGNAL(triggered()), 653 SIGNAL(triggered()),
594 this, 654 this,
595 SLOT(actionChangeTextColor 655 SLOT(actionChangeTextColor()));
596 656
597 // Default Color 657 // Default Color
598 658
599 QAction *defaultColorChooser ; 659 QAction *defaultColorChooser ;
600 // === Action Menu === 660 // === Action Menu ===
601 defaultColorChooser = mStyle->addAction("Def 661 defaultColorChooser = mStyle->addAction("Default color");
602 QObject ::connect(defaultColorChooser, 662 QObject ::connect(defaultColorChooser,
603 SIGNAL(triggered()), 663 SIGNAL(triggered()),
604 this, 664 this,
605 SLOT(actionChangeDefaultCo 665 SLOT(actionChangeDefaultColor()));
606 666
607 667
608 // === Action Menu === 668 // === Action Menu ===
609 QMenu *mActions = fContextMenu->addMenu("&Ac 669 QMenu *mActions = fContextMenu->addMenu("&Actions");
610 QAction *createEPS = mActions->addAction("Sa 670 QAction *createEPS = mActions->addAction("Save as ...");
611 QObject ::connect(createEPS, 671 QObject ::connect(createEPS,
612 SIGNAL(triggered()), 672 SIGNAL(triggered()),
613 this, 673 this,
614 SLOT(actionSaveImage())); 674 SLOT(actionSaveImage()));
615 675
616 // === Action Menu === 676 // === Action Menu ===
617 QAction *movieParameters = mActions->addActi 677 QAction *movieParameters = mActions->addAction("Save as movie...");
618 QObject ::connect(movieParameters, 678 QObject ::connect(movieParameters,
619 SIGNAL(triggered()), 679 SIGNAL(triggered()),
620 this, 680 this,
621 SLOT(actionMovieParameters 681 SLOT(actionMovieParameters()));
622 682
623 683
624 684
625 685
626 // === Special Menu === 686 // === Special Menu ===
627 QMenu *mSpecial = fContextMenu->addMenu("S&p 687 QMenu *mSpecial = fContextMenu->addMenu("S&pecial");
628 QMenu *mTransparency = mSpecial->addMenu("Tr 688 QMenu *mTransparency = mSpecial->addMenu("Transparency");
629 QAction *transparencyOn = mTransparency->add 689 QAction *transparencyOn = mTransparency->addAction("On");
630 QAction *transparencyOff = mTransparency->ad 690 QAction *transparencyOff = mTransparency->addAction("Off");
631 691
632 if (transparency_enabled == false) { 692 if (transparency_enabled == false) {
633 createRadioAction(transparencyOn,transpare 693 createRadioAction(transparencyOn,transparencyOff,SLOT(toggleTransparency(bool)),2);
634 } else if (transparency_enabled == true) { 694 } else if (transparency_enabled == true) {
635 createRadioAction(transparencyOn,transpare 695 createRadioAction(transparencyOn,transparencyOff,SLOT(toggleTransparency(bool)),1);
636 } else { 696 } else {
637 mSpecial->clear(); 697 mSpecial->clear();
638 } 698 }
639 699
640 700
641 QMenu *mAntialiasing = mSpecial->addMenu("An 701 QMenu *mAntialiasing = mSpecial->addMenu("Antialiasing");
642 QAction *antialiasingOn = mAntialiasing->add 702 QAction *antialiasingOn = mAntialiasing->addAction("On");
643 QAction *antialiasingOff = mAntialiasing->ad 703 QAction *antialiasingOff = mAntialiasing->addAction("Off");
644 704
645 if (antialiasing_enabled == false) { 705 if (antialiasing_enabled == false) {
646 createRadioAction(antialiasingOn,antialias 706 createRadioAction(antialiasingOn,antialiasingOff,SLOT(toggleAntialiasing(bool)),2);
647 } else if (antialiasing_enabled == true) { 707 } else if (antialiasing_enabled == true) {
648 createRadioAction(antialiasingOn,antialias 708 createRadioAction(antialiasingOn,antialiasingOff,SLOT(toggleAntialiasing(bool)),1);
649 } else { 709 } else {
650 mAntialiasing->clear(); 710 mAntialiasing->clear();
651 } 711 }
652 712
653 QMenu *mHaloing = mSpecial->addMenu("Haloing 713 QMenu *mHaloing = mSpecial->addMenu("Haloing");
654 QAction *haloingOn = mHaloing->addAction("On 714 QAction *haloingOn = mHaloing->addAction("On");
655 QAction *haloingOff = mHaloing->addAction("O 715 QAction *haloingOff = mHaloing->addAction("Off");
656 if (haloing_enabled == false) { 716 if (haloing_enabled == false) {
657 createRadioAction(haloingOn,haloingOff,SLO 717 createRadioAction(haloingOn,haloingOff,SLOT(toggleHaloing(bool)),2);
658 } else if (haloing_enabled == true) { 718 } else if (haloing_enabled == true) {
659 createRadioAction(haloingOn,haloingOff,SLO 719 createRadioAction(haloingOn,haloingOff,SLOT(toggleHaloing(bool)),1);
660 } else { 720 } else {
661 mHaloing->clear(); 721 mHaloing->clear();
662 } 722 }
663 723
664 QMenu *mAux = mSpecial->addMenu("Auxiliary e 724 QMenu *mAux = mSpecial->addMenu("Auxiliary edges");
665 QAction *auxOn = mAux->addAction("On"); 725 QAction *auxOn = mAux->addAction("On");
666 QAction *auxOff = mAux->addAction("Off"); 726 QAction *auxOff = mAux->addAction("Off");
667 if (!fVP.IsAuxEdgeVisible()) { 727 if (!fVP.IsAuxEdgeVisible()) {
668 createRadioAction(auxOn,auxOff,SLOT(toggle 728 createRadioAction(auxOn,auxOff,SLOT(toggleAux(bool)),2);
669 } else { 729 } else {
670 createRadioAction(auxOn,auxOff,SLOT(toggle 730 createRadioAction(auxOn,auxOff,SLOT(toggleAux(bool)),1);
671 } 731 }
672 732
673 733
674 QMenu *mHiddenMarkers = mSpecial->addMenu("H 734 QMenu *mHiddenMarkers = mSpecial->addMenu("Hidden markers");
675 QAction *hiddenMarkersOn = mHiddenMarkers->a 735 QAction *hiddenMarkersOn = mHiddenMarkers->addAction("On");
676 QAction *hiddenMarkersOff = mHiddenMarkers-> 736 QAction *hiddenMarkersOff = mHiddenMarkers->addAction("Off");
677 if (fVP.IsMarkerNotHidden()) { 737 if (fVP.IsMarkerNotHidden()) {
678 createRadioAction(hiddenMarkersOn,hiddenMa 738 createRadioAction(hiddenMarkersOn,hiddenMarkersOff,SLOT(toggleHiddenMarkers(bool)),2);
679 } else { 739 } else {
680 createRadioAction(hiddenMarkersOn,hiddenMa 740 createRadioAction(hiddenMarkersOn,hiddenMarkersOff,SLOT(toggleHiddenMarkers(bool)),1);
681 } 741 }
682 742
683 743
684 744
685 QMenu *mFullScreen = mSpecial->addMenu("&Ful 745 QMenu *mFullScreen = mSpecial->addMenu("&Full screen");
686 fFullScreenOn = mFullScreen->addAction("On") 746 fFullScreenOn = mFullScreen->addAction("On");
687 fFullScreenOff = mFullScreen->addAction("Off 747 fFullScreenOff = mFullScreen->addAction("Off");
688 createRadioAction(fFullScreenOn,fFullScreenO 748 createRadioAction(fFullScreenOn,fFullScreenOff,SLOT(toggleFullScreen(bool)),2);
689 749
690 // INIT All 750 // INIT All
691 updateToolbarAndMouseContextMenu(); 751 updateToolbarAndMouseContextMenu();
692 } 752 }
693 753
694 void G4OpenGLQtViewer::G4manageContextMenuEven 754 void G4OpenGLQtViewer::G4manageContextMenuEvent(QContextMenuEvent *e)
695 { 755 {
696 if (!fGLWidget) { 756 if (!fGLWidget) {
697 G4cerr << "Visualization window not define 757 G4cerr << "Visualization window not defined, please choose one before" << G4endl;
698 } else { 758 } else {
699 759
700 if (!fContextMenu) 760 if (!fContextMenu)
701 createPopupMenu(); 761 createPopupMenu();
702 762
703 // launch menu 763 // launch menu
704 if ( fContextMenu ) { 764 if ( fContextMenu ) {
705 fContextMenu->exec( e->globalPos() ); 765 fContextMenu->exec( e->globalPos() );
706 // delete fContextMenu; 766 // delete fContextMenu;
707 } 767 }
708 } 768 }
709 e->accept(); 769 e->accept();
710 } 770 }
711 771
712 772
713 /** 773 /**
714 Create a radio button menu. The two menu wi 774 Create a radio button menu. The two menu will be connected. When click on one,
715 eatch state will be invert and callback met 775 eatch state will be invert and callback method will be called.
716 @param action1 first action to connect 776 @param action1 first action to connect
717 @param action2 second action to connect 777 @param action2 second action to connect
718 @param method callback method 778 @param method callback method
719 @param nCheck: 1 : first action will be set 779 @param nCheck: 1 : first action will be set true. 2 : second action will be set true
720 */ 780 */
721 void G4OpenGLQtViewer::createRadioAction(QActi 781 void G4OpenGLQtViewer::createRadioAction(QAction *action1,QAction *action2, const std::string& method,unsigned int nCheck) {
722 782
723 action1->setCheckable(true); 783 action1->setCheckable(true);
724 action2->setCheckable(true); 784 action2->setCheckable(true);
725 785
726 if (nCheck ==1) 786 if (nCheck ==1)
727 action1->setChecked (true); 787 action1->setChecked (true);
728 else 788 else
729 action2->setChecked (true); 789 action2->setChecked (true);
730 790
731 QObject ::connect(action1, SIGNAL(triggered( 791 QObject ::connect(action1, SIGNAL(triggered(bool)),action2, SLOT(toggle()));
732 QObject ::connect(action2, SIGNAL(triggered( 792 QObject ::connect(action2, SIGNAL(triggered(bool)),action1, SLOT(toggle()));
733 793
734 QObject ::connect(action1, SIGNAL(toggled(bo 794 QObject ::connect(action1, SIGNAL(toggled(bool)),this, method.c_str());
735 795
736 } 796 }
737 797
738 798
739 799
740 /** 800 /**
741 Show shortcuts for this mouse action 801 Show shortcuts for this mouse action
742 */ 802 */
743 void G4OpenGLQtViewer::showShortcuts() { 803 void G4OpenGLQtViewer::showShortcuts() {
744 G4String text; 804 G4String text;
745 805
746 text = "========= Mouse Shortcuts =========\ 806 text = "========= Mouse Shortcuts =========\n";
747 if (fUiQt != NULL) { 807 if (fUiQt != NULL) {
748 if (fUiQt->IsIconRotateSelected()) { // r 808 if (fUiQt->IsIconRotateSelected()) { // rotate
749 text += "Click and move mouse to rotate 809 text += "Click and move mouse to rotate volume \n";
750 text += "ALT + Click and move mouse to r 810 text += "ALT + Click and move mouse to rotate volume (Toggle View/Theta-Phi Direction) \n";
751 text += "CTRL + Click and move mouse to 811 text += "CTRL + Click and move mouse to zoom in/out \n";
752 text += "SHIFT + Click and move mouse to 812 text += "SHIFT + Click and move mouse to change camera point of view \n";
753 } else if (fUiQt->IsIconMoveSelected()) { 813 } else if (fUiQt->IsIconMoveSelected()) { //move
754 text += "Move camera point of view with 814 text += "Move camera point of view with mouse \n";
755 } else if (fUiQt->IsIconPickSelected()) { 815 } else if (fUiQt->IsIconPickSelected()) { //pick
756 text += "Click and pick \n"; 816 text += "Click and pick \n";
757 } 817 }
758 } else { 818 } else {
759 text += "Click and move mouse to rotate vo 819 text += "Click and move mouse to rotate volume \n";
760 text += "ALT + Click and move mouse to rot 820 text += "ALT + Click and move mouse to rotate volume (Toggle View/Theta-Phi Direction) \n";
761 text += "CTRL + Click and zoom mouse to zo 821 text += "CTRL + Click and zoom mouse to zoom in/out \n";
762 text += "SHIFT + Click and zoommove camera 822 text += "SHIFT + Click and zoommove camera point of view \n";
763 } 823 }
764 text += "========= Move Shortcuts ========= 824 text += "========= Move Shortcuts ========= \n";
765 text += "Press left/right arrows to move vol 825 text += "Press left/right arrows to move volume left/right \n";
766 text += "Press up/down arrows to move volume 826 text += "Press up/down arrows to move volume up/down \n";
767 text += "Press '+'/'-' to move volume toward 827 text += "Press '+'/'-' to move volume toward/forward \n";
768 text += "\n"; 828 text += "\n";
769 text += "========= Rotation (Theta/Phi) Shor 829 text += "========= Rotation (Theta/Phi) Shortcuts ========= \n";
770 text += "Press SHIFT + left/right arrows to 830 text += "Press SHIFT + left/right arrows to rotate volume left/right \n";
771 text += "Press SHIFT + up/down arrows to rot 831 text += "Press SHIFT + up/down arrows to rotate volume up/down \n";
772 text += "\n"; 832 text += "\n";
773 text += "========= Rotation (View Direction) 833 text += "========= Rotation (View Direction) Shortcuts ========= \n";
774 text += "Press ALT + left/right to rotate vo 834 text += "Press ALT + left/right to rotate volume around vertical direction \n";
775 text += "Press ALT + up/down to rotate volum 835 text += "Press ALT + up/down to rotate volume around horizontal direction \n";
776 text += "\n"; 836 text += "\n";
777 text += "========= Zoom View ========= \n"; 837 text += "========= Zoom View ========= \n";
778 text += "Press CTRL + '+'/'-' to zoom into v 838 text += "Press CTRL + '+'/'-' to zoom into volume \n";
779 text += "\n"; 839 text += "\n";
780 text += "========= Misc ========= \n"; 840 text += "========= Misc ========= \n";
781 text += "Press ALT +/- to slow/speed rotatio 841 text += "Press ALT +/- to slow/speed rotation/move \n";
782 text += "Press H to reset view \n"; 842 text += "Press H to reset view \n";
783 text += "Press Esc to exit FullScreen \n"; 843 text += "Press Esc to exit FullScreen \n";
784 text += "\n"; 844 text += "\n";
785 text += "========= Video ========= \n"; 845 text += "========= Video ========= \n";
786 text += "In video mode : \n"; 846 text += "In video mode : \n";
787 text += " Press SPACE to Start/Pause video r 847 text += " Press SPACE to Start/Pause video recording \n";
788 text += " Press RETURN to Stop video recordi 848 text += " Press RETURN to Stop video recording \n";
789 text += "\n"; 849 text += "\n";
790 850
791 G4cout << text; 851 G4cout << text;
792 852
793 if ( fShortcutsDialog == NULL) { 853 if ( fShortcutsDialog == NULL) {
794 fShortcutsDialog = new QDialog(); 854 fShortcutsDialog = new QDialog();
795 fShortcutsDialogInfos = new QTextEdit() ; 855 fShortcutsDialogInfos = new QTextEdit() ;
796 QVBoxLayout *mainLayout = new QVBoxLayout; 856 QVBoxLayout *mainLayout = new QVBoxLayout;
797 mainLayout->addWidget(fShortcutsDialogInfo 857 mainLayout->addWidget(fShortcutsDialogInfos);
798 fShortcutsDialog->setLayout(mainLayout); 858 fShortcutsDialog->setLayout(mainLayout);
799 fShortcutsDialog->setWindowTitle(tr("Short 859 fShortcutsDialog->setWindowTitle(tr("Shortcuts"));
800 } 860 }
801 861
802 fShortcutsDialogInfos->setPlainText(text.dat 862 fShortcutsDialogInfos->setPlainText(text.data());
803 fShortcutsDialog->show(); 863 fShortcutsDialog->show();
804 } 864 }
805 865
806 866
807 867
808 /** 868 /**
809 Slot activated when mouse action is toggle 869 Slot activated when mouse action is toggle
810 @param aAction : 1 rotate, 2 move, 3 pick, 870 @param aAction : 1 rotate, 2 move, 3 pick, 4 zoom out, 5 zoom in
811 @see G4OpenGLStoredQtViewer::DrawView 871 @see G4OpenGLStoredQtViewer::DrawView
812 @see G4XXXStoredViewer::CompareForKernelVis 872 @see G4XXXStoredViewer::CompareForKernelVisit
813 */ 873 */
814 void G4OpenGLQtViewer::toggleMouseAction(int a 874 void G4OpenGLQtViewer::toggleMouseAction(int aAction) {
815 875
816 if (aAction == 1) { 876 if (aAction == 1) {
817 fUiQt->SetIconRotateSelected(); 877 fUiQt->SetIconRotateSelected();
818 } else if (aAction == 2) { 878 } else if (aAction == 2) {
819 fUiQt->SetIconMoveSelected(); 879 fUiQt->SetIconMoveSelected();
820 } else if (aAction == 3) { 880 } else if (aAction == 3) {
821 togglePicking(); 881 togglePicking();
822 } else if (aAction == 4) { 882 } else if (aAction == 4) {
823 fUiQt->SetIconZoomOutSelected(); 883 fUiQt->SetIconZoomOutSelected();
824 } else if (aAction == 5) { 884 } else if (aAction == 5) {
825 fUiQt->SetIconZoomInSelected(); 885 fUiQt->SetIconZoomInSelected();
826 } 886 }
827 887
828 updateQWidget(); 888 updateQWidget();
829 updateToolbarAndMouseContextMenu(); 889 updateToolbarAndMouseContextMenu();
830 } 890 }
831 891
832 892
833 /** 893 /**
834 Slot activated when drawing menu is toggle 894 Slot activated when drawing menu is toggle
835 Warning : When G4OpenGLStoredQtViewer::Draw 895 Warning : When G4OpenGLStoredQtViewer::DrawView() method call,
836 KernelVisitDecision () will be call and wil 896 KernelVisitDecision () will be call and will set the fNeedKernelVisit
837 to 1. See G4XXXStoredViewer::CompareForKern 897 to 1. See G4XXXStoredViewer::CompareForKernelVisit for explanations.
838 It will cause a redraw of the view 898 It will cause a redraw of the view
839 @param aAction : 1 wireframe, 2 line remova 899 @param aAction : 1 wireframe, 2 line removal, 3 surface removal, 4 line & surface removal
840 @see G4OpenGLStoredQtViewer::DrawView 900 @see G4OpenGLStoredQtViewer::DrawView
841 @see G4XXXStoredViewer::CompareForKernelVis 901 @see G4XXXStoredViewer::CompareForKernelVisit
842 */ 902 */
843 void G4OpenGLQtViewer::toggleSurfaceAction(int 903 void G4OpenGLQtViewer::toggleSurfaceAction(int aAction) {
844 904
845 G4ViewParameters::DrawingStyle d_style = G4V 905 G4ViewParameters::DrawingStyle d_style = G4ViewParameters::wireframe;
846 906
847 if (aAction ==1) { 907 if (aAction ==1) {
848 d_style = G4ViewParameters::wireframe; 908 d_style = G4ViewParameters::wireframe;
849 909
850 } else if (aAction ==2) { 910 } else if (aAction ==2) {
851 d_style = G4ViewParameters::hlr; 911 d_style = G4ViewParameters::hlr;
852 912
853 } else if (aAction ==3) { 913 } else if (aAction ==3) {
854 d_style = G4ViewParameters::hsr; 914 d_style = G4ViewParameters::hsr;
855 915
856 } else if (aAction ==4) { 916 } else if (aAction ==4) {
857 d_style = G4ViewParameters::hlhsr; 917 d_style = G4ViewParameters::hlhsr;
858 } 918 }
859 fVP.SetDrawingStyle(d_style); 919 fVP.SetDrawingStyle(d_style);
860 920
861 updateToolbarAndMouseContextMenu(); 921 updateToolbarAndMouseContextMenu();
862 updateQWidget(); 922 updateQWidget();
863 } 923 }
864 924
865 925
866 /** 926 /**
867 SLOT Activate by a click on the projection 927 SLOT Activate by a click on the projection menu
868 Warning : When G4OpenGLStoredQtViewer::Draw 928 Warning : When G4OpenGLStoredQtViewer::DrawView() method call,
869 KernelVisitDecision () will be call and wil 929 KernelVisitDecision () will be call and will set the fNeedKernelVisit
870 to 1. See G4XXXStoredViewer::CompareForKern 930 to 1. See G4XXXStoredViewer::CompareForKernelVisit for explanations.
871 It will cause a redraw of the view 931 It will cause a redraw of the view
872 @param check : 1 orthographic, 2 perspectiv 932 @param check : 1 orthographic, 2 perspective
873 @see G4OpenGLStoredQtViewer::DrawView 933 @see G4OpenGLStoredQtViewer::DrawView
874 @see G4XXXStoredViewer::CompareForKernelVis 934 @see G4XXXStoredViewer::CompareForKernelVisit
875 */ 935 */
876 void G4OpenGLQtViewer::toggleProjection(bool c 936 void G4OpenGLQtViewer::toggleProjection(bool check) {
877 937
878 if (check) { 938 if (check) {
879 fVP.SetOrthogonalProjection (); 939 fVP.SetOrthogonalProjection ();
880 } else { 940 } else {
881 fVP.SetPerspectiveProjection(); 941 fVP.SetPerspectiveProjection();
882 } 942 }
883 updateToolbarAndMouseContextMenu(); 943 updateToolbarAndMouseContextMenu();
884 updateQWidget(); 944 updateQWidget();
885 } 945 }
886 946
887 947
888 /** 948 /**
889 SLOT Activate by a click on the transparenc 949 SLOT Activate by a click on the transparency menu
890 @param check : 1 , 0 950 @param check : 1 , 0
891 */ 951 */
892 void G4OpenGLQtViewer::toggleTransparency(bool 952 void G4OpenGLQtViewer::toggleTransparency(bool check) {
893 953
894 if (check) { 954 if (check) {
895 transparency_enabled = true; 955 transparency_enabled = true;
896 } else { 956 } else {
897 transparency_enabled = false; 957 transparency_enabled = false;
898 } 958 }
899 SetNeedKernelVisit (true); 959 SetNeedKernelVisit (true);
900 updateToolbarAndMouseContextMenu(); 960 updateToolbarAndMouseContextMenu();
901 updateQWidget(); 961 updateQWidget();
902 } 962 }
903 963
904 /** 964 /**
905 SLOT Activate by a click on the antialiasin 965 SLOT Activate by a click on the antialiasing menu
906 @param check : 1 , 0 966 @param check : 1 , 0
907 */ 967 */
908 void G4OpenGLQtViewer::toggleAntialiasing(bool 968 void G4OpenGLQtViewer::toggleAntialiasing(bool check) {
909 969
910 if (!check) { 970 if (!check) {
911 antialiasing_enabled = false; 971 antialiasing_enabled = false;
912 glDisable (GL_LINE_SMOOTH); 972 glDisable (GL_LINE_SMOOTH);
913 glDisable (GL_POLYGON_SMOOTH); 973 glDisable (GL_POLYGON_SMOOTH);
914 } else { 974 } else {
915 antialiasing_enabled = true; 975 antialiasing_enabled = true;
916 glEnable (GL_LINE_SMOOTH); 976 glEnable (GL_LINE_SMOOTH);
917 glHint (GL_LINE_SMOOTH_HINT, GL_NICEST); 977 glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
918 glEnable (GL_POLYGON_SMOOTH); 978 glEnable (GL_POLYGON_SMOOTH);
919 glHint (GL_POLYGON_SMOOTH_HINT, GL_NICEST) 979 glHint (GL_POLYGON_SMOOTH_HINT, GL_NICEST);
920 } 980 }
921 981
922 updateToolbarAndMouseContextMenu(); 982 updateToolbarAndMouseContextMenu();
923 updateQWidget(); 983 updateQWidget();
924 } 984 }
925 985
926 /** 986 /**
927 SLOT Activate by a click on the haloing men 987 SLOT Activate by a click on the haloing menu
928 @param check : 1 , 0 988 @param check : 1 , 0
929 */ 989 */
930 //FIXME : I SEE NOTHING... 990 //FIXME : I SEE NOTHING...
931 void G4OpenGLQtViewer::toggleHaloing(bool chec 991 void G4OpenGLQtViewer::toggleHaloing(bool check) {
932 if (check) { 992 if (check) {
933 haloing_enabled = false; 993 haloing_enabled = false;
934 } else { 994 } else {
935 haloing_enabled = true; 995 haloing_enabled = true;
936 } 996 }
937 997
938 updateToolbarAndMouseContextMenu(); 998 updateToolbarAndMouseContextMenu();
939 updateQWidget(); 999 updateQWidget();
940 1000
941 } 1001 }
942 1002
943 /** 1003 /**
944 SLOT Activate by a click on the auxiliaire 1004 SLOT Activate by a click on the auxiliaire edges menu
945 @param check : 1 , 0 1005 @param check : 1 , 0
946 */ 1006 */
947 void G4OpenGLQtViewer::toggleAux(bool check) { 1007 void G4OpenGLQtViewer::toggleAux(bool check) {
948 if (check) { 1008 if (check) {
949 fVP.SetAuxEdgeVisible(true); 1009 fVP.SetAuxEdgeVisible(true);
950 } else { 1010 } else {
951 fVP.SetAuxEdgeVisible(false); 1011 fVP.SetAuxEdgeVisible(false);
952 } 1012 }
953 SetNeedKernelVisit (true); 1013 SetNeedKernelVisit (true);
954 updateToolbarAndMouseContextMenu(); 1014 updateToolbarAndMouseContextMenu();
955 updateQWidget(); 1015 updateQWidget();
956 } 1016 }
957 1017
958 1018
959 void G4OpenGLQtViewer::togglePicking() { 1019 void G4OpenGLQtViewer::togglePicking() {
960 // FIXME : Not the good way to do, we should 1020 // FIXME : Not the good way to do, we should handle the multiple cases of Icon/ContextMenu and CheckBox in a better way
961 if (fUiQt) { 1021 if (fUiQt) {
962 if (!fVP.IsPicking()) { 1022 if (!fVP.IsPicking()) {
963 fUiQt->SetIconPickSelected(); 1023 fUiQt->SetIconPickSelected();
964 } else { 1024 } else {
965 fUiQt->SetIconRotateSelected(); 1025 fUiQt->SetIconRotateSelected();
966 } 1026 }
967 } 1027 }
968 1028
969 G4UImanager* UI = G4UImanager::GetUIpointer( 1029 G4UImanager* UI = G4UImanager::GetUIpointer();
970 if(UI != NULL) { 1030 if(UI != NULL) {
971 if (!fVP.IsPicking()) { 1031 if (!fVP.IsPicking()) {
972 UI->ApplyCommand(std::string("/vis/viewe 1032 UI->ApplyCommand(std::string("/vis/viewer/set/picking true"));
973 } else { 1033 } else {
974 UI->ApplyCommand(std::string("/vis/viewe 1034 UI->ApplyCommand(std::string("/vis/viewer/set/picking false"));
975 } 1035 }
976 } 1036 }
977 1037
978 } 1038 }
979 1039
980 1040
981 /** 1041 /**
982 SLOT Activate by a click on the hidden mark 1042 SLOT Activate by a click on the hidden marker menu
983 @param check : 1 , 0 1043 @param check : 1 , 0
984 */ 1044 */
985 void G4OpenGLQtViewer::toggleHiddenMarkers(boo 1045 void G4OpenGLQtViewer::toggleHiddenMarkers(bool check) {
986 if (check) { 1046 if (check) {
987 fVP.SetMarkerHidden(); 1047 fVP.SetMarkerHidden();
988 } else { 1048 } else {
989 fVP.SetMarkerNotHidden(); 1049 fVP.SetMarkerNotHidden();
990 } 1050 }
991 // SetNeedKernelVisit (true); 1051 // SetNeedKernelVisit (true);
992 updateToolbarAndMouseContextMenu(); 1052 updateToolbarAndMouseContextMenu();
993 updateQWidget(); 1053 updateQWidget();
994 } 1054 }
995 1055
996 /** 1056 /**
997 SLOT Activate by a click on the full screen 1057 SLOT Activate by a click on the full screen menu
998 */ 1058 */
999 void G4OpenGLQtViewer::toggleFullScreen(bool c 1059 void G4OpenGLQtViewer::toggleFullScreen(bool check) {
1000 if (check != fGLWidget->isFullScreen()) { / 1060 if (check != fGLWidget->isFullScreen()) { //toggle
1001 fGLWidget->setWindowState(fGLWidget->wind 1061 fGLWidget->setWindowState(fGLWidget->windowState() ^ Qt::WindowFullScreen);
1002 } 1062 }
1003 } 1063 }
1004 1064
1005 1065
1006 void G4OpenGLQtViewer::savePPMToTemp() { 1066 void G4OpenGLQtViewer::savePPMToTemp() {
1007 if (fMovieTempFolderPath == "") { 1067 if (fMovieTempFolderPath == "") {
1008 return; 1068 return;
1009 } 1069 }
1010 auto qGLW = dynamic_cast<G4QGLWidgetType*> << 1070 QGLWidget* qGLW = dynamic_cast<QGLWidget*> (fGLWidget) ;
1011 if (! qGLW) { 1071 if (! qGLW) {
1012 return; 1072 return;
1013 } 1073 }
1014 QString fileName ="Test"+QString::number(fR 1074 QString fileName ="Test"+QString::number(fRecordFrameNumber)+".ppm";
1015 QString filePath =fMovieTempFolderPath+file 1075 QString filePath =fMovieTempFolderPath+fileName;
1016 1076
1017 QImage image; 1077 QImage image;
1018 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)) <<
1019 image = qGLW->grabFrameBuffer(); 1078 image = qGLW->grabFrameBuffer();
1020 #else <<
1021 image = qGLW->grabFramebuffer(); <<
1022 #endif <<
1023 bool res = false; 1079 bool res = false;
1024 1080
1025 res = image.save(filePath,0); 1081 res = image.save(filePath,0);
1026 if (res == false) { 1082 if (res == false) {
1027 resetRecording(); 1083 resetRecording();
1028 setRecordingInfos("Can't save tmp file "+ 1084 setRecordingInfos("Can't save tmp file "+filePath);
1029 return; 1085 return;
1030 } 1086 }
1031 1087
1032 setRecordingInfos("File "+fileName+" saved" 1088 setRecordingInfos("File "+fileName+" saved");
1033 fRecordFrameNumber++; 1089 fRecordFrameNumber++;
1034 } 1090 }
1035 1091
1036 1092
1037 1093
1038 void G4OpenGLQtViewer::actionSaveImage() { 1094 void G4OpenGLQtViewer::actionSaveImage() {
1039 QString filters; 1095 QString filters;
1040 for (unsigned int i = 0; i < fExportImageFo 1096 for (unsigned int i = 0; i < fExportImageFormatVector.size(); ++i) {
1041 filters += QString("*.") + fExportImageFo 1097 filters += QString("*.") + fExportImageFormatVector.at(i).c_str() + ";;";
1042 } 1098 }
1043 1099
1044 QString* selectedFormat = new QString(fDefa 1100 QString* selectedFormat = new QString(fDefaultExportImageFormat.c_str());
1045 QString qFilename; 1101 QString qFilename;
1046 qFilename = QFileDialog::getSaveFileName ( 1102 qFilename = QFileDialog::getSaveFileName ( fGLWidget,
1047 tr(" 1103 tr("Save as ..."),
1048 fFil 1104 fFileSavePath,
1049 filt 1105 filters,
1050 sele 1106 selectedFormat );
1051 1107
1052 1108
1053 std::string name = qFilename.toStdString(). 1109 std::string name = qFilename.toStdString().c_str();
1054 1110
1055 // bmp jpg jpeg png ppm xbm xpm 1111 // bmp jpg jpeg png ppm xbm xpm
1056 if (name.empty()) { 1112 if (name.empty()) {
1057 return; 1113 return;
1058 } 1114 }
1059 1115
1060 fFileSavePath = QFileInfo(qFilename).path() 1116 fFileSavePath = QFileInfo(qFilename).path();
1061 1117
1062 std::string format = selectedFormat->toLowe 1118 std::string format = selectedFormat->toLower().toStdString().c_str();
1063 1119
1064 // set the format to current 1120 // set the format to current
1065 fExportImageFormat = format.substr(format.f 1121 fExportImageFormat = format.substr(format.find_last_of(".") + 1);
1066 1122
1067 std::string filename = name; 1123 std::string filename = name;
1068 std::string extension = ""; 1124 std::string extension = "";
1069 if (name.find_last_of(".") != std::string:: 1125 if (name.find_last_of(".") != std::string::npos) {
1070 filename = name.substr(0,name.find_last_o 1126 filename = name.substr(0,name.find_last_of(".") + 1);
1071 extension = name.substr(name.find_last_of 1127 extension = name.substr(name.find_last_of(".") + 1);
1072 } else { 1128 } else {
1073 extension = fExportImageFormat; 1129 extension = fExportImageFormat;
1074 } 1130 }
1075 1131
1076 filename+= "."+ extension; 1132 filename+= "."+ extension;
1077 1133
1078 if (!setExportFilename(filename.c_str(),0)) 1134 if (!setExportFilename(filename.c_str(),0)) {
1079 return; 1135 return;
1080 } 1136 }
1081 1137
1082 G4OpenGLQtExportDialog* exportDialog= new G 1138 G4OpenGLQtExportDialog* exportDialog= new G4OpenGLQtExportDialog(fGLWidget,format.c_str(),fGLWidget->height(),fGLWidget->width());
1083 if( exportDialog->exec()) { 1139 if( exportDialog->exec()) {
1084 1140
1085 if ((exportDialog->getWidth() !=fGLWidget 1141 if ((exportDialog->getWidth() !=fGLWidget->width()) ||
1086 (exportDialog->getHeight() !=fGLWidge 1142 (exportDialog->getHeight() !=fGLWidget->height())) {
1087 setExportSize(exportDialog->getWidth(), 1143 setExportSize(exportDialog->getWidth(),exportDialog->getHeight());
1088 1144
1089 } 1145 }
1090 if (fExportImageFormat == "eps") { 1146 if (fExportImageFormat == "eps") {
1091 fVectoredPs = exportDialog->getVectorEP 1147 fVectoredPs = exportDialog->getVectorEPS();
1092 } else if (fExportImageFormat == "ps") { 1148 } else if (fExportImageFormat == "ps") {
1093 fVectoredPs = true; 1149 fVectoredPs = true;
1094 } 1150 }
1095 fLastExportSliderValue = exportDialog->ge 1151 fLastExportSliderValue = exportDialog->getSliderValue();
1096 1152
1097 if (exportImage(filename)) { 1153 if (exportImage(filename)) {
1098 // set the default format to current 1154 // set the default format to current
1099 fDefaultExportImageFormat = format; 1155 fDefaultExportImageFormat = format;
1100 } 1156 }
1101 } else { // cancel selected 1157 } else { // cancel selected
1102 return; 1158 return;
1103 } 1159 }
1104 1160
1105 } 1161 }
1106 1162
1107 1163
1108 void G4OpenGLQtViewer::actionChangeBackground 1164 void G4OpenGLQtViewer::actionChangeBackgroundColor() {
1109 1165
1110 // //I need to revisit the kernel if the 1166 // //I need to revisit the kernel if the background colour changes and
1111 // //hidden line removal is enabled, beca 1167 // //hidden line removal is enabled, because hlr drawing utilises the
1112 // //background colour in its drawing... 1168 // //background colour in its drawing...
1113 // // (Note added by JA 13/9/2005) Backgr 1169 // // (Note added by JA 13/9/2005) Background now handled in view
1114 // // parameters. A kernel visit is trig 1170 // // parameters. A kernel visit is triggered on change of background.
>> 1171
>> 1172 #if QT_VERSION < 0x040500
>> 1173 bool a;
>> 1174 const QColor color = QColor(QColorDialog::getRgba (QColor(Qt::black).rgba(),&a,fGLWidget));
>> 1175 #else
1115 const QColor color = 1176 const QColor color =
1116 QColorDialog::getColor(Qt::black, 1177 QColorDialog::getColor(Qt::black,
1117 fGLWidget, 1178 fGLWidget,
1118 " Get background c 1179 " Get background color and transparency",
1119 QColorDialog::Show 1180 QColorDialog::ShowAlphaChannel);
>> 1181 #endif
1120 if (color.isValid()) { 1182 if (color.isValid()) {
1121 G4Colour colour(((G4double)color.red())/2 1183 G4Colour colour(((G4double)color.red())/255,
1122 ((G4double)color.green()) 1184 ((G4double)color.green())/255,
1123 ((G4double)color.blue())/ 1185 ((G4double)color.blue())/255,
1124 ((G4double)color.alpha()) 1186 ((G4double)color.alpha())/255);
1125 fVP.SetBackgroundColour(colour); 1187 fVP.SetBackgroundColour(colour);
1126 1188
1127 updateToolbarAndMouseContextMenu(); 1189 updateToolbarAndMouseContextMenu();
1128 updateQWidget(); 1190 updateQWidget();
1129 } 1191 }
1130 } 1192 }
1131 1193
1132 void G4OpenGLQtViewer::actionChangeTextColor( 1194 void G4OpenGLQtViewer::actionChangeTextColor() {
>> 1195
>> 1196 #if QT_VERSION < 0x040500
>> 1197 bool a;
>> 1198 const QColor color = QColor(QColorDialog::getRgba (QColor(Qt::yellow).rgba(),&a,fGLWidget));
>> 1199 #else
1133 const QColor& color = 1200 const QColor& color =
1134 QColorDialog::getColor(Qt::yellow, 1201 QColorDialog::getColor(Qt::yellow,
1135 fGLWidget, 1202 fGLWidget,
1136 " Get text color a 1203 " Get text color and transparency",
1137 QColorDialog::Show 1204 QColorDialog::ShowAlphaChannel);
>> 1205 #endif
1138 if (color.isValid()) { 1206 if (color.isValid()) {
1139 G4Colour colour(((G4double)color.red())/2 1207 G4Colour colour(((G4double)color.red())/255,
1140 ((G4double)color.green()) 1208 ((G4double)color.green())/255,
1141 ((G4double)color.blue())/ 1209 ((G4double)color.blue())/255,
1142 ((G4double)color.alpha()) 1210 ((G4double)color.alpha())/255);
1143 1211
1144 fVP.SetDefaultTextColour(colour); 1212 fVP.SetDefaultTextColour(colour);
1145 1213
1146 updateToolbarAndMouseContextMenu(); 1214 updateToolbarAndMouseContextMenu();
1147 updateQWidget(); 1215 updateQWidget();
1148 } 1216 }
1149 } 1217 }
1150 1218
1151 void G4OpenGLQtViewer::actionChangeDefaultCol 1219 void G4OpenGLQtViewer::actionChangeDefaultColor() {
>> 1220
>> 1221 #if QT_VERSION < 0x040500
>> 1222 bool a;
>> 1223 const QColor color = QColor(QColorDialog::getRgba (QColor(Qt::white).rgba(),&a,fGLWidget));
>> 1224 #else
1152 const QColor& color = 1225 const QColor& color =
1153 QColorDialog::getColor(Qt::white, 1226 QColorDialog::getColor(Qt::white,
1154 fGLWidget, 1227 fGLWidget,
1155 " Get default colo 1228 " Get default color and transparency",
1156 QColorDialog::Show 1229 QColorDialog::ShowAlphaChannel);
>> 1230 #endif
1157 if (color.isValid()) { 1231 if (color.isValid()) {
1158 G4Colour colour(((G4double)color.red())/2 1232 G4Colour colour(((G4double)color.red())/255,
1159 ((G4double)color.green()) 1233 ((G4double)color.green())/255,
1160 ((G4double)color.blue())/ 1234 ((G4double)color.blue())/255,
1161 ((G4double)color.alpha()) 1235 ((G4double)color.alpha())/255);
1162 1236
1163 fVP.SetDefaultColour(colour); 1237 fVP.SetDefaultColour(colour);
1164 1238
1165 updateToolbarAndMouseContextMenu(); 1239 updateToolbarAndMouseContextMenu();
1166 updateQWidget(); 1240 updateQWidget();
1167 } 1241 }
1168 } 1242 }
1169 1243
1170 1244
1171 void G4OpenGLQtViewer::actionMovieParameters( 1245 void G4OpenGLQtViewer::actionMovieParameters() {
1172 showMovieParametersDialog(); 1246 showMovieParametersDialog();
1173 } 1247 }
1174 1248
1175 1249
1176 void G4OpenGLQtViewer::showMovieParametersDia 1250 void G4OpenGLQtViewer::showMovieParametersDialog() {
1177 if (!fMovieParametersDialog) { 1251 if (!fMovieParametersDialog) {
1178 fMovieParametersDialog= new G4OpenGLQtMov 1252 fMovieParametersDialog= new G4OpenGLQtMovieDialog(this,fGLWidget);
1179 displayRecordingStatus(); 1253 displayRecordingStatus();
1180 fMovieParametersDialog->checkEncoderSwPar 1254 fMovieParametersDialog->checkEncoderSwParameters();
1181 fMovieParametersDialog->checkSaveFileName 1255 fMovieParametersDialog->checkSaveFileNameParameters();
1182 fMovieParametersDialog->checkTempFolderPa 1256 fMovieParametersDialog->checkTempFolderParameters();
1183 if (getEncoderPath() == "") { 1257 if (getEncoderPath() == "") {
1184 setRecordingInfos("ppmtompeg is needed 1258 setRecordingInfos("ppmtompeg is needed to encode in video format. It is available here: http://netpbm.sourceforge.net ");
1185 } 1259 }
1186 } 1260 }
1187 fMovieParametersDialog->show(); 1261 fMovieParametersDialog->show();
1188 } 1262 }
1189 1263
1190 1264
1191 1265
1192 void G4OpenGLQtViewer::FinishView() 1266 void G4OpenGLQtViewer::FinishView()
1193 { 1267 {
1194 /* From Apple doc: 1268 /* From Apple doc:
1195 CGLFlushDrawable : Copies the back buffer o 1269 CGLFlushDrawable : Copies the back buffer of a double-buffered context to the front buffer.
1196 If the backing store attribute is set to fa 1270 If the backing store attribute is set to false, the buffers can be exchanged rather than copied
1197 */ 1271 */
1198 glFlush (); 1272 glFlush ();
1199 1273
1200 // L. Garnier 10/2009 : Not necessary and c 1274 // L. Garnier 10/2009 : Not necessary and cause problems on mac OS X 10.6
1201 // fGLWidget->swapBuffers (); 1275 // fGLWidget->swapBuffers ();
1202 } 1276 }
1203 1277
1204 /** 1278 /**
1205 Save the current mouse press point 1279 Save the current mouse press point
1206 @param p mouse click point 1280 @param p mouse click point
1207 */ 1281 */
1208 void G4OpenGLQtViewer::G4MousePressEvent(QMou 1282 void G4OpenGLQtViewer::G4MousePressEvent(QMouseEvent *evnt)
1209 { 1283 {
1210 if (evnt->button() == Qt::RightButton) { 1284 if (evnt->button() == Qt::RightButton) {
1211 return; 1285 return;
1212 } 1286 }
1213 if ((evnt->button() & Qt::LeftButton) && (! 1287 if ((evnt->button() & Qt::LeftButton) && (! (evnt->modifiers() & Qt::ControlModifier ))){
1214 fGLWidget->setMouseTracking(true); 1288 fGLWidget->setMouseTracking(true);
1215 fAutoMove = false; // stop automove 1289 fAutoMove = false; // stop automove
1216 fLastPos1 = evnt->pos(); 1290 fLastPos1 = evnt->pos();
1217 fLastPos2 = fLastPos1; 1291 fLastPos2 = fLastPos1;
1218 fLastPos3 = fLastPos2; 1292 fLastPos3 = fLastPos2;
1219 fLastEventTime->start(); 1293 fLastEventTime->start();
1220 if (fUiQt != NULL) { 1294 if (fUiQt != NULL) {
1221 1295
1222 if (fUiQt->IsIconZoomInSelected()) { / 1296 if (fUiQt->IsIconZoomInSelected()) { // zoomIn
1223 // Move click point to center of OGL 1297 // Move click point to center of OGL
1224 1298
1225 float deltaX = ((float)getWinWidth()/ 1299 float deltaX = ((float)getWinWidth()/2-evnt->pos().x());
1226 float deltaY = ((float)getWinHeight() 1300 float deltaY = ((float)getWinHeight()/2-evnt->pos().y());
1227 1301
1228 G4double coefTrans = 0; 1302 G4double coefTrans = 0;
1229 coefTrans = ((G4double)getSceneNearWi 1303 coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinWidth());
1230 if (getWinHeight() <getWinWidth()) { 1304 if (getWinHeight() <getWinWidth()) {
1231 coefTrans = ((G4double)getSceneNear 1305 coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinHeight());
1232 } 1306 }
1233 fVP.IncrementPan(-deltaX*coefTrans,de 1307 fVP.IncrementPan(-deltaX*coefTrans,deltaY*coefTrans,0);
1234 fVP.SetZoomFactor(1.5 * fVP.GetZoomFa 1308 fVP.SetZoomFactor(1.5 * fVP.GetZoomFactor());
1235 1309
1236 updateQWidget(); 1310 updateQWidget();
1237 1311
1238 } else if (fUiQt->IsIconZoomOutSelected 1312 } else if (fUiQt->IsIconZoomOutSelected()) { // zoomOut
1239 // Move click point to center of OGL 1313 // Move click point to center of OGL
1240 moveScene(((float)getWinWidth()/2-evn 1314 moveScene(((float)getWinWidth()/2-evnt->pos().x()),((float)getWinHeight()/2-evnt->pos().y()),0,true);
1241 1315
1242 fVP.SetZoomFactor(0.75 * fVP.GetZoomF 1316 fVP.SetZoomFactor(0.75 * fVP.GetZoomFactor());
1243 updateQWidget(); 1317 updateQWidget();
1244 1318
1245 } else if (fUiQt->IsIconRotateSelected( 1319 } else if (fUiQt->IsIconRotateSelected() ) {
1246 1320
1247 if (fShiftKeyPress) { // move 1321 if (fShiftKeyPress) { // move
1248 fGLWidget->setCursor(QCursor(Qt::Si 1322 fGLWidget->setCursor(QCursor(Qt::SizeAllCursor));
1249 1323
1250 } else { // rotate 1324 } else { // rotate
1251 fGLWidget->setCursor(QCursor(Qt::Cl 1325 fGLWidget->setCursor(QCursor(Qt::ClosedHandCursor));
1252 } 1326 }
1253 } else if (fUiQt->IsIconMoveSelected()) 1327 } else if (fUiQt->IsIconMoveSelected()) {
1254 fGLWidget->setCursor(QCursor(Qt::Size 1328 fGLWidget->setCursor(QCursor(Qt::SizeAllCursor));
1255 } else if (fUiQt->IsIconPickSelected()) 1329 } else if (fUiQt->IsIconPickSelected()) {
1256 fGLWidget->setCursor(QCursor(Qt::Poin 1330 fGLWidget->setCursor(QCursor(Qt::PointingHandCursor));
1257 } 1331 }
1258 } 1332 }
1259 } 1333 }
1260 } 1334 }
1261 1335
1262 /** 1336 /**
1263 */ 1337 */
1264 void G4OpenGLQtViewer::G4MouseReleaseEvent(QM 1338 void G4OpenGLQtViewer::G4MouseReleaseEvent(QMouseEvent *evnt)
1265 { 1339 {
1266 #if QT_VERSION < 0x060000 <<
1267 #else <<
1268 {auto* qGLW = dynamic_cast<G4QGLWidgetType*> <<
1269 if (qGLW) qGLW->makeCurrent();} <<
1270 ResizeGLView(); <<
1271 #endif <<
1272 GLint viewport[4]; 1340 GLint viewport[4];
1273 glGetIntegerv(GL_VIEWPORT, viewport); 1341 glGetIntegerv(GL_VIEWPORT, viewport);
1274 1342
1275 // factorX == factorY 1343 // factorX == factorY
1276 double factorX = ((double)viewport[2]/fGLW 1344 double factorX = ((double)viewport[2]/fGLWidget->width());
1277 double factorY = ((double)viewport[3]/fGLW 1345 double factorY = ((double)viewport[3]/fGLWidget->height());
1278 fSpinningDelay = (int)fLastEventTime->elaps 1346 fSpinningDelay = (int)fLastEventTime->elapsed();
1279 QPoint delta = (fLastPos3-fLastPos1)*factor 1347 QPoint delta = (fLastPos3-fLastPos1)*factorX;
1280 1348
1281 // reset cursor state 1349 // reset cursor state
1282 fGLWidget->setCursor(QCursor(Qt::ArrowCurso 1350 fGLWidget->setCursor(QCursor(Qt::ArrowCursor));
1283 1351
1284 if (fVP.IsPicking()){ // pick 1352 if (fVP.IsPicking()){ // pick
1285 if ((delta.x() != 0) || (delta.y() != 0)) 1353 if ((delta.x() != 0) || (delta.y() != 0)) {
1286 return; 1354 return;
1287 } 1355 }
1288 updatePickInfosWidget(evnt->pos().x()*fac 1356 updatePickInfosWidget(evnt->pos().x()*factorX,evnt->pos().y()*factorY);
1289 1357
1290 } else if (fSpinningDelay < fLaunchSpinDela 1358 } else if (fSpinningDelay < fLaunchSpinDelay ) {
1291 if ((delta.x() == 0) && (delta.y() == 0)) 1359 if ((delta.x() == 0) && (delta.y() == 0)) {
1292 return; 1360 return;
1293 } 1361 }
1294 1362
1295 fAutoMove = true; 1363 fAutoMove = true;
1296 #if (QT_VERSION < QT_VERSION_CHECK(5, 14, 0)) << 1364 #if QT_VERSION < 0x050e00
1297 QTime lastMoveTime; 1365 QTime lastMoveTime;
1298 #else 1366 #else
1299 QElapsedTimer lastMoveTime; 1367 QElapsedTimer lastMoveTime;
1300 #endif 1368 #endif
1301 lastMoveTime.start(); 1369 lastMoveTime.start();
1302 // try to addapt speed move/rotate lookin 1370 // try to addapt speed move/rotate looking to drawing speed
1303 float correctionFactor = 5; 1371 float correctionFactor = 5;
1304 while (fAutoMove) { 1372 while (fAutoMove) {
1305 if ( lastMoveTime.elapsed() >= (int)(10 1373 if ( lastMoveTime.elapsed() >= (int)(1000/fNbMaxFramesPerSec)) {
1306 float lTime = 1000.0f/lastMoveTime.el << 1374 float lTime = 1000/lastMoveTime.elapsed();
1307 if (((((float)delta.x())/correctionFa 1375 if (((((float)delta.x())/correctionFactor)*lTime > fNbMaxAnglePerSec) ||
1308 ((((float)delta.x())/correctionFa 1376 ((((float)delta.x())/correctionFactor)*lTime < -fNbMaxAnglePerSec) ) {
1309 correctionFactor = (float)delta.x() 1377 correctionFactor = (float)delta.x()*(lTime/fNbMaxAnglePerSec);
1310 if (delta.x() <0 ) { 1378 if (delta.x() <0 ) {
1311 correctionFactor = -correctionFac 1379 correctionFactor = -correctionFactor;
1312 } 1380 }
1313 } 1381 }
1314 if (((((float)delta.y())/correctionFa 1382 if (((((float)delta.y())/correctionFactor)*lTime > fNbMaxAnglePerSec) ||
1315 ((((float)delta.y())/correctionFa 1383 ((((float)delta.y())/correctionFactor)*lTime < -fNbMaxAnglePerSec) ) {
1316 correctionFactor = (float)delta.y() 1384 correctionFactor = (float)delta.y()*(lTime/fNbMaxAnglePerSec);
1317 if (delta.y() <0 ) { 1385 if (delta.y() <0 ) {
1318 correctionFactor = -correctionFac 1386 correctionFactor = -correctionFactor;
1319 } 1387 }
1320 } 1388 }
1321 1389
1322 // Check Qt Versions for META Keys 1390 // Check Qt Versions for META Keys
1323 1391
1324 // Click and move mouse to rotate vol 1392 // Click and move mouse to rotate volume
1325 // ALT + Click and move mouse to rota 1393 // ALT + Click and move mouse to rotate volume (View Direction)
1326 // SHIFT + Click and move camera poin 1394 // SHIFT + Click and move camera point of view
1327 // CTRL + Click and zoom mouse to zoo 1395 // CTRL + Click and zoom mouse to zoom in/out
1328 1396
1329 lastMoveTime.start(); 1397 lastMoveTime.start();
1330 1398
1331 bool rotate = false; 1399 bool rotate = false;
1332 bool move = false; 1400 bool move = false;
1333 1401
1334 if (fUiQt != NULL) { 1402 if (fUiQt != NULL) {
1335 if (fUiQt->IsIconRotateSelected()) 1403 if (fUiQt->IsIconRotateSelected()) { // rotate
1336 rotate = true; 1404 rotate = true;
1337 } else if (fUiQt->IsIconMoveSelecte 1405 } else if (fUiQt->IsIconMoveSelected()) { // move
1338 move = true; 1406 move = true;
1339 } 1407 }
1340 } else { 1408 } else {
1341 rotate = true; 1409 rotate = true;
1342 } 1410 }
1343 // prevent from closing widget when r 1411 // prevent from closing widget when rotating (cause a crash)
1344 if (fIsDeleting) { 1412 if (fIsDeleting) {
1345 return; 1413 return;
1346 } 1414 }
1347 1415
1348 if (rotate) { // rotate 1416 if (rotate) { // rotate
1349 if (fNoKeyPress) { 1417 if (fNoKeyPress) {
1350 rotateQtScene(((float)delta.x())/ 1418 rotateQtScene(((float)delta.x())/correctionFactor,((float)delta.y())/correctionFactor);
1351 } else if (fAltKeyPress) { 1419 } else if (fAltKeyPress) {
1352 rotateQtSceneToggle(((float)delta 1420 rotateQtSceneToggle(((float)delta.x())/correctionFactor,((float)delta.y())/correctionFactor);
1353 } 1421 }
1354 1422
1355 } else if (move) { // move 1423 } else if (move) { // move
1356 moveScene(-((float)delta.x())/corre 1424 moveScene(-((float)delta.x())/correctionFactor,-((float)delta.y())/correctionFactor,0,true);
1357 } 1425 }
1358 } 1426 }
1359 ((QApplication*)G4Qt::getInstance ())-> 1427 ((QApplication*)G4Qt::getInstance ())->processEvents();
1360 } 1428 }
1361 } 1429 }
1362 fGLWidget->setMouseTracking(false); 1430 fGLWidget->setMouseTracking(false);
1363 1431
1364 } 1432 }
1365 1433
1366 1434
1367 void G4OpenGLQtViewer::G4MouseDoubleClickEven 1435 void G4OpenGLQtViewer::G4MouseDoubleClickEvent()
1368 { 1436 {
1369 fGLWidget->setMouseTracking(true); 1437 fGLWidget->setMouseTracking(true);
1370 } 1438 }
1371 1439
1372 1440
1373 /** 1441 /**
1374 @param pos_x mouse x position 1442 @param pos_x mouse x position
1375 @param pos_y mouse y position 1443 @param pos_y mouse y position
1376 @param mButtons mouse button active 1444 @param mButtons mouse button active
1377 @param mAutoMove true: apply this move til 1445 @param mAutoMove true: apply this move till another evnt came, false :one time move
1378 */ 1446 */
1379 1447
1380 void G4OpenGLQtViewer::G4MouseMoveEvent(QMous 1448 void G4OpenGLQtViewer::G4MouseMoveEvent(QMouseEvent *evnt)
1381 { 1449 {
1382 1450
1383 Qt::MouseButtons mButtons = evnt->buttons() 1451 Qt::MouseButtons mButtons = evnt->buttons();
1384 1452
1385 updateKeyModifierState(evnt->modifiers()); 1453 updateKeyModifierState(evnt->modifiers());
1386 1454
1387 if (fAutoMove) { 1455 if (fAutoMove) {
1388 return; 1456 return;
1389 } 1457 }
1390 1458
1391 fLastPos3 = fLastPos2; 1459 fLastPos3 = fLastPos2;
1392 fLastPos2 = fLastPos1; 1460 fLastPos2 = fLastPos1;
1393 <<
1394 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)) <<
1395 fLastPos1 = QPoint(evnt->x(), evnt->y()); 1461 fLastPos1 = QPoint(evnt->x(), evnt->y());
1396 #else <<
1397 fLastPos1 = QPoint(evnt->position().x(), ev <<
1398 #endif <<
1399 1462
1400 int deltaX = fLastPos2.x()-fLastPos1.x(); 1463 int deltaX = fLastPos2.x()-fLastPos1.x();
1401 int deltaY = fLastPos2.y()-fLastPos1.y(); 1464 int deltaY = fLastPos2.y()-fLastPos1.y();
1402 1465
1403 bool move = false; 1466 bool move = false;
1404 if (fUiQt != NULL) { 1467 if (fUiQt != NULL) {
1405 if (fUiQt->IsIconMoveSelected()) { // mo 1468 if (fUiQt->IsIconMoveSelected()) { // move
1406 move = true; 1469 move = true;
1407 } 1470 }
1408 } 1471 }
1409 if (!move) { // rotate, pick, zoom... 1472 if (!move) { // rotate, pick, zoom...
1410 if (mButtons & Qt::LeftButton) { 1473 if (mButtons & Qt::LeftButton) {
1411 if (fNoKeyPress) { 1474 if (fNoKeyPress) {
1412 rotateQtScene(((float)deltaX),((float 1475 rotateQtScene(((float)deltaX),((float)deltaY));
1413 } else if (fAltKeyPress) { 1476 } else if (fAltKeyPress) {
1414 rotateQtSceneToggle(((float)deltaX),( 1477 rotateQtSceneToggle(((float)deltaX),((float)deltaY));
1415 } else if (fShiftKeyPress) { 1478 } else if (fShiftKeyPress) {
1416 unsigned int sizeWin; 1479 unsigned int sizeWin;
1417 sizeWin = getWinWidth(); 1480 sizeWin = getWinWidth();
1418 if (getWinHeight() < getWinWidth()) { 1481 if (getWinHeight() < getWinWidth()) {
1419 sizeWin = getWinHeight(); 1482 sizeWin = getWinHeight();
1420 } 1483 }
1421 1484
1422 // L.Garnier : 08/2010 100 is the goo 1485 // L.Garnier : 08/2010 100 is the good value, but don't ask me why !
1423 float factor = ((float)100/(float)siz 1486 float factor = ((float)100/(float)sizeWin) ;
1424 moveScene(-(float)deltaX*factor,-(flo 1487 moveScene(-(float)deltaX*factor,-(float)deltaY*factor,0,false);
1425 } else if (fControlKeyPress) { 1488 } else if (fControlKeyPress) {
1426 fVP.SetZoomFactor(fVP.GetZoomFactor() 1489 fVP.SetZoomFactor(fVP.GetZoomFactor()*(1+((float)deltaY)));
1427 } 1490 }
1428 } 1491 }
1429 } else if (move) { // move 1492 } else if (move) { // move
1430 if (mButtons & Qt::LeftButton) { 1493 if (mButtons & Qt::LeftButton) {
1431 moveScene(-(float)deltaX,-(float)deltaY 1494 moveScene(-(float)deltaX,-(float)deltaY,0,true);
1432 } 1495 }
1433 } 1496 }
1434 1497
1435 fLastEventTime->start(); 1498 fLastEventTime->start();
1436 } 1499 }
1437 1500
1438 1501
1439 /** 1502 /**
1440 Move the scene of dx, dy, dz values. 1503 Move the scene of dx, dy, dz values.
1441 @param dx delta mouse x position 1504 @param dx delta mouse x position
1442 @param dy delta mouse y position 1505 @param dy delta mouse y position
1443 @param mouseMove : true if event comes fro 1506 @param mouseMove : true if event comes from a mouse move, false if event comes from key action
1444 */ 1507 */
1445 1508
1446 void G4OpenGLQtViewer::moveScene(float dx,flo 1509 void G4OpenGLQtViewer::moveScene(float dx,float dy, float dz,bool mouseMove)
1447 { 1510 {
1448 if (fHoldMoveEvent) 1511 if (fHoldMoveEvent)
1449 return; 1512 return;
1450 fHoldMoveEvent = true; 1513 fHoldMoveEvent = true;
1451 1514
1452 G4double coefTrans = 0; 1515 G4double coefTrans = 0;
1453 GLdouble coefDepth = 0; 1516 GLdouble coefDepth = 0;
1454 if(mouseMove) { 1517 if(mouseMove) {
1455 coefTrans = ((G4double)getSceneNearWidth( 1518 coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinWidth());
1456 if (getWinHeight() <getWinWidth()) { 1519 if (getWinHeight() <getWinWidth()) {
1457 coefTrans = ((G4double)getSceneNearWidt 1520 coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinHeight());
1458 } 1521 }
1459 } else { 1522 } else {
1460 coefTrans = getSceneNearWidth()*fPan_sens 1523 coefTrans = getSceneNearWidth()*fPan_sens;
1461 coefDepth = getSceneDepth()*fDeltaDepth; 1524 coefDepth = getSceneDepth()*fDeltaDepth;
1462 } 1525 }
1463 fVP.IncrementPan(-dx*coefTrans,dy*coefTrans 1526 fVP.IncrementPan(-dx*coefTrans,dy*coefTrans,dz*coefDepth);
1464 1527
1465 updateQWidget(); 1528 updateQWidget();
1466 if (fAutoMove) 1529 if (fAutoMove)
1467 ((QApplication*)G4Qt::getInstance ())->pr 1530 ((QApplication*)G4Qt::getInstance ())->processEvents();
1468 1531
1469 fHoldMoveEvent = false; 1532 fHoldMoveEvent = false;
1470 } 1533 }
1471 1534
1472 1535
1473 /** 1536 /**
1474 @param dx delta mouse x position 1537 @param dx delta mouse x position
1475 @param dy delta mouse y position 1538 @param dy delta mouse y position
1476 */ 1539 */
1477 1540
1478 void G4OpenGLQtViewer::rotateQtScene(float dx 1541 void G4OpenGLQtViewer::rotateQtScene(float dx, float dy)
1479 { 1542 {
1480 if (fHoldRotateEvent) 1543 if (fHoldRotateEvent)
1481 return; 1544 return;
1482 fHoldRotateEvent = true; 1545 fHoldRotateEvent = true;
1483 1546
1484 rotateScene(dx,dy); 1547 rotateScene(dx,dy);
1485 1548
1486 updateQWidget(); 1549 updateQWidget();
1487 1550
1488 fHoldRotateEvent = false; 1551 fHoldRotateEvent = false;
1489 } 1552 }
1490 1553
1491 /** 1554 /**
1492 @param dx delta mouse x position 1555 @param dx delta mouse x position
1493 @param dy delta mouse y position 1556 @param dy delta mouse y position
1494 */ 1557 */
1495 1558
1496 void G4OpenGLQtViewer::rotateQtSceneToggle(fl 1559 void G4OpenGLQtViewer::rotateQtSceneToggle(float dx, float dy)
1497 { 1560 {
1498 if (fHoldRotateEvent) 1561 if (fHoldRotateEvent)
1499 return; 1562 return;
1500 fHoldRotateEvent = true; 1563 fHoldRotateEvent = true;
1501 1564
1502 rotateSceneToggle(dx,dy); 1565 rotateSceneToggle(dx,dy);
1503 1566
1504 updateQWidget(); 1567 updateQWidget();
1505 1568
1506 fHoldRotateEvent = false; 1569 fHoldRotateEvent = false;
1507 } 1570 }
1508 1571
1509 1572
1510 1573
1511 1574
1512 1575
1513 /** This is the benning of a rescale function 1576 /** This is the benning of a rescale function. It does nothing for the moment
1514 @param aWidth : new width 1577 @param aWidth : new width
1515 @param aHeight : new height 1578 @param aHeight : new height
1516 */ 1579 */
1517 void G4OpenGLQtViewer::rescaleImage( 1580 void G4OpenGLQtViewer::rescaleImage(
1518 int /* aWidth */ 1581 int /* aWidth */
1519 ,int /* aHeight */ 1582 ,int /* aHeight */
1520 ){ 1583 ){
1521 // GLfloat* feedback_buffer; 1584 // GLfloat* feedback_buffer;
1522 // GLint returned; 1585 // GLint returned;
1523 // FILE* file; 1586 // FILE* file;
1524 1587
1525 // feedback_buffer = new GLfloat[size]; 1588 // feedback_buffer = new GLfloat[size];
1526 // glFeedbackBuffer (size, GL_3D_COLOR, f 1589 // glFeedbackBuffer (size, GL_3D_COLOR, feedback_buffer);
1527 // glRenderMode (GL_FEEDBACK); 1590 // glRenderMode (GL_FEEDBACK);
1528 1591
1529 // DrawView(); 1592 // DrawView();
1530 // returned = glRenderMode (GL_RENDER); 1593 // returned = glRenderMode (GL_RENDER);
1531 1594
1532 } 1595 }
1533 1596
1534 1597
1535 1598
1536 1599
1537 void G4OpenGLQtViewer::G4wheelEvent (QWheelEv 1600 void G4OpenGLQtViewer::G4wheelEvent (QWheelEvent * evnt)
1538 { 1601 {
1539 #if (QT_VERSION < QT_VERSION_CHECK(5, 15, 0)) << 1602 #if QT_VERSION < 0x050F00
>> 1603 // Before Qt5.15
1540 fVP.SetZoomFactor(fVP.GetZoomFactor()+(fVP. 1604 fVP.SetZoomFactor(fVP.GetZoomFactor()+(fVP.GetZoomFactor()*(evnt->delta())/1200));
1541 #else 1605 #else
>> 1606 // Qt5.15 and beyond
1542 fVP.SetZoomFactor(fVP.GetZoomFactor()+(fVP. 1607 fVP.SetZoomFactor(fVP.GetZoomFactor()+(fVP.GetZoomFactor()*(evnt->angleDelta().y())/1200));
1543 #endif 1608 #endif
1544 updateQWidget(); 1609 updateQWidget();
1545 } 1610 }
1546 1611
1547 1612
1548 void G4OpenGLQtViewer::G4keyPressEvent (QKeyE 1613 void G4OpenGLQtViewer::G4keyPressEvent (QKeyEvent * evnt)
1549 { 1614 {
1550 if (fHoldKeyEvent) 1615 if (fHoldKeyEvent)
1551 return; 1616 return;
1552 1617
1553 fHoldKeyEvent = true; 1618 fHoldKeyEvent = true;
1554 1619
1555 1620
1556 // with no modifiers 1621 // with no modifiers
1557 updateKeyModifierState(evnt->modifiers()); 1622 updateKeyModifierState(evnt->modifiers());
1558 if ((fNoKeyPress) || (evnt->modifiers() == 1623 if ((fNoKeyPress) || (evnt->modifiers() == Qt::KeypadModifier )) {
1559 if (evnt->key() == Qt::Key_Down) { // go 1624 if (evnt->key() == Qt::Key_Down) { // go down
1560 moveScene(0,1,0,false); 1625 moveScene(0,1,0,false);
1561 } 1626 }
1562 else if (evnt->key() == Qt::Key_Up) { // 1627 else if (evnt->key() == Qt::Key_Up) { // go up
1563 moveScene(0,-1,0,false); 1628 moveScene(0,-1,0,false);
1564 } 1629 }
1565 if (evnt->key() == Qt::Key_Left) { // go 1630 if (evnt->key() == Qt::Key_Left) { // go left
1566 moveScene(-1,0,0,false); 1631 moveScene(-1,0,0,false);
1567 } 1632 }
1568 else if (evnt->key() == Qt::Key_Right) { 1633 else if (evnt->key() == Qt::Key_Right) { // go right
1569 moveScene(1,0,0,false); 1634 moveScene(1,0,0,false);
1570 } 1635 }
1571 if (evnt->key() == Qt::Key_Minus) { // go 1636 if (evnt->key() == Qt::Key_Minus) { // go backward
1572 moveScene(0,0,1,false); 1637 moveScene(0,0,1,false);
1573 } 1638 }
1574 else if (evnt->key() == Qt::Key_Plus) { / 1639 else if (evnt->key() == Qt::Key_Plus) { // go forward
1575 moveScene(0,0,-1,false); 1640 moveScene(0,0,-1,false);
1576 } 1641 }
1577 // escaped from full screen 1642 // escaped from full screen
1578 if (evnt->key() == Qt::Key_Escape) { 1643 if (evnt->key() == Qt::Key_Escape) {
1579 toggleFullScreen(false); 1644 toggleFullScreen(false);
1580 } 1645 }
1581 } 1646 }
1582 // several case here : If return is pressed 1647 // several case here : If return is pressed, in every case -> display the movie parameters dialog
1583 // If one parameter is wrong -> put it in r 1648 // If one parameter is wrong -> put it in red (only save filenam could be wrong..)
1584 // If encoder not found-> does nothing.Only 1649 // If encoder not found-> does nothing.Only display a message in status box
1585 // If all ok-> generate parameter file 1650 // If all ok-> generate parameter file
1586 // If ok -> put encoder button enabled 1651 // If ok -> put encoder button enabled
1587 1652
1588 if ((evnt->key() == Qt::Key_Return) || (evn 1653 if ((evnt->key() == Qt::Key_Return) || (evnt->key() == Qt::Key_Enter)){ // end of video
1589 stopVideo(); 1654 stopVideo();
1590 } 1655 }
1591 if (evnt->key() == Qt::Key_Space){ // start 1656 if (evnt->key() == Qt::Key_Space){ // start/pause of video
1592 startPauseVideo(); 1657 startPauseVideo();
1593 } 1658 }
1594 1659
1595 // H : Return Home view 1660 // H : Return Home view
1596 if (evnt->key() == Qt::Key_H){ // go Home 1661 if (evnt->key() == Qt::Key_H){ // go Home
1597 ResetView(); 1662 ResetView();
1598 1663
1599 updateQWidget(); 1664 updateQWidget();
1600 } 1665 }
1601 1666
1602 // Shift Modifier 1667 // Shift Modifier
1603 if (fShiftKeyPress) { 1668 if (fShiftKeyPress) {
1604 fGLWidget->setCursor(QCursor(Qt::SizeAllC 1669 fGLWidget->setCursor(QCursor(Qt::SizeAllCursor));
1605 1670
1606 if (evnt->key() == Qt::Key_Down) { // rot 1671 if (evnt->key() == Qt::Key_Down) { // rotate phi
1607 rotateQtScene(0,-fRot_sens); 1672 rotateQtScene(0,-fRot_sens);
1608 } 1673 }
1609 else if (evnt->key() == Qt::Key_Up) { // 1674 else if (evnt->key() == Qt::Key_Up) { // rotate phi
1610 rotateQtScene(0,fRot_sens); 1675 rotateQtScene(0,fRot_sens);
1611 } 1676 }
1612 if (evnt->key() == Qt::Key_Left) { // rot 1677 if (evnt->key() == Qt::Key_Left) { // rotate theta
1613 rotateQtScene(fRot_sens,0); 1678 rotateQtScene(fRot_sens,0);
1614 } 1679 }
1615 else if (evnt->key() == Qt::Key_Right) { 1680 else if (evnt->key() == Qt::Key_Right) { // rotate theta
1616 rotateQtScene(-fRot_sens,0); 1681 rotateQtScene(-fRot_sens,0);
1617 } 1682 }
1618 if (evnt->key() == Qt::Key_Plus) { // go 1683 if (evnt->key() == Qt::Key_Plus) { // go forward ("Plus" imply
1619 // "Shift" on Mac French keyboard 1684 // "Shift" on Mac French keyboard
1620 moveScene(0,0,-1,false); 1685 moveScene(0,0,-1,false);
1621 } 1686 }
1622 1687
1623 // Alt Modifier 1688 // Alt Modifier
1624 } 1689 }
1625 if ((fAltKeyPress)) { 1690 if ((fAltKeyPress)) {
1626 fGLWidget->setCursor(QCursor(Qt::ClosedHa 1691 fGLWidget->setCursor(QCursor(Qt::ClosedHandCursor));
1627 1692
1628 if (evnt->key() == Qt::Key_Down) { // rot 1693 if (evnt->key() == Qt::Key_Down) { // rotate phi
1629 rotateQtSceneToggle(0,-fRot_sens); 1694 rotateQtSceneToggle(0,-fRot_sens);
1630 } 1695 }
1631 else if (evnt->key() == Qt::Key_Up) { // 1696 else if (evnt->key() == Qt::Key_Up) { // rotate phi
1632 rotateQtSceneToggle(0,fRot_sens); 1697 rotateQtSceneToggle(0,fRot_sens);
1633 } 1698 }
1634 if (evnt->key() == Qt::Key_Left) { // rot 1699 if (evnt->key() == Qt::Key_Left) { // rotate theta
1635 rotateQtSceneToggle(fRot_sens,0); 1700 rotateQtSceneToggle(fRot_sens,0);
1636 } 1701 }
1637 else if (evnt->key() == Qt::Key_Right) { 1702 else if (evnt->key() == Qt::Key_Right) { // rotate theta
1638 rotateQtSceneToggle(-fRot_sens,0); 1703 rotateQtSceneToggle(-fRot_sens,0);
1639 } 1704 }
1640 1705
1641 // Rotatio +/- 1706 // Rotatio +/-
1642 if (evnt->key() == Qt::Key_Plus) { 1707 if (evnt->key() == Qt::Key_Plus) {
1643 fRot_sens = fRot_sens/0.7; 1708 fRot_sens = fRot_sens/0.7;
1644 G4cout << "Auto-rotation set to : " << 1709 G4cout << "Auto-rotation set to : " << fRot_sens << G4endl;
1645 } 1710 }
1646 else if (evnt->key() == Qt::Key_Minus) { 1711 else if (evnt->key() == Qt::Key_Minus) {
1647 fRot_sens = fRot_sens*0.7; 1712 fRot_sens = fRot_sens*0.7;
1648 G4cout << "Auto-rotation set to : " << 1713 G4cout << "Auto-rotation set to : " << fRot_sens << G4endl;
1649 } 1714 }
1650 1715
1651 // Control Modifier OR Command on MAC 1716 // Control Modifier OR Command on MAC
1652 } 1717 }
1653 if ((fControlKeyPress)) { 1718 if ((fControlKeyPress)) {
1654 if (evnt->key() == Qt::Key_Plus) { 1719 if (evnt->key() == Qt::Key_Plus) {
1655 fVP.SetZoomFactor(fVP.GetZoomFactor()*( 1720 fVP.SetZoomFactor(fVP.GetZoomFactor()*(1+fDeltaZoom));
1656 updateQWidget(); 1721 updateQWidget();
1657 } 1722 }
1658 else if (evnt->key() == Qt::Key_Minus) { 1723 else if (evnt->key() == Qt::Key_Minus) {
1659 fVP.SetZoomFactor(fVP.GetZoomFactor()*( 1724 fVP.SetZoomFactor(fVP.GetZoomFactor()*(1-fDeltaZoom));
1660 updateQWidget(); 1725 updateQWidget();
1661 } 1726 }
1662 } 1727 }
1663 1728
1664 fHoldKeyEvent = false; 1729 fHoldKeyEvent = false;
1665 } 1730 }
1666 1731
1667 1732
1668 void G4OpenGLQtViewer::G4keyReleaseEvent (QKe 1733 void G4OpenGLQtViewer::G4keyReleaseEvent (QKeyEvent *)
1669 { 1734 {
1670 fGLWidget->setCursor(QCursor(Qt::ArrowCurso 1735 fGLWidget->setCursor(QCursor(Qt::ArrowCursor));
1671 } 1736 }
1672 1737
1673 1738
1674 void G4OpenGLQtViewer::updateKeyModifierStat 1739 void G4OpenGLQtViewer::updateKeyModifierState(const Qt::KeyboardModifiers& modifier) {
1675 // Check Qt Versions for META Keys 1740 // Check Qt Versions for META Keys
1676 1741
1677 fNoKeyPress = true; 1742 fNoKeyPress = true;
1678 fAltKeyPress = false; 1743 fAltKeyPress = false;
1679 fShiftKeyPress = false; 1744 fShiftKeyPress = false;
1680 fControlKeyPress = false; 1745 fControlKeyPress = false;
1681 1746
1682 if (modifier & Qt::AltModifier ) { 1747 if (modifier & Qt::AltModifier ) {
1683 fAltKeyPress = true; 1748 fAltKeyPress = true;
1684 fNoKeyPress = false; 1749 fNoKeyPress = false;
1685 } 1750 }
1686 if (modifier & Qt::ShiftModifier ) { 1751 if (modifier & Qt::ShiftModifier ) {
1687 fShiftKeyPress = true; 1752 fShiftKeyPress = true;
1688 fNoKeyPress = false; 1753 fNoKeyPress = false;
1689 } 1754 }
1690 if (modifier & Qt::ControlModifier ) { 1755 if (modifier & Qt::ControlModifier ) {
1691 fControlKeyPress = true; 1756 fControlKeyPress = true;
1692 fNoKeyPress = false; 1757 fNoKeyPress = false;
1693 } 1758 }
1694 } 1759 }
1695 1760
1696 1761
1697 /** Stop the video. Check all parameters and 1762 /** Stop the video. Check all parameters and enable encoder button if all is ok.
1698 */ 1763 */
1699 void G4OpenGLQtViewer::stopVideo() { 1764 void G4OpenGLQtViewer::stopVideo() {
1700 1765
1701 // if encoder parameter is wrong, display p 1766 // if encoder parameter is wrong, display parameters dialog and return
1702 if (!fMovieParametersDialog) { 1767 if (!fMovieParametersDialog) {
1703 showMovieParametersDialog(); 1768 showMovieParametersDialog();
1704 } 1769 }
1705 setRecordingStatus(STOP); 1770 setRecordingStatus(STOP);
1706 1771
1707 if (fRecordFrameNumber >0) { 1772 if (fRecordFrameNumber >0) {
1708 // check parameters if they were modified 1773 // check parameters if they were modified (Re APPLY them...)
1709 if (!(fMovieParametersDialog->checkEncode 1774 if (!(fMovieParametersDialog->checkEncoderSwParameters())) {
1710 setRecordingStatus(BAD_ENCODER); 1775 setRecordingStatus(BAD_ENCODER);
1711 } else if (!(fMovieParametersDialog->che 1776 } else if (!(fMovieParametersDialog->checkSaveFileNameParameters())) {
1712 setRecordingStatus(BAD_OUTPUT); 1777 setRecordingStatus(BAD_OUTPUT);
1713 } 1778 }
1714 } else { 1779 } else {
1715 resetRecording(); 1780 resetRecording();
1716 setRecordingInfos("No frame to encode."); 1781 setRecordingInfos("No frame to encode.");
1717 } 1782 }
1718 } 1783 }
1719 1784
1720 /** Stop the video. Check all parameters and 1785 /** Stop the video. Check all parameters and enable encoder button if all is ok.
1721 */ 1786 */
1722 void G4OpenGLQtViewer::saveVideo() { 1787 void G4OpenGLQtViewer::saveVideo() {
1723 1788
1724 // if encoder parameter is wrong, display p 1789 // if encoder parameter is wrong, display parameters dialog and return
1725 if (!fMovieParametersDialog) { 1790 if (!fMovieParametersDialog) {
1726 showMovieParametersDialog(); 1791 showMovieParametersDialog();
1727 } 1792 }
1728 1793
1729 fMovieParametersDialog->checkEncoderSwParam 1794 fMovieParametersDialog->checkEncoderSwParameters();
1730 fMovieParametersDialog->checkSaveFileNamePa 1795 fMovieParametersDialog->checkSaveFileNameParameters();
1731 1796
1732 if (fRecordingStep == STOP) { 1797 if (fRecordingStep == STOP) {
1733 setRecordingStatus(SAVE); 1798 setRecordingStatus(SAVE);
1734 generateMpegEncoderParameters(); 1799 generateMpegEncoderParameters();
1735 encodeVideo(); 1800 encodeVideo();
1736 } 1801 }
1737 } 1802 }
1738 1803
1739 1804
1740 /** Start/Pause the video.. 1805 /** Start/Pause the video..
1741 */ 1806 */
1742 void G4OpenGLQtViewer::startPauseVideo() { 1807 void G4OpenGLQtViewer::startPauseVideo() {
1743 1808
1744 // first time, if temp parameter is wrong, 1809 // first time, if temp parameter is wrong, display parameters dialog and return
1745 1810
1746 if ( fRecordingStep == WAIT) { 1811 if ( fRecordingStep == WAIT) {
1747 if ( fRecordFrameNumber == 0) { 1812 if ( fRecordFrameNumber == 0) {
1748 if (getTempFolderPath() == "") { // BAD 1813 if (getTempFolderPath() == "") { // BAD_OUTPUT
1749 showMovieParametersDialog(); 1814 showMovieParametersDialog();
1750 setRecordingInfos("You should specifi 1815 setRecordingInfos("You should specified the temp folder in order to make movie");
1751 return; 1816 return;
1752 } else { 1817 } else {
1753 // remove temp folder if it was creat 1818 // remove temp folder if it was create
1754 QString tmp = removeTempFolder(); 1819 QString tmp = removeTempFolder();
1755 if (tmp !="") { 1820 if (tmp !="") {
1756 setRecordingInfos(tmp); 1821 setRecordingInfos(tmp);
1757 return; 1822 return;
1758 } 1823 }
1759 tmp = createTempFolder(); 1824 tmp = createTempFolder();
1760 if (tmp != "") { 1825 if (tmp != "") {
1761 setRecordingInfos("Can't create tem 1826 setRecordingInfos("Can't create temp folder."+tmp);
1762 return; 1827 return;
1763 } 1828 }
1764 } 1829 }
1765 } 1830 }
1766 } 1831 }
1767 if (fRecordingStep == WAIT) { 1832 if (fRecordingStep == WAIT) {
1768 setRecordingStatus(START); 1833 setRecordingStatus(START);
1769 } else if (fRecordingStep == START) { 1834 } else if (fRecordingStep == START) {
1770 setRecordingStatus(PAUSE); 1835 setRecordingStatus(PAUSE);
1771 } else if (fRecordingStep == PAUSE) { 1836 } else if (fRecordingStep == PAUSE) {
1772 setRecordingStatus(CONTINUE); 1837 setRecordingStatus(CONTINUE);
1773 } else if (fRecordingStep == CONTINUE) { 1838 } else if (fRecordingStep == CONTINUE) {
1774 setRecordingStatus(PAUSE); 1839 setRecordingStatus(PAUSE);
1775 } 1840 }
1776 } 1841 }
1777 1842
1778 void G4OpenGLQtViewer::setRecordingStatus(REC 1843 void G4OpenGLQtViewer::setRecordingStatus(RECORDING_STEP step) {
1779 1844
1780 fRecordingStep = step; 1845 fRecordingStep = step;
1781 displayRecordingStatus(); 1846 displayRecordingStatus();
1782 } 1847 }
1783 1848
1784 1849
1785 void G4OpenGLQtViewer::displayRecordingStatus 1850 void G4OpenGLQtViewer::displayRecordingStatus() {
1786 1851
1787 QString txtStatus = ""; 1852 QString txtStatus = "";
1788 if (fRecordingStep == WAIT) { 1853 if (fRecordingStep == WAIT) {
1789 txtStatus = "Waiting to start..."; 1854 txtStatus = "Waiting to start...";
1790 fRecordFrameNumber = 0; // reset the fram 1855 fRecordFrameNumber = 0; // reset the frame number
1791 } else if (fRecordingStep == START) { 1856 } else if (fRecordingStep == START) {
1792 txtStatus = "Start Recording..."; 1857 txtStatus = "Start Recording...";
1793 } else if (fRecordingStep == PAUSE) { 1858 } else if (fRecordingStep == PAUSE) {
1794 txtStatus = "Pause Recording..."; 1859 txtStatus = "Pause Recording...";
1795 } else if (fRecordingStep == CONTINUE) { 1860 } else if (fRecordingStep == CONTINUE) {
1796 txtStatus = "Continue Recording..."; 1861 txtStatus = "Continue Recording...";
1797 } else if (fRecordingStep == STOP) { 1862 } else if (fRecordingStep == STOP) {
1798 txtStatus = "Stop Recording..."; 1863 txtStatus = "Stop Recording...";
1799 } else if (fRecordingStep == READY_TO_ENCOD 1864 } else if (fRecordingStep == READY_TO_ENCODE) {
1800 txtStatus = "Ready to Encode..."; 1865 txtStatus = "Ready to Encode...";
1801 } else if (fRecordingStep == ENCODING) { 1866 } else if (fRecordingStep == ENCODING) {
1802 txtStatus = "Encoding..."; 1867 txtStatus = "Encoding...";
1803 } else if (fRecordingStep == FAILED) { 1868 } else if (fRecordingStep == FAILED) {
1804 txtStatus = "Failed to encode..."; 1869 txtStatus = "Failed to encode...";
1805 } else if ((fRecordingStep == BAD_ENCODER) 1870 } else if ((fRecordingStep == BAD_ENCODER)
1806 || (fRecordingStep == BAD_OUTPUT 1871 || (fRecordingStep == BAD_OUTPUT)
1807 || (fRecordingStep == BAD_TMP)) 1872 || (fRecordingStep == BAD_TMP)) {
1808 txtStatus = "Correct above errors first" 1873 txtStatus = "Correct above errors first";
1809 } else if (fRecordingStep == SUCCESS) { 1874 } else if (fRecordingStep == SUCCESS) {
1810 txtStatus = "File encoded successfully"; 1875 txtStatus = "File encoded successfully";
1811 } else { 1876 } else {
1812 } 1877 }
1813 1878
1814 if (fMovieParametersDialog) { 1879 if (fMovieParametersDialog) {
1815 fMovieParametersDialog->setRecordingStatu 1880 fMovieParametersDialog->setRecordingStatus(txtStatus);
1816 } else { 1881 } else {
1817 G4cout << txtStatus.toStdString().c_str() 1882 G4cout << txtStatus.toStdString().c_str() << G4endl;
1818 } 1883 }
1819 setRecordingInfos(""); 1884 setRecordingInfos("");
1820 } 1885 }
1821 1886
1822 1887
1823 void G4OpenGLQtViewer::setRecordingInfos(cons 1888 void G4OpenGLQtViewer::setRecordingInfos(const QString& txt) {
1824 if (fMovieParametersDialog) { 1889 if (fMovieParametersDialog) {
1825 fMovieParametersDialog->setRecordingInfos 1890 fMovieParametersDialog->setRecordingInfos(txt);
1826 } else { 1891 } else {
1827 G4cout << txt.toStdString().c_str() << G4 1892 G4cout << txt.toStdString().c_str() << G4endl;
1828 } 1893 }
1829 } 1894 }
1830 1895
1831 /** Init the movie parameters. Temp dir and e 1896 /** Init the movie parameters. Temp dir and encoder path
1832 */ 1897 */
1833 void G4OpenGLQtViewer::initMovieParameters() 1898 void G4OpenGLQtViewer::initMovieParameters() {
1834 //init encoder 1899 //init encoder
1835 1900
1836 //look for encoderPath 1901 //look for encoderPath
1837 fProcess = new QProcess(); 1902 fProcess = new QProcess();
1838 1903
1839 QObject ::connect(fProcess,SIGNAL(finished 1904 QObject ::connect(fProcess,SIGNAL(finished ( int)),
1840 this,SLOT(processLookForF 1905 this,SLOT(processLookForFinished()));
1841 fProcess->setProcessChannelMode(QProcess::M 1906 fProcess->setProcessChannelMode(QProcess::MergedChannels);
1842 #if (QT_VERSION < QT_VERSION_CHECK(5, 15, 0)) << 1907 #if QT_VERSION < 0x050F00
>> 1908 // Before Qt5.15
1843 fProcess->start ("which ppmtompeg"); 1909 fProcess->start ("which ppmtompeg");
1844 #else 1910 #else
>> 1911 // Qt5.15 and beyond
1845 fProcess->start ("which ppmtompeg", QString 1912 fProcess->start ("which ppmtompeg", QStringList());
1846 #endif 1913 #endif
1847 } 1914 }
1848 1915
1849 /** @return encoder path or "" if it does not 1916 /** @return encoder path or "" if it does not exist
1850 */ 1917 */
1851 QString G4OpenGLQtViewer::getEncoderPath() { 1918 QString G4OpenGLQtViewer::getEncoderPath() {
1852 return fEncoderPath; 1919 return fEncoderPath;
1853 } 1920 }
1854 1921
1855 1922
1856 /** 1923 /**
1857 * set the new encoder path 1924 * set the new encoder path
1858 * @return "" if correct. The error otherwise 1925 * @return "" if correct. The error otherwise
1859 */ 1926 */
1860 QString G4OpenGLQtViewer::setEncoderPath(QStr 1927 QString G4OpenGLQtViewer::setEncoderPath(QString path) {
1861 if (path == "") { 1928 if (path == "") {
1862 return "ppmtompeg is needed to encode in 1929 return "ppmtompeg is needed to encode in video format. It is available here: http://netpbm.sourceforge.net ";
1863 } 1930 }
1864 1931
1865 path = QDir::cleanPath(path); 1932 path = QDir::cleanPath(path);
1866 QFileInfo *f = new QFileInfo(path); 1933 QFileInfo *f = new QFileInfo(path);
1867 if (!f->exists()) { 1934 if (!f->exists()) {
1868 return "File does not exist"; 1935 return "File does not exist";
1869 } else if (f->isDir()) { 1936 } else if (f->isDir()) {
1870 return "This is a directory"; 1937 return "This is a directory";
1871 } else if (!f->isExecutable()) { 1938 } else if (!f->isExecutable()) {
1872 return "File exist but is not executable" 1939 return "File exist but is not executable";
1873 } else if (!f->isFile()) { 1940 } else if (!f->isFile()) {
1874 return "This is not a file"; 1941 return "This is not a file";
1875 } 1942 }
1876 fEncoderPath = path; 1943 fEncoderPath = path;
1877 1944
1878 if (fRecordingStep == BAD_ENCODER) { 1945 if (fRecordingStep == BAD_ENCODER) {
1879 setRecordingStatus(STOP); 1946 setRecordingStatus(STOP);
1880 } 1947 }
1881 return ""; 1948 return "";
1882 } 1949 }
1883 1950
1884 1951
1885 bool G4OpenGLQtViewer::isRecording(){ 1952 bool G4OpenGLQtViewer::isRecording(){
1886 if ((fRecordingStep == START) || (fRecordin 1953 if ((fRecordingStep == START) || (fRecordingStep == CONTINUE)) {
1887 return true; 1954 return true;
1888 } 1955 }
1889 return false; 1956 return false;
1890 } 1957 }
1891 1958
1892 bool G4OpenGLQtViewer::isPaused(){ 1959 bool G4OpenGLQtViewer::isPaused(){
1893 if (fRecordingStep == PAUSE) { 1960 if (fRecordingStep == PAUSE) {
1894 return true; 1961 return true;
1895 } 1962 }
1896 return false; 1963 return false;
1897 } 1964 }
1898 1965
1899 bool G4OpenGLQtViewer::isEncoding(){ 1966 bool G4OpenGLQtViewer::isEncoding(){
1900 if (fRecordingStep == ENCODING) { 1967 if (fRecordingStep == ENCODING) {
1901 return true; 1968 return true;
1902 } 1969 }
1903 return false; 1970 return false;
1904 } 1971 }
1905 1972
1906 bool G4OpenGLQtViewer::isWaiting(){ 1973 bool G4OpenGLQtViewer::isWaiting(){
1907 if (fRecordingStep == WAIT) { 1974 if (fRecordingStep == WAIT) {
1908 return true; 1975 return true;
1909 } 1976 }
1910 return false; 1977 return false;
1911 } 1978 }
1912 1979
1913 bool G4OpenGLQtViewer::isStopped(){ 1980 bool G4OpenGLQtViewer::isStopped(){
1914 if (fRecordingStep == STOP) { 1981 if (fRecordingStep == STOP) {
1915 return true; 1982 return true;
1916 } 1983 }
1917 return false; 1984 return false;
1918 } 1985 }
1919 1986
1920 bool G4OpenGLQtViewer::isFailed(){ 1987 bool G4OpenGLQtViewer::isFailed(){
1921 if (fRecordingStep == FAILED) { 1988 if (fRecordingStep == FAILED) {
1922 return true; 1989 return true;
1923 } 1990 }
1924 return false; 1991 return false;
1925 } 1992 }
1926 1993
1927 bool G4OpenGLQtViewer::isSuccess(){ 1994 bool G4OpenGLQtViewer::isSuccess(){
1928 if (fRecordingStep == SUCCESS) { 1995 if (fRecordingStep == SUCCESS) {
1929 return true; 1996 return true;
1930 } 1997 }
1931 return false; 1998 return false;
1932 } 1999 }
1933 2000
1934 bool G4OpenGLQtViewer::isBadEncoder(){ 2001 bool G4OpenGLQtViewer::isBadEncoder(){
1935 if (fRecordingStep == BAD_ENCODER) { 2002 if (fRecordingStep == BAD_ENCODER) {
1936 return true; 2003 return true;
1937 } 2004 }
1938 return false; 2005 return false;
1939 } 2006 }
1940 bool G4OpenGLQtViewer::isBadTmp(){ 2007 bool G4OpenGLQtViewer::isBadTmp(){
1941 if (fRecordingStep == BAD_TMP) { 2008 if (fRecordingStep == BAD_TMP) {
1942 return true; 2009 return true;
1943 } 2010 }
1944 return false; 2011 return false;
1945 } 2012 }
1946 bool G4OpenGLQtViewer::isBadOutput(){ 2013 bool G4OpenGLQtViewer::isBadOutput(){
1947 if (fRecordingStep == BAD_OUTPUT) { 2014 if (fRecordingStep == BAD_OUTPUT) {
1948 return true; 2015 return true;
1949 } 2016 }
1950 return false; 2017 return false;
1951 } 2018 }
1952 2019
1953 void G4OpenGLQtViewer::setBadEncoder(){ 2020 void G4OpenGLQtViewer::setBadEncoder(){
1954 fRecordingStep = BAD_ENCODER; 2021 fRecordingStep = BAD_ENCODER;
1955 displayRecordingStatus(); 2022 displayRecordingStatus();
1956 } 2023 }
1957 void G4OpenGLQtViewer::setBadTmp(){ 2024 void G4OpenGLQtViewer::setBadTmp(){
1958 fRecordingStep = BAD_TMP; 2025 fRecordingStep = BAD_TMP;
1959 displayRecordingStatus(); 2026 displayRecordingStatus();
1960 } 2027 }
1961 void G4OpenGLQtViewer::setBadOutput(){ 2028 void G4OpenGLQtViewer::setBadOutput(){
1962 fRecordingStep = BAD_OUTPUT; 2029 fRecordingStep = BAD_OUTPUT;
1963 displayRecordingStatus(); 2030 displayRecordingStatus();
1964 } 2031 }
1965 2032
1966 void G4OpenGLQtViewer::setWaiting(){ 2033 void G4OpenGLQtViewer::setWaiting(){
1967 fRecordingStep = WAIT; 2034 fRecordingStep = WAIT;
1968 displayRecordingStatus(); 2035 displayRecordingStatus();
1969 } 2036 }
1970 2037
1971 2038
1972 bool G4OpenGLQtViewer::isReadyToEncode(){ 2039 bool G4OpenGLQtViewer::isReadyToEncode(){
1973 if (fRecordingStep == READY_TO_ENCODE) { 2040 if (fRecordingStep == READY_TO_ENCODE) {
1974 return true; 2041 return true;
1975 } 2042 }
1976 return false; 2043 return false;
1977 } 2044 }
1978 2045
1979 void G4OpenGLQtViewer::resetRecording() { 2046 void G4OpenGLQtViewer::resetRecording() {
1980 setRecordingStatus(WAIT); 2047 setRecordingStatus(WAIT);
1981 } 2048 }
1982 2049
1983 /** 2050 /**
1984 * set the temp folder path 2051 * set the temp folder path
1985 * @return "" if correct. The error otherwise 2052 * @return "" if correct. The error otherwise
1986 */ 2053 */
1987 QString G4OpenGLQtViewer::setTempFolderPath(Q 2054 QString G4OpenGLQtViewer::setTempFolderPath(QString path) {
1988 2055
1989 if (path == "") { 2056 if (path == "") {
1990 return "Path does not exist"; 2057 return "Path does not exist";
1991 } 2058 }
1992 path = QDir::cleanPath(path); 2059 path = QDir::cleanPath(path);
1993 QFileInfo *d = new QFileInfo(path); 2060 QFileInfo *d = new QFileInfo(path);
1994 if (!d->exists()) { 2061 if (!d->exists()) {
1995 return "Path does not exist"; 2062 return "Path does not exist";
1996 } else if (!d->isDir()) { 2063 } else if (!d->isDir()) {
1997 return "This is not a directory"; 2064 return "This is not a directory";
1998 } else if (!d->isReadable()) { 2065 } else if (!d->isReadable()) {
1999 return path +" is read protected"; 2066 return path +" is read protected";
2000 } else if (!d->isWritable()) { 2067 } else if (!d->isWritable()) {
2001 return path +" is write protected"; 2068 return path +" is write protected";
2002 } 2069 }
2003 2070
2004 if (fRecordingStep == BAD_TMP) { 2071 if (fRecordingStep == BAD_TMP) {
2005 setRecordingStatus(WAIT); 2072 setRecordingStatus(WAIT);
2006 } 2073 }
2007 fTempFolderPath = path; 2074 fTempFolderPath = path;
2008 return ""; 2075 return "";
2009 } 2076 }
2010 2077
2011 /** @return the temp folder path or "" if it 2078 /** @return the temp folder path or "" if it does not exist
2012 */ 2079 */
2013 QString G4OpenGLQtViewer::getTempFolderPath() 2080 QString G4OpenGLQtViewer::getTempFolderPath() {
2014 return fTempFolderPath; 2081 return fTempFolderPath;
2015 } 2082 }
2016 2083
2017 /** 2084 /**
2018 * set the save file name path 2085 * set the save file name path
2019 * @return "" if correct. The error otherwise 2086 * @return "" if correct. The error otherwise
2020 */ 2087 */
2021 QString G4OpenGLQtViewer::setSaveFileName(QSt 2088 QString G4OpenGLQtViewer::setSaveFileName(QString path) {
2022 2089
2023 if (path == "") { 2090 if (path == "") {
2024 return "Path does not exist"; 2091 return "Path does not exist";
2025 } 2092 }
2026 2093
2027 QFileInfo *file = new QFileInfo(path); 2094 QFileInfo *file = new QFileInfo(path);
2028 QDir dir = file->dir(); 2095 QDir dir = file->dir();
2029 path = QDir::cleanPath(path); 2096 path = QDir::cleanPath(path);
2030 if (file->exists()) { 2097 if (file->exists()) {
2031 return "File already exist, please choose 2098 return "File already exist, please choose a new one";
2032 } else if (!dir.exists()) { 2099 } else if (!dir.exists()) {
2033 return "Dir does not exist"; 2100 return "Dir does not exist";
2034 } else if (!dir.isReadable()) { 2101 } else if (!dir.isReadable()) {
2035 return path +" is read protected"; 2102 return path +" is read protected";
2036 } 2103 }
2037 2104
2038 if (fRecordingStep == BAD_OUTPUT) { 2105 if (fRecordingStep == BAD_OUTPUT) {
2039 setRecordingStatus(STOP); 2106 setRecordingStatus(STOP);
2040 } 2107 }
2041 fSaveFileName = path; 2108 fSaveFileName = path;
2042 return ""; 2109 return "";
2043 } 2110 }
2044 2111
2045 /** @return the save file path 2112 /** @return the save file path
2046 */ 2113 */
2047 QString G4OpenGLQtViewer::getSaveFileName() { 2114 QString G4OpenGLQtViewer::getSaveFileName() {
2048 return fSaveFileName ; 2115 return fSaveFileName ;
2049 } 2116 }
2050 2117
2051 /** Create a Qt_temp folder in the temp folde 2118 /** Create a Qt_temp folder in the temp folder given
2052 * The temp folder will be like this /tmp/QtM 2119 * The temp folder will be like this /tmp/QtMovie_12-02-2008_12_12_58/
2053 * @return "" if success. Error message if no 2120 * @return "" if success. Error message if not.
2054 */ 2121 */
2055 QString G4OpenGLQtViewer::createTempFolder() 2122 QString G4OpenGLQtViewer::createTempFolder() {
2056 fMovieTempFolderPath = ""; 2123 fMovieTempFolderPath = "";
2057 //check 2124 //check
2058 QString tmp = setTempFolderPath(fTempFolder 2125 QString tmp = setTempFolderPath(fTempFolderPath);
2059 if (tmp != "") { 2126 if (tmp != "") {
2060 return tmp; 2127 return tmp;
2061 } 2128 }
2062 QString sep = QString(QDir::separator()); 2129 QString sep = QString(QDir::separator());
2063 QString path = sep+"QtMovie_"+QDateTime::cu 2130 QString path = sep+"QtMovie_"+QDateTime::currentDateTime ().toString("dd-MM-yyyy_hh-mm-ss")+sep;
2064 QDir *d = new QDir(QDir::cleanPath(fTempFol 2131 QDir *d = new QDir(QDir::cleanPath(fTempFolderPath));
2065 // check if it is already present 2132 // check if it is already present
2066 if (d->exists(path)) { 2133 if (d->exists(path)) {
2067 return "Folder "+path+" already exists.Pl 2134 return "Folder "+path+" already exists.Please remove it first";
2068 } 2135 }
2069 if (d->mkdir(fTempFolderPath+path)) { 2136 if (d->mkdir(fTempFolderPath+path)) {
2070 fMovieTempFolderPath = fTempFolderPath+pa 2137 fMovieTempFolderPath = fTempFolderPath+path;
2071 return ""; 2138 return "";
2072 } 2139 }
2073 return "Can't create "+fTempFolderPath+path 2140 return "Can't create "+fTempFolderPath+path;
2074 } 2141 }
2075 2142
2076 /** Remove the Qt_temp folder in the temp fol 2143 /** Remove the Qt_temp folder in the temp folder
2077 */ 2144 */
2078 QString G4OpenGLQtViewer::removeTempFolder() 2145 QString G4OpenGLQtViewer::removeTempFolder() {
2079 // remove files in Qt_temp folder 2146 // remove files in Qt_temp folder
2080 if (fMovieTempFolderPath == "") { 2147 if (fMovieTempFolderPath == "") {
2081 return ""; 2148 return "";
2082 } 2149 }
2083 QDir *d = new QDir(QDir::cleanPath(fMovieTe 2150 QDir *d = new QDir(QDir::cleanPath(fMovieTempFolderPath));
2084 if (!d->exists()) { 2151 if (!d->exists()) {
2085 return ""; // already remove 2152 return ""; // already remove
2086 } 2153 }
2087 2154
2088 d->setFilter( QDir::Files ); 2155 d->setFilter( QDir::Files );
2089 QStringList subDirList = d->entryList(); 2156 QStringList subDirList = d->entryList();
2090 int res = true; 2157 int res = true;
2091 QString error = ""; 2158 QString error = "";
2092 for (QStringList::ConstIterator it = subDir 2159 for (QStringList::ConstIterator it = subDirList.begin() ;(it != subDirList.end()) ; it++) {
2093 const QString currentFile = *it; 2160 const QString currentFile = *it;
2094 if (!d->remove(currentFile)) { 2161 if (!d->remove(currentFile)) {
2095 res = false; 2162 res = false;
2096 QString file = fMovieTempFolderPath+cur 2163 QString file = fMovieTempFolderPath+currentFile;
2097 error +="Removing file failed : "+file; 2164 error +="Removing file failed : "+file;
2098 } else { 2165 } else {
2099 } 2166 }
2100 } 2167 }
2101 if (res) { 2168 if (res) {
2102 if (d->rmdir(fMovieTempFolderPath)) { 2169 if (d->rmdir(fMovieTempFolderPath)) {
2103 fMovieTempFolderPath = ""; 2170 fMovieTempFolderPath = "";
2104 return ""; 2171 return "";
2105 } else { 2172 } else {
2106 return "Dir "+fMovieTempFolderPath+" sh 2173 return "Dir "+fMovieTempFolderPath+" should be empty, but could not remove it";
2107 } 2174 }
2108 2175
2109 } 2176 }
2110 return "Could not remove "+fMovieTempFolder 2177 return "Could not remove "+fMovieTempFolderPath+" because of the following errors :"+error;
2111 } 2178 }
2112 2179
2113 /** 2180 /**
2114 Export image. Try to get the format accordi 2181 Export image. Try to get the format according to the file extention.
2115 If not present, the last one choosen by /vi 2182 If not present, the last one choosen by /vis/ogl/set/exportFormat
2116 If not, will take the default format : eps 2183 If not, will take the default format : eps
2117 Best format actually available is pdf (vect 2184 Best format actually available is pdf (vectored and allow transparency)
2118 If name is not set, it will take the defaul 2185 If name is not set, it will take the default name value given by /vis/ogl/set/printFilename
2119 */ 2186 */
2120 bool G4OpenGLQtViewer::exportImage(std::strin 2187 bool G4OpenGLQtViewer::exportImage(std::string name, int width, int height) {
2121 2188
2122 auto* qGLW = dynamic_cast<G4QGLWidgetType*> << 2189 QGLWidget* qGLW = dynamic_cast<QGLWidget*> (fGLWidget) ;
2123 if (! qGLW) { 2190 if (! qGLW) {
2124 return false; 2191 return false;
2125 } 2192 }
2126 // If there is already an extention 2193 // If there is already an extention
2127 bool increaseFileNumber = true; 2194 bool increaseFileNumber = true;
2128 // if 2195 // if
2129 if (name.size() != name.substr(name.find_la 2196 if (name.size() != name.substr(name.find_last_of(".") + 1).size()) {
2130 increaseFileNumber = false; 2197 increaseFileNumber = false;
2131 } 2198 }
2132 if (! setExportFilename(name,increaseFileNu 2199 if (! setExportFilename(name,increaseFileNumber)) {
2133 return false; 2200 return false;
2134 } 2201 }
2135 if ((width !=-1) && (height != -1)) { 2202 if ((width !=-1) && (height != -1)) {
2136 setExportSize(width, height); 2203 setExportSize(width, height);
2137 } 2204 }
2138 // first, try to do it with generic functio 2205 // first, try to do it with generic function
2139 if (G4OpenGLViewer::exportImage(name, width 2206 if (G4OpenGLViewer::exportImage(name, width, height)) {
2140 return true; 2207 return true;
2141 2208
2142 // Then try Qt saving functions 2209 // Then try Qt saving functions
2143 } else { 2210 } else {
2144 QImage image; 2211 QImage image;
2145 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)) <<
2146 image = qGLW->grabFrameBuffer(); 2212 image = qGLW->grabFrameBuffer();
2147 #else <<
2148 image = qGLW->grabFramebuffer(); <<
2149 #endif <<
2150 2213
2151 bool res = image.save(QString(getRealPrin 2214 bool res = image.save(QString(getRealPrintFilename().c_str()),0,fLastExportSliderValue);
2152 2215
2153 if (!res) { 2216 if (!res) {
2154 G4cerr << "Error saving file... " << ge 2217 G4cerr << "Error saving file... " << getRealPrintFilename().c_str() << G4endl;
2155 return false; 2218 return false;
2156 } else { 2219 } else {
2157 G4cout << "File " << getRealPrintFilena 2220 G4cout << "File " << getRealPrintFilename().c_str() << " size: " << fGLWidget->width() << "x" << fGLWidget->height() << " has been saved " << G4endl;
2158 fExportFilenameIndex++; 2221 fExportFilenameIndex++;
2159 } 2222 }
2160 } 2223 }
2161 return true; 2224 return true;
2162 } 2225 }
2163 2226
2164 bool G4OpenGLQtViewer::generateMpegEncoderPar 2227 bool G4OpenGLQtViewer::generateMpegEncoderParameters () {
2165 2228
2166 // save the parameter file 2229 // save the parameter file
2167 FILE* fp; 2230 FILE* fp;
2168 fp = fopen (QString(fMovieTempFolderPath+fP 2231 fp = fopen (QString(fMovieTempFolderPath+fParameterFileName).toStdString().c_str(), "w");
2169 2232
2170 if (fp == NULL) { 2233 if (fp == NULL) {
2171 setRecordingInfos("Generation of paramete 2234 setRecordingInfos("Generation of parameter file failed");
2172 return false; 2235 return false;
2173 } 2236 }
2174 2237
2175 fprintf (fp,"# Pattern affects speed, quali 2238 fprintf (fp,"# Pattern affects speed, quality and compression. See the User's Guide\n");
2176 fprintf (fp,"# for more info.\n"); 2239 fprintf (fp,"# for more info.\n");
2177 fprintf (fp,"\n"); 2240 fprintf (fp,"\n");
2178 fprintf (fp,"PATTERN I\n"); 2241 fprintf (fp,"PATTERN I\n");
2179 fprintf (fp,"OUTPUT %s\n",getSaveFileName 2242 fprintf (fp,"OUTPUT %s\n",getSaveFileName().toStdString().c_str());
2180 fprintf (fp,"\n"); 2243 fprintf (fp,"\n");
2181 fprintf (fp,"# You must specify the type of 2244 fprintf (fp,"# You must specify the type of the input files. The choices are:\n");
2182 fprintf (fp,"# YUV, PPM, JMOVIE, Y, JPEG 2245 fprintf (fp,"# YUV, PPM, JMOVIE, Y, JPEG, PNM\n");
2183 fprintf (fp,"# (must be upper case)\n"); 2246 fprintf (fp,"# (must be upper case)\n");
2184 fprintf (fp,"#\n"); 2247 fprintf (fp,"#\n");
2185 fprintf (fp,"BASE_FILE_FORMAT PPM\n"); 2248 fprintf (fp,"BASE_FILE_FORMAT PPM\n");
2186 fprintf (fp,"\n"); 2249 fprintf (fp,"\n");
2187 fprintf (fp,"\n"); 2250 fprintf (fp,"\n");
2188 fprintf (fp,"# If you are using YUV, there 2251 fprintf (fp,"# If you are using YUV, there are different supported file formats.\n");
2189 fprintf (fp,"# EYUV or UCB are the same as 2252 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 2253 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 Abeka 2254 fprintf (fp,"# Other formats, such as Abekas, Phillips, or a general format are\n");
2192 fprintf (fp,"# permissible, the general for 2255 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 2256 fprintf (fp,"# to specify the file order.\n");
2194 fprintf (fp,"\n"); 2257 fprintf (fp,"\n");
2195 fprintf (fp,"INPUT_FORMAT UCB\n"); 2258 fprintf (fp,"INPUT_FORMAT UCB\n");
2196 fprintf (fp,"\n"); 2259 fprintf (fp,"\n");
2197 fprintf (fp,"# the conversion statement\n") 2260 fprintf (fp,"# the conversion statement\n");
2198 fprintf (fp,"#\n"); 2261 fprintf (fp,"#\n");
2199 fprintf (fp,"# Each occurrence of '*' will 2262 fprintf (fp,"# Each occurrence of '*' will be replaced by the input file\n");
2200 fprintf (fp,"#\n"); 2263 fprintf (fp,"#\n");
2201 fprintf (fp,"# e.g., if you have a bunch of 2264 fprintf (fp,"# e.g., if you have a bunch of GIF files, then this might be:\n");
2202 fprintf (fp,"# INPUT_CONVERT giftoppm *\n" 2265 fprintf (fp,"# INPUT_CONVERT giftoppm *\n");
2203 fprintf (fp,"#\n"); 2266 fprintf (fp,"#\n");
2204 fprintf (fp,"# e.g., if you have a bunch of 2267 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 * 2268 fprintf (fp,"# INPUT_CONVERT cat *.Y *.U *.V\n");
2206 fprintf (fp,"#\n"); 2269 fprintf (fp,"#\n");
2207 fprintf (fp,"# e.g., if you are grabbing fr 2270 fprintf (fp,"# e.g., if you are grabbing from laser disc you might have something like\n");
2208 fprintf (fp,"# INPUT_CONVERT goto frame *; 2271 fprintf (fp,"# INPUT_CONVERT goto frame *; grabppm\n");
2209 fprintf (fp,"# 'INPUT_CONVERT *' means the 2272 fprintf (fp,"# 'INPUT_CONVERT *' means the files are already in the base file format\n");
2210 fprintf (fp,"#\n"); 2273 fprintf (fp,"#\n");
2211 fprintf (fp,"INPUT_CONVERT * \n"); 2274 fprintf (fp,"INPUT_CONVERT * \n");
2212 fprintf (fp,"\n"); 2275 fprintf (fp,"\n");
2213 fprintf (fp,"# number of frames in a GOP.\n 2276 fprintf (fp,"# number of frames in a GOP.\n");
2214 fprintf (fp,"#\n"); 2277 fprintf (fp,"#\n");
2215 fprintf (fp,"# since each GOP must have at 2278 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_ 2279 fprintf (fp,"# the first I-frame after GOP_SIZE frames to start the next GOP\n");
2217 fprintf (fp,"#\n"); 2280 fprintf (fp,"#\n");
2218 fprintf (fp,"# later, will add more flexibl 2281 fprintf (fp,"# later, will add more flexible GOP signalling\n");
2219 fprintf (fp,"#\n"); 2282 fprintf (fp,"#\n");
2220 fprintf (fp,"GOP_SIZE 1\n"); 2283 fprintf (fp,"GOP_SIZE 1\n");
2221 fprintf (fp,"\n"); 2284 fprintf (fp,"\n");
2222 fprintf (fp,"# number of slices in a frame\ 2285 fprintf (fp,"# number of slices in a frame\n");
2223 fprintf (fp,"#\n"); 2286 fprintf (fp,"#\n");
2224 fprintf (fp,"# 1 is a good number. another 2287 fprintf (fp,"# 1 is a good number. another possibility is the number of macroblock rows\n");
2225 fprintf (fp,"# (which is the height divided 2288 fprintf (fp,"# (which is the height divided by 16)\n");
2226 fprintf (fp,"#\n"); 2289 fprintf (fp,"#\n");
2227 fprintf (fp,"SLICES_PER_FRAME 1\n"); 2290 fprintf (fp,"SLICES_PER_FRAME 1\n");
2228 fprintf (fp,"PIXEL HALF"); 2291 fprintf (fp,"PIXEL HALF");
2229 fprintf (fp,"\n"); 2292 fprintf (fp,"\n");
2230 fprintf (fp,"# directory to get all input f 2293 fprintf (fp,"# directory to get all input files from (makes this file easier to read)\n");
2231 fprintf (fp,"INPUT_DIR %s\n",fMovieTempFol 2294 fprintf (fp,"INPUT_DIR %s\n",fMovieTempFolderPath.toStdString().c_str());
2232 fprintf (fp,"\n"); 2295 fprintf (fp,"\n");
2233 fprintf (fp,"# There are a bunch of ways to 2296 fprintf (fp,"# There are a bunch of ways to specify the input files.\n");
2234 fprintf (fp,"# from a simple one-per-line l 2297 fprintf (fp,"# from a simple one-per-line listing, to the following \n");
2235 fprintf (fp,"# way of numbering them. See 2298 fprintf (fp,"# way of numbering them. See the manual for more information.\n");
2236 fprintf (fp,"INPUT\n"); 2299 fprintf (fp,"INPUT\n");
2237 fprintf (fp,"# '*' is replaced by the numbe 2300 fprintf (fp,"# '*' is replaced by the numbers 01, 02, 03, 04\n");
2238 fprintf (fp,"# if I instead do [01-11], it 2301 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 w 2302 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 2303 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 2304 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"); 2305 fprintf (fp,"# if you do, too bad!!!\n");
2243 fprintf (fp,"#\n"); 2306 fprintf (fp,"#\n");
2244 fprintf (fp,"#\n"); 2307 fprintf (fp,"#\n");
2245 fprintf (fp,"Test*.ppm [0-%d]\n",fRecordFr 2308 fprintf (fp,"Test*.ppm [0-%d]\n",fRecordFrameNumber-1);
2246 fprintf (fp,"# can have more files here if 2309 fprintf (fp,"# can have more files here if you want...there is no limit on the number\n");
2247 fprintf (fp,"# of files\n"); 2310 fprintf (fp,"# of files\n");
2248 fprintf (fp,"END_INPUT\n"); 2311 fprintf (fp,"END_INPUT\n");
2249 fprintf (fp,"\n"); 2312 fprintf (fp,"\n");
2250 fprintf (fp,"\n"); 2313 fprintf (fp,"\n");
2251 fprintf (fp,"\n"); 2314 fprintf (fp,"\n");
2252 fprintf (fp,"# Many of the remaining option 2315 fprintf (fp,"# Many of the remaining options have to do with the motion search and qscale\n");
2253 fprintf (fp,"\n"); 2316 fprintf (fp,"\n");
2254 fprintf (fp,"# FULL or HALF -- must be uppe 2317 fprintf (fp,"# FULL or HALF -- must be upper case\n");
2255 fprintf (fp,"# Should be FULL for computer 2318 fprintf (fp,"# Should be FULL for computer generated images\n");
2256 fprintf (fp,"PIXEL FULL\n"); 2319 fprintf (fp,"PIXEL FULL\n");
2257 fprintf (fp,"\n"); 2320 fprintf (fp,"\n");
2258 fprintf (fp,"# means +/- this many pixels f 2321 fprintf (fp,"# means +/- this many pixels for both P and B frame searches\n");
2259 fprintf (fp,"# specify two numbers if you w 2322 fprintf (fp,"# specify two numbers if you wish to serc different ranges in the two.\n");
2260 fprintf (fp,"RANGE 10\n"); 2323 fprintf (fp,"RANGE 10\n");
2261 fprintf (fp,"\n"); 2324 fprintf (fp,"\n");
2262 fprintf (fp,"# The two search algorithm par 2325 fprintf (fp,"# The two search algorithm parameters below mostly affect speed,\n");
2263 fprintf (fp,"# with some affect on compress 2326 fprintf (fp,"# with some affect on compression and almost none on quality.\n");
2264 fprintf (fp,"\n"); 2327 fprintf (fp,"\n");
2265 fprintf (fp,"# this must be one of {EXHAUST 2328 fprintf (fp,"# this must be one of {EXHAUSTIVE, SUBSAMPLE, LOGARITHMIC}\n");
2266 fprintf (fp,"PSEARCH_ALG LOGARITHMIC\n"); 2329 fprintf (fp,"PSEARCH_ALG LOGARITHMIC\n");
2267 fprintf (fp,"\n"); 2330 fprintf (fp,"\n");
2268 fprintf (fp,"# this must be one of {SIMPLE, 2331 fprintf (fp,"# this must be one of {SIMPLE, CROSS2, EXHAUSTIVE}\n");
2269 fprintf (fp,"#\n"); 2332 fprintf (fp,"#\n");
2270 fprintf (fp,"# note that EXHAUSTIVE is real 2333 fprintf (fp,"# note that EXHAUSTIVE is really, really, really slow\n");
2271 fprintf (fp,"#\n"); 2334 fprintf (fp,"#\n");
2272 fprintf (fp,"BSEARCH_ALG SIMPLE\n"); 2335 fprintf (fp,"BSEARCH_ALG SIMPLE\n");
2273 fprintf (fp,"\n"); 2336 fprintf (fp,"\n");
2274 fprintf (fp,"#\n"); 2337 fprintf (fp,"#\n");
2275 fprintf (fp,"# these specify the q-scale fo 2338 fprintf (fp,"# these specify the q-scale for I, P, and B frames\n");
2276 fprintf (fp,"# (values must be between 1 an 2339 fprintf (fp,"# (values must be between 1 and 31)\n");
2277 fprintf (fp,"# These are the Qscale values 2340 fprintf (fp,"# These are the Qscale values for the entire frame in variable bit-rate\n");
2278 fprintf (fp,"# mode, and starting points (b 2341 fprintf (fp,"# mode, and starting points (but not important) for constant bit rate\n");
2279 fprintf (fp,"#\n"); 2342 fprintf (fp,"#\n");
2280 fprintf (fp,"\n"); 2343 fprintf (fp,"\n");
2281 fprintf (fp,"# Qscale (Quantization scale) 2344 fprintf (fp,"# Qscale (Quantization scale) affects quality and compression,\n");
2282 fprintf (fp,"# but has very little effect o 2345 fprintf (fp,"# but has very little effect on speed.\n");
2283 fprintf (fp,"\n"); 2346 fprintf (fp,"\n");
2284 fprintf (fp,"IQSCALE 4\n"); 2347 fprintf (fp,"IQSCALE 4\n");
2285 fprintf (fp,"PQSCALE 5\n"); 2348 fprintf (fp,"PQSCALE 5\n");
2286 fprintf (fp,"BQSCALE 12\n"); 2349 fprintf (fp,"BQSCALE 12\n");
2287 fprintf (fp,"\n"); 2350 fprintf (fp,"\n");
2288 fprintf (fp,"# this must be ORIGINAL or DEC 2351 fprintf (fp,"# this must be ORIGINAL or DECODED\n");
2289 fprintf (fp,"REFERENCE_FRAME ORIGINAL\n"); 2352 fprintf (fp,"REFERENCE_FRAME ORIGINAL\n");
2290 fprintf (fp,"\n"); 2353 fprintf (fp,"\n");
2291 fprintf (fp,"# for parallel parameters see 2354 fprintf (fp,"# for parallel parameters see parallel.param in the examples subdirectory\n");
2292 fprintf (fp,"\n"); 2355 fprintf (fp,"\n");
2293 fprintf (fp,"# if you want constant bit-rat 2356 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"); 2357 fprintf (fp,"#BIT_RATE 1000000\n");
2295 fprintf (fp,"\n"); 2358 fprintf (fp,"\n");
2296 fprintf (fp,"# To specify the buffer size ( 2359 fprintf (fp,"# To specify the buffer size (327680 is default, measused in bits, for 16bit words)\n");
2297 fprintf (fp,"BUFFER_SIZE 327680\n"); 2360 fprintf (fp,"BUFFER_SIZE 327680\n");
2298 fprintf (fp,"\n"); 2361 fprintf (fp,"\n");
2299 fprintf (fp,"# The frame rate is the number 2362 fprintf (fp,"# The frame rate is the number of frames/second (legal values:\n");
2300 fprintf (fp,"# 23.976, 24, 25, 29.97, 30, 5 2363 fprintf (fp,"# 23.976, 24, 25, 29.97, 30, 50 ,59.94, 60\n");
2301 fprintf (fp,"FRAME_RATE 30\n"); 2364 fprintf (fp,"FRAME_RATE 30\n");
2302 fprintf (fp,"\n"); 2365 fprintf (fp,"\n");
2303 fprintf (fp,"# There are many more options, 2366 fprintf (fp,"# There are many more options, see the users manual for examples....\n");
2304 fprintf (fp,"# ASPECT_RATIO, USER_DATA, GAM 2367 fprintf (fp,"# ASPECT_RATIO, USER_DATA, GAMMA, IQTABLE, etc.\n");
2305 fprintf (fp,"\n"); 2368 fprintf (fp,"\n");
2306 fprintf (fp,"\n"); 2369 fprintf (fp,"\n");
2307 fclose (fp); 2370 fclose (fp);
2308 2371
2309 setRecordingInfos("Parameter file "+fParame 2372 setRecordingInfos("Parameter file "+fParameterFileName+" generated in "+fMovieTempFolderPath);
2310 setRecordingStatus(READY_TO_ENCODE); 2373 setRecordingStatus(READY_TO_ENCODE);
2311 return true; 2374 return true;
2312 } 2375 }
2313 2376
2314 void G4OpenGLQtViewer::encodeVideo() 2377 void G4OpenGLQtViewer::encodeVideo()
2315 { 2378 {
2316 if ((getEncoderPath() != "") && (getSaveFil 2379 if ((getEncoderPath() != "") && (getSaveFileName() != "")) {
2317 setRecordingStatus(ENCODING); 2380 setRecordingStatus(ENCODING);
2318 2381
2319 fProcess = new QProcess(); 2382 fProcess = new QProcess();
>> 2383 #if QT_VERSION > 0x040100
2320 QObject ::connect(fProcess,SIGNAL(finishe 2384 QObject ::connect(fProcess,SIGNAL(finished ( int,QProcess::ExitStatus)),
2321 this,SLOT(processEncode 2385 this,SLOT(processEncodeFinished()));
2322 QObject ::connect(fProcess,SIGNAL(readyRe 2386 QObject ::connect(fProcess,SIGNAL(readyReadStandardOutput ()),
2323 this,SLOT(processEncode 2387 this,SLOT(processEncodeStdout()));
2324 #if (QT_VERSION < QT_VERSION_CHECK(5, 10, 0)) << 2388 #else
>> 2389 QObject ::connect(fProcess,SIGNAL(finished ( int)),
>> 2390 this,SLOT(processEncodeFinished()));
>> 2391 QObject ::connect(fProcess,SIGNAL(readyReadStandardOutput ()),
>> 2392 this,SLOT(processEncodeStdout()));
>> 2393 #endif
>> 2394 #if QT_VERSION < 0x050a00
2325 fProcess->setReadChannelMode(QProcess::Me 2395 fProcess->setReadChannelMode(QProcess::MergedChannels);
2326 #else 2396 #else
2327 fProcess->setProcessChannelMode(QProcess: 2397 fProcess->setProcessChannelMode(QProcess::MergedChannels);
2328 #endif 2398 #endif
2329 fProcess->start (fEncoderPath, QStringLis 2399 fProcess->start (fEncoderPath, QStringList(fMovieTempFolderPath+fParameterFileName));
2330 } 2400 }
2331 } 2401 }
2332 2402
2333 2403
2334 // FIXME : does not work on Qt3 2404 // FIXME : does not work on Qt3
2335 void G4OpenGLQtViewer::processEncodeStdout() 2405 void G4OpenGLQtViewer::processEncodeStdout()
2336 { 2406 {
2337 QString tmp = fProcess->readAllStandardOutp 2407 QString tmp = fProcess->readAllStandardOutput ().data();
2338 auto start = tmp.lastIndexOf("ESTIMATED TIM << 2408 int start = tmp.lastIndexOf("ESTIMATED TIME");
2339 tmp = tmp.mid(start,tmp.indexOf("\n",start) 2409 tmp = tmp.mid(start,tmp.indexOf("\n",start)-start);
2340 setRecordingInfos(tmp); 2410 setRecordingInfos(tmp);
2341 } 2411 }
2342 2412
2343 2413
2344 void G4OpenGLQtViewer::processEncodeFinished( 2414 void G4OpenGLQtViewer::processEncodeFinished()
2345 { 2415 {
2346 2416
2347 QString txt = ""; 2417 QString txt = "";
2348 txt = getProcessErrorMsg(); 2418 txt = getProcessErrorMsg();
2349 if (txt == "") { 2419 if (txt == "") {
2350 setRecordingStatus(SUCCESS); 2420 setRecordingStatus(SUCCESS);
2351 } else { 2421 } else {
2352 setRecordingStatus(FAILED); 2422 setRecordingStatus(FAILED);
2353 } 2423 }
2354 // setRecordingInfos(txt+removeTempFolder( 2424 // setRecordingInfos(txt+removeTempFolder());
2355 } 2425 }
2356 2426
2357 2427
2358 void G4OpenGLQtViewer::processLookForFinished 2428 void G4OpenGLQtViewer::processLookForFinished()
2359 { 2429 {
2360 2430
2361 QString txt = getProcessErrorMsg(); 2431 QString txt = getProcessErrorMsg();
2362 if (txt != "") { 2432 if (txt != "") {
2363 fEncoderPath = ""; 2433 fEncoderPath = "";
2364 } else { 2434 } else {
2365 fEncoderPath = QString(fProcess->readAllS 2435 fEncoderPath = QString(fProcess->readAllStandardOutput ().data()).trimmed();
2366 // if not found, return "not found" 2436 // if not found, return "not found"
2367 if (fEncoderPath.contains(" ")) { 2437 if (fEncoderPath.contains(" ")) {
2368 fEncoderPath = ""; 2438 fEncoderPath = "";
2369 } else if (!fEncoderPath.contains("ppmtom 2439 } else if (!fEncoderPath.contains("ppmtompeg")) {
2370 fEncoderPath = ""; 2440 fEncoderPath = "";
2371 } 2441 }
2372 setEncoderPath(fEncoderPath); 2442 setEncoderPath(fEncoderPath);
2373 } 2443 }
2374 // init temp folder 2444 // init temp folder
2375 setTempFolderPath(QDir::temp ().absolutePat 2445 setTempFolderPath(QDir::temp ().absolutePath ());
2376 } 2446 }
2377 2447
2378 2448
2379 QString G4OpenGLQtViewer::getProcessErrorMsg( 2449 QString G4OpenGLQtViewer::getProcessErrorMsg()
2380 { 2450 {
2381 QString txt = ""; 2451 QString txt = "";
2382 if (fProcess->exitCode() != 0) { 2452 if (fProcess->exitCode() != 0) {
2383 switch (fProcess->error()) { 2453 switch (fProcess->error()) {
2384 case QProcess::FailedToStart: 2454 case QProcess::FailedToStart:
2385 txt = "The process failed to start. Eit 2455 txt = "The process failed to start. Either the invoked program is missing, or you may have insufficient permissions to invoke the program.\n";
2386 break; 2456 break;
2387 case QProcess::Crashed: 2457 case QProcess::Crashed:
2388 txt = "The process crashed some time af 2458 txt = "The process crashed some time after starting successfully.\n";
2389 break; 2459 break;
2390 case QProcess::Timedout: 2460 case QProcess::Timedout:
2391 txt = "The last waitFor...() function t 2461 txt = "The last waitFor...() function timed out. The state of QProcess is unchanged, and you can try calling waitFor...() again.\n";
2392 break; 2462 break;
2393 case QProcess::WriteError: 2463 case QProcess::WriteError:
2394 txt = "An error occurred when attemptin 2464 txt = "An error occurred when attempting to write to the process. For example, the process may not be running, or it may have closed its input channel.\n";
2395 break; 2465 break;
2396 case QProcess::ReadError: 2466 case QProcess::ReadError:
2397 txt = "An error occurred when attemptin 2467 txt = "An error occurred when attempting to read from the process. For example, the process may not be running.\n";
2398 break; 2468 break;
2399 case QProcess::UnknownError: 2469 case QProcess::UnknownError:
2400 txt = "An unknown error occurred. This 2470 txt = "An unknown error occurred. This is the default return value of error().\n";
2401 break; 2471 break;
2402 } 2472 }
2403 } 2473 }
2404 return txt; 2474 return txt;
2405 } 2475 }
2406 2476
2407 2477
2408 2478
2409 2479
2410 QWidget *G4OpenGLQtViewer::getParentWidget() 2480 QWidget *G4OpenGLQtViewer::getParentWidget()
2411 { 2481 {
2412 // launch Qt if not 2482 // launch Qt if not
2413 G4Qt* interactorManager = G4Qt::getInstance 2483 G4Qt* interactorManager = G4Qt::getInstance ();
>> 2484 // G4UImanager* UI =
>> 2485 // G4UImanager::GetUIpointer();
2414 2486
2415 bool found = false; 2487 bool found = false;
2416 QDialog* dialog = NULL; 2488 QDialog* dialog = NULL;
2417 // create window 2489 // create window
2418 if (((QApplication*)interactorManager->GetM 2490 if (((QApplication*)interactorManager->GetMainInteractor())) {
2419 // look for the main window 2491 // look for the main window
2420 QWidgetList wl = QApplication::allWidgets 2492 QWidgetList wl = QApplication::allWidgets();
2421 QWidget *widget = NULL; 2493 QWidget *widget = NULL;
2422 for (int i=0; i < wl.size(); i++) { 2494 for (int i=0; i < wl.size(); i++) {
2423 widget = wl.at(i); 2495 widget = wl.at(i);
2424 if ((found== false) && (widget->inherit 2496 if ((found== false) && (widget->inherits("QMainWindow"))) {
2425 dialog = new QDialog(widget,Qt::Windo 2497 dialog = new QDialog(widget,Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowMinMaxButtonsHint);
2426 found = true; 2498 found = true;
2427 } 2499 }
2428 } 2500 }
2429 2501
2430 if (found==false) { 2502 if (found==false) {
2431 dialog = new QDialog(); 2503 dialog = new QDialog();
2432 } 2504 }
2433 } else { 2505 } else {
2434 dialog= new QDialog(); 2506 dialog= new QDialog();
2435 } 2507 }
2436 if (found) { 2508 if (found) {
2437 return dialog; 2509 return dialog;
2438 } else { 2510 } else {
2439 return NULL; 2511 return NULL;
2440 } 2512 }
2441 } 2513 }
2442 2514
2443 2515
2444 void G4OpenGLQtViewer::createSceneTreeWidget( 2516 void G4OpenGLQtViewer::createSceneTreeWidget() {
2445 fUISceneTreeWidget = fUiQt->GetSceneTreeWid 2517 fUISceneTreeWidget = fUiQt->GetSceneTreeWidget();
2446 2518
2447 if (!fUISceneTreeWidget) { 2519 if (!fUISceneTreeWidget) {
2448 return; 2520 return;
2449 } 2521 }
2450 2522
2451 // do not remove previous widgets, hide the 2523 // do not remove previous widgets, hide them!
2452 QLayoutItem * wItem; 2524 QLayoutItem * wItem;
2453 bool found = false; 2525 bool found = false;
2454 if (fUISceneTreeWidget->layout()->count() ) 2526 if (fUISceneTreeWidget->layout()->count() ) {
2455 for(int idx = 0; idx < fUISceneTreeWidget 2527 for(int idx = 0; idx < fUISceneTreeWidget->layout()->count(); idx++){
2456 wItem = fUISceneTreeWidget->layout()->i 2528 wItem = fUISceneTreeWidget->layout()->itemAt(idx);
2457 if (fSceneTreeWidget) { 2529 if (fSceneTreeWidget) {
2458 if(dynamic_cast<QWidget *>(wItem->wid 2530 if(dynamic_cast<QWidget *>(wItem->widget())) {
2459 if (wItem->widget()->windowTitle() 2531 if (wItem->widget()->windowTitle() == fSceneTreeWidget->windowTitle()) {
2460 wItem->widget()->show(); 2532 wItem->widget()->show();
2461 found = true; 2533 found = true;
2462 } else { 2534 } else {
2463 wItem->widget()->hide(); 2535 wItem->widget()->hide();
2464 } 2536 }
2465 } 2537 }
2466 } else { 2538 } else {
2467 // wItem->widget()->hide(); << 2539 wItem->widget()->hide();
2468 } 2540 }
2469 } 2541 }
2470 } 2542 }
2471 2543
2472 if (!found) { 2544 if (!found) {
2473 // initialize scene tree / viewer propert 2545 // initialize scene tree / viewer properties / picking
2474 fSceneTreeWidget = new QWidget(); 2546 fSceneTreeWidget = new QWidget();
2475 QVBoxLayout* layoutSceneTree = new QVBoxL 2547 QVBoxLayout* layoutSceneTree = new QVBoxLayout();
2476 fSceneTreeWidget->setStyleSheet ("padding 2548 fSceneTreeWidget->setStyleSheet ("padding: 0px ");
2477 2549
2478 fSceneTreeWidget->setLayout(layoutSceneTr 2550 fSceneTreeWidget->setLayout(layoutSceneTree);
2479 fSceneTreeWidget->layout()->setContentsMa 2551 fSceneTreeWidget->layout()->setContentsMargins(5,5,5,5);
2480 fSceneTreeWidget->setWindowTitle(QString( 2552 fSceneTreeWidget->setWindowTitle(QString(GetName().data()));
2481 2553
2482 if (fUISceneTreeWidget != NULL) { 2554 if (fUISceneTreeWidget != NULL) {
2483 // fUISceneTreeWidget->layout()->addWidg << 2555 fUISceneTreeWidget->layout()->addWidget(fSceneTreeWidget);
2484 } 2556 }
2485 2557
2486 // not available for Immediate mode 2558 // not available for Immediate mode
2487 if (dynamic_cast<G4OpenGLStoredQtViewer*> 2559 if (dynamic_cast<G4OpenGLStoredQtViewer*> (this)) {
2488 createSceneTreeComponent(); 2560 createSceneTreeComponent();
2489 } 2561 }
2490 } 2562 }
2491 } 2563 }
2492 2564
2493 2565
2494 void G4OpenGLQtViewer::createSceneTreeCompone 2566 void G4OpenGLQtViewer::createSceneTreeComponent(){
2495 2567
2496 QLayout* vLayout = fSceneTreeWidget->layout 2568 QLayout* vLayout = fSceneTreeWidget->layout();
2497 2569
2498 // Search line 2570 // Search line
2499 QWidget* coutButtonWidget = new QWidget(); 2571 QWidget* coutButtonWidget = new QWidget();
2500 QHBoxLayout* layoutCoutTBButtons = new QHBo 2572 QHBoxLayout* layoutCoutTBButtons = new QHBoxLayout();
2501 2573
2502 fFilterOutput = new QLineEdit(); 2574 fFilterOutput = new QLineEdit();
2503 fFilterOutput->setToolTip("Filter output by 2575 fFilterOutput->setToolTip("Filter output by...");
2504 fFilterOutput->setStyleSheet ("padding: 0px 2576 fFilterOutput->setStyleSheet ("padding: 0px ");
2505 2577
2506 QPixmap* searchIcon = fUiQt->getSearchIcon( 2578 QPixmap* searchIcon = fUiQt->getSearchIcon();
>> 2579 #if QT_VERSION > 0x050100
2507 fFilterOutput->addAction(*searchIcon,QLineE 2580 fFilterOutput->addAction(*searchIcon,QLineEdit::TrailingPosition);
2508 fFilterOutput->setStyleSheet ("border-radiu 2581 fFilterOutput->setStyleSheet ("border-radius:7px;");
>> 2582 #else
>> 2583 QPushButton *coutTBFilterButton = new QPushButton();
>> 2584 coutTBFilterButton->setIcon(*searchIcon);
>> 2585 coutTBFilterButton->setStyleSheet ("padding-left: 0px; border:0px;");
>> 2586 fFilterOutput->setStyleSheet ("padding-right: 0px;");
>> 2587 #endif
2509 layoutCoutTBButtons->addWidget(fFilterOutpu 2588 layoutCoutTBButtons->addWidget(fFilterOutput);
2510 2589
>> 2590 #if QT_VERSION <= 0x050100
>> 2591 layoutCoutTBButtons->addWidget(coutTBFilterButton);
>> 2592 #endif
>> 2593
2511 coutButtonWidget->setLayout(layoutCoutTBBut 2594 coutButtonWidget->setLayout(layoutCoutTBButtons);
2512 vLayout->addWidget(coutButtonWidget); 2595 vLayout->addWidget(coutButtonWidget);
2513 2596
2514 // reduce margins 2597 // reduce margins
2515 vLayout->setContentsMargins(0,0,0,0); 2598 vLayout->setContentsMargins(0,0,0,0);
2516 2599
2517 2600
2518 fSceneTreeComponentTreeWidget = new QTreeWi 2601 fSceneTreeComponentTreeWidget = new QTreeWidget();
2519 fSceneTreeComponentTreeWidget->setSelection 2602 fSceneTreeComponentTreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
2520 fSceneTreeComponentTreeWidget->setHeaderLab 2603 fSceneTreeComponentTreeWidget->setHeaderLabel ("Scene tree : "+QString(GetName().data()));
2521 fSceneTreeComponentTreeWidget->setColumnHid 2604 fSceneTreeComponentTreeWidget->setColumnHidden (1,true); // copy number
2522 fSceneTreeComponentTreeWidget->setColumnHid 2605 fSceneTreeComponentTreeWidget->setColumnHidden (2,true); // PO index
2523 fSceneTreeComponentTreeWidget->setColumnHid 2606 fSceneTreeComponentTreeWidget->setColumnHidden (3,true); // Informations
2524 // data(0) : POindex 2607 // data(0) : POindex
2525 // data(1) : copy number 2608 // data(1) : copy number
2526 // data(2) : g4color 2609 // data(2) : g4color
2527 2610
2528 vLayout->addWidget(fSceneTreeComponentTreeW 2611 vLayout->addWidget(fSceneTreeComponentTreeWidget);
2529 2612
2530 connect(fSceneTreeComponentTreeWidget,SIGNA 2613 connect(fSceneTreeComponentTreeWidget,SIGNAL(itemChanged(QTreeWidgetItem*, int)),SLOT(sceneTreeComponentItemChanged(QTreeWidgetItem*, int)));
2531 connect(fSceneTreeComponentTreeWidget,SIGNA 2614 connect(fSceneTreeComponentTreeWidget,SIGNAL(itemSelectionChanged ()),SLOT(sceneTreeComponentSelected()));
2532 connect(fSceneTreeComponentTreeWidget,SIGNA 2615 connect(fSceneTreeComponentTreeWidget,SIGNAL(itemDoubleClicked ( QTreeWidgetItem*, int)),SLOT(changeColorAndTransparency( QTreeWidgetItem*, int)));
2533 2616
2534 2617
2535 // Depth slider 2618 // Depth slider
2536 QWidget *helpWidget = new QWidget(); 2619 QWidget *helpWidget = new QWidget();
2537 QHBoxLayout *helpLayout = new QHBoxLayout() 2620 QHBoxLayout *helpLayout = new QHBoxLayout();
2538 2621
2539 QWidget* depthWidget = new QWidget(); 2622 QWidget* depthWidget = new QWidget();
2540 QWidget *showBox = new QWidget(depthWidget) 2623 QWidget *showBox = new QWidget(depthWidget);
2541 QHBoxLayout *showBoxLayout = new QHBoxLayou 2624 QHBoxLayout *showBoxLayout = new QHBoxLayout();
2542 2625
2543 // reduce margins 2626 // reduce margins
2544 showBoxLayout->setContentsMargins(5,5,5,5); 2627 showBoxLayout->setContentsMargins(5,5,5,5);
2545 2628
2546 QLabel *zero = new QLabel(); 2629 QLabel *zero = new QLabel();
2547 zero->setText("Show all"); 2630 zero->setText("Show all");
2548 QLabel *one = new QLabel(); 2631 QLabel *one = new QLabel();
2549 one->setText("Hide all"); 2632 one->setText("Hide all");
2550 fSceneTreeDepthSlider = new QSlider ( Qt::H 2633 fSceneTreeDepthSlider = new QSlider ( Qt::Horizontal);
2551 fSceneTreeDepthSlider->setMaximum (1000); 2634 fSceneTreeDepthSlider->setMaximum (1000);
2552 fSceneTreeDepthSlider->setMinimum (0); 2635 fSceneTreeDepthSlider->setMinimum (0);
2553 fSceneTreeDepthSlider->setTickPosition(QSli 2636 fSceneTreeDepthSlider->setTickPosition(QSlider::TicksAbove);
2554 // set a minimum size 2637 // set a minimum size
2555 fSceneTreeDepthSlider->setMinimumWidth (40) 2638 fSceneTreeDepthSlider->setMinimumWidth (40);
2556 2639
2557 showBoxLayout->addWidget(zero); 2640 showBoxLayout->addWidget(zero);
2558 showBoxLayout->addWidget(fSceneTreeDepthSli 2641 showBoxLayout->addWidget(fSceneTreeDepthSlider);
2559 showBoxLayout->addWidget(one); 2642 showBoxLayout->addWidget(one);
2560 2643
2561 showBox->setLayout(showBoxLayout); 2644 showBox->setLayout(showBoxLayout);
2562 2645
2563 helpLayout->addWidget(showBox); 2646 helpLayout->addWidget(showBox);
2564 helpWidget->setLayout(helpLayout); 2647 helpWidget->setLayout(helpLayout);
2565 helpLayout->setContentsMargins(0,0,0,0); 2648 helpLayout->setContentsMargins(0,0,0,0);
2566 2649
2567 vLayout->addWidget(helpWidget); 2650 vLayout->addWidget(helpWidget);
2568 2651
2569 connect( fSceneTreeDepthSlider, SIGNAL( val 2652 connect( fSceneTreeDepthSlider, SIGNAL( valueChanged(int) ), this, SLOT( changeDepthInSceneTree(int) ) );
2570 connect( fFilterOutput, SIGNAL( textEdited 2653 connect( fFilterOutput, SIGNAL( textEdited ( const QString &) ), this, SLOT(changeSearchSelection()));
2571 fTreeItemModels.clear(); 2654 fTreeItemModels.clear();
2572 2655
2573 fPVRootNodeCreate = false; 2656 fPVRootNodeCreate = false;
2574 2657
2575 fMaxPOindexInserted = -1; 2658 fMaxPOindexInserted = -1;
2576 2659
2577 2660
2578 } 2661 }
2579 2662
2580 2663
2581 void G4OpenGLQtViewer::createViewerProperties 2664 void G4OpenGLQtViewer::createViewerPropertiesWidget() {
2582 2665
2583 // Get the pointer to the Viewer Properties 2666 // Get the pointer to the Viewer Properties widget
2584 fUIViewerPropertiesWidget = fUiQt->GetViewe 2667 fUIViewerPropertiesWidget = fUiQt->GetViewerPropertiesWidget();
2585 2668
2586 if (!fUIViewerPropertiesWidget) { 2669 if (!fUIViewerPropertiesWidget) {
2587 return; 2670 return;
2588 } 2671 }
2589 2672
2590 // remove previous widgets 2673 // remove previous widgets
2591 QLayoutItem * wItem; 2674 QLayoutItem * wItem;
2592 if (fUIViewerPropertiesWidget->layout()->co 2675 if (fUIViewerPropertiesWidget->layout()->count()) {
2593 while ((wItem = fUIViewerPropertiesWidget 2676 while ((wItem = fUIViewerPropertiesWidget->layout()->takeAt(0)) != 0) {
2594 delete wItem->widget(); 2677 delete wItem->widget();
2595 delete wItem; 2678 delete wItem;
2596 } 2679 }
2597 } 2680 }
2598 2681
2599 // add properties 2682 // add properties
2600 QGroupBox *groupBox = new QGroupBox(); 2683 QGroupBox *groupBox = new QGroupBox();
2601 groupBox->setTitle(GetName().data()); 2684 groupBox->setTitle(GetName().data());
2602 QVBoxLayout *vbox = new QVBoxLayout; 2685 QVBoxLayout *vbox = new QVBoxLayout;
2603 2686
2604 // add properties content 2687 // add properties content
2605 fViewerPropertiesTableWidget = new QTableWi 2688 fViewerPropertiesTableWidget = new QTableWidget();
2606 2689
2607 QSizePolicy vPolicy = fViewerPropertiesTabl 2690 QSizePolicy vPolicy = fViewerPropertiesTableWidget->sizePolicy();
2608 vPolicy.setVerticalStretch(4); 2691 vPolicy.setVerticalStretch(4);
2609 2692
2610 vbox->addWidget(fViewerPropertiesTableWidge 2693 vbox->addWidget(fViewerPropertiesTableWidget);
2611 groupBox->setLayout(vbox); 2694 groupBox->setLayout(vbox);
2612 fUIViewerPropertiesWidget->layout()->addWid 2695 fUIViewerPropertiesWidget->layout()->addWidget(groupBox);
2613 2696
2614 connect(fViewerPropertiesTableWidget, SIGNA 2697 connect(fViewerPropertiesTableWidget, SIGNAL(itemChanged(QTableWidgetItem*)),this, SLOT(tableWidgetViewerSetItemChanged(QTableWidgetItem *)));
2615 2698
2616 updateViewerPropertiesTableWidget(); 2699 updateViewerPropertiesTableWidget();
2617 2700
2618 QDialog* dial = static_cast<QDialog*> (fUIV 2701 QDialog* dial = static_cast<QDialog*> (fUIViewerPropertiesWidget->parent());
2619 if (dial) { 2702 if (dial) {
2620 // change name 2703 // change name
2621 dial->setWindowTitle(QString("Viewer prop 2704 dial->setWindowTitle(QString("Viewer properties - ")+GetName());
2622 } 2705 }
2623 } 2706 }
2624 2707
2625 2708
2626 void G4OpenGLQtViewer::createPickInfosWidget( 2709 void G4OpenGLQtViewer::createPickInfosWidget(){
2627 2710
2628 // Get the pointer to the Pick infos widget 2711 // Get the pointer to the Pick infos widget
2629 fUIPickInfosWidget = fUiQt->GetPickInfosWid 2712 fUIPickInfosWidget = fUiQt->GetPickInfosWidget();
2630 2713
2631 if (!fUIPickInfosWidget) { 2714 if (!fUIPickInfosWidget) {
2632 return; 2715 return;
2633 } 2716 }
2634 2717
2635 // remove previous widgets 2718 // remove previous widgets
2636 QLayoutItem * wItem; 2719 QLayoutItem * wItem;
2637 if (fUIPickInfosWidget->layout()->count()) 2720 if (fUIPickInfosWidget->layout()->count()) {
2638 while ((wItem = fUIPickInfosWidget->layou 2721 while ((wItem = fUIPickInfosWidget->layout()->takeAt(0)) != 0) {
2639 delete wItem->widget(); 2722 delete wItem->widget();
2640 delete wItem; 2723 delete wItem;
2641 } 2724 }
2642 } 2725 }
2643 2726
2644 QGroupBox *groupBox = new QGroupBox(""); 2727 QGroupBox *groupBox = new QGroupBox("");
2645 QVBoxLayout *vbox = new QVBoxLayout; 2728 QVBoxLayout *vbox = new QVBoxLayout;
2646 2729
2647 // add picking infos 2730 // add picking infos
2648 QWidget *pickingInfoWidget = new QWidget(); 2731 QWidget *pickingInfoWidget = new QWidget();
2649 QHBoxLayout *pickingInfoLayout = new QHBoxL 2732 QHBoxLayout *pickingInfoLayout = new QHBoxLayout();
2650 2733
2651 pickingInfoWidget->setStyleSheet ("padding- 2734 pickingInfoWidget->setStyleSheet ("padding-left: 0px; border:0px;");
2652 pickingInfoWidget->setLayout(pickingInfoLay 2735 pickingInfoWidget->setLayout(pickingInfoLayout);
2653 2736
2654 vbox->addWidget(pickingInfoWidget); 2737 vbox->addWidget(pickingInfoWidget);
2655 // add picking content 2738 // add picking content
2656 2739
2657 fPickInfosScrollArea = new QScrollArea(); 2740 fPickInfosScrollArea = new QScrollArea();
2658 fPickInfosScrollArea->setWidgetResizable(tr 2741 fPickInfosScrollArea->setWidgetResizable(true);
2659 2742
2660 2743
2661 fPickInfosWidget = new QWidget(); 2744 fPickInfosWidget = new QWidget();
2662 fPickInfosWidget->setStyleSheet ("padding: 2745 fPickInfosWidget->setStyleSheet ("padding: 0px ");
2663 2746
2664 QVBoxLayout* vLayout = new QVBoxLayout(); 2747 QVBoxLayout* vLayout = new QVBoxLayout();
2665 fPickInfosWidget->setLayout (vLayout); 2748 fPickInfosWidget->setLayout (vLayout);
2666 fPickInfosScrollArea->setWidget(fPickInfosW 2749 fPickInfosScrollArea->setWidget(fPickInfosWidget);
2667 2750
2668 QSizePolicy vPolicy = fPickInfosWidget->siz 2751 QSizePolicy vPolicy = fPickInfosWidget->sizePolicy();
2669 vPolicy.setVerticalStretch(4); 2752 vPolicy.setVerticalStretch(4);
2670 vbox->addWidget(fPickInfosScrollArea); 2753 vbox->addWidget(fPickInfosScrollArea);
2671 pickingInfoLayout->setContentsMargins(0,0,0 2754 pickingInfoLayout->setContentsMargins(0,0,0,0);
2672 vLayout->setContentsMargins(0,0,0,0); 2755 vLayout->setContentsMargins(0,0,0,0);
2673 vbox->setContentsMargins(1,1,1,1); 2756 vbox->setContentsMargins(1,1,1,1);
2674 2757
2675 groupBox->setLayout(vbox); 2758 groupBox->setLayout(vbox);
2676 fUIPickInfosWidget->layout()->addWidget(gro 2759 fUIPickInfosWidget->layout()->addWidget(groupBox);
2677 2760
2678 updatePickInfosWidget(fLastPickPoint.x(),fL 2761 updatePickInfosWidget(fLastPickPoint.x(),fLastPickPoint.y());
2679 } 2762 }
2680 2763
2681 2764
2682 // set the component to check/unchecked, also 2765 // set the component to check/unchecked, also go into its child
2683 // and set the same status to all his childs 2766 // and set the same status to all his childs
2684 void G4OpenGLQtViewer::setCheckComponent(QTre 2767 void G4OpenGLQtViewer::setCheckComponent(QTreeWidgetItem* item,bool check)
2685 { 2768 {
2686 if (item) { 2769 if (item) {
2687 2770
2688 const PVPath& fullPath = fTreeItemModels[ 2771 const PVPath& fullPath = fTreeItemModels[item->data(0,Qt::UserRole).toInt()];
2689 // If a physical volume 2772 // If a physical volume
2690 if (fullPath.size() > 0) { 2773 if (fullPath.size() > 0) {
2691 SetTouchable(fullPath); 2774 SetTouchable(fullPath);
2692 TouchableSetVisibility(fullPath, check) 2775 TouchableSetVisibility(fullPath, check);
2693 fMouseOnSceneTree = true; 2776 fMouseOnSceneTree = true;
2694 } 2777 }
2695 } 2778 }
2696 2779
2697 if (item != NULL) { 2780 if (item != NULL) {
2698 if (check) { 2781 if (check) {
2699 item->setCheckState(0,Qt::Checked); 2782 item->setCheckState(0,Qt::Checked);
2700 } else { 2783 } else {
2701 item->setCheckState(0,Qt::Unchecked); 2784 item->setCheckState(0,Qt::Unchecked);
2702 } 2785 }
2703 updatePositivePoIndexSceneTreeWidgetQuick 2786 updatePositivePoIndexSceneTreeWidgetQuickMap(item->data(0,Qt::UserRole).toInt(),item);
2704 int nChildCount = item->childCount(); 2787 int nChildCount = item->childCount();
2705 for (int i = 0; i < nChildCount; i++) { 2788 for (int i = 0; i < nChildCount; i++) {
2706 setCheckComponent(item->child(i),check) 2789 setCheckComponent(item->child(i),check);
2707 } 2790 }
2708 } 2791 }
2709 } 2792 }
2710 2793
2711 #if QT_VERSION < 0x060000 <<
2712 #else <<
2713 //G.Barrand : from stackoverflow "How to rend <<
2714 static void transform_point(GLdouble out[4], <<
2715 { <<
2716 #define M(row,col) m[col*4+row] <<
2717 out[0] = <<
2718 M(0, 0) * in[0] + M(0, 1) * in[1] + M <<
2719 out[1] = <<
2720 M(1, 0) * in[0] + M(1, 1) * in[1] + M <<
2721 out[2] = <<
2722 M(2, 0) * in[0] + M(2, 1) * in[1] + M <<
2723 out[3] = <<
2724 M(3, 0) * in[0] + M(3, 1) * in[1] + M <<
2725 #undef M <<
2726 } <<
2727 inline GLint project_point(GLdouble objx, GLd <<
2728 const GLdouble model[16], const GLdouble <<
2729 const GLint viewport[4], <<
2730 GLdouble * winx, GLdouble * winy, GLdoubl <<
2731 { <<
2732 GLdouble in[4], out[4]; <<
2733 <<
2734 in[0] = objx; <<
2735 in[1] = objy; <<
2736 in[2] = objz; <<
2737 in[3] = 1.0; <<
2738 transform_point(out, model, in); <<
2739 transform_point(in, proj, out); <<
2740 <<
2741 if (in[3] == 0.0) <<
2742 return GL_FALSE; <<
2743 <<
2744 in[0] /= in[3]; <<
2745 in[1] /= in[3]; <<
2746 in[2] /= in[3]; <<
2747 <<
2748 *winx = viewport[0] + (1 + in[0]) * viewp <<
2749 *winy = viewport[1] + (1 + in[1]) * viewp <<
2750 <<
2751 *winz = (1 + in[2]) / 2; <<
2752 return GL_TRUE; <<
2753 } <<
2754 static void render_text(QOpenGLWidget& widget <<
2755 double world_x, double world <<
2756 double offset_x, double offs <<
2757 const QFont& font, <<
2758 const QColor& color, <<
2759 const char* text) <<
2760 { <<
2761 GLdouble model[4][4]; <<
2762 glGetDoublev(GL_MODELVIEW_MATRIX, &model[ <<
2763 GLdouble proj[4][4]; <<
2764 glGetDoublev(GL_PROJECTION_MATRIX, &proj[ <<
2765 GLint view[4]; <<
2766 glGetIntegerv(GL_VIEWPORT, &view[0]); <<
2767 <<
2768 GLdouble textPosX = 0, textPosY = 0, text <<
2769 project_point(world_x, world_y, world_z, <<
2770 &model[0][0], &proj[0][0], <<
2771 &textPosX, &textPosY, &text <<
2772 <<
2773 textPosX /= GLdouble(widget.devicePixelRa <<
2774 textPosY /= GLdouble(widget.devicePixelRa <<
2775 <<
2776 textPosY = GLdouble(widget.height()) - te <<
2777 <<
2778 textPosX += offset_x; <<
2779 textPosY += offset_y; <<
2780 <<
2781 GLboolean GL_BLEND_enabled = glIsEnabled( <<
2782 <<
2783 QPainter painter(&widget); <<
2784 painter.setPen(color); <<
2785 painter.setFont(font); <<
2786 painter.setRenderHints(QPainter::Antialia <<
2787 painter.drawText(textPosX, textPosY, text <<
2788 painter.end(); <<
2789 <<
2790 if(GL_BLEND_enabled==GL_TRUE) { <<
2791 ::glEnable(GL_BLEND); <<
2792 ::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINU <<
2793 } <<
2794 } <<
2795 #endif <<
2796 2794
2797 void G4OpenGLQtViewer::DrawText(const G4Text& 2795 void G4OpenGLQtViewer::DrawText(const G4Text& g4text)
2798 { 2796 {
2799 auto* qGLW = dynamic_cast<G4QGLWidgetType*> << 2797 QGLWidget* qGLW = dynamic_cast<QGLWidget*> (fGLWidget) ;
2800 if (! qGLW) { 2798 if (! qGLW) {
2801 return; 2799 return;
2802 } 2800 }
2803 if (isGl2psWriting()) { 2801 if (isGl2psWriting()) {
2804 2802
2805 G4OpenGLViewer::DrawText(g4text); 2803 G4OpenGLViewer::DrawText(g4text);
2806 2804
2807 } else { 2805 } else {
2808 2806
2809 if (!fGLWidget) return; 2807 if (!fGLWidget) return;
2810 2808
2811 if (!G4Threading::IsMasterThread()) retur << 2809 #ifdef G4MULTITHREADED
>> 2810 if (G4Threading::G4GetThreadId() != G4Threading::MASTER_ID) return;
>> 2811 #endif
2812 2812
2813 G4VSceneHandler::MarkerSizeType sizeType; 2813 G4VSceneHandler::MarkerSizeType sizeType;
2814 G4double size = fSceneHandler.GetMarkerSi 2814 G4double size = fSceneHandler.GetMarkerSize(g4text,sizeType);
2815 2815
2816 QFont font = QFont(); 2816 QFont font = QFont();
2817 font.setPointSizeF(size); 2817 font.setPointSizeF(size);
2818 2818
2819 const G4Colour& c = fSceneHandler.GetText 2819 const G4Colour& c = fSceneHandler.GetTextColour(g4text);
>> 2820 glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha());
2820 2821
2821 G4Point3D position = g4text.GetPosition() 2822 G4Point3D position = g4text.GetPosition();
2822 2823
2823 const G4String& textString = g4text.GetTe 2824 const G4String& textString = g4text.GetText();
2824 const char* textCString = textString.c_st 2825 const char* textCString = textString.c_str();
2825 2826
2826 // Calculate move for centre and right ad << 2827 glRasterPos3d(position.x(),position.y(),position.z());
2827 QFontMetrics f(font); <<
2828 G4double span = f.boundingRect(textCStrin <<
2829 <<
2830 G4double xmove = 0.; <<
2831 G4double ymove = 0.; <<
2832 2828
>> 2829 // Calculate move for centre and right adjustment
>> 2830 QFontMetrics* f = new QFontMetrics (font);
>> 2831 #if QT_VERSION > 0x050110
>> 2832 G4double span = f->boundingRect(textCString).width();
>> 2833 #else
>> 2834 G4double span = f->width(textCString);
>> 2835 #endif
>> 2836 G4double xmove = 0., ymove = 0.;
2833 switch (g4text.GetLayout()) { 2837 switch (g4text.GetLayout()) {
2834 case G4Text::left: break; 2838 case G4Text::left: break;
2835 case G4Text::centre: xmove -= span / 2.; 2839 case G4Text::centre: xmove -= span / 2.; break;
2836 case G4Text::right: xmove -= span; 2840 case G4Text::right: xmove -= span;
2837 } 2841 }
2838 2842
2839 //Add offsets 2843 //Add offsets
2840 xmove += g4text.GetXOffset(); 2844 xmove += g4text.GetXOffset();
2841 ymove += g4text.GetYOffset(); 2845 ymove += g4text.GetYOffset();
2842 2846
2843 #if QT_VERSION < 0x060000 <<
2844 glColor4d(c.GetRed(),c.GetGreen(),c.GetBl <<
2845 glRasterPos3d(position.x(),position.y(),p <<
2846 // xmove, ymove in pixels - or are they? 2847 // xmove, ymove in pixels - or are they?
2847 #ifdef __APPLE__ 2848 #ifdef __APPLE__
2848 const G4double fudgeFactor = 2.; 2849 const G4double fudgeFactor = 2.;
2849 #else 2850 #else
2850 const G4double fudgeFactor = 1.; 2851 const G4double fudgeFactor = 1.;
2851 #endif 2852 #endif
2852 xmove *= fudgeFactor; 2853 xmove *= fudgeFactor;
2853 ymove *= fudgeFactor; 2854 ymove *= fudgeFactor;
>> 2855
2854 qGLW->renderText 2856 qGLW->renderText
2855 ((position.x()+(2*xmove)/getWinWidth()) 2857 ((position.x()+(2*xmove)/getWinWidth()),
2856 (position.y()+(2*ymove)/getWinHeight() 2858 (position.y()+(2*ymove)/getWinHeight()),
2857 position.z(), 2859 position.z(),
2858 textCString, 2860 textCString,
2859 font); 2861 font);
2860 #else << 2862
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(),pos <<
2867 xmove,ymove, <<
2868 font,color,textCString); <<
2869 #endif <<
2870 } 2863 }
2871 } 2864 }
2872 2865
2873 2866
2874 void G4OpenGLQtViewer::ResetView () { 2867 void G4OpenGLQtViewer::ResetView () {
2875 G4OpenGLViewer::ResetView(); 2868 G4OpenGLViewer::ResetView();
2876 fDeltaDepth = 0.01; 2869 fDeltaDepth = 0.01;
2877 fDeltaZoom = 0.05; 2870 fDeltaZoom = 0.05;
2878 } 2871 }
2879 2872
2880 2873
2881 2874
2882 2875
2883 void G4OpenGLQtViewer::addPVSceneTreeElement( 2876 void G4OpenGLQtViewer::addPVSceneTreeElement(const G4String& model, G4PhysicalVolumeModel* pPVModel, int currentPOIndex) {
2884 2877
2885 const QString& modelShortName = getModelSho 2878 const QString& modelShortName = getModelShortName(model);
2886 2879
2887 if (modelShortName == "") { 2880 if (modelShortName == "") {
2888 return ; 2881 return ;
2889 } 2882 }
2890 // try to init it 2883 // try to init it
2891 if (fSceneTreeComponentTreeWidget == NULL) 2884 if (fSceneTreeComponentTreeWidget == NULL) {
2892 createSceneTreeComponent(); 2885 createSceneTreeComponent();
2893 } 2886 }
2894 2887
2895 // if no UI 2888 // if no UI
2896 if (fSceneTreeComponentTreeWidget == NULL) 2889 if (fSceneTreeComponentTreeWidget == NULL) {
2897 return; 2890 return;
2898 } 2891 }
2899 2892
2900 fSceneTreeComponentTreeWidget->blockSignals 2893 fSceneTreeComponentTreeWidget->blockSignals(true);
2901 2894
2902 // Create the "volume" node if not 2895 // Create the "volume" node if not
2903 // if (fSceneTreeComponentTreeWidget->topL 2896 // if (fSceneTreeComponentTreeWidget->topLevelItemCount () == 0) {
2904 if (!fPVRootNodeCreate) { 2897 if (!fPVRootNodeCreate) {
2905 const G4Colour& color = fSceneHandler.Get 2898 const G4Colour& color = fSceneHandler.GetColour();
2906 2899
2907 fModelShortNameItem = createTreeWidgetIte 2900 fModelShortNameItem = createTreeWidgetItem(pPVModel->GetFullPVPath(),
2908 2901 modelShortName,
2909 2902 0, // currentPVCopyNb
2910 2903 -1, // currentPVPOIndex
2911 2904 "",
2912 2905 Qt::Checked,
2913 2906 NULL,
2914 2907 color);
2915 fPVRootNodeCreate = true; 2908 fPVRootNodeCreate = true;
2916 } 2909 }
2917 2910
2918 bool added = parseAndInsertInSceneTree(fMod 2911 bool added = parseAndInsertInSceneTree(fModelShortNameItem,pPVModel,0,modelShortName,0,currentPOIndex);
2919 if (!added) { 2912 if (!added) {
2920 } 2913 }
2921 2914
2922 fSceneTreeComponentTreeWidget->blockSignals 2915 fSceneTreeComponentTreeWidget->blockSignals(false);
2923 2916
2924 } 2917 }
2925 2918
2926 2919
2927 /** 2920 /**
2928 if treeNode is NULL, then add this treeNod 2921 if treeNode is NULL, then add this treeNode to the TreeWidget
2929 @return the inserted item 2922 @return the inserted item
2930 */ 2923 */
2931 QTreeWidgetItem* G4OpenGLQtViewer::createTree 2924 QTreeWidgetItem* G4OpenGLQtViewer::createTreeWidgetItem(
2932 const PVPath& fullPath 2925 const PVPath& fullPath
2933 ,const QString& name 2926 ,const QString& name
2934 ,int copyNb 2927 ,int copyNb
2935 ,int POIndex 2928 ,int POIndex
2936 ,const QString& logicalName 2929 ,const QString& logicalName
2937 ,Qt::CheckState state 2930 ,Qt::CheckState state
2938 ,QTreeWidgetItem * parentTreeNode 2931 ,QTreeWidgetItem * parentTreeNode
2939 ,const G4Colour& color 2932 ,const G4Colour& color
2940 ) { 2933 ) {
2941 2934
2942 // Set depth 2935 // Set depth
2943 if (fullPath.size() > fSceneTreeDepth) { 2936 if (fullPath.size() > fSceneTreeDepth) {
2944 fSceneTreeDepth = (unsigned int)fullPath. 2937 fSceneTreeDepth = (unsigned int)fullPath.size();
2945 // Change slider value 2938 // Change slider value
2946 if (fSceneTreeDepthSlider) { 2939 if (fSceneTreeDepthSlider) {
2947 fSceneTreeDepthSlider->setTickInterval( 2940 fSceneTreeDepthSlider->setTickInterval(1000/(fSceneTreeDepth+1));
2948 } 2941 }
2949 } 2942 }
2950 QTreeWidgetItem * newItem = NULL; 2943 QTreeWidgetItem * newItem = NULL;
2951 if (parentTreeNode == NULL) { 2944 if (parentTreeNode == NULL) {
2952 newItem = new QTreeWidgetItem(); 2945 newItem = new QTreeWidgetItem();
2953 fSceneTreeComponentTreeWidget->addTopLeve 2946 fSceneTreeComponentTreeWidget->addTopLevelItem(newItem);
2954 } else { 2947 } else {
2955 newItem = new QTreeWidgetItem(parentTreeN 2948 newItem = new QTreeWidgetItem(parentTreeNode);
2956 fSceneTreeComponentTreeWidget->addTopLeve 2949 fSceneTreeComponentTreeWidget->addTopLevelItem(parentTreeNode);
2957 } 2950 }
2958 2951
2959 2952
2960 newItem->setText(0,name); 2953 newItem->setText(0,name);
2961 newItem->setData(1,Qt::UserRole,copyNb); 2954 newItem->setData(1,Qt::UserRole,copyNb);
2962 newItem->setText(2,QString::number(POIndex) 2955 newItem->setText(2,QString::number(POIndex));
2963 newItem->setData(0, Qt::UserRole, POIndex); 2956 newItem->setData(0, Qt::UserRole, POIndex);
2964 newItem->setText(3,logicalName); 2957 newItem->setText(3,logicalName);
2965 newItem->setFlags(newItem->flags()|Qt::Item 2958 newItem->setFlags(newItem->flags()|Qt::ItemIsUserCheckable);
2966 newItem->setCheckState(0,state); 2959 newItem->setCheckState(0,state);
2967 newItem->setExpanded(true); 2960 newItem->setExpanded(true);
2968 updatePositivePoIndexSceneTreeWidgetQuickMa 2961 updatePositivePoIndexSceneTreeWidgetQuickMap(POIndex,newItem);
2969 2962
2970 changeQColorForTreeWidgetItem(newItem,QColo 2963 changeQColorForTreeWidgetItem(newItem,QColor((int)(color.GetRed()*255),
2971 2964 (int)(color.GetGreen()*255),
2972 2965 (int)(color.GetBlue()*255),
2973 2966 (int)(color.GetAlpha()*255)));
2974 2967
2975 // If invisible 2968 // If invisible
2976 if ((state == Qt::Unchecked) && (POIndex == 2969 if ((state == Qt::Unchecked) && (POIndex == -1)) {
2977 newItem->setForeground (0, QBrush( Qt::gr 2970 newItem->setForeground (0, QBrush( Qt::gray) );
2978 2971
2979 // Set a tootip 2972 // Set a tootip
2980 newItem->setToolTip (0,QString( 2973 newItem->setToolTip (0,QString(
2981 "This node 2974 "This node exists in the geometry but has not been\n")+
2982 "drawn, perhaps beca 2975 "drawn, perhaps because it has been set invisible. It \n"+
2983 "cannot be made visi 2976 "cannot be made visible with a click on the button.\n"+
2984 "To see it, change t 2977 "To see it, change the visibility, for example, with \n"+
2985 "/vis/geometry/set/v 2978 "/vis/geometry/set/visibility " + logicalName + " 0 true\n"+
2986 "and rebuild the vie 2979 "and rebuild the view with /vis/viewer/rebuild.\n"+
2987 "Click here will onl 2980 "Click here will only show/hide all child components");
2988 } else { 2981 } else {
2989 // Set a tootip 2982 // Set a tootip
2990 newItem->setToolTip (0,QString("double-cl 2983 newItem->setToolTip (0,QString("double-click to change the color"));
2991 } 2984 }
2992 2985
2993 // special case: if alpha=0, it is a totall 2986 // special case: if alpha=0, it is a totally transparent objet,
2994 // then, do not redraw it 2987 // then, do not redraw it
2995 if (color.GetAlpha() == 0) { 2988 if (color.GetAlpha() == 0) {
2996 state = Qt::Unchecked; 2989 state = Qt::Unchecked;
2997 newItem->setCheckState(0,state); 2990 newItem->setCheckState(0,state);
2998 updatePositivePoIndexSceneTreeWidgetQuick 2991 updatePositivePoIndexSceneTreeWidgetQuickMap(POIndex,newItem);
2999 } 2992 }
3000 2993
3001 fTreeItemModels.insert(std::pair <int, PVPa 2994 fTreeItemModels.insert(std::pair <int, PVPath > (POIndex,fullPath) );
3002 2995
3003 // Check last status of this item and chang 2996 // Check last status of this item and change if necessary
3004 // open/close/hidden/visible/selected 2997 // open/close/hidden/visible/selected
3005 changeOpenCloseVisibleHiddenSelectedColorSc 2998 changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement(newItem);
3006 return newItem; 2999 return newItem;
3007 } 3000 }
3008 3001
3009 3002
3010 // 3003 //
3011 // Recursive function. 3004 // Recursive function.
3012 // Try to insert the given item : 3005 // Try to insert the given item :
3013 // - If not present and last item of the pa 3006 // - If not present and last item of the path: insert it and mark it CHECK
3014 // - If not present and NOT last item of th 3007 // - If not present and NOT last item of the path: insert it and mark it UNCHECKED
3015 // - If already present and name/PO/Transfo 3008 // - If already present and name/PO/Transformation identical, then it is a transparent
3016 // object : Change the PO number and tran 3009 // object : Change the PO number and transparency
3017 // - If already present and PO different, t 3010 // - If already present and PO different, then it is an unvisible item : Have to
3018 // set it visible 3011 // set it visible
3019 // - else : Create a new element 3012 // - else : Create a new element
3020 // @return true if inserted, false if alrea 3013 // @return true if inserted, false if already present
3021 // 3014 //
3022 bool G4OpenGLQtViewer::parseAndInsertInSceneT 3015 bool G4OpenGLQtViewer::parseAndInsertInSceneTree(
3023 QTreeWidgetItem * parentItem 3016 QTreeWidgetItem * parentItem
3024 ,G4PhysicalVolumeModel* pPVModel 3017 ,G4PhysicalVolumeModel* pPVModel
3025 ,unsigned int fullPathIndex 3018 ,unsigned int fullPathIndex
3026 ,const QString& parentRoot 3019 ,const QString& parentRoot
3027 ,unsigned int currentIndexInTreeSceneHandler 3020 ,unsigned int currentIndexInTreeSceneHandler
3028 ,int currentPVPOIndex 3021 ,int currentPVPOIndex
3029 ) { 3022 ) {
3030 3023
3031 if (parentItem == NULL) { 3024 if (parentItem == NULL) {
3032 return false; 3025 return false;
3033 } 3026 }
3034 3027
3035 const PVPath& fullPath = pPVModel->GetFullP 3028 const PVPath& fullPath = pPVModel->GetFullPVPath();
3036 3029
3037 std::ostringstream oss; 3030 std::ostringstream oss;
3038 oss << fullPath.at(fullPathIndex).GetCopyNo 3031 oss << fullPath.at(fullPathIndex).GetCopyNo();
3039 std::string currentPVName = G4String(fullPa 3032 std::string currentPVName = G4String(fullPath.at(fullPathIndex).GetPhysicalVolume()->GetName()+" ["+oss.str()+"]").data();
3040 3033
3041 int currentPVCopyNb = fullPath.at(fullPathI 3034 int currentPVCopyNb = fullPath.at(fullPathIndex).GetCopyNo();
3042 3035
3043 const G4Colour& color = fSceneHandler.GetCo 3036 const G4Colour& color = fSceneHandler.GetColour();
3044 3037
3045 // look in all children in order to get if 3038 // look in all children in order to get if their is already a
3046 // child corresponding: 3039 // child corresponding:
3047 // - if so, go into this child 3040 // - if so, go into this child
3048 // - if not : create it as invisible 3041 // - if not : create it as invisible
3049 3042
3050 // Realy quick check if the POindex is alre 3043 // Realy quick check if the POindex is already there
3051 QTreeWidgetItem* subItem = NULL; 3044 QTreeWidgetItem* subItem = NULL;
3052 QList<QTreeWidgetItem *> parentItemList; 3045 QList<QTreeWidgetItem *> parentItemList;
3053 3046
3054 3047
3055 // first of all, very quick check if it was 3048 // first of all, very quick check if it was not the same as last one
3056 3049
3057 // Check only if it is a transparent object 3050 // Check only if it is a transparent object
3058 // If it is the last item and it is not tra 3051 // If it is the last item and it is not transparent -> nothing to look for,
3059 // simply add it. 3052 // simply add it.
3060 if ((currentIndexInTreeSceneHandler == (ful 3053 if ((currentIndexInTreeSceneHandler == (fullPath.size()-1)) && ((color.GetAlpha() == 1.))) {
3061 } else { 3054 } else {
3062 QString lookForString = QString(currentPV 3055 QString lookForString = QString(currentPVName.c_str());
3063 for (int i = 0;i < parentItem->childCount 3056 for (int i = 0;i < parentItem->childCount(); i++ ) {
3064 if (parentItem->child(i)->text(0) == lo 3057 if (parentItem->child(i)->text(0) == lookForString) {
3065 parentItemList.push_back(parentItem-> 3058 parentItemList.push_back(parentItem->child(i));
3066 } 3059 }
3067 } 3060 }
3068 } 3061 }
3069 3062
3070 for (int i = 0; i < parentItemList.size(); 3063 for (int i = 0; i < parentItemList.size(); ++i) {
3071 const std::string& parentItemName = paren 3064 const std::string& parentItemName = parentItemList.at(i)->text(0).toStdString();
3072 int parentItemCopyNb = parentItemList.at( 3065 int parentItemCopyNb = parentItemList.at(i)->data(1,Qt::UserRole).toInt();
3073 int parentItemPOIndex = parentItemList.at 3066 int parentItemPOIndex = parentItemList.at(i)->data(0,Qt::UserRole).toInt();
3074 3067
3075 // if already inside 3068 // if already inside
3076 // -> return true 3069 // -> return true
3077 // special case, do not have to deal with 3070 // special case, do not have to deal with hierarchy except for PhysicalVolume
3078 3071
3079 3072
3080 /* Physical Volume AND copy number equal 3073 /* Physical Volume AND copy number equal AND name equal */
3081 if (((parentRoot == fTouchableVolumes) && 3074 if (((parentRoot == fTouchableVolumes) && (currentPVCopyNb == parentItemCopyNb)
3082 && (currentPVName == parentItemName) 3075 && (currentPVName == parentItemName)) ||
3083 /* NOT a Physical Volume AND copy nu 3076 /* NOT a Physical Volume AND copy number equal */
3084 ((parentRoot != fTouchableVolumes) && 3077 ((parentRoot != fTouchableVolumes) && (currentPVCopyNb == parentItemCopyNb)
3085 /*AND name equal AND PO index equa 3078 /*AND name equal AND PO index equal*/
3086 && (currentPVName == parentItemName) 3079 && (currentPVName == parentItemName) && (currentPVPOIndex == parentItemPOIndex) )) {
3087 3080
3088 // then check for the Transform3D 3081 // then check for the Transform3D
3089 bool sameTransform = true; 3082 bool sameTransform = true;
3090 if (parentItemPOIndex >= 0) { 3083 if (parentItemPOIndex >= 0) {
3091 const PVPath& fullPathTmp = fTreeItem 3084 const PVPath& fullPathTmp = fTreeItemModels[parentItemPOIndex];
3092 if (fullPathTmp.size() > 0) { 3085 if (fullPathTmp.size() > 0) {
3093 if (fullPathTmp.at(fullPathTmp.size 3086 if (fullPathTmp.at(fullPathTmp.size()-1).GetTransform () == pPVModel->GetTransformation ()) {
3094 sameTransform = true; 3087 sameTransform = true;
3095 } else { 3088 } else {
3096 sameTransform = false; 3089 sameTransform = false;
3097 } 3090 }
3098 } 3091 }
3099 } 3092 }
3100 3093
3101 // Same transformation, then try to cha 3094 // Same transformation, then try to change the PO index
3102 if (sameTransform == true) { 3095 if (sameTransform == true) {
3103 // already exist in the tree, is it a 3096 // already exist in the tree, is it a transparent object ?
3104 // If so, then have to change the PO 3097 // If so, then have to change the PO index ONLY if it is the last
3105 // and then change the state ONLY if 3098 // and then change the state ONLY if POIndex has change
3106 // If not, then go deaper 3099 // If not, then go deaper
3107 3100
3108 // last element 3101 // last element
3109 if (currentIndexInTreeSceneHandler == 3102 if (currentIndexInTreeSceneHandler == (fullPath.size()-1)) {
3110 3103
3111 parentItemList.at(i)->setText(2,QSt 3104 parentItemList.at(i)->setText(2,QString::number(currentPVPOIndex));
3112 parentItemList.at(i)->setData(0, Qt 3105 parentItemList.at(i)->setData(0, Qt::UserRole,currentPVPOIndex);
3113 3106
3114 fTreeItemModels.insert(std::pair <i 3107 fTreeItemModels.insert(std::pair <int, PVPath >(currentPVPOIndex,fullPath) );
3115 3108
3116 // Then remove tooltip and special 3109 // Then remove tooltip and special font
3117 QFont f = QFont(); 3110 QFont f = QFont();
3118 parentItemList.at(i)->setFont (0,f) 3111 parentItemList.at(i)->setFont (0,f);
3119 3112
3120 // set foreground 3113 // set foreground
3121 parentItemList.at(i)->setForeground 3114 parentItemList.at(i)->setForeground (0,QBrush());
3122 3115
3123 // Set a tootip 3116 // Set a tootip
3124 parentItemList.at(i)->setToolTip (0 3117 parentItemList.at(i)->setToolTip (0,"");
3125 3118
3126 changeQColorForTreeWidgetItem(paren 3119 changeQColorForTreeWidgetItem(parentItemList.at(i),QColor((int)(color.GetRed()*255),
3127 3120 (int)(color.GetGreen()*255),
3128 3121 (int)(color.GetBlue()*255),
3129 3122 (int)(color.GetAlpha()*255)));
3130 3123
3131 // set check only if there is somet 3124 // set check only if there is something to display
3132 if (color.GetAlpha() > 0) { 3125 if (color.GetAlpha() > 0) {
3133 parentItemList.at(i)->setCheckSta 3126 parentItemList.at(i)->setCheckState(0,Qt::Checked);
3134 updatePositivePoIndexSceneTreeWid 3127 updatePositivePoIndexSceneTreeWidgetQuickMap(currentPVPOIndex,parentItemList.at(i));
3135 } 3128 }
3136 return false; 3129 return false;
3137 } else { 3130 } else {
3138 subItem = parentItemList.at(i); 3131 subItem = parentItemList.at(i);
3139 } 3132 }
3140 3133
3141 // Exists but not the end of path, th 3134 // Exists but not the end of path, then forget get it
3142 } else if (currentIndexInTreeSceneHandl 3135 } else if (currentIndexInTreeSceneHandler < (fullPath.size()-1)) {
3143 subItem = parentItemList.at(i); 3136 subItem = parentItemList.at(i);
3144 } 3137 }
3145 } 3138 }
3146 3139
3147 } // end for 3140 } // end for
3148 3141
3149 // if it the last, then add it and set it c 3142 // if it the last, then add it and set it checked
3150 if (currentIndexInTreeSceneHandler == (full 3143 if (currentIndexInTreeSceneHandler == (fullPath.size()-1)) {
3151 /* subItem =*/ createTreeWidgetItem(fullP 3144 /* subItem =*/ createTreeWidgetItem(fullPath,
3152 QString(cu 3145 QString(currentPVName.c_str()),
3153 currentPVC 3146 currentPVCopyNb,
3154 currentPVP 3147 currentPVPOIndex,
3155 QString(fu 3148 QString(fullPath.at(fullPathIndex).GetPhysicalVolume()->GetLogicalVolume()->GetName().data()),
3156 Qt::Checke 3149 Qt::Checked,
3157 parentItem 3150 parentItem,
3158 color); 3151 color);
3159 3152
3160 if (currentPVPOIndex > fMaxPOindexInserte 3153 if (currentPVPOIndex > fMaxPOindexInserted) {
3161 fMaxPOindexInserted = currentPVPOIndex; 3154 fMaxPOindexInserted = currentPVPOIndex;
3162 } 3155 }
3163 3156
3164 } else { 3157 } else {
3165 3158
3166 // if no child found, then this child is 3159 // if no child found, then this child is create and marked as invisible, then go inside
3167 if (subItem == NULL) { 3160 if (subItem == NULL) {
3168 3161
3169 if (currentIndexInTreeSceneHandler < (f 3162 if (currentIndexInTreeSceneHandler < (fullPath.size()-1)) {
3170 subItem = createTreeWidgetItem(fullPa 3163 subItem = createTreeWidgetItem(fullPath,
3171 QStrin 3164 QString(currentPVName.c_str()),
3172 curren 3165 currentPVCopyNb,
3173 -1, 3166 -1,
3174 QStrin 3167 QString(fullPath.at(fullPathIndex).GetPhysicalVolume()->GetLogicalVolume()->GetName().data()),
3175 Qt::Un 3168 Qt::Unchecked,
3176 parent 3169 parentItem,
3177 color) 3170 color);
3178 } 3171 }
3179 } 3172 }
3180 3173
3181 return parseAndInsertInSceneTree(subItem, 3174 return parseAndInsertInSceneTree(subItem,pPVModel,fullPathIndex+1,parentRoot,currentIndexInTreeSceneHandler+1,currentPVPOIndex);
3182 } 3175 }
3183 return true; 3176 return true;
3184 } 3177 }
3185 3178
3186 3179
3187 void G4OpenGLQtViewer::changeOpenCloseVisible 3180 void G4OpenGLQtViewer::changeOpenCloseVisibleHiddenSelectedColorSceneTreeElement(
3188 QTreeWidgetItem* subItem 3181 QTreeWidgetItem* subItem
3189 ) 3182 )
3190 { 3183 {
3191 // Check if object with the same POIndex is 3184 // Check if object with the same POIndex is the same in old tree
3192 QTreeWidgetItem* oldItem = NULL; 3185 QTreeWidgetItem* oldItem = NULL;
3193 3186
3194 QTreeWidgetItem* foundItem = getOldTreeWidg 3187 QTreeWidgetItem* foundItem = getOldTreeWidgetItem(subItem->data(0,Qt::UserRole).toInt());
3195 3188
3196 if (foundItem != NULL) { 3189 if (foundItem != NULL) {
3197 if (isSameSceneTreeElement(foundItem,subI 3190 if (isSameSceneTreeElement(foundItem,subItem)) {
3198 oldItem = foundItem; 3191 oldItem = foundItem;
3199 } 3192 }
3200 } 3193 }
3201 if (foundItem == NULL) { // PO should have 3194 if (foundItem == NULL) { // PO should have change, parse all
3202 3195
3203 // POindex > 0 3196 // POindex > 0
3204 std::map <int, QTreeWidgetItem*>::const_i 3197 std::map <int, QTreeWidgetItem*>::const_iterator i;
3205 i = fOldPositivePoIndexSceneTreeWidgetQui 3198 i = fOldPositivePoIndexSceneTreeWidgetQuickMap.cbegin();
3206 while (i != fOldPositivePoIndexSceneTreeW 3199 while (i != fOldPositivePoIndexSceneTreeWidgetQuickMap.cend()) {
3207 if (isSameSceneTreeElement(i->second,su 3200 if (isSameSceneTreeElement(i->second,subItem)) {
3208 oldItem = i->second; 3201 oldItem = i->second;
3209 i = fOldPositivePoIndexSceneTreeWidge 3202 i = fOldPositivePoIndexSceneTreeWidgetQuickMap.cend();
3210 } else { 3203 } else {
3211 ++i; 3204 ++i;
3212 } 3205 }
3213 } 3206 }
3214 // POindex == 0 ? 3207 // POindex == 0 ?
3215 if (oldItem == NULL) { 3208 if (oldItem == NULL) {
3216 std::size_t a = 0; 3209 std::size_t a = 0;
3217 while (a < fOldNullPoIndexSceneTreeWidg 3210 while (a < fOldNullPoIndexSceneTreeWidgetQuickVector.size()) {
3218 if (isSameSceneTreeElement(fOldNullPo 3211 if (isSameSceneTreeElement(fOldNullPoIndexSceneTreeWidgetQuickVector[a],subItem)) {
3219 oldItem = fOldNullPoIndexSceneTreeW 3212 oldItem = fOldNullPoIndexSceneTreeWidgetQuickVector[a];
3220 a = fOldNullPoIndexSceneTreeWidgetQ 3213 a = fOldNullPoIndexSceneTreeWidgetQuickVector.size();
3221 } else { 3214 } else {
3222 ++a; 3215 ++a;
3223 } 3216 }
3224 } 3217 }
3225 } 3218 }
3226 } 3219 }
3227 3220
3228 // if found : retore old state 3221 // if found : retore old state
3229 if (oldItem != NULL) { 3222 if (oldItem != NULL) {
3230 subItem->setFlags(oldItem->flags()); // 3223 subItem->setFlags(oldItem->flags()); // flags
3231 subItem->setCheckState(0,oldItem->checkSt 3224 subItem->setCheckState(0,oldItem->checkState(0)); // check state
3232 subItem->setSelected(oldItem->isSelected( 3225 subItem->setSelected(oldItem->isSelected()); // selected
3233 subItem->setExpanded(oldItem->isExpanded 3226 subItem->setExpanded(oldItem->isExpanded ()); // expand
3234 3227
3235 // change color 3228 // change color
3236 // when we call this function, the color 3229 // when we call this function, the color in the item is the one of vis Attr
3237 3230
3238 std::map <int, QTreeWidgetItem* >::iterat 3231 std::map <int, QTreeWidgetItem* >::iterator it;
3239 3232
3240 // getOldPO 3233 // getOldPO
3241 int oldPOIndex = oldItem->data(0,Qt::User 3234 int oldPOIndex = oldItem->data(0,Qt::UserRole).toInt();
3242 it = fOldPositivePoIndexSceneTreeWidgetQu 3235 it = fOldPositivePoIndexSceneTreeWidgetQuickMap.find(oldPOIndex);
3243 QColor color; 3236 QColor color;
3244 3237
3245 // get old Vis Attr Color 3238 // get old Vis Attr Color
3246 std::map <int, QColor >::iterator itVis; 3239 std::map <int, QColor >::iterator itVis;
3247 itVis = fOldVisAttrColorMap.find(oldPOInd 3240 itVis = fOldVisAttrColorMap.find(oldPOIndex);
3248 3241
3249 QColor oldVisAttrColor; 3242 QColor oldVisAttrColor;
3250 const QColor& newVisAttrColor = subItem-> 3243 const QColor& newVisAttrColor = subItem->data(2,Qt::UserRole).value<QColor>();
3251 3244
3252 bool visAttrChange = false; 3245 bool visAttrChange = false;
3253 // if old vis attr color found 3246 // if old vis attr color found
3254 if (itVis != fOldVisAttrColorMap.end()) { 3247 if (itVis != fOldVisAttrColorMap.end()) {
3255 oldVisAttrColor = itVis->second; 3248 oldVisAttrColor = itVis->second;
3256 if (oldVisAttrColor != newVisAttrColor) 3249 if (oldVisAttrColor != newVisAttrColor) {
3257 visAttrChange = true; 3250 visAttrChange = true;
3258 } 3251 }
3259 } else { 3252 } else {
3260 visAttrChange = true; 3253 visAttrChange = true;
3261 } 3254 }
3262 3255
3263 if (visAttrChange) { 3256 if (visAttrChange) {
3264 fOldVisAttrColorMap.insert(std::pair <i 3257 fOldVisAttrColorMap.insert(std::pair <int, QColor > (subItem->data(0,Qt::UserRole).toInt(),newVisAttrColor) );
3265 3258
3266 } else { // if no changes, get old PO val 3259 } else { // if no changes, get old PO value
3267 // if old PO found 3260 // if old PO found
3268 if (it != fOldPositivePoIndexSceneTreeW 3261 if (it != fOldPositivePoIndexSceneTreeWidgetQuickMap.end()) {
3269 color = (it->second)->data(2,Qt::User 3262 color = (it->second)->data(2,Qt::UserRole).value<QColor>();
3270 } else { 3263 } else {
3271 color = oldItem->data(2,Qt::UserRole) 3264 color = oldItem->data(2,Qt::UserRole).value<QColor>();
3272 } 3265 }
3273 changeQColorForTreeWidgetItem(subItem,c 3266 changeQColorForTreeWidgetItem(subItem,color);
3274 } 3267 }
3275 } 3268 }
3276 3269
3277 return; 3270 return;
3278 } 3271 }
3279 3272
3280 3273
3281 3274
3282 // Check if both items are identical. 3275 // Check if both items are identical.
3283 // For that, check name, copy number, transfo 3276 // For that, check name, copy number, transformation
3284 // special case for "non Touchables", do not 3277 // special case for "non Touchables", do not check the PO index, check only the name
3285 bool G4OpenGLQtViewer::isSameSceneTreeElement 3278 bool G4OpenGLQtViewer::isSameSceneTreeElement(
3286 QTreeWidgetItem* parentOldItem 3279 QTreeWidgetItem* parentOldItem
3287 ,QTreeWidgetItem* parentNewItem 3280 ,QTreeWidgetItem* parentNewItem
3288 ) { 3281 ) {
3289 3282
3290 int newPO = -1; 3283 int newPO = -1;
3291 int oldPO = -1; 3284 int oldPO = -1;
3292 3285
3293 int newCpNumber = -1; 3286 int newCpNumber = -1;
3294 int oldCpNumber = -1; 3287 int oldCpNumber = -1;
3295 3288
3296 bool firstWhile = true; 3289 bool firstWhile = true;
3297 3290
3298 while ((parentOldItem != NULL) && (parentNe 3291 while ((parentOldItem != NULL) && (parentNewItem != NULL)) {
3299 3292
3300 // check transform, optimize getting data 3293 // check transform, optimize getting data(..,..) that consume lot of time
3301 if (!firstWhile) { 3294 if (!firstWhile) {
3302 oldPO = parentOldItem->data(0,Qt::UserR 3295 oldPO = parentOldItem->data(0,Qt::UserRole).toInt();
3303 newPO = parentNewItem->data(0,Qt::UserR 3296 newPO = parentNewItem->data(0,Qt::UserRole).toInt();
3304 } 3297 }
3305 firstWhile = false; 3298 firstWhile = false;
3306 3299
3307 if ((oldPO >= 0) && 3300 if ((oldPO >= 0) &&
3308 (newPO >= 0)) { 3301 (newPO >= 0)) {
3309 const PVPath& oldFullPath = fOldTreeIte 3302 const PVPath& oldFullPath = fOldTreeItemModels[oldPO];
3310 const PVPath& newFullPath = fTreeItemMo 3303 const PVPath& newFullPath = fTreeItemModels[newPO];
3311 if ((oldFullPath.size() > 0) && 3304 if ((oldFullPath.size() > 0) &&
3312 (newFullPath.size() > 0)) { 3305 (newFullPath.size() > 0)) {
3313 if (oldFullPath.size() != newFullPath 3306 if (oldFullPath.size() != newFullPath.size()) {
3314 return false; 3307 return false;
3315 } 3308 }
3316 if (oldFullPath.at(oldFullPath.size() 3309 if (oldFullPath.at(oldFullPath.size()-1).GetTransform () == newFullPath.at(newFullPath.size()-1).GetTransform ()) {
3317 newCpNumber = newFullPath.at(newFul 3310 newCpNumber = newFullPath.at(newFullPath.size()-1).GetCopyNo();
3318 oldCpNumber = oldFullPath.at(oldFul 3311 oldCpNumber = oldFullPath.at(oldFullPath.size()-1).GetCopyNo();
3319 // ok 3312 // ok
3320 } else { 3313 } else {
3321 return false; 3314 return false;
3322 } 3315 }
3323 } 3316 }
3324 } 3317 }
3325 3318
3326 // Check copy Number 3319 // Check copy Number
3327 if (oldCpNumber == -1) { 3320 if (oldCpNumber == -1) {
3328 oldCpNumber = parentOldItem->data(1,Qt: 3321 oldCpNumber = parentOldItem->data(1,Qt::UserRole).toInt();
3329 } 3322 }
3330 if (newCpNumber == -1) { 3323 if (newCpNumber == -1) {
3331 newCpNumber = parentNewItem->data(1,Qt: 3324 newCpNumber = parentNewItem->data(1,Qt::UserRole).toInt();
3332 } 3325 }
3333 if ((oldCpNumber != newCpNumber) || 3326 if ((oldCpNumber != newCpNumber) ||
3334 // Check name 3327 // Check name
3335 (parentOldItem->text(0) != parentNewI 3328 (parentOldItem->text(0) != parentNewItem->text(0)) ) {
3336 // try to optimize 3329 // try to optimize
3337 return false; 3330 return false;
3338 } else if ((parentOldItem->text(0) != par 3331 } else if ((parentOldItem->text(0) != parentNewItem->text(0)) || // Logical Name
3339 (parentOldItem->text(3) != par 3332 (parentOldItem->text(3) != parentNewItem->text(3))) { // Check logical name
3340 return false; 3333 return false;
3341 } else { 3334 } else {
3342 parentOldItem = parentOldItem->parent() 3335 parentOldItem = parentOldItem->parent();
3343 parentNewItem = parentNewItem->parent() 3336 parentNewItem = parentNewItem->parent();
3344 } 3337 }
3345 } // end while 3338 } // end while
3346 3339
3347 return true; 3340 return true;
3348 } 3341 }
3349 3342
3350 3343
3351 void G4OpenGLQtViewer::addNonPVSceneTreeEleme 3344 void G4OpenGLQtViewer::addNonPVSceneTreeElement(
3352 const G4String& model 3345 const G4String& model
3353 ,int currentPOIndex 3346 ,int currentPOIndex
3354 ,const std::string& modelDescription 3347 ,const std::string& modelDescription
3355 ,const G4Visible& visible 3348 ,const G4Visible& visible
3356 ) { 3349 ) {
3357 3350
3358 QString modelShortName = getModelShortName( 3351 QString modelShortName = getModelShortName(model);
3359 G4Colour color; 3352 G4Colour color;
3360 3353
3361 // Special case for text 3354 // Special case for text
3362 try { 3355 try {
3363 const G4Text& g4Text = dynamic_cast<const 3356 const G4Text& g4Text = dynamic_cast<const G4Text&>(visible);
3364 color = fSceneHandler.GetTextColour(g4Tex 3357 color = fSceneHandler.GetTextColour(g4Text);
3365 } 3358 }
3366 catch (const std::bad_cast&) { 3359 catch (const std::bad_cast&) {
3367 color = fSceneHandler.GetColour(); 3360 color = fSceneHandler.GetColour();
3368 } 3361 }
3369 3362
3370 // Special case for marker 3363 // Special case for marker
3371 try { 3364 try {
3372 const G4VMarker& g4Marker = dynamic_cast< 3365 const G4VMarker& g4Marker = dynamic_cast<const G4VMarker&>(visible);
3373 if (g4Marker.GetInfo() != "") { 3366 if (g4Marker.GetInfo() != "") {
3374 modelShortName = g4Marker.GetInfo(); 3367 modelShortName = g4Marker.GetInfo();
3375 } 3368 }
3376 } 3369 }
3377 catch (const std::bad_cast&) {} 3370 catch (const std::bad_cast&) {}
3378 3371
3379 if (modelShortName == "") { 3372 if (modelShortName == "") {
3380 return ; 3373 return ;
3381 } 3374 }
3382 // try to init it 3375 // try to init it
3383 if (fSceneTreeComponentTreeWidget == NULL) 3376 if (fSceneTreeComponentTreeWidget == NULL) {
3384 createSceneTreeComponent(); 3377 createSceneTreeComponent();
3385 } 3378 }
3386 3379
3387 // if no UI 3380 // if no UI
3388 if (fSceneTreeComponentTreeWidget == NULL) 3381 if (fSceneTreeComponentTreeWidget == NULL) {
3389 return; 3382 return;
3390 } 3383 }
3391 3384
3392 fSceneTreeComponentTreeWidget->blockSignals 3385 fSceneTreeComponentTreeWidget->blockSignals(true);
3393 3386
3394 // Create the "Model" node if not 3387 // Create the "Model" node if not
3395 3388
3396 QList<QTreeWidgetItem *> resItem; 3389 QList<QTreeWidgetItem *> resItem;
3397 resItem = fSceneTreeComponentTreeWidget->f 3390 resItem = fSceneTreeComponentTreeWidget->findItems (modelShortName, Qt::MatchExactly, 0 );
3398 QTreeWidgetItem * currentItem = NULL; 3391 QTreeWidgetItem * currentItem = NULL;
3399 const PVPath tmpFullPath; 3392 const PVPath tmpFullPath;
3400 3393
3401 if (resItem.empty()) { 3394 if (resItem.empty()) {
3402 currentItem = createTreeWidgetItem(tmpFul 3395 currentItem = createTreeWidgetItem(tmpFullPath,
3403 modelS 3396 modelShortName,
3404 0, // 3397 0, // currentPVCopyNb
3405 -1, // 3398 -1, // currentPVPOIndex
3406 "", 3399 "",
3407 Qt::Ch 3400 Qt::Checked,
3408 NULL, 3401 NULL,
3409 color) 3402 color);
3410 } else { 3403 } else {
3411 currentItem = resItem.first(); 3404 currentItem = resItem.first();
3412 } 3405 }
3413 3406
3414 // Is this volume already in the tree AND P 3407 // Is this volume already in the tree AND PO is not the same?
3415 const QList<QTreeWidgetItem *>& 3408 const QList<QTreeWidgetItem *>&
3416 resItems = fSceneTreeComponentTreeWidget-> 3409 resItems = fSceneTreeComponentTreeWidget->findItems (QString(modelDescription.c_str()), Qt::MatchFixedString| Qt::MatchCaseSensitive|Qt::MatchRecursive, 0 );
3417 3410
3418 bool alreadyPresent = false; 3411 bool alreadyPresent = false;
3419 for (int i = 0; i < resItems.size(); ++i) { 3412 for (int i = 0; i < resItems.size(); ++i) {
3420 if (currentPOIndex == resItems.at(i)->dat 3413 if (currentPOIndex == resItems.at(i)->data(0,Qt::UserRole).toInt()) {
3421 alreadyPresent = true; 3414 alreadyPresent = true;
3422 } 3415 }
3423 } 3416 }
3424 if (!alreadyPresent) { 3417 if (!alreadyPresent) {
3425 createTreeWidgetItem(tmpFullPath, 3418 createTreeWidgetItem(tmpFullPath,
3426 modelShortName, 3419 modelShortName,
3427 0, // currentPVCopyN 3420 0, // currentPVCopyNb
3428 currentPOIndex, 3421 currentPOIndex,
3429 "", 3422 "",
3430 Qt::Checked, 3423 Qt::Checked,
3431 currentItem, 3424 currentItem,
3432 color); 3425 color);
3433 } 3426 }
3434 fSceneTreeComponentTreeWidget->blockSignals 3427 fSceneTreeComponentTreeWidget->blockSignals(false);
3435 3428
3436 } 3429 }
3437 3430
3438 3431
3439 /** 3432 /**
3440 Get the short name for a given label 3433 Get the short name for a given label
3441 */ 3434 */
3442 QString G4OpenGLQtViewer::getModelShortName(c 3435 QString G4OpenGLQtViewer::getModelShortName(const G4String& model) {
3443 3436
3444 QString modelShortName = model.data(); 3437 QString modelShortName = model.data();
3445 if (modelShortName.mid(0,modelShortName.ind 3438 if (modelShortName.mid(0,modelShortName.indexOf(" ")) == "G4PhysicalVolumeModel") {
3446 modelShortName = fTouchableVolumes; 3439 modelShortName = fTouchableVolumes;
3447 } else { 3440 } else {
3448 if (modelShortName.mid(0,2) == "G4") { 3441 if (modelShortName.mid(0,2) == "G4") {
3449 modelShortName = modelShortName.mid(2); 3442 modelShortName = modelShortName.mid(2);
3450 } 3443 }
3451 if (modelShortName.indexOf("Model") != -1 3444 if (modelShortName.indexOf("Model") != -1) {
3452 modelShortName = modelShortName.mid(0,m 3445 modelShortName = modelShortName.mid(0,modelShortName.indexOf("Model"));
3453 } 3446 }
3454 } 3447 }
3455 return modelShortName; 3448 return modelShortName;
3456 } 3449 }
3457 3450
3458 3451
3459 3452
3460 bool G4OpenGLQtViewer::isTouchableVisible(int 3453 bool G4OpenGLQtViewer::isTouchableVisible(int POindex){
3461 3454
3462 // If no scene tree (Immediate viewer) 3455 // If no scene tree (Immediate viewer)
3463 if (fSceneTreeComponentTreeWidget == NULL) 3456 if (fSceneTreeComponentTreeWidget == NULL) {
3464 return false; 3457 return false;
3465 } 3458 }
3466 3459
3467 // should be the next one 3460 // should be the next one
3468 // Prevent to get out the std::map 3461 // Prevent to get out the std::map
3469 if (fLastSceneTreeWidgetAskForIterator != f 3462 if (fLastSceneTreeWidgetAskForIterator != fLastSceneTreeWidgetAskForIteratorEnd) {
3470 fLastSceneTreeWidgetAskForIterator++; 3463 fLastSceneTreeWidgetAskForIterator++;
3471 } 3464 }
3472 QTreeWidgetItem* item = getTreeWidgetItem(P 3465 QTreeWidgetItem* item = getTreeWidgetItem(POindex);
3473 3466
3474 if (item != NULL) { 3467 if (item != NULL) {
3475 if ( item->checkState(0) == Qt::Checked) 3468 if ( item->checkState(0) == Qt::Checked) {
3476 return true; 3469 return true;
3477 } 3470 }
3478 } 3471 }
3479 return false; 3472 return false;
3480 } 3473 }
3481 3474
3482 3475
3483 bool G4OpenGLQtViewer::parseAndCheckVisibilit 3476 bool G4OpenGLQtViewer::parseAndCheckVisibility(QTreeWidgetItem * treeNode,int POindex){
3484 bool isFound = false; 3477 bool isFound = false;
3485 for (int i = 0; i < treeNode->childCount() 3478 for (int i = 0; i < treeNode->childCount() ; ++i) {
3486 3479
3487 if (treeNode->child(i)->data(0,Qt::UserRo 3480 if (treeNode->child(i)->data(0,Qt::UserRole).toInt() == POindex) {
3488 if (treeNode->child(i)->checkState(0) = 3481 if (treeNode->child(i)->checkState(0) == Qt::Checked) {
3489 return true; 3482 return true;
3490 } 3483 }
3491 } 3484 }
3492 isFound = parseAndCheckVisibility(treeNod 3485 isFound = parseAndCheckVisibility(treeNode->child(i),POindex);
3493 if (isFound) { 3486 if (isFound) {
3494 return true; 3487 return true;
3495 } 3488 }
3496 } // end for 3489 } // end for
3497 return false; 3490 return false;
3498 } 3491 }
3499 3492
3500 3493
3501 std::string G4OpenGLQtViewer::parseSceneTreeA 3494 std::string G4OpenGLQtViewer::parseSceneTreeAndSaveState(){
3502 std::string commandLine = ""; 3495 std::string commandLine = "";
3503 for (int b=0;b<fSceneTreeComponentTreeWidge 3496 for (int b=0;b<fSceneTreeComponentTreeWidget->topLevelItemCount();b++) {
3504 commandLine += parseSceneTreeElementAndSa 3497 commandLine += parseSceneTreeElementAndSaveState(fSceneTreeComponentTreeWidget->topLevelItem(b),1)+"\n";
3505 } 3498 }
3506 if (commandLine != "") { 3499 if (commandLine != "") {
3507 commandLine = std::string("# Disable auto 3500 commandLine = std::string("# Disable auto refresh and quieten vis messages whilst scene and\n") +
3508 "# trajectories are established:\n" + 3501 "# trajectories are established:\n" +
3509 "/vis/viewer/set/autoRefresh false\n" + 3502 "/vis/viewer/set/autoRefresh false\n" +
3510 "/vis/verbose errors" + 3503 "/vis/verbose errors" +
3511 commandLine + 3504 commandLine +
3512 "# Re-establish auto refreshing and verbo 3505 "# Re-establish auto refreshing and verbosity:\n" +
3513 "/vis/viewer/set/autoRefresh true\n" + 3506 "/vis/viewer/set/autoRefresh true\n" +
3514 "/vis/verbose confirmations\n"; 3507 "/vis/verbose confirmations\n";
3515 } 3508 }
3516 return commandLine; 3509 return commandLine;
3517 } 3510 }
3518 3511
3519 3512
3520 std::string G4OpenGLQtViewer::parseSceneTreeE 3513 std::string G4OpenGLQtViewer::parseSceneTreeElementAndSaveState(QTreeWidgetItem* item, unsigned int level){
3521 // parse current item 3514 // parse current item
3522 std::string str( level, ' ' ); 3515 std::string str( level, ' ' );
3523 std::string commandLine = "\n#"+ str + "PV 3516 std::string commandLine = "\n#"+ str + "PV Name: " + item->text(0).toStdString();
3524 3517
3525 if (item->text(3) != "") { 3518 if (item->text(3) != "") {
3526 commandLine += " LV Name: "+item->text(3) 3519 commandLine += " LV Name: "+item->text(3).toStdString()+"\n";
3527 // save check state 3520 // save check state
3528 commandLine += "/vis/geometry/set/visibil 3521 commandLine += "/vis/geometry/set/visibility " + item->text(3).toStdString() + " ! "; // let default value for depth
3529 if (item->checkState(0) == Qt::Checked) { 3522 if (item->checkState(0) == Qt::Checked) {
3530 commandLine += "1"; 3523 commandLine += "1";
3531 } 3524 }
3532 if (item->checkState(0) == Qt::Unchecked) 3525 if (item->checkState(0) == Qt::Unchecked) {
3533 commandLine += "0"; 3526 commandLine += "0";
3534 } 3527 }
3535 commandLine +="\n"; 3528 commandLine +="\n";
3536 3529
3537 // save color 3530 // save color
3538 const QColor& c = item->data(2,Qt::UserRo 3531 const QColor& c = item->data(2,Qt::UserRole).value<QColor>();
3539 std::stringstream red; 3532 std::stringstream red;
3540 red << ((double)c.red())/255; 3533 red << ((double)c.red())/255;
3541 std::stringstream green; 3534 std::stringstream green;
3542 green << (double)c.green()/255; 3535 green << (double)c.green()/255;
3543 std::stringstream blue; 3536 std::stringstream blue;
3544 blue << ((double)c.blue())/255; 3537 blue << ((double)c.blue())/255;
3545 std::stringstream alpha; 3538 std::stringstream alpha;
3546 alpha << ((double)c.alpha())/255; 3539 alpha << ((double)c.alpha())/255;
3547 3540
3548 commandLine += "/vis/geometry/set/colour 3541 commandLine += "/vis/geometry/set/colour " + item->text(3).toStdString() + " ! " + red.str() + " " + green.str() + " " + blue.str() + " " + alpha.str()+"\n";
3549 3542
3550 } else { 3543 } else {
3551 commandLine += "\n"; 3544 commandLine += "\n";
3552 } 3545 }
3553 3546
3554 // parse childs 3547 // parse childs
3555 for (int b=0;b< item->childCount();b++) { 3548 for (int b=0;b< item->childCount();b++) {
3556 commandLine += parseSceneTreeElementAndSa 3549 commandLine += parseSceneTreeElementAndSaveState(item->child(b),level+1);
3557 } 3550 }
3558 3551
3559 return commandLine; 3552 return commandLine;
3560 } 3553 }
3561 3554
3562 3555
3563 void G4OpenGLQtViewer::sceneTreeComponentItem 3556 void G4OpenGLQtViewer::sceneTreeComponentItemChanged(QTreeWidgetItem* item, int) {
3564 3557
3565 if (fCheckSceneTreeComponentSignalLock == f 3558 if (fCheckSceneTreeComponentSignalLock == false) {
3566 fCheckSceneTreeComponentSignalLock = true 3559 fCheckSceneTreeComponentSignalLock = true;
3567 G4bool checked = false; 3560 G4bool checked = false;
3568 if (item->checkState(0) == Qt::Checked) { 3561 if (item->checkState(0) == Qt::Checked) {
3569 checked = true; 3562 checked = true;
3570 } 3563 }
3571 setCheckComponent(item,checked); 3564 setCheckComponent(item,checked);
3572 updateQWidget(); 3565 updateQWidget();
3573 3566
3574 fCheckSceneTreeComponentSignalLock = fals 3567 fCheckSceneTreeComponentSignalLock = false;
3575 } 3568 }
3576 } 3569 }
3577 3570
3578 3571
3579 void G4OpenGLQtViewer::sceneTreeComponentSele 3572 void G4OpenGLQtViewer::sceneTreeComponentSelected() {
3580 } 3573 }
3581 3574
3582 void G4OpenGLQtViewer::changeDepthInSceneTree 3575 void G4OpenGLQtViewer::changeDepthInSceneTree (int val){
3583 3576
3584 // If no scene tree (Immediate viewer) 3577 // If no scene tree (Immediate viewer)
3585 if (fSceneTreeComponentTreeWidget == NULL) 3578 if (fSceneTreeComponentTreeWidget == NULL) {
3586 return; 3579 return;
3587 } 3580 }
3588 3581
3589 // max depth : fSceneTreeDepth 3582 // max depth : fSceneTreeDepth
3590 // val is between 0 and 1 3583 // val is between 0 and 1
3591 // 0 .1 .2 .3 .4 .5 .6 .7 .8 .9 1 3584 // 0 .1 .2 .3 .4 .5 .6 .7 .8 .9 1
3592 // 1 1.4 2 3585 // 1 1.4 2
3593 // 1 2 3 4 3586 // 1 2 3 4
3594 3587
3595 // Get the depth : 3588 // Get the depth :
3596 double depth = 1 + ((double)val)/1000 * ((d 3589 double depth = 1 + ((double)val)/1000 * ((double)fSceneTreeDepth+1);
3597 3590
3598 // lock update on scene tree items 3591 // lock update on scene tree items
3599 fCheckSceneTreeComponentSignalLock = true; 3592 fCheckSceneTreeComponentSignalLock = true;
3600 3593
3601 // Disable redraw each time ! 3594 // Disable redraw each time !
3602 G4bool currentAutoRefresh = fVP.IsAutoRefre 3595 G4bool currentAutoRefresh = fVP.IsAutoRefresh();
3603 fVP.SetAutoRefresh(false); 3596 fVP.SetAutoRefresh(false);
3604 3597
3605 for (int b=0;b<fSceneTreeComponentTreeWidge 3598 for (int b=0;b<fSceneTreeComponentTreeWidget->topLevelItemCount();b++) {
3606 changeDepthOnSceneTreeItem(depth,1.,fScen 3599 changeDepthOnSceneTreeItem(depth,1.,fSceneTreeComponentTreeWidget->topLevelItem(b));
3607 } 3600 }
3608 3601
3609 // Enable redraw ! 3602 // Enable redraw !
3610 fVP.SetAutoRefresh(currentAutoRefresh); 3603 fVP.SetAutoRefresh(currentAutoRefresh);
3611 updateQWidget(); 3604 updateQWidget();
3612 3605
3613 // unlock update on scene tree items 3606 // unlock update on scene tree items
3614 fCheckSceneTreeComponentSignalLock = false; 3607 fCheckSceneTreeComponentSignalLock = false;
3615 3608
3616 } 3609 }
3617 3610
3618 3611
3619 void G4OpenGLQtViewer::changeColorAndTranspar 3612 void G4OpenGLQtViewer::changeColorAndTransparency(QTreeWidgetItem* item,int) {
3620 3613
3621 if (item == NULL) { 3614 if (item == NULL) {
3622 return; 3615 return;
3623 } 3616 }
3624 const QColor& old = QColor(item->data(2,Qt: 3617 const QColor& old = QColor(item->data(2,Qt::UserRole).value<QColor>());
3625 3618
>> 3619 #if QT_VERSION < 0x040500
>> 3620 bool a;
>> 3621 const QColor& color = QColor(QColorDialog::getRgba (old.rgba(),&a,fSceneTreeComponentTreeWidget));
>> 3622 #else
3626 const QColor& color = QColorDialog::getColo 3623 const QColor& color = QColorDialog::getColor(old,
3627 fScen 3624 fSceneTreeComponentTreeWidget,
3628 " Get 3625 " Get color and transparency",
3629 QColo 3626 QColorDialog::ShowAlphaChannel);
>> 3627 #endif
3630 3628
3631 if (color.isValid()) { 3629 if (color.isValid()) {
3632 3630
3633 changeColorAndTransparency(item->data(0,Q 3631 changeColorAndTransparency(item->data(0,Qt::UserRole).toInt(),
3634 G4Colour (((G4 3632 G4Colour (((G4double)color.red())/255,
3635 ((G4 3633 ((G4double)color.green())/255,
3636 ((G4 3634 ((G4double)color.blue())/255,
3637 ((G4 3635 ((G4double)color.alpha())/255));
3638 3636
3639 // set scene tree parameters 3637 // set scene tree parameters
3640 changeQColorForTreeWidgetItem(item,color) 3638 changeQColorForTreeWidgetItem(item,color);
3641 } 3639 }
3642 } 3640 }
3643 3641
3644 3642
3645 void G4OpenGLQtViewer::changeColorAndTranspar 3643 void G4OpenGLQtViewer::changeColorAndTransparency(GLuint index, G4Color color) {
3646 3644
3647 // change vis attributes to set new colour 3645 // change vis attributes to set new colour
3648 G4int iPO = index; 3646 G4int iPO = index;
3649 if (iPO >= 0 && fTreeItemModels.find(iPO) ! 3647 if (iPO >= 0 && fTreeItemModels.find(iPO) != fTreeItemModels.end()) {
3650 const PVPath& fullPath = fTreeItemModels[ 3648 const PVPath& fullPath = fTreeItemModels[iPO];
3651 // If a physical volume 3649 // If a physical volume
3652 if (fullPath.size()) { 3650 if (fullPath.size()) {
3653 SetTouchable(fullPath); 3651 SetTouchable(fullPath);
3654 TouchableSetColour(fullPath, color); 3652 TouchableSetColour(fullPath, color);
3655 fMouseOnSceneTree = true; 3653 fMouseOnSceneTree = true;
3656 } 3654 }
3657 } 3655 }
3658 } 3656 }
3659 3657
3660 3658
3661 G4Colour G4OpenGLQtViewer::getColorForPoIndex 3659 G4Colour G4OpenGLQtViewer::getColorForPoIndex(int poIndex) {
3662 // FIXME 09/2014 : Could be optimize by sea 3660 // FIXME 09/2014 : Could be optimize by searching in a tab instead of item->data
3663 QTreeWidgetItem* item = getTreeWidgetItem(p 3661 QTreeWidgetItem* item = getTreeWidgetItem(poIndex);
3664 3662
3665 if (item != NULL) { 3663 if (item != NULL) {
3666 3664
3667 const QColor& color = item->data(2,Qt::Us 3665 const QColor& color = item->data(2,Qt::UserRole).value<QColor>();
3668 G4Colour g4c(((G4double)color.red())/255, 3666 G4Colour g4c(((G4double)color.red())/255,
3669 ((G4double)color.green())/25 3667 ((G4double)color.green())/255,
3670 ((G4double)color.blue())/255 3668 ((G4double)color.blue())/255,
3671 ((G4double)color.alpha())/25 3669 ((G4double)color.alpha())/255);
3672 3670
3673 return g4c; 3671 return g4c;
3674 } 3672 }
3675 return G4Colour(); 3673 return G4Colour();
3676 } 3674 }
3677 3675
3678 3676
3679 const std::vector<G4ModelingParameters::VisAt 3677 const std::vector<G4ModelingParameters::VisAttributesModifier>*
3680 G4OpenGLQtViewer::GetPrivateVisAttributesModi 3678 G4OpenGLQtViewer::GetPrivateVisAttributesModifiers() const
3681 { 3679 {
3682 static std::vector<G4ModelingParameters::Vi 3680 static std::vector<G4ModelingParameters::VisAttributesModifier>
3683 privateVisAttributesModifiers; 3681 privateVisAttributesModifiers;
3684 3682
3685 privateVisAttributesModifiers.clear(); 3683 privateVisAttributesModifiers.clear();
3686 3684
3687 // I don't think we need this. (JA Sep 2016) 3685 // I don't think we need this. (JA Sep 2016).
3688 // // For each modified touchable... 3686 // // For each modified touchable...
3689 // std::map<int,PVPath>::const_iterator i; 3687 // std::map<int,PVPath>::const_iterator i;
3690 // for (i = fTreeItemModels.begin(); 3688 // for (i = fTreeItemModels.begin();
3691 // i != fTreeItemModels.end(); 3689 // i != fTreeItemModels.end();
3692 // ++i) { 3690 // ++i) {
3693 // 3691 //
3694 // // How do I know if it's been modified 3692 // // How do I know if it's been modified or not?
3695 // 3693 //
3696 // int iPO = i->first; 3694 // int iPO = i->first;
3697 // const PVPath& fullPath = i->second; 3695 // const PVPath& fullPath = i->second;
3698 // 3696 //
3699 // // If a physical volume 3697 // // If a physical volume
3700 // if (fullPath.size()) { 3698 // if (fullPath.size()) {
3701 // 3699 //
3702 // // const G4bool& visibilityChanged 3700 // // const G4bool& visibilityChanged = ???
3703 // // const G4bool& visibility = ??? 3701 // // const G4bool& visibility = ???
3704 // // const G4bool& colourChanged = ? 3702 // // const G4bool& colourChanged = ???
3705 // // const QColor& colour = ??? 3703 // // const QColor& colour = ???
3706 // // G4Colour g4colour(((G4double)co 3704 // // G4Colour g4colour(((G4double)colour.red())/255,
3707 // // ((G4double)co 3705 // // ((G4double)colour.green())/255,
3708 // // ((G4double)co 3706 // // ((G4double)colour.blue())/255,
3709 // // ((G4double)co 3707 // // ((G4double)colour.alpha())/255);
3710 // // Next 4 lines are for testing, to b 3708 // // Next 4 lines are for testing, to be replaced by the above...
3711 // G4bool visibilityChanged = true; 3709 // G4bool visibilityChanged = true;
3712 // G4bool visibility = true; 3710 // G4bool visibility = true;
3713 // G4bool colourChanged = true; 3711 // G4bool colourChanged = true;
3714 // G4Colour g4colour(G4Colour::Red()); 3712 // G4Colour g4colour(G4Colour::Red());
3715 // 3713 //
3716 // // Instantiate a working copy of a G4 3714 // // Instantiate a working copy of a G4VisAttributes object...
3717 // G4VisAttributes workingVisAtts; 3715 // G4VisAttributes workingVisAtts;
3718 // // ...and use it to create vis attrib 3716 // // ...and use it to create vis attribute modifiers...
3719 // if (visibilityChanged) { 3717 // if (visibilityChanged) {
3720 // workingVisAtts.SetVisibility(visibi 3718 // workingVisAtts.SetVisibility(visibility);
3721 // privateVisAttributesModifiers.push_ 3719 // privateVisAttributesModifiers.push_back
3722 // (G4ModelingParameters::VisAttribute 3720 // (G4ModelingParameters::VisAttributesModifier
3723 // (workingVisAtts, 3721 // (workingVisAtts,
3724 // G4ModelingParameters::VASVisibili 3722 // G4ModelingParameters::VASVisibility,
3725 // fullPath)); 3723 // fullPath));
3726 // } 3724 // }
3727 // if (colourChanged) { 3725 // if (colourChanged) {
3728 // workingVisAtts.SetColour(g4colour); 3726 // workingVisAtts.SetColour(g4colour);
3729 // privateVisAttributesModifiers.push_ 3727 // privateVisAttributesModifiers.push_back
3730 // (G4ModelingParameters::VisAttribute 3728 // (G4ModelingParameters::VisAttributesModifier
3731 // (workingVisAtts, 3729 // (workingVisAtts,
3732 // G4ModelingParameters::VASColour, 3730 // G4ModelingParameters::VASColour,
3733 // fullPath)); 3731 // fullPath));
3734 // } 3732 // }
3735 // } 3733 // }
3736 // } 3734 // }
3737 3735
3738 return &privateVisAttributesModifiers; 3736 return &privateVisAttributesModifiers;
3739 } 3737 }
3740 3738
3741 3739
3742 void G4OpenGLQtViewer::changeSearchSelection( 3740 void G4OpenGLQtViewer::changeSearchSelection()
3743 { 3741 {
3744 const QString& searchText = fFilterOutput-> 3742 const QString& searchText = fFilterOutput->text();
3745 if (fSceneTreeComponentTreeWidget == NULL) 3743 if (fSceneTreeComponentTreeWidget == NULL) {
3746 return; 3744 return;
3747 } 3745 }
3748 3746
3749 // unselect all 3747 // unselect all
3750 for (int a=0; a<fSceneTreeComponentTreeWidg 3748 for (int a=0; a<fSceneTreeComponentTreeWidget->topLevelItemCount(); a++) {
3751 fSceneTreeComponentTreeWidget->topLevelIt 3749 fSceneTreeComponentTreeWidget->topLevelItem(a)->setExpanded(false);
3752 fSceneTreeComponentTreeWidget->topLevelIt 3750 fSceneTreeComponentTreeWidget->topLevelItem(a)->setSelected(false);
3753 clearSceneTreeSelection(fSceneTreeCompone 3751 clearSceneTreeSelection(fSceneTreeComponentTreeWidget->topLevelItem(a));
3754 } 3752 }
3755 3753
3756 QList<QTreeWidgetItem *> itemList = fSceneT 3754 QList<QTreeWidgetItem *> itemList = fSceneTreeComponentTreeWidget->findItems (searchText,Qt::MatchContains | Qt::MatchRecursive,0);
3757 3755
3758 for (int i = 0; i < itemList.size(); ++i) { 3756 for (int i = 0; i < itemList.size(); ++i) {
3759 QTreeWidgetItem* expandParentItem = itemL 3757 QTreeWidgetItem* expandParentItem = itemList.at(i);
3760 while (expandParentItem->parent() != NULL 3758 while (expandParentItem->parent() != NULL) {
3761 expandParentItem->parent()->setExpanded 3759 expandParentItem->parent()->setExpanded(true);
3762 expandParentItem = expandParentItem->pa 3760 expandParentItem = expandParentItem->parent();
3763 } 3761 }
3764 itemList.at(i)->setSelected(true); 3762 itemList.at(i)->setSelected(true);
3765 } 3763 }
3766 3764
3767 } 3765 }
3768 3766
3769 3767
3770 void G4OpenGLQtViewer::clearSceneTreeSelectio 3768 void G4OpenGLQtViewer::clearSceneTreeSelection(QTreeWidgetItem* item) {
3771 for (int a=0; a<item->childCount(); a++) { 3769 for (int a=0; a<item->childCount(); a++) {
3772 item->child(a)->setSelected(false); 3770 item->child(a)->setSelected(false);
3773 item->child(a)->setExpanded(false); 3771 item->child(a)->setExpanded(false);
3774 clearSceneTreeSelection(item->child(a)); 3772 clearSceneTreeSelection(item->child(a));
3775 } 3773 }
3776 3774
3777 } 3775 }
3778 3776
3779 3777
3780 bool G4OpenGLQtViewer::isPVVolume(QTreeWidget 3778 bool G4OpenGLQtViewer::isPVVolume(QTreeWidgetItem* item) {
3781 QTreeWidgetItem* sParent = item; 3779 QTreeWidgetItem* sParent = item;
3782 while (sParent->parent() != NULL) { 3780 while (sParent->parent() != NULL) {
3783 sParent = sParent->parent(); 3781 sParent = sParent->parent();
3784 } 3782 }
3785 if (sParent->text(0) != fTouchableVolumes) 3783 if (sParent->text(0) != fTouchableVolumes) {
3786 return false; 3784 return false;
3787 } 3785 }
3788 // item is the "Touchable" node 3786 // item is the "Touchable" node
3789 if (item->text(0) == fTouchableVolumes) { 3787 if (item->text(0) == fTouchableVolumes) {
3790 return false; 3788 return false;
3791 } 3789 }
3792 return true; 3790 return true;
3793 } 3791 }
3794 3792
3795 3793
3796 void G4OpenGLQtViewer::changeDepthOnSceneTree 3794 void G4OpenGLQtViewer::changeDepthOnSceneTreeItem(
3797 double lookForDepth 3795 double lookForDepth
3798 ,double currentDepth 3796 ,double currentDepth
3799 ,QTreeWidgetItem* item 3797 ,QTreeWidgetItem* item
3800 ) { 3798 ) {
3801 double transparencyLevel = 0.; 3799 double transparencyLevel = 0.;
3802 3800
3803 // look for a 2.2 depth and we are at level 3801 // look for a 2.2 depth and we are at level 3
3804 // -> Set all theses items to Opaque 3802 // -> Set all theses items to Opaque
3805 // ONLY if it is a PV volume ! 3803 // ONLY if it is a PV volume !
3806 if (isPVVolume(item)) { 3804 if (isPVVolume(item)) {
3807 if ((lookForDepth-currentDepth) < 0) { 3805 if ((lookForDepth-currentDepth) < 0) {
3808 item->setCheckState(0,Qt::Checked); 3806 item->setCheckState(0,Qt::Checked);
3809 updatePositivePoIndexSceneTreeWidgetQui 3807 updatePositivePoIndexSceneTreeWidgetQuickMap(item->data(0,Qt::UserRole).toInt(),item);
3810 transparencyLevel = 1; 3808 transparencyLevel = 1;
3811 } else if ((lookForDepth-currentDepth) > 3809 } else if ((lookForDepth-currentDepth) > 1 ){
3812 item->setCheckState(0,Qt::Unchecked); 3810 item->setCheckState(0,Qt::Unchecked);
3813 updatePositivePoIndexSceneTreeWidgetQui 3811 updatePositivePoIndexSceneTreeWidgetQuickMap(item->data(0,Qt::UserRole).toInt(),item);
3814 transparencyLevel = 0; 3812 transparencyLevel = 0;
3815 } else { 3813 } else {
3816 item->setCheckState(0,Qt::Checked); 3814 item->setCheckState(0,Qt::Checked);
3817 updatePositivePoIndexSceneTreeWidgetQui 3815 updatePositivePoIndexSceneTreeWidgetQuickMap(item->data(0,Qt::UserRole).toInt(),item);
3818 transparencyLevel = 1-(lookForDepth-cur 3816 transparencyLevel = 1-(lookForDepth-currentDepth);
3819 } 3817 }
3820 } 3818 }
3821 3819
3822 if (item->data(0,Qt::UserRole).toInt() >= 0 3820 if (item->data(0,Qt::UserRole).toInt() >= 0) {
3823 const G4Colour& color = getColorForPoInde 3821 const G4Colour& color = getColorForPoIndex(item->data(0,Qt::UserRole).toInt());
3824 3822
3825 // We are less depper (ex:tree depth:2) t 3823 // We are less depper (ex:tree depth:2) than lookForDepth (ex:3.1)
3826 // -> Have to hide this level ONLY if it 3824 // -> Have to hide this level ONLY if it was not hidden before
3827 3825
3828 // Not on a top level item case 3826 // Not on a top level item case
3829 // Do not set if it was already set 3827 // Do not set if it was already set
3830 3828
3831 // Should add them all the time in case o 3829 // Should add them all the time in case of an older command has change transparency
3832 // before. Should be checked in changeDep 3830 // before. Should be checked in changeDepthInSceneTree for duplicated commands
3833 // Do not change transparency if not visi 3831 // Do not change transparency if not visible by humain (and avoid precision value
3834 // problems..) 3832 // problems..)
3835 if (((color.GetAlpha()-transparencyLevel) 3833 if (((color.GetAlpha()-transparencyLevel) > 0.000001) ||
3836 ((color.GetAlpha()-transparencyLevel) 3834 ((color.GetAlpha()-transparencyLevel) < -0.000001)) {
3837 if ((item->text(3) != "")) { 3835 if ((item->text(3) != "")) {
3838 // FIXME : Should not test this here 3836 // FIXME : Should not test this here because of transparent
3839 // volume that will came after and wi 3837 // volume that will came after and with a different alpha level
3840 // Good thing to do is to check and s 3838 // Good thing to do is to check and suppress doubles in changeDepthInSceneTree
3841 // and then check if last (transparen 3839 // and then check if last (transparents volumes) has to change alpha
3842 3840
3843 changeQColorForTreeWidgetItem(item,QC 3841 changeQColorForTreeWidgetItem(item,QColor((int)(color.GetRed()*255),
3844 3842 (int)(color.GetGreen()*255),
3845 3843 (int)(color.GetBlue()*255),
3846 3844 (int)(transparencyLevel*255)));
3847 } 3845 }
3848 } 3846 }
3849 } 3847 }
3850 3848
3851 for (int b=0;b< item->childCount();b++) { 3849 for (int b=0;b< item->childCount();b++) {
3852 changeDepthOnSceneTreeItem(lookForDepth,c 3850 changeDepthOnSceneTreeItem(lookForDepth,currentDepth+1,item->child(b));
3853 } 3851 }
3854 } 3852 }
3855 3853
3856 3854
3857 void G4OpenGLQtViewer::clearTreeWidget(){ 3855 void G4OpenGLQtViewer::clearTreeWidget(){
3858 // be careful about calling this twice 3856 // be careful about calling this twice
3859 3857
3860 if (fSceneTreeComponentTreeWidget) { 3858 if (fSceneTreeComponentTreeWidget) {
3861 3859
3862 if (fSceneTreeComponentTreeWidget->topLev 3860 if (fSceneTreeComponentTreeWidget->topLevelItemCount () > 0) {
3863 3861
3864 fPVRootNodeCreate = false; 3862 fPVRootNodeCreate = false;
3865 3863
3866 // reset all old 3864 // reset all old
3867 fOldPositivePoIndexSceneTreeWidgetQuick 3865 fOldPositivePoIndexSceneTreeWidgetQuickMap.clear();
3868 fOldNullPoIndexSceneTreeWidgetQuickVect 3866 fOldNullPoIndexSceneTreeWidgetQuickVector.clear();
3869 fOldTreeItemModels.clear(); 3867 fOldTreeItemModels.clear();
3870 3868
3871 // Clone everything 3869 // Clone everything
3872 for (int b =0; b <fSceneTreeComponentTr 3870 for (int b =0; b <fSceneTreeComponentTreeWidget->topLevelItemCount();b++) {
3873 // All tree widgets are in : 3871 // All tree widgets are in :
3874 // then we could get the old POindex 3872 // then we could get the old POindex and get
3875 // .visible/Hidden 3873 // .visible/Hidden
3876 // .Check/Uncheck 3874 // .Check/Uncheck
3877 // .selected 3875 // .selected
3878 // .colour status from std::map 3876 // .colour status from std::map
3879 3877
3880 // clone top level items 3878 // clone top level items
3881 int poIndex = fSceneTreeComponentTree 3879 int poIndex = fSceneTreeComponentTreeWidget->topLevelItem(b)->data(0,Qt::UserRole).toInt();
3882 if (poIndex != -1) { 3880 if (poIndex != -1) {
3883 fOldPositivePoIndexSceneTreeWidgetQ 3881 fOldPositivePoIndexSceneTreeWidgetQuickMap.insert(std::pair <int, QTreeWidgetItem*> (poIndex,cloneWidgetItem(fSceneTreeComponentTreeWidget->topLevelItem(b))));
3884 } else { 3882 } else {
3885 fOldNullPoIndexSceneTreeWidgetQuick 3883 fOldNullPoIndexSceneTreeWidgetQuickVector.push_back(cloneWidgetItem(fSceneTreeComponentTreeWidget->topLevelItem(b)));
3886 } 3884 }
3887 3885
3888 // clone leaves 3886 // clone leaves
3889 cloneSceneTree(fSceneTreeComponentTre 3887 cloneSceneTree(fSceneTreeComponentTreeWidget->topLevelItem(b));
3890 } 3888 }
3891 // delete all elements 3889 // delete all elements
3892 3890
3893 fOldTreeItemModels.insert(fTreeItemMode 3891 fOldTreeItemModels.insert(fTreeItemModels.begin(), fTreeItemModels.end());
3894 3892
3895 // all is copy, then clear scene tree 3893 // all is copy, then clear scene tree
3896 int tmp2 = fSceneTreeComponentTreeWidge 3894 int tmp2 = fSceneTreeComponentTreeWidget->topLevelItemCount();
3897 while (tmp2 > 0) { 3895 while (tmp2 > 0) {
3898 delete fSceneTreeComponentTreeWidget- 3896 delete fSceneTreeComponentTreeWidget->takeTopLevelItem (0);
3899 tmp2 = fSceneTreeComponentTreeWidget- 3897 tmp2 = fSceneTreeComponentTreeWidget->topLevelItemCount();
3900 } 3898 }
3901 fPositivePoIndexSceneTreeWidgetQuickMap 3899 fPositivePoIndexSceneTreeWidgetQuickMap.clear();
3902 3900
3903 // put correct value in paramaters 3901 // put correct value in paramaters
3904 fOldLastSceneTreeWidgetAskForIterator = 3902 fOldLastSceneTreeWidgetAskForIterator = fOldPositivePoIndexSceneTreeWidgetQuickMap.begin();
3905 fOldLastSceneTreeWidgetAskForIteratorEn 3903 fOldLastSceneTreeWidgetAskForIteratorEnd = fOldPositivePoIndexSceneTreeWidgetQuickMap.end();
3906 fSceneTreeDepth = 1; 3904 fSceneTreeDepth = 1;
3907 fModelShortNameItem = NULL; 3905 fModelShortNameItem = NULL;
3908 fMaxPOindexInserted = -1; 3906 fMaxPOindexInserted = -1;
3909 3907
3910 } 3908 }
3911 } 3909 }
3912 } 3910 }
3913 3911
3914 3912
3915 /** 3913 /**
3916 Clone : 3914 Clone :
3917 - Open/close 3915 - Open/close
3918 - Visible/hidden 3916 - Visible/hidden
3919 - Selected 3917 - Selected
3920 */ 3918 */
3921 QTreeWidgetItem * G4OpenGLQtViewer::cloneWidg 3919 QTreeWidgetItem * G4OpenGLQtViewer::cloneWidgetItem(QTreeWidgetItem* item) {
3922 3920
3923 QTreeWidgetItem* cloneItem = new QTreeWidge 3921 QTreeWidgetItem* cloneItem = new QTreeWidgetItem();
3924 3922
3925 // Clone what is create createTreeWidgetIte 3923 // Clone what is create createTreeWidgetItem step
3926 3924
3927 cloneItem->setText(0,item->text(0)); 3925 cloneItem->setText(0,item->text(0));
3928 cloneItem->setData(1,Qt::UserRole,item->dat 3926 cloneItem->setData(1,Qt::UserRole,item->data(1,Qt::UserRole).toInt());
3929 cloneItem->setText(2,item->text(2)); 3927 cloneItem->setText(2,item->text(2));
3930 cloneItem->setData(0, Qt::UserRole,item->da 3928 cloneItem->setData(0, Qt::UserRole,item->data(0,Qt::UserRole).toInt());
3931 cloneItem->setText(3,item->text(3)); 3929 cloneItem->setText(3,item->text(3));
3932 cloneItem->setFlags(item->flags()); 3930 cloneItem->setFlags(item->flags());
3933 cloneItem->setToolTip(0,item->toolTip(0)); 3931 cloneItem->setToolTip(0,item->toolTip(0));
3934 cloneItem->setCheckState(0,item->checkState 3932 cloneItem->setCheckState(0,item->checkState(0));
3935 cloneItem->setSelected(item->isSelected()); 3933 cloneItem->setSelected(item->isSelected());
3936 cloneItem->setExpanded(item->isExpanded ()) 3934 cloneItem->setExpanded(item->isExpanded ());
3937 3935
3938 cloneItem->setData(2,Qt::UserRole,item->dat 3936 cloneItem->setData(2,Qt::UserRole,item->data(2,Qt::UserRole).value<QColor>());
3939 3937
3940 return cloneItem; 3938 return cloneItem;
3941 } 3939 }
3942 3940
3943 3941
3944 /** 3942 /**
3945 Clone the current tree in order to get a s 3943 Clone the current tree in order to get a snapshot of old version
3946 */ 3944 */
3947 void G4OpenGLQtViewer::cloneSceneTree( 3945 void G4OpenGLQtViewer::cloneSceneTree(
3948 QTreeWidgetItem* rootItem 3946 QTreeWidgetItem* rootItem
3949 ) { 3947 ) {
3950 3948
3951 for (int b=0;b< rootItem->childCount();b++) 3949 for (int b=0;b< rootItem->childCount();b++) {
3952 3950
3953 QTreeWidgetItem *child = rootItem->child( 3951 QTreeWidgetItem *child = rootItem->child(b);
3954 3952
3955 // clone top level items 3953 // clone top level items
3956 int poIndex = child->data(0,Qt::UserRole) 3954 int poIndex = child->data(0,Qt::UserRole).toInt();
3957 if (poIndex != -1) { 3955 if (poIndex != -1) {
3958 fOldPositivePoIndexSceneTreeWidgetQuick 3956 fOldPositivePoIndexSceneTreeWidgetQuickMap.insert(std::pair <int, QTreeWidgetItem*> (poIndex,cloneWidgetItem(child)));
3959 } else { 3957 } else {
3960 fOldNullPoIndexSceneTreeWidgetQuickVect 3958 fOldNullPoIndexSceneTreeWidgetQuickVector.push_back(cloneWidgetItem(child));
3961 } 3959 }
3962 cloneSceneTree(child); 3960 cloneSceneTree(child);
3963 } 3961 }
3964 } 3962 }
3965 3963
3966 3964
3967 /** 3965 /**
3968 Update the quick scene tree visibility map 3966 Update the quick scene tree visibility map (used by parseAndCheckVisibility)
3969 */ 3967 */
3970 void G4OpenGLQtViewer::updatePositivePoIndex 3968 void G4OpenGLQtViewer::updatePositivePoIndexSceneTreeWidgetQuickMap(int POindex,QTreeWidgetItem* item) {
3971 3969
3972 // Check state 3970 // Check state
3973 std::map <int, QTreeWidgetItem*>::iterator 3971 std::map <int, QTreeWidgetItem*>::iterator i;
3974 i = fPositivePoIndexSceneTreeWidgetQuickMa 3972 i = fPositivePoIndexSceneTreeWidgetQuickMap.find(POindex);
3975 3973
3976 if (i == fPositivePoIndexSceneTreeWidgetQu 3974 if (i == fPositivePoIndexSceneTreeWidgetQuickMap.end()) {
3977 fPositivePoIndexSceneTreeWidgetQuickMap. 3975 fPositivePoIndexSceneTreeWidgetQuickMap.insert(std::pair <int, QTreeWidgetItem*> (POindex,item) );
3978 fLastSceneTreeWidgetAskForIterator = fPo 3976 fLastSceneTreeWidgetAskForIterator = fPositivePoIndexSceneTreeWidgetQuickMap.end();
3979 fLastSceneTreeWidgetAskForIteratorEnd = 3977 fLastSceneTreeWidgetAskForIteratorEnd = fPositivePoIndexSceneTreeWidgetQuickMap.end();
3980 } else { 3978 } else {
3981 i->second = item; 3979 i->second = item;
3982 } 3980 }
3983 } 3981 }
3984 3982
3985 3983
3986 3984
3987 void G4OpenGLQtViewer::changeQColorForTreeWid 3985 void G4OpenGLQtViewer::changeQColorForTreeWidgetItem(QTreeWidgetItem* item,const QColor& qc) {
3988 3986
3989 int POIndex = item->data(0,Qt::UserRole).to 3987 int POIndex = item->data(0,Qt::UserRole).toInt();
3990 updatePositivePoIndexSceneTreeWidgetQuickMa 3988 updatePositivePoIndexSceneTreeWidgetQuickMap(POIndex,item );
3991 3989
3992 QPixmap pixmap = QPixmap(QSize(16, 16)); 3990 QPixmap pixmap = QPixmap(QSize(16, 16));
3993 if (item->data(0,Qt::UserRole).toInt() != - 3991 if (item->data(0,Qt::UserRole).toInt() != -1) {
3994 pixmap.fill (qc); 3992 pixmap.fill (qc);
3995 } else { 3993 } else {
3996 pixmap.fill (QColor(255,255,255,255)); 3994 pixmap.fill (QColor(255,255,255,255));
3997 } 3995 }
3998 QPainter painter(&pixmap); 3996 QPainter painter(&pixmap);
3999 painter.setPen(Qt::black); 3997 painter.setPen(Qt::black);
4000 painter.drawRect(0,0,15,15); // Draw contou 3998 painter.drawRect(0,0,15,15); // Draw contour
4001 3999
4002 item->setIcon(0,pixmap); 4000 item->setIcon(0,pixmap);
4003 item->setData(2,Qt::UserRole,qc); 4001 item->setData(2,Qt::UserRole,qc);
4004 } 4002 }
4005 4003
4006 4004
4007 4005
4008 /** 4006 /**
4009 @return the corresponding item if existing 4007 @return the corresponding item if existing.
4010 Look into fPositivePoIndexSceneTreeWidgetQ 4008 Look into fPositivePoIndexSceneTreeWidgetQuickMap
4011 */ 4009 */
4012 QTreeWidgetItem* G4OpenGLQtViewer::getTreeWid 4010 QTreeWidgetItem* G4OpenGLQtViewer::getTreeWidgetItem(int POindex){
4013 4011
4014 // -1 is not a visible item 4012 // -1 is not a visible item
4015 if (POindex == -1) { 4013 if (POindex == -1) {
4016 return NULL; 4014 return NULL;
4017 } 4015 }
4018 4016
4019 if (fPositivePoIndexSceneTreeWidgetQuickMap 4017 if (fPositivePoIndexSceneTreeWidgetQuickMap.size() == 0){
4020 return NULL; 4018 return NULL;
4021 } 4019 }
4022 4020
4023 if (fLastSceneTreeWidgetAskForIterator != f 4021 if (fLastSceneTreeWidgetAskForIterator != fLastSceneTreeWidgetAskForIteratorEnd) {
4024 if (POindex == fLastSceneTreeWidgetAskFor 4022 if (POindex == fLastSceneTreeWidgetAskForIterator->first) {
4025 if (fLastSceneTreeWidgetAskForIterator- 4023 if (fLastSceneTreeWidgetAskForIterator->second != NULL) {
4026 return fLastSceneTreeWidgetAskForIter 4024 return fLastSceneTreeWidgetAskForIterator->second;
4027 } 4025 }
4028 } 4026 }
4029 } 4027 }
4030 4028
4031 // if not, use the "find" algorithm 4029 // if not, use the "find" algorithm
4032 fLastSceneTreeWidgetAskForIterator = fPosit 4030 fLastSceneTreeWidgetAskForIterator = fPositivePoIndexSceneTreeWidgetQuickMap.find(POindex);
4033 fLastSceneTreeWidgetAskForIteratorEnd = fPo 4031 fLastSceneTreeWidgetAskForIteratorEnd = fPositivePoIndexSceneTreeWidgetQuickMap.end();
4034 4032
4035 if (fLastSceneTreeWidgetAskForIterator != f 4033 if (fLastSceneTreeWidgetAskForIterator != fPositivePoIndexSceneTreeWidgetQuickMap.end()) {
4036 return fLastSceneTreeWidgetAskForIterator 4034 return fLastSceneTreeWidgetAskForIterator->second;
4037 } 4035 }
4038 return NULL; 4036 return NULL;
4039 } 4037 }
4040 4038
4041 /** 4039 /**
4042 @return the corresponding item if existing 4040 @return the corresponding item if existing in the old tree
4043 Look into fOldPositivePoIndexSceneTreeWidg 4041 Look into fOldPositivePoIndexSceneTreeWidgetQuickMap
4044 */ 4042 */
4045 QTreeWidgetItem* G4OpenGLQtViewer::getOldTree 4043 QTreeWidgetItem* G4OpenGLQtViewer::getOldTreeWidgetItem(int POindex){
4046 4044
4047 4045
4048 // -1 is not a visible item 4046 // -1 is not a visible item
4049 if (POindex == -1) { 4047 if (POindex == -1) {
4050 return NULL; 4048 return NULL;
4051 } 4049 }
4052 4050
4053 if (fOldPositivePoIndexSceneTreeWidgetQuick 4051 if (fOldPositivePoIndexSceneTreeWidgetQuickMap.size() == 0){
4054 return NULL; 4052 return NULL;
4055 } 4053 }
4056 4054
4057 // Should be call only once by item additio 4055 // Should be call only once by item addition
4058 // Prevent to get out the std::map 4056 // Prevent to get out the std::map
4059 if (fOldLastSceneTreeWidgetAskForIterator ! 4057 if (fOldLastSceneTreeWidgetAskForIterator != fOldLastSceneTreeWidgetAskForIteratorEnd) {
4060 fOldLastSceneTreeWidgetAskForIterator++; 4058 fOldLastSceneTreeWidgetAskForIterator++;
4061 } 4059 }
4062 4060
4063 if (fOldLastSceneTreeWidgetAskForIterator ! 4061 if (fOldLastSceneTreeWidgetAskForIterator != fOldPositivePoIndexSceneTreeWidgetQuickMap.end()) {
4064 if (POindex == fOldLastSceneTreeWidgetAsk 4062 if (POindex == fOldLastSceneTreeWidgetAskForIterator->first) {
4065 if (fOldLastSceneTreeWidgetAskForIterat 4063 if (fOldLastSceneTreeWidgetAskForIterator->second != NULL) {
4066 return fOldLastSceneTreeWidgetAskForI 4064 return fOldLastSceneTreeWidgetAskForIterator->second;
4067 } 4065 }
4068 } 4066 }
4069 } 4067 }
4070 4068
4071 // if not, use the "find" algorithm 4069 // if not, use the "find" algorithm
4072 fOldLastSceneTreeWidgetAskForIterator = fOl 4070 fOldLastSceneTreeWidgetAskForIterator = fOldPositivePoIndexSceneTreeWidgetQuickMap.find(POindex);
4073 fOldLastSceneTreeWidgetAskForIteratorEnd = 4071 fOldLastSceneTreeWidgetAskForIteratorEnd = fOldPositivePoIndexSceneTreeWidgetQuickMap.end();
4074 4072
4075 if (fOldLastSceneTreeWidgetAskForIterator ! 4073 if (fOldLastSceneTreeWidgetAskForIterator != fOldPositivePoIndexSceneTreeWidgetQuickMap.end()) {
4076 return fOldLastSceneTreeWidgetAskForItera 4074 return fOldLastSceneTreeWidgetAskForIterator->second;
4077 } 4075 }
4078 return NULL; 4076 return NULL;
4079 } 4077 }
4080 4078
4081 4079
4082 4080
4083 /** 4081 /**
4084 Should replace actual tree by the one in t 4082 Should replace actual tree by the one in this class
4085 and update tree 4083 and update tree
4086 */ 4084 */
4087 void G4OpenGLQtViewer::displaySceneTreeCompon 4085 void G4OpenGLQtViewer::displaySceneTreeComponent() {
4088 // no UI 4086 // no UI
4089 if (fUISceneTreeWidget == NULL) { 4087 if (fUISceneTreeWidget == NULL) {
4090 return; 4088 return;
4091 } 4089 }
4092 if (fSceneTreeComponentTreeWidget == NULL) 4090 if (fSceneTreeComponentTreeWidget == NULL) {
4093 return; 4091 return;
4094 } 4092 }
4095 4093
4096 // sort tree items 4094 // sort tree items
4097 fSceneTreeComponentTreeWidget->sortItems (0 4095 fSceneTreeComponentTreeWidget->sortItems (0, Qt::AscendingOrder );
4098 4096
4099 return; 4097 return;
4100 } 4098 }
4101 4099
4102 4100
4103 /** 4101 /**
4104 Update the toolbar Icons/Mouse context men 4102 Update the toolbar Icons/Mouse context menu
4105 - Change ortho/perspective 4103 - Change ortho/perspective
4106 - Change surface style 4104 - Change surface style
4107 - Change cursor style 4105 - Change cursor style
4108 */ 4106 */
4109 void G4OpenGLQtViewer::updateToolbarAndMouseC 4107 void G4OpenGLQtViewer::updateToolbarAndMouseContextMenu(){
4110 if (fBatchMode) { 4108 if (fBatchMode) {
4111 return; 4109 return;
4112 } 4110 }
4113 4111
4114 G4ViewParameters::DrawingStyle 4112 G4ViewParameters::DrawingStyle
4115 d_style = fVP.GetDrawingStyle(); 4113 d_style = fVP.GetDrawingStyle();
4116 4114
4117 // Surface style 4115 // Surface style
4118 if (d_style == G4ViewParameters::wireframe) 4116 if (d_style == G4ViewParameters::wireframe) {
4119 if (fUiQt) fUiQt->SetIconWireframeSelecte 4117 if (fUiQt) fUiQt->SetIconWireframeSelected();
4120 if (fContextMenu) { 4118 if (fContextMenu) {
4121 fDrawingWireframe->setChecked(true); 4119 fDrawingWireframe->setChecked(true);
4122 fDrawingLineRemoval->setChecked(false); 4120 fDrawingLineRemoval->setChecked(false);
4123 fDrawingSurfaceRemoval->setChecked(fals 4121 fDrawingSurfaceRemoval->setChecked(false);
4124 fDrawingLineSurfaceRemoval->setChecked( 4122 fDrawingLineSurfaceRemoval->setChecked(false);
4125 } 4123 }
4126 } else if (d_style == G4ViewParameters::hlr 4124 } else if (d_style == G4ViewParameters::hlr) {
4127 if (fUiQt) fUiQt->SetIconHLRSelected(); 4125 if (fUiQt) fUiQt->SetIconHLRSelected();
4128 if (fContextMenu) { 4126 if (fContextMenu) {
4129 fDrawingLineRemoval->setChecked(true); 4127 fDrawingLineRemoval->setChecked(true);
4130 fDrawingWireframe->setChecked(false); 4128 fDrawingWireframe->setChecked(false);
4131 fDrawingSurfaceRemoval->setChecked(fals 4129 fDrawingSurfaceRemoval->setChecked(false);
4132 fDrawingLineSurfaceRemoval->setChecked( 4130 fDrawingLineSurfaceRemoval->setChecked(false);
4133 } 4131 }
4134 } else if (d_style == G4ViewParameters::hsr 4132 } else if (d_style == G4ViewParameters::hsr) {
4135 if (fUiQt) fUiQt->SetIconSolidSelected(); 4133 if (fUiQt) fUiQt->SetIconSolidSelected();
4136 if (fContextMenu) { 4134 if (fContextMenu) {
4137 fDrawingSurfaceRemoval->setChecked(true 4135 fDrawingSurfaceRemoval->setChecked(true);
4138 fDrawingWireframe->setChecked(false); 4136 fDrawingWireframe->setChecked(false);
4139 fDrawingLineRemoval->setChecked(false); 4137 fDrawingLineRemoval->setChecked(false);
4140 fDrawingLineSurfaceRemoval->setChecked( 4138 fDrawingLineSurfaceRemoval->setChecked(false);
4141 } 4139 }
4142 } else if (d_style == G4ViewParameters::hlh 4140 } else if (d_style == G4ViewParameters::hlhsr) {
4143 if (fUiQt) fUiQt->SetIconHLHSRSelected(); 4141 if (fUiQt) fUiQt->SetIconHLHSRSelected();
4144 if (fContextMenu) { 4142 if (fContextMenu) {
4145 fDrawingLineSurfaceRemoval->setChecked( 4143 fDrawingLineSurfaceRemoval->setChecked(true);
4146 fDrawingWireframe->setChecked(false); 4144 fDrawingWireframe->setChecked(false);
4147 fDrawingLineRemoval->setChecked(false); 4145 fDrawingLineRemoval->setChecked(false);
4148 fDrawingSurfaceRemoval->setChecked(fals 4146 fDrawingSurfaceRemoval->setChecked(false);
4149 fDrawingLineSurfaceRemoval->setChecked( 4147 fDrawingLineSurfaceRemoval->setChecked(false);
4150 } 4148 }
4151 } 4149 }
4152 4150
4153 4151
4154 // projection style 4152 // projection style
4155 G4double d_proj = fVP.GetFieldHalfAngle () 4153 G4double d_proj = fVP.GetFieldHalfAngle () ;
4156 if (d_proj == 0.) { // ortho 4154 if (d_proj == 0.) { // ortho
4157 if (fUiQt) fUiQt->SetIconOrthoSelected(); 4155 if (fUiQt) fUiQt->SetIconOrthoSelected();
4158 if (fContextMenu) { 4156 if (fContextMenu) {
4159 fProjectionOrtho->setChecked(true); 4157 fProjectionOrtho->setChecked(true);
4160 fProjectionPerspective->setChecked(fals 4158 fProjectionPerspective->setChecked(false);
4161 } 4159 }
4162 } else { 4160 } else {
4163 if (fUiQt) fUiQt->SetIconPerspectiveSelec 4161 if (fUiQt) fUiQt->SetIconPerspectiveSelected();
4164 if (fContextMenu) { 4162 if (fContextMenu) {
4165 fProjectionPerspective->setChecked(tr 4163 fProjectionPerspective->setChecked(true);
4166 fProjectionOrtho->setChecked(false); 4164 fProjectionOrtho->setChecked(false);
4167 } 4165 }
4168 } 4166 }
4169 4167
4170 4168
4171 // mouse style : They are controlled by UI 4169 // mouse style : They are controlled by UI !
4172 if (fUiQt && fContextMenu) { 4170 if (fUiQt && fContextMenu) {
4173 if (fUiQt->IsIconPickSelected()) { 4171 if (fUiQt->IsIconPickSelected()) {
4174 fMousePickAction->setChecked(true); 4172 fMousePickAction->setChecked(true);
4175 fMouseZoomOutAction->setChecked(false); 4173 fMouseZoomOutAction->setChecked(false);
4176 fMouseZoomInAction->setChecked(false); 4174 fMouseZoomInAction->setChecked(false);
4177 fMouseRotateAction->setChecked(false); 4175 fMouseRotateAction->setChecked(false);
4178 fMouseMoveAction->setChecked(false); 4176 fMouseMoveAction->setChecked(false);
4179 } else if (fUiQt->IsIconZoomOutSelected() 4177 } else if (fUiQt->IsIconZoomOutSelected()) {
4180 fMouseZoomOutAction->setChecked(true); 4178 fMouseZoomOutAction->setChecked(true);
4181 fMousePickAction->setChecked(false); 4179 fMousePickAction->setChecked(false);
4182 fMouseZoomInAction->setChecked(false); 4180 fMouseZoomInAction->setChecked(false);
4183 fMouseRotateAction->setChecked(false); 4181 fMouseRotateAction->setChecked(false);
4184 fMouseMoveAction->setChecked(false); 4182 fMouseMoveAction->setChecked(false);
4185 } else if (fUiQt->IsIconZoomInSelected()) 4183 } else if (fUiQt->IsIconZoomInSelected()) {
4186 fMouseZoomInAction->setChecked(true); 4184 fMouseZoomInAction->setChecked(true);
4187 fMousePickAction->setChecked(false); 4185 fMousePickAction->setChecked(false);
4188 fMouseZoomOutAction->setChecked(false); 4186 fMouseZoomOutAction->setChecked(false);
4189 fMouseRotateAction->setChecked(false); 4187 fMouseRotateAction->setChecked(false);
4190 fMouseMoveAction->setChecked(false); 4188 fMouseMoveAction->setChecked(false);
4191 } else if (fUiQt->IsIconRotateSelected()) 4189 } else if (fUiQt->IsIconRotateSelected()) {
4192 fMouseRotateAction->setChecked(true); 4190 fMouseRotateAction->setChecked(true);
4193 fMousePickAction->setChecked(false); 4191 fMousePickAction->setChecked(false);
4194 fMouseZoomOutAction->setChecked(false); 4192 fMouseZoomOutAction->setChecked(false);
4195 fMouseZoomInAction->setChecked(false); 4193 fMouseZoomInAction->setChecked(false);
4196 fMouseMoveAction->setChecked(false); 4194 fMouseMoveAction->setChecked(false);
4197 } else if (fUiQt->IsIconMoveSelected()) { 4195 } else if (fUiQt->IsIconMoveSelected()) {
4198 fMouseMoveAction->setChecked(true); 4196 fMouseMoveAction->setChecked(true);
4199 fMousePickAction->setChecked(false); 4197 fMousePickAction->setChecked(false);
4200 fMouseZoomOutAction->setChecked(false); 4198 fMouseZoomOutAction->setChecked(false);
4201 fMouseZoomInAction->setChecked(false); 4199 fMouseZoomInAction->setChecked(false);
4202 fMouseRotateAction->setChecked(false); 4200 fMouseRotateAction->setChecked(false);
4203 } 4201 }
4204 } 4202 }
4205 } 4203 }
4206 4204
4207 <<
4208 /** 4205 /**
4209 Update the scene tree widget 4206 Update the scene tree widget
4210 */ 4207 */
4211 void G4OpenGLQtViewer::updateSceneTreeWidget( 4208 void G4OpenGLQtViewer::updateSceneTreeWidget() {
4212 // Ensure case where closing a UI tab close 4209 // Ensure case where closing a UI tab close the widget
4213 if (!fSceneTreeWidget) { 4210 if (!fSceneTreeWidget) {
4214 createSceneTreeWidget(); 4211 createSceneTreeWidget();
4215 } 4212 }
4216 } 4213 }
4217 4214
4218 4215
4219 /** 4216 /**
4220 Update the viewer properties component widge 4217 Update the viewer properties component widget
4221 Clear it only if the number of command is le 4218 Clear it only if the number of command is less than the previous table widget row count
4222 */ 4219 */
4223 void G4OpenGLQtViewer::updateViewerProperties 4220 void G4OpenGLQtViewer::updateViewerPropertiesTableWidget() {
4224 4221
4225 if (!isCurrentWidget()) { 4222 if (!isCurrentWidget()) {
4226 return; 4223 return;
4227 } 4224 }
4228 4225
4229 // Ensure case where closing a UI tab close 4226 // Ensure case where closing a UI tab close the widget
4230 if (!fViewerPropertiesTableWidget) { 4227 if (!fViewerPropertiesTableWidget) {
4231 createViewerPropertiesWidget(); 4228 createViewerPropertiesWidget();
4232 } 4229 }
4233 int treeWidgetInfosIgnoredCommands = 0; 4230 int treeWidgetInfosIgnoredCommands = 0;
4234 G4UImanager* UI = G4UImanager::GetUIpointer 4231 G4UImanager* UI = G4UImanager::GetUIpointer();
4235 G4UIcommandTree * commandTreeTop = UI->GetT 4232 G4UIcommandTree * commandTreeTop = UI->GetTree();
4236 G4UIcommandTree* path = commandTreeTop->Fin 4233 G4UIcommandTree* path = commandTreeTop->FindCommandTree("/vis/viewer/set/");
4237 4234
4238 if (!path) { 4235 if (!path) {
4239 return; 4236 return;
4240 } 4237 }
4241 4238
4242 // clear old table 4239 // clear old table
4243 if ((path->GetCommandEntry()-fTreeWidgetInf 4240 if ((path->GetCommandEntry()-fTreeWidgetInfosIgnoredCommands) != fViewerPropertiesTableWidget->rowCount()) {
4244 fViewerPropertiesTableWidget->clear(); 4241 fViewerPropertiesTableWidget->clear();
4245 } 4242 }
4246 4243
4247 fViewerPropertiesTableWidget->blockSignals( 4244 fViewerPropertiesTableWidget->blockSignals(true);
4248 // TODO : Could be optimized by comparing c 4245 // TODO : Could be optimized by comparing current command to old commands. That should not change so much
4249 4246
4250 fViewerPropertiesTableWidget->setColumnCoun 4247 fViewerPropertiesTableWidget->setColumnCount (2);
4251 fViewerPropertiesTableWidget->setRowCount ( 4248 fViewerPropertiesTableWidget->setRowCount (path->GetCommandEntry()-fTreeWidgetInfosIgnoredCommands);
4252 fViewerPropertiesTableWidget->setHorizontal 4249 fViewerPropertiesTableWidget->setHorizontalHeaderLabels(QStringList() << tr("Property")
4253 4250 << tr("Value"));
4254 fViewerPropertiesTableWidget->verticalHeade 4251 fViewerPropertiesTableWidget->verticalHeader()->setVisible(false);
4255 fViewerPropertiesTableWidget->setAlternatin 4252 fViewerPropertiesTableWidget->setAlternatingRowColors (true);
4256 4253
4257 // For the moment, we do only command that 4254 // For the moment, we do only command that have a "set" command in UI
4258 4255
4259 for (int a=0;a<path->GetCommandEntry();a++) 4256 for (int a=0;a<path->GetCommandEntry();a++) {
4260 G4UIcommand* commandTmp = path->GetComman 4257 G4UIcommand* commandTmp = path->GetCommand(a+1);
4261 4258
4262 // get current parameters 4259 // get current parameters
4263 QString params = ""; 4260 QString params = "";
4264 4261
4265 if(commandTmp->GetCommandName() == "autoR 4262 if(commandTmp->GetCommandName() == "autoRefresh") {
4266 if (fVP.IsAutoRefresh()) { 4263 if (fVP.IsAutoRefresh()) {
4267 params = "True"; 4264 params = "True";
4268 } else { 4265 } else {
4269 params = "False"; 4266 params = "False";
4270 } 4267 }
4271 } else if(commandTmp->GetCommandName() == 4268 } else if(commandTmp->GetCommandName() == "auxiliaryEdge") {
4272 if (fVP.IsAuxEdgeVisible()) { 4269 if (fVP.IsAuxEdgeVisible()) {
4273 params = "True"; 4270 params = "True";
4274 } else { 4271 } else {
4275 params = "False"; 4272 params = "False";
4276 } 4273 }
4277 } else if(commandTmp->GetCommandName() == 4274 } else if(commandTmp->GetCommandName() == "background") {
4278 params = QString().number(fVP.GetBackgr 4275 params = QString().number(fVP.GetBackgroundColour().GetRed()) + " "+
4279 QString().number(fVP.GetBackgroundColou 4276 QString().number(fVP.GetBackgroundColour().GetGreen()) + " "+
4280 QString().number(fVP.GetBackgroundColou 4277 QString().number(fVP.GetBackgroundColour().GetBlue()) + " "+
4281 QString().number(fVP.GetBackgroundColou 4278 QString().number(fVP.GetBackgroundColour().GetAlpha());
4282 4279
4283 } else if(commandTmp->GetCommandName() == 4280 } else if(commandTmp->GetCommandName() == "culling") {
4284 params = QString().number(fVP. IsCullin 4281 params = QString().number(fVP. IsCulling ());
4285 } else if(commandTmp->GetCommandName() == 4282 } else if(commandTmp->GetCommandName() == "cutawayMode") {
4286 if (fVP.GetCutawayMode() == G4ViewParam 4283 if (fVP.GetCutawayMode() == G4ViewParameters::cutawayUnion) {
4287 params = "union"; 4284 params = "union";
4288 } else { 4285 } else {
4289 params = "intersection"; 4286 params = "intersection";
4290 } 4287 }
4291 4288
4292 } else if(commandTmp->GetCommandName() == 4289 } else if(commandTmp->GetCommandName() == "defaultColour") {
4293 params = QString().number(fVP.GetDefaul 4290 params = QString().number(fVP.GetDefaultVisAttributes()->GetColor().GetRed()) + " "+
4294 QString().number(fVP.GetDefaultVisAttri 4291 QString().number(fVP.GetDefaultVisAttributes()->GetColor().GetGreen()) + " "+
4295 QString().number(fVP.GetDefaultVisAttri 4292 QString().number(fVP.GetDefaultVisAttributes()->GetColor().GetBlue()) + " "+
4296 QString().number(fVP.GetDefaultVisAttri 4293 QString().number(fVP.GetDefaultVisAttributes()->GetColor().GetAlpha());
4297 4294
4298 } else if(commandTmp->GetCommandName() == 4295 } else if(commandTmp->GetCommandName() == "defaultTextColour") {
4299 params = QString().number(fVP.GetDefaul 4296 params = QString().number(fVP.GetDefaultTextVisAttributes()->GetColor().GetRed()) + " "+
4300 QString().number(fVP.GetDefaultTextVisA 4297 QString().number(fVP.GetDefaultTextVisAttributes()->GetColor().GetGreen()) + " "+
4301 QString().number(fVP.GetDefaultTextVisA 4298 QString().number(fVP.GetDefaultTextVisAttributes()->GetColor().GetBlue()) + " "+
4302 QString().number(fVP.GetDefaultTextVisA 4299 QString().number(fVP.GetDefaultTextVisAttributes()->GetColor().GetAlpha());
4303 4300
4304 } else if(commandTmp->GetCommandName() == 4301 } else if(commandTmp->GetCommandName() == "edge") {
4305 G4ViewParameters::DrawingStyle existing 4302 G4ViewParameters::DrawingStyle existingStyle = fVP.GetDrawingStyle();
4306 params = "False"; 4303 params = "False";
4307 if (existingStyle == G4ViewParameters:: 4304 if (existingStyle == G4ViewParameters::hsr) {
4308 params = "True"; 4305 params = "True";
4309 } 4306 }
4310 4307
4311 } else if(commandTmp->GetCommandName() == 4308 } else if(commandTmp->GetCommandName() == "explodeFactor") {
4312 params = QString().number(fVP.GetExplod 4309 params = QString().number(fVP.GetExplodeFactor()) + " " + QString(G4String(G4BestUnit(fVP.GetExplodeFactor(),"Length")).data());
4313 4310
4314 } else if(commandTmp->GetCommandName() == 4311 } else if(commandTmp->GetCommandName() == "globalLineWidthScale") {
4315 params = QString().number(fVP.GetGlobal 4312 params = QString().number(fVP.GetGlobalLineWidthScale());
4316 4313
4317 } else if(commandTmp->GetCommandName() == 4314 } else if(commandTmp->GetCommandName() == "globalMarkerScale") {
4318 params = QString().number(fVP.GetGlobal 4315 params = QString().number(fVP.GetGlobalMarkerScale());
4319 4316
4320 } else if(commandTmp->GetCommandName() == 4317 } else if(commandTmp->GetCommandName() == "hiddenEdge") {
4321 G4ViewParameters::DrawingStyle style = 4318 G4ViewParameters::DrawingStyle style = fVP.GetDrawingStyle();
4322 if ((style == G4ViewParameters::hlr) || 4319 if ((style == G4ViewParameters::hlr) ||
4323 (style == G4ViewParameters::hlhsr)) 4320 (style == G4ViewParameters::hlhsr)) {
4324 params = "True"; 4321 params = "True";
4325 } else { 4322 } else {
4326 params = "False"; 4323 params = "False";
4327 } 4324 }
4328 4325
4329 } else if(commandTmp->GetCommandName() == 4326 } else if(commandTmp->GetCommandName() == "hiddenMarker") {
4330 if (fVP.IsMarkerNotHidden()) { 4327 if (fVP.IsMarkerNotHidden()) {
4331 params = "False"; 4328 params = "False";
4332 } else { 4329 } else {
4333 params = "True"; 4330 params = "True";
4334 } 4331 }
4335 4332
4336 } else if(commandTmp->GetCommandName() == 4333 } else if(commandTmp->GetCommandName() == "lightsMove") {
4337 if (fVP.GetLightsMoveWithCamera()) { 4334 if (fVP.GetLightsMoveWithCamera()) {
4338 params = "camera"; 4335 params = "camera";
4339 } else { 4336 } else {
4340 params = "object"; 4337 params = "object";
4341 } 4338 }
4342 } else if(commandTmp->GetCommandName() == 4339 } else if(commandTmp->GetCommandName() == "lightsThetaPhi") {
4343 G4Vector3D direction = fVP.GetLightpoin 4340 G4Vector3D direction = fVP.GetLightpointDirection();
4344 // degree 4341 // degree
4345 params = QString().number(direction.the 4342 params = QString().number(direction.theta()/CLHEP::degree)+ " "+ QString().number(direction.phi()/CLHEP::degree)+" deg";
4346 if (commandTmp->GetParameterEntries() = 4343 if (commandTmp->GetParameterEntries() == 3) {
4347 if (commandTmp->GetParameter(2)->GetD 4344 if (commandTmp->GetParameter(2)->GetDefaultValue() != "deg") {
4348 params = QString().number(direction 4345 params = QString().number(direction.theta())+ " "+ QString().number(direction.phi())+" "+commandTmp->GetParameter(2)->GetDefaultValue().data();
4349 } 4346 }
4350 } 4347 }
4351 } else if(commandTmp->GetCommandName() == 4348 } else if(commandTmp->GetCommandName() == "lightsVector") {
4352 params = QString().number(fVP.GetLightpo 4349 params = QString().number(fVP.GetLightpointDirection().x()) + " "+
4353 QString().number(fVP.GetLightpointDirec 4350 QString().number(fVP.GetLightpointDirection().y()) + " "+
4354 QString().number(fVP.GetLightpointDirec 4351 QString().number(fVP.GetLightpointDirection().z());
4355 4352
4356 } else if(commandTmp->GetCommandName() == 4353 } else if(commandTmp->GetCommandName() == "lineSegmentsPerCircle") {
4357 params = QString().number(fVP.GetNoOfSi 4354 params = QString().number(fVP.GetNoOfSides());
4358 4355
4359 } else if(commandTmp->GetCommandName() == 4356 } else if(commandTmp->GetCommandName() == "picking") {
4360 if (fVP.IsPicking()) { 4357 if (fVP.IsPicking()) {
4361 params = "True"; 4358 params = "True";
4362 } else { 4359 } else {
4363 params = "False"; 4360 params = "False";
4364 } 4361 }
4365 4362
4366 } else if(commandTmp->GetCommandName() == 4363 } else if(commandTmp->GetCommandName() == "projection") {
4367 if (fVP.GetFieldHalfAngle() == 0.) { 4364 if (fVP.GetFieldHalfAngle() == 0.) {
4368 params = "orthogonal"; 4365 params = "orthogonal";
4369 } else { 4366 } else {
4370 params = QString("perspective ") + QS 4367 params = QString("perspective ") + QString().number(fVP.GetFieldHalfAngle()/CLHEP::degree) + " deg";
4371 } 4368 }
4372 4369
4373 } else if(commandTmp->GetCommandName() == 4370 } else if(commandTmp->GetCommandName() == "rotationStyle") {
4374 if (fVP.GetRotationStyle() == G4ViewPar 4371 if (fVP.GetRotationStyle() == G4ViewParameters::constrainUpDirection) {
4375 params = "constrainUpDirection"; 4372 params = "constrainUpDirection";
4376 } else { 4373 } else {
4377 params = "freeRotation"; 4374 params = "freeRotation";
4378 } 4375 }
4379 4376
4380 } else if(commandTmp->GetCommandName() == 4377 } else if(commandTmp->GetCommandName() == "sectionPlane") {
4381 if (fVP.IsSection()) { 4378 if (fVP.IsSection()) {
4382 params = QString("on ") + 4379 params = QString("on ") +
4383 G4String(G4BestUnit(fVP.GetSectionPla 4380 G4String(G4BestUnit(fVP.GetSectionPlane().point(),"Length")).data()+
4384 QString().number(fVP.GetSectionPlane( 4381 QString().number(fVP.GetSectionPlane().normal().x())
4385 + " " + QString().number(fVP.GetSecti 4382 + " " + QString().number(fVP.GetSectionPlane().normal().y())
4386 + " " + QString().number(fVP.GetSecti 4383 + " " + QString().number(fVP.GetSectionPlane().normal().z());
4387 } else { 4384 } else {
4388 params = "off"; 4385 params = "off";
4389 } 4386 }
4390 4387
4391 } else if(commandTmp->GetCommandName() == 4388 } else if(commandTmp->GetCommandName() == "style") {
4392 if (fVP.GetDrawingStyle() == G4ViewPara 4389 if (fVP.GetDrawingStyle() == G4ViewParameters::wireframe || fVP.GetDrawingStyle() == G4ViewParameters::hlr) {
4393 params = "wireframe"; 4390 params = "wireframe";
4394 } else { 4391 } else {
4395 params = "surface"; 4392 params = "surface";
4396 } 4393 }
4397 4394
4398 4395
4399 } else if(commandTmp->GetCommandName() == 4396 } else if(commandTmp->GetCommandName() == "targetPoint") {
4400 G4Point3D point = fVP.GetCurrentTargetP 4397 G4Point3D point = fVP.GetCurrentTargetPoint();
4401 if (fSceneHandler.GetScene()) { 4398 if (fSceneHandler.GetScene()) {
4402 G4String b = G4BestUnit(fSceneHandler 4399 G4String b = G4BestUnit(fSceneHandler.GetScene()->GetStandardTargetPoint() + fVP.GetCurrentTargetPoint(),"Length");
4403 params = b.data(); 4400 params = b.data();
4404 } 4401 }
4405 } else if(commandTmp->GetCommandName() == 4402 } else if(commandTmp->GetCommandName() == "upThetaPhi") {
4406 G4Vector3D up = fVP.GetUpVector(); 4403 G4Vector3D up = fVP.GetUpVector();
4407 // degree 4404 // degree
4408 params = QString().number(up.theta()/CL 4405 params = QString().number(up.theta()/CLHEP::degree)+ " "+ QString().number(up.phi()/CLHEP::degree)+" deg";
4409 if (commandTmp->GetParameterEntries() = 4406 if (commandTmp->GetParameterEntries() == 3) {
4410 if (commandTmp->GetParameter(2)->GetD 4407 if (commandTmp->GetParameter(2)->GetDefaultValue() != "deg") {
4411 params = QString().number(up.theta( 4408 params = QString().number(up.theta())+ " "+ QString().number(up.phi())+" "+commandTmp->GetParameter(2)->GetDefaultValue().data();
4412 } 4409 }
4413 } 4410 }
4414 } else if(commandTmp->GetCommandName() == 4411 } else if(commandTmp->GetCommandName() == "upVector") {
4415 G4Vector3D up = fVP.GetUpVector(); 4412 G4Vector3D up = fVP.GetUpVector();
4416 params = QString().number(up.x())+ " " 4413 params = QString().number(up.x())+ " "+ QString().number(up.y())+" "+QString().number(up.z())+ " ";
4417 4414
4418 } else if(commandTmp->GetCommandName() == 4415 } else if(commandTmp->GetCommandName() == "viewpointThetaPhi") {
4419 G4Vector3D direction = fVP.GetViewpoint 4416 G4Vector3D direction = fVP.GetViewpointDirection();
4420 // degree 4417 // degree
4421 params = QString().number(direction.the 4418 params = QString().number(direction.theta()/CLHEP::degree)+ " "+ QString().number(direction.phi()/CLHEP::degree)+" deg";
4422 if (commandTmp->GetParameterEntries() = 4419 if (commandTmp->GetParameterEntries() == 3) {
4423 if (commandTmp->GetParameter(2)->GetD 4420 if (commandTmp->GetParameter(2)->GetDefaultValue() != "deg") {
4424 params = QString().number(direction 4421 params = QString().number(direction.theta())+ " "+ QString().number(direction.phi())+" "+commandTmp->GetParameter(2)->GetDefaultValue().data();
4425 } 4422 }
4426 } 4423 }
4427 } else if(commandTmp->GetCommandName() == 4424 } else if(commandTmp->GetCommandName() == "viewpointVector") {
4428 G4Vector3D direction = fVP.GetViewpoint 4425 G4Vector3D direction = fVP.GetViewpointDirection();
4429 params = QString().number(direction.x() 4426 params = QString().number(direction.x())+ " "+ QString().number(direction.y())+" "+QString().number(direction.z());
4430 } else { 4427 } else {
4431 // No help 4428 // No help
4432 } 4429 }
4433 4430
4434 /* DO NOT DISPLAY COMMANDS WITHOUT ANY PA 4431 /* DO NOT DISPLAY COMMANDS WITHOUT ANY PARAMETERS SET
4435 if (params == "") { 4432 if (params == "") {
4436 // TODO : display default parameters // 4433 // TODO : display default parameters // should not be editable ?
4437 4434
4438 for( G4int i_thParameter=0; i_thParamet 4435 for( G4int i_thParameter=0; i_thParameter<commandTmp->GetParameterEntries(); i_thParameter++ ) {
4439 commandParam = commandTmp->GetParamet 4436 commandParam = commandTmp->GetParameter(i_thParameter);
4440 4437
4441 if (QString(QChar(commandParam->GetPa 4438 if (QString(QChar(commandParam->GetParameterType())) == "b") {
4442 if (commandParam->GetDefaultValue() 4439 if (commandParam->GetDefaultValue().data()) {
4443 params += "True"; 4440 params += "True";
4444 } else { 4441 } else {
4445 params += "False"; 4442 params += "False";
4446 } 4443 }
4447 } else { 4444 } else {
4448 params += QString((char*)(commandPa 4445 params += QString((char*)(commandParam->GetDefaultValue()).data());
4449 } 4446 }
4450 if (i_thParameter<commandTmp->GetPara 4447 if (i_thParameter<commandTmp->GetParameterEntries()-1) {
4451 params += " "; 4448 params += " ";
4452 } 4449 }
4453 } 4450 }
4454 } 4451 }
4455 */ 4452 */
4456 4453
4457 if (params != "") { 4454 if (params != "") {
4458 4455
4459 QTableWidgetItem *nameItem; 4456 QTableWidgetItem *nameItem;
4460 QTableWidgetItem *paramItem; 4457 QTableWidgetItem *paramItem;
4461 4458
4462 // already present ? 4459 // already present ?
4463 QList<QTableWidgetItem *> list = fViewe 4460 QList<QTableWidgetItem *> list = fViewerPropertiesTableWidget->findItems (commandTmp->GetCommandName().data(),Qt::MatchExactly);
4464 if (list.size() == 1) { 4461 if (list.size() == 1) {
4465 nameItem = list.first(); 4462 nameItem = list.first();
4466 paramItem = fViewerPropertiesTableWid 4463 paramItem = fViewerPropertiesTableWidget->item(nameItem->row(),1);
4467 4464
4468 } else { 4465 } else {
4469 nameItem = new QTableWidgetItem(); 4466 nameItem = new QTableWidgetItem();
4470 paramItem = new QTableWidgetItem(); 4467 paramItem = new QTableWidgetItem();
4471 fViewerPropertiesTableWidget->setItem 4468 fViewerPropertiesTableWidget->setItem(a-treeWidgetInfosIgnoredCommands, 0, nameItem);
4472 fViewerPropertiesTableWidget->setItem 4469 fViewerPropertiesTableWidget->setItem(a-treeWidgetInfosIgnoredCommands, 1, paramItem);
4473 4470
4474 // Set Guidance 4471 // Set Guidance
4475 QString guidance; 4472 QString guidance;
4476 G4int n_guidanceEntry = (G4int)comman 4473 G4int n_guidanceEntry = (G4int)commandTmp->GetGuidanceEntries();
4477 for( G4int i_thGuidance=0; i_thGuidan 4474 for( G4int i_thGuidance=0; i_thGuidance < n_guidanceEntry; i_thGuidance++ ) {
4478 guidance += QString((char*)(command 4475 guidance += QString((char*)(commandTmp->GetGuidanceLine(i_thGuidance)).data()) + "\n";
4479 } 4476 }
4480 4477
4481 nameItem->setToolTip(guidance); 4478 nameItem->setToolTip(guidance);
4482 paramItem->setToolTip(GetCommandParam 4479 paramItem->setToolTip(GetCommandParameterList(commandTmp));
4483 4480
4484 fViewerPropertiesTableWidget->setRowH 4481 fViewerPropertiesTableWidget->setRowHeight(a-treeWidgetInfosIgnoredCommands,15);
4485 } 4482 }
4486 4483
4487 // set current name and parameters 4484 // set current name and parameters
4488 nameItem->setText(commandTmp->GetComman 4485 nameItem->setText(commandTmp->GetCommandName().data());
4489 paramItem->setText(params); 4486 paramItem->setText(params);
4490 4487
4491 nameItem->setFlags(Qt::NoItemFlags); 4488 nameItem->setFlags(Qt::NoItemFlags);
4492 nameItem->setForeground(QBrush()); 4489 nameItem->setForeground(QBrush());
4493 4490
4494 } else { 4491 } else {
4495 treeWidgetInfosIgnoredCommands++; 4492 treeWidgetInfosIgnoredCommands++;
4496 } 4493 }
4497 } 4494 }
4498 // remove empty content row 4495 // remove empty content row
4499 for (int i=0; i<treeWidgetInfosIgnoredComma 4496 for (int i=0; i<treeWidgetInfosIgnoredCommands; i++) {
4500 fViewerPropertiesTableWidget->removeRow ( 4497 fViewerPropertiesTableWidget->removeRow (fViewerPropertiesTableWidget->rowCount() - 1);
4501 } 4498 }
4502 4499
4503 // The resize should done only at creation 4500 // The resize should done only at creation
4504 if (!fViewerPropertiesTableWidgetIsInit) { 4501 if (!fViewerPropertiesTableWidgetIsInit) {
4505 fViewerPropertiesTableWidgetIsInit = true 4502 fViewerPropertiesTableWidgetIsInit = true;
4506 4503
4507 fViewerPropertiesTableWidget->resizeColum 4504 fViewerPropertiesTableWidget->resizeColumnsToContents();
4508 4505
4509 int x = fViewerPropertiesTableWidget->hor 4506 int x = fViewerPropertiesTableWidget->horizontalHeader()->length();
4510 int y = fViewerPropertiesTableWidget->ver 4507 int y = fViewerPropertiesTableWidget->verticalHeader()->length()+ fViewerPropertiesTableWidget->horizontalHeader()->sizeHint().height() + 2;
4511 4508
4512 // fViewerPropertiesTableWidget->vertica 4509 // fViewerPropertiesTableWidget->verticalHeader()->setResizeMode(QHeaderView::ResizeToContents);
4513 // fViewerPropertiesTableWidget->horizon 4510 // fViewerPropertiesTableWidget->horizontalHeader()->setResizeMode(QHeaderView::ResizeToContents);
4514 4511
4515 // resize to fit content 4512 // resize to fit content
4516 QDialog* dial = static_cast<QDialog*> (fU 4513 QDialog* dial = static_cast<QDialog*> (fUIViewerPropertiesWidget->parent());
4517 if (dial) { 4514 if (dial) {
4518 dial->resize(x+56,y+46); // more or les 4515 dial->resize(x+56,y+46); // more or less (margins) ...
4519 } 4516 }
4520 } 4517 }
4521 fViewerPropertiesTableWidget->blockSignals( 4518 fViewerPropertiesTableWidget->blockSignals(false);
4522 4519
4523 fTreeWidgetInfosIgnoredCommands = treeWidge 4520 fTreeWidgetInfosIgnoredCommands = treeWidgetInfosIgnoredCommands;
4524 } 4521 }
4525 4522
4526 4523
4527 /** 4524 /**
4528 Update the pick infos component widget 4525 Update the pick infos component widget
4529 */ 4526 */
4530 void G4OpenGLQtViewer::updatePickInfosWidget( 4527 void G4OpenGLQtViewer::updatePickInfosWidget(int aX, int aY) {
4531 fLastPickPoint = QPoint(aX,aY); 4528 fLastPickPoint = QPoint(aX,aY);
4532 4529
4533 if (!isCurrentWidget()) { 4530 if (!isCurrentWidget()) {
4534 return; 4531 return;
4535 } 4532 }
4536 // Ensure case where closing a UI tab close 4533 // Ensure case where closing a UI tab close the widget
4537 if (!fPickInfosWidget) { 4534 if (!fPickInfosWidget) {
4538 createPickInfosWidget(); 4535 createPickInfosWidget();
4539 } 4536 }
4540 4537
4541 #if QT_VERSION < 0x060000 <<
4542 #else <<
4543 {auto* qGLW = dynamic_cast<G4QGLWidgetType*> <<
4544 if (qGLW) qGLW->makeCurrent();} <<
4545 ResizeGLView(); <<
4546 #endif <<
4547 const std::vector < G4OpenGLViewerPickMap* 4538 const std::vector < G4OpenGLViewerPickMap* > & pickMapVector = GetPickDetails(aX,aY);
4548 4539
4549 // remove all previous widgets 4540 // remove all previous widgets
4550 if (fPickInfosWidget) { 4541 if (fPickInfosWidget) {
4551 QLayoutItem * wItem; 4542 QLayoutItem * wItem;
4552 if (fPickInfosWidget->layout()->count()) 4543 if (fPickInfosWidget->layout()->count()) {
4553 while ((wItem = fPickInfosWidget->layou 4544 while ((wItem = fPickInfosWidget->layout()->takeAt(0)) != 0) {
4554 delete wItem->widget(); 4545 delete wItem->widget();
4555 delete wItem; 4546 delete wItem;
4556 } 4547 }
4557 } 4548 }
4558 } else { 4549 } else {
4559 // Ensure case where closing a UI tab clo 4550 // Ensure case where closing a UI tab close the widget
4560 if (!fPickInfosWidget) { 4551 if (!fPickInfosWidget) {
4561 createPickInfosWidget(); 4552 createPickInfosWidget();
4562 } 4553 }
4563 } 4554 }
4564 4555
>> 4556 // Create a new signalMapper
>> 4557 #if QT_VERSION < 0x050600
>> 4558 delete fSignalMapperPicking;
>> 4559 fSignalMapperPicking = new QSignalMapper(this);
>> 4560 #endif
>> 4561
4565 // parse all pick results 4562 // parse all pick results
4566 G4int nPickedObjectsWithAttributes = 0; 4563 G4int nPickedObjectsWithAttributes = 0;
4567 for (unsigned int a=0; a< pickMapVector.siz 4564 for (unsigned int a=0; a< pickMapVector.size(); a++) {
4568 const auto& pickMap = pickMapVector[a]; 4565 const auto& pickMap = pickMapVector[a];
4569 // Add a box inside the pick viewer box 4566 // Add a box inside the pick viewer box
4570 std::ostringstream label; 4567 std::ostringstream label;
4571 std::ostringstream content; 4568 std::ostringstream content;
4572 std::string txt = pickMap->getAttributes( 4569 std::string txt = pickMap->getAttributes()[0].data();
4573 if (pickMapVector[a]->getAttributes().siz 4570 if (pickMapVector[a]->getAttributes().size()) {
4574 ++nPickedObjectsWithAttributes; 4571 ++nPickedObjectsWithAttributes;
4575 4572
4576 std::size_t pos1 = txt.find(':'); 4573 std::size_t pos1 = txt.find(':');
4577 std::string storeKey = txt.substr(0,pos 4574 std::string storeKey = txt.substr(0,pos1);
4578 4575
4579 if (storeKey == "G4PhysicalVolumeModel" 4576 if (storeKey == "G4PhysicalVolumeModel") {
4580 4577
4581 label << "Volume:"; 4578 label << "Volume:";
4582 std::size_t pos2 = txt.find(':',pos1+ 4579 std::size_t pos2 = txt.find(':',pos1+1);
4583 std::size_t pos3 = txt.find('\n',pos2 4580 std::size_t pos3 = txt.find('\n',pos2+1);
4584 label << txt.substr(pos2+1,pos3-pos2- 4581 label << txt.substr(pos2+1,pos3-pos2-1);
4585 4582
4586 } else if (storeKey == "G4TrajectoriesM 4583 } else if (storeKey == "G4TrajectoriesModel") {
4587 4584
4588 label << "Trajectory:"; 4585 label << "Trajectory:";
4589 std::size_t pos2 = txt.find(':',pos1+ 4586 std::size_t pos2 = txt.find(':',pos1+1);
4590 std::size_t pos3 = txt.find('\n',pos2 4587 std::size_t pos3 = txt.find('\n',pos2+1);
4591 label << " Run:" << txt.substr(pos2+1 4588 label << " Run:" << txt.substr(pos2+1,pos3-pos2-1);
4592 std::size_t pos4 = txt.find(':',pos3+ 4589 std::size_t pos4 = txt.find(':',pos3+1);
4593 std::size_t pos5 = txt.find('\n',pos4 4590 std::size_t pos5 = txt.find('\n',pos4+1);
4594 label << ", Event:" << txt.substr(pos 4591 label << ", Event:" << txt.substr(pos4+1,pos5-pos4-1);
4595 4592
4596 } else { 4593 } else {
4597 4594
4598 label << "Hit number:" << a << ", Pic 4595 label << "Hit number:" << a << ", PickName: " << pickMap->getPickName();
4599 4596
4600 } 4597 }
4601 4598
4602 // Accumulate all content with the same 4599 // Accumulate all content with the same pickname
4603 content << pickMap->print().data(); 4600 content << pickMap->print().data();
4604 G4int thisPickName = pickMap->getPickNa 4601 G4int thisPickName = pickMap->getPickName();
4605 while (++a < pickMapVector.size()) { 4602 while (++a < pickMapVector.size()) {
4606 const auto& a_pickMap = pickMapVector 4603 const auto& a_pickMap = pickMapVector[a];
4607 if (a_pickMap->getPickName() == thisP 4604 if (a_pickMap->getPickName() == thisPickName) {
4608 content << a_pickMap->print().data( 4605 content << a_pickMap->print().data();
4609 } else { 4606 } else {
4610 a--; 4607 a--;
4611 break; 4608 break;
4612 } 4609 }
4613 } 4610 }
4614 4611
4615 QPushButton* pickCoutButton = new QPush 4612 QPushButton* pickCoutButton = new QPushButton(label.str().c_str());
4616 pickCoutButton->setStyleSheet ("text-al 4613 pickCoutButton->setStyleSheet ("text-align: left; padding: 1px; border: 0px;");
4617 pickCoutButton->setIcon(*fTreeIconClose 4614 pickCoutButton->setIcon(*fTreeIconClosed);
4618 fPickInfosWidget->layout()->addWidget(p 4615 fPickInfosWidget->layout()->addWidget(pickCoutButton);
4619 4616
4620 QStringList newStr; 4617 QStringList newStr;
4621 4618
4622 // Add to stringList 4619 // Add to stringList
4623 newStr = QStringList(QString(content.st 4620 newStr = QStringList(QString(content.str().c_str()).trimmed());
4624 4621
4625 QTextEdit* ed = new QTextEdit(); 4622 QTextEdit* ed = new QTextEdit();
4626 ed->setReadOnly(true); 4623 ed->setReadOnly(true);
4627 fPickInfosWidget->layout()->addWidget(e 4624 fPickInfosWidget->layout()->addWidget(ed);
4628 ed->setVisible((false)); 4625 ed->setVisible((false));
4629 ed->append(newStr.join("")); 4626 ed->append(newStr.join(""));
4630 4627
>> 4628 #if QT_VERSION < 0x050600
>> 4629 connect(pickCoutButton, SIGNAL(clicked()), fSignalMapperPicking, SLOT(map()));
>> 4630 fSignalMapperPicking->setMapping(pickCoutButton,fPickInfosWidget->layout()->count()-1);
>> 4631 #else
4631 std::cout << pickCoutButton->text().toS 4632 std::cout << pickCoutButton->text().toStdString() << " "<< fPickInfosWidget->layout()->count()-1<< std::endl;
4632 int tmp = fPickInfosWidget->layout()->c 4633 int tmp = fPickInfosWidget->layout()->count()-1;
4633 connect(pickCoutButton, &QPushButton::c 4634 connect(pickCoutButton, &QPushButton::clicked , [this, tmp](){ this->toggleSceneTreeComponentPickingCout(tmp);});
>> 4635 #endif
4634 } 4636 }
4635 } 4637 }
>> 4638 #if QT_VERSION < 0x050600
>> 4639 connect(fSignalMapperPicking, SIGNAL(mapped(int)),this, SLOT(toggleSceneTreeComponentPickingCout(int)));
>> 4640 #endif
4636 4641
4637 // add a label to push everything up! 4642 // add a label to push everything up!
4638 QLabel * pushUp = new QLabel(""); 4643 QLabel * pushUp = new QLabel("");
4639 QSizePolicy vPolicy = QSizePolicy(QSizePoli 4644 QSizePolicy vPolicy = QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
4640 vPolicy.setVerticalStretch(10); 4645 vPolicy.setVerticalStretch(10);
4641 pushUp->setSizePolicy(vPolicy); 4646 pushUp->setSizePolicy(vPolicy);
4642 fPickInfosWidget->layout()->addWidget(pushU 4647 fPickInfosWidget->layout()->addWidget(pushUp);
4643 4648
4644 // highlight the first one : 4649 // highlight the first one :
4645 4650
4646 // first un-highlight the last selected 4651 // first un-highlight the last selected
4647 changeColorAndTransparency(fLastHighlightNa 4652 changeColorAndTransparency(fLastHighlightName,fLastHighlightColor);
4648 4653
4649 if (pickMapVector.size() > 0 ) { 4654 if (pickMapVector.size() > 0 ) {
4650 // get the new one 4655 // get the new one
4651 fLastHighlightName = pickMapVector[0]->ge 4656 fLastHighlightName = pickMapVector[0]->getPickName();
4652 fLastHighlightColor = getColorForPoIndex( 4657 fLastHighlightColor = getColorForPoIndex(fLastHighlightName);
4653 // set the new one 4658 // set the new one
4654 changeColorAndTransparency(fLastHighlight 4659 changeColorAndTransparency(fLastHighlightName,G4Color(1,1,1,1));
4655 4660
4656 updateQWidget(); 4661 updateQWidget();
4657 } 4662 }
4658 QDialog* dial = static_cast<QDialog*> (fUIP 4663 QDialog* dial = static_cast<QDialog*> (fUIPickInfosWidget->parent());
4659 if (dial) { 4664 if (dial) {
4660 // change name 4665 // change name
4661 std::ostringstream oss; 4666 std::ostringstream oss;
4662 if (nPickedObjectsWithAttributes == 0) { 4667 if (nPickedObjectsWithAttributes == 0) {
4663 oss << "No object"; 4668 oss << "No object";
4664 } else if (nPickedObjectsWithAttributes = 4669 } else if (nPickedObjectsWithAttributes == 1) {
4665 oss << "1 object"; 4670 oss << "1 object";
4666 } else { 4671 } else {
4667 oss << nPickedObjectsWithAttributes << 4672 oss << nPickedObjectsWithAttributes << " objects";
4668 } 4673 }
4669 oss << " selected - " << GetName(); 4674 oss << " selected - " << GetName();
4670 dial->setWindowTitle(oss.str().c_str()); 4675 dial->setWindowTitle(oss.str().c_str());
4671 } 4676 }
4672 // set picking cout visible 4677 // set picking cout visible
4673 fPickInfosScrollArea->setVisible(true); 4678 fPickInfosScrollArea->setVisible(true);
4674 } 4679 }
4675 4680
4676 4681
4677 void G4OpenGLQtViewer::toggleSceneTreeCompone 4682 void G4OpenGLQtViewer::toggleSceneTreeComponentPickingCout(int pickItem) {
4678 4683
4679 QWidget* w; 4684 QWidget* w;
4680 // close other items, it could take too muc 4685 // close other items, it could take too much space
4681 4686
4682 for (int a=0; a<fPickInfosWidget->layout()- 4687 for (int a=0; a<fPickInfosWidget->layout()->count(); a++) {
4683 w = fPickInfosWidget->layout()->itemAt(a) 4688 w = fPickInfosWidget->layout()->itemAt(a)->widget();
4684 QTextEdit* ed = dynamic_cast<QTextEdit*>( 4689 QTextEdit* ed = dynamic_cast<QTextEdit*>(w);
4685 QPushButton* button; 4690 QPushButton* button;
4686 if (ed) { 4691 if (ed) {
4687 if (a == pickItem) { 4692 if (a == pickItem) {
4688 w->setVisible(!w->isVisible()); 4693 w->setVisible(!w->isVisible());
4689 } else { 4694 } else {
4690 w->setVisible(false); 4695 w->setVisible(false);
4691 } 4696 }
4692 if (a >= 1) { 4697 if (a >= 1) {
4693 button = dynamic_cast<QPushButton*>(f 4698 button = dynamic_cast<QPushButton*>(fPickInfosWidget->layout()->itemAt(a-1)->widget());
4694 if (button) { 4699 if (button) {
4695 if (button->isVisible()) { 4700 if (button->isVisible()) {
4696 button->setIcon(*fTreeIconOpen); 4701 button->setIcon(*fTreeIconOpen);
4697 } else { 4702 } else {
4698 button->setIcon(*fTreeIconClosed) 4703 button->setIcon(*fTreeIconClosed);
4699 } 4704 }
4700 } 4705 }
4701 } 4706 }
4702 } 4707 }
4703 } 4708 }
4704 } 4709 }
4705 4710
4706 4711
4707 void G4OpenGLQtViewer::currentTabActivated(in 4712 void G4OpenGLQtViewer::currentTabActivated(int currentTab) {
4708 if (fUiQt->GetViewerTabWidget()->tabText(cu << 4713 if (fUiQt->GetViewerTabWidget()->tabText(currentTab) == GetName()) {
4709 createViewerPropertiesWidget(); 4714 createViewerPropertiesWidget();
4710 // createPickInfosWidget(); // Causes a / << 4715 createPickInfosWidget();
4711 // createSceneTreeWidget(); // ...this ol << 4716 createSceneTreeWidget();
4712 } 4717 }
4713 } 4718 }
4714 4719
4715 4720
4716 void G4OpenGLQtViewer::tableWidgetViewerSetIt 4721 void G4OpenGLQtViewer::tableWidgetViewerSetItemChanged(QTableWidgetItem * item) {
4717 G4UImanager* UI = G4UImanager::GetUIpointer 4722 G4UImanager* UI = G4UImanager::GetUIpointer();
4718 if(UI != NULL) { 4723 if(UI != NULL) {
4719 QTableWidgetItem* previous = fViewerPrope 4724 QTableWidgetItem* previous = fViewerPropertiesTableWidget->item(fViewerPropertiesTableWidget->row(item),0);
4720 if (previous) { 4725 if (previous) {
4721 fViewerPropertiesTableWidget->blockSign 4726 fViewerPropertiesTableWidget->blockSignals(true);
4722 UI->ApplyCommand((std::string("/vis/vie 4727 UI->ApplyCommand((std::string("/vis/viewer/set/")
4723 + previous->text().to 4728 + previous->text().toStdString()
4724 + " " 4729 + " "
4725 + item->text().toStdS 4730 + item->text().toStdString()).c_str());
4726 fViewerPropertiesTableWidget->blockSign 4731 fViewerPropertiesTableWidget->blockSignals(false);
4727 } 4732 }
4728 } 4733 }
4729 } 4734 }
4730 4735
4731 bool G4OpenGLQtViewer::isCurrentWidget(){ 4736 bool G4OpenGLQtViewer::isCurrentWidget(){
4732 G4Qt* interactorManager = G4Qt::getInstance 4737 G4Qt* interactorManager = G4Qt::getInstance ();
4733 if (!interactorManager->IsExternalApp()) { 4738 if (!interactorManager->IsExternalApp()) {
4734 4739
4735 // Prevent from repainting a hidden tab ( 4740 // Prevent from repainting a hidden tab (the current tab name has to be the one of th GL viewer)
4736 if ( GetName() != fUiQt->GetViewerTabWidg 4741 if ( GetName() != fUiQt->GetViewerTabWidget()->tabText(fUiQt->GetViewerTabWidget()->currentIndex()).toStdString().c_str()) {
4737 return false; 4742 return false;
4738 } 4743 }
4739 } 4744 }
4740 return true; 4745 return true;
4741 } 4746 }
4742 4747
4743 /** Build the parameter list parameters in 4748 /** Build the parameter list parameters in a QString<br>
4744 Reimplement partialy the G4UIparameter.cc 4749 Reimplement partialy the G4UIparameter.cc
4745 @param aCommand : command to list parameters 4750 @param aCommand : command to list parameters
4746 @see G4UIparameter::List() 4751 @see G4UIparameter::List()
4747 @see G4UIcommand::List() 4752 @see G4UIcommand::List()
4748 @return the command list parameters, or "" i 4753 @return the command list parameters, or "" if nothing
4749 */ 4754 */
4750 QString G4OpenGLQtViewer::GetCommandParameter 4755 QString G4OpenGLQtViewer::GetCommandParameterList (
4751 const G4UIc 4756 const G4UIcommand *aCommand
4752 ) 4757 )
4753 { 4758 {
4754 G4int n_parameterEntry = (G4int)aCommand->G 4759 G4int n_parameterEntry = (G4int)aCommand->GetParameterEntries();
4755 QString txt; 4760 QString txt;
4756 4761
4757 if( n_parameterEntry > 0 ) { 4762 if( n_parameterEntry > 0 ) {
4758 G4UIparameter *param; 4763 G4UIparameter *param;
4759 4764
4760 // Re-implementation of G4UIparameter.cc 4765 // Re-implementation of G4UIparameter.cc
4761 4766
4762 for( G4int i_thParameter=0; i_thParameter 4767 for( G4int i_thParameter=0; i_thParameter<n_parameterEntry; i_thParameter++ ) {
4763 param = aCommand->GetParameter(i_thPara 4768 param = aCommand->GetParameter(i_thParameter);
4764 txt += "\nParameter : " + QString((char 4769 txt += "\nParameter : " + QString((char*)(param->GetParameterName()).data()) + "\n";
4765 if( ! param->GetParameterGuidance().emp 4770 if( ! param->GetParameterGuidance().empty() )
4766 txt += QString((char*)(param->GetPara 4771 txt += QString((char*)(param->GetParameterGuidance()).data())+ "\n" ;
4767 txt += " Parameter type : " + QString( 4772 txt += " Parameter type : " + QString(QChar(param->GetParameterType())) + "\n";
4768 if(param->IsOmittable()){ 4773 if(param->IsOmittable()){
4769 txt += " Omittable : True\n"; 4774 txt += " Omittable : True\n";
4770 } else { 4775 } else {
4771 txt += " Omittable : False\n"; 4776 txt += " Omittable : False\n";
4772 } 4777 }
4773 if( param->GetCurrentAsDefault() ) { 4778 if( param->GetCurrentAsDefault() ) {
4774 txt += " Default value : taken from 4779 txt += " Default value : taken from the current value\n";
4775 } else if( ! param->GetDefaultValue().e 4780 } else if( ! param->GetDefaultValue().empty() ) {
4776 txt += " Default value : " + QStrin 4781 txt += " Default value : " + QString((char*)(param->GetDefaultValue()).data())+ "\n";
4777 } 4782 }
4778 if( ! param->GetParameterRange().empty( 4783 if( ! param->GetParameterRange().empty() ) {
4779 txt += " Parameter range : " + QStrin 4784 txt += " Parameter range : " + QString((char*)(param->GetParameterRange()).data())+ "\n";
4780 } 4785 }
4781 if( ! param->GetParameterCandidates().e 4786 if( ! param->GetParameterCandidates().empty() ) {
4782 txt += " Candidates : " + QStrin 4787 txt += " Candidates : " + QString((char*)(param->GetParameterCandidates()).data())+ "\n";
4783 } 4788 }
4784 } 4789 }
4785 } 4790 }
4786 return txt; 4791 return txt;
4787 } 4792 }
4788 4793
4789 #ifdef G4MULTITHREADED 4794 #ifdef G4MULTITHREADED
4790 4795
4791 namespace { <<
4792 G4Mutex visSubThreadMutex = G4MUTEX_INITIAL <<
4793 G4Condition waitForVisSubThreadInitialized <<
4794 G4bool visSubThreadEstablished = false; <<
4795 G4bool qObjectsSwitched = false; <<
4796 G4QGLWidgetType* qGLWidget = nullptr; <<
4797 } <<
4798 <<
4799 void G4OpenGLQtViewer::DoneWithMasterThread() 4796 void G4OpenGLQtViewer::DoneWithMasterThread()
4800 { 4797 {
4801 // Called by Main Thread ! 4798 // Called by Main Thread !
4802 4799
4803 // Initialise and check qGLWidget - no need << 4800 // Useful to avoid two vis thread at the same time
4804 qGLWidget = dynamic_cast<G4QGLWidgetType*>( << 4801 //G4MUTEXLOCK(&mWaitForVisSubThreadQtOpenGLContextInitialized);
4805 if (qGLWidget == nullptr) return; << 4802 if(!lWaitForVisSubThreadQtOpenGLContextInitialized->owns_lock())
4806 << 4803 lWaitForVisSubThreadQtOpenGLContextInitialized->lock();
4807 // Done with master thread <<
4808 qGLWidget->doneCurrent(); <<
4809 <<
4810 // Set current QThread for the way back <<
4811 fQGLContextMainThread = QThread::currentThr <<
4812 } <<
4813 <<
4814 void G4OpenGLQtViewer::MovingToVisSubThread() <<
4815 { <<
4816 // Still on master thread but vis thread ha <<
4817 <<
4818 if (qGLWidget == nullptr) return; <<
4819 <<
4820 // Wait until SwitchToVisSubThread has foun <<
4821 { <<
4822 G4AutoLock lock(&visSubThreadMutex); <<
4823 G4CONDITIONWAITLAMBDA(&waitForVisSubThreadI <<
4824 } <<
4825 <<
4826 // Move stuff to sub-thread <<
4827 if(qGLWidget->context()) qGLWidget->context <<
4828 <<
4829 // Inform sub-thread <<
4830 G4AutoLock lock(&visSubThreadMutex); <<
4831 qObjectsSwitched = true; <<
4832 lock.unlock(); <<
4833 G4CONDITIONBROADCAST(&waitForVisSubThreadIn <<
4834 } 4804 }
4835 4805
4836 void G4OpenGLQtViewer::SwitchToVisSubThread() 4806 void G4OpenGLQtViewer::SwitchToVisSubThread()
4837 { 4807 {
4838 // Called by VisSub Thread ! 4808 // Called by VisSub Thread !
4839 4809
4840 if (qGLWidget == nullptr) return; << 4810 QGLWidget* qGLW = dynamic_cast<QGLWidget*> (fGLWidget) ;
>> 4811 if (! qGLW) {
>> 4812 return;
>> 4813 }
4841 4814
4842 // Set the current QThread to its static va 4815 // Set the current QThread to its static variable
4843 fQGLContextVisSubThread = QThread::currentT << 4816 SetQGLContextVisSubThread(QThread::currentThread());
4844 4817
4845 // Let MovingToVisSubThread know we have th << 4818 // - Wait for the vis thread to set its QThread
4846 { << 4819 G4CONDITIONBROADCAST(&c1_VisSubThreadQtOpenGLContextInitialized);
4847 G4AutoLock lock(&visSubThreadMutex); << 4820 // a condition without a locked mutex is an undefined behavior.
4848 visSubThreadEstablished = true; << 4821 // we check if the mutex owns the lock, and if not, we lock it
4849 G4CONDITIONBROADCAST(&waitForVisSubThreadIn << 4822 if(!lWaitForVisSubThreadQtOpenGLContextMoved->owns_lock())
4850 } << 4823 lWaitForVisSubThreadQtOpenGLContextMoved->lock();
4851 << 4824
4852 // Wait until MovingToVisSubThread has move << 4825 // Unlock the vis thread if it is Qt Viewer
4853 { << 4826 G4CONDITIONWAIT(&c2_VisSubThreadQtOpenGLContextMoved,
4854 G4AutoLock lock(&visSubThreadMutex); << 4827 lWaitForVisSubThreadQtOpenGLContextMoved);
4855 G4CONDITIONWAITLAMBDA(&waitForVisSubThreadI <<
4856 } <<
4857 4828
4858 // make context current 4829 // make context current
4859 qGLWidget->makeCurrent(); << 4830 qGLW->makeCurrent();
4860 } 4831 }
4861 4832
4862 void G4OpenGLQtViewer::DoneWithVisSubThread() 4833 void G4OpenGLQtViewer::DoneWithVisSubThread()
4863 { 4834 {
4864 // Called by vis sub thread 4835 // Called by vis sub thread
4865 << 4836 QGLWidget* qGLW = dynamic_cast<QGLWidget*> (fGLWidget) ;
4866 if (qGLWidget == nullptr) return; << 4837 if (! qGLW) {
>> 4838 return;
>> 4839 }
4867 4840
4868 // finish with this vis sub thread context 4841 // finish with this vis sub thread context
4869 qGLWidget->doneCurrent(); << 4842 qGLW->doneCurrent();
4870 4843
4871 // and move stuff back to the main thread << 4844 #if QT_VERSION > 0x050000
4872 if(qGLWidget->context()) qGLWidget->context << 4845 // and move it back to the main thread
>> 4846 qGLW->context()->moveToThread(fQGLContextMainThread);
>> 4847 #endif
4873 } 4848 }
4874 4849
4875 void G4OpenGLQtViewer::SwitchToMasterThread() 4850 void G4OpenGLQtViewer::SwitchToMasterThread()
4876 { 4851 {
4877 // Called by master Thread ! << 4852 // Called by VisSub Thread !
>> 4853
>> 4854 QGLWidget* qGLW = dynamic_cast<QGLWidget*> (fGLWidget) ;
>> 4855 if (! qGLW) {
>> 4856 return;
>> 4857 }
>> 4858
>> 4859 // Useful to avoid two vis thread at the same time
>> 4860 //G4MUTEXUNLOCK(&mWaitForVisSubThreadQtOpenGLContextInitialized);
>> 4861 if(lWaitForVisSubThreadQtOpenGLContextInitialized->owns_lock())
>> 4862 lWaitForVisSubThreadQtOpenGLContextInitialized->unlock();
>> 4863
>> 4864 qGLW->makeCurrent();
>> 4865 }
>> 4866
4878 4867
4879 if (qGLWidget == nullptr) return; << 4868 void G4OpenGLQtViewer::MovingToVisSubThread(){
>> 4869 // Called by Main Thread !
>> 4870
>> 4871 QGLWidget* qGLW = dynamic_cast<QGLWidget*> (fGLWidget) ;
>> 4872 if (! qGLW) {
>> 4873 return;
>> 4874 }
4880 4875
4881 qGLWidget->makeCurrent(); << 4876 // a condition without a locked mutex is an undefined behavior.
>> 4877 // we check if the mutex owns the lock, and if not, we lock it
>> 4878 if(!lWaitForVisSubThreadQtOpenGLContextInitialized->owns_lock())
>> 4879 lWaitForVisSubThreadQtOpenGLContextInitialized->lock();
>> 4880
>> 4881 // - Wait for the vis sub thread to set its QThread
>> 4882 G4CONDITIONWAIT(&c1_VisSubThreadQtOpenGLContextInitialized,
>> 4883 lWaitForVisSubThreadQtOpenGLContextInitialized);
>> 4884
>> 4885 // Set current QThread for the way back
>> 4886 SetQGLContextMainThread(QThread::currentThread());
>> 4887
>> 4888 // finish with this main thread context
>> 4889 qGLW->doneCurrent();
>> 4890 #if QT_VERSION > 0x050000
>> 4891 qGLW->context()->moveToThread(fQGLContextVisSubThread);
>> 4892 #endif
4882 4893
4883 visSubThreadEstablished = false; << 4894 G4CONDITIONBROADCAST(&c2_VisSubThreadQtOpenGLContextMoved);
4884 qObjectsSwitched = false; <<
4885 } 4895 }
4886 4896
4887 #endif 4897 #endif
4888 4898
4889 4899
4890 /* 4900 /*
4891 4901
4892 void MultiLayer::exportToSVG(const QString& f 4902 void MultiLayer::exportToSVG(const QString& fname)
4893 { 4903 {
4894 QPicture picture; 4904 QPicture picture;
4895 QPainter p(&picture); 4905 QPainter p(&picture);
4896 for (int i=0;i<(int)graphsList->count();i++) 4906 for (int i=0;i<(int)graphsList->count();i++)
4897 { 4907 {
4898 Graph *gr=(Graph *)graphsList->at(i); 4908 Graph *gr=(Graph *)graphsList->at(i);
4899 Plot *myPlot= (Plot *)gr->plotWidget(); 4909 Plot *myPlot= (Plot *)gr->plotWidget();
4900 4910
4901 QPoint pos=gr->pos(); 4911 QPoint pos=gr->pos();
4902 4912
4903 int width=int(myPlot->frameGeometry().width() 4913 int width=int(myPlot->frameGeometry().width());
4904 int height=int(myPlot->frameGeometry().height 4914 int height=int(myPlot->frameGeometry().height());
4905 4915
4906 myPlot->print(&p, QRect(pos,QSize(width,heigh 4916 myPlot->print(&p, QRect(pos,QSize(width,height)));
4907 } 4917 }
4908 4918
4909 p.end(); 4919 p.end();
4910 picture.save(fname, "svg"); 4920 picture.save(fname, "svg");
4911 } 4921 }
4912 */ 4922 */
4913 4923