G4OpenInventorXtExaminerViewer Class Reference

#include <G4OpenInventorXtExaminerViewer.hh>


Public Member Functions

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

Data Fields

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

Protected Member Functions

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

Protected Attributes

std::string curEltName
SbVec3f camUpVec
SbVec3f camDir

Friends

class HookEventProcState

Data Structures

struct  elementForSorting
struct  sceneElement
struct  viewPtData


Detailed Description

Definition at line 63 of file G4OpenInventorXtExaminerViewer.hh.


Constructor & Destructor Documentation

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

Definition at line 122 of file G4OpenInventorXtExaminerViewer.cc.

References TRUE.

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

G4OpenInventorXtExaminerViewer::~G4OpenInventorXtExaminerViewer (  ) 

Definition at line 577 of file G4OpenInventorXtExaminerViewer.cc.

00578 {
00579    if (superimposition != NULL) {
00580       removeSuperimposition(superimposition);
00581       superimposition->unref();
00582       superimposition = NULL;
00583    }
00584    if (animateSensor->isScheduled())
00585       animateSensor->unschedule();
00586    delete animateSensor;
00587    delete sceneChangeSensor;
00588 
00589    delete[] curViewPtName;
00590    delete searcher;
00591 
00592    viewer = 0;
00593 }

G4OpenInventorXtExaminerViewer::G4OpenInventorXtExaminerViewer ( Widget  parent,
const char *  name,
SbBool  embed,
SoXtFullViewer::BuildFlag  flag,
SoXtViewer::Type  type,
SbBool  build 
) [protected]

Definition at line 132 of file G4OpenInventorXtExaminerViewer.cc.

00135                               :
00136    SoXtExaminerViewer(parent, name, embed, flag, type, FALSE)
00137 {
00138    this->constructor(build);
00139 }


Member Function Documentation

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

Definition at line 668 of file G4OpenInventorXtExaminerViewer.cc.

Referenced by buildWidget().

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

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

Definition at line 4703 of file G4OpenInventorXtExaminerViewer.cc.

04705 {
04706    this->escapeCallback = callback;
04707    this->examinerObject = object;
04708 }

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

Definition at line 654 of file G4OpenInventorXtExaminerViewer.cc.

Referenced by buildWidget().

00655 {
00656    Arg args[1];
00657    Widget menu = XmCreatePulldownMenu(menuBar, (char *) name.c_str(), NULL, 0);
00658 
00659    XtSetArg(args[0], XmNsubMenuId, menu);
00660    Widget w = XmCreateCascadeButton(menuBar, (char *) name.c_str(), args, 1);
00661    XtManageChild(w);
00662 
00663    return menu;
00664 }

void G4OpenInventorXtExaminerViewer::afterRealizeHook (  )  [protected, virtual]

Definition at line 773 of file G4OpenInventorXtExaminerViewer.cc.

References loadViewPts(), and warningMsgDialog().

00774 {
00775    SoXtExaminerViewer::afterRealizeHook();
00776 
00777    // Default height is used when selecting and viewing scene elements
00778    // FWJ Added defaultHeight for Ortho camera
00779    SoCamera *cam = getCamera();
00780    if (cam) {
00781       if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
00782          defaultHeightAngle =
00783             ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
00784          toggleCameraType();
00785          defaultHeight =
00786             ((SoOrthographicCamera *) cam)->height.getValue();
00787          toggleCameraType();
00788       } else {
00789          defaultHeight =
00790             ((SoOrthographicCamera *) cam)->height.getValue();
00791          toggleCameraType();
00792          cam = getCamera();
00793          if (cam->isOfType(SoPerspectiveCamera::getClassTypeId()))
00794             defaultHeightAngle =
00795                ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
00796          toggleCameraType();
00797       }
00798    }
00799 
00800    // Open the default bookmark file
00801    fileIn.open(fileName.c_str());
00802    if (!fileIn.fail()) {
00803       if (!loadViewPts()) {
00804          String dialogName = (char *) "Error Loading File";
00805          std::string msg = "Wrong or corrupted input file.";
00806          warningMsgDialog(msg, dialogName, NULL);
00807       } else {
00808          // Opens a file without erasing it
00809          fileOut.open(fileName.c_str(), std::ios::in);
00810          fileOut.seekp(0, std::ios::end); // For appending new data to the end
00811          constructListsDialog(getParentWidget(), this, NULL); // Pop up listsDialog
00812 
00813          if (viewPtList.size()) {
00814             // FWJ disabled auto-selection of first viewpoint.
00815             // Initial view should be user-controllable & not forced
00816             //            setViewPt();
00817             XtSetSensitive(nextViewPtButton, True);
00818             XtSetSensitive(prevViewPtButton, True);
00819          }
00820       }
00821 
00822       fileIn.close();
00823    } else {
00824       // Creates a new default bookmark file
00825       fileOut.open(fileName.c_str());
00826       constructListsDialog(getParentWidget(), this, NULL); // Pop up listsDialog
00827    }
00828 
00829    fileIn.clear();
00830 
00831    SoSeparator *root = (SoSeparator *) (getSceneManager()->getSceneGraph());
00832    if (root == NULL)
00833       SoDebugError::post("G4OpenInventorXtExaminerViewer::afterRealizeHook", "Root is null.");
00834    else {
00835       root->addChild(myCam); // For position/orientation calculation during animation
00836    }
00837 
00838    sceneChangeSensor = new SoNodeSensor;
00839    sceneChangeSensor->setFunction(sceneChangeCB);
00840    sceneChangeSensor->attach(root);
00841    sceneChangeSensor->setData(this);
00842 
00843    // Monitor mouseover events for displaying the name of scene elements
00844    // An SoEventCallback is needed instead of using the default processSoEvent
00845    // because that last one does not provide us with an SoPath to the object
00846    // that was picked
00847    SoEventCallback *moCB = new SoEventCallback;
00848    moCB->addEventCallback(
00849                           SoLocation2Event::getClassTypeId(),
00850                           mouseoverCB, static_cast<void *>(this));
00851    root->addChild(moCB);
00852 
00853    // Override the default picking mechanism present in G4OpenInventorViewer
00854    // because we want abbreviated output when picking a trajectory
00855    SoEventCallback *pickCB = new SoEventCallback;
00856    pickCB->addEventCallback(
00857                             SoMouseButtonEvent::getClassTypeId(),
00858                             pickingCB, static_cast<void *>(this));
00859    root->addChild(pickCB);
00860 
00861 }

Widget G4OpenInventorXtExaminerViewer::buildWidget ( Widget  parent  )  [protected]

Definition at line 597 of file G4OpenInventorXtExaminerViewer.cc.

References addButton(), and addMenu().

00598 {
00599    Widget shell;
00600    Atom WM_DELETE_WINDOW;
00601 
00602    if (!parent)
00603       SoDebugError::post("G4OpenInventorXtExaminerViewer::buildWidget", "Error: Parent is null.");
00604 
00605    Arg args[10];
00606    XtSetArg(args[0], XmNtopAttachment, XmATTACH_FORM);
00607    XtSetArg(args[1], XmNleftAttachment, XmATTACH_FORM);
00608    XtSetArg(args[2], XmNrightAttachment, XmATTACH_FORM);
00609    XtSetArg(args[3], XmNbottomAttachment, XmATTACH_FORM);
00610    Widget form = XmCreateForm(parent, (char *) "Form", args, 4);
00611    XtManageChild(form);
00612 
00613    shell = XtParent(form);
00614    WM_DELETE_WINDOW = XInternAtom(XtDisplay(parent), "WM_DELETE_WINDOW",
00615                                   False);
00616    XmAddWMProtocolCallback(shell, WM_DELETE_WINDOW,
00617                            (XtCallbackProc)closeMainWindowCB, this);
00618 
00619    XtSetArg(args[0], XmNtopAttachment, XmATTACH_FORM);
00620    XtSetArg(args[1], XmNleftAttachment, XmATTACH_FORM);
00621    XtSetArg(args[2], XmNrightAttachment, XmATTACH_FORM);
00622    menuBar = XmCreateMenuBar(form, (char *) "MenuBar", args, 3);
00623    XtManageChild(menuBar);
00624 
00625    fileMenu = addMenu("File");
00626    this->addButton(fileMenu, "Open Viewpoint File...", openViewPtFileCB);
00627    addButton(fileMenu, "New Viewpoint File", newViewPtFileCB);
00628    addButton(fileMenu, "Load Ref. Coords", loadRefCoordsDialogCB);
00629    addButton(fileMenu, "Save Ref. Coords", saveRefCoordsDialogCB);
00630    addButton(fileMenu, "Load Scene Graph", loadSceneGraphDialogCB);
00631    addButton(fileMenu, "Save Scene Graph", saveSceneGraphDialogCB);
00632    XtManageChild(
00633           XmCreateSeparatorGadget(fileMenu, (char *) "Separator", NULL, 0));
00634 
00635    Widget menu = addMenu("Tools");
00636    addButton(menu, "Animate Ref. Particle", animateRefParticleCB);
00637    addButton(menu, "Go to start of Ref path", gotoRefPathStartCB);
00638    addButton(menu, "Invert Ref path", invertRefPathCB);
00639 
00640    Widget viewerBase = SoXtFullViewer::buildWidget(form);
00641 
00642    XtSetArg(args[0], XmNtopAttachment, XmATTACH_WIDGET);
00643    XtSetArg(args[1], XmNtopWidget, menuBar);
00644    XtSetArg(args[2], XmNleftAttachment, XmATTACH_FORM);
00645    XtSetArg(args[3], XmNrightAttachment, XmATTACH_FORM);
00646    XtSetArg(args[4], XmNbottomAttachment, XmATTACH_FORM);
00647    XtSetValues(viewerBase, args, 5);
00648 
00649    return viewerBase;
00650 }

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

void G4OpenInventorXtExaminerViewer::createViewerButtons ( Widget  parent,
SbPList *  buttonlist 
) [protected, virtual]

Definition at line 678 of file G4OpenInventorXtExaminerViewer.cc.

References CLHEP::detail::n, and TRUE.

