Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/OpenGL/src/G4OpenGLXmRotationCallbacks.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/G4OpenGLXmRotationCallbacks.cc (Version 11.3.0) and /visualization/OpenGL/src/G4OpenGLXmRotationCallbacks.cc (Version 9.4.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: G4OpenGLXmRotationCallbacks.cc,v 1.17 2009-01-19 16:53:42 lgarnier Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-04-patch-02 $
 27 //                                                 29 //
 28 //                                                 30 // 
 29 // Andrew Walkden  16th April 1997                 31 // Andrew Walkden  16th April 1997
 30 // G4OpenGLXmRotationCallbacks :                   32 // G4OpenGLXmRotationCallbacks : 
 31 //                       Several callback func     33 //                       Several callback functions used by
 32 //                       elements of the contr     34 //                       elements of the control panel to
 33 //                       rotate the view.          35 //                       rotate the view.
 34                                                    36 
                                                   >>  37 #ifdef G4VIS_BUILD_OPENGLXM_DRIVER
                                                   >>  38 
 35 #include "G4OpenGLXmViewer.hh"                     39 #include "G4OpenGLXmViewer.hh"
 36                                                    40 
 37 #include "G4PhysicalConstants.hh"              << 
 38 #include "G4Scene.hh"                              41 #include "G4Scene.hh"
 39 #include "G4UImanager.hh"                          42 #include "G4UImanager.hh"
 40 #include "G4ios.hh"                                43 #include "G4ios.hh"
 41                                                    44 
 42 void G4OpenGLXmViewer::theta_rotation_callback     45 void G4OpenGLXmViewer::theta_rotation_callback (Widget w, 
 43                 XtPointer clientData,              46                 XtPointer clientData, 
 44                 XtPointer callData)                47                 XtPointer callData) 
 45 {                                                  48 {
 46   XmArrowButtonCallbackStruct *cbs = (XmArrowB     49   XmArrowButtonCallbackStruct *cbs = (XmArrowButtonCallbackStruct*) callData;
 47   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*     50   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
 48                                                    51 
 49   pView->rotate_right = get_boolean_userData (     52   pView->rotate_right = get_boolean_userData (w);
 50                                                    53 
 51   if (cbs->reason == XmCR_ARM) {                   54   if (cbs->reason == XmCR_ARM) {
 52     rotate_in_theta (pView, NULL);                 55     rotate_in_theta (pView, NULL);
 53   } else if (cbs->reason == XmCR_DISARM) {         56   } else if (cbs->reason == XmCR_DISARM) {
 54     XtRemoveTimeOut (pView->rotation_timer);       57     XtRemoveTimeOut (pView->rotation_timer);
 55   }                                                58   }
 56 }                                                  59 }
 57                                                    60 
 58 void G4OpenGLXmViewer::rotate_in_theta (XtPoin     61 void G4OpenGLXmViewer::rotate_in_theta (XtPointer clientData,
 59               XtIntervalId* timer_id)              62               XtIntervalId* timer_id) 
 60 {                                                  63 {
 61   //theta spin stuff here                          64   //theta spin stuff here
 62   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*     65   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
 63                                                    66 
 64   if (pView->rotate_right) {                       67   if (pView->rotate_right) {
 65     pView->rotateScene(1,0);                   <<  68     pView->rotateScene((G4double)pView->rot_sens,0,1);
 66   } else {                                         69   } else {
 67     pView->rotateScene(-1,0);                  <<  70     pView->rotateScene(-(G4double)pView->rot_sens,0,1);
 68   }                                                71   }
 69   /*                                               72   /*
 70   G4double delta_theta;                            73   G4double delta_theta;
 71                                                    74 
 72   if (pView->fVP.GetLightsMoveWithCamera()) {      75   if (pView->fVP.GetLightsMoveWithCamera()) {
 73     if (pView->rotate_right) {                     76     if (pView->rotate_right) {
 74       delta_theta = -(pView->fRot_sens);       <<  77       delta_theta = -((G4double)pView->rot_sens);
 75     } else {                                       78     } else {
 76       delta_theta = pView->fRot_sens;          <<  79       delta_theta = (G4double)pView->rot_sens;
 77     }                                              80     }
 78   } else {                                         81   } else {
 79     if (pView->rotate_right) {                     82     if (pView->rotate_right) {
 80       delta_theta = pView->fRot_sens;          <<  83       delta_theta = (G4double)pView->rot_sens;
 81     } else {                                       84     } else {
 82       delta_theta = -(pView->fRot_sens);       <<  85       delta_theta = -((G4double)pView->rot_sens);
 83     }                                              86     }
 84   }                                                87   }    
 85   delta_theta *= deg;                              88   delta_theta *= deg;
 86   // Rotates by fixed azimuthal angle delta_th     89   // Rotates by fixed azimuthal angle delta_theta.
 87                                                    90 
 88   const G4Vector3D& vp = pView->fVP.GetViewpoi     91   const G4Vector3D& vp = pView->fVP.GetViewpointDirection ().unit ();
 89   const G4Vector3D& up = pView->fVP.GetUpVecto     92   const G4Vector3D& up = pView->fVP.GetUpVector ().unit ();
 90   const G4Vector3D& zprime = up;                   93   const G4Vector3D& zprime = up;
 91   G4double cosalpha = up.dot (vp);                 94   G4double cosalpha = up.dot (vp);
 92   G4double sinalpha = std::sqrt (1. - std::pow     95   G4double sinalpha = std::sqrt (1. - std::pow (cosalpha, 2));
 93   G4Vector3D yprime = (zprime.cross (vp)).unit     96   G4Vector3D yprime = (zprime.cross (vp)).unit ();
 94   G4Vector3D xprime = yprime.cross (zprime);       97   G4Vector3D xprime = yprime.cross (zprime);
 95   // Projection of vp on plane perpendicular t     98   // Projection of vp on plane perpendicular to up...
 96   G4Vector3D a1 = sinalpha * xprime;               99   G4Vector3D a1 = sinalpha * xprime;
 97   // Required new projection...                   100   // Required new projection...
 98   G4Vector3D a2 =                                 101   G4Vector3D a2 =
 99     sinalpha * (std::cos (delta_theta) * xprim    102     sinalpha * (std::cos (delta_theta) * xprime + std::sin (delta_theta) * yprime);
100   // Required Increment vector...                 103   // Required Increment vector...
101   G4Vector3D delta = a2 - a1;                     104   G4Vector3D delta = a2 - a1;
102   // So new viewpoint is...                       105   // So new viewpoint is...
103   G4Vector3D viewPoint = vp + delta;              106   G4Vector3D viewPoint = vp + delta;
104                                                   107 
105   pView->fVP.SetViewAndLights (viewPoint);        108   pView->fVP.SetViewAndLights (viewPoint);  
106   */                                              109   */
107                                                   110 
108   pView->SetView ();                              111   pView->SetView ();
109   pView->ClearView ();                            112   pView->ClearView ();
110   pView->DrawView ();                             113   pView->DrawView ();
111                                                   114 
112   pView->rotation_timer = XtAppAddTimeOut         115   pView->rotation_timer = XtAppAddTimeOut 
113     (pView->app,                                  116     (pView->app,
114      timer_id == NULL ? 500 : 1,                  117      timer_id == NULL ? 500 : 1,
115      rotate_in_theta,                             118      rotate_in_theta,
116      pView);                                      119      pView);
117 }                                                 120 }  
118                                                   121 
119 void G4OpenGLXmViewer::phi_rotation_callback (    122 void G4OpenGLXmViewer::phi_rotation_callback (Widget w, 
120               XtPointer clientData,               123               XtPointer clientData, 
121               XtPointer callData)                 124               XtPointer callData) 
122 {                                                 125 {
123   XmArrowButtonCallbackStruct *cbs = (XmArrowB    126   XmArrowButtonCallbackStruct *cbs = (XmArrowButtonCallbackStruct*) callData;
124   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*    127   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
125                                                   128 
126   pView->rotate_up = get_boolean_userData (w);    129   pView->rotate_up = get_boolean_userData (w);
127                                                   130 
128   if (cbs->reason == XmCR_ARM) {                  131   if (cbs->reason == XmCR_ARM) {
129     rotate_in_phi (pView, NULL);                  132     rotate_in_phi (pView, NULL);
130   } else if (cbs->reason == XmCR_DISARM) {        133   } else if (cbs->reason == XmCR_DISARM) {
131     XtRemoveTimeOut (pView->rotation_timer);      134     XtRemoveTimeOut (pView->rotation_timer);
132   }                                               135   }
133 }                                                 136 }
134                                                   137 
135 void G4OpenGLXmViewer::rotate_in_phi (XtPointe    138 void G4OpenGLXmViewer::rotate_in_phi (XtPointer clientData,
136             XtIntervalId* timer_id)               139             XtIntervalId* timer_id)
137 {                                                 140 {
138   //phi spin stuff here                           141   //phi spin stuff here
139   //  G4double delta_alpha;                       142   //  G4double delta_alpha;
140   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*    143   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
141                                                   144 
142   if (pView -> rotate_up) {                       145   if (pView -> rotate_up) {
143     pView->rotateScene(0,-1);                  << 146     pView->rotateScene(0,-(G4double)pView->rot_sens,1);
144   } else {                                        147   } else {
145     pView->rotateScene(0,1);                   << 148     pView->rotateScene(0,(G4double)pView->rot_sens,1);
146   }                                               149   }
147   /*                                              150   /*
148   if (pView->fVP.GetLightsMoveWithCamera()) {     151   if (pView->fVP.GetLightsMoveWithCamera()) {
149     if (pView -> rotate_up) {                     152     if (pView -> rotate_up) {
150       delta_alpha = -(pView->fRot_sens);       << 153       delta_alpha = -((G4double)pView->rot_sens);
151     } else {                                      154     } else {
152       delta_alpha = pView->fRot_sens;          << 155       delta_alpha = (G4double)pView->rot_sens;
153     }                                             156     }
154   } else {                                        157   } else {
155     if (pView -> rotate_up) {                     158     if (pView -> rotate_up) {
156       delta_alpha = pView->fRot_sens;          << 159       delta_alpha = (G4double)pView->rot_sens;
157     } else {                                      160     } else {
158       delta_alpha = -(pView->fRot_sens);       << 161       delta_alpha = -((G4double)pView->rot_sens);
159     }                                             162     }
160   }                                               163   }    
161                                                   164 
162   delta_alpha *= deg;                             165   delta_alpha *= deg;
163                                                   166 
164   const G4Vector3D& vp = pView->fVP.GetViewpoi    167   const G4Vector3D& vp = pView->fVP.GetViewpointDirection ().unit ();
165   const G4Vector3D& up = pView->fVP.GetUpVecto    168   const G4Vector3D& up = pView->fVP.GetUpVector ().unit ();
166                                                   169 
167   const G4Vector3D& xprime = vp;                  170   const G4Vector3D& xprime = vp;
168   G4Vector3D yprime = (up.cross(xprime)).unit(    171   G4Vector3D yprime = (up.cross(xprime)).unit();
169   G4Vector3D zprime = (xprime.cross(yprime)).u    172   G4Vector3D zprime = (xprime.cross(yprime)).unit();
170                                                   173 
171   G4Vector3D new_vp = std::cos(delta_alpha) *     174   G4Vector3D new_vp = std::cos(delta_alpha) * xprime + std::sin(delta_alpha) * zprime;
172                                                   175 
173   pView->fVP.SetViewAndLights (new_vp.unit());    176   pView->fVP.SetViewAndLights (new_vp.unit());
174                                                   177 
175   if (pView->fVP.GetLightsMoveWithCamera()) {     178   if (pView->fVP.GetLightsMoveWithCamera()) {
176     G4Vector3D new_up = (new_vp.cross(yprime))    179     G4Vector3D new_up = (new_vp.cross(yprime)).unit();
177     pView->fVP.SetUpVector(new_up);               180     pView->fVP.SetUpVector(new_up);
178   }                                               181   }
179                                                   182 
180   */                                              183   */
181   pView->SetView ();                              184   pView->SetView ();
182   pView->ClearView ();                            185   pView->ClearView ();
183   pView->DrawView ();                             186   pView->DrawView ();
184                                                   187   
185   pView->rotation_timer = XtAppAddTimeOut         188   pView->rotation_timer = XtAppAddTimeOut 
186     (pView->app,                                  189     (pView->app,
187      timer_id == NULL ? 500 : 1,                  190      timer_id == NULL ? 500 : 1,
188      rotate_in_phi,                               191      rotate_in_phi,
189      pView);                                      192      pView);
190 }                                                 193 }
191                                                   194 
192 void G4OpenGLXmViewer::set_rot_sens_callback (    195 void G4OpenGLXmViewer::set_rot_sens_callback (Widget w, 
193               XtPointer clientData,               196               XtPointer clientData, 
194               XtPointer callData)                 197               XtPointer callData) 
195 {                                                 198 {
196   XmScaleCallbackStruct *cbs = (XmScaleCallbac    199   XmScaleCallbackStruct *cbs = (XmScaleCallbackStruct*) callData;
197   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*    200   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
198   short dp = -1;                                  201   short dp = -1;
199   G4float ten_to_the_dp = 10.;                    202   G4float ten_to_the_dp = 10.;
200                                                   203 
201   XtVaGetValues (w,                               204   XtVaGetValues (w, 
202      XmNdecimalPoints, &dp,                       205      XmNdecimalPoints, &dp,
203      NULL);                                       206      NULL);
204                                                   207 
205   if (dp == 0) {                                  208   if (dp == 0) {
206     ten_to_the_dp = 1.;                           209     ten_to_the_dp = 1.;
207   } else if ( dp > 0) {                           210   } else if ( dp > 0) {
208     for (G4int i = 1; i < (G4int)dp; i++) {       211     for (G4int i = 1; i < (G4int)dp; i++) {
209       ten_to_the_dp *= 10.;                       212       ten_to_the_dp *= 10.;
210     }                                             213     }
211   } else {                                        214   } else {
212     G4Exception                                << 215     G4Exception("Bad value returned for dp in set_rot_sens_callback");
213       ("G4OpenGLXmViewer::set_rot_sens_callbac << 
214        "opengl2004", FatalException,           << 
215        "Bad value returned for dp in set_rot_s << 
216   }                                               216   }
217                                                   217 
218   pView->fRot_sens = (G4float)(cbs->value) / t << 218   pView->rot_sens = (G4float)(cbs->value) / ten_to_the_dp;
219 }                                                 219 }  
220                                                   220 
221 void G4OpenGLXmViewer::set_rot_subject_callbac    221 void G4OpenGLXmViewer::set_rot_subject_callback (Widget w, 
222                  XtPointer clientData,            222                  XtPointer clientData, 
223                  XtPointer)                       223                  XtPointer) 
224 {                                                 224 {
225   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*    225   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*)clientData;
226                                                   226   
227   G4int choice = get_int_userData (w);            227   G4int choice = get_int_userData (w);
228                                                   228   
229   switch (choice) {                               229   switch (choice) {
230   case 0:                                         230   case 0: 
231     {                                             231     {
232       pView->fVP.SetLightsMoveWithCamera (true    232       pView->fVP.SetLightsMoveWithCamera (true);
233       break;                                      233       break;
234     }                                             234     }
235   case 1:                                         235   case 1:
236     {                                             236     {
237       pView->fVP.SetLightsMoveWithCamera (fals    237       pView->fVP.SetLightsMoveWithCamera (false);
238       break;                                      238       break;
239     }                                             239     }
240   default:                                        240   default:
241     {                                             241     {
242       G4Exception                              << 242       G4Exception("Unrecognised choice made in set_rot_subject_callback"); 
243   ("G4OpenGLXmViewer::set_rot_subject_callback << 
244    "opengl2005", FatalException,               << 
245    "Unrecognised choice made in set_rot_subjec << 
246     }                                             243     }
247   }                                               244   }
248 }                                                 245 }  
249                                                   246 
250 void G4OpenGLXmViewer::wobble_callback (Widget    247 void G4OpenGLXmViewer::wobble_callback (Widget w, 
251               XtPointer,                          248               XtPointer, 
252               XtPointer)                          249               XtPointer) 
253 {                                                 250 {
254   G4OpenGLXmViewer* pView;                        251   G4OpenGLXmViewer* pView;
255                                                   252   
256   XtVaGetValues (w,                               253   XtVaGetValues (w,
257      XmNuserData, &pView,                         254      XmNuserData, &pView,
258      NULL);                                       255      NULL);
259                                                   256   
260   pView->original_vp = pView->fVP.GetViewpoint    257   pView->original_vp = pView->fVP.GetViewpointDirection();
261   pView->wobble_timer = XtAppAddTimeOut           258   pView->wobble_timer = XtAppAddTimeOut
262     (pView->app,                                  259     (pView->app,
263      (long unsigned int) (1000. * (1. / pView-    260      (long unsigned int) (1000. * (1. / pView->wob_sens)),
264      wobble_timer_callback,                       261      wobble_timer_callback,
265      pView);                                      262      pView);
266 }                                                 263 }  
267                                                   264 
268 void G4OpenGLXmViewer::wobble_timer_callback (    265 void G4OpenGLXmViewer::wobble_timer_callback (XtPointer clientData,
269               XtIntervalId*)                      266               XtIntervalId*) 
270 {                                                 267 {
271   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*    268   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*)clientData;
272   const G4Vector3D& up = pView->fVP.GetUpVecto    269   const G4Vector3D& up = pView->fVP.GetUpVector();
273   G4Vector3D third_axis = up.cross(pView->orig    270   G4Vector3D third_axis = up.cross(pView->original_vp);
274   G4double pi_div_by_ten = pi / 10.0;             271   G4double pi_div_by_ten = pi / 10.0;
275   G4Vector3D d_up = 0.1 * (std::sin ((G4double    272   G4Vector3D d_up = 0.1 * (std::sin ((G4double)pView->frameNo * pi_div_by_ten * 2.)) * up;
276   G4Vector3D d_third_axis = 0.1 * (std::sin ((    273   G4Vector3D d_third_axis = 0.1 * (std::sin ((G4double)pView->frameNo * (pi_div_by_ten))) * third_axis;
277                                                   274 
278   pView->fVP.SetViewAndLights (pView->original    275   pView->fVP.SetViewAndLights (pView->original_vp + d_up + d_third_axis);
279                                                   276 
280   pView->SetView ();                              277   pView->SetView ();
281   pView->ClearView ();                            278   pView->ClearView ();
282   pView->DrawView ();                             279   pView->DrawView ();
283                                                   280   
284   if (pView->frameNo++ == 20) {                   281   if (pView->frameNo++ == 20) {
285     if (pView->wobble_timer) {                    282     if (pView->wobble_timer) {
286       XtRemoveTimeOut (pView->wobble_timer);      283       XtRemoveTimeOut (pView->wobble_timer);
287       pView->frameNo = 0;                         284       pView->frameNo = 0;
288       pView->fVP.SetViewAndLights (pView->orig    285       pView->fVP.SetViewAndLights (pView->original_vp);
289       pView->SetView ();                          286       pView->SetView ();
290       pView->ClearView ();                        287       pView->ClearView ();
291       pView->DrawView ();                         288       pView->DrawView ();
292    }                                              289    }
293   } else {                                        290   } else {
294     pView->wobble_timer = XtAppAddTimeOut         291     pView->wobble_timer = XtAppAddTimeOut
295       (pView->app,                                292       (pView->app,
296        (long unsigned int) (1000. * (1. / pVie    293        (long unsigned int) (1000. * (1. / pView->wob_sens)),
297        wobble_timer_callback,                     294        wobble_timer_callback,
298        pView);                                    295        pView);
299   }                                               296   }
300 }                                                 297 }
301                                                   298 
302 void G4OpenGLXmViewer::reset_callback (Widget     299 void G4OpenGLXmViewer::reset_callback (Widget w, 
303              XtPointer,                           300              XtPointer, 
304              XtPointer)                           301              XtPointer) 
305 {                                                 302 {
306                                                   303   
307   G4OpenGLXmViewer* pView;                        304   G4OpenGLXmViewer* pView;
308                                                   305   
309   XtVaGetValues (w,                               306   XtVaGetValues (w,
310      XmNuserData, &pView,                         307      XmNuserData, &pView,
311      NULL);                                       308      NULL);
312                                                   309   
313   pView->fVP.SetCurrentTargetPoint(G4Point3D()    310   pView->fVP.SetCurrentTargetPoint(G4Point3D());
314   pView->fVP.SetZoomFactor(1.0);                  311   pView->fVP.SetZoomFactor(1.0);
315   pView->fVP.SetDolly(0.0);                       312   pView->fVP.SetDolly(0.0);
316   pView->SetView ();                              313   pView->SetView ();
317   pView->ClearView ();                            314   pView->ClearView ();
318   pView->DrawView ();                             315   pView->DrawView ();
319   pView->zoom_low = 0.1;                          316   pView->zoom_low = 0.1;
320   pView->zoom_high = 10.0;                        317   pView->zoom_high = 10.0;
321                                                   318   
322 }                                                 319 }
                                                   >> 320 #endif
323                                                   321