Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
G4OpenInventorXtExaminerViewer.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// Open Inventor Xt Extended Viewer - 30 Oct 2012
28// Rastislav Ondrasek, Pierre-Luc Gagnon, Frederick Jones TRIUMF
29
30#include <stdio.h>
31#include <string.h>
32#include <string>
33#include <sstream>
34#include <cmath>
35#include <iostream>
36#include <iomanip>
37#include <algorithm> // For using sort on a vector
38#include <X11/keysym.h>
39
40#include <Xm/Xm.h>
41#include <Xm/Text.h>
42#include <Xm/List.h>
43#include <Xm/MessageB.h>
44#include <Xm/PushB.h>
45#include <Xm/ToggleB.h>
46#include <Xm/CascadeB.h>
47#include <Xm/ArrowBG.h>
48#include <Xm/Form.h>
49#include <Xm/RowColumn.h>
50#include <Xm/FileSB.h>
51#include <Xm/SelectioB.h>
52#include <Xm/Protocols.h>
53#include <Xm/SeparatoG.h>
54#include <Xm/DialogS.h>
55#include <Xm/PanedW.h>
56#include <Xm/LabelG.h>
57#include <Xm/Scale.h>
58#include <Xm/DrawingA.h>
59
60#include <Inventor/Xt/SoXt.h>
61//#include <Inventor/Xt/SoXtInternal.h>
62#include <Inventor/Xt/SoXtCursor.h>
63#include <Inventor/events/SoKeyboardEvent.h>
64#include <Inventor/events/SoMouseButtonEvent.h>
65#include <Inventor/events/SoLocation2Event.h>
66#include <Inventor/nodes/SoSeparator.h>
67#include <Inventor/nodes/SoOrthographicCamera.h>
68#include <Inventor/nodes/SoPerspectiveCamera.h>
69#include <Inventor/nodes/SoEventCallback.h>
70#include <Inventor/nodes/SoLineSet.h>
71#include <Inventor/nodes/SoMaterial.h>
72#include <Inventor/errors/SoDebugError.h>
73#include <Inventor/SoPickedPoint.h>
74#include <Inventor/actions/SoWriteAction.h>
75
76#include "G4OpenInventorXtExaminerViewer.hh"
77#include "wheelmouse.h" // To use mouse scrolling in dialogs
78#include "SoXtInternal.h"
79#include <Inventor/sensors/SoTimerSensor.h> // Animation
80#include <Inventor/sensors/SoNodeSensor.h> // Detect start of run
81#include "saveViewPt.h"
82#include "console.h"
83#include "favorites.h"
84
85#include "Geant4_SoPolyhedron.h"
86//#include "G4RunManager.hh"
87//#include "G4Run.hh"
88#include "G4TrajectoryPoint.hh"
89#include "G4AttHolder.hh"
90#include "G4AttCheck.hh"
91
92#include <Inventor/nodes/SoCallback.h>
93#include <Inventor/nodes/SoSwitch.h>
94#include <Inventor/nodes/SoScale.h>
95#include <Inventor/nodes/SoTranslation.h>
96#include <Inventor/actions/SoSearchAction.h>
97#include <Inventor/actions/SoGetBoundingBoxAction.h>
98
99#include <Inventor/nodes/SoCoordinate3.h>
100// For rendering distance during animation:
101#include <Inventor/nodes/SoText2.h>
102#include <Inventor/nodes/SoFont.h>
103#include <Inventor/nodes/SoPointSet.h>
104#include <Inventor/nodes/SoDrawStyle.h>
105#include <Inventor/nodes/SoBaseColor.h>
106
107// For searching for nodes within kits:
108#include <Inventor/nodekits/SoBaseKit.h>
109
110G4OpenInventorXtExaminerViewer* G4OpenInventorXtExaminerViewer::viewer = 0;
111
112static const char* thisClassName = "G4OpenInventorXtExaminerViewer";
113
114#define MIN_SPEED 2.1 // Lower number means faster
115#define START_STEP 0.3
116#define SPEED_INDICATOR_STEP 0.045
117#define MAX_SPEED_INDICATOR 0.81
118// Number of steps 90 degree rotation around an element is split into
119#define ROT_CNT 6
120
121// Public constructor
122G4OpenInventorXtExaminerViewer::G4OpenInventorXtExaminerViewer(Widget parent,
123 const char *name, SbBool embed,
124 SoXtFullViewer::BuildFlag flag, SoXtViewer::Type type) :
125 SoXtExaminerViewer(parent, name, embed, flag, type, FALSE)
126{
127// Tell GLWidget not to build just yet
128 this->constructor(TRUE);
129}
130
131// Protected constructor for classes deriving from this viewer.
132G4OpenInventorXtExaminerViewer::G4OpenInventorXtExaminerViewer(Widget parent,
133 const char *name, SbBool embed,
134 SoXtFullViewer::BuildFlag flag, SoXtViewer::Type type,
135 SbBool build) :
136 SoXtExaminerViewer(parent, name, embed, flag, type, FALSE)
137{
138 this->constructor(build);
139}
140
141// Called by all constructors to set up widgets and initialize member fields.
142void G4OpenInventorXtExaminerViewer::constructor(const SbBool build)
143{
144 setClassName(thisClassName);
145
146 hookBeamOn = new HookEventProcState(this);
147 this->newEvents = false;
148
149 fileName = ".bookmarkFile"; // Default viewpoint file name
150 viewPtIdx = -1; // index of the most recent viewpoint in viewPtList vector
151 animateSensor = new SoTimerSensor(
152 G4OpenInventorXtExaminerViewer::animateSensorCB, this);
153 animateSensorRotation = new SoTimerSensor(
154 G4OpenInventorXtExaminerViewer::animateSensorRotationCB, this);
155 animateBtwPtsPeriod = MIN_SPEED;
156 currentState = GENERAL;
157 myCam = new SoPerspectiveCamera;
158 MAX_VP_IDX = 3;
159 MAX_VP_NAME = 35; // Max length of a viewpoint name, padded with spaces
160 rotCnt = ROT_CNT; // For 90 degree rotations
161 curViewPtName = new char[MAX_VP_NAME + 1];
162 left_right = up_down = 0; // For movements around the beam during animation
163 speedStep = START_STEP; // For smoother animation speed increase/decrease
164 rotUpVec = false; // Used during scene element rotations
165 step = 1; //By default
166 // Used for moving along the beam with the
167 // mouse instead of rotating the view
168 lshiftdown = rshiftdown = false;
169 // Used for rotating the view with the camera
170 // staying in place
171 lctrldown = rctrldown = false;
172 // Used to send abbreviated output to the console when
173 abbrOutputFlag = false;
174 pickRefPathFlag = false;
175 prevColorField = NULL;
176 warningFlag = false; // We come from the warning dialog
177 viewer = this;
178 openFileDialog = newFileDialog = listsDialog = (Widget) NULL;
179 loadRefCoordsDialog = saveRefCoordsDialog = NULL;
180 loadSceneGraphDialog = saveSceneGraphDialog = NULL;
181 myElementList = NULL;
182
183 newSceneGraph = NULL;
184 zcoordSetFlag = false;
185
186 //////////////////////////SUPERIMPOSED SCENE//////////////////////////
187 searcher = NULL;
188 // Used in animation; progressively scaled for gradual speed change
189 maxSpeed = 0.0f;
190
191 static const char * superimposed[] = {
192 "#Inventor V2.1 ascii", "",
193 "Separator ",
194 "{",
195 " MaterialBinding ",
196 " {",
197 " value OVERALL",
198 " }",
199 " OrthographicCamera ",
200 " {",
201 " height 1",
202 " nearDistance 0",
203 " farDistance 1",
204 " }",
205 " DEF soxt->callback Callback { }",
206 " Separator ",
207 " {",
208 " DEF soxt->translation Translation ",
209 " {",
210 " translation 0 0 0",
211 " }",
212 " DEF soxt->scale Scale ",
213 " {",
214 " scaleFactor 1 1 1",
215 " }",
216 " DEF soxt->geometry Coordinate3 ",
217 " {",
218 " point ",
219 " [",
220 " -0.81 -0.04 0, -0.81 0 0,",
221 " -0.81 0.04 0, 0 -0.04 0,",
222 " 0 0 0, 0 0.04 0,",
223 " 0.81 -0.04 0, 0.81 0 0,",
224 " 0.81 0.04 0,",
225 " 0 0.02 0,", // idx 9
226 " 0.81 0.02 0, 0.81 -0.02 0,",
227 " 0 -0.02 0,",
228 " 0 0.01 0,", // idx 13
229 " 0.4 0.01 0, 0.4 -0.01 0,",
230 " 0 -0.01 0",
231 " ]",
232 " }",
233 // current speed indicator (outline)
234 " DEF soxt->animSpeedOutlineSwitch Switch ",
235 " {",
236 " whichChild -3",
237 " Material ",
238 " {",
239 " emissiveColor 0 0 0",
240 " }",
241 " IndexedFaceSet ",
242 " {",
243 " coordIndex ",
244 " [",
245 " 12, 11, 10, 9, -1",
246 " ]",
247 " }",
248 " }",
249 // the coordinate system
250 " DEF soxt->axisSwitch Switch ",
251 " {",
252 " whichChild -3",
253 " BaseColor ",
254 " {",
255 " rgb 1 1 1",
256 " }",
257 " IndexedLineSet ",
258 " {",
259 " coordIndex ",
260 " [",
261 " 0, 2, -1,",
262 " 3, 5, -1,",
263 " 6, 8, -1,",
264 " 1, 7, -1",
265 " ]",
266 " }",
267 " }",
268 // current speed indicator
269 " DEF soxt->animSpeedSwitch Switch ",
270 " {",
271 " whichChild -3",
272 " Material ",
273 " {",
274 " emissiveColor 0 1 0",
275 " }",
276 " IndexedFaceSet ",
277 " {",
278 " coordIndex ",
279 " [",
280 " 16, 15, 14, 13, -1",
281 " ]",
282 " }",
283 " }",
284 " }",
285 // For displaying either z position (during animation) or current viewpoint name
286 " DEF soxt->curInfoSwitch Switch ",
287 " {",
288 " whichChild -3",
289 " DEF soxt->curInfoTrans Translation ",
290 " {",
291 " translation 10 20 30 ",
292 " }",
293 " DEF soxt->curInfoFont Font ",
294 " {",
295 " name defaultFont:Bold",
296 " size 16",
297 " }",
298 " DEF soxt->curInfoText Text2 ",
299 " {",
300 " string Hello",
301 " }",
302 " }",
303 // Need to use different fields for mouseover
304 // because newlines are ignored when the scene is rendered
305 " Separator ",
306 " {",
307 " DEF soxt->mouseOverTransLogName Translation ",
308 " {",
309 " translation 0 0 0 ",
310 " }",
311 " DEF soxt->mouseOverFontLogName Font ",
312 " {",
313 " name defaultFont:Bold",
314 " size 16",
315 " }",
316 " DEF soxt->mouseOverTextLogName Text2 { } ",
317 " }",
318 " Separator ",
319 " {",
320 " DEF soxt->mouseOverTransSolid Translation ",
321 " {",
322 " translation 0 0 0 ",
323 " }",
324 " DEF soxt->mouseOverFontSolid Font ",
325 " {",
326 " name defaultFont:Bold",
327 " size 16",
328 " }",
329 " DEF soxt->mouseOverTextSolid Text2 { } ",
330 " }",
331 " Separator ",
332 " {",
333 " DEF soxt->mouseOverTransMaterial Translation ",
334 " {",
335 " translation 0 0 0 ",
336 " }",
337 " DEF soxt->mouseOverFontMaterial Font ",
338 " {",
339 " name defaultFont:Bold",
340 " size 16",
341 " }",
342 " DEF soxt->mouseOverTextMaterial Text2 { } ",
343 " }",
344 " Separator ",
345 " {",
346 " DEF soxt->mouseOverTransZPos Translation ",
347 " {",
348 " translation 0 0 0 ",
349 " }",
350 " DEF soxt->mouseOverFontZPos Font ",
351 " {",
352 " name defaultFont:Bold",
353 " size 16",
354 " }",
355 " DEF soxt->mouseOverTextZPos Text2 { } ",
356 " }",
357 "}", NULL
358 };
359
360 int i, bufsize;
361 for (i = bufsize = 0; superimposed[i]; i++)
362 bufsize += strlen(superimposed[i]) + 1;
363 char * buf = new char[bufsize + 1];
364 for (i = bufsize = 0; superimposed[i]; i++) {
365 strcpy(buf + bufsize, superimposed[i]);
366 bufsize += strlen(superimposed[i]);
367 buf[bufsize] = '\n';
368 bufsize++;
369 }
370 SoInput * input = new SoInput;
371 input->setBuffer(buf, bufsize);
372 SbBool ok = SoDB::read(input, this->superimposition);
373 (void)ok; // FWJ added to avoid compiler warning
374 assert(ok);
375 delete input;
376 delete[] buf;
377 this->superimposition->ref();
378
379 this->sscale = (SoScale *) this->getSuperimpositionNode(
380 this->superimposition, "soxt->scale");
381 this->stranslation = (SoTranslation *) this->getSuperimpositionNode(
382 this->superimposition, "soxt->translation");
383 this->sgeometry = (SoCoordinate3 *) this->getSuperimpositionNode(
384 this->superimposition, "soxt->geometry");
385 this->axisSwitch = (SoSwitch *) this->getSuperimpositionNode(
386 this->superimposition, "soxt->axisSwitch");
387 this->animSpeedOutlineSwitch = (SoSwitch *) this->getSuperimpositionNode(
388 this->superimposition, "soxt->animSpeedOutlineSwitch");
389 this->animSpeedSwitch = (SoSwitch *) this->getSuperimpositionNode(
390 this->superimposition, "soxt->animSpeedSwitch");
391 this->curInfoSwitch = (SoSwitch *) this->getSuperimpositionNode(
392 this->superimposition, "soxt->curInfoSwitch");
393 this->curInfoTrans = (SoTranslation *) this->getSuperimpositionNode(
394 this->superimposition, "soxt->curInfoTrans");
395 this->curInfoFont = (SoFont *) this->getSuperimpositionNode(
396 this->superimposition, "soxt->curInfoFont");
397 this->curInfoText = (SoText2 *) this->getSuperimpositionNode(
398 this->superimposition, "soxt->curInfoText");
399 this->mouseOverTransLogName = (SoTranslation*)this->getSuperimpositionNode(
400 this->superimposition, "soxt->mouseOverTransLogName");
401 this->mouseOverFontLogName = (SoFont *) this->getSuperimpositionNode(
402 this->superimposition, "soxt->mouseOverFontLogName");
403 this->mouseOverTextLogName = (SoText2 *) this->getSuperimpositionNode(
404 this->superimposition, "soxt->mouseOverTextLogName");
405 this->mouseOverTransSolid = (SoTranslation *) this->getSuperimpositionNode(
406 this->superimposition, "soxt->mouseOverTransSolid");
407 this->mouseOverFontSolid = (SoFont *) this->getSuperimpositionNode(
408 this->superimposition, "soxt->mouseOverFontSolid");
409 this->mouseOverTextSolid = (SoText2 *) this->getSuperimpositionNode(
410 this->superimposition, "soxt->mouseOverTextSolid");
411 this->mouseOverTransMaterial = (SoTranslation*)this->getSuperimpositionNode(
412 this->superimposition, "soxt->mouseOverTransMaterial");
413 this->mouseOverFontMaterial = (SoFont *) this->getSuperimpositionNode(
414 this->superimposition, "soxt->mouseOverFontMaterial");
415 this->mouseOverTextMaterial = (SoText2 *) this->getSuperimpositionNode(
416 this->superimposition, "soxt->mouseOverTextMaterial");
417 this->mouseOverTransZPos = (SoTranslation *) this->getSuperimpositionNode(
418 this->superimposition, "soxt->mouseOverTransZPos");
419 this->mouseOverFontZPos = (SoFont *) this->getSuperimpositionNode(
420 this->superimposition, "soxt->mouseOverFontZPos");
421 this->mouseOverTextZPos = (SoText2 *) this->getSuperimpositionNode(
422 this->superimposition, "soxt->mouseOverTextZPos");
423
424 SoCallback * cb = (SoCallback *) this->getSuperimpositionNode(
425 this->superimposition, "soxt->callback");
426 cb->setCallback(superimpositionCB, this);
427
428 this->addSuperimposition(this->superimposition);
429 this->setSuperimpositionEnabled(this->superimposition, FALSE);
430 axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
431 animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
432 animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
433
434 /////////////////////\SUPERIMPOSED SCENE///////////////////////////////////
435
436 // Build everything else like the parent viewer does
437 if (build) {
438 Widget w = buildWidget(getParentWidget());
439 setBaseWidget(w);
440
441 // Make this window a little bigger because of the extra buttons
442 // FWJ but it is already set to 600x600 by vis/open
443 // setSize(SbVec2s(500, 550));
444 }
445
446}
447
448
449// Static function that returns the pointer to G4OpenInventorXtExaminerViewer
450G4OpenInventorXtExaminerViewer *G4OpenInventorXtExaminerViewer::getObject()
451{
452 if (!viewer)
453 new G4OpenInventorXtExaminerViewer();
454 return viewer;
455}
456
457
458// This method locates a named node in the superimposed or original scene.
459SoNode *
460G4OpenInventorXtExaminerViewer::getSuperimpositionNode(SoNode *root,
461 const char * name)
462{
463 if (!this->searcher)
464 this->searcher = new SoSearchAction;
465 searcher->reset();
466 searcher->setName(SbName(name));
467 searcher->setInterest(SoSearchAction::FIRST);
468 searcher->setSearchingAll(TRUE);
469 searcher->apply(root);
470 assert(searcher->getPath());
471 return searcher->getPath()->getTail();
472}
473
474
475void G4OpenInventorXtExaminerViewer::superimpositionCB(void * closure,
476 SoAction * action)
477{
478 if (closure)
479 ((G4OpenInventorXtExaminerViewer*)closure)->superimpositionEvent(action);
480}
481
482
483// Renders and positions speed indicator and longitudinal
484// distance/viewpoint name on the drawing canvas
485void G4OpenInventorXtExaminerViewer::superimpositionEvent(SoAction * action)
486{
487
488 if (!action->isOfType(SoGLRenderAction::getClassTypeId()))
489 return;
490 SbViewportRegion vpRegion =
491 ((SoGLRenderAction *) action)->getViewportRegion();
492 SbVec2s viewportSize = vpRegion.getViewportSizePixels();
493
494 float aspect = float(viewportSize[0]) / float(viewportSize[1]);
495 float factorx = 1.0f / float(viewportSize[1]) * 220.0f;
496 float factory = factorx;
497
498 if (aspect > 1.0f) {
499 this->stranslation->translation.setValue(SbVec3f(0.0f, -0.4f, 0.0f));
500 } else {
501 this->stranslation->translation.setValue(
502 SbVec3f(0.0f, -0.4f / aspect, 0.0f));
503 factorx /= aspect;
504 factory /= aspect;
505 }
506 if (viewportSize[0] > 500)
507 factorx *= 500.0f / 400.0f;
508 else
509 factorx *= float(viewportSize[0]) / 400.0f;
510 this->sscale->scaleFactor.setValue(SbVec3f(factorx, factory, 1.0f));
511
512 float xInfo, yInfo, xMouseLogName, yMouseLogName, xMouseSolid, yMouseSolid,
513 xMouseMaterial, yMouseMaterial, xMouseZPos, yMouseZPos;
514 xInfo = -.45;
515 yInfo = .45;
516 xMouseLogName = 0.0;
517 yMouseLogName = -.75;
518 xMouseSolid = 0.0;
519 yMouseSolid = -.78;
520 xMouseMaterial = 0.0;
521 yMouseMaterial = -.81;
522 xMouseZPos = 0.0;
523 yMouseZPos = -.84;
524
525 if (aspect > 1.0f) {
526 xInfo *= aspect;
527 xMouseSolid *= aspect;
528 xMouseMaterial *= aspect;
529 this->curInfoTrans->translation.setValue(SbVec3f(xInfo, yInfo, 0.0));
530 this->mouseOverTransLogName->translation.setValue(
531 SbVec3f(xMouseLogName, yMouseLogName, 0.0));
532 this->mouseOverTransSolid->translation.setValue(
533 SbVec3f(xMouseSolid, yMouseSolid, 0.0));
534 this->mouseOverTransMaterial->translation.setValue(
535 SbVec3f(xMouseMaterial, yMouseMaterial, 0.0));
536 this->mouseOverTransZPos->translation.setValue(
537 SbVec3f(xMouseZPos, yMouseZPos, 0.0));
538 } else {
539 yInfo /= aspect;
540 yMouseSolid /= aspect;
541 yMouseMaterial /= aspect;
542 this->curInfoTrans->translation.setValue(SbVec3f(xInfo, yInfo, 0.0));
543 this->mouseOverTransLogName->translation.setValue(
544 SbVec3f(xMouseLogName, yMouseLogName, 0.0));
545 this->mouseOverTransSolid->translation.setValue(
546 SbVec3f(xMouseSolid, yMouseSolid, 0.0));
547 this->mouseOverTransMaterial->translation.setValue(
548 SbVec3f(xMouseMaterial, yMouseMaterial, 0.0));
549 this->mouseOverTransZPos->translation.setValue(
550 SbVec3f(xMouseZPos, yMouseZPos, 0.0));
551 }
552
553 if (currentState == VIEWPOINT) { // Displaying viewpoint name
554 this->curInfoFont->size.setValue(15);
555 this->curInfoFont->name.setValue("defaultFont:Italic");
556 this->curInfoText->string.setValue(SbString(curViewPtName));
557 }
558 else if(currentState == GENERAL) { // Displaying longitudinal distance
559 this->curInfoFont->size.setValue(16);
560 this->curInfoFont->name.setValue("defaultFont:Bold");
561 this->curInfoText->string.setValue(SbString(""));
562 }
563 else {
564 if (refParticleIdx < (int) refParticleTrajectory.size() - 1) {
565 this->curInfoFont->size.setValue(16);
566 this->curInfoFont->name.setValue("defaultFont:Bold");
567
568 char zPos[20];
569 sprintf(zPos, "%7.2f [m]", refZPositions[refParticleIdx] / 1000);
570
571 this->curInfoText->string.setValue(SbString(zPos));
572 }
573 }
574}
575
576
577G4OpenInventorXtExaminerViewer::~G4OpenInventorXtExaminerViewer()
578{
579 if (superimposition != NULL) {
580 removeSuperimposition(superimposition);
581 superimposition->unref();
582 superimposition = NULL;
583 }
584 if (animateSensor->isScheduled())
585 animateSensor->unschedule();
586 delete animateSensor;
587 delete sceneChangeSensor;
588
589 delete[] curViewPtName;
590 delete searcher;
591
592 viewer = 0;
593}
594
595
596// Adds a menu bar and a few menu items to the viewer.
597Widget G4OpenInventorXtExaminerViewer::buildWidget(Widget parent)
598{
599 Widget shell;
600 Atom WM_DELETE_WINDOW;
601
602 if (!parent)
603 SoDebugError::post("G4OpenInventorXtExaminerViewer::buildWidget", "Error: Parent is null.");
604
605 Arg args[10];
606 XtSetArg(args[0], XmNtopAttachment, XmATTACH_FORM);
607 XtSetArg(args[1], XmNleftAttachment, XmATTACH_FORM);
608 XtSetArg(args[2], XmNrightAttachment, XmATTACH_FORM);
609 XtSetArg(args[3], XmNbottomAttachment, XmATTACH_FORM);
610 Widget form = XmCreateForm(parent, (char *) "Form", args, 4);
611 XtManageChild(form);
612
613 shell = XtParent(form);
614 WM_DELETE_WINDOW = XInternAtom(XtDisplay(parent), "WM_DELETE_WINDOW",
615 False);
616 XmAddWMProtocolCallback(shell, WM_DELETE_WINDOW,
617 (XtCallbackProc)closeMainWindowCB, this);
618
619 XtSetArg(args[0], XmNtopAttachment, XmATTACH_FORM);
620 XtSetArg(args[1], XmNleftAttachment, XmATTACH_FORM);
621 XtSetArg(args[2], XmNrightAttachment, XmATTACH_FORM);
622 menuBar = XmCreateMenuBar(form, (char *) "MenuBar", args, 3);
623 XtManageChild(menuBar);
624
625 fileMenu = addMenu("File");
626 this->addButton(fileMenu, "Open Viewpoint File...", openViewPtFileCB);
627 addButton(fileMenu, "New Viewpoint File", newViewPtFileCB);
628 addButton(fileMenu, "Load Ref. Coords", loadRefCoordsDialogCB);
629 addButton(fileMenu, "Save Ref. Coords", saveRefCoordsDialogCB);
630 addButton(fileMenu, "Load Scene Graph", loadSceneGraphDialogCB);
631 addButton(fileMenu, "Save Scene Graph", saveSceneGraphDialogCB);
632 XtManageChild(
633 XmCreateSeparatorGadget(fileMenu, (char *) "Separator", NULL, 0));
634
635 Widget menu = addMenu("Tools");
636 addButton(menu, "Animate Ref. Particle", animateRefParticleCB);
637 addButton(menu, "Go to start of Ref path", gotoRefPathStartCB);
638 addButton(menu, "Invert Ref path", invertRefPathCB);
639
640 Widget viewerBase = SoXtFullViewer::buildWidget(form);
641
642 XtSetArg(args[0], XmNtopAttachment, XmATTACH_WIDGET);
643 XtSetArg(args[1], XmNtopWidget, menuBar);
644 XtSetArg(args[2], XmNleftAttachment, XmATTACH_FORM);
645 XtSetArg(args[3], XmNrightAttachment, XmATTACH_FORM);
646 XtSetArg(args[4], XmNbottomAttachment, XmATTACH_FORM);
647 XtSetValues(viewerBase, args, 5);
648
649 return viewerBase;
650}
651
652
653// Adds a new menu to menuBar
654Widget G4OpenInventorXtExaminerViewer::addMenu(std::string name)
655{
656 Arg args[1];
657 Widget menu = XmCreatePulldownMenu(menuBar, (char *) name.c_str(), NULL, 0);
658
659 XtSetArg(args[0], XmNsubMenuId, menu);
660 Widget w = XmCreateCascadeButton(menuBar, (char *) name.c_str(), args, 1);
661 XtManageChild(w);
662
663 return menu;
664}
665
666
667// Adds a new button to menu
668void G4OpenInventorXtExaminerViewer::addButton(Widget menu, std::string name,
669 XtCallbackProc cb)
670{
671 Widget button = XmCreatePushButton(menu, (char *) name.c_str(), NULL, 0);
672 XtManageChild(button);
673 XtAddCallback(button, XmNactivateCallback, cb, this);
674}
675
676
677// Overloaded for saving of and browsing through viewpoints.
678void G4OpenInventorXtExaminerViewer::createViewerButtons(Widget parent,
679 SbPList * buttonlist)
680{
681 int n;
682 Arg args[6];
683 Widget saveViewPtButton, abbrOutputButton, pickRefPathButton;
684
685 // Create original buttons
686 SoXtExaminerViewer::createViewerButtons(parent, buttonlist);
687
688 // Handle disappearing button caused by SoXtExaminerViewer::setCamera
689 Widget emptyButton = XtVaCreateManagedWidget("", xmPushButtonWidgetClass,
690 parent, NULL);
691 buttonlist->append(emptyButton);
692
693 // Left arrow that goes back one view point on click
694 n = 0;
695 XtSetArg(args[n], XmNtopPosition, 1); n++;
696 XtSetArg(args[n], XmNbottomPosition, 2); n++;
697 XtSetArg(args[n], XmNleftPosition, 0); n++;
698 XtSetArg(args[n], XmNrightPosition, 1); n++;
699 XtSetArg(args[n], XmNarrowDirection, XmARROW_LEFT); n++;
700 XtSetArg(args[n], XmNsensitive, False); n++;
701 prevViewPtButton = XmCreateArrowButtonGadget(parent, (char *) "ArrowL",
702 args, n);
703 XtManageChild(prevViewPtButton);
704 XtAddCallback(prevViewPtButton, XmNactivateCallback,
705 G4OpenInventorXtExaminerViewer::prevViewPtCB, this);
706 buttonlist->append(prevViewPtButton);
707
708 // Right arrow that goes forward one view point on click
709 n = 0;
710 XtSetArg(args[n], XmNtopPosition, 1); n++;
711 XtSetArg(args[n], XmNbottomPosition, 2); n++;
712 XtSetArg(args[n], XmNleftPosition, 0); n++;
713 XtSetArg(args[n], XmNrightPosition, 1); n++;
714 XtSetArg(args[n], XmNarrowDirection, XmARROW_RIGHT); n++;
715 XtSetArg(args[n], XmNsensitive, False); n++;
716 nextViewPtButton = XmCreateArrowButtonGadget(parent, (char *) "ArrowR",
717 args, n);
718 XtManageChild(nextViewPtButton);
719 XtAddCallback(nextViewPtButton, XmNactivateCallback,
720 G4OpenInventorXtExaminerViewer::nextViewPtCB, this);
721 buttonlist->append(nextViewPtButton);
722
723 // Save button for storing current camera parameters
724 saveViewPtButton = XtVaCreateManagedWidget("Save", xmPushButtonWidgetClass,
725 parent, NULL);
726 XtAddCallback(saveViewPtButton, XmNactivateCallback,
727 G4OpenInventorXtExaminerViewer::saveViewPtCB, this);
728 Pixmap saveVP, saveVP_ins;
729 saveVP = SoXtInternal::createPixmapFromXpm(saveViewPtButton,
730 saveViewPt_xpm);
731 saveVP_ins = SoXtInternal::createPixmapFromXpm(saveViewPtButton,
732 saveViewPt_xpm, TRUE);
733 XtVaSetValues(saveViewPtButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
734 saveVP, XmNselectPixmap, saveVP, XmNlabelInsensitivePixmap,
735 saveVP_ins, XmNselectInsensitivePixmap, saveVP_ins, NULL);
736 buttonlist->append(saveViewPtButton);
737
738 // Toggle button to get abbreviated output
739 abbrOutputButton = XtVaCreateManagedWidget("Abbr",
740 xmToggleButtonWidgetClass, parent, XmNindicatorOn, False, NULL);
741 XtAddCallback(abbrOutputButton, XmNdisarmCallback, G4OpenInventorXtExaminerViewer::abbrOutputCB,
742 this);
743 Pixmap consolexpm, consolexpm_ins;
744 consolexpm = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
745 console_xpm);
746 consolexpm_ins = SoXtInternal::createPixmapFromXpm(abbrOutputButton,
747 console_xpm, TRUE);
748 XtVaSetValues(abbrOutputButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
749 consolexpm, XmNselectPixmap, consolexpm, XmNlabelInsensitivePixmap,
750 consolexpm_ins, XmNselectInsensitivePixmap, consolexpm_ins, NULL);
751 buttonlist->append(abbrOutputButton);
752
753 // Button for selecting the beam that will act as reference path
754 pickRefPathButton = XtVaCreateManagedWidget("Refpath", xmPushButtonWidgetClass,
755 parent, NULL);
756 XtAddCallback(pickRefPathButton, XmNactivateCallback,
757 G4OpenInventorXtExaminerViewer::pickRefPathCB, this);
758 Pixmap favoritesxpm, favoritesxpm_ins;
759 favoritesxpm = SoXtInternal::createPixmapFromXpm(pickRefPathButton,
760 favorites_xpm);
761 favoritesxpm_ins = SoXtInternal::createPixmapFromXpm(pickRefPathButton,
762 favorites_xpm, TRUE);
763 XtVaSetValues(pickRefPathButton, XmNlabelType, XmPIXMAP, XmNlabelPixmap,
764 favoritesxpm, XmNselectPixmap, favoritesxpm, XmNlabelInsensitivePixmap,
765 favoritesxpm_ins, XmNselectInsensitivePixmap, favoritesxpm_ins, NULL);
766 buttonlist->append(pickRefPathButton);
767
768}
769
770
771// Called right after buttons and widgets get realized.
772// It sets the viewpoint last accessed.
773void G4OpenInventorXtExaminerViewer::afterRealizeHook()
774{
775 SoXtExaminerViewer::afterRealizeHook();
776
777 // Default height is used when selecting and viewing scene elements
778 // FWJ Added defaultHeight for Ortho camera
779 SoCamera *cam = getCamera();
780 if (cam) {
781 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
782 defaultHeightAngle =
783 ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
784 toggleCameraType();
785 defaultHeight =
786 ((SoOrthographicCamera *) cam)->height.getValue();
787 toggleCameraType();
788 } else {
789 defaultHeight =
790 ((SoOrthographicCamera *) cam)->height.getValue();
791 toggleCameraType();
792 cam = getCamera();
793 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId()))
794 defaultHeightAngle =
795 ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
796 toggleCameraType();
797 }
798 }
799
800 // Open the default bookmark file
801 fileIn.open(fileName.c_str());
802 if (!fileIn.fail()) {
803 if (!loadViewPts()) {
804 String dialogName = (char *) "Error Loading File";
805 std::string msg = "Wrong or corrupted input file.";
806 warningMsgDialog(msg, dialogName, NULL);
807 } else {
808 // Opens a file without erasing it
809 fileOut.open(fileName.c_str(), std::ios::in);
810 fileOut.seekp(0, std::ios::end); // For appending new data to the end
811 constructListsDialog(getParentWidget(), this, NULL); // Pop up listsDialog
812
813 if (viewPtList.size()) {
814 // FWJ disabled auto-selection of first viewpoint.
815 // Initial view should be user-controllable & not forced
816 // setViewPt();
817 XtSetSensitive(nextViewPtButton, True);
818 XtSetSensitive(prevViewPtButton, True);
819 }
820 }
821
822 fileIn.close();
823 } else {
824 // Creates a new default bookmark file
825 fileOut.open(fileName.c_str());
826 constructListsDialog(getParentWidget(), this, NULL); // Pop up listsDialog
827 }
828
829 fileIn.clear();
830
831 SoSeparator *root = (SoSeparator *) (getSceneManager()->getSceneGraph());
832 if (root == NULL)
833 SoDebugError::post("G4OpenInventorXtExaminerViewer::afterRealizeHook", "Root is null.");
834 else {
835 root->addChild(myCam); // For position/orientation calculation during animation
836 }
837
838 sceneChangeSensor = new SoNodeSensor;
839 sceneChangeSensor->setFunction(sceneChangeCB);
840 sceneChangeSensor->attach(root);
841 sceneChangeSensor->setData(this);
842
843 // Monitor mouseover events for displaying the name of scene elements
844 // An SoEventCallback is needed instead of using the default processSoEvent
845 // because that last one does not provide us with an SoPath to the object
846 // that was picked
847 SoEventCallback *moCB = new SoEventCallback;
848 moCB->addEventCallback(
849 SoLocation2Event::getClassTypeId(),
850 mouseoverCB, static_cast<void *>(this));
851 root->addChild(moCB);
852
853 // Override the default picking mechanism present in G4OpenInventorViewer
854 // because we want abbreviated output when picking a trajectory
855 SoEventCallback *pickCB = new SoEventCallback;
856 pickCB->addEventCallback(
857 SoMouseButtonEvent::getClassTypeId(),
858 pickingCB, static_cast<void *>(this));
859 root->addChild(pickCB);
860
861}
862
863
864// Rotates camera 90 degrees around a scene element.
865// Rotation is animated for smoothness.
866void G4OpenInventorXtExaminerViewer::rotateCamera()
867{
868 SoCamera *cam = getCamera();
869
870 SbRotation rot(rotAxis, M_PI / (2 * ROT_CNT));
871 rot.multVec(camDir, camDir);
872 rot.multVec(camUpVec, camUpVec);
873
874 SbVec3f camPosNew = prevPt - (camDir*distance);
875 cam->position = camPosNew;
876 cam->pointAt(prevPt, camUpVec);
877 cam->focalDistance = (prevPt - camPosNew).length();
878
879 rotCnt--;
880
881 if (animateSensorRotation->isScheduled()) {
882 animateSensorRotation->unschedule();
883 }
884
885 animateSensorRotation->setBaseTime(SbTime::getTimeOfDay());
886 animateSensorRotation->setInterval(SbTime(0.02));
887 animateSensorRotation->schedule();
888
889}
890
891
892// Slides camera along the beamline.
893void G4OpenInventorXtExaminerViewer::moveCamera(float dist, bool lookdown)
894{
895
896 SoCamera *cam = getCamera();
897 SbVec3f p1, p2; // The particle moves from p1 to p2
898 SbVec3f particleDir; // Direction vector from p1 to p2
899 SbVec3f camPosNew; // New position of the camera
900
901 if(refParticleTrajectory.size() == 0) {
902 //refParticleTrajectory hasn't been set yet
903 if(dist)
904 distance = dist;
905 else
906 distance = (cam->position.getValue() - center).length();
907
908 cam->position.setValue(center + offsetFromCenter*distance);
909 cam->focalDistance = (cam->position.getValue() - center).length();
910 cam->pointAt(center, upVector);
911 }
912 else{
913
914 // If we move forward past the last trajectory point,
915 // go back to the beginning
916 if (refParticleIdx >= (int) refParticleTrajectory.size() - 1) {
917 prevPt = refParticleTrajectory[refParticleIdx - step];
918 dist = (prevPt - cam->position.getValue()).length();
919 refParticleIdx = 0;
920 }
921 // If we move backward past the beginning,
922 // go to the last trajectory point
923 if (refParticleIdx < 0) {
924 prevPt = refParticleTrajectory[refParticleIdx + step];
925 dist = (prevPt - cam->position.getValue()).length();
926 refParticleIdx = refParticleTrajectory.size() - 2;
927 }
928
929 // Set start and end points
930 p1 = refParticleTrajectory[refParticleIdx];
931 p2 = refParticleTrajectory[refParticleIdx + step];
932
933 // Get the direction from p1 to p2
934 particleDir = p2 - p1;
935 particleDir.normalize();
936
937 if(prevParticleDir == SbVec3f(0,0,0)){
938 // First time entering BEAMLINE mode, look at
939 // the element from the front, with camera upright
940 if(lookdown)
941 camDir = SbVec3f(0,0,1);
942 else
943 camDir = SbVec3f(1,0,0);
944 camUpVec = SbVec3f(0,1,0);
945
946 // In case the start of the goes in a
947 // direction other than +z, rotate the camera accordingly
948 SbRotation rot(SbVec3f(0,0,1), particleDir);
949 rot.multVec(camDir, camDir);
950 rot.multVec(camUpVec, camUpVec);
951
952 }
953 else if(particleDir != prevParticleDir) {
954 // The beamline has changed direction
955
956 SbRotation rot(prevParticleDir, particleDir);
957 rot.multVec(camDir, camDir);
958 rot.multVec(camUpVec, camUpVec);
959
960 }
961
962 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
963 if (!dist)
964 distance = (prevPt - cam->position.getValue()).length();
965 else
966 distance = dist;
967 }
968
969 if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
970 if (!dist)
971 distance = (prevPt - cam->position.getValue()).length();
972 else
973 distance = dist;
974 }
975
976
977 float x,y,z;
978 prevPt.getValue(x,y,z);
979
980
981 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
982 camPosNew = p2 - (camDir*distance);
983 }
984 if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
985 camPosNew = p2 - (camDir);
986 }
987
988 cam->position = camPosNew;
989 cam->pointAt(p2, camUpVec);
990 // FWJ Disabled: zooms out the Persp camera much too far
991 // and can't recover by zooming in!
992 // cam->focalDistance = (p2 - camPosNew).length();
993
994 p2.getValue(x,y,z);
995 camPosNew.getValue(x,y,z);
996
997 prevParticleDir = particleDir;
998 prevPt = p1; // For accurate distance calculation
999
1000 }
1001
1002}
1003
1004
1005void G4OpenInventorXtExaminerViewer::pickingCB(void *aThis,
1006 SoEventCallback *eventCB)
1007{
1008 SoHandleEventAction* action = eventCB->getAction();
1009 const SoPickedPoint *pp = action->getPickedPoint();
1010 G4OpenInventorXtExaminerViewer* This = (G4OpenInventorXtExaminerViewer*)aThis;
1011
1012 if(pp != NULL) {
1013
1014 SoPath* path = pp->getPath();
1015 SoNode* node = ((SoFullPath*)path)->getTail();
1016
1017 if(node->getTypeId() == SoLineSet::getClassTypeId()){
1018
1019 if(This->pickRefPathFlag){
1020 This->pickRefPathFlag = false;
1021 if(This->viewingBeforePickRef != This->isViewing())
1022 This->setViewing(This->viewingBeforePickRef);
1023 else
1024 This->setComponentCursor(SoXtCursor(SoXtCursor::DEFAULT));
1025
1026 // The trajectory is a set of lines stored in a LineSet
1027 SoLineSet * trajectory = (SoLineSet *)node;
1028
1029 // The set of all trajectories is stored in a Seperator group node
1030 // one level above the LineSet that was picked. The nodes under that
1031 // seperator are as follows (in this order): Material, LightModel,
1032 // ResetTransform, MatrixTransform, Coordinate3, DrawStyle, LineSet
1033 SoSeparator * grpNode =
1034 (SoSeparator*)(((SoFullPath*)path)->getNodeFromTail(1));
1035
1036 // The node that contains the coordinates for the trajectory is a
1037 // Coordinate3 node which occurs before the LineSet node. We iterate
1038 // back through the nodes in the group until we find the Coordinate3 node
1039 int nodeIndex = grpNode->findChild(trajectory);
1040 SoNode * tmpNode;
1041 // FWJ needs initialization
1042 SoCoordinate3 * coords = 0;
1043 // SoCoordinate3 * coords;
1044 // We allow only 100 iterations, in case the node isn't found
1045 // (should take only a few iterations)
1046 for(int i = 0; i < 100; ++i) {
1047 --nodeIndex;
1048
1049 tmpNode = grpNode->getChild(nodeIndex);
1050 if(tmpNode->getTypeId() == SoCoordinate3::getClassTypeId()){
1051 //node found
1052 coords = (SoCoordinate3 *)tmpNode;
1053 break;
1054 }
1055 }
1056
1057 if(coords == NULL){
1058 String dialogName = (char *) "No coordinates";
1059 std::string msg = "Could not find the coordinates node"
1060 " for the picked trajectory."
1061 " Reference trajectory not set";
1062 This->warningMsgDialog(msg, dialogName, NULL);
1063 return;
1064 }
1065
1066
1067 if ((This->lshiftdown) || (This->rshiftdown))
1068 This->setReferencePath(trajectory, coords, true);
1069 else
1070 This->setReferencePath(trajectory, coords, false);
1071
1072 return;
1073
1074 }
1075 else if(This->abbrOutputFlag) {
1076
1077 G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(node);
1078 if(attHolder && attHolder->GetAttDefs().size()) {
1079
1080 std::string strTrajPoint = "G4TrajectoryPoint:";
1081 std::ostringstream oss;
1082 for (size_t i = 0; i < attHolder->GetAttDefs().size(); ++i) {
1083 G4cout << G4AttCheck(attHolder->GetAttValues()[i],
1084 attHolder->GetAttDefs()[i]);
1085 oss << G4AttCheck(attHolder->GetAttValues()[i],
1086 attHolder->GetAttDefs()[i]);
1087 if(oss.str().find(strTrajPoint) != std::string::npos) {
1088
1089 // Last attribute displayed was a trajectory point. Since we
1090 // want abbreviated output, display the last one and exit
1091 // (unless we're already at the last (and only) trajectory point)
1092 if(i != attHolder->GetAttDefs().size()-1) {
1093 G4cout << G4AttCheck(
1094 attHolder->GetAttValues()[attHolder->GetAttDefs().size()-1],
1095 attHolder->GetAttDefs()[attHolder->GetAttDefs().size()-1]);
1096 }
1097 break;
1098 }
1099 }
1100 } else {
1101 G4String name((char*)node->getName().getString());
1102 G4String cls((char*)node->getTypeId().getName().getString());
1103 G4cout << "SoNode : " << node
1104 << " SoType : " << cls
1105 << " name : " << name
1106 << G4endl;
1107 G4cout << "No attributes attached." << G4endl;
1108 }
1109
1110 return;
1111 }
1112 else{
1113 //Go to default behavior
1114 }
1115 }
1116 else {
1117 //Go to default behavior
1118 }
1119
1120 // Default behavior in G4OpenInventorViewer::SelectionCB
1121 G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(node);
1122 if(attHolder && attHolder->GetAttDefs().size()) {
1123 for (size_t i = 0; i < attHolder->GetAttDefs().size(); ++i) {
1124 G4cout << G4AttCheck(attHolder->GetAttValues()[i],
1125 attHolder->GetAttDefs()[i]);
1126 }
1127 } else {
1128 G4String name((char*)node->getName().getString());
1129 G4String cls((char*)node->getTypeId().getName().getString());
1130 G4cout << "SoNode : " << node
1131 << " SoType : " << cls
1132 << " name : " << name
1133 << G4endl;
1134 G4cout << "No attributes attached." << G4endl;
1135 }
1136
1137 //Suppress other event handlers
1138 eventCB->setHandled();
1139 }
1140}
1141
1142
1143void G4OpenInventorXtExaminerViewer::mouseoverCB(void *aThis, SoEventCallback *eventCB)
1144{
1145 SoHandleEventAction* action = eventCB->getAction();
1146 const SoPickedPoint *pp = action->getPickedPoint();
1147 G4OpenInventorXtExaminerViewer* This = (G4OpenInventorXtExaminerViewer*)aThis;
1148
1149 if(!This->abbrOutputFlag)
1150 return;
1151
1152 if(pp != NULL) {
1153
1154 const SbViewportRegion & viewportRegion = action->getViewportRegion();
1155
1156 std::string sLogName;
1157 float x,y,z;
1158 std::stringstream ssZPos;
1159 std::stringstream ssSolids;
1160 std::stringstream ssMaterials;
1161 SoPath * path = pp->getPath();
1162 SoNode* node = ((SoFullPath*)path)->getTail();
1163
1164 if(node->getTypeId() == Geant4_SoPolyhedron::getClassTypeId()) {
1165
1166 sLogName = "Logical Volume: ";
1167 sLogName += ((Geant4_SoPolyhedron *)node)->getName().getString();
1168
1169 SoGetBoundingBoxAction bAction(viewportRegion);
1170 bAction.apply((SoFullPath*)path);
1171 SbBox3f bBox = bAction.getBoundingBox();
1172 SbVec3f center = bBox.getCenter();
1173 center.getValue(x,y,z);
1174 ssZPos << "Pos: " << x << " " << y << " " << z;
1175
1176 G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(node);
1177 if(attHolder && attHolder->GetAttDefs().size()) {
1178
1179 std::vector<const std::map<G4String,G4AttDef>*> vecDefs =
1180 attHolder->GetAttDefs();
1181 std::vector<const std::vector<G4AttValue>*> vecVals =
1182 attHolder->GetAttValues();
1183 for (size_t i = 0; i < vecDefs.size(); ++i) {
1184 const std::vector<G4AttValue> * vals = vecVals[i];
1185
1186 std::vector<G4AttValue>::const_iterator iValue;
1187
1188 for (iValue = vals->begin(); iValue != vals->end(); ++iValue) {
1189 const G4String& valueName = iValue->GetName();
1190 const G4String& value = iValue->GetValue();
1191
1192 if(valueName == "Solid") {
1193 if(ssSolids.str() == "")
1194 ssSolids << "Solid Name: " << value;
1195 else
1196 ssSolids << ", " << value;
1197 }
1198
1199 if(valueName == "Material") {
1200 if(ssMaterials.str() == "")
1201 ssMaterials << "Material Name: " << value;
1202 else
1203 ssMaterials << ", " << value;
1204 }
1205 }
1206 }
1207 }
1208 }
1209
1210 bool redraw = false;
1211 if(std::string(This->mouseOverTextLogName->string.getValues(0)->getString()) != sLogName) {
1212 This->mouseOverTextLogName->string.setValue(SbString(sLogName.c_str()));
1213 redraw = true;
1214 }
1215 if(std::string(This->mouseOverTextSolid->string.getValues(0)->getString()) != ssSolids.str()) {
1216 This->mouseOverTextSolid->string.setValue(SbString(ssSolids.str().c_str()));
1217 redraw = true;
1218 }
1219 if(std::string(This->mouseOverTextMaterial->string.getValues(0)->getString()) != ssMaterials.str()){
1220 This->mouseOverTextMaterial->string.setValue(SbString(ssMaterials.str().c_str()));
1221 redraw = true;
1222 }
1223 if(std::string(This->mouseOverTextZPos->string.getValues(0)->getString()) != ssZPos.str()) {
1224 This->mouseOverTextZPos->string.setValue(SbString(ssZPos.str().c_str()));
1225 redraw = true;
1226 }
1227
1228 if(redraw) {
1229 This->setSuperimpositionEnabled(This->superimposition, TRUE);
1230 This->scheduleRedraw();
1231 }
1232
1233 eventCB->setHandled();
1234 }
1235 else {
1236 if(std::string(This->mouseOverTextLogName->string.getValues(0)->getString()) != "") {
1237 This->mouseOverTextLogName->string.setValue(SbString(""));
1238 This->scheduleRedraw();
1239 }
1240 if(std::string(This->mouseOverTextSolid->string.getValues(0)->getString()) != "") {
1241 This->mouseOverTextSolid->string.setValue(SbString(""));
1242 This->scheduleRedraw();
1243 }
1244 if(std::string(This->mouseOverTextMaterial->string.getValues(0)->getString()) != "") {
1245 This->mouseOverTextMaterial->string.setValue(SbString(""));
1246 This->scheduleRedraw();
1247 }
1248 if(std::string(This->mouseOverTextZPos->string.getValues(0)->getString()) != "") {
1249 This->mouseOverTextZPos->string.setValue(SbString(""));
1250 This->scheduleRedraw();
1251 }
1252 }
1253}
1254
1255
1256SbBool G4OpenInventorXtExaminerViewer::processSoEvent(const SoEvent * const ev) {
1257 SoCamera *cam = getCamera();
1258 const SoType type(ev->getTypeId());
1259
1260 if (type.isDerivedFrom(SoMouseButtonEvent::getClassTypeId())) {
1261 SoMouseButtonEvent * me = (SoMouseButtonEvent *) ev;
1262
1263 if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
1264 || currentState == PAUSED_ANIMATION) {
1265 switch (me->getButton()) {
1266 case SoMouseButtonEvent::BUTTON4: // Scroll wheel up
1267 if (me->getState() == SoButtonEvent::DOWN) {
1268 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
1269 float hAngle =
1270 ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
1271 ((SoPerspectiveCamera *) cam)->heightAngle = hAngle
1272 + 0.01f;
1273 return TRUE;
1274 } else if (cam->isOfType(
1275 SoOrthographicCamera::getClassTypeId())) {
1276 float height =
1277 ((SoOrthographicCamera *) cam)->height.getValue();
1278 ((SoOrthographicCamera *) cam)->height = height + 5;
1279 return TRUE;
1280 }
1281 }
1282 break;
1283 case SoMouseButtonEvent::BUTTON5: // Scroll wheel down
1284 if (me->getState() == SoButtonEvent::DOWN) {
1285 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
1286 float hAngle =
1287 ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
1288 if (hAngle > 0.01)
1289 ((SoPerspectiveCamera *) cam)->heightAngle = hAngle
1290 - 0.01f;
1291 return TRUE;
1292 } else if (cam->isOfType(
1293 SoOrthographicCamera::getClassTypeId())) {
1294 float height =
1295 ((SoOrthographicCamera *) cam)->height.getValue();
1296 if (height > 5)
1297 ((SoOrthographicCamera *) cam)->height = height - 5;
1298 return TRUE;
1299 }
1300 }
1301 break;
1302 default:
1303 break;
1304 }
1305 }
1306 if (currentState == GENERAL) {
1307
1308 }
1309 }
1310
1311 if (type.isDerivedFrom(SoKeyboardEvent::getClassTypeId())) {
1312 SoKeyboardEvent * ke = (SoKeyboardEvent *) ev;
1313
1314 if (SoKeyboardEvent::isKeyPressEvent(ev, ke->getKey())) {
1315 switch (ke->getKey()) {
1316 case SoKeyboardEvent::LEFT_SHIFT:
1317 this->lshiftdown = true;
1318 return TRUE;
1319 case SoKeyboardEvent::RIGHT_SHIFT:
1320 this->rshiftdown = true;
1321 return TRUE;
1322 case SoKeyboardEvent::LEFT_CONTROL:
1323 this->lctrldown = true;
1324 return TRUE;
1325 case SoKeyboardEvent::RIGHT_CONTROL:
1326 this->rctrldown = true;
1327 return TRUE;
1328 case SoKeyboardEvent::SPACE:
1329 if (currentState == ANIMATION
1330 || currentState == REVERSED_ANIMATION) {
1331 beforePausing = currentState;
1332 currentState = PAUSED_ANIMATION;
1333 if (animateSensor->isScheduled())
1334 animateSensor->unschedule();
1335 return TRUE;
1336 } else if (currentState == PAUSED_ANIMATION) {
1337 if (maxSpeed) {
1338 if ((beforePausing == ANIMATION
1339 && refParticleIdx
1340 < (int) refParticleTrajectory.size() - 1)
1341 || (beforePausing == REVERSED_ANIMATION
1342 && refParticleIdx > 0)) {
1343 currentState = beforePausing;
1344 animateRefParticle();
1345 }
1346 }
1347 return TRUE;
1348 }
1349 break;
1350 case SoKeyboardEvent::ESCAPE:
1351 if (currentState == ANIMATION
1352 || currentState == REVERSED_ANIMATION
1353 || currentState == PAUSED_ANIMATION) {
1354
1355 if (animateSensor->isScheduled())
1356 animateSensor->unschedule();
1357 currentState = prevState;
1358 refParticleIdx = prevRefIdx;
1359 setSuperimpositionEnabled(superimposition, FALSE);
1360 maxSpeed = 0.0f;
1361 step = 1;
1362
1363 scheduleRedraw();
1364 if (currentState == VIEWPOINT) {
1365 setSuperimpositionEnabled(superimposition, TRUE);
1366 axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
1367 animSpeedOutlineSwitch->whichChild.setValue(
1368 SO_SWITCH_NONE);
1369 animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
1370
1371 scheduleRedraw();
1372 }
1373 restoreCamera();
1374 return TRUE;
1375 }
1376 break;
1377 case SoKeyboardEvent::DELETE:
1378 if (viewPtList.size()
1379 && (currentState != ANIMATION
1380 || currentState != REVERSED_ANIMATION
1381 || currentState != PAUSED_ANIMATION)) {
1382 String dialogName = (char *) "Delete Viewpoint";
1383 std::string msg = "Are you sure you want to delete current viewpoint?";
1384 warningMsgDialog(msg, dialogName, deleteViewPtCB);
1385 return TRUE;
1386 }
1387 break;
1388 case SoKeyboardEvent::LEFT_ARROW:
1389 switch (currentState) {
1390 case BEAMLINE:
1391 if ((this->lshiftdown) || (this->rshiftdown)){
1392 refParticleIdx -= step;
1393 moveCamera();
1394 }
1395 else if ((this->lctrldown) || (this->rctrldown)){
1396 if (SoXtExaminerViewer::isAnimating())
1397 stopAnimating();
1398 prevState = currentState;
1399 currentState = ROTATING;
1400 animateBtwPtsPeriod = 0.08f;
1401
1402 SbVec3f tmp = camDir;
1403 tmp.negate();
1404 rotAxis = tmp;
1405
1406 rotCnt = ROT_CNT;
1407 moveCamera(); // To make sure camera is perpendicular to the beamline
1408
1409 rotateCamera();
1410 }
1411 else{
1412 if (SoXtExaminerViewer::isAnimating())
1413 stopAnimating();
1414 prevState = currentState;
1415 currentState = ROTATING;
1416 animateBtwPtsPeriod = 0.08f;
1417
1418 SbVec3f tmp = camUpVec;
1419 tmp.negate();
1420 rotAxis = tmp;
1421
1422 rotCnt = ROT_CNT;
1423 moveCamera(); // To make sure camera is perpendicular to the beamline
1424
1425 rotateCamera();
1426
1427 }
1428 return TRUE;
1429
1430 case ANIMATION:
1431 case REVERSED_ANIMATION:
1432 left_right -= 1.5f;
1433 return TRUE;
1434 case PAUSED_ANIMATION:
1435 left_right -= 1.5f;
1436 setStartingPtForAnimation();
1437 cam->position = myCam->position;
1438 return TRUE;
1439 case GENERAL:
1440 case VIEWPOINT:
1441 if ((!this->lshiftdown) && (!this->rshiftdown)) {
1442 // Using this allows us to look around without
1443 // changing the camera parameters (camDir, camUpVec)
1444 this->bottomWheelMotion(
1445 this->getBottomWheelValue() + 0.1f);
1446
1447 return TRUE;
1448 }
1449 break;
1450 case ROTATING:
1451 // For this state, let the keyboard event
1452 // be handled by superclass
1453 break;
1454 default:
1455 SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
1456 "Unhandled viewer state");
1457 break;
1458 }
1459 break;
1460
1461 case SoKeyboardEvent::RIGHT_ARROW:
1462 switch(currentState){
1463 case BEAMLINE:
1464 if ((this->lshiftdown) || (this->rshiftdown)){
1465 refParticleIdx += step;
1466 moveCamera();
1467 }
1468 else if ((this->lctrldown) || (this->rctrldown)){
1469 if (SoXtExaminerViewer::isAnimating())
1470 stopAnimating();
1471 prevState = currentState;
1472 currentState = ROTATING;
1473 animateBtwPtsPeriod = 0.08f;
1474
1475 rotAxis = camDir;
1476
1477 rotCnt = ROT_CNT;
1478 moveCamera(); // To make sure camera is perpendicular to the beamline
1479
1480 rotateCamera();
1481 }
1482 else{
1483 if (SoXtExaminerViewer::isAnimating())
1484 stopAnimating();
1485 prevState = currentState;
1486 currentState = ROTATING;
1487 animateBtwPtsPeriod = 0.08f;
1488
1489 rotAxis = camUpVec;
1490
1491 rotCnt = ROT_CNT;
1492 moveCamera(); // To make sure camera is perpendicular to the beamline
1493
1494 rotateCamera();
1495 }
1496 return TRUE;
1497
1498 case ANIMATION:
1499 case REVERSED_ANIMATION:
1500 left_right += 1.5f;
1501 return TRUE;
1502 case PAUSED_ANIMATION:
1503 left_right += 1.5f;
1504 setStartingPtForAnimation();
1505 cam->position = myCam->position;
1506 return TRUE;
1507 case GENERAL:
1508 case VIEWPOINT:
1509 if ((!this->lshiftdown) && (!this->rshiftdown)) {
1510 // Using this allows us to look around without
1511 // changing the camera parameters (camDir, camUpVec)
1512 this->bottomWheelMotion(
1513 this->getBottomWheelValue() - 0.1f);
1514 return TRUE;
1515 }
1516 break;
1517 case ROTATING:
1518 // For this state, let the keyboard event
1519 // be handled by superclass
1520 break;
1521 default:
1522 SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
1523 "Unhandled viewer state");
1524 break;
1525 }
1526 break;
1527
1528 case SoKeyboardEvent::DOWN_ARROW:
1529 switch(currentState){
1530 case BEAMLINE:
1531
1532 if ((this->lshiftdown) || (this->rshiftdown)){
1533 refParticleIdx -= step;
1534 moveCamera();
1535 }
1536 else{
1537 if (SoXtExaminerViewer::isAnimating())
1538 stopAnimating();
1539 prevState = currentState;
1540 currentState = ROTATING;
1541 animateBtwPtsPeriod = 0.08f;
1542
1543 rotAxis = camDir.cross(camUpVec);
1544
1545 rotCnt = ROT_CNT;
1546 moveCamera(); // To make sure camera is perpendicular to the beamline
1547
1548 rotateCamera();
1549
1550 }
1551 return TRUE;
1552
1553 case ANIMATION:
1554 case REVERSED_ANIMATION:
1555 up_down -= 1.5f;
1556 return TRUE;
1557 case PAUSED_ANIMATION:
1558 up_down -= 1.5f;
1559 setStartingPtForAnimation();
1560 cam->position = myCam->position;
1561 return TRUE;
1562 case GENERAL:
1563 case VIEWPOINT:
1564 // Using this allows us to look around without
1565 // changing the camera parameters (camDir, camUpVec)
1566 if ((!this->lshiftdown) && (!this->rshiftdown)) {
1567 this->leftWheelMotion(this->getLeftWheelValue() - 0.1f);
1568 return TRUE;
1569 }
1570 break;
1571 case ROTATING:
1572 // For this state, let the keyboard event
1573 // be handled by superclass
1574 break;
1575 default:
1576 SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
1577 "Unhandled viewer state");
1578 break;
1579 }
1580 break;
1581
1582 case SoKeyboardEvent::UP_ARROW:
1583 switch(currentState){
1584 case BEAMLINE:
1585 if ((this->lshiftdown) || (this->rshiftdown)){
1586 refParticleIdx -= step;
1587 moveCamera();
1588 }
1589 else{
1590 if (SoXtExaminerViewer::isAnimating())
1591 stopAnimating();
1592 prevState = currentState;
1593 currentState = ROTATING;
1594 animateBtwPtsPeriod = 0.08f;
1595
1596 rotAxis = camUpVec.cross(camDir);
1597
1598 rotCnt = ROT_CNT;
1599 moveCamera();
1600
1601 rotateCamera();
1602
1603
1604 }
1605 return TRUE;
1606 case ANIMATION:
1607 case REVERSED_ANIMATION:
1608 up_down += 1.5f;
1609 return TRUE;
1610 case PAUSED_ANIMATION:
1611 up_down += 1.5f;
1612 setStartingPtForAnimation();
1613 cam->position = myCam->position;
1614 return TRUE;
1615 case GENERAL:
1616 case VIEWPOINT:
1617 // Using this allows us to look around without
1618 // changing the camera parameters (camDir, camUpVec)
1619 if ((!this->lshiftdown) && (!this->rshiftdown)) {
1620 this->leftWheelMotion(this->getLeftWheelValue() + 0.1f);
1621 return TRUE;
1622 }
1623 break;
1624 case ROTATING:
1625 // For this state, let the keyboard event
1626 // be handled by superclass
1627 break;
1628 default:
1629 SoDebugError::post("G4OpenInventorXtExaminerViewer::processSoEvent",
1630 "Unhandled viewer state");
1631 break;
1632 }
1633 break;
1634
1635 case SoKeyboardEvent::PAGE_UP:
1636 switch(currentState){
1637 case BEAMLINE:
1638 if (step < (int) refParticleTrajectory.size() / 5) // Magic number
1639 step++;
1640 return TRUE;
1641 case ANIMATION:
1642 incSpeed();
1643 maxSpeed += SPEED_INDICATOR_STEP;
1644 if (maxSpeed > 0.8)
1645 maxSpeed = MAX_SPEED_INDICATOR;
1646 scheduleRedraw();
1647
1648 return TRUE;
1649 case REVERSED_ANIMATION:
1650 if(!animateSensor->isScheduled()){
1651 currentState = ANIMATION;
1652 if (refParticleIdx
1653 < (int) refParticleTrajectory.size() - 1) {
1654 refParticleIdx++;
1655 maxSpeed = SPEED_INDICATOR_STEP;
1656 scheduleRedraw();
1657 animateRefParticle();
1658 }
1659 }
1660 else{
1661 maxSpeed += SPEED_INDICATOR_STEP;
1662 decSpeed();
1663 scheduleRedraw();
1664 }
1665 return TRUE;
1666 case PAUSED_ANIMATION:
1667 maxSpeed += SPEED_INDICATOR_STEP;
1668 if (maxSpeed > 0.8)
1669 maxSpeed = MAX_SPEED_INDICATOR;
1670
1671 if (beforePausing == ANIMATION) {
1672 incSpeed();
1673 } else {
1674 decSpeed();
1675 if (animateBtwPtsPeriod >= MIN_SPEED)
1676 beforePausing = ANIMATION;
1677 }
1678
1679 scheduleRedraw();
1680 return TRUE;
1681 default: //fall through
1682 break;
1683 }
1684 break;
1685
1686 case SoKeyboardEvent::PAGE_DOWN:
1687 switch(currentState){
1688 case BEAMLINE:
1689 if (step > 1)
1690 step--;
1691 return TRUE;
1692 case ANIMATION:
1693 if(!animateSensor->isScheduled()){
1694 currentState = REVERSED_ANIMATION;
1695 if (refParticleIdx > 1) {
1696 refParticleIdx--;
1697 maxSpeed = -SPEED_INDICATOR_STEP;
1698 scheduleRedraw();
1699 animateRefParticle();
1700 }
1701 }
1702 else{
1703 maxSpeed -= SPEED_INDICATOR_STEP;
1704 decSpeed();
1705 scheduleRedraw();
1706 }
1707 return TRUE;
1708 case REVERSED_ANIMATION:
1709 incSpeed();
1710 maxSpeed -= SPEED_INDICATOR_STEP;
1711 if (maxSpeed < -0.8)
1712 maxSpeed = -MAX_SPEED_INDICATOR;
1713 scheduleRedraw();
1714 return TRUE;
1715 case PAUSED_ANIMATION:
1716 maxSpeed -= SPEED_INDICATOR_STEP;
1717 if (maxSpeed < -0.8)
1718 maxSpeed = -MAX_SPEED_INDICATOR;
1719 if (beforePausing == REVERSED_ANIMATION) {
1720 incSpeed();
1721 } else {
1722 decSpeed();
1723 if (animateBtwPtsPeriod >= MIN_SPEED)
1724 beforePausing = REVERSED_ANIMATION;
1725 }
1726 scheduleRedraw();
1727 return TRUE;
1728 default:
1729 //fall through
1730 break;
1731 }
1732 break;
1733
1734 case SoKeyboardEvent::E:
1735 this->escapeCallback(this->examinerObject);
1736 break;
1737
1738 default:
1739 break; // To get rid of compiler warnings
1740 }
1741 }
1742 if (SoKeyboardEvent::isKeyReleaseEvent(ev, ke->getKey())) {
1743 switch (ke->getKey()) {
1744 case SoKeyboardEvent::LEFT_SHIFT:
1745 this->lshiftdown = false;
1746 return TRUE;
1747 case SoKeyboardEvent::RIGHT_SHIFT:
1748 this->rshiftdown = false;
1749 return TRUE;
1750 case SoKeyboardEvent::LEFT_CONTROL:
1751 this->lctrldown = false;
1752 return TRUE;
1753 case SoKeyboardEvent::RIGHT_CONTROL:
1754 this->rctrldown = false;
1755 return TRUE;
1756 default:
1757 break;
1758 }
1759 }
1760 }
1761
1762 if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
1763 || currentState == ROTATING)
1764 return FALSE;
1765 else
1766 return SoXtExaminerViewer::processSoEvent(ev);
1767}
1768
1769// Called by hitting PageUp during animation.
1770void G4OpenInventorXtExaminerViewer::incSpeed() {
1771 if (std::ceil(animateBtwPtsPeriod * 100) >= 4) {
1772 if (speedStep > 0.08)
1773 speedStep -= 0.02;
1774 else
1775 speedStep = 0.02;
1776 animateBtwPtsPeriod -= speedStep;
1777 } else
1778 animateBtwPtsPeriod = 0.0;
1779
1780 if (currentState != PAUSED_ANIMATION) {
1781 int lastIdx = refParticleTrajectory.size() - 1;
1782 if (refParticleIdx < lastIdx && !animateSensor->isScheduled())
1783 animateRefParticle();
1784 }
1785}
1786
1787// Called by hitting PageDown during animation.
1788void G4OpenInventorXtExaminerViewer::decSpeed() {
1789 animateBtwPtsPeriod += speedStep;
1790 if (animateBtwPtsPeriod < MIN_SPEED) {
1791 if (std::floor(animateBtwPtsPeriod * 100) == 12) { // Errors in double representation
1792 speedStep = 0.08;
1793 } else if (animateBtwPtsPeriod > 0.12)
1794 speedStep += 0.02;
1795 } else {
1796 animateBtwPtsPeriod = MIN_SPEED;
1797 speedStep = START_STEP;
1798 maxSpeed = 0.0f;
1799 if (animateSensor->isScheduled())
1800 animateSensor->unschedule();
1801 }
1802}
1803
1804// Based on the user's interaction the speed indicator bar needs to be adjusted.
1805void G4OpenInventorXtExaminerViewer::updateSpeedIndicator(void) {
1806 assert(this->sgeometry != NULL);
1807
1808 SbVec3f * points = this->sgeometry->point.startEditing();
1809
1810 if (points[10][0] == 0.0f)
1811 this->animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_ALL);
1812 if (points[14][0] == 0.0f)
1813 this->animSpeedSwitch->whichChild.setValue(SO_SWITCH_ALL);
1814 points[10][0] = this->maxSpeed;
1815 points[11][0] = this->maxSpeed;
1816 points[14][0] = this->maxSpeed;
1817 points[15][0] = this->maxSpeed;
1818 this->sgeometry->point.finishEditing();
1819
1820 if (this->maxSpeed == 0.0f) {
1821 this->animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
1822 this->animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
1823 }
1824}
1825
1826void G4OpenInventorXtExaminerViewer::actualRedraw(void) {
1827 switch (currentState) {
1828 case ANIMATION:
1829 case REVERSED_ANIMATION:
1830 case PAUSED_ANIMATION:
1831 updateSpeedIndicator();
1832 SoXtExaminerViewer::actualRedraw();
1833 break;
1834 default:
1835 SoXtExaminerViewer::actualRedraw();
1836 break;
1837 }
1838}
1839
1840void G4OpenInventorXtExaminerViewer::setReferencePath(SoLineSet *lineset, SoCoordinate3 *coords, bool append)
1841{
1842 // TODO: Color the reference path
1843 // Disable the color stuff for now: changes all trajectories
1844
1845// // We change the color of the trajectory too, so we get its material
1846// nodeIndex = grpNode->findChild(trajectory);
1847// SoMaterial * mat;
1848// for(int i = 0; i < 100; ++i){
1849// --nodeIndex;
1850//
1851// tmpNode = grpNode->getChild(nodeIndex);
1852// if(tmpNode->getTypeId() == SoMaterial::getClassTypeId()){
1853// //node found
1854// mat = (SoMaterial *)tmpNode;
1855//
1856// break;
1857// }
1858// }
1859//
1860//
1861// // Restore default color for previously picked trajectory
1862// // and set different color for current pick
1863// if(This->prevColorField)
1864// ((SoMFColor *)This->prevColorField)->setValue(0.0, 1.0, 0.0);
1865// This->prevColorField = (void *)&mat->diffuseColor;
1866//
1867//
1868// if(mat->diffuseColor.isConnected())
1869// std::cout << "connected" << std::endl;
1870//
1871// mat->diffuseColor.setValue(41.0/255.0, 230.0/255.0, 230.0/255.0);
1872//
1873// std::cout << "R: " << mat->diffuseColor[0][0] << " ";
1874// std::cout << "G: " << mat->diffuseColor[0][1] << " ";
1875// std::cout << "B: " << mat->diffuseColor[0][2] << std::endl;
1876
1877 // The trajectory is composed of all the polyline segments in the
1878 // multiple value field (SoMFInt32) numVertices.
1879 // For each of the numVertices.getNum()* polyline segments,
1880 // retrieve the points from the SoCoordinate3 node
1881 SbVec3f refParticlePt;
1882
1883 if(!append)
1884 this->refParticleTrajectory.clear();
1885
1886 for(int i = 0; i < lineset->numVertices.getNum(); ++i){
1887 for(int j = 0; j < lineset->numVertices[i]; ++j){
1888 refParticlePt = coords->point[j];
1889 this->refParticleTrajectory.push_back(refParticlePt);
1890 }
1891 }
1892 // Remove points that are too close to each other
1893 this->evenOutRefParticlePts();
1894 this->setReferencePathZPos();
1895 this->sortElements();
1896}
1897
1898
1899void G4OpenInventorXtExaminerViewer::setReferencePathZPos()
1900{
1901 refZPositions.clear();
1902 refZPositions.push_back(0);
1903 float dist;
1904 for(unsigned int i=0; i < this->refParticleTrajectory.size() - 1; ++i){
1905 dist = (refParticleTrajectory[i] -
1906 refParticleTrajectory[i + 1]).length();
1907 refZPositions.push_back(refZPositions[i] + dist);
1908 }
1909}
1910
1911
1912void G4OpenInventorXtExaminerViewer::findAndSetRefPath()
1913{
1914 SoSearchAction action;
1915 action.setType(SoLineSet::getClassTypeId(),false);
1916 action.setInterest(SoSearchAction::ALL);
1917 action.apply(this->getSceneGraph());
1918
1919 SoPathList &pathList = action.getPaths();
1920
1921 if(pathList.getLength() != 0){
1922
1923 SoCoordinate3 * coords = NULL;
1924 std::vector<SoCoordinate3 *> coordvec;
1925 std::vector<SoLineSet *> linevec;
1926
1927 bool refPathFound = false;
1928 for(int i = 0; i < pathList.getLength(); ++i) {
1929 SoFullPath *path = (SoFullPath *)pathList[i];
1930
1931 G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(path->getTail());
1932 for (size_t j = 0; j < attHolder->GetAttDefs().size(); ++j) {
1933 std::ostringstream oss;
1934 oss << G4AttCheck(attHolder->GetAttValues()[j], attHolder->GetAttDefs()[j]);
1935
1936 std::string findStr = "Type of trajectory (Type): ";
1937 std::string compareValue = "REFERENCE";
1938 size_t idx = oss.str().find(findStr);
1939
1940 if(idx != std::string::npos) {
1941 if(oss.str().substr(idx + findStr.size(), compareValue.size()) == compareValue) {
1942 coords = this->getCoordsNode(path);
1943 if(coords != NULL){
1944 refPathFound = true;
1945 coordvec.push_back(coords);
1946 linevec.push_back((SoLineSet *)path->getTail());
1947 }
1948 break;
1949 }
1950 }
1951
1952 findStr = "Track ID (ID): ";
1953 idx = oss.str().find(findStr);
1954 if(idx != std::string::npos) {
1955 //index all primary tracks
1956 std::string tmpstr = oss.str().substr(idx + findStr.size(),1);
1957 std::istringstream buffer(tmpstr);
1958 int num;
1959 buffer >> num;
1960 if(num == 1) {
1961
1962 // Check if next character is a number,
1963 // in which case we don't have Track ID 1
1964 const char * nextChar =
1965 oss.str().substr(idx + findStr.size() + 1,1).c_str();
1966 if(std::isdigit(nextChar[0]))
1967 break; //Not a primary track, continue with next track
1968
1969 coords = this->getCoordsNode(path);
1970 if(coords != NULL){
1971 coordvec.push_back(coords);
1972 linevec.push_back((SoLineSet *)path->getTail());
1973 break; //Found coords node, continue with next track
1974 }
1975 }
1976 else
1977 break; //Not a primary track, continue with next track
1978 }
1979 else{
1980 //Not a Track ID attribute, fall through
1981 }
1982 }
1983
1984 if(refPathFound)
1985 break;
1986 }
1987
1988 if(coordvec.empty())
1989 return; //No track with a Coordinate3 node found
1990
1991 if(refPathFound){
1992 //set ref path to last traj, coord in the vecs
1993 this->setReferencePath(linevec.back(), coordvec.back());
1994 return;
1995 }
1996 //else
1997
1998 int longestIdx = 0;
1999 float longestLength = 0.0;
2000 // For all paths
2001 for(unsigned int i=0;i < linevec.size(); ++i){
2002
2003 //First generate a vector with all the points in this lineset
2004 std::vector<SbVec3f> trajectory;
2005 // For all lines in the i path
2006 for(int j=0; j < linevec[i]->numVertices.getNum(); ++j){
2007 // For all points in line j
2008 for(int k=0; k < linevec[i]->numVertices[j]; ++k){
2009 trajectory.push_back(coordvec[i]->point[k]);
2010 }
2011 }
2012
2013 // Then calculate the total length
2014 float tmpLength=0.0;
2015 for(unsigned int j=0; j < trajectory.size() - 1; ++j){
2016 tmpLength += (trajectory[j] - trajectory[j + 1]).length();
2017 }
2018
2019 if(tmpLength > longestLength){
2020 longestIdx = i;
2021 longestLength = tmpLength;
2022 }
2023 }
2024
2025 // Set the longest path as the reference path
2026 this->setReferencePath(linevec[longestIdx], coordvec[longestIdx]);
2027 }
2028}
2029
2030
2031SoCoordinate3 * G4OpenInventorXtExaminerViewer::getCoordsNode(SoFullPath *path)
2032{
2033 SoLineSet *trajectory = (SoLineSet *)path->getTail();
2034 SoSeparator * grpNode = (SoSeparator*)(((SoFullPath*)path)->getNodeFromTail(1));
2035 int nodeIndex = grpNode->findChild(trajectory);
2036 SoNode * tmpNode;
2037
2038 // We allow only 100 iterations, in case the node isn't found
2039 // (should take only a few iterations)
2040 for(int i = 0; i < 100; ++i){
2041 --nodeIndex;
2042
2043 tmpNode = grpNode->getChild(nodeIndex);
2044 if(tmpNode->getTypeId() == SoCoordinate3::getClassTypeId()){
2045 //node found
2046 return (SoCoordinate3 *)tmpNode;
2047 }
2048 }
2049 return NULL; //coords node not found
2050}
2051
2052
2053// Displays scene elements on the right side of listsDialog.
2054// else: scene graph is searched for Geant4_SoPolyhedron type nodes
2055void G4OpenInventorXtExaminerViewer::getSceneElements()
2056{
2057 std::string field, eltName;
2058
2059 std::map<std::string, int> duplicates;
2060 std::map<std::string, int> sceneElts;
2061 SoSearchAction search;
2062 Geant4_SoPolyhedron *node;
2063 SoGroup *root = (SoGroup *)getSceneManager()->getSceneGraph();
2064
2065 SoBaseKit::setSearchingChildren(TRUE);
2066
2067 search.reset();
2068 search.setSearchingAll(TRUE);
2069 search.setInterest(SoSearchAction::ALL);
2070 search.setType(Geant4_SoPolyhedron::getClassTypeId(), 0);
2071 search.apply(root);
2072
2073 SoPathList &pl = search.getPaths();
2074
2075
2076 // First find which names occur more than once so we can append a counter to them
2077 for(int i = 0; i < pl.getLength(); i++) {
2078 SoFullPath *path = (SoFullPath *)pl[i];
2079 node = (Geant4_SoPolyhedron *)path->getTail();
2080 eltName = node->getName();
2081 if(duplicates.count(eltName))
2082 duplicates[eltName]++;
2083 else
2084 duplicates[eltName] = 1;
2085 }
2086
2087 for(int i = 0; i < pl.getLength(); i++) {
2088 float x,y,z;
2089 std::stringstream ssCount;
2090 SoFullPath *path = (SoFullPath *)pl[i];
2091 node = (Geant4_SoPolyhedron *)path->getTail();
2092 eltName = node->getName();
2093 field = eltName;
2094 if(duplicates[eltName] == 1)
2095 ssCount << "";//duplicates[field]
2096 else {
2097 if(sceneElts.count(eltName))
2098 sceneElts[eltName]++;
2099 else
2100 sceneElts[eltName] = 1;
2101
2102 ssCount << sceneElts[eltName];
2103 field += "_";
2104 }
2105
2106 field += ssCount.str();
2107
2108 SoGetBoundingBoxAction bAction(getViewportRegion());
2109 bAction.apply(path);
2110 SbBox3f bBox = bAction.getBoundingBox();
2111
2112 SbVec3f centr = bBox.getCenter();
2113 centr.getValue(x,y,z);
2114
2115 path->ref();
2116 sceneElement el = { field, path, centr, 0.0 };
2117 this->sceneElements.push_back(el);
2118 }
2119}
2120
2121
2122float G4OpenInventorXtExaminerViewer::sqrlen(const SbVec3f &a)
2123{
2124 float x,y,z;
2125 a.getValue(x,y,z);
2126 return x*x + y*y + z*z;
2127}
2128
2129
2130void G4OpenInventorXtExaminerViewer::distanceToTrajectory(const SbVec3f &q,
2131 float &dist,
2132 SbVec3f &closestPoint,
2133 int &index)
2134{
2135 // a : Previous point on trajectory
2136 // b : Next point on trajectory
2137 // q : the point in space
2138 // dab, daq, dbq: distance between a & b, a & q, b & q
2139 //
2140 // Theory: A point p on a line ab is defined as:
2141 //
2142 // p(t) = a+t⋅(b–a)
2143 //
2144 // note: All are vectors except the parameter t
2145 //
2146 // When t is between 0 and 1 the point p is situated between a and b on ab.
2147 // The point p is defined in terms of the parameter t, subsequently so does
2148 // the distance from the query point q to the point p. To find the minimum
2149 // of that distance we differentiate it and set equal to zero:
2150 //
2151 // diff(Norm(p(t)- q)) = 0
2152 //
2153 // note: diff means taking the derivative with regard to t
2154 //
2155 // The resulting t is given in the code below. The square of the distance
2156 // between p and q is given by:
2157 //
2158 // d^2 = (Norm(p(t)-q))^2
2159 //
2160 // The expression found is given in the code below (current_dist)
2161 //
2162 // Ref: http://programmizm.sourceforge.net/blog/2012/
2163 // distance-from-a-point-to-a-polyline
2164 //
2165 // --PLG
2166
2167 const size_t count = this->refParticleTrajectory.size();
2168 assert(count>0);
2169
2170 SbVec3f b = this->refParticleTrajectory[0];
2171 SbVec3f dbq = b - q;
2172 float sqrDist = sqrlen(dbq);
2173 closestPoint = b;
2174 index = 0;
2175 for (size_t i = 1; i < count; ++i) {
2176 const SbVec3f a = b;
2177 const SbVec3f daq = dbq;
2178 b = this->refParticleTrajectory[i];
2179 dbq = b - q;
2180 const SbVec3f dab = a - b;
2181
2182 float dab_x, dab_y, dab_z;
2183 dab.getValue(dab_x,dab_y,dab_z);
2184 float daq_x, daq_y, daq_z;
2185 daq.getValue(daq_x, daq_y, daq_z);
2186 float dbq_x, dbq_y, dbq_z;
2187 dbq.getValue(dbq_x, dbq_y, dbq_z);
2188
2189 const float inv_sqrlen = 1./sqrlen(dab);
2190 const float t = (dab_x*daq_x + dab_y*daq_y + dab_z*daq_z)*inv_sqrlen;
2191
2192 if (t<0.){
2193 // The trajectory point occurs before point a
2194 // Go to the next point
2195 continue;
2196 }
2197 float current_dist;
2198 if (t<=1.){
2199 // The trajectory point occurs between a and b.
2200 // Compute the distance to that point
2201 current_dist = daq_x*daq_x + daq_y*daq_y + daq_z*daq_z
2202 - t*(daq_x*dab_x + daq_y*dab_y + daq_z*dab_z)
2203 + t*t*(dab_x*dab_x + dab_y*dab_y + dab_z*dab_z);
2204 }
2205 else { //t>1.
2206 // The trajectory point occurs after b.
2207 // Get the distance to point b
2208 current_dist = sqrlen(dbq);
2209 }
2210
2211 if (current_dist < sqrDist){
2212 sqrDist = current_dist;
2213 closestPoint = a + t*(b-a);
2214 index = i;
2215 }
2216 }
2217
2218 dist = std::sqrt(sqrDist);
2219}
2220
2221
2222void G4OpenInventorXtExaminerViewer::sortElements()
2223{
2224 if(this->refParticleTrajectory.empty())
2225 return;
2226
2227 float * trajLength = new float[this->refParticleTrajectory.size()];
2228 typedef std::map<elementForSorting, sceneElement> sortedMap;
2229 sortedMap sorted;
2230
2231 // For every point on the reference trajectory, compute
2232 // the total length from the start
2233 SbVec3f prevPoint;
2234 std::vector<SbVec3f>::iterator itRef = this->refParticleTrajectory.begin();
2235 int trajIndex = 0;
2236 prevPoint = *itRef;
2237 trajLength[trajIndex] = 0.0;
2238 ++itRef;
2239 ++trajIndex;
2240 for(; itRef != this->refParticleTrajectory.end(); ++itRef, ++trajIndex){
2241 trajLength[trajIndex] = trajLength[trajIndex-1] + (*itRef - prevPoint).length();
2242 prevPoint = *itRef;
2243 }
2244
2245 // Compute the smallest distance between the element
2246 // and the reference trajectory (find the closest point),
2247 // then map the element to the trajectory length of that
2248 // point (calculated above)
2249 SoGetBoundingBoxAction bAction(this->getViewportRegion());
2250 SbVec3f elementCoord;
2251 std::vector<sceneElement>::iterator itEl;
2252 int elementIndex;
2253 elementForSorting el;
2254 for(itEl = this->sceneElements.begin(), elementIndex = 0;
2255 itEl != this->sceneElements.end(); ++itEl, ++elementIndex){
2256 bAction.apply(itEl->path);
2257 elementCoord = bAction.getBoundingBox().getCenter();
2258
2259 int index;
2260 distanceToTrajectory(elementCoord, el.smallestDistance, el.closestPoint, index);
2261 itEl->closestPointZCoord = el.closestPointZCoord = trajLength[index];
2262 el.distanceToBeamlineStart = (itEl->center - this->refParticleTrajectory[0]).length();
2263
2264 // This map of the scene elements (or their coordinates rather)
2265 // is automatically sorted by trajectory length (Z coord), then
2266 // by the distance between the element and the point in case the Z coord
2267 // is the same as another element. This is done by using as a key
2268 // an element structure which implements the operator for weak ordering
2269 sorted.insert(std::make_pair(el,*itEl));
2270 }
2271
2272 // store the sorted elements into the vector field
2273 this->sceneElements.clear();
2274
2275 sortedMap::iterator itSorted = sorted.begin();
2276 for(; itSorted != sorted.end(); itSorted++)
2277 this->sceneElements.push_back(itSorted->second);
2278
2279 this->zcoordSetFlag = true;
2280
2281
2282 Widget formTop = XtNameToWidget(this->listsDialog, "FormTop");
2283 Widget formTopRight = XtNameToWidget(formTop, "FormTopRight");
2284
2285 this->createElementsList(formTopRight);
2286
2287 delete[] trajLength;
2288}
2289
2290
2291void G4OpenInventorXtExaminerViewer::createElementsList(Widget formTopRight)
2292{
2293 if(this->myElementList != NULL)
2294 XtUnmanageChild(this->myElementList);
2295
2296 int size = this->sceneElements.size();
2297 XmString *elements = (XmString *) XtMalloc(size * sizeof(XmString));
2298
2299 std::vector<sceneElement>::const_iterator it;
2300 int count = 0;
2301 std::stringstream ss;
2302 for(it=this->sceneElements.begin(); it!=this->sceneElements.end(); ++it) {
2303 ss << it->name;
2304 if(zcoordSetFlag)
2305 ss << " [" << it->closestPointZCoord << "]";
2306 elements[count] = XmStringCreateLocalized((char *)ss.str().c_str());
2307 ++count;
2308 ss.str("");
2309 }
2310
2311 Arg args[10];
2312 int n;
2313
2314 // Label Right
2315 n = 0;
2316 Widget labelRight;
2317 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
2318
2319 labelRight = XmCreateLabelGadget(formTopRight, (char*)"Element [S mm]",
2320 args, n);
2321 XtManageChild(labelRight);
2322
2323 // List Right
2324 n = 0;
2325 XtSetArg(args[n], XmNvisibleItemCount, 7); n++;
2326 XtSetArg(args[n], XmNitemCount, size); n++;
2327 XtSetArg(args[n], XmNitems, elements); n++;
2328 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
2329 XtSetArg(args[n], XmNtopWidget, labelRight); n++;
2330 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
2331 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
2332 XtSetArg(args[n], XmNwidth, 280); n++;
2333 // XtSetArg(args[n], XmNwidth, 300); n++;
2334
2335 this->myElementList = XmCreateScrolledList(formTopRight, (char *) "ListRight", args, n);
2336
2337 XtAddCallback(this->myElementList, XmNbrowseSelectionCallback,
2338 (XtCallbackProc) lookAtSceneElementCB, this);
2339 xmAddMouseEventHandler(this->myElementList); // Add scrolling functionality
2340 XtManageChild(this->myElementList);
2341
2342 if (elements != NULL) {
2343 for (int i = 0; i < size; i++)
2344 XmStringFree(elements[i]);
2345 XtFree((char *) elements);
2346 }
2347}
2348
2349
2350// Pops up a custom dialog listsDialog containing
2351// scene elements and viewpoints.
2352
2353void G4OpenInventorXtExaminerViewer::constructListsDialog(Widget w,
2354 XtPointer client_data,
2355 XtPointer)
2356{
2357 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
2358 if (This->listsDialog) {
2359 return;
2360 }
2361
2362 if (This->currentState == ANIMATION || This->currentState == PAUSED_ANIMATION) {
2363 if (This->animateSensor->isScheduled())
2364 This->animateSensor->unschedule();
2365 This->refParticleIdx = This->prevRefIdx;
2366 This->restoreCamera();
2367 This->currentState = This->prevState;
2368 }
2369
2370 This->step = 1; // Default values
2371 This->refParticleIdx = 0;
2372 if (This->refParticleTrajectory.size()){
2373 This->prevPt = This->refParticleTrajectory[0]; // For calculating distance
2374 }
2375
2376 This->getSceneElements();
2377
2378 int n = 0;
2379 Arg args[10];
2380 Atom WM_DELETE_WINDOW;
2381
2382 ///////////////////////CUSTOM listsDialog///////////////////////////////
2383
2384 Widget topShell;
2385 topShell = SoXt::getShellWidget(This->getParentWidget());
2386
2387 // Shell Dialog
2388 std::string dialogNameStr = This->fileName.substr(This->fileName.rfind('/') + 1);
2389 char *dialogName = new char[dialogNameStr.size() + 1];
2390 strcpy(dialogName, dialogNameStr.c_str());
2391
2392 n = 0;
2393 XtSetArg(args[n], XmNx, 610); n++;
2394 This->myShellDialog = XmCreateDialogShell(topShell, dialogName, args, n);
2395
2396 delete[] dialogName;
2397 WM_DELETE_WINDOW = XInternAtom(XtDisplay(w), "WM_DELETE_WINDOW", False);
2398 XmAddWMProtocolCallback(This->myShellDialog, WM_DELETE_WINDOW,
2399 (XtCallbackProc)closeListsDialogCB, This);
2400
2401 // Main Pane(listsDialog)
2402 n = 0;
2403 XtSetArg(args[n], XmNsashWidth, 1); n++;
2404 XtSetArg(args[n], XmNsashHeight, 1); n++;
2405 XtSetArg(args[n], XmNseparatorOn, False); n++;
2406 This->listsDialog = XmCreatePanedWindow(This->myShellDialog, (char *) "MainPane",
2407 args, n);
2408
2409
2410 ////////////////////////TOP FORM//////////////////////////
2411 n = 0;
2412 Widget formTop = XmCreateForm(This->listsDialog, (char *) "FormTop", args, n);
2413
2414 n = 0;
2415 XtSetArg(args[n], XmNmarginWidth, 8); n++;
2416 XtSetArg(args[n], XmNmarginHeight, 8); n++;
2417 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
2418 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
2419 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
2420 Widget formTopRight = XmCreateForm(formTop, (char *) "FormTopRight", args,
2421 n);
2422
2423 n = 0;
2424 XtSetArg(args[n], XmNmarginWidth, 8); n++;
2425 XtSetArg(args[n], XmNmarginHeight, 8); n++;
2426 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
2427 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
2428 XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
2429 XtSetArg(args[n], XmNrightWidget, formTopRight); n++;
2430 XtSetArg(args[n], XmNrightOffset, 10); n++;
2431 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
2432 Widget formTopLeft = XmCreateForm(formTop, (char *) "FormTopLeft", args, n);
2433
2434 /////TOP RIGHT/////
2435
2436 This->createElementsList(formTopRight);
2437 XtManageChild(formTopRight);
2438
2439 /////TOP LEFT/////
2440
2441 // Label Left
2442 n = 0;
2443 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
2444 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
2445 Widget labelLeft = XmCreateLabelGadget(formTopLeft, (char *) "ViewPoints",
2446 args, n);
2447 XtManageChild(labelLeft);
2448
2449 // List Left
2450 n = 0;
2451 XtSetArg(args[n], XmNlistSizePolicy, XmRESIZE_IF_POSSIBLE); n++;
2452 XtSetArg(args[n], XmNvisibleItemCount, 7); n++;
2453 // XtSetArg(args[n], XmNwidth, 140); n++;
2454 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
2455 XtSetArg(args[n], XmNtopWidget, labelLeft); n++;
2456 XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
2457 XtSetArg(args[n], XmNrightWidget, This->myElementList); n++;
2458 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
2459 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
2460 XtSetArg(args[n], XmNwidth, 200); n++;
2461
2462 This->myViewPtList = XmCreateScrolledList(formTopLeft, (char *) "ListLeft",
2463 args, n);
2464 if (This->viewPtList.size())
2465 This->addViewPoints();
2466 XtAddCallback(This->myViewPtList, XmNbrowseSelectionCallback,
2467 (XtCallbackProc) loadBookmarkCB, This);
2468 xmAddMouseEventHandler(This->myViewPtList); // Add scrolling functionality
2469
2470 XtManageChild(This->myViewPtList);
2471
2472 XtManageChild(formTopLeft);
2473
2474 XtManageChild(formTop);
2475
2476 ////////////////////MIDDLE FORM///////////////////////////
2477 n = 0;
2478 XtSetArg(args[n], XmNmarginWidth, 6); n++;
2479 Widget formMiddle = XmCreateForm(This->listsDialog, (char *) "MiddleForm", args,
2480 n);
2481
2482 // Label
2483 n = 0;
2484 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
2485 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
2486 XtSetArg(args[n], XmNtopWidget, This->myViewPtList); n++;
2487 Widget label = XmCreateLabelGadget(formMiddle, (char *) "Selection", args,
2488 n);
2489 XtManageChild(label);
2490
2491 // Text
2492 n = 0;
2493 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
2494 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
2495 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
2496 XtSetArg(args[n], XmNtopWidget, label); n++;
2497 XtSetArg(args[n], XmNtopOffset, 3); n++;
2498 XtSetArg(args[n], XmNmaxLength, This->MAX_VP_NAME); n++;
2499 This->viewPtSelection = XmCreateText(formMiddle, (char *) "Txt", args, n);
2500 XtManageChild(This->viewPtSelection);
2501
2502 Dimension h1, h2, h;
2503 XtVaGetValues(label, XmNheight, &h1, NULL);
2504 XtVaGetValues(This->viewPtSelection, XmNheight, &h2, NULL);
2505
2506 h = (Dimension) (1.1 * (h1 + h2));
2507
2508 XtVaSetValues(formMiddle, XmNpaneMaximum, h, XmNpaneMinimum, h, NULL);
2509 XtManageChild(formMiddle);
2510
2511 /////////////////////BOTTOM FORM///////////////////////////
2512 // Action Area Form
2513 n = 0;
2514 XtSetArg(args[n], XmNfractionBase, 4); n++;
2515 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
2516 XtSetArg(args[n], XmNtopWidget, This->viewPtSelection); n++;
2517 Widget formAction = XmCreateForm(This->listsDialog, (char *) "ActionForm", args,
2518 n);
2519
2520 n = 0;
2521 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
2522 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
2523 XtSetArg(args[n], XmNtopOffset, 3); n++;
2524 XtSetArg(args[n], XmNbottomOffset, 5); n++;
2525 Widget separator = XmCreateSeparatorGadget(formAction, (char *) "Sep", args, n);
2526
2527 XtManageChild(separator);
2528
2529 Widget button = XmCreatePushButton(formAction, (char *) "Delete", NULL, 0);
2530 XtVaSetValues(button, XmNtopAttachment, XmATTACH_WIDGET, XmNtopWidget,
2531 separator, XmNbottomAttachment, XmATTACH_FORM, XmNleftAttachment,
2532 XmATTACH_POSITION, XmNleftPosition, 0, XmNrightAttachment,
2533 XmATTACH_POSITION, XmNrightPosition, 1,
2534 XmNdefaultButtonShadowThickness, 2, XmNwidth, 40, XmNheight, 30,
2535 NULL);
2536
2537 XtAddCallback(button, XmNactivateCallback,
2538 (XtCallbackProc) deleteBookmarkCB, This);
2539 XtManageChild(button);
2540
2541 button = XmCreatePushButton(formAction, (char *) "Rename", NULL, 0);
2542 XtVaSetValues(button, XmNtopAttachment, XmATTACH_WIDGET, XmNtopWidget,
2543 separator, XmNbottomAttachment, XmATTACH_FORM, XmNleftAttachment,
2544 XmATTACH_POSITION, XmNleftPosition, 1, XmNrightAttachment,
2545 XmATTACH_POSITION, XmNrightPosition, 2,
2546 XmNdefaultButtonShadowThickness, 2, XmNwidth, 40, XmNheight, 30,
2547 NULL);
2548
2549 XtAddCallback(button, XmNactivateCallback,
2550 (XtCallbackProc) renameBookmarkCB, This);
2551 XtManageChild(button);
2552
2553 button = XmCreatePushButton(formAction, (char *) "Sort", NULL, 0);
2554 XtVaSetValues(button, XmNtopAttachment, XmATTACH_WIDGET, XmNtopWidget,
2555 separator, XmNbottomAttachment, XmATTACH_FORM, XmNleftAttachment,
2556 XmATTACH_POSITION, XmNleftPosition, 2, XmNrightAttachment,
2557 XmATTACH_POSITION, XmNrightPosition, 3,
2558 XmNdefaultButtonShadowThickness, 2, XmNwidth, 40, XmNheight, 30,
2559 NULL);
2560
2561 XtAddCallback(button, XmNactivateCallback, (XtCallbackProc) sortBookmarksCB, This);
2562 XtManageChild(button);
2563
2564 button = XmCreatePushButton(formAction, (char *) "Close", NULL, 0);
2565 XtVaSetValues(button, XmNtopAttachment, XmATTACH_WIDGET, XmNtopWidget,
2566 separator, XmNbottomAttachment, XmATTACH_FORM, XmNleftAttachment,
2567 XmATTACH_POSITION, XmNleftPosition, 3, XmNrightAttachment,
2568 XmATTACH_POSITION, XmNrightPosition, 4,
2569 XmNdefaultButtonShadowThickness, 2, XmNwidth, 40, XmNheight, 30,
2570 NULL);
2571
2572 XtAddCallback(button, XmNactivateCallback, (XtCallbackProc) closeListsDialogCB, This);
2573 XtManageChild(button);
2574
2575 XtManageChild(formAction);
2576 XtVaGetValues(button, XmNheight, &h1, NULL);
2577 XtVaSetValues(formAction, XmNpaneMaximum, h1, XmNpaneMinimum, h1, NULL);
2578
2579 XtManageChild(This->listsDialog);
2580
2581 ////////////////////////CUSTOM listsDialog///////////////////////////////
2582}
2583
2584
2585// Called when user clicks a scene element in listsDialog.
2586// Zooms onto that element.
2587void G4OpenInventorXtExaminerViewer::lookAtSceneElementCB(Widget,
2588 XtPointer client_data,
2589 XtPointer call_data)
2590{
2591 char *value;
2592 std::string elementField;
2593 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
2594 SoCamera * cam = This->getCamera();
2595
2596 if (This->SoXtExaminerViewer::isAnimating())
2597 This->stopAnimating();
2598
2599 XmListCallbackStruct *cbs = (XmListCallbackStruct *) call_data;
2600
2601 value = (char *) XmStringUnparse(cbs->item, XmFONTLIST_DEFAULT_TAG,
2602 XmCHARSET_TEXT, XmCHARSET_TEXT, NULL, 0, XmOUTPUT_ALL);
2603 if (This->currentState == ANIMATION || This->currentState == REVERSED_ANIMATION
2604 || This->currentState == PAUSED_ANIMATION ) {
2605 if (This->animateSensor->isScheduled())
2606 This->animateSensor->unschedule();
2607 This->setSuperimpositionEnabled(This->superimposition, FALSE);
2608 This->maxSpeed = 0.0f;
2609 This->scheduleRedraw();
2610 This->restoreCamera();
2611 This->currentState = This->prevState;
2612 } else if (This->currentState == VIEWPOINT)
2613 This->setSuperimpositionEnabled(This->superimposition, FALSE);
2614
2615 elementField = value;
2616
2617 int idx = elementField.find_last_of("[");
2618 if(idx == -1)
2619 idx = elementField.size(); //if "[" not found for whatever reason (list not sorted)
2620 else
2621 idx--; // To get rid of the space that is between the name and '['
2622
2623 bool error = false;
2624 SoFullPath *path;
2625 SoSearchAction search;
2626 SoNode *root = This->getSceneManager()->getSceneGraph();
2627 int counter, idxUnderscore = elementField.find_last_of("_");
2628
2629 This->parseString<int>(counter, elementField.substr(idxUnderscore + 1, idx), error);
2630
2631 SoBaseKit::setSearchingChildren(TRUE);
2632 search.reset();
2633 search.setSearchingAll(TRUE);
2634
2635 if(error) { // No counter is present => element name was not modified
2636 This->curEltName = elementField.substr(0, idx);
2637 search.setName(This->curEltName.c_str());
2638 search.apply(root);
2639
2640 path = (SoFullPath *)search.getPath();
2641 }
2642 else {
2643 This->curEltName = elementField.substr(0, idxUnderscore);
2644 search.setInterest(SoSearchAction::ALL);
2645 search.setName(This->curEltName.c_str());
2646 search.apply(root);
2647
2648 SoPathList &pl = search.getPaths();
2649 path = (SoFullPath *)pl[counter - 1]; // Since counter starts at 1, not 0
2650 }
2651
2652 G4ThreeVector global;
2653
2654 if ((idx > 0) && (path)) {
2655
2656 if(!This->refParticleTrajectory.empty()){
2657
2658 SoGetBoundingBoxAction bAction(This->getViewportRegion());
2659 bAction.apply(path);
2660 SbBox3f bBox = bAction.getBoundingBox();
2661 SbVec3f elementCoord = bBox.getCenter();
2662
2663 This->refParticleIdx = 0;
2664 SbVec3f p;
2665
2666 float absLengthNow, absLengthMin;
2667 int maxIdx = This->refParticleTrajectory.size() - 2;
2668 int targetIdx = 0;
2669 SbVec3f dir;
2670
2671 p = This->refParticleTrajectory[This->refParticleIdx];
2672 absLengthMin = (p - elementCoord).length();
2673 This->refParticleIdx++;
2674
2675 // Find a ref. particle's point closest to element's global coords
2676 while (This->refParticleIdx < maxIdx) {
2677 p = This->refParticleTrajectory[This->refParticleIdx];
2678 absLengthNow = (p - elementCoord).length();
2679
2680 if (absLengthNow < absLengthMin) {
2681 absLengthMin = absLengthNow;
2682 targetIdx = This->refParticleIdx;
2683 }
2684 This->refParticleIdx++;
2685 }
2686
2687 if (This->currentState != BEAMLINE) { // Set up default zoom
2688 SbVec3f p1, pN;
2689 This->currentState = BEAMLINE;
2690 This->prevParticleDir = SbVec3f(0,0,0); //so that moveCamera() knows sets default parameters
2691
2692 p1 = This->prevPt = This->refParticleTrajectory[0];
2693 pN = This->refParticleTrajectory[This->refParticleTrajectory.size() - 1];
2694 This->distance = (pN - p1).length() / 10;
2695
2696 // FWJ Restore the default height instead of hard-wired value
2697 if (cam->isOfType(SoOrthographicCamera::getClassTypeId()))
2698 ((SoOrthographicCamera *) cam)->height.setValue(This->defaultHeight);
2699 // ((SoOrthographicCamera *) cam)->height.setValue(10000.0f);
2700 else if (cam->isOfType(SoPerspectiveCamera::getClassTypeId()))
2701 ((SoPerspectiveCamera *) cam)->heightAngle.setValue(
2702 This->defaultHeightAngle);
2703 } else {
2704 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId()))
2705 This->distance = (This->prevPt - cam->position.getValue()).length();
2706 }
2707 This->refParticleIdx = targetIdx;
2708
2709 //////////////////////////////////////////////////////////////
2710 This->setSuperimpositionEnabled(This->superimposition, TRUE);
2711 This->axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
2712 This->animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
2713 This->animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
2714 This->scheduleRedraw();
2715 //////////////////////////////////////////////////////////////
2716
2717 This->moveCamera(This->distance);
2718 XtFree(value);
2719
2720 }
2721 else{
2722 This->offsetFromCenter.setValue(0, 0, 1);
2723 This->distance = 50;// small number since using viewAll() for default zoom
2724 This->upVector.setValue(0, 1, 0);
2725
2726 This->moveCamera(This->distance);
2727 cam->viewAll(path, This->getViewportRegion());
2728 }
2729 }
2730
2731 XmTextSetString(This->viewPtSelection, NULL);
2732}
2733
2734
2735// Destroyes listsDialog and resets necessary member fields.
2736
2737void G4OpenInventorXtExaminerViewer::closeListsDialogCB(Widget,
2738 XtPointer client_data,
2739 XtPointer)
2740{
2741 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
2742
2743 This->sceneElements.clear();
2744 This->refParticleTrajectory.clear();
2745
2746 This->currentState = GENERAL;
2747 XtDestroyWidget(This->myShellDialog);
2748 This->listsDialog = NULL;
2749}
2750
2751// Called when user clicks left arrow button. Loads previous viewpoint.
2752void G4OpenInventorXtExaminerViewer::prevViewPtCB(Widget, XtPointer client_data,
2753 XtPointer) {
2754 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
2755
2756 if (This->viewPtIdx == 0)
2757 This->viewPtIdx = This->viewPtList.size() - 1;
2758 else
2759 This->viewPtIdx--;
2760
2761 This->writeViewPtIdx();
2762 This->setViewPt();
2763}
2764
2765// Called when user clicks right arrow button. Loads next viewpoint.
2766void G4OpenInventorXtExaminerViewer::nextViewPtCB(Widget, XtPointer client_data,
2767 XtPointer) {
2768 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
2769
2770 if (This->viewPtIdx >= (int) This->viewPtList.size() - 1)
2771 This->viewPtIdx = 0;
2772 else
2773 This->viewPtIdx++;
2774
2775 This->writeViewPtIdx();
2776 This->setViewPt();
2777}
2778
2779
2780// Updates the viewPtIdx in a viewpoint file.
2781
2782void G4OpenInventorXtExaminerViewer::writeViewPtIdx()
2783{
2784 std::string idxStr;
2785 std::stringstream out;
2786 out << viewPtIdx;
2787 idxStr = out.str();
2788 fileOut.seekp(0, std::ios::beg);
2789
2790 while ((int) idxStr.length() < MAX_VP_IDX) {
2791 idxStr += " ";
2792 }
2793
2794 fileOut << idxStr << "\n";
2795 fileOut.flush();
2796 fileOut.seekp(0, std::ios::end);
2797}
2798
2799
2800// Sets the viewpoint based on camera data that viewPtIdx is pointing to.
2801
2802void G4OpenInventorXtExaminerViewer::setViewPt()
2803{
2804 if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
2805 || currentState == ROTATING) {
2806
2807 if (animateSensor->isScheduled())
2808 animateSensor->unschedule();
2809 setSuperimpositionEnabled(superimposition, FALSE);
2810 maxSpeed = 0.0f;
2811 scheduleRedraw();
2812 }
2813
2814 SoCamera * camera = getCamera();
2815 if (camera == NULL) {
2816 String dialogName = (char *) "Missing Camera Node";
2817 std::string msg = "Camera is null. Unable to set the viewpoint.";
2818 warningMsgDialog(msg, dialogName, NULL);
2819 return;
2820 }
2821
2822 if (!viewPtList.size()) {
2823 String dialogName = (char *) "Missing Viewpoints";
2824 std::string msg = "There are no viewpoints to load.";
2825 warningMsgDialog(msg, dialogName, NULL);
2826 return;
2827 }
2828
2829 if (SoXtExaminerViewer::isAnimating())
2830 stopAnimating();
2831
2832 if (currentState != VIEWPOINT) {
2833 currentState = VIEWPOINT;
2834 //////////////////////////////////////////////////////////////
2835 setSuperimpositionEnabled(superimposition, TRUE);
2836 axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
2837 animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
2838 animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
2839
2840 scheduleRedraw();
2841 ///////////////////////////////////////////////////////////////
2842 }
2843
2844 curViewPtName = viewPtList[viewPtIdx].viewPtName;
2845 camera->viewportMapping = viewPtList[viewPtIdx].viewportMapping;
2846 camera->position = viewPtList[viewPtIdx].position;
2847 camera->orientation = viewPtList[viewPtIdx].orientation;
2848 camera->aspectRatio = viewPtList[viewPtIdx].aspectRatio;
2849 camera->nearDistance = viewPtList[viewPtIdx].nearDistance;
2850 camera->farDistance = viewPtList[viewPtIdx].farDistance;
2851 camera->focalDistance = viewPtList[viewPtIdx].focalDistance;
2852
2853 // Restore camera height (changed by zooming)
2854 if (camera->isOfType(SoPerspectiveCamera::getClassTypeId())) {
2855 if (viewPtList[viewPtIdx].camType == ORTHOGRAPHIC) {
2856 toggleCameraType();
2857 camera = getCamera();
2858 ((SoOrthographicCamera *) camera)->height.setValue(
2859 viewPtList[viewPtIdx].height);
2860 } else
2861 ((SoPerspectiveCamera *) camera)->heightAngle.setValue(
2862 viewPtList[viewPtIdx].height);
2863 } else if (camera->isOfType(SoOrthographicCamera::getClassTypeId())) {
2864 if (viewPtList[viewPtIdx].camType == PERSPECTIVE) {
2865 toggleCameraType();
2866 camera = getCamera();
2867 ((SoPerspectiveCamera *) camera)->heightAngle.setValue(
2868 viewPtList[viewPtIdx].height);
2869 } else
2870 ((SoOrthographicCamera *) camera)->height.setValue(
2871 viewPtList[viewPtIdx].height);
2872 } else {
2873 SoDebugError::post("G4OpenInventorXtExaminerViewer::setViewPt",
2874 "Only Perspective and Orthographic cameras are supported.");
2875 return;
2876 }
2877
2878}
2879
2880
2881// Pops up a prompt asking for a new viewpoint name.
2882
2883void G4OpenInventorXtExaminerViewer::saveViewPtCB(Widget w,
2884 XtPointer client_data,
2885 XtPointer)
2886{
2887 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
2888
2889 if (This->fileName.empty()) {
2890 newViewPtFileCB(w, This, NULL);
2891 This->returnToSaveVP = true;
2892 return; // Need to return and call this fn again from newViewPtFileCB since flow of control does not stall here but keeps going
2893 }
2894
2895 int n = 0;
2896 Arg args[4];
2897 Widget nameViewPtDialog;
2898 Widget parent = This->getParentWidget(); //gets the dialogshell of the ExaminerViewer widget
2899 XmString label = XmStringCreateLocalized((char *) "Name the viewpoint:");
2900
2901 XtSetArg(args[n], XmNselectionLabelString, label); n++;
2902 XtSetArg(args[n], XmNautoUnmanage, False); n++; //prevent the dialog from closing
2903 //automatically, in case the name
2904 //is wrong
2905
2906 nameViewPtDialog = XmCreatePromptDialog(parent, (char *) "Save Viewpoint",
2907 args, n);
2908
2909 XmStringFree(label);
2910 XtAddCallback(nameViewPtDialog, XmNokCallback, getViewPtNameCB, This);
2911 XtAddCallback(nameViewPtDialog, XmNcancelCallback,
2912 (XtCallbackProc) XtDestroyWidget, NULL);
2913
2914 Widget text = XtNameToWidget(nameViewPtDialog, "Text");
2915 XtVaSetValues(text, XmNmaxLength, This->MAX_VP_NAME, NULL);
2916 std::string autoName = "";
2917 if (!This->warningFlag) { //leave the TextField as it is if coming back from warning dialog
2918 autoName = This->viewPtAutoName();
2919 }
2920 This->warningFlag = false;
2921 XmTextSetString(text, (char *) autoName.c_str());
2922 XmTextSetInsertionPosition(text, autoName.length());
2923
2924 XtUnmanageChild(XtNameToWidget(nameViewPtDialog, "Help"));
2925 XtManageChild(nameViewPtDialog);
2926}
2927
2928
2929std::string G4OpenInventorXtExaminerViewer::viewPtAutoName()
2930{
2931 std::string viewPt;
2932 std::stringstream sstream;
2933 std::vector<int> existingViewPts;
2934 int tmp;
2935
2936 //Build the list of names of the form viewpoint_* already present
2937 for (unsigned int i = 0; i < this->viewPtList.size(); ++i) {
2938 viewPt = this->viewPtList[i].viewPtName;
2939 if (viewPt.find("viewpoint_") != std::string::npos) {
2940 tmp = atoi(viewPt.substr(10).c_str());
2941 if (tmp == 0) {
2942 //0 means couldn't convert to integer OR viewpoint_0
2943 if (!viewPt.compare("viewpoint_0"))
2944 existingViewPts.push_back(0);
2945 } else
2946 existingViewPts.push_back(tmp);
2947 }
2948 }
2949
2950 sstream.str("");
2951 sstream.clear();
2952
2953 //Return the view viewpoint_* name available
2954 if (existingViewPts.size() > 0) {
2955 int vpNum = 0;
2956 while (true) {
2957 if (std::find(existingViewPts.begin(), existingViewPts.end(), vpNum)
2958 == existingViewPts.end()) {
2959 sstream << "viewpoint_" << vpNum;
2960 return sstream.str();
2961 }
2962 ++vpNum;
2963 }
2964 } else {
2965 return "viewpoint_0";
2966 }
2967 return "";
2968}
2969
2970
2971void G4OpenInventorXtExaminerViewer::abbrOutputCB(Widget,
2972 XtPointer client_data,
2973 XtPointer)
2974{
2975 G4OpenInventorXtExaminerViewer * This =
2976 (G4OpenInventorXtExaminerViewer *) client_data;
2977 This->abbrOutputFlag = !(This->abbrOutputFlag);
2978}
2979
2980
2981void G4OpenInventorXtExaminerViewer::pickRefPathCB(Widget,
2982 XtPointer client_data,
2983 XtPointer)
2984{
2985 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
2986
2987 // Save viewing state and go to picking mode
2988 This->viewingBeforePickRef = This->isViewing();
2989 if(This->isViewing())
2990 This->setViewing(false);
2991 This->setComponentCursor(SoXtCursor(SoXtCursor::CROSSHAIR));
2992 This->pickRefPathFlag = true;
2993}
2994
2995
2996// Examines new viewpoint name and if OK calls saveViewPt.
2997
2998void G4OpenInventorXtExaminerViewer::getViewPtNameCB(Widget w,
2999 XtPointer client_data,
3000 XtPointer call_data)
3001{
3002 char *name = NULL;
3003 std::string strName;
3004 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
3005 XmSelectionBoxCallbackStruct *cbs =
3006 (XmSelectionBoxCallbackStruct *) call_data;
3007 XmStringGetLtoR(cbs->value, XmFONTLIST_DEFAULT_TAG, &name);
3008
3009 if (!name) {
3010 return;
3011 }
3012 if (!*name) {
3013 XtFree(name);
3014 return;
3015 }
3016
3017 strName = name;
3018 XtFree(name);
3019
3020 int beg = strName.find_first_not_of(' '); // Remove leading/trailing spaces
3021 int end = strName.find_last_not_of(' ');
3022 strName = strName.substr(beg, end - beg + 1);
3023
3024 bool nameExists = false;
3025 int size = This->viewPtList.size();
3026 for (int i = 0; i < size; i++) {
3027 if (!strcmp(This->viewPtList[i].viewPtName, strName.c_str())) {
3028 nameExists = true;
3029 break;
3030 }
3031 }
3032
3033 if (!nameExists) {
3034 name = new char[This->MAX_VP_NAME + 1];
3035 strcpy(name, strName.c_str());
3036 if (This->viewPtIdx == -1)
3037 This->viewPtIdx = 0;
3038 This->saveViewPt(name);
3039 if (This->listsDialog) {
3040 XmListAddItemUnselected(This->myViewPtList, cbs->value, 0); // vpName
3041 }
3042 //Dismiss the nameViewPtDialog dialog
3043 XtUnmanageChild(w);
3044 } else {
3045 String dialogName = (char *) "Existing Viewpoint";
3046 std::string msg = "The viewpoint already exists.";
3047 This->warningMsgDialog(msg, dialogName, NULL);
3048
3049 }
3050}
3051
3052
3053// Saves current camera parameters to a viewpoint file.
3054
3055void G4OpenInventorXtExaminerViewer::saveViewPt(char *name)
3056{
3057 SbVec3f axis;
3058 viewPtData tmp;
3059 float x, y, z, angle;
3060 SoCamera * camera = getCamera();
3061
3062 if (viewPtList.size() == 0) {
3063 writeViewPtIdx();
3064 XtSetSensitive(nextViewPtButton, True); // Makes arrow buttons clickable
3065 XtSetSensitive(prevViewPtButton, True);
3066 }
3067
3068 tmp.viewPtName = name;
3069 tmp.viewportMapping = camera->viewportMapping.getValue();
3070 tmp.position = camera->position.getValue();
3071 tmp.orientation = camera->orientation.getValue();
3072 tmp.aspectRatio = camera->aspectRatio.getValue();
3073 tmp.nearDistance = camera->nearDistance.getValue();
3074 tmp.farDistance = camera->farDistance.getValue();
3075 tmp.focalDistance = camera->focalDistance.getValue();
3076
3077 // Save camera height (changed by zooming)
3078 if (camera->isOfType(SoPerspectiveCamera::getClassTypeId())) {
3079 tmp.height = ((SoPerspectiveCamera *) camera)->heightAngle.getValue();
3080 tmp.camType = PERSPECTIVE;
3081 } else if (camera->isOfType(SoOrthographicCamera::getClassTypeId())) {
3082 tmp.height = ((SoOrthographicCamera *) camera)->height.getValue();
3083 tmp.camType = ORTHOGRAPHIC;
3084 } else {
3085 SoDebugError::post("G4OpenInventorXtExaminerViewer::saveViewPtCB",
3086 "Only Perspective and Orthographic cameras are supported.");
3087 return;
3088 }
3089
3090 viewPtList.push_back(tmp);
3091
3092 // Now save the view point to a .txt file
3093 std::string vpName = name;
3094
3095 while ((int) vpName.size() <= MAX_VP_NAME)
3096 vpName += " ";
3097
3098 fileOut << vpName << std::endl;
3099 tmp.position.getValue(x, y, z);
3100 fileOut << x << " " << y << " " << z << std::endl;
3101
3102 // Reusing x, y and z for storing the axis
3103 tmp.orientation.getValue(axis, angle);
3104 axis.getValue(x, y, z);
3105 fileOut << x << " " << y << " " << z << " " << angle << std::endl;
3106
3107 fileOut << tmp.camType << " " << tmp.height << std::endl;
3108 fileOut << tmp.focalDistance << " ";
3109 fileOut << tmp.nearDistance << " ";
3110 fileOut << tmp.farDistance << std::endl;
3111 fileOut << tmp.viewportMapping << " ";
3112 fileOut << tmp.aspectRatio << "\n" << std::endl;
3113 fileOut.flush();
3114 viewPtIdx++;
3115}
3116
3117
3118void G4OpenInventorXtExaminerViewer::deleteViewPtCB(Widget,
3119 XtPointer client_data,
3120 XtPointer)
3121{
3122 G4OpenInventorXtExaminerViewer * This =
3123 (G4OpenInventorXtExaminerViewer *) client_data;
3124 This->deleteViewPt();
3125}
3126
3127
3128// Deletes current viewpoint the user is looking at.
3129// Updates the input file and bookmarks as well.
3130
3131void G4OpenInventorXtExaminerViewer::deleteViewPt(char *vpName)
3132{
3133 std::string line;
3134 int end;
3135 fileIn.open(fileName.c_str());
3136 std::ofstream out("temporaryFile.txt");
3137
3138 if (!vpName)
3139 vpName = viewPtList[viewPtIdx].viewPtName;
3140
3141 if (listsDialog) {
3142 XmString vpNameStr = XmStringCreateLocalized(vpName);
3143
3144 XmListDeleteItem(myViewPtList, vpNameStr);
3145 XmStringFree(vpNameStr);
3146 }
3147
3148 getline(fileIn, line); // Printing the viewpoint idx
3149 out << line << "\n";
3150
3151 while (getline(fileIn, line)) {
3152 end = line.find_last_not_of(' ');
3153 line = line.substr(0, end + 1);
3154 if (!strcmp(line.c_str(), vpName)) { // Equal
3155 while (line.size()) {
3156 getline(fileIn, line);
3157 }
3158
3159 while (getline(fileIn, line))
3160 out << line << "\n";
3161 } else {
3162 while (line.size()) {
3163 out << line << "\n";
3164 getline(fileIn, line);
3165 }
3166 out << "\n";
3167 }
3168 }
3169
3170 int idx = 0; // Remove viewpoint from the vector
3171 int size = viewPtList.size();
3172 while (idx < size) {
3173 if (!strcmp(viewPtList[idx].viewPtName, vpName)) {
3174 viewPtList.erase(viewPtList.begin() + idx);
3175 break;
3176 }
3177 idx++;
3178 }
3179
3180 out.close();
3181 fileOut.close();
3182 fileIn.clear();
3183 fileIn.close();
3184
3185 remove(fileName.c_str());
3186 rename("temporaryFile.txt", fileName.c_str());
3187
3188 fileOut.open(fileName.c_str(), std::ios::in);
3189 fileOut.seekp(0, std::ios::end);
3190
3191 if (!viewPtList.size()) { // viewPtList is empty
3192 curViewPtName = (char *) "";
3193 scheduleRedraw();
3194 XtSetSensitive(nextViewPtButton, False);
3195 XtSetSensitive(prevViewPtButton, False);
3196 } else {
3197 if (viewPtIdx >= (int) viewPtList.size())
3198 viewPtIdx--;
3199 writeViewPtIdx();
3200 setViewPt();
3201 }
3202}
3203
3204
3205// Renames currently selected viewpoint.
3206
3207void G4OpenInventorXtExaminerViewer::renameViewPt(char *vpName)
3208{
3209 int idx = 0, end, pos;
3210 int size = viewPtList.size();
3211 std::string line, newName;
3212 fileIn.open(fileName.c_str());
3213
3214 newName = vpName;
3215 while ((int) newName.size() < MAX_VP_NAME)
3216 newName += " ";
3217
3218 getline(fileIn, line);
3219 pos = fileIn.tellg();
3220 while (getline(fileIn, line)) {
3221 end = line.find_last_not_of(' ');
3222 line = line.substr(0, end + 1);
3223 if (!strcmp(line.c_str(), curViewPtName)) {
3224 fileOut.seekp(pos);
3225 fileOut << newName;
3226 fileOut.seekp(0, std::ios::end); // Set the file pointer to the end of the file
3227 break;
3228 }
3229 while (line.size())
3230 getline(fileIn, line);
3231 pos = fileIn.tellg();
3232 }
3233
3234 fileIn.close();
3235 fileIn.clear();
3236
3237 while (idx < size) {
3238 if (!strcmp(viewPtList[idx].viewPtName, curViewPtName)) {
3239 strcpy(viewPtList[idx].viewPtName, vpName);
3240 break;
3241 }
3242 idx++;
3243 }
3244}
3245
3246
3247// Rewrites entire viewpoint file with sorted viewpoints.
3248
3249void G4OpenInventorXtExaminerViewer::sortViewPts(std::vector<std::string> sortedViewPts)
3250{
3251 SbVec3f axis;
3252 float x, y, z, angle;
3253 int sortIdx = 0, unsortIdx = 0;
3254
3255 if (fileOut.is_open())
3256 fileOut.close();
3257
3258 fileOut.open(fileName.c_str()); // Erase current viewpoint file
3259
3260 writeViewPtIdx();
3261
3262 int size = sortedViewPts.size();
3263 while (sortIdx < size) {
3264 while (strcmp(sortedViewPts[sortIdx].c_str(),
3265 viewPtList[unsortIdx].viewPtName))
3266 unsortIdx++;
3267
3268 std::string vpName = viewPtList[unsortIdx].viewPtName;
3269
3270 while ((int) vpName.size() < MAX_VP_NAME)
3271 vpName += " ";
3272 fileOut << vpName << std::endl;
3273 viewPtList[unsortIdx].position.getValue(x, y, z);
3274 fileOut << x << " " << y << " " << z << std::endl;
3275
3276 // Reusing x, y and z for storing the axis
3277 viewPtList[unsortIdx].orientation.getValue(axis, angle);
3278 axis.getValue(x, y, z);
3279 fileOut << x << " " << y << " " << z << " " << angle << std::endl;
3280
3281 fileOut << viewPtList[unsortIdx].camType << " "
3282 << viewPtList[unsortIdx].height << std::endl;
3283 fileOut << viewPtList[unsortIdx].focalDistance << " ";
3284
3285 fileOut << viewPtList[unsortIdx].nearDistance << " ";
3286
3287 fileOut << viewPtList[unsortIdx].farDistance << std::endl;
3288
3289 fileOut << viewPtList[unsortIdx].viewportMapping << " ";
3290 fileOut << viewPtList[unsortIdx].aspectRatio << "\n" << std::endl;
3291 fileOut.flush();
3292
3293 unsortIdx = 0;
3294 sortIdx++;
3295 }
3296}
3297
3298
3299// Loads view point data from a file into a vector.
3300
3301bool G4OpenInventorXtExaminerViewer::loadViewPts()
3302{
3303 bool error = false;
3304 viewPtData tmp;
3305 std::string token;
3306 SbVec3f axis;
3307 SbRotation orient;
3308 float x, y, z, angle;
3309
3310 // Gets the last view point accessed, stored in the first line of the data file.
3311 fileIn >> token;
3312 parseString<int>(viewPtIdx, token, error);
3313 getline(fileIn, token); // Remove "\n"
3314 // Converts data from string type into necessary types
3315 while (getline(fileIn, token)) {
3316
3317 int end = token.find_last_not_of(' '); // Remove padded spaces
3318 token = token.substr(0, end + 1);
3319
3320 char *vpName = new char[token.size() + 1];
3321 strcpy(vpName, token.c_str());
3322 tmp.viewPtName = vpName;
3323 fileIn >> token;
3324
3325 parseString<float>(x, token, error);
3326 fileIn >> token;
3327 parseString<float>(y, token, error);
3328 fileIn >> token;
3329 parseString<float>(z, token, error);
3330 fileIn >> token;
3331 tmp.position = axis.setValue(x, y, z);
3332
3333 parseString<float>(x, token, error);
3334 fileIn >> token;
3335 parseString<float>(y, token, error);
3336 fileIn >> token;
3337 parseString<float>(z, token, error);
3338 fileIn >> token;
3339 parseString<float>(angle, token, error);
3340 fileIn >> token;
3341 orient.setValue(axis.setValue(x, y, z), angle);
3342 tmp.orientation = orient.getValue();
3343
3344 int camType;
3345 parseString<int>(camType, token, error);
3346 fileIn >> token;
3347 tmp.camType = (CameraType) camType;
3348
3349 parseString<float>(tmp.height, token, error);
3350 fileIn >> token;
3351 parseString<float>(tmp.focalDistance, token, error);
3352 fileIn >> token;
3353 parseString<float>(tmp.nearDistance, token, error);
3354 fileIn >> token;
3355 parseString<float>(tmp.farDistance, token, error);
3356 fileIn >> token;
3357 parseString<int>(tmp.viewportMapping, token, error);
3358 fileIn >> token;
3359 parseString<float>(tmp.aspectRatio, token, error);
3360
3361 getline(fileIn, token); // To remove "\n" characters
3362 getline(fileIn, token);
3363
3364 if (error) {
3365 viewPtIdx = 0;
3366 viewPtList.clear();
3367 return false;
3368 }
3369 viewPtList.push_back(tmp);
3370 }
3371
3372 return true;
3373}
3374
3375
3376// Converts a string type word into a float type.
3377
3378template<class T>
3379void G4OpenInventorXtExaminerViewer::parseString(T &t, const std::string &s,
3380 bool &error)
3381{
3382 std::istringstream str(s);
3383 if ((str >> t).fail())
3384 error = true;
3385}
3386
3387
3388// Generic fileSelectionDialog creation.
3389
3390void G4OpenInventorXtExaminerViewer::popUpFileSelDialog(Widget &dialog,
3391 std::string dialogName,
3392 std::string buttonLabel,
3393 XtCallbackProc cbOK)
3394{
3395 int n;
3396 Arg args[3];
3397 Widget parent, scrollWidget;
3398 parent = SoXt::getShellWidget(getParentWidget());
3399
3400 if (dialog == NULL) {
3401
3402 // Change the 'OK' button to whatever buttonLabel contains
3403 XmString str = XmStringCreateLocalized((char *) buttonLabel.c_str());
3404
3405 n = 0;
3406 XtSetArg(args[n], XmNokLabelString, str); n++;
3407 XtSetArg(args[n], XmNresizePolicy, XmRESIZE_NONE); n++;
3408
3409 dialog = XmCreateFileSelectionDialog(parent,
3410 (char *) dialogName.c_str(), args, n);
3411
3412 XtAddCallback(dialog, XmNokCallback, cbOK, this);
3413 XtAddCallback(dialog, XmNcancelCallback, cancelFileSelDialogCB, this);
3414
3415 // Adding scrolling functionality to the widget
3416 scrollWidget = XmFileSelectionBoxGetChild(dialog, XmDIALOG_DIR_LIST);
3417 if (scrollWidget)
3418 xmAddMouseEventHandler(scrollWidget);
3419 scrollWidget = XmFileSelectionBoxGetChild(dialog, XmDIALOG_LIST);
3420 if (scrollWidget)
3421 xmAddMouseEventHandler(scrollWidget);
3422
3423 XtUnmanageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_HELP_BUTTON));
3424 XmStringFree(str);
3425 }
3426 XtManageChild(dialog);
3427}
3428
3429
3430// Generic fileSelectionDialog cancelation.
3431
3432void G4OpenInventorXtExaminerViewer::cancelFileSelDialogCB(Widget w,
3433 XtPointer,
3434 XtPointer)
3435{
3436 XtUnmanageChild(w);
3437}
3438
3439
3440// Displays a file selection dialog that allows to open a new viewpoint file.
3441
3442void G4OpenInventorXtExaminerViewer::openViewPtFileCB(Widget,
3443 XtPointer client_data,
3444 XtPointer)
3445{
3446 G4OpenInventorXtExaminerViewer * This =
3447 (G4OpenInventorXtExaminerViewer *) client_data;
3448 This->popUpFileSelDialog(This->openFileDialog, "Open File", "Load",
3449 viewPtFileSelectedCB);
3450}
3451
3452
3453void G4OpenInventorXtExaminerViewer::viewPtFileSelectedCB(Widget w,
3454 XtPointer client_data,
3455 XtPointer call_data)
3456{
3457 char *file = NULL;
3458 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
3459 XmFileSelectionBoxCallbackStruct *cbs =
3460 (XmFileSelectionBoxCallbackStruct *) call_data;
3461
3462 // Get the file
3463 if (cbs) {
3464 if (!(file = (char *) XmStringUnparse(cbs->value,
3465 XmFONTLIST_DEFAULT_TAG, XmCHARSET_TEXT, XmCHARSET_TEXT, NULL, 0,
3466 XmOUTPUT_ALL))) {
3467 SoDebugError::post("G4OpenInventorXtExaminerViewer::fileSelectedCB",
3468 "Internal error during file opening");
3469 return;
3470 }
3471
3472 This->fileIn.open(file);
3473 if (!This->fileIn.fail()) {
3474 // Opens a file without erasing it
3475 This->cleanUpAfterPrevFile();
3476 if (!This->loadViewPts()) {
3477 String dialogName = (char *) "Error Loading File";
3478 std::string msg = "Wrong or corrupted input file.";
3479 This->warningMsgDialog(msg, dialogName, NULL);
3480 } else {
3481 This->fileName = file;
3482 This->fileOut.open(This->fileName.c_str(), std::ios::in);
3483 This->fileOut.seekp(0, std::ios::end);
3484
3485 if (!This->listsDialog)
3486 constructListsDialog(w, This, NULL); // Pop up listsDialog
3487 else
3488 This->addViewPoints();
3489
3490 std::string newDialogName = This->fileName.substr(
3491 This->fileName.rfind('/') + 1);
3492 XtVaSetValues(This->myShellDialog, XmNtitle,
3493 (char *) newDialogName.c_str(), NULL);
3494
3495 if (This->viewPtList.size()) {
3496 This->setViewPt();
3497 XmTextSetString(This->viewPtSelection, NULL);
3498 XtSetSensitive(This->nextViewPtButton, True);
3499 XtSetSensitive(This->prevViewPtButton, True);
3500 } else {
3501 XtSetSensitive(This->nextViewPtButton, False);
3502 XtSetSensitive(This->prevViewPtButton, False);
3503 }
3504
3505 XtUnmanageChild(w);
3506 }
3507
3508 This->fileIn.close();
3509 } else {
3510 String dialogName = (char *) "Nonexistent File";
3511 std::string msg = "Unable to open file.";
3512 This->warningMsgDialog(msg, dialogName, NULL);
3513 }
3514 }
3515
3516 This->fileIn.clear();
3517 XtFree(file);
3518}
3519
3520
3521// Adds bookmarks to listsDialog.
3522
3523void G4OpenInventorXtExaminerViewer::addViewPoints()
3524{
3525 int size = viewPtList.size();
3526 if (!size)
3527 return;
3528
3529 XmString *viewPts;
3530
3531 viewPts = (XmString *) XtMalloc(size * sizeof(XmString));
3532 for (int i = 0; i < size; i++)
3533 viewPts[i] = XmStringCreateLocalized(viewPtList[i].viewPtName);
3534
3535 XmListAddItemsUnselected(myViewPtList, viewPts, size, 1);
3536
3537 if (viewPts != NULL) {
3538 for (int i = 0; i < size; i++)
3539 XmStringFree(viewPts[i]);
3540 XtFree((char *) viewPts);
3541 }
3542}
3543
3544
3545// Called before loading a new viewpoint file.
3546// Resets member fields to default values.
3547
3548void G4OpenInventorXtExaminerViewer::cleanUpAfterPrevFile()
3549{
3550 viewPtIdx = -1;
3551 viewPtList.clear();
3552 setSuperimpositionEnabled(superimposition, FALSE);
3553 scheduleRedraw();
3554 currentState = GENERAL;
3555 if (fileOut.is_open())
3556 fileOut.close();
3557 if (listsDialog) // Clear viewpoints
3558 XmListDeleteAllItems(myViewPtList);
3559}
3560
3561
3562// Generic function for displaying a warning dialog.
3563
3564void G4OpenInventorXtExaminerViewer::warningMsgDialog(std::string msg,
3565 String dialogName,
3566 XtCallbackProc cb)
3567{
3568 Arg args[5];
3569 unsigned int n;
3570 XmString warningMsg;
3571
3572 warningMsg = XmStringCreateLocalized((char *)msg.c_str());
3573
3574 n = 0;
3575 XtSetArg(args[n], XmNmessageString, warningMsg); n++;
3576 Widget warningDialog = XmCreateWarningDialog(getParentWidget(), dialogName, args, n);
3577 if (cb)
3578 XtAddCallback(warningDialog, XmNokCallback, cb, this);
3579
3580 XmStringFree(warningMsg);
3581
3582 XtVaSetValues (warningDialog, XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL, NULL);
3583 XtUnmanageChild(XtNameToWidget(warningDialog, "Help"));
3584 XtUnmanageChild(XtNameToWidget(warningDialog, "Cancel"));
3585
3586 XtManageChild(warningDialog);
3587}
3588
3589
3590void G4OpenInventorXtExaminerViewer::newViewPtFileCB(Widget,
3591 XtPointer client_data,
3592 XtPointer)
3593{
3594 G4OpenInventorXtExaminerViewer * This =
3595 (G4OpenInventorXtExaminerViewer *) client_data;
3596 This->popUpFileSelDialog(This->newFileDialog, "New File", "Save",
3597 createNewVPFileCB);
3598}
3599
3600
3601void G4OpenInventorXtExaminerViewer::createNewVPFileCB(Widget w,
3602 XtPointer client_data,
3603 XtPointer call_data)
3604{
3605 char *file;
3606 std::string fName;
3607 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
3608 XmFileSelectionBoxCallbackStruct *cbs =
3609 (XmFileSelectionBoxCallbackStruct *) call_data;
3610
3611 // Get the file
3612 if (cbs) {
3613 if (!(file = (char *) XmStringUnparse(cbs->value,
3614 XmFONTLIST_DEFAULT_TAG, XmCHARSET_TEXT, XmCHARSET_TEXT, NULL, 0,
3615 XmOUTPUT_ALL))) {
3616 SoDebugError::post("G4OpenInventorXtExaminerViewer::createNewVPFileCB",
3617 "Internal error during file opening");
3618 return;
3619 }
3620
3621 This->fileName = file;
3622 fName = This->fileName.substr(This->fileName.rfind('/') + 1); // Extracts just the name of the file
3623 This->fileIn.open(file);
3624 if (This->fileIn.fail()) { // Filename does not exist
3625 This->cleanUpAfterPrevFile();
3626 This->fileOut.open(file); // Creates a new empty file
3627 XtSetSensitive(This->nextViewPtButton, False);
3628 XtSetSensitive(This->prevViewPtButton, False);
3629 if (This->listsDialog)
3630 closeListsDialogCB(w, This, NULL);
3631 constructListsDialog(w, This, NULL);
3632 XtUnmanageChild(w);
3633 if (This->returnToSaveVP) {
3634 This->returnToSaveVP = false;
3635 saveViewPtCB(NULL, This, NULL);
3636 }
3637 } else { // Filename already exists
3638 String dialogName = (char *) "Existing File";
3639 std::string msg = "'" + fName + "' already exists. Do you want to overwrite it?";
3640 This->warningMsgDialog(msg, dialogName, overwriteFileCB);
3641 This->fileIn.close();
3642 }
3643 This->fileIn.clear();
3644 XtFree(file);
3645 }
3646}
3647
3648
3649void G4OpenInventorXtExaminerViewer::overwriteFileCB(Widget,
3650 XtPointer client_data,
3651 XtPointer)
3652{
3653 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
3654 This->cleanUpAfterPrevFile();
3655 XtSetSensitive(This->nextViewPtButton, False);
3656 XtSetSensitive(This->prevViewPtButton, False);
3657
3658 XtUnmanageChild(This->newFileDialog);
3659
3660 This->fileOut.open(This->fileName.c_str());
3661
3662 if (This->returnToSaveVP) {
3663 This->returnToSaveVP = false;
3664 saveViewPtCB(NULL, This, NULL);
3665 }
3666}
3667
3668
3669void G4OpenInventorXtExaminerViewer::loadRefCoordsDialogCB(Widget,
3670 XtPointer client_data,
3671 XtPointer)
3672{
3673 G4OpenInventorXtExaminerViewer * This =
3674 (G4OpenInventorXtExaminerViewer *)client_data;
3675 This->popUpFileSelDialog(This->loadRefCoordsDialog, "Load Ref Coords",
3676 "Load", loadRefCoordsCB);
3677}
3678
3679
3680void G4OpenInventorXtExaminerViewer::loadRefCoordsCB(Widget w,
3681 XtPointer client_data,
3682 XtPointer call_data)
3683{
3684 char *file = NULL;
3685 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *)client_data;
3686 XmFileSelectionBoxCallbackStruct *cbs = (XmFileSelectionBoxCallbackStruct *)call_data;
3687
3688 // Get the file
3689 if(cbs) {
3690
3691 file = (char *)XmStringUnparse(cbs->value, XmFONTLIST_DEFAULT_TAG,
3692 XmCHARSET_TEXT, XmCHARSET_TEXT,
3693 NULL, 0, XmOUTPUT_ALL);
3694
3695 std::ifstream ifs(file);
3696 if(ifs.is_open()){
3697 This->refParticleTrajectory.clear();
3698 float x,y,z;
3699 while(ifs >> x >> y >> z){
3700 This->refParticleTrajectory.push_back(SbVec3f(x,y,z));
3701 }
3702 ifs.close();
3703 XtUnmanageChild(w);
3704 }
3705 else{
3706 String dialogName = (char *) "Problem reading file";
3707 std::string msg = "Problem reading file";
3708 This->warningMsgDialog(msg, dialogName, NULL);
3709 return;
3710
3711 }
3712 }
3713
3714 return;
3715}
3716
3717
3718void G4OpenInventorXtExaminerViewer::saveRefCoordsDialogCB(Widget,
3719 XtPointer client_data,
3720 XtPointer)
3721{
3722 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
3723
3724 if (!This->refParticleTrajectory.size()) {
3725 String dialogName = (char *) "No Reference Trajectory";
3726 std::string msg = "You need to start a run or load a reference trajectory from a file";
3727 This->warningMsgDialog(msg, dialogName, NULL);
3728 return;
3729 }
3730
3731 int n;
3732 Arg args[3];
3733 Widget parent, scrollWidget;
3734 parent = SoXt::getShellWidget(This->getParentWidget());
3735
3736 if (This->saveRefCoordsDialog == NULL) {
3737
3738 // Change the 'OK' button to whatever buttonLabel contains
3739 XmString str = XmStringCreateLocalized((char *)"Save");
3740
3741 n = 0;
3742 XtSetArg(args[n], XmNokLabelString, str); n++;
3743 XtSetArg(args[n], XmNresizePolicy, XmRESIZE_NONE); n++;
3744
3745 This->saveRefCoordsDialog = XmCreateFileSelectionDialog(parent,(char *)"Save Ref Coords", args, n);
3746
3747 XtAddCallback(This->saveRefCoordsDialog, XmNokCallback, saveRefCoordsCB, This);
3748 XtAddCallback(This->saveRefCoordsDialog, XmNcancelCallback, cancelFileSelDialogCB, This);
3749
3750 // Adding scrolling functionality to the widget
3751 scrollWidget = XmFileSelectionBoxGetChild(This->saveRefCoordsDialog, XmDIALOG_DIR_LIST);
3752 if (scrollWidget)
3753 xmAddMouseEventHandler(scrollWidget);
3754 scrollWidget = XmFileSelectionBoxGetChild(This->saveRefCoordsDialog, XmDIALOG_LIST);
3755 if (scrollWidget)
3756 xmAddMouseEventHandler(scrollWidget);
3757
3758 XtUnmanageChild(XmSelectionBoxGetChild(This->saveRefCoordsDialog, XmDIALOG_HELP_BUTTON));
3759 XmStringFree(str);
3760 }
3761
3762 //TODO: Auto name?
3763
3764 XtManageChild(This->saveRefCoordsDialog);
3765
3766}
3767
3768
3769void G4OpenInventorXtExaminerViewer::saveRefCoordsCB(Widget w,
3770 XtPointer client_data,
3771 XtPointer call_data)
3772{
3773 char *file;
3774 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
3775 XmFileSelectionBoxCallbackStruct *cbs =
3776 (XmFileSelectionBoxCallbackStruct *) call_data;
3777
3778 // Get the file
3779 if (cbs) {
3780
3781 file = (char *)XmStringUnparse(cbs->value, XmFONTLIST_DEFAULT_TAG,
3782 XmCHARSET_TEXT, XmCHARSET_TEXT,
3783 NULL, 0, XmOUTPUT_ALL);
3784
3785 std::ifstream ifile(file);
3786 if (ifile) {
3787 //File already exists
3788
3789 Arg args[4];
3790 Widget parent = This->getParentWidget(); //gets the dialogshell of the ExaminerViewer widget
3791 Widget confirmOverwriteDialog;
3792 XmString msg;
3793
3794 confirmOverwriteDialog = XmCreateQuestionDialog (parent, (char *)"Confirm overwrite", args, 0);
3795 msg = XmStringCreateLocalized ((char *)"File exists. Overwrite?");
3796 XtVaSetValues (confirmOverwriteDialog, XmNmessageString, msg, NULL);
3797
3798 // If users presses OK, we want to return to this function and
3799 // save the file. For that to work, pass it the current widget
3800 // to be able to grab the filename.
3801 XtVaSetValues (confirmOverwriteDialog, XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL, NULL);
3802 XtAddCallback (confirmOverwriteDialog, XmNokCallback, saveRefCoordsOverWriteCB, client_data);
3803 XtAddCallback (confirmOverwriteDialog, XmNcancelCallback, saveRefCoordsOverWriteCB, client_data);
3804
3805 XmStringFree (msg);
3806
3807 //The confirmOverwriteDialog will need this
3808 This->saveRefCoordsFileName = file;
3809 This->saveRefCoordsWidget = w;
3810
3811 XtUnmanageChild(XtNameToWidget(confirmOverwriteDialog, "Help"));
3812 XtManageChild(confirmOverwriteDialog);
3813
3814 return;
3815 }
3816 else{
3817
3818 std::ofstream ofs(file);
3819 if(ofs.is_open()){
3820 float x,y,z;
3821 for(unsigned int i=0; i < This->refParticleTrajectory.size(); ++i){
3822 This->refParticleTrajectory[i].getValue(x,y,z);
3823 ofs << x << " " << y << " " << z << "\n";
3824 }
3825 ofs.close();
3826 XtUnmanageChild(w);
3827 }
3828 else{
3829 String dialogName = (char *) "Error opening file";
3830 std::string msg = "There was a problem trying to open the file '";
3831 msg += This->saveRefCoordsFileName;
3832 msg += "'";
3833
3834 This->warningMsgDialog(msg, dialogName, NULL);
3835 }
3836 }
3837 }
3838
3839 return;
3840}
3841
3842
3843void G4OpenInventorXtExaminerViewer::saveRefCoordsOverWriteCB(Widget w,
3844 XtPointer client_data,
3845 XtPointer call_data)
3846{
3847 XmAnyCallbackStruct *cbs = (XmAnyCallbackStruct *) call_data;
3848 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
3849
3850 switch (cbs->reason) {
3851 case XmCR_OK:
3852 {
3853 // Overwrite confirmed, save file and dismiss both
3854 // dialogs (file dialog and overwrite confirmation dialog)
3855 std::ofstream ofs(This->saveRefCoordsFileName.c_str());
3856 if(ofs.is_open()){
3857 float x,y,z;
3858 for(unsigned int i=0; i < This->refParticleTrajectory.size(); ++i){
3859 This->refParticleTrajectory[i].getValue(x,y,z);
3860 ofs << x << " " << y << " " << z << "\n";
3861 }
3862 ofs.close();
3863 XtUnmanageChild(w);
3864 XtUnmanageChild(This->saveRefCoordsWidget);
3865 }
3866 else{
3867 String dialogName = (char *) "Error opening file";
3868 std::string msg = "There was a problem trying to open the file '";
3869 msg += This->saveRefCoordsFileName;
3870 msg += "'";
3871
3872 This->warningMsgDialog(msg, dialogName, NULL);
3873 }
3874 break;
3875 }
3876 case XmCR_CANCEL:
3877 {
3878 // Overwrite refused, dismiss overwrite confirmation
3879 // dialog and return to file dialog
3880
3881 // Give focus to the text field instead of the OK button
3882 XmProcessTraversal(XtNameToWidget(This->saveRefCoordsWidget, "Text"), XmTRAVERSE_CURRENT);
3883
3884 XtUnmanageChild(w);
3885 This->saveRefCoordsFileName.clear();
3886 This->saveRefCoordsWidget = NULL;
3887 break;
3888 }
3889 default:
3890 return;
3891 }
3892}
3893
3894
3895void G4OpenInventorXtExaminerViewer::loadSceneGraphDialogCB(Widget,
3896 XtPointer client_data,
3897 XtPointer)
3898{
3899 G4OpenInventorXtExaminerViewer * This =
3900 (G4OpenInventorXtExaminerViewer *)client_data;
3901 This->popUpFileSelDialog(This->loadSceneGraphDialog, "Load Scene Graph",
3902 "Load", loadSceneGraphCB);
3903 return;
3904}
3905
3906
3907void G4OpenInventorXtExaminerViewer::loadSceneGraphCB(Widget w,
3908 XtPointer client_data,
3909 XtPointer call_data)
3910{
3911 char *file = NULL;
3912 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *)client_data;
3913 XmFileSelectionBoxCallbackStruct *cbs = (XmFileSelectionBoxCallbackStruct *)call_data;
3914
3915 if(cbs) {
3916
3917 file = (char *)XmStringUnparse(cbs->value, XmFONTLIST_DEFAULT_TAG,
3918 XmCHARSET_TEXT, XmCHARSET_TEXT,
3919 NULL, 0, XmOUTPUT_ALL);
3920
3921 SoInput sceneInput;
3922 if (!sceneInput.openFile(file)) {
3923 String dialogName = (char *) "Problem opening file";
3924 std::string msg = "Cannot open file ";
3925 msg += file;
3926 This->warningMsgDialog(msg, dialogName, NULL);
3927
3928 sceneInput.closeFile();
3929 XtUnmanageChild(w);
3930 }
3931 // Read the whole file into the database
3932 This->newSceneGraph = SoDB::readAll(&sceneInput);
3933 if (This->newSceneGraph == NULL) {
3934 String dialogName = (char *) "Problem reading file";
3935 std::string msg = "Problem reading file";
3936 This->warningMsgDialog(msg, dialogName, NULL);
3937 return;
3938 }
3939
3940 //This->newSceneGraph->ref();
3941 This->setSceneGraph(This->newSceneGraph);
3942 }
3943
3944 return;
3945}
3946
3947
3948void G4OpenInventorXtExaminerViewer::saveSceneGraphDialogCB(Widget,
3949 XtPointer client_data,
3950 XtPointer)
3951{
3952 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
3953
3954 int n;
3955 Arg args[3];
3956 Widget parent, scrollWidget;
3957 parent = SoXt::getShellWidget(This->getParentWidget());
3958
3959 if (This->saveSceneGraphDialog == NULL) {
3960
3961 // Change the 'OK' button to whatever buttonLabel contains
3962 XmString str = XmStringCreateLocalized((char *)"Save");
3963
3964 n = 0;
3965 XtSetArg(args[n], XmNokLabelString, str); n++;
3966 XtSetArg(args[n], XmNresizePolicy, XmRESIZE_NONE); n++;
3967
3968 This->saveSceneGraphDialog = XmCreateFileSelectionDialog(parent,(char *)"Save Scene Graph", args, n);
3969
3970 XtAddCallback(This->saveSceneGraphDialog, XmNokCallback, saveSceneGraphCB, This);
3971 XtAddCallback(This->saveSceneGraphDialog, XmNcancelCallback, cancelFileSelDialogCB, This);
3972
3973 // Adding scrolling functionality to the widget
3974 scrollWidget = XmFileSelectionBoxGetChild(This->saveSceneGraphDialog, XmDIALOG_DIR_LIST);
3975 if (scrollWidget)
3976 xmAddMouseEventHandler(scrollWidget);
3977 scrollWidget = XmFileSelectionBoxGetChild(This->saveSceneGraphDialog, XmDIALOG_LIST);
3978 if (scrollWidget)
3979 xmAddMouseEventHandler(scrollWidget);
3980
3981 XtUnmanageChild(XmSelectionBoxGetChild(This->saveSceneGraphDialog, XmDIALOG_HELP_BUTTON));
3982 XmStringFree(str);
3983 }
3984
3985 //TODO: Auto name?
3986
3987 XtManageChild(This->saveSceneGraphDialog);
3988
3989}
3990
3991
3992
3993void G4OpenInventorXtExaminerViewer::saveSceneGraphCB(Widget w,
3994 XtPointer client_data,
3995 XtPointer call_data)
3996{
3997 char *file;
3998 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
3999 XmFileSelectionBoxCallbackStruct *cbs =
4000 (XmFileSelectionBoxCallbackStruct *) call_data;
4001
4002 if (cbs) {
4003
4004 file = (char *)XmStringUnparse(cbs->value, XmFONTLIST_DEFAULT_TAG,
4005 XmCHARSET_TEXT, XmCHARSET_TEXT,
4006 NULL, 0, XmOUTPUT_ALL);
4007
4008 std::ifstream ifile(file);
4009 if (ifile) {
4010 //File already exists
4011
4012 Arg args[4];
4013 Widget parent = This->getParentWidget(); //gets the dialogshell of the ExaminerViewer widget
4014 Widget confirmOverwriteDialog;
4015 XmString msg;
4016
4017 confirmOverwriteDialog = XmCreateQuestionDialog (parent, (char *)"Confirm overwrite", args, 0);
4018 msg = XmStringCreateLocalized ((char *)"File exists. Overwrite?");
4019 XtVaSetValues (confirmOverwriteDialog, XmNmessageString, msg, NULL);
4020
4021 // If users presses OK, we want to return to this function and
4022 // save the file. For that to work, pass it the current widget
4023 // to be able to grab the filename.
4024 XtVaSetValues (confirmOverwriteDialog, XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL, NULL);
4025 XtAddCallback (confirmOverwriteDialog, XmNokCallback, saveSceneGraphOverWriteCB, client_data);
4026 XtAddCallback (confirmOverwriteDialog, XmNcancelCallback, saveSceneGraphOverWriteCB, client_data);
4027
4028 XmStringFree (msg);
4029
4030 //The confirmOverwriteDialog will need this
4031 This->saveScenegraphFileName = file;
4032 This->saveScenegraphWidget = w;
4033
4034 XtUnmanageChild(XtNameToWidget(confirmOverwriteDialog, "Help"));
4035 XtManageChild(confirmOverwriteDialog);
4036
4037 return;
4038 }
4039 else{
4040
4041 SoWriteAction writeAction;
4042 SoSeparator *root = (SoSeparator *) (This->getSceneGraph());
4043
4044 SoOutput * out = writeAction.getOutput();
4045
4046 if(out->openFile(file)){
4047 out->setBinary(FALSE);
4048 writeAction.apply(root);
4049 out->closeFile();
4050
4051 XtUnmanageChild(w);
4052 }
4053 else{
4054 String dialogName = (char *) "Error opening file";
4055 std::string msg = "There was a problem trying to open the file '";
4056 msg += This->saveScenegraphFileName;
4057 msg += "'";
4058
4059 This->warningMsgDialog(msg, dialogName, NULL);
4060 }
4061
4062 }
4063 }
4064
4065 return;
4066}
4067
4068
4069
4070void G4OpenInventorXtExaminerViewer::saveSceneGraphOverWriteCB(Widget w,
4071 XtPointer client_data,
4072 XtPointer call_data)
4073{
4074 XmAnyCallbackStruct *cbs = (XmAnyCallbackStruct *) call_data;
4075 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
4076
4077 switch (cbs->reason) {
4078 case XmCR_OK:
4079 {
4080 // Overwrite confirmed, save file and dismiss both
4081 // dialogs (file dialog and overwrite confirmation dialog)
4082 SoWriteAction writeAction;
4083 SoSeparator *root = (SoSeparator *) (This->getSceneGraph());
4084
4085 SoOutput * out = writeAction.getOutput();
4086 if(out->openFile(This->saveScenegraphFileName.c_str())){
4087 out->setBinary(FALSE);
4088 writeAction.apply(root);
4089 out->closeFile();
4090
4091 XtUnmanageChild(w);
4092 XtUnmanageChild(This->saveScenegraphWidget);
4093 This->saveScenegraphFileName.clear();
4094 This->saveScenegraphWidget = NULL;
4095 }
4096 else{
4097 String dialogName = (char *) "Error opening file";
4098 std::string msg = "There was a problem trying to open the file '";
4099 msg += This->saveScenegraphFileName;
4100 msg += "'";
4101
4102 This->warningMsgDialog(msg, dialogName, NULL);
4103 This->saveScenegraphFileName.clear();
4104 This->saveScenegraphWidget = NULL;
4105 }
4106 break;
4107 }
4108 case XmCR_CANCEL:
4109 {
4110 // Overwrite refused, dismiss overwrite confirmation
4111 // dialog and return to file dialog
4112
4113 // Give focus to the text field instead of the OK button
4114 XmProcessTraversal(XtNameToWidget(This->saveScenegraphWidget, "Text"), XmTRAVERSE_CURRENT);
4115
4116 XtUnmanageChild(w);
4117 This->saveScenegraphFileName.clear();
4118 This->saveScenegraphWidget = NULL;
4119 break;
4120 }
4121 default:
4122 return;
4123 }
4124}
4125
4126
4127// Receives the name of the bookmark clicked and searches for it in viewPtList.
4128
4129void G4OpenInventorXtExaminerViewer::loadBookmarkCB(Widget,
4130 XtPointer client_data,
4131 XtPointer call_data)
4132{
4133 char *vpName;
4134 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
4135 XmListCallbackStruct *cbs = (XmListCallbackStruct *) call_data;
4136
4137 vpName = (char *) XmStringUnparse(cbs->item, XmFONTLIST_DEFAULT_TAG,
4138 XmCHARSET_TEXT, XmCHARSET_TEXT, NULL, 0, XmOUTPUT_ALL);
4139
4140 for (int i = 0; i < (int) This->viewPtList.size(); i++) {
4141 if (!strcmp(This->viewPtList[i].viewPtName, vpName)) {
4142 This->viewPtIdx = i;
4143 break;
4144 }
4145 }
4146 XmTextSetString(This->viewPtSelection, vpName);
4147
4148 This->writeViewPtIdx();
4149 This->setViewPt();
4150 XtFree(vpName);
4151}
4152
4153
4154
4155void G4OpenInventorXtExaminerViewer::deleteBookmarkCB(Widget,
4156 XtPointer client_data,
4157 XtPointer)
4158{
4159 char *vpName;
4160 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
4161
4162 vpName = XmTextGetString(This->viewPtSelection);
4163
4164 XmString vpNameStr = XmStringCreateLocalized(vpName);
4165
4166 if (XmListItemExists(This->myViewPtList, vpNameStr)) {
4167 XmListDeleteItem(This->myViewPtList, vpNameStr);
4168 This->deleteViewPt(vpName);
4169 }
4170
4171 XmStringFree(vpNameStr);
4172 XmTextSetString(This->viewPtSelection, NULL);
4173 XtFree(vpName);
4174}
4175
4176
4177void G4OpenInventorXtExaminerViewer::renameBookmarkCB(Widget,
4178 XtPointer client_data,
4179 XtPointer)
4180{
4181 std::string vpNameStr;
4182 char *vpName;
4183 int *pos_list, pos_cnt;
4184 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
4185
4186 vpName = XmTextGetString(This->viewPtSelection);
4187
4188 if (!strlen(vpName) || !strcmp(This->curViewPtName, vpName)) {
4189 XtFree(vpName);
4190 return;
4191 }
4192
4193 vpNameStr = vpName;
4194 XtFree(vpName);
4195 int beg = vpNameStr.find_first_not_of(' '); // Remove leading/trailing spaces
4196 int end = vpNameStr.find_last_not_of(' ');
4197 vpNameStr = vpNameStr.substr(beg, end - beg + 1);
4198 vpName = new char[vpNameStr.size() + 1];
4199 strcpy(vpName, vpNameStr.c_str());
4200
4201 int size = This->viewPtList.size();
4202 for (int i = 0; i < size; i++) {
4203 if (!strcmp(vpName, This->viewPtList[i].viewPtName)) {
4204
4205 String dialogName = (char *) "Existing Viewpoint";
4206 std::string msg = "'";
4207 msg += vpName;
4208 msg += "' already exists. Choose a different name";
4209
4210 This->warningMsgDialog(msg, dialogName, NULL);
4211 return;
4212 }
4213 }
4214
4215 XmString vpNameXmStr = XmStringCreateLocalized(vpName);
4216
4217 if (XmListGetSelectedPos(This->myViewPtList, &pos_list, &pos_cnt)) {
4218 XmListReplaceItemsPos(This->myViewPtList, &vpNameXmStr, 1, pos_list[0]);
4219 This->renameViewPt(vpName);
4220 XtFree((char *) pos_list);
4221 }
4222
4223 if (This->currentState == VIEWPOINT)
4224 This->scheduleRedraw();
4225
4226 XmStringFree(vpNameXmStr);
4227}
4228
4229
4230void G4OpenInventorXtExaminerViewer::sortBookmarksCB(Widget,
4231 XtPointer client_data,
4232 XtPointer)
4233{
4234 int size;
4235 char *vpName;
4236 XmString *strList, *newStrList;
4237 std::vector<std::string> charList;
4238 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
4239
4240 if (This->viewPtList.size() < 2)
4241 return;
4242
4243 // Get current entries from the list
4244 XtVaGetValues(This->myViewPtList, XmNitemCount, &size, XmNitems, &strList,
4245 NULL);
4246
4247 for (int i = 0; i < size; i++) {
4248 vpName = (char *) XmStringUnparse(strList[i], XmFONTLIST_DEFAULT_TAG,
4249 XmCHARSET_TEXT, XmCHARSET_TEXT, NULL, 0, XmOUTPUT_ALL);
4250 charList.push_back(vpName);
4251 XtFree(vpName);
4252 }
4253
4254 std::sort(charList.begin(), charList.end());
4255
4256 newStrList = (XmString *) XtMalloc(size * sizeof(XmString));
4257 for (int i = 0; i < size; i++) {
4258 // viewPtIdx has to be changed to account for a different order in viewPtList
4259 if (!strcmp(charList[i].c_str(), This->curViewPtName))
4260 This->viewPtIdx = i;
4261 char *vpName2 = new char[charList[i].size() + 1];
4262 strcpy(vpName2, charList[i].c_str());
4263 newStrList[i] = XmStringCreateLocalized(vpName2);
4264 delete vpName2;
4265 }
4266
4267 XmListDeleteAllItems(This->myViewPtList);
4268 XmListAddItemsUnselected(This->myViewPtList, newStrList, size, 1);
4269
4270 This->sortViewPts(charList);
4271
4272 if (newStrList != NULL) {
4273 for (int i = 0; i < size; i++)
4274 XmStringFree(newStrList[i]);
4275 XtFree((char *) newStrList);
4276 }
4277}
4278
4279
4280void G4OpenInventorXtExaminerViewer::evenOutRefParticlePts()
4281{
4282 if(this->refParticleTrajectory.empty())
4283 return;
4284
4285 SbVec3f p1, p2, p3, dirNow, dirNxt, dir, p2_tmp, p_start, p_corner, p_nxt;
4286 float avgDistBtwPts = 0;
4287 float totalDistBtwPts = 0;
4288 std::vector<SbVec3f> newRefParticleTrajectory;
4289 SbVec3f refPoint;
4290 int size = refParticleTrajectory.size() - 1;
4291 int numOfPts = 0;
4292 for (int i = 0; i < size; i++) {
4293 p1 = refParticleTrajectory[i];
4294 p2 = refParticleTrajectory[i + 1];
4295 if (p1 == p2)
4296 continue;
4297 numOfPts++;
4298 totalDistBtwPts += (p2 - p1).length();
4299 }
4300
4301 avgDistBtwPts = totalDistBtwPts / numOfPts;
4302 float minDistAllowed = 0.75 * avgDistBtwPts;
4303 // float maxDistAllowed = 1.25 * avgDistBtwPts; // Pts tend to be close not far
4304
4305 float x, y, z;
4306 int i = 0, j = 0;
4307 while (i < size) {
4308 p1 = refParticleTrajectory[i];
4309 p2 = refParticleTrajectory[i + 1];
4310
4311 refPoint = p1;
4312 p1.getValue(x, y, z);
4313
4314 newRefParticleTrajectory.push_back(refPoint);
4315
4316 j = i;
4317 while ((p2 - p1).length() < minDistAllowed && j < (size - 1)) {
4318 j++;
4319
4320 p1 = refParticleTrajectory[j];
4321 p2 = refParticleTrajectory[j + 1];
4322 }
4323 if (j != i)
4324 i = j + 1;
4325 else
4326 i++;
4327 }
4328
4329 refParticleTrajectory.clear();
4330 refParticleTrajectory = newRefParticleTrajectory;
4331}
4332
4333
4334// Called when the viewer is closed; closes all open widgets.
4335
4336void G4OpenInventorXtExaminerViewer::closeMainWindowCB(Widget,
4337 XtPointer client_data,
4338 XtPointer)
4339{
4340 G4OpenInventorXtExaminerViewer * This =
4341 (G4OpenInventorXtExaminerViewer *) client_data;
4342
4343 if (This->openFileDialog)
4344 XtUnmanageChild(This->openFileDialog);
4345
4346 if (This->newFileDialog)
4347 XtUnmanageChild(This->newFileDialog);
4348
4349 if (This->listsDialog)
4350 closeListsDialogCB(NULL, This, NULL);
4351}
4352
4353
4354void G4OpenInventorXtExaminerViewer::saveCurCamera()
4355{
4356 SoCamera *cam = getCamera();
4357 camB4Animation.viewportMapping = cam->viewportMapping.getValue();
4358 camB4Animation.position = cam->position.getValue();
4359 camB4Animation.orientation = cam->orientation.getValue();
4360 camB4Animation.aspectRatio = cam->aspectRatio.getValue();
4361 camB4Animation.nearDistance = cam->nearDistance.getValue();
4362 camB4Animation.farDistance = cam->farDistance.getValue();
4363 camB4Animation.focalDistance = cam->focalDistance.getValue();
4364
4365 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
4366 camB4Animation.height =
4367 ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
4368 camB4Animation.camType = PERSPECTIVE;
4369 } else if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
4370 camB4Animation.height =
4371 ((SoOrthographicCamera *) cam)->height.getValue();
4372 camB4Animation.camType = ORTHOGRAPHIC;
4373 }
4374}
4375
4376
4377void G4OpenInventorXtExaminerViewer::restoreCamera()
4378{
4379 SoCamera *cam = getCamera();
4380
4381 cam->viewportMapping = camB4Animation.viewportMapping;
4382 cam->position = camB4Animation.position;
4383 cam->orientation = camB4Animation.orientation;
4384 cam->aspectRatio = camB4Animation.aspectRatio;
4385 cam->nearDistance = camB4Animation.nearDistance;
4386 cam->farDistance = camB4Animation.farDistance;
4387 cam->focalDistance = camB4Animation.focalDistance;
4388
4389 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
4390 if (camB4Animation.camType == ORTHOGRAPHIC) {
4391 toggleCameraType();
4392 cam = getCamera();
4393 ((SoOrthographicCamera *) cam)->height.setValue(
4394 camB4Animation.height);
4395 } else
4396 ((SoPerspectiveCamera *) cam)->heightAngle.setValue(
4397 camB4Animation.height);
4398 } else if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
4399 if (camB4Animation.camType == PERSPECTIVE) {
4400 toggleCameraType();
4401 cam = getCamera();
4402 ((SoPerspectiveCamera *) cam)->heightAngle.setValue(
4403 camB4Animation.height);
4404 } else
4405 ((SoOrthographicCamera *) cam)->height.setValue(
4406 camB4Animation.height);
4407 }
4408}
4409
4410
4411void G4OpenInventorXtExaminerViewer::animateSensorRotationCB(void *data,
4412 SoSensor *sensor)
4413{
4414 SbTime curTime = SbTime::getTimeOfDay();
4415 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) data;
4416 SoTimerSensor *s = (SoTimerSensor *) sensor;
4417
4418 float t = float((curTime - s->getBaseTime()).getValue())
4419 / This->animateBtwPtsPeriod;
4420
4421 if ((t > 1.0f) || (t + s->getInterval().getValue() > 1.0f))
4422 t = 1.0f;
4423 SbBool end = (t == 1.0f);
4424
4425 if (end) {
4426 This->animateSensorRotation->unschedule();
4427 if(This->rotCnt){
4428 // rotations left
4429 This->rotateCamera();
4430 }
4431 else {
4432 // rotation over
4433 This->currentState = This->prevState;
4434 return;
4435 }
4436 }
4437
4438}
4439
4440
4441// Called repeatedly during reference particle animation
4442
4443void G4OpenInventorXtExaminerViewer::animateSensorCB(void *data,
4444 SoSensor *sensor)
4445{
4446 SbTime curTime = SbTime::getTimeOfDay();
4447 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) data;
4448 SoCamera *cam = This->getCamera();
4449 SoTimerSensor *s = (SoTimerSensor *) sensor;
4450
4451 float t = float((curTime - s->getBaseTime()).getValue())
4452 / This->animateBtwPtsPeriod;
4453
4454 if ((t > 1.0f) || (t + s->getInterval().getValue() > 1.0f))
4455 t = 1.0f;
4456 SbBool end = (t == 1.0f);
4457
4458 cam->orientation = SbRotation::slerp(This->camStartOrient, This->camEndOrient, t);
4459 cam->position = This->camStartPos + (This->camEndPos - This->camStartPos) * t;
4460
4461 if (end) {
4462 This->animateSensor->unschedule();
4463
4464 if (This->currentState == ANIMATION) {
4465 if (This->refParticleIdx < (int) (This->refParticleTrajectory.size() - 1))
4466 This->animateRefParticle();
4467 else {
4468 This->animateBtwPtsPeriod = MIN_SPEED;
4469 This->speedStep = START_STEP;
4470 }
4471 }
4472 if (This->currentState == REVERSED_ANIMATION) {
4473 if (This->refParticleIdx >= 1)
4474 This->animateRefParticle();
4475 else {
4476 This->animateBtwPtsPeriod = MIN_SPEED;
4477 This->speedStep = START_STEP;
4478 }
4479 }
4480 }
4481}
4482
4483
4484void G4OpenInventorXtExaminerViewer::setStartingPtForAnimation()
4485{
4486 if (SoXtExaminerViewer::isAnimating())
4487 stopAnimating();
4488
4489 SbRotation rot;
4490 SbVec3f p1, p2, p2_tmp, camUpV, camD, camD_tmp, leftRightAxis;
4491 float x1, y1, z1, x2, y2, z2;
4492
4493 if (currentState == ANIMATION) {
4494 p1 = refParticleTrajectory[refParticleIdx];
4495 p2 = refParticleTrajectory[++(refParticleIdx)];
4496 } else if (currentState == REVERSED_ANIMATION) {
4497 p2 = refParticleTrajectory[refParticleIdx];
4498 p1 = refParticleTrajectory[--(refParticleIdx)];
4499 } else if (currentState == PAUSED_ANIMATION) {
4500 if (refParticleIdx < (int) refParticleTrajectory.size()) {
4501 p1 = refParticleTrajectory[refParticleIdx];
4502 p2 = refParticleTrajectory[refParticleIdx + 1];
4503 } else {
4504 p1 = refParticleTrajectory[refParticleIdx - 1];
4505 p2 = refParticleTrajectory[refParticleIdx];
4506 }
4507 }
4508 p1.getValue(x1, y1, z1);
4509 p2.getValue(x2, y2, z2);
4510
4511 camD = p2 - p1;
4512 camD.normalize();
4513
4514 p2_tmp.setValue(x2, y1, z2);
4515 camD_tmp = p2_tmp - p1;
4516 camD_tmp.normalize();
4517
4518 camUpV.setValue(0, 1, 0);
4519 rot.setValue(camD_tmp, camD);
4520 rot.multVec(camUpV, camUpV);
4521
4522 leftRightAxis = camD.cross(camUpV);
4523
4524 myCam->position = p1;
4525 myCam->pointAt(p2, camUpV);
4526
4527 // Update camera position
4528 p1 = p1 + (up_down * camUpV) + (left_right * leftRightAxis);
4529 myCam->position = p1;
4530}
4531
4532
4533void G4OpenInventorXtExaminerViewer::gotoRefPathStart()
4534{
4535 G4OpenInventorXtExaminerViewer::gotoRefPathStartCB(NULL, (void *)this,
4536 NULL);
4537}
4538
4539
4540void G4OpenInventorXtExaminerViewer::gotoRefPathStartCB(Widget,
4541 XtPointer client_data,
4542 XtPointer)
4543{
4544 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
4545
4546 if (!This->refParticleTrajectory.size()) {
4547 String dialogName = (char *) "No Reference Trajectory";
4548 std::string msg = "You need to start a run or load a reference trajectory from a file";
4549 This->warningMsgDialog(msg, dialogName, NULL);
4550 return;
4551 }
4552
4553 if (This->currentState == ROTATING)
4554 return;
4555 if (This->currentState == ANIMATION || This->currentState == REVERSED_ANIMATION
4556 || This->currentState == PAUSED_ANIMATION) {
4557 if (This->animateSensor->isScheduled())
4558 This->animateSensor->unschedule();
4559 This->setSuperimpositionEnabled(This->superimposition, FALSE);
4560 This->maxSpeed = 0.0f;
4561 This->scheduleRedraw();
4562 } else {
4563 This->saveCurCamera();
4564 This->prevState = This->currentState;
4565 This->prevRefIdx = This->refParticleIdx;
4566 }
4567
4568 if (This->SoXtExaminerViewer::isAnimating())
4569 This->stopAnimating();
4570
4571 This->up_down = 0;
4572 This->left_right = 0;
4573 This->step = 1;
4574
4575 This->refParticleIdx = 0;
4576 This->currentState = BEAMLINE;
4577 This->setSuperimpositionEnabled(This->superimposition, TRUE);
4578 This->axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
4579 This->animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
4580 This->animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
4581 This->scheduleRedraw();
4582
4583 // FWJ Disabled: this is set in moveCamera()
4584 // Zoom in
4585 // SoCamera *cam = This->getCamera();
4586 // cam->focalDistance = 0.1f;
4587
4588 This->prevParticleDir = SbVec3f(0,0,0);
4589
4590 //Default zoom
4591 SbVec3f p1 = This->refParticleTrajectory[0];
4592 SbVec3f pN = This->refParticleTrajectory[This->refParticleTrajectory.size() - 1];
4593 This->distance = (pN - p1).length() / 10;
4594
4595 This->moveCamera(This->distance, true);
4596}
4597
4598
4599void G4OpenInventorXtExaminerViewer::invertRefPathCB(Widget,
4600 XtPointer client_data,
4601 XtPointer)
4602{
4603 G4OpenInventorXtExaminerViewer * This =
4604 (G4OpenInventorXtExaminerViewer *) client_data;
4605 This->invertRefPath();
4606}
4607
4608
4609void G4OpenInventorXtExaminerViewer::invertRefPath()
4610{
4611 std::reverse(this->refParticleTrajectory.begin(),
4612 this->refParticleTrajectory.end());
4613 this->setReferencePathZPos();
4614 this->sortElements();
4615}
4616
4617
4618void G4OpenInventorXtExaminerViewer::animateRefParticleCB(Widget,
4619 XtPointer client_data,
4620 XtPointer)
4621{
4622 G4OpenInventorXtExaminerViewer * This = (G4OpenInventorXtExaminerViewer *) client_data;
4623
4624 if (!This->refParticleTrajectory.size()) {
4625 This->returnToAnim = true;
4626 String dialogName = (char *) "No Reference Trajectory";
4627 std::string msg = "You need to start a run or load a reference trajectory from a file";
4628 This->warningMsgDialog(msg, dialogName, NULL);
4629 return;
4630 }
4631
4632 if (!This->refParticleTrajectory.size())
4633 return;
4634
4635 ///////////////////////////////////////////////////////////////
4636 This->setSuperimpositionEnabled(This->superimposition, TRUE);
4637 This->maxSpeed = SPEED_INDICATOR_STEP;
4638 This->axisSwitch->whichChild.setValue(SO_SWITCH_ALL);
4639 This->animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_ALL);
4640 This->animSpeedSwitch->whichChild.setValue(SO_SWITCH_ALL);
4641 This->scheduleRedraw();
4642 ///////////////////////////////////////////////////////////////
4643
4644 SoCamera *cam = This->getCamera();
4645 // SbVec3f camDirOld, camDirNew, camDirNew_tmp, camUpVec, P0, P1, P1_tmp;
4646
4647 if (This->currentState == ANIMATION || This->currentState == REVERSED_ANIMATION
4648 || This->currentState == ROTATING)
4649 return;
4650
4651 if (This->currentState != PAUSED_ANIMATION) {
4652
4653 This->saveCurCamera();
4654 This->prevState = This->currentState;
4655 This->prevRefIdx = This->refParticleIdx;
4656
4657 if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
4658 This->toggleCameraType();
4659 cam = This->getCamera();
4660 }
4661
4662 This->refParticleIdx = 0; // Set the camera to the starting point of the animation
4663 This->animateBtwPtsPeriod = MIN_SPEED;
4664 This->speedStep = START_STEP;
4665 This->left_right = This->up_down = 0;
4666
4667 cam->focalDistance = 0.1f;
4668 ((SoPerspectiveCamera *) cam)->heightAngle = 0.50f;
4669 }
4670
4671 This->currentState = ANIMATION;
4672 This->setStartingPtForAnimation();
4673
4674 cam->position = (This->myCam)->position.getValue();
4675 cam->orientation = (This->myCam)->orientation.getValue();
4676 This->animateRefParticle(); // Animate the camera
4677}
4678
4679
4680void G4OpenInventorXtExaminerViewer::animateRefParticle()
4681{
4682 SoCamera *cam = getCamera();
4683
4684 camStartPos = cam->position.getValue();
4685 camStartOrient = cam->orientation.getValue();
4686
4687 if (currentState != BEAMLINE)
4688 setStartingPtForAnimation();
4689
4690 camEndPos = myCam->position.getValue();
4691 camEndOrient = myCam->orientation.getValue();
4692
4693 if (animateSensor->isScheduled())
4694 animateSensor->unschedule();
4695
4696 animateSensor->setBaseTime(SbTime::getTimeOfDay());
4697 animateSensor->setInterval(SbTime(0.02));
4698
4699 animateSensor->schedule();
4700}
4701
4702
4703void G4OpenInventorXtExaminerViewer::addEscapeCallback(
4704 void (*callback)(void *), void * object)
4705{
4706 this->escapeCallback = callback;
4707 this->examinerObject = object;
4708}
4709
4710
4711void G4OpenInventorXtExaminerViewer::sceneChangeCB(void *userData, SoSensor *)
4712{
4713 G4OpenInventorXtExaminerViewer* This =
4714 (G4OpenInventorXtExaminerViewer*)userData;
4715 if(This->newEvents){
4716 This->findAndSetRefPath();
4717 This->newEvents = false;
4718 }
4719}
4720
4721
4722HookEventProcState::HookEventProcState(G4OpenInventorXtExaminerViewer* vwr)
4723{
4724 this->viewer = vwr;
4725}
4726
4727
4728HookEventProcState::~HookEventProcState()
4729{;}
4730
4731
4732G4bool HookEventProcState::Notify(G4ApplicationState requiredState)
4733{
4734 if(requiredState == G4State_EventProc){
4735 this->viewer->newEvents = true;
4736 }
4737 return true;
4738}
G4ApplicationState
G4ApplicationState
Definition: G4ApplicationState.hh:85
G4State_EventProc
@ G4State_EventProc
Definition: G4ApplicationState.hh:86
MAX_SPEED_INDICATOR
#define MAX_SPEED_INDICATOR
Definition: G4OpenInventorXtExaminerViewer.cc:117
SPEED_INDICATOR_STEP
#define SPEED_INDICATOR_STEP
Definition: G4OpenInventorXtExaminerViewer.cc:116
G4bool
bool G4bool
Definition: G4Types.hh:67
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cout
G4DLLIMPORT std::ostream G4cout
Geant4_SoPolyhedron.h
M_PI
#define M_PI
Definition: SbMath.h:34
G4AttHolder::GetAttValues
const std::vector< const std::vector< G4AttValue > * > & GetAttValues() const
Definition: G4AttHolder.hh:60
G4AttHolder::GetAttDefs
const std::vector< const std::map< G4String, G4AttDef > * > & GetAttDefs() const
Definition: G4AttHolder.hh:62
G4OpenInventorXtExaminerViewer::warningMsgDialog
void warningMsgDialog(std::string, String, XtCallbackProc)
Definition: G4OpenInventorXtExaminerViewer.cc:3564
G4OpenInventorXtExaminerViewer::processSoEvent
virtual SbBool processSoEvent(const SoEvent *const event)
Definition: G4OpenInventorXtExaminerViewer.cc:1256
G4OpenInventorXtExaminerViewer::addButton
void addButton(Widget menu, std::string name, XtCallbackProc)
Definition: G4OpenInventorXtExaminerViewer.cc:668
G4OpenInventorXtExaminerViewer::G4OpenInventorXtExaminerViewer
G4OpenInventorXtExaminerViewer(Widget parent=NULL, const char *name=NULL, SbBool embed=TRUE, SoXtFullViewer::BuildFlag flag=BUILD_ALL, SoXtViewer::Type type=BROWSER)
Definition: G4OpenInventorXtExaminerViewer.cc:122
G4OpenInventorXtExaminerViewer::createViewerButtons
virtual void createViewerButtons(Widget parent, SbPList *buttonlist)
Definition: G4OpenInventorXtExaminerViewer.cc:678
G4OpenInventorXtExaminerViewer::addEscapeCallback
void addEscapeCallback(void(*cb)(void *), void *)
Definition: G4OpenInventorXtExaminerViewer.cc:4703
G4OpenInventorXtExaminerViewer::moveCamera
void moveCamera(float dist=0, bool lookdown=false)
Definition: G4OpenInventorXtExaminerViewer.cc:893
G4OpenInventorXtExaminerViewer::parseString
void parseString(T &t, const std::string &s, bool &error)
Definition: G4OpenInventorXtExaminerViewer.cc:3379
Geant4_SoPolyhedron
Definition: Geant4_SoPolyhedron.h:54
HookEventProcState::HookEventProcState
HookEventProcState(G4OpenInventorXtExaminerViewer *)
Definition: G4OpenInventorXtExaminerViewer.cc:4722
HookEventProcState::Notify
virtual G4bool Notify(G4ApplicationState requiredState)
Definition: G4OpenInventorXtExaminerViewer.cc:4732
SoXtInternal::createPixmapFromXpm
static Pixmap createPixmapFromXpm(Widget button, const char **xpm, SbBool ghost=FALSE)
TRUE
#define TRUE
Definition: globals.hh:55
FALSE
#define FALSE
Definition: globals.hh:52
xmAddMouseEventHandler
void xmAddMouseEventHandler(Widget w)
Definition: wheelmouse.cc:125
userData
#define userData
Definition: xmlparse.cc:555
buffer
#define buffer
Definition: xmlparse.cc:611