Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer 3 // * License and Disclaimer * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of * 6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and * 7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file * 8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 9 // * include a list of copyright holders. 9 // * include a list of copyright holders. * 10 // * 10 // * * 11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above * 16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. * 17 // * 17 // * * 18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and * 19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. * 20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or * 21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its * 22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your * 23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. * 24 // ******************************************* 24 // ******************************************************************** 25 // 25 // 26 // 26 // >> 27 // $Id: G4OpenGLXmPanningCallbacks.cc,v 1.8 2006/06/29 21:19:50 gunter Exp $ >> 28 // GEANT4 tag $Name: geant4-09-02-patch-01 $ 27 // 29 // 28 // 30 // 29 // Andrew Walkden 16th April 1997 31 // Andrew Walkden 16th April 1997 30 // G4OpenGLXmPanningCallbacks : 32 // G4OpenGLXmPanningCallbacks : 31 // Several callback func 33 // Several callback functions used by 32 // elements of the contr 34 // elements of the control panel to`pan' 33 // the view (i.e. move t 35 // the view (i.e. move the viewpoint and 34 // camera positions by e 36 // camera positions by equal amounts). 35 // Zoom callback is also 37 // Zoom callback is also here. 36 38 37 #include "G4OpenGLXmViewer.hh" << 39 #ifdef G4VIS_BUILD_OPENGLXM_DRIVER 38 #include "G4VSceneHandler.hh" << 39 #include <Xm/ToggleB.h> << 40 40 >> 41 #include "G4OpenGLXmViewer.hh" 41 #include "G4Scene.hh" 42 #include "G4Scene.hh" 42 43 43 void G4OpenGLXmViewer::zoom_callback (Widget w 44 void G4OpenGLXmViewer::zoom_callback (Widget w, 44 XtPointer clientData, 45 XtPointer clientData, 45 XtPointer callData) 46 XtPointer callData) 46 { 47 { 47 XmScaleCallbackStruct *cbs = (XmScaleCallbac 48 XmScaleCallbackStruct *cbs = (XmScaleCallbackStruct*) callData; 48 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer* 49 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData; 49 short dp = -1; 50 short dp = -1; 50 G4float ten_to_the_dp = 10.; 51 G4float ten_to_the_dp = 10.; 51 52 52 XtVaGetValues (w, 53 XtVaGetValues (w, 53 XmNdecimalPoints, &dp, 54 XmNdecimalPoints, &dp, 54 NULL); 55 NULL); 55 56 56 if (dp == 0) { 57 if (dp == 0) { 57 ten_to_the_dp = 1.; 58 ten_to_the_dp = 1.; 58 } else if ( dp > 0) { 59 } else if ( dp > 0) { 59 for (G4int i = 1; i < (G4int)dp; i++) { 60 for (G4int i = 1; i < (G4int)dp; i++) { 60 ten_to_the_dp *= 10.; 61 ten_to_the_dp *= 10.; 61 } 62 } 62 } else { 63 } else { 63 G4cout << "dp is " << dp << G4endl; 64 G4cout << "dp is " << dp << G4endl; 64 return; 65 return; 65 } 66 } 66 67 67 68 68 G4double zoomBy = (G4double)(cbs->value) / t 69 G4double zoomBy = (G4double)(cbs->value) / ten_to_the_dp; 69 if (zoomBy <= 0.01) { 70 if (zoomBy <= 0.01) { 70 zoomBy = 0.01; 71 zoomBy = 0.01; 71 } 72 } 72 73 73 pView->fVP.SetZoomFactor (zoomBy); 74 pView->fVP.SetZoomFactor (zoomBy); 74 pView->SetView (); 75 pView->SetView (); 75 pView->ClearView (); 76 pView->ClearView (); 76 pView -> DrawView (); 77 pView -> DrawView (); 77 } 78 } 78 79 79 void G4OpenGLXmViewer::dolly_callback (Widget 80 void G4OpenGLXmViewer::dolly_callback (Widget w, 80 XtPointer clientData, 81 XtPointer clientData, 81 XtPointer callData) 82 XtPointer callData) 82 { 83 { 83 XmScaleCallbackStruct *cbs = (XmScaleCallbac 84 XmScaleCallbackStruct *cbs = (XmScaleCallbackStruct*) callData; 84 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer* 85 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData; 85 short dp = -1; 86 short dp = -1; 86 G4float ten_to_the_dp = 10.; 87 G4float ten_to_the_dp = 10.; 87 88 88 XtVaGetValues (w, 89 XtVaGetValues (w, 89 XmNdecimalPoints, &dp, 90 XmNdecimalPoints, &dp, 90 NULL); 91 NULL); 91 92 92 if (dp == 0) { 93 if (dp == 0) { 93 ten_to_the_dp = 1.; 94 ten_to_the_dp = 1.; 94 } else if ( dp > 0) { 95 } else if ( dp > 0) { 95 for (G4int i = 1; i < (G4int)dp; i++) { 96 for (G4int i = 1; i < (G4int)dp; i++) { 96 ten_to_the_dp *= 10.; 97 ten_to_the_dp *= 10.; 97 } 98 } 98 } else { 99 } else { 99 G4cout << "dp is " << dp << G4endl; 100 G4cout << "dp is " << dp << G4endl; 100 return; 101 return; 101 } 102 } 102 103 103 G4double dolly = (G4double)(cbs->value) / te 104 G4double dolly = (G4double)(cbs->value) / ten_to_the_dp; 104 105 105 pView->fVP.SetDolly (dolly); 106 pView->fVP.SetDolly (dolly); 106 pView->SetView (); 107 pView->SetView (); 107 pView->ClearView (); 108 pView->ClearView (); 108 pView->DrawView (); 109 pView->DrawView (); 109 110 110 } 111 } 111 112 112 void G4OpenGLXmViewer::pan_left_right_callback 113 void G4OpenGLXmViewer::pan_left_right_callback (Widget w, 113 XtPointer clientData, 114 XtPointer clientData, 114 XtPointer callData) 115 XtPointer callData) 115 { 116 { 116 XmArrowButtonCallbackStruct *cbs = (XmArrowB 117 XmArrowButtonCallbackStruct *cbs = (XmArrowButtonCallbackStruct*) callData; 117 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer* 118 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData; 118 119 119 pView->pan_right = get_boolean_userData (w); 120 pView->pan_right = get_boolean_userData (w); 120 121 121 if (cbs->reason == XmCR_ARM) { 122 if (cbs->reason == XmCR_ARM) { 122 left_right_pan_callback (pView,NULL); 123 left_right_pan_callback (pView,NULL); 123 } else if (cbs->reason == XmCR_DISARM) { 124 } else if (cbs->reason == XmCR_DISARM) { 124 XtRemoveTimeOut (pView->pan_timer); 125 XtRemoveTimeOut (pView->pan_timer); 125 } 126 } 126 } 127 } 127 128 128 void G4OpenGLXmViewer::left_right_pan_callback 129 void G4OpenGLXmViewer::left_right_pan_callback (XtPointer clientData, 129 XtIntervalId* timer_id) 130 XtIntervalId* timer_id) 130 131 131 { 132 { 132 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer* 133 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData; 133 G4double delta; 134 G4double delta; 134 135 135 if (pView->pan_right) { 136 if (pView->pan_right) { 136 delta = pView->fPan_sens; << 137 delta = (G4double)pView->pan_sens; 137 } else { 138 } else { 138 delta = -pView->fPan_sens; << 139 delta = -((G4double)pView->pan_sens); 139 } 140 } 140 141 141 G4Point3D stp 142 G4Point3D stp 142 = pView -> GetSceneHandler()->GetScene()-> 143 = pView -> GetSceneHandler()->GetScene()->GetStandardTargetPoint(); 143 144 144 G4Point3D tp = stp + pView -> fVP.GetCurrent 145 G4Point3D tp = stp + pView -> fVP.GetCurrentTargetPoint (); 145 146 146 const G4Vector3D& upVector = pView->fVP.GetU 147 const G4Vector3D& upVector = pView->fVP.GetUpVector (); 147 const G4Vector3D& vpVector = pView->fVP.GetV 148 const G4Vector3D& vpVector = pView->fVP.GetViewpointDirection (); 148 149 149 G4Vector3D unitRight = (upVector.cross (vpVe 150 G4Vector3D unitRight = (upVector.cross (vpVector)).unit(); 150 G4Vector3D unitUp = (vpVector.cross (unit 151 G4Vector3D unitUp = (vpVector.cross (unitRight)).unit(); 151 152 152 tp += delta * unitRight; 153 tp += delta * unitRight; 153 pView->fVP.SetCurrentTargetPoint (tp - stp); 154 pView->fVP.SetCurrentTargetPoint (tp - stp); 154 155 155 pView->SetView (); 156 pView->SetView (); 156 pView->ClearView (); 157 pView->ClearView (); 157 pView->DrawView (); 158 pView->DrawView (); 158 159 159 pView->pan_timer = XtAppAddTimeOut 160 pView->pan_timer = XtAppAddTimeOut 160 (pView->app, 161 (pView->app, 161 timer_id == NULL ? 500 : 1, 162 timer_id == NULL ? 500 : 1, 162 left_right_pan_callback, 163 left_right_pan_callback, 163 pView); 164 pView); 164 } 165 } 165 166 166 void G4OpenGLXmViewer::pan_up_down_callback (W 167 void G4OpenGLXmViewer::pan_up_down_callback (Widget w, 167 XtPointer clientData, 168 XtPointer clientData, 168 XtPointer callData) 169 XtPointer callData) 169 { 170 { 170 XmArrowButtonCallbackStruct *cbs = (XmArrowB 171 XmArrowButtonCallbackStruct *cbs = (XmArrowButtonCallbackStruct*) callData; 171 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer* 172 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData; 172 173 173 pView->pan_up = get_boolean_userData (w); 174 pView->pan_up = get_boolean_userData (w); 174 175 175 if (cbs->reason == XmCR_ARM) { 176 if (cbs->reason == XmCR_ARM) { 176 up_down_pan_callback (pView,NULL); 177 up_down_pan_callback (pView,NULL); 177 } else if (cbs->reason == XmCR_DISARM) { 178 } else if (cbs->reason == XmCR_DISARM) { 178 XtRemoveTimeOut (pView->pan_timer); 179 XtRemoveTimeOut (pView->pan_timer); 179 } 180 } 180 } 181 } 181 182 182 void G4OpenGLXmViewer::up_down_pan_callback (X 183 void G4OpenGLXmViewer::up_down_pan_callback (XtPointer clientData, 183 XtIntervalId* timer_id) 184 XtIntervalId* timer_id) 184 { 185 { 185 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer* 186 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData; 186 G4double delta; 187 G4double delta; 187 188 188 if (pView->pan_up) { 189 if (pView->pan_up) { 189 delta = pView->fPan_sens; << 190 delta = (G4double)pView->pan_sens; 190 } else { 191 } else { 191 delta = -(pView->fPan_sens); << 192 delta = -((G4double)pView->pan_sens); 192 } 193 } 193 194 194 G4Point3D stp 195 G4Point3D stp 195 = pView -> GetSceneHandler()->GetScene()-> 196 = pView -> GetSceneHandler()->GetScene()->GetStandardTargetPoint(); 196 G4Point3D tp = stp + pView -> fVP.GetCurrent 197 G4Point3D tp = stp + pView -> fVP.GetCurrentTargetPoint (); 197 const G4Vector3D& upVector = pView->fVP.GetU 198 const G4Vector3D& upVector = pView->fVP.GetUpVector (); 198 const G4Vector3D& vpVector = pView->fVP.GetV 199 const G4Vector3D& vpVector = pView->fVP.GetViewpointDirection (); 199 200 200 G4Vector3D unitRight = (upVector.cross (vpVe 201 G4Vector3D unitRight = (upVector.cross (vpVector)).unit(); 201 G4Vector3D unitUp = (vpVector.cross (unit 202 G4Vector3D unitUp = (vpVector.cross (unitRight)).unit(); 202 tp += delta * unitUp; 203 tp += delta * unitUp; 203 pView->fVP.SetCurrentTargetPoint (tp - stp); 204 pView->fVP.SetCurrentTargetPoint (tp - stp); 204 205 205 pView->SetView (); 206 pView->SetView (); 206 pView->ClearView (); 207 pView->ClearView (); 207 pView->DrawView (); 208 pView->DrawView (); 208 209 209 pView->pan_timer = XtAppAddTimeOut 210 pView->pan_timer = XtAppAddTimeOut 210 (pView->app, 211 (pView->app, 211 timer_id == NULL ? 500 : 1, 212 timer_id == NULL ? 500 : 1, 212 up_down_pan_callback, 213 up_down_pan_callback, 213 pView); 214 pView); 214 } 215 } 215 216 216 void G4OpenGLXmViewer::set_pan_sens_callback ( 217 void G4OpenGLXmViewer::set_pan_sens_callback (Widget w, 217 XtPointer clientData, 218 XtPointer clientData, 218 XtPointer callData) 219 XtPointer callData) 219 { 220 { 220 XmScaleCallbackStruct *cbs = (XmScaleCallbac 221 XmScaleCallbackStruct *cbs = (XmScaleCallbackStruct*) callData; 221 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer* 222 G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData; 222 short dp = -1; 223 short dp = -1; 223 G4float ten_to_the_dp = 10.; 224 G4float ten_to_the_dp = 10.; 224 225 225 XtVaGetValues (w, 226 XtVaGetValues (w, 226 XmNdecimalPoints, &dp, 227 XmNdecimalPoints, &dp, 227 NULL); 228 NULL); 228 229 229 if (dp == 0) { 230 if (dp == 0) { 230 ten_to_the_dp = 1.; 231 ten_to_the_dp = 1.; 231 } else if ( dp > 0) { 232 } else if ( dp > 0) { 232 for (G4int i = 1; i < (G4int)dp; i++) { 233 for (G4int i = 1; i < (G4int)dp; i++) { 233 ten_to_the_dp *= 10.; 234 ten_to_the_dp *= 10.; 234 } 235 } 235 } else { 236 } else { 236 G4cout << "dp is " << dp << G4endl; 237 G4cout << "dp is " << dp << G4endl; 237 return; 238 return; 238 } 239 } 239 240 240 pView->fPan_sens = (G4double)((cbs->value) / << 241 pView->pan_sens = (G4double)((cbs->value) / ten_to_the_dp); 241 } 242 } >> 243 >> 244 #endif >> 245 >> 246 242 247