Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/OpenGL/src/G4OpenGLStoredQtViewer.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/OpenGL/src/G4OpenGLStoredQtViewer.cc (Version 11.3.0) and /visualization/OpenGL/src/G4OpenGLStoredQtViewer.cc (Version 10.0.p2)


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