00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036 #include "config.h"
00037
00038 #include <assert.h>
00039
00040 #include <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>
00099 #include <X11/Xlib.h>
00100 #endif
00101
00102 #ifdef KeyRelease
00103
00104 #undef KeyRelease
00105 #endif
00106
00107 #ifdef KeyPress
00108
00109 #undef KeyPress
00110 #endif
00111 #endif // Q_WS_X11 && ! K_WS_QTONLY
00112
00113 using namespace KParts;
00114
00115 KMdi::FrameDecor KMdiMainFrm::m_frameDecoration = KMdi::KDELook;
00116
00117 class KMdiMainFrmPrivate
00118 {
00119 public:
00120 KMdiMainFrmPrivate() : focusList( 0 )
00121 {
00122 for ( int i = 0;i < 4;i++ )
00123 {
00124 activeDockPriority[ i ] = 0;
00125 m_styleIDEAlMode = 0;
00126 m_toolviewStyle = 0;
00127 }
00128 }
00129 ~KMdiMainFrmPrivate()
00130 {}
00131 KMdiDockContainer* activeDockPriority[ 4 ];
00132 KMdiFocusList *focusList;
00133 int m_styleIDEAlMode;
00134 int m_toolviewStyle;
00135 TDEAction *closeWindowAction;
00136 };
00137
00138
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
00182 m_pDocumentViews = new TQPtrList<KMdiChildView>;
00183 m_pDocumentViews->setAutoDelete( false );
00184 m_pToolViews = new TQMap<TQWidget*, KMdiToolViewAccessor*>;
00185
00186
00187 setFocusPolicy( TQ_ClickFocus );
00188
00189
00190 createMdiManager();
00191
00192
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
00199 setView( m_pDockbaseAreaOfDocumentViews );
00200 setMainDockWidget( m_pDockbaseAreaOfDocumentViews );
00201
00202
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
00224 createTaskBar();
00225
00226
00227
00228 setMenuForSDIModeSysButtons( menuBar() );
00229
00230 switch ( mdiMode )
00231 {
00232 case KMdi::IDEAlMode:
00233 kdDebug(760) << k_funcinfo << "Switching to IDEAl mode" << endl;
00234 switchToIDEAlMode();
00235 break;
00236 case KMdi::TabPageMode:
00237 kdDebug(760) << k_funcinfo << "Switching to tab page mode" << endl;
00238 switchToTabPageMode();
00239 break;
00240 case KMdi::ToplevelMode:
00241 kdDebug(760) << k_funcinfo << "Switching to top level mode" << endl;
00242 switchToToplevelMode();
00243 break;
00244 default:
00245 m_mdiMode = KMdi::ChildframeMode;
00246 kdDebug(760) << k_funcinfo << "Switching to child frame mode" << endl;
00247 break;
00248 }
00249
00250
00251 m_pDragEndTimer = new 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
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
00295 KMdiMainFrm::~KMdiMainFrm()
00296 {
00297
00298 TQValueList<KMdiChildView*> children;
00299 for ( KMdiChildView * w = m_pDocumentViews->first();w;w = m_pDocumentViews->next() )
00300 children.append( w );
00301
00302
00303 TQValueListIterator<KMdiChildView*> childIt;
00304 for ( childIt = children.begin(); childIt != children.end(); ++childIt )
00305 {
00306 closeWindow( *childIt, false );
00307 }
00308
00309 emit lastChildViewClosed();
00310 delete m_pDocumentViews;
00311 delete m_pToolViews;
00312 m_pToolViews = 0;
00313 delete m_pDragEndTimer;
00314
00315 delete m_pUndockButtonPixmap;
00316 delete m_pMinButtonPixmap;
00317 delete m_pRestoreButtonPixmap;
00318 delete m_pCloseButtonPixmap;
00319
00320
00321 delete m_pDockMenu;
00322 delete m_pMdiModeMenu;
00323 delete m_pPlacingMenu;
00324 delete m_pTaskBarPopup;
00325 delete m_pWindowPopup;
00326 delete m_pWindowMenu;
00327 delete m_mdiGUIClient;
00328 delete m_pTempDockSession;
00329 m_mdiGUIClient = 0;
00330 delete d;
00331 d = 0;
00332 }
00333
00334
00335
00336 void KMdiMainFrm::applyOptions()
00337 {
00338 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
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
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
00406
00407 void KMdiMainFrm::setMinimumSize( int minw, int minh )
00408 {
00409 if ( ( m_mdiMode == KMdi::ToplevelMode ) && !parentWidget() )
00410 return ;
00411 DockMainWindow::setMinimumSize( minw, minh );
00412 }
00413
00414
00415
00416 KMdiChildView* KMdiMainFrm::createWrapper( TQWidget *view, const TQString& name, const TQString& shortName )
00417 {
00418 Q_ASSERT( view );
00419
00420 KMdiChildView* pMDICover = new KMdiChildView( name , 0L ,
00421 name.latin1() );
00422 TQBoxLayout* pLayout = new TQHBoxLayout( pMDICover, 0, -1, "layout" );
00423 view->reparent( pMDICover, TQPoint( 0, 0 ) );
00424 pLayout->addWidget( view );
00425
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
00438
00439 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, int flags )
00440 {
00441 addWindow( pWnd, flags, -1 );
00442 }
00443
00444 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, int flags, int index )
00445 {
00446 if ( windowExists( pWnd, AnyView ) )
00447 return;
00448
00449 if ( flags & KMdi::ToolWindow )
00450 {
00451 addToolWindow( pWnd );
00452
00453 pWnd->move( m_pMdi->mapToGlobal( m_pMdi->getCascadePoint() ) );
00454
00455 return ;
00456 }
00457
00458 d->closeWindowAction->setEnabled(true);
00459
00460
00461 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
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 );
00499 }
00500 else
00501 attachWindow( pWnd, !( flags & KMdi::Hide ), flags & KMdi::UseKMdiSizeHint );
00502
00503 if ( ( m_bMaximizedChildFrmMode && ( !m_bSDIApplication && ( flags & KMdi::Detach ) )
00504 && m_mdiMode != KMdi::ToplevelMode ) || ( flags & KMdi::Maximize ) )
00505 {
00506 if ( !pWnd->isMaximized() )
00507 pWnd->maximize();
00508 }
00509
00510 if ( !m_bSDIApplication || ( flags & KMdi::Detach ) )
00511 {
00512 if ( flags & KMdi::Minimize )
00513 pWnd->minimize();
00514
00515 if ( !( flags & KMdi::Hide ) )
00516 {
00517 if ( pWnd->isAttached() )
00518 pWnd->mdiParent()->show();
00519 else
00520 pWnd->show();
00521 }
00522 }
00523 }
00524 }
00525
00526
00527 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, 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
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
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
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 );
00594 }
00595 else
00596 mtva->place( pos, pTargetWnd, percent );
00597
00598
00599 return mtva;
00600 }
00601
00602
00603 void KMdiMainFrm::attachWindow( KMdiChildView *pWnd, bool bShow, bool bAutomaticResize )
00604 {
00605 pWnd->installEventFilter( this );
00606
00607
00608 bool bCascade = false;
00609 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
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;
00659 }
00660
00661
00662 void KMdiMainFrm::detachWindow( KMdiChildView *pWnd, bool bShow )
00663 {
00664 if ( pWnd->isAttached() )
00665 {
00666 pWnd->removeEventFilter( this );
00667 pWnd->youAreDetached();
00668
00669 if ( pWnd->parent() )
00670 {
00671 KMdiChildFrm * lpC = pWnd->mdiParent();
00672 if ( lpC )
00673 {
00674 if ( lpC->icon() )
00675 {
00676 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 );
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
00719 if ( bShow )
00720 {
00721 activateView( pWnd );
00722 }
00723
00724 emit childViewIsDetachedNow( pWnd );
00725 }
00726
00727
00728 void KMdiMainFrm::removeWindowFromMdi( KMdiChildView *pWnd )
00729 {
00730 Q_UNUSED( pWnd );
00731
00732
00733 #if 0
00734 if ( !( m_pWinList->removeRef( pWnd ) ) )
00735 return ;
00736 if ( m_pWinList->count() == 0 )
00737 m_pCurrentWindow = 0L;
00738
00739 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 );
00786 }
00787 }
00788 delete pDockW;
00789 if ( m_pWinList->count() == 1 )
00790 {
00791 m_pWinList->last() ->activate();
00792 }
00793 }
00794 else if ( pWnd->isAttached() )
00795 {
00796 pWnd->mdiParent() ->hide();
00797 m_pMdi->destroyChildButNotItsView( pWnd->mdiParent() );
00798 }
00799 else
00800 {
00801
00802 if ( m_pMdi->getVisibleChildCount() > 0 )
00803 {
00804 setActiveWindow();
00805 m_pCurrentWindow = 0L;
00806 KMdiChildView* pView = m_pMdi->topChild() ->m_pClient;
00807 if ( pView )
00808 {
00809 pView->activate();
00810 }
00811 }
00812 else if ( m_pWinList->count() > 0 )
00813 {
00814
00815
00816 }
00817 }
00818
00819 if ( pWnd->isToolView() )
00820 pWnd->m_bToolView = false;
00821
00822 if ( !m_pCurrentWindow )
00823 emit lastChildViewClosed();
00824 #endif
00825 }
00826
00827
00828 void KMdiMainFrm::closeWindow( KMdiChildView *pWnd, bool layoutTaskBar )
00829 {
00830 if ( !pWnd )
00831 return ;
00832
00833 m_pDocumentViews->removeRef( pWnd );
00834 if ( m_pDocumentViews->count() == 0 )
00835 m_pCurrentWindow = 0L;
00836
00837 if ( m_pTaskBar )
00838 {
00839 m_pTaskBar->removeWinButton( pWnd, layoutTaskBar );
00840 }
00841
00842 if ( ( m_mdiMode == KMdi::TabPageMode ) || ( m_mdiMode == KMdi::IDEAlMode ) )
00843 {
00844 if ( !m_documentTabWidget )
00845 return ;
00846 if ( m_pDocumentViews->count() == 0 )
00847 m_pClose->hide();
00848 pWnd->reparent( 0L, TQPoint( 0, 0 ) );
00849 kdDebug(760) << "-------- 1" << endl;
00850 if ( m_pDocumentViews->count() == 1 )
00851 {
00852 m_pDocumentViews->last() ->activate();
00853 }
00854 }
00855 if ( ( m_mdiMode == KMdi::TabPageMode ) || ( m_mdiMode == KMdi::IDEAlMode ) )
00856 {
00857 if ( m_pDocumentViews->count() == 0 )
00858 {
00859 if ( !m_pDockbaseAreaOfDocumentViews )
00860 {
00861 m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", 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 );
00888 }
00889 }
00890 delete pDockW;
00891 #endif
00892
00893 delete pWnd;
00894 if ( m_pDocumentViews->count() == 1 )
00895 {
00896 m_pDocumentViews->last() ->activate();
00897 }
00898 }
00899 else if ( pWnd->isAttached() )
00900 {
00901 m_pMdi->destroyChild( pWnd->mdiParent() );
00902 }
00903 else
00904 {
00905 delete pWnd;
00906
00907 if ( m_pMdi->getVisibleChildCount() > 0 )
00908 {
00909 setActiveWindow();
00910 m_pCurrentWindow = 0L;
00911 KMdiChildView* pView = m_pMdi->topChild() ->m_pClient;
00912 if ( pView )
00913 {
00914 pView->activate();
00915 }
00916 }
00917 else if ( m_pDocumentViews->count() > 0 )
00918 {
00919 if ( m_pDocumentViews->current() )
00920 {
00921 m_pDocumentViews->current() ->activate();
00922 m_pDocumentViews->current() ->setFocus();
00923 }
00924 else
00925 {
00926 m_pDocumentViews->last() ->activate();
00927 m_pDocumentViews->last() ->setFocus();
00928 }
00929 }
00930 }
00931
00932 if ( !m_pCurrentWindow )
00933 {
00934 d->closeWindowAction->setEnabled(false);
00935 emit lastChildViewClosed();
00936 }
00937 }
00938
00939
00940 KMdiChildView* KMdiMainFrm::findWindow( const 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
00952 KMdiChildView* KMdiMainFrm::activeWindow()
00953 {
00954 return m_pCurrentWindow;
00955 }
00956
00957
00958 bool KMdiMainFrm::windowExists( KMdiChildView *pWnd, ExistsAs as )
00959 {
00960 if ( ( as == ToolView ) || ( as == AnyView ) )
00961 {
00962 if ( m_pToolViews->contains( pWnd ) )
00963 return true;
00964 if ( as == ToolView )
00965 return false;
00966 }
00967
00968 if ( m_pDocumentViews->findRef( pWnd ) != -1 )
00969 return true;
00970
00971 return false;
00972 }
00973
00974 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
00986 TQPopupMenu* KMdiMainFrm::taskBarPopup( KMdiChildView *pWnd, bool )
00987 {
00988
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
01006 m_pTaskBarPopup->insertSeparator();
01007 m_pTaskBarPopup->insertItem( i18n( "Operations" ), windowPopup( pWnd, false ) );
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 );
01043 if ( !pWnd->isActiveWindow() )
01044 pWnd->setActiveWindow();
01045
01046 pWnd->raise();
01047 }
01048 }
01049 if ( !switching() )
01050 activeWindow()->updateTimeStamp();
01051 emit collapseOverlapContainers();
01052 pWnd->m_bMainframesActivateViewIsPending = false;
01053 }
01054
01055
01056 void KMdiMainFrm::activateView( KMdiChildView* pWnd )
01057 {
01058 pWnd->m_bMainframesActivateViewIsPending = true;
01059
01060 bool bActivateNecessary = true;
01061 if ( m_pCurrentWindow != pWnd )
01062 m_pCurrentWindow = pWnd;
01063 else
01064 {
01065 bActivateNecessary = false;
01066
01067
01068 pWnd->m_bInterruptActivation = true;
01069 }
01070
01071 if ( m_pTaskBar )
01072 m_pTaskBar->setActiveButton( pWnd );
01073
01074 if ( m_documentTabWidget && m_mdiMode == KMdi::TabPageMode || m_mdiMode == KMdi::IDEAlMode )
01075 {
01076 m_documentTabWidget->showPage( pWnd );
01077 pWnd->activate();
01078 }
01079 else
01080 {
01081 if ( pWnd->isAttached() )
01082 {
01083 if ( bActivateNecessary && ( m_pMdi->topChild() == pWnd->mdiParent() ) )
01084 pWnd->activate();
01085
01086 pWnd->mdiParent() ->raiseAndActivate();
01087 }
01088 if ( !pWnd->isAttached() )
01089 {
01090 if ( bActivateNecessary )
01091 pWnd->activate();
01092
01093 m_pMdi->setTopChild( 0L );
01094 if ( !pWnd->isActiveWindow() )
01095 pWnd->setActiveWindow();
01096
01097 pWnd->raise();
01098 }
01099 }
01100
01101 emit collapseOverlapContainers();
01102
01103 pWnd->m_bMainframesActivateViewIsPending = false;
01104 }
01105
01106 void KMdiMainFrm::taskbarButtonRightClicked( KMdiChildView *pWnd )
01107 {
01108 activateView( pWnd );
01109
01110 taskBarPopup( pWnd, true ) ->popup( 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
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141 }
01142 else if ( isVisible() && e->type() == TQEvent::Move )
01143 {
01144 if ( m_pDragEndTimer->isActive() )
01145 {
01146
01147 m_pDragEndTimer->stop();
01148 }
01149 else
01150 {
01151
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 );
01160 }
01161
01162 return DockMainWindow::event( e );
01163 }
01164
01165 bool KMdiMainFrm::eventFilter( TQObject * , TQEvent *e )
01166 {
01167 if ( e->type() == TQEvent::Resize && m_mdiMode == KMdi::ToplevelMode )
01168 {
01169 verifyToplevelHeight();
01170 return false;
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;
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;
01230 }
01231
01235 void KMdiMainFrm::closeAllViews()
01236 {
01237
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
01276 if ( !rootDockWidgetList && !positionList )
01277 return ;
01278
01279
01280 const int frameBorderWidth = 7;
01281 const int windowTitleHeight = 10;
01282
01283 TQObjectList* pObjList = queryList( "KDockWidget" );
01284 if ( pObjList->isEmpty() )
01285 pObjList = queryList( "KDockWidget_Compat::KDockWidget" );
01286
01287 TQObjectListIt it( *pObjList );
01288
01289 while ( ( *it ) )
01290 {
01291 KDockWidget* dockWindow = 0L;
01292 KDockWidget* rootDockWindow = 0L;
01293 KDockWidget* undockCandidate = 0L;
01294 TQWidget* pW = TQT_TQWIDGET( ( *it ) );
01295
01296
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
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;
01354 setUndockPositioningOffset( TQPoint( 0, ( m_pTaskBar ? m_pTaskBar->height() : 0 ) + frameBorderWidth ) );
01355
01356
01357 TQPtrList<KDockWidget> rootDockWidgetList;
01358 TQValueList<TQRect> positionList;
01359
01360
01361 switch( oldMdiMode )
01362 {
01363 case KMdi::ChildframeMode:
01364 finishChildframeMode();
01365 break;
01366 case KMdi::TabPageMode:
01367 finishTabPageMode();
01368 break;
01369 case KMdi::IDEAlMode:
01370 finishIDEAlMode();
01371 findRootDockWidgets( &rootDockWidgetList, &positionList );
01372 break;
01373 default:
01374 break;
01375 }
01376
01377
01378 TQPtrListIterator<KDockWidget> kdwit( rootDockWidgetList );
01379 for ( ; ( *kdwit ); ++kdwit )
01380 ( *kdwit )->undock();
01381
01382
01383 if ( oldMdiMode == KMdi::TabPageMode || oldMdiMode == KMdi::IDEAlMode )
01384 {
01385 if ( !m_pDockbaseAreaOfDocumentViews )
01386 {
01387 m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", 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
01394 setView( m_pDockbaseAreaOfDocumentViews );
01395 setMainDockWidget( m_pDockbaseAreaOfDocumentViews );
01396 }
01397
01398 if ( !parentWidget() )
01399 {
01400
01401
01402
01403 int topDockHeight = topDock() ? topDock()->height() : 0;
01404 int bottomDockHeight = bottomDock() ? bottomDock()->height() : 0;
01405 int menuBarHeight = hasMenuBar() ? menuBar()->height() : 0;
01406 if ( m_pDocumentViews->count() != 0 )
01407 setFixedHeight( height() - m_pDockbaseAreaOfDocumentViews->height() );
01408 else
01409 {
01410 kdDebug(760) << k_funcinfo << "height is: " << height() << endl;
01411 kdDebug(760) << k_funcinfo << "top dock height: " << topDockHeight << endl;
01412 kdDebug(760) << k_funcinfo << "bottom dock height: " << bottomDockHeight << endl;
01413 kdDebug(760) << k_funcinfo << "menu bar height: " << menuBarHeight << endl;
01414 kdDebug(760) << k_funcinfo << "dock base area height: " << m_pDockbaseAreaOfDocumentViews->height() << endl;
01415 setFixedHeight( topDockHeight + menuBarHeight );
01416 }
01417 }
01418
01419
01420
01421 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
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
01470 findRootDockWidgets( &rootDockWidgetList, &positionList );
01471 kdDebug(760) << k_funcinfo << "Found " << rootDockWidgetList.count() << " widgets to undock" << endl;
01472
01473
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
01490 findRootDockWidgets( &rootDockWidgetList, &positionList );
01491 kdDebug(760) << k_funcinfo << "Found " << rootDockWidgetList.count() << " widgets to undock" << endl;
01492
01493
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
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
01517 setView( m_pDockbaseAreaOfDocumentViews );
01518 setMainDockWidget( m_pDockbaseAreaOfDocumentViews );
01519 m_pDockbaseAreaOfDocumentViews->setEnableDocking( KDockWidget::DockNone );
01520 m_pDockbaseAreaOfDocumentViews->setDockSite( KDockWidget::DockCorner );
01521 kdDebug(760) << k_funcinfo << "Dock base area has been set to the main view" << endl;
01522 }
01523 m_pDockbaseAreaOfDocumentViews->setWidget( m_pMdi );
01524 m_pDockbaseAreaOfDocumentViews->show();
01525
01526 if ( ( m_mdiMode == KMdi::TabPageMode ) || ( m_mdiMode == KMdi::IDEAlMode ) )
01527 {
01528 kdDebug(760) << k_funcinfo << "trying to dock back the undock toolviews" << endl;
01529 TQPtrListIterator<KDockWidget> it( rootDockWidgetList );
01530 for ( ; ( *it ); ++it )
01531 ( *it )->dockBack();
01532 }
01533
01534 if ( m_mdiMode == KMdi::ToplevelMode && m_pTempDockSession )
01535 {
01536
01537 kdDebug(760) << k_funcinfo << "Restoring old dock scenario memorized from toplevel mode" << endl;
01538 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
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
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
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 ;
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
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
01670 pView->resize( sz );
01671 pView->setMinimumSize( mins.width(), mins.height() );
01672 pView->setMaximumSize( maxs.width(), maxs.height() );
01673
01674
01675
01676
01677
01678
01679 }
01680 delete m_documentTabWidget;
01681 m_documentTabWidget = 0;
01682 m_pTaskBar->switchOn( true );
01683 }
01684 }
01685
01686
01687
01688 void KMdiMainFrm::setupTabbedDocumentViewSpace()
01689 {
01690
01691 if ( ( m_mdiMode == KMdi::ToplevelMode ) && !parentWidget() )
01692 {
01693 setMinimumHeight( m_oldMainFrmMinHeight );
01694 setMaximumHeight( m_oldMainFrmMaxHeight );
01695 resize( width(), m_oldMainFrmHeight );
01696 m_oldMainFrmHeight = 0;
01697
01698 emit leftTopLevelMode();
01699 TQApplication::sendPostedEvents();
01700
01701
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
01728
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;
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();
01791 dockWidget->setTabPageLabel( it.data()->wrappedWidget()->caption() );
01792 break;
01793 case KMdi::TextAndIcon:
01794 dockWidget->setPixmap( *( it.data()->wrappedWidget()->icon() ) );
01795 dockWidget->setTabPageLabel( it.data()->wrappedWidget()->caption() );
01796 default:
01797 break;
01798 }
01799 toolviewExists = true;
01800 }
01801 }
01802
01803 if ( toolviewExists )
01804 {
01805
01806 if ( m_mdiMode == KMdi::IDEAlMode && flag == KMdi::TextOnly )
01807 {
01808 KMdiMainFrm::switchToTabPageMode();
01809 KMdiMainFrm::switchToIDEAlMode();
01810 }
01811 else
01812 {
01813 writeDockConfig();
01814 readDockConfig();
01815 }
01816 }
01817 }
01818
01822 void KMdiMainFrm::switchToIDEAlMode()
01823 {
01824 kdDebug(760) << k_funcinfo << "switching to IDEAl mode" << endl;
01825
01826 if ( m_mdiMode == KMdi::IDEAlMode )
01827 {
01828 emit mdiModeHasBeenChangedTo( KMdi::IDEAlMode );
01829 return ;
01830 }
01831
01832 switch( m_mdiMode )
01833 {
01834 case KMdi::ChildframeMode:
01835 finishChildframeMode();
01836 break;
01837 case KMdi::ToplevelMode:
01838 finishToplevelMode();
01839 break;
01840 case KMdi::TabPageMode:
01841 m_mdiMode = KMdi::IDEAlMode;
01842 setupToolViewsForIDEALMode();
01843 emit mdiModeHasBeenChangedTo( KMdi::IDEAlMode );
01844 return;
01845 break;
01846 default:
01847 break;
01848 }
01849
01850 setupTabbedDocumentViewSpace();
01851 m_mdiMode = KMdi::IDEAlMode;
01852 setupToolViewsForIDEALMode();
01853
01854 if ( m_pCurrentWindow )
01855 m_pCurrentWindow->setFocus();
01856
01857 m_pTaskBar->switchOn( false );
01858
01859 if ( m_pClose )
01860 {
01861 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
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 );
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
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
02090 do
02091 {
02092 if ( pParent->inherits( "KDockWidget" ) || pParent->inherits( "KDockWidget_Compat::KDockWidget" ) )
02093 {
02094 pDockW = ( KDockWidget* ) pParent;
02095 pDockW->undock();
02096 if ( pParent != m_pDockbaseAreaOfDocumentViews )
02097 {
02098 pParent->close();
02099 delete pParent;
02100 }
02101 }
02102 else
02103 {
02104 pParent = pParent->parentWidget();
02105 }
02106 }
02107 while ( pParent && !pDockW );
02108 if ( centralWidget() == pParent )
02109 {
02110 setCentralWidget( 0L );
02111 }
02112 }
02113 m_pTaskBar->switchOn( true );
02114
02115 }
02116
02117 }
02118
02119 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
02171
02172
02173
02174 #endif
02175
02176 }
02177
02178 }
02179
02180
02188 void KMdiMainFrm::setMenuForSDIModeSysButtons( KMenuBar* pMenuBar )
02189 {
02190 if ( m_bSDIApplication )
02191 return ;
02192
02193 m_pMainMenuBar = pMenuBar;
02194 if ( m_pMainMenuBar == 0L )
02195 return ;
02196
02197 if ( !m_pUndock )
02198 m_pUndock = new 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
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 {
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;
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 {
02368 ++pos;
02369 }
02370 else
02371 {
02372 pos = m.begin();
02373 }
02374 activateView( pos.data() );
02375 delete it;
02376 }
02377
02379 void KMdiMainFrm::activateLastWin()
02380 {
02381 m_bSwitching= true;
02382 KMdiIterator<KMdiChildView*>* it = createIterator();
02383 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
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 ;
02462
02463 kdDebug(760) << k_funcinfo << "Turning off maximized child frame mode" << endl;
02464 m_bMaximizedChildFrmMode = false;
02465
02466 KMdiChildFrm* pFrmChild = m_pMdi->topChild();
02467 if ( pFrmChild && pFrmChild->m_pClient && pFrmChild->state() == KMdiChildFrm::Maximized )
02468 {
02469 pFrmChild->m_pClient->restore();
02470 switchOffMaximizeModeForMenu( pFrmChild );
02471 }
02472 }
02473 }
02474
02476 void KMdiMainFrm::switchOffMaximizeModeForMenu( KMdiChildFrm* oldChild )
02477 {
02478
02479 if ( !m_pMainMenuBar )
02480 return ;
02481
02482 m_pMainMenuBar->removeItem( m_pMainMenuBar->idAt( 0 ) );
02483
02484 if ( oldChild )
02485 {
02486 Q_ASSERT( m_pClose );
02487 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
02502
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
02557 void KMdiMainFrm::fillWindowMenu()
02558 {
02559 bool tabPageMode = false;
02560 if ( m_mdiMode == KMdi::TabPageMode )
02561 tabPageMode = true;
02562
02563 bool IDEAlMode = false;
02564 if ( m_mdiMode == KMdi::IDEAlMode )
02565 IDEAlMode = true;
02566
02567 bool noViewOpened = false;
02568 if ( m_pDocumentViews->isEmpty() )
02569 noViewOpened = true;
02570
02571
02572 if ( !m_bClearingOfWindowMenuBlocked )
02573 m_pWindowMenu->clear();
02574
02575 d->closeWindowAction->plug(m_pWindowMenu);
02576
02577 int closeAllId = m_pWindowMenu->insertItem( i18n( "Close &All" ), this, 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
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
02661 if ( pView->isMinimized() )
02662 {
02663 item += "(";
02664 item += pView->caption();
02665 item += ")";
02666 }
02667 else
02668 {
02669 item += " ";
02670 item += pView->caption();
02671 }
02672
02673
02674 unsigned int indx;
02675 unsigned int windowItemCount = m_pWindowMenu->count() - entryCount;
02676 bool inserted = false;
02677 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;
02706 }
02707 }
02708 if ( !inserted )
02709 {
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
02730
02731 void KMdiMainFrm::windowMenuItemActivated( int id )
02732 {
02733 if ( id < 100 )
02734 return ;
02735 id -= 100;
02736 KMdiChildView *pView = m_pDocumentViews->at( id );
02737 if ( !pView )
02738 return ;
02739 if ( pView->isMinimized() )
02740 pView->minimize();
02741 if ( m_mdiMode != KMdi::TabPageMode )
02742 {
02743 KMdiChildFrm * pTopChild = m_pMdi->topChild();
02744 if ( pTopChild )
02745 {
02746 if ( ( pView == pTopChild->m_pClient ) && pView->isAttached() )
02747 {
02748 return ;
02749 }
02750 }
02751 }
02752 activateView( pView );
02753 }
02754
02755
02756
02757 void KMdiMainFrm::dockMenuItemActivated( int id )
02758 {
02759 if ( id < 100 )
02760 return ;
02761 id -= 100;
02762 KMdiChildView *pView = m_pDocumentViews->at( id );
02763 if ( !pView )
02764 return ;
02765 if ( pView->isMinimized() )
02766 pView->minimize();
02767 if ( pView->isAttached() )
02768 {
02769 detachWindow( pView, true );
02770 }
02771 else
02772 {
02773 attachWindow( pView, true );
02774 }
02775 }
02776
02777
02778
02779 void KMdiMainFrm::popupWindowMenu( TQPoint p )
02780 {
02781 if ( !isFakingSDIApplication() )
02782 {
02783 m_pWindowMenu->popup( p );
02784 }
02785 }
02786
02787
02788 void KMdiMainFrm::dragEndTimeOut()
02789 {
02790
02791 KMdiChildView * pView;
02792 for ( m_pDocumentViews->first(); ( pView = m_pDocumentViews->current() ) != 0L; m_pDocumentViews->next() )
02793 {
02794 KMdiChildFrmDragEndEvent dragEndEvent( 0L );
02795 TQApplication::sendEvent( pView, &dragEndEvent );
02796 }
02797 }
02798
02799
02800
02801 void KMdiMainFrm::setFrameDecorOfAttachedViews( int frameDecor )
02802 {
02803 switch ( frameDecor )
02804 {
02805 case 0:
02806 m_frameDecoration = KMdi::Win95Look;
02807 break;
02808 case 1:
02809 m_frameDecoration = KMdi::KDE1Look;
02810 break;
02811 case 2:
02812 m_frameDecoration = KMdi::KDELook;
02813 break;
02814 case 3:
02815 m_frameDecoration = KMdi::KDELaptopLook;
02816 break;
02817 default:
02818 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
02863
02864
02865 return ;
02866 }
02867 for ( int dst = 3, src = 2;src >= 0;dst--, src-- )
02868 {
02869 if ( d->activeDockPriority[ src ] == td )
02870 src--;
02871 if ( src < 0 )
02872 break;
02873 d->activeDockPriority[ dst ] = d->activeDockPriority[ src ];
02874 }
02875 d->activeDockPriority[ 0 ] = td;
02876 }
02877
02878 void KMdiMainFrm::removeFromActiveDockList( KMdiDockContainer* td )
02879 {
02880 for ( int i = 0;i < 4;i++ )
02881 {
02882 if ( d->activeDockPriority[ i ] == td )
02883 {
02884 for ( ;i < 3;i++ )
02885 d->activeDockPriority[ i ] = d->activeDockPriority[ i + 1 ];
02886 d->activeDockPriority[ 3 ] = 0;
02887 break;
02888 }
02889 }
02890
02891
02892
02893
02894
02895
02896
02897 }
02898
02899 void KMdiMainFrm::prevToolViewInDock()
02900 {
02901 KMdiDockContainer * td = d->activeDockPriority[ 0 ];
02902 if ( !td )
02903 return ;
02904 td->prevToolView();
02905 }
02906
02907 void KMdiMainFrm::nextToolViewInDock()
02908 {
02909 KMdiDockContainer * td = d->activeDockPriority[ 0 ];
02910 if ( !td )
02911 return ;
02912 td->nextToolView();
02913 }
02914
02915 KMdi::TabWidgetVisibility KMdiMainFrm::tabWidgetVisibility()
02916 {
02917 if ( m_documentTabWidget )
02918 return m_documentTabWidget->tabWidgetVisibility();
02919
02920 return KMdi::NeverShowTabs;
02921 }
02922
02923 void KMdiMainFrm::setTabWidgetVisibility( KMdi::TabWidgetVisibility visibility )
02924 {
02925 if ( m_documentTabWidget )
02926 m_documentTabWidget->setTabWidgetVisibility( visibility );
02927 }
02928
02929 KTabWidget * KMdiMainFrm::tabWidget() const
02930 {
02931 return m_documentTabWidget;
02932 }
02933
02934 #include "tdemdimainfrm.moc"
02935
02936
02937