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

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(*	cb )(void *),
		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.

{ return fileMenu; }

Referenced by G4OpenInventorXtExtendedViewer::Initialise().

getMenuBar()

Widget G4OpenInventorXtExaminerViewer::getMenuBar ( )

inline

Definition at line 98 of file G4OpenInventorXtExaminerViewer.hh.

{ 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;
}

Referenced by loadViewPts().

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);
}

Referenced by afterRealizeHook(), and processSoEvent().

Friends And Related Symbol Documentation

G4OpenInventorXtExaminerViewerMessenger

friend class G4OpenInventorXtExaminerViewerMessenger

friend

Definition at line 67 of file G4OpenInventorXtExaminerViewer.hh.

G4OpenInventorXtExtendedViewer

friend class G4OpenInventorXtExtendedViewer

friend

Definition at line 69 of file G4OpenInventorXtExaminerViewer.hh.

HookEventProcState

friend class HookEventProcState

friend

Definition at line 148 of file G4OpenInventorXtExaminerViewer.hh.

Member Data Documentation

abbrOutputFlag

bool G4OpenInventorXtExaminerViewer::abbrOutputFlag

Definition at line 110 of file G4OpenInventorXtExaminerViewer.hh.

camDir

SbVec3f G4OpenInventorXtExaminerViewer::camDir

protected

Definition at line 134 of file G4OpenInventorXtExaminerViewer.hh.

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

camUpVec

SbVec3f G4OpenInventorXtExaminerViewer::camUpVec

protected

Definition at line 133 of file G4OpenInventorXtExaminerViewer.hh.

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

curEltName

std::string G4OpenInventorXtExaminerViewer::curEltName

protected

Definition at line 132 of file G4OpenInventorXtExaminerViewer.hh.

pickRefPathFlag

bool G4OpenInventorXtExaminerViewer::pickRefPathFlag

Definition at line 111 of file G4OpenInventorXtExaminerViewer.hh.

saveRefCoordsFileName

std::string G4OpenInventorXtExaminerViewer::saveRefCoordsFileName

Definition at line 105 of file G4OpenInventorXtExaminerViewer.hh.

saveRefCoordsWidget

Widget G4OpenInventorXtExaminerViewer::saveRefCoordsWidget

Definition at line 106 of file G4OpenInventorXtExaminerViewer.hh.

saveScenegraphFileName

std::string G4OpenInventorXtExaminerViewer::saveScenegraphFileName

Definition at line 103 of file G4OpenInventorXtExaminerViewer.hh.

saveScenegraphWidget

Widget G4OpenInventorXtExaminerViewer::saveScenegraphWidget

Definition at line 104 of file G4OpenInventorXtExaminerViewer.hh.

viewingBeforePickRef

bool G4OpenInventorXtExaminerViewer::viewingBeforePickRef

Definition at line 112 of file G4OpenInventorXtExaminerViewer.hh.

warningFlag

bool G4OpenInventorXtExaminerViewer::warningFlag

Definition at line 101 of file G4OpenInventorXtExaminerViewer.hh.

---

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

• G4OpenInventorXtExaminerViewer.hh
• G4OpenInventorXtExaminerViewer.cc