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