source: trunk/source/visualization/OpenGL/src/G4OpenGLQtViewer.cc~ @ 1350

Last change on this file since 1350 was 1350, checked in by garnier, 13 years ago

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