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

Last change on this file since 601 was 599, checked in by garnier, 18 years ago

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