00680 {
00681    int n;
00682    Arg args[6];
00683    Widget saveViewPtButton, abbrOutputButton, pickRefPathButton;
00684 
00685    // Create original buttons
00686    SoXtExaminerViewer::createViewerButtons(parent, buttonlist);
00687 
00688    // Handle disappearing button caused by SoXtExaminerViewer::setCamera
00689    Widget emptyButton = XtVaCreateManagedWidget("", xmPushButtonWidgetClass,
00690                                                 parent, NULL);
00691    buttonlist->append(emptyButton);
00692 
00693    // Left arrow that goes back one view point on click
00694    n = 0;
00695    XtSetArg(args[n], XmNtopPosition, 1);        n++;
00696    XtSetArg(args[n], XmNbottomPosition, 2);     n++;
00697    XtSetArg(args[n], XmNleftPosition, 0);       n++;
00698    XtSetArg(args[n], XmNrightPosition, 1);      n++;
00699    XtSetArg(args[n], XmNarrowDirection, XmARROW_LEFT);  n++;
00700    XtSetArg(args[n], XmNsensitive, False);      n++;
00701    prevViewPtButton = XmCreateArrowButtonGadget(parent, (char *) "ArrowL",
00702                                                 args, n);
00703    XtManageChild(prevViewPtButton);
00704    XtAddCallback(prevViewPtButton, XmNactivateCallback,
00705                  G4OpenInventorXtExaminerViewer::prevViewPtCB, this);
00706    buttonlist->append(prevViewPtButton);
00707 
00708    // Right arrow that goes forward one view point on click
00709    n = 0;
00710    XtSetArg(args[n], XmNtopPosition, 1);        n++;
00711    XtSetArg(args[n], XmNbottomPosition, 2);     n++;
00712    XtSetArg(args[n], XmNleftPosition, 0);       n++;
00713    XtSetArg(args[n], XmNrightPosition, 1);      n++;
00714    XtSetArg(args[n], XmNarrowDirection, XmARROW_RIGHT); n++;
00715    XtSetArg(args[n], XmNsensitive, False);      n++;
00716    nextViewPtButton = XmCreateArrowButtonGadget(parent, (char *) "ArrowR",
00717                                                 args, n);
00718    XtManageChild(nextViewPtButton);
00719    XtAddCallback(nextViewPtButton, XmNactivateCallback,
00720                  G4OpenInventorXtExaminerViewer::nextViewPtCB, this);
00721    buttonlist->append(nextViewPtButton);
00722 
00723    // Save button for storing current camera parameters
00724    saveViewPtButton = XtVaCreateManagedWidget("Save", xmPushButtonWidgetClass,
00725                                               parent, NULL);
00726    XtAddCallback(saveViewPtButton, XmNactivateCallback,
00727                  G4OpenInventorXtExaminerViewer::saveViewPtCB, this);
00728    Pixmap saveVP, saveVP_ins;
00729    saveVP = SoXtInternal::createPixmapFromXpm(saveViewPtButton,
00730                                               saveViewPt_xpm);
00731    saveVP_ins = SoXtInternal::createPixmapFromXpm(saveViewPtButton,
00732                                                   saveViewPt_xpm, TRUE);
00733    XtVaSetValues(saveViewPtButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
00734                  saveVP, XmNselectPixmap, saveVP, XmNlabelInsensitivePixmap,
00735                  saveVP_ins, XmNselectInsensitivePixmap, saveVP_ins, NULL);
00736    buttonlist->append(saveViewPtButton);
00737 
00738    // Toggle button to get abbreviated output
00739    abbrOutputButton = XtVaCreateManagedWidget("Abbr",
00740                                               xmToggleButtonWidgetClass, parent, XmNindicatorOn, False, NULL);
00741    XtAddCallback(abbrOutputButton, XmNdisarmCallback, G4OpenInventorXtExaminerViewer::abbrOutputCB,
00742                  this);
00743    Pixmap consolexpm, consolexpm_ins;
00744    consolexpm = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
00745                                                   console_xpm);
00746    consolexpm_ins = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
00747                                                       console_xpm, TRUE);
00748    XtVaSetValues(abbrOutputButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
00749                  consolexpm, XmNselectPixmap, consolexpm, XmNlabelInsensitivePixmap,
00750                  consolexpm_ins, XmNselectInsensitivePixmap, consolexpm_ins, NULL);
00751    buttonlist->append(abbrOutputButton);
00752 
00753    // Button for selecting the beam that will act as reference path
00754    pickRefPathButton = XtVaCreateManagedWidget("Refpath", xmPushButtonWidgetClass,
00755                                                parent, NULL);
00756    XtAddCallback(pickRefPathButton, XmNactivateCallback,
00757                  G4OpenInventorXtExaminerViewer::pickRefPathCB, this);
00758    Pixmap favoritesxpm, favoritesxpm_ins;
00759    favoritesxpm = SoXtInternal::createPixmapFromXpm(pickRefPathButton,
00760                                                     favorites_xpm);
00761    favoritesxpm_ins = SoXtInternal::createPixmapFromXpm(pickRefPathButton,
00762                                                         favorites_xpm, TRUE);
00763    XtVaSetValues(pickRefPathButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
00764        favoritesxpm, XmNselectPixmap, favoritesxpm, XmNlabelInsensitivePixmap,
00765        favoritesxpm_ins, XmNselectInsensitivePixmap, favoritesxpm_ins, NULL);
00766    buttonlist->append(pickRefPathButton);
00767 
00768 }

Widget G4OpenInventorXtExaminerViewer::getMenu (  )  [inline]

Definition at line 90 of file G4OpenInventorXtExaminerViewer.hh.

00090 { return fileMenu; }

Widget G4OpenInventorXtExaminerViewer::getMenuBar (  )  [inline]

Definition at line 89 of file G4OpenInventorXtExaminerViewer.hh.

00089 { return menuBar; }

bool G4OpenInventorXtExaminerViewer::loadViewPts (  )  [protected]

Definition at line 3301 of file G4OpenInventorXtExaminerViewer.cc.

Referenced by afterRealizeHook().

03302 {
03303    bool error = false;
03304    viewPtData tmp;
03305    std::string token;
03306    SbVec3f axis;
03307    SbRotation orient;
03308    float x, y, z, angle;
03309 
03310    // Gets the last view point accessed, stored in the first line of the data file.
03311    fileIn >> token;
03312    parseString<int>(viewPtIdx, token, error);
03313    getline(fileIn, token); // Remove "\n"
03314    // Converts data from string type into necessary types
03315    while (getline(fileIn, token)) {
03316 
03317       int end = token.find_last_not_of(' '); // Remove padded spaces
03318       token = token.substr(0, end + 1);
03319 
03320       char *vpName = new char[token.size() + 1];
03321       strcpy(vpName, token.c_str());
03322       tmp.viewPtName = vpName;
03323       fileIn >> token;
03324 
03325       parseString<float>(x, token, error);
03326       fileIn >> token;
03327       parseString<float>(y, token, error);
03328       fileIn >> token;
03329       parseString<float>(z, token, error);
03330       fileIn >> token;
03331       tmp.position = axis.setValue(x, y, z);
03332 
03333       parseString<float>(x, token, error);
03334       fileIn >> token;
03335       parseString<float>(y, token, error);
03336       fileIn >> token;
03337       parseString<float>(z, token, error);
03338       fileIn >> token;
03339       parseString<float>(angle, token, error);
03340       fileIn >> token;
03341       orient.setValue(axis.setValue(x, y, z), angle);
03342       tmp.orientation = orient.getValue();
03343 
03344       int camType;
03345       parseString<int>(camType, token, error);
03346       fileIn >> token;
03347       tmp.camType = (CameraType) camType;
03348 
03349       parseString<float>(tmp.height, token, error);
03350       fileIn >> token;
03351       parseString<float>(tmp.focalDistance, token, error);
03352       fileIn >> token;
03353       parseString<float>(tmp.nearDistance, token, error);
03354       fileIn >> token;
03355       parseString<float>(tmp.farDistance, token, error);
03356       fileIn >> token;
03357       parseString<int>(tmp.viewportMapping, token, error);
03358       fileIn >> token;
03359       parseString<float>(tmp.aspectRatio, token, error);
03360 
03361       getline(fileIn, token); // To remove "\n" characters
03362       getline(fileIn, token);
03363 
03364       if (error) {
03365          viewPtIdx = 0;
03366          viewPtList.clear();
03367          return false;
03368       }
03369       viewPtList.push_back(tmp);
03370    }
03371 
03372    return true;
03373 }

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

Definition at line 893 of file G4OpenInventorXtExaminerViewer.cc.

References camDir, and camUpVec.

Referenced by processSoEvent().

00894 {
00895 
00896    SoCamera *cam = getCamera();
00897    SbVec3f p1, p2;       // The particle moves from p1 to p2
00898    SbVec3f particleDir;  // Direction vector from p1 to p2
00899    SbVec3f camPosNew;    // New position of the camera
00900 
00901    if(refParticleTrajectory.size() == 0) {
00902       //refParticleTrajectory hasn't been set yet
00903       if(dist)
00904          distance = dist;
00905       else
00906          distance = (cam->position.getValue() - center).length();
00907 
00908       cam->position.setValue(center + offsetFromCenter*distance);
00909       cam->focalDistance = (cam->position.getValue() - center).length();
00910       cam->pointAt(center, upVector);
00911    }
00912    else{
00913 
00914       // If we move forward past the last trajectory point,
00915       // go back to the beginning
00916       if (refParticleIdx >= (int) refParticleTrajectory.size() - 1) {
00917          prevPt = refParticleTrajectory[refParticleIdx - step];
00918          dist = (prevPt - cam->position.getValue()).length();
00919          refParticleIdx = 0;
00920       }
00921       // If we move backward past the beginning,
00922       // go to the last trajectory point
00923       if (refParticleIdx < 0) {
00924          prevPt = refParticleTrajectory[refParticleIdx + step];
00925          dist = (prevPt - cam->position.getValue()).length();
00926          refParticleIdx = refParticleTrajectory.size() - 2;
00927       }
00928 
00929       // Set start and end points
00930       p1 = refParticleTrajectory[refParticleIdx];
00931       p2 = refParticleTrajectory[refParticleIdx + step];
00932 
00933       // Get the direction from p1 to p2
00934       particleDir = p2 - p1;
00935       particleDir.normalize();
00936 
00937       if(prevParticleDir == SbVec3f(0,0,0)){
00938          // First time entering BEAMLINE mode, look at
00939          // the element from the front, with camera upright
00940          if(lookdown)
00941             camDir = SbVec3f(0,0,1);
00942          else
00943             camDir = SbVec3f(1,0,0);
00944          camUpVec = SbVec3f(0,1,0);
00945 
00946          // In case the start of the goes in a
00947          // direction other than +z, rotate the camera accordingly
00948          SbRotation rot(SbVec3f(0,0,1), particleDir);
00949          rot.multVec(camDir, camDir);
00950          rot.multVec(camUpVec, camUpVec);
00951 
00952       }
00953       else if(particleDir != prevParticleDir) {
00954          // The beamline has changed direction
00955 
00956          SbRotation rot(prevParticleDir, particleDir);
00957          rot.multVec(camDir, camDir);
00958          rot.multVec(camUpVec, camUpVec);
00959 
00960       }
00961 
00962       if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
00963          if (!dist)
00964             distance = (prevPt - cam->position.getValue()).length();
00965          else
00966             distance = dist;
00967       }
00968 
00969       if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
00970          if (!dist)
00971             distance = (prevPt - cam->position.getValue()).length();
00972          else
00973             distance = dist;
00974       }
00975 
00976 
00977       float x,y,z;
00978       prevPt.getValue(x,y,z);
00979 
00980 
00981       if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
00982          camPosNew = p2 - (camDir*distance);
00983       }
00984       if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
00985          camPosNew = p2 - (camDir);
00986       }
00987 
00988       cam->position = camPosNew;
00989       cam->pointAt(p2, camUpVec);
00990       // FWJ Disabled: zooms out the Persp camera much too far
00991       // and can't recover by zooming in!
00992       //      cam->focalDistance = (p2 - camPosNew).length();
00993 
00994       p2.getValue(x,y,z);
00995       camPosNew.getValue(x,y,z);
00996 
00997       prevParticleDir = particleDir;
00998       prevPt = p1; // For accurate distance calculation
00999 
01000    }
01001 
01002 }

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

Definition at line 3379 of file G4OpenInventorXtExaminerViewer.cc.

