Context Navigation

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

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

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

Download in other formats: