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