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

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

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