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

Last change on this file was 1340, checked in by garnier, 15 years ago

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