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

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