Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Classes | Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Friends | List of all members
G4OpenInventorXtExaminerViewer Class Reference

#include <G4OpenInventorXtExaminerViewer.hh>

Inheritance diagram for G4OpenInventorXtExaminerViewer:
Inheritance graph
[legend]
Collaboration diagram for G4OpenInventorXtExaminerViewer:
Collaboration graph
[legend]

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 *)
 

Public Attributes

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 G4OpenInventorXtExaminerViewerMessenger
 
class G4OpenInventorXtExtendedViewer
 
class HookEventProcState
 

Detailed Description

Definition at line 65 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 130 of file G4OpenInventorXtExaminerViewer.cc.

132  :
133  SoXtExaminerViewer(parent, name, embed, flag, type, FALSE)
134 {
135 // Tell GLWidget not to build just yet
136  this->constructor(TRUE);
137 }
name
const XML_Char * name
Definition: expat.h:151
FALSE
#define FALSE
Definition: globals.hh:52
TRUE
#define TRUE
Definition: globals.hh:55
G4OpenInventorXtExaminerViewer::~G4OpenInventorXtExaminerViewer ( )

Definition at line 586 of file G4OpenInventorXtExaminerViewer.cc.

587 {
588  if (superimposition != NULL) {
589  removeSuperimposition(superimposition);
590  superimposition->unref();
591  superimposition = NULL;
592  }
593  if (animateSensor->isScheduled())
594  animateSensor->unschedule();
595  delete animateSensor;
596  delete sceneChangeSensor;
597 
598  delete[] curViewPtName;
599  delete searcher;
600 
601  viewer = 0;
602 }
G4OpenInventorXtExaminerViewer::G4OpenInventorXtExaminerViewer ( Widget  parent,
const char *  name,
SbBool  embed,
SoXtFullViewer::BuildFlag  flag,
SoXtViewer::Type  type,
SbBool  build 
)
protected

Definition at line 140 of file G4OpenInventorXtExaminerViewer.cc.

143  :
144  SoXtExaminerViewer(parent, name, embed, flag, type, FALSE)
145 {
146  this->constructor(build);
147 }
name
const XML_Char * name
Definition: 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 677 of file G4OpenInventorXtExaminerViewer.cc.

679 {
680  Widget button = XmCreatePushButton(menu, (char *) name.c_str(), NULL, 0);
681  XtManageChild(button);
682  XtAddCallback(button, XmNactivateCallback, cb, this);
683 }
name
const XML_Char * name
Definition: expat.h:151

Here is the caller graph for this function:

void G4OpenInventorXtExaminerViewer::addEscapeCallback ( void(*)(void *)  cb,
void *  object 
)

Definition at line 4889 of file G4OpenInventorXtExaminerViewer.cc.

4891 {
4892  this->escapeCallback = callback;
4893  this->examinerObject = object;
4894 }
Widget G4OpenInventorXtExaminerViewer::addMenu ( std::string  name)

Definition at line 663 of file G4OpenInventorXtExaminerViewer.cc.

664 {
665  Arg args[1];
666  Widget menu = XmCreatePulldownMenu(menuBar, (char *) name.c_str(), NULL, 0);
667 
668  XtSetArg(args[0], XmNsubMenuId, menu);
669  Widget w = XmCreateCascadeButton(menuBar, (char *) name.c_str(), args, 1);
670  XtManageChild(w);
671 
672  return menu;
673 }
name
const XML_Char * name
Definition: expat.h:151

Here is the caller graph for this function:

void G4OpenInventorXtExaminerViewer::afterRealizeHook ( )
protectedvirtual

Definition at line 806 of file G4OpenInventorXtExaminerViewer.cc.

807 {
808  SoXtExaminerViewer::afterRealizeHook();
809 
810  // Default height is used when selecting and viewing scene elements
811  // FWJ Added defaultHeight for Ortho camera
812  SoCamera *cam = getCamera();
813  if (cam) {
814  if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
815  defaultHeightAngle =
816  ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
817  toggleCameraType();
818  defaultHeight =
819  ((SoOrthographicCamera *) cam)->height.getValue();
820  toggleCameraType();
821  } else {
822  defaultHeight =
823  ((SoOrthographicCamera *) cam)->height.getValue();
824  toggleCameraType();
825  cam = getCamera();
826  if (cam->isOfType(SoPerspectiveCamera::getClassTypeId()))
827  defaultHeightAngle =
828  ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
829  toggleCameraType();
830  }
831  }
832 
833  // Open the default bookmark file
834  fileIn.open(fileName.c_str());
835  if (!fileIn.fail()) {
836  if (!loadViewPts()) {
837  String dialogName = (char *) "Error Loading File";
838  std::string msg = "Wrong or corrupted input file.";
839  warningMsgDialog(msg, dialogName, NULL);
840  } else {
841  // Opens a file without erasing it
842  fileOut.open(fileName.c_str(), std::ios::in);
843  fileOut.seekp(0, std::ios::end); // For appending new data to the end
844  constructListsDialog(getParentWidget(), this, NULL); // Pop up listsDialog
845 
846  if (viewPtList.size()) {
847  // FWJ disabled auto-selection of first viewpoint.
848  // Initial view should be user-controllable & not forced
849  // setViewPt();
850  XtSetSensitive(nextViewPtButton, True);
851  XtSetSensitive(prevViewPtButton, True);
852  }
853  }
854 
855  fileIn.close();
856  } else {
857  // Creates a new default bookmark file
858  fileOut.open(fileName.c_str());
859  constructListsDialog(getParentWidget(), this, NULL); // Pop up listsDialog
860  }
861 
862  fileIn.clear();
863 
864  SoSeparator *root = (SoSeparator *) (getSceneManager()->getSceneGraph());
865  if (root == NULL)
866  SoDebugError::post("G4OpenInventorXtExaminerViewer::afterRealizeHook", "Root is null.");
867  else {
868  root->addChild(myCam); // For position/orientation calculation during animation
869  }
870 
871  sceneChangeSensor = new SoNodeSensor;
872  sceneChangeSensor->setFunction(sceneChangeCB);
873  sceneChangeSensor->attach(root);
874  sceneChangeSensor->setData(this);
875 
876  // Monitor mouseover events for displaying the name of scene elements
877  // An SoEventCallback is needed instead of using the default processSoEvent
878  // because that last one does not provide us with an SoPath to the object
879  // that was picked
880  SoEventCallback *moCB = new SoEventCallback;
881  moCB->addEventCallback(
882  SoLocation2Event::getClassTypeId(),
883  mouseoverCB, static_cast<void *>(this));
884  root->addChild(moCB);
885 
886  // Override the default picking mechanism present in G4OpenInventorViewer
887  // because we want abbreviated output when picking a trajectory
888  SoEventCallback *pickCB = new SoEventCallback;
889  pickCB->addEventCallback(
890  SoMouseButtonEvent::getClassTypeId(),
891  pickingCB, static_cast<void *>(this));
892  root->addChild(pickCB);
893 
894 }
G4OpenInventorXtExaminerViewer::warningMsgDialog
void warningMsgDialog(std::string, String, XtCallbackProc)
Definition: G4OpenInventorXtExaminerViewer.cc:3740

