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

Last change on this file since 1034 was 1029, checked in by garnier, 17 years ago

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