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

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() [1/2]

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.

                                                           :
   SoXtExaminerViewer(parent, name, embed, flag, type, FALSE)
{
// Tell GLWidget not to build just yet
   this->constructor(TRUE);
}

◆ ~G4OpenInventorXtExaminerViewer()

G4OpenInventorXtExaminerViewer::~G4OpenInventorXtExaminerViewer ( )

Definition at line 586 of file G4OpenInventorXtExaminerViewer.cc.

{
   if (superimposition != NULL) {
      removeSuperimposition(superimposition);
      superimposition->unref();
      superimposition = NULL;
   }
   if (animateSensor->isScheduled())
      animateSensor->unschedule();
   delete animateSensor;
   delete sceneChangeSensor;
 
   delete[] curViewPtName;
   delete searcher;
 
   viewer = 0;
}

◆ G4OpenInventorXtExaminerViewer() [2/2]

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.

                              :
   SoXtExaminerViewer(parent, name, embed, flag, type, FALSE)
{
   this->constructor(build);
}

Member Function Documentation

◆ addButton()

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

Definition at line 677 of file G4OpenInventorXtExaminerViewer.cc.

{
   Widget button = XmCreatePushButton(menu, (char *) name.c_str(), NULL, 0);
   XtManageChild(button);
   XtAddCallback(button, XmNactivateCallback, cb, this);
}

Referenced by buildWidget().

◆ addEscapeCallback()

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

Definition at line 4905 of file G4OpenInventorXtExaminerViewer.cc.

{
   this->escapeCallback = callback;
   this->examinerObject = object;
}

Referenced by G4OpenInventorXtExtendedViewer::Initialise().

◆ addMenu()

Widget G4OpenInventorXtExaminerViewer::addMenu ( std::string name )

Definition at line 663 of file G4OpenInventorXtExaminerViewer.cc.

{
   Arg args[1];
   Widget menu = XmCreatePulldownMenu(menuBar, (char *) name.c_str(), NULL, 0);
 
   XtSetArg(args[0], XmNsubMenuId, menu);
   Widget w = XmCreateCascadeButton(menuBar, (char *) name.c_str(), args, 1);
   XtManageChild(w);
 
   return menu;
}

Referenced by buildWidget().

◆ afterRealizeHook()

void G4OpenInventorXtExaminerViewer::afterRealizeHook ( )

protectedvirtual

Definition at line 806 of file G4OpenInventorXtExaminerViewer.cc.

{
   SoXtExaminerViewer::afterRealizeHook();
 
   // Default height is used when selecting and viewing scene elements
   // FWJ Added defaultHeight for Ortho camera
   SoCamera *cam = getCamera();
   if (cam) {
      if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
         defaultHeightAngle =
            ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
         toggleCameraType();
         defaultHeight =
            ((SoOrthographicCamera *) cam)->height.getValue();
         toggleCameraType();
      } else {
         defaultHeight =
            ((SoOrthographicCamera *) cam)->height.getValue();
         toggleCameraType();
         cam = getCamera();
         if (cam->isOfType(SoPerspectiveCamera::getClassTypeId()))
            defaultHeightAngle =
               ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
         toggleCameraType();
      }
   }
 
   // Open the default bookmark file
   fileIn.open(fileName.c_str());
   if (!fileIn.fail()) {
      if (!loadViewPts()) {
         String dialogName = (char *) "Error Loading File";
         std::string msg = "Wrong or corrupted input file.";
         warningMsgDialog(msg, dialogName, NULL);
      } else {
         // Opens a file without erasing it
         fileOut.open(fileName.c_str(), std::ios::in);
         fileOut.seekp(0, std::ios::end); // For appending new data to the end
         constructListsDialog(getParentWidget(), this, NULL); // Pop up listsDialog
         if (viewPtList.size()) {
            // FWJ disabled auto-selection of first viewpoint.
            // Initial view should be user-controllable & not forced
            //    setViewPt();
            XtSetSensitive(nextViewPtButton, True);
            XtSetSensitive(prevViewPtButton, True);
         }
      }
      fileIn.close();
   } else {
      // Creates a new default bookmark file
      fileOut.open(fileName.c_str());
      constructListsDialog(getParentWidget(), this, NULL); // Pop up listsDialog
   }
 
   fileIn.clear();
 
   SoSeparator *root = (SoSeparator *) (getSceneManager()->getSceneGraph());
   if (root == NULL)
      SoDebugError::post("G4OpenInventorXtExaminerViewer::afterRealizeHook", "Root is null.");
   else {
      root->addChild(myCam); // For position/orientation calculation during animation
   }
 
   sceneChangeSensor = new SoNodeSensor;
   sceneChangeSensor->setFunction(sceneChangeCB);
   sceneChangeSensor->attach(root);
   sceneChangeSensor->setData(this);
 
   // Monitor mouseover events for displaying the name of scene elements
   // An SoEventCallback is needed instead of using the default processSoEvent
   // because that last one does not provide us with an SoPath to the object
   // that was picked
   SoEventCallback *moCB = new SoEventCallback;
   moCB->addEventCallback(
                          SoLocation2Event::getClassTypeId(),
                          mouseoverCB, static_cast<void *>(this));
   root->addChild(moCB);
 
   // Override the default picking mechanism present in G4OpenInventorViewer
   // because we want abbreviated output when picking a trajectory
   SoEventCallback *pickCB = new SoEventCallback;
   pickCB->addEventCallback(
                            SoMouseButtonEvent::getClassTypeId(),
                            pickingCB, static_cast<void *>(this));
   root->addChild(pickCB);
 
}

