kmdimainfrm.cpp

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