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

Last change on this file since 923 was 917, checked in by garnier, 17 years ago

renommage
  • Property svn:mime-type set to text/cpp
File size: 80.3 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.35 2009/02/04 16:48:41 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#if QT_VERSION < 0x040000
1278 QStrList listFormat=QImageIO::outputFormats();
1279 char *tmp=listFormat.first();
1280 while (tmp!=0) {
1281 filters += QString(tmp) + ";;";
1282 tmp=listFormat.next();
1283 }
1284#else
1285 QList<QByteArray> formats = QImageWriter::supportedImageFormats ();
1286 for (int i = 0; i < formats.size(); ++i) {
1287 filters +=formats.at(i) + ";;";
1288 }
1289#endif
1290 filters += "eps;;";
1291 filters += "ps;;";
1292 filters += "pdf";
1293 QString* selectedFormat = new QString();
1294#if QT_VERSION < 0x040000
1295 fPrintFilename = QFileDialog::getSaveFileName ( ".",
1296 filters,
1297 GLWindow,
1298 "Save file dialog",
1299 tr("Save as ..."),
1300 selectedFormat ).ascii();
1301#else
1302 fPrintFilename = QFileDialog::getSaveFileName ( GLWindow,
1303 tr("Save as ..."),
1304 ".",
1305 filters,
1306 selectedFormat ).toStdString().c_str();
1307#endif
1308 // bmp jpg jpeg png ppm xbm xpm
1309 if (fPrintFilename.empty()) {
1310 return;
1311 }
1312#if QT_VERSION < 0x040000
1313 fPrintFilename += "." + selectedFormat->ascii();
1314 QString format = selectedFormat->lower();
1315#else
1316 fPrintFilename += "." + selectedFormat->toStdString();
1317 QString format = selectedFormat->toLower();
1318#endif
1319 G4OpenGLQtExportDialog* exportDialog= new G4OpenGLQtExportDialog(GLWindow,format,fWindow->height(),fWindow->width());
1320 if( exportDialog->exec()) {
1321
1322 QImage image;
1323 bool res = false;
1324 if ((exportDialog->getWidth() !=fWindow->width()) ||
1325 (exportDialog->getHeight() !=fWindow->height())) {
1326 if (format != QString("eps")) {
1327 G4cerr << "Export->Change Size : This function is not implemented, to export in another size, please resize your frame to what you need" << G4endl;
1328
1329 // rescaleImage(exportDialog->getWidth(),exportDialog->getHeight());// re-scale image
1330 // QGLWidget* glResized = fWindow;
1331
1332 // FIXME :
1333 // L.Garnier : I've try to implement change size function, but the problem is
1334 // the renderPixmap function call the QGLWidget to resize and it doesn't draw
1335 // the content of this widget... It only draw the background.
1336
1337 // fWindow->renderPixmap (exportDialog->getWidth()*2,exportDialog->getHeight()*2,true );
1338
1339 // QPixmap pixmap = fWindow->renderPixmap ();
1340
1341 // image = pixmap->toImage();
1342 // glResized->resize(exportDialog->getWidth()*2,exportDialog->getHeight()*2);
1343 // image = glResized->grabFrameBuffer();
1344 }
1345 } else {
1346 image = fWindow->grabFrameBuffer();
1347 }
1348 if (format == QString("eps")) {
1349 if (exportDialog->getVectorEPS()) {
1350 printVectoredEPS();
1351 res = true;
1352 } else {
1353 res = generateEPS(fPrintFilename.c_str(),exportDialog->getNbColor(),(unsigned int)image.width(),(unsigned int)image.height());
1354 }
1355 } else if ((format == "ps") || (format == "pdf")) {
1356 res = generatePS_PDF(fPrintFilename,exportDialog->getNbColor(),image);
1357 } else if ((format == "tif") ||
1358 (format == "tiff") ||
1359 (format == "jpg") ||
1360 (format == "jpeg") ||
1361 (format == "png") ||
1362 (format == "pbm") ||
1363 (format == "pgm") ||
1364 (format == "ppm") ||
1365 (format == "bmp") ||
1366 (format == "xbm") ||
1367 (format == "xpm")) {
1368#if QT_VERSION < 0x040000
1369 res = image.save(QString(fPrintFilename.c_str()),selectedFormat->ascii(),exportDialog->getSliderValue());
1370#else
1371 res = image.save(QString(fPrintFilename.c_str()),0,exportDialog->getSliderValue());
1372#endif
1373 } else {
1374 G4cerr << "This version of G4UI Could not generate the selected format" << G4endl;
1375 }
1376 if (res == false) {
1377 G4cerr << "Error while saving file... "<<fPrintFilename.c_str()<< G4endl;
1378 } else {
1379 G4cout << "File "<<fPrintFilename.c_str()<<" has been saved " << G4endl;
1380 }
1381
1382 } else { // cancel selected
1383 return;
1384 }
1385
1386}
1387
1388
1389void G4OpenGLQtViewer::actionMovieParameters() {
1390 showMovieParametersDialog();
1391}
1392
1393
1394void G4OpenGLQtViewer::showMovieParametersDialog() {
1395 if (!fMovieParametersDialog) {
1396 fMovieParametersDialog= new G4OpenGLQtMovieDialog(this,GLWindow);
1397 displayRecordingStatus();
1398 fMovieParametersDialog->checkEncoderSwParameters();
1399 fMovieParametersDialog->checkSaveFileNameParameters();
1400 fMovieParametersDialog->checkTempFolderParameters();
1401 if (getEncoderPath() == "") {
1402 setRecordingInfos("mpeg_encode is needed to encode in video format. It is available here: http://bmrc.berkeley.edu/frame/research/mpeg/");
1403 }
1404 }
1405 fMovieParametersDialog->show();
1406}
1407
1408
1409/*
1410// 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
1411
1412void Graph::exportToSVG(const QString& fname)
1413{
1414 // enable workaround for Qt3 misalignments
1415 QwtPainter::setSVGMode(true);
1416 QPicture picture;
1417 QPainter p(&picture);
1418 d_plot->print(&p, d_plot->rect());
1419 p.end();
1420
1421 picture.save(fname, "svg");
1422}
1423*/
1424
1425
1426
1427void G4OpenGLQtViewer::FinishView()
1428{
1429 glFlush ();
1430 fWindow->swapBuffers ();
1431}
1432
1433/**
1434 Save the current mouse press point
1435 @param p mouse click point
1436*/
1437void G4OpenGLQtViewer::G4MousePressEvent(QMouseEvent *event)
1438{
1439#if QT_VERSION < 0x040000
1440 if ((event->button() & Qt::LeftButton)
1441 && !((event->state() & Qt::ShiftButton)
1442 || (event->state() & Qt::ControlButton)
1443 || (event->state() & Qt::AltButton)
1444 || (event->state() & Qt::MetaButton))) {
1445#else
1446 if ((event->buttons() & Qt::LeftButton)
1447 && !((event->modifiers() & Qt::ShiftModifier)
1448 || (event->modifiers() & Qt::ControlModifier)
1449 || (event->modifiers() & Qt::AltModifier)
1450 || (event->modifiers() & Qt::MetaModifier))) {
1451#endif
1452 fWindow->setMouseTracking(true);
1453 fAutoMove = false; // stop automove
1454 fLastPos1 = event->pos();
1455 fLastPos2 = fLastPos1;
1456 fLastPos3 = fLastPos2;
1457 fLastEventTime->start();
1458 if (fMouseAction == STYLE3){ // pick
1459 Pick(event->pos().x(),event->pos().y());
1460 }
1461 }
1462}
1463
1464/**
1465*/
1466void G4OpenGLQtViewer::G4MouseReleaseEvent()
1467{
1468 fSpinningDelay = fLastEventTime->elapsed();
1469 QPoint delta = (fLastPos3-fLastPos1);
1470 if ((delta.x() == 0) && (delta.y() == 0)) {
1471 return;
1472 }
1473 if (fSpinningDelay < fLaunchSpinDelay ) {
1474 fAutoMove = true;
1475 QTime lastMoveTime;
1476 lastMoveTime.start();
1477 // try to addapt speed move/rotate looking to drawing speed
1478 int cycles = 4;
1479 while (fAutoMove) {
1480 // if ( lastMoveTime.elapsed() > (fSpinningDelay / (cycles/2))) {
1481 if (fMouseAction == STYLE1) { // rotate
1482 rotateQtScene(((float)delta.x())/cycles,((float)delta.y())/cycles);
1483 } else if (fMouseAction == STYLE2) { // move
1484 moveScene(-((float)delta.x())/cycles,-((float)delta.y())/cycles,0,true);
1485 }
1486 lastMoveTime.start();
1487 cycles = 1 ;
1488 ((QApplication*)G4Qt::getInstance ())->processEvents();
1489 cycles ++ ;
1490 }
1491 }
1492 fWindow->setMouseTracking(false);
1493
1494}
1495
1496
1497void G4OpenGLQtViewer::G4MouseDoubleClickEvent()
1498{
1499 fWindow->setMouseTracking(true);
1500}
1501
1502
1503/**
1504 @param pos_x mouse x position
1505 @param pos_y mouse y position
1506 @param mButtons mouse button active
1507 @param mAutoMove true: apply this move till another evnt came, false :one time move
1508*/
1509
1510void G4OpenGLQtViewer::G4MouseMoveEvent(QMouseEvent *event)
1511{
1512
1513#if QT_VERSION < 0x040000
1514 Qt::ButtonState mButtons = event->state();
1515#else
1516 Qt::MouseButtons mButtons = event->buttons();
1517#endif
1518
1519 if (fAutoMove) {
1520 return;
1521 }
1522
1523 fLastPos3 = fLastPos2;
1524 fLastPos2 = fLastPos1;
1525 fLastPos1 = QPoint(event->x(), event->y());
1526
1527 int deltaX = fLastPos2.x()-fLastPos1.x();
1528 int deltaY = fLastPos2.y()-fLastPos1.y();
1529
1530 if (fMouseAction == STYLE1) { // rotate
1531 if (mButtons & Qt::LeftButton) {
1532 rotateQtScene(deltaX,deltaY);
1533 }
1534 } else if (fMouseAction == STYLE2) { // move
1535 if (mButtons & Qt::LeftButton) {
1536 moveScene(-deltaX,-deltaY,0,true);
1537 }
1538 }
1539
1540 fLastEventTime->start();
1541}
1542
1543
1544/**
1545 Move the scene of dx, dy, dz values.
1546 @param dx delta mouse x position
1547 @param dy delta mouse y position
1548 @param mouseMove : true if even comes from a mouse move, false if even comes from key action
1549*/
1550
1551void G4OpenGLQtViewer::moveScene(float dx,float dy, float dz,bool mouseMove)
1552{
1553 if (fHoldMoveEvent)
1554 return;
1555 fHoldMoveEvent = true;
1556
1557 G4double coefTrans = 0;
1558 GLdouble coefDepth = 0;
1559 if(mouseMove) {
1560 coefTrans = ((G4double)getSceneNearWidth())/((G4double)fWinSize_x);
1561 if (fWinSize_y <fWinSize_x) {
1562 coefTrans = ((G4double)getSceneNearWidth())/((G4double)fWinSize_y);
1563 }
1564 } else {
1565 coefTrans = getSceneNearWidth()*fDeltaSceneTranslation;
1566 coefDepth = getSceneDepth()*fDeltaDepth;
1567 }
1568 fVP.IncrementPan(-dx*coefTrans,dy*coefTrans,dz*coefDepth);
1569 emit moveX(-dx*coefTrans);
1570 emit moveY(dy*coefTrans);
1571 emit moveZ(dz*coefTrans);
1572
1573 updateQWidget();
1574 if (fAutoMove)
1575 ((QApplication*)G4Qt::getInstance ())->processEvents();
1576
1577 fHoldMoveEvent = false;
1578}
1579
1580
1581/**
1582 @param dx delta mouse x position
1583 @param dy delta mouse y position
1584*/
1585
1586void G4OpenGLQtViewer::rotateQtScene(float dx, float dy)
1587{
1588 if (fHoldRotateEvent)
1589 return;
1590 fHoldRotateEvent = true;
1591
1592 if( dx != 0) {
1593 rotateScene(dx,0,fDeltaRotation);
1594 emit rotateTheta(dx);
1595 }
1596 if( dy != 0) {
1597 rotateScene(0,dy,fDeltaRotation);
1598 emit rotatePhi(dy);
1599 }
1600 updateQWidget();
1601
1602 fHoldRotateEvent = false;
1603}
1604
1605/**
1606 @param dx delta mouse x position
1607 @param dy delta mouse y position
1608*/
1609
1610void G4OpenGLQtViewer::rotateQtCamera(float dx, float dy)
1611{
1612 if (fHoldRotateEvent)
1613 return;
1614 fHoldRotateEvent = true;
1615
1616 rotateScene(dx,dy,fDeltaRotation);
1617 emit rotateTheta(dx);
1618 emit rotatePhi(dy);
1619 updateQWidget();
1620
1621 fHoldRotateEvent = false;
1622}
1623
1624
1625
1626
1627/** This is the benning of a rescale function. It does nothing for the moment
1628 @param aWidth : new width
1629 @param aHeight : new height
1630*/
1631void G4OpenGLQtViewer::rescaleImage(
1632 int aWidth
1633,int aHeight
1634){
1635 // GLfloat* feedback_buffer;
1636 // GLint returned;
1637 // FILE* file;
1638
1639// feedback_buffer = new GLfloat[size];
1640// glFeedbackBuffer (size, GL_3D_COLOR, feedback_buffer);
1641// glRenderMode (GL_FEEDBACK);
1642
1643// DrawView();
1644// returned = glRenderMode (GL_RENDER);
1645
1646}
1647
1648
1649
1650/**
1651 Generate Postscript or PDF form image
1652 @param aFilename : name of file
1653 @param aInColor : numbers of colors : 1->BW 2->RGB
1654 @param aImage : Image to print
1655*/
1656bool G4OpenGLQtViewer::generatePS_PDF (
1657 const std::string aFilename
1658,int aInColor
1659,QImage aImage
1660)
1661{
1662
1663#if QT_VERSION < 0x040000
1664#ifdef Q_WS_MAC || Q_WS_X11
1665 QPrinter printer;
1666 // printer.setPageSize(pageSize);
1667 if (aInColor == 1) {
1668 printer.setColorMode(QPrinter::GrayScale);
1669 } else {
1670 printer.setColorMode(QPrinter::Color);
1671 }
1672
1673 /* FIXME : I don't know which format it will save...
1674 if (aFilename.endsWith(".ps")) {
1675 printer.setOutputFormat(QPrinter::PostScriptFormat);
1676 } else {
1677 printer.setOutputFormat(QPrinter::PdfFormat);
1678 }
1679 */
1680 printer.setOutputFileName(aFilename);
1681 // printer.setFullPage ( true);
1682 QPainter paint(&printer);
1683 paint.drawImage (0,0,aImage );
1684 paint.end();
1685#else
1686 G4cerr << "This fonction is only supported on Mac OsX or X11 with Qt3. Full platform supported with Qt4" << G4endl;
1687#endif
1688#else
1689 QPrinter printer;
1690 // printer.setPageSize(pageSize);
1691
1692 // FIXME : L. Garnier 4/12/07
1693 // This is not working, it does nothing. Image is staying in color mode
1694 // So I have desactivate the B/W button in GUI
1695 if ((!aImage.isGrayscale ()) &&(aInColor ==1 )) {
1696#if QT_VERSION < 0x040000
1697 aImage = aImage.convertDepth(1,Qt::MonoOnly);
1698#else
1699 aImage = aImage.convertToFormat ( aImage.format(), Qt::MonoOnly);
1700#endif
1701 }
1702
1703
1704 if (aFilename.substr(aFilename.size()-3) == ".ps") {
1705#if QT_VERSION > 0x040200
1706 printer.setOutputFormat(QPrinter::PostScriptFormat);
1707#endif
1708 } else {
1709#if QT_VERSION > 0x040100
1710 printer.setOutputFormat(QPrinter::PdfFormat);
1711#endif
1712 }
1713#if QT_VERSION > 0x040100
1714 printer.setOutputFileName(QString(aFilename.c_str()));
1715#endif
1716 // printer.setFullPage ( true);
1717 QPainter paint(&printer);
1718 paint.drawImage (0,0,aImage);
1719 paint.end();
1720#endif
1721 return true;
1722}
1723
1724
1725void G4OpenGLQtViewer::G4wheelEvent (QWheelEvent * event)
1726{
1727 fVP.SetZoomFactor(fVP.GetZoomFactor()+(fVP.GetZoomFactor()*(event->delta())/1200));
1728 updateQWidget();
1729}
1730
1731
1732void G4OpenGLQtViewer::G4keyPressEvent (QKeyEvent * event)
1733{
1734 if (fHoldKeyEvent)
1735 return;
1736
1737 fHoldKeyEvent = true;
1738
1739#if QT_VERSION < 0x040000
1740 if ((event->key() == Qt::Key_Down) && (event->state() & Qt::AltButton )) { // go backward
1741#else
1742 if ((event->key() == Qt::Key_Down) && (event->modifiers() & Qt::AltModifier )) { // go backward
1743#endif
1744
1745 moveScene(0,0,1,false);
1746 }
1747#if QT_VERSION < 0x040000
1748 else if ((event->key() == Qt::Key_Up) && (event->state() & Qt::AltButton)) { // go forward
1749#else
1750 else if ((event->key() == Qt::Key_Up) && (event->modifiers() & Qt::AltModifier)) { // go forward
1751#endif
1752 moveScene(0,0,-1,false);
1753 }
1754#if QT_VERSION < 0x040000
1755 if ((event->key() == Qt::Key_Down) && (event->state() & Qt::ShiftButton)) { // rotate phi
1756#else
1757 if ((event->key() == Qt::Key_Down) && (event->modifiers() & Qt::ShiftModifier)) { // rotate phi
1758#endif
1759 rotateQtCamera(0,-1);
1760 }
1761#if QT_VERSION < 0x040000
1762 else if ((event->key() == Qt::Key_Up) && (event->state() & Qt::ShiftButton)) { // rotate phi
1763#else
1764 else if ((event->key() == Qt::Key_Up) && (event->modifiers() & Qt::ShiftModifier)) { // rotate phi
1765#endif
1766 rotateQtCamera(0,1);
1767 }
1768#if QT_VERSION < 0x040000
1769 if ((event->key() == Qt::Key_Left) && (event->state() & Qt::ShiftButton)) { // rotate theta
1770#else
1771 if ((event->key() == Qt::Key_Left) && (event->modifiers() & Qt::ShiftModifier)) { // rotate theta
1772#endif
1773 rotateQtCamera(1,0);
1774 }
1775#if QT_VERSION < 0x040000
1776 else if ((event->key() == Qt::Key_Right) && (event->state() & Qt::ShiftButton)) { // rotate theta
1777#else
1778 else if ((event->key() == Qt::Key_Right) && (event->modifiers() & Qt::ShiftModifier)) { // rotate theta
1779#endif
1780 rotateQtCamera(-1,0);
1781 }
1782
1783#if QT_VERSION < 0x040000
1784 if ((event->state() & Qt::AltButton)) {
1785#else
1786 if ((event->modifiers() & Qt::AltModifier)) {
1787#endif
1788 if (event->key() == Qt::Key_Plus) {
1789 fDeltaRotation = fDeltaRotation/0.7;
1790 }
1791 else if (event->key() == Qt::Key_Minus) {
1792 fDeltaRotation = fDeltaRotation*0.7;
1793 }
1794 } else {
1795 if (event->key() == Qt::Key_Plus) {
1796 fVP.SetZoomFactor(fVP.GetZoomFactor()*(1+fDeltaZoom));
1797 updateQWidget();
1798 }
1799 else if (event->key() == Qt::Key_Minus) {
1800 fVP.SetZoomFactor(fVP.GetZoomFactor()*(1-fDeltaZoom));
1801 updateQWidget();
1802 }
1803 }
1804
1805
1806 if (event->key() == Qt::Key_Escape) { // escaped from full screen
1807#if QT_VERSION >= 0x030200
1808 toggleFullScreen(false);
1809#endif
1810 }
1811 // several case here : If return is pressed, in every case -> display the movie parameters dialog
1812 // If one parameter is wrong -> put it in red (only save filenam could be wrong..)
1813 // If encoder not found-> does nothing.Only display a message in status box
1814 // If all ok-> generate parameter file
1815 // If ok -> put encoder button enabled
1816
1817 if ((event->key() == Qt::Key_Return) || (event->key() == Qt::Key_Enter)){ // end of video
1818 stopVideo();
1819 }
1820 if (event->key() == Qt::Key_Space){ // start/pause of video
1821 startPauseVideo();
1822 }
1823
1824 // with no modifiers
1825#if QT_VERSION < 0x040000
1826 if (event->state() == Qt::NoButton) {
1827#else
1828 if ((event->modifiers() == Qt::NoModifier) || (event->modifiers() == Qt::KeypadModifier )) {
1829#endif
1830 if (event->key() == Qt::Key_Down) { // go down
1831 moveScene(0,1,0,false);
1832 }
1833 else if (event->key() == Qt::Key_Up) { // go up
1834 moveScene(0,-1,0,false);
1835 }
1836 if (event->key() == Qt::Key_Left) { // go left
1837 moveScene(-1,0,0,false);
1838 }
1839 else if (event->key() == Qt::Key_Right) { // go right
1840 moveScene(1,0,0,false);
1841 }
1842 }
1843 fHoldKeyEvent = false;
1844}
1845
1846
1847/** Stop the video. Check all parameters and enable encoder button if all is ok.
1848*/
1849void G4OpenGLQtViewer::stopVideo() {
1850
1851 // if encoder parameter is wrong, display parameters dialog and return
1852 if (!fMovieParametersDialog) {
1853 showMovieParametersDialog();
1854 }
1855 setRecordingStatus(STOP);
1856
1857 if (fRecordFrameNumber >0) {
1858 // check parameters if they were modified (Re APPLY them...)
1859 if (!(fMovieParametersDialog->checkEncoderSwParameters())) {
1860 setRecordingStatus(BAD_ENCODER);
1861 } else if (!(fMovieParametersDialog->checkSaveFileNameParameters())) {
1862 setRecordingStatus(BAD_OUTPUT);
1863 }
1864 } else {
1865 resetRecording();
1866 setRecordingInfos("No frame to encode.");
1867 }
1868}
1869
1870/** Stop the video. Check all parameters and enable encoder button if all is ok.
1871*/
1872void G4OpenGLQtViewer::saveVideo() {
1873
1874 // if encoder parameter is wrong, display parameters dialog and return
1875 if (!fMovieParametersDialog) {
1876 showMovieParametersDialog();
1877 }
1878
1879 fMovieParametersDialog->checkEncoderSwParameters();
1880 fMovieParametersDialog->checkSaveFileNameParameters();
1881
1882 if (fRecordingStep == STOP) {
1883 setRecordingStatus(SAVE);
1884 generateMpegEncoderParameters();
1885 encodeVideo();
1886 }
1887}
1888
1889
1890/** Start/Pause the video..
1891*/
1892void G4OpenGLQtViewer::startPauseVideo() {
1893
1894 // first time, if temp parameter is wrong, display parameters dialog and return
1895
1896 if (( fRecordingStep == WAIT)) {
1897 if ( fRecordFrameNumber == 0) {
1898 if (getTempFolderPath() == "") { // BAD_OUTPUT
1899 showMovieParametersDialog();
1900 setRecordingInfos("You should specified the temp folder in order to make movie");
1901 return;
1902 } else {
1903 // remove temp folder if it was create
1904 QString tmp = removeTempFolder();
1905 if (tmp !="") {
1906 setRecordingInfos(tmp);
1907 return;
1908 }
1909 tmp = createTempFolder();
1910 if (tmp != "") {
1911 setRecordingInfos("Can't create temp folder."+tmp);
1912 return;
1913 }
1914 }
1915 }
1916 }
1917 if ((fRecordingStep == WAIT)) {
1918 setRecordingStatus(START);
1919 } else if (fRecordingStep == START) {
1920 setRecordingStatus(PAUSE);
1921 } else if (fRecordingStep == PAUSE) {
1922 setRecordingStatus(CONTINUE);
1923 } else if (fRecordingStep == CONTINUE) {
1924 setRecordingStatus(PAUSE);
1925 }
1926}
1927
1928void G4OpenGLQtViewer::setRecordingStatus(RECORDING_STEP step) {
1929
1930 fRecordingStep = step;
1931 displayRecordingStatus();
1932}
1933
1934
1935void G4OpenGLQtViewer::displayRecordingStatus() {
1936
1937 QString txtStatus = "";
1938 if (fRecordingStep == WAIT) {
1939 txtStatus = "Waiting to start...";
1940 fRecordFrameNumber = 0; // reset the frame number
1941 } else if (fRecordingStep == START) {
1942 txtStatus = "Start Recording...";
1943 } else if (fRecordingStep == PAUSE) {
1944 txtStatus = "Pause Recording...";
1945 } else if (fRecordingStep == CONTINUE) {
1946 txtStatus = "Continue Recording...";
1947 } else if (fRecordingStep == STOP) {
1948 txtStatus = "Stop Recording...";
1949 } else if (fRecordingStep == READY_TO_ENCODE) {
1950 txtStatus = "Ready to Encode...";
1951 } else if (fRecordingStep == ENCODING) {
1952 txtStatus = "Encoding...";
1953 } else if (fRecordingStep == FAILED) {
1954 txtStatus = "Failed to encode...";
1955 } else if ((fRecordingStep == BAD_ENCODER)
1956 || (fRecordingStep == BAD_OUTPUT)
1957 || (fRecordingStep == BAD_TMP)) {
1958 txtStatus = "Correct above errors first";
1959 } else if (fRecordingStep == SUCCESS) {
1960 txtStatus = "File encoded successfully";
1961 } else {
1962 }
1963
1964 if (fMovieParametersDialog) {
1965 fMovieParametersDialog->setRecordingStatus(txtStatus);
1966 } else {
1967#if QT_VERSION < 0x040000
1968 G4cout << txtStatus.ascii() << G4endl;
1969#else
1970 G4cout << txtStatus.toStdString().c_str() << G4endl;
1971#endif
1972 }
1973 setRecordingInfos("");
1974}
1975
1976
1977void G4OpenGLQtViewer::setRecordingInfos(QString txt) {
1978 if (fMovieParametersDialog) {
1979 fMovieParametersDialog->setRecordingInfos(txt);
1980 } else {
1981#if QT_VERSION < 0x040000
1982 G4cout << txt.ascii() << G4endl;
1983#else
1984 G4cout << txt.toStdString().c_str() << G4endl;
1985#endif
1986 }
1987}
1988
1989/** Init the movie parameters. Temp dir and encoder path
1990*/
1991void G4OpenGLQtViewer::initMovieParameters() {
1992 //init encoder
1993
1994 //look for encoderPath
1995 fProcess = new QProcess();
1996
1997#if QT_VERSION < 0x040000
1998 QObject ::connect(fProcess,SIGNAL(processExited ()),
1999 this,SLOT(processLookForFinished()));
2000 fProcess->setCommunication(QProcess::DupStderr);
2001 fProcess->setArguments(QStringList("which mpeg_encode"));
2002 fProcess->start();
2003#else
2004 QObject ::connect(fProcess,SIGNAL(finished ( int)),
2005 this,SLOT(processLookForFinished()));
2006 fProcess->setReadChannelMode(QProcess::MergedChannels);
2007 fProcess->start ("which mpeg_encode");
2008#endif
2009
2010}
2011
2012/** @return encoder path or "" if it does not exist
2013 */
2014QString G4OpenGLQtViewer::getEncoderPath() {
2015 return fEncoderPath;
2016}
2017
2018
2019/**
2020 * set the new encoder path
2021 * @return "" if correct. The error otherwise
2022*/
2023QString G4OpenGLQtViewer::setEncoderPath(QString path) {
2024 if (path == "") {
2025 return "File does not exist";
2026 }
2027
2028#if QT_VERSION < 0x040000
2029 path = QDir::cleanDirPath(path);
2030#else
2031 path = QDir::cleanPath(path);
2032#endif
2033 QFileInfo *f = new QFileInfo(path);
2034 if (!f->exists()) {
2035 return "File does not exist";
2036 } else if (f->isDir()) {
2037 return "This is a directory";
2038 } else if (!f->isExecutable()) {
2039 return "File exist but is not executable";
2040 } else if (!f->isFile()) {
2041 return "This is not a file";
2042 }
2043 fEncoderPath = path;
2044
2045 if ((fRecordingStep == BAD_ENCODER)) {
2046 setRecordingStatus(STOP);
2047 }
2048 return "";
2049}
2050
2051
2052bool G4OpenGLQtViewer::isRecording(){
2053 if ((fRecordingStep == START) || (fRecordingStep == CONTINUE)) {
2054 return true;
2055 }
2056 return false;
2057}
2058
2059bool G4OpenGLQtViewer::isPaused(){
2060 if (fRecordingStep == PAUSE) {
2061 return true;
2062 }
2063 return false;
2064}
2065
2066bool G4OpenGLQtViewer::isEncoding(){
2067 if (fRecordingStep == ENCODING) {
2068 return true;
2069 }
2070 return false;
2071}
2072
2073bool G4OpenGLQtViewer::isWaiting(){
2074 if (fRecordingStep == WAIT) {
2075 return true;
2076 }
2077 return false;
2078}
2079
2080bool G4OpenGLQtViewer::isStopped(){
2081 if (fRecordingStep == STOP) {
2082 return true;
2083 }
2084 return false;
2085}
2086
2087bool G4OpenGLQtViewer::isFailed(){
2088 if (fRecordingStep == FAILED) {
2089 return true;
2090 }
2091 return false;
2092}
2093
2094bool G4OpenGLQtViewer::isSuccess(){
2095 if (fRecordingStep == SUCCESS) {
2096 return true;
2097 }
2098 return false;
2099}
2100
2101bool G4OpenGLQtViewer::isBadEncoder(){
2102 if (fRecordingStep == BAD_ENCODER) {
2103 return true;
2104 }
2105 return false;
2106}
2107bool G4OpenGLQtViewer::isBadTmp(){
2108 if (fRecordingStep == BAD_TMP) {
2109 return true;
2110 }
2111 return false;
2112}
2113bool G4OpenGLQtViewer::isBadOutput(){
2114 if (fRecordingStep == BAD_OUTPUT) {
2115 return true;
2116 }
2117 return false;
2118}
2119
2120void G4OpenGLQtViewer::setBadEncoder(){
2121 fRecordingStep = BAD_ENCODER;
2122 displayRecordingStatus();
2123}
2124void G4OpenGLQtViewer::setBadTmp(){
2125 fRecordingStep = BAD_TMP;
2126 displayRecordingStatus();
2127}
2128void G4OpenGLQtViewer::setBadOutput(){
2129 fRecordingStep = BAD_OUTPUT;
2130 displayRecordingStatus();
2131}
2132
2133void G4OpenGLQtViewer::setWaiting(){
2134 fRecordingStep = WAIT;
2135 displayRecordingStatus();
2136}
2137
2138
2139bool G4OpenGLQtViewer::isReadyToEncode(){
2140 if (fRecordingStep == READY_TO_ENCODE) {
2141 return true;
2142 }
2143 return false;
2144}
2145
2146void G4OpenGLQtViewer::resetRecording() {
2147 setRecordingStatus(WAIT);
2148}
2149
2150/**
2151 * set the temp folder path
2152 * @return "" if correct. The error otherwise
2153*/
2154QString G4OpenGLQtViewer::setTempFolderPath(QString path) {
2155
2156 if (path == "") {
2157 return "Path does not exist";
2158 }
2159#if QT_VERSION < 0x040000
2160 path = QDir::cleanDirPath(path);
2161#else
2162 path = QDir::cleanPath(path);
2163#endif
2164 QFileInfo *d = new QFileInfo(path);
2165 if (!d->exists()) {
2166 return "Path does not exist";
2167 } else if (!d->isDir()) {
2168 return "This is not a directory";
2169 } else if (!d->isReadable()) {
2170 return path +" is read protected";
2171 } else if (!d->isWritable()) {
2172 return path +" is write protected";
2173 }
2174
2175 if ((fRecordingStep == BAD_TMP)) {
2176 setRecordingStatus(WAIT);
2177 }
2178 fTempFolderPath = path;
2179 return "";
2180}
2181
2182/** @return the temp folder path or "" if it does not exist
2183 */
2184QString G4OpenGLQtViewer::getTempFolderPath() {
2185 return fTempFolderPath;
2186}
2187
2188/**
2189 * set the save file name path
2190 * @return "" if correct. The error otherwise
2191*/
2192QString G4OpenGLQtViewer::setSaveFileName(QString path) {
2193
2194 if (path == "") {
2195 return "Path does not exist";
2196 }
2197
2198 QFileInfo *file = new QFileInfo(path);
2199 QDir dir = file->dir();
2200#if QT_VERSION < 0x040000
2201 path = QDir::cleanDirPath(path);
2202#else
2203 path = QDir::cleanPath(path);
2204#endif
2205 if (file->exists()) {
2206 return "File already exist, please choose a new one";
2207 } else if (!dir.exists()) {
2208 return "Dir does not exist";
2209 } else if (!dir.isReadable()) {
2210 return path +" is read protected";
2211 }
2212
2213 if ((fRecordingStep == BAD_OUTPUT)) {
2214 setRecordingStatus(STOP);
2215 }
2216 fSaveFileName = path;
2217 return "";
2218}
2219
2220/** @return the save file path
2221 */
2222QString G4OpenGLQtViewer::getSaveFileName() {
2223 return fSaveFileName ;
2224}
2225
2226/** Create a Qt_temp folder in the temp folder given
2227* The temp folder will be like this /tmp/QtMovie_12-02-2008_12_12_58/
2228* @return "" if success. Error message if not.
2229*/
2230QString G4OpenGLQtViewer::createTempFolder() {
2231 fMovieTempFolderPath = "";
2232 //check
2233 QString tmp = setTempFolderPath(fTempFolderPath);
2234 if (tmp != "") {
2235 return tmp;
2236 }
2237#if QT_VERSION < 0x040000
2238 QString sep = QChar(QDir::separator());
2239#else
2240 QString sep = QString(QDir::separator());
2241#endif
2242 QString path = sep+"QtMovie_"+QDateTime::currentDateTime ().toString("dd-MM-yyyy_hh-mm-ss")+sep;
2243#if QT_VERSION < 0x040000
2244 QDir *d = new QDir(QDir::cleanDirPath(fTempFolderPath));
2245#else
2246 QDir *d = new QDir(QDir::cleanPath(fTempFolderPath));
2247#endif
2248 // check if it is already present
2249 if (d->exists(path)) {
2250 return "Folder "+path+" already exists.Please remove it first";
2251 }
2252 if (d->mkdir(fTempFolderPath+path)) {
2253 fMovieTempFolderPath = fTempFolderPath+path;
2254 return "";
2255 } else {
2256 return "Can't create "+fTempFolderPath+path;
2257 }
2258 return "-";
2259}
2260
2261/** Remove the Qt_temp folder in the temp folder
2262*/
2263QString G4OpenGLQtViewer::removeTempFolder() {
2264 // remove files in Qt_temp folder
2265 if (fMovieTempFolderPath == "") {
2266 return "";
2267 }
2268#if QT_VERSION < 0x040000
2269 QDir *d = new QDir(QDir::cleanDirPath(fMovieTempFolderPath));
2270#else
2271 QDir *d = new QDir(QDir::cleanPath(fMovieTempFolderPath));
2272#endif
2273 if (!d->exists()) {
2274 return ""; // already remove
2275 }
2276
2277 d->setFilter( QDir::Files );
2278 QStringList subDirList = d->entryList();
2279 int res = true;
2280 QString error = "";
2281 for (QStringList::ConstIterator it = subDirList.begin() ;(it != subDirList.end()) ; it++) {
2282 const QString currentFile = *it;
2283 if (!d->remove(currentFile)) {
2284 res = false;
2285 QString file = fMovieTempFolderPath+currentFile;
2286 error +="Removing file failed : "+file;
2287 } else {
2288 }
2289 }
2290 if (res) {
2291 if (d->rmdir(fMovieTempFolderPath)) {
2292 fMovieTempFolderPath = "";
2293 return "";
2294 } else {
2295 return "Dir "+fMovieTempFolderPath+" should be empty, but could not remove it";
2296 }
2297
2298 }
2299 return "Could not remove "+fMovieTempFolderPath+" because of the following errors :"+error;
2300}
2301
2302
2303
2304bool G4OpenGLQtViewer::hasPendingEvents () {
2305 return ((QApplication*)G4Qt::getInstance ())->hasPendingEvents ();
2306}
2307
2308bool G4OpenGLQtViewer::generateMpegEncoderParameters () {
2309
2310 // save the parameter file
2311 FILE* fp;
2312#if QT_VERSION < 0x040000
2313 fp = fopen (QString(fMovieTempFolderPath+fParameterFileName).ascii(), "w");
2314#else
2315 fp = fopen (QString(fMovieTempFolderPath+fParameterFileName).toStdString().c_str(), "w");
2316#endif
2317
2318 if (fp == NULL) {
2319 setRecordingInfos("Generation of parameter file failed");
2320 return false;
2321 }
2322
2323 fprintf (fp,"# parameter file template with lots of comments to assist you\n");
2324 fprintf (fp,"#\n");
2325 fprintf (fp,"# you can use this as a template, copying it to a separate file then modifying\n");
2326 fprintf (fp,"# the copy\n");
2327 fprintf (fp,"#\n");
2328 fprintf (fp,"#\n");
2329 fprintf (fp,"# any line beginning with '#' is a comment\n");
2330 fprintf (fp,"#\n");
2331 fprintf (fp,"# no line should be longer than 255 characters\n");
2332 fprintf (fp,"#\n");
2333 fprintf (fp,"#\n");
2334 fprintf (fp,"# general format of each line is:\n");
2335 fprintf (fp,"# \n");
2336 fprintf (fp,"#\n");
2337 fprintf (fp,"# lines can generally be in any order\n");
2338 fprintf (fp,"#\n");
2339 fprintf (fp,"# an exception is the option 'INPUT' which must be followed by input\n");
2340 fprintf (fp,"# files in the order in which they must appear, followed by 'END_INPUT'\n");
2341 fprintf (fp,"#\n");
2342 fprintf (fp,"# Also, if you use the `command` method of generating input file names,\n");
2343 fprintf (fp,"# the command will only be executed in the INPUT_DIR if INPUT_DIR preceeds\n");
2344 fprintf (fp,"# the INPUT parameter.\n");
2345 fprintf (fp,"#\n");
2346 fprintf (fp,"# MUST be in UPPER CASE\n");
2347 fprintf (fp,"#\n");
2348 fprintf (fp,"\n");
2349 fprintf (fp,"# Pattern affects speed, quality and compression. See the User's Guide\n");
2350 fprintf (fp,"# for more info.\n");
2351 fprintf (fp,"\n");
2352 fprintf (fp,"PATTERN IBBPBBPBBPBBPBBP\n");
2353#if QT_VERSION < 0x040000
2354 fprintf (fp,"OUTPUT %s\n",getSaveFileName().ascii());
2355#else
2356 fprintf (fp,"OUTPUT %s\n",getSaveFileName().toStdString().c_str());
2357#endif
2358 fprintf (fp,"\n");
2359 fprintf (fp,"# mpeg_encode really only accepts 3 different file formats, but using a\n");
2360 fprintf (fp,"# conversion statement it can effectively handle ANY file format\n");
2361 fprintf (fp,"#\n");
2362 fprintf (fp,"# You must specify the type of the input files. The choices are:\n");
2363 fprintf (fp,"# YUV, PPM, JMOVIE, Y, JPEG, PNM\n");
2364 fprintf (fp,"# (must be upper case)\n");
2365 fprintf (fp,"#\n");
2366 fprintf (fp,"BASE_FILE_FORMAT PPM\n");
2367 fprintf (fp,"\n");
2368 fprintf (fp,"#\n");
2369 fprintf (fp,"# if YUV format (or using parallel version), must provide width and height\n");
2370 fprintf (fp,"# YUV_SIZE widthxheight\n");
2371 fprintf (fp,"# this option is ignored if BASE_FILE_FORMAT is not YUV and you're running\n");
2372 fprintf (fp,"# on just one machine\n");
2373 fprintf (fp,"#\n");
2374 fprintf (fp,"YUV_SIZE 352x240\n");
2375 fprintf (fp,"\n");
2376 fprintf (fp,"# If you are using YUV, there are different supported file formats.\n");
2377 fprintf (fp,"# EYUV or UCB are the same as previous versions of this encoder.\n");
2378 fprintf (fp,"# (All the Y's, then U's then V's, in 4:2:0 subsampling.)\n");
2379 fprintf (fp,"# Other formats, such as Abekas, Phillips, or a general format are\n");
2380 fprintf (fp,"# permissible, the general format is a string of Y's, U's, and V's\n");
2381 fprintf (fp,"# to specify the file order.\n");
2382 fprintf (fp,"\n");
2383 fprintf (fp,"INPUT_FORMAT UCB\n");
2384 fprintf (fp,"\n");
2385 fprintf (fp,"# the conversion statement\n");
2386 fprintf (fp,"#\n");
2387 fprintf (fp,"# Each occurrence of '*' will be replaced by the input file\n");
2388 fprintf (fp,"#\n");
2389 fprintf (fp,"# e.g., if you have a bunch of GIF files, then this might be:\n");
2390 fprintf (fp,"# INPUT_CONVERT giftoppm *\n");
2391 fprintf (fp,"#\n");
2392 fprintf (fp,"# e.g., if you have a bunch of files like a.Y a.U a.V, etc., then:\n");
2393 fprintf (fp,"# INPUT_CONVERT cat *.Y *.U *.V\n");
2394 fprintf (fp,"#\n");
2395 fprintf (fp,"# e.g., if you are grabbing from laser disc you might have something like\n");
2396 fprintf (fp,"# INPUT_CONVERT goto frame *; grabppm\n");
2397 fprintf (fp,"# 'INPUT_CONVERT *' means the files are already in the base file format\n");
2398 fprintf (fp,"#\n");
2399 fprintf (fp,"INPUT_CONVERT * \n");
2400 fprintf (fp,"\n");
2401 fprintf (fp,"# number of frames in a GOP.\n");
2402 fprintf (fp,"#\n");
2403 fprintf (fp,"# since each GOP must have at least one I-frame, the encoder will find the\n");
2404 fprintf (fp,"# the first I-frame after GOP_SIZE frames to start the next GOP\n");
2405 fprintf (fp,"#\n");
2406 fprintf (fp,"# later, will add more flexible GOP signalling\n");
2407 fprintf (fp,"#\n");
2408 fprintf (fp,"GOP_SIZE 16\n");
2409 fprintf (fp,"\n");
2410 fprintf (fp,"# number of slices in a frame\n");
2411 fprintf (fp,"#\n");
2412 fprintf (fp,"# 1 is a good number. another possibility is the number of macroblock rows\n");
2413 fprintf (fp,"# (which is the height divided by 16)\n");
2414 fprintf (fp,"#\n");
2415 fprintf (fp,"SLICES_PER_FRAME 1\n");
2416 fprintf (fp,"\n");
2417 fprintf (fp,"# directory to get all input files from (makes this file easier to read)\n");
2418#if QT_VERSION < 0x040000
2419 fprintf (fp,"INPUT_DIR %s\n",fMovieTempFolderPath.ascii());
2420#else
2421 fprintf (fp,"INPUT_DIR %s\n",fMovieTempFolderPath.toStdString().c_str());
2422#endif
2423 fprintf (fp,"\n");
2424 fprintf (fp,"# There are a bunch of ways to specify the input files.\n");
2425 fprintf (fp,"# from a simple one-per-line listing, to the following \n");
2426 fprintf (fp,"# way of numbering them. See the manual for more information.\n");
2427 fprintf (fp,"INPUT\n");
2428 fprintf (fp,"# '*' is replaced by the numbers 01, 02, 03, 04\n");
2429 fprintf (fp,"# if I instead do [01-11], it would be 01, 02, ..., 09, 10, 11\n");
2430 fprintf (fp,"# if I instead do [1-11], it would be 1, 2, 3, ..., 9, 10, 11\n");
2431 fprintf (fp,"# if I instead do [1-11+3], it would be 1, 4, 7, 10\n");
2432 fprintf (fp,"# the program assumes none of your input files has a name ending in ']'\n");
2433 fprintf (fp,"# if you do, too bad!!!\n");
2434 fprintf (fp,"#\n");
2435 fprintf (fp,"#\n");
2436 fprintf (fp,"Test*.ppm [0-%d]\n",fRecordFrameNumber-1);
2437 fprintf (fp,"# can have more files here if you want...there is no limit on the number\n");
2438 fprintf (fp,"# of files\n");
2439 fprintf (fp,"END_INPUT\n");
2440 fprintf (fp,"\n");
2441 fprintf (fp,"\n");
2442 fprintf (fp,"\n");
2443 fprintf (fp,"# Many of the remaining options have to do with the motion search and qscale\n");
2444 fprintf (fp,"\n");
2445 fprintf (fp,"# FULL or HALF -- must be upper case\n");
2446 fprintf (fp,"# Should be FULL for computer generated images\n");
2447 fprintf (fp,"PIXEL FULL\n");
2448 fprintf (fp,"\n");
2449 fprintf (fp,"# means +/- this many pixels for both P and B frame searches\n");
2450 fprintf (fp,"# specify two numbers if you wish to serc different ranges in the two.\n");
2451 fprintf (fp,"RANGE 10\n");
2452 fprintf (fp,"\n");
2453 fprintf (fp,"# The two search algorithm parameters below mostly affect speed,\n");
2454 fprintf (fp,"# with some affect on compression and almost none on quality.\n");
2455 fprintf (fp,"\n");
2456 fprintf (fp,"# this must be one of {EXHAUSTIVE, SUBSAMPLE, LOGARITHMIC}\n");
2457 fprintf (fp,"PSEARCH_ALG LOGARITHMIC\n");
2458 fprintf (fp,"\n");
2459 fprintf (fp,"# this must be one of {SIMPLE, CROSS2, EXHAUSTIVE}\n");
2460 fprintf (fp,"#\n");
2461 fprintf (fp,"# note that EXHAUSTIVE is really, really, really slow\n");
2462 fprintf (fp,"#\n");
2463 fprintf (fp,"BSEARCH_ALG SIMPLE\n");
2464 fprintf (fp,"\n");
2465 fprintf (fp,"#\n");
2466 fprintf (fp,"# these specify the q-scale for I, P, and B frames\n");
2467 fprintf (fp,"# (values must be between 1 and 31)\n");
2468 fprintf (fp,"# These are the Qscale values for the entire frame in variable bit-rate\n");
2469 fprintf (fp,"# mode, and starting points (but not important) for constant bit rate\n");
2470 fprintf (fp,"#\n");
2471 fprintf (fp,"\n");
2472 fprintf (fp,"# Qscale (Quantization scale) affects quality and compression,\n");
2473 fprintf (fp,"# but has very little effect on speed.\n");
2474 fprintf (fp,"\n");
2475 fprintf (fp,"IQSCALE 4\n");
2476 fprintf (fp,"PQSCALE 5\n");
2477 fprintf (fp,"BQSCALE 12\n");
2478 fprintf (fp,"\n");
2479 fprintf (fp,"# this must be ORIGINAL or DECODED\n");
2480 fprintf (fp,"REFERENCE_FRAME ORIGINAL\n");
2481 fprintf (fp,"\n");
2482 fprintf (fp,"# for parallel parameters see parallel.param in the exmaples subdirectory\n");
2483 fprintf (fp,"\n");
2484 fprintf (fp,"# if you want constant bit-rate mode, specify it as follows (number is bits/sec):\n");
2485 fprintf (fp,"#BIT_RATE 1000000\n");
2486 fprintf (fp,"\n");
2487 fprintf (fp,"# To specify the buffer size (327680 is default, measused in bits, for 16bit words)\n");
2488 fprintf (fp,"BUFFER_SIZE 327680\n");
2489 fprintf (fp,"\n");
2490 fprintf (fp,"# The frame rate is the number of frames/second (legal values:\n");
2491 fprintf (fp,"# 23.976, 24, 25, 29.97, 30, 50 ,59.94, 60\n");
2492 fprintf (fp,"FRAME_RATE 30\n");
2493 fprintf (fp,"\n");
2494 fprintf (fp,"# There are many more options, see the users manual for examples....\n");
2495 fprintf (fp,"# ASPECT_RATIO, USER_DATA, GAMMA, IQTABLE, etc.\n");
2496 fprintf (fp,"\n");
2497 fprintf (fp,"\n");
2498 fclose (fp);
2499
2500 setRecordingInfos("Parameter file "+fParameterFileName+" generated in "+fMovieTempFolderPath);
2501 setRecordingStatus(READY_TO_ENCODE);
2502 return true;
2503}
2504
2505void G4OpenGLQtViewer::encodeVideo()
2506{
2507 if ((getEncoderPath() != "") && (getSaveFileName() != "")) {
2508 setRecordingStatus(ENCODING);
2509
2510#if QT_VERSION < 0x040000
2511 QStringList args = QStringList(fEncoderPath);
2512 args.push_back(fMovieTempFolderPath+fParameterFileName);
2513 fProcess = new QProcess(args);
2514 QObject ::connect(fProcess,SIGNAL(processExited ()),
2515 this,SLOT(processEncodeFinished()));
2516 QObject ::connect(fProcess,SIGNAL(readyReadStdout ()),
2517 this,SLOT(processEncodeStdout()));
2518 fProcess->setCommunication(QProcess::DupStderr);
2519 fProcess->launch("");
2520#else
2521 fProcess = new QProcess();
2522#if QT_VERSION > 0x040100
2523 QObject ::connect(fProcess,SIGNAL(finished ( int,QProcess::ExitStatus)),
2524 this,SLOT(processEncodeFinished()));
2525 QObject ::connect(fProcess,SIGNAL(readyReadStandardOutput ()),
2526 this,SLOT(processEncodeStdout()));
2527#else
2528 QObject ::connect(fProcess,SIGNAL(finished ( int)),
2529 this,SLOT(processEncodeFinished()));
2530 QObject ::connect(fProcess,SIGNAL(readyReadStandardOutput ()),
2531 this,SLOT(processEncodeStdout()));
2532#endif
2533 fProcess->setReadChannelMode(QProcess::MergedChannels);
2534 fProcess->start (fEncoderPath, QStringList(fMovieTempFolderPath+fParameterFileName));
2535#endif
2536 }
2537}
2538
2539
2540// FIXME : does not work on Qt3
2541void G4OpenGLQtViewer::processEncodeStdout()
2542{
2543#if QT_VERSION > 0x040000
2544 QString tmp = fProcess->readAllStandardOutput ().data();
2545 int start = tmp.lastIndexOf("ESTIMATED TIME");
2546 tmp = tmp.mid(start,tmp.indexOf("\n",start)-start);
2547#else
2548 QString tmp = fProcess->readStdout ().data();
2549 int start = tmp.findRev("ESTIMATED TIME");
2550 tmp = tmp.mid(start,tmp.find("\n",start)-start);
2551#endif
2552 setRecordingInfos(tmp);
2553}
2554
2555
2556void G4OpenGLQtViewer::processEncodeFinished()
2557{
2558
2559 QString txt = "";
2560 txt = getProcessErrorMsg();
2561 if (txt == "") {
2562 setRecordingStatus(SUCCESS);
2563 } else {
2564 setRecordingStatus(FAILED);
2565 }
2566 // setRecordingInfos(txt+removeTempFolder());
2567}
2568
2569
2570void G4OpenGLQtViewer::processLookForFinished()
2571 {
2572
2573 QString txt = getProcessErrorMsg();
2574 if (txt != "") {
2575 fEncoderPath = "";
2576 } else {
2577#if QT_VERSION > 0x040000
2578 fEncoderPath = QString(fProcess->readAllStandardOutput ().data()).trimmed();
2579#else
2580 fEncoderPath = QString(fProcess->readStdout ().data()).simplifyWhiteSpace();
2581#endif
2582 // if not found, return "not found"
2583 if (fEncoderPath.contains(" ")) {
2584 fEncoderPath = "";
2585 } else if (!fEncoderPath.contains("mpeg_encode")) {
2586 fEncoderPath = "";
2587 }
2588 setEncoderPath(fEncoderPath);
2589 }
2590 // init temp folder
2591#if QT_VERSION > 0x040000
2592 setTempFolderPath(QDir::temp ().absolutePath ());
2593#else
2594 // Let's have a try
2595 setTempFolderPath("/tmp/");
2596#endif
2597}
2598
2599
2600QString G4OpenGLQtViewer::getProcessErrorMsg()
2601{
2602 QString txt = "";
2603#if QT_VERSION < 0x040000
2604 if (!fProcess->normalExit ()) {
2605 txt = "Exist status "+ fProcess->exitStatus ();
2606 }
2607#else
2608 if (fProcess->exitCode() != 0) {
2609 switch (fProcess->error()) {
2610 case QProcess::FailedToStart:
2611 txt = "The process failed to start. Either the invoked program is missing, or you may have insufficient permissions to invoke the program.\n";
2612 break;
2613 case QProcess::Crashed:
2614 txt = "The process crashed some time after starting successfully.\n";
2615 break;
2616 case QProcess::Timedout:
2617 txt = "The last waitFor...() function timed out. The state of QProcess is unchanged, and you can try calling waitFor...() again.\n";
2618 break;
2619 case QProcess::WriteError:
2620 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";
2621 break;
2622 case QProcess::ReadError:
2623 txt = "An error occurred when attempting to read from the process. For example, the process may not be running.\n";
2624 break;
2625 case QProcess::UnknownError:
2626 txt = "An unknown error occurred. This is the default return value of error().\n";
2627 break;
2628 }
2629 }
2630#endif
2631 return txt;
2632}
2633
2634/*
2635
2636void MultiLayer::exportToSVG(const QString& fname)
2637{
2638 QPicture picture;
2639 QPainter p(&picture);
2640 for (int i=0;i<(int)graphsList->count();i++)
2641 {
2642 Graph *gr=(Graph *)graphsList->at(i);
2643 Plot *myPlot= (Plot *)gr->plotWidget();
2644
2645 QPoint pos=gr->pos();
2646
2647 int width=int(myPlot->frameGeometry().width());
2648 int height=int(myPlot->frameGeometry().height());
2649
2650 myPlot->print(&p, QRect(pos,QSize(width,height)));
2651 }
2652
2653 p.end();
2654 picture.save(fname, "svg");
2655}
2656*/
2657#endif
Note: See TracBrowser for help on using the repository browser.