| 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 // 26 //
>> 27 // $Id: G4OpenGLStoredQtViewer.cc,v 1.20.2.1 2009/03/13 09:02:57 gcosmo Exp $
>> 28 // GEANT4 tag $Name: geant4-09-02-patch-04 $
27 // 29 //
28 // 30 //
29 // Class G4OpenGLStoredQtViewer : a class deri 31 // Class G4OpenGLStoredQtViewer : a class derived from G4OpenGLQtViewer and
30 // G4OpenGLStor 32 // G4OpenGLStoredViewer.
31 33
>> 34 #ifdef G4VIS_BUILD_OPENGLQT_DRIVER
>> 35
32 #include "G4OpenGLStoredQtViewer.hh" 36 #include "G4OpenGLStoredQtViewer.hh"
33 37
34 #include "G4OpenGLStoredSceneHandler.hh" <<
35 #include "G4ios.hh" 38 #include "G4ios.hh"
36 #include "G4Threading.hh" <<
37 #include "G4UIQt.hh" <<
38 #if 0x060000 <= QT_VERSION <<
39 #include "G4Qt.hh" <<
40 #endif <<
41 39
42 #include <qapplication.h> << 40 //#include <qmouseevent.h>
43 #include <qtabwidget.h> << 41 #include <qevent.h> // include <qcontextmenuevent.h>
44 42
45 G4OpenGLStoredQtViewer::G4OpenGLStoredQtViewer 43 G4OpenGLStoredQtViewer::G4OpenGLStoredQtViewer
46 (G4OpenGLStoredSceneHandler& sceneHandler, 44 (G4OpenGLStoredSceneHandler& sceneHandler,
47 const G4String& name): 45 const G4String& name):
48 G4VViewer (sceneHandler, sceneHandler.Increm 46 G4VViewer (sceneHandler, sceneHandler.IncrementViewCount (), name),
49 G4OpenGLViewer (sceneHandler), 47 G4OpenGLViewer (sceneHandler),
50 G4OpenGLQtViewer (sceneHandler), 48 G4OpenGLQtViewer (sceneHandler),
51 G4OpenGLStoredViewer (sceneHandler), << 49 G4OpenGLStoredViewer (sceneHandler) // FIXME : gerer le pb du parent !
52 G4QGLWidgetType() <<
53 { 50 {
54 if (fViewId < 0) return; // In case error i <<
55 <<
56 #if QT_VERSION < 0x060000 <<
57 fQGLWidgetInitialiseCompleted = false; <<
58 51
59 // Indicates that the widget has no backgr << 52 //set true to picking
60 G4QGLWidgetType::setAttribute (Qt::WA_NoSyst << 53 fVP.SetPicking(true);
61 << 54 #if QT_VERSION < 0x040000
62 setFocusPolicy(Qt::StrongFocus); // enable k << 55 setFocusPolicy(QWidget::StrongFocus); // enable keybord events
63 fHasToRepaint = false; <<
64 fPaintEventLock = false; <<
65 fUpdateGLLock = false; <<
66 #else 56 #else
67 // Indicates that the widget has no backgrou <<
68 G4QGLWidgetType::setAttribute (Qt::WA_NoSyst <<
69 <<
70 setFocusPolicy(Qt::StrongFocus); // enable k 57 setFocusPolicy(Qt::StrongFocus); // enable keybord events
71 #endif 58 #endif
72 } << 59 hasToRepaint =false;
73 <<
74 G4OpenGLStoredQtViewer::~G4OpenGLStoredQtViewe <<
75 <<
76 void G4OpenGLStoredQtViewer::Initialise() { <<
77 #if QT_VERSION < 0x060000 <<
78 60
79 fQGLWidgetInitialiseCompleted = false; << 61 if (fViewId < 0) return; // In case error in base class instantiation.
80 CreateMainWindow (this,QString(GetName())); << 62 }
81 63
>> 64 G4OpenGLStoredQtViewer::~G4OpenGLStoredQtViewer() {
82 makeCurrent(); 65 makeCurrent();
83 glDrawBuffer (GL_BACK); << 66 // this is connect to the Dialog for deleting it properly
>> 67 // when close event.
>> 68 // ((QDialog*)window())->reject();
>> 69 }
84 70
85 // set the good tab active << 71 void G4OpenGLStoredQtViewer::Initialise() {
86 if (G4QGLWidgetType::parentWidget()) { << 72 #ifdef G4DEBUG_VIS_OGL
87 auto *parentTab = dynamic_cast<QTabWidget* << 73 printf("G4OpenGLStoredQtViewer::Initialise 1\n");
88 if (parentTab) { <<
89 parentTab->setCurrentIndex(parentTab->co <<
90 } <<
91 } <<
92 <<
93 fQGLWidgetInitialiseCompleted = true; <<
94 #else <<
95 CreateMainWindow (this,QString(GetName())); <<
96 // Set jpg as default export format for Qt v <<
97 setExportImageFormat("jpg"); <<
98 #endif 74 #endif
>> 75 readyToPaint = false;
>> 76 CreateMainWindow (this,QString(fName));
>> 77 CreateFontLists ();
>> 78
>> 79 readyToPaint = true;
99 } 80 }
100 81
101 #if QT_VERSION < 0x060000 <<
102 void G4OpenGLStoredQtViewer::initializeGL () { 82 void G4OpenGLStoredQtViewer::initializeGL () {
103 83
104 InitializeGLView (); 84 InitializeGLView ();
105 85
106 if (fSceneHandler.GetScene() == 0) { << 86 #ifdef G4DEBUG_VIS_OGL
107 fHasToRepaint =false; << 87 printf("G4OpenGLStoredQtViewer::InitialiseGL () 1\n");
108 } else { <<
109 fHasToRepaint =true; <<
110 } <<
111 <<
112 // Set the component visible <<
113 // setVisible(true) ; <<
114 <<
115 // Set jpg as default export format for Qt v <<
116 setExportImageFormat("jpg"); <<
117 } <<
118 #endif 88 #endif
119 89
120 G4bool G4OpenGLStoredQtViewer::CompareForKerne << 90 // clear the buffers and window.
121 { << 91 ClearView ();
122 // Identical to G4OpenGLStoredViewer::Compar << 92 FinishView ();
123 // for checking of VisAttributesModifiers, b << 93
124 // G4OpenGLStoredQtViewer keeps track of its << 94 glDepthFunc (GL_LEQUAL);
125 // modifiers (fTreeItemModels, etc.). << 95 glDepthMask (GL_TRUE);
126 if ( <<
127 (lastVP.GetDrawingStyle () != fVP.Get <<
128 (lastVP.GetNumberOfCloudPoints() != fVP <<
129 (lastVP.IsAuxEdgeVisible () != fVP.IsA <<
130 (lastVP.IsCulling () != fVP.IsC <<
131 (lastVP.IsCullingInvisible () != fVP.IsC <<
132 (lastVP.IsDensityCulling () != fVP.IsD <<
133 (lastVP.IsCullingCovered () != fVP.IsC <<
134 (lastVP.GetCBDAlgorithmNumber() != <<
135 fVP.GetCBDAlgorithmNumber()) <<
136 // Note: Section and Cutaway can reveal <<
137 // backface culling is implemented, the <<
138 // the back-facing faces are not there. <<
139 // (commented out) backface culling (it <<
140 // in fact, performance seems to improve <<
141 (lastVP.IsSection () != fVP.IsS <<
142 // Section (DCUT) is NOT implemented loc <<
143 // (lastVP.IsCutaway () != fVP. <<
144 // Cutaways are implemented locally so w <<
145 (lastVP.IsExplode () != fVP.IsE <<
146 (lastVP.GetNoOfSides () != fVP.Get <<
147 (lastVP.GetGlobalMarkerScale() != fVP <<
148 (lastVP.GetGlobalLineWidthScale() != fVP <<
149 (lastVP.IsMarkerNotHidden () != fVP.IsM <<
150 (lastVP.GetDefaultVisAttributes()->GetCo <<
151 fVP.GetDefaultVisAttributes()->GetColou <<
152 (lastVP.GetDefaultTextVisAttributes()->G <<
153 fVP.GetDefaultTextVisAttributes()->GetC <<
154 (lastVP.GetBackgroundColour ()!= fVP.Get <<
155 (lastVP.IsPicking () != fVP.IsP <<
156 (lastVP.IsSpecialMeshRendering() != fVP. <<
157 (lastVP.GetSpecialMeshRenderingOption() <<
158 return true; <<
159 <<
160 // Don't check VisAttributesModifiers if thi <<
161 // initiated by a mouse interaction on the s <<
162 if (fMouseOnSceneTree) { <<
163 // Reset the flag. <<
164 fMouseOnSceneTree = false; <<
165 } else { <<
166 // Not initiated by a mouse so compare for <<
167 if (lastVP.GetVisAttributesModifiers() != <<
168 return true; <<
169 } <<
170 } <<
171 96
172 if (lastVP.IsDensityCulling () && << 97 if (fSceneHandler.GetScene() == 0) {
173 (lastVP.GetVisibleDensity () != fVP.GetV << 98 hasToRepaint =false;
174 return true; << 99 } else {
175 << 100 hasToRepaint =true;
176 // /***************************************** <<
177 // If section (DCUT) is implemented locally, <<
178 if (lastVP.IsSection () && <<
179 (lastVP.GetSectionPlane () != fVP.GetSec <<
180 return true; <<
181 // ***************************************** <<
182 <<
183 /******************************************* <<
184 If cutaways are implemented locally, commen <<
185 if (lastVP.IsCutaway ()) { <<
186 if (vp.GetCutawayMode() != fVP.GetCutawayMo <<
187 if (lastVP.GetCutawayPlanes ().size () != <<
188 fVP.GetCutawayPlanes ().size ()) return tru <<
189 for (size_t i = 0; i < lastVP.GetCutawayPla <<
190 if (lastVP.GetCutawayPlanes()[i] != fVP.Get <<
191 return true; <<
192 } <<
193 ******************************************* <<
194 <<
195 if (lastVP.GetCBDAlgorithmNumber() > 0) { <<
196 if (lastVP.GetCBDParameters().size() != fV <<
197 else if (lastVP.GetCBDParameters() != fVP. <<
198 } 101 }
199 102
200 if (lastVP.IsExplode () && << 103 #ifdef G4DEBUG_VIS_OGL
201 (lastVP.GetExplodeFactor () != fVP.GetEx << 104 printf("G4OpenGLStoredQtViewer::InitialiseGL END\n");
202 return true; << 105 #endif
203 <<
204 if (lastVP.IsSpecialMeshRendering() && <<
205 (lastVP.GetSpecialMeshVolumes() != fVP.G <<
206 return true; <<
207 <<
208 return false; <<
209 } 106 }
210 107
211 G4bool G4OpenGLStoredQtViewer::POSelected(size <<
212 { <<
213 return isTouchableVisible((int)POListIndex); <<
214 } <<
215 <<
216 G4bool G4OpenGLStoredQtViewer::TOSelected(size <<
217 { <<
218 return true; <<
219 } <<
220 108
221 void G4OpenGLStoredQtViewer::DrawView () { 109 void G4OpenGLStoredQtViewer::DrawView () {
222 #if QT_VERSION < 0x060000 << 110 #ifdef G4DEBUG_VIS_OGL
223 #else << 111 printf("G4OpenGLStoredQtViewer::DrawView VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV\n");
224 if(IsGettingPickInfos()) { <<
225 paintGL(); <<
226 return; <<
227 } <<
228 #endif 112 #endif
229 #if (QT_VERSION < 0x060000) || !defined(G4MULT << 113 // That's no the same logic as Immediate Viewer, I don't know why...
230 updateQWidget(); << 114 // But if I send updateGL here, we go here :
231 #else << 115 // updateQWidget -> paintGL -> ComputeView
232 if (G4Threading::IsMasterThread()) { << 116 // whih is not the same as ComputeView Directly
233 updateQWidget(); << 117 // And we loose the redraw of things !
234 } else { << 118
235 update(); //G.Barrand: updateQWidget() ind << 119 ComputeView();
236 } << 120 #ifdef G4DEBUG_VIS_OGL
>> 121 printf("G4OpenGLStoredQtViewer::DrawView ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
237 #endif 122 #endif
238 } 123 }
239 124
240 void G4OpenGLStoredQtViewer::ComputeView () { 125 void G4OpenGLStoredQtViewer::ComputeView () {
241 126
242 #if QT_VERSION < 0x060000 << 127 #ifdef G4DEBUG_VIS_OGL
243 makeCurrent(); << 128 printf("G4OpenGLStoredQtViewer::ComputeView %d %d VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV\n",fWinSize_x, fWinSize_y);
244 #endif 129 #endif
245 << 130 makeCurrent();
246 G4ViewParameters::DrawingStyle dstyle = GetV << 131 G4ViewParameters::DrawingStyle style = GetViewParameters().GetDrawingStyle();
247 132
248 //Make sure current viewer is attached and c 133 //Make sure current viewer is attached and clean...
249 134
250 //See if things have changed from last time 135 //See if things have changed from last time and remake if necessary...
251 // The fNeedKernelVisit flag might have been 136 // The fNeedKernelVisit flag might have been set by the user in
252 // /vis/viewer/rebuild, but if not, make dec 137 // /vis/viewer/rebuild, but if not, make decision and set flag only
253 // if necessary... 138 // if necessary...
254 if (!fNeedKernelVisit) { 139 if (!fNeedKernelVisit) {
255 KernelVisitDecision (); 140 KernelVisitDecision ();
256 } 141 }
257 fLastVP = fVP; <<
258 G4bool kernelVisitWasNeeded = fNeedKernelVis 142 G4bool kernelVisitWasNeeded = fNeedKernelVisit; // Keep (ProcessView resets).
259 ProcessView (); 143 ProcessView ();
260 144
261 if (kernelVisitWasNeeded) { <<
262 displaySceneTreeComponent(); <<
263 } <<
264 145
265 if(dstyle!=G4ViewParameters::hlr && << 146 if(style!=G4ViewParameters::hlr &&
266 haloing_enabled) { 147 haloing_enabled) {
>> 148 #ifdef G4DEBUG_VIS_OGL
>> 149 printf("G4OpenGLStoredQtViewer::ComputeView DANS LE IF\n");
>> 150 #endif
267 151
268 HaloingFirstPass (); 152 HaloingFirstPass ();
269 DrawDisplayLists (); 153 DrawDisplayLists ();
270 glFlush (); 154 glFlush ();
271 155
272 HaloingSecondPass (); 156 HaloingSecondPass ();
273 157
274 DrawDisplayLists (); 158 DrawDisplayLists ();
275 FinishView (); 159 FinishView ();
276 160
277 } else { 161 } else {
278 162
279 // If kernel visit was needed, drawing and 163 // If kernel visit was needed, drawing and FinishView will already
280 // have been done, so... 164 // have been done, so...
281 if (!kernelVisitWasNeeded) { 165 if (!kernelVisitWasNeeded) {
>> 166 #ifdef G4DEBUG_VIS_OGL
>> 167 printf("************************** G4OpenGLStoredQtViewer::ComputeView Don't need kernel Visit \n");
>> 168 #endif
282 DrawDisplayLists (); 169 DrawDisplayLists ();
283 FinishView (); 170 FinishView ();
284 } else { 171 } else {
>> 172 #ifdef G4DEBUG_VIS_OGL
>> 173 printf("************************** G4OpenGLStoredQtViewer::ComputeView need kernel Visit \n");
>> 174 #endif
285 // However, union cutaways are implement 175 // However, union cutaways are implemented in DrawDisplayLists, so make
286 // an extra pass... 176 // an extra pass...
287 if (fVP.IsCutaway() && 177 if (fVP.IsCutaway() &&
288 fVP.GetCutawayMode() == G4ViewParame 178 fVP.GetCutawayMode() == G4ViewParameters::cutawayUnion) {
289 ClearView(); 179 ClearView();
290 DrawDisplayLists (); 180 DrawDisplayLists ();
291 FinishView (); 181 FinishView ();
>> 182 #ifdef G4DEBUG_VIS_OGL
>> 183 printf("*************************** CASE 4 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ \n");
>> 184 #endif
292 } else { // ADD TO AVOID KernelVisit=1 a 185 } else { // ADD TO AVOID KernelVisit=1 and nothing to display
293 DrawDisplayLists (); 186 DrawDisplayLists ();
294 FinishView (); 187 FinishView ();
295 } 188 }
296 } 189 }
297 } 190 }
298 191
299 if (isRecording()) { 192 if (isRecording()) {
300 savePPMToTemp(); 193 savePPMToTemp();
301 } 194 }
302 195
303 #if QT_VERSION < 0x060000 << 196 #ifdef G4DEBUG_VIS_OGL
304 fHasToRepaint = true; << 197 printf("G4OpenGLStoredQtViewer::ComputeView %d %d ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ \n",fWinSize_x, fWinSize_y);
305 #endif 198 #endif
>> 199 hasToRepaint =true;
306 } 200 }
307 201
308 202
309 /** 203 /**
310 - Lors du resize de la fenetre, on doit non 204 - Lors du resize de la fenetre, on doit non pas redessiner le detecteur, mais aussi les evenements
311 */ 205 */
312 void G4OpenGLStoredQtViewer::resizeGL( 206 void G4OpenGLStoredQtViewer::resizeGL(
313 int aWid 207 int aWidth
314 ,int aHe 208 ,int aHeight)
315 { 209 {
316 // Set new size, it will be update when next 210 // Set new size, it will be update when next Repaint()->SetView() called
317 if ((aWidth > 0) && (aHeight > 0)) { << 211 fWinSize_x = aWidth;
318 #if QT_VERSION < 0x060000 << 212 fWinSize_y = aHeight;
319 ResizeWindow(aWidth,aHeight); << 213 hasToRepaint = true;
320 fHasToRepaint = sizeHasChanged(); <<
321 #else <<
322 ResizeWindow(devicePixelRatio()*aWidth,dev <<
323 #endif <<
324 } <<
325 } 214 }
326 215
327 216
328 // We have to get several case : <<
329 // - Only activate the windows (mouse click fo <<
330 // - resize window -> redraw <<
331 // - try to avoid recompute everything if we d <<
332 <<
333 void G4OpenGLStoredQtViewer::paintGL() 217 void G4OpenGLStoredQtViewer::paintGL()
334 { 218 {
335 #if QT_VERSION < 0x060000 << 219 #ifdef G4DEBUG_VIS_OGL
336 updateToolbarAndMouseContextMenu(); << 220 printf("G4OpenGLStoredQtViewer::paintGL ??\n");
337 #else <<
338 //G.Barrand: don't do any change in the GUI <<
339 #endif 221 #endif
340 << 222 if (!readyToPaint) {
341 #if QT_VERSION < 0x060000 << 223 readyToPaint= true;
342 if (fPaintEventLock) { <<
343 // return ; <<
344 } <<
345 fPaintEventLock = true; <<
346 if ((getWinWidth() == 0) && (getWinHeight() <<
347 return; 224 return;
348 } 225 }
349 <<
350 if (!fQGLWidgetInitialiseCompleted) { <<
351 fPaintEventLock = false; <<
352 return; <<
353 } <<
354 <<
355 // DO NOT RESIZE IF SIZE HAS NOT CHANGE : 226 // DO NOT RESIZE IF SIZE HAS NOT CHANGE :
356 // WHEN CLICK ON THE FRAME FOR EXAMPLE 227 // WHEN CLICK ON THE FRAME FOR EXAMPLE
357 // EXECEPT WHEN MOUSE MOVE EVENT 228 // EXECEPT WHEN MOUSE MOVE EVENT
358 if ( !fHasToRepaint) { << 229 if ( !hasToRepaint) {
359 // L. Garnier : Trap to get the size with << 230 if (((fWinSize_x == (unsigned int)width())) &&(fWinSize_y == (unsigned int) height())) {
360 // Tested on Qt4.5 on mac, 4.4 on windows, <<
361 int sw = 0; <<
362 int sh = 0; <<
363 if (!isMaximized() && !isFullScreen()) { <<
364 sw = normalGeometry().width(); <<
365 sh = normalGeometry().height(); <<
366 } else { <<
367 sw = frameGeometry().width(); <<
368 sh = frameGeometry().height(); <<
369 } <<
370 if ((getWinWidth() == (unsigned int)sw) && <<
371 return; 231 return;
372 } 232 }
373 } 233 }
374 #else << 234 #ifdef G4DEBUG_VIS_OGL
375 if ((getWinWidth() == 0) && (getWinHeight() << 235 printf("G4OpenGLStoredQtViewer::paintGL VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV ready %d\n",readyToPaint);
376 #endif 236 #endif
377 237
378 #if QT_VERSION < 0x060000 <<
379 #else <<
380 InitializeGLView (); <<
381 #endif <<
382 <<
383 // Ensure that we really draw the BACK buffe <<
384 glDrawBuffer (GL_BACK); <<
385 <<
386 SetView(); 238 SetView();
387 << 239
388 ClearView (); //ok, put the background corre 240 ClearView (); //ok, put the background correct
389 ComputeView(); 241 ComputeView();
390 << 242
391 #if QT_VERSION < 0x060000 << 243 hasToRepaint =false;
392 fHasToRepaint = false; << 244
393 << 245 #ifdef G4DEBUG_VIS_OGL
394 fPaintEventLock = false; << 246 printf("G4OpenGLStoredQtViewer::paintGL ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ready %d\n",readyToPaint);
395 #endif <<
396 } <<
397 <<
398 #if QT_VERSION < 0x060000 <<
399 void G4OpenGLStoredQtViewer::paintEvent(QPaint <<
400 if (! fQGLWidgetInitialiseCompleted) { <<
401 return; <<
402 } <<
403 // Force a repaint next time if the FRAMEBUF <<
404 fHasToRepaint = isFramebufferReady(); <<
405 if ( fHasToRepaint) { <<
406 // Will really update the widget by callin <<
407 // The widget's rendering context will bec <<
408 // will be called if it hasn't already bee <<
409 // Copies the back buffer of a double-buff <<
410 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)) <<
411 updateGL(); <<
412 #else <<
413 // Not sure this is correct.... <<
414 paintGL(); <<
415 #endif 247 #endif
416 } <<
417 } 248 }
418 #endif <<
419 249
420 void G4OpenGLStoredQtViewer::mousePressEvent(Q 250 void G4OpenGLStoredQtViewer::mousePressEvent(QMouseEvent *event)
421 { 251 {
422 G4MousePressEvent(event); 252 G4MousePressEvent(event);
423 } 253 }
424 254
425 void G4OpenGLStoredQtViewer::keyPressEvent (QK 255 void G4OpenGLStoredQtViewer::keyPressEvent (QKeyEvent * event)
426 { 256 {
427 G4keyPressEvent(event); 257 G4keyPressEvent(event);
428 } 258 }
429 259
430 void G4OpenGLStoredQtViewer::keyReleaseEvent ( << 260 void G4OpenGLStoredQtViewer::wheelEvent (QWheelEvent * event)
431 { <<
432 G4keyReleaseEvent(event); <<
433 } <<
434 <<
435 void G4OpenGLStoredQtViewer::wheelEvent (QWhee <<
436 { 261 {
437 G4wheelEvent(event); 262 G4wheelEvent(event);
438 } 263 }
439 264
440 #if QT_VERSION < 0x060000 <<
441 void G4OpenGLStoredQtViewer::showEvent (QShowE <<
442 { <<
443 if (fQGLWidgetInitialiseCompleted) { <<
444 fHasToRepaint = true; <<
445 } <<
446 } <<
447 #endif <<
448 <<
449 /** 265 /**
450 * This function was build in order to make a 266 * This function was build in order to make a zoom on double clic event.
451 * It was think to build a rubberband on the z 267 * It was think to build a rubberband on the zoom area, but never work fine
452 */ 268 */
453 void G4OpenGLStoredQtViewer::mouseDoubleClickE << 269 void G4OpenGLStoredQtViewer::mouseDoubleClickEvent(QMouseEvent *event)
454 { 270 {
455 G4MouseDoubleClickEvent(); 271 G4MouseDoubleClickEvent();
456 } 272 }
457 273
458 void G4OpenGLStoredQtViewer::mouseReleaseEvent 274 void G4OpenGLStoredQtViewer::mouseReleaseEvent(QMouseEvent *event)
459 { 275 {
460 G4MouseReleaseEvent(event); << 276 G4MouseReleaseEvent();
461 } 277 }
462 278
463 void G4OpenGLStoredQtViewer::mouseMoveEvent(QM 279 void G4OpenGLStoredQtViewer::mouseMoveEvent(QMouseEvent *event)
464 { 280 {
465 G4MouseMoveEvent(event); 281 G4MouseMoveEvent(event);
466 } 282 }
467 283
468 284
469 void G4OpenGLStoredQtViewer::contextMenuEvent( 285 void G4OpenGLStoredQtViewer::contextMenuEvent(QContextMenuEvent *e)
470 { 286 {
471 G4manageContextMenuEvent(e); 287 G4manageContextMenuEvent(e);
472 } 288 }
473 289
474 void G4OpenGLStoredQtViewer::updateQWidget() { 290 void G4OpenGLStoredQtViewer::updateQWidget() {
475 #if QT_VERSION < 0x060000 << 291 hasToRepaint= true;
476 if (fUpdateGLLock) { << 292 updateGL();
477 return; << 293 hasToRepaint= false;
478 } <<
479 <<
480 if (! isCurrentWidget()){ <<
481 return; <<
482 } <<
483 <<
484 fUpdateGLLock = true; <<
485 fHasToRepaint= true; <<
486 // Will really update the widget by calling <<
487 // The widget's rendering context will becom <<
488 // will be called if it hasn't already been <<
489 // Copies the back buffer of a double-buffer <<
490 repaint(); // will read scene tree state <<
491 // updateGL() // From J.Allison picking bran <<
492 updateViewerPropertiesTableWidget(); <<
493 updateSceneTreeWidget(); <<
494 fUpdateGLLock = false; <<
495 #else <<
496 //if (!isCurrentWidget()) return; //G.Barran <<
497 //G.Barrand: don't do any change in the GUI <<
498 update(); <<
499 #endif <<
500 } 294 }
501 295
502 void G4OpenGLStoredQtViewer::ShowView () << 296 void G4OpenGLStoredQtViewer::ShowView (
>> 297 )
>> 298 //////////////////////////////////////////////////////////////////////////////
>> 299 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
503 { 300 {
>> 301 #if QT_VERSION < 0x040000
>> 302 setActiveWindow();
>> 303 #else
504 activateWindow(); 304 activateWindow();
505 #if 0x060000 <= QT_VERSION <<
506 ((QApplication*)G4Qt::getInstance ())->proce <<
507 #endif 305 #endif
>> 306 updateQWidget();
508 } 307 }
509 308
510 << 309 #endif
511 void G4OpenGLStoredQtViewer::DisplayTimePOColo <<
512 G4Colour& c, <<
513 size_t poIndex) { <<
514 c = getColorForPoIndex((int)poIndex); <<
515 } <<
516 310