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

Last change on this file since 873 was 850, checked in by garnier, 16 years ago

geant4.8.2 beta
  • 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.12 2008/04/04 13:32:22 allison Exp $
28// GEANT4 tag $Name: HEAD $
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* pVViewer = pVisManager->GetCurrentViewer();
233
234  if (!pVViewer) {
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*>(pVViewer);
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 print_string to preserve Xm behaviour...
255      char* tmp_string = new char[50];
256      strcpy (tmp_string, pOGLViewer->print_string);
257      // Make new print string...
258      static G4int file_count = 0;
259      std::ostringstream oss;
260      oss << "G4OpenGL_" << file_count++ << ".eps";
261      strcpy (pOGLViewer->print_string, oss.str().c_str());
262      // Print eps file...
263      pOGLViewer->print();
264      // Restore print_string for Xm...
265      strcpy (pOGLViewer->print_string, tmp_string);
266      delete tmp_string;
267      return;
268    }
269
270  G4OpenGLStoredViewer* pViewer =
271    dynamic_cast<G4OpenGLStoredViewer*>(pVViewer);
272
273  if (!pViewer) {
274    G4cout <<
275  "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
276  "\n  The time slice viewing feature is only implemented for OGL Stored"
277  "\n  viewers at present.  Use \"/vis/viewer/select\" or \"/vis/open\"."
278           << G4endl;
279    return;
280  }
281
282  if (command == fpCommandDisplayHeadTime)
283    {
284      G4String display;
285      G4double screenX, screenY, screenSize, red, green, blue;
286      std::istringstream iss(newValue);
287      iss >> display >> screenX >> screenY
288          >> screenSize >> red >> green >> blue;
289      pViewer->fDisplayHeadTime = command->ConvertToBool(display);
290      pViewer->fDisplayHeadTimeX = screenX;
291      pViewer->fDisplayHeadTimeY = screenY;
292      pViewer->fDisplayHeadTimeSize = screenSize;
293      pViewer->fDisplayHeadTimeRed = red;
294      pViewer->fDisplayHeadTimeGreen = green;
295      pViewer->fDisplayHeadTimeBlue = blue;
296    }
297
298  if (command == fpCommandDisplayLightFront)
299    {
300      G4String display, originX, originY, originZ, unitS, originT, unitT;
301      G4double red, green, blue;
302      std::istringstream iss(newValue);
303      iss >> display
304          >> originX >> originY >> originZ >> unitS
305          >> originT >> unitT
306          >> red >> green >> blue;
307      pViewer->fDisplayLightFront = command->ConvertToBool(display);
308      pViewer->fDisplayLightFrontX =
309        command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
310      pViewer->fDisplayLightFrontY =
311        command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
312      pViewer->fDisplayLightFrontZ =
313        command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
314      pViewer->fDisplayLightFrontT =
315        command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
316      pViewer->fDisplayLightFrontRed = red;
317      pViewer->fDisplayLightFrontGreen = green;
318      pViewer->fDisplayLightFrontBlue = blue;
319    }
320
321  if (command == fpCommandEndTime)
322    {
323      G4String end_time_string, end_time_unit,
324        time_range_string, time_range_unit;
325      std::istringstream iss(newValue);
326      iss >> end_time_string >> end_time_unit
327          >> time_range_string >> time_range_unit;
328      pViewer->fEndTime = command->ConvertToDimensionedDouble
329        (G4String(end_time_string + ' ' + end_time_unit));
330      G4double timeRange = command->ConvertToDimensionedDouble
331        (G4String(time_range_string + ' ' + time_range_unit));
332      if (timeRange > 0.) {
333        pViewer->fStartTime = pViewer->fEndTime - timeRange;
334      }
335      if (pViewer->fVP.IsAutoRefresh())
336        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
337    }
338
339  if (command == fpCommandFade)
340    {
341      pViewer->fFadeFactor = command->ConvertToDouble(newValue);
342      if (pViewer->fVP.IsAutoRefresh())
343        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
344    }
345
346  if (command == fpCommandPrintMode)
347    {
348      if (newValue == "vectored") pViewer->vectored_ps = true;
349      if (newValue == "pixmap") {
350        pViewer->vectored_ps = false;
351        if (pVisManager->GetVerbosity() >= G4VisManager::warnings) {
352          G4cout <<
353            "WARNING: Only implemented for X Windows at present."
354                 << G4endl;
355        }
356      }
357    }
358
359  if (command == fpCommandStartTime)
360    {
361      G4String start_time_string, start_time_unit,
362        time_range_string, time_range_unit;
363      std::istringstream iss(newValue);
364      iss >> start_time_string >> start_time_unit
365          >> time_range_string >> time_range_unit;
366      pViewer->fStartTime = command->ConvertToDimensionedDouble
367        (G4String(start_time_string + ' ' + start_time_unit));
368      G4double timeRange = command->ConvertToDimensionedDouble
369        (G4String(time_range_string + ' ' + time_range_unit));
370      if (timeRange > 0.) {
371        pViewer->fEndTime = pViewer->fStartTime + timeRange;
372      }
373      if (pViewer->fVP.IsAutoRefresh())
374        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
375    }
376
377  if (command == fpCommandTransparency)
378    {
379      pViewer->transparency_enabled = command->ConvertToBool(newValue);
380      if (pViewer->fVP.IsAutoRefresh())
381        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
382    }
383
384}
385
386#endif
Note: See TracBrowser for help on using the repository browser.