Here is the call graph for this function:

Widget G4OpenInventorXtExaminerViewer::buildWidget ( Widget  parent)
protected

Definition at line 606 of file G4OpenInventorXtExaminerViewer.cc.

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

Here is the call graph for this function:

Widget G4OpenInventorXtExaminerViewer::createScale ( Widget  ,
char *  ,
int  ,
float   
)
void G4OpenInventorXtExaminerViewer::createViewerButtons ( Widget  parent,
SbPList *  buttonlist 
)
protectedvirtual

Definition at line 687 of file G4OpenInventorXtExaminerViewer.cc.

689 {
690  int n;
691  Arg args[6];
692  Widget saveViewPtButton, abbrOutputButton, pickRefPathButton;
693  Widget switchWireFrameButton;
694 
695  // Create original buttons
696  SoXtExaminerViewer::createViewerButtons(parent, buttonlist);
697 
698  // Handle disappearing button caused by SoXtExaminerViewer::setCamera
699  Widget emptyButton = XtVaCreateManagedWidget("", xmPushButtonWidgetClass,
700  parent, NULL);
701  buttonlist->append(emptyButton);
702 
703  // Left arrow that goes back one view point on click
704  n = 0;
705  XtSetArg(args[n], XmNtopPosition, 1); n++;
706  XtSetArg(args[n], XmNbottomPosition, 2); n++;
707  XtSetArg(args[n], XmNleftPosition, 0); n++;
708  XtSetArg(args[n], XmNrightPosition, 1); n++;
709  XtSetArg(args[n], XmNarrowDirection, XmARROW_LEFT); n++;
710  XtSetArg(args[n], XmNsensitive, False); n++;
711  prevViewPtButton = XmCreateArrowButtonGadget(parent, (char *) "ArrowL",
712  args, n);
713  XtManageChild(prevViewPtButton);
714  XtAddCallback(prevViewPtButton, XmNactivateCallback,
715  G4OpenInventorXtExaminerViewer::prevViewPtCB, this);
716  buttonlist->append(prevViewPtButton);
717 
718  // Right arrow that goes forward one view point on click
719  n = 0;
720  XtSetArg(args[n], XmNtopPosition, 1); n++;
721  XtSetArg(args[n], XmNbottomPosition, 2); n++;
722  XtSetArg(args[n], XmNleftPosition, 0); n++;
723  XtSetArg(args[n], XmNrightPosition, 1); n++;
724  XtSetArg(args[n], XmNarrowDirection, XmARROW_RIGHT); n++;
725  XtSetArg(args[n], XmNsensitive, False); n++;
726  nextViewPtButton = XmCreateArrowButtonGadget(parent, (char *) "ArrowR",
727  args, n);
728  XtManageChild(nextViewPtButton);
729  XtAddCallback(nextViewPtButton, XmNactivateCallback,
730  G4OpenInventorXtExaminerViewer::nextViewPtCB, this);
731  buttonlist->append(nextViewPtButton);
732 
733  // Save button for storing current camera parameters
734  saveViewPtButton = XtVaCreateManagedWidget("Save", xmPushButtonWidgetClass,
735  parent, NULL);
736  XtAddCallback(saveViewPtButton, XmNactivateCallback,
737  G4OpenInventorXtExaminerViewer::saveViewPtCB, this);
738  Pixmap saveVP, saveVP_ins;
739  saveVP = SoXtInternal::createPixmapFromXpm(saveViewPtButton,
740  saveViewPt_xpm);
741  saveVP_ins = SoXtInternal::createPixmapFromXpm(saveViewPtButton,
742  saveViewPt_xpm, TRUE);
743  XtVaSetValues(saveViewPtButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
744  saveVP, XmNselectPixmap, saveVP, XmNlabelInsensitivePixmap,
745  saveVP_ins, XmNselectInsensitivePixmap, saveVP_ins, NULL);
746  buttonlist->append(saveViewPtButton);
747 
748  // Toggle button to get abbreviated output
749  abbrOutputButton = XtVaCreateManagedWidget("Abbr",
750  xmToggleButtonWidgetClass, parent, XmNindicatorOn, False, NULL);
751  XtAddCallback(abbrOutputButton, XmNdisarmCallback, G4OpenInventorXtExaminerViewer::abbrOutputCB,
752  this);
753  Pixmap pickextxpm, pickextxpm_ins;
754  pickextxpm = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
755  pickext_xpm);
756  pickextxpm_ins = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
757  pickext_xpm, TRUE);
758  XtVaSetValues(abbrOutputButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
759  pickextxpm, XmNselectPixmap, pickextxpm, XmNlabelInsensitivePixmap,
760  pickextxpm_ins, XmNselectInsensitivePixmap, pickextxpm_ins, NULL);
761  // Pixmap consolexpm, consolexpm_ins;
762  // consolexpm = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
763  // console_xpm);
764  // consolexpm_ins = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
765  // console_xpm, TRUE);
766  // XtVaSetValues(abbrOutputButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
767  // consolexpm, XmNselectPixmap, consolexpm, XmNlabelInsensitivePixmap,
768  // consolexpm_ins, XmNselectInsensitivePixmap, consolexpm_ins, NULL);
769  buttonlist->append(abbrOutputButton);
770 
771  // Button for selecting the beam that will act as reference path
772  pickRefPathButton = XtVaCreateManagedWidget("Refpath", xmPushButtonWidgetClass,
773  parent, NULL);
774  XtAddCallback(pickRefPathButton, XmNactivateCallback,
775  G4OpenInventorXtExaminerViewer::pickRefPathCB, this);
776  Pixmap pickrefxpm, pickrefxpm_ins;
777  pickrefxpm = SoXtInternal::createPixmapFromXpm(pickRefPathButton,
778  pickref_xpm);
779  pickrefxpm_ins = SoXtInternal::createPixmapFromXpm(pickRefPathButton,
780  pickref_xpm, TRUE);
781  XtVaSetValues(pickRefPathButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
782  pickrefxpm, XmNselectPixmap, pickrefxpm, XmNlabelInsensitivePixmap,
783  pickrefxpm_ins, XmNselectInsensitivePixmap, pickrefxpm_ins, NULL);
784 
785  buttonlist->append(pickRefPathButton);
786 
787  // Toggle button for switching in and out of wireframe mode
788  switchWireFrameButton = XtVaCreateManagedWidget("Wireframe",
789  xmToggleButtonWidgetClass, parent, XmNindicatorOn, False, NULL);
790  XtAddCallback(switchWireFrameButton, XmNvalueChangedCallback,
791  G4OpenInventorXtExaminerViewer::switchWireFrameCB, this);
792  Pixmap wireframe, wireframe_ins;
793  wireframe = SoXtInternal::createPixmapFromXpm(switchWireFrameButton,
794  wireframe_xpm);
795  wireframe_ins = SoXtInternal::createPixmapFromXpm(switchWireFrameButton,
796  wireframe_xpm, TRUE);
797  XtVaSetValues(switchWireFrameButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
798  wireframe, XmNselectPixmap, wireframe, XmNlabelInsensitivePixmap,
799  wireframe_ins, XmNselectInsensitivePixmap, wireframe_ins, NULL);
800  buttonlist->append(switchWireFrameButton);
801 }
pickext_xpm
static const char * pickext_xpm[]
Definition: pickext.h:5
wireframe_xpm
static const char * wireframe_xpm[]
Definition: wireframe.h:5
pickref_xpm
static const char * pickref_xpm[]
Definition: pickref.h:5
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)
saveViewPt_xpm
static const char * saveViewPt_xpm[]
Definition: saveViewPt.h:5

