Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/OpenGL/src/G4OpenGLWin32Viewer.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/G4OpenGLWin32Viewer.cc (Version 11.3.0) and /visualization/OpenGL/src/G4OpenGLWin32Viewer.cc (Version 9.4.p4)


  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 //
                                                   >>  26 //
                                                   >>  27 // $Id: G4OpenGLWin32Viewer.cc,v 1.20 2009-05-20 13:19:09 lgarnier Exp $
                                                   >>  28 // GEANT4 tag $Name: not supported by cvs2svn $
                                                   >>  29 //
 25 //                                                 30 // 
 26 // G4OpenGLWin32Viewer : Class to provide Wind <<  31 // G4OpenGLWin32Viewer : Class to provide WindowsNT specific
 27 //                       functionality for Ope <<  32 //                     functionality for OpenGL in GEANT4
 28 //                                                 33 //
 29 // 27/06/2003 : G.Barrand : implementation (at     34 // 27/06/2003 : G.Barrand : implementation (at last !).
 30                                                    35 
                                                   >>  36 #ifdef G4VIS_BUILD_OPENGLWIN32_DRIVER
                                                   >>  37 
 31 #include "G4OpenGLWin32Viewer.hh"                  38 #include "G4OpenGLWin32Viewer.hh"
 32 #include "G4VViewer.hh"                            39 #include "G4VViewer.hh"
 33 #include "G4VSceneHandler.hh"                      40 #include "G4VSceneHandler.hh"
 34 #include "G4OpenGLSceneHandler.hh"                 41 #include "G4OpenGLSceneHandler.hh"
 35 #include "G4Scene.hh"                          << 
 36                                                    42 
 37 #include "G4ios.hh"                                43 #include "G4ios.hh"
 38 #include "G4VisExtent.hh"                          44 #include "G4VisExtent.hh"
 39 #include "G4LogicalVolume.hh"                      45 #include "G4LogicalVolume.hh"
 40 #include "G4VSolid.hh"                             46 #include "G4VSolid.hh"
 41 #include "G4Point3D.hh"                            47 #include "G4Point3D.hh"
 42 #include "G4Normal3D.hh"                           48 #include "G4Normal3D.hh"
 43                                                    49 
 44 #include "G4SystemOfUnits.hh"                  << 
 45                                                    50 
 46 //////////////////////////////////////////////     51 //////////////////////////////////////////////////////////////////////////////
 47 void G4OpenGLWin32Viewer::SetView (                52 void G4OpenGLWin32Viewer::SetView (
 48 )                                                  53 ) 
 49 //////////////////////////////////////////////     54 //////////////////////////////////////////////////////////////////////////////
 50 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!     55 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
 51 {                                                  56 {
 52   if(!fHDC) return;                                57   if(!fHDC) return;
 53   if(!fHGLRC) return;                              58   if(!fHGLRC) return;
 54   ::wglMakeCurrent(fHDC,fHGLRC);                   59   ::wglMakeCurrent(fHDC,fHGLRC);
 55   G4OpenGLViewer::SetView ();                      60   G4OpenGLViewer::SetView ();  
 56 }                                                  61 }
 57                                                    62 
 58 //////////////////////////////////////////////     63 //////////////////////////////////////////////////////////////////////////////
 59 void G4OpenGLWin32Viewer::ShowView (               64 void G4OpenGLWin32Viewer::ShowView (
 60 )                                                  65 ) 
 61 //////////////////////////////////////////////     66 //////////////////////////////////////////////////////////////////////////////
 62 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!     67 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
 63 {                                                  68 {
 64   if(!fHDC) return;                                69   if(!fHDC) return;
 65   glFlush ();                                      70   glFlush ();
 66   // Empty the Windows message queue :             71   // Empty the Windows message queue :
 67   MSG event;                                       72   MSG event;
 68   while ( ::PeekMessage(&event, NULL, 0, 0, PM     73   while ( ::PeekMessage(&event, NULL, 0, 0, PM_REMOVE) ) {
 69     ::TranslateMessage(&event);                    74     ::TranslateMessage(&event);
 70     ::DispatchMessage (&event);                    75     ::DispatchMessage (&event);
 71   }                                                76   }
 72 }                                                  77 }
 73                                                    78 
 74 //////////////////////////////////////////////     79 //////////////////////////////////////////////////////////////////////////////
 75 void G4OpenGLWin32Viewer::GetWin32Connection (     80 void G4OpenGLWin32Viewer::GetWin32Connection (
 76 )                                                  81 ) 
 77 //////////////////////////////////////////////     82 //////////////////////////////////////////////////////////////////////////////
 78 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!     83 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
 79 {                                                  84 {
 80 }                                                  85 }
 81                                                    86 
 82 //////////////////////////////////////////////     87 //////////////////////////////////////////////////////////////////////////////
 83 void G4OpenGLWin32Viewer::CreateGLWin32Context     88 void G4OpenGLWin32Viewer::CreateGLWin32Context (
 84 )                                                  89 ) 
 85 //////////////////////////////////////////////     90 //////////////////////////////////////////////////////////////////////////////
 86 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!     91 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
 87 {                                                  92 {
 88 }                                                  93 }
 89                                                    94 
 90 //////////////////////////////////////////////     95 //////////////////////////////////////////////////////////////////////////////
 91 void G4OpenGLWin32Viewer::CreateMainWindow (       96 void G4OpenGLWin32Viewer::CreateMainWindow (
 92 )                                                  97 ) 
 93 //////////////////////////////////////////////     98 //////////////////////////////////////////////////////////////////////////////
 94 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!     99 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
 95 {                                                 100 {
 96   if(fWindow) return; //Done.                     101   if(fWindow) return; //Done.
 97                                                   102 
 98   // Bill Gates stuff...                          103   // Bill Gates stuff...
 99   static const char className[] = "G4OpenGLWin    104   static const char className[] = "G4OpenGLWin32";
100   static G4bool done = false;                  << 105   static bool done = false;
101   if(done==false) {                               106   if(done==false) {
102     WNDCLASS wc;                                  107     WNDCLASS wc;
103     wc.style = CS_HREDRAW | CS_VREDRAW;           108     wc.style = CS_HREDRAW | CS_VREDRAW;
104     wc.lpfnWndProc = (WNDPROC)WindowProc;         109     wc.lpfnWndProc = (WNDPROC)WindowProc;
105     wc.cbClsExtra = 0;                            110     wc.cbClsExtra = 0;
106     wc.cbWndExtra = 0;                            111     wc.cbWndExtra = 0;
107     wc.hInstance = ::GetModuleHandle(NULL);       112     wc.hInstance = ::GetModuleHandle(NULL);
108     wc.hIcon = LoadIcon  (NULL, IDI_APPLICATIO    113     wc.hIcon = LoadIcon  (NULL, IDI_APPLICATION);
109     wc.hCursor = LoadCursor(NULL,IDC_CROSS);      114     wc.hCursor = LoadCursor(NULL,IDC_CROSS);
110     wc.hbrBackground = NULL;                      115     wc.hbrBackground = NULL;
111     wc.lpszMenuName = className;                  116     wc.lpszMenuName = className;
112     wc.lpszClassName = className;                 117     wc.lpszClassName = className;
113     ::RegisterClass(&wc);                         118     ::RegisterClass(&wc);
114     done = true;                                  119     done = true;
115   }                                               120   }  
116                                                   121   
117   ResizeWindow(fVP.GetWindowSizeHintX(),fVP.Ge    122   ResizeWindow(fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
118                                                   123 
119   G4int x_res=GetSystemMetrics(SM_CXSCREEN);   << 124   int x_res=GetSystemMetrics(SM_CXSCREEN);
120   G4int y_res=GetSystemMetrics(SM_CYSCREEN);   << 125   int y_res=GetSystemMetrics(SM_CYSCREEN);
121                                                   126   
122   //FIXME : NOT tested !                          127   //FIXME : NOT tested !
123   fWindow = ::CreateWindowEx(0, className,fNam << 128   fWindow = ::CreateWindow(className,fName.c_str(), 
124          WS_OVERLAPPEDWINDOW,                     129          WS_OVERLAPPEDWINDOW,
125          //WS_CHILD | WS_VISIBLE,                 130          //WS_CHILD | WS_VISIBLE,
126                            //        0,0,         131                            //        0,0,
127                            fVP.GetWindowAbsolu    132                            fVP.GetWindowAbsoluteLocationHintX(x_res),
128                            fVP.GetWindowAbsolu    133                            fVP.GetWindowAbsoluteLocationHintY(y_res),
129          getWinWidth(), getWinHeight(),           134          getWinWidth(), getWinHeight(),
130          NULL, NULL,                              135          NULL, NULL, 
131          ::GetModuleHandle(NULL),                 136          ::GetModuleHandle(NULL),
132          NULL);                                   137          NULL);
133   if(!fWindow) return;                            138   if(!fWindow) return;
134                                                   139 
135   ::SetWindowLongPtr(fWindow,GWLP_USERDATA,LON << 140   ::SetWindowLong(fWindow,GWL_USERDATA,LONG(this));
136                                                   141 
137   // initialize OpenGL rendering :                142   // initialize OpenGL rendering :
138   fHDC = ::GetDC(fWindow);                        143   fHDC = ::GetDC(fWindow);
139   if( fHDC && (SetWindowPixelFormat(fHDC)==TRU    144   if( fHDC && (SetWindowPixelFormat(fHDC)==TRUE) ) {
140     fHGLRC = ::wglCreateContext(fHDC);            145     fHGLRC = ::wglCreateContext(fHDC);
141   }                                               146   }
142                                                   147   
143   if(fHDC && fHGLRC) {                            148   if(fHDC && fHGLRC) {
144     ::wglMakeCurrent(fHDC,fHGLRC);                149     ::wglMakeCurrent(fHDC,fHGLRC);
145   }                                               150   }
146                                                   151 
147   //G.Barrand : avoid to indirectly pass in    << 
148   //              WindowProc/[WM_SIZE,WM_PAINT << 
149   //            from this method. Else we have << 
150   fInCreateWindow = true;                      << 
151                                                << 
152   ::SetForegroundWindow(fWindow);                 152   ::SetForegroundWindow(fWindow);
153   ::ShowWindow(fWindow,SW_SHOWDEFAULT);           153   ::ShowWindow(fWindow,SW_SHOWDEFAULT);
154   ::UpdateWindow(fWindow);                        154   ::UpdateWindow(fWindow);
155   ::DrawMenuBar(fWindow);                         155   ::DrawMenuBar(fWindow);
156                                                << 
157   fInCreateWindow = false;                     << 
158 }                                                 156 }
159                                                   157 
160 //////////////////////////////////////////////    158 //////////////////////////////////////////////////////////////////////////////
161 G4OpenGLWin32Viewer::G4OpenGLWin32Viewer (        159 G4OpenGLWin32Viewer::G4OpenGLWin32Viewer (
162  G4OpenGLSceneHandler& scene                      160  G4OpenGLSceneHandler& scene
163 )                                                 161 )
164 :G4VViewer (scene, -1)                            162 :G4VViewer (scene, -1)
165 ,G4OpenGLViewer (scene)                           163 ,G4OpenGLViewer (scene)
166 ,fMouseHovered(false)                          << 
167 ,fMousePressed(false)                          << 
168 ,fMousePressedX(0)                             << 
169 ,fMousePressedY(0)                             << 
170 ,fHDC(0)                                       << 
171 ,fWindow(0)                                       164 ,fWindow(0)
                                                   >> 165 ,fHDC(0)
172 ,fHGLRC(0)                                        166 ,fHGLRC(0)
173 ,fInCreateWindow(false)                        << 
174 //////////////////////////////////////////////    167 //////////////////////////////////////////////////////////////////////////////
175 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!    168 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
176 {                                                 169 {
177 }                                                 170 }
178                                                   171 
179 //////////////////////////////////////////////    172 //////////////////////////////////////////////////////////////////////////////
180 G4OpenGLWin32Viewer::~G4OpenGLWin32Viewer (       173 G4OpenGLWin32Viewer::~G4OpenGLWin32Viewer (
181 )                                                 174 ) 
182 //////////////////////////////////////////////    175 //////////////////////////////////////////////////////////////////////////////
183 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!    176 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
184 {                                                 177 {
185   // This is the end (Jim Morisson).              178   // This is the end (Jim Morisson).
186   if (fViewId >= 0) {                             179   if (fViewId >= 0) {
187     if(wglGetCurrentContext()!=NULL) wglMakeCu    180     if(wglGetCurrentContext()!=NULL) wglMakeCurrent(NULL,NULL);
188     if(fHGLRC)  {                                 181     if(fHGLRC)  {
189       wglDeleteContext(fHGLRC);                   182       wglDeleteContext(fHGLRC);
190       fHGLRC = NULL;                              183       fHGLRC = NULL;
191     }                                             184     }
192                                                   185     
193     if(fWindow) {                                 186     if(fWindow) {
194       ::SetWindowLongPtr(fWindow,GWLP_USERDATA << 187       ::SetWindowLong(fWindow,GWL_USERDATA,LONG(NULL));
195       if(fHDC) ::ReleaseDC(fWindow,fHDC);         188       if(fHDC) ::ReleaseDC(fWindow,fHDC);
196       ::DestroyWindow(fWindow);                   189       ::DestroyWindow(fWindow);
197     }                                             190     }
198   }                                               191   }
199 }                                                 192 }
200                                                   193 
201 //////////////////////////////////////////////    194 //////////////////////////////////////////////////////////////////////////////
202 LRESULT CALLBACK G4OpenGLWin32Viewer::WindowPr << 195 LRESULT CALLBACK G4OpenGLWin32Viewer::WindowProc ( 
203  HWND aWindow                                  << 196  HWND   aWindow
204 ,UINT aMessage                                 << 197 ,UINT   aMessage
205 ,WPARAM aWParam                                   198 ,WPARAM aWParam
206 ,LPARAM aLParam                                   199 ,LPARAM aLParam
207 )                                                 200 )
208 //////////////////////////////////////////////    201 //////////////////////////////////////////////////////////////////////////////
209 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!    202 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
210 {                                                 203 {
211   switch (aMessage) {                          << 204 /*
212     case WM_SIZE: {                            << 205   switch (aMessage) { 
213       //FIXME : have to handle WM_RESIZE       << 206   case WM_PAINT:{
214       // Seems to be done (ovidio.pena AT upm. << 207     printf("debug : PAINT\n");
215       auto* This = (G4OpenGLWin32Viewer*)      << 208     HDC hDC;
216                    ::GetWindowLongPtr(aWindow, << 209     PAINTSTRUCT ps;
217       if (This) {                              << 210     hDC = BeginPaint(aWindow,&ps);
218         This->fWinSize_x = (G4int) LOWORD(aLPa << 211     if(This) {
219         This->fWinSize_y = (G4int) HIWORD(aLPa << 212       // FIXME : To have an automatic refresh someone have to redraw here.
220         if (!This->fInCreateWindow) {          << 213     }
221           This->SetView();                     << 214     EndPaint(aWindow, &ps);
222           glViewport(0, 0, This->fWinSize_x, T << 215 
223           This->DrawView();                    << 216     //FIXME : have to handle WM_RESIZE
224         }                                      << 217     //pView->fWinSize_x = (G4int) width;
225       }                                        << 218     //pView->fWinSize_y = (G4int) height;
226       return 0;                                << 219     G4OpenGLWin32Viewer* This = 
227     }                                          << 220       (G4OpenGLWin32Viewer*)::GetWindowLong(aWindow,GWL_USERDATA);
228                                                << 221     if(This) {
229     case WM_PAINT: {                           << 
230       PAINTSTRUCT ps;                          << 
231       BeginPaint(aWindow, &ps);                << 
232       auto* This = (G4OpenGLWin32Viewer*)      << 
233                    ::GetWindowLongPtr(aWindow, << 
234       if (This) {                              << 
235         //FIXME : To have an automatic refresh << 
236         // Seems to be done (ovidio.pena AT up << 
237         if(!This->fInCreateWindow) {           << 
238           This->SetView();                     << 
239           This->ClearView();                   << 
240           This->DrawView();                    << 
241         }                                      << 
242       }                                        << 
243       EndPaint(aWindow, &ps);                  << 
244       return 0;                                << 
245     }                                          << 
246                                                << 
247     case WM_LBUTTONDOWN: {                     << 
248       auto* This = (G4OpenGLWin32Viewer*)      << 
249                    ::GetWindowLongPtr(aWindow, << 
250       This->TrackMouse(LOWORD(aLParam), HIWORD << 
251       return 0;                                << 
252     }                                          << 
253                                                << 
254     case WM_RBUTTONDOWN: {                     << 
255       auto* This = (G4OpenGLWin32Viewer*)      << 
256                    ::GetWindowLongPtr(aWindow, << 
257       This->TrackMouse(LOWORD(aLParam), HIWORD << 
258       return 0;                                << 
259     }                                          << 
260                                                << 
261     case WM_LBUTTONUP: {                       << 
262       auto* This = (G4OpenGLWin32Viewer*)      << 
263                    ::GetWindowLongPtr(aWindow, << 
264       This->ReleaseMouse();                    << 
265       return 0;                                << 
266     }                                          << 
267                                                << 
268     case WM_RBUTTONUP: {                       << 
269       auto* This = (G4OpenGLWin32Viewer*)      << 
270                    ::GetWindowLongPtr(aWindow, << 
271       This->ReleaseMouse();                    << 
272       return 0;                                << 
273     }                                          << 
274                                                << 
275     case WM_MOUSEHOVER: {                      << 
276       auto* This = (G4OpenGLWin32Viewer*)      << 
277                    ::GetWindowLongPtr(aWindow, << 
278       This->fMouseHovered = true;              << 
279             return 0;                          << 
280     }                                          << 
281                                                << 
282     case WM_MOUSELEAVE: {                      << 
283       auto* This = (G4OpenGLWin32Viewer*)      << 
284                    ::GetWindowLongPtr(aWindow, << 
285       This->fMouseHovered = false;             << 
286       return 0;                                << 
287     }                                          << 
288                                                << 
289     case WM_MOUSEMOVE: {                       << 
290       auto* This = (G4OpenGLWin32Viewer*)      << 
291                    ::GetWindowLongPtr(aWindow, << 
292                                                << 
293       if (!This->fMouseHovered) {              << 
294         // mouse hover/leave tracking          << 
295         TRACKMOUSEEVENT tme;                   << 
296         tme.cbSize = sizeof(tme);              << 
297         tme.dwFlags = TME_HOVER | TME_LEAVE;   << 
298         tme.hwndTrack = aWindow;               << 
299         tme.dwHoverTime = HOVER_DEFAULT;       << 
300         ::TrackMouseEvent(&tme);               << 
301         This->fMouseHovered = true;            << 
302       }                                        << 
303                                                << 
304       if (This->fMousePressed) {               << 
305         G4int x = (G4int) LOWORD(aLParam);     << 
306         G4int y = (G4int) HIWORD(aLParam);     << 
307         G4int dx = x - This->fMousePressedX;   << 
308         G4int dy = y - This->fMousePressedY;   << 
309         This->fMousePressedX = x;              << 
310         This->fMousePressedY = y;              << 
311                                                << 
312         if (aWParam == MK_LBUTTON) {  // Rotat << 
313           This->SetRotation(dx, dy);           << 
314         }                                      << 
315                                                << 
316         if (aWParam == MK_RBUTTON) {  // Shift << 
317           This->SetShift(dx, dy);              << 
318         }                                      << 
319                                                << 
320         This->SetView();                       << 
321         This->ClearView();                     << 
322         This->DrawView();                      << 
323       }                                        << 
324                                                << 
325       return 0;                                << 
326     }                                          << 
327                                                << 
328     case WM_MOUSEWHEEL: {                      << 
329       auto* This = (G4OpenGLWin32Viewer*)      << 
330                    ::GetWindowLongPtr(aWindow, << 
331                                                << 
332       G4int delta = (short) HIWORD(aWParam);   << 
333                                                << 
334       This->SetZoom(delta);                    << 
335                                                << 
336       This->SetView();                            222       This->SetView();
                                                   >> 223       glViewport(0,0,This->fWinSize_x,This->fWinSize_y);
337       This->ClearView();                          224       This->ClearView();
338       This->DrawView();                           225       This->DrawView();
339       return 0;                                << 226       // WARNING : the below empty the Windows message queue...
                                                   >> 227       This->FinishView();
340     }                                             228     }
341                                                << 229   } return 0;
342     default:                                   << 230   default:
343       return DefWindowProc(aWindow, aMessage,  << 231     return DefWindowProc(aWindow,aMessage,aWParam,aLParam);
344   }                                               232   }
345 //  return DefWindowProc(aWindow,aMessage,aWPa << 233 */
                                                   >> 234   return DefWindowProc(aWindow,aMessage,aWParam,aLParam);
346 }                                                 235 }
347                                                   236 
348 //////////////////////////////////////////////    237 //////////////////////////////////////////////////////////////////////////////
349 G4bool G4OpenGLWin32Viewer::SetWindowPixelForm << 238 bool G4OpenGLWin32Viewer::SetWindowPixelFormat(
350  HDC aHdc                                         239  HDC aHdc
351 )                                                 240 )
352 //////////////////////////////////////////////    241 //////////////////////////////////////////////////////////////////////////////
353 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!    242 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
354 {                                                 243 {
355   // The ungessable...                            244   // The ungessable...
356                                                   245 
357   PIXELFORMATDESCRIPTOR pfd;                      246   PIXELFORMATDESCRIPTOR pfd;
358   pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);      247   pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
359   pfd.nVersion = 1;                               248   pfd.nVersion = 1;
360   pfd.dwFlags =                                   249   pfd.dwFlags = 
361     PFD_DRAW_TO_WINDOW |                          250     PFD_DRAW_TO_WINDOW | 
362     PFD_SUPPORT_OPENGL |                          251     PFD_SUPPORT_OPENGL | 
363     PFD_DOUBLEBUFFER |                            252     PFD_DOUBLEBUFFER | 
364     PFD_STEREO_DONTCARE;                          253     PFD_STEREO_DONTCARE;  
365   pfd.iPixelType = PFD_TYPE_RGBA;                 254   pfd.iPixelType = PFD_TYPE_RGBA;
366   pfd.cColorBits = 32;                            255   pfd.cColorBits = 32;
367   pfd.cRedBits = 8;                               256   pfd.cRedBits = 8;
368   pfd.cRedShift = 16;                             257   pfd.cRedShift = 16;
369   pfd.cGreenBits = 8;                             258   pfd.cGreenBits = 8;
370   pfd.cGreenShift = 8;                            259   pfd.cGreenShift = 8;
371   pfd.cBlueBits = 8;                              260   pfd.cBlueBits = 8;
372   pfd.cBlueShift = 0;                             261   pfd.cBlueShift = 0;
373   pfd.cAlphaBits = 0;                             262   pfd.cAlphaBits = 0;
374   pfd.cAlphaShift = 0;                            263   pfd.cAlphaShift = 0;
375   pfd.cAccumBits = 64;                            264   pfd.cAccumBits = 64;  
376   pfd.cAccumRedBits = 16;                         265   pfd.cAccumRedBits = 16;
377   pfd.cAccumGreenBits = 16;                       266   pfd.cAccumGreenBits = 16;
378   pfd.cAccumBlueBits = 16;                        267   pfd.cAccumBlueBits = 16;
379   pfd.cAccumAlphaBits = 0;                        268   pfd.cAccumAlphaBits = 0;
380   pfd.cDepthBits = 32;                            269   pfd.cDepthBits = 32;
381   pfd.cStencilBits = 8;                           270   pfd.cStencilBits = 8;
382   pfd.cAuxBuffers = 0;                            271   pfd.cAuxBuffers = 0;
383   pfd.iLayerType = PFD_MAIN_PLANE;                272   pfd.iLayerType = PFD_MAIN_PLANE;
384   pfd.bReserved = 0;                              273   pfd.bReserved = 0;
385   pfd.dwLayerMask = 0;                            274   pfd.dwLayerMask = 0;
386   pfd.dwVisibleMask = 0;                          275   pfd.dwVisibleMask = 0;
387   pfd.dwDamageMask = 0;                           276   pfd.dwDamageMask = 0;
388                                                   277   
389   G4int pixelIndex = ::ChoosePixelFormat(aHdc, << 278   int pixelIndex = ::ChoosePixelFormat(aHdc,&pfd);
390   if (pixelIndex==0) {                            279   if (pixelIndex==0) {
391     pixelIndex = 1;                               280     pixelIndex = 1; 
392     if (::DescribePixelFormat(aHdc,               281     if (::DescribePixelFormat(aHdc, 
393             pixelIndex,                           282             pixelIndex, 
394             sizeof(PIXELFORMATDESCRIPTOR),        283             sizeof(PIXELFORMATDESCRIPTOR), 
395             &pfd)==0) {                           284             &pfd)==0) {
396       return false;                               285       return false;
397     }                                             286     }
398   }                                               287   }
399   if (::SetPixelFormat(aHdc,pixelIndex,&pfd)==    288   if (::SetPixelFormat(aHdc,pixelIndex,&pfd)==FALSE) return false;
400   return true;                                    289   return true;
401 }                                                 290 }
402                                                   291 
403 ////////////////////////////////////////////// << 
404 void G4OpenGLWin32Viewer::TrackMouse(          << 
405  G4int x                                       << 
406 ,G4int y                                       << 
407 )                                              << 
408 ////////////////////////////////////////////// << 
409 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 
410 {                                              << 
411   fMousePressed = true;                        << 
412   fMousePressedX = x;                          << 
413   fMousePressedY = y;                          << 
414 }                                              << 
415                                                << 
416 ////////////////////////////////////////////// << 
417 void G4OpenGLWin32Viewer::ReleaseMouse(        << 
418 )                                              << 
419 ////////////////////////////////////////////// << 
420 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 
421 {                                              << 
422   fMousePressed = false;                       << 
423   fMousePressedX = 0;                          << 
424   fMousePressedY = 0;                          << 
425 }                                              << 
426                                                << 
427 ////////////////////////////////////////////// << 
428 void G4OpenGLWin32Viewer::SetShift(            << 
429  G4int dx                                      << 
430 ,G4int dy                                      << 
431 )                                              << 
432 ////////////////////////////////////////////// << 
433 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 
434 {                                              << 
435   const G4double sceneRadius = GetSceneHandler << 
436                              ->GetExtent().Get << 
437   const G4double scale = 300;  // Roughly pixe << 
438   const G4double dxScene = dx*sceneRadius/scal << 
439   const G4double dyScene = dy*sceneRadius/scal << 
440   fVP.IncrementPan(-dxScene,dyScene);          << 
441 }                                              << 
442                                                << 
443 ////////////////////////////////////////////// << 
444 void G4OpenGLWin32Viewer::SetRotation(         << 
445  G4int dx                                      << 
446 ,G4int dy                                      << 
447 )                                              << 
448 ////////////////////////////////////////////// << 
449 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 
450 {                                              << 
451   // Simple ad-hoc algorithms (borrowed from G << 
452   const G4Vector3D& x_prime = fVP.GetViewpoint << 
453                               .cross(fVP.GetUp << 
454   const G4Vector3D& y_prime = x_prime.cross(fV << 
455   const G4double scale = 200;  // Roughly pixe << 
456   G4Vector3D newViewpointDirection = fVP.GetVi << 
457   newViewpointDirection += dx*x_prime/scale;   << 
458   newViewpointDirection += dy*y_prime/scale;   << 
459   fVP.SetViewpointDirection(newViewpointDirect << 
460                                                << 
461   if (fVP.GetRotationStyle() == G4ViewParamete << 
462       G4Vector3D newUpVector = fVP.GetUpVector << 
463       newUpVector += dx*x_prime/scale;         << 
464       newUpVector += dy*y_prime/scale;         << 
465       fVP.SetUpVector(newUpVector.unit());     << 
466   }                                            << 
467 }                                              << 
468                                                << 
469 ////////////////////////////////////////////// << 
470 void G4OpenGLWin32Viewer::SetZoom(             << 
471  G4int delta                                   << 
472 )                                              << 
473 ////////////////////////////////////////////// << 
474 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 
475 {                                              << 
476     if (fVP.GetFieldHalfAngle() == 0.) {  // O << 
477         const G4double scale = 500;  // Empiri << 
478         fVP.MultiplyZoomFactor(1. + delta/scal << 
479     } else {                              // P << 
480         const G4double scale = fVP.GetFieldHal << 
481         fVP.SetDolly(fVP.GetDolly() + delta/sc << 
482     }                                          << 
483 }                                              << 
484                                                   292 
                                                   >> 293 #endif
485                                                   294