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

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

update
  • Property svn:mime-type set to text/cpp
File size: 16.6 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.18 2009/05/14 16:38:23 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  fpCommandPrintSize =
72    new G4UIcommand("/vis/ogl/set/printSize", this);
73  fpCommandPrintSize->SetGuidance ("Set print size");
74  fpCommandPrintSize->SetGuidance ("Tip : -1 will mean 'print size' = 'window size'");
75  fpCommandPrintSize->SetGuidance ("       Setting size greatter than your maximum graphic card capacity , will set the size to maximum  size.");
76  G4UIparameter* parameterPrintSize;
77  parameterPrintSize = new G4UIparameter ("width", 'd', omitable = false);
78  parameterPrintSize->SetDefaultValue(-1);
79  fpCommandPrintSize->SetParameter(parameterPrintSize);
80  parameterPrintSize = new G4UIparameter ("height", 'd', omitable = false);
81  parameterPrintSize->SetDefaultValue(-1);
82  fpCommandPrintSize->SetParameter(parameterPrintSize);
83
84  fpCommandPrintFilename =
85    new G4UIcommand("/vis/ogl/set/printFilename", this);
86  fpCommandPrintFilename->SetGuidance ("Set print filename");
87  fpCommandPrintFilename->SetGuidance ("Setting 'incremental' will increment filename by one at each new print, starting at 0");
88  G4UIparameter* parameterPrintFilename;
89  parameterPrintFilename = new G4UIparameter ("name", 's', omitable = true);
90  parameterPrintFilename->SetDefaultValue("G4OpenGL");
91  fpCommandPrintFilename->SetParameter(parameterPrintFilename);
92  parameterPrintFilename = new G4UIparameter ("incremental", 'b', omitable = true);
93  parameterPrintFilename->SetDefaultValue(1);
94  fpCommandPrintFilename->SetParameter(parameterPrintFilename);
95
96  fpDirectorySet = new G4UIdirectory ("/vis/ogl/set/");
97  fpDirectorySet->SetGuidance("G4OpenGLViewer set commands.");
98
99  G4UIparameter* parameter;
100
101  fpCommandDisplayHeadTime =
102    new G4UIcommand("/vis/ogl/set/displayHeadTime", this);
103  fpCommandDisplayHeadTime->SetGuidance
104    ("Display head time of range in 2D text.");
105  parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
106  parameter->SetDefaultValue(false);
107  fpCommandDisplayHeadTime->SetParameter(parameter);
108  parameter = new G4UIparameter ("screenX", 'd', omitable = true);
109  parameter->SetGuidance("-1 < screenX < 1");
110  parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
111  parameter->SetDefaultValue(-0.9);
112  fpCommandDisplayHeadTime->SetParameter(parameter);
113  parameter = new G4UIparameter ("screenY", 'd', omitable = true);
114  parameter->SetGuidance("-1 < screenY < 1");
115  parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
116  parameter->SetDefaultValue(-0.9);
117  fpCommandDisplayHeadTime->SetParameter(parameter);
118  parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
119  parameter->SetDefaultValue(24.);
120  fpCommandDisplayHeadTime->SetParameter(parameter);
121  parameter = new G4UIparameter ("red", 'd', omitable = true);
122  parameter->SetParameterRange("red >= 0. && red <= 1.");
123  parameter->SetDefaultValue(0.);
124  fpCommandDisplayHeadTime->SetParameter(parameter);
125  parameter = new G4UIparameter ("green", 'd', omitable = true);
126  parameter->SetParameterRange("green >= 0. && green <= 1.");
127  parameter->SetDefaultValue(1.);
128  fpCommandDisplayHeadTime->SetParameter(parameter);
129  parameter = new G4UIparameter ("blue", 'd', omitable = true);
130  parameter->SetParameterRange("blue >= 0. && blue <= 1.");
131  parameter->SetDefaultValue(1.);
132  fpCommandDisplayHeadTime->SetParameter(parameter);
133
134  fpCommandDisplayLightFront =
135    new G4UIcommand("/vis/ogl/set/displayLightFront", this);
136  fpCommandDisplayLightFront->SetGuidance
137    ("Display the light front at head time.");
138  fpCommandDisplayLightFront->SetGuidance
139    ("Tip: The trajectories can appear of jump ahead of the light front"
140     "\nbecause their time range overlaps the viewer's time range.  To"
141     "\naverage out this discrete time effect, advance the light front by"
142     "\nhalf the trajectories interval. E.g., if the trajectory time slice"
143     "\ninterval is 0.01 ns:"
144     "\n  /vis/ogl/set/displayLightFront true -90 0 0 mm -0.005 ns"
145     "\nTo prevent them beating the light front at all:"
146     "\n  /vis/ogl/set/displayLightFront true -90 0 0 mm -0.01 ns");
147  parameter = new G4UIparameter ("displayLightFront", 'b', omitable = false);
148  parameter->SetDefaultValue(false);
149  fpCommandDisplayLightFront->SetParameter(parameter);
150  parameter = new G4UIparameter ("originX", 'd', omitable = true);
151  parameter->SetDefaultValue(0.);
152  fpCommandDisplayLightFront->SetParameter(parameter);
153  parameter = new G4UIparameter ("originY", 'd', omitable = true);
154  parameter->SetDefaultValue(0.);
155  fpCommandDisplayLightFront->SetParameter(parameter);
156  parameter = new G4UIparameter ("originZ", 'd', omitable = true);
157  parameter->SetDefaultValue(0.);
158  fpCommandDisplayLightFront->SetParameter(parameter);
159  parameter = new G4UIparameter ("space_unit", 's', omitable = true);
160  parameter->SetDefaultValue("m");
161  fpCommandDisplayLightFront->SetParameter(parameter);
162  parameter = new G4UIparameter ("originT", 'd', omitable = true);
163  parameter->SetDefaultValue(0.);
164  fpCommandDisplayLightFront->SetParameter(parameter);
165  parameter = new G4UIparameter ("time_unit", 's', omitable = true);
166  parameter->SetDefaultValue("s");
167  fpCommandDisplayLightFront->SetParameter(parameter);
168  parameter = new G4UIparameter ("red", 'd', omitable = true);
169  parameter->SetParameterRange("red >= 0. && red <= 1.");
170  parameter->SetDefaultValue(0.);
171  fpCommandDisplayLightFront->SetParameter(parameter);
172  parameter = new G4UIparameter ("green", 'd', omitable = true);
173  parameter->SetParameterRange("green >= 0. && green <= 1.");
174  parameter->SetDefaultValue(1.);
175  fpCommandDisplayLightFront->SetParameter(parameter);
176  parameter = new G4UIparameter ("blue", 'd', omitable = true);
177  parameter->SetParameterRange("blue >= 0. && blue <= 1.");
178  parameter->SetDefaultValue(0.);
179  fpCommandDisplayLightFront->SetParameter(parameter);
180
181  fpCommandEndTime =
182    new G4UIcommand("/vis/ogl/set/endTime", this);
183  fpCommandEndTime->SetGuidance("Set end and range of track time.");
184  parameter = new G4UIparameter ("end-time", 'd', omitable = false);
185  parameter->SetDefaultValue(DBL_MAX);
186  fpCommandEndTime->SetParameter(parameter);
187  parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
188  parameter->SetDefaultValue("ns");
189  fpCommandEndTime->SetParameter(parameter);
190  parameter = new G4UIparameter ("time-range", 'd', omitable = true);
191  parameter->SetDefaultValue(-1.);
192  fpCommandEndTime->SetParameter(parameter);
193  parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
194  parameter->SetDefaultValue("ns");
195  fpCommandEndTime->SetParameter(parameter);
196
197  fpCommandFade = new G4UIcmdWithADouble("/vis/ogl/set/fade", this);
198  fpCommandFade->SetGuidance
199    ("0: no fade; 1: maximum fade with time within range.");
200  fpCommandFade->SetParameterName("fadefactor", omitable = false);
201  fpCommandFade->SetRange("fadefactor>=0.&&fadefactor<=1.");
202  fpCommandFade->SetDefaultValue(0.);
203
204  fpCommandPrintMode = new G4UIcmdWithAString
205    ("/vis/ogl/set/printMode",this);
206  fpCommandPrintMode->SetGuidance("Set print mode");
207  fpCommandPrintMode->SetParameterName("print_mode",omitable = true);
208  fpCommandPrintMode->SetCandidates("vectored pixmap");
209  fpCommandPrintMode->SetDefaultValue("vectored");
210
211  fpCommandStartTime =
212    new G4UIcommand("/vis/ogl/set/startTime", this);
213  fpCommandStartTime->SetGuidance("Set start and range of track time.");
214  parameter = new G4UIparameter ("start-time", 'd', omitable = false);
215  parameter->SetDefaultValue(-DBL_MAX);
216  fpCommandStartTime->SetParameter(parameter);
217  parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
218  parameter->SetDefaultValue("ns");
219  fpCommandStartTime->SetParameter(parameter);
220  parameter = new G4UIparameter ("time-range", 'd', omitable = true);
221  parameter->SetDefaultValue(-1.);
222  fpCommandStartTime->SetParameter(parameter);
223  parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
224  parameter->SetDefaultValue("ns");
225  fpCommandStartTime->SetParameter(parameter);
226
227  fpCommandTransparency =
228    new G4UIcmdWithABool("/vis/ogl/set/transparency", this);
229  fpCommandTransparency->SetGuidance
230    ("True/false to enable/disable rendering of transparent objects.");
231  fpCommandTransparency->SetParameterName
232    ("transparency-enabled", omitable = true);
233  fpCommandTransparency->SetDefaultValue(true);
234}
235
236G4OpenGLViewerMessenger::~G4OpenGLViewerMessenger ()
237{
238  delete fpCommandPrintMode;
239  delete fpCommandTransparency;
240  delete fpCommandStartTime;
241  delete fpCommandFade;
242  delete fpCommandEndTime;
243  delete fpCommandDisplayLightFront;
244  delete fpCommandDisplayHeadTime;
245  delete fpDirectorySet;
246  delete fpCommandPrintEPS;
247  delete fpDirectory;
248
249  delete fpInstance;
250}
251
252void G4OpenGLViewerMessenger::SetNewValue
253(G4UIcommand* command, G4String newValue)
254{
255  G4VisManager* pVisManager = G4VisManager::GetInstance();
256
257  G4VViewer* pViewer = pVisManager->GetCurrentViewer();
258
259  if (!pViewer) {
260    G4cout <<
261      "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
262      "\n  \"/vis/open\", or similar, to get one."
263           << G4endl;
264    return;
265  }
266
267  G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pViewer);
268
269  if (!pOGLViewer) {
270    G4cout <<
271      "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type"
272      "\n  OGL.  Use \"/vis/viewer/select\" or \"/vis/open\"."
273           << G4endl;
274    return;
275  }
276
277  if (command == fpCommandPrintEPS)
278    {
279      pOGLViewer->printEPS();
280      return;
281    }
282
283  if (command == fpCommandPrintSize)
284    {
285      G4int width,height;
286      std::istringstream iss(newValue);
287      iss >> width
288          >> height;
289      pOGLViewer->setPrintSize(width,height);
290    }
291
292  if (command == fpCommandPrintFilename)
293    {
294      G4String name;
295      G4bool inc;
296      std::istringstream iss(newValue);
297      iss >> name
298          >> inc;
299      pOGLViewer->setPrintFilename(name,inc);
300    }
301
302  if (command == fpCommandPrintMode)
303    {
304      if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
305      if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
306      return;
307    }
308
309  if (command == fpCommandTransparency)
310    {
311      pOGLViewer->transparency_enabled = command->ConvertToBool(newValue);
312      if (pOGLViewer->fVP.IsAutoRefresh())
313        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
314      return;
315    }
316
317  G4OpenGLStoredViewer* pOGLSViewer =
318    dynamic_cast<G4OpenGLStoredViewer*>(pViewer);
319
320  if (!pOGLSViewer)
321    {
322      G4cout <<
323  "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
324  "\n  The time slice viewing feature is only implemented for OGL Stored"
325  "\n  viewers at present.  Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
326             << G4endl;
327      return;
328    }
329
330  if (command == fpCommandDisplayHeadTime)
331    {
332      G4String display;
333      G4double screenX, screenY, screenSize, red, green, blue;
334      std::istringstream iss(newValue);
335      iss >> display >> screenX >> screenY
336          >> screenSize >> red >> green >> blue;
337      pOGLSViewer->fDisplayHeadTime = command->ConvertToBool(display);
338      pOGLSViewer->fDisplayHeadTimeX = screenX;
339      pOGLSViewer->fDisplayHeadTimeY = screenY;
340      pOGLSViewer->fDisplayHeadTimeSize = screenSize;
341      pOGLSViewer->fDisplayHeadTimeRed = red;
342      pOGLSViewer->fDisplayHeadTimeGreen = green;
343      pOGLSViewer->fDisplayHeadTimeBlue = blue;
344      return;
345    }
346
347  if (command == fpCommandDisplayLightFront)
348    {
349      G4String display, originX, originY, originZ, unitS, originT, unitT;
350      G4double red, green, blue;
351      std::istringstream iss(newValue);
352      iss >> display
353          >> originX >> originY >> originZ >> unitS
354          >> originT >> unitT
355          >> red >> green >> blue;
356      pOGLSViewer->fDisplayLightFront = command->ConvertToBool(display);
357      pOGLSViewer->fDisplayLightFrontX =
358        command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
359      pOGLSViewer->fDisplayLightFrontY =
360        command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
361      pOGLSViewer->fDisplayLightFrontZ =
362        command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
363      pOGLSViewer->fDisplayLightFrontT =
364        command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
365      pOGLSViewer->fDisplayLightFrontRed = red;
366      pOGLSViewer->fDisplayLightFrontGreen = green;
367      pOGLSViewer->fDisplayLightFrontBlue = blue;
368      return;
369    }
370
371  if (command == fpCommandEndTime)
372    {
373      G4String end_time_string, end_time_unit,
374        time_range_string, time_range_unit;
375      std::istringstream iss(newValue);
376      iss >> end_time_string >> end_time_unit
377          >> time_range_string >> time_range_unit;
378      pOGLSViewer->fEndTime = command->ConvertToDimensionedDouble
379        (G4String(end_time_string + ' ' + end_time_unit));
380      G4double timeRange = command->ConvertToDimensionedDouble
381        (G4String(time_range_string + ' ' + time_range_unit));
382      if (timeRange > 0.) {
383        pOGLSViewer->fStartTime = pOGLSViewer->fEndTime - timeRange;
384      }
385      if (pOGLSViewer->fVP.IsAutoRefresh())
386        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
387      return;
388    }
389
390  if (command == fpCommandFade)
391    {
392      pOGLSViewer->fFadeFactor = command->ConvertToDouble(newValue);
393      if (pOGLSViewer->fVP.IsAutoRefresh())
394        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
395    }
396
397  if (command == fpCommandStartTime)
398    {
399      G4String start_time_string, start_time_unit,
400        time_range_string, time_range_unit;
401      std::istringstream iss(newValue);
402      iss >> start_time_string >> start_time_unit
403          >> time_range_string >> time_range_unit;
404      pOGLSViewer->fStartTime = command->ConvertToDimensionedDouble
405        (G4String(start_time_string + ' ' + start_time_unit));
406      G4double timeRange = command->ConvertToDimensionedDouble
407        (G4String(time_range_string + ' ' + time_range_unit));
408      if (timeRange > 0.) {
409        pOGLSViewer->fEndTime = pOGLSViewer->fStartTime + timeRange;
410      }
411      if (pOGLSViewer->fVP.IsAutoRefresh())
412        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
413      return;
414    }
415
416}
417
418#endif
Note: See TracBrowser for help on using the repository browser.