Context Navigation

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

Last change on this file since 915 was 915, checked in by garnier, 16 years ago
print improvments begin, see History file
Property svn:mime-type set to `text/cpp`
File size: 85.6 KB

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

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

Download in other formats: