Context Navigation

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

Last change on this file since 870 was 866, checked in by garnier, 16 years ago
see history
Property svn:mime-type set to `text/cpp`
File size: 87.8 KB

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

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

Download in other formats: