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

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

en OGLIX ca marche...
  • 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//
[941]27// $Id: G4OpenGLViewerMessenger.cc,v 1.15 2009/03/05 16:36:13 lgarnier 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
[946]179
[593]180 fpCommandPrintMode = new G4UIcmdWithAString
181 ("/vis/ogl/set/printMode",this);
182 fpCommandPrintMode->SetGuidance("Set print mode");
183 fpCommandPrintMode->SetParameterName("print_mode",omitable = true);
184 fpCommandPrintMode->SetCandidates("vectored pixmap");
185 fpCommandPrintMode->SetDefaultValue("vectored");
186
[529]187 fpCommandStartTime =
188 new G4UIcommand("/vis/ogl/set/startTime", this);
189 fpCommandStartTime->SetGuidance("Set start and range of track time.");
190 parameter = new G4UIparameter ("start-time", 'd', omitable = false);
[789]191 parameter->SetDefaultValue(-DBL_MAX);
[529]192 fpCommandStartTime->SetParameter(parameter);
193 parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
194 parameter->SetDefaultValue("ns");
195 fpCommandStartTime->SetParameter(parameter);
196 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
197 parameter->SetDefaultValue(-1.);
198 fpCommandStartTime->SetParameter(parameter);
199 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
200 parameter->SetDefaultValue("ns");
201 fpCommandStartTime->SetParameter(parameter);
202
203 fpCommandTransparency =
204 new G4UIcmdWithABool("/vis/ogl/set/transparency", this);
205 fpCommandTransparency->SetGuidance
206 ("True/false to enable/disable rendering of transparent objects.");
207 fpCommandTransparency->SetParameterName
208 ("transparency-enabled", omitable = true);
209 fpCommandTransparency->SetDefaultValue(true);
210}
211
212G4OpenGLViewerMessenger::~G4OpenGLViewerMessenger ()
213{
[593]214 delete fpCommandPrintMode;
[529]215 delete fpCommandTransparency;
216 delete fpCommandStartTime;
217 delete fpCommandFade;
218 delete fpCommandEndTime;
219 delete fpCommandDisplayLightFront;
220 delete fpCommandDisplayHeadTime;
221 delete fpDirectorySet;
[593]222 delete fpCommandPrintEPS;
[529]223 delete fpDirectory;
[593]224
225 delete fpInstance;
[529]226}
227
228void G4OpenGLViewerMessenger::SetNewValue
229(G4UIcommand* command, G4String newValue)
230{
[946]231
[529]232 G4VisManager* pVisManager = G4VisManager::GetInstance();
233
[946]234
[529]235 G4VViewer* pVViewer = pVisManager->GetCurrentViewer();
236
237 if (!pVViewer) {
238 G4cout <<
239 "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
240 "\n \"/vis/open\", or similar, to get one."
241 << G4endl;
242 return;
243 }
244
245 G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pVViewer);
246
247 if (!pOGLViewer) {
248 G4cout <<
249 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type"
250 "\n OGL. Use \"/vis/viewer/select\" or \"/vis/open\"."
251 << G4endl;
252 return;
253 }
254
[946]255 if (command == fpCommandPrintEPS)
[593]256 {
[916]257 // Keep copy of fPrintFilename to preserve Xm behaviour...
258 std::string tmp_string = pOGLViewer->fPrintFilename;
259
[593]260 // Make new print string...
261 static G4int file_count = 0;
262 std::ostringstream oss;
263 oss << "G4OpenGL_" << file_count++ << ".eps";
[916]264 pOGLViewer->fPrintFilename = std::string(oss.str().c_str());
[593]265 // Print eps file...
[946]266 printf("G4OpenGLViewerMessenger : Call printEPS \n");
[941]267 pOGLViewer->printEPS();
[916]268 // Restore fPrintFilename for Xm...
269 pOGLViewer->fPrintFilename = tmp_string;
[593]270 return;
271 }
272
[946]273 if (command == fpCommandPrintMode)
274 {
275 if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
276 if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
277 }
278
[529]279 G4OpenGLStoredViewer* pViewer =
280 dynamic_cast<G4OpenGLStoredViewer*>(pVViewer);
281
282 if (!pViewer) {
283 G4cout <<
284 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
285 "\n The time slice viewing feature is only implemented for OGL Stored"
286 "\n viewers at present. Use \"/vis/viewer/select\" or \"/vis/open\"."
287 << G4endl;
288 return;
289 }
290
291 if (command == fpCommandDisplayHeadTime)
292 {
293 G4String display;
294 G4double screenX, screenY, screenSize, red, green, blue;
295 std::istringstream iss(newValue);
296 iss >> display >> screenX >> screenY
297 >> screenSize >> red >> green >> blue;
298 pViewer->fDisplayHeadTime = command->ConvertToBool(display);
299 pViewer->fDisplayHeadTimeX = screenX;
300 pViewer->fDisplayHeadTimeY = screenY;
301 pViewer->fDisplayHeadTimeSize = screenSize;
302 pViewer->fDisplayHeadTimeRed = red;
303 pViewer->fDisplayHeadTimeGreen = green;
304 pViewer->fDisplayHeadTimeBlue = blue;
305 }
306
307 if (command == fpCommandDisplayLightFront)
308 {
309 G4String display, originX, originY, originZ, unitS, originT, unitT;
310 G4double red, green, blue;
311 std::istringstream iss(newValue);
312 iss >> display
313 >> originX >> originY >> originZ >> unitS
314 >> originT >> unitT
315 >> red >> green >> blue;
316 pViewer->fDisplayLightFront = command->ConvertToBool(display);
317 pViewer->fDisplayLightFrontX =
318 command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
319 pViewer->fDisplayLightFrontY =
320 command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
321 pViewer->fDisplayLightFrontZ =
322 command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
323 pViewer->fDisplayLightFrontT =
324 command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
325 pViewer->fDisplayLightFrontRed = red;
326 pViewer->fDisplayLightFrontGreen = green;
327 pViewer->fDisplayLightFrontBlue = blue;
328 }
329
330 if (command == fpCommandEndTime)
331 {
332 G4String end_time_string, end_time_unit,
333 time_range_string, time_range_unit;
334 std::istringstream iss(newValue);
335 iss >> end_time_string >> end_time_unit
336 >> time_range_string >> time_range_unit;
337 pViewer->fEndTime = command->ConvertToDimensionedDouble
338 (G4String(end_time_string + ' ' + end_time_unit));
339 G4double timeRange = command->ConvertToDimensionedDouble
340 (G4String(time_range_string + ' ' + time_range_unit));
341 if (timeRange > 0.) {
342 pViewer->fStartTime = pViewer->fEndTime - timeRange;
343 }
344 if (pViewer->fVP.IsAutoRefresh())
345 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
346 }
347
348 if (command == fpCommandFade)
349 {
350 pViewer->fFadeFactor = command->ConvertToDouble(newValue);
351 if (pViewer->fVP.IsAutoRefresh())
352 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
353 }
354
355 if (command == fpCommandStartTime)
356 {
357 G4String start_time_string, start_time_unit,
358 time_range_string, time_range_unit;
359 std::istringstream iss(newValue);
360 iss >> start_time_string >> start_time_unit
361 >> time_range_string >> time_range_unit;
362 pViewer->fStartTime = command->ConvertToDimensionedDouble
363 (G4String(start_time_string + ' ' + start_time_unit));
364 G4double timeRange = command->ConvertToDimensionedDouble
365 (G4String(time_range_string + ' ' + time_range_unit));
366 if (timeRange > 0.) {
367 pViewer->fEndTime = pViewer->fStartTime + timeRange;
368 }
369 if (pViewer->fVP.IsAutoRefresh())
370 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
371 }
372
373 if (command == fpCommandTransparency)
374 {
375 pViewer->transparency_enabled = command->ConvertToBool(newValue);
376 if (pViewer->fVP.IsAutoRefresh())
377 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
378 }
379
380}
[608]381
382#endif
Note: See TracBrowser for help on using the repository browser.