03381 {
03382    std::istringstream str(s);
03383    if ((str >> t).fail())
03384       error = true;
03385 }

SbBool G4OpenInventorXtExaminerViewer::processSoEvent ( const SoEvent *const   event  )  [protected, virtual]

Definition at line 1256 of file G4OpenInventorXtExaminerViewer.cc.

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

01256                                                                               {
01257    SoCamera *cam = getCamera();
01258    const SoType type(ev->getTypeId());
01259 
01260    if (type.isDerivedFrom(SoMouseButtonEvent::getClassTypeId())) {
01261       SoMouseButtonEvent * me = (SoMouseButtonEvent *) ev;
01262 
01263       if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
01264           || currentState == PAUSED_ANIMATION) {
01265          switch (me->getButton()) {
01266          case SoMouseButtonEvent::BUTTON4: // Scroll wheel up
01267             if (me->getState() == SoButtonEvent::DOWN) {
01268                if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
01269                   float hAngle =
01270                      ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
01271                   ((SoPerspectiveCamera *) cam)->heightAngle = hAngle
01272                      + 0.01f;
01273                   return TRUE;
01274                } else if (cam->isOfType(
01275                                         SoOrthographicCamera::getClassTypeId())) {
01276                   float height =
01277                      ((SoOrthographicCamera *) cam)->height.getValue();
01278                   ((SoOrthographicCamera *) cam)->height = height + 5;
01279                   return TRUE;
01280                }
01281             }
01282             break;
01283          case SoMouseButtonEvent::BUTTON5: // Scroll wheel down
01284             if (me->getState() == SoButtonEvent::DOWN) {
01285                if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
01286                   float hAngle =
01287                      ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
01288                   if (hAngle > 0.01)
01289                      ((SoPerspectiveCamera *) cam)->heightAngle = hAngle
01290                         - 0.01f;
01291                   return TRUE;
01292                } else if (cam->isOfType(
01293                                         SoOrthographicCamera::getClassTypeId())) {
01294                   float height =
01295                      ((SoOrthographicCamera *) cam)->height.getValue();
01296                   if (height > 5)
01297                      ((SoOrthographicCamera *) cam)->height = height - 5;
01298                   return TRUE;
01299                }
01300             }
01301             break;
01302          default:
01303             break;
01304          }
01305       }
01306       if (currentState == GENERAL) {
01307 
01308       }
01309    }
01310 
01311    if (type.isDerivedFrom(SoKeyboardEvent::getClassTypeId())) {
01312       SoKeyboardEvent * ke = (SoKeyboardEvent *) ev;
01313 
01314       if (SoKeyboardEvent::isKeyPressEvent(ev, ke->getKey())) {
01315          switch (ke->getKey()) {
01316          case SoKeyboardEvent::LEFT_SHIFT:
01317             this->lshiftdown = true;
01318             return TRUE;
01319          case SoKeyboardEvent::RIGHT_SHIFT:
01320             this->rshiftdown = true;
01321             return TRUE;
01322          case SoKeyboardEvent::LEFT_CONTROL:
01323             this->lctrldown = true;
01324             return TRUE;
01325          case SoKeyboardEvent::RIGHT_CONTROL:
01326             this->rctrldown = true;
01327             return TRUE;
01328          case SoKeyboardEvent::SPACE:
01329             if (currentState == ANIMATION
01330                 || currentState == REVERSED_ANIMATION) {
01331                beforePausing = currentState;
01332                currentState = PAUSED_ANIMATION;
01333                if (animateSensor->isScheduled())
01334                   animateSensor->unschedule();
01335                return TRUE;
01336             } else if (currentState == PAUSED_ANIMATION) {
01337                if (maxSpeed) {
01338                   if ((beforePausing == ANIMATION
01339                        && refParticleIdx
01340                        < (int) refParticleTrajectory.size() - 1)
01341                       || (beforePausing == REVERSED_ANIMATION
01342                           && refParticleIdx > 0)) {
01343                      currentState = beforePausing;
01344                      animateRefParticle();
01345                   }
01346                }
01347                return TRUE;
01348             }
01349             break;
01350          case SoKeyboardEvent::ESCAPE:
01351             if (currentState == ANIMATION
01352                 || currentState == REVERSED_ANIMATION
01353                 || currentState == PAUSED_ANIMATION) {
01354 
01355                if (animateSensor->isScheduled())
01356                   animateSensor->unschedule();
01357                currentState = prevState;
01358                refParticleIdx = prevRefIdx;
01359                setSuperimpositionEnabled(superimposition, FALSE);
01360                maxSpeed = 0.0f;
01361                step = 1;
01362 
01363                scheduleRedraw();
01364                if (currentState == VIEWPOINT) {
01365                   setSuperimpositionEnabled(superimposition, TRUE);
01366                   axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
01367                   animSpeedOutlineSwitch->whichChild.setValue(
01368                                                               SO_SWITCH_NONE);
01369                   animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
01370 
01371                   scheduleRedraw();
01372                }
01373                restoreCamera();
01374                return TRUE;
01375             }
01376             break;
01377          case SoKeyboardEvent::DELETE:
01378             if (viewPtList.size()
01379                 && (currentState != ANIMATION
01380                     || currentState != REVERSED_ANIMATION
01381                     || currentState != PAUSED_ANIMATION)) {
01382                String dialogName = (char *) "Delete Viewpoint";
01383                std::string msg = "Are you sure you want to delete current viewpoint?";
01384                warningMsgDialog(msg, dialogName, deleteViewPtCB);
01385                return TRUE;
01386             }
01387             break;
01388          case SoKeyboardEvent::LEFT_ARROW:
01389             switch (currentState) {
01390             case BEAMLINE:
01391                if ((this->lshiftdown)   || (this->rshiftdown)){
01392                   refParticleIdx -= step;
01393                   moveCamera();
01394                }
01395                else if ((this->lctrldown)       || (this->rctrldown)){
01396                   if (SoXtExaminerViewer::isAnimating())
01397                      stopAnimating();
01398                   prevState = currentState;
01399                   currentState = ROTATING;
01400                   animateBtwPtsPeriod = 0.08f;
01401 
01402                   SbVec3f tmp = camDir;
01403                   tmp.negate();
01404                   rotAxis = tmp;
01405 
01406                   rotCnt = ROT_CNT;
01407                   moveCamera(); // To make sure camera is perpendicular to the beamline
01408 
01409                   rotateCamera();
01410                }
01411                else{
01412                   if (SoXtExaminerViewer::isAnimating())
01413                      stopAnimating();
01414                   prevState = currentState;
01415                   currentState = ROTATING;
01416                   animateBtwPtsPeriod = 0.08f;
01417 
01418                   SbVec3f tmp = camUpVec;
01419                   tmp.negate();
01420                   rotAxis = tmp;
01421 
01422                   rotCnt = ROT_CNT;
01423                   moveCamera(); // To make sure camera is perpendicular to the beamline
01424 
01425                   rotateCamera();
01426 
01427                }
01428                return TRUE;
01429 
01430             case ANIMATION:
01431             case REVERSED_ANIMATION:
01432                left_right -= 1.5f;
01433                return TRUE;
01434             case PAUSED_ANIMATION:
01435                left_right -= 1.5f;
01436                setStartingPtForAnimation();
01437                cam->position = myCam->position;
01438                return TRUE;
01439             case GENERAL:
01440             case VIEWPOINT:
01441                if ((!this->lshiftdown) && (!this->rshiftdown)) {
01442                   // Using this allows us to look around without
01443                   // changing the camera parameters (camDir, camUpVec)
01444                   this->bottomWheelMotion(
01445                                           this->getBottomWheelValue() + 0.1f);
01446 
01447                   return TRUE;
01448                }
01449                break;
01450             case ROTATING:
01451                // For this state, let the keyboard event
01452                // be handled by superclass
01453                break;
01454             default:
01455                SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
01456                                   "Unhandled viewer state");
01457                break;
01458             }
01459             break;
01460 
01461          case SoKeyboardEvent::RIGHT_ARROW:
01462             switch(currentState){
01463             case BEAMLINE:
01464                if ((this->lshiftdown)   || (this->rshiftdown)){
01465                   refParticleIdx += step;
01466                   moveCamera();
01467                }
01468                else if ((this->lctrldown)       || (this->rctrldown)){
01469                   if (SoXtExaminerViewer::isAnimating())
01470                      stopAnimating();
01471                   prevState = currentState;
01472                   currentState = ROTATING;
01473                   animateBtwPtsPeriod = 0.08f;
01474 
01475                   rotAxis = camDir;
01476 
01477                   rotCnt = ROT_CNT;
01478                   moveCamera(); // To make sure camera is perpendicular to the beamline
01479 
01480                   rotateCamera();
01481                }
01482                else{
01483                   if (SoXtExaminerViewer::isAnimating())
01484                      stopAnimating();
01485                   prevState = currentState;
01486                   currentState = ROTATING;
01487                   animateBtwPtsPeriod = 0.08f;
01488 
01489                   rotAxis = camUpVec;
01490 
01491                   rotCnt = ROT_CNT;
01492                   moveCamera(); // To make sure camera is perpendicular to the beamline
01493 
01494                   rotateCamera();
01495                }
01496                return TRUE;
01497 
01498             case ANIMATION:
01499             case REVERSED_ANIMATION:
01500                left_right += 1.5f;
01501                return TRUE;
01502             case PAUSED_ANIMATION:
01503                left_right += 1.5f;
01504                setStartingPtForAnimation();
01505                cam->position = myCam->position;
01506                return TRUE;
01507             case GENERAL:
01508             case VIEWPOINT:
01509                if ((!this->lshiftdown) && (!this->rshiftdown)) {
01510                   // Using this allows us to look around without
01511                   // changing the camera parameters (camDir, camUpVec)
01512                   this->bottomWheelMotion(
01513                                           this->getBottomWheelValue() - 0.1f);
01514                   return TRUE;
01515                }
01516                break;
01517             case ROTATING:
01518                // For this state, let the keyboard event
01519                // be handled by superclass
01520                break;
01521             default:
01522                SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
01523                                   "Unhandled viewer state");
01524                break;
01525             }
01526             break;
01527 
01528          case SoKeyboardEvent::DOWN_ARROW:
01529             switch(currentState){
01530             case BEAMLINE:
01531 
01532                if ((this->lshiftdown)   || (this->rshiftdown)){
01533                   refParticleIdx -= step;
01534                   moveCamera();
01535                }
01536                else{
01537                   if (SoXtExaminerViewer::isAnimating())
01538                      stopAnimating();
01539                   prevState = currentState;
01540                   currentState = ROTATING;
01541                   animateBtwPtsPeriod = 0.08f;
01542 
01543                   rotAxis = camDir.cross(camUpVec);
01544 
01545                   rotCnt = ROT_CNT;
01546                   moveCamera(); // To make sure camera is perpendicular to the beamline
01547 
01548                   rotateCamera();
01549 
01550                }
01551                return TRUE;
01552 
01553             case ANIMATION:
01554             case REVERSED_ANIMATION:
01555                up_down -= 1.5f;
01556                return TRUE;
01557             case PAUSED_ANIMATION:
01558                up_down -= 1.5f;
01559                setStartingPtForAnimation();
01560                cam->position = myCam->position;
01561                return TRUE;
01562             case GENERAL:
01563             case VIEWPOINT:
01564                // Using this allows us to look around without
01565                // changing the camera parameters (camDir, camUpVec)
01566                if ((!this->lshiftdown) && (!this->rshiftdown)) {
01567                   this->leftWheelMotion(this->getLeftWheelValue() - 0.1f);
01568                   return TRUE;
01569                }
01570                break;
01571             case ROTATING:
01572                // For this state, let the keyboard event
01573                // be handled by superclass
01574                break;
01575             default:
01576                SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
01577                                   "Unhandled viewer state");
01578                break;
01579             }
01580             break;
01581 
01582          case SoKeyboardEvent::UP_ARROW:
01583             switch(currentState){
01584             case BEAMLINE:
01585                if ((this->lshiftdown)   || (this->rshiftdown)){
01586                   refParticleIdx -= step;
01587                   moveCamera();
01588                }
01589                else{
01590                   if (SoXtExaminerViewer::isAnimating())
01591                      stopAnimating();
01592                   prevState = currentState;
01593                   currentState = ROTATING;
01594                   animateBtwPtsPeriod = 0.08f;
01595 
01596                   rotAxis = camUpVec.cross(camDir);
01597 
01598                   rotCnt = ROT_CNT;
01599                   moveCamera();
01600 
01601                   rotateCamera();
01602 
01603 
01604                }
01605                return TRUE;
01606             case ANIMATION:
01607             case REVERSED_ANIMATION:
01608                up_down += 1.5f;
01609                return TRUE;
01610             case PAUSED_ANIMATION:
01611                up_down += 1.5f;
01612                setStartingPtForAnimation();
01613                cam->position = myCam->position;
01614                return TRUE;
01615             case GENERAL:
01616             case VIEWPOINT:
01617                // Using this allows us to look around without
01618                // changing the camera parameters (camDir, camUpVec)
01619                if ((!this->lshiftdown) && (!this->rshiftdown)) {
01620                   this->leftWheelMotion(this->getLeftWheelValue() + 0.1f);
01621                   return TRUE;
01622                }
01623                break;
01624             case ROTATING:
01625                // For this state, let the keyboard event
01626                // be handled by superclass
01627                break;
01628             default:
01629                SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
01630                                   "Unhandled viewer state");
01631                break;
01632             }
01633             break;
01634 
01635          case SoKeyboardEvent::PAGE_UP:
01636             switch(currentState){
01637             case BEAMLINE:
01638                if (step < (int) refParticleTrajectory.size() / 5) // Magic number
01639                   step++;
01640                return TRUE;
01641             case ANIMATION:
01642                incSpeed();
01643                maxSpeed += SPEED_INDICATOR_STEP;
01644                if (maxSpeed > 0.8)
01645                   maxSpeed = MAX_SPEED_INDICATOR;
01646                scheduleRedraw();
01647 
01648                return TRUE;
01649             case REVERSED_ANIMATION:
01650                if(!animateSensor->isScheduled()){
01651                   currentState = ANIMATION;
01652                   if (refParticleIdx
01653                       < (int) refParticleTrajectory.size() - 1) {
01654                      refParticleIdx++;
01655                      maxSpeed = SPEED_INDICATOR_STEP;
01656                      scheduleRedraw();
01657                      animateRefParticle();
01658                   }
01659                }
01660                else{
01661                   maxSpeed += SPEED_INDICATOR_STEP;
01662                   decSpeed();
01663                   scheduleRedraw();
01664                }
01665                return TRUE;
01666             case PAUSED_ANIMATION:
01667                maxSpeed += SPEED_INDICATOR_STEP;
01668                if (maxSpeed > 0.8)
01669                   maxSpeed = MAX_SPEED_INDICATOR;
01670 
01671                if (beforePausing == ANIMATION) {
01672                   incSpeed();
01673                } else {
01674                   decSpeed();
01675                   if (animateBtwPtsPeriod >= MIN_SPEED)
01676                      beforePausing = ANIMATION;
01677                }
01678 
01679                scheduleRedraw();
01680                return TRUE;
01681             default:    //fall through
01682                break;
01683             }
01684             break;
01685 
01686          case SoKeyboardEvent::PAGE_DOWN:
01687             switch(currentState){
01688             case BEAMLINE:
01689                if (step > 1)
01690                   step--;
01691                return TRUE;
01692             case ANIMATION:
01693                if(!animateSensor->isScheduled()){
01694                   currentState = REVERSED_ANIMATION;
01695                   if (refParticleIdx > 1) {
01696                      refParticleIdx--;
01697                      maxSpeed = -SPEED_INDICATOR_STEP;
01698                      scheduleRedraw();
01699                      animateRefParticle();
01700                   }
01701                }
01702                else{
01703                   maxSpeed -= SPEED_INDICATOR_STEP;
01704                   decSpeed();
01705                   scheduleRedraw();
01706                }
01707                return TRUE;
01708             case REVERSED_ANIMATION:
01709                incSpeed();
01710                maxSpeed -= SPEED_INDICATOR_STEP;
01711                if (maxSpeed < -0.8)
01712                   maxSpeed = -MAX_SPEED_INDICATOR;
01713                scheduleRedraw();
01714                return TRUE;
01715             case PAUSED_ANIMATION:
01716                maxSpeed -= SPEED_INDICATOR_STEP;
01717                if (maxSpeed < -0.8)
01718                   maxSpeed = -MAX_SPEED_INDICATOR;
01719                if (beforePausing == REVERSED_ANIMATION) {
01720                   incSpeed();
01721                } else {
01722                   decSpeed();
01723                   if (animateBtwPtsPeriod >= MIN_SPEED)
01724                      beforePausing = REVERSED_ANIMATION;
01725                }
01726                scheduleRedraw();
01727                return TRUE;
01728             default:
01729                //fall through
01730                break;
01731             }
01732             break;
01733 
01734          case SoKeyboardEvent::E:
01735             this->escapeCallback(this->examinerObject);
01736             break;
01737 
01738          default:
01739             break; // To get rid of compiler warnings
01740          }
01741       }
01742       if (SoKeyboardEvent::isKeyReleaseEvent(ev, ke->getKey())) {
01743          switch (ke->getKey()) {
01744          case SoKeyboardEvent::LEFT_SHIFT:
01745             this->lshiftdown = false;
01746             return TRUE;
01747          case SoKeyboardEvent::RIGHT_SHIFT:
01748             this->rshiftdown = false;
01749             return TRUE;
01750          case SoKeyboardEvent::LEFT_CONTROL:
01751             this->lctrldown = false;
01752             return TRUE;
01753          case SoKeyboardEvent::RIGHT_CONTROL:
01754             this->rctrldown = false;
01755             return TRUE;
01756          default:
01757             break;
01758          }
01759       }
01760    }
01761 
01762    if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
01763        || currentState == ROTATING)
01764       return FALSE;
01765    else
01766       return SoXtExaminerViewer::processSoEvent(ev);
01767 }

