Context Navigation

source: trunk/source/interfaces/basic/src/G4UIQt.cc @ 1243

Last change on this file since 1243 was 1243, checked in by garnier, 14 years ago
update
Property svn:mime-type set to `text/cpp`
File size: 53.2 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: G4UIQt.cc,v 1.30 2010/01/06 14:13:08 lgarnier Exp $
28	// GEANT4 tag $Name: laurent-QtUI_with_tabs_v1 $
29	//
30	// L. Garnier
31
32	#ifdef G4UI_BUILD_QT_SESSION
33
34	#include "G4Types.hh"
35
36	#include <string.h>
37
38	#include "G4UIQt.hh"
39	#include "G4UImanager.hh"
40	#include "G4StateManager.hh"
41	#include "G4UIcommandTree.hh"
42	#include "G4UIcommandStatus.hh"
43
44	#include "G4Qt.hh"
45
46	#include <qapplication.h>
47	#include <qlineedit.h>
48	#include <qwidget.h>
49	#include <qmenubar.h>
50	#include <qlayout.h>
51	#include <qpushbutton.h>
52	#include <qlabel.h>
53	#include <qtoolbox.h>
54	#include <qsplitter.h>
55	#include <qscrollbar.h>
56	#include <qdialog.h>
57	#include <qevent.h>
58	#include <qtextedit.h>
59	#include <qsignalmapper.h>
60	#include <qtabwidget.h>
61	#include <qtabbar.h>
62	#include <qresizeevent>
63	#include <qstringlist.h>
64
65	#include <qmainwindow.h>
66	#if QT_VERSION >= 0x040000
67	#include <qmenu.h>
68	#include <qlistwidget.h>
69	#include <qtreewidget.h>
70	#else
71	#include <qaction.h>
72	#include <qheader.h>
73	#include <qlistview.h>
74	#include <qpopupmenu.h>
75	#include <qwidgetlist.h>
76	#endif
77
78
79
80	#include <stdlib.h>
81
82	// Pourquoi Static et non variables de classe ?
83	static G4bool exitSession = true;
84	static G4bool exitPause = true;
85
86	/** Build a Qt window with a menubar, output area and promt area<br>
87	<pre>
88	+-----------------------+
89	\|exit menu\| \|
90	\| \|
91	\| +-------------------+ \|
92	\| \| \| \|
93	\| \| Output area \| \|
94	\| \| \| \|
95	\| +-------------------+ \|
96	\| \| clear \| \|
97	\| +-------------------+ \|
98	\| \| promt history \| \|
99	\| +-------------------+ \|
100	\| +-------------------+ \|
101	\| \|> promt area \| \|
102	\| +-------------------+ \|
103	+-----------------------+
104	</pre>
105	*/
106	G4UIQt::G4UIQt (
107	int argc
108	,char** argv
109	)
110	:fG4cout("")
111	,fHelpTBWidget(NULL)
112	,fHistoryTBWidget(NULL)
113	,fCoutTBWidget(NULL)
114	,fVisParametersTBWidget(NULL)
115	,fViewComponentsTBWidget(NULL)
116	,fTabWidget(NULL)
117	,fCoutText("Output")
118	{
119
120	G4Qt* interactorManager = G4Qt::getInstance (argc,argv,(char*)"Qt");
121	if (!(QApplication*)interactorManager->GetMainInteractor()) {
122	G4cout << "G4UIQt : Unable to init Qt. Aborted" << G4endl;
123	}
124
125	G4UImanager* UI = G4UImanager::GetUIpointer();
126	if(UI!=NULL) UI->SetSession(this);
127
128	// Check if already define in external app QMainWindow
129	bool found = false;
130	#if QT_VERSION < 0x040000
131	// theses lines does nothing exept this one "GLWindow = new QDialog(0..."
132	// but if I comment them, it doesn't work...
133	QWidgetList *list = QApplication::allWidgets();
134	QWidgetListIt it( *list ); // iterate over the widgets
135	QWidget * widget;
136	while ( (widget=it.current()) != 0 ) { // for each widget...
137	++it;
138	if ((found== false) && (widget->inherits("QMainWindow"))) {
139	found = true;
140	}
141	}
142	delete list; // delete the list, not the widgets
143	#else
144	foreach (QWidget *widget, QApplication::allWidgets()) {
145	if ((found== false) && (widget->inherits("QMainWindow"))) {
146	found = true;
147	}
148	}
149	#endif
150
151	if (found) {
152	G4cout << "G4UIQt : Found an external App with a QMainWindow already defined. Aborted" << G4endl;
153	return ;
154	}
155	fMainWindow = new QMainWindow();
156
157	#ifdef G4DEBUG_INTERFACES_BASIC
158	printf("G4UIQt::Initialise after main window creation UImanager:%d G4UIQt(this) : %d+++++++++++\n",UI,this);
159	#endif
160
161	QWidget *mainWidget = new QWidget(fMainWindow);
162	#if QT_VERSION < 0x040000
163	fMyVSplitter = new QSplitter(Qt::Horizontal,fMainWindow);
164	fToolBox = new QToolBox(Qt::Horizontal,fMyVSplitter);
165	#else
166	fMyVSplitter = new QSplitter(Qt::Horizontal,fMainWindow);
167	fToolBox = new QToolBox(mainWidget);
168	#endif
169
170	// Set layouts
171
172	// Add a empty tabwidget
173	fTabWidget = new G4QTabWidget(fMyVSplitter);
174	#if QT_VERSION >= 0x040500
175	fTabWidget->setTabsClosable (true);
176	#endif
177
178	#if QT_VERSION >= 0x040200
179	fTabWidget->setUsesScrollButtons (true);
180	#endif
181
182	QWidget* commandLineWidget = new QWidget(mainWidget);
183	#if QT_VERSION < 0x040000
184	QVBoxLayout *layoutCommandLine = new QVBoxLayout(commandLineWidget);
185	#else
186	QVBoxLayout *layoutCommandLine = new QVBoxLayout();
187	#endif
188
189	// fill them
190
191	fCommandLabel = new QLabel("",commandLineWidget);
192
193	fCommandArea = new QLineEdit(commandLineWidget);
194	fCommandArea->installEventFilter(this);
195	#if QT_VERSION < 0x040000
196	fCommandArea->setActiveWindow();
197	#else
198	fCommandArea->activateWindow();
199	#endif
200
201	#if QT_VERSION < 0x040000
202	fCommandArea->setFocusPolicy ( QWidget::StrongFocus );
203	fCommandArea->setFocus();
204	#else
205	fCommandArea->setFocusPolicy ( Qt::StrongFocus );
206	fCommandArea->setFocus(Qt::TabFocusReason);
207	#endif
208
209
210
211	layoutCommandLine->addWidget(fCommandLabel);
212	layoutCommandLine->addWidget(fCommandArea);
213	#if QT_VERSION >= 0x040000
214	QVBoxLayout *mainLayout = new QVBoxLayout();
215	#else
216	QVBoxLayout *mainLayout = new QVBoxLayout(mainWidget);
217	#endif
218
219	fHelpTBWidget = new QWidget(fToolBox);
220	fHistoryTBWidget = new QWidget(fToolBox);
221	fCoutTBWidget = new QWidget(fToolBox);
222	fVisParametersTBWidget = new QWidget(fToolBox);
223	fViewComponentsTBWidget = new QWidget(fToolBox);
224
225	CreateVisParametersTBWidget();
226	CreateViewComponentsTBWidget();
227	CreateHelpTBWidget();
228	CreateCoutTBWidget();
229	CreateHistoryTBWidget();
230
231	// the splitter
232	fToolBox->addItem(fVisParametersTBWidget,"Vis parameters");
233	fToolBox->addItem(fViewComponentsTBWidget,"Viewer components");
234	fToolBox->addItem(fHelpTBWidget,"Help");
235	fToolBox->addItem(fCoutTBWidget,"Cout");
236	fToolBox->addItem(fHistoryTBWidget,"History");
237
238
239
240	fToolBox->setSizePolicy (QSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed));
241	fTabWidget->setSizePolicy (QSizePolicy(QSizePolicy::Maximum,QSizePolicy::Maximum));
242
243	QSizePolicy policy = fTabWidget->sizePolicy();
244	policy.setHorizontalStretch(1);
245	policy.setVerticalStretch(1);
246	fTabWidget->setSizePolicy(policy);
247
248	fEmptyViewerTabLabel = new QLabel(" If you want to have a Viewer, please use /vis/open commands. ");
249
250	// Only at creation. Will be set visible when sessionStart();
251	fTabWidget->setVisible(false);
252	fEmptyViewerTabLabel->setVisible(false);
253
254	fMyVSplitter->addWidget(fToolBox);
255	fMyVSplitter->addWidget(fEmptyViewerTabLabel);
256	// fMyVSplitter->addWidget(fTabWidget);
257
258	// unset parent fot TabWidget
259	#if QT_VERSION < 0x040000
260	fTabWidget->reparent(0,0,QPoint(0,0));
261	#else
262	fTabWidget->setParent(0);
263	#endif
264
265
266	#if QT_VERSION >= 0x040000
267	commandLineWidget->setLayout(layoutCommandLine);
268	#endif
269	commandLineWidget->setSizePolicy (QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum));
270	mainLayout->addWidget(fMyVSplitter,1);
271	mainLayout->addWidget(commandLineWidget);
272
273	#ifdef G4DEBUG_INTERFACES_BASIC
274	printf("G4UIQt::G4UIQt :: 5\n");
275	#endif
276
277	#if QT_VERSION >= 0x040000
278	mainWidget->setLayout(mainLayout);
279	#endif
280
281	fMainWindow->setCentralWidget(mainWidget);
282
283	#if QT_VERSION < 0x040000
284
285	// Add a quit subMenu
286	QPopupMenu *fileMenu = new QPopupMenu( fMainWindow);
287	fileMenu->insertItem( "&Quit", this, SLOT(ExitSession()), CTRL+Key_Q );
288	fMainWindow->menuBar()->insertItem( QString("&File"), fileMenu );
289
290	#else
291
292	// Add a quit subMenu
293	QMenu *fileMenu = fMainWindow->menuBar()->addMenu("File");
294	fileMenu->addAction("Quit", this, SLOT(ExitSession()));
295
296	#endif
297
298	AddInteractor ("file",(G4Interactor)fileMenu);
299	#ifdef G4DEBUG_INTERFACES_BASIC
300	printf("G4UIQt::G4UIQt :: 6\n");
301	#endif
302
303	connect(fCommandArea, SIGNAL(returnPressed()), SLOT(CommandEnteredCallback()));
304	connect(fTabWidget, SIGNAL(tabCloseRequested(int)), this, SLOT(TabCloseCallback(int)));
305	connect(fTabWidget, SIGNAL(currentChanged ( int ) ), SLOT(UpdateTabWidget(int)));
306	if(UI!=NULL) UI->SetCoutDestination(this); // TO KEEP
307
308	interactorManager->SetG4UI(this);
309
310	#if QT_VERSION < 0x040000
311	fMainWindow->setCaption( tr( "G4UI Session" ));
312	fMainWindow->resize(900,600);
313	fMainWindow->move(50,100);
314	#else
315	fMainWindow->setWindowTitle( tr("G4UI Session") );
316	fMainWindow->resize(900,600);
317	fMainWindow->move(QPoint(50,100));
318	#endif
319
320	// Set visible
321	#if QT_VERSION >= 0x040000
322	#if QT_VERSION >= 0x040200
323	fMainWindow->setVisible(true);
324	#else
325	fMainWindow->show();
326	#endif
327	#else
328	fMainWindow->show();
329	#endif
330
331	#ifdef G4DEBUG_INTERFACES_BASIC
332	printf("G4UIQt::G4UIQt END\n");
333	#endif
334	}
335
336
337
338	G4UIQt::~G4UIQt(
339	)
340	{
341	#ifdef G4DEBUG_INTERFACES_BASIC
342	printf("G4UIQt::~G4UIQt Delete\n");
343	#endif
344	G4UImanager* UI = G4UImanager::GetUIpointer(); // TO KEEP
345	if(UI!=NULL) { // TO KEEP
346	UI->SetSession(NULL); // TO KEEP
347	UI->SetCoutDestination(NULL); // TO KEEP
348	}
349
350	if (fMainWindow!=NULL) {
351	#ifdef G4DEBUG_INTERFACES_BASIC
352	printf("G4UIQt::~G4UIQt DELETE fMainWindow\n");
353	#endif
354	delete fMainWindow;
355	}
356	}
357
358	/** Create the History ToolBox Widget
359	*/
360	void G4UIQt::CreateHistoryTBWidget(
361	)
362	{
363
364	#if QT_VERSION < 0x040000
365	QVBoxLayout *layoutHistoryTB = new QVBoxLayout(fHistoryTBWidget);
366
367	fHistoryTBTableList = new QListView(fHistoryTBWidget);
368	fHistoryTBTableList->setSorting (-1, FALSE);
369	fHistoryTBTableList->setSelectionMode(QListView::Single);
370	fHistoryTBTableList->addColumn("");
371	fHistoryTBTableList->header()->hide();
372	connect(fHistoryTBTableList, SIGNAL(selectionChanged()), SLOT(CommandHistoryCallback()));
373	#else
374	QVBoxLayout *layoutHistoryTB = new QVBoxLayout();
375	fHistoryTBTableList = new QListWidget();
376	fHistoryTBTableList->setSelectionMode(QAbstractItemView::SingleSelection);
377	connect(fHistoryTBTableList, SIGNAL(itemSelectionChanged()), SLOT(CommandHistoryCallback()));
378	#endif
379	fHistoryTBTableList->installEventFilter(this);
380
381	layoutHistoryTB->addWidget(fHistoryTBTableList);
382
383	#if QT_VERSION >= 0x040000
384	fHistoryTBWidget->setLayout(layoutHistoryTB);
385	#endif
386	}
387
388	/** Create the Help ToolBox Widget
389	*/
390	void G4UIQt::CreateHelpTBWidget(
391	)
392	{
393
394
395	#if QT_VERSION < 0x040000
396	QWidget *helpWidget = new QWidget(fHelpTBWidget);
397	QHBoxLayout *helpLayout = new QHBoxLayout(helpWidget);
398	QVBoxLayout *vLayout = new QVBoxLayout(fHelpTBWidget);
399	QSplitter *splitter = new QSplitter(Qt::Horizontal,fHelpTBWidget);
400	#else
401	QWidget *helpWidget = new QWidget();
402	QHBoxLayout *helpLayout = new QHBoxLayout();
403	QVBoxLayout *vLayout = new QVBoxLayout();
404	QSplitter *splitter = new QSplitter(Qt::Horizontal);
405	#endif
406	fHelpLine = new QLineEdit(fHelpTBWidget);
407	helpLayout->addWidget(new QLabel("Search :",helpWidget));
408	helpLayout->addWidget(fHelpLine);
409	#if QT_VERSION < 0x040000
410	connect( fHelpLine, SIGNAL( returnPressed () ), this, SLOT( LookForHelpStringCallback() ) );
411	#else
412	connect( fHelpLine, SIGNAL( editingFinished () ), this, SLOT( LookForHelpStringCallback() ) );
413	#endif
414
415	// the help tree
416	#if QT_VERSION < 0x040000
417	fHelpTreeWidget = new QListView(splitter);
418	#else
419	fHelpTreeWidget = new QTreeWidget();
420	#endif
421	fHelpTreeWidget = CreateHelpTree();
422
423	fHelpArea = new QTextEdit(splitter);
424	fHelpArea->setReadOnly(true);
425
426	// Set layouts
427
428	#if QT_VERSION >= 0x040000
429	if (fHelpTreeWidget)
430	splitter->addWidget(fHelpTreeWidget);
431	splitter->addWidget(fHelpArea);
432	#endif
433
434
435	#if QT_VERSION >= 0x040000
436	vLayout->addWidget(helpWidget);
437	vLayout->addWidget(splitter,1);
438	#endif
439
440	fHelpTBWidget->setMinimumSize(50,50);
441	fHelpTBWidget->setSizePolicy (QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum));
442	// set the splitter size
443	#if QT_VERSION >= 0x040000
444	QList<int> list;
445	#else
446	QValueList<int> list;
447	#endif
448	list.append( 50 );
449	list.append( 50 );
450	splitter->setSizes(list);
451
452	#if QT_VERSION >= 0x040000
453	helpWidget->setLayout(helpLayout);
454	fHelpTBWidget->setLayout(vLayout);
455	#endif
456	}
457
458
459	/** Create the Cout ToolBox Widget
460	*/
461	void G4UIQt::CreateCoutTBWidget(
462	)
463	{
464	#if QT_VERSION >= 0x040000
465	QVBoxLayout *layoutCoutTB = new QVBoxLayout();
466	#else
467	QVBoxLayout *layoutCoutTB = new QVBoxLayout(fCoutTBWidget);
468	#endif
469
470	fCoutTBTextArea = new QTextEdit(fCoutTBWidget);
471	fCoutFilter = new QLineEdit(fCoutTBWidget);
472	QLabel* coutFilterLabel = new QLabel("Filter : ",fCoutTBWidget);
473
474	QPushButton *coutTBClearButton = new QPushButton("clear",fCoutTBWidget);
475	connect(coutTBClearButton, SIGNAL(clicked()), SLOT(ClearButtonCallback()));
476	connect(fCoutFilter, SIGNAL(textEdited ( const QString &)), SLOT(CoutFilterCallback( const QString &)));
477
478	fCoutTBTextArea->setReadOnly(true);
479
480	QWidget* coutButtonWidget = new QWidget(fCoutTBWidget);
481	QHBoxLayout* layoutCoutTBButtons = new QHBoxLayout(coutButtonWidget);
482	layoutCoutTBButtons->addWidget(coutTBClearButton);
483	layoutCoutTBButtons->addWidget(coutFilterLabel);
484	layoutCoutTBButtons->addWidget(fCoutFilter);
485
486	layoutCoutTB->addWidget(fCoutTBTextArea);
487	layoutCoutTB->addWidget(coutButtonWidget);
488
489	#if QT_VERSION >= 0x040000
490	fCoutTBWidget->setLayout(layoutCoutTB);
491	#endif
492	}
493
494
495	/** Create the VisParameters ToolBox Widget
496	*/
497	void G4UIQt::CreateVisParametersTBWidget(
498	)
499	{
500	}
501
502
503	/** Create the ViewComponents ToolBox Widget
504	*/
505	void G4UIQt::CreateViewComponentsTBWidget(
506	)
507	{
508	}
509
510
511	/** Add a new tab widget.
512	Create the tab if it was not done
513	*/
514	bool G4UIQt::AddTabWidget(
515	QWidget* aWidget
516	,QString name
517	,int sizeX
518	,int sizeY
519	)
520	{
521	#ifdef G4DEBUG_INTERFACES_BASIC
522	printf("G4UIQt::AddTabWidget %d %d\n",sizeX, sizeY);
523	#endif
524	if (!aWidget) {
525	return false;
526	}
527
528	// Remove QLabel
529	if ( fMyVSplitter->indexOf(fEmptyViewerTabLabel) != -1) {
530	#if QT_VERSION < 0x040000
531	fEmptyViewerTabLabel->reparent(0,0,QPoint(0,0));
532	#else
533	fEmptyViewerTabLabel->setParent(0);
534	#endif
535	fMyVSplitter->addWidget(fTabWidget);
536	#if QT_VERSION < 0x040000
537	aWidget->reparent(fTabWidget,0,QPoint(0,0));
538	#else
539	aWidget->setParent(fTabWidget);
540	#endif
541	}
542
543
544
545	#ifdef G4DEBUG_INTERFACES_BASIC
546	printf("G4UIQt::AddTabWidget ADD %d %d + %d %d---------------------------------------------------\n",sizeX, sizeY,sizeX-fTabWidget->width(),sizeY-fTabWidget->height());
547	#endif
548
549	#ifdef G4DEBUG_INTERFACES_BASIC
550	printf("G4UIQt::AddTabWidget resize VVVVVVVVVVVG4UIQt G4UIQt G4UIQt G4UIQt G4UIQt G4UIQt G4UIQt G4UIQt \n");
551	printf("G4UIQt::AddTabWidget resize 22222222222 W---:%d + sx:%d -fwx:%d H---:%d + sy:%d -fwy:%d TabW:%d TabH:%d G4UIQt G4UIQt aWX:%d aWY:%d\n",fMainWindow->width(),sizeX,fTabWidget->width(),fMainWindow->height(),sizeY,fTabWidget->height(),fTabWidget->width(),fTabWidget->height(),aWidget->size().height(),aWidget->size().width());
552	#endif
553
554	fMainWindow->resize(fMainWindow->width()+sizeX-fTabWidget->width(),fMainWindow->height()+sizeY-fTabWidget->height());
555
556	// Problems with resize. The widgets are not realy drawn at this step,
557	// then we have to force them on order to check the size
558
559	fTabWidget->insertTab(fTabWidget->count(),aWidget,name);
560
561	// if (fTabWidget->count() == 1) {
562	// connect(fTabWidget, SIGNAL(currentChanged ( int ) ), SLOT(UpdateTabWidget(int)));
563	// connect(fTabWidget, SIGNAL(resizeEvent ( QResizeEvent* ) ), SLOT(ResizeTabWidget( QResizeEvent*)));
564	// }
565
566	fTabWidget->setCurrentIndex(fTabWidget->count()-1);
567	// UpdateTabWidget(fTabWidget->count()-1);
568	// Set visible
569	#if QT_VERSION >= 0x040000
570	#if QT_VERSION >= 0x040200
571	fMainWindow->setVisible(true);
572	#else
573	fMainWindow->show();
574	#endif
575	#else
576	fMainWindow->show();
577	#endif
578
579
580
581	// // // Check size
582	// // int offX = (sizeX-aWidget->size().width());
583	// // int offY = (sizeY-aWidget->size().height());
584
585	// // #ifdef G4DEBUG_INTERFACES_BASIC
586	// // printf("G4UIQt::AddTabWidget resize AFTER FIRST W:%d + sx:%d -fwx:%d H:%d + sy:%d -fwy:%d TabW:%d TabH:%d G4UIQt G4UIQt offX:%d offY:%d aWX:%d aWY:%d\n",fMainWindow->width(),sizeX,fTabWidget->width(),fMainWindow->height(),sizeY,fTabWidget->height(),fTabWidget->width(),fTabWidget->height(),offX,offY,aWidget->size().height(),aWidget->size().width());
587	// // #endif
588
589	// // // and correct if necessairy
590	// // if ((offX != 0) \|\|(offY != 0)) {
591	// // fMainWindow->resize(fMainWindow->width()+offX,fMainWindow->height()+offY);
592	// // // Re-Set visible
593	// // #if QT_VERSION >= 0x040000
594	// // #if QT_VERSION >= 0x040200
595	// // fMainWindow->setVisible(true);
596	// // #else
597	// // fMainWindow->show();
598	// // #endif
599	// // #else
600	// // fMainWindow->show();
601	// // #endif
602	// // }
603
604	// // #ifdef G4DEBUG_INTERFACES_BASIC
605	// // printf("G4UIQt::AddTabWidget resize ^^^^^^^^^^^^ W:%d + sx:%d -fwx:%d H:%d + sy:%d -fwy:%d TabW:%d TabH:%d G4UIQt G4UIQt offX:%d offY:%d aWX:%d aWY:%d\n",fMainWindow->width(),sizeX,fTabWidget->width(),fMainWindow->height(),sizeY,fTabWidget->height(),fTabWidget->width(),fTabWidget->height(),offX,offY,aWidget->size().height(),aWidget->size().width());
606	// // #endif
607	printf("G4UIQt::AddTabWidget END\n");
608	// // #endif
609
610	fTabWidget->setVisible(true);
611
612	return true;
613	}
614
615
616	void G4UIQt::UpdateTabWidget(int tabNumber) {
617	#ifdef G4DEBUG_INTERFACES_BASIC
618	printf("G4UIQt::UpdateTabWidget %d\n",tabNumber);
619	#endif
620	if ( fTabWidget == NULL) {
621	fTabWidget = new G4QTabWidget;
622	}
623
624
625	#ifdef G4DEBUG_INTERFACES_BASIC
626	printf("G4UIQt::UpdateTabWidget CALL REPAINT tabGL\n");
627	#endif
628
629	fTabWidget->setCurrentIndex(tabNumber);
630
631	// Send this signal to unblock graphic updates !
632	fTabWidget->setVisible(true);
633
634	// This will send a paintEvent to OGL Viewers
635	fTabWidget->setTabSelected();
636
637	#ifdef G4DEBUG_INTERFACES_BASIC
638	printf("G4UIQt::UpdateTabWidget END\n");
639	#endif
640	}
641
642
643	/** Send resize event to all tabs
644	*/
645	void G4UIQt::ResizeTabWidget( QResizeEvent* e) {
646	for (int a=0;a<fTabWidget->count() ;a++) {
647	#ifdef G4DEBUG_INTERFACES_BASIC
648	printf("G4UIQt::ResizeTabWidget +++++++++++++++++++++++++++++++++++++++\n");
649	#endif
650	fTabWidget->widget(a)->resize(e->size());
651	}
652	}
653
654
655	/** Start the Qt main loop
656	*/
657	G4UIsession* G4UIQt::SessionStart (
658	)
659	{
660	#ifdef G4DEBUG_INTERFACES_BASIC
661	printf("G4UIQt::G4UIQt SessionStart\n");
662	#endif
663
664	G4Qt* interactorManager = G4Qt::getInstance ();
665
666	Prompt("Session :");
667	exitSession = false;
668
669	fTabWidget->setVisible(true);
670	fEmptyViewerTabLabel->setVisible(true);
671
672	#if QT_VERSION >= 0x040000
673	#if QT_VERSION >= 0x040200
674	fMainWindow->setVisible(true);
675	#else
676	fMainWindow->show();
677	#endif
678	#else
679	fMainWindow->show();
680	#endif
681
682	QCoreApplication::sendPostedEvents () ;
683
684	#ifdef G4DEBUG_INTERFACES_BASIC
685	printf("G4UIQt::G4UIQt SessionStart2\n");
686	#endif
687	interactorManager->DisableSecondaryLoop (); // TO KEEP
688	if ((QApplication*)interactorManager->GetMainInteractor())
689	((QApplication*)interactorManager->GetMainInteractor())->exec();
690
691	// on ne passe pas le dessous ? FIXME ????
692	// je ne pense pas 13/06
693
694	// void* event; // TO KEEP
695	// while((event = interactorManager->GetEvent())!=NULL) { // TO KEEP
696	// interactorManager->DispatchEvent(event); // TO KEEP
697	// if(exitSession==true) break; // TO KEEP
698	// } // TO KEEP
699
700	interactorManager->EnableSecondaryLoop ();
701	return this;
702	}
703
704
705	/** Display the prompt in the prompt area
706	@param aPrompt : string to display as the promt label
707	//FIXME : probablement inutile puisque le seul a afficher qq chose d'autre
708	que "session" est SecondaryLoop()
709	*/
710	void G4UIQt::Prompt (
711	G4String aPrompt
712	)
713	{
714	if (!aPrompt) return;
715
716	fCommandLabel->setText((char*)aPrompt.data());
717	}
718
719
720
721	void G4UIQt::SessionTerminate (
722	)
723	{
724	G4Qt* interactorManager = G4Qt::getInstance ();
725	fMainWindow->close();
726	((QApplication*)interactorManager->GetMainInteractor())->exit();
727	}
728
729
730
731	/**
732	Called by intercoms/src/G4UImanager.cc<br>
733	Called by visualization/management/src/G4VisCommands.cc with "EndOfEvent" argument<br>
734	It have to pause the session command terminal.<br>
735	Call SecondaryLoop to wait for exit event<br>
736	@param aState
737	@see : G4VisCommandReviewKeptEvents::SetNewValue
738	*/
739	void G4UIQt::PauseSessionStart (
740	G4String aState
741	)
742	{
743	if (!aState) return;
744
745	if(aState=="G4_pause> ") { // TO KEEP
746	SecondaryLoop ("Pause, type continue to exit this state"); // TO KEEP
747	} // TO KEEP
748
749	if(aState=="EndOfEvent") { // TO KEEP
750	// Picking with feed back in event data Done here !!!
751	SecondaryLoop ("End of event, type continue to exit this state"); // TO KEEP
752	} // TO KEEP
753	}
754
755
756
757	/**
758	Begin the secondary loop
759	@param a_prompt : label to display as the prompt label
760	*/
761	void G4UIQt::SecondaryLoop (
762	G4String aPrompt
763	)
764	{
765	if (!aPrompt) return;
766
767	G4Qt* interactorManager = G4Qt::getInstance (); // TO KEEP ?
768	Prompt(aPrompt); // TO KEEP
769	exitPause = false; // TO KEEP
770	void* event; // TO KEEP
771	while((event = interactorManager->GetEvent())!=NULL) { // TO KEEP
772	interactorManager->DispatchEvent(event); // TO KEEP
773	if(exitPause==true) break; // TO KEEP
774	} // TO KEEP
775	Prompt("Session :"); // TO KEEP
776	}
777
778
779
780	/**
781	Receive a cout from Geant4. We have to display it in the cout zone
782	@param aString : label to add in the display area
783	@return 0
784	*/
785	G4int G4UIQt::ReceiveG4cout (
786	G4String aString
787	)
788	{
789	if (!aString) return 0;
790
791	QStringList newStr;
792
793	// Add to stringList
794	#if QT_VERSION < 0x040000
795	newStr = QStringList(QString((char*)aString.data()).simplifyWhiteSpace());
796	#else
797	newStr = QStringList(QString((char*)aString.data()).trimmed());
798	#endif
799	fG4cout += newStr;
800
801	QStringList result = newStr.filter(fCoutFilter->text());
802
803	if (result.join("\n").isEmpty()) {
804	return 0;
805	}
806	fCoutTBTextArea->append(result.join("\n"));
807	fCoutTBTextArea->repaint();
808
809	#if QT_VERSION < 0x040000
810	fCoutTBTextArea->verticalScrollBar()->setValue(fCoutTBTextArea->verticalScrollBar()->maxValue());
811	#else
812	fCoutTBTextArea->verticalScrollBar()->setSliderPosition(fCoutTBTextArea->verticalScrollBar()->maximum());
813	#endif
814
815	return 0;
816	}
817
818
819	/**
820	Receive a cerr from Geant4. We have to display it in the cout zone
821	@param aString : label to add in the display area
822	@return 0
823	*/
824	G4int G4UIQt::ReceiveG4cerr (
825	G4String aString
826	)
827	{
828	if (!aString) return 0;
829
830	QStringList newStr;
831
832	// Add to stringList
833	#if QT_VERSION < 0x040000
834	newStr = QStringList(QString((char*)aString.data()).simplifyWhiteSpace());
835	#else
836	newStr = QStringList(QString((char*)aString.data()).trimmed());
837	#endif
838	fG4cout += newStr;
839
840	QStringList result = newStr.filter(fCoutFilter->text());
841
842	#if QT_VERSION < 0x040000
843	QColor previousColor = fCoutTBTextArea->color();
844	fCoutTBTextArea->setColor(Qt::red);
845	fCoutTBTextArea->append(result.join("\n"));
846	fCoutTBTextArea->setColor(previousColor);
847	fCoutTBTextArea->verticalScrollBar()->setValue(fCoutTBTextArea->verticalScrollBar()->maxValue());
848	#else
849	QColor previousColor = fCoutTBTextArea->textColor();
850	fCoutTBTextArea->setTextColor(Qt::red);
851	fCoutTBTextArea->append(result.join("\n"));
852	fCoutTBTextArea->setTextColor(previousColor);
853	fCoutTBTextArea->verticalScrollBar()->setSliderPosition(fCoutTBTextArea->verticalScrollBar()->maximum());
854	#endif
855	fCoutTBTextArea->repaint();
856	return 0;
857	}
858
859
860
861	/**
862	Add a new menu to the menu bar
863	@param aName name of menu
864	@param aLabel label to display
865	*/
866	void G4UIQt::AddMenu (
867	const char* aName
868	,const char* aLabel
869	)
870	{
871	if (aName == NULL) return;
872	if (aLabel == NULL) return;
873
874	#if QT_VERSION < 0x040000
875	QPopupMenu *fileMenu = new QPopupMenu( fMainWindow);
876	fMainWindow->menuBar()->insertItem( aLabel, fileMenu );
877	#else
878	QMenu *fileMenu = new QMenu(aLabel);
879	fMainWindow->menuBar()->insertMenu(fMainWindow->menuBar()->actions().last(),fileMenu);
880	#endif
881
882	AddInteractor (aName,(G4Interactor)fileMenu);
883	}
884
885
886	/**
887	Add a new button to a menu
888	@param aMenu : parent menu
889	@param aLabel : label to display
890	@param aCommand : command to execute as a callback
891	*/
892	void G4UIQt::AddButton (
893	const char* aMenu
894	,const char* aLabel
895	,const char* aCommand
896	)
897	{
898	if(aMenu==NULL) return; // TO KEEP
899	if(aLabel==NULL) return; // TO KEEP
900	if(aCommand==NULL) return; // TO KEEP
901
902	#if QT_VERSION < 0x040000
903	QPopupMenu parent = (QPopupMenu)GetInteractor(aMenu);
904	#else
905	QMenu parent = (QMenu)GetInteractor(aMenu);
906	#endif
907
908	if(parent==NULL) return;
909
910	QSignalMapper *signalMapper = new QSignalMapper(this);
911	#if QT_VERSION < 0x030200
912	QAction *action = new QAction(QString(aLabel),QString(aLabel),QKeySequence::QKeySequence (),signalMapper, SLOT(map()));
913	action->addTo(parent);
914	connect(action,SIGNAL(activated()),signalMapper,SLOT(map()));
915
916	#elif QT_VERSION < 0x040000
917	QAction *action = new QAction(QString(aLabel),QKeySequence::QKeySequence (),signalMapper, SLOT(map()));
918	action->addTo(parent);
919	connect(action,SIGNAL(activated()),signalMapper,SLOT(map()));
920
921	#else
922	QAction *action = parent->addAction(aLabel, signalMapper, SLOT(map()));
923
924	#endif
925	connect(signalMapper, SIGNAL(mapped(const QString &)),this, SLOT(ButtonCallback(const QString&)));
926	signalMapper->setMapping(action, QString(aCommand));
927	}
928
929
930
931
932	void G4UIQt::ActivateCommand(
933	G4String newCommand
934	)
935	{
936	if (!fHelpTreeWidget) {
937	return;
938	}
939	// Look for the choosen command "newCommand"
940	size_t i = newCommand.index(" ");
941	G4String targetCom ="";
942	if( i != std::string::npos )
943	{
944	G4String newValue = newCommand(i+1,newCommand.length()-(i+1));
945	newValue.strip(G4String::both);
946	targetCom = ModifyToFullPathCommand( newValue );
947	}
948	#ifdef G4DEBUG_INTERFACES_BASIC
949	printf("G4UIQt::ActivateCommand found : %d \n",targetCom.data());
950	#endif
951	if (targetCom != "") {
952	OpenHelpTreeOnCommand(targetCom.data());
953	}
954
955	fToolBox->setCurrentWidget(fHelpTBWidget);
956	}
957
958
959
960	/**
961	Create the help tree widget
962	@param parent : parent of tree widget
963	@return the widget containing the tree or NULL if it could not have beeen created
964	*/
965
966	#if QT_VERSION < 0x040000
967	QListView * G4UIQt::CreateHelpTree()
968	#else
969	QTreeWidget * G4UIQt::CreateHelpTree()
970	#endif
971	{
972	G4UImanager* UI = G4UImanager::GetUIpointer();
973	if(UI==NULL) return NULL;
974	G4UIcommandTree * treeTop = UI->GetTree();
975
976
977	// build widget
978	#if QT_VERSION < 0x040000
979	fHelpTreeWidget->setSelectionMode(QListView::Single);
980	fHelpTreeWidget->setRootIsDecorated(true);
981	fHelpTreeWidget->addColumn("Command");
982	fHelpTreeWidget->header()->setResizeEnabled(FALSE,1);
983	#else
984	fHelpTreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
985	QStringList labels;
986	labels << QString("Command");
987	fHelpTreeWidget->setHeaderLabels(labels);
988	#endif
989
990	G4int treeSize = treeTop->GetTreeEntry();
991	#if QT_VERSION < 0x040000
992	QListViewItem * newItem;
993	#else
994	QTreeWidgetItem * newItem;
995	#endif
996	for (int a=0;a<treeSize;a++) {
997	// Creating new item
998
999	#if QT_VERSION < 0x040000
1000	newItem = new QListViewItem(fHelpTreeWidget);
1001	newItem->setText(0,QString((char*)(treeTop->GetTree(a+1)->GetPathName()).data()).simplifyWhiteSpace());
1002	#else
1003	newItem = new QTreeWidgetItem(fHelpTreeWidget);
1004	newItem->setText(0,QString((char*)(treeTop->GetTree(a+1)->GetPathName()).data()).trimmed());
1005	#endif
1006
1007
1008	// look for childs
1009	CreateChildTree(newItem,treeTop->GetTree(a+1));
1010	// items.append(newItem);
1011	}
1012
1013
1014	#if QT_VERSION < 0x040000
1015	connect(fHelpTreeWidget, SIGNAL(selectionChanged ()),this, SLOT(HelpTreeClicCallback()));
1016	connect(fHelpTreeWidget, SIGNAL(doubleClicked (QListViewItem*)),this, SLOT(HelpTreeDoubleClicCallback()));
1017	#else
1018	connect(fHelpTreeWidget, SIGNAL(itemSelectionChanged ()),this, SLOT(HelpTreeClicCallback()));
1019	connect(fHelpTreeWidget, SIGNAL(itemDoubleClicked (QTreeWidgetItem*,int)),this, SLOT(HelpTreeDoubleClicCallback()));
1020	#endif
1021
1022	return fHelpTreeWidget;
1023	}
1024
1025
1026
1027	/** Fill the Help Tree Widget
1028	@param aParent : parent item to fill
1029	@param aCommandTree : commandTree node associate with this part of the Tree
1030	*/
1031	#if QT_VERSION < 0x040000
1032	void G4UIQt::CreateChildTree(
1033	QListViewItem *aParent
1034	,G4UIcommandTree *aCommandTree
1035	#else
1036	void G4UIQt::CreateChildTree(
1037	QTreeWidgetItem *aParent
1038	,G4UIcommandTree *aCommandTree
1039	#endif
1040	)
1041	{
1042	if (aParent == NULL) return;
1043	if (aCommandTree == NULL) return;
1044
1045
1046	// Creating new item
1047	#if QT_VERSION < 0x040000
1048	QListViewItem * newItem;
1049	#else
1050	QTreeWidgetItem * newItem;
1051	#endif
1052
1053	// Get the Sub directories
1054	for (int a=0;a<aCommandTree->GetTreeEntry();a++) {
1055
1056	#if QT_VERSION < 0x040000
1057	newItem = new QListViewItem(aParent);
1058	newItem->setText(0,QString((char*)(aCommandTree->GetTree(a+1)->GetPathName()).data()).simplifyWhiteSpace());
1059
1060	#else
1061	newItem = new QTreeWidgetItem(aParent);
1062	newItem->setText(0,QString((char*)(aCommandTree->GetTree(a+1)->GetPathName()).data()).trimmed());
1063	#endif
1064
1065	CreateChildTree(newItem,aCommandTree->GetTree(a+1));
1066	}
1067
1068
1069
1070	// Get the Commands
1071
1072	for (int a=0;a<aCommandTree->GetCommandEntry();a++) {
1073
1074	QStringList stringList;
1075	#if QT_VERSION < 0x040000
1076	newItem = new QListViewItem(aParent);
1077	newItem->setText(0,QString((char*)(aCommandTree->GetCommand(a+1)->GetCommandPath()).data()).simplifyWhiteSpace());
1078	newItem->setOpen(false);
1079
1080	#else
1081	newItem = new QTreeWidgetItem(aParent);
1082	newItem->setText(0,QString((char*)(aCommandTree->GetCommand(a+1)->GetCommandPath()).data()).trimmed());
1083	#if QT_VERSION < 0x040202
1084	fHelpTreeWidget->setItemExpanded(newItem,false);
1085	#else
1086	newItem->setExpanded(false);
1087	#endif
1088	#endif
1089
1090	}
1091	}
1092
1093
1094	/** Find a treeItemWidget in the help tree
1095	@param aCommand item's String to look for
1096	@return item if found, NULL if not
1097	*/
1098	#if QT_VERSION < 0x040000
1099	QListViewItem* G4UIQt::FindTreeItem(
1100	QListViewItem *aParent
1101	#else
1102	QTreeWidgetItem* G4UIQt::FindTreeItem(
1103	QTreeWidgetItem *aParent
1104	#endif
1105	,const QString& aCommand
1106	)
1107	{
1108	if (aParent == NULL) return NULL;
1109
1110	if (aParent->text(0) == aCommand)
1111	return aParent;
1112
1113	#if QT_VERSION < 0x040000
1114	QListViewItem * tmp = NULL;
1115	QListViewItem* tmpItem = aParent->firstChild();
1116	while (tmpItem != 0) {
1117	if (!tmp)
1118	tmp = FindTreeItem(tmpItem,aCommand);
1119	tmpItem = tmpItem->nextSibling();
1120	}
1121
1122	#else
1123	QTreeWidgetItem * tmp = NULL;
1124	for (int a=0;a<aParent->childCount();a++) {
1125	if (!tmp)
1126	tmp = FindTreeItem(aParent->child(a),aCommand);
1127	}
1128	#endif
1129	return tmp;
1130	}
1131
1132
1133
1134	/** Build the command list parameters in a QString<br>
1135	Reimplement partialy the G4UIparameter.cc
1136	@param aCommand : command to list parameters
1137	@see G4UIparameter::List()
1138	@see G4UIcommand::List()
1139	@return the command list parameters, or "" if nothing
1140	*/
1141	QString G4UIQt::GetCommandList (
1142	const G4UIcommand *aCommand
1143	)
1144	{
1145
1146	QString txt ="";
1147	if (aCommand == NULL)
1148	return txt;
1149
1150	G4String commandPath = aCommand->GetCommandPath();
1151	G4String rangeString = aCommand->GetRange();
1152	G4int n_guidanceEntry = aCommand->GetGuidanceEntries();
1153	G4int n_parameterEntry = aCommand->GetParameterEntries();
1154
1155	if ((commandPath == "") &&
1156	(rangeString == "") &&
1157	(n_guidanceEntry == 0) &&
1158	(n_parameterEntry == 0)) {
1159	return txt;
1160	}
1161
1162	if((commandPath.length()-1)!='/') {
1163	txt += "Command " + QString((char*)(commandPath).data()) + "\n";
1164	}
1165	txt += "Guidance :\n";
1166
1167	for( G4int i_thGuidance=0; i_thGuidance < n_guidanceEntry; i_thGuidance++ ) {
1168	txt += QString((char*)(aCommand->GetGuidanceLine(i_thGuidance)).data()) + "\n";
1169	}
1170	if( ! rangeString.isNull() ) {
1171	txt += " Range of parameters : " + QString((char*)(rangeString).data()) + "\n";
1172	}
1173	if( n_parameterEntry > 0 ) {
1174	G4UIparameter *param;
1175
1176	// Re-implementation of G4UIparameter.cc
1177
1178	for( G4int i_thParameter=0; i_thParameter<n_parameterEntry; i_thParameter++ ) {
1179	param = aCommand->GetParameter(i_thParameter);
1180	txt += "\nParameter : " + QString((char*)(param->GetParameterName()).data()) + "\n";
1181	if( ! param->GetParameterGuidance().isNull() )
1182	txt += QString((char*)(param->GetParameterGuidance()).data())+ "\n" ;
1183	txt += " Parameter type : " + QString(QChar(param->GetParameterType())) + "\n";
1184	if(param->IsOmittable()){
1185	txt += " Omittable : True\n";
1186	} else {
1187	txt += " Omittable : False\n";
1188	}
1189	if( param->GetCurrentAsDefault() ) {
1190	txt += " Default value : taken from the current value\n";
1191	} else if( ! param->GetDefaultValue().isNull() ) {
1192	txt += " Default value : " + QString((char*)(param->GetDefaultValue()).data())+ "\n";
1193	}
1194	if( ! param->GetParameterRange().isNull() ) {
1195	txt += " Parameter range : " + QString((char*)(param->GetParameterRange()).data())+ "\n";
1196	}
1197	if( ! param->GetParameterCandidates().isNull() ) {
1198	txt += " Candidates : " + QString((char*)(param->GetParameterCandidates()).data())+ "\n";
1199	}
1200	}
1201	}
1202	return txt;
1203	}
1204
1205
1206
1207	/** Implement G4VBasicShell vurtual function
1208	*/
1209	G4bool G4UIQt::GetHelpChoice(
1210	G4int&
1211	)
1212	{
1213	#ifdef G4DEBUG_INTERFACES_BASIC
1214	printf("G4UIQt::GetHelpChoice SHOULD NEVER GO HERE");
1215	#endif
1216	return true;
1217	}
1218
1219
1220	/** Event filter method. Every event from QtApplication goes here.<br/>
1221	We apply a filter only for the Up and Down Arrow press when the QLineEdit<br/>
1222	is active. If this filter match, Up arrow we give the previous command<br/>
1223	and Down arrow will give the next if exist.<br/>
1224	@param obj Emitter of the event
1225	@param event Kind of event
1226	*/
1227	bool G4UIQt::eventFilter( // Should stay with a minuscule eventFilter because of Qt
1228	QObject *aObj
1229	,QEvent *aEvent
1230	)
1231	{
1232	bool moveCommandCursor = false;
1233	if (aObj == NULL) return false;
1234	if (aEvent == NULL) return false;
1235
1236	if (aObj == fHistoryTBTableList) {
1237	if (aEvent->type() == QEvent::KeyPress) {
1238	fCommandArea->setFocus();
1239	}
1240	}
1241	if (aObj == fCommandArea) {
1242	if (aEvent->type() == QEvent::KeyPress) {
1243	QKeyEvent e = static_cast<QKeyEvent>(aEvent);
1244	if ((e->key() == (Qt::Key_Down)) \|\|
1245	(e->key() == (Qt::Key_PageDown)) \|\|
1246	(e->key() == (Qt::Key_Up)) \|\|
1247	(e->key() == (Qt::Key_PageUp))) {
1248	#if QT_VERSION < 0x040000
1249	// count rows...
1250	QListViewItem* tmpItem = fHistoryTBTableList->firstChild();
1251	int selection = -1;
1252	int index = 0;
1253	while (tmpItem != 0) {
1254	if (tmpItem == fHistoryTBTableList->selectedItem()) {
1255	selection = index;
1256	}
1257	index ++;
1258	tmpItem = tmpItem->nextSibling();
1259	}
1260	if (fHistoryTBTableList->childCount()) {
1261	if (selection == -1) {
1262	selection = fHistoryTBTableList->childCount()-1;
1263	} else {
1264	if (e->key() == (Qt::Key_Down)) {
1265	if (selection <(fHistoryTBTableList->childCount()-1))
1266	selection++;
1267	} else if (e->key() == (Qt::Key_PageDown)) {
1268	selection = fHistoryTBTableList->childCount()-1;
1269	#else
1270	int selection = fHistoryTBTableList->currentRow();
1271	if (fHistoryTBTableList->count()) {
1272	if (selection == -1) {
1273	selection = fHistoryTBTableList->count()-1;
1274	} else {
1275	if (e->key() == (Qt::Key_Down)) {
1276	if (selection <(fHistoryTBTableList->count()-1))
1277	selection++;
1278	} else if (e->key() == (Qt::Key_PageDown)) {
1279	selection = fHistoryTBTableList->count()-1;
1280	#endif
1281	} else if (e->key() == (Qt::Key_Up)) {
1282	if (selection >0)
1283	selection --;
1284	} else if (e->key() == (Qt::Key_PageUp)) {
1285	selection = 0;
1286	}
1287	}
1288	fHistoryTBTableList->clearSelection();
1289	#if QT_VERSION < 0x040000
1290	QListViewItem* tmpItem = fHistoryTBTableList->firstChild();
1291	int index = 0;
1292	while (tmpItem != 0) {
1293	if (index == selection) {
1294	tmpItem->setSelected(true);
1295	fHistoryTBTableList->setCurrentItem(tmpItem);
1296	}
1297	index ++;
1298	tmpItem = tmpItem->nextSibling();
1299	}
1300	#else
1301	#if QT_VERSION < 0x040202
1302	fHistoryTBTableList->setItemSelected(fHistoryTBTableList->item(selection),true);
1303	#else
1304	fHistoryTBTableList->item(selection)->setSelected(true);
1305	#endif
1306	fHistoryTBTableList->setCurrentItem(fHistoryTBTableList->item(selection));
1307	#endif
1308	}
1309	moveCommandCursor = true;
1310	} else if (e->key() == (Qt::Key_Tab)) {
1311	#if QT_VERSION < 0x040000
1312	G4String ss = Complete(fCommandArea->text().ascii());
1313	#else
1314	G4String ss = Complete(fCommandArea->text().toStdString().c_str());
1315	#endif
1316	fCommandArea->setText((char*)(ss.data()));
1317
1318	// do not pass by parent, it will disable widget tab focus !
1319	return true;
1320	#if QT_VERSION >= 0x040000
1321	// L.Garnier : MetaModifier is CTRL for MAC, but I don't want to put a MAC
1322	// specific #ifdef
1323	} else if (((e->modifiers () == Qt::ControlModifier) \|\| (e->modifiers () == Qt::MetaModifier)) && (e->key() == Qt::Key_A)) {
1324	fCommandArea->home(false);
1325	return true;
1326	} else if (((e->modifiers () == Qt::ControlModifier) \|\| (e->modifiers () == Qt::MetaModifier)) && (e->key() == Qt::Key_E)) {
1327	fCommandArea->end(false);
1328	return true;
1329	#endif
1330	}
1331	}
1332	}
1333	bool res= false;
1334	// change cursor position if needed
1335	if (moveCommandCursor == true) {
1336	#ifdef G4DEBUG_INTERFACES_BASIC
1337	printf("G4UIQt::eventFilter setCursor Position\n");
1338	#endif
1339	fCommandArea->setCursorPosition ( fCommandArea->text().length() );
1340	fCommandArea->setCursorPosition (4);
1341	} else {
1342	// pass the event on to the parent class
1343	res = QObject::eventFilter(aObj, aEvent);
1344	}
1345	return res;
1346	}
1347
1348
1349
1350
1351	/***************************************************************************/
1352	//
1353	// SLOTS DEFINITIONS
1354	//
1355	/***************************************************************************/
1356
1357	/** Called when user give "help" command.
1358	*/
1359	void G4UIQt::ShowHelpCallback (
1360	)
1361	{
1362	TerminalHelp("");
1363	}
1364
1365
1366	/** Called when user click on clear button. Clear the text Output area
1367	*/
1368	void G4UIQt::ClearButtonCallback (
1369	)
1370	{
1371	fCoutTBTextArea->clear();
1372	fG4cout.clear();
1373	}
1374
1375	/** Called when user exit session
1376	*/
1377	void G4UIQt::ExitSession (
1378	)
1379	{
1380	SessionTerminate();
1381	}
1382
1383	void G4UIQt::ExitHelp(
1384	)
1385	{
1386	}
1387
1388	/** Callback call when "click on a menu entry.<br>
1389	Send the associated command to geant4
1390	*/
1391	void G4UIQt::CommandEnteredCallback (
1392	)
1393	{
1394	#if QT_VERSION < 0x040000
1395	G4String command (fCommandArea->text().ascii());
1396	if (fCommandArea->text().simplifyWhiteSpace() != "") {
1397
1398	QListViewItem *newItem = new QListViewItem(fHistoryTBTableList);
1399	newItem->setText(0,fCommandArea->text());
1400	fHistoryTBTableList->insertItem(newItem);
1401	// now we have to arrange
1402	QListViewItem *temp= fHistoryTBTableList->lastItem();
1403	for (int i=0; i<fHistoryTBTableList->childCount()-1;i++) {
1404	fHistoryTBTableList->takeItem(temp);
1405	fHistoryTBTableList->insertItem(temp);
1406	temp= fHistoryTBTableList->lastItem();
1407	}
1408	#else
1409	G4String command (fCommandArea->text().toStdString().c_str());
1410	if (fCommandArea->text().trimmed() != "") {
1411	fHistoryTBTableList->addItem(fCommandArea->text());
1412	#endif
1413	fHistoryTBTableList->clearSelection();
1414	fHistoryTBTableList->setCurrentItem(NULL);
1415	fCommandArea->setText("");
1416
1417	G4Qt* interactorManager = G4Qt::getInstance ();
1418	if (interactorManager) {
1419	interactorManager->FlushAndWaitExecution();
1420	}
1421	if (command(0,4) != "help") {
1422	ApplyShellCommand (command,exitSession,exitPause);
1423	} else {
1424	ActivateCommand(command);
1425	}
1426	if(exitSession==true)
1427	SessionTerminate();
1428	}
1429	}
1430
1431
1432	/** Callback call when "enter" clicked on the command zone.<br>
1433	Send the command to geant4
1434	@param aCommand
1435	*/
1436	void G4UIQt::ButtonCallback (
1437	const QString& aCommand
1438	)
1439	{
1440	#if QT_VERSION < 0x040000
1441	G4String ss = G4String(aCommand.ascii());
1442	#else
1443	G4String ss = G4String(aCommand.toStdString().c_str());
1444	#endif
1445	ApplyShellCommand(ss,exitSession,exitPause);
1446	if(exitSession==true)
1447	SessionTerminate();
1448	}
1449
1450
1451
1452	/** This callback is activated when user selected a item in the help tree
1453	*/
1454	void G4UIQt::HelpTreeClicCallback (
1455	)
1456	{
1457	#if QT_VERSION < 0x040000
1458	QListViewItem* item = NULL;
1459	#else
1460	QTreeWidgetItem* item = NULL;
1461	#endif
1462	if (!fHelpTreeWidget)
1463	return ;
1464
1465	if (!fHelpArea)
1466	return;
1467
1468	#if QT_VERSION < 0x040000
1469	item =fHelpTreeWidget->selectedItem();
1470	#else
1471	QList<QTreeWidgetItem *> list =fHelpTreeWidget->selectedItems();
1472	if (list.isEmpty())
1473	return;
1474	item = list.first();
1475	#endif
1476	if (!item)
1477	return;
1478
1479	G4UImanager* UI = G4UImanager::GetUIpointer();
1480	if(UI==NULL) return;
1481	G4UIcommandTree * treeTop = UI->GetTree();
1482
1483
1484
1485	std::string itemText;
1486	#if QT_VERSION < 0x040000
1487	itemText = std::string(item->text(0).ascii());
1488	#else
1489	itemText = std::string(item->text(0).toStdString());
1490	#endif
1491
1492	G4UIcommand* command = treeTop->FindPath(itemText.c_str());
1493
1494	if (command) {
1495	#if QT_VERSION >= 0x040000
1496	#if QT_VERSION < 0x040200
1497	fHelpArea->clear();
1498	fHelpArea->append(GetCommandList(command));
1499	#else
1500	fHelpArea->setText(GetCommandList(command));
1501	#endif
1502	#else
1503	fHelpArea->setText(GetCommandList(command));
1504	#endif
1505	} else { // this is a command
1506	G4UIcommandTree* path = treeTop->FindCommandTree(itemText.c_str());
1507	if ( path) {
1508	// this is not a command, this is a sub directory
1509	// We display the Title
1510	#if QT_VERSION >= 0x040000
1511	#if QT_VERSION < 0x040200
1512	fHelpArea->clear();
1513	fHelpArea->append(path->GetTitle().data());
1514	#else
1515	fHelpArea->setText(path->GetTitle().data());
1516	#endif
1517	#else
1518	fHelpArea->setText(path->GetTitle().data());
1519	#endif
1520	}
1521	}
1522	}
1523
1524	/** This callback is activated when user double clic on a item in the help tree
1525	*/
1526	void G4UIQt::HelpTreeDoubleClicCallback (
1527	)
1528	{
1529	HelpTreeClicCallback();
1530
1531	#if QT_VERSION < 0x040000
1532	QListViewItem* item = NULL;
1533	#else
1534	QTreeWidgetItem* item = NULL;
1535	#endif
1536	if (!fHelpTreeWidget)
1537	return ;
1538
1539	if (!fHelpArea)
1540	return;
1541
1542	#if QT_VERSION < 0x040000
1543	item =fHelpTreeWidget->selectedItem();
1544	#else
1545	QList<QTreeWidgetItem *> list =fHelpTreeWidget->selectedItems();
1546	if (list.isEmpty())
1547	return;
1548	item = list.first();
1549	#endif
1550	if (!item)
1551	return;
1552
1553	fCommandArea->clear();
1554	fCommandArea->setText(item->text(0));
1555	}
1556
1557
1558	/** Callback called when user select an old command in the command history<br>
1559	Give it to the command area.
1560	*/
1561	void G4UIQt::CommandHistoryCallback(
1562	)
1563	{
1564	#if QT_VERSION < 0x040000
1565	QListViewItem* item = NULL;
1566	#else
1567	QListWidgetItem* item = NULL;
1568	#endif
1569	if (!fHistoryTBTableList)
1570	return ;
1571
1572
1573	#if QT_VERSION < 0x040000
1574	item =fHistoryTBTableList->selectedItem();
1575	#else
1576	QList<QListWidgetItem *> list =fHistoryTBTableList->selectedItems();
1577	if (list.isEmpty())
1578	return;
1579	item = list.first();
1580	#endif
1581	if (!item)
1582	return;
1583	#if QT_VERSION < 0x040000
1584	fCommandArea->setText(item->text(0));
1585	#else
1586	fCommandArea->setText(item->text());
1587	#endif
1588	#ifdef G4DEBUG_INTERFACES_BASIC
1589	printf("G4UIQt::CommandHistoryCallback change text\n");
1590	#endif
1591	}
1592
1593
1594	void G4UIQt::CoutFilterCallback(
1595	const QString & text) {
1596
1597	#ifdef G4DEBUG_INTERFACES_BASIC
1598	printf("G4UIQt::CoutFilterCallback : %s\n",text.toStdString().c_str());
1599	#endif
1600
1601	QStringList result = fG4cout.filter(text);
1602
1603	fCoutTBTextArea->setText(result.join("\n"));
1604	fCoutTBTextArea->repaint();
1605	#if QT_VERSION < 0x040000
1606	fCoutTBTextArea->verticalScrollBar()->setValue(fCoutTBTextArea->verticalScrollBar()->maxValue());
1607	#else
1608	fCoutTBTextArea->verticalScrollBar()->setSliderPosition(fCoutTBTextArea->verticalScrollBar()->maximum());
1609	#endif
1610	#ifdef G4DEBUG_INTERFACES_BASIC
1611	printf("G4UIQt::CoutFilterCallback textSize:%d resSize:%d \n",fG4cout.join("").size(),result.join("").size());
1612	#endif
1613
1614	}
1615
1616	/** Callback called when user give a new string to look for<br>
1617	Display a list of matching commands descriptions. If no string is set,
1618	will display the complete help tree
1619	*/
1620	void G4UIQt::LookForHelpStringCallback(
1621	)
1622	{
1623	QString searchText = fHelpLine->text();
1624
1625	#if QT_VERSION < 0x040200
1626	fHelpArea->clear();
1627	#else
1628	fHelpArea->setText("");
1629	#endif
1630	if (searchText =="") {
1631	// clear old help tree
1632	fHelpTreeWidget->clear();
1633	#if QT_VERSION < 0x040000
1634	fHelpTreeWidget->removeColumn(1);
1635	fHelpTreeWidget->removeColumn(0);
1636	#endif
1637	CreateHelpTree();
1638	return;
1639	} else {
1640	OpenHelpTreeOnCommand(searchText);
1641	}
1642	}
1643
1644
1645	void G4UIQt::OpenHelpTreeOnCommand(
1646	const QString & searchText
1647	)
1648	{
1649
1650	// the help tree
1651	G4UImanager* UI = G4UImanager::GetUIpointer();
1652	if(UI==NULL) return;
1653	G4UIcommandTree * treeTop = UI->GetTree();
1654
1655	G4int treeSize = treeTop->GetTreeEntry();
1656
1657	// clear old help tree
1658	fHelpTreeWidget->clear();
1659	#if QT_VERSION < 0x040000
1660	fHelpTreeWidget->removeColumn(1);
1661	fHelpTreeWidget->removeColumn(0);
1662	#endif
1663
1664	// look for new items
1665
1666	int tmp = 0;
1667	#if QT_VERSION < 0x040000
1668	int multFactor = 1000; // factor special for having double keys in Qt3
1669	int doubleKeyAdd = 0; // decay for doubleKeys in Qt3
1670	#endif
1671
1672	QMap<int,QString> commandResultMap;
1673	QMap<int,QString> commandChildResultMap;
1674
1675	for (int a=0;a<treeSize;a++) {
1676	G4UIcommand* command = treeTop->FindPath(treeTop->GetTree(a+1)->GetPathName().data());
1677	#if QT_VERSION > 0x040000
1678	tmp = GetCommandList (command).count(searchText,Qt::CaseInsensitive);
1679	#else
1680	tmp = GetCommandList (command).contains(searchText,false);
1681	#endif
1682	if (tmp >0) {
1683	#if QT_VERSION > 0x040000
1684	commandResultMap.insertMulti(tmp,QString((char*)(treeTop->GetTree(a+1)->GetPathName()).data()));
1685	#else // tricky thing for Qt3...
1686	doubleKeyAdd = 0;
1687	while (commandResultMap.find( tmp*multFactor+doubleKeyAdd) != commandResultMap.end()) {
1688	doubleKeyAdd ++;
1689	}
1690	commandResultMap.insert( tmpmultFactor+doubleKeyAdd,QString((char)(treeTop->GetTree(a+1)->GetPathName()).data()) );
1691	#endif
1692	}
1693	// look for childs
1694	commandChildResultMap = LookForHelpStringInChildTree(treeTop->GetTree(a+1),searchText);
1695	// insert new childs
1696	if (!commandChildResultMap.empty()) {
1697	#if QT_VERSION > 0x040000
1698	QMap<int,QString>::const_iterator i = commandChildResultMap.constBegin();
1699	while (i != commandChildResultMap.constEnd()) {
1700	commandResultMap.insertMulti(i.key(),i.value());
1701	#else // tricky thing for Qt3...
1702	QMap<int,QString>::const_iterator i = commandChildResultMap.begin();
1703	while (i != commandChildResultMap.end()) {
1704	doubleKeyAdd = 0;
1705	while (commandResultMap.find( i.key()*multFactor+doubleKeyAdd) != commandResultMap.end()) {
1706	doubleKeyAdd ++;
1707	}
1708	commandResultMap.insert(i.key()*multFactor+doubleKeyAdd,i.data());
1709	#endif
1710	i++;
1711	}
1712	commandChildResultMap.clear();
1713	}
1714	}
1715
1716	// build new help tree
1717	#if QT_VERSION < 0x040000
1718	fHelpTreeWidget->setSelectionMode(QListView::Single);
1719	fHelpTreeWidget->setRootIsDecorated(true);
1720	fHelpTreeWidget->addColumn("Command");
1721	fHelpTreeWidget->addColumn("Match");
1722	// fHelpTreeWidget->header()->setResizeEnabled(FALSE,1);
1723	#else
1724	fHelpTreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
1725	fHelpTreeWidget->setColumnCount(2);
1726	QStringList labels;
1727	labels << QString("Command") << QString("Match");
1728	fHelpTreeWidget->setHeaderLabels(labels);
1729	#endif
1730
1731	if (commandResultMap.empty()) {
1732	#if QT_VERSION < 0x040200
1733	fHelpArea->clear();
1734	fHelpArea->append("No match found");
1735	#else
1736	fHelpArea->setText("No match found");
1737	#endif
1738	return;
1739	}
1740
1741	#if QT_VERSION > 0x040000
1742	QMap<int,QString>::const_iterator i = commandResultMap.constEnd();
1743	#else
1744	QMap<int,QString>::const_iterator i = commandResultMap.end();
1745	#endif
1746	i--;
1747	// 10 maximum progress values
1748	float multValue = 10.0/(float)(i.key());
1749	QString progressChar = "\|";
1750	QString progressStr = "\|";
1751
1752	#if QT_VERSION < 0x040000
1753	QListViewItem * newItem;
1754	#else
1755	QTreeWidgetItem * newItem;
1756	#endif
1757	bool end = false;
1758	while (!end) {
1759	#if QT_VERSION > 0x040000
1760	if (i == commandResultMap.constBegin()) {
1761	#else
1762	if (i == commandResultMap.begin()) {
1763	#endif
1764	end = true;
1765	}
1766	for(int a=0;a<int(i.key()*multValue);a++) {
1767	progressStr += progressChar;
1768	}
1769	#if QT_VERSION < 0x040000
1770	newItem = new QListViewItem(fHelpTreeWidget);
1771	newItem->setText(0,i.data().simplifyWhiteSpace());
1772	#else
1773	newItem = new QTreeWidgetItem(fHelpTreeWidget);
1774	newItem->setText(0,i.value().trimmed());
1775	#endif
1776	newItem->setText(1,progressStr);
1777
1778	#if QT_VERSION >= 0x040200
1779	newItem->setForeground ( 1, QBrush(Qt::blue) );
1780	#endif
1781	progressStr = "\|";
1782	i--;
1783	}
1784	// FIXME : to be checked on Qt3
1785	#if QT_VERSION < 0x040000
1786	fHelpTreeWidget->setColumnWidthMode (1,QListView::Maximum);
1787	fHelpTreeWidget->setSorting(1,false);
1788	#else
1789	fHelpTreeWidget->resizeColumnToContents (0);
1790	fHelpTreeWidget->sortItems(1,Qt::DescendingOrder);
1791	// fHelpTreeWidget->setColumnWidth(1,10);//resizeColumnToContents (1);
1792	#endif
1793	}
1794
1795
1796
1797
1798	QMap<int,QString> G4UIQt::LookForHelpStringInChildTree(
1799	G4UIcommandTree *aCommandTree
1800	,const QString & text
1801	)
1802	{
1803	QMap<int,QString> commandResultMap;
1804	if (aCommandTree == NULL) return commandResultMap;
1805
1806	#if QT_VERSION < 0x040000
1807	int multFactor = 1000; // factor special for having double keys in Qt3
1808	int doubleKeyAdd = 0; // decay for doubleKeys in Qt3
1809	#endif
1810
1811	// Get the Sub directories
1812	int tmp = 0;
1813	QMap<int,QString> commandChildResultMap;
1814
1815	for (int a=0;a<aCommandTree->GetTreeEntry();a++) {
1816	const G4UIcommand* command = aCommandTree->GetGuidance();
1817	#if QT_VERSION > 0x040000
1818	tmp = GetCommandList (command).count(text,Qt::CaseInsensitive);
1819	#else
1820	tmp = GetCommandList (command).contains(text,false);
1821	#endif
1822	if (tmp >0) {
1823	#if QT_VERSION > 0x040000
1824	commandResultMap.insertMulti(tmp,QString((char*)(aCommandTree->GetTree(a+1)->GetPathName()).data()));
1825	#else // tricky thing for Qt3...
1826	doubleKeyAdd = 0;
1827	while (commandResultMap.find( tmp*multFactor+doubleKeyAdd) != commandResultMap.end()) {
1828	doubleKeyAdd ++;
1829	}
1830	commandResultMap.insert(tmpmultFactor+doubleKeyAdd,QString((char)(aCommandTree->GetTree(a+1)->GetPathName()).data()));
1831	#endif
1832	}
1833	// look for childs
1834	commandChildResultMap = LookForHelpStringInChildTree(aCommandTree->GetTree(a+1),text);
1835
1836	if (!commandChildResultMap.empty()) {
1837	// insert new childs
1838	#if QT_VERSION > 0x040000
1839	QMap<int,QString>::const_iterator i = commandChildResultMap.constBegin();
1840	while (i != commandChildResultMap.constEnd()) {
1841	commandResultMap.insertMulti(i.key(),i.value());
1842	#else // tricky thing for Qt3...
1843	QMap<int,QString>::const_iterator i = commandChildResultMap.begin();
1844	while (i != commandChildResultMap.end()) {
1845	doubleKeyAdd = 0;
1846	while (commandResultMap.find( i.key()*multFactor+doubleKeyAdd) != commandResultMap.end()) {
1847	doubleKeyAdd ++;
1848	}
1849	commandResultMap.insert(i.key()*multFactor+doubleKeyAdd,i.data());
1850	#endif
1851	i++;
1852	}
1853	commandChildResultMap.clear();
1854	}
1855	}
1856	// Get the Commands
1857
1858	for (int a=0;a<aCommandTree->GetCommandEntry();a++) {
1859	const G4UIcommand* command = aCommandTree->GetCommand(a+1);
1860	#if QT_VERSION > 0x040000
1861	tmp = GetCommandList (command).count(text,Qt::CaseInsensitive);
1862	#else
1863	tmp = GetCommandList (command).contains(text,false);
1864	#endif
1865	if (tmp >0) {
1866	#if QT_VERSION > 0x040000
1867	commandResultMap.insertMulti(tmp,QString((char*)(aCommandTree->GetCommand(a+1)->GetCommandPath()).data()));
1868	#else // tricky thing for Qt3...
1869	doubleKeyAdd = 0;
1870	while (commandResultMap.find( tmp*multFactor+doubleKeyAdd) != commandResultMap.end()) {
1871	doubleKeyAdd ++;
1872	}
1873	commandResultMap.insert(tmpmultFactor+doubleKeyAdd,QString((char)(aCommandTree->GetCommand(a+1)->GetCommandPath()).data()));
1874	#endif
1875	}
1876
1877	}
1878	return commandResultMap;
1879	}
1880
1881
1882
1883	G4QTabWidget::G4QTabWidget(
1884	QSplitter*& split
1885	):QTabWidget(split)
1886	{
1887	}
1888
1889	G4QTabWidget::G4QTabWidget(
1890	):QTabWidget()
1891	{
1892	}
1893
1894
1895
1896	void G4UIQt::TabCloseCallback(int a){
1897	#ifdef G4DEBUG_INTERFACES_BASIC
1898	printf("G4UIQt::TabCloseCallback %d ---------------------------------\n",a);
1899	#endif
1900	QWidget* temp = fTabWidget->widget(a);
1901	fTabWidget->removeTab (a);
1902	delete temp;
1903
1904	if (fTabWidget->count() == 0) {
1905	fMyVSplitter->addWidget(fEmptyViewerTabLabel);
1906	#if QT_VERSION < 0x040000
1907	fTabWidget->reparent(0,0,QPoint(0,0));
1908	#else
1909	fTabWidget->setParent(0);
1910	#endif
1911	}
1912	}
1913
1914
1915	void G4UIQt::CurrentChangedCallback(int a){
1916	#ifdef G4DEBUG_INTERFACES_BASIC
1917	printf("G4UIQt::CurrentChangeCallback %d ---------------------------------\n",a);
1918	#endif
1919
1920	}
1921
1922	void G4QTabWidget::paintEvent(
1923	QPaintEvent * event
1924	)
1925	{
1926
1927	if (currentWidget()) {
1928	#ifdef G4DEBUG_INTERFACES_BASIC
1929	printf("G4QTabWidget::paintEvent repaint type : %d -- rect %d %d region:%d %d page : %d %d ________________________ for = %d i= %d w: %d\n", event->type(),event->rect().height(),event->rect().width(),event->region().boundingRect().width(),event->region().boundingRect().height(),currentWidget()->width(),currentWidget()->height(),this,currentIndex(),currentWidget());
1930	#endif
1931	if ( isTabSelected()) {
1932
1933	QCoreApplication::sendPostedEvents () ;
1934	#ifdef G4DEBUG_INTERFACES_BASIC
1935	printf("G4QTabWidget::paintEvent OK\n");
1936	#endif
1937	QString text = tabText (currentIndex());
1938	QString paramSelect = QString("/vis/viewer/select ")+text;
1939	G4UImanager* UI = G4UImanager::GetUIpointer();
1940	if(UI!=NULL) {
1941	UI->ApplyCommand(paramSelect.toStdString().c_str());
1942	}
1943	unselectTab();
1944	repaint();
1945	}
1946	}
1947	}
1948
1949	#endif

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

Download in other formats: