source: trunk/geant4/visualization/OpenGL/src/G4OpenGLViewerMessenger.cc@ 597

Last change on this file since 597 was 593, checked in by garnier, 18 years ago

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