void G4OpenInventorXtExaminerViewer::rotateCamera (  )  [protected]

Definition at line 866 of file G4OpenInventorXtExaminerViewer.cc.

References camDir, camUpVec, and ROT_CNT.

Referenced by processSoEvent().

00867 {
00868    SoCamera *cam = getCamera();
00869 
00870    SbRotation rot(rotAxis, M_PI / (2 * ROT_CNT));
00871    rot.multVec(camDir, camDir);
00872    rot.multVec(camUpVec, camUpVec);
00873 
00874    SbVec3f camPosNew = prevPt - (camDir*distance);
00875    cam->position = camPosNew;
00876    cam->pointAt(prevPt, camUpVec);
00877    cam->focalDistance = (prevPt - camPosNew).length();
00878 
00879    rotCnt--;
00880 
00881    if (animateSensorRotation->isScheduled()) {
00882       animateSensorRotation->unschedule();
00883    }
00884 
00885    animateSensorRotation->setBaseTime(SbTime::getTimeOfDay());
00886    animateSensorRotation->setInterval(SbTime(0.02));
00887    animateSensorRotation->schedule();
00888 
00889 }

void G4OpenInventorXtExaminerViewer::updateViewParams ( SoKeyboardEvent::Key   )  [protected]

void G4OpenInventorXtExaminerViewer::warningMsgDialog ( std::string  ,
String  ,
XtCallbackProc   
)

