Geant4.10
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Data Structures | Public Member Functions | Data Fields | Protected Member Functions | Protected Attributes | Friends
G4OpenInventorXtExaminerViewer Class Reference

#include <G4OpenInventorXtExaminerViewer.hh>

Inheritance diagram for G4OpenInventorXtExaminerViewer:

Public Member Functions

 G4OpenInventorXtExaminerViewer (Widget parent=NULL, const char *name=NULL, SbBool embed=TRUE, SoXtFullViewer::BuildFlag flag=BUILD_ALL, SoXtViewer::Type type=BROWSER)
 
 ~G4OpenInventorXtExaminerViewer ()
 
template<class T >
void parseString (T &t, const std::string &s, bool &error)
 
Widget addMenu (std::string name)
 
void addButton (Widget menu, std::string name, XtCallbackProc)
 
Widget getMenuBar ()
 
Widget getMenu ()
 
void warningMsgDialog (std::string, String, XtCallbackProc)
 
Widget createScale (Widget, char *, int, float)
 
void addEscapeCallback (void(*cb)(void *), void *)
 

Data Fields

bool warningFlag
 
std::string saveScenegraphFileName
 
Widget saveScenegraphWidget
 
std::string saveRefCoordsFileName
 
Widget saveRefCoordsWidget
 
bool abbrOutputFlag
 
bool pickRefPathFlag
 
bool viewingBeforePickRef
 

Protected Member Functions

 G4OpenInventorXtExaminerViewer (Widget parent, const char *name, SbBool embed, SoXtFullViewer::BuildFlag flag, SoXtViewer::Type type, SbBool build)
 
Widget buildWidget (Widget parent)
 
virtual void createViewerButtons (Widget parent, SbPList *buttonlist)
 
virtual SbBool processSoEvent (const SoEvent *const event)
 
void moveCamera (float dist=0, bool lookdown=false)
 
void rotateCamera ()
 
void updateViewParams (SoKeyboardEvent::Key)
 
bool loadViewPts ()
 
virtual void afterRealizeHook ()
 

Protected Attributes

std::string curEltName
 
SbVec3f camUpVec
 
SbVec3f camDir
 

Friends

class HookEventProcState
 

Detailed Description

Definition at line 63 of file G4OpenInventorXtExaminerViewer.hh.

Constructor & Destructor Documentation

G4OpenInventorXtExaminerViewer::G4OpenInventorXtExaminerViewer ( Widget  parent = NULL,
const char *  name = NULL,
SbBool  embed = TRUE,
SoXtFullViewer::BuildFlag  flag = BUILD_ALL,
SoXtViewer::Type  type = BROWSER 
)

Definition at line 123 of file G4OpenInventorXtExaminerViewer.cc.

References TRUE.

125  :
126  SoXtExaminerViewer(parent, name, embed, flag, type, FALSE)
127 {
128 // Tell GLWidget not to build just yet
129  this->constructor(TRUE);
130 }
name
const XML_Char * name
Definition: include/expat.h:151
FALSE
#define FALSE
Definition: globals.hh:52
TRUE
#define TRUE
Definition: globals.hh:55
G4OpenInventorXtExaminerViewer::~G4OpenInventorXtExaminerViewer ( )

Definition at line 576 of file G4OpenInventorXtExaminerViewer.cc.

577 {
578  if (superimposition != NULL) {
579  removeSuperimposition(superimposition);
580  superimposition->unref();
581  superimposition = NULL;
582  }
583  if (animateSensor->isScheduled())
584  animateSensor->unschedule();
585  delete animateSensor;
586  delete sceneChangeSensor;
587 
588  delete[] curViewPtName;
589  delete searcher;
590 
591  viewer = 0;
592 }
G4OpenInventorXtExaminerViewer::G4OpenInventorXtExaminerViewer ( Widget  parent,
const char *  name,
SbBool  embed,
SoXtFullViewer::BuildFlag  flag,
SoXtViewer::Type  type,
SbBool  build 
)
protected

Definition at line 133 of file G4OpenInventorXtExaminerViewer.cc.

136  :
137  SoXtExaminerViewer(parent, name, embed, flag, type, FALSE)
138 {
139  this->constructor(build);
140 }
name
const XML_Char * name
Definition: include/expat.h:151
FALSE
#define FALSE
Definition: globals.hh:52

Member Function Documentation

void G4OpenInventorXtExaminerViewer::addButton ( Widget  menu,
std::string  name,
XtCallbackProc  cb 
)

Definition at line 667 of file G4OpenInventorXtExaminerViewer.cc.

Referenced by buildWidget().

669 {
670  Widget button = XmCreatePushButton(menu, (char *) name.c_str(), NULL, 0);
671  XtManageChild(button);
672  XtAddCallback(button, XmNactivateCallback, cb, this);
673 }
name
const XML_Char * name
Definition: include/expat.h:151
void G4OpenInventorXtExaminerViewer::addEscapeCallback ( void(*)(void *)  cb,
void *  object 
)

Definition at line 4706 of file G4OpenInventorXtExaminerViewer.cc.

4708 {
4709  this->escapeCallback = callback;
4710  this->examinerObject = object;
4711 }
Widget G4OpenInventorXtExaminerViewer::addMenu ( std::string  name)

Definition at line 653 of file G4OpenInventorXtExaminerViewer.cc.

Referenced by buildWidget().

654 {
655  Arg args[1];
656  Widget menu = XmCreatePulldownMenu(menuBar, (char *) name.c_str(), NULL, 0);
657 
658  XtSetArg(args[0], XmNsubMenuId, menu);
659  Widget w = XmCreateCascadeButton(menuBar, (char *) name.c_str(), args, 1);
660  XtManageChild(w);
661 
662  return menu;
663 }
name
const XML_Char * name
Definition: include/expat.h:151
void G4OpenInventorXtExaminerViewer::afterRealizeHook ( )
protectedvirtual

Definition at line 772 of file G4OpenInventorXtExaminerViewer.cc.

References loadViewPts(), and warningMsgDialog().

