source: tags/Visualization_after-vis09-02-01-tag/OpenGL/src/G4OpenGLViewerMessenger.cc @ 958

Last change on this file since 958 was 948, checked in by garnier, 15 years ago

Works for OGLSXm et non vector
  • 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.16 2009/03/18 14:34:28 allison Exp $
28// GEANT4 tag $Name:  $
29
30#ifdef G4VIS_BUILD_OPENGL_DRIVER
31
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"
39#include "G4UIcmdWithoutParameter.hh"
40#include "G4UIcmdWithADouble.hh"
41#include "G4UIcmdWithABool.hh"
42#include "G4UIcmdWithAString.hh"
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
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"
68     "\nnumber, starting at 0."
69     "\nCan be \"vectored\" or \"pixmap\" - see \"/vis/ogl/set/printMode\".");
70
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);
160  parameter->SetDefaultValue(DBL_MAX);
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
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
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);
190  parameter->SetDefaultValue(-DBL_MAX);
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{
213  delete fpCommandPrintMode;
214  delete fpCommandTransparency;
215  delete fpCommandStartTime;
216  delete fpCommandFade;
217  delete fpCommandEndTime;
218  delete fpCommandDisplayLightFront;
219  delete fpCommandDisplayHeadTime;
220  delete fpDirectorySet;
221  delete fpCommandPrintEPS;
222  delete fpDirectory;
223
224  delete fpInstance;
225}
226
227void G4OpenGLViewerMessenger::SetNewValue
228(G4UIcommand* command, G4String newValue)
229{
230  G4VisManager* pVisManager = G4VisManager::GetInstance();
231
232  G4VViewer* pViewer = pVisManager->GetCurrentViewer();
233
234  if (!pViewer) {
235    G4cout <<
236      "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
237      "\n  \"/vis/open\", or similar, to get one."
238           << G4endl;
239    return;
240  }
241
242  G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pViewer);
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
252  if (command == fpCommandPrintEPS)
253    {
254      // Keep copy of fPrintFilename to preserve Xm behaviour...
255      std::string tmp_string = pOGLViewer->fPrintFilename;
256
257      // Make new print string...
258      static G4int file_count = 0;
259      std::ostringstream oss;
260      oss << "G4OpenGL_" << file_count++ << ".eps";
261      pOGLViewer->fPrintFilename = std::string(oss.str().c_str());
262      // Print eps file...
263      pOGLViewer->printEPS();
264      // Restore fPrintFilename for Xm...
265      pOGLViewer->fPrintFilename = tmp_string;
266      return;
267    }
268
269  if (command == fpCommandPrintMode)
270    {
271      if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
272      if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
273    }
274
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    }
281
282  G4OpenGLStoredViewer* pOGLSViewer =
283    dynamic_cast<G4OpenGLStoredViewer*>(pViewer);
284
285  if (!pOGLSViewer) {
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"
289  "\n  viewers at present.  Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
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;
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;
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;
319      pOGLSViewer->fDisplayLightFront = command->ConvertToBool(display);
320      pOGLSViewer->fDisplayLightFrontX =
321        command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
322      pOGLSViewer->fDisplayLightFrontY =
323        command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
324      pOGLSViewer->fDisplayLightFrontZ =
325        command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
326      pOGLSViewer->fDisplayLightFrontT =
327        command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
328      pOGLSViewer->fDisplayLightFrontRed = red;
329      pOGLSViewer->fDisplayLightFrontGreen = green;
330      pOGLSViewer->fDisplayLightFrontBlue = blue;
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;
340      pOGLSViewer->fEndTime = command->ConvertToDimensionedDouble
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.) {
345        pOGLSViewer->fStartTime = pOGLSViewer->fEndTime - timeRange;
346      }
347      if (pOGLSViewer->fVP.IsAutoRefresh())
348        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
349    }
350
351  if (command == fpCommandFade)
352    {
353      pOGLSViewer->fFadeFactor = command->ConvertToDouble(newValue);
354      if (pOGLSViewer->fVP.IsAutoRefresh())
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;
365      pOGLSViewer->fStartTime = command->ConvertToDimensionedDouble
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.) {
370        pOGLSViewer->fEndTime = pOGLSViewer->fStartTime + timeRange;
371      }
372      if (pOGLSViewer->fVP.IsAutoRefresh())
373        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
374    }
375
376}
377
378#endif
Note: See TracBrowser for help on using the repository browser.