Definition at line 3564 of file G4OpenInventorXtExaminerViewer.cc.

Referenced by afterRealizeHook(), and processSoEvent().

03567 {
03568    Arg args[5];
03569    unsigned int n;
03570    XmString warningMsg;
03571 
03572    warningMsg = XmStringCreateLocalized((char *)msg.c_str());
03573 
03574    n = 0;
03575    XtSetArg(args[n], XmNmessageString, warningMsg);     n++;
03576    Widget warningDialog = XmCreateWarningDialog(getParentWidget(), dialogName, args, n);
03577    if (cb)
03578       XtAddCallback(warningDialog, XmNokCallback, cb, this);
03579 
03580    XmStringFree(warningMsg);
03581 
03582    XtVaSetValues (warningDialog, XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL, NULL);
03583    XtUnmanageChild(XtNameToWidget(warningDialog, "Help"));
03584    XtUnmanageChild(XtNameToWidget(warningDialog, "Cancel"));
03585 
03586    XtManageChild(warningDialog);
03587 }


Friends And Related Function Documentation

friend class HookEventProcState [friend]

Definition at line 136 of file G4OpenInventorXtExaminerViewer.hh.


Field Documentation

bool G4OpenInventorXtExaminerViewer::abbrOutputFlag

Definition at line 101 of file G4OpenInventorXtExaminerViewer.hh.

