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

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

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