kmdi Library API Documentation

kmdimainfrm.cpp

00001 //---------------------------------------------------------------------------- 00002 // filename : kmdimainfrm.cpp 00003 //---------------------------------------------------------------------------- 00004 // Project : KDE MDI extension 00005 // 00006 // begin : 07/1999 by Szymon Stefanek as part of kvirc 00007 // (an IRC application) 00008 // changes : 09/1999 by Falk Brettschneider to create an 00009 // - 06/2000 stand-alone Qt extension set of 00010 // classes and a Qt-based library 00011 // 2000-2003 maintained by the KDevelop project 00012 // patches : 02/2000 by Massimo Morin (mmorin@schedsys.com) 00013 // */2000 by Lars Beikirch (Lars.Beikirch@gmx.net) 00014 // 01/2003 by Jens Zurheide (jens.zurheide@gmx.de) 00015 // 00016 // copyright : (C) 1999-2003 by Szymon Stefanek (stefanek@tin.it) 00017 // and 00018 // Falk Brettschneider 00019 // email : falkbr@kdevelop.org (Falk Brettschneider) 00020 //---------------------------------------------------------------------------- 00021 // 00022 //---------------------------------------------------------------------------- 00023 // 00024 // This program is free software; you can redistribute it and/or modify 00025 // it under the terms of the GNU Library General Public License as 00026 // published by the Free Software Foundation; either version 2 of the 00027 // License, or (at your option) any later version. 00028 // 00029 //---------------------------------------------------------------------------- 00030 00031 00032 /* 00033 * ATTENTION: please do you part to try to make this file legible. It's 00034 * extremely hard to read already. Especially follow the indenting rules. 00035 */ 00036 #include "config.h" 00037 00038 #include <assert.h> 00039 00040 #include <qcursor.h> 00041 #include <qclipboard.h> 00042 #include <qobjectlist.h> 00043 #include <qpopupmenu.h> 00044 #include <qmenubar.h> 00045 00046 #include <kmenubar.h> 00047 #include <kapplication.h> 00048 #include <kdebug.h> 00049 #include <kdeversion.h> 00050 #include <qtabwidget.h> 00051 #include <klocale.h> 00052 #if defined Q_WS_X11 && ! defined K_WS_QTONLY 00053 #include <kipc.h> // schroder remove this in x11 too, not needed any more... 00054 #endif 00055 00056 #include <kiconloader.h> 00057 #include "kmdidockcontainer.h" 00058 00059 00060 #include <qtoolbutton.h> 00061 #include <qlayout.h> 00062 #include <qtimer.h> 00063 #include <qtextstream.h> 00064 #include <qstring.h> 00065 #include <qmap.h> 00066 #include <qvaluelist.h> 00067 00068 #include "kmdimainfrm.h" 00069 #include "kmditaskbar.h" 00070 #include "kmdichildfrm.h" 00071 #include "kmdichildarea.h" 00072 #include "kmdichildview.h" 00073 #include "kmdidockcontainer.h" 00074 #include "kmditoolviewaccessor_p.h" 00075 #include "kmdifocuslist.h" 00076 #include "kmdidocumentviewtabwidget.h" 00077 #include "kmdiguiclient.h" 00078 00079 #include "win_undockbutton.xpm" 00080 #include "win_minbutton.xpm" 00081 #include "win_restorebutton.xpm" 00082 #include "win_closebutton.xpm" 00083 #include "kde_undockbutton.xpm" 00084 #include "kde_minbutton.xpm" 00085 #include "kde_restorebutton.xpm" 00086 #include "kde_closebutton.xpm" 00087 #include "kde2_undockbutton.xpm" 00088 #include "kde2_minbutton.xpm" 00089 #include "kde2_restorebutton.xpm" 00090 #include "kde2_closebutton.xpm" 00091 #include "kde2laptop_undockbutton.xpm" 00092 #include "kde2laptop_minbutton.xpm" 00093 #include "kde2laptop_restorebutton.xpm" 00094 #include "kde2laptop_closebutton.xpm" 00095 #include "kde2laptop_closebutton_menu.xpm" 00096 00097 #if defined Q_WS_X11 && ! defined K_WS_QTONLY 00098 #ifndef NO_KDE 00099 #include <X11/X.h> // schroder 00100 #include <X11/Xlib.h> // schroder 00101 #endif 00102 00103 #ifdef KeyRelease 00104 /* I hate the defines in the X11 header files. Get rid of one of them */ 00105 #undef KeyRelease 00106 #endif 00107 00108 #ifdef KeyPress 00109 /* I hate the defines in the X11 header files. Get rid of one of them */ 00110 #undef KeyPress 00111 #endif 00112 #endif // Q_WS_X11 && ! K_WS_QTONLY 00113 00114 using namespace KParts; 00115 00116 KMdi::FrameDecor KMdiMainFrm::m_frameDecoration = KMdi::KDELook; 00117 00118 //KMdi::MdiMode KMdiMainFrm::m_mdiMode = KMdi::ChildframeMode; 00119 00120 class KMdiMainFrmPrivate { 00121 public: 00122 KMdiMainFrmPrivate(): focusList(0) { 00123 for (int i=0;i<4;i++) { 00124 activeDockPriority[i]=0; 00125 m_styleIDEAlMode = 0; 00126 m_toolviewStyle = 0; 00127 } 00128 } 00129 ~KMdiMainFrmPrivate() {} 00130 KMdiDockContainer* activeDockPriority[4]; 00131 KMdiFocusList *focusList; 00132 int m_styleIDEAlMode; 00133 int m_toolviewStyle; 00134 }; 00135 00136 //============ constructor ============// 00137 KMdiMainFrm::KMdiMainFrm(QWidget* parentWidget, const char* name, KMdi::MdiMode mdiMode,WFlags flags) 00138 : KParts::DockMainWindow( parentWidget, name, flags) 00139 ,m_mdiMode(KMdi::UndefinedMode) 00140 ,m_pMdi(0L) 00141 ,m_pTaskBar(0L) 00142 ,m_pDocumentViews(0L) 00143 ,m_pCurrentWindow(0L) 00144 ,m_pWindowPopup(0L) 00145 ,m_pTaskBarPopup(0L) 00146 ,m_pWindowMenu(0L) 00147 ,m_pDockMenu(0L) 00148 ,m_pMdiModeMenu(0L) 00149 ,m_pPlacingMenu(0L) 00150 ,m_pMainMenuBar(0L) 00151 ,m_pUndockButtonPixmap(0L) 00152 ,m_pMinButtonPixmap(0L) 00153 ,m_pRestoreButtonPixmap(0L) 00154 ,m_pCloseButtonPixmap(0L) 00155 ,m_pUndock(0L) 00156 ,m_pMinimize(0L) 00157 ,m_pRestore(0L) 00158 ,m_pClose(0L) 00159 ,m_bMaximizedChildFrmMode(false) 00160 ,m_oldMainFrmHeight(0) 00161 ,m_oldMainFrmMinHeight(0) 00162 ,m_oldMainFrmMaxHeight(0) 00163 ,m_bSDIApplication(false) 00164 ,m_pDockbaseAreaOfDocumentViews(0L) 00165 ,m_pTempDockSession(0L) 00166 ,m_bClearingOfWindowMenuBlocked(false) 00167 ,m_pDragEndTimer(0L) 00168 ,m_bSwitching(false) 00169 ,m_leftContainer(0) 00170 ,m_rightContainer(0) 00171 ,m_topContainer(0) 00172 ,m_bottomContainer(0) 00173 ,d(new KMdiMainFrmPrivate()) 00174 ,m_mdiGUIClient(0) 00175 ,m_managedDockPositionMode(false) 00176 ,m_documentTabWidget(0) 00177 { 00178 kdDebug()<<"=== KMdiMainFrm() ==="<<endl; 00179 // Create the local lists of windows 00180 m_pDocumentViews = new QPtrList<KMdiChildView>; 00181 m_pDocumentViews->setAutoDelete(false); 00182 m_pToolViews = new QMap<QWidget*,KMdiToolViewAccessor*>; 00183 00184 // This seems to be needed (re-check it after Qt2.0 comed out) 00185 setFocusPolicy(ClickFocus); 00186 00187 // create the central widget 00188 createMdiManager(); 00189 00190 // cover KMdi's childarea by a dockwidget 00191 m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", QPixmap(), 0L, "mdi_area_cover"); 00192 m_pDockbaseAreaOfDocumentViews->setDockWindowTransient(this,true); 00193 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockNone); 00194 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockCorner); 00195 m_pDockbaseAreaOfDocumentViews->setWidget(m_pMdi); 00196 // set this dock to main view 00197 setView(m_pDockbaseAreaOfDocumentViews); 00198 setMainDockWidget(m_pDockbaseAreaOfDocumentViews); 00199 00200 // Apply options for the MDI manager 00201 applyOptions(); 00202 00203 m_pTaskBarPopup=new QPopupMenu( this, "taskbar_popup_menu"); 00204 m_pWindowPopup=new QPopupMenu( this, "window_popup_menu"); 00205 00206 m_pWindowMenu = new QPopupMenu( this, "window_menu"); 00207 m_pWindowMenu->setCheckable( true); 00208 QObject::connect( m_pWindowMenu, SIGNAL(aboutToShow()), this, SLOT(fillWindowMenu()) ); 00209 00210 m_pDockMenu = new QPopupMenu( this, "dock_menu"); 00211 m_pDockMenu->setCheckable( true); 00212 00213 m_pMdiModeMenu = new QPopupMenu( this, "mdimode_menu"); 00214 m_pMdiModeMenu->setCheckable( true); 00215 00216 m_pPlacingMenu = new QPopupMenu( this, "placing_menu"); 00217 00218 // the MDI view taskbar 00219 createTaskBar(); 00220 00221 // this is only a hack, but prevents us from crash because the buttons are otherwise 00222 // not created before we switch the modes where we need them !!! 00223 setMenuForSDIModeSysButtons(menuBar()); 00224 00225 switch (mdiMode) { 00226 case KMdi::IDEAlMode: 00227 kdDebug(760)<<"switch(mdiMode): IDEAlMode"<<endl; 00228 switchToIDEAlMode(); 00229 break; 00230 case KMdi::TabPageMode: 00231 kdDebug(760)<<"switch(mdiMode): TabPageMode"<<endl; 00232 switchToTabPageMode(); 00233 break; 00234 case KMdi::ToplevelMode: 00235 kdDebug(760)<<"switch(mdiMode): TopLevelMode"<<endl; 00236 switchToToplevelMode(); 00237 break; 00238 default: 00239 m_mdiMode=KMdi::ChildframeMode; 00240 kdDebug(760)<<"switch(mdiMode): default"<<endl; 00241 break; 00242 } 00243 00244 // drag end timer 00245 m_pDragEndTimer = new QTimer(); 00246 connect(m_pDragEndTimer, SIGNAL(timeout()), this, SLOT(dragEndTimeOut())); 00247 } 00248 00249 void KMdiMainFrm::setStandardMDIMenuEnabled(bool showModeMenu) { 00250 m_mdiGUIClient=new KMDIPrivate::KMDIGUIClient(this,showModeMenu); 00251 connect(m_mdiGUIClient,SIGNAL(toggleTop()),this,SIGNAL(toggleTop())); 00252 connect(m_mdiGUIClient,SIGNAL(toggleLeft()),this,SIGNAL(toggleLeft())); 00253 connect(m_mdiGUIClient,SIGNAL(toggleRight()),this,SIGNAL(toggleRight())); 00254 connect(m_mdiGUIClient,SIGNAL(toggleBottom()),this,SIGNAL(toggleBottom())); 00255 00256 if (m_mdiMode==KMdi::IDEAlMode) { 00257 if (m_topContainer) 00258 connect(this,SIGNAL(toggleTop()),m_topContainer->getWidget(),SLOT(toggle())); 00259 if (m_leftContainer) 00260 connect(this,SIGNAL(toggleLeft()),m_leftContainer->getWidget(),SLOT(toggle())); 00261 if (m_rightContainer) 00262 connect(this,SIGNAL(toggleRight()),m_rightContainer->getWidget(),SLOT(toggle())); 00263 if (m_bottomContainer) 00264 connect(this,SIGNAL(toggleBottom()),m_bottomContainer->getWidget(),SLOT(toggle())); 00265 } 00266 00267 emit mdiModeHasBeenChangedTo(m_mdiMode); 00268 } 00269 00270 //============ ~KMdiMainFrm ============// 00271 KMdiMainFrm::~KMdiMainFrm() 00272 { 00273 //save the children first to a list, as removing invalidates our iterator 00274 QValueList<KMdiChildView *> children; 00275 for(KMdiChildView *w = m_pDocumentViews->first();w;w= m_pDocumentViews->next()){ 00276 children.append(w); 00277 } 00278 // safely close the windows so properties are saved... 00279 QValueListIterator<KMdiChildView *> childIt; 00280 for (childIt = children.begin(); childIt != children.end(); ++childIt) 00281 { 00282 closeWindow(*childIt, false); // without re-layout taskbar! 00283 } 00284 00285 emit lastChildViewClosed(); 00286 delete m_pDocumentViews; 00287 delete m_pToolViews; 00288 m_pToolViews=0; 00289 delete m_pDragEndTimer; 00290 00291 delete m_pUndockButtonPixmap; 00292 delete m_pMinButtonPixmap; 00293 delete m_pRestoreButtonPixmap; 00294 delete m_pCloseButtonPixmap; 00295 00296 //deletes added for Release-Version-Pop-Up-WinMenu-And-Go-Out-Problem 00297 delete m_pDockMenu; 00298 delete m_pMdiModeMenu; 00299 delete m_pPlacingMenu; 00300 delete m_pTaskBarPopup; 00301 delete m_pWindowPopup; 00302 delete m_pWindowMenu; 00303 delete m_mdiGUIClient; 00304 m_mdiGUIClient=0; 00305 delete d; 00306 d=0; 00307 } 00308 00309 //============ applyOptions ============// 00310 #ifdef __GNUC__ 00311 #warning fixme 00312 #endif 00313 void KMdiMainFrm::applyOptions() 00314 { 00315 for(KMdiChildView *w = m_pDocumentViews->first();w;w= m_pDocumentViews->next()){ 00316 QWidget *wdgt = w; 00317 if(w->mdiParent())wdgt =w->mdiParent(); 00318 // Really ugly hack to FORCE the resize event 00319 // a resize(width(),height()) won't work... 00320 wdgt->resize(wdgt->width()+1,wdgt->height()+1); 00321 wdgt->resize(wdgt->width()-1,wdgt->height()-1); 00322 } 00323 } 00324 00325 //============ createMdiManager ============// 00326 void KMdiMainFrm::createMdiManager() 00327 { 00328 m_pMdi=new KMdiChildArea(this); 00329 setCentralWidget(m_pMdi); 00330 QObject::connect( m_pMdi, SIGNAL(nowMaximized(bool)), this, SLOT(setEnableMaximizedChildFrmMode(bool)) ); 00331 QObject::connect( m_pMdi, SIGNAL(noMaximizedChildFrmLeft(KMdiChildFrm*)), this, SLOT(switchOffMaximizeModeForMenu(KMdiChildFrm*)) ); 00332 QObject::connect( m_pMdi, SIGNAL(sysButtonConnectionsMustChange(KMdiChildFrm*,KMdiChildFrm*)), this, SLOT(updateSysButtonConnections(KMdiChildFrm*,KMdiChildFrm*)) ); 00333 QObject::connect( m_pMdi, SIGNAL(popupWindowMenu(QPoint)), this, SLOT(popupWindowMenu(QPoint)) ); 00334 QObject::connect( m_pMdi, SIGNAL(lastChildFrmClosed()), this, SIGNAL(lastChildFrmClosed()) ); 00335 } 00336 00337 //============ createTaskBar ==============// 00338 void KMdiMainFrm::createTaskBar() 00339 { 00340 m_pTaskBar = new KMdiTaskBar(this,QMainWindow::DockBottom); 00341 m_pTaskBar->installEventFilter( this); 00342 } 00343 00344 void KMdiMainFrm::slot_toggleTaskBar() 00345 { 00346 if (!m_pTaskBar) 00347 return; 00348 m_pTaskBar->switchOn( !m_pTaskBar->isSwitchedOn()); 00349 } 00350 00351 void KMdiMainFrm::resizeEvent(QResizeEvent *e) 00352 { 00353 if( (m_mdiMode == KMdi::ToplevelMode) && !parentWidget()) 00354 if( e->oldSize().height() != e->size().height()) { 00355 return; 00356 } 00357 KParts::DockMainWindow::resizeEvent(e); 00358 if (!m_mdiGUIClient) return; 00359 setSysButtonsAtMenuPosition(); 00360 } 00361 00362 //================ setMinimumSize ===============// 00363 00364 void KMdiMainFrm::setMinimumSize( int minw, int minh) 00365 { 00366 if( (m_mdiMode == KMdi::ToplevelMode) && !parentWidget()) 00367 return; 00368 DockMainWindow::setMinimumSize( minw, minh); 00369 } 00370 00371 //================ wrapper ===============// 00372 00373 KMdiChildView* KMdiMainFrm::createWrapper(QWidget *view, const QString& name, const QString& shortName) 00374 { 00375 Q_ASSERT( view ); // if this assert fails, then some part didn't return a widget. Fix the part ;) 00376 00377 KMdiChildView* pMDICover = new KMdiChildView(name, // caption 00378 0L, // parent 00379 name.latin1()); // object name, necessary later in the dockwidgets 00380 QBoxLayout* pLayout = new QHBoxLayout( pMDICover, 0, -1, "layout"); 00381 view->reparent(pMDICover, QPoint(0,0)); 00382 pLayout->addWidget(view); 00383 // pMDICover->setName(name); 00384 pMDICover->setTabCaption(shortName); 00385 pMDICover->setCaption(name); 00386 00387 const QPixmap* wndIcon = view->icon(); 00388 if (wndIcon) { 00389 pMDICover->setIcon(*wndIcon); 00390 } 00391 pMDICover->trackIconAndCaptionChanges(view); 00392 return pMDICover; 00393 } 00394 00395 //================ addWindow ===============// 00396 00397 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, int flags) 00398 { 00399 addWindow(pWnd, flags, -1); 00400 } 00401 00402 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, int flags, int index) 00403 { 00404 if( windowExists( pWnd,AnyView)) { 00405 // is already added to the MDI system 00406 return; 00407 } 00408 00409 if( flags & KMdi::ToolWindow) { 00410 addToolWindow( pWnd); 00411 // some kind of cascading 00412 pWnd->move(m_pMdi->mapToGlobal(m_pMdi->getCascadePoint())); 00413 00414 return; 00415 } 00416 00417 // common connections used when under MDI control 00418 QObject::connect( pWnd, SIGNAL(clickedInWindowMenu(int)), this, SLOT(windowMenuItemActivated(int)) ); 00419 QObject::connect( pWnd, SIGNAL(focusInEventOccurs(KMdiChildView*)), this, SLOT(activateView(KMdiChildView*)) ); 00420 QObject::connect( pWnd, SIGNAL(childWindowCloseRequest(KMdiChildView*)), this, SLOT(childWindowCloseRequest(KMdiChildView*)) ); 00421 QObject::connect( pWnd, SIGNAL(attachWindow(KMdiChildView*,bool)), this, SLOT(attachWindow(KMdiChildView*,bool)) ); 00422 QObject::connect( pWnd, SIGNAL(detachWindow(KMdiChildView*,bool)), this, SLOT(detachWindow(KMdiChildView*,bool)) ); 00423 QObject::connect( pWnd, SIGNAL(clickedInDockMenu(int)), this, SLOT(dockMenuItemActivated(int)) ); 00424 connect(pWnd,SIGNAL(activated(KMdiChildView*)),this,SIGNAL(viewActivated(KMdiChildView*))); 00425 connect(pWnd,SIGNAL(deactivated(KMdiChildView*)),this,SIGNAL(viewDeactivated(KMdiChildView*))); 00426 if (index == -1) 00427 m_pDocumentViews->append(pWnd); 00428 else 00429 m_pDocumentViews->insert(index, pWnd); 00430 if (m_pTaskBar) { 00431 KMdiTaskBarButton* but = m_pTaskBar->addWinButton(pWnd); 00432 QObject::connect( pWnd, SIGNAL(tabCaptionChanged(const QString&)), but, SLOT(setNewText(const QString&)) ); 00433 } 00434 00435 // embed the view depending on the current MDI mode 00436 if (m_mdiMode == KMdi::TabPageMode || m_mdiMode == KMdi::IDEAlMode) { 00437 // const QPixmap& wndIcon = pWnd->icon() ? *(pWnd->icon()) : QPixmap(); 00438 00439 m_documentTabWidget->insertTab(pWnd, pWnd->icon() ? *(pWnd->icon()) : QPixmap(),pWnd->tabCaption(), index); 00440 00441 /* 00442 connect(pWnd,SIGNAL(iconOrCaptionUdpated(QWidget*,QPixmap,const QString&)), 00443 m_documentTabWidget,SLOT(updateView(QWidget*,QPixmap,const QString&))); 00444 */ 00445 connect( pWnd, SIGNAL(iconUpdated(QWidget*, QPixmap )), m_documentTabWidget, SLOT(updateIconInView(QWidget*, QPixmap )) ); 00446 connect( pWnd, SIGNAL(captionUpdated(QWidget*, const QString& )), m_documentTabWidget, SLOT(updateCaptionInView(QWidget*, const QString& )) ); 00447 #if 0 00448 KDockWidget* pCover = createDockWidget( pWnd->name(), 00449 wndIcon, 00450 0L, // parent 00451 pWnd->caption(), 00452 pWnd->tabCaption()); 00453 pCover->setWidget( pWnd); 00454 pCover->setToolTipString( pWnd->caption()); 00455 pCover->setDockWindowTransient(this,true); 00456 if (!(flags & KMdi::Detach)) { 00457 m_pDockbaseOfTabPage->setDockSite(KDockWidget::DockFullSite); 00458 pCover->manualDock( m_pDockbaseOfTabPage, KDockWidget::DockCenter); 00459 pCover->setEnableDocking(KDockWidget::DockNone); 00460 if (m_pDockbaseOfTabPage == m_pDockbaseAreaOfDocumentViews) { 00461 m_pDockbaseAreaOfDocumentViews->undock(); 00462 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockNone); 00463 } 00464 else { 00465 m_pDockbaseOfTabPage->setDockSite(KDockWidget::DockCorner); 00466 } 00467 m_pDockbaseOfTabPage = (KDockWidget*) pCover; 00468 } 00469 if (!(flags & KMdi::Hide)) { 00470 pCover->show(); 00471 } 00472 pWnd->setFocus(); 00473 if (m_pDocumentViews->count() == 1) { 00474 m_pClose->show(); // show the close button in case it isn't already 00475 } 00476 #endif 00477 } else { 00478 if( (flags & KMdi::Detach) || (m_mdiMode == KMdi::ToplevelMode)) { 00479 detachWindow( pWnd, !(flags & KMdi::Hide)); 00480 emit childViewIsDetachedNow(pWnd); // fake it because detach won't call it in this case of addWindow-to-MDI 00481 } else { 00482 attachWindow( pWnd, !(flags & KMdi::Hide), flags & KMdi::UseKMdiSizeHint); 00483 } 00484 00485 if ((m_bMaximizedChildFrmMode && !(m_bSDIApplication && (flags & KMdi::Detach)) && (m_mdiMode != KMdi::ToplevelMode)) 00486 || (flags & KMdi::Maximize) ) { 00487 if (!pWnd->isMaximized()) 00488 pWnd->maximize(); 00489 } 00490 if (!m_bSDIApplication || (flags & KMdi::Detach)) { 00491 if (flags & KMdi::Minimize) 00492 { 00493 pWnd->minimize(); 00494 } 00495 if (!(flags & KMdi::Hide)) { 00496 if (pWnd->isAttached()) { 00497 pWnd->mdiParent()->show(); 00498 } else { 00499 pWnd->show(); 00500 } 00501 } 00502 } 00503 } 00504 } 00505 00506 //============ addWindow ============// 00507 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, QRect rectNormal, int flags) 00508 { 00509 addWindow( pWnd, flags); 00510 if (m_bMaximizedChildFrmMode && pWnd->isAttached()) { 00511 pWnd->setRestoreGeometry( rectNormal); 00512 } else { 00513 pWnd->setGeometry( rectNormal); 00514 } 00515 } 00516 00517 //============ addWindow ============// 00518 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, QPoint pos, int flags) 00519 { 00520 addWindow( pWnd, flags); 00521 if (m_bMaximizedChildFrmMode && pWnd->isAttached()) { 00522 pWnd->setRestoreGeometry( QRect(pos, pWnd->restoreGeometry().size())); 00523 } else { 00524 pWnd->move( pos); 00525 } 00526 } 00527 00528 00529 00530 KMdiToolViewAccessor *KMdiMainFrm::createToolWindow() 00531 { 00532 return new KMdiToolViewAccessor(this); 00533 } 00534 00535 00536 void KMdiMainFrm::deleteToolWindow( QWidget* pWnd) { 00537 if (m_pToolViews->contains(pWnd)) { 00538 deleteToolWindow((*m_pToolViews)[pWnd]); 00539 } 00540 } 00541 00542 void KMdiMainFrm::deleteToolWindow( KMdiToolViewAccessor *accessor) { 00543 if (!accessor) return; 00544 delete accessor; 00545 } 00546 00547 //============ addWindow ============// 00548 KMdiToolViewAccessor *KMdiMainFrm::addToolWindow( QWidget* pWnd, KDockWidget::DockPosition pos, QWidget* pTargetWnd, int percent, const QString& tabToolTip, const QString& tabCaption) 00549 { 00550 QWidget *tvta=pWnd; 00551 KDockWidget* pDW = dockManager->getDockWidgetFromName(pWnd->name()); 00552 if (pDW) { 00553 // probably readDockConfig already created the widgetContainer, use that 00554 pDW->setWidget(pWnd); 00555 00556 if (pWnd->icon()) { 00557 pDW->setPixmap(*pWnd->icon()); 00558 } 00559 pDW->setTabPageLabel((tabCaption==0)?pWnd->caption():tabCaption); 00560 pDW->setToolTipString(tabToolTip); 00561 dockManager->removeFromAutoCreateList(pDW); 00562 pWnd=pDW; 00563 } 00564 00565 QRect r=pWnd->geometry(); 00566 00567 KMdiToolViewAccessor *mtva=new KMdiToolViewAccessor(this,pWnd,tabToolTip,(tabCaption==0)?pWnd->caption():tabCaption); 00568 m_pToolViews->insert(tvta,mtva); 00569 00570 if (pos == KDockWidget::DockNone) { 00571 mtva->d->widgetContainer->setEnableDocking(KDockWidget::DockNone); 00572 mtva->d->widgetContainer->reparent(this, Qt::WType_TopLevel | Qt::WType_Dialog, r.topLeft(), true); //pToolView->isVisible()); 00573 } else { // add (and dock) the toolview as DockWidget view 00574 //const QPixmap& wndIcon = pWnd->icon() ? *(pWnd->icon()) : QPixmap(); 00575 00576 //KDockWidget *pCover=mtva->d->widgetContainer; 00577 00578 mtva->place(pos, pTargetWnd,percent); 00579 00580 } 00581 00582 return mtva; 00583 } 00584 00585 //============ attachWindow ============// 00586 void KMdiMainFrm::attachWindow(KMdiChildView *pWnd, bool bShow, bool bAutomaticResize) 00587 { 00588 pWnd->installEventFilter(this); 00589 00590 // decide whether window shall be cascaded 00591 bool bCascade = false; 00592 QApplication::sendPostedEvents(); 00593 QRect frameGeo = pWnd->frameGeometry(); 00594 QPoint topLeftScreen = pWnd->mapToGlobal(QPoint(0,0)); 00595 QPoint topLeftMdiChildArea = m_pMdi->mapFromGlobal(topLeftScreen); 00596 QRect childAreaGeo = m_pMdi->geometry(); 00597 if ( (topLeftMdiChildArea.x() < 0) || (topLeftMdiChildArea.y() < 0) || 00598 (topLeftMdiChildArea.x()+frameGeo.width() > childAreaGeo.width()) || 00599 (topLeftMdiChildArea.y()+frameGeo.height() > childAreaGeo.height()) ) { 00600 bCascade = true; 00601 } 00602 00603 // create frame and insert child view 00604 KMdiChildFrm *lpC=new KMdiChildFrm(m_pMdi); 00605 pWnd->hide(); 00606 if (!bCascade) { 00607 lpC->move(topLeftMdiChildArea); 00608 } 00609 lpC->setClient(pWnd, bAutomaticResize); 00610 lpC->setFocus(); 00611 pWnd->youAreAttached(lpC); 00612 if( (m_mdiMode == KMdi::ToplevelMode) && !parentWidget()) { 00613 setMinimumHeight( m_oldMainFrmMinHeight); 00614 setMaximumHeight( m_oldMainFrmMaxHeight); 00615 resize( width(), m_oldMainFrmHeight); 00616 m_oldMainFrmHeight = 0; 00617 switchToChildframeMode(); 00618 } 00619 00620 m_pMdi->manageChild(lpC,false,bCascade); 00621 if (m_pMdi->topChild() && m_pMdi->topChild()->isMaximized()) { 00622 QRect r = lpC->geometry(); 00623 lpC->setGeometry(-lpC->m_pClient->x(), -lpC->m_pClient->y(), 00624 m_pMdi->width() + KMDI_CHILDFRM_DOUBLE_BORDER, 00625 m_pMdi->height() + lpC->captionHeight() + KMDI_CHILDFRM_SEPARATOR + KMDI_CHILDFRM_DOUBLE_BORDER); 00626 lpC->setRestoreGeometry(r); 00627 } 00628 00629 if (bShow) { 00630 lpC->show(); 00631 } 00632 00633 #undef FocusIn 00634 QFocusEvent fe(QEvent::FocusIn); 00635 QApplication::sendEvent( pWnd, &fe); 00636 00637 m_pCurrentWindow = pWnd; // required for checking the active item 00638 } 00639 00640 //============= detachWindow ==============// 00641 void KMdiMainFrm::detachWindow(KMdiChildView *pWnd, bool bShow) 00642 { 00643 if (pWnd->isAttached()) { 00644 pWnd->removeEventFilter(this); 00645 pWnd->youAreDetached(); 00646 // this is only if it was attached and you want to detach it 00647 if (pWnd->parent()) { 00648 KMdiChildFrm *lpC=pWnd->mdiParent(); 00649 if (lpC) { 00650 if (lpC->icon()) { 00651 QPixmap pixm(*(lpC->icon())); 00652 pWnd->setIcon(pixm); 00653 } 00654 QString capt(lpC->caption()); 00655 if (!bShow) 00656 lpC->hide(); 00657 lpC->unsetClient( m_undockPositioningOffset); 00658 m_pMdi->destroyChildButNotItsView(lpC,false); //Do not focus the new top child , we loose focus... 00659 pWnd->setCaption(capt); 00660 } 00661 } 00662 } 00663 else { 00664 if (pWnd->size().isEmpty() || (pWnd->size() == QSize(1,1))) { 00665 if (m_pCurrentWindow) { 00666 pWnd->setGeometry( QRect( m_pMdi->getCascadePoint(m_pDocumentViews->count()-1), m_pCurrentWindow->size())); 00667 } 00668 else { 00669 pWnd->setGeometry( QRect( m_pMdi->getCascadePoint(m_pDocumentViews->count()-1), defaultChildFrmSize())); 00670 } 00671 } 00672 #if defined Q_WS_X11 && ! defined K_WS_QTONLY 00673 if (mdiMode() == KMdi::ToplevelMode) { 00674 XSetTransientForHint(qt_xdisplay(),pWnd->winId(),topLevelWidget()->winId()); 00675 } 00676 #endif 00677 00678 return; 00679 } 00680 00681 #if defined Q_WS_X11 && ! defined K_WS_QTONLY 00682 if (mdiMode() == KMdi::ToplevelMode) { 00683 XSetTransientForHint(qt_xdisplay(),pWnd->winId(),topLevelWidget()->winId()); 00684 } 00685 #endif 00686 00687 // this will show it... 00688 if (bShow) { 00689 activateView(pWnd); 00690 } 00691 00692 emit childViewIsDetachedNow(pWnd); 00693 } 00694 00695 //============== removeWindowFromMdi ==============// 00696 void KMdiMainFrm::removeWindowFromMdi(KMdiChildView *pWnd) 00697 { 00698 Q_UNUSED(pWnd) 00699 //Closes a child window. sends no close event : simply deletes it 00700 #ifdef __GNUC__ 00701 #warning FIXME FIXME FIXME 00702 #endif 00703 #if 0 00704 if (!(m_pWinList->removeRef(pWnd))) 00705 return; 00706 if (m_pWinList->count() == 0) 00707 m_pCurrentWindow = 0L; 00708 00709 QObject::disconnect( pWnd, SIGNAL(attachWindow(KMdiChildView*,bool)), this, SLOT(attachWindow(KMdiChildView*,bool)) ); 00710 QObject::disconnect( pWnd, SIGNAL(detachWindow(KMdiChildView*,bool)), this, SLOT(detachWindow(KMdiChildView*,bool)) ); 00711 QObject::disconnect( pWnd, SIGNAL(focusInEventOccurs(KMdiChildView*)), this, SLOT(activateView(KMdiChildView*)) ); 00712 QObject::disconnect( pWnd, SIGNAL(childWindowCloseRequest(KMdiChildView*)), this, SLOT(childWindowCloseRequest(KMdiChildView*)) ); 00713 QObject::disconnect( pWnd, SIGNAL(clickedInWindowMenu(int)), this, SLOT(windowMenuItemActivated(int)) ); 00714 QObject::disconnect( pWnd, SIGNAL(clickedInDockMenu(int)), this, SLOT(dockMenuItemActivated(int)) ); 00715 00716 if (m_pTaskBar) { 00717 KMdiTaskBarButton* but = m_pTaskBar->getButton(pWnd); 00718 if (but != 0L) { 00719 QObject::disconnect( pWnd, SIGNAL(tabCaptionChanged(const QString&)), but, SLOT(setNewText(const QString&)) ); 00720 } 00721 m_pTaskBar->removeWinButton(pWnd); 00722 } 00723 00724 if (m_mdiMode == KMdi::TabPageMode) { 00725 if (m_pWinList->count() == 0) { 00726 if (!m_pDockbaseAreaOfDocumentViews) { 00727 m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", QPixmap(), 0L, "mdi_area_cover"); 00728 m_pDockbaseAreaOfDocumentViews->setDockWindowTransient(this,true); 00729 00730 m_pDockbaseAreaOfDocumentViews->setWidget(m_pMdi); 00731 setMainDockWidget(m_pDockbaseAreaOfDocumentViews); 00732 } 00733 m_pDockbaseOfTabPage->setDockSite(KDockWidget::DockFullSite); 00734 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockCenter); 00735 m_pDockbaseAreaOfDocumentViews->manualDock( m_pDockbaseOfTabPage, KDockWidget::DockCenter); 00736 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockNone); 00737 m_pDockbaseOfTabPage = m_pDockbaseAreaOfDocumentViews; 00738 m_pClose->hide(); 00739 } 00740 KDockWidget* pDockW = (KDockWidget*) pWnd->parentWidget(); 00741 pWnd->reparent(0L, QPoint(0,0)); 00742 pDockW->setWidget(0L); 00743 if (pDockW == m_pDockbaseOfTabPage) { 00744 QTabWidget* pTab = (QTabWidget*) pDockW->parentWidget()->parentWidget(); 00745 int cnt = pTab->count(); 00746 m_pDockbaseOfTabPage = (KDockWidget*) pTab->page(cnt - 2); 00747 if (pDockW == m_pDockbaseOfTabPage) { 00748 m_pDockbaseOfTabPage = (KDockWidget*) pTab->page(cnt - 1); // different to the one deleted next 00749 } 00750 } 00751 delete pDockW; 00752 if (m_pWinList->count() == 1) { 00753 m_pWinList->last()->activate(); // all other views are activated by tab switch 00754 } 00755 } 00756 else if (pWnd->isAttached()) { 00757 pWnd->mdiParent()->hide(); 00758 m_pMdi->destroyChildButNotItsView(pWnd->mdiParent()); 00759 } 00760 else { 00761 // is not attached 00762 if (m_pMdi->getVisibleChildCount() > 0) { 00763 setActiveWindow(); 00764 m_pCurrentWindow = 0L; 00765 KMdiChildView* pView = m_pMdi->topChild()->m_pClient; 00766 if (pView) { 00767 pView->activate(); 00768 } 00769 } 00770 else if (m_pWinList->count() > 0) { 00771 //crash? m_pWinList->last()->activate(); 00772 //crash? m_pWinList->last()->setFocus(); 00773 } 00774 } 00775 00776 if (pWnd->isToolView()) 00777 pWnd->m_bToolView = false; 00778 00779 if (!m_pCurrentWindow) 00780 emit lastChildViewClosed(); 00781 #endif 00782 } 00783 00784 //============== closeWindow ==============// 00785 void KMdiMainFrm::closeWindow(KMdiChildView *pWnd, bool layoutTaskBar) 00786 { 00787 if (!pWnd) return; 00788 //Closes a child window. sends no close event : simply deletes it 00789 m_pDocumentViews->removeRef(pWnd); 00790 if (m_pDocumentViews->count() == 0) 00791 m_pCurrentWindow = 0L; 00792 00793 if (m_pTaskBar) { 00794 m_pTaskBar->removeWinButton(pWnd, layoutTaskBar); 00795 } 00796 00797 if ((m_mdiMode == KMdi::TabPageMode) || (m_mdiMode==KMdi::IDEAlMode)) { 00798 if (!m_documentTabWidget) return; //oops 00799 if (m_pDocumentViews->count()==0) m_pClose->hide(); 00800 pWnd->reparent(0L, QPoint(0,0)); 00801 kdDebug() << "-------- 1" << endl; 00802 if (m_pDocumentViews->count() == 1) { 00803 m_pDocumentViews->last()->activate(); // all other views are activated by tab switch 00804 } 00805 } 00806 if ((m_mdiMode == KMdi::TabPageMode) || (m_mdiMode==KMdi::IDEAlMode)) { 00807 if (m_pDocumentViews->count() == 0) { 00808 if (!m_pDockbaseAreaOfDocumentViews) { 00809 m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", QPixmap(), 0L, "mdi_area_cover"); 00810 m_pDockbaseAreaOfDocumentViews->setDockWindowTransient(this,true); 00811 m_pDockbaseAreaOfDocumentViews->setWidget(m_pMdi); 00812 setMainDockWidget(m_pDockbaseAreaOfDocumentViews); 00813 } 00814 #if 0 00815 m_pDockbaseOfTabPage->setDockSite(KDockWidget::DockFullSite); 00816 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockCenter); 00817 m_pDockbaseAreaOfDocumentViews->manualDock( m_pDockbaseOfTabPage, KDockWidget::DockCenter); 00818 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockNone); 00819 m_pDockbaseOfTabPage = m_pDockbaseAreaOfDocumentViews; 00820 #endif 00821 m_pClose->hide(); 00822 } 00823 #if 0 00824 KDockWidget* pDockW = (KDockWidget*) pWnd->parentWidget(); 00825 pWnd->reparent(0L, QPoint(0,0)); 00826 pDockW->setWidget(0L); 00827 if (pDockW == m_pDockbaseOfTabPage) { 00828 QTabWidget* pTab = (QTabWidget*) pDockW->parentWidget()->parentWidget(); 00829 int cnt = pTab->count(); 00830 m_pDockbaseOfTabPage = (KDockWidget*) pTab->page(cnt - 2); 00831 if (pDockW == m_pDockbaseOfTabPage) { 00832 m_pDockbaseOfTabPage = (KDockWidget*) pTab->page(cnt - 1); // different to the one deleted next 00833 } 00834 } 00835 delete pDockW; 00836 #endif 00837 delete pWnd; 00838 if (m_pDocumentViews->count() == 1) { 00839 m_pDocumentViews->last()->activate(); // all other views are activated by tab switch 00840 } 00841 } else if (pWnd->isAttached()) { 00842 m_pMdi->destroyChild(pWnd->mdiParent()); 00843 } else { 00844 delete pWnd; 00845 // is not attached 00846 if (m_pMdi->getVisibleChildCount() > 0) { 00847 setActiveWindow(); 00848 m_pCurrentWindow = 0L; 00849 KMdiChildView* pView = m_pMdi->topChild()->m_pClient; 00850 if (pView) { 00851 pView->activate(); 00852 } 00853 } else if (m_pDocumentViews->count() > 0) { 00854 if (m_pDocumentViews->current()) { 00855 m_pDocumentViews->current()->activate(); 00856 m_pDocumentViews->current()->setFocus(); 00857 } 00858 else { 00859 m_pDocumentViews->last()->activate(); 00860 m_pDocumentViews->last()->setFocus(); 00861 } 00862 } 00863 } 00864 00865 if (!m_pCurrentWindow) 00866 emit lastChildViewClosed(); 00867 } 00868 00869 //================== findWindow =================// 00870 KMdiChildView * KMdiMainFrm::findWindow(const QString& caption) 00871 { 00872 for(KMdiChildView *w=m_pDocumentViews->first();w;w=m_pDocumentViews->next()){ 00873 if(QString(w->caption()) == QString(caption))return w; //F.B. 00874 } 00875 return 0L; 00876 } 00877 00878 //================== activeWindow ===================// 00879 KMdiChildView * KMdiMainFrm::activeWindow() 00880 { 00881 return m_pCurrentWindow; 00882 } 00883 00884 //================== windowExists ? =================// 00885 bool KMdiMainFrm::windowExists(KMdiChildView *pWnd, ExistsAs as) 00886 { 00887 if ((as==ToolView) || (as==AnyView)) { 00888 if (m_pToolViews->contains(pWnd)) return true; 00889 if (as==ToolView) return false; 00890 } 00891 00892 for(KMdiChildView *w=m_pDocumentViews->first();w;w=m_pDocumentViews->next()){ 00893 if (w == pWnd) return true; 00894 } 00895 00896 return false; 00897 } 00898 00899 QPopupMenu * KMdiMainFrm::windowPopup(KMdiChildView * pWnd,bool bIncludeTaskbarPopup) 00900 { 00901 m_pWindowPopup->clear(); 00902 if(bIncludeTaskbarPopup){ 00903 m_pWindowPopup->insertItem(i18n("Window"),taskBarPopup(pWnd,false)); 00904 m_pWindowPopup->insertSeparator(); 00905 } 00906 return m_pWindowPopup; 00907 } 00908 00909 //================ taskBarPopup =================// 00910 QPopupMenu * KMdiMainFrm::taskBarPopup(KMdiChildView *pWnd,bool /*bIncludeWindowPopup*/) 00911 { 00912 //returns the g_pTaskBarPopup filled according to the KMdiChildView state 00913 m_pTaskBarPopup->clear(); 00914 if(pWnd->isAttached()){ 00915 m_pTaskBarPopup->insertItem(i18n("Undock"),pWnd,SLOT(detach())); 00916 m_pTaskBarPopup->insertSeparator(); 00917 if(pWnd->isMinimized() || pWnd->isMaximized()) 00918 m_pTaskBarPopup->insertItem(i18n("Restore"),pWnd,SLOT(restore())); 00919 if(!pWnd->isMaximized())m_pTaskBarPopup->insertItem(i18n("Maximize"),pWnd,SLOT(maximize())); 00920 if(!pWnd->isMinimized())m_pTaskBarPopup->insertItem(i18n("Minimize"),pWnd,SLOT(minimize())); 00921 } else m_pTaskBarPopup->insertItem(i18n("Dock"),pWnd,SLOT(attach())); 00922 m_pTaskBarPopup->insertSeparator(); 00923 m_pTaskBarPopup->insertItem(i18n("Close"),pWnd,SLOT(close())); 00924 // the window has a view...get the window popup 00925 m_pTaskBarPopup->insertSeparator(); 00926 m_pTaskBarPopup->insertItem(i18n("Operations"),windowPopup(pWnd,false)); //alvoid recursion 00927 return m_pTaskBarPopup; 00928 } 00929 00930 void KMdiMainFrm::slotDocCurrentChanged(QWidget* pWidget) 00931 { 00932 KMdiChildView *pWnd = static_cast<KMdiChildView*>(pWidget); 00933 pWnd->m_bMainframesActivateViewIsPending = true; 00934 00935 bool bActivateNecessary = true; 00936 if (m_pCurrentWindow != pWnd) { 00937 m_pCurrentWindow = pWnd; 00938 } 00939 00940 if (m_pTaskBar) { 00941 m_pTaskBar->setActiveButton(pWnd); 00942 } 00943 00944 if (m_documentTabWidget && m_mdiMode == KMdi::TabPageMode || m_mdiMode==KMdi::IDEAlMode) { 00945 m_documentTabWidget->showPage(pWnd); 00946 pWnd->activate(); 00947 } 00948 else { 00949 if (pWnd->isAttached()) { 00950 if (bActivateNecessary && (m_pMdi->topChild() == pWnd->mdiParent())) { 00951 pWnd->activate(); 00952 } 00953 pWnd->mdiParent()->raiseAndActivate(); 00954 } 00955 if (!pWnd->isAttached()) { 00956 if (bActivateNecessary) 00957 pWnd->activate(); 00958 m_pMdi->setTopChild(0L); // lose focus in the mainframe window 00959 if (!pWnd->isActiveWindow()) { 00960 pWnd->setActiveWindow(); 00961 } 00962 pWnd->raise(); 00963 } 00964 } 00965 emit collapseOverlapContainers(); 00966 pWnd->m_bMainframesActivateViewIsPending = false; 00967 } 00968 00969 00970 void KMdiMainFrm::activateView(KMdiChildView* pWnd) 00971 { 00972 pWnd->m_bMainframesActivateViewIsPending = true; 00973 00974 bool bActivateNecessary = true; 00975 if (m_pCurrentWindow != pWnd) { 00976 m_pCurrentWindow = pWnd; 00977 } else { 00978 bActivateNecessary = false; 00979 // if this method is called as answer to view->activate(), 00980 // interrupt it because it's not necessary 00981 pWnd->m_bInterruptActivation = true; 00982 } 00983 00984 if (m_pTaskBar) { 00985 m_pTaskBar->setActiveButton(pWnd); 00986 } 00987 00988 if (m_documentTabWidget && m_mdiMode == KMdi::TabPageMode || m_mdiMode==KMdi::IDEAlMode) { 00989 m_documentTabWidget->showPage(pWnd); 00990 pWnd->activate(); 00991 } 00992 #if 0 00993 if (m_mdiMode == KMdi::TabPageMode) { 00994 makeWidgetDockVisible(pWnd); 00995 m_pDockbaseOfTabPage = (KDockWidget*) pWnd->parentWidget(); 00996 } 00997 #endif 00998 else { 00999 if (pWnd->isAttached()) { 01000 if (bActivateNecessary && (m_pMdi->topChild() == pWnd->mdiParent())) { 01001 pWnd->activate(); 01002 } 01003 pWnd->mdiParent()->raiseAndActivate(); 01004 } 01005 if (!pWnd->isAttached()) { 01006 if (bActivateNecessary) 01007 pWnd->activate(); 01008 m_pMdi->setTopChild(0L); // lose focus in the mainframe window 01009 if (!pWnd->isActiveWindow()) { 01010 pWnd->setActiveWindow(); 01011 } 01012 pWnd->raise(); 01013 // if (!pWnd->hasFocus()) { 01014 // pWnd->setFocus(); 01015 // } 01016 } 01017 } 01018 01019 emit collapseOverlapContainers(); 01020 01021 pWnd->m_bMainframesActivateViewIsPending = false; 01022 } 01023 01024 void KMdiMainFrm::taskbarButtonRightClicked(KMdiChildView *pWnd) 01025 { 01026 activateView( pWnd); // set focus 01027 QApplication::sendPostedEvents(); 01028 taskBarPopup( pWnd, true)->popup( QCursor::pos()); 01029 } 01030 01031 void KMdiMainFrm::childWindowCloseRequest(KMdiChildView *pWnd) 01032 { 01033 KMdiViewCloseEvent* ce = new KMdiViewCloseEvent( pWnd); 01034 QApplication::postEvent( this, ce); 01035 } 01036 01037 bool KMdiMainFrm::event( QEvent* e) 01038 { 01039 if( e->type() == QEvent::User) { 01040 KMdiChildView* pWnd = (KMdiChildView*)((KMdiViewCloseEvent*)e)->data(); 01041 if( pWnd != 0L) 01042 closeWindow( pWnd); 01043 return true; 01044 // A little hack: If MDI child views are moved implicietly by moving 01045 // the main widget the should know this too. Unfortunately there seems to 01046 // be no way to catch the move start / move stop situations for the main 01047 // widget in a clean way. (There is no MouseButtonPress/Release or 01048 // something like that.) Therefore we do the following: When we get the 01049 // "first" move event we start a timer and interprete it as "drag begin". 01050 // If we get the next move event and the timer is running we restart the 01051 // timer and don't do anything else. If the timer elapses (this meens we 01052 // haven't had any move event for a while) we interprete this as "drag 01053 // end". If the moving didn't stop actually, we will later get another 01054 // "drag begin", so we get a drag end too much, but this would be the same 01055 // as if the user would stop moving for a little while. 01056 // Actually we seem to be lucky that the timer does not elapse while we 01057 // are moving -> so we have no obsolete drag end / begin 01058 } else if( isVisible() && (e->type() == QEvent::Move)) { 01059 if (m_pDragEndTimer->isActive()) { 01060 // this is not the first move -> stop old timer 01061 m_pDragEndTimer->stop(); 01062 } else { 01063 // this is the first move -> send the drag begin to all concerned views 01064 KMdiChildView* pView; 01065 for (m_pDocumentViews->first(); (pView = m_pDocumentViews->current()) != 0L; m_pDocumentViews->next()) { 01066 KMdiChildFrmDragBeginEvent dragBeginEvent(0L); 01067 QApplication::sendEvent(pView, &dragBeginEvent); 01068 } 01069 } 01070 m_pDragEndTimer->start(200, true); // single shot after 200 ms 01071 } 01072 01073 return DockMainWindow::event( e); 01074 } 01075 01076 bool KMdiMainFrm::eventFilter(QObject * /*obj*/, QEvent *e ) 01077 { 01078 if( e->type() == QEvent::FocusIn) { 01079 QFocusEvent* pFE = (QFocusEvent*) e; 01080 if (pFE->reason() == QFocusEvent::ActiveWindow) { 01081 if (m_pCurrentWindow && !m_pCurrentWindow->isHidden() && !m_pCurrentWindow->isAttached() && m_pMdi->topChild()) { 01082 return true; // eat the event 01083 } 01084 } 01085 if (m_pMdi) { 01086 static bool bFocusTCIsPending = false; 01087 if (!bFocusTCIsPending) { 01088 bFocusTCIsPending = true; 01089 m_pMdi->focusTopChild(); 01090 bFocusTCIsPending = false; 01091 } 01092 } 01093 } else if (e->type() == QEvent::KeyRelease) { 01094 if (switching()) { 01095 KAction *a = actionCollection()->action( "view_last_window" ) ; 01096 if (a) { 01097 const KShortcut cut( a->shortcut() ); 01098 const KKeySequence& seq = cut.seq( 0 ); 01099 const KKey& key = seq.key(0); 01100 int modFlags = key.modFlags(); 01101 int state = ((QKeyEvent *)e)->state(); 01102 KKey key2( (QKeyEvent *)e ); 01103 01108 if (state != ((QKeyEvent *)e)->stateAfter() && 01109 ((modFlags & KKey::CTRL) > 0) == ((state & Qt::ControlButton) > 0 ) && 01110 ((modFlags & KKey::ALT) > 0) == ((state & Qt::AltButton) > 0) && 01111 ((modFlags & KKey::WIN) > 0) == ((state & Qt::MetaButton) > 0) ) 01112 { 01113 activeWindow()->updateTimeStamp(); 01114 setSwitching(false); 01115 } 01116 return true; 01117 } else { 01118 kdDebug(9000) << "KAction( \"view_last_window\") not found." << endl; 01119 } 01120 } 01121 } 01122 return false; // standard event processing 01123 } 01124 01128 void KMdiMainFrm::closeAllViews() 01129 { 01130 //save the children first to a list, as removing invalidates our iterator 01131 QValueList<KMdiChildView *> children; 01132 for(KMdiChildView *w = m_pDocumentViews->first();w;w= m_pDocumentViews->next()){ 01133 children.append(w); 01134 } 01135 QValueListIterator<KMdiChildView *> childIt; 01136 for (childIt = children.begin(); childIt != children.end(); ++childIt) 01137 { 01138 (*childIt)->close(); 01139 } 01140 } 01141 01142 01146 void KMdiMainFrm::iconifyAllViews() 01147 { 01148 for(KMdiChildView *w = m_pDocumentViews->first();w;w= m_pDocumentViews->next()) 01149 w->minimize(); 01150 } 01151 01155 void KMdiMainFrm::closeActiveView() 01156 { 01157 if( m_pCurrentWindow != 0L) { 01158 m_pCurrentWindow->close(); 01159 } 01160 } 01161 01163 void KMdiMainFrm::findRootDockWidgets(QPtrList<KDockWidget>* pRootDockWidgetList, QValueList<QRect>* pPositionList) 01164 { 01165 if (!pRootDockWidgetList) return; 01166 if (!pPositionList) return; 01167 01168 // since we set some windows to toplevel, we must consider the window manager's window frame 01169 const int frameBorderWidth = 7; // @todo: Can we / do we need to ask the window manager? 01170 const int windowTitleHeight = 10; // @todo: -"- 01171 01172 QObjectList* pObjList = queryList( "KDockWidget"); 01173 if (pObjList->isEmpty()) { 01174 pObjList = queryList( "KDockWidget_Compat::KDockWidget"); 01175 } 01176 QObjectListIt it( *pObjList); 01177 QObject* pObj; 01178 // for all dockwidgets (which are children of this mainwindow) 01179 while ((pObj = it.current()) != 0L) { 01180 ++it; 01181 KDockWidget* pDockW = (KDockWidget*) pObj; 01182 KDockWidget* pRootDockW = 0L; 01183 KDockWidget* pUndockCandidate = 0L; 01184 QWidget* pW = pDockW; 01185 // find the oldest ancestor of the current dockwidget that can be undocked 01186 while (!pW->isTopLevel()) { 01187 if (pW->inherits("KDockWidget") || pW->inherits("KDockWidget_Compat::KDockWidget")) { 01188 pUndockCandidate = (KDockWidget*) pW; 01189 if (pUndockCandidate->enableDocking() != KDockWidget::DockNone) 01190 pRootDockW = pUndockCandidate; 01191 } 01192 pW = pW->parentWidget(); 01193 } 01194 if (pRootDockW) { 01195 // if that oldest ancestor is not already in the list, append it 01196 bool found = false; 01197 QPtrListIterator<KDockWidget> it2( *pRootDockWidgetList); 01198 if (!pRootDockWidgetList->isEmpty()) { 01199 for ( ; it2.current() && !found; ++it2 ) { 01200 KDockWidget* pDockW = it2.current(); 01201 if (pDockW == pRootDockW) 01202 found = true; 01203 } 01204 if (!found) { 01205 pRootDockWidgetList->append( (KDockWidget*)pDockW); 01206 kdDebug(760)<<"pRootDockWidgetList->append("<<pDockW->name()<<");"<<endl; 01207 QPoint p = pDockW->mapToGlobal( pDockW->pos())-pDockW->pos(); 01208 QRect r( p.x(), 01209 p.y()+m_undockPositioningOffset.y(), 01210 pDockW->width() - windowTitleHeight - frameBorderWidth*2, 01211 pDockW->height() - windowTitleHeight - frameBorderWidth*2); 01212 pPositionList->append( r); 01213 } 01214 } 01215 else { 01216 pRootDockWidgetList->append( (KDockWidget*)pRootDockW); 01217 kdDebug(760)<<"pRootDockWidgetList->append("<<pDockW->name()<<");"<<endl; 01218 QPoint p = pRootDockW->mapToGlobal( pRootDockW->pos())-pRootDockW->pos(); 01219 QRect r( p.x(), 01220 p.y()+m_undockPositioningOffset.y(), 01221 pRootDockW->width() - windowTitleHeight - frameBorderWidth*2, 01222 pRootDockW->height() - windowTitleHeight - frameBorderWidth*2); 01223 pPositionList->append( r); 01224 } 01225 } 01226 } 01227 delete pObjList; 01228 } 01229 01233 void KMdiMainFrm::switchToToplevelMode() 01234 { 01235 if (m_mdiMode == KMdi::ToplevelMode) { 01236 emit mdiModeHasBeenChangedTo(KMdi::ToplevelMode); 01237 return; 01238 } 01239 01240 KMdi::MdiMode oldMdiMode = m_mdiMode; 01241 01242 const int frameBorderWidth = 7; // @todo: Can we / do we need to ask the window manager? 01243 setUndockPositioningOffset( QPoint( 0, (m_pTaskBar ? m_pTaskBar->height() : 0) + frameBorderWidth)); 01244 01245 01246 // 1.) select the dockwidgets to be undocked and store their geometry 01247 QPtrList<KDockWidget> rootDockWidgetList; 01248 QValueList<QRect> positionList; 01249 if (oldMdiMode!=KMdi::IDEAlMode) 01250 findRootDockWidgets(&rootDockWidgetList, &positionList); 01251 01252 // 2.) undock the MDI views of QextMDI 01253 if (oldMdiMode == KMdi::ChildframeMode) { 01254 finishChildframeMode(); 01255 } else if (oldMdiMode == KMdi::TabPageMode) { // if tabified, release all views from their docking covers 01256 finishTabPageMode(); 01257 } else if (m_mdiMode == KMdi::IDEAlMode) { 01258 finishIDEAlMode(); 01259 findRootDockWidgets(&rootDockWidgetList, &positionList); 01260 } 01261 01262 // if (hasMenuBar()) menuBar()->setTopLevelMenu(false); 01263 01264 // 3.) undock all these found oldest ancestors (being KDockWidgets) 01265 QPtrListIterator<KDockWidget> it3( rootDockWidgetList); 01266 for (; it3.current(); ++it3 ) { 01267 KDockWidget* pDockW = it3.current(); 01268 pDockW->undock(); 01269 } 01270 01271 // 4.) recreate the MDI childframe area and hide it 01272 if ((oldMdiMode == KMdi::TabPageMode) || (oldMdiMode==KMdi::IDEAlMode)) { 01273 if (!m_pDockbaseAreaOfDocumentViews) { 01274 m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", QPixmap(), 0L, "mdi_area_cover"); 01275 m_pDockbaseAreaOfDocumentViews->setDockWindowTransient(this,true); 01276 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockNone); 01277 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockCorner); 01278 m_pDockbaseAreaOfDocumentViews->setWidget(m_pMdi); 01279 } 01280 // set this dock to main view 01281 setView(m_pDockbaseAreaOfDocumentViews); 01282 setMainDockWidget(m_pDockbaseAreaOfDocumentViews); 01283 //REMOVE m_pDockbaseOfTabPage = m_pDockbaseAreaOfDocumentViews; 01284 } 01285 QApplication::sendPostedEvents(); 01286 if (!parentWidget()) { 01287 m_oldMainFrmMinHeight = minimumHeight(); 01288 m_oldMainFrmMaxHeight = maximumHeight(); 01289 m_oldMainFrmHeight = height(); 01290 if( m_pDocumentViews->count()) 01291 setFixedHeight( height() - m_pDockbaseAreaOfDocumentViews->height()); 01292 else { // consider space for the taskbar 01293 QApplication::sendPostedEvents(); 01294 setFixedHeight( height() - m_pDockbaseAreaOfDocumentViews->height() + 27); 01295 } 01296 } 01297 01298 #ifdef __GNUC__ 01299 #warning fixme 01300 #endif 01301 // 5. show the child views again 01302 QPtrListIterator<KMdiChildView> it( *m_pDocumentViews); 01303 for( it.toFirst(); it.current(); ++it) { 01304 KMdiChildView* pView = it.current(); 01305 #if defined Q_WS_X11 && ! defined K_WS_QTONLY 01306 XSetTransientForHint(qt_xdisplay(),pView->winId(),winId()); 01307 #endif 01308 // if( !pView->isToolView()) 01309 pView->show(); 01310 } 01311 01312 // 6.) reset all memorized positions of the undocked ones and show them again 01313 QValueList<QRect>::Iterator it5; 01314 for (it3.toFirst(), it5 = positionList.begin() ; it3.current(), it5 != positionList.end(); ++it3, ++it5 ) { 01315 KDockWidget* pDockW = it3.current(); 01316 pDockW->setGeometry( (*it5)); 01317 pDockW->show(); 01318 } 01319 01320 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockNone); 01321 m_mdiMode = KMdi::ToplevelMode; 01322 //qDebug("ToplevelMode on"); 01323 01324 emit mdiModeHasBeenChangedTo(KMdi::ToplevelMode); 01325 01326 } 01327 01328 void KMdiMainFrm::finishToplevelMode() 01329 { 01330 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockCorner); 01331 //KIPC::sendMessage(KIPC::ToolbarStyleChanged,winId()); 01332 } 01333 01337 void KMdiMainFrm::switchToChildframeMode() 01338 { 01339 if (m_mdiMode == KMdi::ChildframeMode) { 01340 emit mdiModeHasBeenChangedTo(KMdi::ChildframeMode); 01341 return; 01342 } 01343 01344 QPtrList<KDockWidget> rootDockWidgetList; 01345 if (m_mdiMode == KMdi::TabPageMode) { 01346 // select the dockwidgets to be undocked and store their geometry 01347 QValueList<QRect> positionList; 01348 findRootDockWidgets(&rootDockWidgetList, &positionList); 01349 01350 // undock all these found oldest ancestors (being KDockWidgets) 01351 QPtrListIterator<KDockWidget> it3( rootDockWidgetList); 01352 for (; it3.current(); ++it3 ) { 01353 KDockWidget* pDockW = it3.current(); 01354 pDockW->undock(); 01355 } 01356 01357 finishTabPageMode(); 01358 } else if (m_mdiMode == KMdi::ToplevelMode) { 01359 finishToplevelMode(); 01360 } else if (m_mdiMode == KMdi::IDEAlMode) { 01361 finishIDEAlMode(false); 01362 01363 // select the dockwidgets to be undocked and store their geometry 01364 QValueList<QRect> positionList; 01365 findRootDockWidgets(&rootDockWidgetList, &positionList); 01366 01367 01368 01369 // undock all these found oldest ancestors (being KDockWidgets) 01370 01371 QPtrListIterator<KDockWidget> it3( rootDockWidgetList); 01372 for (; it3.current(); ++it3 ) { 01373 KDockWidget* pDockW = it3.current(); 01374 pDockW->undock(); 01375 } 01376 m_mdiMode=KMdi::TabPageMode; 01377 finishTabPageMode(); 01378 m_mdiMode=KMdi::IDEAlMode; 01379 01380 } 01381 01382 //return; //debug 01383 01384 01385 if (!m_pDockbaseAreaOfDocumentViews) { 01386 // cover KMdi's childarea by a dockwidget 01387 m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", QPixmap(), 0L, "mdi_area_cover"); 01388 m_pDockbaseAreaOfDocumentViews->setDockWindowTransient(this,true); 01389 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockNone); 01390 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockCorner); 01391 m_pDockbaseAreaOfDocumentViews->setWidget(m_pMdi); 01392 kdDebug(760)<<"!swtichToChildframeMode: m_pDockbaseAreaOfDocumentViews"<<endl; 01393 } 01394 if (m_pDockbaseAreaOfDocumentViews->isTopLevel()) { 01395 // set this dock to main view 01396 setView(m_pDockbaseAreaOfDocumentViews); 01397 setMainDockWidget(m_pDockbaseAreaOfDocumentViews); 01398 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockNone); 01399 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockCorner); 01400 //REMOVE m_pDockbaseOfTabPage = m_pDockbaseAreaOfDocumentViews; 01401 kdDebug(760)<<"swtichToChildframeMode: m_pDockbaaseAreaOfDocumentViews->isTopLevel()"<<endl; 01402 } 01403 m_pDockbaseAreaOfDocumentViews->setWidget(m_pMdi); //JW 01404 m_pDockbaseAreaOfDocumentViews->show(); 01405 //return; //debug 01406 if ( (m_mdiMode == KMdi::TabPageMode) || (m_mdiMode == KMdi::IDEAlMode)) { 01407 kdDebug(760)<<"switchToChildFrameMode: trying to dock back toolviews"<<endl; 01408 QPtrListIterator<KDockWidget> it4( rootDockWidgetList); 01409 for (; it4.current(); ++it4 ) { 01410 KDockWidget* pDockW = it4.current(); 01411 pDockW->dockBack(); 01412 } 01413 } 01414 01415 if (m_mdiMode == KMdi::ToplevelMode && m_pTempDockSession) { 01416 // restore the old dock szenario which we memorized at the time we switched to toplevel mode 01417 QDomElement oldDockState = m_pTempDockSession->namedItem("cur_dock_state").toElement(); 01418 readDockConfig( oldDockState); 01419 } 01420 01421 KMdi::MdiMode oldMdiMode = m_mdiMode; 01422 m_mdiMode = KMdi::ChildframeMode; 01423 01424 #ifdef __GNUC__ 01425 #warning fixme 01426 #endif 01427 QPtrListIterator<KMdiChildView> it( *m_pDocumentViews); 01428 for( ; it.current(); ++it) { 01429 KMdiChildView* pView = it.current(); 01430 if( !pView->isToolView()) 01431 if( !pView->isAttached()) 01432 attachWindow( pView, true); 01433 } 01434 for( it.toFirst(); it.current(); ++it) { 01435 KMdiChildView* pView = it.current(); 01436 if( !pView->isToolView()) 01437 pView->show(); 01438 } 01439 if( (oldMdiMode == KMdi::ToplevelMode) && !parentWidget()) { 01440 setMinimumHeight( m_oldMainFrmMinHeight); 01441 setMaximumHeight( m_oldMainFrmMaxHeight); 01442 resize( width(), m_oldMainFrmHeight); 01443 m_oldMainFrmHeight = 0; 01444 //qDebug("TopLevelMode off"); 01445 emit leftTopLevelMode(); 01446 } 01447 emit mdiModeHasBeenChangedTo(KMdi::ChildframeMode); 01448 } 01449 01450 void KMdiMainFrm::finishChildframeMode() 01451 { 01452 // save the old dock szenario of the dockwidged-like tool views to a DOM tree 01453 delete m_pTempDockSession; 01454 m_pTempDockSession = new QDomDocument( "docksession"); 01455 QDomElement curDockState = m_pTempDockSession->createElement("cur_dock_state"); 01456 m_pTempDockSession->appendChild( curDockState); 01457 writeDockConfig( curDockState); 01458 01459 // detach all non-tool-views to toplevel 01460 QPtrListIterator<KMdiChildView> it( *m_pDocumentViews); 01461 for( ; it.current(); ++it) { 01462 KMdiChildView* pView = it.current(); 01463 if( pView->isToolView()) 01464 continue; 01465 if( pView->isAttached()) { 01466 if( pView->isMaximized()) 01467 pView->mdiParent()->setGeometry( 0, 0, m_pMdi->width(), m_pMdi->height()); 01468 detachWindow( pView, false); 01469 } 01470 } 01471 } 01472 01473 01474 01475 01479 void KMdiMainFrm::switchToTabPageMode() 01480 { 01481 KMdiChildView* pRemActiveWindow = activeWindow(); 01482 01483 if (m_mdiMode == KMdi::TabPageMode) { 01484 emit mdiModeHasBeenChangedTo(KMdi::TabPageMode); 01485 return; // nothing need to be done 01486 } 01487 01488 // make sure that all MDI views are detached 01489 if (m_mdiMode == KMdi::ChildframeMode) { 01490 finishChildframeMode(); 01491 } else if (m_mdiMode == KMdi::ToplevelMode) { 01492 finishToplevelMode(); 01493 } else if (m_mdiMode == KMdi::IDEAlMode) { 01494 finishIDEAlMode(false); 01495 emit mdiModeHasBeenChangedTo(KMdi::TabPageMode); 01496 m_mdiMode=KMdi::TabPageMode; 01497 return; 01498 } 01499 01500 setupTabbedDocumentViewSpace(); 01501 m_mdiMode = KMdi::TabPageMode; 01502 if (pRemActiveWindow) 01503 pRemActiveWindow->setFocus(); 01504 01505 m_pTaskBar->switchOn(false); 01506 01507 assert(m_pClose); 01508 QObject::connect( m_pClose, SIGNAL(clicked()), this, SLOT(closeViewButtonPressed()) ); 01509 if (m_pDocumentViews->count() > 0) { 01510 m_pClose->show(); 01511 } 01512 //qDebug("TabPageMode on"); 01513 emit mdiModeHasBeenChangedTo(KMdi::TabPageMode); 01514 } 01515 01516 void KMdiMainFrm::finishTabPageMode() 01517 { 01518 // if tabified, release all views from their docking covers 01519 if (m_mdiMode == KMdi::TabPageMode) { 01520 m_pClose->hide(); 01521 QObject::disconnect( m_pClose, SIGNAL(clicked()), this, SLOT(closeViewButtonPressed()) ); 01522 01523 QPtrListIterator<KMdiChildView> it( *m_pDocumentViews); 01524 for( ; it.current(); ++it) { 01525 KMdiChildView* pView = it.current(); 01526 if( pView->isToolView()) 01527 continue; 01528 kdDebug(760)<<"KMdiMainFrm::finishTabPageMode: in loop"<<endl; 01529 QSize mins = pView->minimumSize(); 01530 QSize maxs = pView->maximumSize(); 01531 QSize sz = pView->size(); 01532 QWidget* pParent = pView->parentWidget(); 01533 QPoint p(pParent->mapToGlobal(pParent->pos())-pParent->pos()+m_undockPositioningOffset); 01534 m_documentTabWidget->removePage(pView); 01535 pView->reparent(0,0,p); 01536 // pView->reparent(0,0,p); 01537 pView->resize(sz); 01538 pView->setMinimumSize(mins.width(),mins.height()); 01539 pView->setMaximumSize(maxs.width(),maxs.height()); 01540 // ((KDockWidget*)pParent)->undock(); // this destroys the dockwiget cover, too 01541 // pParent->close(); 01542 // delete pParent; 01543 // if (centralWidget() == pParent) { 01544 // setCentralWidget(0L); // avoid dangling pointer 01545 // } 01546 } 01547 delete m_documentTabWidget; 01548 m_documentTabWidget=0; 01549 m_pTaskBar->switchOn(true); 01550 } 01551 } 01552 01553 01554 01555 void KMdiMainFrm::setupTabbedDocumentViewSpace() { 01556 // resize to childframe mode size of the mainwindow if we were in toplevel mode 01557 if( (m_mdiMode == KMdi::ToplevelMode) && !parentWidget()) { 01558 setMinimumHeight( m_oldMainFrmMinHeight); 01559 setMaximumHeight( m_oldMainFrmMaxHeight); 01560 resize( width(), m_oldMainFrmHeight); 01561 m_oldMainFrmHeight = 0; 01562 //qDebug("TopLevelMode off"); 01563 emit leftTopLevelMode(); 01564 QApplication::sendPostedEvents(); 01565 01566 // restore the old dock szenario which we memorized at the time we switched to toplevel mode 01567 if (m_pTempDockSession) { 01568 QDomElement oldDockState = m_pTempDockSession->namedItem("cur_dock_state").toElement(); 01569 readDockConfig( oldDockState); 01570 } 01571 } 01572 01573 #if 0 01574 if (m_pDockbaseOfTabPage != m_pDockbaseAreaOfDocumentViews) { 01575 delete m_pDockbaseOfTabPage; 01576 m_pDockbaseOfTabPage = m_pDockbaseAreaOfDocumentViews; 01577 } 01578 #endif 01579 delete m_documentTabWidget; 01580 m_documentTabWidget=new KMdiDocumentViewTabWidget(m_pDockbaseAreaOfDocumentViews); 01581 connect(m_documentTabWidget,SIGNAL(currentChanged(QWidget*)),this,SLOT(slotDocCurrentChanged(QWidget*))); 01582 m_pDockbaseAreaOfDocumentViews->setWidget(m_documentTabWidget); 01583 m_documentTabWidget->show(); 01584 QPtrListIterator<KMdiChildView> it4( *m_pDocumentViews); 01585 for( ; it4.current(); ++it4) { 01586 KMdiChildView* pView = it4.current(); 01587 m_documentTabWidget->addTab(pView, pView->icon() ? *(pView->icon()) : QPixmap(),pView->tabCaption()); 01588 /* 01589 connect(pView,SIGNAL(iconOrCaptionUdpated(QWidget*,QPixmap,const QString&)), 01590 m_documentTabWidget,SLOT(updateView(QWidget*,QPixmap,const QString&))); 01591 */ 01592 connect( pView, SIGNAL(iconUpdated(QWidget*, QPixmap )), m_documentTabWidget, SLOT(updateIconInView(QWidget*, QPixmap )) ); 01593 connect( pView, SIGNAL(captionUpdated(QWidget*, const QString& )), m_documentTabWidget, SLOT(updateCaptionInView(QWidget*, const QString& )) ); 01594 01595 } 01596 } 01597 01598 01599 void KMdiMainFrm::setIDEAlModeStyle(int flags) 01600 { 01601 d->m_styleIDEAlMode = flags; // see KMultiTabBar for the first 3 bits 01602 if (m_leftContainer) { 01603 KMdiDockContainer *tmpL=(KMdiDockContainer*) (m_leftContainer->getWidget()->qt_cast("KMdiDockContainer")); 01604 if (tmpL) tmpL->setStyle(flags); 01605 } 01606 01607 if (m_rightContainer) { 01608 KMdiDockContainer *tmpR=(KMdiDockContainer*) (m_rightContainer->getWidget()->qt_cast("KMdiDockContainer")); 01609 if (tmpR) tmpR->setStyle(flags); 01610 } 01611 01612 if (m_topContainer) { 01613 KMdiDockContainer *tmpT=(KMdiDockContainer*) (m_topContainer->getWidget()->qt_cast("KMdiDockContainer")); 01614 if (tmpT) tmpT->setStyle(flags); 01615 } 01616 01617 if (m_bottomContainer) { 01618 KMdiDockContainer *tmpB=(KMdiDockContainer*) (m_bottomContainer->getWidget()->qt_cast("KMdiDockContainer")); 01619 if (tmpB) tmpB->setStyle(flags); 01620 } 01621 } 01622 01623 void KMdiMainFrm::setToolviewStyle(int flag) 01624 { 01625 if (m_mdiMode == KMdi::IDEAlMode) { 01626 setIDEAlModeStyle(flag); 01627 } 01628 d->m_toolviewStyle = flag; 01629 bool toolviewExists = false; 01630 QMap<QWidget*,KMdiToolViewAccessor*>::Iterator it; 01631 for (it = m_pToolViews->begin(); it != m_pToolViews->end(); ++it) { 01632 KDockWidget *dockWidget = dynamic_cast<KDockWidget*>(it.data()->wrapperWidget()); 01633 if (dockWidget) { 01634 if (flag == KMdi::IconOnly) 01635 { 01636 dockWidget->setTabPageLabel(" "); 01637 dockWidget->setPixmap(*(it.data()->wrappedWidget()->icon())); 01638 } else 01639 if (flag == KMdi::TextOnly) 01640 { 01641 dockWidget->setPixmap(); //FIXME: Does not hide the icon in the IDEAl mode. 01642 dockWidget->setTabPageLabel(it.data()->wrappedWidget()->caption()); 01643 } else 01644 if (flag == KMdi::TextAndIcon) 01645 { 01646 dockWidget->setPixmap(*(it.data()->wrappedWidget()->icon())); 01647 dockWidget->setTabPageLabel(it.data()->wrappedWidget()->caption()); 01648 } 01649 toolviewExists = true; 01650 } 01651 } 01652 if (toolviewExists) 01653 { 01654 //workaround for the above FIXME to make switching to TextOnly mode work in IDEAl as well. Be sure that this version of switch* is called. 01655 if (m_mdiMode == KMdi::IDEAlMode && flag == KMdi::TextOnly) 01656 { 01657 KMdiMainFrm::switchToTabPageMode(); 01658 KMdiMainFrm::switchToIDEAlMode(); 01659 } else 01660 { 01661 writeDockConfig(); 01662 readDockConfig(); 01663 } 01664 } 01665 } 01666 01670 void KMdiMainFrm::switchToIDEAlMode() 01671 { 01672 kdDebug(760)<<"SWITCHING TO IDEAL"<<endl; 01673 KMdiChildView* pRemActiveWindow = activeWindow(); 01674 01675 if (m_mdiMode == KMdi::IDEAlMode) { 01676 emit mdiModeHasBeenChangedTo(KMdi::IDEAlMode); 01677 return; // nothing need to be done 01678 } 01679 01680 // make sure that all MDI views are detached 01681 if (m_mdiMode == KMdi::ChildframeMode) { 01682 finishChildframeMode(); 01683 } else if (m_mdiMode == KMdi::ToplevelMode) { 01684 finishToplevelMode(); 01685 } else if (m_mdiMode == KMdi::TabPageMode) { 01686 m_mdiMode=KMdi::IDEAlMode; 01687 setupToolViewsForIDEALMode(); 01688 emit mdiModeHasBeenChangedTo(KMdi::IDEAlMode); 01689 return; 01690 } 01691 01692 setupTabbedDocumentViewSpace(); 01693 m_mdiMode = KMdi::IDEAlMode; 01694 01695 01696 setupToolViewsForIDEALMode(); 01697 01698 if (pRemActiveWindow) 01699 pRemActiveWindow->setFocus(); 01700 01701 m_pTaskBar->switchOn(false); 01702 01703 assert(m_pClose); 01704 QObject::connect( m_pClose, SIGNAL(clicked()), this, SLOT(closeViewButtonPressed()) ); 01705 if (m_pDocumentViews->count() > 0) { 01706 m_pClose->show(); 01707 } 01708 //qDebug("IDEAlMode on"); 01709 01710 emit mdiModeHasBeenChangedTo(KMdi::IDEAlMode); 01711 } 01712 01713 01714 void KMdiMainFrm::dockToolViewsIntoContainers(QPtrList<KDockWidget>& widgetsToReparent,KDockWidget *container) { 01715 for ( KDockWidget *dw = widgetsToReparent.first(); dw; 01716 dw=widgetsToReparent.next()){ 01717 dw->manualDock(container,KDockWidget::DockCenter,20); 01718 dw->loseFormerBrotherDockWidget(); 01719 } 01720 } 01721 01722 void KMdiMainFrm::findToolViewsDockedToMain(QPtrList<KDockWidget>* list,KDockWidget::DockPosition dprtmw) { 01723 KDockWidget *mainDock=getMainDockWidget(); 01724 if (mainDock->parentDockTabGroup()) { 01725 mainDock=dynamic_cast<KDockWidget*>(mainDock->parentDockTabGroup()->parent()); 01726 // FIXME: will likely crash below due to unchecked cast 01727 } 01728 01729 KDockWidget* widget=mainDock->findNearestDockWidget(dprtmw); 01730 if (widget) { 01731 if (widget->parentDockTabGroup()) { 01732 widget=static_cast<KDockWidget*>(widget->parentDockTabGroup()->parent()); 01733 } 01734 01735 if (widget) { 01736 KDockTabGroup *tg=dynamic_cast<KDockTabGroup*>(widget-> 01737 getWidget()); 01738 if (tg) { 01739 kdDebug(760)<<"KDockTabGroup found"<<endl; 01740 for (int i=0;i<tg->count();i++) 01741 list->append((KDockWidget*)static_cast<KDockWidget*>( 01742 tg->page(i))); 01743 } else 01744 list->append((KDockWidget*)widget); 01745 } else 01746 kdDebug(760)<<"setupToolViewsForIDEALMode: no widget found"<<endl; 01747 } else 01748 kdDebug(760)<<"No main dock widget found"<<endl; 01749 } 01750 01751 01752 void KMdiMainFrm::setupToolViewsForIDEALMode() 01753 { 01754 m_leftContainer = createDockWidget("KMdiDock::leftDock",SmallIcon("misc"),0L,"Left Dock"); 01755 m_rightContainer = createDockWidget("KMdiDock::rightDock",SmallIcon("misc"),0L,"Right Dock"); 01756 m_topContainer = createDockWidget("KMdiDock::topDock",SmallIcon("misc"),0L,"Top Dock"); 01757 m_bottomContainer = createDockWidget("KMdiDock::bottomDock",SmallIcon("misc"),0L,"Bottom Dock"); 01758 01759 KDockWidget *mainDock=getMainDockWidget(); 01760 KDockWidget *w=mainDock; 01761 if (mainDock->parentDockTabGroup()) { 01762 w=static_cast<KDockWidget*>(mainDock->parentDockTabGroup()->parent()); 01763 } 01764 01765 QPtrList<KDockWidget> leftReparentWidgets; 01766 QPtrList<KDockWidget> rightReparentWidgets; 01767 QPtrList<KDockWidget> bottomReparentWidgets; 01768 QPtrList<KDockWidget> topReparentWidgets; 01769 01770 if (mainDock->parentDockTabGroup()) { 01771 mainDock=static_cast<KDockWidget*>(mainDock->parentDockTabGroup()->parent()); 01772 } 01773 01774 findToolViewsDockedToMain(&leftReparentWidgets,KDockWidget::DockLeft); 01775 findToolViewsDockedToMain(&rightReparentWidgets,KDockWidget::DockRight); 01776 findToolViewsDockedToMain(&bottomReparentWidgets,KDockWidget::DockBottom); 01777 findToolViewsDockedToMain(&topReparentWidgets,KDockWidget::DockTop); 01778 01779 mainDock->setEnableDocking(KDockWidget::DockNone); //::DockCorner); 01780 mainDock->setDockSite(KDockWidget::DockCorner); 01781 01782 01783 KMdiDockContainer *tmpDC; 01784 m_leftContainer->setWidget(tmpDC=new KMdiDockContainer(m_leftContainer, this, KDockWidget::DockLeft, d->m_styleIDEAlMode)); 01785 m_leftContainer->setEnableDocking(KDockWidget::DockLeft); 01786 m_leftContainer->manualDock(mainDock, KDockWidget::DockLeft,20); 01787 tmpDC->init(); 01788 if (m_mdiGUIClient) connect (this,SIGNAL(toggleLeft()),tmpDC,SLOT(toggle())); 01789 connect(this,SIGNAL(collapseOverlapContainers()),tmpDC,SLOT(collapseOverlapped())); 01790 connect(tmpDC,SIGNAL(activated(KMdiDockContainer*)),this,SLOT(setActiveToolDock(KMdiDockContainer*))); 01791 connect(tmpDC,SIGNAL(deactivated(KMdiDockContainer*)),this,SLOT(removeFromActiveDockList(KMdiDockContainer*))); 01792 01793 m_rightContainer->setWidget(tmpDC=new KMdiDockContainer(m_rightContainer, this, KDockWidget::DockRight, d->m_styleIDEAlMode)); 01794 m_rightContainer->setEnableDocking(KDockWidget::DockRight); 01795 m_rightContainer->manualDock(mainDock, KDockWidget::DockRight,80); 01796 tmpDC->init(); 01797 if (m_mdiGUIClient) connect (this,SIGNAL(toggleRight()),tmpDC,SLOT(toggle())); 01798 connect(this,SIGNAL(collapseOverlapContainers()),tmpDC,SLOT(collapseOverlapped())); 01799 connect(tmpDC,SIGNAL(activated(KMdiDockContainer*)),this,SLOT(setActiveToolDock(KMdiDockContainer*))); 01800 connect(tmpDC,SIGNAL(deactivated(KMdiDockContainer*)),this,SLOT(removeFromActiveDockList(KMdiDockContainer*))); 01801 01802 m_topContainer->setWidget(tmpDC=new KMdiDockContainer(m_topContainer, this, KDockWidget::DockTop, d->m_styleIDEAlMode)); 01803 m_topContainer->setEnableDocking(KDockWidget::DockTop); 01804 m_topContainer->manualDock(mainDock, KDockWidget::DockTop,20); 01805 tmpDC->init(); 01806 if (m_mdiGUIClient) connect (this,SIGNAL(toggleTop()),tmpDC,SLOT(toggle())); 01807 connect(this,SIGNAL(collapseOverlapContainers()),tmpDC,SLOT(collapseOverlapped())); 01808 connect(tmpDC,SIGNAL(activated(KMdiDockContainer*)),this,SLOT(setActiveToolDock(KMdiDockContainer*))); 01809 connect(tmpDC,SIGNAL(deactivated(KMdiDockContainer*)),this,SLOT(removeFromActiveDockList(KMdiDockContainer*))); 01810 01811 m_bottomContainer->setWidget(tmpDC=new KMdiDockContainer(m_bottomContainer, this, KDockWidget::DockBottom, d->m_styleIDEAlMode)); 01812 m_bottomContainer->setEnableDocking(KDockWidget::DockBottom); 01813 m_bottomContainer->manualDock(mainDock, KDockWidget::DockBottom,80); 01814 tmpDC->init(); 01815 if (m_mdiGUIClient) connect (this,SIGNAL(toggleBottom()),tmpDC,SLOT(toggle())); 01816 connect(this,SIGNAL(collapseOverlapContainers()),tmpDC,SLOT(collapseOverlapped())); 01817 connect(tmpDC,SIGNAL(activated(KMdiDockContainer*)),this,SLOT(setActiveToolDock(KMdiDockContainer*))); 01818 connect(tmpDC,SIGNAL(deactivated(KMdiDockContainer*)),this,SLOT(removeFromActiveDockList(KMdiDockContainer*))); 01819 01820 m_leftContainer->setDockSite( KDockWidget::DockCenter ); 01821 m_rightContainer->setDockSite( KDockWidget::DockCenter ); 01822 m_topContainer->setDockSite( KDockWidget::DockCenter ); 01823 m_bottomContainer->setDockSite( KDockWidget::DockCenter ); 01824 01825 dockToolViewsIntoContainers(leftReparentWidgets,m_leftContainer); 01826 dockToolViewsIntoContainers(rightReparentWidgets,m_rightContainer); 01827 dockToolViewsIntoContainers(bottomReparentWidgets,m_bottomContainer); 01828 dockToolViewsIntoContainers(topReparentWidgets,m_topContainer); 01829 01830 01831 dockManager->setSpecialLeftDockContainer(m_leftContainer); 01832 dockManager->setSpecialRightDockContainer(m_rightContainer); 01833 dockManager->setSpecialTopDockContainer(m_topContainer); 01834 dockManager->setSpecialBottomDockContainer(m_bottomContainer); 01835 01836 01837 ((KMdiDockContainer*) (m_leftContainer->getWidget()))->hideIfNeeded(); 01838 ((KMdiDockContainer*) (m_rightContainer->getWidget()))->hideIfNeeded(); 01839 ((KMdiDockContainer*) (m_topContainer->getWidget()))->hideIfNeeded(); 01840 ((KMdiDockContainer*) (m_bottomContainer->getWidget()))->hideIfNeeded(); 01841 01842 } 01843 01844 01845 01846 void KMdiMainFrm::finishIDEAlMode(bool full) 01847 { 01848 // if tabified, release all views from their docking covers 01849 if (m_mdiMode == KMdi::IDEAlMode) { 01850 assert(m_pClose); 01851 m_pClose->hide(); 01852 QObject::disconnect( m_pClose, SIGNAL(clicked()), this, SLOT(closeViewButtonPressed()) ); 01853 01854 01855 QStringList leftNames; 01856 leftNames=prepareIdealToTabs(m_leftContainer); 01857 int leftWidth=m_leftContainer->width(); 01858 01859 QStringList rightNames; 01860 rightNames=prepareIdealToTabs(m_rightContainer); 01861 int rightWidth=m_rightContainer->width(); 01862 01863 QStringList topNames; 01864 topNames=prepareIdealToTabs(m_topContainer); 01865 int topHeight=m_topContainer->height(); 01866 01867 QStringList bottomNames; 01868 bottomNames=prepareIdealToTabs(m_bottomContainer); 01869 int bottomHeight=m_bottomContainer->height(); 01870 01871 01872 kdDebug(760)<<"leftNames"<<leftNames<<endl; 01873 kdDebug(760)<<"rightNames"<<rightNames<<endl; 01874 kdDebug(760)<<"topNames"<<topNames<<endl; 01875 kdDebug(760)<<"bottomNames"<<bottomNames<<endl; 01876 01877 delete m_leftContainer; 01878 m_leftContainer=0; 01879 delete m_rightContainer; 01880 m_rightContainer=0; 01881 delete m_bottomContainer; 01882 m_bottomContainer=0; 01883 delete m_topContainer; 01884 m_topContainer=0; 01885 01886 01887 idealToolViewsToStandardTabs(bottomNames,KDockWidget::DockBottom,bottomHeight); 01888 idealToolViewsToStandardTabs(leftNames,KDockWidget::DockLeft,leftWidth); 01889 idealToolViewsToStandardTabs(rightNames,KDockWidget::DockRight,rightWidth); 01890 idealToolViewsToStandardTabs(topNames,KDockWidget::DockTop,topHeight); 01891 01892 QApplication::sendPostedEvents(); 01893 01894 if (!full) return; 01895 01896 QPtrListIterator<KMdiChildView> it( *m_pDocumentViews); 01897 for( ; it.current(); ++it) { 01898 KMdiChildView* pView = it.current(); 01899 if( pView->isToolView()) 01900 continue; 01901 QSize mins = pView->minimumSize(); 01902 QSize maxs = pView->maximumSize(); 01903 QSize sz = pView->size(); 01904 QWidget* pParent = pView->parentWidget(); 01905 QPoint p(pParent->mapToGlobal(pParent->pos())-pParent->pos()+m_undockPositioningOffset); 01906 pView->reparent(0,0,p); 01907 pView->reparent(0,0,p); 01908 pView->resize(sz); 01909 pView->setMinimumSize(mins.width(),mins.height()); 01910 pView->setMaximumSize(maxs.width(),maxs.height()); 01911 KDockWidget* pDockW = 0L; 01912 // find the oldest ancestor of the current dockwidget that can be undocked 01913 do { 01914 if (pParent->inherits("KDockWidget") || pParent->inherits("KDockWidget_Compat::KDockWidget")) { 01915 pDockW = (KDockWidget*) pParent; 01916 pDockW->undock(); // this destroys the dockwiget cover, too 01917 if (pParent != m_pDockbaseAreaOfDocumentViews) { 01918 pParent->close(); 01919 delete pParent; 01920 } 01921 } 01922 else { 01923 pParent = pParent->parentWidget(); 01924 } 01925 } 01926 while (pParent && !pDockW); 01927 if (centralWidget() == pParent) { 01928 setCentralWidget(0L); // avoid dangling pointer 01929 } 01930 } 01931 m_pTaskBar->switchOn(true); 01932 01933 } 01934 01935 } 01936 01937 QStringList KMdiMainFrm::prepareIdealToTabs(KDockWidget* container) { 01938 KDockContainer* pDW = dynamic_cast<KDockContainer*>(container->getWidget()); 01939 QStringList widgetNames=((KMdiDockContainer*)pDW)->containedWidgets(); 01940 for (QStringList::iterator it=widgetNames.begin();it!=widgetNames.end();++it) { 01941 KDockWidget* dw = (KDockWidget*) manager()->getDockWidgetFromName(*it); 01942 dw->undock(); 01943 dw->setLatestKDockContainer(0); 01944 dw->loseFormerBrotherDockWidget(); 01945 } 01946 return widgetNames; 01947 } 01948 01949 void KMdiMainFrm::idealToolViewsToStandardTabs(QStringList widgetNames,KDockWidget::DockPosition pos,int size) { 01950 Q_UNUSED(size) 01951 01952 KDockWidget *mainDock=getMainDockWidget(); 01953 if (mainDock->parentDockTabGroup()) { 01954 mainDock=static_cast<KDockWidget*>(mainDock->parentDockTabGroup()->parent()); 01955 } 01956 01957 if(widgetNames.count()>0) { 01958 QStringList::iterator it=widgetNames.begin(); 01959 KDockWidget *dwpd=manager()->getDockWidgetFromName(*it); 01960 if (!dwpd) { 01961 kdDebug(760)<<"Fatal error in finishIDEAlMode"<<endl; 01962 return; 01963 } 01964 dwpd->manualDock(mainDock,pos,20); 01965 ++it; 01966 for (;it!=widgetNames.end();++it) { 01967 KDockWidget *tmpdw=manager()->getDockWidgetFromName(*it); 01968 if (!tmpdw) { 01969 kdDebug(760)<<"Fatal error in finishIDEAlMode"<<endl; 01970 return; 01971 } 01972 tmpdw->manualDock(dwpd,KDockWidget::DockCenter,20); 01973 } 01974 01975 #if 0 01976 QWidget *wid=dwpd->parentDockTabGroup(); 01977 if (!wid) wid=dwpd; 01978 wid->setGeometry(0,0,20,20); 01979 /* wid->resize( 01980 ((pos==KDockWidget::DockLeft) || (pos==KDockWidget::DockRight))?size:wid->width(), 01981 ((pos==KDockWidget::DockLeft) || (pos==KDockWidget::DockRight))?wid->height():size); 01982 */ 01983 #endif 01984 } 01985 01986 } 01987 01988 01996 void KMdiMainFrm::setMenuForSDIModeSysButtons( KMenuBar* pMenuBar) 01997 { 01998 if (m_bSDIApplication) // there are no buttons in the menubar in this mode (although the view is always maximized) 01999 return; 02000 02001 m_pMainMenuBar = pMenuBar; 02002 if( m_pMainMenuBar == 0L) 02003 return; // use setMenuForSDIModeSysButtons( 0L) for unsetting the external main menu! 02004 02005 if (!m_pUndock) 02006 m_pUndock = new QToolButton( pMenuBar); 02007 if (!m_pRestore) 02008 m_pRestore = new QToolButton( pMenuBar); 02009 if (!m_pMinimize) 02010 m_pMinimize = new QToolButton( pMenuBar); 02011 if (!m_pClose) 02012 m_pClose = new QToolButton( pMenuBar); 02013 m_pUndock->setAutoRaise(false); 02014 m_pMinimize->setAutoRaise(false); 02015 m_pRestore->setAutoRaise(false); 02016 m_pClose->setAutoRaise(false); 02017 02018 setSysButtonsAtMenuPosition(); 02019 02020 delete m_pUndockButtonPixmap; 02021 delete m_pMinButtonPixmap; 02022 delete m_pRestoreButtonPixmap; 02023 delete m_pCloseButtonPixmap; 02024 // create the decoration pixmaps 02025 if (frameDecorOfAttachedViews() == KMdi::Win95Look) { 02026 m_pUndockButtonPixmap = new QPixmap( win_undockbutton); 02027 m_pMinButtonPixmap = new QPixmap( win_minbutton); 02028 m_pRestoreButtonPixmap = new QPixmap( win_restorebutton); 02029 m_pCloseButtonPixmap = new QPixmap( win_closebutton); 02030 } 02031 else if (frameDecorOfAttachedViews() == KMdi::KDE1Look) { 02032 m_pUndockButtonPixmap = new QPixmap( kde_undockbutton); 02033 m_pMinButtonPixmap = new QPixmap( kde_minbutton); 02034 m_pRestoreButtonPixmap = new QPixmap( kde_restorebutton); 02035 m_pCloseButtonPixmap = new QPixmap( kde_closebutton); 02036 m_pUndock->setAutoRaise(true); 02037 m_pMinimize->setAutoRaise(true); 02038 m_pRestore->setAutoRaise(true); 02039 m_pClose->setAutoRaise(true); 02040 } 02041 else if (frameDecorOfAttachedViews() == KMdi::KDELook) { 02042 m_pUndockButtonPixmap = new QPixmap( kde2_undockbutton); 02043 m_pMinButtonPixmap = new QPixmap( kde2_minbutton); 02044 m_pRestoreButtonPixmap = new QPixmap( kde2_restorebutton); 02045 m_pCloseButtonPixmap = new QPixmap( kde2_closebutton); 02046 } 02047 else { // kde2laptop look 02048 m_pUndockButtonPixmap = new QPixmap( kde2laptop_undockbutton); 02049 m_pMinButtonPixmap = new QPixmap( kde2laptop_minbutton); 02050 m_pRestoreButtonPixmap = new QPixmap( kde2laptop_restorebutton); 02051 m_pCloseButtonPixmap = new QPixmap( kde2laptop_closebutton); 02052 } 02053 02054 m_pUndock->hide(); 02055 m_pMinimize->hide(); 02056 m_pRestore->hide(); 02057 m_pClose->hide(); 02058 02059 m_pUndock->setPixmap( *m_pUndockButtonPixmap); 02060 m_pMinimize->setPixmap( *m_pMinButtonPixmap); 02061 m_pRestore->setPixmap( *m_pRestoreButtonPixmap); 02062 m_pClose->setPixmap( *m_pCloseButtonPixmap); 02063 } 02064 02065 void KMdiMainFrm::setSysButtonsAtMenuPosition() 02066 { 02067 if( m_pMainMenuBar == 0L) 02068 return; 02069 if( m_pMainMenuBar->parentWidget() == 0L) 02070 return; 02071 02072 int menuW = m_pMainMenuBar->parentWidget()->width(); 02073 int h; 02074 int y; 02075 if (frameDecorOfAttachedViews() == KMdi::Win95Look) 02076 h = 16; 02077 else if (frameDecorOfAttachedViews() == KMdi::KDE1Look) 02078 h = 20; 02079 else if (frameDecorOfAttachedViews() == KMdi::KDELook) 02080 h = 16; 02081 else 02082 h = 14; 02083 y = m_pMainMenuBar->height()/2 - h/2; 02084 02085 if (frameDecorOfAttachedViews() == KMdi::KDELaptopLook) { 02086 int w = 27; 02087 m_pUndock->setGeometry( ( menuW - ( w * 3) - 5), y, w, h); 02088 m_pMinimize->setGeometry( ( menuW - ( w * 2) - 5), y, w, h); 02089 m_pRestore->setGeometry( ( menuW - w - 5), y, w, h); 02090 } 02091 else { 02092 m_pUndock->setGeometry( ( menuW - ( h * 4) - 5), y, h, h); 02093 m_pMinimize->setGeometry( ( menuW - ( h * 3) - 5), y, h, h); 02094 m_pRestore->setGeometry( ( menuW - ( h * 2) - 5), y, h, h); 02095 m_pClose->setGeometry( ( menuW - h - 5), y, h, h); 02096 } 02097 } 02098 02100 void KMdiMainFrm::activateNextWin() 02101 { 02102 KMdiIterator<KMdiChildView*>* it = createIterator(); 02103 KMdiChildView* aWin = activeWindow(); 02104 for (it->first(); !it->isDone(); it->next()) { 02105 if (it->currentItem() == aWin) { 02106 it->next(); 02107 if (!it->currentItem()) { 02108 it->first(); 02109 } 02110 if (it->currentItem()) { 02111 activateView(it->currentItem()); 02112 } 02113 break; 02114 } 02115 } 02116 delete it; 02117 } 02118 02120 void KMdiMainFrm::activatePrevWin() 02121 { 02122 KMdiIterator<KMdiChildView*>* it = createIterator(); 02123 KMdiChildView* aWin = activeWindow(); 02124 for (it->first(); !it->isDone(); it->next()) { 02125 if (it->currentItem() == aWin) { 02126 it->prev(); 02127 if (!it->currentItem()) { 02128 it->last(); 02129 } 02130 if (it->currentItem()) { 02131 activateView(it->currentItem()); 02132 } 02133 break; 02134 } 02135 } 02136 delete it; 02137 } 02138 02140 void KMdiMainFrm::activateFirstWin() 02141 { 02142 KMdiIterator<KMdiChildView*>* it = createIterator(); 02143 QMap<QDateTime,KMdiChildView*> m; 02144 for (it->first(); !it->isDone(); it->next()) { 02145 m.insert(it->currentItem()->getTimeStamp(), it->currentItem()); 02146 } 02147 02148 if ( !activeWindow() ) return; 02149 02150 QDateTime current = activeWindow()->getTimeStamp(); 02151 QMap<QDateTime,KMdiChildView*>::iterator pos(m.find(current)); 02152 QMap<QDateTime,KMdiChildView*>::iterator newPos = pos; 02153 if (pos != m.end()) { 02154 ++newPos; 02155 } 02156 if (newPos != m.end()) { // look ahead 02157 ++pos; 02158 } 02159 else { 02160 pos = m.begin(); 02161 } 02162 activateView(pos.data()); 02163 m_bSwitching= true; // flag that we are currently switching between windows 02164 delete it; 02165 } 02166 02168 void KMdiMainFrm::activateLastWin() 02169 { 02170 KMdiIterator<KMdiChildView*>* it = createIterator(); 02171 QMap<QDateTime,KMdiChildView*> m; 02172 for (it->first(); !it->isDone(); it->next()) { 02173 m.insert(it->currentItem()->getTimeStamp(), it->currentItem()); 02174 } 02175 02176 if ( !activeWindow() ) return; 02177 02178 QDateTime current = activeWindow()->getTimeStamp(); 02179 QMap<QDateTime,KMdiChildView*>::iterator pos(m.find(current)); 02180 if (pos != m.begin()) { 02181 --pos; 02182 } 02183 else { 02184 pos = m.end(); 02185 --pos; 02186 } 02187 activateView(pos.data()); 02188 m_bSwitching= true; // flag that we are currently switching between windows 02189 delete it; 02190 } 02191 02193 void KMdiMainFrm::activateView(int index) 02194 { 02195 KMdiChildView* pView = m_pDocumentViews->first(); 02196 for (int i = 0; pView && (i < index); i++) { 02197 pView = m_pDocumentViews->next(); 02198 } 02199 if (pView) { 02200 pView->activate(); 02201 } 02202 } 02203 02205 void KMdiMainFrm::setEnableMaximizedChildFrmMode(bool bEnable) 02206 { 02207 if (bEnable) { 02208 m_bMaximizedChildFrmMode = true; 02209 //qDebug("MaximizeMode on"); 02210 02211 KMdiChildFrm* pCurrentChild = m_pMdi->topChild(); 02212 if( !pCurrentChild) 02213 return; 02214 02215 // if there is no menubar given, those system buttons aren't possible 02216 if( m_pMainMenuBar == 0L) 02217 return; 02218 02219 QObject::connect( m_pUndock, SIGNAL(clicked()), pCurrentChild, SLOT(undockPressed()) ); 02220 m_pUndock->show(); 02221 QObject::connect( m_pMinimize, SIGNAL(clicked()), pCurrentChild, SLOT(minimizePressed()) ); 02222 m_pMinimize->show(); 02223 QObject::connect( m_pRestore, SIGNAL(clicked()), pCurrentChild, SLOT(maximizePressed()) ); 02224 m_pRestore->show(); 02225 02226 if (frameDecorOfAttachedViews() == KMdi::KDELaptopLook) { 02227 m_pMainMenuBar->insertItem( QPixmap(kde2laptop_closebutton_menu), m_pMdi->topChild(), SLOT(closePressed()), 0, -1, 0); 02228 } 02229 else { 02230 m_pMainMenuBar->insertItem( *pCurrentChild->icon(), pCurrentChild->systemMenu(), -1, 0); 02231 assert(m_pClose); 02232 QObject::connect( m_pClose, SIGNAL(clicked()), pCurrentChild, SLOT(closePressed()) ); 02233 m_pClose->show(); 02234 } 02235 } 02236 else { 02237 if (!m_bMaximizedChildFrmMode) return; // already set, nothing to do 02238 02239 m_bMaximizedChildFrmMode = false; 02240 //qDebug("MaximizeMode off"); 02241 02242 KMdiChildFrm* pFrmChild = m_pMdi->topChild(); 02243 if (!pFrmChild) return; 02244 02245 if (pFrmChild->m_pClient && pFrmChild->state() == KMdiChildFrm::Maximized) { 02246 pFrmChild->m_pClient->restore(); 02247 switchOffMaximizeModeForMenu( pFrmChild); 02248 } 02249 } 02250 } 02251 02253 void KMdiMainFrm::switchOffMaximizeModeForMenu(KMdiChildFrm* oldChild) 02254 { 02255 //qDebug("switching off maximize mode for menu"); 02256 02257 // if there is no menubar given, those system buttons aren't possible 02258 if( m_pMainMenuBar == 0L) 02259 return; 02260 02261 m_pMainMenuBar->removeItem( m_pMainMenuBar->idAt(0)); 02262 02263 if( oldChild) { 02264 assert(m_pClose); 02265 QObject::disconnect( m_pUndock, SIGNAL(clicked()), oldChild, SLOT(undockPressed()) ); 02266 QObject::disconnect( m_pMinimize, SIGNAL(clicked()), oldChild, SLOT(minimizePressed()) ); 02267 QObject::disconnect( m_pRestore, SIGNAL(clicked()), oldChild, SLOT(maximizePressed()) ); 02268 QObject::disconnect( m_pClose, SIGNAL(clicked()), oldChild, SLOT(closePressed()) ); 02269 } 02270 m_pUndock->hide(); 02271 m_pMinimize->hide(); 02272 m_pRestore->hide(); 02273 m_pClose->hide(); 02274 } 02275 02277 void KMdiMainFrm::updateSysButtonConnections( KMdiChildFrm* oldChild, KMdiChildFrm* newChild) 02278 { 02279 //qDebug("updateSysButtonConnections"); 02280 // if there is no menubar given, those system buttons aren't possible 02281 if( m_pMainMenuBar == 0L) 02282 return; 02283 02284 if (newChild) { 02285 if (frameDecorOfAttachedViews() == KMdi::KDELaptopLook) { 02286 m_pMainMenuBar->insertItem( QPixmap(kde2laptop_closebutton_menu), newChild, SLOT(closePressed()), 0, -1, 0); 02287 } 02288 else { 02289 m_pMainMenuBar->insertItem( *newChild->icon(), newChild->systemMenu(), -1, 0); 02290 } 02291 } 02292 if (oldChild) { 02293 m_pMainMenuBar->removeItem( m_pMainMenuBar->idAt(1)); 02294 } 02295 if (oldChild) { 02296 assert(m_pClose); 02297 QObject::disconnect( m_pUndock, SIGNAL(clicked()), oldChild, SLOT(undockPressed()) ); 02298 QObject::disconnect( m_pMinimize, SIGNAL(clicked()), oldChild, SLOT(minimizePressed()) ); 02299 QObject::disconnect( m_pRestore, SIGNAL(clicked()), oldChild, SLOT(maximizePressed()) ); 02300 QObject::disconnect( m_pClose, SIGNAL(clicked()), oldChild, SLOT(closePressed()) ); 02301 } 02302 if (newChild) { 02303 assert(m_pClose); 02304 QObject::connect( m_pUndock, SIGNAL(clicked()), newChild, SLOT(undockPressed()) ); 02305 QObject::connect( m_pMinimize, SIGNAL(clicked()), newChild, SLOT(minimizePressed()) ); 02306 QObject::connect( m_pRestore, SIGNAL(clicked()), newChild, SLOT(maximizePressed()) ); 02307 QObject::connect( m_pClose, SIGNAL(clicked()), newChild, SLOT(closePressed()) ); 02308 } 02309 } 02310 02312 bool KMdiMainFrm::isViewTaskBarOn() 02313 { 02314 bool bOn = false; 02315 if (m_pTaskBar) 02316 bOn = m_pTaskBar->isSwitchedOn(); 02317 return bOn; 02318 } 02319 02321 void KMdiMainFrm::showViewTaskBar() 02322 { 02323 if (m_pTaskBar) 02324 m_pTaskBar->switchOn(true); 02325 } 02326 02328 void KMdiMainFrm::hideViewTaskBar() 02329 { 02330 if (m_pTaskBar) 02331 m_pTaskBar->switchOn(false); 02332 } 02333 02334 //=============== fillWindowMenu ===============// 02335 void KMdiMainFrm::fillWindowMenu() 02336 { 02337 bool bTabPageMode = false; 02338 if (m_mdiMode == KMdi::TabPageMode) 02339 bTabPageMode = true; 02340 bool bIDEAlMode = FALSE; 02341 if (m_mdiMode == KMdi::IDEAlMode) 02342 bIDEAlMode = TRUE; 02343 02344 bool bNoViewOpened = false; 02345 if (m_pDocumentViews->isEmpty()) { 02346 bNoViewOpened = true; 02347 } 02348 // construct the menu and its submenus 02349 if (!m_bClearingOfWindowMenuBlocked) { 02350 m_pWindowMenu->clear(); 02351 } 02352 int closeId = m_pWindowMenu->insertItem(i18n("&Close"), this, SLOT(closeActiveView())); 02353 int closeAllId = m_pWindowMenu->insertItem(i18n("Close &All"), this, SLOT(closeAllViews())); 02354 if (bNoViewOpened) { 02355 m_pWindowMenu->setItemEnabled(closeId, false); 02356 m_pWindowMenu->setItemEnabled(closeAllId, false); 02357 } 02358 if (!bTabPageMode && !bIDEAlMode) { 02359 int iconifyId = m_pWindowMenu->insertItem(i18n("&Minimize All"), this, SLOT(iconifyAllViews())); 02360 if (bNoViewOpened) { 02361 m_pWindowMenu->setItemEnabled(iconifyId, false); 02362 } 02363 } 02364 m_pWindowMenu->insertSeparator(); 02365 m_pWindowMenu->insertItem(i18n("&MDI Mode"), m_pMdiModeMenu); 02366 m_pMdiModeMenu->clear(); 02367 m_pMdiModeMenu->insertItem(i18n("&Toplevel Mode"), this, SLOT(switchToToplevelMode())); 02368 m_pMdiModeMenu->insertItem(i18n("C&hildframe Mode"), this, SLOT(switchToChildframeMode())); 02369 m_pMdiModeMenu->insertItem(i18n("Ta&b Page Mode"), this, SLOT(switchToTabPageMode())); 02370 m_pMdiModeMenu->insertItem(i18n("I&DEAl Mode"), this, SLOT(switchToIDEAlMode())); 02371 switch (m_mdiMode) { 02372 case KMdi::ToplevelMode: 02373 m_pMdiModeMenu->setItemChecked(m_pMdiModeMenu->idAt(0), true); 02374 break; 02375 case KMdi::ChildframeMode: 02376 m_pMdiModeMenu->setItemChecked(m_pMdiModeMenu->idAt(1), true); 02377 break; 02378 case KMdi::TabPageMode: 02379 m_pMdiModeMenu->setItemChecked(m_pMdiModeMenu->idAt(2), true); 02380 break; 02381 case KMdi::IDEAlMode: 02382 m_pMdiModeMenu->setItemChecked(m_pMdiModeMenu->idAt(3),true); 02383 break; 02384 default: 02385 break; 02386 } 02387 m_pWindowMenu->insertSeparator(); 02388 if (!bTabPageMode && !bIDEAlMode) { 02389 int placMenuId = m_pWindowMenu->insertItem(i18n("&Tile..."), m_pPlacingMenu); 02390 m_pPlacingMenu->clear(); 02391 m_pPlacingMenu->insertItem(i18n("Ca&scade Windows"), m_pMdi,SLOT(cascadeWindows())); 02392 m_pPlacingMenu->insertItem(i18n("Cascade &Maximized"), m_pMdi,SLOT(cascadeMaximized())); 02393 m_pPlacingMenu->insertItem(i18n("Expand &Vertically"), m_pMdi,SLOT(expandVertical())); 02394 m_pPlacingMenu->insertItem(i18n("Expand &Horizontally"), m_pMdi,SLOT(expandHorizontal())); 02395 m_pPlacingMenu->insertItem(i18n("Tile &Non-overlapped"), m_pMdi,SLOT(tileAnodine())); 02396 m_pPlacingMenu->insertItem(i18n("Tile Overla&pped"), m_pMdi,SLOT(tilePragma())); 02397 m_pPlacingMenu->insertItem(i18n("Tile V&ertically"), m_pMdi,SLOT(tileVertically())); 02398 if (m_mdiMode == KMdi::ToplevelMode) { 02399 m_pWindowMenu->setItemEnabled(placMenuId, false); 02400 } 02401 m_pWindowMenu->insertSeparator(); 02402 int dockUndockId = m_pWindowMenu->insertItem(i18n("&Dock/Undock..."), m_pDockMenu); 02403 m_pDockMenu->clear(); 02404 m_pWindowMenu->insertSeparator(); 02405 if (bNoViewOpened) { 02406 m_pWindowMenu->setItemEnabled(placMenuId, false); 02407 m_pWindowMenu->setItemEnabled(dockUndockId, false); 02408 } 02409 } 02410 int entryCount = m_pWindowMenu->count(); 02411 02412 // for all child frame windows: give an ID to every window and connect them in the end with windowMenuItemActivated() 02413 int i=100; 02414 KMdiChildView* pView = 0L; 02415 QPtrListIterator<KMdiChildView> it(*m_pDocumentViews); 02416 QValueList<QDateTime> timeStamps; 02417 for (; it.current(); ++it) { 02418 pView = it.current(); 02419 QDateTime timeStamp( pView->getTimeStamp() ); 02420 02421 if (pView->isToolView()) { 02422 continue; 02423 } 02424 02425 QString item; 02426 // set titles of minimized windows in brackets 02427 if (pView->isMinimized()) { 02428 item += "("; 02429 item += pView->caption(); 02430 item += ")"; 02431 } 02432 else { 02433 item += " "; 02434 item += pView->caption(); 02435 } 02436 02437 // insert the window entry sorted by access time 02438 unsigned int indx; 02439 unsigned int windowItemCount = m_pWindowMenu->count() - entryCount; 02440 bool inserted = false; 02441 QString tmpString; 02442 QValueList<QDateTime>::iterator timeStampIterator = timeStamps.begin(); 02443 for (indx = 0; indx <= windowItemCount; indx++, ++timeStampIterator) { 02444 bool putHere = false; 02445 if ((*timeStampIterator) < timeStamp) { 02446 putHere = true; 02447 timeStamps.insert(timeStampIterator, timeStamp); 02448 } 02449 if (putHere) { 02450 m_pWindowMenu->insertItem( item, pView, SLOT(slot_clickedInWindowMenu()), 0, -1, indx+entryCount); 02451 if (pView == m_pCurrentWindow) { 02452 m_pWindowMenu->setItemChecked( m_pWindowMenu->idAt( indx+entryCount), true); 02453 } 02454 pView->setWindowMenuID(i); 02455 if (!bTabPageMode) { 02456 m_pDockMenu->insertItem( item, pView, SLOT(slot_clickedInDockMenu()), 0, -1, indx); 02457 if (pView->isAttached()) { 02458 m_pDockMenu->setItemChecked( m_pDockMenu->idAt( indx), true); 02459 } 02460 } 02461 inserted = true; 02462 break; 02463 indx = windowItemCount+1; // break the loop 02464 } 02465 } 02466 if (!inserted) { // append it 02467 m_pWindowMenu->insertItem( item, pView, SLOT(slot_clickedInWindowMenu()), 0, -1, windowItemCount+entryCount); 02468 if (pView == m_pCurrentWindow) { 02469 m_pWindowMenu->setItemChecked( m_pWindowMenu->idAt(windowItemCount+entryCount), true); 02470 } 02471 pView->setWindowMenuID( i); 02472 if (!bTabPageMode) { 02473 m_pDockMenu->insertItem( item, pView, SLOT(slot_clickedInDockMenu()), 0, -1, windowItemCount); 02474 if (pView->isAttached()) { 02475 m_pDockMenu->setItemChecked( m_pDockMenu->idAt(windowItemCount), true); 02476 } 02477 } 02478 } 02479 i++; 02480 } 02481 } 02482 02483 //================ windowMenuItemActivated ===============// 02484 02485 void KMdiMainFrm::windowMenuItemActivated(int id) 02486 { 02487 if (id < 100) return; 02488 id -= 100; 02489 KMdiChildView *pView = m_pDocumentViews->at( id); 02490 if (!pView) return; 02491 if (pView->isMinimized()) pView->minimize(); 02492 if (m_mdiMode != KMdi::TabPageMode) { 02493 KMdiChildFrm* pTopChild = m_pMdi->topChild(); 02494 if (pTopChild) { 02495 if ((pView == pTopChild->m_pClient) && pView->isAttached()) { 02496 return; 02497 } 02498 } 02499 } 02500 activateView( pView); 02501 } 02502 02503 //================ dockMenuItemActivated ===============// 02504 02505 void KMdiMainFrm::dockMenuItemActivated(int id) 02506 { 02507 if( id < 100) return; 02508 id -= 100; 02509 KMdiChildView *pView = m_pDocumentViews->at( id); 02510 if( !pView) return; 02511 if( pView->isMinimized()) pView->minimize(); 02512 if( pView->isAttached()) { 02513 detachWindow( pView, true); 02514 } 02515 else { // is detached 02516 attachWindow( pView, true); 02517 } 02518 } 02519 02520 //================ popupWindowMenu ===============// 02521 02522 void KMdiMainFrm::popupWindowMenu(QPoint p) 02523 { 02524 if (!isFakingSDIApplication()) { 02525 m_pWindowMenu->popup( p); 02526 } 02527 } 02528 02529 //================ dragEndTimeOut ===============// 02530 void KMdiMainFrm::dragEndTimeOut() 02531 { 02532 // send drag end to all concerned views. 02533 KMdiChildView* pView; 02534 for (m_pDocumentViews->first(); (pView = m_pDocumentViews->current()) != 0L; m_pDocumentViews->next()) { 02535 KMdiChildFrmDragEndEvent dragEndEvent(0L); 02536 QApplication::sendEvent(pView, &dragEndEvent); 02537 } 02538 } 02539 02540 //================ setFrameDecorOfAttachedViews ===============// 02541 02542 void KMdiMainFrm::setFrameDecorOfAttachedViews( int frameDecor) 02543 { 02544 switch (frameDecor) { 02545 case 0: 02546 m_frameDecoration = KMdi::Win95Look; 02547 break; 02548 case 1: 02549 m_frameDecoration = KMdi::KDE1Look; 02550 break; 02551 case 2: 02552 m_frameDecoration = KMdi::KDELook; 02553 break; 02554 case 3: 02555 m_frameDecoration = KMdi::KDELaptopLook; 02556 break; 02557 default: 02558 qDebug("unknown MDI decoration"); 02559 break; 02560 } 02561 setMenuForSDIModeSysButtons( m_pMainMenuBar); 02562 QPtrListIterator<KMdiChildView> it( *m_pDocumentViews); 02563 for( ; it.current(); ++it) { 02564 KMdiChildView* pView = it.current(); 02565 if( pView->isToolView()) 02566 continue; 02567 if( pView->isAttached()) 02568 pView->mdiParent()->redecorateButtons(); 02569 } 02570 } 02571 02572 void KMdiMainFrm::fakeSDIApplication() 02573 { 02574 m_bSDIApplication = true; 02575 if (m_pTaskBar) 02576 m_pTaskBar->close(); 02577 m_pTaskBar = 0L; 02578 } 02579 02580 void KMdiMainFrm::closeViewButtonPressed() 02581 { 02582 KMdiChildView* pView = activeWindow(); 02583 if (pView) { 02584 pView->close(); 02585 } 02586 } 02587 02588 void KMdiMainFrm::setManagedDockPositionModeEnabled(bool enabled) 02589 { 02590 m_managedDockPositionMode=enabled; 02591 } 02592 02593 void KMdiMainFrm::setActiveToolDock(KMdiDockContainer* td) { 02594 if (td==d->activeDockPriority[0]) return; 02595 if (d->activeDockPriority[0]==0) { 02596 d->activeDockPriority[0]=td; 02597 // d->focusList=new KMdiFocusList(this); 02598 // if (m_pMdi) d->focusList->addWidgetTree(m_pMdi); 02599 // if (m_documentTabWidget) d->focusList->addWidgetTree(m_documentTabWidget); 02600 return; 02601 } 02602 for (int dst=3,src=2;src>=0;dst--,src--) { 02603 if (d->activeDockPriority[src]==td) src--; 02604 if (src<0) break; 02605 d->activeDockPriority[dst]=d->activeDockPriority[src]; 02606 } 02607 d->activeDockPriority[0]=td; 02608 } 02609 02610 void KMdiMainFrm::removeFromActiveDockList(KMdiDockContainer* td) { 02611 for (int i=0;i<4;i++) { 02612 if (d->activeDockPriority[i]==td) { 02613 for (;i<3;i++) 02614 d->activeDockPriority[i]=d->activeDockPriority[i+1]; 02615 d->activeDockPriority[3]=0; 02616 break; 02617 } 02618 } 02619 /* 02620 if (d->activeDockPriority[0]==0) { 02621 if (d->focusList) d->focusList->restore(); 02622 delete d->focusList; 02623 d->focusList=0; 02624 } 02625 */ 02626 } 02627 02628 void KMdiMainFrm::prevToolViewInDock() { 02629 KMdiDockContainer* td=d->activeDockPriority[0]; 02630 if (!td) return; 02631 td->prevToolView(); 02632 } 02633 02634 void KMdiMainFrm::nextToolViewInDock() { 02635 KMdiDockContainer* td=d->activeDockPriority[0]; 02636 if (!td) return; 02637 td->nextToolView(); 02638 } 02639 02640 KMdi::TabWidgetVisibility KMdiMainFrm::tabWidgetVisibility() 02641 { 02642 if ( m_documentTabWidget ) 02643 return m_documentTabWidget->tabWidgetVisibility(); 02644 02645 return KMdi::NeverShowTabs; 02646 } 02647 02648 void KMdiMainFrm::setTabWidgetVisibility( KMdi::TabWidgetVisibility visibility ) 02649 { 02650 if ( m_documentTabWidget ) 02651 m_documentTabWidget->setTabWidgetVisibility( visibility ); 02652 } 02653 02654 KTabWidget * KMdiMainFrm::tabWidget() const 02655 { 02656 return m_documentTabWidget; 02657 } 02658 02659 #include "kmdimainfrm.moc" 02660 02661 // vim: ts=2 sw=2 et 02662 // kate: space-indent on; indent-width 2; replace-tabs on;
KDE Logo
This file is part of the documentation for kmdi Library Version 3.3.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Sep 29 09:42:03 2004 by doxygen 1.3.8 written by Dimitri van Heesch, © 1997-2003