SbVec3f G4OpenInventorXtExaminerViewer::camDir [protected]

Definition at line 123 of file G4OpenInventorXtExaminerViewer.hh.

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

SbVec3f G4OpenInventorXtExaminerViewer::camUpVec [protected]

Definition at line 122 of file G4OpenInventorXtExaminerViewer.hh.

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

std::string G4OpenInventorXtExaminerViewer::curEltName [protected]

Definition at line 121 of file G4OpenInventorXtExaminerViewer.hh.

bool G4OpenInventorXtExaminerViewer::pickRefPathFlag

Definition at line 102 of file G4OpenInventorXtExaminerViewer.hh.

std::string G4OpenInventorXtExaminerViewer::saveRefCoordsFileName

Definition at line 96 of file G4OpenInventorXtExaminerViewer.hh.

Widget G4OpenInventorXtExaminerViewer::saveRefCoordsWidget

Definition at line 97 of file G4OpenInventorXtExaminerViewer.hh.

std::string G4OpenInventorXtExaminerViewer::saveScenegraphFileName

Definition at line 94 of file G4OpenInventorXtExaminerViewer.hh.

Widget G4OpenInventorXtExaminerViewer::saveScenegraphWidget

Definition at line 95 of file G4OpenInventorXtExaminerViewer.hh.

bool G4OpenInventorXtExaminerViewer::viewingBeforePickRef

Definition at line 103 of file G4OpenInventorXtExaminerViewer.hh.

bool G4OpenInventorXtExaminerViewer::warningFlag

Definition at line 92 of file G4OpenInventorXtExaminerViewer.hh.


The documentation for this class was generated from the following files:
Generated on Mon May 27 17:52:47 2013 for Geant4 by  doxygen 1.4.7