source: trunk/geant4/visualization/OpenGL/old-src/G4OpenGLViewerMessenger.cc@ 564

Last change on this file since 564 was 562, checked in by garnier, 18 years ago

r565@mac-90108: laurentgarnier | 2007-08-14 14:18:03 +0200
mise a jour suite au plantage de svk (cheksum error) suite au crash du DD en juin
  • Property svn:mime-type set to text/cpp
File size: 13.4 KB
RevLine 
[562]1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: G4OpenGLViewerMessenger.cc,v 1.5 2006/10/24 06:20:42 allison Exp $
28// GEANT4 tag $Name: geant4-08-02-patch-01 $
29
30#include "G4OpenGLViewerMessenger.hh"
31
32#include "G4OpenGLViewer.hh"
33#include "G4OpenGLStoredViewer.hh"
34#include "G4UImanager.hh"
35#include "G4UIcommand.hh"
36#include "G4UIdirectory.hh"
37#include "G4UIcmdWithADouble.hh"
38#include "G4UIcmdWithABool.hh"
39#include "G4VisManager.hh"
40#include <sstream>
41
42G4OpenGLViewerMessenger*
43G4OpenGLViewerMessenger::fpInstance = 0;
44
45G4OpenGLViewerMessenger*
46G4OpenGLViewerMessenger::GetInstance()
47{
48 if (!fpInstance) fpInstance = new G4OpenGLViewerMessenger;
49 return fpInstance;
50}
51
52G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
53{
54 G4bool omitable;
55
56 fpDirectory = new G4UIdirectory("/vis/ogl/");
57 fpDirectory->SetGuidance("G4OpenGLViewer commands.");
58
59 fpDirectorySet = new G4UIdirectory ("/vis/ogl/set/");
60 fpDirectorySet->SetGuidance("G4OpenGLViewer set commands.");
61
62 G4UIparameter* parameter;
63
64 fpCommandDisplayHeadTime =
65 new G4UIcommand("/vis/ogl/set/displayHeadTime", this);
66 fpCommandDisplayHeadTime->SetGuidance
67 ("Display head time of range in 2D text.");
68 parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
69 parameter->SetDefaultValue(false);
70 fpCommandDisplayHeadTime->SetParameter(parameter);
71 parameter = new G4UIparameter ("screenX", 'd', omitable = true);
72 parameter->SetGuidance("-1 < screenX < 1");
73 parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
74 parameter->SetDefaultValue(-0.9);
75 fpCommandDisplayHeadTime->SetParameter(parameter);
76 parameter = new G4UIparameter ("screenY", 'd', omitable = true);
77 parameter->SetGuidance("-1 < screenY < 1");
78 parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
79 parameter->SetDefaultValue(-0.9);
80 fpCommandDisplayHeadTime->SetParameter(parameter);
81 parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
82 parameter->SetDefaultValue(24.);
83 fpCommandDisplayHeadTime->SetParameter(parameter);
84 parameter = new G4UIparameter ("red", 'd', omitable = true);
85 parameter->SetParameterRange("red >= 0. && red <= 1.");
86 parameter->SetDefaultValue(0.);
87 fpCommandDisplayHeadTime->SetParameter(parameter);
88 parameter = new G4UIparameter ("green", 'd', omitable = true);
89 parameter->SetParameterRange("green >= 0. && green <= 1.");
90 parameter->SetDefaultValue(1.);
91 fpCommandDisplayHeadTime->SetParameter(parameter);
92 parameter = new G4UIparameter ("blue", 'd', omitable = true);
93 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
94 parameter->SetDefaultValue(1.);
95 fpCommandDisplayHeadTime->SetParameter(parameter);
96
97 fpCommandDisplayLightFront =
98 new G4UIcommand("/vis/ogl/set/displayLightFront", this);
99 fpCommandDisplayLightFront->SetGuidance
100 ("Display the light front at head time.");
101 fpCommandDisplayLightFront->SetGuidance
102 ("Tip: The trajectories can appear of jump ahead of the light front"
103 "\nbecause their time range overlaps the viewer's time range. To"
104 "\naverage out this discrete time effect, advance the light front by"
105 "\nhalf the trajectories interval. E.g., if the trajectory time slice"
106 "\ninterval is 0.01 ns:"
107 "\n /vis/ogl/set/displayLightFront true -90 0 0 mm -0.005 ns"
108 "\nTo prevent them beating the light front at all:"
109 "\n /vis/ogl/set/displayLightFront true -90 0 0 mm -0.01 ns");
110 parameter = new G4UIparameter ("displayLightFront", 'b', omitable = false);
111 parameter->SetDefaultValue(false);
112 fpCommandDisplayLightFront->SetParameter(parameter);
113 parameter = new G4UIparameter ("originX", 'd', omitable = true);
114 parameter->SetDefaultValue(0.);
115 fpCommandDisplayLightFront->SetParameter(parameter);
116 parameter = new G4UIparameter ("originY", 'd', omitable = true);
117 parameter->SetDefaultValue(0.);
118 fpCommandDisplayLightFront->SetParameter(parameter);
119 parameter = new G4UIparameter ("originZ", 'd', omitable = true);
120 parameter->SetDefaultValue(0.);
121 fpCommandDisplayLightFront->SetParameter(parameter);
122 parameter = new G4UIparameter ("space_unit", 's', omitable = true);
123 parameter->SetDefaultValue("m");
124 fpCommandDisplayLightFront->SetParameter(parameter);
125 parameter = new G4UIparameter ("originT", 'd', omitable = true);
126 parameter->SetDefaultValue(0.);
127 fpCommandDisplayLightFront->SetParameter(parameter);
128 parameter = new G4UIparameter ("time_unit", 's', omitable = true);
129 parameter->SetDefaultValue("s");
130 fpCommandDisplayLightFront->SetParameter(parameter);
131 parameter = new G4UIparameter ("red", 'd', omitable = true);
132 parameter->SetParameterRange("red >= 0. && red <= 1.");
133 parameter->SetDefaultValue(0.);
134 fpCommandDisplayLightFront->SetParameter(parameter);
135 parameter = new G4UIparameter ("green", 'd', omitable = true);
136 parameter->SetParameterRange("green >= 0. && green <= 1.");
137 parameter->SetDefaultValue(1.);
138 fpCommandDisplayLightFront->SetParameter(parameter);
139 parameter = new G4UIparameter ("blue", 'd', omitable = true);
140 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
141 parameter->SetDefaultValue(0.);
142 fpCommandDisplayLightFront->SetParameter(parameter);
143
144 fpCommandEndTime =
145 new G4UIcommand("/vis/ogl/set/endTime", this);
146 fpCommandEndTime->SetGuidance("Set end and range of track time.");
147 parameter = new G4UIparameter ("end-time", 'd', omitable = false);
148 parameter->SetDefaultValue(DBL_MAX);
149 fpCommandEndTime->SetParameter(parameter);
150 parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
151 parameter->SetDefaultValue("ns");
152 fpCommandEndTime->SetParameter(parameter);
153 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
154 parameter->SetDefaultValue(-1.);
155 fpCommandEndTime->SetParameter(parameter);
156 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
157 parameter->SetDefaultValue("ns");
158 fpCommandEndTime->SetParameter(parameter);
159
160 fpCommandFade = new G4UIcmdWithADouble("/vis/ogl/set/fade", this);
161 fpCommandFade->SetGuidance
162 ("0: no fade; 1: maximum fade with time within range.");
163 fpCommandFade->SetParameterName("fadefactor", omitable = false);
164 fpCommandFade->SetRange("fadefactor>=0.&&fadefactor<=1.");
165 fpCommandFade->SetDefaultValue(0.);
166
167 fpCommandStartTime =
168 new G4UIcommand("/vis/ogl/set/startTime", this);
169 fpCommandStartTime->SetGuidance("Set start and range of track time.");
170 parameter = new G4UIparameter ("start-time", 'd', omitable = false);
171 parameter->SetDefaultValue(-DBL_MAX);
172 fpCommandStartTime->SetParameter(parameter);
173 parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
174 parameter->SetDefaultValue("ns");
175 fpCommandStartTime->SetParameter(parameter);
176 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
177 parameter->SetDefaultValue(-1.);
178 fpCommandStartTime->SetParameter(parameter);
179 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
180 parameter->SetDefaultValue("ns");
181 fpCommandStartTime->SetParameter(parameter);
182
183 fpCommandTransparency =
184 new G4UIcmdWithABool("/vis/ogl/set/transparency", this);
185 fpCommandTransparency->SetGuidance
186 ("True/false to enable/disable rendering of transparent objects.");
187 fpCommandTransparency->SetParameterName
188 ("transparency-enabled", omitable = true);
189 fpCommandTransparency->SetDefaultValue(true);
190}
191
192G4OpenGLViewerMessenger::~G4OpenGLViewerMessenger ()
193{
194 delete fpCommandTransparency;
195 delete fpCommandStartTime;
196 delete fpCommandFade;
197 delete fpCommandEndTime;
198 delete fpCommandDisplayLightFront;
199 delete fpCommandDisplayHeadTime;
200 delete fpDirectorySet;
201 delete fpDirectory;
202}
203
204void G4OpenGLViewerMessenger::SetNewValue
205(G4UIcommand* command, G4String newValue)
206{
207 G4VisManager* pVisManager = G4VisManager::GetInstance();
208
209 G4VViewer* pVViewer = pVisManager->GetCurrentViewer();
210
211 if (!pVViewer) {
212 G4cout <<
213 "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
214 "\n \"/vis/open\", or similar, to get one."
215 << G4endl;
216 return;
217 }
218
219 G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pVViewer);
220
221 if (!pOGLViewer) {
222 G4cout <<
223 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type"
224 "\n OGL. Use \"/vis/viewer/select\" or \"/vis/open\"."
225 << G4endl;
226 return;
227 }
228
229 G4OpenGLStoredViewer* pViewer =
230 dynamic_cast<G4OpenGLStoredViewer*>(pVViewer);
231
232 if (!pViewer) {
233 G4cout <<
234 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
235 "\n The time slice viewing feature is only implemented for OGL Stored"
236 "\n viewers at present. Use \"/vis/viewer/select\" or \"/vis/open\"."
237 << G4endl;
238 return;
239 }
240
241 if (command == fpCommandDisplayHeadTime)
242 {
243 G4String display;
244 G4double screenX, screenY, screenSize, red, green, blue;
245 std::istringstream iss(newValue);
246 iss >> display >> screenX >> screenY
247 >> screenSize >> red >> green >> blue;
248 pViewer->fDisplayHeadTime = command->ConvertToBool(display);
249 pViewer->fDisplayHeadTimeX = screenX;
250 pViewer->fDisplayHeadTimeY = screenY;
251 pViewer->fDisplayHeadTimeSize = screenSize;
252 pViewer->fDisplayHeadTimeRed = red;
253 pViewer->fDisplayHeadTimeGreen = green;
254 pViewer->fDisplayHeadTimeBlue = blue;
255 }
256
257 if (command == fpCommandDisplayLightFront)
258 {
259 G4String display, originX, originY, originZ, unitS, originT, unitT;
260 G4double red, green, blue;
261 std::istringstream iss(newValue);
262 iss >> display
263 >> originX >> originY >> originZ >> unitS
264 >> originT >> unitT
265 >> red >> green >> blue;
266 pViewer->fDisplayLightFront = command->ConvertToBool(display);
267 pViewer->fDisplayLightFrontX =
268 command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
269 pViewer->fDisplayLightFrontY =
270 command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
271 pViewer->fDisplayLightFrontZ =
272 command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
273 pViewer->fDisplayLightFrontT =
274 command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
275 pViewer->fDisplayLightFrontRed = red;
276 pViewer->fDisplayLightFrontGreen = green;
277 pViewer->fDisplayLightFrontBlue = blue;
278 }
279
280 if (command == fpCommandEndTime)
281 {
282 G4String end_time_string, end_time_unit,
283 time_range_string, time_range_unit;
284 std::istringstream iss(newValue);
285 iss >> end_time_string >> end_time_unit
286 >> time_range_string >> time_range_unit;
287 pViewer->fEndTime = command->ConvertToDimensionedDouble
288 (G4String(end_time_string + ' ' + end_time_unit));
289 G4double timeRange = command->ConvertToDimensionedDouble
290 (G4String(time_range_string + ' ' + time_range_unit));
291 if (timeRange > 0.) {
292 pViewer->fStartTime = pViewer->fEndTime - timeRange;
293 }
294 if (pViewer->fVP.IsAutoRefresh())
295 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
296 }
297
298 if (command == fpCommandFade)
299 {
300 pViewer->fFadeFactor = command->ConvertToDouble(newValue);
301 if (pViewer->fVP.IsAutoRefresh())
302 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
303 }
304
305 if (command == fpCommandStartTime)
306 {
307 G4String start_time_string, start_time_unit,
308 time_range_string, time_range_unit;
309 std::istringstream iss(newValue);
310 iss >> start_time_string >> start_time_unit
311 >> time_range_string >> time_range_unit;
312 pViewer->fStartTime = command->ConvertToDimensionedDouble
313 (G4String(start_time_string + ' ' + start_time_unit));
314 G4double timeRange = command->ConvertToDimensionedDouble
315 (G4String(time_range_string + ' ' + time_range_unit));
316 if (timeRange > 0.) {
317 pViewer->fEndTime = pViewer->fStartTime + timeRange;
318 }
319 if (pViewer->fVP.IsAutoRefresh())
320 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
321 }
322
323 if (command == fpCommandTransparency)
324 {
325 pViewer->transparency_enabled = command->ConvertToBool(newValue);
326 if (pViewer->fVP.IsAutoRefresh())
327 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
328 }
329
330}
Note: See TracBrowser for help on using the repository browser.