773 {
774  SoXtExaminerViewer::afterRealizeHook();
775 
776  // Default height is used when selecting and viewing scene elements
777  // FWJ Added defaultHeight for Ortho camera
778  SoCamera *cam = getCamera();
779  if (cam) {
780  if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
781  defaultHeightAngle =
782  ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
783  toggleCameraType();
784  defaultHeight =
785  ((SoOrthographicCamera *) cam)->height.getValue();
786  toggleCameraType();
787  } else {
788  defaultHeight =
789  ((SoOrthographicCamera *) cam)->height.getValue();
790  toggleCameraType();
791  cam = getCamera();
792  if (cam->isOfType(SoPerspectiveCamera::getClassTypeId()))
793  defaultHeightAngle =
794  ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
795  toggleCameraType();
796  }
797  }
798 
799  // Open the default bookmark file
800  fileIn.open(fileName.c_str());
801  if (!fileIn.fail()) {
802  if (!loadViewPts()) {
803  String dialogName = (char *) "Error Loading File";
804  std::string msg = "Wrong or corrupted input file.";
805  warningMsgDialog(msg, dialogName, NULL);
806  } else {
807  // Opens a file without erasing it
808  fileOut.open(fileName.c_str(), std::ios::in);
809  fileOut.seekp(0, std::ios::end); // For appending new data to the end
810  constructListsDialog(getParentWidget(), this, NULL); // Pop up listsDialog
811 
812  if (viewPtList.size()) {
813  // FWJ disabled auto-selection of first viewpoint.
814  // Initial view should be user-controllable & not forced
815  // setViewPt();
816  XtSetSensitive(nextViewPtButton, True);
817  XtSetSensitive(prevViewPtButton, True);
818  }
819  }
820 
821  fileIn.close();
822  } else {
823  // Creates a new default bookmark file
824  fileOut.open(fileName.c_str());
825  constructListsDialog(getParentWidget(), this, NULL); // Pop up listsDialog
826  }
827 
828  fileIn.clear();
829 
830  SoSeparator *root = (SoSeparator *) (getSceneManager()->getSceneGraph());
831  if (root == NULL)
832  SoDebugError::post("G4OpenInventorXtExaminerViewer::afterRealizeHook", "Root is null.");
833  else {
834  root->addChild(myCam); // For position/orientation calculation during animation
835  }
836 
837  sceneChangeSensor = new SoNodeSensor;
838  sceneChangeSensor->setFunction(sceneChangeCB);
839  sceneChangeSensor->attach(root);
840  sceneChangeSensor->setData(this);
841 
842  // Monitor mouseover events for displaying the name of scene elements
843  // An SoEventCallback is needed instead of using the default processSoEvent
844  // because that last one does not provide us with an SoPath to the object
845  // that was picked
846  SoEventCallback *moCB = new SoEventCallback;
847  moCB->addEventCallback(
848  SoLocation2Event::getClassTypeId(),
849  mouseoverCB, static_cast<void *>(this));
850  root->addChild(moCB);
851 
852  // Override the default picking mechanism present in G4OpenInventorViewer
853  // because we want abbreviated output when picking a trajectory
854  SoEventCallback *pickCB = new SoEventCallback;
855  pickCB->addEventCallback(
856  SoMouseButtonEvent::getClassTypeId(),
857  pickingCB, static_cast<void *>(this));
858  root->addChild(pickCB);
859 
860 }
G4OpenInventorXtExaminerViewer::warningMsgDialog
void warningMsgDialog(std::string, String, XtCallbackProc)
Definition: G4OpenInventorXtExaminerViewer.cc:3565
Widget G4OpenInventorXtExaminerViewer::buildWidget ( Widget  parent)
protected

Definition at line 596 of file G4OpenInventorXtExaminerViewer.cc.

References addButton(), and addMenu().

597 {
598  Widget shell;
599  Atom WM_DELETE_WINDOW;
600 
601  if (!parent)
602  SoDebugError::post("G4OpenInventorXtExaminerViewer::buildWidget", "Error: Parent is null.");
603 
604  Arg args[10];
605  XtSetArg(args[0], XmNtopAttachment, XmATTACH_FORM);
606  XtSetArg(args[1], XmNleftAttachment, XmATTACH_FORM);
607  XtSetArg(args[2], XmNrightAttachment, XmATTACH_FORM);
608  XtSetArg(args[3], XmNbottomAttachment, XmATTACH_FORM);
609  Widget form = XmCreateForm(parent, (char *) "Form", args, 4);
610  XtManageChild(form);
611 
612  shell = XtParent(form);
613  WM_DELETE_WINDOW = XInternAtom(XtDisplay(parent), "WM_DELETE_WINDOW",
614  False);
615  XmAddWMProtocolCallback(shell, WM_DELETE_WINDOW,
616  (XtCallbackProc)closeMainWindowCB, this);
617 
618  XtSetArg(args[0], XmNtopAttachment, XmATTACH_FORM);
619  XtSetArg(args[1], XmNleftAttachment, XmATTACH_FORM);
620  XtSetArg(args[2], XmNrightAttachment, XmATTACH_FORM);
621  menuBar = XmCreateMenuBar(form, (char *) "MenuBar", args, 3);
622  XtManageChild(menuBar);
623 
624  fileMenu = addMenu("File");
625  this->addButton(fileMenu, "Open Viewpoint File...", openViewPtFileCB);
626  addButton(fileMenu, "New Viewpoint File", newViewPtFileCB);
627  addButton(fileMenu, "Load Ref. Coords", loadRefCoordsDialogCB);
628  addButton(fileMenu, "Save Ref. Coords", saveRefCoordsDialogCB);
629  addButton(fileMenu, "Load Scene Graph", loadSceneGraphDialogCB);
630  addButton(fileMenu, "Save Scene Graph", saveSceneGraphDialogCB);
631  XtManageChild(
632  XmCreateSeparatorGadget(fileMenu, (char *) "Separator", NULL, 0));
633 
634  Widget menu = addMenu("Tools");
635  addButton(menu, "Animate Ref. Particle", animateRefParticleCB);
636  addButton(menu, "Go to start of Ref path", gotoRefPathStartCB);
637  addButton(menu, "Invert Ref path", invertRefPathCB);
638 
639  Widget viewerBase = SoXtFullViewer::buildWidget(form);
640 
641  XtSetArg(args[0], XmNtopAttachment, XmATTACH_WIDGET);
642  XtSetArg(args[1], XmNtopWidget, menuBar);
643  XtSetArg(args[2], XmNleftAttachment, XmATTACH_FORM);
644  XtSetArg(args[3], XmNrightAttachment, XmATTACH_FORM);
645  XtSetArg(args[4], XmNbottomAttachment, XmATTACH_FORM);
646  XtSetValues(viewerBase, args, 5);
647 
648  return viewerBase;
649 }
G4OpenInventorXtExaminerViewer::addButton
void addButton(Widget menu, std::string name, XtCallbackProc)
Definition: G4OpenInventorXtExaminerViewer.cc:667
Widget G4OpenInventorXtExaminerViewer::createScale ( Widget  ,
char *  ,
int  ,
float   
)
void G4OpenInventorXtExaminerViewer::createViewerButtons ( Widget  parent,
SbPList *  buttonlist 
)
protectedvirtual