Here is the call graph for this function:

Widget G4OpenInventorXtExaminerViewer::getMenu ( )
inline

Definition at line 99 of file G4OpenInventorXtExaminerViewer.hh.

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

Definition at line 98 of file G4OpenInventorXtExaminerViewer.hh.

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

Definition at line 3477 of file G4OpenInventorXtExaminerViewer.cc.

3478 {
3479  bool error = false;
3480  viewPtData tmp;
3481  std::string token;
3482  SbVec3f axis;
3483  SbRotation orient;
3484  float x, y, z, angle;
3485 
3486  // Gets the last view point accessed, stored in the first line of the data file.
3487  fileIn >> token;
3488  parseString<int>(viewPtIdx, token, error);
3489  getline(fileIn, token); // Remove "\n"
3490  // Converts data from string type into necessary types
3491  while (getline(fileIn, token)) {
3492 
3493  int end = token.find_last_not_of(' '); // Remove padded spaces
3494  token = token.substr(0, end + 1);
3495 
3496  char *vpName = new char[token.size() + 1];
3497  strcpy(vpName, token.c_str());
3498  tmp.viewPtName = vpName;
3499  fileIn >> token;
3500 
3501  parseString<float>(x, token, error);
3502  fileIn >> token;
3503  parseString<float>(y, token, error);
3504  fileIn >> token;
3505  parseString<float>(z, token, error);
3506  fileIn >> token;
3507  tmp.position = axis.setValue(x, y, z);
3508 
3509  parseString<float>(x, token, error);
3510  fileIn >> token;
3511  parseString<float>(y, token, error);
3512  fileIn >> token;
3513  parseString<float>(z, token, error);
3514  fileIn >> token;
3515  parseString<float>(angle, token, error);
3516  fileIn >> token;
3517  orient.setValue(axis.setValue(x, y, z), angle);
3518  tmp.orientation = orient.getValue();
3519 
3520  int camType;
3521  parseString<int>(camType, token, error);
3522  fileIn >> token;
3523  tmp.camType = (CameraType) camType;
3524 
3525  parseString<float>(tmp.height, token, error);
3526  fileIn >> token;
3527  parseString<float>(tmp.focalDistance, token, error);
3528  fileIn >> token;
3529  parseString<float>(tmp.nearDistance, token, error);
3530  fileIn >> token;
3531  parseString<float>(tmp.farDistance, token, error);
3532  fileIn >> token;
3533  parseString<int>(tmp.viewportMapping, token, error);
3534  fileIn >> token;
3535  parseString<float>(tmp.aspectRatio, token, error);
3536 
3537  getline(fileIn, token); // To remove "\n" characters
3538  getline(fileIn, token);
3539 
3540  if (error) {
3541  viewPtIdx = 0;
3542  viewPtList.clear();
3543  return false;
3544  }
3545  viewPtList.push_back(tmp);
3546  }
3547 
3548  return true;
3549 }
angle
static G4double angle[DIM]
Definition: G4ScreeningMottCrossSection.cc:80
test.x
tuple x
Definition: test.py:50
test.z
tuple z
Definition: test.py:28
error
static PROLOG_HANDLER error
Definition: xmlrole.cc:112

