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 #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>
00099 #include <X11/Xlib.h>
00100 #endif
00101
00102 #ifdef KeyRelease
00103
00104 #undef KeyRelease
00105 #endif
00106
00107 #ifdef KeyPress
00108
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
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
00182 m_pDocumentViews = new QPtrList<KMdiChildView>;
00183 m_pDocumentViews->setAutoDelete( false );
00184 m_pToolViews = new QMap<QWidget*, KMdiToolViewAccessor*>;
00185
00186
00187 setFocusPolicy( ClickFocus );
00188
00189
00190 createMdiManager();
00191
00192
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
00199 setView( m_pDockbaseAreaOfDocumentViews );
00200 setMainDockWidget( m_pDockbaseAreaOfDocumentViews );
00201
00202
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
00224 createTaskBar();
00225
00226
00227
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
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
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
00295 KMdiMainFrm::~KMdiMainFrm()
00296 {
00297
00298 QValueList<KMdiChildView*> children;
00299 for ( KMdiChildView * w = m_pDocumentViews->first();w;w = m_pDocumentViews->next() )
00300 children.append( w );
00301
00302
00303 QValueListIterator<KMdiChildView*> childIt;
00304 for ( childIt = children.begin(); childIt != children.end(); ++childIt )
00305 {
00306 closeWindow( *childIt, false );
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
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
00335
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
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
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
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
00415
00416 KMdiChildView* KMdiMainFrm::createWrapper( QWidget *view, const QString& name, const QString& shortName )
00417 {
00418 Q_ASSERT( view );
00419
00420 KMdiChildView* pMDICover = new KMdiChildView( name , 0L ,
00421 name.latin1() );
00422 QBoxLayout* pLayout = new QHBoxLayout( pMDICover, 0, -1, "layout" );
00423 view->reparent( pMDICover, QPoint( 0, 0 ) );
00424 pLayout->addWidget( view );
00425
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
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 ) )
00447 return;
00448
00449 if ( flags & KMdi::ToolWindow )
00450 {
00451 addToolWindow( pWnd );
00452
00453 pWnd->move( m_pMdi->mapToGlobal( m_pMdi->getCascadePoint() ) );
00454
00455 return ;
00456 }
00457
00458 d->closeWindowAction->setEnabled(true);
00459
00460
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
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 );
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
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
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
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
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 );
00594 }
00595 else
00596 mtva->place( pos, pTargetWnd, percent );
00597
00598
00599 return mtva;
00600 }
00601
00602
00603 void KMdiMainFrm::attachWindow( KMdiChildView *pWnd, bool bShow, bool bAutomaticResize )
00604 {
00605 pWnd->installEventFilter( this );
00606
00607
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
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;
00659 }
00660
00661
00662 void KMdiMainFrm::detachWindow( KMdiChildView *pWnd, bool bShow )
00663 {
00664 if ( pWnd->isAttached() )
00665 {
00666 pWnd->removeEventFilter( this );
00667 pWnd->youAreDetached();
00668
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 );
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
00719 if ( bShow )
00720 {
00721 activateView( pWnd );
00722 }
00723
00724 emit childViewIsDetachedNow( pWnd );
00725 }
00726
00727
00728 void KMdiMainFrm::removeWindowFromMdi( KMdiChildView *pWnd )
00729 {
00730 Q_UNUSED( pWnd );
00731
00732
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 );
00786 }
00787 }
00788 delete pDockW;
00789 if ( m_pWinList->count() == 1 )
00790 {
00791 m_pWinList->last() ->activate();
00792 }
00793 }
00794 else if ( pWnd->isAttached() )
00795 {
00796 pWnd->mdiParent() ->hide();
00797 m_pMdi->destroyChildButNotItsView( pWnd->mdiParent() );
00798 }
00799 else
00800 {
00801
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
00815
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
00828 void KMdiMainFrm::closeWindow( KMdiChildView *pWnd, bool layoutTaskBar )
00829 {
00830 if ( !pWnd )
00831 return ;
00832
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 ;
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();
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 );
00888 }
00889 }
00890 delete pDockW;
00891 #endif
00892
00893 delete pWnd;
00894 if ( m_pDocumentViews->count() == 1 )
00895 {
00896 m_pDocumentViews->last() ->activate();
00897 }
00898 }
00899 else if ( pWnd->isAttached() )
00900 {
00901 m_pMdi->destroyChild( pWnd->mdiParent() );
00902 }
00903 else
00904 {
00905 delete pWnd;
00906
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
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
00952 KMdiChildView* KMdiMainFrm::activeWindow()
00953 {
00954 return m_pCurrentWindow;
00955 }
00956
00957
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
00986 QPopupMenu* KMdiMainFrm::taskBarPopup( KMdiChildView *pWnd, bool )
00987 {
00988
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
01006 m_pTaskBarPopup->insertSeparator();
01007 m_pTaskBarPopup->insertItem( i18n( "Operations" ), windowPopup( pWnd, false ) );
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 );
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
01067
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 );
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 );
01109
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
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141 }
01142 else if ( isVisible() && e->type() == QEvent::Move )
01143 {
01144 if ( m_pDragEndTimer->isActive() )
01145 {
01146
01147 m_pDragEndTimer->stop();
01148 }
01149 else
01150 {
01151
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 );
01160 }
01161
01162 return DockMainWindow::event( e );
01163 }
01164
01165 bool KMdiMainFrm::eventFilter( QObject * , QEvent *e )
01166 {
01167 if ( e->type() == QEvent::Resize && m_mdiMode == KMdi::ToplevelMode )
01168 {
01169 verifyToplevelHeight();
01170 return false;
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;
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;
01230 }
01231
01235 void KMdiMainFrm::closeAllViews()
01236 {
01237
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
01276 if ( !rootDockWidgetList && !positionList )
01277 return ;
01278
01279
01280 const int frameBorderWidth = 7;
01281 const int windowTitleHeight = 10;
01282
01283 QObjectList* pObjList = queryList( "KDockWidget" );
01284 if ( pObjList->isEmpty() )
01285 pObjList = queryList( "KDockWidget_Compat::KDockWidget" );
01286
01287 QObjectListIt it( *pObjList );
01288
01289 while ( ( *it ) )
01290 {
01291 KDockWidget* dockWindow = 0L;
01292 KDockWidget* rootDockWindow = 0L;
01293 KDockWidget* undockCandidate = 0L;
01294 QWidget* pW = static_cast<QWidget*>( ( *it ) );
01295
01296
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
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;
01354 setUndockPositioningOffset( QPoint( 0, ( m_pTaskBar ? m_pTaskBar->height() : 0 ) + frameBorderWidth ) );
01355
01356
01357 QPtrList<KDockWidget> rootDockWidgetList;
01358 QValueList<QRect> positionList;
01359
01360
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;
01375 }
01376
01377
01378 QPtrListIterator<KDockWidget> kdwit( rootDockWidgetList );
01379 for ( ; ( *kdwit ); ++kdwit )
01380 ( *kdwit )->undock();
01381
01382
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
01394 setView( m_pDockbaseAreaOfDocumentViews );
01395 setMainDockWidget( m_pDockbaseAreaOfDocumentViews );
01396 }
01397
01398 if ( !parentWidget() )
01399 {
01400
01401
01402
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
01420
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
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
01470 findRootDockWidgets( &rootDockWidgetList, &positionList );
01471 kdDebug(760) << k_funcinfo << "Found " << rootDockWidgetList.count() << " widgets to undock" << endl;
01472
01473
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
01490 findRootDockWidgets( &rootDockWidgetList, &positionList );
01491 kdDebug(760) << k_funcinfo << "Found " << rootDockWidgetList.count() << " widgets to undock" << endl;
01492
01493
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
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
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 );
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
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
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
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
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 ;
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
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
01670 pView->resize( sz );
01671 pView->setMinimumSize( mins.width(), mins.height() );
01672 pView->setMaximumSize( maxs.width(), maxs.height() );
01673
01674
01675
01676
01677
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
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
01698 emit leftTopLevelMode();
01699 QApplication::sendPostedEvents();
01700
01701
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
01728
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;
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();
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
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 ;
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
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 );
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
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
02090 do
02091 {
02092 if ( pParent->inherits( "KDockWidget" ) || pParent->inherits( "KDockWidget_Compat::KDockWidget" ) )
02093 {
02094 pDockW = ( KDockWidget* ) pParent;
02095 pDockW->undock();
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 );
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
02171
02172
02173
02174 #endif
02175
02176 }
02177
02178 }
02179
02180
02188 void KMdiMainFrm::setMenuForSDIModeSysButtons( KMenuBar* pMenuBar )
02189 {
02190 if ( m_bSDIApplication )
02191 return ;
02192
02193 m_pMainMenuBar = pMenuBar;
02194 if ( m_pMainMenuBar == 0L )
02195 return ;
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
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 {
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;
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 {
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;
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
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 ;
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
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
02502
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
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
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
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
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
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;
02706 }
02707 }
02708 if ( !inserted )
02709 {
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
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
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 {
02773 attachWindow( pView, true );
02774 }
02775 }
02776
02777
02778
02779 void KMdiMainFrm::popupWindowMenu( QPoint p )
02780 {
02781 if ( !isFakingSDIApplication() )
02782 {
02783 m_pWindowMenu->popup( p );
02784 }
02785 }
02786
02787
02788 void KMdiMainFrm::dragEndTimeOut()
02789 {
02790
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
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
02863
02864
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
02892
02893
02894
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
02937