Definition at line 677 of file G4OpenInventorXtExaminerViewer.cc.

References SoXtInternal::createPixmapFromXpm(), n, and TRUE.

679 {
680  int n;
681  Arg args[6];
682  Widget saveViewPtButton, abbrOutputButton, pickRefPathButton;
683 
684  // Create original buttons
685  SoXtExaminerViewer::createViewerButtons(parent, buttonlist);
686 
687  // Handle disappearing button caused by SoXtExaminerViewer::setCamera
688  Widget emptyButton = XtVaCreateManagedWidget("", xmPushButtonWidgetClass,
689  parent, NULL);
690  buttonlist->append(emptyButton);
691 
692  // Left arrow that goes back one view point on click
693  n = 0;
694  XtSetArg(args[n], XmNtopPosition, 1); n++;
695  XtSetArg(args[n], XmNbottomPosition, 2); n++;
696  XtSetArg(args[n], XmNleftPosition, 0); n++;
697  XtSetArg(args[n], XmNrightPosition, 1); n++;
698  XtSetArg(args[n], XmNarrowDirection, XmARROW_LEFT); n++;
699  XtSetArg(args[n], XmNsensitive, False); n++;
700  prevViewPtButton = XmCreateArrowButtonGadget(parent, (char *) "ArrowL",
701  args, n);
702  XtManageChild(prevViewPtButton);
703  XtAddCallback(prevViewPtButton, XmNactivateCallback,
704  G4OpenInventorXtExaminerViewer::prevViewPtCB, this);
705  buttonlist->append(prevViewPtButton);
706 
707  // Right arrow that goes forward one view point on click
708  n = 0;
709  XtSetArg(args[n], XmNtopPosition, 1); n++;
710  XtSetArg(args[n], XmNbottomPosition, 2); n++;
711  XtSetArg(args[n], XmNleftPosition, 0); n++;
712  XtSetArg(args[n], XmNrightPosition, 1); n++;
713  XtSetArg(args[n], XmNarrowDirection, XmARROW_RIGHT); n++;
714  XtSetArg(args[n], XmNsensitive, False); n++;
715  nextViewPtButton = XmCreateArrowButtonGadget(parent, (char *) "ArrowR",
716  args, n);
717  XtManageChild(nextViewPtButton);
718  XtAddCallback(nextViewPtButton, XmNactivateCallback,
719  G4OpenInventorXtExaminerViewer::nextViewPtCB, this);
720  buttonlist->append(nextViewPtButton);
721 
722  // Save button for storing current camera parameters
723  saveViewPtButton = XtVaCreateManagedWidget("Save", xmPushButtonWidgetClass,
724  parent, NULL);
725  XtAddCallback(saveViewPtButton, XmNactivateCallback,
726  G4OpenInventorXtExaminerViewer::saveViewPtCB, this);
727  Pixmap saveVP, saveVP_ins;
728  saveVP = SoXtInternal::createPixmapFromXpm(saveViewPtButton,
729  saveViewPt_xpm);
730  saveVP_ins = SoXtInternal::createPixmapFromXpm(saveViewPtButton,
731  saveViewPt_xpm, TRUE);
732  XtVaSetValues(saveViewPtButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
733  saveVP, XmNselectPixmap, saveVP, XmNlabelInsensitivePixmap,
734  saveVP_ins, XmNselectInsensitivePixmap, saveVP_ins, NULL);
735  buttonlist->append(saveViewPtButton);
736 
737  // Toggle button to get abbreviated output
738  abbrOutputButton = XtVaCreateManagedWidget("Abbr",
739  xmToggleButtonWidgetClass, parent, XmNindicatorOn, False, NULL);
740  XtAddCallback(abbrOutputButton, XmNdisarmCallback, G4OpenInventorXtExaminerViewer::abbrOutputCB,
741  this);
742  Pixmap consolexpm, consolexpm_ins;
743  consolexpm = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
744  console_xpm);
745  consolexpm_ins = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
746  console_xpm, TRUE);
747  XtVaSetValues(abbrOutputButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
748  consolexpm, XmNselectPixmap, consolexpm, XmNlabelInsensitivePixmap,
749  consolexpm_ins, XmNselectInsensitivePixmap, consolexpm_ins, NULL);
750  buttonlist->append(abbrOutputButton);
751 
752  // Button for selecting the beam that will act as reference path
753  pickRefPathButton = XtVaCreateManagedWidget("Refpath", xmPushButtonWidgetClass,
754  parent, NULL);
755  XtAddCallback(pickRefPathButton, XmNactivateCallback,
756  G4OpenInventorXtExaminerViewer::pickRefPathCB, this);
757  Pixmap favoritesxpm, favoritesxpm_ins;
758  favoritesxpm = SoXtInternal::createPixmapFromXpm(pickRefPathButton,
759  favorites_xpm);
760  favoritesxpm_ins = SoXtInternal::createPixmapFromXpm(pickRefPathButton,
761  favorites_xpm, TRUE);
762  XtVaSetValues(pickRefPathButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
763  favoritesxpm, XmNselectPixmap, favoritesxpm, XmNlabelInsensitivePixmap,
764  favoritesxpm_ins, XmNselectInsensitivePixmap, favoritesxpm_ins, NULL);
765  buttonlist->append(pickRefPathButton);
766 
767 }
TRUE
#define TRUE
Definition: globals.hh:55
n
const G4int n
Definition: G4UrQMD1_3Interface.hh:144
SoXtInternal::createPixmapFromXpm
static Pixmap createPixmapFromXpm(Widget button, const char **xpm, SbBool ghost=FALSE)
Widget G4OpenInventorXtExaminerViewer::getMenu ( )
inline

Definition at line 90 of file G4OpenInventorXtExaminerViewer.hh.

90 { return fileMenu; }
Widget G4OpenInventorXtExaminerViewer::getMenuBar ( )
inline

Definition at line 89 of file G4OpenInventorXtExaminerViewer.hh.

89 { return menuBar; }
bool G4OpenInventorXtExaminerViewer::loadViewPts ( )
protected

Definition at line 3302 of file G4OpenInventorXtExaminerViewer.cc.

References test::x, and z.

Referenced by afterRealizeHook().

3303 {
3304  bool error = false;
3305  viewPtData tmp;
3306  std::string token;
3307  SbVec3f axis;
3308  SbRotation orient;
3309  float x, y, z, angle;
3310 
3311  // Gets the last view point accessed, stored in the first line of the data file.
3312  fileIn >> token;
3313  parseString<int>(viewPtIdx, token, error);
3314  getline(fileIn, token); // Remove "\n"
3315  // Converts data from string type into necessary types
3316  while (getline(fileIn, token)) {
3317 
3318  int end = token.find_last_not_of(' '); // Remove padded spaces
3319  token = token.substr(0, end + 1);
3320 
3321  char *vpName = new char[token.size() + 1];
3322  strcpy(vpName, token.c_str());
3323  tmp.viewPtName = vpName;
3324  fileIn >> token;
3325 
3326  parseString<float>(x, token, error);
3327  fileIn >> token;
3328  parseString<float>(y, token, error);
3329  fileIn >> token;
3330  parseString<float>(z, token, error);
3331  fileIn >> token;
3332  tmp.position = axis.setValue(x, y, z);
3333 
3334  parseString<float>(x, token, error);
3335  fileIn >> token;
3336  parseString<float>(y, token, error);
3337  fileIn >> token;
3338  parseString<float>(z, token, error);
3339  fileIn >> token;
3340  parseString<float>(angle, token, error);
3341  fileIn >> token;
3342  orient.setValue(axis.setValue(x, y, z), angle);
3343  tmp.orientation = orient.getValue();
3344 
3345  int camType;
3346  parseString<int>(camType, token, error);
3347  fileIn >> token;
3348  tmp.camType = (CameraType) camType;
3349 
3350  parseString<float>(tmp.height, token, error);
3351  fileIn >> token;
3352  parseString<float>(tmp.focalDistance, token, error);
3353  fileIn >> token;
3354  parseString<float>(tmp.nearDistance, token, error);
3355  fileIn >> token;
3356  parseString<float>(tmp.farDistance, token, error);
3357  fileIn >> token;
3358  parseString<int>(tmp.viewportMapping, token, error);
3359  fileIn >> token;
3360  parseString<float>(tmp.aspectRatio, token, error);
3361 
3362  getline(fileIn, token); // To remove "\n" characters
3363  getline(fileIn, token);
3364 
3365  if (error) {
3366  viewPtIdx = 0;
3367  viewPtList.clear();
3368  return false;
3369  }
3370  viewPtList.push_back(tmp);
3371  }
3372 
3373  return true;
3374 }
z
G4double z
Definition: TRTMaterials.hh:39
void G4OpenInventorXtExaminerViewer::moveCamera ( float  dist = 0,
bool  lookdown = false 
)
protected

Definition at line 892 of file G4OpenInventorXtExaminerViewer.cc.

References camDir, camUpVec, test::x, and z.

Referenced by processSoEvent().

893 {
894 
895  SoCamera *cam = getCamera();
896  SbVec3f p1, p2; // The particle moves from p1 to p2
897  SbVec3f particleDir; // Direction vector from p1 to p2
898  SbVec3f camPosNew; // New position of the camera
899 
900  if(refParticleTrajectory.size() == 0) {
901  //refParticleTrajectory hasn't been set yet
902  if(dist)
903  distance = dist;
904  else
905  distance = (cam->position.getValue() - center).length();
906 
907  cam->position.setValue(center + offsetFromCenter*distance);
908  cam->focalDistance = (cam->position.getValue() - center).length();
909  cam->pointAt(center, upVector);
910  }
911  else{
912 
913  // If we move forward past the last trajectory point,
914  // go back to the beginning
915  if (refParticleIdx >= (int) refParticleTrajectory.size() - 1) {
916  prevPt = refParticleTrajectory[refParticleIdx - step];
917  dist = (prevPt - cam->position.getValue()).length();
918  refParticleIdx = 0;
919  }
920  // If we move backward past the beginning,
921  // go to the last trajectory point
922  if (refParticleIdx < 0) {
923  prevPt = refParticleTrajectory[refParticleIdx + step];
924  dist = (prevPt - cam->position.getValue()).length();
925  refParticleIdx = refParticleTrajectory.size() - 2;
926  }
927 
928  // Set start and end points
929  p1 = refParticleTrajectory[refParticleIdx];
930  p2 = refParticleTrajectory[refParticleIdx + step];
931 
932  // Get the direction from p1 to p2
933  particleDir = p2 - p1;
934  particleDir.normalize();
935 
936  if(prevParticleDir == SbVec3f(0,0,0)){
937  // First time entering BEAMLINE mode, look at
938  // the element from the front, with camera upright
939  if(lookdown)
940  camDir = SbVec3f(0,0,1);
941  else
942  camDir = SbVec3f(1,0,0);
943  camUpVec = SbVec3f(0,1,0);
944 
945  // In case the start of the goes in a
946  // direction other than +z, rotate the camera accordingly
947  SbRotation rot(SbVec3f(0,0,1), particleDir);
948  rot.multVec(camDir, camDir);
949  rot.multVec(camUpVec, camUpVec);
950 
951  }
952  else if(particleDir != prevParticleDir) {
953  // The beamline has changed direction
954 
955  SbRotation rot(prevParticleDir, particleDir);
956  rot.multVec(camDir, camDir);
957  rot.multVec(camUpVec, camUpVec);
958 
959  }
960 
961  if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
962  if (!dist)
963  distance = (prevPt - cam->position.getValue()).length();
964  else
965  distance = dist;
966  }
967 
968  if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
969  if (!dist)
970  distance = (prevPt - cam->position.getValue()).length();
971  else
972  distance = dist;
973  }
974 
975 
976  float x,y,z;
977  prevPt.getValue(x,y,z);
978 
979 
980  if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
981  camPosNew = p2 - (camDir*distance);
982  }
983  if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
984  camPosNew = p2 - (camDir);
985  }
986 
987  cam->position = camPosNew;
988  cam->pointAt(p2, camUpVec);
989  // FWJ Disabled: zooms out the Persp camera much too far
990  // and can't recover by zooming in!
991  // cam->focalDistance = (p2 - camPosNew).length();
992 
993  p2.getValue(x,y,z);
994  camPosNew.getValue(x,y,z);
995 
996  prevParticleDir = particleDir;
997  prevPt = p1; // For accurate distance calculation
998 
999  }
1000 
1001 }
z
G4double z
Definition: TRTMaterials.hh:39
template<class T >
void G4OpenInventorXtExaminerViewer::parseString ( T &  t,
const std::string &  s,
bool &  error 
)

