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

Last change on this file since 595 was 593, checked in by garnier, 17 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
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.9 2007/06/15 09:52:52 gcosmo Exp $
28// GEANT4 tag $Name: geant4-09-00-ref-01 $
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
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);
157  parameter->SetDefaultValue(G4OPENGL_DBL_MAX);
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
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
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);
187  parameter->SetDefaultValue(-G4OPENGL_DBL_MAX);
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{
210  delete fpCommandPrintMode;
211  delete fpCommandTransparency;
212  delete fpCommandStartTime;
213  delete fpCommandFade;
214  delete fpCommandEndTime;
215  delete fpCommandDisplayLightFront;
216  delete fpCommandDisplayHeadTime;
217  delete fpDirectorySet;
218  delete fpCommandPrintEPS;
219  delete fpDirectory;
220
221  delete fpInstance;
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
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
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
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
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.