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

Last change on this file since 553 was 529, checked in by garnier, 17 years ago

r658@mac-90108: laurentgarnier | 2007-06-25 12:02:16 +0200
import de visualisation
  • Property svn:mime-type set to text/cpp
File size: 13.4 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.5 2006/10/24 06:20:42 allison Exp $
28// GEANT4 tag $Name: geant4-08-02-patch-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 "G4UIcmdWithADouble.hh"
38#include "G4UIcmdWithABool.hh"
39#include "G4VisManager.hh"
40#include <sstream>
41
42G4OpenGLViewerMessenger*
43G4OpenGLViewerMessenger::fpInstance = 0;
44
45G4OpenGLViewerMessenger*
46G4OpenGLViewerMessenger::GetInstance()
47{
48  if (!fpInstance) fpInstance = new G4OpenGLViewerMessenger;
49  return fpInstance;
50}
51
52G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
53{
54  G4bool omitable;
55
56  fpDirectory = new G4UIdirectory("/vis/ogl/");
57  fpDirectory->SetGuidance("G4OpenGLViewer commands.");
58
59  fpDirectorySet = new G4UIdirectory ("/vis/ogl/set/");
60  fpDirectorySet->SetGuidance("G4OpenGLViewer set commands.");
61
62  G4UIparameter* parameter;
63
64  fpCommandDisplayHeadTime =
65    new G4UIcommand("/vis/ogl/set/displayHeadTime", this);
66  fpCommandDisplayHeadTime->SetGuidance
67    ("Display head time of range in 2D text.");
68  parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
69  parameter->SetDefaultValue(false);
70  fpCommandDisplayHeadTime->SetParameter(parameter);
71  parameter = new G4UIparameter ("screenX", 'd', omitable = true);
72  parameter->SetGuidance("-1 < screenX < 1");
73  parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
74  parameter->SetDefaultValue(-0.9);
75  fpCommandDisplayHeadTime->SetParameter(parameter);
76  parameter = new G4UIparameter ("screenY", 'd', omitable = true);
77  parameter->SetGuidance("-1 < screenY < 1");
78  parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
79  parameter->SetDefaultValue(-0.9);
80  fpCommandDisplayHeadTime->SetParameter(parameter);
81  parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
82  parameter->SetDefaultValue(24.);
83  fpCommandDisplayHeadTime->SetParameter(parameter);
84  parameter = new G4UIparameter ("red", 'd', omitable = true);
85  parameter->SetParameterRange("red >= 0. && red <= 1.");
86  parameter->SetDefaultValue(0.);
87  fpCommandDisplayHeadTime->SetParameter(parameter);
88  parameter = new G4UIparameter ("green", 'd', omitable = true);
89  parameter->SetParameterRange("green >= 0. && green <= 1.");
90  parameter->SetDefaultValue(1.);
91  fpCommandDisplayHeadTime->SetParameter(parameter);
92  parameter = new G4UIparameter ("blue", 'd', omitable = true);
93  parameter->SetParameterRange("blue >= 0. && blue <= 1.");
94  parameter->SetDefaultValue(1.);
95  fpCommandDisplayHeadTime->SetParameter(parameter);
96
97  fpCommandDisplayLightFront =
98    new G4UIcommand("/vis/ogl/set/displayLightFront", this);
99  fpCommandDisplayLightFront->SetGuidance
100    ("Display the light front at head time.");
101  fpCommandDisplayLightFront->SetGuidance
102    ("Tip: The trajectories can appear of jump ahead of the light front"
103     "\nbecause their time range overlaps the viewer's time range.  To"
104     "\naverage out this discrete time effect, advance the light front by"
105     "\nhalf the trajectories interval. E.g., if the trajectory time slice"
106     "\ninterval is 0.01 ns:"
107     "\n  /vis/ogl/set/displayLightFront true -90 0 0 mm -0.005 ns"
108     "\nTo prevent them beating the light front at all:"
109     "\n  /vis/ogl/set/displayLightFront true -90 0 0 mm -0.01 ns");
110  parameter = new G4UIparameter ("displayLightFront", 'b', omitable = false);
111  parameter->SetDefaultValue(false);
112  fpCommandDisplayLightFront->SetParameter(parameter);
113  parameter = new G4UIparameter ("originX", 'd', omitable = true);
114  parameter->SetDefaultValue(0.);
115  fpCommandDisplayLightFront->SetParameter(parameter);
116  parameter = new G4UIparameter ("originY", 'd', omitable = true);
117  parameter->SetDefaultValue(0.);
118  fpCommandDisplayLightFront->SetParameter(parameter);
119  parameter = new G4UIparameter ("originZ", 'd', omitable = true);
120  parameter->SetDefaultValue(0.);
121  fpCommandDisplayLightFront->SetParameter(parameter);
122  parameter = new G4UIparameter ("space_unit", 's', omitable = true);
123  parameter->SetDefaultValue("m");
124  fpCommandDisplayLightFront->SetParameter(parameter);
125  parameter = new G4UIparameter ("originT", 'd', omitable = true);
126  parameter->SetDefaultValue(0.);
127  fpCommandDisplayLightFront->SetParameter(parameter);
128  parameter = new G4UIparameter ("time_unit", 's', omitable = true);
129  parameter->SetDefaultValue("s");
130  fpCommandDisplayLightFront->SetParameter(parameter);
131  parameter = new G4UIparameter ("red", 'd', omitable = true);
132  parameter->SetParameterRange("red >= 0. && red <= 1.");
133  parameter->SetDefaultValue(0.);
134  fpCommandDisplayLightFront->SetParameter(parameter);
135  parameter = new G4UIparameter ("green", 'd', omitable = true);
136  parameter->SetParameterRange("green >= 0. && green <= 1.");
137  parameter->SetDefaultValue(1.);
138  fpCommandDisplayLightFront->SetParameter(parameter);
139  parameter = new G4UIparameter ("blue", 'd', omitable = true);
140  parameter->SetParameterRange("blue >= 0. && blue <= 1.");
141  parameter->SetDefaultValue(0.);
142  fpCommandDisplayLightFront->SetParameter(parameter);
143
144  fpCommandEndTime =
145    new G4UIcommand("/vis/ogl/set/endTime", this);
146  fpCommandEndTime->SetGuidance("Set end and range of track time.");
147  parameter = new G4UIparameter ("end-time", 'd', omitable = false);
148  parameter->SetDefaultValue(DBL_MAX);
149  fpCommandEndTime->SetParameter(parameter);
150  parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
151  parameter->SetDefaultValue("ns");
152  fpCommandEndTime->SetParameter(parameter);
153  parameter = new G4UIparameter ("time-range", 'd', omitable = true);
154  parameter->SetDefaultValue(-1.);
155  fpCommandEndTime->SetParameter(parameter);
156  parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
157  parameter->SetDefaultValue("ns");
158  fpCommandEndTime->SetParameter(parameter);
159
160  fpCommandFade = new G4UIcmdWithADouble("/vis/ogl/set/fade", this);
161  fpCommandFade->SetGuidance
162    ("0: no fade; 1: maximum fade with time within range.");
163  fpCommandFade->SetParameterName("fadefactor", omitable = false);
164  fpCommandFade->SetRange("fadefactor>=0.&&fadefactor<=1.");
165  fpCommandFade->SetDefaultValue(0.);
166
167  fpCommandStartTime =
168    new G4UIcommand("/vis/ogl/set/startTime", this);
169  fpCommandStartTime->SetGuidance("Set start and range of track time.");
170  parameter = new G4UIparameter ("start-time", 'd', omitable = false);
171  parameter->SetDefaultValue(-DBL_MAX);
172  fpCommandStartTime->SetParameter(parameter);
173  parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
174  parameter->SetDefaultValue("ns");
175  fpCommandStartTime->SetParameter(parameter);
176  parameter = new G4UIparameter ("time-range", 'd', omitable = true);
177  parameter->SetDefaultValue(-1.);
178  fpCommandStartTime->SetParameter(parameter);
179  parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
180  parameter->SetDefaultValue("ns");
181  fpCommandStartTime->SetParameter(parameter);
182
183  fpCommandTransparency =
184    new G4UIcmdWithABool("/vis/ogl/set/transparency", this);
185  fpCommandTransparency->SetGuidance
186    ("True/false to enable/disable rendering of transparent objects.");
187  fpCommandTransparency->SetParameterName
188    ("transparency-enabled", omitable = true);
189  fpCommandTransparency->SetDefaultValue(true);
190}
191
192G4OpenGLViewerMessenger::~G4OpenGLViewerMessenger ()
193{
194  delete fpCommandTransparency;
195  delete fpCommandStartTime;
196  delete fpCommandFade;
197  delete fpCommandEndTime;
198  delete fpCommandDisplayLightFront;
199  delete fpCommandDisplayHeadTime;
200  delete fpDirectorySet;
201  delete fpDirectory;
202}
203
204void G4OpenGLViewerMessenger::SetNewValue
205(G4UIcommand* command, G4String newValue)
206{
207  G4VisManager* pVisManager = G4VisManager::GetInstance();
208
209  G4VViewer* pVViewer = pVisManager->GetCurrentViewer();
210
211  if (!pVViewer) {
212    G4cout <<
213      "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
214      "\n  \"/vis/open\", or similar, to get one."
215           << G4endl;
216    return;
217  }
218
219  G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pVViewer);
220
221  if (!pOGLViewer) {
222    G4cout <<
223      "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type"
224      "\n  OGL.  Use \"/vis/viewer/select\" or \"/vis/open\"."
225           << G4endl;
226    return;
227  }
228
229  G4OpenGLStoredViewer* pViewer =
230    dynamic_cast<G4OpenGLStoredViewer*>(pVViewer);
231
232  if (!pViewer) {
233    G4cout <<
234  "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
235  "\n  The time slice viewing feature is only implemented for OGL Stored"
236  "\n  viewers at present.  Use \"/vis/viewer/select\" or \"/vis/open\"."
237           << G4endl;
238    return;
239  }
240
241  if (command == fpCommandDisplayHeadTime)
242    {
243      G4String display;
244      G4double screenX, screenY, screenSize, red, green, blue;
245      std::istringstream iss(newValue);
246      iss >> display >> screenX >> screenY
247          >> screenSize >> red >> green >> blue;
248      pViewer->fDisplayHeadTime = command->ConvertToBool(display);
249      pViewer->fDisplayHeadTimeX = screenX;
250      pViewer->fDisplayHeadTimeY = screenY;
251      pViewer->fDisplayHeadTimeSize = screenSize;
252      pViewer->fDisplayHeadTimeRed = red;
253      pViewer->fDisplayHeadTimeGreen = green;
254      pViewer->fDisplayHeadTimeBlue = blue;
255    }
256
257  if (command == fpCommandDisplayLightFront)
258    {
259      G4String display, originX, originY, originZ, unitS, originT, unitT;
260      G4double red, green, blue;
261      std::istringstream iss(newValue);
262      iss >> display
263          >> originX >> originY >> originZ >> unitS
264          >> originT >> unitT
265          >> red >> green >> blue;
266      pViewer->fDisplayLightFront = command->ConvertToBool(display);
267      pViewer->fDisplayLightFrontX =
268        command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
269      pViewer->fDisplayLightFrontY =
270        command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
271      pViewer->fDisplayLightFrontZ =
272        command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
273      pViewer->fDisplayLightFrontT =
274        command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
275      pViewer->fDisplayLightFrontRed = red;
276      pViewer->fDisplayLightFrontGreen = green;
277      pViewer->fDisplayLightFrontBlue = blue;
278    }
279
280  if (command == fpCommandEndTime)
281    {
282      G4String end_time_string, end_time_unit,
283        time_range_string, time_range_unit;
284      std::istringstream iss(newValue);
285      iss >> end_time_string >> end_time_unit
286          >> time_range_string >> time_range_unit;
287      pViewer->fEndTime = command->ConvertToDimensionedDouble
288        (G4String(end_time_string + ' ' + end_time_unit));
289      G4double timeRange = command->ConvertToDimensionedDouble
290        (G4String(time_range_string + ' ' + time_range_unit));
291      if (timeRange > 0.) {
292        pViewer->fStartTime = pViewer->fEndTime - timeRange;
293      }
294      if (pViewer->fVP.IsAutoRefresh())
295        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
296    }
297
298  if (command == fpCommandFade)
299    {
300      pViewer->fFadeFactor = command->ConvertToDouble(newValue);
301      if (pViewer->fVP.IsAutoRefresh())
302        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
303    }
304
305  if (command == fpCommandStartTime)
306    {
307      G4String start_time_string, start_time_unit,
308        time_range_string, time_range_unit;
309      std::istringstream iss(newValue);
310      iss >> start_time_string >> start_time_unit
311          >> time_range_string >> time_range_unit;
312      pViewer->fStartTime = command->ConvertToDimensionedDouble
313        (G4String(start_time_string + ' ' + start_time_unit));
314      G4double timeRange = command->ConvertToDimensionedDouble
315        (G4String(time_range_string + ' ' + time_range_unit));
316      if (timeRange > 0.) {
317        pViewer->fEndTime = pViewer->fStartTime + timeRange;
318      }
319      if (pViewer->fVP.IsAutoRefresh())
320        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
321    }
322
323  if (command == fpCommandTransparency)
324    {
325      pViewer->transparency_enabled = command->ConvertToBool(newValue);
326      if (pViewer->fVP.IsAutoRefresh())
327        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
328    }
329
330}
Note: See TracBrowser for help on using the repository browser.