Context Navigation

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

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: