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

Last change on this file since 816 was 789, checked in by garnier, 18 years ago

r815@wl-72126: garnier | 2008-04-23 15:28:34 +0200
maj par rapport au CVS
  • 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.12 2008/04/04 13:32:22 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* pVViewer = pVisManager->GetCurrentViewer();
233
234 if (!pVViewer) {
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*>(pVViewer);
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 print_string to preserve Xm behaviour...
255 char* tmp_string = new char[50];
256 strcpy (tmp_string, pOGLViewer->print_string);
257 // Make new print string...
258 static G4int file_count = 0;
259 std::ostringstream oss;
260 oss << "G4OpenGL_" << file_count++ << ".eps";
261 strcpy (pOGLViewer->print_string, oss.str().c_str());
262 // Print eps file...
263 pOGLViewer->print();
264 // Restore print_string for Xm...
265 strcpy (pOGLViewer->print_string, tmp_string);
266 delete tmp_string;
267 return;
268 }
269
270 G4OpenGLStoredViewer* pViewer =
271 dynamic_cast<G4OpenGLStoredViewer*>(pVViewer);
272
273 if (!pViewer) {
274 G4cout <<
275 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
276 "\n The time slice viewing feature is only implemented for OGL Stored"
277 "\n viewers at present. Use \"/vis/viewer/select\" or \"/vis/open\"."
278 << G4endl;
279 return;
280 }
281
282 if (command == fpCommandDisplayHeadTime)
283 {
284 G4String display;
285 G4double screenX, screenY, screenSize, red, green, blue;
286 std::istringstream iss(newValue);
287 iss >> display >> screenX >> screenY
288 >> screenSize >> red >> green >> blue;
289 pViewer->fDisplayHeadTime = command->ConvertToBool(display);
290 pViewer->fDisplayHeadTimeX = screenX;
291 pViewer->fDisplayHeadTimeY = screenY;
292 pViewer->fDisplayHeadTimeSize = screenSize;
293 pViewer->fDisplayHeadTimeRed = red;
294 pViewer->fDisplayHeadTimeGreen = green;
295 pViewer->fDisplayHeadTimeBlue = blue;
296 }
297
298 if (command == fpCommandDisplayLightFront)
299 {
300 G4String display, originX, originY, originZ, unitS, originT, unitT;
301 G4double red, green, blue;
302 std::istringstream iss(newValue);
303 iss >> display
304 >> originX >> originY >> originZ >> unitS
305 >> originT >> unitT
306 >> red >> green >> blue;
307 pViewer->fDisplayLightFront = command->ConvertToBool(display);
308 pViewer->fDisplayLightFrontX =
309 command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
310 pViewer->fDisplayLightFrontY =
311 command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
312 pViewer->fDisplayLightFrontZ =
313 command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
314 pViewer->fDisplayLightFrontT =
315 command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
316 pViewer->fDisplayLightFrontRed = red;
317 pViewer->fDisplayLightFrontGreen = green;
318 pViewer->fDisplayLightFrontBlue = blue;
319 }
320
321 if (command == fpCommandEndTime)
322 {
323 G4String end_time_string, end_time_unit,
324 time_range_string, time_range_unit;
325 std::istringstream iss(newValue);
326 iss >> end_time_string >> end_time_unit
327 >> time_range_string >> time_range_unit;
328 pViewer->fEndTime = command->ConvertToDimensionedDouble
329 (G4String(end_time_string + ' ' + end_time_unit));
330 G4double timeRange = command->ConvertToDimensionedDouble
331 (G4String(time_range_string + ' ' + time_range_unit));
332 if (timeRange > 0.) {
333 pViewer->fStartTime = pViewer->fEndTime - timeRange;
334 }
335 if (pViewer->fVP.IsAutoRefresh())
336 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
337 }
338
339 if (command == fpCommandFade)
340 {
341 pViewer->fFadeFactor = command->ConvertToDouble(newValue);
342 if (pViewer->fVP.IsAutoRefresh())
343 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
344 }
345
346 if (command == fpCommandPrintMode)
347 {
348 if (newValue == "vectored") pViewer->vectored_ps = true;
349 if (newValue == "pixmap") {
350 pViewer->vectored_ps = false;
351 if (pVisManager->GetVerbosity() >= G4VisManager::warnings) {
352 G4cout <<
353 "WARNING: Only implemented for X Windows at present."
354 << G4endl;
355 }
356 }
357 }
358
359 if (command == fpCommandStartTime)
360 {
361 G4String start_time_string, start_time_unit,
362 time_range_string, time_range_unit;
363 std::istringstream iss(newValue);
364 iss >> start_time_string >> start_time_unit
365 >> time_range_string >> time_range_unit;
366 pViewer->fStartTime = command->ConvertToDimensionedDouble
367 (G4String(start_time_string + ' ' + start_time_unit));
368 G4double timeRange = command->ConvertToDimensionedDouble
369 (G4String(time_range_string + ' ' + time_range_unit));
370 if (timeRange > 0.) {
371 pViewer->fEndTime = pViewer->fStartTime + timeRange;
372 }
373 if (pViewer->fVP.IsAutoRefresh())
374 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
375 }
376
377 if (command == fpCommandTransparency)
378 {
379 pViewer->transparency_enabled = command->ConvertToBool(newValue);
380 if (pViewer->fVP.IsAutoRefresh())
381 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
382 }
383
384}
385
386#endif
Note: See TracBrowser for help on using the repository browser.