◆ buildWidget()

Widget G4OpenInventorXtExaminerViewer::buildWidget ( Widget parent )

protected

Definition at line 606 of file G4OpenInventorXtExaminerViewer.cc.

{
   Widget shell;
   Atom WM_DELETE_WINDOW;
 
   if (!parent)
      SoDebugError::post("G4OpenInventorXtExaminerViewer::buildWidget", "Error: Parent is null.");
 
   Arg args[10];
   XtSetArg(args[0], XmNtopAttachment, XmATTACH_FORM);
   XtSetArg(args[1], XmNleftAttachment, XmATTACH_FORM);
   XtSetArg(args[2], XmNrightAttachment, XmATTACH_FORM);
   XtSetArg(args[3], XmNbottomAttachment, XmATTACH_FORM);
   Widget form = XmCreateForm(parent, (char *) "Form", args, 4);
   XtManageChild(form);
 
   shell = XtParent(form);
   WM_DELETE_WINDOW = XInternAtom(XtDisplay(parent), "WM_DELETE_WINDOW",
                                  False);
   XmAddWMProtocolCallback(shell, WM_DELETE_WINDOW,
                           (XtCallbackProc)closeMainWindowCB, this);
 
   XtSetArg(args[0], XmNtopAttachment, XmATTACH_FORM);
   XtSetArg(args[1], XmNleftAttachment, XmATTACH_FORM);
   XtSetArg(args[2], XmNrightAttachment, XmATTACH_FORM);
   menuBar = XmCreateMenuBar(form, (char *) "MenuBar", args, 3);
   XtManageChild(menuBar);
 
   fileMenu = addMenu("File");
   this->addButton(fileMenu, "Open Viewpoint File...", openViewPtFileCB);
   addButton(fileMenu, "New Viewpoint File", newViewPtFileCB);
   addButton(fileMenu, "Load Ref. Coords", loadRefCoordsDialogCB);
   addButton(fileMenu, "Save Ref. Coords", saveRefCoordsDialogCB);
   addButton(fileMenu, "Load Scene Graph", loadSceneGraphDialogCB);
   addButton(fileMenu, "Save Scene Graph", saveSceneGraphDialogCB);
   XtManageChild(
          XmCreateSeparatorGadget(fileMenu, (char *) "Separator", NULL, 0));
 
   Widget menu = addMenu("Tools");
   addButton(menu, "Animate Ref. Particle", animateRefParticleCB);
   addButton(menu, "Go to start of Ref path", gotoRefPathStartCB);
   addButton(menu, "Invert Ref path", invertRefPathCB);
 
   Widget viewerBase = SoXtFullViewer::buildWidget(form);
 
   XtSetArg(args[0], XmNtopAttachment, XmATTACH_WIDGET);
   XtSetArg(args[1], XmNtopWidget, menuBar);
   XtSetArg(args[2], XmNleftAttachment, XmATTACH_FORM);
   XtSetArg(args[3], XmNrightAttachment, XmATTACH_FORM);
   XtSetArg(args[4], XmNbottomAttachment, XmATTACH_FORM);
   XtSetValues(viewerBase, args, 5);
 
   return viewerBase;
}

◆ createScale()

Widget G4OpenInventorXtExaminerViewer::createScale	(	Widget	,
		char *	,
		int	,
		float
	)

◆ createViewerButtons()

void G4OpenInventorXtExaminerViewer::createViewerButtons	(	Widget	parent,
		SbPList *	buttonlist
	)

protectedvirtual

Definition at line 687 of file G4OpenInventorXtExaminerViewer.cc.

