Context Navigation

source: trunk/geant4/visualization/OpenGL/src/G4OpenGLQtViewer.cc @ 729

Last change on this file since 729 was 729, checked in by garnier, 17 years ago
correction du ticket #120
Property svn:mime-type set to `text/cpp`
File size: 70.6 KB

Line
1	//
2	// ********************************************************************
3	// * License and Disclaimer *
4	// * *
5	// * The Geant4 software is copyright of the Copyright Holders of *
6	// * the Geant4 Collaboration. It is provided under the terms and *
7	// * conditions of the Geant4 Software License, included in the file *
8	// * LICENSE and available at http://cern.ch/geant4/license . These *
9	// * include a list of copyright holders. *
10	// * *
11	// * Neither the authors of this software system, nor their employing *
12	// * institutes,nor the agencies providing financial support for this *
13	// * work make any representation or warranty, express or implied, *
14	// * regarding this software system or assume any liability for its *
15	// * use. Please see the license in the file LICENSE and URL above *
16	// * for the full disclaimer and the limitation of liability. *
17	// * *
18	// * This code implementation is the result of the scientific and *
19	// * technical work of the GEANT4 collaboration. *
20	// * By using, copying, modifying or distributing the software (or *
21	// * any work based on the software) you agree to acknowledge its *
22	// * use in resulting scientific publications, and indicate your *
23	// * acceptance of all terms of the Geant4 Software license. *
24	// ********************************************************************
25	//
26	//
27	// $Id: G4OpenGLQtViewer.cc,v 1.10 2008/01/30 10:54:13 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 "G4UnitsTable.hh"
51	#include "G4Qt.hh"
52	#include "G4UImanager.hh"
53	#include "G4UIcommandTree.hh"
54	#include <qapplication.h>
55	#include <qlayout.h>
56	#include <qdialog.h>
57	#include <qprocess.h>
58
59	#if QT_VERSION >= 0x040000
60	#include <qmenu.h>
61	#include <qimagewriter.h>
62	#else
63	#include <qaction.h>
64	#include <qwidgetlist.h>
65	#include <qpopupmenu.h>
66	#include <qimage.h>
67	#endif
68
69	#include <qapplication.h>
70	#include <qmessagebox.h>
71	#include <qfiledialog.h>
72	#include <qprinter.h>
73	#include <qpainter.h>
74	#include <qgl.h> // include <qglwidget.h>
75	#include <qdialog.h>
76	#include <qevent.h> //include <qcontextmenuevent.h>
77
78
79	//////////////////////////////////////////////////////////////////////////////
80	/**
81	Implementation of virtual method of G4VViewer
82	*/
83	void G4OpenGLQtViewer::SetView (
84	)
85	//////////////////////////////////////////////////////////////////////////////
86	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
87	{
88	#ifdef GEANT4_QT_DEBUG
89	printf("G4OpenGLQtViewer::SetView ++++++++++++++++++++\n");
90	#endif
91	// if(!fHDC) return;
92	// if(!fHGLRC) return;
93	// ::wglMakeCurrent(fHDC,fHGLRC);
94	// fWindow->makeCurrent();
95	G4OpenGLViewer::SetView ();
96	#ifdef GEANT4_QT_DEBUG
97	printf("G4OpenGLQtViewer::SetView --------------------\n");
98	#endif
99	}
100
101	/**
102	* Set the viewport of the scene
103	*/
104	void G4OpenGLQtViewer::setupViewport(int aWidth, int aHeight)
105	{
106	int side = aWidth;
107	if (aHeight < aWidth) side = aHeight;
108	glViewport((aWidth - side) / 2, (aHeight - side) / 2, side, side);
109
110	glMatrixMode(GL_PROJECTION);
111	glLoadIdentity();
112	glOrtho(-0.5, +0.5, +0.5, -0.5, 4.0, 15.0);
113	glMatrixMode(GL_MODELVIEW);
114	}
115
116
117	//////////////////////////////////////////////////////////////////////////////
118	/**
119	Implementation of virtual method of G4VViewer
120	*/
121	void G4OpenGLQtViewer::ShowView (
122	)
123	//////////////////////////////////////////////////////////////////////////////
124	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
125	{
126	#ifdef GEANT4_QT_DEBUG
127	printf("G4OpenGLQtViewer::ShowView +++++++++++++++++++++\n");
128	#endif
129	if (!GLWindow) {
130	G4cerr << "Visualization window not defined, please choose one before\n" << G4endl;
131	} else {
132	#if QT_VERSION < 0x040000
133	GLWindow->setActiveWindow();
134	#else
135	GLWindow->activateWindow();
136	#endif
137	#ifdef GEANT4_QT_DEBUG
138	printf("G4OpenGLQtViewer::ShowView -----------------------\n");
139	#endif
140	}
141	glFlush ();
142	// // Empty the Windows message queue :
143	// MSG event;
144	// while ( ::PeekMessage(&event, NULL, 0, 0, PM_REMOVE) ) {
145	// ::TranslateMessage(&event);
146	// ::DispatchMessage (&event);
147	// }
148	}
149
150
151
152	//////////////////////////////////////////////////////////////////////////////
153	void G4OpenGLQtViewer::CreateGLQtContext (
154	)
155	//////////////////////////////////////////////////////////////////////////////
156	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
157	{
158	#ifdef GEANT4_QT_DEBUG
159	printf("G4OpenGLQtViewer::CreateGLQtContext \n");
160	#endif
161	}
162
163
164	//////////////////////////////////////////////////////////////////////////////
165	void G4OpenGLQtViewer::CreateMainWindow (
166	QGLWidget* glWidget
167	)
168	//////////////////////////////////////////////////////////////////////////////
169	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
170	{
171
172	if(fWindow) return; //Done.
173	#ifdef GEANT4_QT_DEBUG
174	printf("G4OpenGLQtViewer::CreateMainWindow glWidget\n");
175	#endif
176
177	// launch Qt if not
178	G4Qt* interactorManager = G4Qt::getInstance ();
179	// G4UImanager* UI = G4UImanager::GetUIpointer();
180
181	fWindow = glWidget ;
182	// fWindow->makeCurrent();
183
184	// create window
185	if (((QApplication*)interactorManager->GetMainInteractor())) {
186	// look for the main window
187	bool found = false;
188	#if QT_VERSION < 0x040000
189	// theses lines does nothing exept this one "GLWindow = new QDialog(0..."
190	// but if I comment them, it doesn't work...
191	QWidgetList *list = QApplication::allWidgets();
192	QWidgetListIt it( *list ); // iterate over the widgets
193	QWidget * widget;
194	while ( (widget=it.current()) != 0 ) { // for each widget...
195	++it;
196	if ((found== false) && (widget->inherits("QMainWindow"))) {
197	GLWindow = new QDialog(0,0,FALSE,Qt::WStyle_Title \| Qt::WStyle_SysMenu \| Qt::WStyle_MinMax );
198	found = true;
199	}
200	}
201	delete list; // delete the list, not the widgets
202	#else
203	foreach (QWidget *widget, QApplication::allWidgets()) {
204	if ((found== false) && (widget->inherits("QMainWindow"))) {
205	GLWindow = new QDialog(0,Qt::WindowTitleHint \| Qt::WindowSystemMenuHint \| Qt::WindowMinMaxButtonsHint);
206	found = true;
207	}
208	}
209	#endif
210
211	#if QT_VERSION < 0x040000
212	glWidget->reparent(GLWindow,0,QPoint(0,0));
213	#else
214	glWidget->setParent(GLWindow);
215	#endif
216
217	if (found==false) {
218	#ifdef GEANT4_QT_DEBUG
219	printf("G4OpenGLQtViewer::CreateMainWindow case Qapp exist, but not found\n");
220	#endif
221	GLWindow = new QDialog();
222	}
223	} else {
224	#ifdef GEANT4_QT_DEBUG
225	printf("G4OpenGLQtViewer::CreateMainWindow case Qapp exist\n");
226	#endif
227	GLWindow = new QDialog();
228	}
229
230	QHBoxLayout *mainLayout = new QHBoxLayout(GLWindow);
231
232	mainLayout->addWidget(fWindow);
233
234	#if QT_VERSION < 0x040000
235	GLWindow->setCaption( tr( "QGl Viewer" ));
236	#else
237	GLWindow->setLayout(mainLayout);
238	GLWindow->setWindowTitle(tr("QGl Viewer"));
239	#endif
240	GLWindow->resize(300, 300);
241	GLWindow->move(900,300);
242	GLWindow->show();
243
244	// delete the pointer if close this
245	// GLWindow->setAttribute(Qt::WA_DeleteOnClose);
246
247	#if QT_VERSION >= 0x040000
248	// QObject ::connect(GLWindow,
249	// SIGNAL(rejected()),
250	// this,
251	// SLOT(dialogClosed()));
252	#endif
253
254	WinSize_x = 400;
255	WinSize_y = 400;
256	if (WinSize_x < fVP.GetWindowSizeHintX ())
257	WinSize_x = fVP.GetWindowSizeHintX ();
258	if (WinSize_y < fVP.GetWindowSizeHintY ())
259	WinSize_y = fVP.GetWindowSizeHintY ();
260
261	if(!fWindow) return;
262	#ifdef GEANT4_QT_DEBUG
263	printf("G4OpenGLQtViewer::CreateMainWindow glWidget END\n");
264	#endif
265
266	if (!fContextMenu)
267	createPopupMenu();
268
269	}
270
271	#if QT_VERSION >= 0x040000
272	/** Close the dialog and set the pointer to NULL
273	*/
274	// void G4OpenGLQtViewer::dialogClosed() {
275	// #ifdef GEANT4_QT_DEBUG
276	// printf("G4OpenGLQtViewer::dialogClosed END\n");
277	// #endif
278	// // GLWindow = NULL;
279	// }
280	#endif
281
282	//////////////////////////////////////////////////////////////////////////////
283	G4OpenGLQtViewer::G4OpenGLQtViewer (
284	G4OpenGLSceneHandler& scene
285	)
286	:G4VViewer (scene, -1)
287	,G4OpenGLViewer (scene)
288	,fWindow(0)
289	,fRecordFrames(false)
290	,fRecordFrameNumber(0)
291	,fContextMenu(0)
292	,fMouseAction(STYLE1)
293	,fDeltaRotation(1)
294	,fDeltaSceneTranslation(0.01)
295	,fDeltaDepth(0.01)
296	,fDeltaZoom(0.1)
297	,fDeltaMove(0.05)
298	,fHoldKeyEvent(false)
299	,fHoldMoveEvent(false)
300	,fHoldRotateEvent(false)
301	,fAutoMove(false)
302	{
303	#ifdef GEANT4_QT_DEBUG
304	printf("G4OpenGLQtViewer::G4OpenGLQtViewer \n");
305	#endif
306	}
307
308	//////////////////////////////////////////////////////////////////////////////
309	G4OpenGLQtViewer::~G4OpenGLQtViewer (
310	)
311	//////////////////////////////////////////////////////////////////////////////
312	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
313	{
314	#ifdef GEANT4_QT_DEBUG
315	printf("G4OpenGLQtViewer::~G4OpenGLQtViewer \n");
316	#endif
317	}
318
319
320	/**
321	Create a popup menu for the widget. This menu is activated by right-mouse click
322	*/
323	void G4OpenGLQtViewer::createPopupMenu() {
324
325	#if QT_VERSION < 0x040000
326	fContextMenu = new QPopupMenu( GLWindow,"All" );
327	#else
328	fContextMenu = new QMenu("All");
329	#endif
330
331	#if QT_VERSION < 0x040000
332	QPopupMenu *mMouseAction = new QPopupMenu( fContextMenu );
333	fContextMenu->insertItem("&Mouse actions",mMouseAction);
334	#if QT_VERSION < 0x030200
335	fRotateAction = new QAction("&Rotate","&Rotate",CTRL+Key_R,mMouseAction,0,true);
336	fMoveAction = new QAction("&Move","&Move",CTRL+Key_M,mMouseAction,0,true);
337	fPickAction = new QAction("&Pick","&Pick",CTRL+Key_P,mMouseAction,0,true);
338	QAction * shortcutsAction = new QAction("&Show shortcuts","&Show shortcuts",CTRL+Key_S,mMouseAction,0,true);
339	#else
340	fRotateAction = new QAction("&Rotate",CTRL+Key_R,mMouseAction);
341	fMoveAction = new QAction("&Move",CTRL+Key_M,mMouseAction);
342	fPickAction = new QAction("&Pick",CTRL+Key_P,mMouseAction);
343	QAction *shortcutsAction = new QAction("&Show shortcuts",CTRL+Key_S,mMouseAction);
344	#endif
345	fRotateAction->addTo(mMouseAction);
346	fMoveAction->addTo(mMouseAction);
347	fPickAction->addTo(mMouseAction);
348	shortcutsAction->addTo(mMouseAction);
349
350	fRotateAction->setToggleAction(true);
351	fMoveAction->setToggleAction(true);
352	fPickAction->setToggleAction(true);
353	shortcutsAction->setToggleAction(true);
354
355	fRotateAction->setOn(true);
356	fMoveAction->setOn(false);
357	fPickAction->setOn(false);
358	shortcutsAction->setOn(false);
359
360
361	QObject ::connect(fRotateAction,
362	SIGNAL(activated()),
363	this,
364	SLOT(actionMouseRotate()));
365
366	QObject ::connect(fMoveAction,
367	SIGNAL(activated()),
368	this,
369	SLOT(actionMouseMove()));
370
371	QObject ::connect(fPickAction,
372	SIGNAL(activated()),
373	this,
374	SLOT(actionMousePick()));
375
376	QObject ::connect(shortcutsAction,
377	SIGNAL(activated()),
378	this,
379	SLOT(showShortcuts()));
380
381	#else
382	QMenu *mMouseAction = fContextMenu->addMenu("&Mouse actions");
383
384	fRotateAction = mMouseAction->addAction("Rotate");
385	fMoveAction = mMouseAction->addAction("Move");
386	fPickAction = mMouseAction->addAction("Pick");
387	QAction *shortcutsAction = mMouseAction->addAction("Show shortcuts");
388
389	fRotateAction->setCheckable(true);
390	fMoveAction->setCheckable(false);
391	fPickAction->setCheckable(false);
392	shortcutsAction->setCheckable(false);
393
394	fRotateAction->setChecked(true);
395	fMoveAction->setChecked(false);
396	fPickAction->setChecked(false);
397	shortcutsAction->setChecked(false);
398
399	QObject ::connect(fRotateAction,
400	SIGNAL(triggered(bool)),
401	this,
402	SLOT(actionMouseRotate()));
403
404	QObject ::connect(fMoveAction,
405	SIGNAL(triggered(bool)),
406	this,
407	SLOT(actionMouseMove()));
408
409	QObject ::connect(fPickAction,
410	SIGNAL(triggered(bool)),
411	this,
412	SLOT(actionMousePick()));
413
414	QObject ::connect(shortcutsAction,
415	SIGNAL(triggered(bool)),
416	this,
417	SLOT(showShortcuts()));
418	#endif
419
420	#if QT_VERSION < 0x040000
421	// === Style Menu ===
422	QPopupMenu *mStyle = new QPopupMenu(fContextMenu);
423
424	QPopupMenu *mRepresentation = new QPopupMenu(fContextMenu);
425
426	QPopupMenu *mProjection = new QPopupMenu(fContextMenu);
427
428	#if QT_VERSION < 0x030200
429	QAction *polyhedron = new QAction("&Polyhedron","&Polyhedron",CTRL+Key_P,mRepresentation,0,true);
430	QAction *nurbs = new QAction("&NURBS","&NURBS",CTRL+Key_N,mRepresentation,0,true);
431
432	QAction *ortho = new QAction("&Orthographic","&Orthographic",CTRL+Key_O,mProjection,0,true);
433	QAction *perspective = new QAction("&Perspective","&Perspective",CTRL+Key_P,mProjection,0,true);
434	#else
435	QAction *polyhedron = new QAction("&Polyhedron",CTRL+Key_P,mRepresentation);
436	QAction *nurbs = new QAction("&NURBS",CTRL+Key_N,mRepresentation);
437
438	QAction *ortho = new QAction("&Orthographic",CTRL+Key_O,mProjection);
439	QAction *perspective = new QAction("&Perspective",CTRL+Key_P,mProjection);
440	polyhedron->setToggleAction(true);
441	nurbs->setToggleAction(true);
442	ortho->setToggleAction(true);
443	perspective->setToggleAction(true);
444	#endif
445	polyhedron->addTo(mRepresentation);
446	nurbs->addTo(mRepresentation);
447
448	ortho->addTo(mProjection);
449	perspective->addTo(mProjection);
450
451	mStyle->insertItem("&Representation",mRepresentation);
452	mStyle->insertItem("&Projection",mProjection);
453	fContextMenu->insertItem("&Style",mStyle);
454
455
456	#else
457	// === Style Menu ===
458	QMenu *mStyle = fContextMenu->addMenu("&Style");
459
460	QMenu *mRepresentation = mStyle->addMenu("&Representation");
461	QMenu *mProjection = mStyle->addMenu("&Projection");
462	QAction *polyhedron = mRepresentation->addAction("Polyhedron");
463	QAction *nurbs = mRepresentation->addAction("NURBS");
464
465	QAction *ortho = mProjection->addAction("Orthographic");
466	QAction *perspective = mProjection->addAction("Persepective");
467	#endif
468
469	// INIT mRepresentation
470	G4ViewParameters::RepStyle style;
471	style = fVP.GetRepStyle();
472	if (style == G4ViewParameters::polyhedron) {
473	createRadioAction(polyhedron,nurbs,SLOT(toggleRepresentation(bool)),1);
474	} else if (style == G4ViewParameters::nurbs) {
475	createRadioAction(polyhedron,nurbs,SLOT(toggleRepresentation(bool)),2);
476	} else {
477	mRepresentation->clear();
478	}
479
480	// INIT mProjection
481	if (fVP.GetFieldHalfAngle() == 0) {
482	createRadioAction(ortho, perspective,SLOT(toggleProjection(bool)),1);
483	} else {
484	createRadioAction(ortho, perspective,SLOT(toggleProjection(bool)),2);
485	}
486
487	#if QT_VERSION < 0x040000
488	// === Drawing Menu ===
489	QPopupMenu *mDrawing = new QPopupMenu(fContextMenu);
490	fContextMenu->insertItem("&Drawing",mDrawing);
491
492	#if QT_VERSION < 0x030200
493	fDrawingWireframe = new QAction("&Wireframe","&Wireframe",CTRL+Key_W,mDrawing,0,true);
494	fDrawingLineRemoval = new QAction("&Hidden line removal","&Hidden line removal",CTRL+Key_L,mDrawing,0,true);
495	fDrawingSurfaceRemoval = new QAction("&Hidden surface removal","&Hidden surface removal",CTRL+Key_S,mDrawing,0,true);
496	fDrawingLineSurfaceRemoval = new QAction("&Hidden line and surface removal","&Hidden line and surface removal",CTRL+Key_R,mDrawing,0,true);
497	#else
498	fDrawingWireframe = new QAction("&Wireframe",CTRL+Key_W,mDrawing);
499	fDrawingLineRemoval = new QAction("&Hidden line removal",CTRL+Key_L,mDrawing);
500	fDrawingSurfaceRemoval = new QAction("&Hidden surface removal",CTRL+Key_S,mDrawing);
501	fDrawingLineSurfaceRemoval = new QAction("&Hidden line and surface removal",CTRL+Key_R,mDrawing);
502	#endif
503	fDrawingWireframe->setToggleAction(true);
504	fDrawingLineRemoval->setToggleAction(true);
505	fDrawingSurfaceRemoval->setToggleAction(true);
506	fDrawingLineSurfaceRemoval->setToggleAction(true);
507
508	fDrawingWireframe->addTo(mDrawing);
509	fDrawingLineRemoval->addTo(mDrawing);
510	fDrawingSurfaceRemoval->addTo(mDrawing);
511	fDrawingLineSurfaceRemoval->addTo(mDrawing);
512
513
514	#else
515	// === Drawing Menu ===
516	QMenu *mDrawing = mStyle->addMenu("&Drawing");
517
518	fDrawingWireframe = mDrawing->addAction("Wireframe");
519	fDrawingWireframe->setCheckable(true);
520
521	fDrawingLineRemoval = mDrawing->addAction("Hidden line removal");
522	fDrawingLineRemoval->setCheckable(true);
523
524	fDrawingSurfaceRemoval = mDrawing->addAction("Hidden Surface removal");
525	fDrawingSurfaceRemoval->setCheckable(true);
526
527	fDrawingLineSurfaceRemoval = mDrawing->addAction("Hidden line and surface removal");
528	fDrawingLineSurfaceRemoval->setCheckable(true);
529	#endif
530	// INIT Drawing
531	G4ViewParameters::DrawingStyle d_style;
532	d_style = fVP.GetDrawingStyle();
533
534	#if QT_VERSION < 0x040000
535	if (d_style == G4ViewParameters::wireframe) {
536	fDrawingWireframe->setOn(true);
537	} else if (d_style == G4ViewParameters::hlr) {
538	fDrawingLineRemoval->setOn(true);
539	} else if (d_style == G4ViewParameters::hsr) {
540	fDrawingSurfaceRemoval->setOn(true);
541	} else if (d_style == G4ViewParameters::hlhsr) {
542	fDrawingLineSurfaceRemoval->setOn(true);
543	} else {
544	mDrawing->clear();
545	}
546	#ifdef GEANT4_QT_DEBUG
547	printf("G4OpenGLQtViewer:: fDrawingWireframe 1\n");
548	#endif
549	QObject ::connect(fDrawingWireframe,
550	SIGNAL(activated()),
551	this,
552	SLOT(actionDrawingWireframe()));
553	#ifdef GEANT4_QT_DEBUG
554	printf("G4OpenGLQtViewer:: fDrawingWireframe 2\n");
555	#endif
556	QObject ::connect(fDrawingLineRemoval,
557	SIGNAL(activated()),
558	this,
559	SLOT(actionDrawingLineRemoval()));
560	QObject ::connect(fDrawingSurfaceRemoval,
561	SIGNAL(activated()),
562	this,
563	SLOT(actionDrawingSurfaceRemoval()));
564	QObject ::connect(fDrawingLineSurfaceRemoval,
565	SIGNAL(activated()),
566	this,
567	SLOT(actionDrawingLineSurfaceRemoval()));
568	#else
569	if (d_style == G4ViewParameters::wireframe) {
570	fDrawingWireframe->setChecked(true);
571	} else if (d_style == G4ViewParameters::hlr) {
572	fDrawingLineRemoval->setChecked(true);
573	} else if (d_style == G4ViewParameters::hsr) {
574	fDrawingSurfaceRemoval->setChecked(true);
575	} else if (d_style == G4ViewParameters::hlhsr) {
576	fDrawingLineSurfaceRemoval->setChecked(true);
577	} else {
578	mDrawing->clear();
579	}
580	QObject ::connect(fDrawingWireframe,
581	SIGNAL(triggered(bool)),
582	this,
583	SLOT(actionDrawingWireframe()));
584	QObject ::connect(fDrawingLineRemoval,
585	SIGNAL(triggered(bool)),
586	this,
587	SLOT(actionDrawingLineRemoval()));
588	QObject ::connect(fDrawingSurfaceRemoval,
589	SIGNAL(triggered(bool)),
590	this,
591	SLOT(actionDrawingSurfaceRemoval()));
592	QObject ::connect(fDrawingLineSurfaceRemoval,
593	SIGNAL(triggered(bool)),
594	this,
595	SLOT(actionDrawingLineSurfaceRemoval()));
596	#endif
597
598
599
600	#if QT_VERSION < 0x040000
601	QPopupMenu *mBackground = new QPopupMenu(mStyle);
602	mStyle->insertItem("&Background color",mBackground);
603
604	#if QT_VERSION < 0x030200
605	QAction *white = new QAction("&White","&White",CTRL+Key_W,mBackground,0,true);
606	QAction *black = new QAction("&Black","&Black",CTRL+Key_B,mBackground,0,true);
607	#else
608	QAction *white = new QAction("&White",CTRL+Key_W,mBackground);
609	QAction *black = new QAction("&Black",CTRL+Key_B,mBackground);
610	white->setToggleAction(true);
611	black->setToggleAction(true);
612	#endif
613	white->addTo(mBackground);
614	black->addTo(mBackground);
615
616	#else
617	QMenu *mBackground = mStyle->addMenu("&Background color");
618	QAction *white = mBackground->addAction("White");
619	QAction *black = mBackground->addAction("Black");
620
621	#endif
622	if (background.GetRed() == 1. &&
623	background.GetGreen() == 1. &&
624	background.GetBlue() == 1.) {
625	createRadioAction(white,black,SLOT(toggleBackground(bool)),1);
626	} else {
627	createRadioAction(white,black,SLOT(toggleBackground(bool)),2);
628	}
629
630
631	#if QT_VERSION < 0x040000
632	// === Action Menu ===
633	QPopupMenu *mActions = new QPopupMenu(fContextMenu);
634	fContextMenu->insertItem("&Actions",mActions);
635
636	#if QT_VERSION < 0x030200
637	QAction *createEPS = new QAction("&Save as ...","&Save as ...",CTRL+Key_S,mActions,0,true);
638	#else
639	QAction *createEPS = new QAction("&Save as ...",CTRL+Key_S,mActions);
640	#endif
641	createEPS->addTo(mActions);
642	QObject ::connect(createEPS,
643	SIGNAL(activated()),
644	this,
645	SLOT(actionCreateEPS()));
646
647	#else
648	// === Action Menu ===
649	QMenu *mActions = fContextMenu->addMenu("&Actions");
650	QAction *createEPS = mActions->addAction("Save as ...");
651	QObject ::connect(createEPS,
652	SIGNAL(triggered()),
653	this,
654	SLOT(actionCreateEPS()));
655	#endif
656
657
658
659	#if QT_VERSION < 0x040000
660	// === Special Menu ===
661	QPopupMenu *mSpecial = new QPopupMenu(fContextMenu);
662	fContextMenu->insertItem("S&pecial",mSpecial);
663
664	QPopupMenu *mTransparency = new QPopupMenu(mSpecial);
665	mSpecial->insertItem("Transparency",mTransparency);
666
667	#if QT_VERSION < 0x030200
668	QAction *transparencyOn = new QAction("&On","&On",CTRL+Key_O,mTransparency,0,true);
669	QAction *transparencyOff = new QAction("&Off","&Off",CTRL+Key_F,mTransparency,0,true);
670	#else
671	QAction *transparencyOn = new QAction("&On",CTRL+Key_O,mTransparency);
672	QAction *transparencyOff = new QAction("&Off",CTRL+Key_F,mTransparency);
673	transparencyOn->setToggleAction(true);
674	transparencyOff->setToggleAction(true);
675	#endif
676	transparencyOn->addTo(mTransparency);
677	transparencyOff->addTo(mTransparency);
678
679	#else
680	// === Special Menu ===
681	QMenu *mSpecial = fContextMenu->addMenu("S&pecial");
682	QMenu *mTransparency = mSpecial->addMenu("Transparency");
683	QAction *transparencyOn = mTransparency->addAction("On");
684	QAction *transparencyOff = mTransparency->addAction("Off");
685	#endif
686
687	if (transparency_enabled == false) {
688	createRadioAction(transparencyOn,transparencyOff,SLOT(toggleTransparency(bool)),2);
689	} else if (transparency_enabled == true) {
690	createRadioAction(transparencyOn,transparencyOff,SLOT(toggleTransparency(bool)),1);
691	} else {
692	mSpecial->clear();
693	}
694
695
696	#if QT_VERSION < 0x040000
697	QPopupMenu *mAntialiasing = new QPopupMenu(mSpecial);
698	mSpecial->insertItem("Antialiasing",mAntialiasing);
699
700	#if QT_VERSION < 0x030200
701	QAction *antialiasingOn = new QAction("&On","&On",CTRL+Key_O,mAntialiasing,0,true);
702	QAction *antialiasingOff = new QAction("&Off","&Off",CTRL+Key_F,mAntialiasing,0,true);
703	#else
704	QAction *antialiasingOn = new QAction("&On",CTRL+Key_O,mAntialiasing);
705	QAction *antialiasingOff = new QAction("&Off",CTRL+Key_F,mAntialiasing);
706	antialiasingOn->setToggleAction(true);
707	antialiasingOff->setToggleAction(true);
708	#endif
709	antialiasingOn->addTo(mAntialiasing);
710	antialiasingOff->addTo(mAntialiasing);
711
712	#else
713	QMenu *mAntialiasing = mSpecial->addMenu("Antialiasing");
714	QAction *antialiasingOn = mAntialiasing->addAction("On");
715	QAction *antialiasingOff = mAntialiasing->addAction("Off");
716	#endif
717
718	if (antialiasing_enabled == false) {
719	createRadioAction(antialiasingOn,antialiasingOff,SLOT(toggleAntialiasing(bool)),2);
720	} else if (antialiasing_enabled == true) {
721	createRadioAction(antialiasingOn,antialiasingOff,SLOT(toggleAntialiasing(bool)),1);
722	} else {
723	mAntialiasing->clear();
724	}
725
726	#if QT_VERSION < 0x040000
727	QPopupMenu *mHaloing = new QPopupMenu(mSpecial);
728	mSpecial->insertItem("Haloing",mHaloing);
729
730	#if QT_VERSION < 0x030200
731	QAction *haloingOn = new QAction("&On","&On",CTRL+Key_O,mHaloing,0,true);
732	QAction *haloingOff = new QAction("&Off","&Off",CTRL+Key_F,mHaloing,0,true);
733	#else
734	QAction *haloingOn = new QAction("&On",CTRL+Key_O,mHaloing);
735	QAction *haloingOff = new QAction("&Off",CTRL+Key_F,mHaloing);
736	haloingOn->setToggleAction(true);
737	haloingOff->setToggleAction(true);
738	#endif
739	haloingOn->addTo(mHaloing);
740	haloingOff->addTo(mHaloing);
741	#else
742	QMenu *mHaloing = mSpecial->addMenu("Haloing");
743	QAction *haloingOn = mHaloing->addAction("On");
744	QAction *haloingOff = mHaloing->addAction("Off");
745	#endif
746	if (haloing_enabled == false) {
747	createRadioAction(haloingOn,haloingOff,SLOT(toggleHaloing(bool)),2);
748	} else if (haloing_enabled == true) {
749	createRadioAction(haloingOn,haloingOff,SLOT(toggleHaloing(bool)),1);
750	} else {
751	mHaloing->clear();
752	}
753
754	#if QT_VERSION < 0x040000
755	QPopupMenu *mAux = new QPopupMenu(mSpecial);
756	mSpecial->insertItem("Auxiliairy edges",mAux);
757
758	#if QT_VERSION < 0x030200
759	QAction *auxOn = new QAction("&On","&On",CTRL+Key_O,mAux,0,true);
760	QAction *auxOff = new QAction("&Off","&Off",CTRL+Key_F,mAux,0,true);
761	#else
762	QAction *auxOn = new QAction("&On",CTRL+Key_O,mAux);
763	QAction *auxOff = new QAction("&Off",CTRL+Key_F,mAux);
764	auxOn->setToggleAction(true);
765	auxOff->setToggleAction(true);
766	#endif
767	auxOn->addTo(mAux);
768	auxOff->addTo(mAux);
769
770	#else
771	QMenu *mAux = mSpecial->addMenu("Auxiliary edges");
772	QAction *auxOn = mAux->addAction("On");
773	QAction *auxOff = mAux->addAction("Off");
774	#endif
775	if (!fVP.IsAuxEdgeVisible()) {
776	createRadioAction(auxOn,auxOff,SLOT(toggleAux(bool)),1);
777	} else {
778	createRadioAction(auxOn,auxOff,SLOT(toggleAux(bool)),2);
779	}
780
781
782
783	#if QT_VERSION < 0x040000
784	QPopupMenu *mFullScreen = new QPopupMenu(mSpecial);
785	mSpecial->insertItem("Full screen",mFullScreen);
786
787	#if QT_VERSION < 0x030200
788	fFullScreenOn = new QAction("&On","&On",CTRL+Key_O,mFullScreen,0,true);
789	fFullScreenOff = new QAction("&Off","&Off",CTRL+Key_F,mFullScreen,0,true);
790	#else
791	fFullScreenOn = new QAction("&On",CTRL+Key_O,mFullScreen);
792	fFullScreenOff = new QAction("&Off",CTRL+Key_F,mFullScreen);
793	fFullScreenOn->setToggleAction(true);
794	fFullScreenOff->setToggleAction(true);
795	#endif
796	fFullScreenOn->addTo(mFullScreen);
797	fFullScreenOff->addTo(mFullScreen);
798	#else
799	QMenu *mFullScreen = mSpecial->addMenu("&Full screen");
800	fFullScreenOn = mFullScreen->addAction("On");
801	fFullScreenOff = mFullScreen->addAction("Off");
802	#endif
803	createRadioAction(fFullScreenOn,fFullScreenOff,SLOT(toggleFullScreen(bool)),2);
804
805	}
806
807	void G4OpenGLQtViewer::manageContextMenuEvent(QContextMenuEvent *e)
808	{
809	if (!GLWindow) {
810	G4cerr << "Visualization window not defined, please choose one before\n" << G4endl;
811	} else {
812
813	if (!fContextMenu)
814	createPopupMenu();
815
816	// launch menu
817	if ( fContextMenu ) {
818	fContextMenu->exec( e->globalPos() );
819	// delete fContextMenu;
820	}
821	}
822	e->accept();
823	}
824
825
826	/**
827	Create a radio button menu. The two menu will be connected. When click on one,
828	eatch state will be invert and callback method will be called.
829	@param action1 first action to connect
830	@param action2 second action to connect
831	@param method callback method
832	@param nCheck: 1 : first action will be set true. 2 : second action will be set true
833	*/
834	#if QT_VERSION < 0x040000
835	void G4OpenGLQtViewer::createRadioAction(QAction action1,QAction action2, const std::string& method,unsigned int nCheck) {
836
837	if (action1->parent()->inherits("QPopupMenu")){
838	((QPopupMenu*)action1->parent())->setCheckable(true);
839	((QPopupMenu*)action2->parent())->setCheckable(true);
840	}
841	action1->setOn(false);
842	action2->setOn(false);
843
844	if (nCheck ==1)
845	action1->setOn(true);
846	else
847	action2->setOn(true);
848
849	//FIXME : Should not work on Qt3
850	QObject ::connect(action1, SIGNAL(activated()),action2, SLOT(toggle()));
851	QObject ::connect(action2, SIGNAL(activated()),action1, SLOT(toggle()));
852
853	QObject ::connect(action1, SIGNAL(toggled(bool)),this, method.c_str());
854	}
855
856	#else
857	void G4OpenGLQtViewer::createRadioAction(QAction action1,QAction action2, const std::string& method,unsigned int nCheck) {
858
859	action1->setCheckable(true);
860	action2->setCheckable(true);
861
862	if (nCheck ==1)
863	action1->setChecked (true);
864	else
865	action2->setChecked (true);
866
867	QObject ::connect(action1, SIGNAL(triggered(bool)),action2, SLOT(toggle()));
868	QObject ::connect(action2, SIGNAL(triggered(bool)),action1, SLOT(toggle()));
869
870	QObject ::connect(action1, SIGNAL(toggled(bool)),this, method.c_str());
871
872	}
873	#endif
874
875	/**
876	Slot activate when mouseAction->rotate menu is set
877	*/
878	void G4OpenGLQtViewer::actionMouseRotate() {
879	emit toggleMouseAction(STYLE1);
880	}
881
882
883	/**
884	Slot activate when mouseAction->rotate menu is set
885	*/
886	void G4OpenGLQtViewer::actionMouseMove() {
887	emit toggleMouseAction(STYLE2);
888	}
889
890
891	/**
892	Slot activate when mouseAction->zoom menu is set
893	*/
894	void G4OpenGLQtViewer::actionMousePick() {
895	#ifdef GEANT4_QT_DEBUG
896	printf("G4OpenGLQtViewer::actionMousePick \n");
897	#endif
898	emit toggleMouseAction(STYLE3);
899	}
900
901
902	/**
903	Slot activate when drawing->wireframe menu is set
904	*/
905	void G4OpenGLQtViewer::actionDrawingWireframe() {
906	emit toggleDrawingAction(1);
907	}
908
909	/**
910	Slot activate when drawing->line removal menu is set
911	*/
912	void G4OpenGLQtViewer::actionDrawingLineRemoval() {
913	emit toggleDrawingAction(2);
914	}
915
916	/**
917	Slot activate when drawing->surface removal menu is set
918	*/
919	void G4OpenGLQtViewer::actionDrawingSurfaceRemoval() {
920	emit toggleDrawingAction(3);
921	}
922
923	/**
924	Slot activate when drawing->wireframe menu is set
925	*/
926	void G4OpenGLQtViewer::actionDrawingLineSurfaceRemoval() {
927	emit toggleDrawingAction(4);
928	}
929
930
931	/**
932	Slot activated when mouse action is toggle
933	@param aAction : STYLE1, STYLE2, STYLE3
934	*/
935	void G4OpenGLQtViewer::toggleMouseAction(mouseActions aAction) {
936
937	if ((aAction == STYLE1) \|\| //initialize all
938	(aAction == STYLE2) \|\|
939	(aAction == STYLE3)) {
940	#if QT_VERSION < 0x040000
941	fRotateAction->setOn (false);
942	fMoveAction->setOn (false);
943	fPickAction->setOn (false);
944	#else
945	fRotateAction->setChecked (false);
946	fMoveAction->setChecked (false);
947	fPickAction->setChecked (false);
948	#endif
949	fVP.SetPicking(false);
950	fMouseAction = aAction;
951	}
952	// rotate
953	if (aAction == STYLE1) { // rotate
954	showShortcuts();
955	#if QT_VERSION < 0x040000
956	fRotateAction->setOn (true);
957	#else
958	fRotateAction->setChecked (true);
959	#endif
960	} else if (aAction == STYLE2) { //move
961	#if QT_VERSION < 0x040000
962	fMoveAction->setOn (true);
963	#else
964	fMoveAction->setChecked (true);
965	#endif
966	} else if (aAction == STYLE3) { //pick
967	#if QT_VERSION < 0x040000
968	fPickAction->setOn (true);
969	#else
970	fPickAction->setChecked (true);
971	#endif
972	fVP.SetPicking(true);
973	}
974	}
975
976	/**
977	Show shortcuts for this mouse action
978	*/
979	void G4OpenGLQtViewer::showShortcuts() {
980	if (fMouseAction == STYLE1) { // rotate
981	G4cout << "Click and move mouse to rotate volume \n" << G4endl;
982	G4cout << "Press left/right arrows to move volume left/right\n" << G4endl;
983	G4cout << "Press up/down arrows to move volume up/down\n" << G4endl;
984	G4cout << "Press ALT+up/down arrows to move volume toward/forward\n" << G4endl;
985	G4cout << "Press SHIFT+left/right arrows to rotate volume left/right\n" << G4endl;
986	G4cout << "Press SHIFT+up/down arrows to rotate volume up/down\n" << G4endl;
987	G4cout << "Press ALT+/- to slow/speed auto rotation/move\n" << G4endl;
988	G4cout << "In video mode : \n" << G4endl;
989	G4cout << " Press SPACE to Start/Pause video recording \n" << G4endl;
990	G4cout << " Press RETURN to Stop video recording \n" << G4endl;
991	} else if (fMouseAction == STYLE2) { //move
992	G4cout << "Move camera point of view with mouse\n" << G4endl;
993	G4cout << "Press left/right arrows to move volume left/right\n" << G4endl;
994	G4cout << "Press up/down arrows to move volume up/down\n" << G4endl;
995	G4cout << "Press ALT+up/down arrows to move volume toward/forward\n" << G4endl;
996	G4cout << "Press SHIFT+left/right arrows to rotate volume left/right\n" << G4endl;
997	G4cout << "Press SHIFT+up/down arrows to rotate volume up/down\n" << G4endl;
998	G4cout << "Press +/- to zoom into volume\n" << G4endl;
999	G4cout << "Press ALT+/- to slow/speed auto rotation/move\n" << G4endl;
1000	G4cout << "In video mode : \n" << G4endl;
1001	G4cout << " Press SPACE to Start/Pause video recording \n" << G4endl;
1002	G4cout << " Press RETURN to Stop video recording \n" << G4endl;
1003	} else if (fMouseAction == STYLE3) { //pick
1004	G4cout << "Click and pick \n" << G4endl;
1005	}
1006
1007	}
1008
1009
1010
1011	/**
1012	Slot activated when drawing menu is toggle
1013	Warning : When G4OpenGLStoredQtViewer::DrawView() method call,
1014	KernelVisitDecision () will be call and will set the fNeedKernelVisit
1015	to 1. See G4XXXStoredViewer::CompareForKernelVisit for explanations.
1016	It will cause a redraw of the view
1017	@param aAction : 1 wireframe, 2 line removal, 3 surface removal, 4 line & surface removal
1018	@see G4OpenGLStoredQtViewer::DrawView
1019	@see G4XXXStoredViewer::CompareForKernelVisit
1020	*/
1021	void G4OpenGLQtViewer::toggleDrawingAction(int aAction) {
1022
1023	G4ViewParameters::DrawingStyle d_style;
1024
1025
1026	// initialize
1027	if ((aAction >0) && (aAction <5)) {
1028	#if QT_VERSION < 0x040000
1029	fDrawingWireframe->setOn(false);
1030	fDrawingLineRemoval->setOn(false);
1031	fDrawingSurfaceRemoval->setOn(false);
1032	fDrawingLineSurfaceRemoval->setOn(false);
1033	#else
1034	fDrawingWireframe->setChecked (false);
1035	fDrawingLineRemoval->setChecked (false);
1036	fDrawingSurfaceRemoval->setChecked (false);
1037	fDrawingLineSurfaceRemoval->setChecked (false);
1038	#endif
1039	}
1040	if (aAction ==1) {
1041	#if QT_VERSION < 0x040000
1042	fDrawingWireframe->setOn(true);
1043	#else
1044	fDrawingWireframe->setChecked (true);
1045	#endif
1046
1047	d_style = G4ViewParameters::wireframe;
1048
1049	} else if (aAction ==2) {
1050	#if QT_VERSION < 0x040000
1051	fDrawingLineRemoval->setOn(true);
1052	#else
1053	fDrawingLineRemoval->setChecked (true);
1054	#endif
1055
1056	d_style = G4ViewParameters::hlr;
1057
1058	} else if (aAction ==3) {
1059	#if QT_VERSION < 0x040000
1060	fDrawingSurfaceRemoval->setOn(true);
1061	#else
1062	fDrawingSurfaceRemoval->setChecked (true);
1063	#endif
1064
1065	d_style = G4ViewParameters::hsr;
1066
1067	} else if (aAction ==4) {
1068	#if QT_VERSION < 0x040000
1069	fDrawingLineSurfaceRemoval->setOn(true);
1070	#else
1071	fDrawingLineSurfaceRemoval->setChecked (true);
1072	#endif
1073	d_style = G4ViewParameters::hlhsr;
1074	}
1075	fVP.SetDrawingStyle(d_style);
1076
1077	updateQWidget();
1078	}
1079
1080
1081	/**
1082	SLOT Activate by a click on the representation menu
1083	Warning : When G4OpenGLStoredQtViewer::DrawView() method call,
1084	KernelVisitDecision () will be call and will set the fNeedKernelVisit
1085	to 1. See G4XXXStoredViewer::CompareForKernelVisit for explanations.
1086	It will cause a redraw of the view
1087	@param check : 1 polyhedron, 0 nurbs
1088	@see G4OpenGLStoredQtViewer::DrawView
1089	@see G4XXXStoredViewer::CompareForKernelVisit
1090	*/
1091	void G4OpenGLQtViewer::toggleRepresentation(bool check) {
1092
1093	G4ViewParameters::RepStyle style;
1094	if (check == 1) {
1095	style = G4ViewParameters::polyhedron;
1096	} else {
1097	style = G4ViewParameters::nurbs;
1098	}
1099	fVP.SetRepStyle (style);
1100
1101	updateQWidget();
1102	}
1103
1104	/**
1105	SLOT Activate by a click on the projection menu
1106	Warning : When G4OpenGLStoredQtViewer::DrawView() method call,
1107	KernelVisitDecision () will be call and will set the fNeedKernelVisit
1108	to 1. See G4XXXStoredViewer::CompareForKernelVisit for explanations.
1109	It will cause a redraw of the view
1110	@param check : 1 orthographic, 2 perspective
1111	@see G4OpenGLStoredQtViewer::DrawView
1112	@see G4XXXStoredViewer::CompareForKernelVisit
1113	*/
1114	void G4OpenGLQtViewer::toggleProjection(bool check) {
1115
1116	if (check == 1) {
1117	fVP.SetFieldHalfAngle (0);
1118	} else {
1119
1120	// look for the default parameter hidden in G4UIcommand parameters
1121	G4UImanager* UI = G4UImanager::GetUIpointer();
1122	if(UI==NULL)
1123	return;
1124	G4UIcommandTree * treeTop = UI->GetTree();
1125
1126	// find command
1127	G4UIcommand* command = treeTop->FindPath("/vis/viewer/set/projection");
1128	if (!command)
1129	return;
1130
1131	// find param
1132	G4UIparameter * angleParam = NULL;
1133	for(G4int i=0; i<command->GetParameterEntries(); i++)
1134	{
1135	if( command->GetParameter(i)->GetParameterName() == "field-half-angle" ) {
1136	angleParam = command->GetParameter(i);
1137	}
1138	}
1139	if (!angleParam)
1140	return;
1141
1142	// find unit
1143	G4UIparameter * unitParam = NULL;
1144	for(G4int i=0; i<command->GetParameterEntries(); i++)
1145	{
1146	if( command->GetParameter(i)->GetParameterName() == "unit" ) {
1147	unitParam = command->GetParameter(i);
1148	}
1149	}
1150	if (!unitParam)
1151	return;
1152
1153	G4double defaultValue = command->ConvertToDouble(angleParam->GetDefaultValue())
1154	* G4UnitDefinition::GetValueOf(unitParam->GetDefaultValue());
1155	if (defaultValue > 89.5 \|\| defaultValue <= 0.0) {
1156	G4cerr << "Field half angle should be 0 < angle <= 89.5 degrees. Check your default Field half angle parameter\n";
1157	} else {
1158	G4cout << "Perspective view has been set to default value. Field half angle="<<angleParam->GetDefaultValue() <<" \n" << G4endl;
1159	fVP.SetFieldHalfAngle (defaultValue);
1160	SetView ();
1161	}
1162	}
1163	updateQWidget();
1164	}
1165
1166
1167	/**
1168	SLOT Activate by a click on the background menu
1169	@param check : 1 white, 0 black
1170	*/
1171	void G4OpenGLQtViewer::toggleBackground(bool check) {
1172
1173	// //I need to revisit the kernel if the background colour changes and
1174	// //hidden line removal is enabled, because hlr drawing utilises the
1175	// //background colour in its drawing...
1176	// // (Note added by JA 13/9/2005) Background now handled in view
1177	// // parameters. A kernel visit is triggered on change of background.
1178	if (check == 1) {
1179	((G4ViewParameters&)this->GetViewParameters()).
1180	SetBackgroundColour(G4Colour(1.,1.,1.)); // White
1181	} else {
1182	((G4ViewParameters&)this->GetViewParameters()).
1183	SetBackgroundColour(G4Colour(0.,0.,0.)); // Black
1184	}
1185	updateQWidget();
1186	}
1187
1188	/**
1189	SLOT Activate by a click on the transparency menu
1190	@param check : 1 , 0
1191	*/
1192	void G4OpenGLQtViewer::toggleTransparency(bool check) {
1193
1194	if (check) {
1195	transparency_enabled = false;
1196	} else {
1197	transparency_enabled = true;
1198	}
1199	SetNeedKernelVisit (true);
1200	updateQWidget();
1201	}
1202
1203	/**
1204	SLOT Activate by a click on the antialiasing menu
1205	@param check : 1 , 0
1206	*/
1207	void G4OpenGLQtViewer::toggleAntialiasing(bool check) {
1208
1209	if (!check) {
1210	antialiasing_enabled = false;
1211	glDisable (GL_LINE_SMOOTH);
1212	glDisable (GL_POLYGON_SMOOTH);
1213	} else {
1214	antialiasing_enabled = true;
1215	glEnable (GL_LINE_SMOOTH);
1216	glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
1217	glEnable (GL_POLYGON_SMOOTH);
1218	glHint (GL_POLYGON_SMOOTH_HINT, GL_NICEST);
1219	}
1220
1221	updateQWidget();
1222	}
1223
1224	/**
1225	SLOT Activate by a click on the haloing menu
1226	@param check : 1 , 0
1227	*/
1228	//FIXME : I SEE NOTHING...
1229	void G4OpenGLQtViewer::toggleHaloing(bool check) {
1230	if (check) {
1231	haloing_enabled = false;
1232	} else {
1233	haloing_enabled = true;
1234	}
1235
1236	updateQWidget();
1237
1238	}
1239
1240	/**
1241	SLOT Activate by a click on the auxiliaire edges menu
1242	@param check : 1 , 0
1243	*/
1244	void G4OpenGLQtViewer::toggleAux(bool check) {
1245	if (check) {
1246	fVP.SetAuxEdgeVisible(false);
1247	} else {
1248	fVP.SetAuxEdgeVisible(true);
1249	}
1250	SetNeedKernelVisit (true);
1251	updateQWidget();
1252
1253	}
1254
1255	/**
1256	SLOT Activate by a click on the full screen menu
1257	*/
1258	void G4OpenGLQtViewer::toggleFullScreen(bool check) {
1259	if (check != GLWindow->isFullScreen()) { //toggle
1260	#if QT_VERSION >= 0x030200
1261	GLWindow->setWindowState(GLWindow->windowState() ^ Qt::WindowFullScreen);
1262	#else
1263	G4cerr << "This version of Qt could not do fullScreen. Resizing the widget is the only solution available.\n" << G4endl;
1264	#endif
1265	}
1266	}
1267
1268
1269	void G4OpenGLQtViewer::saveForVideo(QString nomFich) {
1270	if (nomFich == "") {
1271	return;
1272	}
1273
1274	QImage image;
1275	image = fWindow->grabFrameBuffer();
1276	bool res = false;
1277
1278	nomFich += "."+QString("ppm");
1279	#if QT_VERSION < 0x040000
1280	res = image.save(nomFich,"ppm");
1281	#else
1282	res = image.save(nomFich,0);
1283	#endif
1284	if (res == false) {
1285	#if QT_VERSION < 0x040000
1286	G4cerr << "Error while saving file... "<<nomFich.ascii()<<"\n" << G4endl;
1287	#else
1288	G4cerr << "Error while saving file... "<<nomFich.toStdString().c_str()<<"\n" << G4endl;
1289	#endif
1290	fRecordFrames = false;
1291	}
1292
1293	#if QT_VERSION < 0x040000
1294	printf("SaveForVideo ^^^^^^^^^^^^^^^^^^^^^^^^ %s\n",nomFich.ascii());
1295	#else
1296	printf("SaveForVideo ^^^^^^^^^^^^^^^^^^^^^^^^ %s\n",nomFich.toStdString().c_str());
1297	#endif
1298	}
1299
1300
1301
1302	void G4OpenGLQtViewer::actionCreateEPS() {
1303	QString filters;
1304	#if QT_VERSION < 0x040000
1305	QStrList listFormat=QImageIO::outputFormats();
1306	char *tmp=listFormat.first();
1307	while (tmp!=0) {
1308	filters += QString(tmp) + ";;";
1309	tmp=listFormat.next();
1310	}
1311	#else
1312	QList<QByteArray> formats = QImageWriter::supportedImageFormats ();
1313	for (int i = 0; i < formats.size(); ++i) {
1314	filters +=formats.at(i) + ";;";
1315	}
1316	#endif
1317	filters += "eps;;";
1318	filters += "ps;;";
1319	filters += "pdf";
1320	QString* selectedFormat = new QString();
1321	#if QT_VERSION < 0x040000
1322	QString nomFich = QFileDialog::getSaveFileName ( ".",
1323	filters,
1324	GLWindow,
1325	"Save file dialog",
1326	tr("Save as ..."),
1327	selectedFormat );
1328	#else
1329	QString nomFich = QFileDialog::getSaveFileName ( GLWindow,
1330	tr("Save as ..."),
1331	".",
1332	filters,
1333	selectedFormat );
1334	#endif
1335	// bmp jpg jpeg png ppm xbm xpm
1336	if (nomFich == "") {
1337	return;
1338	}
1339	#if QT_VERSION < 0x040000
1340	nomFich += "."+QString(selectedFormat->ascii());
1341	QString format = selectedFormat->lower();
1342	#else
1343	nomFich += "."+QString(selectedFormat->toStdString().c_str());
1344	QString format = selectedFormat->toLower();
1345	#endif
1346	G4OpenGLQtExportDialog* exportDialog= new G4OpenGLQtExportDialog(GLWindow,format,fWindow->height(),fWindow->width());
1347	if( exportDialog->exec()) {
1348
1349	QImage image;
1350	bool res = false;
1351	if ((exportDialog->getWidth() !=fWindow->width()) \|\|
1352	(exportDialog->getHeight() !=fWindow->height())) {
1353	if (format != QString("eps")) {
1354	G4cerr << "Export->Change Size : This function is not implemented, to export in another size, please resize your frame to what you need\n" << G4endl;
1355
1356	// rescaleImage(exportDialog->getWidth(),exportDialog->getHeight());// re-scale image
1357	// QGLWidget* glResized = fWindow;
1358
1359	// FIXME :
1360	// L.Garnier : I've try to implement change size function, but the problem is
1361	// the renderPixmap function call the QGLWidget to resize and it doesn't draw
1362	// the content of this widget... It only draw the background.
1363
1364	// fWindow->renderPixmap (exportDialog->getWidth()2,exportDialog->getHeight()2,true );
1365
1366	// QPixmap pixmap = fWindow->renderPixmap ();
1367
1368	// image = pixmap->toImage();
1369	// glResized->resize(exportDialog->getWidth()2,exportDialog->getHeight()2);
1370	// image = glResized->grabFrameBuffer();
1371	}
1372	} else {
1373	image = fWindow->grabFrameBuffer();
1374	}
1375	if (format == QString("eps")) {
1376	if (exportDialog->getVectorEPS()) {
1377	res = generateVectorEPS(nomFich,exportDialog->getWidth(),exportDialog->getHeight(),image);
1378	} else {
1379	res = generateEPS(nomFich,exportDialog->getNbColor(),image);
1380	}
1381	} else if ((format == "ps") \|\| (format == "pdf")) {
1382	res = generatePS_PDF(nomFich,exportDialog->getNbColor(),image);
1383	} else if ((format == "tif") \|\|
1384	(format == "tiff") \|\|
1385	(format == "jpg") \|\|
1386	(format == "jpeg") \|\|
1387	(format == "png") \|\|
1388	(format == "pbm") \|\|
1389	(format == "pgm") \|\|
1390	(format == "ppm") \|\|
1391	(format == "bmp") \|\|
1392	(format == "xbm") \|\|
1393	(format == "xpm")) {
1394	#if QT_VERSION < 0x040000
1395	res = image.save(nomFich,selectedFormat->ascii(),exportDialog->getSliderValue());
1396	#else
1397	res = image.save(nomFich,0,exportDialog->getSliderValue());
1398	#endif
1399	} else {
1400	G4cerr << "This version of G4UI Could not generate the selected format\n" << G4endl;
1401	}
1402	if (res == false) {
1403	#if QT_VERSION < 0x040000
1404	G4cerr << "Error while saving file... "<<nomFich.ascii()<<"\n" << G4endl;
1405	#else
1406	G4cerr << "Error while saving file... "<<nomFich.toStdString().c_str()<<"\n" << G4endl;
1407	#endif
1408	} else {
1409	#if QT_VERSION < 0x040000
1410	G4cout << "File "<<nomFich.ascii()<<" has been saved \n" << G4endl;
1411	#else
1412	G4cout << "File "<<nomFich.toStdString().c_str()<<" has been saved \n" << G4endl;
1413	#endif
1414	}
1415
1416	} else { // cancel selected
1417	return;
1418	}
1419
1420	#ifdef GEANT4_QT_DEBUG
1421	printf("G4OpenGLQtViewer::actionCreateEPS() \n");
1422	#endif
1423	}
1424
1425	/*
1426	// 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
1427
1428	void Graph::exportToSVG(const QString& fname)
1429	{
1430	// enable workaround for Qt3 misalignments
1431	QwtPainter::setSVGMode(true);
1432	QPicture picture;
1433	QPainter p(&picture);
1434	d_plot->print(&p, d_plot->rect());
1435	p.end();
1436
1437	picture.save(fname, "svg");
1438	}
1439	*/
1440
1441
1442
1443
1444	/**
1445	Save the current mouse press point
1446	@param p mouse click point
1447	*/
1448	#if QT_VERSION < 0x040000
1449	void G4OpenGLQtViewer::G4MousePressEvent(QPoint p,Qt::ButtonState mButtons)
1450	#else
1451	void G4OpenGLQtViewer::G4MousePressEvent(QPoint p,Qt::MouseButtons mButtons)
1452	#endif
1453	{
1454	fAutoMove = false; // stop automove
1455	fLastPos = p;
1456	if (fMouseAction == STYLE2){ // pick
1457	Pick(p.x(),p.y());
1458	}
1459	}
1460
1461
1462	/**
1463	@param pos_x mouse x position
1464	@param pos_y mouse y position
1465	@param mButtons mouse button active
1466	@param mAutoMove true: apply this move till another evnt came, false :one time move
1467	*/
1468
1469	#if QT_VERSION < 0x040000
1470	void G4OpenGLQtViewer::G4MouseMoveEvent(int pos_x, int pos_y,Qt::ButtonState mButtons,bool mAutoMove)
1471	#else
1472	void G4OpenGLQtViewer::G4MouseMoveEvent(int pos_x, int pos_y,Qt::MouseButtons mButtons,bool mAutoMove)
1473	#endif
1474	{
1475	fAutoMove = mAutoMove;
1476
1477	if (!fAutoMove) { // keep old delta if automove
1478	fDeltaPosX = fLastPos.x() - pos_x;
1479	fDeltaPosY = fLastPos.y() - pos_y;
1480	}
1481
1482	if ((fDeltaPosX == 0) && (fDeltaPosY == 0)) {
1483	fAutoMove = false;
1484	}
1485
1486	if (fMouseAction == STYLE1) { // rotate
1487	if (mButtons & Qt::LeftButton) {
1488	rotateScene(fDeltaPosX,fDeltaPosY,fAutoMove);
1489	}
1490	} else if (fMouseAction == STYLE2) { // move
1491	if (mButtons & Qt::LeftButton) {
1492	if (fAutoMove) {
1493	while (fAutoMove) {
1494	moveScene(-fDeltaPosX,-fDeltaPosY,0,true,true);
1495	((QApplication*)G4Qt::getInstance ())->processEvents();
1496	}
1497	} else {
1498	moveScene(-fDeltaPosX,-fDeltaPosY,0,true,false);
1499	}
1500	}
1501	}
1502	fLastPos = QPoint(pos_x, pos_y);
1503	}
1504
1505
1506	/**
1507	Move the scene of dx, dy, dz values.
1508	@param dx delta mouse x position
1509	@param dy delta mouse y position
1510	@param mouseMove : true if even comes froma mouse move, false if even comes from key action
1511	*/
1512
1513	void G4OpenGLQtViewer::moveScene(G4double dx,G4double dy, G4double dz,bool mouseMove,bool mAutoMove)
1514	{
1515	if (fHoldMoveEvent)
1516	return;
1517	fHoldMoveEvent = true;
1518
1519	if( mAutoMove == false) {
1520	fAutoMove = true;
1521	}
1522	G4double coefTrans = 0;
1523	GLdouble coefDepth = 0;
1524	while (fAutoMove) {
1525	if( mAutoMove == false) {
1526	fAutoMove = false;
1527	}
1528	if(mouseMove) {
1529	coefTrans = ((G4double)getSceneNearWidth())/((G4double)WinSize_x);
1530	if (WinSize_y <WinSize_x) {
1531	coefTrans = ((G4double)getSceneNearWidth())/((G4double)WinSize_y);
1532	}
1533	} else {
1534	coefTrans = getSceneNearWidth()*fDeltaSceneTranslation;
1535	coefDepth = getSceneDepth()*fDeltaDepth;
1536	}
1537	fVP.IncrementPan(-dxcoefTrans,dycoefTrans,dz*coefDepth);
1538
1539	updateQWidget();
1540	if (fAutoMove)
1541	((QApplication*)G4Qt::getInstance ())->processEvents();
1542	}
1543
1544	fHoldMoveEvent = false;
1545	}
1546
1547
1548	/**
1549	@param dx delta mouse x position
1550	@param dy delta mouse y position
1551	*/
1552
1553	void G4OpenGLQtViewer::rotateScene(G4double dx, G4double dy,bool mAutoRotate)
1554	{
1555	if (fHoldRotateEvent)
1556	return;
1557	fHoldRotateEvent = true;
1558
1559	if( mAutoRotate == false) {
1560	fAutoMove = true;
1561	}
1562	G4Vector3D vp;
1563	G4Vector3D up;
1564
1565	G4Vector3D xprime;
1566	G4Vector3D yprime;
1567	G4Vector3D zprime;
1568
1569	G4double delta_alpha;
1570	G4double delta_theta;
1571
1572	G4Vector3D new_vp;
1573	G4Vector3D new_up;
1574
1575	G4double cosalpha;
1576	G4double sinalpha;
1577
1578	G4Vector3D a1;
1579	G4Vector3D a2;
1580	G4Vector3D delta;
1581	G4Vector3D viewPoint;
1582
1583	while (fAutoMove) {
1584	if( mAutoRotate == false) {
1585	fAutoMove = false;
1586	}
1587
1588	//phi spin stuff here
1589
1590	vp = fVP.GetViewpointDirection ().unit ();
1591	up = fVP.GetUpVector ().unit ();
1592
1593	yprime = (up.cross(vp)).unit();
1594	zprime = (vp.cross(yprime)).unit();
1595
1596	if (fVP.GetLightsMoveWithCamera()) {
1597	delta_alpha = dy * fDeltaRotation;
1598	delta_theta = -dx * fDeltaRotation;
1599	} else {
1600	delta_alpha = -dy * fDeltaRotation;
1601	delta_theta = dx * fDeltaRotation;
1602	}
1603
1604	delta_alpha *= deg;
1605	delta_theta *= deg;
1606
1607	new_vp = std::cos(delta_alpha) * vp + std::sin(delta_alpha) * zprime;
1608
1609	// to avoid z rotation flipping
1610	// to allow more than 360° rotation
1611	if (fVP.GetLightsMoveWithCamera()) {
1612	new_up = (new_vp.cross(yprime)).unit();
1613	if (new_vp.z()*vp.z() <0) {
1614	new_up.set(new_up.x(),-new_up.y(),new_up.z());
1615	}
1616	} else {
1617	new_up = up;
1618	if (new_vp.z()*vp.z() <0) {
1619	new_up.set(new_up.x(),-new_up.y(),new_up.z());
1620	}
1621	}
1622	fVP.SetUpVector(new_up);
1623	////////////////
1624	// Rotates by fixed azimuthal angle delta_theta.
1625
1626	cosalpha = new_up.dot (new_vp.unit());
1627	sinalpha = std::sqrt (1. - std::pow (cosalpha, 2));
1628	yprime = (new_up.cross (new_vp.unit())).unit ();
1629	xprime = yprime.cross (new_up);
1630	// Projection of vp on plane perpendicular to up...
1631	a1 = sinalpha * xprime;
1632	// Required new projection...
1633	a2 = sinalpha * (std::cos (delta_theta) * xprime + std::sin (delta_theta) * yprime);
1634	// Required Increment vector...
1635	delta = a2 - a1;
1636	// So new viewpoint is...
1637	viewPoint = new_vp.unit() + delta;
1638
1639	#ifdef GEANT4_QT_DEBUG
1640	// printf("vp Vector : %f %f %f delta_alpha:%f delta_theta:%f cosalpha:%f sinalpha:%f\n",viewPoint.x(),viewPoint.y(),viewPoint.z(),delta_alpha,delta_theta,cosalpha,sinalpha);
1641	// printf("up : %f %f %f\n",up.x(),up.y(),up.z());
1642	// printf("new up : %f %f %f\n",new_up.x(),new_up.y(),new_up.z());
1643	// printf("vp : %f %f %f\n",vp.x(),vp.y(),vp.z());
1644	// printf("new_vp : %f %f %f\n",new_vp.x(),new_vp.y(),new_vp.z());
1645	#endif
1646	fVP.SetViewAndLights (viewPoint);
1647	updateQWidget();
1648
1649	if (fAutoMove)
1650	((QApplication*)G4Qt::getInstance ())->processEvents();
1651	}
1652
1653	fHoldRotateEvent = false;
1654	}
1655
1656	/** This is the benning of a rescale function. It does nothing for the moment
1657	@param aWidth : new width
1658	@param aHeight : new height
1659	*/
1660	void G4OpenGLQtViewer::rescaleImage(
1661	int aWidth
1662	,int aHeight
1663	){
1664	#ifdef GEANT4_QT_DEBUG
1665	printf("should rescale \n");
1666	#endif
1667	GLfloat* feedback_buffer;
1668	GLint returned;
1669	FILE* file;
1670
1671	// feedback_buffer = new GLfloat[size];
1672	// glFeedbackBuffer (size, GL_3D_COLOR, feedback_buffer);
1673	// glRenderMode (GL_FEEDBACK);
1674
1675	// glViewport (0, 0, aWidth, aHeight);
1676	// DrawView();
1677	// returned = glRenderMode (GL_RENDER);
1678
1679	}
1680
1681	/**
1682	Generate Vectorial Encapsulated Postscript form image
1683	@param aFilename : name of file
1684	@param aInColor : numbers of colors : 1->BW 2->RGB 3->RGB+Alpha
1685	@param aImage : Image to print
1686	*/
1687	bool G4OpenGLQtViewer::generateVectorEPS (
1688	QString aFilename
1689	,int aWidth
1690	,int aHeight
1691	,QImage aImage
1692	)
1693	{
1694	// Print vectored PostScript
1695
1696	G4int size = 5000000;
1697
1698	GLfloat* feedback_buffer;
1699	GLint returned;
1700	FILE* file;
1701
1702	feedback_buffer = new GLfloat[size];
1703	glFeedbackBuffer (size, GL_3D_COLOR, feedback_buffer);
1704	glRenderMode (GL_FEEDBACK);
1705
1706	int side = aWidth;
1707	if (aHeight < aWidth) side = aHeight;
1708	glViewport((aWidth - side) / 2, (aHeight - side) / 2, side, side);
1709	DrawView();
1710
1711	returned = glRenderMode (GL_RENDER);
1712
1713
1714	#if QT_VERSION < 0x040000
1715	file = fopen (aFilename.ascii(), "w");
1716	#else
1717	file = fopen (aFilename.toStdString().c_str(), "w");
1718	#endif
1719	if (file) {
1720	spewWireframeEPS (file, returned, feedback_buffer, "rendereps");
1721	} else {
1722	#if QT_VERSION < 0x040000
1723	G4cerr << "Could not open "<< aFilename.ascii()<<"\n" << G4endl;
1724	#else
1725	G4cerr << "Could not open "<< aFilename.toStdString().c_str()<<"\n" << G4endl;
1726	#endif
1727	}
1728
1729	delete[] feedback_buffer;
1730
1731	return true;
1732	}
1733
1734	/**
1735	Generate Encapsulated Postscript form image
1736	@param aFilename : name of file
1737	@param aInColor : numbers of colors : 1->BW 2->RGB 3->RGB+Alpha
1738	@param aImage : Image to print
1739	*/
1740	bool G4OpenGLQtViewer::generateEPS (
1741	QString aFilename
1742	,int aInColor
1743	,QImage aImage
1744	)
1745	{
1746	// FIXME
1747	#ifdef GEANT4_QT_DEBUG
1748	printf("saving EPS\n");
1749	#endif
1750
1751	FILE* fp;
1752
1753	if (aImage.bits () == NULL)
1754	return false;
1755
1756	#if QT_VERSION < 0x040000
1757	fp = fopen (aFilename.ascii(), "w");
1758	#else
1759	fp = fopen (aFilename.toStdString().c_str(), "w");
1760	#endif
1761	if (fp == NULL) {
1762	return false;
1763	}
1764
1765	fprintf (fp, "%%!PS-Adobe-2.0 EPSF-1.2\n");
1766	#if QT_VERSION < 0x040000
1767	fprintf (fp, "%%%%Title: %s\n", aFilename.ascii());
1768	#else
1769	fprintf (fp, "%%%%Title: %s\n", aFilename.toStdString().c_str());
1770	#endif
1771	fprintf (fp, "%%%%Creator: OpenGL pixmap render output\n");
1772	fprintf (fp, "%%%%BoundingBox: 0 0 %d %d\n", aImage.width(), aImage.height());
1773	fprintf (fp, "%%%%EndComments\n");
1774	fprintf (fp, "gsave\n");
1775	fprintf (fp, "/bwproc {\n");
1776	fprintf (fp, " rgbproc\n");
1777	fprintf (fp, " dup length 3 idiv string 0 3 0 \n");
1778	fprintf (fp, " 5 -1 roll {\n");
1779	fprintf (fp, " add 2 1 roll 1 sub dup 0 eq\n");
1780	fprintf (fp, " { pop 3 idiv 3 -1 roll dup 4 -1 roll dup\n");
1781	fprintf (fp, " 3 1 roll 5 -1 roll } put 1 add 3 0 \n");
1782	fprintf (fp, " { 2 1 roll } ifelse\n");
1783	fprintf (fp, " }forall\n");
1784	fprintf (fp, " pop pop pop\n");
1785	fprintf (fp, "} def\n");
1786	fprintf (fp, "systemdict /colorimage known not {\n");
1787	fprintf (fp, " /colorimage {\n");
1788	fprintf (fp, " pop\n");
1789	fprintf (fp, " pop\n");
1790	fprintf (fp, " /rgbproc exch def\n");
1791	fprintf (fp, " { bwproc } image\n");
1792	fprintf (fp, " } def\n");
1793	fprintf (fp, "} if\n");
1794	fprintf (fp, "/picstr %d string def\n", aImage.width() * aInColor);
1795	fprintf (fp, "%d %d scale\n", aImage.width(), aImage.height());
1796	fprintf (fp, "%d %d %d\n", aImage.width(), aImage.height(), 8);
1797	fprintf (fp, "[%d 0 0 %d 0 0]\n", aImage.width(), aImage.height());
1798	fprintf (fp, "{currentfile picstr readhexstring pop}\n");
1799	fprintf (fp, "false %d\n", aInColor);
1800	fprintf (fp, "colorimage\n");
1801
1802
1803	int width = aImage.width();
1804	int height = aImage.height();
1805	int depth = aImage.depth();
1806	int size = width*height;
1807
1808	if (depth == 1)
1809	size = (width+7)/8*height;
1810	else if (aInColor == 1)
1811	size = size*3;
1812
1813	int i = 0;
1814	// if ( aInColor ==1 ) {
1815	// FIXME : L. Garnier. For the moment 10 dec 2007, I could not find a way
1816	// to save correctly grayscale Image. I mean that color or grayscale image
1817	// have the same file save size !
1818
1819	/* } else*/ if (depth == 8) {
1820	for(int y=height-1; y >=0 ; y--) {
1821	const uchar * s = aImage.scanLine(y);
1822	for(int x=0; x <width; x++) {
1823	QRgb rgb = aImage.color(s[x]);
1824	if (aInColor == 1) {
1825	fprintf (fp, " %02hx ",(unsigned char)qGray(rgb));
1826	i++;
1827	} else {
1828	fprintf (fp, " %02hx %02hx %02hx",
1829	(unsigned char) qRed(rgb),
1830	(unsigned char) qGreen(rgb),
1831	(unsigned char) qBlue(rgb));
1832	i += 3;
1833	}
1834	}
1835	fprintf (fp, "\n");
1836	}
1837	} else {
1838	#if QT_VERSION < 0x040000
1839	bool alpha = aImage.hasAlphaBuffer();
1840	#else
1841	bool alpha = aImage.hasAlphaChannel();
1842	for(int y=height-1; y >=0 ; y--) {
1843	QRgb * s = (QRgb*)(aImage.scanLine(y));
1844	for(int x=0; x <width; x++) {
1845	QRgb rgb = (*s++);
1846	if (alpha && qAlpha(rgb) < 0x40) // 25% alpha, convert to white -
1847	rgb = qRgb(0xff, 0xff, 0xff);
1848	if (aInColor == 1) {
1849	fprintf (fp, " %02hx ",(unsigned char)qGray(rgb));
1850	i++;
1851	} else {
1852	fprintf (fp, " %02hx %02hx %02hx",
1853	(unsigned char) qRed(rgb),
1854	(unsigned char) qGreen(rgb),
1855	(unsigned char) qBlue(rgb));
1856	i += 3;
1857	}
1858	}
1859	fprintf (fp, "\n");
1860	}
1861	#endif
1862
1863	}
1864
1865	fprintf (fp, "grestore\n");
1866	fprintf (fp, "showpage\n");
1867	fclose (fp);
1868
1869	return true;
1870	}
1871	/**
1872	Generate Postscript or PDF form image
1873	@param aFilename : name of file
1874	@param aInColor : numbers of colors : 1->BW 2->RGB
1875	@param aImage : Image to print
1876	*/
1877	bool G4OpenGLQtViewer::generatePS_PDF (
1878	QString aFilename
1879	,int aInColor
1880	,QImage aImage
1881	)
1882	{
1883
1884	#if QT_VERSION < 0x040000
1885	#ifdef Q_WS_MAC \|\| Q_WS_X11
1886	QPrinter printer;
1887	// printer.setPageSize(pageSize);
1888	if (aInColor == 1) {
1889	printer.setColorMode(QPrinter::GrayScale);
1890	} else {
1891	printer.setColorMode(QPrinter::Color);
1892	}
1893
1894	/* FIXME : I don't know which format it will save...
1895	if (aFilename.endsWith(".ps")) {
1896	printer.setOutputFormat(QPrinter::PostScriptFormat);
1897	} else {
1898	printer.setOutputFormat(QPrinter::PdfFormat);
1899	}
1900	*/
1901	printer.setOutputFileName(aFilename);
1902	// printer.setFullPage ( true);
1903	QPainter paint(&printer);
1904	paint.drawImage (0,0,aImage );
1905	paint.end();
1906	#else
1907	G4cerr << "This fonction is only supported on Mac OsX or X11 with Qt3. Full platform supported with Qt4\n" << G4endl;
1908	#endif
1909	#else
1910	QPrinter printer;
1911	// printer.setPageSize(pageSize);
1912
1913	// FIXME : L. Garnier 4/12/07
1914	// This is not working, it does nothing. Image is staying in color mode
1915	// So I have desactivate the B/W button in GUI
1916	if ((!aImage.isGrayscale ()) &&(aInColor ==1 )) {
1917	#if QT_VERSION < 0x040000
1918	aImage = aImage.convertDepth(1,Qt::MonoOnly);
1919	#else
1920	aImage = aImage.convertToFormat ( aImage.format(), Qt::MonoOnly);
1921	#endif
1922	}
1923
1924
1925	if (aFilename.endsWith(".ps")) {
1926	#if QT_VERSION > 0x040200
1927	printer.setOutputFormat(QPrinter::PostScriptFormat);
1928	#endif
1929	} else {
1930	#if QT_VERSION > 0x040100
1931	printer.setOutputFormat(QPrinter::PdfFormat);
1932	#endif
1933	}
1934	#if QT_VERSION > 0x040100
1935	printer.setOutputFileName(aFilename);
1936	#endif
1937	// printer.setFullPage ( true);
1938	QPainter paint(&printer);
1939	paint.drawImage (0,0,aImage);
1940	paint.end();
1941	#endif
1942	return true;
1943	}
1944
1945
1946
1947	void G4OpenGLQtViewer::G4keyPressEvent (QKeyEvent * event)
1948	{
1949	if (fHoldKeyEvent)
1950	return;
1951
1952	fHoldKeyEvent = true;
1953
1954	#if QT_VERSION < 0x040000
1955	if ((event->key() == Qt::Key_Down) && (event->state() & Qt::AltButton )) { // go backward
1956	#else
1957	if ((event->key() == Qt::Key_Down) && (event->modifiers() & Qt::AltModifier )) { // go backward
1958	#endif
1959
1960	moveScene(0,0,1,false);
1961	}
1962	#if QT_VERSION < 0x040000
1963	else if ((event->key() == Qt::Key_Up) && (event->state() & Qt::AltButton)) { // go forward
1964	#else
1965	else if ((event->key() == Qt::Key_Up) && (event->modifiers() & Qt::AltModifier)) { // go forward
1966	#endif
1967	moveScene(0,0,-1,false);
1968	}
1969	#if QT_VERSION < 0x040000
1970	if ((event->key() == Qt::Key_Down) && (event->state() & Qt::ShiftButton)) { // rotate phi
1971	#else
1972	if ((event->key() == Qt::Key_Down) && (event->modifiers() & Qt::ShiftModifier)) { // rotate phi
1973	#endif
1974	rotateScene(0,-1);
1975	}
1976	#if QT_VERSION < 0x040000
1977	else if ((event->key() == Qt::Key_Up) && (event->state() & Qt::ShiftButton)) { // rotate phi
1978	#else
1979	else if ((event->key() == Qt::Key_Up) && (event->modifiers() & Qt::ShiftModifier)) { // rotate phi
1980	#endif
1981	rotateScene(0,1);
1982	}
1983	#if QT_VERSION < 0x040000
1984	if ((event->key() == Qt::Key_Left) && (event->state() & Qt::ShiftButton)) { // rotate theta
1985	#else
1986	if ((event->key() == Qt::Key_Left) && (event->modifiers() & Qt::ShiftModifier)) { // rotate theta
1987	#endif
1988	rotateScene(1,0);
1989	}
1990	#if QT_VERSION < 0x040000
1991	else if ((event->key() == Qt::Key_Right) && (event->state() & Qt::ShiftButton)) { // rotate theta
1992	#else
1993	else if ((event->key() == Qt::Key_Right) && (event->modifiers() & Qt::ShiftModifier)) { // rotate theta
1994	#endif
1995	rotateScene(-1,0);
1996	}
1997
1998	#if QT_VERSION < 0x040000
1999	if ((event->state() & Qt::AltButton)) {
2000	#else
2001	if ((event->modifiers() & Qt::AltModifier)) {
2002	#endif
2003	if (event->key() == Qt::Key_Plus) {
2004	fDeltaRotation = fDeltaRotation/0.7;
2005	}
2006	else if (event->key() == Qt::Key_Minus) {
2007	fDeltaRotation = fDeltaRotation*0.7;
2008	}
2009	} else {
2010	if (event->key() == Qt::Key_Plus) {
2011	fVP.SetZoomFactor(fVP.GetZoomFactor()*(1+fDeltaZoom));
2012	updateQWidget();
2013	}
2014	else if (event->key() == Qt::Key_Minus) {
2015	fVP.SetZoomFactor(fVP.GetZoomFactor()*(1-fDeltaZoom));
2016	updateQWidget();
2017	}
2018	}
2019
2020
2021	if (event->key() == Qt::Key_Escape) { // escaped from full screen
2022	#if QT_VERSION >= 0x030200
2023	if (GLWindow->isFullScreen()) {
2024	#if QT_VERSION < 0x040000
2025	fFullScreenOn->activated();
2026	#else
2027	fFullScreenOn->trigger();
2028	#endif
2029	}
2030	#endif
2031	}
2032
2033	if ((event->key() == Qt::Key_Return) \|\| (event->key() == Qt::Key_Enter)){ // end of video
2034	fRecordFrames = false;
2035	G4cout << "Recording Stop... \n" << G4endl;
2036	G4cout << "Saving /temp/output.mpg \n" << G4endl;
2037	saveVideo("/temp/output.mpg");
2038	}
2039	if (event->key() == Qt::Key_Space){ // start/pause of video
2040	fRecordFrames = !fRecordFrames;
2041	if (fRecordFrames) {
2042	G4cout << "Recording Start... \n" << G4endl;
2043	} else {
2044	G4cout << "Recording Pause... \n" << G4endl;
2045	}
2046	}
2047
2048	// with no modifiers
2049	#if QT_VERSION < 0x040000
2050	if (event->state() == Qt::NoButton) {
2051	#else
2052	if (event->modifiers() == Qt::NoModifier) {
2053	#endif
2054	if (event->key() == Qt::Key_Down) { // go down
2055	moveScene(0,-1,0,false);
2056	}
2057	else if (event->key() == Qt::Key_Up) { // go up
2058	moveScene(0,1,0,false);
2059	}
2060	if (event->key() == Qt::Key_Left) { // go left
2061	moveScene(-1,0,0,false);
2062	}
2063	else if (event->key() == Qt::Key_Right) { // go right
2064	moveScene(1,0,0,false);
2065	}
2066	}
2067	fHoldKeyEvent = false;
2068	}
2069
2070
2071	bool G4OpenGLQtViewer::hasPendingEvents () {
2072	return ((QApplication*)G4Qt::getInstance ())->hasPendingEvents ();
2073	}
2074
2075	bool G4OpenGLQtViewer::saveVideo (QString outputName) {
2076
2077	// save the parameter file
2078	FILE* fp;
2079	fp = fopen ("/temp/parameter_file.par", "w");
2080
2081	if (fp == NULL) {
2082	return false;
2083	}
2084
2085	fprintf (fp,"# parameter file template with lots of comments to assist you\n");
2086	fprintf (fp,"#\n");
2087	fprintf (fp,"# you can use this as a template, copying it to a separate file then modifying\n");
2088	fprintf (fp,"# the copy\n");
2089	fprintf (fp,"#\n");
2090	fprintf (fp,"#\n");
2091	fprintf (fp,"# any line beginning with '#' is a comment\n");
2092	fprintf (fp,"#\n");
2093	fprintf (fp,"# no line should be longer than 255 characters\n");
2094	fprintf (fp,"#\n");
2095	fprintf (fp,"#\n");
2096	fprintf (fp,"# general format of each line is:\n");
2097	fprintf (fp,"# \n");
2098	fprintf (fp,"#\n");
2099	fprintf (fp,"# lines can generally be in any order\n");
2100	fprintf (fp,"#\n");
2101	fprintf (fp,"# an exception is the option 'INPUT' which must be followed by input\n");
2102	fprintf (fp,"# files in the order in which they must appear, followed by 'END_INPUT'\n");
2103	fprintf (fp,"#\n");
2104	fprintf (fp,"# Also, if you use the `command` method of generating input file names,\n");
2105	fprintf (fp,"# the command will only be executed in the INPUT_DIR if INPUT_DIR preceeds\n");
2106	fprintf (fp,"# the INPUT parameter.\n");
2107	fprintf (fp,"#\n");
2108	fprintf (fp,"# MUST be in UPPER CASE\n");
2109	fprintf (fp,"#\n");
2110	fprintf (fp,"\n");
2111	fprintf (fp,"# Pattern affects speed, quality and compression. See the User's Guide\n");
2112	fprintf (fp,"# for more info.\n");
2113	fprintf (fp,"\n");
2114	fprintf (fp,"PATTERN IBBPBBPBBPBBPBBP\n");
2115	#if QT_VERSION < 0x040000
2116	fprintf (fp,"OUTPUT %s\n",outputName.ascii());
2117	#else
2118	fprintf (fp,"OUTPUT %s\n",outputName.toStdString().c_str());
2119	#endif
2120	fprintf (fp,"\n");
2121	fprintf (fp,"# mpeg_encode really only accepts 3 different file formats, but using a\n");
2122	fprintf (fp,"# conversion statement it can effectively handle ANY file format\n");
2123	fprintf (fp,"#\n");
2124	fprintf (fp,"# You must specify the type of the input files. The choices are:\n");
2125	fprintf (fp,"# YUV, PPM, JMOVIE, Y, JPEG, PNM\n");
2126	fprintf (fp,"# (must be upper case)\n");
2127	fprintf (fp,"#\n");
2128	fprintf (fp,"BASE_FILE_FORMAT PPM\n");
2129	fprintf (fp,"\n");
2130	fprintf (fp,"#\n");
2131	fprintf (fp,"# if YUV format (or using parallel version), must provide width and height\n");
2132	fprintf (fp,"# YUV_SIZE widthxheight\n");
2133	fprintf (fp,"# this option is ignored if BASE_FILE_FORMAT is not YUV and you're running\n");
2134	fprintf (fp,"# on just one machine\n");
2135	fprintf (fp,"#\n");
2136	fprintf (fp,"YUV_SIZE 352x240\n");
2137	fprintf (fp,"\n");
2138	fprintf (fp,"# If you are using YUV, there are different supported file formats.\n");
2139	fprintf (fp,"# EYUV or UCB are the same as previous versions of this encoder.\n");
2140	fprintf (fp,"# (All the Y's, then U's then V's, in 4:2:0 subsampling.)\n");
2141	fprintf (fp,"# Other formats, such as Abekas, Phillips, or a general format are\n");
2142	fprintf (fp,"# permissible, the general format is a string of Y's, U's, and V's\n");
2143	fprintf (fp,"# to specify the file order.\n");
2144	fprintf (fp,"\n");
2145	fprintf (fp,"INPUT_FORMAT UCB\n");
2146	fprintf (fp,"\n");
2147	fprintf (fp,"# the conversion statement\n");
2148	fprintf (fp,"#\n");
2149	fprintf (fp,"# Each occurrence of '*' will be replaced by the input file\n");
2150	fprintf (fp,"#\n");
2151	fprintf (fp,"# e.g., if you have a bunch of GIF files, then this might be:\n");
2152	fprintf (fp,"# INPUT_CONVERT giftoppm *\n");
2153	fprintf (fp,"#\n");
2154	fprintf (fp,"# e.g., if you have a bunch of files like a.Y a.U a.V, etc., then:\n");
2155	fprintf (fp,"# INPUT_CONVERT cat .Y .U *.V\n");
2156	fprintf (fp,"#\n");
2157	fprintf (fp,"# e.g., if you are grabbing from laser disc you might have something like\n");
2158	fprintf (fp,"# INPUT_CONVERT goto frame *; grabppm\n");
2159	fprintf (fp,"# 'INPUT_CONVERT *' means the files are already in the base file format\n");
2160	fprintf (fp,"#\n");
2161	fprintf (fp,"INPUT_CONVERT * \n");
2162	fprintf (fp,"\n");
2163	fprintf (fp,"# number of frames in a GOP.\n");
2164	fprintf (fp,"#\n");
2165	fprintf (fp,"# since each GOP must have at least one I-frame, the encoder will find the\n");
2166	fprintf (fp,"# the first I-frame after GOP_SIZE frames to start the next GOP\n");
2167	fprintf (fp,"#\n");
2168	fprintf (fp,"# later, will add more flexible GOP signalling\n");
2169	fprintf (fp,"#\n");
2170	fprintf (fp,"GOP_SIZE 16\n");
2171	fprintf (fp,"\n");
2172	fprintf (fp,"# number of slices in a frame\n");
2173	fprintf (fp,"#\n");
2174	fprintf (fp,"# 1 is a good number. another possibility is the number of macroblock rows\n");
2175	fprintf (fp,"# (which is the height divided by 16)\n");
2176	fprintf (fp,"#\n");
2177	fprintf (fp,"SLICES_PER_FRAME 1\n");
2178	fprintf (fp,"\n");
2179	fprintf (fp,"# directory to get all input files from (makes this file easier to read)\n");
2180	fprintf (fp,"INPUT_DIR /temp\n");
2181	fprintf (fp,"\n");
2182	fprintf (fp,"# There are a bunch of ways to specify the input files.\n");
2183	fprintf (fp,"# from a simple one-per-line listing, to the following \n");
2184	fprintf (fp,"# way of numbering them. See the manual for more information.\n");
2185	fprintf (fp,"INPUT\n");
2186	fprintf (fp,"# '*' is replaced by the numbers 01, 02, 03, 04\n");
2187	fprintf (fp,"# if I instead do [01-11], it would be 01, 02, ..., 09, 10, 11\n");
2188	fprintf (fp,"# if I instead do [1-11], it would be 1, 2, 3, ..., 9, 10, 11\n");
2189	fprintf (fp,"# if I instead do [1-11+3], it would be 1, 4, 7, 10\n");
2190	fprintf (fp,"# the program assumes none of your input files has a name ending in ']'\n");
2191	fprintf (fp,"# if you do, too bad!!!\n");
2192	fprintf (fp,"#\n");
2193	fprintf (fp,"#\n");
2194	fprintf (fp,"Test*.ppm [0-%d]\n",fRecordFrameNumber);
2195	fprintf (fp,"# can have more files here if you want...there is no limit on the number\n");
2196	fprintf (fp,"# of files\n");
2197	fprintf (fp,"END_INPUT\n");
2198	fprintf (fp,"\n");
2199	fprintf (fp,"\n");
2200	fprintf (fp,"\n");
2201	fprintf (fp,"# Many of the remaining options have to do with the motion search and qscale\n");
2202	fprintf (fp,"\n");
2203	fprintf (fp,"# FULL or HALF -- must be upper case\n");
2204	fprintf (fp,"# Should be FULL for computer generated images\n");
2205	fprintf (fp,"PIXEL FULL\n");
2206	fprintf (fp,"\n");
2207	fprintf (fp,"# means +/- this many pixels for both P and B frame searches\n");
2208	fprintf (fp,"# specify two numbers if you wish to serc different ranges in the two.\n");
2209	fprintf (fp,"RANGE 10\n");
2210	fprintf (fp,"\n");
2211	fprintf (fp,"# The two search algorithm parameters below mostly affect speed,\n");
2212	fprintf (fp,"# with some affect on compression and almost none on quality.\n");
2213	fprintf (fp,"\n");
2214	fprintf (fp,"# this must be one of {EXHAUSTIVE, SUBSAMPLE, LOGARITHMIC}\n");
2215	fprintf (fp,"PSEARCH_ALG LOGARITHMIC\n");
2216	fprintf (fp,"\n");
2217	fprintf (fp,"# this must be one of {SIMPLE, CROSS2, EXHAUSTIVE}\n");
2218	fprintf (fp,"#\n");
2219	fprintf (fp,"# note that EXHAUSTIVE is really, really, really slow\n");
2220	fprintf (fp,"#\n");
2221	fprintf (fp,"BSEARCH_ALG SIMPLE\n");
2222	fprintf (fp,"\n");
2223	fprintf (fp,"#\n");
2224	fprintf (fp,"# these specify the q-scale for I, P, and B frames\n");
2225	fprintf (fp,"# (values must be between 1 and 31)\n");
2226	fprintf (fp,"# These are the Qscale values for the entire frame in variable bit-rate\n");
2227	fprintf (fp,"# mode, and starting points (but not important) for constant bit rate\n");
2228	fprintf (fp,"#\n");
2229	fprintf (fp,"\n");
2230	fprintf (fp,"# Qscale (Quantization scale) affects quality and compression,\n");
2231	fprintf (fp,"# but has very little effect on speed.\n");
2232	fprintf (fp,"\n");
2233	fprintf (fp,"IQSCALE 4\n");
2234	fprintf (fp,"PQSCALE 5\n");
2235	fprintf (fp,"BQSCALE 12\n");
2236	fprintf (fp,"\n");
2237	fprintf (fp,"# this must be ORIGINAL or DECODED\n");
2238	fprintf (fp,"REFERENCE_FRAME ORIGINAL\n");
2239	fprintf (fp,"\n");
2240	fprintf (fp,"# for parallel parameters see parallel.param in the exmaples subdirectory\n");
2241	fprintf (fp,"\n");
2242	fprintf (fp,"# if you want constant bit-rate mode, specify it as follows (number is bits/sec):\n");
2243	fprintf (fp,"#BIT_RATE 1000000\n");
2244	fprintf (fp,"\n");
2245	fprintf (fp,"# To specify the buffer size (327680 is default, measused in bits, for 16bit words)\n");
2246	fprintf (fp,"BUFFER_SIZE 327680\n");
2247	fprintf (fp,"\n");
2248	fprintf (fp,"# The frame rate is the number of frames/second (legal values:\n");
2249	fprintf (fp,"# 23.976, 24, 25, 29.97, 30, 50 ,59.94, 60\n");
2250	fprintf (fp,"FRAME_RATE 30\n");
2251	fprintf (fp,"\n");
2252	fprintf (fp,"# There are many more options, see the users manual for examples....\n");
2253	fprintf (fp,"# ASPECT_RATIO, USER_DATA, GAMMA, IQTABLE, etc.\n");
2254	fprintf (fp,"\n");
2255	fprintf (fp,"\n");
2256	fclose (fp);
2257
2258	QProcess::execute ("/sw/bin/mpeg_encode", QStringList("/temp/parameter_file.par"));
2259	return true;
2260	}
2261
2262	/*
2263
2264	void MultiLayer::exportToSVG(const QString& fname)
2265	{
2266	QPicture picture;
2267	QPainter p(&picture);
2268	for (int i=0;i<(int)graphsList->count();i++)
2269	{
2270	Graph gr=(Graph )graphsList->at(i);
2271	Plot myPlot= (Plot )gr->plotWidget();
2272
2273	QPoint pos=gr->pos();
2274
2275	int width=int(myPlot->frameGeometry().width());
2276	int height=int(myPlot->frameGeometry().height());
2277
2278	myPlot->print(&p, QRect(pos,QSize(width,height)));
2279	}
2280
2281	p.end();
2282	picture.save(fname, "svg");
2283	}
2284	*/
2285	#endif

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

Download in other formats: