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