Here is the caller graph for this function:

void G4OpenInventorXtExaminerViewer::moveCamera ( float  dist = 0,
bool  lookdown = false 
)
protected

Definition at line 926 of file G4OpenInventorXtExaminerViewer.cc.

927 {
928 
929  SoCamera *cam = getCamera();
930  SbVec3f p1, p2; // The particle moves from p1 to p2
931  SbVec3f particleDir; // Direction vector from p1 to p2
932  SbVec3f camPosNew; // New position of the camera
933 
934  if(refParticleTrajectory.size() == 0) {
935  //refParticleTrajectory hasn't been set yet
936  if(dist)
937  distance = dist;
938  else
939  distance = (cam->position.getValue() - center).length();
940 
941  cam->position.setValue(center + offsetFromCenter*distance);
942  cam->focalDistance = (cam->position.getValue() - center).length();
943  cam->pointAt(center, upVector);
944  }
945  else{
946 
947  // If we move forward past the last trajectory point,
948  // go back to the beginning
949  if (refParticleIdx >= (int) refParticleTrajectory.size() - 1) {
950  prevPt = refParticleTrajectory[refParticleIdx - step];
951  dist = (prevPt - cam->position.getValue()).length();
952  refParticleIdx = 0;
953  }
954  // If we move backward past the beginning,
955  // go to the last trajectory point
956  if (refParticleIdx < 0) {
957  prevPt = refParticleTrajectory[refParticleIdx + step];
958  dist = (prevPt - cam->position.getValue()).length();
959  refParticleIdx = refParticleTrajectory.size() - 2;
960  }
961 
962  // Set start and end points
963  p1 = refParticleTrajectory[refParticleIdx];
964  p2 = refParticleTrajectory[refParticleIdx + step];
965 
966  // Get the direction from p1 to p2
967  particleDir = p2 - p1;
968  particleDir.normalize();
969 
970  if(prevParticleDir == SbVec3f(0,0,0)){
971  // First time entering BEAMLINE mode, look at
972  // the element from the front, with camera upright
973  if(lookdown)
974  camDir = SbVec3f(0,0,1);
975  else
976  camDir = SbVec3f(1,0,0);
977  camUpVec = SbVec3f(0,1,0);
978 
979  // In case the start of the goes in a
980  // direction other than +z, rotate the camera accordingly
981  SbRotation rot(SbVec3f(0,0,1), particleDir);
982  rot.multVec(camDir, camDir);
983  rot.multVec(camUpVec, camUpVec);
984 
985  }
986  else if(particleDir != prevParticleDir) {
987  // The beamline has changed direction
988 
989  SbRotation rot(prevParticleDir, particleDir);
990  rot.multVec(camDir, camDir);
991  rot.multVec(camUpVec, camUpVec);
992 
993  }
994 
995  if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
996  if (!dist)
997  distance = (prevPt - cam->position.getValue()).length();
998  else
999  distance = dist;
1000  }
1001 
1002  if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
1003  if (!dist)
1004  distance = (prevPt - cam->position.getValue()).length();
1005  else
1006  distance = dist;
1007  }
1008 
1009 
1010  float x,y,z;
1011  prevPt.getValue(x,y,z);
1012 
1013 
1014  if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
1015  camPosNew = p2 - (camDir*distance);
1016  }
1017  if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
1018  camPosNew = p2 - (camDir);
1019  }
1020 
1021  cam->position = camPosNew;
1022  cam->pointAt(p2, camUpVec);
1023  // FWJ Disabled: zooms out the Persp camera much too far
1024  // and can't recover by zooming in!
1025  // cam->focalDistance = (p2 - camPosNew).length();
1026 
1027  p2.getValue(x,y,z);
1028  camPosNew.getValue(x,y,z);
1029 
1030  prevParticleDir = particleDir;
1031  prevPt = p1; // For accurate distance calculation
1032 
1033  }
1034 
1035 }
test.x
tuple x
Definition: test.py:50
test.z
tuple z
Definition: test.py:28

Here is the caller graph for this function:

template<class T >
void G4OpenInventorXtExaminerViewer::parseString ( T &  t,
const std::string &  s,
bool &  error 
)

Definition at line 3555 of file G4OpenInventorXtExaminerViewer.cc.

3557 {
3558  std::istringstream str(s);
3559  if ((str >> t).fail())
3560  error = true;
3561 }
s
const XML_Char * s
Definition: expat.h:262
error
static PROLOG_HANDLER error
Definition: xmlrole.cc:112
SbBool G4OpenInventorXtExaminerViewer::processSoEvent ( const SoEvent *const  event)
protectedvirtual

Definition at line 1376 of file G4OpenInventorXtExaminerViewer.cc.

1376  {
1377  SoCamera *cam = getCamera();
1378  const SoType type(ev->getTypeId());
1379 
1380  if (type.isDerivedFrom(SoMouseButtonEvent::getClassTypeId())) {
1381  SoMouseButtonEvent * me = (SoMouseButtonEvent *) ev;
1382 
1383  if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
1384  || currentState == PAUSED_ANIMATION) {
1385  switch (me->getButton()) {
1386  case SoMouseButtonEvent::BUTTON4: // Scroll wheel up
1387  if (me->getState() == SoButtonEvent::DOWN) {
1388  if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
1389  float hAngle =
1390  ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
1391  ((SoPerspectiveCamera *) cam)->heightAngle = hAngle
1392  + 0.01f;
1393  return TRUE;
1394  } else if (cam->isOfType(
1395  SoOrthographicCamera::getClassTypeId())) {
1396  float height =
1397  ((SoOrthographicCamera *) cam)->height.getValue();
1398  ((SoOrthographicCamera *) cam)->height = height + 5;
1399  return TRUE;
1400  }
1401  }
1402  break;
1403  case SoMouseButtonEvent::BUTTON5: // Scroll wheel down
1404  if (me->getState() == SoButtonEvent::DOWN) {
1405  if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
1406  float hAngle =
1407  ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
1408  if (hAngle > 0.01)
1409  ((SoPerspectiveCamera *) cam)->heightAngle = hAngle
1410  - 0.01f;
1411  return TRUE;
1412  } else if (cam->isOfType(
1413  SoOrthographicCamera::getClassTypeId())) {
1414  float height =
1415  ((SoOrthographicCamera *) cam)->height.getValue();
1416  if (height > 5)
1417  ((SoOrthographicCamera *) cam)->height = height - 5;
1418  return TRUE;
1419  }
1420  }
1421  break;
1422  default:
1423  break;
1424  }
1425  }
1426  if (currentState == GENERAL) {
1427 
1428  }
1429  }
1430 
1431  if (type.isDerivedFrom(SoKeyboardEvent::getClassTypeId())) {
1432  SoKeyboardEvent * ke = (SoKeyboardEvent *) ev;
1433 
1434  if (SoKeyboardEvent::isKeyPressEvent(ev, ke->getKey())) {
1435  switch (ke->getKey()) {
1436  case SoKeyboardEvent::LEFT_SHIFT:
1437  this->lshiftdown = true;
1438  return TRUE;
1439  case SoKeyboardEvent::RIGHT_SHIFT:
1440  this->rshiftdown = true;
1441  return TRUE;
1442  case SoKeyboardEvent::LEFT_CONTROL:
1443  this->lctrldown = true;
1444  return TRUE;
1445  case SoKeyboardEvent::RIGHT_CONTROL:
1446  this->rctrldown = true;
1447  return TRUE;
1448  case SoKeyboardEvent::SPACE:
1449  if (currentState == ANIMATION
1450  || currentState == REVERSED_ANIMATION) {
1451  beforePausing = currentState;
1452  currentState = PAUSED_ANIMATION;
1453  if (animateSensor->isScheduled())
1454  animateSensor->unschedule();
1455  return TRUE;
1456  } else if (currentState == PAUSED_ANIMATION) {
1457  if (maxSpeed) {
1458  if ((beforePausing == ANIMATION
1459  && refParticleIdx
1460  < (int) refParticleTrajectory.size() - 1)
1461  || (beforePausing == REVERSED_ANIMATION
1462  && refParticleIdx > 0)) {
1463  currentState = beforePausing;
1464  animateRefParticle();
1465  }
1466  }
1467  return TRUE;
1468  }
1469  break;
1470  case SoKeyboardEvent::ESCAPE:
1471  if (currentState == ANIMATION
1472  || currentState == REVERSED_ANIMATION
1473  || currentState == PAUSED_ANIMATION) {
1474 
1475  if (animateSensor->isScheduled())
1476  animateSensor->unschedule();
1477  currentState = prevState;
1478  refParticleIdx = prevRefIdx;
1479  setSuperimpositionEnabled(superimposition, FALSE);
1480  maxSpeed = 0.0f;
1481  step = 1;
1482 
1483  scheduleRedraw();
1484  if (currentState == VIEWPOINT) {
1485  setSuperimpositionEnabled(superimposition, TRUE);
1486  axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
1487  animSpeedOutlineSwitch->whichChild.setValue(
1488  SO_SWITCH_NONE);
1489  animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
1490 
1491  scheduleRedraw();
1492  }
1493  restoreCamera();
1494  return TRUE;
1495  }
1496  break;
1497  case SoKeyboardEvent::DELETE:
1498  if (viewPtList.size()
1499  && (currentState != ANIMATION
1500  || currentState != REVERSED_ANIMATION
1501  || currentState != PAUSED_ANIMATION)) {
1502  String dialogName = (char *) "Delete Viewpoint";
1503  std::string msg = "Are you sure you want to delete current viewpoint?";
1504  warningMsgDialog(msg, dialogName, deleteViewPtCB);
1505  return TRUE;
1506  }
1507  break;
1508  case SoKeyboardEvent::LEFT_ARROW:
1509  switch (currentState) {
1510  case BEAMLINE:
1511  if ((this->lshiftdown) || (this->rshiftdown)){
1512  refParticleIdx -= step;
1513  moveCamera();
1514  }
1515  else if ((this->lctrldown) || (this->rctrldown)){
1516  if (SoXtExaminerViewer::isAnimating())
1517  stopAnimating();
1518  prevState = currentState;
1519  currentState = ROTATING;
1520  animateBtwPtsPeriod = 0.08f;
1521 
1522  SbVec3f tmp = camDir;
1523  tmp.negate();
1524  rotAxis = tmp;
1525 
1526  rotCnt = ROT_CNT;
1527  moveCamera(); // To make sure camera is perpendicular to the beamline
1528 
1529  rotateCamera();
1530  }
1531  else{
1532  if (SoXtExaminerViewer::isAnimating())
1533  stopAnimating();
1534  prevState = currentState;
1535  currentState = ROTATING;
1536  animateBtwPtsPeriod = 0.08f;
1537 
1538  SbVec3f tmp = camUpVec;
1539  tmp.negate();
1540  rotAxis = tmp;
1541 
1542  rotCnt = ROT_CNT;
1543  moveCamera(); // To make sure camera is perpendicular to the beamline
1544 
1545  rotateCamera();
1546 
1547  }
1548  return TRUE;
1549 
1550  case ANIMATION:
1551  case REVERSED_ANIMATION:
1552  left_right -= 1.5f;
1553  return TRUE;
1554  case PAUSED_ANIMATION:
1555  left_right -= 1.5f;
1556  setStartingPtForAnimation();
1557  cam->position = myCam->position;
1558  return TRUE;
1559  case GENERAL:
1560  case VIEWPOINT:
1561  if ((!this->lshiftdown) && (!this->rshiftdown)) {
1562  // Using this allows us to look around without
1563  // changing the camera parameters (camDir, camUpVec)
1564  this->bottomWheelMotion(
1565  this->getBottomWheelValue() + 0.1f);
1566 
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::RIGHT_ARROW:
1582  switch(currentState){
1583  case BEAMLINE:
1584  if ((this->lshiftdown) || (this->rshiftdown)){
1585  refParticleIdx += step;
1586  moveCamera();
1587  }
1588  else if ((this->lctrldown) || (this->rctrldown)){
1589  if (SoXtExaminerViewer::isAnimating())
1590  stopAnimating();
1591  prevState = currentState;
1592  currentState = ROTATING;
1593  animateBtwPtsPeriod = 0.08f;
1594 
1595  rotAxis = camDir;
1596 
1597  rotCnt = ROT_CNT;
1598  moveCamera(); // To make sure camera is perpendicular to the beamline
1599 
1600  rotateCamera();
1601  }
1602  else{
1603  if (SoXtExaminerViewer::isAnimating())
1604  stopAnimating();
1605  prevState = currentState;
1606  currentState = ROTATING;
1607  animateBtwPtsPeriod = 0.08f;
1608 
1609  rotAxis = camUpVec;
1610 
1611  rotCnt = ROT_CNT;
1612  moveCamera(); // To make sure camera is perpendicular to the beamline
1613 
1614  rotateCamera();
1615  }
1616  return TRUE;
1617 
1618  case ANIMATION:
1619  case REVERSED_ANIMATION:
1620  left_right += 1.5f;
1621  return TRUE;
1622  case PAUSED_ANIMATION:
1623  left_right += 1.5f;
1624  setStartingPtForAnimation();
1625  cam->position = myCam->position;
1626  return TRUE;
1627  case GENERAL:
1628  case VIEWPOINT:
1629  if ((!this->lshiftdown) && (!this->rshiftdown)) {
1630  // Using this allows us to look around without
1631  // changing the camera parameters (camDir, camUpVec)
1632  this->bottomWheelMotion(
1633  this->getBottomWheelValue() - 0.1f);
1634  return TRUE;
1635  }
1636  break;
1637  case ROTATING:
1638  // For this state, let the keyboard event
1639  // be handled by superclass
1640  break;
1641  default:
1642  SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
1643  "Unhandled viewer state");
1644  break;
1645  }
1646  break;
1647 
1648  case SoKeyboardEvent::DOWN_ARROW:
1649  switch(currentState){
1650  case BEAMLINE:
1651 
1652  if ((this->lshiftdown) || (this->rshiftdown)){
1653  refParticleIdx -= step;
1654  moveCamera();
1655  }
1656  else{
1657  if (SoXtExaminerViewer::isAnimating())
1658  stopAnimating();
1659  prevState = currentState;
1660  currentState = ROTATING;
1661  animateBtwPtsPeriod = 0.08f;
1662 
1663  rotAxis = camDir.cross(camUpVec);
1664 
1665  rotCnt = ROT_CNT;
1666  moveCamera(); // To make sure camera is perpendicular to the beamline
1667 
1668  rotateCamera();
1669 
1670  }
1671  return TRUE;
1672 
1673  case ANIMATION:
1674  case REVERSED_ANIMATION:
1675  up_down -= 1.5f;
1676  return TRUE;
1677  case PAUSED_ANIMATION:
1678  up_down -= 1.5f;
1679  setStartingPtForAnimation();
1680  cam->position = myCam->position;
1681  return TRUE;
1682  case GENERAL:
1683  case VIEWPOINT:
1684  // Using this allows us to look around without
1685  // changing the camera parameters (camDir, camUpVec)
1686  if ((!this->lshiftdown) && (!this->rshiftdown)) {
1687  this->leftWheelMotion(this->getLeftWheelValue() - 0.1f);
1688  return TRUE;
1689  }
1690  break;
1691  case ROTATING:
1692  // For this state, let the keyboard event
1693  // be handled by superclass
1694  break;
1695  default:
1696  SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
1697  "Unhandled viewer state");
1698  break;
1699  }
1700  break;
1701 
1702  case SoKeyboardEvent::UP_ARROW:
1703  switch(currentState){
1704  case BEAMLINE:
1705  if ((this->lshiftdown) || (this->rshiftdown)){
1706  refParticleIdx -= step;
1707  moveCamera();
1708  }
1709  else{
1710  if (SoXtExaminerViewer::isAnimating())
1711  stopAnimating();
1712  prevState = currentState;
1713  currentState = ROTATING;
1714  animateBtwPtsPeriod = 0.08f;
1715 
1716  rotAxis = camUpVec.cross(camDir);
1717 
1718  rotCnt = ROT_CNT;
1719  moveCamera();
1720 
1721  rotateCamera();
1722 
1723 
1724  }
1725  return TRUE;
1726  case ANIMATION:
1727  case REVERSED_ANIMATION:
1728  up_down += 1.5f;
1729  return TRUE;
1730  case PAUSED_ANIMATION:
1731  up_down += 1.5f;
1732  setStartingPtForAnimation();
1733  cam->position = myCam->position;
1734  return TRUE;
1735  case GENERAL:
1736  case VIEWPOINT:
1737  // Using this allows us to look around without
1738  // changing the camera parameters (camDir, camUpVec)
1739  if ((!this->lshiftdown) && (!this->rshiftdown)) {
1740  this->leftWheelMotion(this->getLeftWheelValue() + 0.1f);
1741  return TRUE;
1742  }
1743  break;
1744  case ROTATING:
1745  // For this state, let the keyboard event
1746  // be handled by superclass
1747  break;
1748  default:
1749  SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
1750  "Unhandled viewer state");
1751  break;
1752  }
1753  break;
1754 
1755  case SoKeyboardEvent::PAGE_UP:
1756  switch(currentState){
1757  case BEAMLINE:
1758  if (step < (int) refParticleTrajectory.size() / 5) // Magic number
1759  step++;
1760  return TRUE;
1761  case ANIMATION:
1762  incSpeed();
1763  maxSpeed += SPEED_INDICATOR_STEP;
1764  if (maxSpeed > 0.8)
1765  maxSpeed = MAX_SPEED_INDICATOR;
1766  scheduleRedraw();
1767 
1768  return TRUE;
1769  case REVERSED_ANIMATION:
1770  if(!animateSensor->isScheduled()){
1771  currentState = ANIMATION;
1772  if (refParticleIdx
1773  < (int) refParticleTrajectory.size() - 1) {
1774  refParticleIdx++;
1775  maxSpeed = SPEED_INDICATOR_STEP;
1776  scheduleRedraw();
1777  animateRefParticle();
1778  }
1779  }
1780  else{
1781  maxSpeed += SPEED_INDICATOR_STEP;
1782  decSpeed();
1783  scheduleRedraw();
1784  }
1785  return TRUE;
1786  case PAUSED_ANIMATION:
1787  maxSpeed += SPEED_INDICATOR_STEP;
1788  if (maxSpeed > 0.8)
1789  maxSpeed = MAX_SPEED_INDICATOR;
1790 
1791  if (beforePausing == ANIMATION) {
1792  incSpeed();
1793  } else {
1794  decSpeed();
1795  if (animateBtwPtsPeriod >= MIN_SPEED)
1796  beforePausing = ANIMATION;
1797  }
1798 
1799  scheduleRedraw();
1800  return TRUE;
1801  default: //fall through
1802  break;
1803  }
1804  break;
1805 
1806  case SoKeyboardEvent::PAGE_DOWN:
1807  switch(currentState){
1808  case BEAMLINE:
1809  if (step > 1)
1810  step--;
1811  return TRUE;
1812  case ANIMATION:
1813  if(!animateSensor->isScheduled()){
1814  currentState = REVERSED_ANIMATION;
1815  if (refParticleIdx > 1) {
1816  refParticleIdx--;
1817  maxSpeed = -SPEED_INDICATOR_STEP;
1818  scheduleRedraw();
1819  animateRefParticle();
1820  }
1821  }
1822  else{
1823  maxSpeed -= SPEED_INDICATOR_STEP;
1824  decSpeed();
1825  scheduleRedraw();
1826  }
1827  return TRUE;
1828  case REVERSED_ANIMATION:
1829  incSpeed();
1830  maxSpeed -= SPEED_INDICATOR_STEP;
1831  if (maxSpeed < -0.8)
1832  maxSpeed = -MAX_SPEED_INDICATOR;
1833  scheduleRedraw();
1834  return TRUE;
1835  case PAUSED_ANIMATION:
1836  maxSpeed -= SPEED_INDICATOR_STEP;
1837  if (maxSpeed < -0.8)
1838  maxSpeed = -MAX_SPEED_INDICATOR;
1839  if (beforePausing == REVERSED_ANIMATION) {
1840  incSpeed();
1841  } else {
1842  decSpeed();
1843  if (animateBtwPtsPeriod >= MIN_SPEED)
1844  beforePausing = REVERSED_ANIMATION;
1845  }
1846  scheduleRedraw();
1847  return TRUE;
1848  default:
1849  //fall through
1850  break;
1851  }
1852  break;
1853 
1854  case SoKeyboardEvent::E:
1855  this->escapeCallback(this->examinerObject);
1856  break;
1857 
1858  default:
1859  break; // To get rid of compiler warnings
1860  }
1861  }
1862  if (SoKeyboardEvent::isKeyReleaseEvent(ev, ke->getKey())) {
1863  switch (ke->getKey()) {
1864  case SoKeyboardEvent::LEFT_SHIFT:
1865  this->lshiftdown = false;
1866  return TRUE;
1867  case SoKeyboardEvent::RIGHT_SHIFT:
1868  this->rshiftdown = false;
1869  return TRUE;
1870  case SoKeyboardEvent::LEFT_CONTROL:
1871  this->lctrldown = false;
1872  return TRUE;
1873  case SoKeyboardEvent::RIGHT_CONTROL:
1874  this->rctrldown = false;
1875  return TRUE;
1876  default:
1877  break;
1878  }
1879  }
1880  }
1881 
1882  if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
1883  || currentState == ROTATING)
1884  return FALSE;
1885  else
1886  return SoXtExaminerViewer::processSoEvent(ev);
1887 }
SPEED_INDICATOR_STEP
#define SPEED_INDICATOR_STEP
Definition: G4OpenInventorXtExaminerViewer.cc:124
ROT_CNT
#define ROT_CNT
Definition: G4OpenInventorXtExaminerViewer.cc:127
MIN_SPEED
#define MIN_SPEED
Definition: G4OpenInventorXtExaminerViewer.cc:122
G4OpenInventorXtExaminerViewer::moveCamera
void moveCamera(float dist=0, bool lookdown=false)
Definition: G4OpenInventorXtExaminerViewer.cc:926
G4OpenInventorXtExaminerViewer::warningMsgDialog
void warningMsgDialog(std::string, String, XtCallbackProc)
Definition: G4OpenInventorXtExaminerViewer.cc:3740
FALSE
#define FALSE
Definition: globals.hh:52
TRUE
#define TRUE
Definition: globals.hh:55
MAX_SPEED_INDICATOR
#define MAX_SPEED_INDICATOR
Definition: G4OpenInventorXtExaminerViewer.cc:125

Here is the call graph for this function:

void G4OpenInventorXtExaminerViewer::rotateCamera ( )
protected

Definition at line 899 of file G4OpenInventorXtExaminerViewer.cc.

900 {
901  SoCamera *cam = getCamera();
902 
903  SbRotation rot(rotAxis, M_PI / (2 * ROT_CNT));
904  rot.multVec(camDir, camDir);
905  rot.multVec(camUpVec, camUpVec);
906 
907  SbVec3f camPosNew = prevPt - (camDir*distance);
908  cam->position = camPosNew;
909  cam->pointAt(prevPt, camUpVec);
910  cam->focalDistance = (prevPt - camPosNew).length();
911 
912  rotCnt--;
913 
914  if (animateSensorRotation->isScheduled()) {
915  animateSensorRotation->unschedule();
916  }
917 
918  animateSensorRotation->setBaseTime(SbTime::getTimeOfDay());
919  animateSensorRotation->setInterval(SbTime(0.02));
920  animateSensorRotation->schedule();
921 
922 }
M_PI
#define M_PI
Definition: SbMath.h:34
ROT_CNT
#define ROT_CNT
Definition: G4OpenInventorXtExaminerViewer.cc:127

Here is the caller graph for this function:

void G4OpenInventorXtExaminerViewer::updateViewParams ( SoKeyboardEvent::Key  )
protected
void G4OpenInventorXtExaminerViewer::warningMsgDialog ( std::string  msg,
String  dialogName,
XtCallbackProc  cb 
)

Definition at line 3740 of file G4OpenInventorXtExaminerViewer.cc.

3743 {
3744  Arg args[5];
3745  unsigned int n;
3746  XmString warningMsg;
3747 
3748  warningMsg = XmStringCreateLocalized((char *)msg.c_str());
3749 
3750  n = 0;
3751  XtSetArg(args[n], XmNmessageString, warningMsg); n++;
3752  Widget warningDialog = XmCreateWarningDialog(getParentWidget(), dialogName, args, n);
3753  if (cb)
3754  XtAddCallback(warningDialog, XmNokCallback, cb, this);
3755 
3756  XmStringFree(warningMsg);
3757 
3758  XtVaSetValues (warningDialog, XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL, NULL);
3759  XtUnmanageChild(XtNameToWidget(warningDialog, "Help"));
3760  XtUnmanageChild(XtNameToWidget(warningDialog, "Cancel"));
3761 
3762  XtManageChild(warningDialog);
3763 }
n
const G4int n
Definition: G4UrQMD1_3Interface.hh:144

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class G4OpenInventorXtExaminerViewerMessenger
friend

Definition at line 67 of file G4OpenInventorXtExaminerViewer.hh.

friend class G4OpenInventorXtExtendedViewer
friend

Definition at line 69 of file G4OpenInventorXtExaminerViewer.hh.

friend class HookEventProcState
friend

Definition at line 148 of file G4OpenInventorXtExaminerViewer.hh.

Member Data Documentation

bool G4OpenInventorXtExaminerViewer::abbrOutputFlag

Definition at line 110 of file G4OpenInventorXtExaminerViewer.hh.

SbVec3f G4OpenInventorXtExaminerViewer::camDir
protected

Definition at line 134 of file G4OpenInventorXtExaminerViewer.hh.

SbVec3f G4OpenInventorXtExaminerViewer::camUpVec
protected

Definition at line 133 of file G4OpenInventorXtExaminerViewer.hh.

std::string G4OpenInventorXtExaminerViewer::curEltName
protected

Definition at line 132 of file G4OpenInventorXtExaminerViewer.hh.

bool G4OpenInventorXtExaminerViewer::pickRefPathFlag

Definition at line 111 of file G4OpenInventorXtExaminerViewer.hh.

std::string G4OpenInventorXtExaminerViewer::saveRefCoordsFileName

Definition at line 105 of file G4OpenInventorXtExaminerViewer.hh.

Widget G4OpenInventorXtExaminerViewer::saveRefCoordsWidget

Definition at line 106 of file G4OpenInventorXtExaminerViewer.hh.

std::string G4OpenInventorXtExaminerViewer::saveScenegraphFileName

Definition at line 103 of file G4OpenInventorXtExaminerViewer.hh.

Widget G4OpenInventorXtExaminerViewer::saveScenegraphWidget

Definition at line 104 of file G4OpenInventorXtExaminerViewer.hh.

bool G4OpenInventorXtExaminerViewer::viewingBeforePickRef

Definition at line 112 of file G4OpenInventorXtExaminerViewer.hh.

bool G4OpenInventorXtExaminerViewer::warningFlag

Definition at line 101 of file G4OpenInventorXtExaminerViewer.hh.

The documentation for this class was generated from the following files: