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

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

Works for OGLSXm et non vector
  • Property svn:mime-type set to text/cpp
File size: 15.1 KB
RevLine 
[529]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//
[948]27// $Id: G4OpenGLViewerMessenger.cc,v 1.16 2009/03/18 14:34:28 allison Exp $
[911]28// GEANT4 tag $Name: $
[529]29
[608]30#ifdef G4VIS_BUILD_OPENGL_DRIVER
31
[529]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"
[593]39#include "G4UIcmdWithoutParameter.hh"
[529]40#include "G4UIcmdWithADouble.hh"
41#include "G4UIcmdWithABool.hh"
[593]42#include "G4UIcmdWithAString.hh"
[529]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
[593]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"
[599]68 "\nnumber, starting at 0."
69 "\nCan be \"vectored\" or \"pixmap\" - see \"/vis/ogl/set/printMode\".");
[593]70
[529]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);
[789]160 parameter->SetDefaultValue(DBL_MAX);
[529]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
[593]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
[529]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);
[789]190 parameter->SetDefaultValue(-DBL_MAX);
[529]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{
[593]213 delete fpCommandPrintMode;
[529]214 delete fpCommandTransparency;
215 delete fpCommandStartTime;
216 delete fpCommandFade;
217 delete fpCommandEndTime;
218 delete fpCommandDisplayLightFront;
219 delete fpCommandDisplayHeadTime;
220 delete fpDirectorySet;
[593]221 delete fpCommandPrintEPS;
[529]222 delete fpDirectory;
[593]223
224 delete fpInstance;
[529]225}
226
227void G4OpenGLViewerMessenger::SetNewValue
228(G4UIcommand* command, G4String newValue)
229{
230 G4VisManager* pVisManager = G4VisManager::GetInstance();
231
[948]232 G4VViewer* pViewer = pVisManager->GetCurrentViewer();
[946]233
[948]234 if (!pViewer) {
[529]235 G4cout <<
236 "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
237 "\n \"/vis/open\", or similar, to get one."
238 << G4endl;
239 return;
240 }
241
[948]242 G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pViewer);
[529]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
[948]252 if (command == fpCommandPrintEPS)
[593]253 {
[916]254 // Keep copy of fPrintFilename to preserve Xm behaviour...
255 std::string tmp_string = pOGLViewer->fPrintFilename;
256
[593]257 // Make new print string...
258 static G4int file_count = 0;
259 std::ostringstream oss;
260 oss << "G4OpenGL_" << file_count++ << ".eps";
[916]261 pOGLViewer->fPrintFilename = std::string(oss.str().c_str());
[593]262 // Print eps file...
[941]263 pOGLViewer->printEPS();
[916]264 // Restore fPrintFilename for Xm...
265 pOGLViewer->fPrintFilename = tmp_string;
[593]266 return;
267 }
268
[946]269 if (command == fpCommandPrintMode)
270 {
271 if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
272 if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
273 }
274
[948]275 if (command == fpCommandTransparency)
276 {
277 pOGLViewer->transparency_enabled = command->ConvertToBool(newValue);
278 if (pOGLViewer->fVP.IsAutoRefresh())
279 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
280 }
[529]281
[948]282 G4OpenGLStoredViewer* pOGLSViewer =
283 dynamic_cast<G4OpenGLStoredViewer*>(pViewer);
284
285 if (!pOGLSViewer) {
[529]286 G4cout <<
287 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
288 "\n The time slice viewing feature is only implemented for OGL Stored"
[948]289 "\n viewers at present. Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
[529]290 << G4endl;
291 return;
292 }
293
294 if (command == fpCommandDisplayHeadTime)
295 {
296 G4String display;
297 G4double screenX, screenY, screenSize, red, green, blue;
298 std::istringstream iss(newValue);
299 iss >> display >> screenX >> screenY
300 >> screenSize >> red >> green >> blue;
[948]301 pOGLSViewer->fDisplayHeadTime = command->ConvertToBool(display);
302 pOGLSViewer->fDisplayHeadTimeX = screenX;
303 pOGLSViewer->fDisplayHeadTimeY = screenY;
304 pOGLSViewer->fDisplayHeadTimeSize = screenSize;
305 pOGLSViewer->fDisplayHeadTimeRed = red;
306 pOGLSViewer->fDisplayHeadTimeGreen = green;
307 pOGLSViewer->fDisplayHeadTimeBlue = blue;
[529]308 }
309
310 if (command == fpCommandDisplayLightFront)
311 {
312 G4String display, originX, originY, originZ, unitS, originT, unitT;
313 G4double red, green, blue;
314 std::istringstream iss(newValue);
315 iss >> display
316 >> originX >> originY >> originZ >> unitS
317 >> originT >> unitT
318 >> red >> green >> blue;
[948]319 pOGLSViewer->fDisplayLightFront = command->ConvertToBool(display);
320 pOGLSViewer->fDisplayLightFrontX =
[529]321 command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
[948]322 pOGLSViewer->fDisplayLightFrontY =
[529]323 command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
[948]324 pOGLSViewer->fDisplayLightFrontZ =
[529]325 command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
[948]326 pOGLSViewer->fDisplayLightFrontT =
[529]327 command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
[948]328 pOGLSViewer->fDisplayLightFrontRed = red;
329 pOGLSViewer->fDisplayLightFrontGreen = green;
330 pOGLSViewer->fDisplayLightFrontBlue = blue;
[529]331 }
332
333 if (command == fpCommandEndTime)
334 {
335 G4String end_time_string, end_time_unit,
336 time_range_string, time_range_unit;
337 std::istringstream iss(newValue);
338 iss >> end_time_string >> end_time_unit
339 >> time_range_string >> time_range_unit;
[948]340 pOGLSViewer->fEndTime = command->ConvertToDimensionedDouble
[529]341 (G4String(end_time_string + ' ' + end_time_unit));
342 G4double timeRange = command->ConvertToDimensionedDouble
343 (G4String(time_range_string + ' ' + time_range_unit));
344 if (timeRange > 0.) {
[948]345 pOGLSViewer->fStartTime = pOGLSViewer->fEndTime - timeRange;
[529]346 }
[948]347 if (pOGLSViewer->fVP.IsAutoRefresh())
[529]348 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
349 }
350
351 if (command == fpCommandFade)
352 {
[948]353 pOGLSViewer->fFadeFactor = command->ConvertToDouble(newValue);
354 if (pOGLSViewer->fVP.IsAutoRefresh())
[529]355 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
356 }
357
358 if (command == fpCommandStartTime)
359 {
360 G4String start_time_string, start_time_unit,
361 time_range_string, time_range_unit;
362 std::istringstream iss(newValue);
363 iss >> start_time_string >> start_time_unit
364 >> time_range_string >> time_range_unit;
[948]365 pOGLSViewer->fStartTime = command->ConvertToDimensionedDouble
[529]366 (G4String(start_time_string + ' ' + start_time_unit));
367 G4double timeRange = command->ConvertToDimensionedDouble
368 (G4String(time_range_string + ' ' + time_range_unit));
369 if (timeRange > 0.) {
[948]370 pOGLSViewer->fEndTime = pOGLSViewer->fStartTime + timeRange;
[529]371 }
[948]372 if (pOGLSViewer->fVP.IsAutoRefresh())
[529]373 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
374 }
375
376}
[608]377
378#endif
Note: See TracBrowser for help on using the repository browser.