Definition at line 3380 of file G4OpenInventorXtExaminerViewer.cc.

3382 {
3383  std::istringstream str(s);
3384  if ((str >> t).fail())
3385  error = true;
3386 }
s
const XML_Char * s
Definition: include/expat.h:262
SbBool G4OpenInventorXtExaminerViewer::processSoEvent ( const SoEvent *const  event)
protectedvirtual

Definition at line 1255 of file G4OpenInventorXtExaminerViewer.cc.

References camDir, camUpVec, FALSE, MAX_SPEED_INDICATOR, MIN_SPEED, moveCamera(), ROT_CNT, rotateCamera(), SPEED_INDICATOR_STEP, TRUE, and warningMsgDialog().

1255  {
1256  SoCamera *cam = getCamera();
1257  const SoType type(ev->getTypeId());
1258 
1259  if (type.isDerivedFrom(SoMouseButtonEvent::getClassTypeId())) {
1260  SoMouseButtonEvent * me = (SoMouseButtonEvent *) ev;
1261 
1262  if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
1263  || currentState == PAUSED_ANIMATION) {
1264  switch (me->getButton()) {
1265  case SoMouseButtonEvent::BUTTON4: // Scroll wheel up
1266  if (me->getState() == SoButtonEvent::DOWN) {
1267  if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
1268  float hAngle =
1269  ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
1270  ((SoPerspectiveCamera *) cam)->heightAngle = hAngle
1271  + 0.01f;
1272  return TRUE;
1273  } else if (cam->isOfType(
1274  SoOrthographicCamera::getClassTypeId())) {
1275  float height =
1276  ((SoOrthographicCamera *) cam)->height.getValue();
1277  ((SoOrthographicCamera *) cam)->height = height + 5;
1278  return TRUE;
1279  }
1280  }
1281  break;
1282  case SoMouseButtonEvent::BUTTON5: // Scroll wheel down
1283  if (me->getState() == SoButtonEvent::DOWN) {
1284  if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
1285  float hAngle =
1286  ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
1287  if (hAngle > 0.01)
1288  ((SoPerspectiveCamera *) cam)->heightAngle = hAngle
1289  - 0.01f;
1290  return TRUE;
1291  } else if (cam->isOfType(
1292  SoOrthographicCamera::getClassTypeId())) {
1293  float height =
1294  ((SoOrthographicCamera *) cam)->height.getValue();
1295  if (height > 5)
1296  ((SoOrthographicCamera *) cam)->height = height - 5;
1297  return TRUE;
1298  }
1299  }
1300  break;
1301  default:
1302  break;
1303  }
1304  }
1305  if (currentState == GENERAL) {
1306 
1307  }
1308  }
1309 
1310  if (type.isDerivedFrom(SoKeyboardEvent::getClassTypeId())) {
1311  SoKeyboardEvent * ke = (SoKeyboardEvent *) ev;
1312 
1313  if (SoKeyboardEvent::isKeyPressEvent(ev, ke->getKey())) {
1314  switch (ke->getKey()) {
1315  case SoKeyboardEvent::LEFT_SHIFT:
1316  this->lshiftdown = true;
1317  return TRUE;
1318  case SoKeyboardEvent::RIGHT_SHIFT:
1319  this->rshiftdown = true;
1320  return TRUE;
1321  case SoKeyboardEvent::LEFT_CONTROL:
1322  this->lctrldown = true;
1323  return TRUE;
1324  case SoKeyboardEvent::RIGHT_CONTROL:
1325  this->rctrldown = true;
1326  return TRUE;
1327  case SoKeyboardEvent::SPACE:
1328  if (currentState == ANIMATION
1329  || currentState == REVERSED_ANIMATION) {
1330  beforePausing = currentState;
1331  currentState = PAUSED_ANIMATION;
1332  if (animateSensor->isScheduled())
1333  animateSensor->unschedule();
1334  return TRUE;
1335  } else if (currentState == PAUSED_ANIMATION) {
1336  if (maxSpeed) {
1337  if ((beforePausing == ANIMATION
1338  && refParticleIdx
1339  < (int) refParticleTrajectory.size() - 1)
1340  || (beforePausing == REVERSED_ANIMATION
1341  && refParticleIdx > 0)) {
1342  currentState = beforePausing;
1343  animateRefParticle();
1344  }
1345  }
1346  return TRUE;
1347  }
1348  break;
1349  case SoKeyboardEvent::ESCAPE:
1350  if (currentState == ANIMATION
1351  || currentState == REVERSED_ANIMATION
1352  || currentState == PAUSED_ANIMATION) {
1353 
1354  if (animateSensor->isScheduled())
1355  animateSensor->unschedule();
1356  currentState = prevState;
1357  refParticleIdx = prevRefIdx;
1358  setSuperimpositionEnabled(superimposition, FALSE);
1359  maxSpeed = 0.0f;
1360  step = 1;
1361 
1362  scheduleRedraw();
1363  if (currentState == VIEWPOINT) {
1364  setSuperimpositionEnabled(superimposition, TRUE);
1365  axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
1366  animSpeedOutlineSwitch->whichChild.setValue(
1367  SO_SWITCH_NONE);
1368  animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
1369 
1370  scheduleRedraw();
1371  }
1372  restoreCamera();
1373  return TRUE;
1374  }
1375  break;
1376  case SoKeyboardEvent::DELETE:
1377  if (viewPtList.size()
1378  && (currentState != ANIMATION
1379  || currentState != REVERSED_ANIMATION
1380  || currentState != PAUSED_ANIMATION)) {
1381  String dialogName = (char *) "Delete Viewpoint";
1382  std::string msg = "Are you sure you want to delete current viewpoint?";
1383  warningMsgDialog(msg, dialogName, deleteViewPtCB);
1384  return TRUE;
1385  }
1386  break;
1387  case SoKeyboardEvent::LEFT_ARROW:
1388  switch (currentState) {
1389  case BEAMLINE:
1390  if ((this->lshiftdown) || (this->rshiftdown)){
1391  refParticleIdx -= step;
1392  moveCamera();
1393  }
1394  else if ((this->lctrldown) || (this->rctrldown)){
1395  if (SoXtExaminerViewer::isAnimating())
1396  stopAnimating();
1397  prevState = currentState;
1398  currentState = ROTATING;
1399  animateBtwPtsPeriod = 0.08f;
1400 
1401  SbVec3f tmp = camDir;
1402  tmp.negate();
1403  rotAxis = tmp;
1404 
1405  rotCnt = ROT_CNT;
1406  moveCamera(); // To make sure camera is perpendicular to the beamline
1407 
1408  rotateCamera();
1409  }
1410  else{
1411  if (SoXtExaminerViewer::isAnimating())
1412  stopAnimating();
1413  prevState = currentState;
1414  currentState = ROTATING;
1415  animateBtwPtsPeriod = 0.08f;
1416 
1417  SbVec3f tmp = camUpVec;
1418  tmp.negate();
1419  rotAxis = tmp;
1420 
1421  rotCnt = ROT_CNT;
1422  moveCamera(); // To make sure camera is perpendicular to the beamline
1423 
1424  rotateCamera();
1425 
1426  }
1427  return TRUE;
1428 
1429  case ANIMATION:
1430  case REVERSED_ANIMATION:
1431  left_right -= 1.5f;
1432  return TRUE;
1433  case PAUSED_ANIMATION:
1434  left_right -= 1.5f;
1435  setStartingPtForAnimation();
1436  cam->position = myCam->position;
1437  return TRUE;
1438  case GENERAL:
1439  case VIEWPOINT:
1440  if ((!this->lshiftdown) && (!this->rshiftdown)) {
1441  // Using this allows us to look around without
1442  // changing the camera parameters (camDir, camUpVec)
1443  this->bottomWheelMotion(
1444  this->getBottomWheelValue() + 0.1f);
1445 
1446  return TRUE;
1447  }
1448  break;
1449  case ROTATING:
1450  // For this state, let the keyboard event
1451  // be handled by superclass
1452  break;
1453  default:
1454  SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
1455  "Unhandled viewer state");
1456  break;
1457  }
1458  break;
1459 
1460  case SoKeyboardEvent::RIGHT_ARROW:
1461  switch(currentState){
1462  case BEAMLINE:
1463  if ((this->lshiftdown) || (this->rshiftdown)){
1464  refParticleIdx += step;
1465  moveCamera();
1466  }
1467  else if ((this->lctrldown) || (this->rctrldown)){
1468  if (SoXtExaminerViewer::isAnimating())
1469  stopAnimating();
1470  prevState = currentState;
1471  currentState = ROTATING;
1472  animateBtwPtsPeriod = 0.08f;
1473 
1474  rotAxis = camDir;
1475 
1476  rotCnt = ROT_CNT;
1477  moveCamera(); // To make sure camera is perpendicular to the beamline
1478 
1479  rotateCamera();
1480  }
1481  else{
1482  if (SoXtExaminerViewer::isAnimating())
1483  stopAnimating();
1484  prevState = currentState;
1485  currentState = ROTATING;
1486  animateBtwPtsPeriod = 0.08f;
1487 
1488  rotAxis = camUpVec;
1489 
1490  rotCnt = ROT_CNT;
1491  moveCamera(); // To make sure camera is perpendicular to the beamline
1492 
1493  rotateCamera();
1494  }
1495  return TRUE;
1496 
1497  case ANIMATION:
1498  case REVERSED_ANIMATION:
1499  left_right += 1.5f;
1500  return TRUE;
1501  case PAUSED_ANIMATION:
1502  left_right += 1.5f;
1503  setStartingPtForAnimation();
1504  cam->position = myCam->position;
1505  return TRUE;
1506  case GENERAL:
1507  case VIEWPOINT:
1508  if ((!this->lshiftdown) && (!this->rshiftdown)) {
1509  // Using this allows us to look around without
1510  // changing the camera parameters (camDir, camUpVec)
1511  this->bottomWheelMotion(
1512  this->getBottomWheelValue() - 0.1f);
1513  return TRUE;
1514  }
1515  break;
1516  case ROTATING:
1517  // For this state, let the keyboard event
1518  // be handled by superclass
1519  break;
1520  default:
1521  SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
1522  "Unhandled viewer state");
1523  break;
1524  }
1525  break;
1526 
1527  case SoKeyboardEvent::DOWN_ARROW:
1528  switch(currentState){
1529  case BEAMLINE:
1530 
1531  if ((this->lshiftdown) || (this->rshiftdown)){
1532  refParticleIdx -= step;
1533  moveCamera();
1534  }
1535  else{
1536  if (SoXtExaminerViewer::isAnimating())
1537  stopAnimating();
1538  prevState = currentState;
1539  currentState = ROTATING;
1540  animateBtwPtsPeriod = 0.08f;
1541 
1542  rotAxis = camDir.cross(camUpVec);
1543 
1544  rotCnt = ROT_CNT;
1545  moveCamera(); // To make sure camera is perpendicular to the beamline
1546 
1547  rotateCamera();
1548 
1549  }
1550  return TRUE;
1551 
1552  case ANIMATION:
1553  case REVERSED_ANIMATION:
1554  up_down -= 1.5f;
1555  return TRUE;
1556  case PAUSED_ANIMATION:
1557  up_down -= 1.5f;
1558  setStartingPtForAnimation();
1559  cam->position = myCam->position;
1560  return TRUE;
1561  case GENERAL:
1562  case VIEWPOINT:
1563  // Using this allows us to look around without
1564  // changing the camera parameters (camDir, camUpVec)
1565  if ((!this->lshiftdown) && (!this->rshiftdown)) {
1566  this->leftWheelMotion(this->getLeftWheelValue() - 0.1f);
1567  return TRUE;
1568  }
1569  break;
1570  case ROTATING:
1571  // For this state, let the keyboard event
1572  // be handled by superclass
1573  break;
1574  default:
1575  SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
1576  "Unhandled viewer state");
1577  break;
1578  }
1579  break;
1580 
1581  case SoKeyboardEvent::UP_ARROW:
1582  switch(currentState){
1583  case BEAMLINE:
1584  if ((this->lshiftdown) || (this->rshiftdown)){
1585  refParticleIdx -= step;
1586  moveCamera();
1587  }
1588  else{
1589  if (SoXtExaminerViewer::isAnimating())
1590  stopAnimating();
1591  prevState = currentState;
1592  currentState = ROTATING;
1593  animateBtwPtsPeriod = 0.08f;
1594 
1595  rotAxis = camUpVec.cross(camDir);
1596 
1597  rotCnt = ROT_CNT;
1598  moveCamera();
1599 
1600  rotateCamera();
1601 
1602 
1603  }
1604  return TRUE;
1605  case ANIMATION:
1606  case REVERSED_ANIMATION:
1607  up_down += 1.5f;
1608  return TRUE;
1609  case PAUSED_ANIMATION:
1610  up_down += 1.5f;
1611  setStartingPtForAnimation();
1612  cam->position = myCam->position;
1613  return TRUE;
1614  case GENERAL:
1615  case VIEWPOINT:
1616  // Using this allows us to look around without
1617  // changing the camera parameters (camDir, camUpVec)
1618  if ((!this->lshiftdown) && (!this->rshiftdown)) {
1619  this->leftWheelMotion(this->getLeftWheelValue() + 0.1f);
1620  return TRUE;
1621  }
1622  break;
1623  case ROTATING:
1624  // For this state, let the keyboard event
1625  // be handled by superclass
1626  break;
1627  default:
1628  SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
1629  "Unhandled viewer state");
1630  break;
1631  }
1632  break;
1633 
1634  case SoKeyboardEvent::PAGE_UP:
1635  switch(currentState){
1636  case BEAMLINE:
1637  if (step < (int) refParticleTrajectory.size() / 5) // Magic number
1638  step++;
1639  return TRUE;
1640  case ANIMATION:
1641  incSpeed();
1642  maxSpeed += SPEED_INDICATOR_STEP;
1643  if (maxSpeed > 0.8)
1644  maxSpeed = MAX_SPEED_INDICATOR;
1645  scheduleRedraw();
1646 
1647  return TRUE;
1648  case REVERSED_ANIMATION:
1649  if(!animateSensor->isScheduled()){
1650  currentState = ANIMATION;
1651  if (refParticleIdx
1652  < (int) refParticleTrajectory.size() - 1) {
1653  refParticleIdx++;
1654  maxSpeed = SPEED_INDICATOR_STEP;
1655  scheduleRedraw();
1656  animateRefParticle();
1657  }
1658  }
1659  else{
1660  maxSpeed += SPEED_INDICATOR_STEP;
1661  decSpeed();
1662  scheduleRedraw();
1663  }
1664  return TRUE;
1665  case PAUSED_ANIMATION:
1666  maxSpeed += SPEED_INDICATOR_STEP;
1667  if (maxSpeed > 0.8)
1668  maxSpeed = MAX_SPEED_INDICATOR;
1669 
1670  if (beforePausing == ANIMATION) {
1671  incSpeed();
1672  } else {
1673  decSpeed();
1674  if (animateBtwPtsPeriod >= MIN_SPEED)
1675  beforePausing = ANIMATION;
1676  }
1677 
1678  scheduleRedraw();
1679  return TRUE;
1680  default: //fall through
1681  break;
1682  }
1683  break;
1684 
1685  case SoKeyboardEvent::PAGE_DOWN:
1686  switch(currentState){
1687  case BEAMLINE:
1688  if (step > 1)
1689  step--;
1690  return TRUE;
1691  case ANIMATION:
1692  if(!animateSensor->isScheduled()){
1693  currentState = REVERSED_ANIMATION;
1694  if (refParticleIdx > 1) {
1695  refParticleIdx--;
1696  maxSpeed = -SPEED_INDICATOR_STEP;
1697  scheduleRedraw();
1698  animateRefParticle();
1699  }
1700  }
1701  else{
1702  maxSpeed -= SPEED_INDICATOR_STEP;
1703  decSpeed();
1704  scheduleRedraw();
1705  }
1706  return TRUE;
1707  case REVERSED_ANIMATION:
1708  incSpeed();
1709  maxSpeed -= SPEED_INDICATOR_STEP;
1710  if (maxSpeed < -0.8)
1711  maxSpeed = -MAX_SPEED_INDICATOR;
1712  scheduleRedraw();
1713  return TRUE;
1714  case PAUSED_ANIMATION:
1715  maxSpeed -= SPEED_INDICATOR_STEP;
1716  if (maxSpeed < -0.8)
1717  maxSpeed = -MAX_SPEED_INDICATOR;
1718  if (beforePausing == REVERSED_ANIMATION) {
1719  incSpeed();
1720  } else {
1721  decSpeed();
1722  if (animateBtwPtsPeriod >= MIN_SPEED)
1723  beforePausing = REVERSED_ANIMATION;
1724  }
1725  scheduleRedraw();
1726  return TRUE;
1727  default:
1728  //fall through
1729  break;
1730  }
1731  break;
1732 
1733  case SoKeyboardEvent::E:
1734  this->escapeCallback(this->examinerObject);
1735  break;
1736 
1737  default:
1738  break; // To get rid of compiler warnings
1739  }
1740  }
1741  if (SoKeyboardEvent::isKeyReleaseEvent(ev, ke->getKey())) {
1742  switch (ke->getKey()) {
1743  case SoKeyboardEvent::LEFT_SHIFT:
1744  this->lshiftdown = false;
1745  return TRUE;
1746  case SoKeyboardEvent::RIGHT_SHIFT:
1747  this->rshiftdown = false;
1748  return TRUE;
1749  case SoKeyboardEvent::LEFT_CONTROL:
1750  this->lctrldown = false;
1751  return TRUE;
1752  case SoKeyboardEvent::RIGHT_CONTROL:
1753  this->rctrldown = false;
1754  return TRUE;
1755  default:
1756  break;
1757  }
1758  }
1759  }
1760 
1761  if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
1762  || currentState == ROTATING)
1763  return FALSE;
1764  else
1765  return SoXtExaminerViewer::processSoEvent(ev);
1766 }
SPEED_INDICATOR_STEP
#define SPEED_INDICATOR_STEP
Definition: G4OpenInventorXtExaminerViewer.cc:117
ROT_CNT
#define ROT_CNT
Definition: G4OpenInventorXtExaminerViewer.cc:120
MIN_SPEED
#define MIN_SPEED
Definition: G4OpenInventorXtExaminerViewer.cc:115
G4OpenInventorXtExaminerViewer::moveCamera
void moveCamera(float dist=0, bool lookdown=false)
Definition: G4OpenInventorXtExaminerViewer.cc:892
G4OpenInventorXtExaminerViewer::warningMsgDialog
void warningMsgDialog(std::string, String, XtCallbackProc)
Definition: G4OpenInventorXtExaminerViewer.cc:3565
FALSE
#define FALSE
Definition: globals.hh:52
TRUE
#define TRUE
Definition: globals.hh:55
MAX_SPEED_INDICATOR
#define MAX_SPEED_INDICATOR
Definition: G4OpenInventorXtExaminerViewer.cc:118
void G4OpenInventorXtExaminerViewer::rotateCamera ( )
protected

