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