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