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

Last change on this file since 1281 was 1281, checked in by garnier, 16 years ago

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