{
   int n;
   Arg args[6];
   Widget saveViewPtButton, abbrOutputButton, pickRefPathButton;
   Widget switchWireFrameButton;
 
   // Create original buttons
   SoXtExaminerViewer::createViewerButtons(parent, buttonlist);
 
   // Handle disappearing button caused by SoXtExaminerViewer::setCamera
   Widget emptyButton = XtVaCreateManagedWidget("", xmPushButtonWidgetClass,
                                                parent, NULL);
   buttonlist->append(emptyButton);
 
   // Left arrow that goes back one view point on click
   n = 0;
   XtSetArg(args[n], XmNtopPosition, 1);    n++;
   XtSetArg(args[n], XmNbottomPosition, 2); n++;
   XtSetArg(args[n], XmNleftPosition, 0);   n++;
   XtSetArg(args[n], XmNrightPosition, 1);  n++;
   XtSetArg(args[n], XmNarrowDirection, XmARROW_LEFT);  n++;
   XtSetArg(args[n], XmNsensitive, False);  n++;
   prevViewPtButton = XmCreateArrowButtonGadget(parent, (char *) "ArrowL",
                                                args, n);
   XtManageChild(prevViewPtButton);
   XtAddCallback(prevViewPtButton, XmNactivateCallback,
                 G4OpenInventorXtExaminerViewer::prevViewPtCB, this);
   buttonlist->append(prevViewPtButton);
 
   // Right arrow that goes forward one view point on click
   n = 0;
   XtSetArg(args[n], XmNtopPosition, 1);    n++;
   XtSetArg(args[n], XmNbottomPosition, 2); n++;
   XtSetArg(args[n], XmNleftPosition, 0);   n++;
   XtSetArg(args[n], XmNrightPosition, 1);  n++;
   XtSetArg(args[n], XmNarrowDirection, XmARROW_RIGHT); n++;
   XtSetArg(args[n], XmNsensitive, False);  n++;
   nextViewPtButton = XmCreateArrowButtonGadget(parent, (char *) "ArrowR",
                                                args, n);
   XtManageChild(nextViewPtButton);
   XtAddCallback(nextViewPtButton, XmNactivateCallback,
                 G4OpenInventorXtExaminerViewer::nextViewPtCB, this);
   buttonlist->append(nextViewPtButton);
 
   // Save button for storing current camera parameters
   saveViewPtButton = XtVaCreateManagedWidget("Save", xmPushButtonWidgetClass,
                                              parent, NULL);
   XtAddCallback(saveViewPtButton, XmNactivateCallback,
                 G4OpenInventorXtExaminerViewer::saveViewPtCB, this);
   Pixmap saveVP, saveVP_ins;
   saveVP = SoXtInternal::createPixmapFromXpm(saveViewPtButton,
                                              saveViewPt_xpm);
   saveVP_ins = SoXtInternal::createPixmapFromXpm(saveViewPtButton,
                                                  saveViewPt_xpm, TRUE);
   XtVaSetValues(saveViewPtButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
                 saveVP, XmNselectPixmap, saveVP, XmNlabelInsensitivePixmap,
                 saveVP_ins, XmNselectInsensitivePixmap, saveVP_ins, NULL);
   buttonlist->append(saveViewPtButton);
 
   // Toggle button to get abbreviated output
   abbrOutputButton = XtVaCreateManagedWidget("Abbr",
                                              xmToggleButtonWidgetClass, parent, XmNindicatorOn, False, NULL);
   XtAddCallback(abbrOutputButton, XmNdisarmCallback, G4OpenInventorXtExaminerViewer::abbrOutputCB,
                 this);
   Pixmap pickextxpm, pickextxpm_ins;
   pickextxpm = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
                                                  pickext_xpm);
   pickextxpm_ins = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
                                                      pickext_xpm, TRUE);
   XtVaSetValues(abbrOutputButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
                 pickextxpm, XmNselectPixmap, pickextxpm, XmNlabelInsensitivePixmap,
                 pickextxpm_ins, XmNselectInsensitivePixmap, pickextxpm_ins, NULL);
   //   Pixmap consolexpm, consolexpm_ins;
   // consolexpm = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
   //                                                console_xpm);
   // consolexpm_ins = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
   //                                                    console_xpm, TRUE);
   // XtVaSetValues(abbrOutputButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
   //               consolexpm, XmNselectPixmap, consolexpm, XmNlabelInsensitivePixmap,
   //               consolexpm_ins, XmNselectInsensitivePixmap, consolexpm_ins, NULL);
   buttonlist->append(abbrOutputButton);
 
   // Button for selecting the beam that will act as reference path
   pickRefPathButton = XtVaCreateManagedWidget("Refpath", xmPushButtonWidgetClass,
                                               parent, NULL);
   XtAddCallback(pickRefPathButton, XmNactivateCallback,
                 G4OpenInventorXtExaminerViewer::pickRefPathCB, this);
   Pixmap pickrefxpm, pickrefxpm_ins;
   pickrefxpm = SoXtInternal::createPixmapFromXpm(pickRefPathButton,
                                                    pickref_xpm);
   pickrefxpm_ins = SoXtInternal::createPixmapFromXpm(pickRefPathButton,
                                                        pickref_xpm, TRUE);
   XtVaSetValues(pickRefPathButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
       pickrefxpm, XmNselectPixmap, pickrefxpm, XmNlabelInsensitivePixmap,
       pickrefxpm_ins, XmNselectInsensitivePixmap, pickrefxpm_ins, NULL);
 
   buttonlist->append(pickRefPathButton);
 
   // Toggle button for switching in and out of wireframe mode
   switchWireFrameButton = XtVaCreateManagedWidget("Wireframe",
         xmToggleButtonWidgetClass, parent,  XmNindicatorOn, False, NULL);
   XtAddCallback(switchWireFrameButton, XmNvalueChangedCallback,
                 G4OpenInventorXtExaminerViewer::switchWireFrameCB, this);
   Pixmap wireframe, wireframe_ins;
   wireframe = SoXtInternal::createPixmapFromXpm(switchWireFrameButton,
                                                 wireframe_xpm);
   wireframe_ins = SoXtInternal::createPixmapFromXpm(switchWireFrameButton,
                                                     wireframe_xpm, TRUE);
   XtVaSetValues(switchWireFrameButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
              wireframe, XmNselectPixmap, wireframe, XmNlabelInsensitivePixmap,
              wireframe_ins, XmNselectInsensitivePixmap, wireframe_ins, NULL);
   buttonlist->append(switchWireFrameButton);
}

