source: trunk/source/visualization/OpenGL/src/G4OpenGLViewerMessenger.cc@ 1023

Last change on this file since 1023 was 977, checked in by garnier, 17 years ago

Ok en SXm, mais Pb sur le retore du contexte
  • Property svn:mime-type set to text/cpp
File size: 15.2 KB
Line 
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.16 2009/03/18 14:34:28 allison Exp $
28// GEANT4 tag $Name: $
29
30#ifdef G4VIS_BUILD_OPENGL_DRIVER
31
32#include "G4OpenGLViewerMessenger.hh"
33
34#include "G4OpenGLViewer.hh"
35#include "G4OpenGLStoredViewer.hh"
36#include "G4UImanager.hh"
37#include "G4UIcommand.hh"
38#include "G4UIdirectory.hh"
39#include "G4UIcmdWithoutParameter.hh"
40#include "G4UIcmdWithADouble.hh"
41#include "G4UIcmdWithABool.hh"
42#include "G4UIcmdWithAString.hh"
43#include "G4VisManager.hh"
44#include <sstream>
45
46G4OpenGLViewerMessenger*
47G4OpenGLViewerMessenger::fpInstance = 0;
48
49G4OpenGLViewerMessenger*
50G4OpenGLViewerMessenger::GetInstance()
51{
52 if (!fpInstance) fpInstance = new G4OpenGLViewerMessenger;
53 return fpInstance;
54}
55
56G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
57{
58 G4bool omitable;
59
60 fpDirectory = new G4UIdirectory("/vis/ogl/");
61 fpDirectory->SetGuidance("G4OpenGLViewer commands.");
62
63 fpCommandPrintEPS =
64 new G4UIcmdWithoutParameter("/vis/ogl/printEPS", this);
65 fpCommandPrintEPS->SetGuidance("Print Encapsulated PostScript file.");
66 fpCommandPrintEPS->SetGuidance
67 ("Generates files with names G4OpenGL_n.eps, where n is a sequence"
68 "\nnumber, starting at 0."
69 "\nCan be \"vectored\" or \"pixmap\" - see \"/vis/ogl/set/printMode\".");
70
71 fpDirectorySet = new G4UIdirectory ("/vis/ogl/set/");
72 fpDirectorySet->SetGuidance("G4OpenGLViewer set commands.");
73
74 G4UIparameter* parameter;
75
76 fpCommandDisplayHeadTime =
77 new G4UIcommand("/vis/ogl/set/displayHeadTime", this);
78 fpCommandDisplayHeadTime->SetGuidance
79 ("Display head time of range in 2D text.");
80 parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
81 parameter->SetDefaultValue(false);
82 fpCommandDisplayHeadTime->SetParameter(parameter);
83 parameter = new G4UIparameter ("screenX", 'd', omitable = true);
84 parameter->SetGuidance("-1 < screenX < 1");
85 parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
86 parameter->SetDefaultValue(-0.9);
87 fpCommandDisplayHeadTime->SetParameter(parameter);
88 parameter = new G4UIparameter ("screenY", 'd', omitable = true);
89 parameter->SetGuidance("-1 < screenY < 1");
90 parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
91 parameter->SetDefaultValue(-0.9);
92 fpCommandDisplayHeadTime->SetParameter(parameter);
93 parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
94 parameter->SetDefaultValue(24.);
95 fpCommandDisplayHeadTime->SetParameter(parameter);
96 parameter = new G4UIparameter ("red", 'd', omitable = true);
97 parameter->SetParameterRange("red >= 0. && red <= 1.");
98 parameter->SetDefaultValue(0.);
99 fpCommandDisplayHeadTime->SetParameter(parameter);
100 parameter = new G4UIparameter ("green", 'd', omitable = true);
101 parameter->SetParameterRange("green >= 0. && green <= 1.");
102 parameter->SetDefaultValue(1.);
103 fpCommandDisplayHeadTime->SetParameter(parameter);
104 parameter = new G4UIparameter ("blue", 'd', omitable = true);
105 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
106 parameter->SetDefaultValue(1.);
107 fpCommandDisplayHeadTime->SetParameter(parameter);
108
109 fpCommandDisplayLightFront =
110 new G4UIcommand("/vis/ogl/set/displayLightFront", this);
111 fpCommandDisplayLightFront->SetGuidance
112 ("Display the light front at head time.");
113 fpCommandDisplayLightFront->SetGuidance
114 ("Tip: The trajectories can appear of jump ahead of the light front"
115 "\nbecause their time range overlaps the viewer's time range. To"
116 "\naverage out this discrete time effect, advance the light front by"
117 "\nhalf the trajectories interval. E.g., if the trajectory time slice"
118 "\ninterval is 0.01 ns:"
119 "\n /vis/ogl/set/displayLightFront true -90 0 0 mm -0.005 ns"
120 "\nTo prevent them beating the light front at all:"
121 "\n /vis/ogl/set/displayLightFront true -90 0 0 mm -0.01 ns");
122 parameter = new G4UIparameter ("displayLightFront", 'b', omitable = false);
123 parameter->SetDefaultValue(false);
124 fpCommandDisplayLightFront->SetParameter(parameter);
125 parameter = new G4UIparameter ("originX", 'd', omitable = true);
126 parameter->SetDefaultValue(0.);
127 fpCommandDisplayLightFront->SetParameter(parameter);
128 parameter = new G4UIparameter ("originY", 'd', omitable = true);
129 parameter->SetDefaultValue(0.);
130 fpCommandDisplayLightFront->SetParameter(parameter);
131 parameter = new G4UIparameter ("originZ", 'd', omitable = true);
132 parameter->SetDefaultValue(0.);
133 fpCommandDisplayLightFront->SetParameter(parameter);
134 parameter = new G4UIparameter ("space_unit", 's', omitable = true);
135 parameter->SetDefaultValue("m");
136 fpCommandDisplayLightFront->SetParameter(parameter);
137 parameter = new G4UIparameter ("originT", 'd', omitable = true);
138 parameter->SetDefaultValue(0.);
139 fpCommandDisplayLightFront->SetParameter(parameter);
140 parameter = new G4UIparameter ("time_unit", 's', omitable = true);
141 parameter->SetDefaultValue("s");
142 fpCommandDisplayLightFront->SetParameter(parameter);
143 parameter = new G4UIparameter ("red", 'd', omitable = true);
144 parameter->SetParameterRange("red >= 0. && red <= 1.");
145 parameter->SetDefaultValue(0.);
146 fpCommandDisplayLightFront->SetParameter(parameter);
147 parameter = new G4UIparameter ("green", 'd', omitable = true);
148 parameter->SetParameterRange("green >= 0. && green <= 1.");
149 parameter->SetDefaultValue(1.);
150 fpCommandDisplayLightFront->SetParameter(parameter);
151 parameter = new G4UIparameter ("blue", 'd', omitable = true);
152 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
153 parameter->SetDefaultValue(0.);
154 fpCommandDisplayLightFront->SetParameter(parameter);
155
156 fpCommandEndTime =
157 new G4UIcommand("/vis/ogl/set/endTime", this);
158 fpCommandEndTime->SetGuidance("Set end and range of track time.");
159 parameter = new G4UIparameter ("end-time", 'd', omitable = false);
160 parameter->SetDefaultValue(DBL_MAX);
161 fpCommandEndTime->SetParameter(parameter);
162 parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
163 parameter->SetDefaultValue("ns");
164 fpCommandEndTime->SetParameter(parameter);
165 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
166 parameter->SetDefaultValue(-1.);
167 fpCommandEndTime->SetParameter(parameter);
168 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
169 parameter->SetDefaultValue("ns");
170 fpCommandEndTime->SetParameter(parameter);
171
172 fpCommandFade = new G4UIcmdWithADouble("/vis/ogl/set/fade", this);
173 fpCommandFade->SetGuidance
174 ("0: no fade; 1: maximum fade with time within range.");
175 fpCommandFade->SetParameterName("fadefactor", omitable = false);
176 fpCommandFade->SetRange("fadefactor>=0.&&fadefactor<=1.");
177 fpCommandFade->SetDefaultValue(0.);
178
179 fpCommandPrintMode = new G4UIcmdWithAString
180 ("/vis/ogl/set/printMode",this);
181 fpCommandPrintMode->SetGuidance("Set print mode");
182 fpCommandPrintMode->SetParameterName("print_mode",omitable = true);
183 fpCommandPrintMode->SetCandidates("vectored pixmap");
184 fpCommandPrintMode->SetDefaultValue("vectored");
185
186 fpCommandStartTime =
187 new G4UIcommand("/vis/ogl/set/startTime", this);
188 fpCommandStartTime->SetGuidance("Set start and range of track time.");
189 parameter = new G4UIparameter ("start-time", 'd', omitable = false);
190 parameter->SetDefaultValue(-DBL_MAX);
191 fpCommandStartTime->SetParameter(parameter);
192 parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
193 parameter->SetDefaultValue("ns");
194 fpCommandStartTime->SetParameter(parameter);
195 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
196 parameter->SetDefaultValue(-1.);
197 fpCommandStartTime->SetParameter(parameter);
198 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
199 parameter->SetDefaultValue("ns");
200 fpCommandStartTime->SetParameter(parameter);
201
202 fpCommandTransparency =
203 new G4UIcmdWithABool("/vis/ogl/set/transparency", this);
204 fpCommandTransparency->SetGuidance
205 ("True/false to enable/disable rendering of transparent objects.");
206 fpCommandTransparency->SetParameterName
207 ("transparency-enabled", omitable = true);
208 fpCommandTransparency->SetDefaultValue(true);
209}
210
211G4OpenGLViewerMessenger::~G4OpenGLViewerMessenger ()
212{
213 delete fpCommandPrintMode;
214 delete fpCommandTransparency;
215 delete fpCommandStartTime;
216 delete fpCommandFade;
217 delete fpCommandEndTime;
218 delete fpCommandDisplayLightFront;
219 delete fpCommandDisplayHeadTime;
220 delete fpDirectorySet;
221 delete fpCommandPrintEPS;
222 delete fpDirectory;
223
224 delete fpInstance;
225}
226
227void G4OpenGLViewerMessenger::SetNewValue
228(G4UIcommand* command, G4String newValue)
229{
230 G4VisManager* pVisManager = G4VisManager::GetInstance();
231
232 G4VViewer* pViewer = pVisManager->GetCurrentViewer();
233
234 if (!pViewer) {
235 G4cout <<
236 "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
237 "\n \"/vis/open\", or similar, to get one."
238 << G4endl;
239 return;
240 }
241
242 G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pViewer);
243
244 if (!pOGLViewer) {
245 G4cout <<
246 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type"
247 "\n OGL. Use \"/vis/viewer/select\" or \"/vis/open\"."
248 << G4endl;
249 return;
250 }
251
252 if (command == fpCommandPrintEPS)
253 {
254 // Keep copy of fPrintFilename to preserve Xm behaviour...
255 std::string tmp_string = pOGLViewer->fPrintFilename;
256
257 // Make new print string...
258 static G4int file_count = 0;
259 std::ostringstream oss;
260 oss << "G4OpenGL_" << file_count++ << ".eps";
261 pOGLViewer->fPrintFilename = std::string(oss.str().c_str());
262 // Print eps file...
263#ifdef G4DEBUG_VIS_OGL
264 printf("G4OpenGLViewerMessenger::SetNewValue Call printEPS %s\n",std::string(oss.str().c_str()).c_str());
265#endif
266 pOGLViewer->printEPS();
267 // Restore fPrintFilename for Xm...
268 pOGLViewer->fPrintFilename = tmp_string;
269 return;
270 }
271
272 if (command == fpCommandPrintMode)
273 {
274 if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
275 if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
276 }
277
278 if (command == fpCommandTransparency)
279 {
280 pOGLViewer->transparency_enabled = command->ConvertToBool(newValue);
281 if (pOGLViewer->fVP.IsAutoRefresh())
282 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
283 }
284
285 G4OpenGLStoredViewer* pOGLSViewer =
286 dynamic_cast<G4OpenGLStoredViewer*>(pViewer);
287
288 if (!pOGLSViewer) {
289 G4cout <<
290 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
291 "\n The time slice viewing feature is only implemented for OGL Stored"
292 "\n viewers at present. Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
293 << G4endl;
294 return;
295 }
296
297 if (command == fpCommandDisplayHeadTime)
298 {
299 G4String display;
300 G4double screenX, screenY, screenSize, red, green, blue;
301 std::istringstream iss(newValue);
302 iss >> display >> screenX >> screenY
303 >> screenSize >> red >> green >> blue;
304 pOGLSViewer->fDisplayHeadTime = command->ConvertToBool(display);
305 pOGLSViewer->fDisplayHeadTimeX = screenX;
306 pOGLSViewer->fDisplayHeadTimeY = screenY;
307 pOGLSViewer->fDisplayHeadTimeSize = screenSize;
308 pOGLSViewer->fDisplayHeadTimeRed = red;
309 pOGLSViewer->fDisplayHeadTimeGreen = green;
310 pOGLSViewer->fDisplayHeadTimeBlue = blue;
311 }
312
313 if (command == fpCommandDisplayLightFront)
314 {
315 G4String display, originX, originY, originZ, unitS, originT, unitT;
316 G4double red, green, blue;
317 std::istringstream iss(newValue);
318 iss >> display
319 >> originX >> originY >> originZ >> unitS
320 >> originT >> unitT
321 >> red >> green >> blue;
322 pOGLSViewer->fDisplayLightFront = command->ConvertToBool(display);
323 pOGLSViewer->fDisplayLightFrontX =
324 command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
325 pOGLSViewer->fDisplayLightFrontY =
326 command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
327 pOGLSViewer->fDisplayLightFrontZ =
328 command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
329 pOGLSViewer->fDisplayLightFrontT =
330 command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
331 pOGLSViewer->fDisplayLightFrontRed = red;
332 pOGLSViewer->fDisplayLightFrontGreen = green;
333 pOGLSViewer->fDisplayLightFrontBlue = blue;
334 }
335
336 if (command == fpCommandEndTime)
337 {
338 G4String end_time_string, end_time_unit,
339 time_range_string, time_range_unit;
340 std::istringstream iss(newValue);
341 iss >> end_time_string >> end_time_unit
342 >> time_range_string >> time_range_unit;
343 pOGLSViewer->fEndTime = command->ConvertToDimensionedDouble
344 (G4String(end_time_string + ' ' + end_time_unit));
345 G4double timeRange = command->ConvertToDimensionedDouble
346 (G4String(time_range_string + ' ' + time_range_unit));
347 if (timeRange > 0.) {
348 pOGLSViewer->fStartTime = pOGLSViewer->fEndTime - timeRange;
349 }
350 if (pOGLSViewer->fVP.IsAutoRefresh())
351 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
352 }
353
354 if (command == fpCommandFade)
355 {
356 pOGLSViewer->fFadeFactor = command->ConvertToDouble(newValue);
357 if (pOGLSViewer->fVP.IsAutoRefresh())
358 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
359 }
360
361 if (command == fpCommandStartTime)
362 {
363 G4String start_time_string, start_time_unit,
364 time_range_string, time_range_unit;
365 std::istringstream iss(newValue);
366 iss >> start_time_string >> start_time_unit
367 >> time_range_string >> time_range_unit;
368 pOGLSViewer->fStartTime = command->ConvertToDimensionedDouble
369 (G4String(start_time_string + ' ' + start_time_unit));
370 G4double timeRange = command->ConvertToDimensionedDouble
371 (G4String(time_range_string + ' ' + time_range_unit));
372 if (timeRange > 0.) {
373 pOGLSViewer->fEndTime = pOGLSViewer->fStartTime + timeRange;
374 }
375 if (pOGLSViewer->fVP.IsAutoRefresh())
376 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
377 }
378
379}
380
381#endif
Note: See TracBrowser for help on using the repository browser.