00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #include "mainwindow.h"
00020
00021 #include <qlayout.h>
00022 #include <qmultilineedit.h>
00023 #include <qvbox.h>
00024 #include <qcheckbox.h>
00025 #include <qvaluelist.h>
00026 #include <qguardedptr.h>
00027
00028 #include <kdeversion.h>
00029 #include <kapplication.h>
00030 #include <kstdaction.h>
00031 #include <kdebug.h>
00032 #include <kaction.h>
00033 #include <klocale.h>
00034 #include <kconfig.h>
00035 #include <kstatusbar.h>
00036 #include <kdialogbase.h>
00037 #include <kkeydialog.h>
00038 #include <kedittoolbar.h>
00039 #include <kmenubar.h>
00040 #include <kmessagebox.h>
00041 #include <kiconloader.h>
00042
00043 #include <kdevproject.h>
00044 #include "projectmanager.h"
00045 #include "partcontroller.h"
00046 #include "plugincontroller.h"
00047 #include "api.h"
00048 #include "core.h"
00049 #include "settingswidget.h"
00050 #include "statusbar.h"
00051 #include "projectsession.h"
00052
00053 #include "toplevel.h"
00054 #include "mainwindowshare.h"
00055 #include <kmditoolviewaccessor.h>
00056
00057
00058 ViewMenuAction::ViewMenuAction(
00059 ViewMenuActionPrivateData Data,
00060 const QString &Name):
00061 KToggleAction(Name),
00062 WindowData (Data)
00063 {}
00064
00065 ViewMenuAction::ViewMenuAction(
00066 ViewMenuActionPrivateData Data,
00067 const QString& text, const QString& pix, const KShortcut& cut,
00068 const QObject* receiver, const char* slot,
00069 KActionCollection* parent, const char* name ):
00070 KToggleAction(text, pix, cut, 0,0, parent, name),
00071 WindowData (Data)
00072 {
00073 connect(this, SIGNAL(activated(const ViewMenuActionPrivateData &)), receiver, slot);
00074 }
00075
00076 void ViewMenuAction::slotActivated()
00077 {
00078 KToggleAction::slotActivated();
00079 emit activated(WindowData);
00080 }
00081
00082
00115 class ToolWindowState
00116 {
00117 public:
00118 ToolWindowState (KDockWidget *pDockWidget);
00119 bool hasDockWidget;
00120 KDockTabGroup * pTabGroup;
00121 bool hasTabGroup;
00122 bool mayBeShown;
00123 bool mayBeHide;
00124 KDockWidget * pDockBaseWindow;
00125 bool hasDockBaseWindow;
00126 bool dockBaseMayBeShow;
00127 bool dockBaseMayBeHide;
00128 bool dockBaseMayBeDockBack;
00129 bool dockBaseIsTopLevel;
00130 QString dockBaseName;
00131 bool viewMenuChecked;
00132 bool viewMenuEnabled;
00133 bool dockBaseIsHidden;
00134 bool dockBaseIsVisible;
00135 };
00136
00137 ToolWindowState::ToolWindowState(KDockWidget *pDockWidget)
00138 {
00139
00140 hasDockWidget = (pDockWidget != 0);
00141 pTabGroup = (hasDockWidget)?pDockWidget->parentDockTabGroup():0L;
00142 hasTabGroup = (pTabGroup != 0);
00143 mayBeShown = (hasDockWidget)?pDockWidget->mayBeShow():false;
00144 mayBeHide = (hasDockWidget)?pDockWidget->mayBeHide():false;
00145
00146
00147 pDockBaseWindow = 0;
00148 if (hasTabGroup) pDockBaseWindow = pDockWidget->dockManager()->findWidgetParentDock(pTabGroup);
00149 else if (hasDockWidget) pDockBaseWindow = pDockWidget->dockManager()->findWidgetParentDock(pDockWidget);
00150 if (mayBeHide && !pDockBaseWindow)
00151 {
00152 pDockBaseWindow = pDockWidget;
00153 }
00154 hasDockBaseWindow = (pDockBaseWindow !=0);
00155 dockBaseMayBeDockBack = (hasDockBaseWindow)?pDockBaseWindow->isDockBackPossible():false;
00156 dockBaseMayBeShow = (hasDockBaseWindow)?pDockBaseWindow->mayBeShow():false;
00157 dockBaseMayBeHide = (hasDockBaseWindow)?pDockBaseWindow->mayBeHide():false;
00158 dockBaseIsTopLevel = (hasDockBaseWindow)?(pDockBaseWindow->parent()==0):false;
00159 dockBaseName = (hasDockBaseWindow)?(pDockBaseWindow->caption()):QString("");
00160 dockBaseIsHidden = (hasDockBaseWindow)?(pDockBaseWindow->isHidden()):false;
00161 dockBaseIsVisible = (hasDockBaseWindow)?(pDockBaseWindow->isVisible()):false;
00162 viewMenuChecked = (hasTabGroup || mayBeHide)?true:false;
00163 viewMenuEnabled = !dockBaseMayBeDockBack && !dockBaseMayBeShow && !dockBaseIsHidden;
00164 }
00165
00185 class ToolDockBaseState
00186 {
00187 public:
00188 ToolDockBaseState(const QPtrList<QWidget> *pViews);
00189 KDockWidget* pDockBaseWindow;
00190 QWidget* pFirstToolWindow;
00191 bool hasDockBaseWindow;
00192 bool dockBaseIsHidden;
00193 bool dockBaseIsVisible;
00194 bool dockBaseMayBeDockBack;
00195 int noViews;
00196 };
00197
00198 ToolDockBaseState::ToolDockBaseState(const QPtrList<QWidget> *pViews):
00199 pDockBaseWindow (0L),
00200 pFirstToolWindow (0L),
00201 hasDockBaseWindow (false),
00202 dockBaseIsHidden (false),
00203 dockBaseIsVisible (false),
00204 dockBaseMayBeDockBack(false),
00205 noViews (0)
00206 {
00207
00208 return;
00209 #warning this crashes in ideal mode, looks like there are dangling pointers on opening another project
00210 QPtrListIterator<QWidget> it(*pViews);
00211 for( ; it.current(); ++it)
00212 {
00213 QWidget *pParent=it.current()->parentWidget();
00214 if (!pParent) continue;
00215 KDockWidget * pDockWidget = 0;
00216 pDockWidget = dynamic_cast<KDockWidget*>(pParent);
00217
00218 if (!pDockWidget) continue;
00219 const ToolWindowState winState(pDockWidget);
00220 if (!pFirstToolWindow && winState.viewMenuChecked) pFirstToolWindow = it.current();
00221 if (winState.hasDockBaseWindow && !hasDockBaseWindow)
00222 {
00223 hasDockBaseWindow = true;
00224 pDockBaseWindow = winState.pDockBaseWindow;
00225 dockBaseMayBeDockBack = winState.dockBaseMayBeDockBack;
00226 dockBaseIsVisible = winState.dockBaseIsVisible;
00227 if (winState.dockBaseIsHidden ||
00228 (winState.dockBaseMayBeDockBack && !winState.dockBaseIsVisible))
00229 dockBaseIsHidden = true;
00230
00231 }
00232 if (winState.viewMenuChecked) noViews++;
00233 }
00234 }
00235
00236
00237 MainWindow::MainWindow(QWidget *parent, const char *name, KMdi::MdiMode mdimode)
00238 : KMdiMainFrm(parent, name, mdimode)
00239 ,m_myWindowsReady(false)
00240 ,m_pShowOutputViews(0L)
00241 ,m_pShowTreeViews(0L)
00242 ,m_toggleViewbar(0L)
00243 ,m_bUiModeSwitchPending(false)
00244 ,m_bRemoveViewPending(false)
00245 {
00246 KConfig *config = kapp->config();
00247 config->setGroup("UI");
00248 mdiStyle = config->readNumEntry("MDIStyle", 1);
00249
00250 setIDEAlModeStyle(mdiStyle);
00251 setStandardMDIMenuEnabled(false);
00252 setManagedDockPositionModeEnabled(true);
00253
00254 resize( 800, 600 );
00255 m_pMainWindowShare = new MainWindowShare(this);
00256
00257 previous_output_view = NULL;
00258
00259 m_pDockbaseAreaOfDocumentViews->dockManager()->setReadDockConfigMode(KDockManager::RestoreAllDockwidgets);
00260 }
00261
00262
00263 void MainWindow::init()
00264 {
00265 actionCollection()->setHighlightingEnabled( true );
00266
00267 #if (KDE_VERSION > 305)
00268 setStandardToolBarMenuEnabled( true );
00269 #endif
00270 setXMLFile("kdevelopui.rc");
00271
00272 createFramework();
00273 createActions();
00274 createStatusBar();
00275
00276 createGUI(0);
00277
00278 m_pMainWindowShare->init();
00279
00280 KAction *a = actionCollection()->action("help_report_bug");
00281 disconnect(a, SIGNAL(activated()), 0, 0);
00282 connect(a, SIGNAL(activated()), m_pMainWindowShare, SLOT(slotReportBug()));
00283
00284 connect(PartController::getInstance(), SIGNAL(activePartChanged(KParts::Part*)),
00285 this, SLOT(createGUI(KParts::Part*)));
00286 connect(Core::getInstance(), SIGNAL(projectOpened()),
00287 this, SLOT(slotReactToProjectOpened()) );
00288 connect(ProjectManager::getInstance()->projectSession(),
00289 SIGNAL(sig_restoreAdditionalViewProperties(const QString&, const QDomElement*)),
00290 this, SLOT(slotRestoreAdditionalViewProperties(const QString&, const QDomElement*)));
00291 connect(ProjectManager::getInstance()->projectSession(),
00292 SIGNAL(sig_saveAdditionalViewProperties(const QString&, QDomElement*)),
00293 this, SLOT(slotSaveAdditionalViewProperties(const QString&, QDomElement*)));
00294
00295 connect(this,SIGNAL(viewActivated(KMdiChildView*)),this,SLOT(slotViewActivated(KMdiChildView*)));
00296
00297 connect( PartController::getInstance(), SIGNAL(partURLChanged(KParts::ReadOnlyPart * )),
00298 this, SLOT(slotPartURLChanged(KParts::ReadOnlyPart * )) );
00299
00300 if (!isFakingSDIApplication()) {
00301 QPopupMenu *menu = (QPopupMenu*) main()->child( "window", "KPopupMenu" );
00302 unsigned int count = menuBar()->count();
00303 if (menu)
00304 setWindowMenu(menu);
00305 else
00306 menuBar()->insertItem( i18n("&Window"), windowMenu(), -1, count-2);
00307 }
00308
00309 if ( PluginController::pluginServices().isEmpty() ) {
00310 KMessageBox::sorry( this, i18n("Unable to find plugins, KDevelop will not work properly.\nPlease make sure "
00311 "that KDevelop is installed in your KDE directory, otherwise you have to add KDevelop's installation "
00312 "path to the environment variable KDEDIRS and run kbuildsycoca. Restart KDevelop afterwards.\n"
00313 "Example for BASH users:\nexport KDEDIRS=/path/to/kdevelop:$KDEDIRS && kbuildsycoca"),
00314 i18n("Could Not Find Plugins") );
00315 }
00316 }
00317
00318
00319 void MainWindow::slotViewActivated(KMdiChildView* view) {
00320 kdDebug()<<"void MainWindow::slotViewActivated(KMdiChildView*)"<<endl;
00321 QWidget *w=view->childAt(5,5);
00322 PartController::getInstance()->slotCurrentChanged(w);
00323 }
00324
00325 MainWindow::~MainWindow()
00326 {
00327 TopLevel::invalidateInstance( this );
00328 }
00329
00330 bool MainWindow::queryClose()
00331 {
00332 return Core::getInstance()->queryClose();
00333 }
00334
00335 bool MainWindow::queryExit()
00336 {
00337 saveSettings();
00338 return true;
00339 }
00340
00341 KMainWindow *MainWindow::main()
00342 {
00343 return this;
00344 }
00345
00346
00347 void MainWindow::createStatusBar()
00348 {
00349 (void) new StatusBar(this);
00350 }
00351
00352
00353 void MainWindow::createFramework()
00354 {
00355 PartController::createInstance(this);
00356 setMenuForSDIModeSysButtons(menuBar());
00357 }
00358
00364 void MainWindow::createActions()
00365 {
00366
00367 ViewMenuActionPrivateData ViewActionData;
00368 ViewActionData.eView = OutputView;
00369 ViewActionData.pChildView = 0L;
00370 ViewActionData.pDockWidget = 0L;
00371 m_pShowOutputViews = new ViewMenuAction(ViewActionData,i18n("All Output Views"), "view_bottom",
00372 CTRL + SHIFT + Key_O, this, SLOT(toggleToolDockBaseState(const ViewMenuActionPrivateData &)),
00373 actionCollection(), "output_view" );
00374 m_pShowOutputViews->setStatusText(i18n("Output view"));
00375 m_pShowOutputViews->setEnabled( true );
00376
00377 ViewActionData.eView = TreeView;
00378 m_pShowTreeViews = new ViewMenuAction(ViewActionData,i18n("All Tree Views"), "tree_win",
00379 CTRL + SHIFT + Key_T, this, SLOT(toggleToolDockBaseState(const ViewMenuActionPrivateData &)),
00380 actionCollection(), "tree_view" );
00381 m_pShowTreeViews->setStatusText(i18n("Tree view"));
00382 m_pShowTreeViews->setEnabled( true );
00383
00384 connect(manager(), SIGNAL(change()),this, SLOT(updateActionState()));
00385
00386 m_pOutputToolViewsMenu = new KActionMenu( i18n("Output Tool Views"), 0, "view_output_tool_views");
00387 m_pOutputToolViewsMenu->setToolTip(i18n("Output tool views"));
00388 m_pOutputToolViewsMenu->setWhatsThis(i18n("<b>Output tool views</b><p>Shows all output views available."));
00389 connect(m_pOutputToolViewsMenu->popupMenu(),SIGNAL(aboutToShow()),this,SLOT(fillOutputToolViewsMenu()));
00390 actionCollection()->insert(m_pOutputToolViewsMenu);
00391
00392 m_pTreeToolViewsMenu = new KActionMenu( i18n("Tree Tool Views"), 0, "view_tree_tool_views");
00393 m_pTreeToolViewsMenu->setToolTip(i18n("Tree tool views"));
00394 m_pTreeToolViewsMenu->setWhatsThis(i18n("<b>Tree tool views</b><p>Shows all tool views available."));
00395 connect(m_pTreeToolViewsMenu->popupMenu(),SIGNAL(aboutToShow()),this,SLOT(fillTreeToolViewsMenu()));
00396 actionCollection()->insert(m_pTreeToolViewsMenu);
00397
00398 m_pMainWindowShare->createActions();
00399 connect(m_pMainWindowShare, SIGNAL(gotoNextWindow()), this, SLOT(gotoNextWindow()));
00400 connect(m_pMainWindowShare, SIGNAL(gotoPreviousWindow()), this, SLOT(gotoPreviousWindow()));
00401 connect(m_pMainWindowShare, SIGNAL(gotoFirstWindow()), this, SLOT(gotoFirstWindow()));
00402 connect(m_pMainWindowShare, SIGNAL(gotoLastWindow()), this, SLOT(gotoLastWindow()));
00403
00404 m_toggleViewbar = KStdAction::showToolbar(this, SLOT(slotToggleViewbar()),actionCollection(), "settings_viewbar");
00405 m_toggleViewbar->setText(i18n("Show &Viewbar"));
00406 m_toggleViewbar->setToolTip( i18n("Show viewbar") );
00407 m_toggleViewbar->setWhatsThis(i18n("<b>Show viewbar</b><p>Hides or shows the viewbar."));
00408 showViewTaskBar();
00409 if (m_mdiMode == KMdi::TabPageMode || m_mdiMode == KMdi::IDEAlMode) {
00410 slotToggleViewbar();
00411 m_toggleViewbar->setEnabled(false);
00412 }
00413
00414 new KAction( i18n("Raise &Editor"), ALT+Key_C, this, SLOT(raiseEditor()), actionCollection(), "raise_editor");
00415 }
00416
00417 KMdiChildView* MainWindow::wrapper(QWidget *view, const QString& name)
00418 {
00419 QString shortName = name;
00420 int length = shortName.length();
00421 shortName = shortName.right(length - (shortName.findRev('/') +1));
00422
00423 KMdiChildView* pMDICover = createWrapper(view, name, shortName);
00424 m_widgetMap.insert(view, pMDICover);
00425 m_childViewMap.insert(pMDICover, view);
00426
00427 return pMDICover;
00428 }
00429
00430
00431 void MainWindow::slotPartURLChanged( KParts::ReadOnlyPart * ro_part )
00432 {
00433 if ( !ro_part || !ro_part->widget() ) return;
00434
00435 KMdiChildView * child = m_widgetMap[ ro_part->widget() ];
00436 if ( child )
00437 {
00438 child->setMDICaption( ro_part->url().fileName() );
00439 }
00440 }
00441
00442
00443 void MainWindow::embedPartView(QWidget *view, const QString &, const QString& fullName)
00444 {
00445 KMdiChildView *child = wrapper(view, fullName);
00446 m_captionDict.insert(fullName, child);
00447
00448 const QPixmap* wndIcon = view->icon();
00449 if (!wndIcon || (wndIcon && (wndIcon->size().height() > 16))) {
00450 view->setIcon(SmallIcon("kdevelop"));
00451 child->setIcon(SmallIcon("kdevelop"));
00452 }
00453
00454
00455 unsigned int mdiFlags = KMdi::StandardAdd | KMdi::UseKMdiSizeHint;
00456 addWindow(child, mdiFlags);
00457
00458 m_partViews.append(child);
00459
00460
00461 if ((mdiMode() == KMdi::ChildframeMode) && isInMaximizedChildFrmMode()) {
00462 QWidget* v;
00463 if (child->mdiParent()) { v = child->mdiParent(); }
00464 else { v = child; }
00465 QRect geom = v->geometry();
00466 v->setGeometry(geom.left(),geom.top(),geom.width()+1,geom.height()+1);
00467 v->setGeometry(geom.left(),geom.top(),geom.width(),geom.height());
00468 }
00469 }
00470
00471 void MainWindow::checkAndFixToolViewObjectName(QWidget* view, const QString& shortName)
00472 {
00473
00474
00475 static unsigned int s_index4DoubledName = 0;
00476
00477 QString objName = view->name();
00478 bool fixed = false;
00479 if (objName.isEmpty()) {
00480 objName = shortName;
00481 fixed = true;
00482 }
00483 if (objName == "unnamed") {
00484 objName = shortName;
00485 fixed = true;
00486 }
00487 if (objName.isEmpty()) {
00488 QString s; s.setNum(s_index4DoubledName++);
00489 objName += "unnamed_" + s;
00490 fixed = true;
00491 }
00492 if (fixed) {
00493 view->setName(objName.latin1());
00494 }
00495 }
00496
00497 void MainWindow::embedSelectView(QWidget *view, const QString &name, const QString &toolTip)
00498 {
00499 const QPixmap* wndIcon = view->icon();
00500 kdDebug(9000) << "icon = " << wndIcon << endl;
00501 if (!wndIcon ) {
00502 view->setIcon(SmallIcon("kdevelop"));
00503 }
00504
00505 QString shortName = name;
00506 int length = shortName.length();
00507 shortName = shortName.right(length - (shortName.findRev('/') +1)).stripWhiteSpace();
00508 checkAndFixToolViewObjectName(view, shortName);
00509
00510 KMdiToolViewAccessor *tmp =
00511 KMdiMainFrm::addToolWindow(view,
00512 KDockWidget::DockLeft,
00513 getMainDockWidget(),
00514 25,
00515 toolTip,
00516 mdiMode() == KMdi::IDEAlMode ? shortName : ""
00517 );
00518
00519 m_selectViews.append(view);
00520 }
00521
00522 void MainWindow::embedSelectViewRight(QWidget* view, const QString& title, const QString &toolTip)
00523 {
00524 if (mdiMode() != KMdi::IDEAlMode) {
00525
00526 embedSelectView( view, title, toolTip );
00527 return;
00528 }
00529
00530
00531 const QPixmap* wndIcon = view->icon();
00532 kdDebug(9000) << "icon = " << wndIcon << endl;
00533 if (!wndIcon ) {
00534 view->setIcon(SmallIcon("kdevelop"));
00535 }
00536
00537 QString shortName = title;
00538 int length = shortName.length();
00539 shortName = shortName.right(length - (shortName.findRev('/') +1)).stripWhiteSpace();
00540 checkAndFixToolViewObjectName(view, shortName);
00541
00542 KMdiToolViewAccessor *tmp=KMdiMainFrm::addToolWindow(view,
00543 KDockWidget::DockRight,
00544 getMainDockWidget(),
00545 25,
00546 toolTip,
00547 shortName);
00548 m_selectViews.append(view);
00549 }
00550
00551 void MainWindow::embedOutputView(QWidget *view, const QString &name, const QString &toolTip)
00552 {
00553 QString shortName = name;
00554 int length = shortName.length();
00555 shortName = shortName.right(length - (shortName.findRev('/') +1)).stripWhiteSpace();
00556 checkAndFixToolViewObjectName(view, shortName);
00557
00558 KMdiToolViewAccessor *tmp =
00559 KMdiMainFrm::addToolWindow(view,
00560 KDockWidget::DockBottom,
00561 getMainDockWidget(),
00562 70,
00563 toolTip,
00564 shortName
00565 );
00566
00567 m_outputViews.append(view);
00568 }
00569
00570
00571 void MainWindow::setViewAvailable(QWidget *pView, bool bEnabled)
00572 {
00573 if (!pView) return;
00574
00575 KDockWidget* pWrappingDockWidget = dockManager->findWidgetParentDock(pView);
00576 if (!pWrappingDockWidget) return;
00577 if (bEnabled) {
00578 pWrappingDockWidget->makeDockVisible();
00579 }
00580 else {
00581 pWrappingDockWidget->undock();
00582 }
00583
00584 if (bEnabled) {
00585 m_unavailableViews.remove(pView);
00586 }
00587 else {
00588 m_unavailableViews.append(pView);
00589 }
00590 }
00591
00592 void MainWindow::removeView(QWidget *view)
00593 {
00594 if (!view) {
00595 return;
00596 }
00597 m_bRemoveViewPending = true;
00598
00599 QGuardedPtr<KMdiChildView> wrapper = m_widgetMap[view];
00600
00601 if (wrapper) {
00602 removeWindowFromMdi(wrapper);
00603 m_partViews.remove(wrapper);
00604 m_widgetMap.remove(view);
00605 m_childViewMap.remove(wrapper);
00606 m_captionDict.remove(wrapper->caption());
00607 }
00608
00609
00610
00611
00612 QGuardedPtr<KDockWidget> pDock = dockManager->findWidgetParentDock(wrapper ? wrapper : view);
00613
00614
00615
00616
00617 view->hide();
00618 view->reparent(this, QPoint(0,0), false);
00619
00620
00621
00622 if (wrapper) {
00623 closeWindow(wrapper);
00624 }
00625
00626 if( pDock ) {
00627 deleteToolWindow(view);
00628
00629
00630 }
00631 else {
00632 kdDebug(9000) << "pDock already destroyed!!" << endl;
00633 }
00634 if (!wrapper) {
00635 m_selectViews.remove(view);
00636 m_outputViews.remove(view);
00637 }
00638
00639 m_bRemoveViewPending = false;
00640 }
00641
00642
00643 void MainWindow::raiseView(QWidget *view)
00644 {
00645 m_myWindowsReady = true;
00646
00647 QPtrList<QWidget> *pViews = 0L;
00648
00649 QWidget *wrapper = m_widgetMap[ view ];
00650 if (wrapper)
00651 wrapper->setFocus();
00652
00653 KDockWidget* pDock = dockManager->findWidgetParentDock(wrapper ? wrapper : view);
00654 if (pDock)
00655 if (!pDock->isVisible())
00656 makeDockVisible(pDock);
00657 }
00658
00659
00660 void MainWindow::lowerView(QWidget *)
00661 {
00662
00663 }
00664
00665 void MainWindow::lowerAllViews()
00666 {
00667
00668 }
00669
00670
00671 void MainWindow::createGUI(KParts::Part *part)
00672 {
00673 if ( !part )
00674 setCaption( QString::null );
00675 KMdiMainFrm::createGUI(part);
00676
00677 m_pMainWindowShare->slotGUICreated( part );
00678 }
00679
00680
00681 void MainWindow::loadSettings()
00682 {
00683 ProjectManager::getInstance()->loadSettings();
00684 loadMDISettings();
00685 applyMainWindowSettings(kapp->config(), "Mainwindow");
00686 }
00687
00688
00689 void MainWindow::loadMDISettings()
00690 {
00691 KConfig *config = kapp->config();
00692 config->setGroup("UI");
00693
00694 int mdiMode = config->readNumEntry("MDIMode", KMdi::IDEAlMode);
00695 switch (mdiMode)
00696 {
00697 case KMdi::ToplevelMode:
00698 {
00699 int childFrmModeHt = config->readNumEntry("Childframe mode height", kapp->desktop()->height() - 50);
00700 resize(width(), childFrmModeHt);
00701 switchToToplevelMode();
00702 }
00703 break;
00704
00705 case KMdi::ChildframeMode:
00706 break;
00707
00708 case KMdi::TabPageMode:
00709 {
00710 int childFrmModeHt = config->readNumEntry("Childframe mode height", kapp->desktop()->height() - 50);
00711 resize(width(), childFrmModeHt);
00712 switchToTabPageMode();
00713 }
00714 break;
00715 case KMdi::IDEAlMode:
00716 {
00717 switchToIDEAlMode();
00718 }
00719
00720 default:
00721 break;
00722 }
00723
00724
00725 bool maxChildFrmMode = config->readBoolEntry("maximized childframes", true);
00726 setEnableMaximizedChildFrmMode(maxChildFrmMode);
00727
00728 readDockConfig(0L, "dockSession_version1");
00729 }
00730
00731 void MainWindow::guiRestoringFinished()
00732 {
00733 dockManager->finishReadDockConfig();
00734 }
00735
00736 void MainWindow::prepareToCloseViews()
00737 {
00738 writeDockConfig(0L, "dockSession_version1");
00739 }
00740
00741 void MainWindow::saveSettings()
00742 {
00743 ProjectManager::getInstance()->saveSettings();
00744 saveMainWindowSettings(kapp->config(), "Mainwindow");
00745 saveMDISettings();
00746 }
00747
00748
00749 void MainWindow::saveMDISettings()
00750 {
00751 KConfig *config = kapp->config();
00752 config->setGroup("UI");
00753
00754 config->writeEntry("maximized childframes", isInMaximizedChildFrmMode());
00755 config->writeEntry("MDIStyle", mdiStyle);
00756 config->writeEntry("MDIMode", mdiMode());
00757 }
00758
00759
00760 void MainWindow::resizeEvent(QResizeEvent *ev)
00761 {
00762 KMdiMainFrm::resizeEvent(ev);
00763 setSysButtonsAtMenuPosition();
00764 }
00765
00766 void MainWindow::childWindowCloseRequest(KMdiChildView *pWnd)
00767 {
00768 PartController::getInstance()->closePartForWidget( m_childViewMap[pWnd] );
00769 }
00770
00771 void MainWindow::gotoNextWindow()
00772 {
00773 activateNextWin();
00774 }
00775
00776 void MainWindow::gotoPreviousWindow()
00777 {
00778 activatePrevWin();
00779 }
00780
00781 void MainWindow::gotoFirstWindow()
00782 {
00783 activateFirstWin();
00784 }
00785
00786 void MainWindow::gotoLastWindow()
00787 {
00788 activateLastWin();
00789 }
00790
00791
00792
00793 void MainWindow::fillWindowMenu()
00794 {
00795 bool bTabPageMode = FALSE;
00796 if (m_mdiMode == KMdi::TabPageMode)
00797 bTabPageMode = TRUE;
00798 bool bIDEAlMode = FALSE;
00799 if (m_mdiMode == KMdi::IDEAlMode)
00800 bIDEAlMode = TRUE;
00801
00802 bool bNoViewOpened = FALSE;
00803 if (m_pDocumentViews->isEmpty()) {
00804 bNoViewOpened = TRUE;
00805 }
00806
00807 if (!m_bClearingOfWindowMenuBlocked) {
00808 clearWindowMenu();
00809 }
00810 int closeId = m_pWindowMenu->insertItem(i18n("&Close"), PartController::getInstance(), SLOT(slotCloseWindow()));
00811 m_windowMenus.append(closeId);
00812 int closeAllId = m_pWindowMenu->insertItem(i18n("Close &All"), PartController::getInstance(), SLOT(slotCloseAllWindows()));
00813 m_windowMenus.append(closeAllId);
00814 int closeAllOtherId = m_pWindowMenu->insertItem(i18n("Close All &Others"), PartController::getInstance(), SLOT(slotCloseOtherWindows()));
00815 m_windowMenus.append(closeAllOtherId);
00816 if (bNoViewOpened) {
00817 m_pWindowMenu->setItemEnabled(closeId, FALSE);
00818 m_pWindowMenu->setItemEnabled(closeAllId, FALSE);
00819 m_pWindowMenu->setItemEnabled(closeAllOtherId, FALSE);
00820 }
00821 if (!bTabPageMode && !bIDEAlMode) {
00822 int iconifyId = m_pWindowMenu->insertItem(i18n("&Minimize All"), this, SLOT(iconifyAllViews()));
00823 m_windowMenus.append(iconifyId);
00824 if (bNoViewOpened) {
00825 m_pWindowMenu->setItemEnabled(iconifyId, FALSE);
00826 }
00827 }
00828 m_windowMenus.append(m_pWindowMenu->insertSeparator());
00829 if (!bTabPageMode && !bIDEAlMode) {
00830 int placMenuId = m_pWindowMenu->insertItem(i18n("&Tile..."), m_pPlacingMenu);
00831 m_windowMenus.append(placMenuId);
00832 m_pPlacingMenu->clear();
00833 m_pPlacingMenu->insertItem(i18n("Ca&scade Windows"), m_pMdi,SLOT(cascadeWindows()));
00834 m_pPlacingMenu->insertItem(i18n("Cascade &Maximized"), m_pMdi,SLOT(cascadeMaximized()));
00835 m_pPlacingMenu->insertItem(i18n("Expand &Vertically"), m_pMdi,SLOT(expandVertical()));
00836 m_pPlacingMenu->insertItem(i18n("Expand &Horizontally"), m_pMdi,SLOT(expandHorizontal()));
00837 m_pPlacingMenu->insertItem(i18n("Tile &Non-overlapped"), m_pMdi,SLOT(tileAnodine()));
00838 m_pPlacingMenu->insertItem(i18n("Tile Overla&pped"), m_pMdi,SLOT(tilePragma()));
00839 m_pPlacingMenu->insertItem(i18n("Tile V&ertically"), m_pMdi,SLOT(tileVertically()));
00840 if (m_mdiMode == KMdi::ToplevelMode) {
00841 m_pWindowMenu->setItemEnabled(placMenuId, FALSE);
00842 }
00843 m_windowMenus.append(m_pWindowMenu->insertSeparator());
00844 int dockUndockId = m_pWindowMenu->insertItem(i18n("&Dock/Undock..."), m_pDockMenu);
00845 m_windowMenus.append(dockUndockId);
00846 m_pDockMenu->clear();
00847 m_windowMenus.append(m_pWindowMenu->insertSeparator());
00848 if (bNoViewOpened) {
00849 m_pWindowMenu->setItemEnabled(placMenuId, FALSE);
00850 m_pWindowMenu->setItemEnabled(dockUndockId, FALSE);
00851 }
00852 }
00853 int entryCount = m_pWindowMenu->count();
00854
00855
00856 int i=100;
00857 KMdiChildView* pView = 0L;
00858 QPtrListIterator<KMdiChildView> it(*m_pDocumentViews);
00859 QValueList<QDateTime> timeStamps;
00860 for (; it.current(); ++it) {
00861
00862 pView = it.current();
00863 if (pView->isToolView()) {
00864 continue;
00865 }
00866 QDateTime timeStamp( pView->getTimeStamp() );
00867
00868 KParts::ReadOnlyPart * ro_part = getPartFromWidget(m_childViewMap[pView]);
00869
00870 QString name = (ro_part==0L)?pView->caption():ro_part->url().prettyURL();
00871 QString item;
00872
00873 if (pView->isMinimized()) {
00874 item += "(";
00875 item += name;
00876 item += ")";
00877 }
00878 else {
00879 item += " ";
00880 item += name;
00881 }
00882
00883
00884 unsigned int indx;
00885 unsigned int windowItemCount = m_pWindowMenu->count() - entryCount;
00886
00887 QString tmpString;
00888
00889 QValueList<QDateTime>::iterator timeStampIterator = timeStamps.begin();
00890 for (indx = 0; indx < windowItemCount; indx++, ++timeStampIterator) {
00891 bool putHere = false;
00892 if ((*timeStampIterator) < timeStamp) {
00893 putHere = true;
00894 }
00895 if ( putHere ) {
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907 break;
00908 }
00909 }
00910
00911 timeStamps.insert( timeStampIterator, timeStamp );
00912 m_windowMenus.append(m_pWindowMenu->insertItem( item, pView, SLOT(slot_clickedInWindowMenu()), 0, -1, indx+entryCount));
00913 if (pView == m_pCurrentWindow)
00914 m_pWindowMenu->setItemChecked( m_pWindowMenu->idAt( indx+entryCount), TRUE);
00915 pView->setWindowMenuID( i);
00916 if (!bTabPageMode) {
00917 m_windowMenus.append(m_pDockMenu->insertItem( item, pView, SLOT(slot_clickedInDockMenu()), 0, -1, indx));
00918 if (pView->isAttached())
00919 m_pDockMenu->setItemChecked( m_pDockMenu->idAt( indx), TRUE);
00920 }
00921
00922 i++;
00923 }
00924 }
00925
00927 void MainWindow::fillOutputToolViewsMenu()
00928 {
00929 fillToolViewsMenu(OutputView);
00930 }
00931
00933 void MainWindow::fillTreeToolViewsMenu()
00934 {
00935 fillToolViewsMenu(TreeView);
00936 }
00937
00938
00948 void MainWindow::fillToolViewsMenu(
00949 EView eView)
00950 {
00951
00952 QPtrList<QWidget>* pViews = 0L;
00953 KActionMenu* pActionMenu = 0L;
00954 ViewMenuAction* pAllViewsAction = 0L;
00955
00956 if (eView == OutputView)
00957 {
00958 pViews = &m_outputViews;
00959 pActionMenu = m_pOutputToolViewsMenu;
00960 pAllViewsAction = m_pShowOutputViews;
00961 }
00962 else
00963 {
00964 pViews = &m_selectViews;
00965 pActionMenu = m_pTreeToolViewsMenu;
00966 pAllViewsAction = m_pShowTreeViews;
00967 }
00968
00969 ToolDockBaseState allToolWinState(pViews);
00970
00971
00972 pActionMenu->popupMenu()->clear();
00973 pActionMenu->insert(pAllViewsAction);
00974 pActionMenu->popupMenu()->insertSeparator();
00975
00976
00977 m_myWindowsReady = true;
00978 QPtrListIterator<QWidget> it(*pViews);
00979 for( ; it.current(); ++it)
00980 {
00981 if (m_unavailableViews.find(it.current()) != -1) {
00982 continue;
00983 }
00984 KDockWidget *pDockWidget = manager()->findWidgetParentDock(it.current());
00985 Q_ASSERT(pDockWidget);
00986 QString Name = pDockWidget->tabPageLabel();
00987 ViewMenuActionPrivateData ActionData;
00988 ActionData.pDockWidget = pDockWidget;
00989 ActionData.pChildView = it.current();
00990 ActionData.eView = eView;
00991
00992 ViewMenuAction* action = new ViewMenuAction(ActionData,Name);
00993 connect(action,
00994 SIGNAL(activated(const ViewMenuActionPrivateData &)),
00995 this,
00996 SLOT(toggleSingleToolWin(const ViewMenuActionPrivateData &)));
00997
00998 const ToolWindowState winState(pDockWidget);
00999 action->setChecked(winState.viewMenuChecked);
01000 action->setEnabled(
01001 (allToolWinState.hasDockBaseWindow && !allToolWinState.dockBaseIsHidden)
01002 || (allToolWinState.noViews==0));
01003 pActionMenu->insert(action);
01004 }
01005 }
01006
01008 void MainWindow::updateActionState()
01009 {
01010 if (!m_bUiModeSwitchPending && !m_bRemoveViewPending) {
01011 ToolDockBaseState outputToolState(&m_outputViews);
01012 ToolDockBaseState treeToolState (&m_selectViews);
01013
01014 m_pShowOutputViews->setChecked(outputToolState.dockBaseIsVisible);
01015 m_pShowTreeViews ->setChecked(treeToolState.dockBaseIsVisible);
01016 }
01017 }
01018
01020 void MainWindow::toggleToolDockBaseState(const ViewMenuActionPrivateData &ActionData)
01021 {
01022 m_myWindowsReady = true;
01023
01024 QPtrList<QWidget> *pViews = 0L;
01025 pViews = (ActionData.eView == OutputView)?&m_outputViews:&m_selectViews;
01026
01027 QPtrListIterator<QWidget> it(*pViews);
01028 const ToolDockBaseState allWinState(pViews);
01029
01030 if(allWinState.dockBaseIsVisible) {
01031 allWinState.pDockBaseWindow->undock();
01032 }
01033 else if (allWinState.dockBaseMayBeDockBack){
01034 allWinState.pDockBaseWindow->dockBack();
01035 }
01036 else if(allWinState.dockBaseIsHidden) {
01037 allWinState.pDockBaseWindow->show();
01038 }
01039 else
01040 {
01041
01042 showAllToolWin(ActionData.eView,1);
01043 }
01044
01045 }
01046
01048 void MainWindow::showAllToolWin(EView eView, bool show )
01049 {
01050
01051 QPtrList<QWidget> *pViews = 0L;
01052
01053 pViews =(eView==OutputView)?&m_outputViews:&m_selectViews;
01054
01055
01056 const ToolDockBaseState allWinState(pViews);
01057 if(allWinState.dockBaseIsHidden)
01058 {
01059 ViewMenuActionPrivateData ActionData;
01060 ActionData.eView = eView;
01061 ActionData.pChildView = 0;
01062 ActionData.pDockWidget = 0;
01063 toggleToolDockBaseState(ActionData);
01064 }
01065
01066
01067 m_myWindowsReady = true;
01068 QPtrListIterator<QWidget> it(*pViews);
01069 for( ; it.current(); ++it)
01070 {
01071 if (m_unavailableViews.find(it.current()) != -1) {
01072 continue;
01073 }
01074 KDockWidget *pDockWidget=manager()->findWidgetParentDock(it.current());
01075 Q_ASSERT(pDockWidget);
01076 QString Name = pDockWidget->name();
01077 ViewMenuActionPrivateData ActionData;
01078 ActionData.pDockWidget = pDockWidget;
01079 ActionData.pChildView = it.current();
01080 ActionData.eView = eView;
01081 const ToolWindowState winState(pDockWidget);
01082 if(winState.viewMenuChecked != show)
01083 toggleSingleToolWin(ActionData);
01084 }
01085
01086 }
01087
01089 void MainWindow::toggleSingleToolWin(const ViewMenuActionPrivateData &ActionData)
01090 {
01091
01092 const ToolWindowState winState(ActionData.pDockWidget);
01093 QPtrList<QWidget> *pViews = 0L;
01094 pViews = (ActionData.eView == OutputView)?&m_outputViews:&m_selectViews;
01095
01096 const ToolDockBaseState allWinState(pViews);
01097 if(winState.hasTabGroup)
01098 {
01099 if (winState.mayBeShown)
01100 {
01101 QWidget *pActiveWidget=winState.pTabGroup->currentPage();
01102 ActionData.pDockWidget->changeHideShowState();
01103 ActionData.pDockWidget->changeHideShowState();
01104 if (allWinState.noViews > 2)
01105 {
01106 winState.pTabGroup->showPage(pActiveWidget);
01107 }
01108 }
01109 else
01110 {
01111 ActionData.pDockWidget->changeHideShowState();
01112 }
01113 }
01114 else
01115 {
01116 if (winState.hasDockWidget)
01117 {
01118 if(winState.mayBeHide)
01119 {
01120 ActionData.pDockWidget->changeHideShowState();
01121 }
01122 else
01123 {
01124
01125 KDockWidget *first =0L;
01126 QPtrListIterator<QWidget> it((ActionData.eView==OutputView)?m_outputViews:m_selectViews);
01127 for( ; it.current(); ++it)
01128 {
01129 KDockWidget *pDockWidget=manager()->findWidgetParentDock(it.current());
01130 if(pDockWidget)
01131 {
01132 KDockTabGroup *pTabGroup = pDockWidget->parentDockTabGroup();
01133 if (pDockWidget->mayBeHide() || pTabGroup)
01134 {
01135 first = manager()->findWidgetParentDock(it.current());
01136 break;
01137 }
01138 }
01139 }
01140 if (!first)
01141 {
01142 if (mdiMode() == KMdi::TabPageMode)
01143 {
01144 first = manager()->findWidgetParentDock (m_partViews.first());
01145 }
01146 if (!first) first = m_pDockbaseAreaOfDocumentViews;
01147 if (ActionData.eView == OutputView) ActionData.pDockWidget->manualDock(first,KDockWidget::DockBottom, 70);
01148 else ActionData.pDockWidget->manualDock(first,KDockWidget::DockLeft , 25);
01149 }
01150 else
01151 {
01152 ActionData.pDockWidget->manualDock(first,KDockWidget::DockCenter, 25);
01153 }
01154 }
01155 }
01156 else
01157 {
01158 Q_ASSERT(0);
01159 #if 0
01160 addToolViewWindow(ActionData.eView, ActionData.pChildView, ActionData.pChildView->name(), ActionData.pChildView->name());
01161 #endif
01162 }
01163 }
01164 }
01165
01166
01167
01168 KParts::ReadOnlyPart * MainWindow::getPartFromWidget(const QWidget * pWidget) const
01169 {
01170
01171 QPtrListIterator<KParts::Part> it(*(PartController::getInstance()->parts()));
01172 for ( ; it.current(); ++it)
01173 {
01174 KParts::ReadOnlyPart *ro_part = dynamic_cast<KParts::ReadOnlyPart*>(it.current());
01175 if (ro_part->widget() == pWidget) return ro_part;
01176 }
01177 return (0L);
01178 }
01179
01180 void MainWindow::switchToToplevelMode()
01181 {
01182 if (m_mdiMode == KMdi::ToplevelMode) return;
01183 m_bUiModeSwitchPending = true;
01184
01185 m_toggleViewbar->setEnabled(true);
01186 if (mdiMode() == KMdi::TabPageMode || mdiMode() == KMdi::IDEAlMode) {
01187 slotToggleViewbar();
01188 }
01189 KMdiMainFrm::switchToToplevelMode();
01190
01191 m_bUiModeSwitchPending = false;
01192 updateActionState();
01193 saveMDISettings();
01194 }
01195
01196 void MainWindow::switchToChildframeMode()
01197 {
01198 if (m_mdiMode == KMdi::ChildframeMode) return;
01199 m_bUiModeSwitchPending = true;
01200
01201 m_toggleViewbar->setEnabled(true);
01202 if (mdiMode() == KMdi::TabPageMode || mdiMode() == KMdi::IDEAlMode) {
01203 slotToggleViewbar();
01204 }
01205 KMdiMainFrm::switchToChildframeMode();
01206
01207 m_bUiModeSwitchPending = false;
01208 updateActionState();
01209 saveMDISettings();
01210 }
01211
01212 void MainWindow::switchToTabPageMode()
01213 {
01214 if (m_mdiMode == KMdi::TabPageMode) return;
01215 m_bUiModeSwitchPending = true;
01216
01217 if (isViewTaskBarOn()) {
01218 slotToggleViewbar();
01219 }
01220 m_toggleViewbar->setEnabled(false);
01221 KMdiMainFrm::switchToTabPageMode();
01222
01223 m_bUiModeSwitchPending = false;
01224 updateActionState();
01225 saveMDISettings();
01226 }
01227
01228 void MainWindow::switchToIDEAlMode()
01229 {
01230 if (m_mdiMode == KMdi::IDEAlMode) return;
01231 m_bUiModeSwitchPending = true;
01232
01233 if (isViewTaskBarOn()) {
01234 slotToggleViewbar();
01235 }
01236 m_toggleViewbar->setEnabled(false);
01237 KMdiMainFrm::switchToIDEAlMode();
01238
01239 m_bUiModeSwitchPending = false;
01240 updateActionState();
01241 saveMDISettings();
01242 }
01243
01244 void MainWindow::slotReactToProjectOpened()
01245 {
01246
01247
01248
01249 QPtrListIterator<QWidget> it(m_unavailableViews);
01250 for (; it.current(); ++it) {
01251 KDockWidget* pWrappingDockWidget = dockManager->findWidgetParentDock(*it);
01252 if (pWrappingDockWidget) {
01253 pWrappingDockWidget->hide();
01254 pWrappingDockWidget->undock();
01255 }
01256 }
01257 }
01258
01259 void MainWindow::slotRestoreAdditionalViewProperties(const QString& viewName, const QDomElement* viewEl)
01260 {
01261 KMdiChildView* pMDICover = m_captionDict[viewName];
01262 if (!pMDICover) { return; }
01263
01264
01265 int nMinMaxMode = viewEl->attribute( "MinMaxMode", "0").toInt();
01266 int nLeft = viewEl->attribute( "Left", "-10000").toInt();
01267 int nTop = viewEl->attribute( "Top", "-10000").toInt();
01268 int nWidth = viewEl->attribute( "Width", "-1").toInt();
01269 int nHeight = viewEl->attribute( "Height", "-1").toInt();
01270
01271
01272 bool bAttached = (bool) viewEl->attribute( "Attach", "1").toInt();
01273
01274
01275 if ((mdiMode() != KMdi::TabPageMode) && (mdiMode() != KMdi::ToplevelMode) && (mdiMode() != KMdi::IDEAlMode)) {
01276 if ((!pMDICover->isAttached()) && (bAttached) ) {
01277 pMDICover->attach();
01278 }
01279 if ( (pMDICover->isAttached()) && (!bAttached) ) {
01280 pMDICover->detach();
01281 }
01282 }
01283 if (nMinMaxMode == 0) {
01284 pMDICover->setInternalGeometry(QRect(nLeft, nTop, nWidth, nHeight));
01285 }
01286 else {
01287 if (nMinMaxMode == 1) {
01288 pMDICover->minimize();
01289 }
01290 if (nMinMaxMode == 2) {
01291
01292 }
01293 pMDICover->setRestoreGeometry(QRect(nLeft, nTop, nWidth, nHeight));
01294 }
01295 }
01296
01297 void MainWindow::slotSaveAdditionalViewProperties(const QString& viewName, QDomElement* viewEl)
01298 {
01299 KMdiChildView* pMDICover = m_captionDict[viewName];
01300 if (!pMDICover) { return; }
01301
01302
01303 QRect geom;
01304 int nMinMaxMode = 0;
01305 if (pMDICover->isMinimized()) {
01306 nMinMaxMode = 1;
01307 }
01308 if (pMDICover->isMaximized()) {
01309 nMinMaxMode = 2;
01310 }
01311 if (nMinMaxMode == 0) {
01312 geom = pMDICover->internalGeometry();
01313 }
01314 else {
01315 geom = pMDICover->restoreGeometry();
01316 }
01317 viewEl->setAttribute( "MinMaxMode", nMinMaxMode);
01318 viewEl->setAttribute( "Left", geom.left());
01319 viewEl->setAttribute( "Top", geom.top());
01320 viewEl->setAttribute( "Width", geom.width());
01321 viewEl->setAttribute( "Height", geom.height());
01322
01323
01324 viewEl->setAttribute( "Attach", pMDICover->isAttached() || (mdiMode() == KMdi::TabPageMode) || (mdiMode() == KMdi::IDEAlMode));
01325 }
01326
01327 void MainWindow::slotToggleViewbar()
01328 {
01329 slot_toggleTaskBar();
01330 }
01331
01332 void MainWindow::setUserInterfaceMode(const QString& uiMode)
01333 {
01334
01335 if (uiMode == "Childframe") {
01336 switchToChildframeMode();
01337 }
01338 else if (uiMode == "TabPage") {
01339 switchToTabPageMode();
01340 }
01341 else if (uiMode == "Toplevel") {
01342 switchToToplevelMode();
01343 }
01344 else if (uiMode == "KMDI-IDEAl") {
01345 switchToIDEAlMode();
01346 }
01347 }
01348
01349 void MainWindow::callCommand(const QString& command)
01350 {
01351 if (isInMaximizedChildFrmMode() && (command == "qextmdi-UI: do hack on session loading finished")
01352 && (mdiMode() == KMdi::ChildframeMode)) {
01353 KMdiChildView* pLastView = 0L;
01354 KMdiChildFrm* pLastFrm = 0L;
01355 KMdiIterator<KMdiChildView*>* winListIter = createIterator();
01356 for (winListIter->first(); !winListIter->isDone(); winListIter->next()){
01357 pLastView = winListIter->currentItem();
01358 if (pLastView->isAttached()) {
01359 pLastFrm = pLastView->mdiParent();
01360 }
01361 }
01362
01363 if (pLastFrm && pLastFrm->parentWidget()) {
01364 QApplication::sendPostedEvents();
01365 pLastFrm->setGeometry(
01366 -KMDI_CHILDFRM_BORDER,
01367 -KMDI_CHILDFRM_BORDER - pLastFrm->captionHeight() - KMDI_CHILDFRM_SEPARATOR,
01368 pLastFrm->parentWidget()->width() + KMDI_CHILDFRM_DOUBLE_BORDER,
01369 pLastFrm->parentWidget()->height() + KMDI_CHILDFRM_SEPARATOR
01370 + KMDI_CHILDFRM_DOUBLE_BORDER + pLastFrm->captionHeight());
01371 }
01372 delete winListIter;
01373 }
01374 }
01375
01379 void MainWindow::storeOutputViewTab()
01380 {
01393 }
01394
01395
01399 void MainWindow::restoreOutputViewTab()
01400 {
01415 }
01416
01417 void MainWindow::clearWindowMenu( )
01418 {
01419 for (QValueList<int>::iterator it = m_windowMenus.begin(); it != m_windowMenus.end(); ++it)
01420 {
01421 m_pWindowMenu->removeItem(*it);
01422 }
01423 }
01424
01425 void MainWindow::setWindowMenu(QPopupMenu *menu)
01426 {
01427 if (m_pWindowMenu)
01428 delete m_pWindowMenu;
01429 m_pWindowMenu = menu;
01430 m_pWindowMenu->setCheckable( TRUE);
01431 QObject::connect( m_pWindowMenu, SIGNAL(aboutToShow()), this, SLOT(fillWindowMenu()) );
01432 }
01433
01434 void MainWindow::setCaption( const QString & caption )
01435 {
01436 KDevProject * project = API::getInstance()->project();
01437 if ( project && !caption.isEmpty() )
01438 {
01439 QString projectname = project->projectName();
01440
01441 QString suffix(".kdevelop");
01442 if ( projectname.endsWith( suffix ) )
01443 {
01444 projectname.truncate( projectname.length() - suffix.length() );
01445 }
01446
01447 KMdiMainFrm::setCaption( projectname + " - " + caption );
01448 }
01449 else
01450 {
01451 KMdiMainFrm::setCaption( caption );
01452 }
01453 }
01454
01455 void MainWindow::raiseEditor( )
01456 {
01457 kdDebug() << k_funcinfo << endl;
01458
01459 KDevPartController * partcontroller = API::getInstance()->partController();
01460 if ( partcontroller->activePart() && partcontroller->activePart()->widget() )
01461 {
01462 partcontroller->activePart()->widget()->setFocus();
01463 }
01464 }
01465
01466 #include "mainwindow.moc"