◆ getMenu()

Widget G4OpenInventorXtExaminerViewer::getMenu ( )

inline

Definition at line 99 of file G4OpenInventorXtExaminerViewer.hh.

99{ return fileMenu; }

Referenced by G4OpenInventorXtExtendedViewer::Initialise().

◆ getMenuBar()

Widget G4OpenInventorXtExaminerViewer::getMenuBar ( )

inline

Definition at line 98 of file G4OpenInventorXtExaminerViewer.hh.

98{ return menuBar; }

Referenced by G4OpenInventorXtExtendedViewer::Initialise().

◆ loadViewPts()

bool G4OpenInventorXtExaminerViewer::loadViewPts ( )

protected

Definition at line 3491 of file G4OpenInventorXtExaminerViewer.cc.

{
   bool error = false;
   viewPtData tmp;
   std::string token;
   SbVec3f axis;
   SbRotation orient;
   float x(0.), y(0.), z(0.), angle(0.);
 
   // Gets the last view point accessed, stored in the first line of the data file.
   fileIn >> token;
   parseString<int>(viewPtIdx, token, error);
   getline(fileIn, token); // Remove "\n"
   // Converts data from string type into necessary types
   while (getline(fileIn, token)) {
 
      int end = token.find_last_not_of(' '); // Remove padded spaces
      token = token.substr(0, end + 1);
 
      char *vpName = new char[token.size() + 1];
      strcpy(vpName, token.c_str());
      tmp.viewPtName = vpName;
      fileIn >> token;
 
      parseString<float>(x, token, error);
      fileIn >> token;
      parseString<float>(y, token, error);
      fileIn >> token;
      parseString<float>(z, token, error);
      fileIn >> token;
      tmp.position = axis.setValue(x, y, z);
 
      parseString<float>(x, token, error);
      fileIn >> token;
      parseString<float>(y, token, error);
      fileIn >> token;
      parseString<float>(z, token, error);
      fileIn >> token;
      parseString<float>(angle, token, error);
      fileIn >> token;
      orient.setValue(axis.setValue(x, y, z), angle);
      tmp.orientation = orient.getValue();
 
      int camType(0);
      parseString<int>(camType, token, error);
      fileIn >> token;
      tmp.camType = (CameraType) camType;
 
      parseString<float>(tmp.height, token, error);
      fileIn >> token;
      parseString<float>(tmp.focalDistance, token, error);
      fileIn >> token;
      parseString<float>(tmp.nearDistance, token, error);
      fileIn >> token;
      parseString<float>(tmp.farDistance, token, error);
      fileIn >> token;
      parseString<int>(tmp.viewportMapping, token, error);
      fileIn >> token;
      parseString<float>(tmp.aspectRatio, token, error);
 
      getline(fileIn, token); // To remove "\n" characters
      getline(fileIn, token);
 
      if (error) {
         viewPtIdx = 0;
         viewPtList.clear();
         return false;
      }
      viewPtList.push_back(tmp);
   }
 
   return true;
}

Referenced by afterRealizeHook().

◆ moveCamera()

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

protected

Definition at line 924 of file G4OpenInventorXtExaminerViewer.cc.

{
 
   SoCamera *cam = getCamera();
   SbVec3f p1(0), p2(0); // The particle moves from p1 to p2
   SbVec3f particleDir;  // Direction vector from p1 to p2
   SbVec3f camPosNew(0); // New position of the camera
 
   if(refParticleTrajectory.size() == 0) {
      //refParticleTrajectory hasn't been set yet
      if(dist)
         distance = dist;
      else
         distance = (cam->position.getValue() - center).length();
 
      cam->position.setValue(center + offsetFromCenter*distance);
      cam->focalDistance = (cam->position.getValue() - center).length();
      cam->pointAt(center, upVector);
   }
   else{
 
      // If we move forward past the last trajectory point,
      // go back to the beginning
      if (refParticleIdx >= (int) refParticleTrajectory.size() - 1) {
         prevPt = refParticleTrajectory[refParticleIdx - step];
         dist = (prevPt - cam->position.getValue()).length();
         refParticleIdx = 0;
      }
      // If we move backward past the beginning,
      // go to the last trajectory point
      if (refParticleIdx < 0) {
         prevPt = refParticleTrajectory[refParticleIdx + step];
         dist = (prevPt - cam->position.getValue()).length();
         refParticleIdx = refParticleTrajectory.size() - 2;
      }
 
      // Set start and end points
      p1 = refParticleTrajectory[refParticleIdx];
      p2 = refParticleTrajectory[refParticleIdx + step];
 
      // Get the direction from p1 to p2
      particleDir = p2 - p1;
      particleDir.normalize();
 
      if(prevParticleDir == SbVec3f(0,0,0)){
         // First time entering BEAMLINE mode, look at
         // the element from the front, with camera upright
         if(lookdown)
            camDir = SbVec3f(0,0,1);
         else
            camDir = SbVec3f(1,0,0);
         camUpVec = SbVec3f(0,1,0);
 
         // In case the start of the goes in a
         // direction other than +z, rotate the camera accordingly
         SbRotation rot(SbVec3f(0,0,1), particleDir);
         rot.multVec(camDir, camDir);
         rot.multVec(camUpVec, camUpVec);
 
      }
      else if(particleDir != prevParticleDir) {
         // The beamline has changed direction
 
         SbRotation rot(prevParticleDir, particleDir);
         rot.multVec(camDir, camDir);
         rot.multVec(camUpVec, camUpVec);
 
      }
 
      if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
         if (!dist)
            distance = (prevPt - cam->position.getValue()).length();
         else
            distance = dist;
      }
 
      // FWJ distance not relevant -- use focalDistance
      // if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
      //    if (!dist)
      //       distance = (prevPt - cam->position.getValue()).length();
      //    else
      //       distance = dist;
      // }
 
 
      float x(0.),y(0.),z(0.);
      prevPt.getValue(x,y,z);
 
 
      if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
         camPosNew = p2 - (camDir*distance);
      }
      if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
         // FWJ maintain focal distance
         camPosNew = p2 - (camDir*cam->focalDistance.getValue());
         //         camPosNew = p2 - (camDir);
      }
 
      cam->position = camPosNew;
      cam->pointAt(p2, camUpVec);
      cam->focalDistance = (p2 - camPosNew).length();
 
      p2.getValue(x,y,z);
      camPosNew.getValue(x,y,z);
 
      prevParticleDir = particleDir;
      prevPt = p1; // For accurate distance calculation
 
   }
 
}

Referenced by processSoEvent().

◆ parseString()

template<class T >

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

Definition at line 3569 of file G4OpenInventorXtExaminerViewer.cc.

{
   std::istringstream str(s);
   if ((str >> t).fail())
      error = true;
}

◆ processSoEvent()

SbBool G4OpenInventorXtExaminerViewer::processSoEvent ( const SoEvent *const event )

protectedvirtual

Definition at line 1375 of file G4OpenInventorXtExaminerViewer.cc.

                                                                              {
   SoCamera *cam = getCamera();
   const SoType type(ev->getTypeId());
 
   if (type.isDerivedFrom(SoMouseButtonEvent::getClassTypeId())) {
      SoMouseButtonEvent * me = (SoMouseButtonEvent *) ev;
 
      if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
          || currentState == PAUSED_ANIMATION) {
         switch (me->getButton()) {
         case SoMouseButtonEvent::BUTTON4: // Scroll wheel up
            if (me->getState() == SoButtonEvent::DOWN) {
               if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
                  float hAngle =
                     ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
                  ((SoPerspectiveCamera *) cam)->heightAngle = hAngle
                     + 0.01f;
                  return TRUE;
               } else if (cam->isOfType(
                                        SoOrthographicCamera::getClassTypeId())) {
                  float height =
                     ((SoOrthographicCamera *) cam)->height.getValue();
                  ((SoOrthographicCamera *) cam)->height = height + 5;
                  return TRUE;
               }
            }
            break;
         case SoMouseButtonEvent::BUTTON5: // Scroll wheel down
            if (me->getState() == SoButtonEvent::DOWN) {
               if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
                  float hAngle =
                     ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
                  if (hAngle > 0.01)
                     ((SoPerspectiveCamera *) cam)->heightAngle = hAngle
                        - 0.01f;
                  return TRUE;
               } else if (cam->isOfType(
                                        SoOrthographicCamera::getClassTypeId())) {
                  float height =
                     ((SoOrthographicCamera *) cam)->height.getValue();
                  if (height > 5)
                     ((SoOrthographicCamera *) cam)->height = height - 5;
                  return TRUE;
               }
            }
            break;
         default:
            break;
         }
      }
      if (currentState == GENERAL) {
 
      }
   }
 
   if (type.isDerivedFrom(SoKeyboardEvent::getClassTypeId())) {
      SoKeyboardEvent * ke = (SoKeyboardEvent *) ev;
 
      if (SoKeyboardEvent::isKeyPressEvent(ev, ke->getKey())) {
         switch (ke->getKey()) {
         case SoKeyboardEvent::LEFT_SHIFT:
            this->lshiftdown = true;
            return TRUE;
         case SoKeyboardEvent::RIGHT_SHIFT:
            this->rshiftdown = true;
            return TRUE;
         case SoKeyboardEvent::LEFT_CONTROL:
            this->lctrldown = true;
            return TRUE;
         case SoKeyboardEvent::RIGHT_CONTROL:
            this->rctrldown = true;
            return TRUE;
         case SoKeyboardEvent::SPACE:
            if (currentState == ANIMATION
                || currentState == REVERSED_ANIMATION) {
               beforePausing = currentState;
               currentState = PAUSED_ANIMATION;
               if (animateSensor->isScheduled())
                  animateSensor->unschedule();
               return TRUE;
            } else if (currentState == PAUSED_ANIMATION) {
               if (maxSpeed) {
                  if ((beforePausing == ANIMATION
                       && refParticleIdx
                       < (int) refParticleTrajectory.size() - 1)
                      || (beforePausing == REVERSED_ANIMATION
                          && refParticleIdx > 0)) {
                     currentState = beforePausing;
                     animateRefParticle();
                  }
               }
               return TRUE;
            }
            break;
         case SoKeyboardEvent::ESCAPE:
            if (currentState == ANIMATION
                || currentState == REVERSED_ANIMATION
                || currentState == PAUSED_ANIMATION) {
 
               if (animateSensor->isScheduled())
                  animateSensor->unschedule();
               currentState = prevState;
               refParticleIdx = prevRefIdx;
               setSuperimpositionEnabled(superimposition, FALSE);
               maxSpeed = 0.0f;
               step = 1;
 
               scheduleRedraw();
               if (currentState == VIEWPOINT) {
                  setSuperimpositionEnabled(superimposition, TRUE);
                  axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
                  animSpeedOutlineSwitch->whichChild.setValue(
                                                              SO_SWITCH_NONE);
                  animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
 
                  scheduleRedraw();
               }
               restoreCamera();
               return TRUE;
            }
            break;
         case SoKeyboardEvent::DELETE:
            if (viewPtList.size()
                && (currentState != ANIMATION
                    && currentState != REVERSED_ANIMATION
                    && currentState != PAUSED_ANIMATION)) {
               String dialogName = (char *) "Delete Viewpoint";
               std::string msg = "Are you sure you want to delete current viewpoint?";
               warningMsgDialog(msg, dialogName, deleteViewPtCB);
               return TRUE;
            }
            break;
         case SoKeyboardEvent::LEFT_ARROW:
            switch (currentState) {
            case BEAMLINE:
               if ((this->lshiftdown)   || (this->rshiftdown)){
                  refParticleIdx -= step;
                  moveCamera();
               }
               else if ((this->lctrldown)   || (this->rctrldown)){
                  if (SoXtExaminerViewer::isAnimating())
                     stopAnimating();
                  prevState = currentState;
                  currentState = ROTATING;
                  animateBtwPtsPeriod = 0.08f;
 
                  SbVec3f tmp = camDir;
                  tmp.negate();
                  rotAxis = tmp;
 
                  rotCnt = ROT_CNT;
                  moveCamera(); // To make sure camera is perpendicular to the beamline
 
                  rotateCamera();
               }
               else{
                  if (SoXtExaminerViewer::isAnimating())
                     stopAnimating();
                  prevState = currentState;
                  currentState = ROTATING;
                  animateBtwPtsPeriod = 0.08f;
 
                  SbVec3f tmp = camUpVec;
                  tmp.negate();
                  rotAxis = tmp;
 
                  rotCnt = ROT_CNT;
                  moveCamera(); // To make sure camera is perpendicular to the beamline
 
                  rotateCamera();
 
               }
               return TRUE;
 
            case ANIMATION:
            case REVERSED_ANIMATION:
               left_right -= 1.5f;
               return TRUE;
            case PAUSED_ANIMATION:
               left_right -= 1.5f;
               setStartingPtForAnimation();
               cam->position = myCam->position;
               return TRUE;
            case GENERAL:
            case VIEWPOINT:
               if ((!this->lshiftdown) && (!this->rshiftdown)) {
                  // Using this allows us to look around without
                  // changing the camera parameters (camDir, camUpVec)
                  this->bottomWheelMotion(
                                          this->getBottomWheelValue() + 0.1f);
 
                  return TRUE;
               }
               break;
            case ROTATING:
               // For this state, let the keyboard event
               // be handled by superclass
               break;
            default:
               SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
                                  "Unhandled viewer state");
               break;
            }
            break;
 
         case SoKeyboardEvent::RIGHT_ARROW:
            switch(currentState){
            case BEAMLINE:
               if ((this->lshiftdown)   || (this->rshiftdown)){
                  refParticleIdx += step;
                  moveCamera();
               }
               else if ((this->lctrldown)   || (this->rctrldown)){
                  if (SoXtExaminerViewer::isAnimating())
                     stopAnimating();
                  prevState = currentState;
                  currentState = ROTATING;
                  animateBtwPtsPeriod = 0.08f;
 
                  rotAxis = camDir;
 
                  rotCnt = ROT_CNT;
                  moveCamera(); // To make sure camera is perpendicular to the beamline
 
                  rotateCamera();
               }
               else{
                  if (SoXtExaminerViewer::isAnimating())
                     stopAnimating();
                  prevState = currentState;
                  currentState = ROTATING;
                  animateBtwPtsPeriod = 0.08f;
 
                  rotAxis = camUpVec;
 
                  rotCnt = ROT_CNT;
                  moveCamera(); // To make sure camera is perpendicular to the beamline
 
                  rotateCamera();
               }
               return TRUE;
 
            case ANIMATION:
            case REVERSED_ANIMATION:
               left_right += 1.5f;
               return TRUE;
            case PAUSED_ANIMATION:
               left_right += 1.5f;
               setStartingPtForAnimation();
               cam->position = myCam->position;
               return TRUE;
            case GENERAL:
            case VIEWPOINT:
               if ((!this->lshiftdown) && (!this->rshiftdown)) {
                  // Using this allows us to look around without
                  // changing the camera parameters (camDir, camUpVec)
                  this->bottomWheelMotion(
                                          this->getBottomWheelValue() - 0.1f);
                  return TRUE;
               }
               break;
            case ROTATING:
               // For this state, let the keyboard event
               // be handled by superclass
               break;
            default:
               SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
                                  "Unhandled viewer state");
               break;
            }
            break;
 
         case SoKeyboardEvent::DOWN_ARROW:
            switch(currentState){
            case BEAMLINE:
 
               if ((this->lshiftdown)   || (this->rshiftdown)){
                  refParticleIdx -= step;
                  moveCamera();
               }
               else{
                  if (SoXtExaminerViewer::isAnimating())
                     stopAnimating();
                  prevState = currentState;
                  currentState = ROTATING;
                  animateBtwPtsPeriod = 0.08f;
 
                  rotAxis = camDir.cross(camUpVec);
 
                  rotCnt = ROT_CNT;
                  moveCamera(); // To make sure camera is perpendicular to the beamline
 
                  rotateCamera();
 
               }
               return TRUE;
 
            case ANIMATION:
            case REVERSED_ANIMATION:
               up_down -= 1.5f;
               return TRUE;
            case PAUSED_ANIMATION:
               up_down -= 1.5f;
               setStartingPtForAnimation();
               cam->position = myCam->position;
               return TRUE;
            case GENERAL:
            case VIEWPOINT:
               // Using this allows us to look around without
               // changing the camera parameters (camDir, camUpVec)
               if ((!this->lshiftdown) && (!this->rshiftdown)) {
                  this->leftWheelMotion(this->getLeftWheelValue() - 0.1f);
                  return TRUE;
               }
               break;
            case ROTATING:
               // For this state, let the keyboard event
               // be handled by superclass
               break;
            default:
               SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
                                  "Unhandled viewer state");
               break;
            }
            break;
 
         case SoKeyboardEvent::UP_ARROW:
            switch(currentState){
            case BEAMLINE:
               if ((this->lshiftdown)   || (this->rshiftdown)){
                  refParticleIdx -= step;
                  moveCamera();
               }
               else{
                  if (SoXtExaminerViewer::isAnimating())
                     stopAnimating();
                  prevState = currentState;
                  currentState = ROTATING;
                  animateBtwPtsPeriod = 0.08f;
 
                  rotAxis = camUpVec.cross(camDir);
 
                  rotCnt = ROT_CNT;
                  moveCamera();
 
                  rotateCamera();
 
 
               }
               return TRUE;
            case ANIMATION:
            case REVERSED_ANIMATION:
               up_down += 1.5f;
               return TRUE;
            case PAUSED_ANIMATION:
               up_down += 1.5f;
               setStartingPtForAnimation();
               cam->position = myCam->position;
               return TRUE;
            case GENERAL:
            case VIEWPOINT:
               // Using this allows us to look around without
               // changing the camera parameters (camDir, camUpVec)
               if ((!this->lshiftdown) && (!this->rshiftdown)) {
                  this->leftWheelMotion(this->getLeftWheelValue() + 0.1f);
                  return TRUE;
               }
               break;
            case ROTATING:
               // For this state, let the keyboard event
               // be handled by superclass
               break;
            default:
               SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
                                  "Unhandled viewer state");
               break;
            }
            break;
 
         case SoKeyboardEvent::PAGE_UP:
            switch(currentState){
            case BEAMLINE:
               if (step < (int) refParticleTrajectory.size() / 5) // Magic number
                  step++;
               return TRUE;
            case ANIMATION:
               incSpeed();
               maxSpeed += SPEED_INDICATOR_STEP;
               if (maxSpeed > 0.8)
                  maxSpeed = MAX_SPEED_INDICATOR;
               scheduleRedraw();
 
               return TRUE;
            case REVERSED_ANIMATION:
               if(!animateSensor->isScheduled()){
                  currentState = ANIMATION;
                  if (refParticleIdx
                      < (int) refParticleTrajectory.size() - 1) {
                     refParticleIdx++;
                     maxSpeed = SPEED_INDICATOR_STEP;
                     scheduleRedraw();
                     animateRefParticle();
                  }
               }
               else{
                  maxSpeed += SPEED_INDICATOR_STEP;
                  decSpeed();
                  scheduleRedraw();
               }
               return TRUE;
            case PAUSED_ANIMATION:
               maxSpeed += SPEED_INDICATOR_STEP;
               if (maxSpeed > 0.8)
                  maxSpeed = MAX_SPEED_INDICATOR;
 
               if (beforePausing == ANIMATION) {
                  incSpeed();
               } else {
                  decSpeed();
                  if (animateBtwPtsPeriod >= MIN_SPEED)
                     beforePausing = ANIMATION;
               }
 
               scheduleRedraw();
               return TRUE;
            default:    //fall through
               break;
            }
            break;
 
         case SoKeyboardEvent::PAGE_DOWN:
            switch(currentState){
            case BEAMLINE:
               if (step > 1)
                  step--;
               return TRUE;
            case ANIMATION:
               if(!animateSensor->isScheduled()){
                  currentState = REVERSED_ANIMATION;
                  if (refParticleIdx > 1) {
                     refParticleIdx--;
                     maxSpeed = -SPEED_INDICATOR_STEP;
                     scheduleRedraw();
                     animateRefParticle();
                  }
               }
               else{
                  maxSpeed -= SPEED_INDICATOR_STEP;
                  decSpeed();
                  scheduleRedraw();
               }
               return TRUE;
            case REVERSED_ANIMATION:
               incSpeed();
               maxSpeed -= SPEED_INDICATOR_STEP;
               if (maxSpeed < -0.8)
                  maxSpeed = -MAX_SPEED_INDICATOR;
               scheduleRedraw();
               return TRUE;
            case PAUSED_ANIMATION:
               maxSpeed -= SPEED_INDICATOR_STEP;
               if (maxSpeed < -0.8)
                  maxSpeed = -MAX_SPEED_INDICATOR;
               if (beforePausing == REVERSED_ANIMATION) {
                  incSpeed();
               } else {
                  decSpeed();
                  if (animateBtwPtsPeriod >= MIN_SPEED)
                     beforePausing = REVERSED_ANIMATION;
               }
               scheduleRedraw();
               return TRUE;
            default:
               //fall through
               break;
            }
            break;
 
         case SoKeyboardEvent::E:
            this->escapeCallback(this->examinerObject);
            break;
 
         default:
            break; // To get rid of compiler warnings
         }
      }
      if (SoKeyboardEvent::isKeyReleaseEvent(ev, ke->getKey())) {
         switch (ke->getKey()) {
         case SoKeyboardEvent::LEFT_SHIFT:
            this->lshiftdown = false;
            return TRUE;
         case SoKeyboardEvent::RIGHT_SHIFT:
            this->rshiftdown = false;
            return TRUE;
         case SoKeyboardEvent::LEFT_CONTROL:
            this->lctrldown = false;
            return TRUE;
         case SoKeyboardEvent::RIGHT_CONTROL:
            this->rctrldown = false;
            return TRUE;
         default:
            break;
         }
      }
   }
 
   if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
       || currentState == ROTATING)
      return FALSE;
   else
      return SoXtExaminerViewer::processSoEvent(ev);
}

◆ rotateCamera()

void G4OpenInventorXtExaminerViewer::rotateCamera ( )

protected

Definition at line 897 of file G4OpenInventorXtExaminerViewer.cc.

{
   SoCamera *cam = getCamera();
 
   SbRotation rot(rotAxis, M_PI / (2 * ROT_CNT));
   rot.multVec(camDir, camDir);
   rot.multVec(camUpVec, camUpVec);
 
   SbVec3f camPosNew = prevPt - (camDir*distance);
   cam->position = camPosNew;
   cam->pointAt(prevPt, camUpVec);
   cam->focalDistance = (prevPt - camPosNew).length();
 
   rotCnt--;
 
   if (animateSensorRotation->isScheduled()) {
      animateSensorRotation->unschedule();
   }
 
   animateSensorRotation->setBaseTime(SbTime::getTimeOfDay());
   animateSensorRotation->setInterval(SbTime(0.02));
   animateSensorRotation->schedule();
 
}

Referenced by processSoEvent().

◆ updateViewParams()

void G4OpenInventorXtExaminerViewer::updateViewParams ( SoKeyboardEvent::Key )

protected

◆ warningMsgDialog()

void G4OpenInventorXtExaminerViewer::warningMsgDialog	(	std::string	msg,
		String	dialogName,
		XtCallbackProc	cb
	)

Definition at line 3754 of file G4OpenInventorXtExaminerViewer.cc.

{
   Arg args[5];
   unsigned int n;
   XmString warningMsg;
 
   warningMsg = XmStringCreateLocalized((char *)msg.c_str());
 
   n = 0;
   XtSetArg(args[n], XmNmessageString, warningMsg); n++;
   Widget warningDialog = XmCreateWarningDialog(getParentWidget(), dialogName, args, n);
   if (cb)
      XtAddCallback(warningDialog, XmNokCallback, cb, this);
 
   XmStringFree(warningMsg);
 
   XtVaSetValues (warningDialog, XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL, NULL);
   XtUnmanageChild(XtNameToWidget(warningDialog, "Help"));
   XtUnmanageChild(XtNameToWidget(warningDialog, "Cancel"));
 
   XtManageChild(warningDialog);
}