Context Navigation

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

Last change on this file since 1121 was 1121, checked in by garnier, 16 years ago
en test...ca marche encore...
Property svn:mime-type set to `text/cpp`
File size: 81.3 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.43 2009/07/29 10:04:45 lgarnier Exp $
28	// GEANT4 tag $Name: $
29	//
30	//
31	// G4OpenGLQtViewer : Class to provide Qt specific
32	// functionality for OpenGL in GEANT4
33	//
34	// 27/06/2003 : G.Barrand : implementation (at last !).
35
36	#ifdef G4VIS_BUILD_OPENGLQT_DRIVER
37
38	#include "G4OpenGLQtViewer.hh"
39	#include "G4VViewer.hh"
40	#include "G4VSceneHandler.hh"
41	#include "G4OpenGLSceneHandler.hh"
42
43	#include "G4ios.hh"
44	#include "G4VisExtent.hh"
45	#include "G4LogicalVolume.hh"
46	#include "G4VSolid.hh"
47	#include "G4Point3D.hh"
48	#include "G4Normal3D.hh"
49	#include "G4Scene.hh"
50	#include "G4OpenGLQtExportDialog.hh"
51	#include "G4OpenGLQtMovieDialog.hh"
52	#include "G4UnitsTable.hh"
53	#include "G4Qt.hh"
54	#include "G4UImanager.hh"
55	#include "G4UIcommandTree.hh"
56	#include <qlayout.h>
57	#include <qdialog.h>
58	#include <qprocess.h>
59	#include <qapplication.h>
60	#include <qdesktopwidget.h>
61
62	#if QT_VERSION >= 0x040000
63	#include <qmenu.h>
64	#include <qimagewriter.h>
65	#else
66	#include <qaction.h>
67	#include <qwidgetlist.h>
68	#include <qpopupmenu.h>
69	#include <qimage.h>
70	#endif
71
72	#include <qapplication.h>
73	#include <qmessagebox.h>
74	#include <qfiledialog.h>
75	#include <qprinter.h>
76	#include <qdatetime.h>
77	#include <qpainter.h>
78	#include <qgl.h> // include <qglwidget.h>
79	#include <qdialog.h>
80	#include <qevent.h> //include <qcontextmenuevent.h>
81
82
83	//////////////////////////////////////////////////////////////////////////////
84	/**
85	Implementation of virtual method of G4VViewer
86	*/
87	void G4OpenGLQtViewer::SetView (
88	)
89	//////////////////////////////////////////////////////////////////////////////
90	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
91	{
92	G4OpenGLViewer::SetView ();
93	}
94
95
96
97
98	//////////////////////////////////////////////////////////////////////////////
99	void G4OpenGLQtViewer::CreateMainWindow (
100	QGLWidget* glWidget
101	,QString name
102	)
103	//////////////////////////////////////////////////////////////////////////////
104	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
105	{
106
107	if(fWindow) return; //Done.
108
109	// launch Qt if not
110	G4Qt* interactorManager = G4Qt::getInstance ();
111	// G4UImanager* UI = G4UImanager::GetUIpointer();
112
113	fWindow = glWidget ;
114	// fWindow->makeCurrent();
115
116	// create window
117	if (((QApplication*)interactorManager->GetMainInteractor())) {
118	// look for the main window
119	bool found = false;
120	#if QT_VERSION < 0x040000
121	// theses lines does nothing exept this one "GLWindow = new QDialog(0..."
122	// but if I comment them, it doesn't work...
123	QWidgetList *list = QApplication::allWidgets();
124	QWidgetListIt it( *list ); // iterate over the widgets
125	QWidget * widget;
126	while ( (widget=it.current()) != 0 ) { // for each widget...
127	++it;
128	if ((found== false) && (widget->inherits("QMainWindow"))) {
129	fGLWindow = new QDialog(0,0,FALSE,Qt::WStyle_Title \| Qt::WStyle_SysMenu \| Qt::WStyle_MinMax );
130	found = true;
131	}
132	}
133	delete list; // delete the list, not the widgets
134	#else
135	foreach (QWidget *widget, QApplication::allWidgets()) {
136	if ((found== false) && (widget->inherits("QMainWindow"))) {
137	fGLWindow = new QDialog(0,Qt::WindowTitleHint \| Qt::WindowSystemMenuHint \| Qt::WindowMinMaxButtonsHint);
138	found = true;
139	}
140	}
141	#endif
142
143	#if QT_VERSION < 0x040000
144	glWidget->reparent(fGLWindow,0,QPoint(0,0));
145	#else
146	glWidget->setParent(fGLWindow);
147	#endif
148
149	if (found==false) {
150	#ifdef G4DEBUG_VIS_OGL
151	printf("G4OpenGLQtViewer::CreateMainWindow case Qapp exist, but not found\n");
152	#endif
153	fGLWindow = new QDialog();
154	}
155	} else {
156	#ifdef G4DEBUG_VIS_OGL
157	printf("G4OpenGLQtViewer::CreateMainWindow case Qapp exist\n");
158	#endif
159	fGLWindow = new QDialog();
160	}
161
162	QHBoxLayout *mainLayout = new QHBoxLayout(fGLWindow);
163	mainLayout->setMargin(0);
164	mainLayout->setSpacing(0);
165	mainLayout->addWidget(fWindow);
166
167	#if QT_VERSION < 0x040000
168	fGLWindow->setCaption(name );
169	#else
170	fGLWindow->setLayout(mainLayout);
171	fGLWindow->setWindowTitle( name);
172	#endif
173	ResizeWindow(fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
174
175	//useful for MACOSX, we have to compt the menuBar height
176	int offset = QApplication::desktop()->height()
177	- QApplication::desktop()->availableGeometry().height();
178
179	G4int YPos= fVP.GetWindowAbsoluteLocationHintY(QApplication::desktop()->height());
180	if (fVP.GetWindowAbsoluteLocationHintY(QApplication::desktop()->height())< offset) {
181	YPos = offset;
182	}
183	fGLWindow->resize(getWinWidth(), getWinHeight());
184	fGLWindow->move(fVP.GetWindowAbsoluteLocationHintX(QApplication::desktop()->width()),YPos);
185	fGLWindow->show();
186
187	if(!fWindow) return;
188	#ifdef G4DEBUG_VIS_OGL
189	printf("G4OpenGLQtViewer::CreateMainWindow glWidget END\n");
190	#endif
191
192	if (!fContextMenu)
193	createPopupMenu();
194
195	}
196
197	#if QT_VERSION >= 0x040000
198	/** Close the dialog and set the pointer to NULL
199	*/
200	// void G4OpenGLQtViewer::dialogClosed() {
201	// // fGLWindow = NULL;
202	// }
203	#endif
204
205	//////////////////////////////////////////////////////////////////////////////
206	G4OpenGLQtViewer::G4OpenGLQtViewer (
207	G4OpenGLSceneHandler& scene
208	)
209	:G4VViewer (scene, -1)
210	,G4OpenGLViewer (scene)
211	,fWindow(0)
212	,fRecordFrameNumber(0)
213	,fRotationAngleX(0)
214	,fRotationAngleY(0)
215	,fDeltaRotationAngleX(0)
216	,fDeltaRotationAngleY(0)
217	,fContextMenu(0)
218	,fMouseAction(STYLE1)
219	,fDeltaRotation(1)
220	,fDeltaSceneTranslation(0.01)
221	,fDeltaDepth(0.01)
222	,fDeltaZoom(0.05)
223	,fDeltaMove(0.05)
224	,fHoldKeyEvent(false)
225	,fHoldMoveEvent(false)
226	,fHoldRotateEvent(false)
227	,fAutoMove(false)
228	,fEncoderPath("")
229	,fTempFolderPath("")
230	,fMovieTempFolderPath("")
231	,fSaveFileName("")
232	,fParameterFileName("mpeg_encode_parameter_file.par")
233	,fMovieParametersDialog(NULL)
234	,fRecordingStep(WAIT)
235	,fProcess(NULL)
236	,fLaunchSpinDelay(100)
237	{
238	#ifdef G4DEBUG_VIS_OGL
239	printf("G4OpenGLQtViewer::Creation ...............\n");
240	#endif
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( fGLWindow,"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 (!fGLWindow) {
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 != fGLWindow->isFullScreen()) { //toggle
1238	#if QT_VERSION >= 0x030200
1239	fGLWindow->setWindowState(fGLWindow->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	std::string name;
1295	#if QT_VERSION < 0x040000
1296	name = QFileDialog::getSaveFileName ( ".",
1297	filters,
1298	fGLWindow,
1299	"Save file dialog",
1300	tr("Save as ..."),
1301	selectedFormat ).ascii();
1302	#else
1303	name = QFileDialog::getSaveFileName ( fGLWindow,
1304	tr("Save as ..."),
1305	".",
1306	filters,
1307	selectedFormat ).toStdString().c_str();
1308	#endif
1309	// bmp jpg jpeg png ppm xbm xpm
1310	if (name.empty()) {
1311	return;
1312	}
1313	#if QT_VERSION < 0x040000
1314	name += "." + std::string(selectedFormat->ascii());
1315	QString format = selectedFormat->lower();
1316	#else
1317	name += "." + selectedFormat->toStdString();
1318	QString format = selectedFormat->toLower();
1319	#endif
1320	setPrintFilename(name.c_str(),0);
1321	G4OpenGLQtExportDialog* exportDialog= new G4OpenGLQtExportDialog(fGLWindow,format,fWindow->height(),fWindow->width());
1322	if( exportDialog->exec()) {
1323
1324	QImage image;
1325	bool res = false;
1326	if ((exportDialog->getWidth() !=fWindow->width()) \|\|
1327	(exportDialog->getHeight() !=fWindow->height())) {
1328	setPrintSize(exportDialog->getWidth(),exportDialog->getHeight());
1329	if ((format != QString("eps")) && (format != QString("ps"))) {
1330	G4cerr << "Export->Change Size : This function is not implemented, to export in another size, please resize your frame to what you need" << G4endl;
1331
1332	// rescaleImage(exportDialog->getWidth(),exportDialog->getHeight());// re-scale image
1333	// QGLWidget* glResized = fWindow;
1334
1335	// FIXME :
1336	// L.Garnier : I've try to implement change size function, but the problem is
1337	// the renderPixmap function call the QGLWidget to resize and it doesn't draw
1338	// the content of this widget... It only draw the background.
1339
1340	// fWindow->renderPixmap (exportDialog->getWidth()2,exportDialog->getHeight()2,true );
1341
1342	// QPixmap pixmap = fWindow->renderPixmap ();
1343
1344	// image = pixmap->toImage();
1345	// glResized->resize(exportDialog->getWidth()2,exportDialog->getHeight()2);
1346	// image = glResized->grabFrameBuffer();
1347	}
1348	} else {
1349	image = fWindow->grabFrameBuffer();
1350	}
1351	if (format == QString("eps")) {
1352	fVectoredPs = exportDialog->getVectorEPS();
1353	printEPS();
1354	} else if (format == "ps") {
1355	fVectoredPs = true;
1356	printEPS();
1357	} else if (format == "pdf") {
1358
1359	res = printPDF(name,exportDialog->getNbColor(),image);
1360
1361	} else if ((format == "tif") \|\|
1362	(format == "tiff") \|\|
1363	(format == "jpg") \|\|
1364	(format == "jpeg") \|\|
1365	(format == "png") \|\|
1366	(format == "pbm") \|\|
1367	(format == "pgm") \|\|
1368	(format == "ppm") \|\|
1369	(format == "bmp") \|\|
1370	(format == "xbm") \|\|
1371	(format == "xpm")) {
1372	#if QT_VERSION < 0x040000
1373	res = image.save(QString(name.c_str()),selectedFormat->ascii(),exportDialog->getSliderValue());
1374	#else
1375	res = image.save(QString(name.c_str()),0,exportDialog->getSliderValue());
1376	#endif
1377	} else {
1378	G4cerr << "This version of G4UI Could not generate the selected format" << G4endl;
1379	}
1380	if ((format == QString("eps")) && (format == QString("ps"))) {
1381	if (res == false) {
1382	G4cerr << "Error while saving file... "<<name.c_str()<< G4endl;
1383	} else {
1384	G4cout << "File "<<name.c_str()<<" has been saved " << G4endl;
1385	}
1386	}
1387
1388	} else { // cancel selected
1389	return;
1390	}
1391
1392	}
1393
1394
1395	void G4OpenGLQtViewer::actionMovieParameters() {
1396	showMovieParametersDialog();
1397	}
1398
1399
1400	void G4OpenGLQtViewer::showMovieParametersDialog() {
1401	if (!fMovieParametersDialog) {
1402	fMovieParametersDialog= new G4OpenGLQtMovieDialog(this,fGLWindow);
1403	displayRecordingStatus();
1404	fMovieParametersDialog->checkEncoderSwParameters();
1405	fMovieParametersDialog->checkSaveFileNameParameters();
1406	fMovieParametersDialog->checkTempFolderParameters();
1407	if (getEncoderPath() == "") {
1408	setRecordingInfos("mpeg_encode is needed to encode in video format. It is available here: http://bmrc.berkeley.edu/frame/research/mpeg/");
1409	}
1410	}
1411	fMovieParametersDialog->show();
1412	}
1413
1414
1415	/*
1416	// 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
1417
1418	void Graph::exportToSVG(const QString& fname)
1419	{
1420	// enable workaround for Qt3 misalignments
1421	QwtPainter::setSVGMode(true);
1422	QPicture picture;
1423	QPainter p(&picture);
1424	d_plot->print(&p, d_plot->rect());
1425	p.end();
1426
1427	picture.save(fname, "svg");
1428	}
1429	*/
1430
1431
1432
1433	void G4OpenGLQtViewer::FinishView()
1434	{
1435	#ifdef G4DEBUG_VIS_OGL
1436	printf("G4OpenGLQtViewer::FinishView\n");
1437	#endif
1438	glFlush ();
1439	fWindow->swapBuffers ();
1440	}
1441
1442	/**
1443	Save the current mouse press point
1444	@param p mouse click point
1445	*/
1446	void G4OpenGLQtViewer::G4MousePressEvent(QMouseEvent *event)
1447	{
1448	#if QT_VERSION < 0x040000
1449	if ((event->button() & Qt::LeftButton)
1450	&& !((event->state() & Qt::ShiftButton)
1451	\|\| (event->state() & Qt::ControlButton)
1452	\|\| (event->state() & Qt::AltButton)
1453	\|\| (event->state() & Qt::MetaButton))) {
1454	#else
1455	if ((event->buttons() & Qt::LeftButton)
1456	&& !((event->modifiers() & Qt::ShiftModifier)
1457	\|\| (event->modifiers() & Qt::ControlModifier)
1458	\|\| (event->modifiers() & Qt::AltModifier)
1459	\|\| (event->modifiers() & Qt::MetaModifier))) {
1460	#endif
1461	fWindow->setMouseTracking(true);
1462	fAutoMove = false; // stop automove
1463	fLastPos1 = event->pos();
1464	fLastPos2 = fLastPos1;
1465	fLastPos3 = fLastPos2;
1466	fLastEventTime->start();
1467	if (fMouseAction == STYLE3){ // pick
1468	Pick(event->pos().x(),event->pos().y());
1469	}
1470	}
1471	}
1472
1473	/**
1474	*/
1475	void G4OpenGLQtViewer::G4MouseReleaseEvent()
1476	{
1477	fSpinningDelay = fLastEventTime->elapsed();
1478	QPoint delta = (fLastPos3-fLastPos1);
1479	if ((delta.x() == 0) && (delta.y() == 0)) {
1480	return;
1481	}
1482	if (fSpinningDelay < fLaunchSpinDelay ) {
1483	fAutoMove = true;
1484	QTime lastMoveTime;
1485	lastMoveTime.start();
1486	// try to addapt speed move/rotate looking to drawing speed
1487	int cycles = 4;
1488	while (fAutoMove) {
1489	// if ( lastMoveTime.elapsed() > (fSpinningDelay / (cycles/2))) {
1490	if (fMouseAction == STYLE1) { // rotate
1491	rotateQtScene(((float)delta.x())/cycles,((float)delta.y())/cycles);
1492	} else if (fMouseAction == STYLE2) { // move
1493	moveScene(-((float)delta.x())/cycles,-((float)delta.y())/cycles,0,true);
1494	}
1495	lastMoveTime.start();
1496	cycles = 1 ;
1497	((QApplication*)G4Qt::getInstance ())->processEvents();
1498	cycles ++ ;
1499	}
1500	}
1501	fWindow->setMouseTracking(false);
1502
1503	}
1504
1505
1506	void G4OpenGLQtViewer::G4MouseDoubleClickEvent()
1507	{
1508	fWindow->setMouseTracking(true);
1509	}
1510
1511
1512	/**
1513	@param pos_x mouse x position
1514	@param pos_y mouse y position
1515	@param mButtons mouse button active
1516	@param mAutoMove true: apply this move till another evnt came, false :one time move
1517	*/
1518
1519	void G4OpenGLQtViewer::G4MouseMoveEvent(QMouseEvent *event)
1520	{
1521
1522	#if QT_VERSION < 0x040000
1523	Qt::ButtonState mButtons = event->state();
1524	#else
1525	Qt::MouseButtons mButtons = event->buttons();
1526	#endif
1527
1528	if (fAutoMove) {
1529	return;
1530	}
1531
1532	fLastPos3 = fLastPos2;
1533	fLastPos2 = fLastPos1;
1534	fLastPos1 = QPoint(event->x(), event->y());
1535
1536	int deltaX = fLastPos2.x()-fLastPos1.x();
1537	int deltaY = fLastPos2.y()-fLastPos1.y();
1538
1539	if (fMouseAction == STYLE1) { // rotate
1540	if (mButtons & Qt::LeftButton) {
1541	rotateQtScene(deltaX,deltaY);
1542	}
1543	} else if (fMouseAction == STYLE2) { // move
1544	if (mButtons & Qt::LeftButton) {
1545	moveScene(-deltaX,-deltaY,0,true);
1546	}
1547	}
1548
1549	fLastEventTime->start();
1550	}
1551
1552
1553	/**
1554	Move the scene of dx, dy, dz values.
1555	@param dx delta mouse x position
1556	@param dy delta mouse y position
1557	@param mouseMove : true if even comes from a mouse move, false if even comes from key action
1558	*/
1559
1560	void G4OpenGLQtViewer::moveScene(float dx,float dy, float dz,bool mouseMove)
1561	{
1562	if (fHoldMoveEvent)
1563	return;
1564	fHoldMoveEvent = true;
1565
1566	G4double coefTrans = 0;
1567	GLdouble coefDepth = 0;
1568	if(mouseMove) {
1569	coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinWidth());
1570	if (getWinHeight() <getWinWidth()) {
1571	coefTrans = ((G4double)getSceneNearWidth())/((G4double)getWinHeight());
1572	}
1573	} else {
1574	coefTrans = getSceneNearWidth()*fDeltaSceneTranslation;
1575	coefDepth = getSceneDepth()*fDeltaDepth;
1576	}
1577	fVP.IncrementPan(-dxcoefTrans,dycoefTrans,dz*coefDepth);
1578	emit moveX(-dx*coefTrans);
1579	emit moveY(dy*coefTrans);
1580	emit moveZ(dz*coefTrans);
1581
1582	updateQWidget();
1583	if (fAutoMove)
1584	((QApplication*)G4Qt::getInstance ())->processEvents();
1585
1586	fHoldMoveEvent = false;
1587	}
1588
1589
1590	/**
1591	@param dx delta mouse x position
1592	@param dy delta mouse y position
1593	*/
1594
1595	void G4OpenGLQtViewer::rotateQtScene(float dx, float dy)
1596	{
1597	if (fHoldRotateEvent)
1598	return;
1599	fHoldRotateEvent = true;
1600
1601	if( dx != 0) {
1602	rotateScene(dx,0,fDeltaRotation);
1603	emit rotateTheta(dx);
1604	}
1605	if( dy != 0) {
1606	rotateScene(0,dy,fDeltaRotation);
1607	emit rotatePhi(dy);
1608	}
1609	updateQWidget();
1610
1611	fHoldRotateEvent = false;
1612	}
1613
1614	/**
1615	@param dx delta mouse x position
1616	@param dy delta mouse y position
1617	*/
1618
1619	void G4OpenGLQtViewer::rotateQtCamera(float dx, float dy)
1620	{
1621	if (fHoldRotateEvent)
1622	return;
1623	fHoldRotateEvent = true;
1624
1625	rotateScene(dx,dy,fDeltaRotation);
1626	emit rotateTheta(dx);
1627	emit rotatePhi(dy);
1628	updateQWidget();
1629
1630	fHoldRotateEvent = false;
1631	}
1632
1633
1634
1635
1636	/** This is the benning of a rescale function. It does nothing for the moment
1637	@param aWidth : new width
1638	@param aHeight : new height
1639	*/
1640	void G4OpenGLQtViewer::rescaleImage(
1641	int /* aWidth */
1642	,int /* aHeight */
1643	){
1644	// GLfloat* feedback_buffer;
1645	// GLint returned;
1646	// FILE* file;
1647
1648	// feedback_buffer = new GLfloat[size];
1649	// glFeedbackBuffer (size, GL_3D_COLOR, feedback_buffer);
1650	// glRenderMode (GL_FEEDBACK);
1651
1652	// DrawView();
1653	// returned = glRenderMode (GL_RENDER);
1654
1655	}
1656
1657
1658
1659	/**
1660	Generate Postscript or PDF form image
1661	@param aFilename : name of file
1662	@param aInColor : numbers of colors : 1->BW 2->RGB
1663	@param aImage : Image to print
1664	*/
1665	bool G4OpenGLQtViewer::printPDF (
1666	const std::string aFilename
1667	,int aInColor
1668	,QImage aImage
1669	)
1670	{
1671
1672	#if QT_VERSION < 0x040000
1673	#if defined(Q_WS_MAC) \|\| defined(Q_WS_X11)
1674	QPrinter printer;
1675	// printer.setPageSize(pageSize);
1676	if (aInColor == 1) {
1677	printer.setColorMode(QPrinter::GrayScale);
1678	} else {
1679	printer.setColorMode(QPrinter::Color);
1680	}
1681
1682	/* FIXME : I don't know which format it will save...
1683	if (aFilename.endsWith(".ps")) {
1684	printer.setOutputFormat(QPrinter::PostScriptFormat);
1685	} else {
1686	printer.setOutputFormat(QPrinter::PdfFormat);
1687	}
1688	*/
1689	printer.setOutputFileName(aFilename);
1690	// printer.setFullPage ( true);
1691	QPainter paint(&printer);
1692	paint.drawImage (0,0,aImage );
1693	paint.end();
1694	#else
1695	G4cerr << "This fonction is only supported on Mac OsX or X11 with Qt3. Full platform supported with Qt4" << G4endl;
1696	// FIXME
1697	// L.Garnier 6 May 2009 : Only to fix compilation warnings
1698	if (aFilename.empty()) {
1699	aInColor = 0;
1700	aImage = 0;
1701	}
1702	// END_OF FIXME
1703	#endif
1704	#else
1705	QPrinter printer;
1706	// printer.setPageSize(pageSize);
1707
1708	// FIXME : L. Garnier 4/12/07
1709	// This is not working, it does nothing. Image is staying in color mode
1710	// So I have desactivate the B/W button in GUI
1711	if ((!aImage.isGrayscale ()) &&(aInColor ==1 )) {
1712	#if QT_VERSION < 0x040000
1713	aImage = aImage.convertDepth(1,Qt::MonoOnly);
1714	#else
1715	aImage = aImage.convertToFormat ( aImage.format(), Qt::MonoOnly);
1716	#endif
1717	}
1718
1719
1720	if (aFilename.substr(aFilename.size()-3) == ".ps") {
1721	#if QT_VERSION > 0x040200
1722	printer.setOutputFormat(QPrinter::PostScriptFormat);
1723	#endif
1724	} else {
1725	#if QT_VERSION > 0x040100
1726	printer.setOutputFormat(QPrinter::PdfFormat);
1727	#endif
1728	}
1729	#if QT_VERSION > 0x040100
1730	printer.setOutputFileName(QString(aFilename.c_str()));
1731	#endif
1732	// printer.setFullPage ( true);
1733	QPainter paint(&printer);
1734	paint.drawImage (0,0,aImage);
1735	paint.end();
1736	#endif
1737	return true;
1738	}
1739
1740
1741	void G4OpenGLQtViewer::G4wheelEvent (QWheelEvent * event)
1742	{
1743	fVP.SetZoomFactor(fVP.GetZoomFactor()+(fVP.GetZoomFactor()*(event->delta())/1200));
1744	updateQWidget();
1745	}
1746
1747
1748	void G4OpenGLQtViewer::G4keyPressEvent (QKeyEvent * event)
1749	{
1750	if (fHoldKeyEvent)
1751	return;
1752
1753	fHoldKeyEvent = true;
1754
1755	#if QT_VERSION < 0x040000
1756	if ((event->key() == Qt::Key_Down) && (event->state() & Qt::AltButton )) { // go backward
1757	#else
1758	if ((event->key() == Qt::Key_Down) && (event->modifiers() & Qt::AltModifier )) { // go backward
1759	#endif
1760
1761	moveScene(0,0,1,false);
1762	}
1763	#if QT_VERSION < 0x040000
1764	else if ((event->key() == Qt::Key_Up) && (event->state() & Qt::AltButton)) { // go forward
1765	#else
1766	else if ((event->key() == Qt::Key_Up) && (event->modifiers() & Qt::AltModifier)) { // go forward
1767	#endif
1768	moveScene(0,0,-1,false);
1769	}
1770	#if QT_VERSION < 0x040000
1771	if ((event->key() == Qt::Key_Down) && (event->state() & Qt::ShiftButton)) { // rotate phi
1772	#else
1773	if ((event->key() == Qt::Key_Down) && (event->modifiers() & Qt::ShiftModifier)) { // rotate phi
1774	#endif
1775	rotateQtCamera(0,-1);
1776	}
1777	#if QT_VERSION < 0x040000
1778	else if ((event->key() == Qt::Key_Up) && (event->state() & Qt::ShiftButton)) { // rotate phi
1779	#else
1780	else if ((event->key() == Qt::Key_Up) && (event->modifiers() & Qt::ShiftModifier)) { // rotate phi
1781	#endif
1782	rotateQtCamera(0,1);
1783	}
1784	#if QT_VERSION < 0x040000
1785	if ((event->key() == Qt::Key_Left) && (event->state() & Qt::ShiftButton)) { // rotate theta
1786	#else
1787	if ((event->key() == Qt::Key_Left) && (event->modifiers() & Qt::ShiftModifier)) { // rotate theta
1788	#endif
1789	rotateQtCamera(1,0);
1790	}
1791	#if QT_VERSION < 0x040000
1792	else if ((event->key() == Qt::Key_Right) && (event->state() & Qt::ShiftButton)) { // rotate theta
1793	#else
1794	else if ((event->key() == Qt::Key_Right) && (event->modifiers() & Qt::ShiftModifier)) { // rotate theta
1795	#endif
1796	rotateQtCamera(-1,0);
1797	}
1798
1799	#if QT_VERSION < 0x040000
1800	if ((event->state() & Qt::AltButton)) {
1801	#else
1802	if ((event->modifiers() & Qt::AltModifier)) {
1803	#endif
1804	if (event->key() == Qt::Key_Plus) {
1805	fDeltaRotation = fDeltaRotation/0.7;
1806	}
1807	else if (event->key() == Qt::Key_Minus) {
1808	fDeltaRotation = fDeltaRotation*0.7;
1809	}
1810	} else {
1811	if (event->key() == Qt::Key_Plus) {
1812	fVP.SetZoomFactor(fVP.GetZoomFactor()*(1+fDeltaZoom));
1813	#ifdef G4DEBUG_VIS_OGL
1814	printf("G4OpenGLQtViewer::KeyPressEvent zoomFactor=%f\n",fVP.GetZoomFactor()*(1+fDeltaZoom));
1815	#endif
1816	updateQWidget();
1817	}
1818	else if (event->key() == Qt::Key_Minus) {
1819	fVP.SetZoomFactor(fVP.GetZoomFactor()*(1-fDeltaZoom));
1820	updateQWidget();
1821	}
1822	}
1823
1824
1825	if (event->key() == Qt::Key_Escape) { // escaped from full screen
1826	#if QT_VERSION >= 0x030200
1827	toggleFullScreen(false);
1828	#endif
1829	}
1830	// several case here : If return is pressed, in every case -> display the movie parameters dialog
1831	// If one parameter is wrong -> put it in red (only save filenam could be wrong..)
1832	// If encoder not found-> does nothing.Only display a message in status box
1833	// If all ok-> generate parameter file
1834	// If ok -> put encoder button enabled
1835
1836	if ((event->key() == Qt::Key_Return) \|\| (event->key() == Qt::Key_Enter)){ // end of video
1837	stopVideo();
1838	}
1839	if (event->key() == Qt::Key_Space){ // start/pause of video
1840	startPauseVideo();
1841	}
1842
1843	// with no modifiers
1844	#if QT_VERSION < 0x040000
1845	if (event->state() == Qt::NoButton) {
1846	#else
1847	if ((event->modifiers() == Qt::NoModifier) \|\| (event->modifiers() == Qt::KeypadModifier )) {
1848	#endif
1849	if (event->key() == Qt::Key_Down) { // go down
1850	moveScene(0,1,0,false);
1851	}
1852	else if (event->key() == Qt::Key_Up) { // go up
1853	moveScene(0,-1,0,false);
1854	}
1855	if (event->key() == Qt::Key_Left) { // go left
1856	moveScene(-1,0,0,false);
1857	}
1858	else if (event->key() == Qt::Key_Right) { // go right
1859	moveScene(1,0,0,false);
1860	}
1861	}
1862	fHoldKeyEvent = false;
1863	}
1864
1865
1866	/** Stop the video. Check all parameters and enable encoder button if all is ok.
1867	*/
1868	void G4OpenGLQtViewer::stopVideo() {
1869
1870	// if encoder parameter is wrong, display parameters dialog and return
1871	if (!fMovieParametersDialog) {
1872	showMovieParametersDialog();
1873	}
1874	setRecordingStatus(STOP);
1875
1876	if (fRecordFrameNumber >0) {
1877	// check parameters if they were modified (Re APPLY them...)
1878	if (!(fMovieParametersDialog->checkEncoderSwParameters())) {
1879	setRecordingStatus(BAD_ENCODER);
1880	} else if (!(fMovieParametersDialog->checkSaveFileNameParameters())) {
1881	setRecordingStatus(BAD_OUTPUT);
1882	}
1883	} else {
1884	resetRecording();
1885	setRecordingInfos("No frame to encode.");
1886	}
1887	}
1888
1889	/** Stop the video. Check all parameters and enable encoder button if all is ok.
1890	*/
1891	void G4OpenGLQtViewer::saveVideo() {
1892
1893	// if encoder parameter is wrong, display parameters dialog and return
1894	if (!fMovieParametersDialog) {
1895	showMovieParametersDialog();
1896	}
1897
1898	fMovieParametersDialog->checkEncoderSwParameters();
1899	fMovieParametersDialog->checkSaveFileNameParameters();
1900
1901	if (fRecordingStep == STOP) {
1902	setRecordingStatus(SAVE);
1903	generateMpegEncoderParameters();
1904	encodeVideo();
1905	}
1906	}
1907
1908
1909	/** Start/Pause the video..
1910	*/
1911	void G4OpenGLQtViewer::startPauseVideo() {
1912
1913	// first time, if temp parameter is wrong, display parameters dialog and return
1914
1915	if (( fRecordingStep == WAIT)) {
1916	if ( fRecordFrameNumber == 0) {
1917	if (getTempFolderPath() == "") { // BAD_OUTPUT
1918	showMovieParametersDialog();
1919	setRecordingInfos("You should specified the temp folder in order to make movie");
1920	return;
1921	} else {
1922	// remove temp folder if it was create
1923	QString tmp = removeTempFolder();
1924	if (tmp !="") {
1925	setRecordingInfos(tmp);
1926	return;
1927	}
1928	tmp = createTempFolder();
1929	if (tmp != "") {
1930	setRecordingInfos("Can't create temp folder."+tmp);
1931	return;
1932	}
1933	}
1934	}
1935	}
1936	if ((fRecordingStep == WAIT)) {
1937	setRecordingStatus(START);
1938	} else if (fRecordingStep == START) {
1939	setRecordingStatus(PAUSE);
1940	} else if (fRecordingStep == PAUSE) {
1941	setRecordingStatus(CONTINUE);
1942	} else if (fRecordingStep == CONTINUE) {
1943	setRecordingStatus(PAUSE);
1944	}
1945	}
1946
1947	void G4OpenGLQtViewer::setRecordingStatus(RECORDING_STEP step) {
1948
1949	fRecordingStep = step;
1950	displayRecordingStatus();
1951	}
1952
1953
1954	void G4OpenGLQtViewer::displayRecordingStatus() {
1955
1956	QString txtStatus = "";
1957	if (fRecordingStep == WAIT) {
1958	txtStatus = "Waiting to start...";
1959	fRecordFrameNumber = 0; // reset the frame number
1960	} else if (fRecordingStep == START) {
1961	txtStatus = "Start Recording...";
1962	} else if (fRecordingStep == PAUSE) {
1963	txtStatus = "Pause Recording...";
1964	} else if (fRecordingStep == CONTINUE) {
1965	txtStatus = "Continue Recording...";
1966	} else if (fRecordingStep == STOP) {
1967	txtStatus = "Stop Recording...";
1968	} else if (fRecordingStep == READY_TO_ENCODE) {
1969	txtStatus = "Ready to Encode...";
1970	} else if (fRecordingStep == ENCODING) {
1971	txtStatus = "Encoding...";
1972	} else if (fRecordingStep == FAILED) {
1973	txtStatus = "Failed to encode...";
1974	} else if ((fRecordingStep == BAD_ENCODER)
1975	\|\| (fRecordingStep == BAD_OUTPUT)
1976	\|\| (fRecordingStep == BAD_TMP)) {
1977	txtStatus = "Correct above errors first";
1978	} else if (fRecordingStep == SUCCESS) {
1979	txtStatus = "File encoded successfully";
1980	} else {
1981	}
1982
1983	if (fMovieParametersDialog) {
1984	fMovieParametersDialog->setRecordingStatus(txtStatus);
1985	} else {
1986	#if QT_VERSION < 0x040000
1987	G4cout << txtStatus.ascii() << G4endl;
1988	#else
1989	G4cout << txtStatus.toStdString().c_str() << G4endl;
1990	#endif
1991	}
1992	setRecordingInfos("");
1993	}
1994
1995
1996	void G4OpenGLQtViewer::setRecordingInfos(QString txt) {
1997	if (fMovieParametersDialog) {
1998	fMovieParametersDialog->setRecordingInfos(txt);
1999	} else {
2000	#if QT_VERSION < 0x040000
2001	G4cout << txt.ascii() << G4endl;
2002	#else
2003	G4cout << txt.toStdString().c_str() << G4endl;
2004	#endif
2005	}
2006	}
2007
2008	/** Init the movie parameters. Temp dir and encoder path
2009	*/
2010	void G4OpenGLQtViewer::initMovieParameters() {
2011	//init encoder
2012
2013	//look for encoderPath
2014	fProcess = new QProcess();
2015
2016	#if QT_VERSION < 0x040000
2017	QObject ::connect(fProcess,SIGNAL(processExited ()),
2018	this,SLOT(processLookForFinished()));
2019	fProcess->setCommunication(QProcess::DupStderr);
2020	fProcess->setArguments(QStringList("which mpeg_encode"));
2021	fProcess->start();
2022	#else
2023	QObject ::connect(fProcess,SIGNAL(finished ( int)),
2024	this,SLOT(processLookForFinished()));
2025	fProcess->setReadChannelMode(QProcess::MergedChannels);
2026	fProcess->start ("which mpeg_encode");
2027	#endif
2028
2029	}
2030
2031	/** @return encoder path or "" if it does not exist
2032	*/
2033	QString G4OpenGLQtViewer::getEncoderPath() {
2034	return fEncoderPath;
2035	}
2036
2037
2038	/**
2039	* set the new encoder path
2040	* @return "" if correct. The error otherwise
2041	*/
2042	QString G4OpenGLQtViewer::setEncoderPath(QString path) {
2043	if (path == "") {
2044	return "File does not exist";
2045	}
2046
2047	#if QT_VERSION < 0x040000
2048	path = QDir::cleanDirPath(path);
2049	#else
2050	path = QDir::cleanPath(path);
2051	#endif
2052	QFileInfo *f = new QFileInfo(path);
2053	if (!f->exists()) {
2054	return "File does not exist";
2055	} else if (f->isDir()) {
2056	return "This is a directory";
2057	} else if (!f->isExecutable()) {
2058	return "File exist but is not executable";
2059	} else if (!f->isFile()) {
2060	return "This is not a file";
2061	}
2062	fEncoderPath = path;
2063
2064	if ((fRecordingStep == BAD_ENCODER)) {
2065	setRecordingStatus(STOP);
2066	}
2067	return "";
2068	}
2069
2070
2071	bool G4OpenGLQtViewer::isRecording(){
2072	if ((fRecordingStep == START) \|\| (fRecordingStep == CONTINUE)) {
2073	return true;
2074	}
2075	return false;
2076	}
2077
2078	bool G4OpenGLQtViewer::isPaused(){
2079	if (fRecordingStep == PAUSE) {
2080	return true;
2081	}
2082	return false;
2083	}
2084
2085	bool G4OpenGLQtViewer::isEncoding(){
2086	if (fRecordingStep == ENCODING) {
2087	return true;
2088	}
2089	return false;
2090	}
2091
2092	bool G4OpenGLQtViewer::isWaiting(){
2093	if (fRecordingStep == WAIT) {
2094	return true;
2095	}
2096	return false;
2097	}
2098
2099	bool G4OpenGLQtViewer::isStopped(){
2100	if (fRecordingStep == STOP) {
2101	return true;
2102	}
2103	return false;
2104	}
2105
2106	bool G4OpenGLQtViewer::isFailed(){
2107	if (fRecordingStep == FAILED) {
2108	return true;
2109	}
2110	return false;
2111	}
2112
2113	bool G4OpenGLQtViewer::isSuccess(){
2114	if (fRecordingStep == SUCCESS) {
2115	return true;
2116	}
2117	return false;
2118	}
2119
2120	bool G4OpenGLQtViewer::isBadEncoder(){
2121	if (fRecordingStep == BAD_ENCODER) {
2122	return true;
2123	}
2124	return false;
2125	}
2126	bool G4OpenGLQtViewer::isBadTmp(){
2127	if (fRecordingStep == BAD_TMP) {
2128	return true;
2129	}
2130	return false;
2131	}
2132	bool G4OpenGLQtViewer::isBadOutput(){
2133	if (fRecordingStep == BAD_OUTPUT) {
2134	return true;
2135	}
2136	return false;
2137	}
2138
2139	void G4OpenGLQtViewer::setBadEncoder(){
2140	fRecordingStep = BAD_ENCODER;
2141	displayRecordingStatus();
2142	}
2143	void G4OpenGLQtViewer::setBadTmp(){
2144	fRecordingStep = BAD_TMP;
2145	displayRecordingStatus();
2146	}
2147	void G4OpenGLQtViewer::setBadOutput(){
2148	fRecordingStep = BAD_OUTPUT;
2149	displayRecordingStatus();
2150	}
2151
2152	void G4OpenGLQtViewer::setWaiting(){
2153	fRecordingStep = WAIT;
2154	displayRecordingStatus();
2155	}
2156
2157
2158	bool G4OpenGLQtViewer::isReadyToEncode(){
2159	if (fRecordingStep == READY_TO_ENCODE) {
2160	return true;
2161	}
2162	return false;
2163	}
2164
2165	void G4OpenGLQtViewer::resetRecording() {
2166	setRecordingStatus(WAIT);
2167	}
2168
2169	/**
2170	* set the temp folder path
2171	* @return "" if correct. The error otherwise
2172	*/
2173	QString G4OpenGLQtViewer::setTempFolderPath(QString path) {
2174
2175	if (path == "") {
2176	return "Path does not exist";
2177	}
2178	#if QT_VERSION < 0x040000
2179	path = QDir::cleanDirPath(path);
2180	#else
2181	path = QDir::cleanPath(path);
2182	#endif
2183	QFileInfo *d = new QFileInfo(path);
2184	if (!d->exists()) {
2185	return "Path does not exist";
2186	} else if (!d->isDir()) {
2187	return "This is not a directory";
2188	} else if (!d->isReadable()) {
2189	return path +" is read protected";
2190	} else if (!d->isWritable()) {
2191	return path +" is write protected";
2192	}
2193
2194	if ((fRecordingStep == BAD_TMP)) {
2195	setRecordingStatus(WAIT);
2196	}
2197	fTempFolderPath = path;
2198	return "";
2199	}
2200
2201	/** @return the temp folder path or "" if it does not exist
2202	*/
2203	QString G4OpenGLQtViewer::getTempFolderPath() {
2204	return fTempFolderPath;
2205	}
2206
2207	/**
2208	* set the save file name path
2209	* @return "" if correct. The error otherwise
2210	*/
2211	QString G4OpenGLQtViewer::setSaveFileName(QString path) {
2212
2213	if (path == "") {
2214	return "Path does not exist";
2215	}
2216
2217	QFileInfo *file = new QFileInfo(path);
2218	QDir dir = file->dir();
2219	#if QT_VERSION < 0x040000
2220	path = QDir::cleanDirPath(path);
2221	#else
2222	path = QDir::cleanPath(path);
2223	#endif
2224	if (file->exists()) {
2225	return "File already exist, please choose a new one";
2226	} else if (!dir.exists()) {
2227	return "Dir does not exist";
2228	} else if (!dir.isReadable()) {
2229	return path +" is read protected";
2230	}
2231
2232	if ((fRecordingStep == BAD_OUTPUT)) {
2233	setRecordingStatus(STOP);
2234	}
2235	fSaveFileName = path;
2236	return "";
2237	}
2238
2239	/** @return the save file path
2240	*/
2241	QString G4OpenGLQtViewer::getSaveFileName() {
2242	return fSaveFileName ;
2243	}
2244
2245	/** Create a Qt_temp folder in the temp folder given
2246	* The temp folder will be like this /tmp/QtMovie_12-02-2008_12_12_58/
2247	* @return "" if success. Error message if not.
2248	*/
2249	QString G4OpenGLQtViewer::createTempFolder() {
2250	fMovieTempFolderPath = "";
2251	//check
2252	QString tmp = setTempFolderPath(fTempFolderPath);
2253	if (tmp != "") {
2254	return tmp;
2255	}
2256	#if QT_VERSION < 0x040000
2257	QString sep = QChar(QDir::separator());
2258	#else
2259	QString sep = QString(QDir::separator());
2260	#endif
2261	QString path = sep+"QtMovie_"+QDateTime::currentDateTime ().toString("dd-MM-yyyy_hh-mm-ss")+sep;
2262	#if QT_VERSION < 0x040000
2263	QDir *d = new QDir(QDir::cleanDirPath(fTempFolderPath));
2264	#else
2265	QDir *d = new QDir(QDir::cleanPath(fTempFolderPath));
2266	#endif
2267	// check if it is already present
2268	if (d->exists(path)) {
2269	return "Folder "+path+" already exists.Please remove it first";
2270	}
2271	if (d->mkdir(fTempFolderPath+path)) {
2272	fMovieTempFolderPath = fTempFolderPath+path;
2273	return "";
2274	} else {
2275	return "Can't create "+fTempFolderPath+path;
2276	}
2277	return "-";
2278	}
2279
2280	/** Remove the Qt_temp folder in the temp folder
2281	*/
2282	QString G4OpenGLQtViewer::removeTempFolder() {
2283	// remove files in Qt_temp folder
2284	if (fMovieTempFolderPath == "") {
2285	return "";
2286	}
2287	#if QT_VERSION < 0x040000
2288	QDir *d = new QDir(QDir::cleanDirPath(fMovieTempFolderPath));
2289	#else
2290	QDir *d = new QDir(QDir::cleanPath(fMovieTempFolderPath));
2291	#endif
2292	if (!d->exists()) {
2293	return ""; // already remove
2294	}
2295
2296	d->setFilter( QDir::Files );
2297	QStringList subDirList = d->entryList();
2298	int res = true;
2299	QString error = "";
2300	for (QStringList::ConstIterator it = subDirList.begin() ;(it != subDirList.end()) ; it++) {
2301	const QString currentFile = *it;
2302	if (!d->remove(currentFile)) {
2303	res = false;
2304	QString file = fMovieTempFolderPath+currentFile;
2305	error +="Removing file failed : "+file;
2306	} else {
2307	}
2308	}
2309	if (res) {
2310	if (d->rmdir(fMovieTempFolderPath)) {
2311	fMovieTempFolderPath = "";
2312	return "";
2313	} else {
2314	return "Dir "+fMovieTempFolderPath+" should be empty, but could not remove it";
2315	}
2316
2317	}
2318	return "Could not remove "+fMovieTempFolderPath+" because of the following errors :"+error;
2319	}
2320
2321
2322
2323	bool G4OpenGLQtViewer::hasPendingEvents () {
2324	return ((QApplication*)G4Qt::getInstance ())->hasPendingEvents ();
2325	}
2326
2327	bool G4OpenGLQtViewer::generateMpegEncoderParameters () {
2328
2329	// save the parameter file
2330	FILE* fp;
2331	#if QT_VERSION < 0x040000
2332	fp = fopen (QString(fMovieTempFolderPath+fParameterFileName).ascii(), "w");
2333	#else
2334	fp = fopen (QString(fMovieTempFolderPath+fParameterFileName).toStdString().c_str(), "w");
2335	#endif
2336
2337	if (fp == NULL) {
2338	setRecordingInfos("Generation of parameter file failed");
2339	return false;
2340	}
2341
2342	fprintf (fp,"# parameter file template with lots of comments to assist you\n");
2343	fprintf (fp,"#\n");
2344	fprintf (fp,"# you can use this as a template, copying it to a separate file then modifying\n");
2345	fprintf (fp,"# the copy\n");
2346	fprintf (fp,"#\n");
2347	fprintf (fp,"#\n");
2348	fprintf (fp,"# any line beginning with '#' is a comment\n");
2349	fprintf (fp,"#\n");
2350	fprintf (fp,"# no line should be longer than 255 characters\n");
2351	fprintf (fp,"#\n");
2352	fprintf (fp,"#\n");
2353	fprintf (fp,"# general format of each line is:\n");
2354	fprintf (fp,"# \n");
2355	fprintf (fp,"#\n");
2356	fprintf (fp,"# lines can generally be in any order\n");
2357	fprintf (fp,"#\n");
2358	fprintf (fp,"# an exception is the option 'INPUT' which must be followed by input\n");
2359	fprintf (fp,"# files in the order in which they must appear, followed by 'END_INPUT'\n");
2360	fprintf (fp,"#\n");
2361	fprintf (fp,"# Also, if you use the `command` method of generating input file names,\n");
2362	fprintf (fp,"# the command will only be executed in the INPUT_DIR if INPUT_DIR preceeds\n");
2363	fprintf (fp,"# the INPUT parameter.\n");
2364	fprintf (fp,"#\n");
2365	fprintf (fp,"# MUST be in UPPER CASE\n");
2366	fprintf (fp,"#\n");
2367	fprintf (fp,"\n");
2368	fprintf (fp,"# Pattern affects speed, quality and compression. See the User's Guide\n");
2369	fprintf (fp,"# for more info.\n");
2370	fprintf (fp,"\n");
2371	fprintf (fp,"PATTERN IBBPBBPBBPBBPBBP\n");
2372	#if QT_VERSION < 0x040000
2373	fprintf (fp,"OUTPUT %s\n",getSaveFileName().ascii());
2374	#else
2375	fprintf (fp,"OUTPUT %s\n",getSaveFileName().toStdString().c_str());
2376	#endif
2377	fprintf (fp,"\n");
2378	fprintf (fp,"# mpeg_encode really only accepts 3 different file formats, but using a\n");
2379	fprintf (fp,"# conversion statement it can effectively handle ANY file format\n");
2380	fprintf (fp,"#\n");
2381	fprintf (fp,"# You must specify the type of the input files. The choices are:\n");
2382	fprintf (fp,"# YUV, PPM, JMOVIE, Y, JPEG, PNM\n");
2383	fprintf (fp,"# (must be upper case)\n");
2384	fprintf (fp,"#\n");
2385	fprintf (fp,"BASE_FILE_FORMAT PPM\n");
2386	fprintf (fp,"\n");
2387	fprintf (fp,"#\n");
2388	fprintf (fp,"# if YUV format (or using parallel version), must provide width and height\n");
2389	fprintf (fp,"# YUV_SIZE widthxheight\n");
2390	fprintf (fp,"# this option is ignored if BASE_FILE_FORMAT is not YUV and you're running\n");
2391	fprintf (fp,"# on just one machine\n");
2392	fprintf (fp,"#\n");
2393	fprintf (fp,"YUV_SIZE 352x240\n");
2394	fprintf (fp,"\n");
2395	fprintf (fp,"# If you are using YUV, there are different supported file formats.\n");
2396	fprintf (fp,"# EYUV or UCB are the same as previous versions of this encoder.\n");
2397	fprintf (fp,"# (All the Y's, then U's then V's, in 4:2:0 subsampling.)\n");
2398	fprintf (fp,"# Other formats, such as Abekas, Phillips, or a general format are\n");
2399	fprintf (fp,"# permissible, the general format is a string of Y's, U's, and V's\n");
2400	fprintf (fp,"# to specify the file order.\n");
2401	fprintf (fp,"\n");
2402	fprintf (fp,"INPUT_FORMAT UCB\n");
2403	fprintf (fp,"\n");
2404	fprintf (fp,"# the conversion statement\n");
2405	fprintf (fp,"#\n");
2406	fprintf (fp,"# Each occurrence of '*' will be replaced by the input file\n");
2407	fprintf (fp,"#\n");
2408	fprintf (fp,"# e.g., if you have a bunch of GIF files, then this might be:\n");
2409	fprintf (fp,"# INPUT_CONVERT giftoppm *\n");
2410	fprintf (fp,"#\n");
2411	fprintf (fp,"# e.g., if you have a bunch of files like a.Y a.U a.V, etc., then:\n");
2412	fprintf (fp,"# INPUT_CONVERT cat .Y .U *.V\n");
2413	fprintf (fp,"#\n");
2414	fprintf (fp,"# e.g., if you are grabbing from laser disc you might have something like\n");
2415	fprintf (fp,"# INPUT_CONVERT goto frame *; grabppm\n");
2416	fprintf (fp,"# 'INPUT_CONVERT *' means the files are already in the base file format\n");
2417	fprintf (fp,"#\n");
2418	fprintf (fp,"INPUT_CONVERT * \n");
2419	fprintf (fp,"\n");
2420	fprintf (fp,"# number of frames in a GOP.\n");
2421	fprintf (fp,"#\n");
2422	fprintf (fp,"# since each GOP must have at least one I-frame, the encoder will find the\n");
2423	fprintf (fp,"# the first I-frame after GOP_SIZE frames to start the next GOP\n");
2424	fprintf (fp,"#\n");
2425	fprintf (fp,"# later, will add more flexible GOP signalling\n");
2426	fprintf (fp,"#\n");
2427	fprintf (fp,"GOP_SIZE 16\n");
2428	fprintf (fp,"\n");
2429	fprintf (fp,"# number of slices in a frame\n");
2430	fprintf (fp,"#\n");
2431	fprintf (fp,"# 1 is a good number. another possibility is the number of macroblock rows\n");
2432	fprintf (fp,"# (which is the height divided by 16)\n");
2433	fprintf (fp,"#\n");
2434	fprintf (fp,"SLICES_PER_FRAME 1\n");
2435	fprintf (fp,"\n");
2436	fprintf (fp,"# directory to get all input files from (makes this file easier to read)\n");
2437	#if QT_VERSION < 0x040000
2438	fprintf (fp,"INPUT_DIR %s\n",fMovieTempFolderPath.ascii());
2439	#else
2440	fprintf (fp,"INPUT_DIR %s\n",fMovieTempFolderPath.toStdString().c_str());
2441	#endif
2442	fprintf (fp,"\n");
2443	fprintf (fp,"# There are a bunch of ways to specify the input files.\n");
2444	fprintf (fp,"# from a simple one-per-line listing, to the following \n");
2445	fprintf (fp,"# way of numbering them. See the manual for more information.\n");
2446	fprintf (fp,"INPUT\n");
2447	fprintf (fp,"# '*' is replaced by the numbers 01, 02, 03, 04\n");
2448	fprintf (fp,"# if I instead do [01-11], it would be 01, 02, ..., 09, 10, 11\n");
2449	fprintf (fp,"# if I instead do [1-11], it would be 1, 2, 3, ..., 9, 10, 11\n");
2450	fprintf (fp,"# if I instead do [1-11+3], it would be 1, 4, 7, 10\n");
2451	fprintf (fp,"# the program assumes none of your input files has a name ending in ']'\n");
2452	fprintf (fp,"# if you do, too bad!!!\n");
2453	fprintf (fp,"#\n");
2454	fprintf (fp,"#\n");
2455	fprintf (fp,"Test*.ppm [0-%d]\n",fRecordFrameNumber-1);
2456	fprintf (fp,"# can have more files here if you want...there is no limit on the number\n");
2457	fprintf (fp,"# of files\n");
2458	fprintf (fp,"END_INPUT\n");
2459	fprintf (fp,"\n");
2460	fprintf (fp,"\n");
2461	fprintf (fp,"\n");
2462	fprintf (fp,"# Many of the remaining options have to do with the motion search and qscale\n");
2463	fprintf (fp,"\n");
2464	fprintf (fp,"# FULL or HALF -- must be upper case\n");
2465	fprintf (fp,"# Should be FULL for computer generated images\n");
2466	fprintf (fp,"PIXEL FULL\n");
2467	fprintf (fp,"\n");
2468	fprintf (fp,"# means +/- this many pixels for both P and B frame searches\n");
2469	fprintf (fp,"# specify two numbers if you wish to serc different ranges in the two.\n");
2470	fprintf (fp,"RANGE 10\n");
2471	fprintf (fp,"\n");
2472	fprintf (fp,"# The two search algorithm parameters below mostly affect speed,\n");
2473	fprintf (fp,"# with some affect on compression and almost none on quality.\n");
2474	fprintf (fp,"\n");
2475	fprintf (fp,"# this must be one of {EXHAUSTIVE, SUBSAMPLE, LOGARITHMIC}\n");
2476	fprintf (fp,"PSEARCH_ALG LOGARITHMIC\n");
2477	fprintf (fp,"\n");
2478	fprintf (fp,"# this must be one of {SIMPLE, CROSS2, EXHAUSTIVE}\n");
2479	fprintf (fp,"#\n");
2480	fprintf (fp,"# note that EXHAUSTIVE is really, really, really slow\n");
2481	fprintf (fp,"#\n");
2482	fprintf (fp,"BSEARCH_ALG SIMPLE\n");
2483	fprintf (fp,"\n");
2484	fprintf (fp,"#\n");
2485	fprintf (fp,"# these specify the q-scale for I, P, and B frames\n");
2486	fprintf (fp,"# (values must be between 1 and 31)\n");
2487	fprintf (fp,"# These are the Qscale values for the entire frame in variable bit-rate\n");
2488	fprintf (fp,"# mode, and starting points (but not important) for constant bit rate\n");
2489	fprintf (fp,"#\n");
2490	fprintf (fp,"\n");
2491	fprintf (fp,"# Qscale (Quantization scale) affects quality and compression,\n");
2492	fprintf (fp,"# but has very little effect on speed.\n");
2493	fprintf (fp,"\n");
2494	fprintf (fp,"IQSCALE 4\n");
2495	fprintf (fp,"PQSCALE 5\n");
2496	fprintf (fp,"BQSCALE 12\n");
2497	fprintf (fp,"\n");
2498	fprintf (fp,"# this must be ORIGINAL or DECODED\n");
2499	fprintf (fp,"REFERENCE_FRAME ORIGINAL\n");
2500	fprintf (fp,"\n");
2501	fprintf (fp,"# for parallel parameters see parallel.param in the exmaples subdirectory\n");
2502	fprintf (fp,"\n");
2503	fprintf (fp,"# if you want constant bit-rate mode, specify it as follows (number is bits/sec):\n");
2504	fprintf (fp,"#BIT_RATE 1000000\n");
2505	fprintf (fp,"\n");
2506	fprintf (fp,"# To specify the buffer size (327680 is default, measused in bits, for 16bit words)\n");
2507	fprintf (fp,"BUFFER_SIZE 327680\n");
2508	fprintf (fp,"\n");
2509	fprintf (fp,"# The frame rate is the number of frames/second (legal values:\n");
2510	fprintf (fp,"# 23.976, 24, 25, 29.97, 30, 50 ,59.94, 60\n");
2511	fprintf (fp,"FRAME_RATE 30\n");
2512	fprintf (fp,"\n");
2513	fprintf (fp,"# There are many more options, see the users manual for examples....\n");
2514	fprintf (fp,"# ASPECT_RATIO, USER_DATA, GAMMA, IQTABLE, etc.\n");
2515	fprintf (fp,"\n");
2516	fprintf (fp,"\n");
2517	fclose (fp);
2518
2519	setRecordingInfos("Parameter file "+fParameterFileName+" generated in "+fMovieTempFolderPath);
2520	setRecordingStatus(READY_TO_ENCODE);
2521	return true;
2522	}
2523
2524	void G4OpenGLQtViewer::encodeVideo()
2525	{
2526	if ((getEncoderPath() != "") && (getSaveFileName() != "")) {
2527	setRecordingStatus(ENCODING);
2528
2529	#if QT_VERSION < 0x040000
2530	QStringList args = QStringList(fEncoderPath);
2531	args.push_back(fMovieTempFolderPath+fParameterFileName);
2532	fProcess = new QProcess(args);
2533	QObject ::connect(fProcess,SIGNAL(processExited ()),
2534	this,SLOT(processEncodeFinished()));
2535	QObject ::connect(fProcess,SIGNAL(readyReadStdout ()),
2536	this,SLOT(processEncodeStdout()));
2537	fProcess->setCommunication(QProcess::DupStderr);
2538	fProcess->launch("");
2539	#else
2540	fProcess = new QProcess();
2541	#if QT_VERSION > 0x040100
2542	QObject ::connect(fProcess,SIGNAL(finished ( int,QProcess::ExitStatus)),
2543	this,SLOT(processEncodeFinished()));
2544	QObject ::connect(fProcess,SIGNAL(readyReadStandardOutput ()),
2545	this,SLOT(processEncodeStdout()));
2546	#else
2547	QObject ::connect(fProcess,SIGNAL(finished ( int)),
2548	this,SLOT(processEncodeFinished()));
2549	QObject ::connect(fProcess,SIGNAL(readyReadStandardOutput ()),
2550	this,SLOT(processEncodeStdout()));
2551	#endif
2552	fProcess->setReadChannelMode(QProcess::MergedChannels);
2553	fProcess->start (fEncoderPath, QStringList(fMovieTempFolderPath+fParameterFileName));
2554	#endif
2555	}
2556	}
2557
2558
2559	void G4OpenGLQtViewer::drawText(
2560	const char * str
2561	,int x
2562	,int y
2563	,int z
2564	,int size ) {
2565
2566	#ifdef G4DEBUG_VIS_OGL
2567	printf ("G4OpenGLStoredQtViewer::drawText-position %d,%d,%d-----------------------------------------\n",x,y,z);
2568	#endif
2569
2570	QFont f1 = QFont("Courrier", size, QFont::Bold);
2571	f1.setPointSizeF(20);
2572
2573	// FIXME : Interesting border effect : resizing world resize detector
2574	// but not traces !
2575	glColor3d (0.123456,0.1234560,0.123456);
2576	fWindow->renderText (x,y,z,str,f1);
2577	glColor3d (0.321,0.321,0.321);
2578	}
2579
2580
2581	// FIXME : does not work on Qt3
2582	void G4OpenGLQtViewer::processEncodeStdout()
2583	{
2584	#if QT_VERSION > 0x040000
2585	QString tmp = fProcess->readAllStandardOutput ().data();
2586	int start = tmp.lastIndexOf("ESTIMATED TIME");
2587	tmp = tmp.mid(start,tmp.indexOf("\n",start)-start);
2588	#else
2589	QString tmp = fProcess->readStdout ().data();
2590	int start = tmp.findRev("ESTIMATED TIME");
2591	tmp = tmp.mid(start,tmp.find("\n",start)-start);
2592	#endif
2593	setRecordingInfos(tmp);
2594	}
2595
2596
2597	void G4OpenGLQtViewer::processEncodeFinished()
2598	{
2599
2600	QString txt = "";
2601	txt = getProcessErrorMsg();
2602	if (txt == "") {
2603	setRecordingStatus(SUCCESS);
2604	} else {
2605	setRecordingStatus(FAILED);
2606	}
2607	// setRecordingInfos(txt+removeTempFolder());
2608	}
2609
2610
2611	void G4OpenGLQtViewer::processLookForFinished()
2612	{
2613
2614	QString txt = getProcessErrorMsg();
2615	if (txt != "") {
2616	fEncoderPath = "";
2617	} else {
2618	#if QT_VERSION > 0x040000
2619	fEncoderPath = QString(fProcess->readAllStandardOutput ().data()).trimmed();
2620	#else
2621	fEncoderPath = QString(fProcess->readStdout ().data()).simplifyWhiteSpace();
2622	#endif
2623	// if not found, return "not found"
2624	if (fEncoderPath.contains(" ")) {
2625	fEncoderPath = "";
2626	} else if (!fEncoderPath.contains("mpeg_encode")) {
2627	fEncoderPath = "";
2628	}
2629	setEncoderPath(fEncoderPath);
2630	}
2631	// init temp folder
2632	#if QT_VERSION > 0x040000
2633	setTempFolderPath(QDir::temp ().absolutePath ());
2634	#else
2635	// Let's have a try
2636	setTempFolderPath("/tmp/");
2637	#endif
2638	}
2639
2640
2641	QString G4OpenGLQtViewer::getProcessErrorMsg()
2642	{
2643	QString txt = "";
2644	#if QT_VERSION < 0x040000
2645	if (!fProcess->normalExit ()) {
2646	txt = "Exist status "+ fProcess->exitStatus ();
2647	}
2648	#else
2649	if (fProcess->exitCode() != 0) {
2650	switch (fProcess->error()) {
2651	case QProcess::FailedToStart:
2652	txt = "The process failed to start. Either the invoked program is missing, or you may have insufficient permissions to invoke the program.\n";
2653	break;
2654	case QProcess::Crashed:
2655	txt = "The process crashed some time after starting successfully.\n";
2656	break;
2657	case QProcess::Timedout:
2658	txt = "The last waitFor...() function timed out. The state of QProcess is unchanged, and you can try calling waitFor...() again.\n";
2659	break;
2660	case QProcess::WriteError:
2661	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";
2662	break;
2663	case QProcess::ReadError:
2664	txt = "An error occurred when attempting to read from the process. For example, the process may not be running.\n";
2665	break;
2666	case QProcess::UnknownError:
2667	txt = "An unknown error occurred. This is the default return value of error().\n";
2668	break;
2669	}
2670	}
2671	#endif
2672	return txt;
2673	}
2674
2675	/*
2676
2677	void MultiLayer::exportToSVG(const QString& fname)
2678	{
2679	QPicture picture;
2680	QPainter p(&picture);
2681	for (int i=0;i<(int)graphsList->count();i++)
2682	{
2683	Graph gr=(Graph )graphsList->at(i);
2684	Plot myPlot= (Plot )gr->plotWidget();
2685
2686	QPoint pos=gr->pos();
2687
2688	int width=int(myPlot->frameGeometry().width());
2689	int height=int(myPlot->frameGeometry().height());
2690
2691	myPlot->print(&p, QRect(pos,QSize(width,height)));
2692	}
2693
2694	p.end();
2695	picture.save(fname, "svg");
2696	}
2697	*/
2698	#endif

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

Download in other formats: