Geant4 Cross Reference

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


  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: G4OpenGLXViewer.cc 92942 2015-09-22 07:31:39Z gcosmo $
 27 //                                                 28 //
 28 //                                                 29 // 
 29 // Andrew Walkden  7th February 1997               30 // Andrew Walkden  7th February 1997
 30 // G4OpenGLXViewer : Class to provide XWindows     31 // G4OpenGLXViewer : Class to provide XWindows specific
 31 //                 functionality for OpenGL in     32 //                 functionality for OpenGL in GEANT4
 32                                                    33 
                                                   >>  34 #ifdef G4VIS_BUILD_OPENGLX_DRIVER
                                                   >>  35 
 33 #include "G4OpenGLXViewer.hh"                      36 #include "G4OpenGLXViewer.hh"
 34                                                    37 
 35 #include "G4OpenGLSceneHandler.hh"                 38 #include "G4OpenGLSceneHandler.hh"
 36 #include "G4OpenGLFontBaseStore.hh"                39 #include "G4OpenGLFontBaseStore.hh"
 37                                                    40 
 38 #include "G4VisExtent.hh"                          41 #include "G4VisExtent.hh"
 39 #include "G4LogicalVolume.hh"                      42 #include "G4LogicalVolume.hh"
 40 #include "G4VSolid.hh"                             43 #include "G4VSolid.hh"
 41 #include "G4Point3D.hh"                            44 #include "G4Point3D.hh"
 42 #include "G4Normal3D.hh"                           45 #include "G4Normal3D.hh"
 43 #include "G4StateManager.hh"                       46 #include "G4StateManager.hh"
 44 #include "G4VisManager.hh"                         47 #include "G4VisManager.hh"
 45 #include "G4Text.hh"                               48 #include "G4Text.hh"
 46 #include "G4Threading.hh"                          49 #include "G4Threading.hh"
 47                                                    50 
 48 #include <X11/Xatom.h>                             51 #include <X11/Xatom.h>
 49 #include <X11/Xutil.h>                             52 #include <X11/Xutil.h>
 50 #include <X11/Xmu/StdCmap.h>                       53 #include <X11/Xmu/StdCmap.h>
 51                                                    54 
 52 #include <assert.h>                                55 #include <assert.h>
 53 #include <sstream>                                 56 #include <sstream>
 54 #include <chrono>                                  57 #include <chrono>
 55 #include <thread>                                  58 #include <thread>
 56                                                    59 
 57 int G4OpenGLXViewer::snglBuf_RGBA[12] =            60 int G4OpenGLXViewer::snglBuf_RGBA[12] =
 58 { GLX_RGBA,                                        61 { GLX_RGBA,
 59   GLX_RED_SIZE, 1,                                 62   GLX_RED_SIZE, 1,
 60   GLX_GREEN_SIZE, 1,                               63   GLX_GREEN_SIZE, 1, 
 61   GLX_BLUE_SIZE, 1,                                64   GLX_BLUE_SIZE, 1,
 62   GLX_DEPTH_SIZE, 1,                               65   GLX_DEPTH_SIZE, 1,
 63   GLX_STENCIL_SIZE, 1,                             66   GLX_STENCIL_SIZE, 1,
 64   None };                                          67   None };
 65                                                    68 
 66 int G4OpenGLXViewer::dblBuf_RGBA[13] =             69 int G4OpenGLXViewer::dblBuf_RGBA[13] =
 67 { GLX_RGBA,                                        70 { GLX_RGBA,
 68   GLX_RED_SIZE, 1,                                 71   GLX_RED_SIZE, 1,
 69   GLX_GREEN_SIZE, 1,                               72   GLX_GREEN_SIZE, 1,
 70   GLX_BLUE_SIZE, 1,                                73   GLX_BLUE_SIZE, 1,
 71   GLX_DOUBLEBUFFER,                                74   GLX_DOUBLEBUFFER,
 72   GLX_DEPTH_SIZE, 1,                               75   GLX_DEPTH_SIZE, 1,
 73   GLX_STENCIL_SIZE, 1,                             76   GLX_STENCIL_SIZE, 1,
 74   None };                                          77   None };
 75                                                    78 
 76 #define NewString(str) \                           79 #define NewString(str) \
 77   ((str) != 0 ? (strncpy((char*)malloc((unsign     80   ((str) != 0 ? (strncpy((char*)malloc((unsigned)strlen(str) + 1), str, (unsigned)strlen(str) + 1)) : (char*)0)
 78                                                    81 
 79 #define USE_DEFAULT_COLORMAP 1                     82 #define USE_DEFAULT_COLORMAP 1
 80 #define USE_STANDARD_COLORMAP 0                    83 #define USE_STANDARD_COLORMAP 0
 81                                                    84 
 82 XVisualInfo*  G4OpenGLXViewer::vi_single_buffe     85 XVisualInfo*  G4OpenGLXViewer::vi_single_buffer = 0;
 83 XVisualInfo*  G4OpenGLXViewer::vi_double_buffe     86 XVisualInfo*  G4OpenGLXViewer::vi_double_buffer = 0;
 84                                                    87 
 85 extern "C" {                                       88 extern "C" {
 86   static Bool G4OpenGLXViewerWaitForNotify (Di     89   static Bool G4OpenGLXViewerWaitForNotify (Display*, XEvent* e, char* arg) {
 87     return (e->type == MapNotify) && (e->xmap.     90     return (e->type == MapNotify) && (e->xmap.window == (Window) arg);
 88   }                                                91   }
 89 }                                                  92 }
 90                                                    93 
 91 void G4OpenGLXViewer::SetView () {                 94 void G4OpenGLXViewer::SetView () {
 92   if (G4Threading::IsMasterThread()) {         << 
 93     glXMakeCurrent (dpy, win, cxMaster);       << 
 94   } else {                                     << 
 95     glXMakeCurrent (dpy, win, cxVisSubThread); << 
 96   }                                            << 
 97   G4OpenGLViewer::SetView ();                      95   G4OpenGLViewer::SetView ();
 98 }                                                  96 }
 99                                                    97 
100 void G4OpenGLXViewer::ShowView () {                98 void G4OpenGLXViewer::ShowView () {
101 //  glXWaitGL (); //Wait for effects of all pr <<  99 #ifdef G4MULTITHREADED
                                                   >> 100 //  G4int thread_id = G4Threading::G4GetThreadId();
                                                   >> 101 //  G4cout << "G4OpenGLXViewer::ShowView: thread " << thread_id << G4endl;
                                                   >> 102 #endif
                                                   >> 103   glXWaitGL (); //Wait for effects of all previous OpenGL commands to
102                 //be propagated before progres    104                 //be propagated before progressing.
103 // JA: Commented out July 2021 - slows renderi << 
104 // don't see any adverse effects.              << 
105                                                << 
106   glFlush ();                                     105   glFlush ();
107                                                   106 
108   if (fVP.IsPicking()) {                          107   if (fVP.IsPicking()) {
109     G4cout <<                                     108     G4cout <<
110       "Window activated for picking (left-mous    109       "Window activated for picking (left-mouse), exit (middle-mouse)."
111      << G4endl;                                   110      << G4endl;
112     while (true) {                                111     while (true) {
113       if (XPending(dpy)) {                        112       if (XPending(dpy)) {
114   XNextEvent(dpy, &event);                        113   XNextEvent(dpy, &event);
115   if (event.type == ButtonPress && event.xbutt    114   if (event.type == ButtonPress && event.xbutton.button == 1) {
116     G4cout << Pick(event.xbutton.x, event.xbut    115     G4cout << Pick(event.xbutton.x, event.xbutton.y) << G4endl;
117   }                                               116   }
118   else if (event.type == ButtonPress && event.    117   else if (event.type == ButtonPress && event.xbutton.button == 2) break;
119       }                                           118       }
120       std::this_thread::sleep_for(std::chrono:    119       std::this_thread::sleep_for(std::chrono::milliseconds(100));
121     }                                             120     }
122   }                                               121   }
123 }                                                 122 }
124                                                   123 
                                                   >> 124 #ifdef G4MULTITHREADED
                                                   >> 125 
125 void G4OpenGLXViewer::SwitchToVisSubThread()      126 void G4OpenGLXViewer::SwitchToVisSubThread()
126 {                                                 127 {
127 #ifdef G4MULTITHREADED                         << 128 //  G4cout << "G4OpenGLXViewer::SwitchToVisSubThread" << G4endl;
128   cxVisSubThread = glXCreateContext (dpy, vi,     129   cxVisSubThread = glXCreateContext (dpy, vi, cxMaster, true);
129   glXMakeCurrent (dpy, win, cxVisSubThread);      130   glXMakeCurrent (dpy, win, cxVisSubThread);
130 #endif                                         << 
131 }                                                 131 }
132                                                   132 
133 void G4OpenGLXViewer::SwitchToMasterThread()      133 void G4OpenGLXViewer::SwitchToMasterThread()
134 {                                                 134 {
135 #ifdef G4MULTITHREADED                         << 135 //  G4cout << "G4OpenGLXViewer::SwitchToMasterThread" << G4endl;
136   glXMakeCurrent (dpy, win, cxMaster);            136   glXMakeCurrent (dpy, win, cxMaster);
137   // and destroy sub-thread context               137   // and destroy sub-thread context
138   glXDestroyContext (dpy, cxVisSubThread);        138   glXDestroyContext (dpy, cxVisSubThread);
139 #endif                                         << 
140 }                                                 139 }
141                                                   140 
                                                   >> 141 #endif
                                                   >> 142 
142 void G4OpenGLXViewer::GetXConnection () {         143 void G4OpenGLXViewer::GetXConnection () {
143 // get a connection.                              144 // get a connection.
144   dpy = XOpenDisplay (0);  // Uses DISPLAY env    145   dpy = XOpenDisplay (0);  // Uses DISPLAY environment variable.
145   if (!dpy) {                                     146   if (!dpy) {
146     fViewId = -1;  // This flags an error.        147     fViewId = -1;  // This flags an error.
147     G4cerr << "G4OpenGLXViewer::G4OpenGLXViewe    148     G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer couldn't open display." << G4endl;
148     return;                                       149     return;
149   }                                               150   }
150                                                   151 
151 // make sure OpenGL is supported and installed    152 // make sure OpenGL is supported and installed properly.
152   if (!glXQueryExtension (dpy, &errorBase, &ev    153   if (!glXQueryExtension (dpy, &errorBase, &eventBase)) {
153     fViewId = -1;  // This flags an error.        154     fViewId = -1;  // This flags an error.
154     G4cerr << "G4OpenGLXViewer::G4OpenGLXViewe    155     G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer X Server has no GLX extension." 
155    << G4endl;                                     156    << G4endl;
156     return;                                       157     return;
157   }                                               158   }
158                                                   159 
159 }                                                 160 }
160                                                   161 
161 void G4OpenGLXViewer::CreateGLXContext (XVisua    162 void G4OpenGLXViewer::CreateGLXContext (XVisualInfo* v) {
162                                                   163 
163   vi = v;                                         164   vi = v;
164 // get window's attributes                        165 // get window's attributes
165   if (!XGetWindowAttributes(dpy, XRootWindow (    166   if (!XGetWindowAttributes(dpy, XRootWindow (dpy, vi -> screen), &xwa)) {
166     fViewId = -1;  // This flags an error.        167     fViewId = -1;  // This flags an error.
167     G4cerr << "G4OpenGLXViewer::G4OpenGLXViewe    168     G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer couldn't return window attributes"
168    << G4endl;                                     169    << G4endl;
169     return;                                       170     return;
170   }                                               171   }
171                                                   172   
172 // create the master GLX context                  173 // create the master GLX context
173   cxMaster = glXCreateContext (dpy, vi, 0, tru    174   cxMaster = glXCreateContext (dpy, vi, 0, true);
174   if (!cxMaster) {                                175   if (!cxMaster) {
175     fViewId = -1;  // This flags an error.        176     fViewId = -1;  // This flags an error.
176     G4cerr << "G4OpenGLXViewer::G4OpenGLXViewe    177     G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer couldn't create context."
177    << G4endl;                                     178    << G4endl;
178     return;                                       179     return;
179   }                                               180   }
180                                                   181 
181 // New stab at getting a colormap                 182 // New stab at getting a colormap
182                                                   183 
183   Status status;                                  184   Status status;
                                                   >> 185   XStandardColormap *standardCmaps = XAllocStandardColormap ();
184   int i, numCmaps;                                186   int i, numCmaps;
185                                                   187 
186   status = XmuLookupStandardColormap (dpy,        188   status = XmuLookupStandardColormap (dpy, 
187               vi -> screen,                       189               vi -> screen, 
188               vi -> visualid,                     190               vi -> visualid, 
189               vi -> depth,                        191               vi -> depth, 
190               XA_RGB_BEST_MAP,                 << 192               XA_RGB_DEFAULT_MAP, 
191               False,                              193               False, 
192               True);                              194               True);
193                                                << 195   
194   if (status == 1) {                              196   if (status == 1) {
195     cmap = 0;                                     197     cmap = 0;
196     XStandardColormap* standardCmaps = XAllocS << 
197     status = XGetRGBColormaps (dpy,               198     status = XGetRGBColormaps (dpy, 
198              XRootWindow (dpy, vi -> screen),  << 199              XRootWindow (dpy, vi -> screen), 
199              &standardCmaps,                      200              &standardCmaps, 
200              &numCmaps,                           201              &numCmaps, 
201              XA_RGB_BEST_MAP);                 << 202              XA_RGB_DEFAULT_MAP);
202     if (status == 1) {                         << 203     if (status == 1)
203       for (i = 0; i < numCmaps; i++) {            204       for (i = 0; i < numCmaps; i++) {
204   if (standardCmaps[i].visualid == vi -> visua    205   if (standardCmaps[i].visualid == vi -> visualid) {
205     cmap = standardCmaps[i].colormap;             206     cmap = standardCmaps[i].colormap;
                                                   >> 207     XFree (standardCmaps);
206     break;                                        208     break;
207   }                                               209   }
208       }                                           210       }
                                                   >> 211     if (!cmap) {
                                                   >> 212       fViewId = -1;  // This flags an error.
                                                   >> 213       if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
                                                   >> 214   G4cerr <<
                                                   >> 215   "G4OpenGLXViewer::G4OpenGLXViewer failed to allocate a standard colormap."
                                                   >> 216          << G4endl;
                                                   >> 217       return;
209     }                                             218     }
210     XFree (standardCmaps);                     << 219     if (G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
211     if(cmap) {                                 << 220       G4cout << "Got standard cmap" << G4endl;
212       if (G4VisManager::GetVerbosity() >= G4Vi << 
213         G4cout << "Got standard cmap" << G4end << 
214     } else {                                   << 
215       //if (G4VisManager::GetVerbosity() >= G4 << 
216       //  G4cerr << "G4OpenGLXViewer::G4OpenGL << 
217       //         << G4endl;                    << 
218       cmap = XCreateColormap (dpy,             << 
219                               XRootWindow(dpy, << 
220                               vi -> visual,    << 
221                               AllocNone);      << 
222       if(cmap) {                               << 
223         if (G4VisManager::GetVerbosity() >= G4 << 
224           G4cout << "Created own cmap" << G4en << 
225       }                                        << 
226       //G.Barrand : at end, we should do a XFr << 
227     }                                          << 
228   } else {                                        221   } else {
229     cmap = XCreateColormap (dpy,                  222     cmap = XCreateColormap (dpy, 
230           XRootWindow(dpy, vi -> screen),         223           XRootWindow(dpy, vi -> screen), 
231           vi -> visual,                           224           vi -> visual, 
232           AllocNone);                             225           AllocNone);
233     if(cmap) {                                 << 226     if (G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
234       if (G4VisManager::GetVerbosity() >= G4Vi << 227       G4cout << "Created own cmap" << G4endl;
235         G4cout << "Created own cmap" << G4endl << 
236     }                                          << 
237     //G.Barrand : at end, we should do a XFree << 
238   }                                               228   }
239                                                   229 
240   if (!cmap) {                                    230   if (!cmap) {
241     fViewId = -1;  // This flags an error.        231     fViewId = -1;  // This flags an error.
242     if (G4VisManager::GetVerbosity() >= G4VisM    232     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
243       G4cout << "G4OpenGLXViewer::G4OpenGLXVie    233       G4cout << "G4OpenGLXViewer::G4OpenGLXViewer failed to allocate a Colormap."
244        << G4endl;                                 234        << G4endl;
245     return;                                       235     return;
246   }                                               236   }
247                                                   237 
248 }                                                 238 }
249                                                   239   
250 void G4OpenGLXViewer::CreateMainWindow () {       240 void G4OpenGLXViewer::CreateMainWindow () {
251                                                   241   
252 // create a window                                242 // create a window
253   swa.colormap = cmap;                            243   swa.colormap = cmap;
254   swa.border_pixel = 0;                           244   swa.border_pixel = 0;
255   swa.event_mask = ExposureMask | ButtonPressM    245   swa.event_mask = ExposureMask | ButtonPressMask | StructureNotifyMask;
256   swa.backing_store = WhenMapped;                 246   swa.backing_store = WhenMapped;
257                                                   247 
258   // Window size and position...                  248   // Window size and position...
259   size_hints = XAllocSizeHints();                 249   size_hints = XAllocSizeHints();
260                                                   250     
261   ResizeWindow(fVP.GetWindowSizeHintX(),fVP.Ge    251   ResizeWindow(fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
262                                                   252 
263   G4int x_origin = fVP.GetWindowAbsoluteLocati    253   G4int x_origin = fVP.GetWindowAbsoluteLocationHintX(DisplayWidth(dpy, vi -> screen));
264                                                   254 
265   // FIXME,  screen size != window size on MAC    255   // FIXME,  screen size != window size on MAC, but I don't know have to get the menuBar
266   // size on MAC. L.Garnier 01/2009               256   // size on MAC. L.Garnier 01/2009
267   G4int y_origin = fVP.GetWindowAbsoluteLocati    257   G4int y_origin = fVP.GetWindowAbsoluteLocationHintY(DisplayHeight(dpy, vi -> screen));
268                                                   258 
269   size_hints->base_width = getWinWidth();         259   size_hints->base_width = getWinWidth();
270   size_hints->base_height = getWinHeight();       260   size_hints->base_height = getWinHeight();
271   size_hints->x = x_origin;                       261   size_hints->x = x_origin;
272   size_hints->y = y_origin;                       262   size_hints->y = y_origin;
273   if (fVP.IsWindowSizeHintX () && fVP.IsWindow    263   if (fVP.IsWindowSizeHintX () && fVP.IsWindowLocationHintX () && fVP.IsWindowLocationHintY ()) {
274     size_hints->flags |= PSize | PPosition;       264     size_hints->flags |= PSize | PPosition;
275   } else if (fVP.IsWindowSizeHintX () && !(fVP    265   } else if (fVP.IsWindowSizeHintX () && !(fVP.IsWindowLocationHintX () || fVP.IsWindowLocationHintY ())) {
276     size_hints->flags |= PSize;                   266     size_hints->flags |= PSize;
277   } else if ((!fVP.IsWindowSizeHintX ()) && fV    267   } else if ((!fVP.IsWindowSizeHintX ()) && fVP.IsWindowLocationHintX () && fVP.IsWindowLocationHintY ()) {
278     size_hints->flags |= PPosition;               268     size_hints->flags |= PPosition;
279   }                                               269   }
280   if (G4VisManager::GetVerbosity() >= G4VisMan    270   if (G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
281     G4cout << "Window name: " << fName << G4en    271     G4cout << "Window name: " << fName << G4endl;
282   strncpy (charViewName, fName, 99); charViewN    272   strncpy (charViewName, fName, 99); charViewName[99] = '\0';
283   char *window_name = charViewName;               273   char *window_name = charViewName;
284   char *icon_name = charViewName;                 274   char *icon_name = charViewName;
285   //char tmpatom[] = "XA_WM_NORMAL_HINTS";        275   //char tmpatom[] = "XA_WM_NORMAL_HINTS"; 
286   wm_hints = XAllocWMHints();                     276   wm_hints = XAllocWMHints();
287   class_hints = XAllocClassHint();                277   class_hints = XAllocClassHint();
288                                                   278 
289   XStringListToTextProperty (&window_name, 1,     279   XStringListToTextProperty (&window_name, 1, &windowName);
290   XStringListToTextProperty (&icon_name, 1, &i    280   XStringListToTextProperty (&icon_name, 1, &iconName);
291                                                   281 
292   wm_hints -> initial_state = NormalState;        282   wm_hints -> initial_state = NormalState;
293   wm_hints -> input = True;                       283   wm_hints -> input = True;
294   wm_hints -> icon_pixmap = icon_pixmap;          284   wm_hints -> icon_pixmap = icon_pixmap;
295   wm_hints -> flags = StateHint | IconPixmapHi    285   wm_hints -> flags = StateHint | IconPixmapHint | InputHint;
296                                                   286 
297   class_hints -> res_name  = NewString("G4Open    287   class_hints -> res_name  = NewString("G4OpenGL");
298   class_hints -> res_class = NewString("G4Open    288   class_hints -> res_class = NewString("G4OpenGL");
299                                                   289 
300    win = XCreateWindow (dpy, XRootWindow (dpy,    290    win = XCreateWindow (dpy, XRootWindow (dpy, vi -> screen), x_origin, 
301                         y_origin, getWinWidth(    291                         y_origin, getWinWidth(), getWinHeight(), 0, vi -> depth,
302                         InputOutput, vi -> vis    292                         InputOutput, vi -> visual,  
303                         CWBorderPixel | CWColo    293                         CWBorderPixel | CWColormap | 
304                         CWEventMask | CWBackin    294                         CWEventMask | CWBackingStore,
305                         &swa);                    295                         &swa);
306                                                   296   
307    XSetWMProperties (dpy, win, &windowName, &i    297    XSetWMProperties (dpy, win, &windowName, &iconName, 0, 0, 
308                      size_hints, wm_hints, cla    298                      size_hints, wm_hints, class_hints);
309                                                   299   
310 // request X to Draw window on screen.            300 // request X to Draw window on screen.
311   XMapWindow (dpy, win);                          301   XMapWindow (dpy, win);
312                                                   302 
313 // Wait for window to appear (wait for an "exp    303 // Wait for window to appear (wait for an "expose" event).
314   XIfEvent (dpy, &event, G4OpenGLXViewerWaitFo    304   XIfEvent (dpy, &event, G4OpenGLXViewerWaitForNotify, (char*) win);
315                                                   305 
316 // connect the context to a window                306 // connect the context to a window
317   Bool success = glXMakeCurrent (dpy, win, cxM    307   Bool success = glXMakeCurrent (dpy, win, cxMaster);
318   if (!success) {                                 308   if (!success) {
319     fViewId = -1;  // This flags an error.        309     fViewId = -1;  // This flags an error.
320     G4cerr << "G4OpenGLXViewer::G4OpenGLXViewe    310     G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer failed to attach a GLX context."
321    << G4endl;                                     311    << G4endl;
322     GLint error = GL_NO_ERROR;                    312     GLint error = GL_NO_ERROR;
323     while ((error = glGetError()) != GL_NO_ERR    313     while ((error = glGetError()) != GL_NO_ERROR) {
324       switch (error) {                            314       switch (error) {
325       case GL_INVALID_ENUM :                      315       case GL_INVALID_ENUM :
326   G4cout << "GL Error: GL_INVALID_ENUM" << G4e    316   G4cout << "GL Error: GL_INVALID_ENUM" << G4endl;break;
327       case GL_INVALID_VALUE :                     317       case GL_INVALID_VALUE :
328   G4cout << "GL Error: GL_INVALID_VALUE" << G4    318   G4cout << "GL Error: GL_INVALID_VALUE" << G4endl;break;
329       case GL_INVALID_OPERATION :                 319       case GL_INVALID_OPERATION :
330   G4cout << "GL Error: GL_INVALID_OPERATION" <    320   G4cout << "GL Error: GL_INVALID_OPERATION" << G4endl;break;
331       case GL_OUT_OF_MEMORY :                     321       case GL_OUT_OF_MEMORY :
332   G4cout << "GL Error: GL_OUT_OF_MEMORY" << G4    322   G4cout << "GL Error: GL_OUT_OF_MEMORY" << G4endl;break;
333       case GL_STACK_UNDERFLOW :                   323       case GL_STACK_UNDERFLOW :
334   G4cout << "GL Error: GL_STACK_UNDERFLOW" <<     324   G4cout << "GL Error: GL_STACK_UNDERFLOW" << G4endl;break;
335       case GL_STACK_OVERFLOW :                    325       case GL_STACK_OVERFLOW :
336   G4cout << "GL Error: GL_STACK_OVERFLOW" << G    326   G4cout << "GL Error: GL_STACK_OVERFLOW" << G4endl;break;
337       default :                                   327       default :
338   G4cout << "GL Error: " << error << G4endl;br    328   G4cout << "GL Error: " << error << G4endl;break;
339       }                                           329       }
340     }                                             330     }
341     return;                                       331     return;
342   }                                               332   }
343 }                                                 333 }
344                                                   334 
345 void G4OpenGLXViewer::CreateFontLists()           335 void G4OpenGLXViewer::CreateFontLists()
346 {                                                 336 {
347   std::map<G4double,G4String> fonts;  // G4VMa    337   std::map<G4double,G4String> fonts;  // G4VMarker screen size and font name.
348   fonts[10.] = "-adobe-courier-bold-r-normal--    338   fonts[10.] = "-adobe-courier-bold-r-normal--10-100-75-75-m-60-iso8859-1";
349   fonts[11.] = "-adobe-courier-bold-r-normal--    339   fonts[11.] = "-adobe-courier-bold-r-normal--11-80-100-100-m-60-iso8859-1";
350   fonts[12.] = "-adobe-courier-bold-r-normal--    340   fonts[12.] = "-adobe-courier-bold-r-normal--12-120-75-75-m-70-iso8859-1";
351   fonts[13.] = "fixed";                           341   fonts[13.] = "fixed";
352   fonts[14.] = "-adobe-courier-bold-r-normal--    342   fonts[14.] = "-adobe-courier-bold-r-normal--14-100-100-100-m-90-iso8859-1";
353   fonts[17.] = "-adobe-courier-bold-r-normal--    343   fonts[17.] = "-adobe-courier-bold-r-normal--17-120-100-100-m-100-iso8859-1";
354   fonts[18.] = "-adobe-courier-bold-r-normal--    344   fonts[18.] = "-adobe-courier-bold-r-normal--18-180-75-75-m-110-iso8859-1";
355   fonts[20.] = "-adobe-courier-bold-r-normal--    345   fonts[20.] = "-adobe-courier-bold-r-normal--20-140-100-100-m-110-iso8859-1";
356   fonts[24.] = "-adobe-courier-bold-r-normal--    346   fonts[24.] = "-adobe-courier-bold-r-normal--24-240-75-75-m-150-iso8859-1";
357   fonts[25.] = "-adobe-courier-bold-r-normal--    347   fonts[25.] = "-adobe-courier-bold-r-normal--25-180-100-100-m-150-iso8859-1";
358   fonts[34.] = "-adobe-courier-bold-r-normal--    348   fonts[34.] = "-adobe-courier-bold-r-normal--34-240-100-100-m-200-iso8859-1";
359   std::map<G4double,G4String>::const_iterator     349   std::map<G4double,G4String>::const_iterator i;
360   for (i = fonts.begin(); i != fonts.end(); ++    350   for (i = fonts.begin(); i != fonts.end(); ++i) {
361     XFontStruct* font_info = XLoadQueryFont(dp    351     XFontStruct* font_info = XLoadQueryFont(dpy, i->second);
362     if (!font_info) {                             352     if (!font_info) {
363       G4cerr <<                                   353       G4cerr <<
364   "G4OpenGLXViewer::CreateFontLists XLoadQuery    354   "G4OpenGLXViewer::CreateFontLists XLoadQueryFont failed for font\n  "
365        << i->second                               355        << i->second
366        << G4endl;                                 356        << G4endl;
367       continue;                                   357       continue;
368     }                                             358     }
369     G4int font_base = glGenLists(256);            359     G4int font_base = glGenLists(256);
370     if (!font_base) {                             360     if (!font_base) {
371       G4cerr <<                                   361       G4cerr <<
372   "G4OpenGLXViewer::CreateFontLists out of dis    362   "G4OpenGLXViewer::CreateFontLists out of display lists for fonts." 
373        << G4endl;                                 363        << G4endl;
374       continue;                                   364       continue;
375     }                                             365     }
376     G4int first = font_info->min_char_or_byte2    366     G4int first = font_info->min_char_or_byte2;
377     G4int last  = font_info->max_char_or_byte2    367     G4int last  = font_info->max_char_or_byte2;
378     glXUseXFont(font_info->fid, first, last-fi    368     glXUseXFont(font_info->fid, first, last-first+1, font_base + first);
379     G4int width = font_info->max_bounds.width;    369     G4int width = font_info->max_bounds.width;
380     G4OpenGLFontBaseStore::AddFontBase            370     G4OpenGLFontBaseStore::AddFontBase
381       (this, font_base, i->first, i->second, w    371       (this, font_base, i->first, i->second, width);
382   }                                               372   }
383 }                                                 373 }
384                                                   374 
385 void G4OpenGLXViewer::DrawText(const G4Text& g    375 void G4OpenGLXViewer::DrawText(const G4Text& g4text)
386 {                                                 376 {
387   if (isGl2psWriting()) {                         377   if (isGl2psWriting()) {
388                                                   378 
389     G4OpenGLViewer::DrawText(g4text);             379     G4OpenGLViewer::DrawText(g4text);
390                                                   380 
391   } else {                                        381   } else {
392                                                   382 
393     G4VSceneHandler::MarkerSizeType sizeType;     383     G4VSceneHandler::MarkerSizeType sizeType;
394     G4double size = fSceneHandler.GetMarkerSiz    384     G4double size = fSceneHandler.GetMarkerSize(g4text,sizeType);
395                                                   385 
396     const G4OpenGLFontBaseStore::FontInfo& fon    386     const G4OpenGLFontBaseStore::FontInfo& fontInfo =
397       G4OpenGLFontBaseStore::GetFontInfo(this,    387       G4OpenGLFontBaseStore::GetFontInfo(this,(int)size);
398     if (fontInfo.fFontBase < 0) {                 388     if (fontInfo.fFontBase < 0) {
399       static G4int callCount = 0;                 389       static G4int callCount = 0;
400       ++callCount;                                390       ++callCount;
401       //if (callCount <= 10 || callCount%100 =    391       //if (callCount <= 10 || callCount%100 == 0) {
402       if (callCount <= 1) {                       392       if (callCount <= 1) {
403         G4cout <<                                 393         G4cout <<
404     "G4OpenGLXViewer::DrawText: No fonts avail    394     "G4OpenGLXViewer::DrawText: No fonts available for \""
405          << fName <<                              395          << fName <<
406           "\"\n  Called with "                    396           "\"\n  Called with "
407                << g4text                          397                << g4text
408                << G4endl;                         398                << G4endl;
409       }                                           399       }
410       return;                                     400       return;
411     }                                             401     }
412                                                   402 
413     const G4Colour& c = fSceneHandler.GetTextC    403     const G4Colour& c = fSceneHandler.GetTextColour(g4text);
414     glColor4d(c.GetRed(),c.GetGreen(),c.GetBlu    404     glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha());
415                                                   405 
416     G4Point3D position = g4text.GetPosition();    406     G4Point3D position = g4text.GetPosition();
417                                                   407 
418     G4String textString = g4text.GetText();       408     G4String textString = g4text.GetText();
419     const char* textCString = textString.c_str    409     const char* textCString = textString.c_str();
420                                                   410   
421     // Set position for raster-style drawers (    411     // Set position for raster-style drawers (X, Xm)
422     glRasterPos3d(position.x(),position.y(),po    412     glRasterPos3d(position.x(),position.y(),position.z());
423                                                   413 
424     glPushAttrib(GL_LIST_BIT);                    414     glPushAttrib(GL_LIST_BIT);
425                                                   415 
426     // Calculate move for centre and right adj    416     // Calculate move for centre and right adjustment
427     G4double span = textString.size() * fontIn    417     G4double span = textString.size() * fontInfo.fWidth;
428     G4double xmove = 0., ymove = 0.;              418     G4double xmove = 0., ymove = 0.;
429     switch (g4text.GetLayout()) {                 419     switch (g4text.GetLayout()) {
430     case G4Text::left: break;                     420     case G4Text::left: break;
431     case G4Text::centre: xmove -= span / 2.; b    421     case G4Text::centre: xmove -= span / 2.; break;
432     case G4Text::right: xmove -= span;            422     case G4Text::right: xmove -= span;
433     }                                             423     }
434                                                   424 
435     //Add offsets                                 425     //Add offsets
436     xmove += g4text.GetXOffset();                 426     xmove += g4text.GetXOffset();
437     ymove += g4text.GetYOffset();                 427     ymove += g4text.GetYOffset();
438                                                   428 
439     // Do move                                    429     // Do move
440     glBitmap(0,0,0,0,xmove,ymove,0);              430     glBitmap(0,0,0,0,xmove,ymove,0);
441                                                   431 
442     // Write characters                           432     // Write characters
443     glListBase(fontInfo.fFontBase);               433     glListBase(fontInfo.fFontBase);
444     glCallLists((G4int)strlen(textCString),GL_ << 434     glCallLists(strlen(textCString),GL_UNSIGNED_BYTE,(GLubyte*)textCString);
445     glPopAttrib();                                435     glPopAttrib();
446   }                                               436   }
447 }                                                 437 }
448                                                   438 
449                                                   439 
450 G4OpenGLXViewer::G4OpenGLXViewer (G4OpenGLScen    440 G4OpenGLXViewer::G4OpenGLXViewer (G4OpenGLSceneHandler& scene):
451 G4VViewer (scene, -1),                            441 G4VViewer (scene, -1),
452 G4OpenGLViewer (scene),                           442 G4OpenGLViewer (scene),
453 vi_immediate (0),                                 443 vi_immediate (0),
454 vi_stored (0),                                    444 vi_stored (0),
455 vi (0),                                           445 vi (0),
456 cmap (0)                                          446 cmap (0)
457 {                                                 447 {
458   // To satisfy Coverity                          448   // To satisfy Coverity
459   xwa.visual = 0;                                 449   xwa.visual = 0;
460   iconName.value = 0;                             450   iconName.value = 0;
461   xwa.screen = 0;                                 451   xwa.screen = 0;
462   windowName.value = 0;                           452   windowName.value = 0;
463                                                   453 
464   GetXConnection ();                              454   GetXConnection ();
465   if (fViewId < 0) return;                        455   if (fViewId < 0) return;
466                                                   456   
467   // Try for a visual suitable for OpenGLImmed    457   // Try for a visual suitable for OpenGLImmediate..
468   // first try for a single buffered RGB windo    458   // first try for a single buffered RGB window
469   if (!vi_single_buffer) {                        459   if (!vi_single_buffer) {
470     vi_single_buffer =                            460     vi_single_buffer =
471       glXChooseVisual (dpy, XDefaultScreen (dp    461       glXChooseVisual (dpy, XDefaultScreen (dpy), snglBuf_RGBA);
472     //G.Barrand : we should do a XFree(vi_sing << 
473   }                                               462   }
474   if (!vi_double_buffer) {                        463   if (!vi_double_buffer) {
475     vi_double_buffer =                            464     vi_double_buffer =
476       glXChooseVisual (dpy, XDefaultScreen (dp    465       glXChooseVisual (dpy, XDefaultScreen (dpy), dblBuf_RGBA);
477     //G.Barrand : we should do a XFree(vi_doub << 
478   }                                               466   }
479                                                   467 
480   if (vi_single_buffer || vi_double_buffer) {     468   if (vi_single_buffer || vi_double_buffer) {
481     if (!vi_double_buffer) {                      469     if (!vi_double_buffer) {
482       G4cout <<                                   470       G4cout <<
483   "G4OpenGLXViewer::G4OpenGLXViewer: unable to    471   "G4OpenGLXViewer::G4OpenGLXViewer: unable to get a double buffer visual."
484   "\n  Working with a single buffer."             472   "\n  Working with a single buffer."
485        << G4endl;                                 473        << G4endl;
486     }                                             474     }
487   } else {                                        475   } else {
488     if (!vi_single_buffer) {                      476     if (!vi_single_buffer) {
489       G4cout <<                                   477       G4cout <<
490   "G4OpenGLXViewer::G4OpenGLXViewer: unable to    478   "G4OpenGLXViewer::G4OpenGLXViewer: unable to get a single buffer visual."
491        << G4endl;                                 479        << G4endl;
492     }                                             480     }
493     if (!vi_double_buffer) {                      481     if (!vi_double_buffer) {
494       G4cout <<                                   482       G4cout <<
495   "G4OpenGLXViewer::G4OpenGLXViewer: unable to    483   "G4OpenGLXViewer::G4OpenGLXViewer: unable to get a double buffer visual."
496        << G4endl;                                 484        << G4endl;
497     }                                             485     }
498   }                                               486   }
499                                                   487 
500   if (vi_single_buffer) {                         488   if (vi_single_buffer) {
501     vi_immediate = vi_single_buffer;              489     vi_immediate = vi_single_buffer;
502     attributeList = snglBuf_RGBA;                 490     attributeList = snglBuf_RGBA;
503   }                                               491   }
504                                                   492   
505   if (!vi_immediate){                             493   if (!vi_immediate){
506     // next try for a double buffered RGB, but    494     // next try for a double buffered RGB, but Draw to top buffer
507     if (vi_double_buffer) {                       495     if (vi_double_buffer) {
508       vi_immediate = vi_double_buffer;            496       vi_immediate = vi_double_buffer;
509       attributeList = dblBuf_RGBA;                497       attributeList = dblBuf_RGBA;
510     }                                             498     }
511   }                                               499   }
512                                                   500 
513   // Now try for a visual suitable for OpenGLS    501   // Now try for a visual suitable for OpenGLStored...
514   // Try for a double buffered RGB window         502   // Try for a double buffered RGB window
515   if (vi_double_buffer) {                         503   if (vi_double_buffer) {
516     vi_stored = vi_double_buffer;                 504     vi_stored = vi_double_buffer;
517     attributeList = dblBuf_RGBA;                  505     attributeList = dblBuf_RGBA;
518   }                                               506   }
519                                                   507 
520   if (!vi_immediate || !vi_stored) {              508   if (!vi_immediate || !vi_stored) {
521     G4cout <<                                     509     G4cout <<
522     "G4OpenGLXViewer::G4OpenGLXViewer: unable     510     "G4OpenGLXViewer::G4OpenGLXViewer: unable to get required visuals."
523      << G4endl;                                   511      << G4endl;
524     fViewId = -1;  // This flags an error.        512     fViewId = -1;  // This flags an error.
525   }                                               513   }
526                                                   514 
527   //  glClearColor (0., 0., 0., 0.);              515   //  glClearColor (0., 0., 0., 0.);
528   //  glClearDepth (1.);                          516   //  glClearDepth (1.);
529 }                                                 517 }
530                                                   518 
531 G4OpenGLXViewer::~G4OpenGLXViewer () {            519 G4OpenGLXViewer::~G4OpenGLXViewer () {
532   if (fViewId >= 0) {                             520   if (fViewId >= 0) {
533     //Close a window from here                    521     //Close a window from here
534     glXMakeCurrent (dpy, None, NULL);             522     glXMakeCurrent (dpy, None, NULL);
535     glXDestroyContext (dpy, cxMaster);            523     glXDestroyContext (dpy, cxMaster);
536     if (win) XDestroyWindow (dpy, win); // ...    524     if (win) XDestroyWindow (dpy, win); // ...if already deleted in
537     // sub-class G4OpenGLXmViewer.                525     // sub-class G4OpenGLXmViewer.
538     // We should do a XFreeColormap(dpy,cmap); << 
539     XFlush (dpy);                                 526     XFlush (dpy);
540   }                                               527   }
541 }                                                 528 }
542                                                   529   
                                                   >> 530 
                                                   >> 531 #endif
543                                                   532