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