Context Navigation

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

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

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

Download in other formats: