kmdi Library API Documentation

kmdimainfrm.cpp

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