kmdi Library API Documentation

kmdimainfrm.cpp

00001 //---------------------------------------------------------------------------- 00002 // filename : kmdimainfrm.cpp 00003 //---------------------------------------------------------------------------- 00004 // Project : KDE MDI extension 00005 // 00006 // begin : 07/1999 by Szymon Stefanek as part of kvirc 00007 // (an IRC application) 00008 // changes : 09/1999 by Falk Brettschneider to create an 00009 // - 06/2000 stand-alone Qt extension set of 00010 // classes and a Qt-based library 00011 // 2000-2003 maintained by the KDevelop project 00012 // patches : 02/2000 by Massimo Morin (mmorin@schedsys.com) 00013 // */2000 by Lars Beikirch (Lars.Beikirch@gmx.net) 00014 // 01/2003 by Jens Zurheide (jens.zurheide@gmx.de) 00015 // 00016 // copyright : (C) 1999-2003 by Szymon Stefanek (stefanek@tin.it) 00017 // and 00018 // Falk Brettschneider 00019 // email : falkbr@kdevelop.org (Falk Brettschneider) 00020 //---------------------------------------------------------------------------- 00021 // 00022 //---------------------------------------------------------------------------- 00023 // 00024 // This program is free software; you can redistribute it and/or modify 00025 // it under the terms of the GNU Library General Public License as 00026 // published by the Free Software Foundation; either version 2 of the 00027 // License, or (at your option) any later version. 00028 // 00029 //---------------------------------------------------------------------------- 00030 00031 00032 /* 00033 * ATTENTION: please do you part to try to make this file legible. It's 00034 * extremely hard to read already. Especially follow the indenting rules. 00035 */ 00036 #include "config.h" 00037 00038 #include <assert.h> 00039 00040 #include <qcursor.h> 00041 #include <qclipboard.h> 00042 #include <qobjectlist.h> 00043 #include <qpopupmenu.h> 00044 #include <qmenubar.h> 00045 00046 #include <kmenubar.h> 00047 #include <kapplication.h> 00048 #include <kdebug.h> 00049 #include <kdeversion.h> 00050 #include <qtabwidget.h> 00051 #include <klocale.h> 00052 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> // schroder 00098 #include <X11/Xlib.h> // schroder 00099 #endif 00100 00101 #ifdef KeyRelease 00102 /* I hate the defines in the X11 header files. Get rid of one of them */ 00103 #undef KeyRelease 00104 #endif 00105 00106 #ifdef KeyPress 00107 /* I hate the defines in the X11 header files. Get rid of one of them */ 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 //============ constructor ============// 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 // Create the local lists of windows 00181 m_pDocumentViews = new QPtrList<KMdiChildView>; 00182 m_pDocumentViews->setAutoDelete( false ); 00183 m_pToolViews = new QMap<QWidget*, KMdiToolViewAccessor*>; 00184 00185 // This seems to be needed (re-check it after Qt2.0 comed out) 00186 setFocusPolicy( ClickFocus ); 00187 00188 // create the central widget 00189 createMdiManager(); 00190 00191 // cover KMdi's childarea by a dockwidget 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 // set this dock to main view 00198 setView( m_pDockbaseAreaOfDocumentViews ); 00199 setMainDockWidget( m_pDockbaseAreaOfDocumentViews ); 00200 00201 // Apply options for the MDI manager 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 // the MDI view taskbar 00228 createTaskBar(); 00229 00230 // this is only a hack, but prevents us from crash because the buttons are otherwise 00231 // not created before we switch the modes where we need them !!! 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 // drag end timer 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 //kdDebug(760) << k_funcinfo << endl; 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 //============ ~KMdiMainFrm ============// 00299 KMdiMainFrm::~KMdiMainFrm() 00300 { 00301 //save the children first to a list, as removing invalidates our iterator 00302 QValueList<KMdiChildView*> children; 00303 for ( KMdiChildView * w = m_pDocumentViews->first();w;w = m_pDocumentViews->next() ) 00304 children.append( w ); 00305 00306 // safely close the windows so properties are saved... 00307 QValueListIterator<KMdiChildView*> childIt; 00308 for ( childIt = children.begin(); childIt != children.end(); ++childIt ) 00309 { 00310 closeWindow( *childIt, false ); // without re-layout taskbar! 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 //deletes added for Release-Version-Pop-Up-WinMenu-And-Go-Out-Problem 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 //============ applyOptions ============// 00339 //FIXME something wrong with this function. dunno what though 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 //============ createMdiManager ============// 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 //============ createTaskBar ==============// 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 //================ setMinimumSize ===============// 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 //================ wrapper ===============// 00419 00420 KMdiChildView* KMdiMainFrm::createWrapper( QWidget *view, const QString& name, const QString& shortName ) 00421 { 00422 Q_ASSERT( view ); // if this assert fails, then some part didn't return a widget. Fix the part ;) 00423 00424 KMdiChildView* pMDICover = new KMdiChildView( name /*caption*/, 0L /*parent*/, 00425 name.latin1() ); 00426 QBoxLayout* pLayout = new QHBoxLayout( pMDICover, 0, -1, "layout" ); 00427 view->reparent( pMDICover, QPoint( 0, 0 ) ); 00428 pLayout->addWidget( view ); 00429 // pMDICover->setName(name); 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 //================ addWindow ===============// 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 ) ) //already added 00451 return; 00452 00453 if ( flags & KMdi::ToolWindow ) 00454 { 00455 addToolWindow( pWnd ); 00456 // some kind of cascading 00457 pWnd->move( m_pMdi->mapToGlobal( m_pMdi->getCascadePoint() ) ); 00458 00459 return ; 00460 } 00461 00462 d->closeWindowAction->setEnabled(true); 00463 00464 // common connections used when under MDI control 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 // embed the view depending on the current MDI mode 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 ); // fake it because detach won't call it in this case of addWindow-to-MDI 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 //============ addWindow ============// 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 //============ addWindow ============// 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 //============ addWindow ============// 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 // probably readDockConfig already created the widgetContainer, use that 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 ); //pToolView->isVisible()); 00598 } 00599 else //add and dock the toolview as a dockwidget view 00600 mtva->place( pos, pTargetWnd, percent ); 00601 00602 00603 return mtva; 00604 } 00605 00606 //============ attachWindow ============// 00607 void KMdiMainFrm::attachWindow( KMdiChildView *pWnd, bool bShow, bool bAutomaticResize ) 00608 { 00609 pWnd->installEventFilter( this ); 00610 00611 // decide whether window shall be cascaded 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 // create frame and insert child view 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; // required for checking the active item 00663 } 00664 00665 //============= detachWindow ==============// 00666 void KMdiMainFrm::detachWindow( KMdiChildView *pWnd, bool bShow ) 00667 { 00668 if ( pWnd->isAttached() ) 00669 { 00670 pWnd->removeEventFilter( this ); 00671 pWnd->youAreDetached(); 00672 // this is only if it was attached and you want to detach it 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 ); //Do not focus the new top child , we loose focus... 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 // this will show it... 00723 if ( bShow ) 00724 { 00725 activateView( pWnd ); 00726 } 00727 00728 emit childViewIsDetachedNow( pWnd ); 00729 } 00730 00731 //============== removeWindowFromMdi ==============// 00732 void KMdiMainFrm::removeWindowFromMdi( KMdiChildView *pWnd ) 00733 { 00734 Q_UNUSED( pWnd ); 00735 //Closes a child window. sends no close event : simply deletes it 00736 //FIXME something wrong with this, but nobody knows whatcart 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 ); // different to the one deleted next 00790 } 00791 } 00792 delete pDockW; 00793 if ( m_pWinList->count() == 1 ) 00794 { 00795 m_pWinList->last() ->activate(); // all other views are activated by tab switch 00796 } 00797 } 00798 else if ( pWnd->isAttached() ) 00799 { 00800 pWnd->mdiParent() ->hide(); 00801 m_pMdi->destroyChildButNotItsView( pWnd->mdiParent() ); 00802 } 00803 else 00804 { 00805 // is not attached 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 //crash? m_pWinList->last()->activate(); 00819 //crash? m_pWinList->last()->setFocus(); 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 //============== closeWindow ==============// 00832 void KMdiMainFrm::closeWindow( KMdiChildView *pWnd, bool layoutTaskBar ) 00833 { 00834 if ( !pWnd ) 00835 return ; 00836 //Closes a child window. sends no close event : simply deletes it 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 ; //oops 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(); // all other views are activated by tab switch 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 ); // different to the one deleted next 00892 } 00893 } 00894 delete pDockW; 00895 #endif 00896 00897 delete pWnd; 00898 if ( m_pDocumentViews->count() == 1 ) 00899 { 00900 m_pDocumentViews->last() ->activate(); // all other views are activated by tab switch 00901 } 00902 } 00903 else if ( pWnd->isAttached() ) 00904 { 00905 m_pMdi->destroyChild( pWnd->mdiParent() ); 00906 } 00907 else 00908 { 00909 delete pWnd; 00910 // is not attached 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 //================== findWindow =================// 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 //================== activeWindow ===================// 00956 KMdiChildView* KMdiMainFrm::activeWindow() 00957 { 00958 return m_pCurrentWindow; 00959 } 00960 00961 //================== windowExists ? =================// 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 //================ taskBarPopup =================// 00990 QPopupMenu* KMdiMainFrm::taskBarPopup( KMdiChildView *pWnd, bool /*bIncludeWindowPopup*/ ) 00991 { 00992 //returns the g_pTaskBarPopup filled according to the KMdiChildView state 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 // the window has a view...get the window popup 01010 m_pTaskBarPopup->insertSeparator(); 01011 m_pTaskBarPopup->insertItem( i18n( "Operations" ), windowPopup( pWnd, false ) ); //alvoid recursion 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 ); // lose focus in the mainframe window 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 // if this method is called as answer to view->activate(), 01071 // interrupt it because it's not necessary 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 ); // lose focus in the mainframe window 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 ); // set focus 01113 //QApplication::sendPostedEvents(); 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 // A little hack: If MDI child views are moved implicietly by moving 01132 // the main widget they should know this too. Unfortunately there seems to 01133 // be no way to catch the move start / move stop situations for the main 01134 // widget in a clean way. (There is no MouseButtonPress/Release or 01135 // something like that.) Therefore we do the following: When we get the 01136 // "first" move event we start a timer and interprete it as "drag begin". 01137 // If we get the next move event and the timer is running we restart the 01138 // timer and don't do anything else. If the timer elapses (this meens we 01139 // haven't had any move event for a while) we interprete this as "drag 01140 // end". If the moving didn't stop actually, we will later get another 01141 // "drag begin", so we get a drag end too much, but this would be the same 01142 // as if the user would stop moving for a little while. 01143 // Actually we seem to be lucky that the timer does not elapse while we 01144 // are moving -> so we have no obsolete drag end / begin 01145 } 01146 else if ( isVisible() && e->type() == QEvent::Move ) 01147 { 01148 if ( m_pDragEndTimer->isActive() ) 01149 { 01150 // this is not the first move -> stop old timer 01151 m_pDragEndTimer->stop(); 01152 } 01153 else 01154 { 01155 // this is the first move -> send the drag begin to all concerned views 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 ); // single shot after 200 ms 01164 } 01165 01166 return DockMainWindow::event( e ); 01167 } 01168 01169 bool KMdiMainFrm::eventFilter( QObject * /*obj*/, QEvent *e ) 01170 { 01171 if ( e->type() == QEvent::Resize && m_mdiMode == KMdi::ToplevelMode ) 01172 { 01173 verifyToplevelHeight(); 01174 return false; //let the rest of the resize magic do its work 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; // eat the event 01186 } 01187 } 01188 if ( m_pMdi ) 01189 { 01190 static bool focusTCIsPending = false; 01191 if ( !focusTCIsPending && m_mdiMode == KMdi::ChildframeMode ) 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; // standard event processing 01234 } 01235 01239 void KMdiMainFrm::closeAllViews() 01240 { 01241 //save the children first to a list, as removing invalidates our iterator 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 //nothing is valid 01280 if ( !rootDockWidgetList && !positionList ) 01281 return ; 01282 01283 // since we set some windows to toplevel, we must consider the window manager's window frame 01284 const int frameBorderWidth = 7; // @todo: Can we / do we need to ask the window manager? 01285 const int windowTitleHeight = 10; // @todo: -"- 01286 01287 QObjectList* pObjList = queryList( "KDockWidget" ); 01288 if ( pObjList->isEmpty() ) 01289 pObjList = queryList( "KDockWidget_Compat::KDockWidget" ); 01290 01291 QObjectListIt it( *pObjList ); 01292 // for all dockwidgets (which are children of this mainwindow) 01293 while ( ( *it ) ) 01294 { 01295 KDockWidget* dockWindow = 0L; /* pDockW */ 01296 KDockWidget* rootDockWindow = 0L; /* pRootDockWindow */ 01297 KDockWidget* undockCandidate = 0L; /* pUndockCandidate */ 01298 QWidget* pW = static_cast<QWidget*>( ( *it ) ); 01299 01300 // find the oldest ancestor of the current dockwidget that can be undocked 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 // if that oldest ancestor is not already in the list, append it 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; // @todo: Can we / do we need to ask the window manager? 01358 setUndockPositioningOffset( QPoint( 0, ( m_pTaskBar ? m_pTaskBar->height() : 0 ) + frameBorderWidth ) ); 01359 01360 // 1.) select the dockwidgets to be undocked and store their geometry 01361 QPtrList<KDockWidget> rootDockWidgetList; 01362 QValueList<QRect> positionList; 01363 01364 // 2.) undock the MDI views of KMDI 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; //do nothing 01379 } 01380 01381 // 3.) undock all these found oldest ancestors (being KDockWidgets) 01382 QPtrListIterator<KDockWidget> kdwit( rootDockWidgetList ); 01383 for ( ; ( *kdwit ); ++kdwit ) 01384 ( *kdwit )->undock(); 01385 01386 // 4.) recreate the MDI childframe area and hide it 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 // set this dock to main view 01398 setView( m_pDockbaseAreaOfDocumentViews ); 01399 setMainDockWidget( m_pDockbaseAreaOfDocumentViews ); 01400 } 01401 // QApplication::sendPostedEvents(); //why do we need to empty the event queue? 01402 if ( !parentWidget() ) 01403 { 01404 //if we don't have a parent widget ( which i expect we wouldn't ) 01405 //make sure we take into account the size of the docks provided by 01406 //QMainWindow 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 //FIXME although i don't know what to fix 01424 // 5. show the child views again 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 // 6.) reset all memorized positions of the undocked ones and show them again 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 // select the dockwidgets to be undocked and store their geometry 01474 findRootDockWidgets( &rootDockWidgetList, &positionList ); 01475 kdDebug(760) << k_funcinfo << "Found " << rootDockWidgetList.count() << " widgets to undock" << endl; 01476 01477 // undock all these found oldest ancestors (being KDockWidgets) 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 // select the dockwidgets to be undocked and store their geometry 01494 findRootDockWidgets( &rootDockWidgetList, &positionList ); 01495 kdDebug(760) << k_funcinfo << "Found " << rootDockWidgetList.count() << " widgets to undock" << endl; 01496 01497 // undock all these found oldest ancestors (being KDockWidgets) 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 // cover KMdi's childarea by a dockwidget 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 // set this dock to main view 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 ); //JW 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 // restore the old dock scenario which we memorized at the time we switched to toplevel mode 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 //FIXME although i don't know what to fix. 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 // save the old dock scenario of the dockwidget-like tool views to a DOM tree 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 // detach all non-tool-views to toplevel 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 ; // nothing need to be done 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 // if tabified, release all views from their docking covers 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 // pView->reparent(0,0,p); 01674 pView->resize( sz ); 01675 pView->setMinimumSize( mins.width(), mins.height() ); 01676 pView->setMaximumSize( maxs.width(), maxs.height() ); 01677 // ((KDockWidget*)pParent)->undock(); // this destroys the dockwiget cover, too 01678 // pParent->close(); 01679 // delete pParent; 01680 // if (centralWidget() == pParent) { 01681 // setCentralWidget(0L); // avoid dangling pointer 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 // resize to childframe mode size of the mainwindow if we were in toplevel mode 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 //qDebug("TopLevelMode off"); 01702 emit leftTopLevelMode(); 01703 QApplication::sendPostedEvents(); 01704 01705 // restore the old dock szenario which we memorized at the time we switched to toplevel mode 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 connect(pView,SIGNAL(iconOrCaptionUdpated(QWidget*,QPixmap,const QString&)), 01732 m_documentTabWidget,SLOT(updateView(QWidget*,QPixmap,const QString&))); 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; // see KMultiTabBar for the first 3 bits 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(); //FIXME: Does not hide the icon in the IDEAl mode. 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 //workaround for the above FIXME to make switching to TextOnly mode work in IDEAl as well. Be sure that this version of switch* is called. 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 ; // nothing need to be done 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 // FIXME: will likely crash below due to unchecked cast 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 ); //::DockCorner); 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 // if tabified, release all views from their docking covers 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 // find the oldest ancestor of the current dockwidget that can be undocked 02094 do 02095 { 02096 if ( pParent->inherits( "KDockWidget" ) || pParent->inherits( "KDockWidget_Compat::KDockWidget" ) ) 02097 { 02098 pDockW = ( KDockWidget* ) pParent; 02099 pDockW->undock(); // this destroys the dockwiget cover, too 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 ); // avoid dangling pointer 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 /* wid->resize( 02175 ((pos==KDockWidget::DockLeft) || (pos==KDockWidget::DockRight))?size:wid->width(), 02176 ((pos==KDockWidget::DockLeft) || (pos==KDockWidget::DockRight))?wid->height():size); 02177 */ 02178 #endif 02179 02180 } 02181 02182 } 02183 02184 02192 void KMdiMainFrm::setMenuForSDIModeSysButtons( KMenuBar* pMenuBar ) 02193 { 02194 if ( m_bSDIApplication ) // there are no buttons in the menubar in this mode (although the view is always maximized) 02195 return ; 02196 02197 m_pMainMenuBar = pMenuBar; 02198 if ( m_pMainMenuBar == 0L ) 02199 return ; // use setMenuForSDIModeSysButtons( 0L) for unsetting the external main menu! 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 // create the decoration pixmaps 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 { // kde2laptop look 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; // flag that we are currently switching between windows 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 { // look ahead 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; // flag that we are currently switching between windows 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 //If we have no child or there is no menubar, we do nothing 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 ; // already set, nothing to do 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 // if there is no menubar given, those system buttons aren't possible 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 //qDebug("updateSysButtonConnections"); 02506 // if there is no menubar given, those system buttons aren't possible 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 //=============== fillWindowMenu ===============// 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 // construct the menu and its submenus 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 // for all child frame windows: give an ID to every window and connect them in the end with windowMenuItemActivated() 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 // set titles of minimized windows in brackets 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 // insert the window entry sorted by access time 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; // break the loop 02710 } 02711 } 02712 if ( !inserted ) 02713 { // append it 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 //================ windowMenuItemActivated ===============// 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 //================ dockMenuItemActivated ===============// 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 { // is detached 02777 attachWindow( pView, true ); 02778 } 02779 } 02780 02781 //================ popupWindowMenu ===============// 02782 02783 void KMdiMainFrm::popupWindowMenu( QPoint p ) 02784 { 02785 if ( !isFakingSDIApplication() ) 02786 { 02787 m_pWindowMenu->popup( p ); 02788 } 02789 } 02790 02791 //================ dragEndTimeOut ===============// 02792 void KMdiMainFrm::dragEndTimeOut() 02793 { 02794 // send drag end to all concerned views. 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 //================ setFrameDecorOfAttachedViews ===============// 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 // d->focusList=new KMdiFocusList(this); 02867 // if (m_pMdi) d->focusList->addWidgetTree(m_pMdi); 02868 // if (m_documentTabWidget) d->focusList->addWidgetTree(m_documentTabWidget); 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 if (d->activeDockPriority[0]==0) { 02896 if (d->focusList) d->focusList->restore(); 02897 delete d->focusList; 02898 d->focusList=0; 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 // vim: ts=2 sw=2 et 02941 // kate: space-indent off; tab-width 4; replace-tabs off; indent-mode csands;
KDE Logo
This file is part of the documentation for kmdi Library Version 3.4.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Tue Apr 12 23:29:42 2005 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003