Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/src/G4VisCommandsCompound.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

  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 
 28 // Compound /vis/ commands - John Allison  15th May 2000
 29 
 30 #include "G4VisCommandsCompound.hh"
 31 
 32 #include "G4VisManager.hh"
 33 #include "G4UImanager.hh"
 34 #include "G4UIcommandTree.hh"
 35 #include "G4UIcmdWithAString.hh"
 36 
 37 #include <sstream>
 38 #include <set>
 39 
 40 #define G4warn G4cout
 41 
 42 ////////////// /vis/drawTree ///////////////////////////////////////
 43 
 44 G4VisCommandDrawTree::G4VisCommandDrawTree() {
 45   G4bool omitable;
 46   fpCommand = new G4UIcommand("/vis/drawTree", this);
 47   fpCommand->SetGuidance
 48     ("Produces a representation of the geometry hierarchy. Further"
 49      "\nguidance is given on running the command. Or look at the guidance"
 50      "\nfor \"/vis/ASCIITree/verbose\".");
 51   fpCommand->SetGuidance("The pre-existing scene and view are preserved.");
 52   G4UIparameter* parameter;
 53   parameter = new G4UIparameter("physical-volume-name", 's', omitable = true);
 54   parameter -> SetDefaultValue("world");
 55   fpCommand -> SetParameter (parameter);
 56   parameter = new G4UIparameter("system", 's', omitable = true);
 57   parameter -> SetDefaultValue("ATree");
 58   fpCommand -> SetParameter (parameter);
 59 }
 60 
 61 G4VisCommandDrawTree::~G4VisCommandDrawTree() {
 62   delete fpCommand;
 63 }
 64 
 65 void G4VisCommandDrawTree::SetNewValue(G4UIcommand*, G4String newValue) {
 66 
 67   G4String pvname, system;
 68   std::istringstream is(newValue);
 69   is >> pvname >> system;
 70 
 71   // Note: The second parameter, "system", is intended to allow the user
 72   // a choice of dedicated tree printing/displaying systems but at present
 73   // the only such dedicated system is ASCIITree.  It doesn't make sense to
 74   // specify OGLSX, for example.  So to avoid confusion we restrict this
 75   // feature to systems that have "Tree" in the name or nickname.
 76 
 77   // Of course, some other systems, such as OGLSQt, have a tree browser
 78   // built-in.  The HepRApp offline browser also has a tree browser
 79   // built in.
 80 
 81   if (!G4StrUtil::contains(system, "Tree")) {
 82     system = "ATree";
 83   }
 84 
 85   G4VGraphicsSystem* keepSystem = fpVisManager->GetCurrentGraphicsSystem();
 86   G4Scene* keepScene = fpVisManager->GetCurrentScene();
 87   G4VSceneHandler* keepSceneHandler = fpVisManager->GetCurrentSceneHandler();
 88   G4VViewer* keepViewer = fpVisManager->GetCurrentViewer();
 89   G4VisManager::Verbosity keepVisVerbosity = fpVisManager->GetVerbosity();
 90   G4bool keepAbleness = fpVisManager->GetConcreteInstance()? true: false;
 91 
 92   G4UImanager* UImanager = G4UImanager::GetUIpointer();
 93   G4int keepUIVerbose = UImanager->GetVerboseLevel();
 94   G4int newVerbose(0);
 95   if (keepUIVerbose >= 2 ||
 96       fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
 97     newVerbose = 2;
 98   UImanager->SetVerboseLevel(newVerbose);
 99 
100   auto errorCode = UImanager->ApplyCommand(G4String("/vis/open " + system));
101   if (errorCode == 0) {
102     if (!keepAbleness) {  // Enable temporarily
103       fpVisManager->SetVerboseLevel("Quiet");
104       UImanager->ApplyCommand("/vis/enable");
105       fpVisManager->SetVerboseLevel(keepVisVerbosity);
106     }
107     UImanager->ApplyCommand("/vis/viewer/reset");
108     UImanager->ApplyCommand(G4String("/vis/drawVolume " + pvname));
109     UImanager->ApplyCommand("/vis/viewer/flush");
110     if (!keepAbleness) {  // Disable again
111       fpVisManager->SetVerboseLevel("Quiet");
112       UImanager->ApplyCommand("/vis/disable");
113       fpVisManager->SetVerboseLevel(keepVisVerbosity);
114     }
115     if (keepViewer) {
116       if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
117         G4warn << "Reverting to " << keepViewer->GetName() << G4endl;
118       }
119       fpVisManager->SetCurrentGraphicsSystem(keepSystem);
120       fpVisManager->SetCurrentScene(keepScene);
121       fpVisManager->SetCurrentSceneHandler(keepSceneHandler);
122       fpVisManager->SetCurrentViewer(keepViewer);
123     }
124   }
125   UImanager->SetVerboseLevel(keepUIVerbose);
126 }
127 
128 ////////////// /vis/drawView ///////////////////////////////////////
129 
130 G4VisCommandDrawView::G4VisCommandDrawView() {
131   G4bool omitable;
132   fpCommand = new G4UIcommand("/vis/drawView", this);
133   fpCommand->SetGuidance
134     ("Draw view from this angle, etc.");
135   G4UIparameter* parameter;
136   parameter = new G4UIparameter("theta-degrees", 'd', omitable = true);
137   parameter -> SetDefaultValue(0.);
138   fpCommand -> SetParameter (parameter);
139   parameter = new G4UIparameter("phi-degrees", 'd', omitable = true);
140   parameter -> SetDefaultValue(0.);
141   fpCommand -> SetParameter (parameter);
142   parameter = new G4UIparameter("pan-right", 'd', omitable = true);
143   parameter -> SetDefaultValue(0.);
144   fpCommand -> SetParameter (parameter);
145   parameter = new G4UIparameter("pan-up", 'd', omitable = true);
146   parameter -> SetDefaultValue(0.);
147   fpCommand -> SetParameter (parameter);
148   parameter = new G4UIparameter("pan-unit", 's', omitable = true);
149   parameter -> SetDefaultValue("cm");
150   fpCommand -> SetParameter (parameter);
151   parameter = new G4UIparameter("zoom-factor", 'd', omitable = true);
152   parameter -> SetDefaultValue(1.);
153   fpCommand -> SetParameter (parameter);
154   parameter = new G4UIparameter("dolly", 'd', omitable = true);
155   parameter -> SetDefaultValue(0.);
156   fpCommand -> SetParameter (parameter);
157   parameter = new G4UIparameter("dolly-unit", 's', omitable = true);
158   parameter -> SetDefaultValue("cm");
159   fpCommand -> SetParameter (parameter);
160 }
161 
162 G4VisCommandDrawView::~G4VisCommandDrawView() {
163   delete fpCommand;
164 }
165 
166 void G4VisCommandDrawView::SetNewValue(G4UIcommand*, G4String newValue) {
167 
168   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
169 
170   G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
171   if (!currentViewer) {
172     if (verbosity >= G4VisManager::warnings) {
173       G4warn <<
174   "WARNING: G4VisCommandsDrawView::SetNewValue: no current viewer."
175        << G4endl;
176     }
177     return;
178   }
179 
180   G4String thetaDeg;
181   G4String phiDeg;
182   G4String panRight;
183   G4String panUp;
184   G4String panUnit;
185   G4String zoomFactor;
186   G4String dolly;
187   G4String dollyUnit;
188   std::istringstream is(newValue);
189   is >> thetaDeg >> phiDeg >> panRight >> panUp >> panUnit
190      >> zoomFactor >> dolly >> dollyUnit;
191   
192   G4UImanager* UImanager = G4UImanager::GetUIpointer();
193   G4ViewParameters vp = currentViewer->GetViewParameters();
194   G4bool keepAutoRefresh = vp.IsAutoRefresh();
195   vp.SetAutoRefresh(false);
196   currentViewer->SetViewParameters(vp);
197   UImanager->ApplyCommand(
198     G4String("/vis/viewer/set/viewpointThetaPhi " + thetaDeg + " " + phiDeg + " deg"));
199   UImanager->ApplyCommand(
200     G4String("/vis/viewer/panTo " + panRight + " " + panUp + " " + panUnit));
201   UImanager->ApplyCommand(
202     G4String("/vis/viewer/zoomTo " + zoomFactor));
203   vp = currentViewer->GetViewParameters();
204   vp.SetAutoRefresh(keepAutoRefresh);
205   currentViewer->SetViewParameters(vp);
206   UImanager->ApplyCommand(
207     G4String("/vis/viewer/dollyTo " + dolly + " " + dollyUnit));
208 }
209 
210 ////////////// /vis/drawLogicalVolume ///////////////////////////////////////
211 
212 G4VisCommandDrawLogicalVolume::G4VisCommandDrawLogicalVolume() {
213   fpCommand = new G4UIcommand("/vis/drawLogicalVolume", this);
214   fpCommand->SetGuidance
215   ("Draws logical volume with additional components.");
216   fpCommand->SetGuidance
217   ("Synonymous with \"/vis/specify\".");
218   fpCommand->SetGuidance
219   ("Creates a scene consisting of this logical volume and asks the"
220    "\n  current viewer to draw it. The scene becomes current.");
221   const G4UIcommandTree* tree = G4UImanager::GetUIpointer()->GetTree();
222   const G4UIcommand* addLogVolCmd = tree->FindPath("/vis/scene/add/logicalVolume");
223   // Pick up guidance from /vis/scene/add/logicalVolume
224   CopyGuidanceFrom(addLogVolCmd,fpCommand);
225   // Pick up parameters from /vis/scene/add/logicalVolume
226   CopyParametersFrom(addLogVolCmd,fpCommand);
227 }
228 
229 G4VisCommandDrawLogicalVolume::~G4VisCommandDrawLogicalVolume() {
230   delete fpCommand;
231 }
232 
233 void G4VisCommandDrawLogicalVolume::SetNewValue(G4UIcommand*, G4String newValue) {
234   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
235   G4UImanager* UImanager = G4UImanager::GetUIpointer();
236   G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
237   const G4ViewParameters& currentViewParams = currentViewer->GetViewParameters();
238   G4bool keepAutoRefresh = currentViewParams.IsAutoRefresh();
239   if (keepAutoRefresh) UImanager->ApplyCommand("/vis/viewer/set/autoRefresh false");
240   UImanager->ApplyCommand("/vis/scene/create");
241   UImanager->ApplyCommand(G4String("/vis/scene/add/logicalVolume " + newValue));
242   UImanager->ApplyCommand("/vis/sceneHandler/attach");
243   G4ViewParameters::DrawingStyle keepDrawingStyle = currentViewParams.GetDrawingStyle();
244   if(keepDrawingStyle != G4ViewParameters::wireframe)
245     UImanager->ApplyCommand("/vis/viewer/set/style wireframe");
246   G4bool keepMarkerNotHidden = currentViewParams.IsMarkerNotHidden();
247   if (!keepMarkerNotHidden) UImanager->ApplyCommand("/vis/viewer/set/hiddenMarker false");
248   if (keepAutoRefresh) UImanager->ApplyCommand("/vis/viewer/set/autoRefresh true");
249   if (verbosity >= G4VisManager::warnings) {
250     if (keepDrawingStyle != currentViewParams.GetDrawingStyle()) {
251       G4warn
252       << "Drawing style changed to wireframe. To restore previous style:";
253       G4String style, edge;
254       switch (keepDrawingStyle) {
255         case G4ViewParameters::wireframe:
256           style = "wireframe"; edge = "false"; break;
257         case G4ViewParameters::hlr:
258           style = "wireframe"; edge = "true"; break;
259         case G4ViewParameters::hsr:
260           style = "surface"; edge = "false"; break;
261         case G4ViewParameters::hlhsr:
262           style = "surface"; edge = "true"; break;
263         case G4ViewParameters::cloud:
264           style = "cloud"; edge = ""; break;
265       }
266       G4warn << "\n  /vis/viewer/set/style " + style;
267       if (!edge.empty()) G4warn << "\n  /vis/viewer/set/hiddenEdge " + edge;
268       G4warn << G4endl;
269     }
270     if (keepMarkerNotHidden != currentViewParams.IsMarkerNotHidden()) {
271       G4warn
272       << "Markers changed to \"not hidden\". To restore previous condition:"
273       << "\n  /vis/viewer/set/hiddenmarker true"
274       << G4endl;
275     }
276   }
277   static G4bool warned = false;
278   if (verbosity >= G4VisManager::confirmations && !warned) {
279     G4cout <<
280     "NOTE: For systems which are not \"auto-refresh\" you will need to"
281     "\n  issue \"/vis/viewer/refresh\" or \"/vis/viewer/flush\"."
282     << G4endl;
283     warned = true;
284   }
285 }
286 
287 ////////////// /vis/drawVolume ///////////////////////////////////////
288 
289 G4VisCommandDrawVolume::G4VisCommandDrawVolume() {
290   fpCommand = new G4UIcommand("/vis/drawVolume", this);
291   fpCommand->SetGuidance
292   ("Creates a scene containing this physical volume and asks the"
293    "\ncurrent viewer to draw it.  The scene becomes current.");
294   const G4UIcommandTree* tree = G4UImanager::GetUIpointer()->GetTree();
295   const G4UIcommand* addVolCmd = tree->FindPath("/vis/scene/add/volume");
296   // Pick up guidance from /vis/scene/add/volume
297   CopyGuidanceFrom(addVolCmd,fpCommand);
298   // Pick up parameters from /vis/scene/add/volume
299   CopyParametersFrom(addVolCmd,fpCommand);
300 }
301 
302 G4VisCommandDrawVolume::~G4VisCommandDrawVolume() {
303   delete fpCommand;
304 }
305 
306 void G4VisCommandDrawVolume::SetNewValue(G4UIcommand*, G4String newValue) {
307   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
308   G4UImanager* UImanager = G4UImanager::GetUIpointer();
309   UImanager->ApplyCommand("/vis/scene/create");
310   UImanager->ApplyCommand(G4String("/vis/scene/add/volume " + newValue));
311   UImanager->ApplyCommand("/vis/sceneHandler/attach");
312   static G4bool warned = false;
313   if (verbosity >= G4VisManager::confirmations && !warned) {
314     G4cout <<
315       "NOTE: For systems which are not \"auto-refresh\" you will need to"
316       "\n  issue \"/vis/viewer/refresh\" or \"/vis/viewer/flush\"."
317      << G4endl;
318     warned = true;
319   }
320 }
321 
322 ////////////// /vis/open ///////////////////////////////////////
323 
324 G4VisCommandOpen::G4VisCommandOpen() {
325   G4bool omitable;
326   fpCommand = new G4UIcommand("/vis/open", this);
327   fpCommand->SetGuidance
328     ("Creates a scene handler and viewer ready for drawing.");
329   fpCommand->SetGuidance
330     ("The scene handler and viewer names are auto-generated.");
331   // Pick up guidance from /vis/viewer/create
332   const G4UIcommandTree* tree = G4UImanager::GetUIpointer()->GetTree();
333   const G4UIcommand* viewerCreateCmd = tree->FindPath("/vis/viewer/create");
334   CopyGuidanceFrom(viewerCreateCmd,fpCommand,2);
335   G4UIparameter* parameter;
336   parameter = new G4UIparameter("graphics-system-name", 's', omitable = true);
337   parameter->SetCurrentAsDefault(true);
338   fpCommand->SetParameter(parameter);
339   parameter = new G4UIparameter("window-size-hint", 's', omitable = true);
340   parameter->SetGuidance
341     ("integer (pixels) for square window placed by window manager or"
342      " X-Windows-type geometry string, e.g. 600x600-100+100");
343   parameter->SetCurrentAsDefault(true);
344   fpCommand->SetParameter(parameter);
345 }
346 
347 G4VisCommandOpen::~G4VisCommandOpen() {
348   delete fpCommand;
349 }
350 
351 G4String G4VisCommandOpen::GetCurrentValue(G4UIcommand*)
352 {
353   G4String graphicsSystemName, windowSizeHint;
354   auto graphicsSystem = fpVisManager->GetCurrentGraphicsSystem();
355   if (graphicsSystem) {
356     // Take name and hint from latest graphics system and viewer
357     graphicsSystemName = graphicsSystem->GetName();
358     auto viewer = fpVisManager->GetCurrentViewer();
359     if (viewer) {
360       windowSizeHint = viewer->GetViewParameters().GetXGeometryString();
361     }
362     else {  // Viewer not yet created?
363       windowSizeHint = fpVisManager->GetDefaultXGeometryString();
364     }
365   }
366   else {  // No graphics system yet - must be first time
367     graphicsSystemName = fpVisManager->GetDefaultGraphicsSystemName();
368     windowSizeHint = fpVisManager->GetDefaultXGeometryString();
369   }
370   return graphicsSystemName + ' ' + windowSizeHint;
371 }
372 
373 void G4VisCommandOpen::SetNewValue (G4UIcommand* command, G4String newValue)
374 {
375   G4String systemName, windowSizeHint;
376   std::istringstream is(newValue);
377   is >> systemName >> windowSizeHint;
378   G4UImanager* UImanager = G4UImanager::GetUIpointer();
379 
380   auto errorCode = UImanager->ApplyCommand(G4String("/vis/sceneHandler/create " + systemName));
381   if (errorCode) {
382     G4warn << "sub-command \"/vis/sceneHandler/create\" failed." << G4endl;
383     goto finish;
384   }
385 
386   errorCode = UImanager->ApplyCommand(G4String("/vis/viewer/create ! ! " + windowSizeHint));
387   if (errorCode) {
388     G4warn << "sub-command \"/vis/viewer/create\" failed." << G4endl;
389     goto finish;
390   }
391 
392 finish:
393   if (errorCode) {
394     fpVisManager->PrintAvailableGraphicsSystems(G4VisManager::warnings,G4warn);
395     if (errorCode != JustWarning) {
396       G4ExceptionDescription ed;
397       ed << "Invoked command has failed - see above.";
398       command->CommandFailed(errorCode,ed);
399     }
400   }
401 }
402 
403 ////////////// /vis/plot ///////////////////////////////////////
404 
405 G4VisCommandPlot::G4VisCommandPlot ()
406 {
407   G4bool omitable;
408   G4UIparameter* parameter;
409 
410   fpCommand = new G4UIcommand("/vis/plot", this);
411   fpCommand -> SetGuidance("Draws plots.");
412   parameter = new G4UIparameter ("type", 's', omitable = false);
413   parameter -> SetParameterCandidates("h1 h2");
414   fpCommand -> SetParameter (parameter);
415   parameter = new G4UIparameter ("id", 'i', omitable = false);
416   fpCommand -> SetParameter (parameter);
417 #ifdef TOOLS_USE_FREETYPE
418   parameter = new G4UIparameter ("style", 's', omitable = true);
419   parameter -> SetParameterCandidates("none ROOT_default hippodraw");
420   parameter -> SetDefaultValue("ROOT_default");
421   fpCommand -> SetParameter (parameter);
422 #endif
423 }
424 
425 G4VisCommandPlot::~G4VisCommandPlot ()
426 {
427   delete fpCommand;
428 }
429 
430 G4String G4VisCommandPlot::GetCurrentValue (G4UIcommand*)
431 {
432   return "";
433 }
434 
435 void G4VisCommandPlot::SetNewValue (G4UIcommand*, G4String newValue)
436 {
437   auto currentViewer = fpVisManager->GetCurrentViewer();
438   if (currentViewer->GetName().find("TOOLSSG") == std::string::npos) {
439     G4warn <<
440     "WARNING: Current viewer not able to draw plots."
441     "\n  Try \"/vis/open TSG\", then \"/vis/plot " << newValue << "\" again."
442     << G4endl;
443     return;
444   }
445 
446   std::istringstream is (newValue);
447   G4String type, id;
448   is >> type >> id;
449 #ifdef TOOLS_USE_FREETYPE
450   G4String style;
451   is >> style;
452 #endif
453 
454   auto keepEnable = fpVisManager->IsEnabled();
455 
456   auto ui = G4UImanager::GetUIpointer();
457   ui->ApplyCommand("/vis/enable");
458   ui->ApplyCommand("/vis/viewer/resetCameraParameters");
459   ui->ApplyCommand("/vis/scene/create");
460   ui->ApplyCommand("/vis/scene/endOfEventAction accumulate 0");  // Don't keep events
461   static G4int plotterID = 0;
462   std::ostringstream ossPlotter;
463   ossPlotter << "plotter-" << plotterID++;
464   const G4String& plotterName = ossPlotter.str();
465   ui->ApplyCommand("/vis/plotter/create " + plotterName);
466   ui->ApplyCommand("/vis/scene/add/plotter " + plotterName);
467   ui->ApplyCommand("/vis/plotter/add/" + type + ' ' + id + ' ' + plotterName);
468 #ifdef TOOLS_USE_FREETYPE
469   if (style != "none") {
470     ui->ApplyCommand("/vis/plotter/addStyle " + plotterName + ' ' + style);
471   }
472 #endif
473   ui->ApplyCommand("/vis/sceneHandler/attach");
474 
475   if (!keepEnable) {
476     fpVisManager->Disable();
477     G4warn <<
478     "WARNING: drawing was enabled for plotting but is now restored to disabled mode."
479     << G4endl;
480   }
481 }
482 
483 ////////////// /vis/specify ///////////////////////////////////////
484 
485 G4VisCommandSpecify::G4VisCommandSpecify() {
486   G4bool omitable;
487   fpCommand = new G4UIcommand("/vis/specify", this);
488   fpCommand->SetGuidance
489     ("Draws logical volume with Boolean components, voxels and readout geometry.");
490   fpCommand->SetGuidance
491     ("Synonymous with \"/vis/drawLogicalVolume\".");
492   fpCommand->SetGuidance
493     ("Creates a scene consisting of this logical volume and asks the"
494      "\n  current viewer to draw it to the specified depth of descent"
495      "\n  showing boolean components (if any), voxels (if any),"
496      "\n  readout geometry (if any), local axes and overlaps (if any),"
497      "\n  under control of the appropriate flag.");
498   fpCommand->SetGuidance
499   ("Note: voxels are not constructed until start of run - /run/beamOn."
500    "\n  (For voxels without a run, \"/run/beamOn 0\".)");
501   fpCommand->SetGuidance("The scene becomes current.");
502   G4UIparameter* parameter;
503   parameter = new G4UIparameter("logical-volume-name", 's', omitable = false);
504   fpCommand->SetParameter(parameter);
505   parameter = new G4UIparameter("depth-of-descent", 'i', omitable = true);
506   parameter->SetDefaultValue(1);
507   fpCommand->SetParameter(parameter);
508   parameter = new G4UIparameter("booleans-flag", 'b', omitable = true);
509   parameter->SetDefaultValue(true);
510   fpCommand->SetParameter(parameter);
511   parameter = new G4UIparameter("voxels-flag", 'b', omitable = true);
512   parameter->SetDefaultValue(true);
513   fpCommand->SetParameter(parameter);
514   parameter = new G4UIparameter("readout-flag", 'b', omitable = true);
515   parameter->SetDefaultValue(true);
516   fpCommand->SetParameter(parameter);
517   parameter = new G4UIparameter("axes-flag", 'b', omitable = true);
518   parameter->SetDefaultValue(true);
519   parameter -> SetGuidance ("Set \"false\" to suppress axes.");
520   fpCommand->SetParameter(parameter);
521   parameter = new G4UIparameter("check-overlap-flag", 'b', omitable = true);
522   parameter->SetDefaultValue(true);
523   parameter -> SetGuidance ("Set \"false\" to suppress overlap check.");
524   fpCommand->SetParameter(parameter);
525 }
526 
527 G4VisCommandSpecify::~G4VisCommandSpecify() {
528   delete fpCommand;
529 }
530 
531 void G4VisCommandSpecify::SetNewValue(G4UIcommand*, G4String newValue) {
532   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
533   G4UImanager* UImanager = G4UImanager::GetUIpointer();
534   // UImanager->ApplyCommand(G4String("/geometry/print " + newValue));
535   UImanager->ApplyCommand("/vis/scene/create");
536   UImanager->ApplyCommand(G4String("/vis/scene/add/logicalVolume " + newValue));
537   UImanager->ApplyCommand("/vis/sceneHandler/attach");
538   static G4bool warned = false;
539   if (verbosity >= G4VisManager::confirmations && !warned) {
540     G4cout <<
541       "NOTE: For systems which are not \"auto-refresh\" you will need to"
542       "\n  issue \"/vis/viewer/refresh\" or \"/vis/viewer/flush\"."
543      << G4endl;
544     warned = true;
545   }
546 }
547