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

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

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