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

Last change on this file since 1040 was 1037, checked in by garnier, 17 years ago

resize en cours de factorisation
  • Property svn:mime-type set to text/cpp
File size: 15.3 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.17 2009/04/28 15:05: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* 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 return;
277 }
278
279 if (command == fpCommandTransparency)
280 {
281 pOGLViewer->transparency_enabled = command->ConvertToBool(newValue);
282 if (pOGLViewer->fVP.IsAutoRefresh())
283 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
284 return;
285 }
286
287 G4OpenGLStoredViewer* pOGLSViewer =
288 dynamic_cast<G4OpenGLStoredViewer*>(pViewer);
289
290 if (!pOGLSViewer)
291 {
292 G4cout <<
293 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
294 "\n The time slice viewing feature is only implemented for OGL Stored"
295 "\n viewers at present. Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
296 << G4endl;
297 return;
298 }
299
300 if (command == fpCommandDisplayHeadTime)
301 {
302 G4String display;
303 G4double screenX, screenY, screenSize, red, green, blue;
304 std::istringstream iss(newValue);
305 iss >> display >> screenX >> screenY
306 >> screenSize >> red >> green >> blue;
307 pOGLSViewer->fDisplayHeadTime = command->ConvertToBool(display);
308 pOGLSViewer->fDisplayHeadTimeX = screenX;
309 pOGLSViewer->fDisplayHeadTimeY = screenY;
310 pOGLSViewer->fDisplayHeadTimeSize = screenSize;
311 pOGLSViewer->fDisplayHeadTimeRed = red;
312 pOGLSViewer->fDisplayHeadTimeGreen = green;
313 pOGLSViewer->fDisplayHeadTimeBlue = blue;
314 return;
315 }
316
317 if (command == fpCommandDisplayLightFront)
318 {
319 G4String display, originX, originY, originZ, unitS, originT, unitT;
320 G4double red, green, blue;
321 std::istringstream iss(newValue);
322 iss >> display
323 >> originX >> originY >> originZ >> unitS
324 >> originT >> unitT
325 >> red >> green >> blue;
326 pOGLSViewer->fDisplayLightFront = command->ConvertToBool(display);
327 pOGLSViewer->fDisplayLightFrontX =
328 command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
329 pOGLSViewer->fDisplayLightFrontY =
330 command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
331 pOGLSViewer->fDisplayLightFrontZ =
332 command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
333 pOGLSViewer->fDisplayLightFrontT =
334 command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
335 pOGLSViewer->fDisplayLightFrontRed = red;
336 pOGLSViewer->fDisplayLightFrontGreen = green;
337 pOGLSViewer->fDisplayLightFrontBlue = blue;
338 return;
339 }
340
341 if (command == fpCommandEndTime)
342 {
343 G4String end_time_string, end_time_unit,
344 time_range_string, time_range_unit;
345 std::istringstream iss(newValue);
346 iss >> end_time_string >> end_time_unit
347 >> time_range_string >> time_range_unit;
348 pOGLSViewer->fEndTime = command->ConvertToDimensionedDouble
349 (G4String(end_time_string + ' ' + end_time_unit));
350 G4double timeRange = command->ConvertToDimensionedDouble
351 (G4String(time_range_string + ' ' + time_range_unit));
352 if (timeRange > 0.) {
353 pOGLSViewer->fStartTime = pOGLSViewer->fEndTime - timeRange;
354 }
355 if (pOGLSViewer->fVP.IsAutoRefresh())
356 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
357 return;
358 }
359
360 if (command == fpCommandFade)
361 {
362 pOGLSViewer->fFadeFactor = command->ConvertToDouble(newValue);
363 if (pOGLSViewer->fVP.IsAutoRefresh())
364 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
365 }
366
367 if (command == fpCommandStartTime)
368 {
369 G4String start_time_string, start_time_unit,
370 time_range_string, time_range_unit;
371 std::istringstream iss(newValue);
372 iss >> start_time_string >> start_time_unit
373 >> time_range_string >> time_range_unit;
374 pOGLSViewer->fStartTime = command->ConvertToDimensionedDouble
375 (G4String(start_time_string + ' ' + start_time_unit));
376 G4double timeRange = command->ConvertToDimensionedDouble
377 (G4String(time_range_string + ' ' + time_range_unit));
378 if (timeRange > 0.) {
379 pOGLSViewer->fEndTime = pOGLSViewer->fStartTime + timeRange;
380 }
381 if (pOGLSViewer->fVP.IsAutoRefresh())
382 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
383 return;
384 }
385
386}
387
388#endif
Note: See TracBrowser for help on using the repository browser.