Definition at line 865 of file G4OpenInventorXtExaminerViewer.cc.

References camDir, camUpVec, M_PI, and ROT_CNT.

Referenced by processSoEvent().

866 {
867  SoCamera *cam = getCamera();
868 
869  SbRotation rot(rotAxis, M_PI / (2 * ROT_CNT));
870  rot.multVec(camDir, camDir);
871  rot.multVec(camUpVec, camUpVec);
872 
873  SbVec3f camPosNew = prevPt - (camDir*distance);
874  cam->position = camPosNew;
875  cam->pointAt(prevPt, camUpVec);
876  cam->focalDistance = (prevPt - camPosNew).length();
877 
878  rotCnt--;
879 
880  if (animateSensorRotation->isScheduled()) {
881  animateSensorRotation->unschedule();
882  }
883 
884  animateSensorRotation->setBaseTime(SbTime::getTimeOfDay());
885  animateSensorRotation->setInterval(SbTime(0.02));
886  animateSensorRotation->schedule();
887 
888 }
M_PI
#define M_PI
Definition: SbMath.h:34
ROT_CNT
#define ROT_CNT
Definition: G4OpenInventorXtExaminerViewer.cc:120
void G4OpenInventorXtExaminerViewer::updateViewParams ( SoKeyboardEvent::Key  )
protected
void G4OpenInventorXtExaminerViewer::warningMsgDialog ( std::string  msg,
String  dialogName,
XtCallbackProc  cb 
)

