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

Last change on this file since 600 was 599, checked in by garnier, 17 years ago

r636@mac-90108: laurentgarnier | 2007-11-12 16:46:00 +0100
modif pour qt3
  • 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.10 2007/11/10 14:51:28 allison Exp $
28// GEANT4 tag $Name:  $
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 "G4UIcmdWithoutParameter.hh"
38#include "G4UIcmdWithADouble.hh"
39#include "G4UIcmdWithABool.hh"
40#include "G4UIcmdWithAString.hh"
41#include "G4VisManager.hh"
42#include <sstream>
43
44G4OpenGLViewerMessenger*
45G4OpenGLViewerMessenger::fpInstance = 0;
46
47G4OpenGLViewerMessenger*
48G4OpenGLViewerMessenger::GetInstance()
49{
50  if (!fpInstance) fpInstance = new G4OpenGLViewerMessenger;
51  return fpInstance;
52}
53
54G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
55{
56  G4bool omitable;
57
58  fpDirectory = new G4UIdirectory("/vis/ogl/");
59  fpDirectory->SetGuidance("G4OpenGLViewer commands.");
60
61  fpCommandPrintEPS =
62    new G4UIcmdWithoutParameter("/vis/ogl/printEPS", this);
63  fpCommandPrintEPS->SetGuidance("Print Encapsulated PostScript file.");
64  fpCommandPrintEPS->SetGuidance
65    ("Generates files with names G4OpenGL_n.eps, where n is a sequence"
66     "\nnumber, starting at 0."
67     "\nCan be \"vectored\" or \"pixmap\" - see \"/vis/ogl/set/printMode\".");
68
69  fpDirectorySet = new G4UIdirectory ("/vis/ogl/set/");
70  fpDirectorySet->SetGuidance("G4OpenGLViewer set commands.");
71
72  G4UIparameter* parameter;
73
74  fpCommandDisplayHeadTime =
75    new G4UIcommand("/vis/ogl/set/displayHeadTime", this);
76  fpCommandDisplayHeadTime->SetGuidance
77    ("Display head time of range in 2D text.");
78  parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
79  parameter->SetDefaultValue(false);
80  fpCommandDisplayHeadTime->SetParameter(parameter);
81  parameter = new G4UIparameter ("screenX", 'd', omitable = true);
82  parameter->SetGuidance("-1 < screenX < 1");
83  parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
84  parameter->SetDefaultValue(-0.9);
85  fpCommandDisplayHeadTime->SetParameter(parameter);
86  parameter = new G4UIparameter ("screenY", 'd', omitable = true);
87  parameter->SetGuidance("-1 < screenY < 1");
88  parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
89  parameter->SetDefaultValue(-0.9);
90  fpCommandDisplayHeadTime->SetParameter(parameter);
91  parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
92  parameter->SetDefaultValue(24.);
93  fpCommandDisplayHeadTime->SetParameter(parameter);
94  parameter = new G4UIparameter ("red", 'd', omitable = true);
95  parameter->SetParameterRange("red >= 0. && red <= 1.");
96  parameter->SetDefaultValue(0.);
97  fpCommandDisplayHeadTime->SetParameter(parameter);
98  parameter = new G4UIparameter ("green", 'd', omitable = true);
99  parameter->SetParameterRange("green >= 0. && green <= 1.");
100  parameter->SetDefaultValue(1.);
101  fpCommandDisplayHeadTime->SetParameter(parameter);
102  parameter = new G4UIparameter ("blue", 'd', omitable = true);
103  parameter->SetParameterRange("blue >= 0. && blue <= 1.");
104  parameter->SetDefaultValue(1.);
105  fpCommandDisplayHeadTime->SetParameter(parameter);
106
107  fpCommandDisplayLightFront =
108    new G4UIcommand("/vis/ogl/set/displayLightFront", this);
109  fpCommandDisplayLightFront->SetGuidance
110    ("Display the light front at head time.");
111  fpCommandDisplayLightFront->SetGuidance
112    ("Tip: The trajectories can appear of jump ahead of the light front"
113     "\nbecause their time range overlaps the viewer's time range.  To"
114     "\naverage out this discrete time effect, advance the light front by"
115     "\nhalf the trajectories interval. E.g., if the trajectory time slice"
116     "\ninterval is 0.01 ns:"
117     "\n  /vis/ogl/set/displayLightFront true -90 0 0 mm -0.005 ns"
118     "\nTo prevent them beating the light front at all:"
119     "\n  /vis/ogl/set/displayLightFront true -90 0 0 mm -0.01 ns");
120  parameter = new G4UIparameter ("displayLightFront", 'b', omitable = false);
121  parameter->SetDefaultValue(false);
122  fpCommandDisplayLightFront->SetParameter(parameter);
123  parameter = new G4UIparameter ("originX", 'd', omitable = true);
124  parameter->SetDefaultValue(0.);
125  fpCommandDisplayLightFront->SetParameter(parameter);
126  parameter = new G4UIparameter ("originY", 'd', omitable = true);
127  parameter->SetDefaultValue(0.);
128  fpCommandDisplayLightFront->SetParameter(parameter);
129  parameter = new G4UIparameter ("originZ", 'd', omitable = true);
130  parameter->SetDefaultValue(0.);
131  fpCommandDisplayLightFront->SetParameter(parameter);
132  parameter = new G4UIparameter ("space_unit", 's', omitable = true);
133  parameter->SetDefaultValue("m");
134  fpCommandDisplayLightFront->SetParameter(parameter);
135  parameter = new G4UIparameter ("originT", 'd', omitable = true);
136  parameter->SetDefaultValue(0.);
137  fpCommandDisplayLightFront->SetParameter(parameter);
138  parameter = new G4UIparameter ("time_unit", 's', omitable = true);
139  parameter->SetDefaultValue("s");
140  fpCommandDisplayLightFront->SetParameter(parameter);
141  parameter = new G4UIparameter ("red", 'd', omitable = true);
142  parameter->SetParameterRange("red >= 0. && red <= 1.");
143  parameter->SetDefaultValue(0.);
144  fpCommandDisplayLightFront->SetParameter(parameter);
145  parameter = new G4UIparameter ("green", 'd', omitable = true);
146  parameter->SetParameterRange("green >= 0. && green <= 1.");
147  parameter->SetDefaultValue(1.);
148  fpCommandDisplayLightFront->SetParameter(parameter);
149  parameter = new G4UIparameter ("blue", 'd', omitable = true);
150  parameter->SetParameterRange("blue >= 0. && blue <= 1.");
151  parameter->SetDefaultValue(0.);
152  fpCommandDisplayLightFront->SetParameter(parameter);
153
154  fpCommandEndTime =
155    new G4UIcommand("/vis/ogl/set/endTime", this);
156  fpCommandEndTime->SetGuidance("Set end and range of track time.");
157  parameter = new G4UIparameter ("end-time", 'd', omitable = false);
158  parameter->SetDefaultValue(G4OPENGL_DBL_MAX);
159  fpCommandEndTime->SetParameter(parameter);
160  parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
161  parameter->SetDefaultValue("ns");
162  fpCommandEndTime->SetParameter(parameter);
163  parameter = new G4UIparameter ("time-range", 'd', omitable = true);
164  parameter->SetDefaultValue(-1.);
165  fpCommandEndTime->SetParameter(parameter);
166  parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
167  parameter->SetDefaultValue("ns");
168  fpCommandEndTime->SetParameter(parameter);
169
170  fpCommandFade = new G4UIcmdWithADouble("/vis/ogl/set/fade", this);
171  fpCommandFade->SetGuidance
172    ("0: no fade; 1: maximum fade with time within range.");
173  fpCommandFade->SetParameterName("fadefactor", omitable = false);
174  fpCommandFade->SetRange("fadefactor>=0.&&fadefactor<=1.");
175  fpCommandFade->SetDefaultValue(0.);
176
177  fpCommandPrintMode = new G4UIcmdWithAString
178    ("/vis/ogl/set/printMode",this);
179  fpCommandPrintMode->SetGuidance("Set print mode");
180  fpCommandPrintMode->SetParameterName("print_mode",omitable = true);
181  fpCommandPrintMode->SetCandidates("vectored pixmap");
182  fpCommandPrintMode->SetDefaultValue("vectored");
183
184  fpCommandStartTime =
185    new G4UIcommand("/vis/ogl/set/startTime", this);
186  fpCommandStartTime->SetGuidance("Set start and range of track time.");
187  parameter = new G4UIparameter ("start-time", 'd', omitable = false);
188  parameter->SetDefaultValue(-G4OPENGL_DBL_MAX);
189  fpCommandStartTime->SetParameter(parameter);
190  parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
191  parameter->SetDefaultValue("ns");
192  fpCommandStartTime->SetParameter(parameter);
193  parameter = new G4UIparameter ("time-range", 'd', omitable = true);
194  parameter->SetDefaultValue(-1.);
195  fpCommandStartTime->SetParameter(parameter);
196  parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
197  parameter->SetDefaultValue("ns");
198  fpCommandStartTime->SetParameter(parameter);
199
200  fpCommandTransparency =
201    new G4UIcmdWithABool("/vis/ogl/set/transparency", this);
202  fpCommandTransparency->SetGuidance
203    ("True/false to enable/disable rendering of transparent objects.");
204  fpCommandTransparency->SetParameterName
205    ("transparency-enabled", omitable = true);
206  fpCommandTransparency->SetDefaultValue(true);
207}
208
209G4OpenGLViewerMessenger::~G4OpenGLViewerMessenger ()
210{
211  delete fpCommandPrintMode;
212  delete fpCommandTransparency;
213  delete fpCommandStartTime;
214  delete fpCommandFade;
215  delete fpCommandEndTime;
216  delete fpCommandDisplayLightFront;
217  delete fpCommandDisplayHeadTime;
218  delete fpDirectorySet;
219  delete fpCommandPrintEPS;
220  delete fpDirectory;
221
222  delete fpInstance;
223}
224
225void G4OpenGLViewerMessenger::SetNewValue
226(G4UIcommand* command, G4String newValue)
227{
228  G4VisManager* pVisManager = G4VisManager::GetInstance();
229
230  G4VViewer* pVViewer = pVisManager->GetCurrentViewer();
231
232  if (!pVViewer) {
233    G4cout <<
234      "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
235      "\n  \"/vis/open\", or similar, to get one."
236           << G4endl;
237    return;
238  }
239
240  G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pVViewer);
241
242  if (!pOGLViewer) {
243    G4cout <<
244      "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type"
245      "\n  OGL.  Use \"/vis/viewer/select\" or \"/vis/open\"."
246           << G4endl;
247    return;
248  }
249
250  if (command == fpCommandPrintEPS)
251    {
252      // Keep copy of print_string to preserve Xm behaviour...
253      char* tmp_string = new char[50];
254      strcpy (tmp_string, pOGLViewer->print_string);
255      // Make new print string...
256      static G4int file_count = 0;
257      std::ostringstream oss;
258      oss << "G4OpenGL_" << file_count++ << ".eps";
259      strcpy (pOGLViewer->print_string, oss.str().c_str());
260      // Print eps file...
261      pOGLViewer->print();
262      // Restore print_string for Xm...
263      strcpy (pOGLViewer->print_string, tmp_string);
264      delete tmp_string;
265      return;
266    }
267
268  G4OpenGLStoredViewer* pViewer =
269    dynamic_cast<G4OpenGLStoredViewer*>(pVViewer);
270
271  if (!pViewer) {
272    G4cout <<
273  "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
274  "\n  The time slice viewing feature is only implemented for OGL Stored"
275  "\n  viewers at present.  Use \"/vis/viewer/select\" or \"/vis/open\"."
276           << G4endl;
277    return;
278  }
279
280  if (command == fpCommandDisplayHeadTime)
281    {
282      G4String display;
283      G4double screenX, screenY, screenSize, red, green, blue;
284      std::istringstream iss(newValue);
285      iss >> display >> screenX >> screenY
286          >> screenSize >> red >> green >> blue;
287      pViewer->fDisplayHeadTime = command->ConvertToBool(display);
288      pViewer->fDisplayHeadTimeX = screenX;
289      pViewer->fDisplayHeadTimeY = screenY;
290      pViewer->fDisplayHeadTimeSize = screenSize;
291      pViewer->fDisplayHeadTimeRed = red;
292      pViewer->fDisplayHeadTimeGreen = green;
293      pViewer->fDisplayHeadTimeBlue = blue;
294    }
295
296  if (command == fpCommandDisplayLightFront)
297    {
298      G4String display, originX, originY, originZ, unitS, originT, unitT;
299      G4double red, green, blue;
300      std::istringstream iss(newValue);
301      iss >> display
302          >> originX >> originY >> originZ >> unitS
303          >> originT >> unitT
304          >> red >> green >> blue;
305      pViewer->fDisplayLightFront = command->ConvertToBool(display);
306      pViewer->fDisplayLightFrontX =
307        command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
308      pViewer->fDisplayLightFrontY =
309        command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
310      pViewer->fDisplayLightFrontZ =
311        command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
312      pViewer->fDisplayLightFrontT =
313        command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
314      pViewer->fDisplayLightFrontRed = red;
315      pViewer->fDisplayLightFrontGreen = green;
316      pViewer->fDisplayLightFrontBlue = blue;
317    }
318
319  if (command == fpCommandEndTime)
320    {
321      G4String end_time_string, end_time_unit,
322        time_range_string, time_range_unit;
323      std::istringstream iss(newValue);
324      iss >> end_time_string >> end_time_unit
325          >> time_range_string >> time_range_unit;
326      pViewer->fEndTime = command->ConvertToDimensionedDouble
327        (G4String(end_time_string + ' ' + end_time_unit));
328      G4double timeRange = command->ConvertToDimensionedDouble
329        (G4String(time_range_string + ' ' + time_range_unit));
330      if (timeRange > 0.) {
331        pViewer->fStartTime = pViewer->fEndTime - timeRange;
332      }
333      if (pViewer->fVP.IsAutoRefresh())
334        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
335    }
336
337  if (command == fpCommandFade)
338    {
339      pViewer->fFadeFactor = command->ConvertToDouble(newValue);
340      if (pViewer->fVP.IsAutoRefresh())
341        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
342    }
343
344  if (command == fpCommandPrintMode)
345    {
346      if (newValue == "vectored") pViewer->vectored_ps = true;
347      if (newValue == "pixmap") {
348        pViewer->vectored_ps = false;
349        if (pVisManager->GetVerbosity() >= G4VisManager::warnings) {
350          G4cout <<
351            "WARNING: Only implemented for X Windows at present."
352                 << G4endl;
353        }
354      }
355    }
356
357  if (command == fpCommandStartTime)
358    {
359      G4String start_time_string, start_time_unit,
360        time_range_string, time_range_unit;
361      std::istringstream iss(newValue);
362      iss >> start_time_string >> start_time_unit
363          >> time_range_string >> time_range_unit;
364      pViewer->fStartTime = command->ConvertToDimensionedDouble
365        (G4String(start_time_string + ' ' + start_time_unit));
366      G4double timeRange = command->ConvertToDimensionedDouble
367        (G4String(time_range_string + ' ' + time_range_unit));
368      if (timeRange > 0.) {
369        pViewer->fEndTime = pViewer->fStartTime + timeRange;
370      }
371      if (pViewer->fVP.IsAutoRefresh())
372        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
373    }
374
375  if (command == fpCommandTransparency)
376    {
377      pViewer->transparency_enabled = command->ConvertToBool(newValue);
378      if (pViewer->fVP.IsAutoRefresh())
379        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
380    }
381
382}
Note: See TracBrowser for help on using the repository browser.