kmdi Library API Documentation

kmdimainfrm.cpp

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