source: trunk/geant4/visualization/OpenGL/src/G4OpenGLQtViewer.cc @ 733

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

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