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

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

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