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