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

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

en OGLIX ca marche...
  • 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.15 2009/03/05 16:36:13 lgarnier 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
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
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);
191  parameter->SetDefaultValue(-DBL_MAX);
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{
214  delete fpCommandPrintMode;
215  delete fpCommandTransparency;
216  delete fpCommandStartTime;
217  delete fpCommandFade;
218  delete fpCommandEndTime;
219  delete fpCommandDisplayLightFront;
220  delete fpCommandDisplayHeadTime;
221  delete fpDirectorySet;
222  delete fpCommandPrintEPS;
223  delete fpDirectory;
224
225  delete fpInstance;
226}
227
228void G4OpenGLViewerMessenger::SetNewValue
229(G4UIcommand* command, G4String newValue)
230{
231 
232  G4VisManager* pVisManager = G4VisManager::GetInstance();
233
234
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
255  if (command == fpCommandPrintEPS) 
256    {
257      // Keep copy of fPrintFilename to preserve Xm behaviour...
258      std::string tmp_string = pOGLViewer->fPrintFilename;
259
260      // Make new print string...
261      static G4int file_count = 0;
262      std::ostringstream oss;
263      oss << "G4OpenGL_" << file_count++ << ".eps";
264      pOGLViewer->fPrintFilename = std::string(oss.str().c_str());
265      // Print eps file...
266      printf("G4OpenGLViewerMessenger : Call printEPS \n");
267      pOGLViewer->printEPS();
268      // Restore fPrintFilename for Xm...
269      pOGLViewer->fPrintFilename = tmp_string;
270      return;
271    }
272
273  if (command == fpCommandPrintMode)
274    {
275      if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
276      if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
277    }
278
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}
381
382#endif
Note: See TracBrowser for help on using the repository browser.