source: trunk/source/visualization/OpenGL/src/G4OpenGLQtViewer.cc@ 1344

Last change on this file since 1344 was 1340, checked in by garnier, 15 years ago

update ti head
  • Property svn:mime-type set to text/cpp
File size: 86.8 KB
Line 
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// $Id: G4OpenGLQtViewer.cc,v 1.55 2010/10/08 10:07:31 lgarnier Exp $
28// GEANT4 tag $Name: $
29//
30//
31// G4OpenGLQtViewer : Class to provide Qt specific
32// functionality for OpenGL in GEANT4
33//
34// 27/06/2003 : G.Barrand : implementation (at last !).
35
36#ifdef G4VIS_BUILD_OPENGLQT_DRIVER
37
38#include "G4OpenGLQtViewer.hh"
39#include "G4VViewer.hh"
40#include "G4VSceneHandler.hh"
41#include "G4OpenGLSceneHandler.hh"
42
43#include "G4ios.hh"
44#include "G4VisExtent.hh"
45#include "G4LogicalVolume.hh"
46#include "G4VSolid.hh"
47#include "G4Point3D.hh"
48#include "G4Normal3D.hh"
49#include "G4Scene.hh"
50#include "G4OpenGLQtExportDialog.hh"
51#include "G4OpenGLQtMovieDialog.hh"
52#include "G4UnitsTable.hh"
53#include "G4Qt.hh"
54#include "G4UIQt.hh"
55#include "G4UImanager.hh"
56#include "G4UIcommandTree.hh"
57#include <qlayout.h>
58#include <qdialog.h>
59#include <qprocess.h>
60#include <qapplication.h>
61#include <qdesktopwidget.h>
62
63#if QT_VERSION >= 0x040000
64#include <qmenu.h>
65#include <qimagewriter.h>
66#else
67#include <qaction.h>
68#include <qwidgetlist.h>
69#include <qpopupmenu.h>
70#include <qimage.h>
71#endif
72
73#include <qapplication.h>
74#include <qmessagebox.h>
75#include <qfiledialog.h>
76#include <qprinter.h>
77#include <qdatetime.h>
78#include <qpainter.h>
79#include <qgl.h> // include <qglwidget.h>
80#include <qdialog.h>
81#include <qcolordialog.h>
82#include <qevent.h> //include <qcontextmenuevent.h>
83
84
85//////////////////////////////////////////////////////////////////////////////
86/**
87 Implementation of virtual method of G4VViewer
88*/
89void G4OpenGLQtViewer::SetView (
90)
91//////////////////////////////////////////////////////////////////////////////
92//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
93{
94 G4OpenGLViewer::SetView ();
95}
96
97
98
99
100//////////////////////////////////////////////////////////////////////////////
101void G4OpenGLQtViewer::CreateMainWindow (
102 QGLWidget* glWidget
103 ,QString name
104)
105//////////////////////////////////////////////////////////////////////////////
106//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
107{
108
109 if(fWindow) return; //Done.
110
111 fWindow = glWidget ;
112 // fWindow->makeCurrent();
113
114 //G4Qt* interactorManager = G4Qt::getInstance ();
115
116 ResizeWindow(fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
117
118 // FIXME L.Garnier 9/11/09 Has to be check !!!
119 // Qt UI with Qt Vis
120 // Qt UI with X Vis
121 // X UI with Qt Vis
122 // X UI with X Vis
123 // Ne marche pas avec un UIBatch !! (ecran blanc)
124
125 // return false if G4UIQt was not launch
126
127 G4UImanager* UI = G4UImanager::GetUIpointer();
128 if (UI == NULL) return;
129
130 if (! static_cast<G4UIQt*> (UI->GetG4UIWindow())) return;
131
132 G4UIQt * uiQt = static_cast<G4UIQt*> (UI->GetG4UIWindow());
133
134 bool isTabbedView = false;
135 if ( uiQt) {
136 isTabbedView = uiQt->AddTabWidget(fWindow,name,getWinWidth(),getWinHeight());
137 }
138#ifdef G4DEBUG_VIS_OGL
139 else {
140 printf("G4OpenGLQtViewer::CreateMainWindow :: UIQt NOt found \n");
141 }
142#endif
143
144 if (!isTabbedView) { // we have to do a dialog
145
146 QWidget *myParent = getParentWidget();
147#ifdef G4DEBUG_VIS_OGL
148 printf("G4OpenGLQtViewer::CreateMainWindow :: getParent OK \n");
149#endif
150 if (myParent != NULL) {
151#if QT_VERSION < 0x040000
152 glWidget->reparent(myParent,0,QPoint(0,0));
153#else
154 glWidget->setParent(myParent);
155#endif
156 }
157 QHBoxLayout *mainLayout = new QHBoxLayout(fGLWindow);
158
159 mainLayout->setMargin(0);
160 mainLayout->setSpacing(0);
161 mainLayout->addWidget(fWindow);
162 if (fGLWindow->inherits("QMainWindow")) {
163#if QT_VERSION < 0x040000
164 fGLWindow->setCaption(name );
165#else
166 fGLWindow->setWindowTitle( name);
167#endif
168 }
169#if QT_VERSION >= 0x040000
170 fGLWindow->setLayout(mainLayout);
171#endif
172
173
174 //useful for MACOSX, we have to compt the menuBar height
175 int offset = QApplication::desktop()->height()
176 - QApplication::desktop()->availableGeometry().height();
177
178 G4int YPos= fVP.GetWindowAbsoluteLocationHintY(QApplication::desktop()->height());
179 if (fVP.GetWindowAbsoluteLocationHintY(QApplication::desktop()->height())< offset) {
180 YPos = offset;
181 }
182 fGLWindow->resize(getWinWidth(), getWinHeight());
183#ifdef G4DEBUG_VIS_OGL
184 printf("G4OpenGLQtViewer::CreateMainWindow :: resizing to %d %d \n",getWinWidth(), getWinHeight());
185#endif
186 fGLWindow->move(fVP.GetWindowAbsoluteLocationHintX(QApplication::desktop()->width()),YPos);
187 fGLWindow->show();
188 } else {
189 fGLWindow = fWindow;
190 fGLWindow->resize(getWinWidth(), getWinHeight());
191 }
192
193 if(!fWindow) return;
194
195 if (!fContextMenu)
196 createPopupMenu();
197
198}
199
200#if QT_VERSION >= 0x040000
201/** Close the dialog and set the pointer to NULL
202 */
203// void G4OpenGLQtViewer::dialogClosed() {
204// // fGLWindow = NULL;
205// }
206#endif
207
208//////////////////////////////////////////////////////////////////////////////
209G4OpenGLQtViewer::G4OpenGLQtViewer (
210 G4OpenGLSceneHandler& scene
211 )
212 :G4VViewer (scene, -1)
213 ,G4OpenGLViewer (scene)
214 ,fWindow(0)
215 ,fRecordFrameNumber(0)
216 ,fContextMenu(0)
217 ,fMouseAction(STYLE1)
218 ,fDeltaRotation(1)
219 ,fDeltaSceneTranslation(0.01)
220 ,fDeltaDepth(0.01)
221 ,fDeltaZoom(0.05)
222 ,fDeltaMove(0.05)
223 ,fHoldKeyEvent(false)
224 ,fHoldMoveEvent(false)
225 ,fHoldRotateEvent(false)
226 ,fAutoMove(false)
227 ,fEncoderPath("")
228 ,fTempFolderPath("")
229 ,fMovieTempFolderPath("")
230 ,fSaveFileName("")
231 ,fParameterFileName("mpeg_encode_parameter_file.par")
232 ,fMovieParametersDialog(NULL)
233 ,fRecordingStep(WAIT)
234 ,fProcess(NULL)
235 ,fNbMaxFramesPerSec(100)
236 ,fNbMaxAnglePerSec(360)
237 ,fLaunchSpinDelay(100)
238 ,fXRot(0)
239 ,fYRot(0)
240 ,fNoKeyPress(true)
241 ,fAltKeyPress(false)
242 ,fControlKeyPress(false)
243 ,fShiftKeyPress(false)
244{
245
246 // launch Qt if not
247 G4Qt::getInstance ();
248
249 fLastPos3 = QPoint(-1,-1);
250 fLastPos2 = QPoint(-1,-1);
251 fLastPos1 = QPoint(-1,-1);
252
253 initMovieParameters();
254
255 fLastEventTime = new QTime();
256
257#ifdef G4DEBUG_VIS_OGL
258 printf("G4OpenGLQtViewer::G4OpenGLQtViewer END\n");
259#endif
260}
261
262//////////////////////////////////////////////////////////////////////////////
263G4OpenGLQtViewer::~G4OpenGLQtViewer (
264)
265//////////////////////////////////////////////////////////////////////////////
266//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
267{
268#if QT_VERSION < 0x040000
269 G4cout <<removeTempFolder().ascii() <<G4endl;
270#else
271 G4cout <<removeTempFolder().toStdString().c_str() <<G4endl;
272#endif
273}
274
275
276/**
277 Create a popup menu for the widget. This menu is activated by right-mouse click
278*/
279void G4OpenGLQtViewer::createPopupMenu() {
280
281#if QT_VERSION < 0x040000
282 fContextMenu = new QPopupMenu( fGLWindow,"All" );
283#else
284 fContextMenu = new QMenu("All");
285#endif
286
287#if QT_VERSION < 0x040000
288 QPopupMenu *mMouseAction = new QPopupMenu( fContextMenu );
289 fContextMenu->insertItem("&Mouse actions",mMouseAction);
290#if QT_VERSION < 0x030200
291 fRotateAction = new QAction("&Rotate","&Rotate",CTRL+Key_R,mMouseAction,0,true);
292 fMoveAction = new QAction("&Move","&Move",CTRL+Key_M,mMouseAction,0,true);
293 fPickAction = new QAction("&Pick","&Pick",CTRL+Key_P,mMouseAction,0,true);
294 QAction * shortcutsAction = new QAction("&Show shortcuts","&Show shortcuts",CTRL+Key_S,mMouseAction,0,true);
295#else
296 fRotateAction = new QAction("&Rotate",CTRL+Key_R,mMouseAction);
297 fMoveAction = new QAction("&Move",CTRL+Key_M,mMouseAction);
298 fPickAction = new QAction("&Pick",CTRL+Key_P,mMouseAction);
299 QAction *shortcutsAction = new QAction("&Show shortcuts",CTRL+Key_S,mMouseAction);
300#endif
301 fRotateAction->addTo(mMouseAction);
302 fMoveAction->addTo(mMouseAction);
303 fPickAction->addTo(mMouseAction);
304 shortcutsAction->addTo(mMouseAction);
305
306 fRotateAction->setToggleAction(true);
307 fMoveAction->setToggleAction(true);
308 fPickAction->setToggleAction(true);
309 shortcutsAction->setToggleAction(true);
310
311 fRotateAction->setOn(true);
312 fMoveAction->setOn(false);
313 fPickAction->setOn(false);
314 shortcutsAction->setOn(false);
315
316
317 QObject ::connect(fRotateAction,
318 SIGNAL(activated()),
319 this,
320 SLOT(actionMouseRotate()));
321
322 QObject ::connect(fMoveAction,
323 SIGNAL(activated()),
324 this,
325 SLOT(actionMouseMove()));
326
327 QObject ::connect(fPickAction,
328 SIGNAL(activated()),
329 this,
330 SLOT(actionMousePick()));
331
332 QObject ::connect(shortcutsAction,
333 SIGNAL(activated()),
334 this,
335 SLOT(showShortcuts()));
336
337#else
338 QMenu *mMouseAction = fContextMenu->addMenu("&Mouse actions");
339
340 fRotateAction = mMouseAction->addAction("Rotate");
341 fMoveAction = mMouseAction->addAction("Move");
342 fPickAction = mMouseAction->addAction("Pick");
343 QAction *shortcutsAction = mMouseAction->addAction("Show shortcuts");
344
345 fRotateAction->setCheckable(true);
346 fMoveAction->setCheckable(false);
347 fPickAction->setCheckable(false);
348 shortcutsAction->setCheckable(false);
349
350 fRotateAction->setChecked(true);
351 fMoveAction->setChecked(false);
352 fPickAction->setChecked(false);
353 shortcutsAction->setChecked(false);
354
355 QObject ::connect(fRotateAction,
356 SIGNAL(triggered(bool)),
357 this,
358 SLOT(actionMouseRotate()));
359
360 QObject ::connect(fMoveAction,
361 SIGNAL(triggered(bool)),
362 this,
363 SLOT(actionMouseMove()));
364
365 QObject ::connect(fPickAction,
366 SIGNAL(triggered(bool)),
367 this,
368 SLOT(actionMousePick()));
369
370 QObject ::connect(shortcutsAction,
371 SIGNAL(triggered(bool)),
372 this,
373 SLOT(showShortcuts()));
374#endif
375
376#if QT_VERSION < 0x040000
377 // === Style Menu ===
378 QPopupMenu *mStyle = new QPopupMenu(fContextMenu);
379
380 QPopupMenu *mRepresentation = new QPopupMenu(fContextMenu);
381
382 QPopupMenu *mProjection = new QPopupMenu(fContextMenu);
383
384#if QT_VERSION < 0x030200
385 QAction *polyhedron = new QAction("&Polyhedron","&Polyhedron",CTRL+Key_P,mRepresentation,0,true);
386 QAction *nurbs = new QAction("&NURBS","&NURBS",CTRL+Key_N,mRepresentation,0,true);
387
388 QAction *ortho = new QAction("&Orthographic","&Orthographic",CTRL+Key_O,mProjection,0,true);
389 QAction *perspective = new QAction("&Perspective","&Perspective",CTRL+Key_P,mProjection,0,true);
390#else
391 QAction *polyhedron = new QAction("&Polyhedron",CTRL+Key_P,mRepresentation);
392 QAction *nurbs = new QAction("&NURBS",CTRL+Key_N,mRepresentation);
393
394 QAction *ortho = new QAction("&Orthographic",CTRL+Key_O,mProjection);
395 QAction *perspective = new QAction("&Perspective",CTRL+Key_P,mProjection);
396 polyhedron->setToggleAction(true);
397 nurbs->setToggleAction(true);
398 ortho->setToggleAction(true);
399 perspective->setToggleAction(true);
400#endif
401 polyhedron->addTo(mRepresentation);
402 nurbs->addTo(mRepresentation);
403
404 ortho->addTo(mProjection);
405 perspective->addTo(mProjection);
406
407 mStyle->insertItem("&Representation",mRepresentation);
408 mStyle->insertItem("&Projection",mProjection);
409 fContextMenu->insertItem("&Style",mStyle);
410
411
412#else
413 // === Style Menu ===
414 QMenu *mStyle = fContextMenu->addMenu("&Style");
415
416 QMenu *mRepresentation = mStyle->addMenu("&Representation");
417 QMenu *mProjection = mStyle->addMenu("&Projection");
418 QAction *polyhedron = mRepresentation->addAction("Polyhedron");
419 QAction *nurbs = mRepresentation->addAction("NURBS");
420
421 QAction *ortho = mProjection->addAction("Orthographic");
422 QAction *perspective = mProjection->addAction("Persepective");
423#endif
424
425 // INIT mRepresentation
426 G4ViewParameters::RepStyle style;
427 style = fVP.GetRepStyle();
428 if (style == G4ViewParameters::polyhedron) {
429 createRadioAction(polyhedron,nurbs,SLOT(toggleRepresentation(bool)),1);
430 } else if (style == G4ViewParameters::nurbs) {
431 createRadioAction(polyhedron,nurbs,SLOT(toggleRepresentation(bool)),2);
432 } else {
433 mRepresentation->clear();
434 }
435
436 // INIT mProjection
437 if (fVP.GetFieldHalfAngle() == 0) {
438 createRadioAction(ortho, perspective,SLOT(toggleProjection(bool)),1);
439 } else {
440 createRadioAction(ortho, perspective,SLOT(toggleProjection(bool)),2);
441 }
442
443#if QT_VERSION < 0x040000
444 // === Drawing Menu ===
445 QPopupMenu *mDrawing = new QPopupMenu(fContextMenu);
446 fContextMenu->insertItem("&Drawing",mDrawing);
447
448#if QT_VERSION < 0x030200
449 fDrawingWireframe = new QAction("&Wireframe","&Wireframe",CTRL+Key_W,mDrawing,0,true);
450 fDrawingLineRemoval = new QAction("&Hidden line removal","&Hidden line removal",CTRL+Key_L,mDrawing,0,true);
451 fDrawingSurfaceRemoval = new QAction("&Hidden surface removal","&Hidden surface removal",CTRL+Key_S,mDrawing,0,true);
452 fDrawingLineSurfaceRemoval = new QAction("&Hidden line and surface removal","&Hidden line and surface removal",CTRL+Key_R,mDrawing,0,true);
453#else
454 fDrawingWireframe = new QAction("&Wireframe",CTRL+Key_W,mDrawing);
455 fDrawingLineRemoval = new QAction("&Hidden line removal",CTRL+Key_L,mDrawing);
456 fDrawingSurfaceRemoval = new QAction("&Hidden surface removal",CTRL+Key_S,mDrawing);
457 fDrawingLineSurfaceRemoval = new QAction("&Hidden line and surface removal",CTRL+Key_R,mDrawing);
458#endif
459 fDrawingWireframe->setToggleAction(true);
460 fDrawingLineRemoval->setToggleAction(true);
461 fDrawingSurfaceRemoval->setToggleAction(true);
462 fDrawingLineSurfaceRemoval->setToggleAction(true);
463
464 fDrawingWireframe->addTo(mDrawing);
465 fDrawingLineRemoval->addTo(mDrawing);
466 fDrawingSurfaceRemoval->addTo(mDrawing);
467 fDrawingLineSurfaceRemoval->addTo(mDrawing);
468
469
470#else
471 // === Drawing Menu ===
472 QMenu *mDrawing = mStyle->addMenu("&Drawing");
473
474 fDrawingWireframe = mDrawing->addAction("Wireframe");
475 fDrawingWireframe->setCheckable(true);
476
477 fDrawingLineRemoval = mDrawing->addAction("Hidden line removal");
478 fDrawingLineRemoval->setCheckable(true);
479
480 fDrawingSurfaceRemoval = mDrawing->addAction("Hidden Surface removal");
481 fDrawingSurfaceRemoval->setCheckable(true);
482
483 fDrawingLineSurfaceRemoval = mDrawing->addAction("Hidden line and surface removal");
484 fDrawingLineSurfaceRemoval->setCheckable(true);
485#endif
486 // INIT Drawing
487 G4ViewParameters::DrawingStyle d_style;
488 d_style = fVP.GetDrawingStyle();
489
490#if QT_VERSION < 0x040000
491 if (d_style == G4ViewParameters::wireframe) {
492 fDrawingWireframe->setOn(true);
493 } else if (d_style == G4ViewParameters::hlr) {
494 fDrawingLineRemoval->setOn(true);
495 } else if (d_style == G4ViewParameters::hsr) {
496 fDrawingSurfaceRemoval->setOn(true);
497 } else if (d_style == G4ViewParameters::hlhsr) {
498 fDrawingLineSurfaceRemoval->setOn(true);
499 } else {
500 mDrawing->clear();
501 }
502 QObject ::connect(fDrawingWireframe,
503 SIGNAL(activated()),
504 this,
505 SLOT(actionDrawingWireframe()));
506 QObject ::connect(fDrawingLineRemoval,
507 SIGNAL(activated()),
508 this,
509 SLOT(actionDrawingLineRemoval()));
510 QObject ::connect(fDrawingSurfaceRemoval,
511 SIGNAL(activated()),
512 this,
513 SLOT(actionDrawingSurfaceRemoval()));
514 QObject ::connect(fDrawingLineSurfaceRemoval,
515 SIGNAL(activated()),
516 this,
517 SLOT(actionDrawingLineSurfaceRemoval()));
518#else
519 if (d_style == G4ViewParameters::wireframe) {
520 fDrawingWireframe->setChecked(true);
521 } else if (d_style == G4ViewParameters::hlr) {
522 fDrawingLineRemoval->setChecked(true);
523 } else if (d_style == G4ViewParameters::hsr) {
524 fDrawingSurfaceRemoval->setChecked(true);
525 } else if (d_style == G4ViewParameters::hlhsr) {
526 fDrawingLineSurfaceRemoval->setChecked(true);
527 } else {
528 mDrawing->clear();
529 }
530 QObject ::connect(fDrawingWireframe,
531 SIGNAL(triggered(bool)),
532 this,
533 SLOT(actionDrawingWireframe()));
534 QObject ::connect(fDrawingLineRemoval,
535 SIGNAL(triggered(bool)),
536 this,
537 SLOT(actionDrawingLineRemoval()));
538 QObject ::connect(fDrawingSurfaceRemoval,
539 SIGNAL(triggered(bool)),
540 this,
541 SLOT(actionDrawingSurfaceRemoval()));
542 QObject ::connect(fDrawingLineSurfaceRemoval,
543 SIGNAL(triggered(bool)),
544 this,
545 SLOT(actionDrawingLineSurfaceRemoval()));
546#endif
547
548 // Background Color
549
550 QAction *backgroundColorChooser ;
551#if QT_VERSION < 0x040000
552 QPopupMenu *mBackgroundColor = new QPopupMenu(mStyle);
553 mStyle->insertItem("&Background color",mBackgroundColor);
554
555#if QT_VERSION < 0x030200
556 backgroundColorChooser = new QAction("&Choose ...","&Choose ...",CTRL+Key_C,mBackgroundColor,0,true);
557#else
558 backgroundColorChooser = new QAction("&Choose ...","&Choose ...",CTRL+Key_C,mBackgroundColor);
559#endif
560 backgroundColorChooser->addTo(mBackgroundColor);
561 QObject ::connect(backgroundColorChooser,
562 SIGNAL(activated()),
563 this,
564 SLOT(actionChangeBackgroundColor()));
565
566#else
567 // === Action Menu ===
568 backgroundColorChooser = mStyle->addAction("Background color");
569 QObject ::connect(backgroundColorChooser,
570 SIGNAL(triggered()),
571 this,
572 SLOT(actionChangeBackgroundColor()));
573#endif
574
575 // Text Color
576
577 QAction *textColorChooser ;
578#if QT_VERSION < 0x040000
579 QPopupMenu *mTextColor = new QPopupMenu(mStyle);
580 mStyle->insertItem("&Text color",mTextColor);
581
582#if QT_VERSION < 0x030200
583 textColorChooser = new QAction("&Choose ...","&Choose ...",CTRL+Key_C,mTextColor,0,true);
584#else
585 textColorChooser = new QAction("&Choose ...","&Choose ...",CTRL+Key_C,mTextColor);
586#endif
587 textColorChooser->addTo(mTextColor);
588 QObject ::connect(textColorChooser,
589 SIGNAL(activated()),
590 this,
591 SLOT(actionChangeTextColor()));
592
593#else
594 // === Action Menu ===
595 textColorChooser = mStyle->addAction("Text color");
596 QObject ::connect(textColorChooser,
597 SIGNAL(triggered()),
598 this,
599 SLOT(actionChangeTextColor()));
600#endif
601
602 // Default Color
603
604 QAction *defaultColorChooser ;
605#if QT_VERSION < 0x040000
606 QPopupMenu *mDefaultColor = new QPopupMenu(mStyle);
607 mStyle->insertItem("&Default color",mDefaultColor);
608
609#if QT_VERSION < 0x030200
610 defaultColorChooser = new QAction("&Choose ...","&Choose ...",CTRL+Key_C,mDefaultColor,0,true);
611#else
612 defaultColorChooser = new QAction("&Choose ...","&Choose ...",CTRL+Key_C,mDefaultColor);
613#endif
614 defaultColorChooser->addTo(mDefaultColor);
615 QObject ::connect(defaultColorChooser,
616 SIGNAL(activated()),
617 this,
618 SLOT(actionChangeDefaultColor()));
619
620#else
621 // === Action Menu ===
622 defaultColorChooser = mStyle->addAction("Default color");
623 QObject ::connect(defaultColorChooser,
624 SIGNAL(triggered()),
625 this,
626 SLOT(actionChangeDefaultColor()));
627#endif
628
629
630#if QT_VERSION < 0x040000
631 // === Action Menu ===
632 QPopupMenu *mActions = new QPopupMenu(fContextMenu);
633 fContextMenu->insertItem("&Actions",mActions);
634
635#if QT_VERSION < 0x030200
636 QAction *createEPS = new QAction("&Save as ...","&Save as ...",CTRL+Key_S,mActions,0,true);
637#else
638 QAction *createEPS = new QAction("&Save as ...",CTRL+Key_S,mActions);
639#endif
640 createEPS->addTo(mActions);
641 QObject ::connect(createEPS,
642 SIGNAL(activated()),
643 this,
644 SLOT(actionSaveImage()));
645
646#else
647 // === Action Menu ===
648 QMenu *mActions = fContextMenu->addMenu("&Actions");
649 QAction *createEPS = mActions->addAction("Save as ...");
650 QObject ::connect(createEPS,
651 SIGNAL(triggered()),
652 this,
653 SLOT(actionSaveImage()));
654#endif
655
656#if QT_VERSION < 0x040000
657#if QT_VERSION < 0x030200
658 QAction *movieParameters = new QAction("&Make Movie...","&Make movie ...",CTRL+Key_M,mActions,0,true);
659#else
660 QAction *movieParameters = new QAction("&Make Movie...",CTRL+Key_M,mActions);
661#endif
662 movieParameters->addTo(mActions);
663 QObject ::connect(movieParameters,
664 SIGNAL(activated()),
665 this,
666 SLOT(actionMovieParameters()));
667
668#else
669 // === Action Menu ===
670 QAction *movieParameters = mActions->addAction("Movie parameters...");
671 QObject ::connect(movieParameters,
672 SIGNAL(triggered()),
673 this,
674 SLOT(actionMovieParameters()));
675#endif
676
677
678
679
680#if QT_VERSION < 0x040000
681 // === Special Menu ===
682 QPopupMenu *mSpecial = new QPopupMenu(fContextMenu);
683 fContextMenu->insertItem("S&pecial",mSpecial);
684
685 QPopupMenu *mTransparency = new QPopupMenu(mSpecial);
686 mSpecial->insertItem("Transparency",mTransparency);
687
688#if QT_VERSION < 0x030200
689 QAction *transparencyOn = new QAction("&On","&On",CTRL+Key_O,mTransparency,0,true);
690 QAction *transparencyOff = new QAction("&Off","&Off",CTRL+Key_F,mTransparency,0,true);
691#else
692 QAction *transparencyOn = new QAction("&On",CTRL+Key_O,mTransparency);
693 QAction *transparencyOff = new QAction("&Off",CTRL+Key_F,mTransparency);
694 transparencyOn->setToggleAction(true);
695 transparencyOff->setToggleAction(true);
696#endif
697 transparencyOn->addTo(mTransparency);
698 transparencyOff->addTo(mTransparency);
699
700#else
701 // === Special Menu ===
702 QMenu *mSpecial = fContextMenu->addMenu("S&pecial");
703 QMenu *mTransparency = mSpecial->addMenu("Transparency");
704 QAction *transparencyOn = mTransparency->addAction("On");
705 QAction *transparencyOff = mTransparency->addAction("Off");
706#endif
707
708 if (transparency_enabled == false) {
709 createRadioAction(transparencyOn,transparencyOff,SLOT(toggleTransparency(bool)),2);
710 } else if (transparency_enabled == true) {
711 createRadioAction(transparencyOn,transparencyOff,SLOT(toggleTransparency(bool)),1);
712 } else {
713 mSpecial->clear();
714 }
715
716
717#if QT_VERSION < 0x040000
718 QPopupMenu *mAntialiasing = new QPopupMenu(mSpecial);
719 mSpecial->insertItem("Antialiasing",mAntialiasing);
720
721#if QT_VERSION < 0x030200
722 QAction *antialiasingOn = new QAction("&On","&On",CTRL+Key_O,mAntialiasing,0,true);
723 QAction *antialiasingOff = new QAction("&Off","&Off",CTRL+Key_F,mAntialiasing,0,true);
724#else
725 QAction *antialiasingOn = new QAction("&On",CTRL+Key_O,mAntialiasing);
726 QAction *antialiasingOff = new QAction("&Off",CTRL+Key_F,mAntialiasing);
727 antialiasingOn->setToggleAction(true);
728 antialiasingOff->setToggleAction(true);
729#endif
730 antialiasingOn->addTo(mAntialiasing);
731 antialiasingOff->addTo(mAntialiasing);
732
733#else
734 QMenu *mAntialiasing = mSpecial->addMenu("Antialiasing");
735 QAction *antialiasingOn = mAntialiasing->addAction("On");
736 QAction *antialiasingOff = mAntialiasing->addAction("Off");
737#endif
738
739 if (antialiasing_enabled == false) {
740 createRadioAction(antialiasingOn,antialiasingOff,SLOT(toggleAntialiasing(bool)),2);
741 } else if (antialiasing_enabled == true) {
742 createRadioAction(antialiasingOn,antialiasingOff,SLOT(toggleAntialiasing(bool)),1);
743 } else {
744 mAntialiasing->clear();
745 }
746
747#if QT_VERSION < 0x040000
748 QPopupMenu *mHaloing = new QPopupMenu(mSpecial);
749 mSpecial->insertItem("Haloing",mHaloing);
750
751#if QT_VERSION < 0x030200
752 QAction *haloingOn = new QAction("&On","&On",CTRL+Key_O,mHaloing,0,true);
753 QAction *haloingOff = new QAction("&Off","&Off",CTRL+Key_F,mHaloing,0,true);
754#else
755 QAction *haloingOn = new QAction("&On",CTRL+Key_O,mHaloing);
756 QAction *haloingOff = new QAction("&Off",CTRL+Key_F,mHaloing);
757 haloingOn->setToggleAction(true);
758 haloingOff->setToggleAction(true);
759#endif
760 haloingOn->addTo(mHaloing);
761 haloingOff->addTo(mHaloing);
762#else
763 QMenu *mHaloing = mSpecial->addMenu("Haloing");
764 QAction *haloingOn = mHaloing->addAction("On");
765 QAction *haloingOff = mHaloing->addAction("Off");
766#endif
767 if (haloing_enabled == false) {
768 createRadioAction(haloingOn,haloingOff,SLOT(toggleHaloing(bool)),2);
769 } else if (haloing_enabled == true) {
770 createRadioAction(haloingOn,haloingOff,SLOT(toggleHaloing(bool)),1);
771 } else {
772 mHaloing->clear();
773 }
774
775#if QT_VERSION < 0x040000
776 QPopupMenu *mAux = new QPopupMenu(mSpecial);
777 mSpecial->insertItem("Auxiliairy edges",mAux);
778
779#if QT_VERSION < 0x030200
780 QAction *auxOn = new QAction("&On","&On",CTRL+Key_O,mAux,0,true);
781 QAction *auxOff = new QAction("&Off","&Off",CTRL+Key_F,mAux,0,true);
782#else
783 QAction *auxOn = new QAction("&On",CTRL+Key_O,mAux);
784 QAction *auxOff = new QAction("&Off",CTRL+Key_F,mAux);
785 auxOn->setToggleAction(true);
786 auxOff->setToggleAction(true);
787#endif
788 auxOn->addTo(mAux);
789 auxOff->addTo(mAux);
790
791#else
792 QMenu *mAux = mSpecial->addMenu("Auxiliary edges");
793 QAction *auxOn = mAux->addAction("On");
794 QAction *auxOff = mAux->addAction("Off");
795#endif
796 if (!fVP.IsAuxEdgeVisible()) {
797 createRadioAction(auxOn,auxOff,SLOT(toggleAux(bool)),1);
798 } else {
799 createRadioAction(auxOn,auxOff,SLOT(toggleAux(bool)),2);
800 }
801
802
803
804#if QT_VERSION < 0x040000
805 QPopupMenu *mFullScreen = new QPopupMenu(mSpecial);
806 mSpecial->insertItem("Full screen",mFullScreen);
807
808#if QT_VERSION < 0x030200
809 fFullScreenOn = new QAction("&On","&On",CTRL+Key_O,mFullScreen,0,true);
810 fFullScreenOff = new QAction("&Off","&Off",CTRL+Key_F,mFullScreen,0,true);
811#else
812 fFullScreenOn = new QAction("&On",CTRL+Key_O,mFullScreen);
813 fFullScreenOff = new QAction("&Off",CTRL+Key_F,mFullScreen);
814 fFullScreenOn->setToggleAction(true);
815 fFullScreenOff->setToggleAction(true);
816#endif
817 fFullScreenOn->addTo(mFullScreen);
818 fFullScreenOff->addTo(mFullScreen);
819#else
820 QMenu *mFullScreen = mSpecial->addMenu("&Full screen");
821 fFullScreenOn = mFullScreen->addAction("On");
822 fFullScreenOff = mFullScreen->addAction("Off");
823#endif
824 createRadioAction(fFullScreenOn,fFullScreenOff,SLOT(toggleFullScreen(bool)),2);
825
826}
827
828
829void G4OpenGLQtViewer::G4manageContextMenuEvent(QContextMenuEvent *e)
830{
831 if (!fGLWindow) {
832 G4cerr << "Visualization window not defined, please choose one before" << G4endl;
833 } else {
834
835 if (!fContextMenu)
836 createPopupMenu();
837
838 // launch menu
839 if ( fContextMenu ) {
840 fContextMenu->exec( e->globalPos() );
841 // delete fContextMenu;
842 }
843 }
844 e->accept();
845}
846
847
848/**
849 Create a radio button menu. The two menu will be connected. When click on one,
850 eatch state will be invert and callback method will be called.
851 @param action1 first action to connect
852 @param action2 second action to connect
853 @param method callback method
854 @param nCheck: 1 : first action will be set true. 2 : second action will be set true
855*/
856#if QT_VERSION < 0x040000
857void G4OpenGLQtViewer::createRadioAction(QAction *action1,QAction *action2, const std::string& method,unsigned int nCheck) {
858
859 if (action1->parent()->inherits("QPopupMenu")){
860 ((QPopupMenu*)action1->parent())->setCheckable(true);
861 ((QPopupMenu*)action2->parent())->setCheckable(true);
862 }
863 action1->setOn(false);
864 action2->setOn(false);
865
866 if (nCheck ==1)
867 action1->setOn(true);
868 else
869 action2->setOn(true);
870
871 //FIXME : Should not work on Qt3
872 QObject ::connect(action1, SIGNAL(activated()),action2, SLOT(toggle()));
873 QObject ::connect(action2, SIGNAL(activated()),action1, SLOT(toggle()));
874
875 QObject ::connect(action1, SIGNAL(toggled(bool)),this, method.c_str());
876}
877
878#else
879void G4OpenGLQtViewer::createRadioAction(QAction *action1,QAction *action2, const std::string& method,unsigned int nCheck) {
880
881 action1->setCheckable(true);
882 action2->setCheckable(true);
883
884 if (nCheck ==1)
885 action1->setChecked (true);
886 else
887 action2->setChecked (true);
888
889 QObject ::connect(action1, SIGNAL(triggered(bool)),action2, SLOT(toggle()));
890 QObject ::connect(action2, SIGNAL(triggered(bool)),action1, SLOT(toggle()));
891
892 QObject ::connect(action1, SIGNAL(toggled(bool)),this, method.c_str());
893
894}
895#endif
896
897/**
898 Slot activate when mouseAction->rotate menu is set
899 */
900void G4OpenGLQtViewer::actionMouseRotate() {
901 emit toggleMouseAction(STYLE1);
902}
903
904
905/**
906 Slot activate when mouseAction->rotate menu is set
907 */
908void G4OpenGLQtViewer::actionMouseMove() {
909 emit toggleMouseAction(STYLE2);
910}
911
912
913/**
914 Slot activate when mouseAction->zoom menu is set
915 */
916void G4OpenGLQtViewer::actionMousePick() {
917 emit toggleMouseAction(STYLE3);
918}
919
920
921/**
922 Slot activate when drawing->wireframe menu is set
923 */
924void G4OpenGLQtViewer::actionDrawingWireframe() {
925 emit toggleDrawingAction(1);
926}
927
928/**
929 Slot activate when drawing->line removal menu is set
930 */
931void G4OpenGLQtViewer::actionDrawingLineRemoval() {
932 emit toggleDrawingAction(2);
933}
934
935/**
936 Slot activate when drawing->surface removal menu is set
937 */
938void G4OpenGLQtViewer::actionDrawingSurfaceRemoval() {
939 emit toggleDrawingAction(3);
940}
941
942/**
943 Slot activate when drawing->wireframe menu is set
944 */
945void G4OpenGLQtViewer::actionDrawingLineSurfaceRemoval() {
946 emit toggleDrawingAction(4);
947}
948
949
950/**
951 Slot activated when mouse action is toggle
952 @param aAction : STYLE1, STYLE2, STYLE3
953 */
954void G4OpenGLQtViewer::toggleMouseAction(mouseActions aAction) {
955
956 if ((aAction == STYLE1) || //initialize all
957 (aAction == STYLE2) ||
958 (aAction == STYLE3)) {
959#if QT_VERSION < 0x040000
960 fRotateAction->setOn (false);
961 fMoveAction->setOn (false);
962 fPickAction->setOn (false);
963#else
964 fRotateAction->setChecked (false);
965 fMoveAction->setChecked (false);
966 fPickAction->setChecked (false);
967#endif
968 fVP.SetPicking(false);
969 fMouseAction = aAction;
970 }
971 // rotate
972 if (aAction == STYLE1) { // rotate
973 showShortcuts();
974#if QT_VERSION < 0x040000
975 fRotateAction->setOn (true);
976#else
977 fRotateAction->setChecked (true);
978#endif
979 } else if (aAction == STYLE2) { //move
980#if QT_VERSION < 0x040000
981 fMoveAction->setOn (true);
982#else
983 fMoveAction->setChecked (true);
984#endif
985 } else if (aAction == STYLE3) { //pick
986#if QT_VERSION < 0x040000
987 fPickAction->setOn (true);
988#else
989 fPickAction->setChecked (true);
990#endif
991 fVP.SetPicking(true);
992 }
993}
994
995/**
996 Show shortcuts for this mouse action
997 */
998void G4OpenGLQtViewer::showShortcuts() {
999 G4cout << "========= Mouse Shortcuts =========" << G4endl;
1000 if (fMouseAction == STYLE1) { // rotate
1001 G4cout << "Click and move mouse to rotate volume " << G4endl;
1002 G4cout << "ALT + Click and move mouse to rotate volume (View Direction)" << G4endl;
1003 G4cout << "CTRL + Click and zoom mouse to zoom in/out" << G4endl;
1004 G4cout << "SHIFT + Click and zoommove camera point of view" << G4endl;
1005 } else if (fMouseAction == STYLE2) { //move
1006 G4cout << "Move camera point of view with mouse" << G4endl;
1007 } else if (fMouseAction == STYLE3) { //pick
1008 G4cout << "Click and pick " << G4endl;
1009 }
1010 G4cout << "========= Move Shortcuts =========" << G4endl;
1011 G4cout << "Press left/right arrows to move volume left/right" << G4endl;
1012 G4cout << "Press up/down arrows to move volume up/down" << G4endl;
1013 G4cout << "Press '+'/'-' to move volume toward/forward" << G4endl;
1014 G4cout << G4endl;
1015 G4cout << "========= Rotation (Theta/Phi) Shortcuts =========" << G4endl;
1016 G4cout << "Press SHIFT + left/right arrows to rotate volume left/right" << G4endl;
1017 G4cout << "Press SHIFT + up/down arrows to rotate volume up/down" << G4endl;
1018 G4cout << G4endl;
1019 G4cout << "========= Rotation (View Direction) Shortcuts =========" << G4endl;
1020 G4cout << "Press ALT + left/right to rotate volume around vertical direction" << G4endl;
1021 G4cout << "Press ALT + up/down to rotate volume around horizontal direction" << G4endl;
1022 G4cout << G4endl;
1023 G4cout << "========= Zoom View =========" << G4endl;
1024 G4cout << "Press CTRL + '+'/'-' to zoom into volume" << G4endl;
1025 G4cout << G4endl;
1026 G4cout << "========= Misc =========" << G4endl;
1027 G4cout << "Press ALT +/- to slow/speed rotation/move" << G4endl;
1028 G4cout << "Press H to reset view" << G4endl;
1029 G4cout << "Press Esc to exit FullScreen" << G4endl;
1030 G4cout << G4endl;
1031 G4cout << "========= Video =========" << G4endl;
1032 G4cout << "In video mode : " << G4endl;
1033 G4cout << " Press SPACE to Start/Pause video recording " << G4endl;
1034 G4cout << " Press RETURN to Stop video recording " << G4endl;
1035 G4cout << G4endl;
1036}
1037
1038
1039
1040/**
1041 Slot activated when drawing menu is toggle
1042 Warning : When G4OpenGLStoredQtViewer::DrawView() method call,
1043 KernelVisitDecision () will be call and will set the fNeedKernelVisit
1044 to 1. See G4XXXStoredViewer::CompareForKernelVisit for explanations.
1045 It will cause a redraw of the view
1046 @param aAction : 1 wireframe, 2 line removal, 3 surface removal, 4 line & surface removal
1047 @see G4OpenGLStoredQtViewer::DrawView
1048 @see G4XXXStoredViewer::CompareForKernelVisit
1049 */
1050void G4OpenGLQtViewer::toggleDrawingAction(int aAction) {
1051
1052 G4ViewParameters::DrawingStyle d_style = G4ViewParameters::wireframe;
1053
1054
1055 // initialize
1056 if ((aAction >0) && (aAction <5)) {
1057#if QT_VERSION < 0x040000
1058 fDrawingWireframe->setOn(false);
1059 fDrawingLineRemoval->setOn(false);
1060 fDrawingSurfaceRemoval->setOn(false);
1061 fDrawingLineSurfaceRemoval->setOn(false);
1062#else
1063 fDrawingWireframe->setChecked (false);
1064 fDrawingLineRemoval->setChecked (false);
1065 fDrawingSurfaceRemoval->setChecked (false);
1066 fDrawingLineSurfaceRemoval->setChecked (false);
1067#endif
1068 }
1069 if (aAction ==1) {
1070#if QT_VERSION < 0x040000
1071 fDrawingWireframe->setOn(true);
1072#else
1073 fDrawingWireframe->setChecked (true);
1074#endif
1075
1076 d_style = G4ViewParameters::wireframe;
1077
1078 } else if (aAction ==2) {
1079#if QT_VERSION < 0x040000
1080 fDrawingLineRemoval->setOn(true);
1081#else
1082 fDrawingLineRemoval->setChecked (true);
1083#endif
1084
1085 d_style = G4ViewParameters::hlr;
1086
1087 } else if (aAction ==3) {
1088#if QT_VERSION < 0x040000
1089 fDrawingSurfaceRemoval->setOn(true);
1090#else
1091 fDrawingSurfaceRemoval->setChecked (true);
1092#endif
1093
1094 d_style = G4ViewParameters::hsr;
1095
1096 } else if (aAction ==4) {
1097#if QT_VERSION < 0x040000
1098 fDrawingLineSurfaceRemoval->setOn(true);
1099#else
1100 fDrawingLineSurfaceRemoval->setChecked (true);
1101#endif
1102 d_style = G4ViewParameters::hlhsr;
1103 }
1104 fVP.SetDrawingStyle(d_style);
1105
1106 updateQWidget();
1107}
1108
1109
1110/**
1111 SLOT Activate by a click on the representation menu
1112 Warning : When G4OpenGLStoredQtViewer::DrawView() method call,
1113 KernelVisitDecision () will be call and will set the fNeedKernelVisit
1114 to 1. See G4XXXStoredViewer::CompareForKernelVisit for explanations.
1115 It will cause a redraw of the view
1116 @param check : 1 polyhedron, 0 nurbs
1117 @see G4OpenGLStoredQtViewer::DrawView
1118 @see G4XXXStoredViewer::CompareForKernelVisit
1119*/
1120void G4OpenGLQtViewer::toggleRepresentation(bool check) {
1121
1122 G4ViewParameters::RepStyle style;
1123 if (check == 1) {
1124 style = G4ViewParameters::polyhedron;
1125 } else {
1126 style = G4ViewParameters::nurbs;
1127 }
1128 fVP.SetRepStyle (style);
1129
1130 updateQWidget();
1131}
1132
1133/**
1134 SLOT Activate by a click on the projection menu
1135 Warning : When G4OpenGLStoredQtViewer::DrawView() method call,
1136 KernelVisitDecision () will be call and will set the fNeedKernelVisit
1137 to 1. See G4XXXStoredViewer::CompareForKernelVisit for explanations.
1138 It will cause a redraw of the view
1139 @param check : 1 orthographic, 2 perspective
1140 @see G4OpenGLStoredQtViewer::DrawView
1141 @see G4XXXStoredViewer::CompareForKernelVisit
1142*/
1143void G4OpenGLQtViewer::toggleProjection(bool check) {
1144
1145 if (check == 1) {
1146 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/projection o");
1147 } else {
1148 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/projection p");
1149 }
1150 updateQWidget();
1151}
1152
1153
1154/**
1155 SLOT Activate by a click on the transparency menu
1156@param check : 1 , 0
1157*/
1158void G4OpenGLQtViewer::toggleTransparency(bool check) {
1159
1160 if (check) {
1161 transparency_enabled = false;
1162 } else {
1163 transparency_enabled = true;
1164 }
1165 SetNeedKernelVisit (true);
1166 updateQWidget();
1167}
1168
1169/**
1170 SLOT Activate by a click on the antialiasing menu
1171@param check : 1 , 0
1172*/
1173void G4OpenGLQtViewer::toggleAntialiasing(bool check) {
1174
1175 if (!check) {
1176 antialiasing_enabled = false;
1177 glDisable (GL_LINE_SMOOTH);
1178 glDisable (GL_POLYGON_SMOOTH);
1179 } else {
1180 antialiasing_enabled = true;
1181 glEnable (GL_LINE_SMOOTH);
1182 glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
1183 glEnable (GL_POLYGON_SMOOTH);
1184 glHint (GL_POLYGON_SMOOTH_HINT, GL_NICEST);
1185 }
1186
1187 updateQWidget();
1188}
1189
1190/**
1191 SLOT Activate by a click on the haloing menu
1192@param check : 1 , 0
1193*/
1194//FIXME : I SEE NOTHING...
1195void G4OpenGLQtViewer::toggleHaloing(bool check) {
1196 if (check) {
1197 haloing_enabled = false;
1198 } else {
1199 haloing_enabled = true;
1200 }
1201
1202 updateQWidget();
1203
1204}
1205
1206/**
1207 SLOT Activate by a click on the auxiliaire edges menu
1208@param check : 1 , 0
1209*/
1210void G4OpenGLQtViewer::toggleAux(bool check) {
1211 if (check) {
1212 fVP.SetAuxEdgeVisible(true);
1213 } else {
1214 fVP.SetAuxEdgeVisible(false);
1215 }
1216 SetNeedKernelVisit (true);
1217 updateQWidget();
1218}
1219
1220/**
1221 SLOT Activate by a click on the full screen menu
1222*/
1223void G4OpenGLQtViewer::toggleFullScreen(bool check) {
1224 if (check != fGLWindow->isFullScreen()) { //toggle
1225#if QT_VERSION >= 0x030200
1226 fGLWindow->setWindowState(fGLWindow->windowState() ^ Qt::WindowFullScreen);
1227#else
1228 G4cerr << "This version of Qt could not do fullScreen. Resizing the widget is the only solution available." << G4endl;
1229#endif
1230 }
1231}
1232
1233
1234void G4OpenGLQtViewer::savePPMToTemp() {
1235 if (fMovieTempFolderPath == "") {
1236 return;
1237 }
1238 QString fileName ="Test"+QString::number(fRecordFrameNumber)+".ppm";
1239 QString filePath =fMovieTempFolderPath+fileName;
1240
1241 QImage image;
1242 image = fWindow->grabFrameBuffer();
1243 bool res = false;
1244
1245#if QT_VERSION < 0x040000
1246 res = image.save(filePath,"PPM");
1247#else
1248 res = image.save(filePath,0);
1249#endif
1250 if (res == false) {
1251 resetRecording();
1252 setRecordingInfos("Can't save tmp file "+filePath);
1253 return;
1254 }
1255
1256 setRecordingInfos("File "+fileName+" saved");
1257 fRecordFrameNumber++;
1258}
1259
1260
1261
1262void G4OpenGLQtViewer::actionSaveImage() {
1263 QString filters;
1264#if QT_VERSION < 0x040000
1265 QStrList listFormat=QImageIO::outputFormats();
1266 char *tmp=listFormat.first();
1267 while (tmp!=0) {
1268 filters += QString(tmp) + ";;";
1269 tmp=listFormat.next();
1270 }
1271#else
1272 QList<QByteArray> formats = QImageWriter::supportedImageFormats ();
1273 for (int i = 0; i < formats.size(); ++i) {
1274 filters +=formats.at(i) + ";;";
1275 }
1276#endif
1277 filters += "eps;;";
1278 filters += "ps;;";
1279 filters += "pdf";
1280 QString* selectedFormat = new QString();
1281 std::string name;
1282#if QT_VERSION < 0x040000
1283 name = QFileDialog::getSaveFileName ( ".",
1284 filters,
1285 fGLWindow,
1286 "Save file dialog",
1287 tr("Save as ..."),
1288 selectedFormat ).ascii();
1289#else
1290 name = QFileDialog::getSaveFileName ( fGLWindow,
1291 tr("Save as ..."),
1292 ".",
1293 filters,
1294 selectedFormat ).toStdString().c_str();
1295#endif
1296 // bmp jpg jpeg png ppm xbm xpm
1297 if (name.empty()) {
1298 return;
1299 }
1300#if QT_VERSION < 0x040000
1301 name += "." + std::string(selectedFormat->ascii());
1302 QString format = selectedFormat->lower();
1303#else
1304 name += "." + selectedFormat->toStdString();
1305 QString format = selectedFormat->toLower();
1306#endif
1307 setPrintFilename(name.c_str(),0);
1308 G4OpenGLQtExportDialog* exportDialog= new G4OpenGLQtExportDialog(fGLWindow,format,fWindow->height(),fWindow->width());
1309 if( exportDialog->exec()) {
1310
1311 QImage image;
1312 bool res = false;
1313 if ((exportDialog->getWidth() !=fWindow->width()) ||
1314 (exportDialog->getHeight() !=fWindow->height())) {
1315 setPrintSize(exportDialog->getWidth(),exportDialog->getHeight());
1316 if ((format != QString("eps")) && (format != QString("ps"))) {
1317 G4cerr << "Export->Change Size : This function is not implemented, to export in another size, please resize your frame to what you need" << G4endl;
1318
1319 // rescaleImage(exportDialog->getWidth(),exportDialog->getHeight());// re-scale image
1320 // QGLWidget* glResized = fWindow;
1321
1322 // FIXME :
1323 // L.Garnier : I've try to implement change size function, but the problem is
1324 // the renderPixmap function call the QGLWidget to resize and it doesn't draw
1325 // the content of this widget... It only draw the background.
1326
1327 // fWindow->renderPixmap (exportDialog->getWidth()*2,exportDialog->getHeight()*2,true );
1328
1329 // QPixmap pixmap = fWindow->renderPixmap ();
1330
1331 // image = pixmap->toImage();
1332 // glResized->resize(exportDialog->getWidth()*2,exportDialog->getHeight()*2);
1333 // image = glResized->grabFrameBuffer();
1334 }
1335 } else {
1336 image = fWindow->grabFrameBuffer();
1337 }
1338 if (format == QString("eps")) {
1339 fVectoredPs = exportDialog->getVectorEPS();
1340 printEPS();
1341 } else if (format == "ps") {
1342 fVectoredPs = true;
1343 printEPS();
1344 } else if (format == "pdf") {
1345
1346 res = printPDF(name,exportDialog->getNbColor(),image);
1347
1348 } else if ((format == "tif") ||
1349 (format == "tiff") ||
1350 (format == "jpg") ||
1351 (format == "jpeg") ||
1352 (format == "png") ||
1353 (format == "pbm") ||
1354 (format == "pgm") ||
1355 (format == "ppm") ||
1356 (format == "bmp") ||
1357 (format == "xbm") ||
1358 (format == "xpm")) {
1359#if QT_VERSION < 0x040000
1360 res = image.save(QString(name.c_str()),selectedFormat->ascii(),exportDialog->getSliderValue());
1361#else
1362 res = image.save(QString(name.c_str()),0,exportDialog->getSliderValue());
1363#endif
1364 } else {
1365 G4cerr << "This version of G4UI Could not generate the selected format" << G4endl;
1366 }
1367 if ((format == QString("eps")) && (format == QString("ps"))) {
1368 if (res == false) {
1369 G4cerr << "Error while saving file... "<<name.c_str()<< G4endl;
1370 } else {
1371 G4cout << "File "<<name.c_str()<<" has been saved " << G4endl;
1372 }
1373 }
1374
1375 } else { // cancel selected
1376 return;
1377 }
1378
1379}
1380
1381
1382void G4OpenGLQtViewer::actionChangeBackgroundColor() {
1383
1384 // //I need to revisit the kernel if the background colour changes and
1385 // //hidden line removal is enabled, because hlr drawing utilises the
1386 // //background colour in its drawing...
1387 // // (Note added by JA 13/9/2005) Background now handled in view
1388 // // parameters. A kernel visit is triggered on change of background.
1389
1390 QColor color;
1391 color = QColorDialog::getColor(Qt::black, fGLWindow);
1392 if (color.isValid()) {
1393 QString com = "/vis/viewer/set/background ";
1394 QString num;
1395 com += num.setNum(((float)color.red())/256)+" ";
1396 com += num.setNum(((float)color.green())/256)+" ";
1397 com += num.setNum(((float)color.blue())/256)+" ";
1398 G4UImanager::GetUIpointer()->ApplyCommand(com.toStdString().c_str());
1399 updateQWidget();
1400 }
1401}
1402
1403void G4OpenGLQtViewer::actionChangeTextColor() {
1404
1405 QColor color;
1406 color = QColorDialog::getColor(Qt::yellow, fGLWindow);
1407 if (color.isValid()) {
1408 QString com = "/vis/viewer/set/defaultTextColour ";
1409 QString num;
1410 com += num.setNum(((float)color.red())/256)+" ";
1411 com += num.setNum(((float)color.green())/256)+" ";
1412 com += num.setNum(((float)color.blue())/256)+" ";
1413 G4UImanager::GetUIpointer()->ApplyCommand(com.toStdString().c_str());
1414 updateQWidget();
1415 }
1416}
1417
1418void G4OpenGLQtViewer::actionChangeDefaultColor() {
1419
1420 QColor color;
1421 color = QColorDialog::getColor(Qt::white, fGLWindow);
1422 printf("actionChangeDefaultColor\n");
1423 if (color.isValid()) {
1424 QString com = "/vis/viewer/set/defaultColour ";
1425 QString num;
1426 com += num.setNum(((float)color.red())/256)+" ";
1427 com += num.setNum(((float)color.green())/256)+" ";
1428 com += num.setNum(((float)color.blue())/256)+" ";
1429 G4UImanager::GetUIpointer()->ApplyCommand(com.toStdString().c_str());
1430 updateQWidget();
1431 }
1432}
1433
1434
1435void G4OpenGLQtViewer::actionMovieParameters() {
1436 showMovieParametersDialog();
1437}
1438
1439
1440void G4OpenGLQtViewer::showMovieParametersDialog() {
1441 if (!fMovieParametersDialog) {
1442 fMovieParametersDialog= new G4OpenGLQtMovieDialog(this,fGLWindow);
1443 displayRecordingStatus();
1444 fMovieParametersDialog->checkEncoderSwParameters();
1445 fMovieParametersDialog->checkSaveFileNameParameters();
1446 fMovieParametersDialog->checkTempFolderParameters();
1447 if (getEncoderPath() == "") {
1448 setRecordingInfos("mpeg_encode is needed to encode in video format. It is available here: http://bmrc.berkeley.edu/frame/research/mpeg/");
1449 }
1450 }
1451 fMovieParametersDialog->show();
1452}
1453
1454
1455/*
1456// http://www.google.com/codesearch?hl=en&q=+jpg+Qt+quality+QDialog+show:FZkUoth8oiw:TONpW2mR-_c:tyTfrKMO-xI&sa=N&cd=2&ct=rc&cs_p=http://soft.proindependent.com/src/qtiplot-0.8.9.zip&cs_f=qtiplot-0.8.9/qtiplot/src/application.cpp#a0
1457
1458void Graph::exportToSVG(const QString& fname)
1459{
1460 // enable workaround for Qt3 misalignments
1461 QwtPainter::setSVGMode(true);
1462 QPicture picture;
1463 QPainter p(&picture);
1464 d_plot->print(&p, d_plot->rect());
1465 p.end();
1466
1467 picture.save(fname, "svg");
1468}
1469*/
1470
1471
1472
1473void G4OpenGLQtViewer::FinishView()
1474{
1475 glFlush ();
1476
1477 // L. Garnier 10/2009 : Not necessary and cause problems on mac OS X 10.6
1478 // fWindow->swapBuffers ();
1479}
1480
1481/**
1482 Save the current mouse press point
1483 @param p mouse click point
1484*/
1485void G4OpenGLQtViewer::G4MousePressEvent(QMouseEvent *event)
1486{
1487#if QT_VERSION < 0x040000
1488 if (event->button() & Qt::LeftButton) {
1489#else
1490 if (event->buttons() & Qt::LeftButton) {
1491#endif
1492 fWindow->setMouseTracking(true);
1493 fAutoMove = false; // stop automove
1494 fLastPos1 = event->pos();
1495 fLastPos2 = fLastPos1;
1496 fLastPos3 = fLastPos2;
1497 fLastEventTime->start();
1498 if (fMouseAction == STYLE3){ // pick
1499 Pick(event->pos().x(),event->pos().y());
1500 }
1501 }
1502}
1503
1504/**
1505*/
1506void G4OpenGLQtViewer::G4MouseReleaseEvent()
1507{
1508 fSpinningDelay = fLastEventTime->elapsed();
1509 QPoint delta = (fLastPos3-fLastPos1);
1510 if ((delta.x() == 0) && (delta.y() == 0)) {
1511 return;
1512 }
1513 if (fSpinningDelay < fLaunchSpinDelay ) {
1514 fAutoMove = true;
1515 QTime lastMoveTime;
1516 lastMoveTime.start();
1517 // try to addapt speed move/rotate looking to drawing speed
1518 float correctionFactor = 5;
1519 while (fAutoMove) {
1520 if ( lastMoveTime.elapsed () >= (int)(1000/fNbMaxFramesPerSec)) {
1521 float lTime = 1000/((float)lastMoveTime.elapsed ());
1522 if (((((float)delta.x())/correctionFactor)*lTime > fNbMaxAnglePerSec) ||
1523 ((((float)delta.x())/correctionFactor)*lTime < -fNbMaxAnglePerSec) ) {
1524 correctionFactor = (float)delta.x()*(lTime/fNbMaxAnglePerSec);
1525 if (delta.x() <0 ) {
1526 correctionFactor = -correctionFactor;
1527 }
1528 }
1529 if (((((float)delta.y())/correctionFactor)*lTime > fNbMaxAnglePerSec) ||
1530 ((((float)delta.y())/correctionFactor)*lTime < -fNbMaxAnglePerSec) ) {
1531 correctionFactor = (float)delta.y()*(lTime/fNbMaxAnglePerSec);
1532 if (delta.y() <0 ) {
1533 correctionFactor = -correctionFactor;
1534 }
1535 }
1536
1537 // Check Qt Versions for META Keys
1538
1539 // Click and move mouse to rotate volume
1540 // ALT + Click and move mouse to rotate volume (View Direction)
1541 // SHIFT + Click and move camera point of view
1542 // CTRL + Click and zoom mouse to zoom in/out
1543
1544 if (fMouseAction == STYLE1) { // rotate
1545 if (fNoKeyPress) {
1546 rotateQtScene(((float)delta.x())/correctionFactor,((float)delta.y())/correctionFactor);
1547 } else if (fAltKeyPress) {
1548 rotateQtSceneInViewDirection(((float)delta.x())/correctionFactor,((float)delta.y())/correctionFactor);
1549 }
1550
1551 } else if (fMouseAction == STYLE2) { // move
1552 moveScene(-((float)delta.x())/correctionFactor,-((float)delta.y())/correctionFactor,0,true);
1553 }
1554 lastMoveTime.start();
1555 }
1556 ((QApplication*)G4Qt::getInstance ())->processEvents();
1557 }
1558 }
1559 fWindow->setMouseTracking(false);
1560
1561}
1562
1563
1564void G4OpenGLQtViewer::G4MouseDoubleClickEvent()
1565{
1566 fWindow->setMouseTracking(true);
1567}
1568
1569
1570/**
1571 @param pos_x mouse x position
1572 @param pos_y mouse y position
1573 @param mButtons mouse button active
1574 @param mAutoMove true: apply this move till another evnt came, false :one time move
1575*/
1576
1577void G4OpenGLQtViewer::G4MouseMoveEvent(QMouseEvent *event)
1578{
1579
1580#if QT_VERSION < 0x040000
1581 Qt::ButtonState mButtons = event->state();
1582#else
1583 Qt::MouseButtons mButtons = event->buttons();
1584#endif
1585
1586#if QT_VERSION < 0x040000
1587 updateKeyModifierState(event->state());
1588#else
1589 updateKeyModifierState(event->modifiers());
1590#endif
1591
1592 if (fAutoMove) {
1593 return;
1594 }
1595
1596 fLastPos3 = fLastPos2;
1597 fLastPos2 = fLastPos1;
1598 fLastPos1 = QPoint(event->x(), event->y());
1599
1600 int deltaX = fLastPos2.x()-fLastPos1.x();
1601 int deltaY = fLastPos2.y()-fLastPos1.y();
1602
1603 if (fMouseAction == STYLE1) { // rotate
1604 if (mButtons & Qt::LeftButton) {
1605 if (fNoKeyPress) {
1606 rotateQtScene(((float)deltaX),((float)deltaY));
1607 } else if (fAltKeyPress) {
1608 rotateQtSceneInViewDirection(((float)deltaX),((float)deltaY));
1609 } else if (fShiftKeyPress) {
1610 unsigned int sizeWin;
1611 sizeWin = getWinWidth();
1612 if (getWinHeight() < getWinWidth()) {
1613 sizeWin = getWinHeight();
1614 }
1615
1616 // L.Garnier : 08/2010 100 is the good value, but don't ask me why !
1617 float factor = ((float)100/(float)sizeWin) ;
1618 moveScene(-(float)deltaX*factor,-(float)deltaY*factor,0,false);
1619 } else if (fControlKeyPress) {
1620 fVP.SetZoomFactor(fVP.GetZoomFactor()*(1+((float)deltaY)));
1621 }
1622 }
1623 } else if (fMouseAction == STYLE2) { // move
1624 if (mButtons & Qt::LeftButton) {
1625 moveScene(-deltaX,-deltaY,0,true);
1626 }
1627 }
1628
1629 fLastEventTime->start();
1630}
1631
1632
1633/**
1634 Move the scene of dx, dy, dz values.
1635 @param dx delta mouse x position
1636 @param dy delta mouse y position
1637 @param mouseMove : true if even comes from a mouse move, false if even comes from key action
1638*/
1639
1640void G4OpenGLQtViewer::moveScene(float dx,float dy, float dz,bool mouseMove)
1641{
1642 if (fHoldMoveEvent)
1643 return;
1644 fHoldMoveEvent = true;
1645
1646 G4double coefTrans = 0;
1647 GLdouble coefDepth = 0;
1648 if(mouseMove) {
1649 coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinWidth());
1650 if (getWinHeight() <getWinWidth()) {
1651 coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinHeight());
1652 }
1653 } else {
1654 coefTrans = getSceneNearWidth()*fDeltaSceneTranslation;
1655 coefDepth = getSceneDepth()*fDeltaDepth;
1656 }
1657 fVP.IncrementPan(-dx*coefTrans,dy*coefTrans,dz*coefDepth);
1658 emit moveX(-static_cast<int>(dx*coefTrans));
1659 emit moveY(static_cast<int>(dy*coefTrans));
1660 emit moveZ(static_cast<int>(dz*coefTrans));
1661
1662 updateQWidget();
1663 if (fAutoMove)
1664 ((QApplication*)G4Qt::getInstance ())->processEvents();
1665
1666 fHoldMoveEvent = false;
1667}
1668
1669
1670/**
1671 @param dx delta mouse x position
1672 @param dy delta mouse y position
1673*/
1674
1675void G4OpenGLQtViewer::rotateQtScene(float dx, float dy)
1676{
1677 if (fHoldRotateEvent)
1678 return;
1679 fHoldRotateEvent = true;
1680
1681 if( dx != 0) {
1682 rotateScene(dx,0,fDeltaRotation);
1683 emit rotateTheta(static_cast<int>(dx));
1684 }
1685 if( dy != 0) {
1686 rotateScene(0,dy,fDeltaRotation);
1687 emit rotatePhi(static_cast<int>(dy));
1688 }
1689 updateQWidget();
1690
1691 fHoldRotateEvent = false;
1692}
1693
1694/**
1695 @param dx delta mouse x position
1696 @param dy delta mouse y position
1697*/
1698
1699void G4OpenGLQtViewer::rotateQtSceneInViewDirection(float dx, float dy)
1700{
1701 if (fHoldRotateEvent)
1702 return;
1703 fHoldRotateEvent = true;
1704
1705 fXRot +=dx;
1706 fYRot +=dy;
1707
1708 rotateSceneInViewDirection(dx,dy,fDeltaRotation/100);
1709
1710 emit rotateTheta(static_cast<int>(dx));
1711 emit rotatePhi(static_cast<int>(dy));
1712 updateQWidget();
1713
1714 fHoldRotateEvent = false;
1715}
1716
1717/**
1718 @param dx delta mouse x position
1719 @param dy delta mouse y position
1720*/
1721
1722void G4OpenGLQtViewer::rotateQtCamera(float dx, float dy)
1723{
1724 if (fHoldRotateEvent)
1725 return;
1726 fHoldRotateEvent = true;
1727
1728 rotateScene(dx,dy,fDeltaRotation);
1729 emit rotateTheta(static_cast<int>(dx));
1730 emit rotatePhi(static_cast<int>(dy));
1731 updateQWidget();
1732
1733 fHoldRotateEvent = false;
1734}
1735
1736/**
1737 @param dx delta mouse x position
1738 @param dy delta mouse y position
1739*/
1740
1741void G4OpenGLQtViewer::rotateQtCameraInViewDirection(float dx, float dy)
1742{
1743 if (fHoldRotateEvent)
1744 return;
1745 fHoldRotateEvent = true;
1746
1747 fVP.SetUpVector(G4Vector3D(0.0, 1.0, 0.0));
1748 fVP.SetViewAndLights (G4Vector3D(0.0, 0.0, 1.0));
1749
1750
1751 fXRot +=dx;
1752 fYRot +=dy;
1753
1754 rotateSceneInViewDirection(fXRot,fYRot,fDeltaRotation/100);
1755
1756 emit rotateTheta(static_cast<int>(dx));
1757 emit rotatePhi(static_cast<int>(dy));
1758 updateQWidget();
1759
1760 fHoldRotateEvent = false;
1761}
1762
1763
1764
1765
1766
1767/** This is the benning of a rescale function. It does nothing for the moment
1768 @param aWidth : new width
1769 @param aHeight : new height
1770*/
1771void G4OpenGLQtViewer::rescaleImage(
1772 int /* aWidth */
1773,int /* aHeight */
1774){
1775 // GLfloat* feedback_buffer;
1776 // GLint returned;
1777 // FILE* file;
1778
1779// feedback_buffer = new GLfloat[size];
1780// glFeedbackBuffer (size, GL_3D_COLOR, feedback_buffer);
1781// glRenderMode (GL_FEEDBACK);
1782
1783// DrawView();
1784// returned = glRenderMode (GL_RENDER);
1785
1786}
1787
1788
1789
1790/**
1791 Generate Postscript or PDF form image
1792 @param aFilename : name of file
1793 @param aInColor : numbers of colors : 1->BW 2->RGB
1794 @param aImage : Image to print
1795*/
1796bool G4OpenGLQtViewer::printPDF (
1797 const std::string aFilename
1798,int aInColor
1799,QImage aImage
1800)
1801{
1802
1803#if QT_VERSION < 0x040000
1804#if defined(Q_WS_MAC) || defined(Q_WS_X11)
1805 QPrinter printer;
1806 // printer.setPageSize(pageSize);
1807 if (aInColor == 1) {
1808 printer.setColorMode(QPrinter::GrayScale);
1809 } else {
1810 printer.setColorMode(QPrinter::Color);
1811 }
1812
1813 /* FIXME : I don't know which format it will save...
1814 if (aFilename.endsWith(".ps")) {
1815 printer.setOutputFormat(QPrinter::PostScriptFormat);
1816 } else {
1817 printer.setOutputFormat(QPrinter::PdfFormat);
1818 }
1819 */
1820 printer.setOutputFileName(QString(aFilename.c_str()));
1821 // printer.setFullPage ( true);
1822 QPainter paint(&printer);
1823 paint.drawImage (0,0,aImage );
1824 paint.end();
1825#else
1826 G4cerr << "This fonction is only supported on Mac OsX or X11 with Qt3. Full platform supported with Qt4" << G4endl;
1827 // FIXME
1828 // L.Garnier 6 May 2009 : Only to fix compilation warnings
1829 if (aFilename.empty()) {
1830 aInColor = 0;
1831 aImage = 0;
1832 }
1833 // END_OF FIXME
1834#endif
1835#else
1836 QPrinter printer;
1837 // printer.setPageSize(pageSize);
1838
1839 // FIXME : L. Garnier 4/12/07
1840 // This is not working, it does nothing. Image is staying in color mode
1841 // So I have desactivate the B/W button in GUI
1842 if ((!aImage.isGrayscale ()) &&(aInColor ==1 )) {
1843#if QT_VERSION < 0x040000
1844 aImage = aImage.convertDepth(1,Qt::MonoOnly);
1845#else
1846 aImage = aImage.convertToFormat ( aImage.format(), Qt::MonoOnly);
1847#endif
1848 }
1849
1850
1851 if (aFilename.substr(aFilename.size()-3) == ".ps") {
1852#if QT_VERSION > 0x040200
1853 printer.setOutputFormat(QPrinter::PostScriptFormat);
1854#endif
1855 } else {
1856#if QT_VERSION > 0x040100
1857 printer.setOutputFormat(QPrinter::PdfFormat);
1858#endif
1859 }
1860#if QT_VERSION > 0x040100
1861 printer.setOutputFileName(QString(aFilename.c_str()));
1862#endif
1863 // printer.setFullPage ( true);
1864 QPainter paint(&printer);
1865 paint.drawImage (0,0,aImage);
1866 paint.end();
1867#endif
1868 return true;
1869}
1870
1871
1872void G4OpenGLQtViewer::G4wheelEvent (QWheelEvent * event)
1873{
1874 fVP.SetZoomFactor(fVP.GetZoomFactor()+(fVP.GetZoomFactor()*(event->delta())/1200));
1875 updateQWidget();
1876}
1877
1878
1879 void G4OpenGLQtViewer::G4keyPressEvent (QKeyEvent * event)
1880{
1881 if (fHoldKeyEvent)
1882 return;
1883
1884 fHoldKeyEvent = true;
1885
1886
1887 // with no modifiers
1888#if QT_VERSION < 0x040000
1889 updateKeyModifierState(event->state());
1890 if (fNoKeyPress) {
1891#else
1892 updateKeyModifierState(event->modifiers());
1893 if ((fNoKeyPress) || (event->modifiers() == Qt::KeypadModifier )) {
1894#endif
1895 if (event->key() == Qt::Key_Down) { // go down
1896 moveScene(0,1,0,false);
1897 }
1898 else if (event->key() == Qt::Key_Up) { // go up
1899 moveScene(0,-1,0,false);
1900 }
1901 if (event->key() == Qt::Key_Left) { // go left
1902 moveScene(-1,0,0,false);
1903 }
1904 else if (event->key() == Qt::Key_Right) { // go right
1905 moveScene(1,0,0,false);
1906 }
1907 if (event->key() == Qt::Key_Minus) { // go backward
1908 moveScene(0,0,1,false);
1909 }
1910 else if (event->key() == Qt::Key_Plus) { // go forward
1911 moveScene(0,0,-1,false);
1912 }
1913
1914 // escaped from full screen
1915 if (event->key() == Qt::Key_Escape) {
1916#if QT_VERSION >= 0x030200
1917 toggleFullScreen(false);
1918#endif
1919 }
1920 }
1921 // several case here : If return is pressed, in every case -> display the movie parameters dialog
1922 // If one parameter is wrong -> put it in red (only save filenam could be wrong..)
1923 // If encoder not found-> does nothing.Only display a message in status box
1924 // If all ok-> generate parameter file
1925 // If ok -> put encoder button enabled
1926
1927 if ((event->key() == Qt::Key_Return) || (event->key() == Qt::Key_Enter)){ // end of video
1928 stopVideo();
1929 }
1930 if (event->key() == Qt::Key_Space){ // start/pause of video
1931 startPauseVideo();
1932 }
1933
1934 // H : Return Home view
1935 if (event->key() == Qt::Key_H){ // go Home
1936 fDeltaRotation = 1;
1937 fDeltaSceneTranslation = 0.01;
1938 fDeltaDepth = 0.01;
1939 fDeltaZoom = 0.05;
1940 fDeltaMove = 0.05;
1941
1942 fVP.SetZoomFactor(1.);
1943 fVP.SetUpVector(G4Vector3D (0., 1., 0.));
1944 fVP.SetViewAndLights (G4Vector3D (0., 0., 1.));
1945
1946 updateQWidget();
1947 }
1948
1949 // Shift Modifier
1950 if (fShiftKeyPress) {
1951 if (event->key() == Qt::Key_Down) { // rotate phi
1952 rotateQtScene(0,-fDeltaRotation);
1953 }
1954 else if (event->key() == Qt::Key_Up) { // rotate phi
1955 rotateQtScene(0,fDeltaRotation);
1956 }
1957 if (event->key() == Qt::Key_Left) { // rotate theta
1958 rotateQtScene(fDeltaRotation,0);
1959 }
1960 else if (event->key() == Qt::Key_Right) { // rotate theta
1961 rotateQtScene(-fDeltaRotation,0);
1962 }
1963
1964 // Alt Modifier
1965 }
1966 if ((fAltKeyPress)) {
1967 if (event->key() == Qt::Key_Down) { // rotate phi
1968 rotateQtSceneInViewDirection(0,-fDeltaRotation);
1969 }
1970 else if (event->key() == Qt::Key_Up) { // rotate phi
1971 rotateQtSceneInViewDirection(0,fDeltaRotation);
1972 }
1973 if (event->key() == Qt::Key_Left) { // rotate theta
1974 rotateQtSceneInViewDirection(fDeltaRotation,0);
1975 }
1976 else if (event->key() == Qt::Key_Right) { // rotate theta
1977 rotateQtSceneInViewDirection(-fDeltaRotation,0);
1978 }
1979
1980 // Rotatio +/-
1981 if (event->key() == Qt::Key_Plus) {
1982 fDeltaRotation = fDeltaRotation/0.7;
1983 G4cout << "Auto-rotation set to : " << fDeltaRotation << G4endl;
1984 }
1985 else if (event->key() == Qt::Key_Minus) {
1986 fDeltaRotation = fDeltaRotation*0.7;
1987 G4cout << "Auto-rotation set to : " << fDeltaRotation << G4endl;
1988 }
1989
1990 // Control Modifier OR Command on MAC
1991 }
1992 if ((fControlKeyPress)) {
1993 if (event->key() == Qt::Key_Plus) {
1994 fVP.SetZoomFactor(fVP.GetZoomFactor()*(1+fDeltaZoom));
1995 updateQWidget();
1996 }
1997 else if (event->key() == Qt::Key_Minus) {
1998 fVP.SetZoomFactor(fVP.GetZoomFactor()*(1-fDeltaZoom));
1999 updateQWidget();
2000 }
2001 }
2002
2003 fHoldKeyEvent = false;
2004}
2005
2006
2007#if QT_VERSION < 0x040000
2008void G4OpenGLQtViewer::updateKeyModifierState(Qt::ButtonState modifier) {
2009#else
2010void G4OpenGLQtViewer::updateKeyModifierState(Qt::KeyboardModifiers modifier) {
2011#endif
2012 // Check Qt Versions for META Keys
2013
2014 fNoKeyPress = true;
2015 fAltKeyPress = false;
2016 fShiftKeyPress = false;
2017 fControlKeyPress = false;
2018
2019#if QT_VERSION < 0x040000
2020 if (modifier & Qt::AltButton ) {
2021 fAltKeyPress = true;
2022 fNoKeyPress = false;
2023 }
2024 if (modifier & Qt::ShiftButton ) {
2025 fShiftKeyPress = true;
2026 fNoKeyPress = false;
2027 }
2028 if (modifier & Qt::ControlButton ) {
2029 fControlKeyPress = true;
2030 fNoKeyPress = false;
2031 }
2032#else
2033 if (modifier & Qt::AltModifier ) {
2034 fAltKeyPress = true;
2035 fNoKeyPress = false;
2036 }
2037 if (modifier & Qt::ShiftModifier ) {
2038 fShiftKeyPress = true;
2039 fNoKeyPress = false;
2040 }
2041 if (modifier & Qt::ControlModifier ) {
2042 fControlKeyPress = true;
2043 fNoKeyPress = false;
2044 }
2045#endif
2046}
2047
2048
2049/** Stop the video. Check all parameters and enable encoder button if all is ok.
2050*/
2051void G4OpenGLQtViewer::stopVideo() {
2052
2053 // if encoder parameter is wrong, display parameters dialog and return
2054 if (!fMovieParametersDialog) {
2055 showMovieParametersDialog();
2056 }
2057 setRecordingStatus(STOP);
2058
2059 if (fRecordFrameNumber >0) {
2060 // check parameters if they were modified (Re APPLY them...)
2061 if (!(fMovieParametersDialog->checkEncoderSwParameters())) {
2062 setRecordingStatus(BAD_ENCODER);
2063 } else if (!(fMovieParametersDialog->checkSaveFileNameParameters())) {
2064 setRecordingStatus(BAD_OUTPUT);
2065 }
2066 } else {
2067 resetRecording();
2068 setRecordingInfos("No frame to encode.");
2069 }
2070}
2071
2072/** Stop the video. Check all parameters and enable encoder button if all is ok.
2073*/
2074void G4OpenGLQtViewer::saveVideo() {
2075
2076 // if encoder parameter is wrong, display parameters dialog and return
2077 if (!fMovieParametersDialog) {
2078 showMovieParametersDialog();
2079 }
2080
2081 fMovieParametersDialog->checkEncoderSwParameters();
2082 fMovieParametersDialog->checkSaveFileNameParameters();
2083
2084 if (fRecordingStep == STOP) {
2085 setRecordingStatus(SAVE);
2086 generateMpegEncoderParameters();
2087 encodeVideo();
2088 }
2089}
2090
2091
2092/** Start/Pause the video..
2093*/
2094void G4OpenGLQtViewer::startPauseVideo() {
2095
2096 // first time, if temp parameter is wrong, display parameters dialog and return
2097
2098 if (( fRecordingStep == WAIT)) {
2099 if ( fRecordFrameNumber == 0) {
2100 if (getTempFolderPath() == "") { // BAD_OUTPUT
2101 showMovieParametersDialog();
2102 setRecordingInfos("You should specified the temp folder in order to make movie");
2103 return;
2104 } else {
2105 // remove temp folder if it was create
2106 QString tmp = removeTempFolder();
2107 if (tmp !="") {
2108 setRecordingInfos(tmp);
2109 return;
2110 }
2111 tmp = createTempFolder();
2112 if (tmp != "") {
2113 setRecordingInfos("Can't create temp folder."+tmp);
2114 return;
2115 }
2116 }
2117 }
2118 }
2119 if ((fRecordingStep == WAIT)) {
2120 setRecordingStatus(START);
2121 } else if (fRecordingStep == START) {
2122 setRecordingStatus(PAUSE);
2123 } else if (fRecordingStep == PAUSE) {
2124 setRecordingStatus(CONTINUE);
2125 } else if (fRecordingStep == CONTINUE) {
2126 setRecordingStatus(PAUSE);
2127 }
2128}
2129
2130void G4OpenGLQtViewer::setRecordingStatus(RECORDING_STEP step) {
2131
2132 fRecordingStep = step;
2133 displayRecordingStatus();
2134}
2135
2136
2137void G4OpenGLQtViewer::displayRecordingStatus() {
2138
2139 QString txtStatus = "";
2140 if (fRecordingStep == WAIT) {
2141 txtStatus = "Waiting to start...";
2142 fRecordFrameNumber = 0; // reset the frame number
2143 } else if (fRecordingStep == START) {
2144 txtStatus = "Start Recording...";
2145 } else if (fRecordingStep == PAUSE) {
2146 txtStatus = "Pause Recording...";
2147 } else if (fRecordingStep == CONTINUE) {
2148 txtStatus = "Continue Recording...";
2149 } else if (fRecordingStep == STOP) {
2150 txtStatus = "Stop Recording...";
2151 } else if (fRecordingStep == READY_TO_ENCODE) {
2152 txtStatus = "Ready to Encode...";
2153 } else if (fRecordingStep == ENCODING) {
2154 txtStatus = "Encoding...";
2155 } else if (fRecordingStep == FAILED) {
2156 txtStatus = "Failed to encode...";
2157 } else if ((fRecordingStep == BAD_ENCODER)
2158 || (fRecordingStep == BAD_OUTPUT)
2159 || (fRecordingStep == BAD_TMP)) {
2160 txtStatus = "Correct above errors first";
2161 } else if (fRecordingStep == SUCCESS) {
2162 txtStatus = "File encoded successfully";
2163 } else {
2164 }
2165
2166 if (fMovieParametersDialog) {
2167 fMovieParametersDialog->setRecordingStatus(txtStatus);
2168 } else {
2169#if QT_VERSION < 0x040000
2170 G4cout << txtStatus.ascii() << G4endl;
2171#else
2172 G4cout << txtStatus.toStdString().c_str() << G4endl;
2173#endif
2174 }
2175 setRecordingInfos("");
2176}
2177
2178
2179void G4OpenGLQtViewer::setRecordingInfos(QString txt) {
2180 if (fMovieParametersDialog) {
2181 fMovieParametersDialog->setRecordingInfos(txt);
2182 } else {
2183#if QT_VERSION < 0x040000
2184 G4cout << txt.ascii() << G4endl;
2185#else
2186 G4cout << txt.toStdString().c_str() << G4endl;
2187#endif
2188 }
2189}
2190
2191/** Init the movie parameters. Temp dir and encoder path
2192*/
2193void G4OpenGLQtViewer::initMovieParameters() {
2194 //init encoder
2195
2196 //look for encoderPath
2197 fProcess = new QProcess();
2198
2199#if QT_VERSION < 0x040000
2200 QObject ::connect(fProcess,SIGNAL(processExited ()),
2201 this,SLOT(processLookForFinished()));
2202 fProcess->setCommunication(QProcess::DupStderr);
2203 fProcess->setArguments(QStringList("which mpeg_encode"));
2204 fProcess->start();
2205#else
2206 QObject ::connect(fProcess,SIGNAL(finished ( int)),
2207 this,SLOT(processLookForFinished()));
2208 fProcess->setReadChannelMode(QProcess::MergedChannels);
2209 fProcess->start ("which mpeg_encode");
2210#endif
2211
2212}
2213
2214/** @return encoder path or "" if it does not exist
2215 */
2216QString G4OpenGLQtViewer::getEncoderPath() {
2217 return fEncoderPath;
2218}
2219
2220
2221/**
2222 * set the new encoder path
2223 * @return "" if correct. The error otherwise
2224*/
2225QString G4OpenGLQtViewer::setEncoderPath(QString path) {
2226 if (path == "") {
2227 return "File does not exist";
2228 }
2229
2230#if QT_VERSION < 0x040000
2231 path = QDir::cleanDirPath(path);
2232#else
2233 path = QDir::cleanPath(path);
2234#endif
2235 QFileInfo *f = new QFileInfo(path);
2236 if (!f->exists()) {
2237 return "File does not exist";
2238 } else if (f->isDir()) {
2239 return "This is a directory";
2240 } else if (!f->isExecutable()) {
2241 return "File exist but is not executable";
2242 } else if (!f->isFile()) {
2243 return "This is not a file";
2244 }
2245 fEncoderPath = path;
2246
2247 if ((fRecordingStep == BAD_ENCODER)) {
2248 setRecordingStatus(STOP);
2249 }
2250 return "";
2251}
2252
2253
2254bool G4OpenGLQtViewer::isRecording(){
2255 if ((fRecordingStep == START) || (fRecordingStep == CONTINUE)) {
2256 return true;
2257 }
2258 return false;
2259}
2260
2261bool G4OpenGLQtViewer::isPaused(){
2262 if (fRecordingStep == PAUSE) {
2263 return true;
2264 }
2265 return false;
2266}
2267
2268bool G4OpenGLQtViewer::isEncoding(){
2269 if (fRecordingStep == ENCODING) {
2270 return true;
2271 }
2272 return false;
2273}
2274
2275bool G4OpenGLQtViewer::isWaiting(){
2276 if (fRecordingStep == WAIT) {
2277 return true;
2278 }
2279 return false;
2280}
2281
2282bool G4OpenGLQtViewer::isStopped(){
2283 if (fRecordingStep == STOP) {
2284 return true;
2285 }
2286 return false;
2287}
2288
2289bool G4OpenGLQtViewer::isFailed(){
2290 if (fRecordingStep == FAILED) {
2291 return true;
2292 }
2293 return false;
2294}
2295
2296bool G4OpenGLQtViewer::isSuccess(){
2297 if (fRecordingStep == SUCCESS) {
2298 return true;
2299 }
2300 return false;
2301}
2302
2303bool G4OpenGLQtViewer::isBadEncoder(){
2304 if (fRecordingStep == BAD_ENCODER) {
2305 return true;
2306 }
2307 return false;
2308}
2309bool G4OpenGLQtViewer::isBadTmp(){
2310 if (fRecordingStep == BAD_TMP) {
2311 return true;
2312 }
2313 return false;
2314}
2315bool G4OpenGLQtViewer::isBadOutput(){
2316 if (fRecordingStep == BAD_OUTPUT) {
2317 return true;
2318 }
2319 return false;
2320}
2321
2322void G4OpenGLQtViewer::setBadEncoder(){
2323 fRecordingStep = BAD_ENCODER;
2324 displayRecordingStatus();
2325}
2326void G4OpenGLQtViewer::setBadTmp(){
2327 fRecordingStep = BAD_TMP;
2328 displayRecordingStatus();
2329}
2330void G4OpenGLQtViewer::setBadOutput(){
2331 fRecordingStep = BAD_OUTPUT;
2332 displayRecordingStatus();
2333}
2334
2335void G4OpenGLQtViewer::setWaiting(){
2336 fRecordingStep = WAIT;
2337 displayRecordingStatus();
2338}
2339
2340
2341bool G4OpenGLQtViewer::isReadyToEncode(){
2342 if (fRecordingStep == READY_TO_ENCODE) {
2343 return true;
2344 }
2345 return false;
2346}
2347
2348void G4OpenGLQtViewer::resetRecording() {
2349 setRecordingStatus(WAIT);
2350}
2351
2352/**
2353 * set the temp folder path
2354 * @return "" if correct. The error otherwise
2355*/
2356QString G4OpenGLQtViewer::setTempFolderPath(QString path) {
2357
2358 if (path == "") {
2359 return "Path does not exist";
2360 }
2361#if QT_VERSION < 0x040000
2362 path = QDir::cleanDirPath(path);
2363#else
2364 path = QDir::cleanPath(path);
2365#endif
2366 QFileInfo *d = new QFileInfo(path);
2367 if (!d->exists()) {
2368 return "Path does not exist";
2369 } else if (!d->isDir()) {
2370 return "This is not a directory";
2371 } else if (!d->isReadable()) {
2372 return path +" is read protected";
2373 } else if (!d->isWritable()) {
2374 return path +" is write protected";
2375 }
2376
2377 if ((fRecordingStep == BAD_TMP)) {
2378 setRecordingStatus(WAIT);
2379 }
2380 fTempFolderPath = path;
2381 return "";
2382}
2383
2384/** @return the temp folder path or "" if it does not exist
2385 */
2386QString G4OpenGLQtViewer::getTempFolderPath() {
2387 return fTempFolderPath;
2388}
2389
2390/**
2391 * set the save file name path
2392 * @return "" if correct. The error otherwise
2393*/
2394QString G4OpenGLQtViewer::setSaveFileName(QString path) {
2395
2396 if (path == "") {
2397 return "Path does not exist";
2398 }
2399
2400 QFileInfo *file = new QFileInfo(path);
2401 QDir dir = file->dir();
2402#if QT_VERSION < 0x040000
2403 path = QDir::cleanDirPath(path);
2404#else
2405 path = QDir::cleanPath(path);
2406#endif
2407 if (file->exists()) {
2408 return "File already exist, please choose a new one";
2409 } else if (!dir.exists()) {
2410 return "Dir does not exist";
2411 } else if (!dir.isReadable()) {
2412 return path +" is read protected";
2413 }
2414
2415 if ((fRecordingStep == BAD_OUTPUT)) {
2416 setRecordingStatus(STOP);
2417 }
2418 fSaveFileName = path;
2419 return "";
2420}
2421
2422/** @return the save file path
2423 */
2424QString G4OpenGLQtViewer::getSaveFileName() {
2425 return fSaveFileName ;
2426}
2427
2428/** Create a Qt_temp folder in the temp folder given
2429* The temp folder will be like this /tmp/QtMovie_12-02-2008_12_12_58/
2430* @return "" if success. Error message if not.
2431*/
2432QString G4OpenGLQtViewer::createTempFolder() {
2433 fMovieTempFolderPath = "";
2434 //check
2435 QString tmp = setTempFolderPath(fTempFolderPath);
2436 if (tmp != "") {
2437 return tmp;
2438 }
2439#if QT_VERSION < 0x040000
2440 QString sep = QChar(QDir::separator());
2441#else
2442 QString sep = QString(QDir::separator());
2443#endif
2444 QString path = sep+"QtMovie_"+QDateTime::currentDateTime ().toString("dd-MM-yyyy_hh-mm-ss")+sep;
2445#if QT_VERSION < 0x040000
2446 QDir *d = new QDir(QDir::cleanDirPath(fTempFolderPath));
2447#else
2448 QDir *d = new QDir(QDir::cleanPath(fTempFolderPath));
2449#endif
2450 // check if it is already present
2451 if (d->exists(path)) {
2452 return "Folder "+path+" already exists.Please remove it first";
2453 }
2454 if (d->mkdir(fTempFolderPath+path)) {
2455 fMovieTempFolderPath = fTempFolderPath+path;
2456 return "";
2457 } else {
2458 return "Can't create "+fTempFolderPath+path;
2459 }
2460 return "-";
2461}
2462
2463/** Remove the Qt_temp folder in the temp folder
2464*/
2465QString G4OpenGLQtViewer::removeTempFolder() {
2466 // remove files in Qt_temp folder
2467 if (fMovieTempFolderPath == "") {
2468 return "";
2469 }
2470#if QT_VERSION < 0x040000
2471 QDir *d = new QDir(QDir::cleanDirPath(fMovieTempFolderPath));
2472#else
2473 QDir *d = new QDir(QDir::cleanPath(fMovieTempFolderPath));
2474#endif
2475 if (!d->exists()) {
2476 return ""; // already remove
2477 }
2478
2479 d->setFilter( QDir::Files );
2480 QStringList subDirList = d->entryList();
2481 int res = true;
2482 QString error = "";
2483 for (QStringList::ConstIterator it = subDirList.begin() ;(it != subDirList.end()) ; it++) {
2484 const QString currentFile = *it;
2485 if (!d->remove(currentFile)) {
2486 res = false;
2487 QString file = fMovieTempFolderPath+currentFile;
2488 error +="Removing file failed : "+file;
2489 } else {
2490 }
2491 }
2492 if (res) {
2493 if (d->rmdir(fMovieTempFolderPath)) {
2494 fMovieTempFolderPath = "";
2495 return "";
2496 } else {
2497 return "Dir "+fMovieTempFolderPath+" should be empty, but could not remove it";
2498 }
2499
2500 }
2501 return "Could not remove "+fMovieTempFolderPath+" because of the following errors :"+error;
2502}
2503
2504
2505
2506bool G4OpenGLQtViewer::hasPendingEvents () {
2507 return ((QApplication*)G4Qt::getInstance ())->hasPendingEvents ();
2508}
2509
2510bool G4OpenGLQtViewer::generateMpegEncoderParameters () {
2511
2512 // save the parameter file
2513 FILE* fp;
2514#if QT_VERSION < 0x040000
2515 fp = fopen (QString(fMovieTempFolderPath+fParameterFileName).ascii(), "w");
2516#else
2517 fp = fopen (QString(fMovieTempFolderPath+fParameterFileName).toStdString().c_str(), "w");
2518#endif
2519
2520 if (fp == NULL) {
2521 setRecordingInfos("Generation of parameter file failed");
2522 return false;
2523 }
2524
2525 fprintf (fp,"# parameter file template with lots of comments to assist you\n");
2526 fprintf (fp,"#\n");
2527 fprintf (fp,"# you can use this as a template, copying it to a separate file then modifying\n");
2528 fprintf (fp,"# the copy\n");
2529 fprintf (fp,"#\n");
2530 fprintf (fp,"#\n");
2531 fprintf (fp,"# any line beginning with '#' is a comment\n");
2532 fprintf (fp,"#\n");
2533 fprintf (fp,"# no line should be longer than 255 characters\n");
2534 fprintf (fp,"#\n");
2535 fprintf (fp,"#\n");
2536 fprintf (fp,"# general format of each line is:\n");
2537 fprintf (fp,"# \n");
2538 fprintf (fp,"#\n");
2539 fprintf (fp,"# lines can generally be in any order\n");
2540 fprintf (fp,"#\n");
2541 fprintf (fp,"# an exception is the option 'INPUT' which must be followed by input\n");
2542 fprintf (fp,"# files in the order in which they must appear, followed by 'END_INPUT'\n");
2543 fprintf (fp,"#\n");
2544 fprintf (fp,"# Also, if you use the `command` method of generating input file names,\n");
2545 fprintf (fp,"# the command will only be executed in the INPUT_DIR if INPUT_DIR preceeds\n");
2546 fprintf (fp,"# the INPUT parameter.\n");
2547 fprintf (fp,"#\n");
2548 fprintf (fp,"# MUST be in UPPER CASE\n");
2549 fprintf (fp,"#\n");
2550 fprintf (fp,"\n");
2551 fprintf (fp,"# Pattern affects speed, quality and compression. See the User's Guide\n");
2552 fprintf (fp,"# for more info.\n");
2553 fprintf (fp,"\n");
2554 fprintf (fp,"PATTERN IBBPBBPBBPBBPBBP\n");
2555#if QT_VERSION < 0x040000
2556 fprintf (fp,"OUTPUT %s\n",getSaveFileName().ascii());
2557#else
2558 fprintf (fp,"OUTPUT %s\n",getSaveFileName().toStdString().c_str());
2559#endif
2560 fprintf (fp,"\n");
2561 fprintf (fp,"# mpeg_encode really only accepts 3 different file formats, but using a\n");
2562 fprintf (fp,"# conversion statement it can effectively handle ANY file format\n");
2563 fprintf (fp,"#\n");
2564 fprintf (fp,"# You must specify the type of the input files. The choices are:\n");
2565 fprintf (fp,"# YUV, PPM, JMOVIE, Y, JPEG, PNM\n");
2566 fprintf (fp,"# (must be upper case)\n");
2567 fprintf (fp,"#\n");
2568 fprintf (fp,"BASE_FILE_FORMAT PPM\n");
2569 fprintf (fp,"\n");
2570 fprintf (fp,"#\n");
2571 fprintf (fp,"# if YUV format (or using parallel version), must provide width and height\n");
2572 fprintf (fp,"# YUV_SIZE widthxheight\n");
2573 fprintf (fp,"# this option is ignored if BASE_FILE_FORMAT is not YUV and you're running\n");
2574 fprintf (fp,"# on just one machine\n");
2575 fprintf (fp,"#\n");
2576 fprintf (fp,"YUV_SIZE 352x240\n");
2577 fprintf (fp,"\n");
2578 fprintf (fp,"# If you are using YUV, there are different supported file formats.\n");
2579 fprintf (fp,"# EYUV or UCB are the same as previous versions of this encoder.\n");
2580 fprintf (fp,"# (All the Y's, then U's then V's, in 4:2:0 subsampling.)\n");
2581 fprintf (fp,"# Other formats, such as Abekas, Phillips, or a general format are\n");
2582 fprintf (fp,"# permissible, the general format is a string of Y's, U's, and V's\n");
2583 fprintf (fp,"# to specify the file order.\n");
2584 fprintf (fp,"\n");
2585 fprintf (fp,"INPUT_FORMAT UCB\n");
2586 fprintf (fp,"\n");
2587 fprintf (fp,"# the conversion statement\n");
2588 fprintf (fp,"#\n");
2589 fprintf (fp,"# Each occurrence of '*' will be replaced by the input file\n");
2590 fprintf (fp,"#\n");
2591 fprintf (fp,"# e.g., if you have a bunch of GIF files, then this might be:\n");
2592 fprintf (fp,"# INPUT_CONVERT giftoppm *\n");
2593 fprintf (fp,"#\n");
2594 fprintf (fp,"# e.g., if you have a bunch of files like a.Y a.U a.V, etc., then:\n");
2595 fprintf (fp,"# INPUT_CONVERT cat *.Y *.U *.V\n");
2596 fprintf (fp,"#\n");
2597 fprintf (fp,"# e.g., if you are grabbing from laser disc you might have something like\n");
2598 fprintf (fp,"# INPUT_CONVERT goto frame *; grabppm\n");
2599 fprintf (fp,"# 'INPUT_CONVERT *' means the files are already in the base file format\n");
2600 fprintf (fp,"#\n");
2601 fprintf (fp,"INPUT_CONVERT * \n");
2602 fprintf (fp,"\n");
2603 fprintf (fp,"# number of frames in a GOP.\n");
2604 fprintf (fp,"#\n");
2605 fprintf (fp,"# since each GOP must have at least one I-frame, the encoder will find the\n");
2606 fprintf (fp,"# the first I-frame after GOP_SIZE frames to start the next GOP\n");
2607 fprintf (fp,"#\n");
2608 fprintf (fp,"# later, will add more flexible GOP signalling\n");
2609 fprintf (fp,"#\n");
2610 fprintf (fp,"GOP_SIZE 16\n");
2611 fprintf (fp,"\n");
2612 fprintf (fp,"# number of slices in a frame\n");
2613 fprintf (fp,"#\n");
2614 fprintf (fp,"# 1 is a good number. another possibility is the number of macroblock rows\n");
2615 fprintf (fp,"# (which is the height divided by 16)\n");
2616 fprintf (fp,"#\n");
2617 fprintf (fp,"SLICES_PER_FRAME 1\n");
2618 fprintf (fp,"\n");
2619 fprintf (fp,"# directory to get all input files from (makes this file easier to read)\n");
2620#if QT_VERSION < 0x040000
2621 fprintf (fp,"INPUT_DIR %s\n",fMovieTempFolderPath.ascii());
2622#else
2623 fprintf (fp,"INPUT_DIR %s\n",fMovieTempFolderPath.toStdString().c_str());
2624#endif
2625 fprintf (fp,"\n");
2626 fprintf (fp,"# There are a bunch of ways to specify the input files.\n");
2627 fprintf (fp,"# from a simple one-per-line listing, to the following \n");
2628 fprintf (fp,"# way of numbering them. See the manual for more information.\n");
2629 fprintf (fp,"INPUT\n");
2630 fprintf (fp,"# '*' is replaced by the numbers 01, 02, 03, 04\n");
2631 fprintf (fp,"# if I instead do [01-11], it would be 01, 02, ..., 09, 10, 11\n");
2632 fprintf (fp,"# if I instead do [1-11], it would be 1, 2, 3, ..., 9, 10, 11\n");
2633 fprintf (fp,"# if I instead do [1-11+3], it would be 1, 4, 7, 10\n");
2634 fprintf (fp,"# the program assumes none of your input files has a name ending in ']'\n");
2635 fprintf (fp,"# if you do, too bad!!!\n");
2636 fprintf (fp,"#\n");
2637 fprintf (fp,"#\n");
2638 fprintf (fp,"Test*.ppm [0-%d]\n",fRecordFrameNumber-1);
2639 fprintf (fp,"# can have more files here if you want...there is no limit on the number\n");
2640 fprintf (fp,"# of files\n");
2641 fprintf (fp,"END_INPUT\n");
2642 fprintf (fp,"\n");
2643 fprintf (fp,"\n");
2644 fprintf (fp,"\n");
2645 fprintf (fp,"# Many of the remaining options have to do with the motion search and qscale\n");
2646 fprintf (fp,"\n");
2647 fprintf (fp,"# FULL or HALF -- must be upper case\n");
2648 fprintf (fp,"# Should be FULL for computer generated images\n");
2649 fprintf (fp,"PIXEL FULL\n");
2650 fprintf (fp,"\n");
2651 fprintf (fp,"# means +/- this many pixels for both P and B frame searches\n");
2652 fprintf (fp,"# specify two numbers if you wish to serc different ranges in the two.\n");
2653 fprintf (fp,"RANGE 10\n");
2654 fprintf (fp,"\n");
2655 fprintf (fp,"# The two search algorithm parameters below mostly affect speed,\n");
2656 fprintf (fp,"# with some affect on compression and almost none on quality.\n");
2657 fprintf (fp,"\n");
2658 fprintf (fp,"# this must be one of {EXHAUSTIVE, SUBSAMPLE, LOGARITHMIC}\n");
2659 fprintf (fp,"PSEARCH_ALG LOGARITHMIC\n");
2660 fprintf (fp,"\n");
2661 fprintf (fp,"# this must be one of {SIMPLE, CROSS2, EXHAUSTIVE}\n");
2662 fprintf (fp,"#\n");
2663 fprintf (fp,"# note that EXHAUSTIVE is really, really, really slow\n");
2664 fprintf (fp,"#\n");
2665 fprintf (fp,"BSEARCH_ALG SIMPLE\n");
2666 fprintf (fp,"\n");
2667 fprintf (fp,"#\n");
2668 fprintf (fp,"# these specify the q-scale for I, P, and B frames\n");
2669 fprintf (fp,"# (values must be between 1 and 31)\n");
2670 fprintf (fp,"# These are the Qscale values for the entire frame in variable bit-rate\n");
2671 fprintf (fp,"# mode, and starting points (but not important) for constant bit rate\n");
2672 fprintf (fp,"#\n");
2673 fprintf (fp,"\n");
2674 fprintf (fp,"# Qscale (Quantization scale) affects quality and compression,\n");
2675 fprintf (fp,"# but has very little effect on speed.\n");
2676 fprintf (fp,"\n");
2677 fprintf (fp,"IQSCALE 4\n");
2678 fprintf (fp,"PQSCALE 5\n");
2679 fprintf (fp,"BQSCALE 12\n");
2680 fprintf (fp,"\n");
2681 fprintf (fp,"# this must be ORIGINAL or DECODED\n");
2682 fprintf (fp,"REFERENCE_FRAME ORIGINAL\n");
2683 fprintf (fp,"\n");
2684 fprintf (fp,"# for parallel parameters see parallel.param in the exmaples subdirectory\n");
2685 fprintf (fp,"\n");
2686 fprintf (fp,"# if you want constant bit-rate mode, specify it as follows (number is bits/sec):\n");
2687 fprintf (fp,"#BIT_RATE 1000000\n");
2688 fprintf (fp,"\n");
2689 fprintf (fp,"# To specify the buffer size (327680 is default, measused in bits, for 16bit words)\n");
2690 fprintf (fp,"BUFFER_SIZE 327680\n");
2691 fprintf (fp,"\n");
2692 fprintf (fp,"# The frame rate is the number of frames/second (legal values:\n");
2693 fprintf (fp,"# 23.976, 24, 25, 29.97, 30, 50 ,59.94, 60\n");
2694 fprintf (fp,"FRAME_RATE 30\n");
2695 fprintf (fp,"\n");
2696 fprintf (fp,"# There are many more options, see the users manual for examples....\n");
2697 fprintf (fp,"# ASPECT_RATIO, USER_DATA, GAMMA, IQTABLE, etc.\n");
2698 fprintf (fp,"\n");
2699 fprintf (fp,"\n");
2700 fclose (fp);
2701
2702 setRecordingInfos("Parameter file "+fParameterFileName+" generated in "+fMovieTempFolderPath);
2703 setRecordingStatus(READY_TO_ENCODE);
2704 return true;
2705}
2706
2707void G4OpenGLQtViewer::encodeVideo()
2708{
2709 if ((getEncoderPath() != "") && (getSaveFileName() != "")) {
2710 setRecordingStatus(ENCODING);
2711
2712#if QT_VERSION < 0x040000
2713 QStringList args = QStringList(fEncoderPath);
2714 args.push_back(fMovieTempFolderPath+fParameterFileName);
2715 fProcess = new QProcess(args);
2716 QObject ::connect(fProcess,SIGNAL(processExited ()),
2717 this,SLOT(processEncodeFinished()));
2718 QObject ::connect(fProcess,SIGNAL(readyReadStdout ()),
2719 this,SLOT(processEncodeStdout()));
2720 fProcess->setCommunication(QProcess::DupStderr);
2721 fProcess->launch("");
2722#else
2723 fProcess = new QProcess();
2724#if QT_VERSION > 0x040100
2725 QObject ::connect(fProcess,SIGNAL(finished ( int,QProcess::ExitStatus)),
2726 this,SLOT(processEncodeFinished()));
2727 QObject ::connect(fProcess,SIGNAL(readyReadStandardOutput ()),
2728 this,SLOT(processEncodeStdout()));
2729#else
2730 QObject ::connect(fProcess,SIGNAL(finished ( int)),
2731 this,SLOT(processEncodeFinished()));
2732 QObject ::connect(fProcess,SIGNAL(readyReadStandardOutput ()),
2733 this,SLOT(processEncodeStdout()));
2734#endif
2735 fProcess->setReadChannelMode(QProcess::MergedChannels);
2736 fProcess->start (fEncoderPath, QStringList(fMovieTempFolderPath+fParameterFileName));
2737#endif
2738 }
2739}
2740
2741
2742// FIXME : does not work on Qt3
2743void G4OpenGLQtViewer::processEncodeStdout()
2744{
2745#if QT_VERSION > 0x040000
2746 QString tmp = fProcess->readAllStandardOutput ().data();
2747 int start = tmp.lastIndexOf("ESTIMATED TIME");
2748 tmp = tmp.mid(start,tmp.indexOf("\n",start)-start);
2749#else
2750 QString tmp = fProcess->readStdout ().data();
2751 int start = tmp.findRev("ESTIMATED TIME");
2752 tmp = tmp.mid(start,tmp.find("\n",start)-start);
2753#endif
2754 setRecordingInfos(tmp);
2755}
2756
2757
2758void G4OpenGLQtViewer::processEncodeFinished()
2759{
2760
2761 QString txt = "";
2762 txt = getProcessErrorMsg();
2763 if (txt == "") {
2764 setRecordingStatus(SUCCESS);
2765 } else {
2766 setRecordingStatus(FAILED);
2767 }
2768 // setRecordingInfos(txt+removeTempFolder());
2769}
2770
2771
2772void G4OpenGLQtViewer::processLookForFinished()
2773 {
2774
2775 QString txt = getProcessErrorMsg();
2776 if (txt != "") {
2777 fEncoderPath = "";
2778 } else {
2779#if QT_VERSION > 0x040000
2780 fEncoderPath = QString(fProcess->readAllStandardOutput ().data()).trimmed();
2781#else
2782 fEncoderPath = QString(fProcess->readStdout ().data()).simplifyWhiteSpace();
2783#endif
2784 // if not found, return "not found"
2785 if (fEncoderPath.contains(" ")) {
2786 fEncoderPath = "";
2787 } else if (!fEncoderPath.contains("mpeg_encode")) {
2788 fEncoderPath = "";
2789 }
2790 setEncoderPath(fEncoderPath);
2791 }
2792 // init temp folder
2793#if QT_VERSION > 0x040000
2794 setTempFolderPath(QDir::temp ().absolutePath ());
2795#else
2796 // Let's have a try
2797 setTempFolderPath("/tmp/");
2798#endif
2799}
2800
2801
2802QString G4OpenGLQtViewer::getProcessErrorMsg()
2803{
2804 QString txt = "";
2805#if QT_VERSION < 0x040000
2806 if (!fProcess->normalExit ()) {
2807 txt = "Exist status "+ fProcess->exitStatus ();
2808 }
2809#else
2810 if (fProcess->exitCode() != 0) {
2811 switch (fProcess->error()) {
2812 case QProcess::FailedToStart:
2813 txt = "The process failed to start. Either the invoked program is missing, or you may have insufficient permissions to invoke the program.\n";
2814 break;
2815 case QProcess::Crashed:
2816 txt = "The process crashed some time after starting successfully.\n";
2817 break;
2818 case QProcess::Timedout:
2819 txt = "The last waitFor...() function timed out. The state of QProcess is unchanged, and you can try calling waitFor...() again.\n";
2820 break;
2821 case QProcess::WriteError:
2822 txt = "An error occurred when attempting to write to the process. For example, the process may not be running, or it may have closed its input channel.\n";
2823 break;
2824 case QProcess::ReadError:
2825 txt = "An error occurred when attempting to read from the process. For example, the process may not be running.\n";
2826 break;
2827 case QProcess::UnknownError:
2828 txt = "An unknown error occurred. This is the default return value of error().\n";
2829 break;
2830 }
2831 }
2832#endif
2833 return txt;
2834}
2835
2836
2837
2838
2839QWidget *G4OpenGLQtViewer::getParentWidget()
2840{
2841 // launch Qt if not
2842 G4Qt* interactorManager = G4Qt::getInstance ();
2843 // G4UImanager* UI =
2844 G4UImanager::GetUIpointer();
2845
2846 bool found = false;
2847
2848 // create window
2849 if (((QApplication*)interactorManager->GetMainInteractor())) {
2850 // look for the main window
2851#if QT_VERSION < 0x040000
2852 // theses lines does nothing exept this one "GLWindow = new QDialog(0..."
2853 // but if I comment them, it doesn't work...
2854 QWidgetList *list = QApplication::allWidgets();
2855 QWidgetListIt it( *list ); // iterate over the widgets
2856 QWidget * widget;
2857 while ( (widget=it.current()) != 0 ) { // for each widget...
2858 ++it;
2859 if ((found== false) && (widget->inherits("QMainWindow"))) {
2860 fGLWindow = new QDialog(0,0,FALSE,Qt::WStyle_Title | Qt::WStyle_SysMenu | Qt::WStyle_MinMax );
2861 found = true;
2862 }
2863 }
2864 delete list; // delete the list, not the widgets
2865#else
2866 foreach (QWidget *widget, QApplication::allWidgets()) {
2867 if ((found== false) && (widget->inherits("QMainWindow"))) {
2868 fGLWindow = new QDialog(widget,Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowMinMaxButtonsHint);
2869 found = true;
2870 }
2871 }
2872#endif
2873
2874 if (found==false) {
2875#ifdef G4DEBUG_VIS_OGL
2876 printf("G4OpenGLQtViewer::CreateMainWindow case Qapp exist, but not found\n");
2877#endif
2878 fGLWindow = new QDialog();
2879 }
2880 } else {
2881#ifdef G4DEBUG_VIS_OGL
2882 printf("G4OpenGLQtViewer::CreateMainWindow case Qapp exist\n");
2883#endif
2884 fGLWindow = new QDialog();
2885#ifdef G4DEBUG_VIS_OGL
2886 printf("G4OpenGLQtViewer::GetParentWidget fGLWindow\n");
2887#endif
2888 }
2889 if (found) {
2890 return fGLWindow;
2891 } else {
2892 return NULL;
2893 }
2894}
2895
2896/*
2897
2898void MultiLayer::exportToSVG(const QString& fname)
2899{
2900 QPicture picture;
2901 QPainter p(&picture);
2902 for (int i=0;i<(int)graphsList->count();i++)
2903 {
2904 Graph *gr=(Graph *)graphsList->at(i);
2905 Plot *myPlot= (Plot *)gr->plotWidget();
2906
2907 QPoint pos=gr->pos();
2908
2909 int width=int(myPlot->frameGeometry().width());
2910 int height=int(myPlot->frameGeometry().height());
2911
2912 myPlot->print(&p, QRect(pos,QSize(width,height)));
2913 }
2914
2915 p.end();
2916 picture.save(fname, "svg");
2917}
2918*/
2919#endif
Note: See TracBrowser for help on using the repository browser.