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

Last change on this file since 1339 was 1335, checked in by garnier, 15 years ago

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