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

Last change on this file since 736 was 736, checked in by garnier, 16 years ago

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