Definition at line 3565 of file G4OpenInventorXtExaminerViewer.cc.

References n.

Referenced by afterRealizeHook(), and processSoEvent().

3568 {
3569  Arg args[5];
3570  unsigned int n;
3571  XmString warningMsg;
3572 
3573  warningMsg = XmStringCreateLocalized((char *)msg.c_str());
3574 
3575  n = 0;
3576  XtSetArg(args[n], XmNmessageString, warningMsg); n++;
3577  Widget warningDialog = XmCreateWarningDialog(getParentWidget(), dialogName, args, n);
3578  if (cb)
3579  XtAddCallback(warningDialog, XmNokCallback, cb, this);
3580 
3581  XmStringFree(warningMsg);
3582 
3583  XtVaSetValues (warningDialog, XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL, NULL);
3584  XtUnmanageChild(XtNameToWidget(warningDialog, "Help"));
3585  XtUnmanageChild(XtNameToWidget(warningDialog, "Cancel"));
3586 
3587  XtManageChild(warningDialog);
3588 }
n
const G4int n
Definition: G4UrQMD1_3Interface.hh:144

Friends And Related Function Documentation

friend class HookEventProcState
friend

Definition at line 136 of file G4OpenInventorXtExaminerViewer.hh.

Field Documentation

bool G4OpenInventorXtExaminerViewer::abbrOutputFlag

