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

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

resize en cours de factorisation
  • Property svn:mime-type set to text/cpp
File size: 15.3 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.17 2009/04/28 15:05:22 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#ifdef G4DEBUG_VIS_OGL
264      printf("G4OpenGLViewerMessenger::SetNewValue Call printEPS %s\n",std::string(oss.str().c_str()).c_str());
265#endif
266      pOGLViewer->printEPS();
267      // Restore fPrintFilename for Xm...
268      pOGLViewer->fPrintFilename = tmp_string;
269      return;
270    }
271
272  if (command == fpCommandPrintMode)
273    {
274      if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
275      if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
276      return;
277    }
278
279  if (command == fpCommandTransparency)
280    {
281      pOGLViewer->transparency_enabled = command->ConvertToBool(newValue);
282      if (pOGLViewer->fVP.IsAutoRefresh())
283        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
284      return;
285    }
286
287  G4OpenGLStoredViewer* pOGLSViewer =
288    dynamic_cast<G4OpenGLStoredViewer*>(pViewer);
289
290  if (!pOGLSViewer)
291    {
292      G4cout <<
293  "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
294  "\n  The time slice viewing feature is only implemented for OGL Stored"
295  "\n  viewers at present.  Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
296             << G4endl;
297      return;
298    }
299
300  if (command == fpCommandDisplayHeadTime)
301    {
302      G4String display;
303      G4double screenX, screenY, screenSize, red, green, blue;
304      std::istringstream iss(newValue);
305      iss >> display >> screenX >> screenY
306          >> screenSize >> red >> green >> blue;
307      pOGLSViewer->fDisplayHeadTime = command->ConvertToBool(display);
308      pOGLSViewer->fDisplayHeadTimeX = screenX;
309      pOGLSViewer->fDisplayHeadTimeY = screenY;
310      pOGLSViewer->fDisplayHeadTimeSize = screenSize;
311      pOGLSViewer->fDisplayHeadTimeRed = red;
312      pOGLSViewer->fDisplayHeadTimeGreen = green;
313      pOGLSViewer->fDisplayHeadTimeBlue = blue;
314      return;
315    }
316
317  if (command == fpCommandDisplayLightFront)
318    {
319      G4String display, originX, originY, originZ, unitS, originT, unitT;
320      G4double red, green, blue;
321      std::istringstream iss(newValue);
322      iss >> display
323          >> originX >> originY >> originZ >> unitS
324          >> originT >> unitT
325          >> red >> green >> blue;
326      pOGLSViewer->fDisplayLightFront = command->ConvertToBool(display);
327      pOGLSViewer->fDisplayLightFrontX =
328        command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
329      pOGLSViewer->fDisplayLightFrontY =
330        command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
331      pOGLSViewer->fDisplayLightFrontZ =
332        command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
333      pOGLSViewer->fDisplayLightFrontT =
334        command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
335      pOGLSViewer->fDisplayLightFrontRed = red;
336      pOGLSViewer->fDisplayLightFrontGreen = green;
337      pOGLSViewer->fDisplayLightFrontBlue = blue;
338      return;
339    }
340
341  if (command == fpCommandEndTime)
342    {
343      G4String end_time_string, end_time_unit,
344        time_range_string, time_range_unit;
345      std::istringstream iss(newValue);
346      iss >> end_time_string >> end_time_unit
347          >> time_range_string >> time_range_unit;
348      pOGLSViewer->fEndTime = command->ConvertToDimensionedDouble
349        (G4String(end_time_string + ' ' + end_time_unit));
350      G4double timeRange = command->ConvertToDimensionedDouble
351        (G4String(time_range_string + ' ' + time_range_unit));
352      if (timeRange > 0.) {
353        pOGLSViewer->fStartTime = pOGLSViewer->fEndTime - timeRange;
354      }
355      if (pOGLSViewer->fVP.IsAutoRefresh())
356        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
357      return;
358    }
359
360  if (command == fpCommandFade)
361    {
362      pOGLSViewer->fFadeFactor = command->ConvertToDouble(newValue);
363      if (pOGLSViewer->fVP.IsAutoRefresh())
364        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
365    }
366
367  if (command == fpCommandStartTime)
368    {
369      G4String start_time_string, start_time_unit,
370        time_range_string, time_range_unit;
371      std::istringstream iss(newValue);
372      iss >> start_time_string >> start_time_unit
373          >> time_range_string >> time_range_unit;
374      pOGLSViewer->fStartTime = command->ConvertToDimensionedDouble
375        (G4String(start_time_string + ' ' + start_time_unit));
376      G4double timeRange = command->ConvertToDimensionedDouble
377        (G4String(time_range_string + ' ' + time_range_unit));
378      if (timeRange > 0.) {
379        pOGLSViewer->fEndTime = pOGLSViewer->fStartTime + timeRange;
380      }
381      if (pOGLSViewer->fVP.IsAutoRefresh())
382        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
383      return;
384    }
385
386}
387
388#endif
Note: See TracBrowser for help on using the repository browser.