Definition at line 101 of file G4OpenInventorXtExaminerViewer.hh.

SbVec3f G4OpenInventorXtExaminerViewer::camDir
protected

Definition at line 123 of file G4OpenInventorXtExaminerViewer.hh.

Referenced by moveCamera(), processSoEvent(), and rotateCamera().

SbVec3f G4OpenInventorXtExaminerViewer::camUpVec
protected

Definition at line 122 of file G4OpenInventorXtExaminerViewer.hh.

Referenced by moveCamera(), processSoEvent(), and rotateCamera().

std::string G4OpenInventorXtExaminerViewer::curEltName
protected

Definition at line 121 of file G4OpenInventorXtExaminerViewer.hh.

bool G4OpenInventorXtExaminerViewer::pickRefPathFlag

Definition at line 102 of file G4OpenInventorXtExaminerViewer.hh.

std::string G4OpenInventorXtExaminerViewer::saveRefCoordsFileName

Definition at line 96 of file G4OpenInventorXtExaminerViewer.hh.

Widget G4OpenInventorXtExaminerViewer::saveRefCoordsWidget

Definition at line 97 of file G4OpenInventorXtExaminerViewer.hh.

std::string G4OpenInventorXtExaminerViewer::saveScenegraphFileName

Definition at line 94 of file G4OpenInventorXtExaminerViewer.hh.

Widget G4OpenInventorXtExaminerViewer::saveScenegraphWidget

Definition at line 95 of file G4OpenInventorXtExaminerViewer.hh.

bool G4OpenInventorXtExaminerViewer::viewingBeforePickRef

Definition at line 103 of file G4OpenInventorXtExaminerViewer.hh.

bool G4OpenInventorXtExaminerViewer::warningFlag

Definition at line 92 of file G4OpenInventorXtExaminerViewer.hh.

The documentation for this class was generated from the following files:
Generated on Wed Apr 30 2014 15:56:51 for Geant4.10 by   doxygen 1.8.7