00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "kmdimainfrm.h"
00021 #include "kmdidockcontainer.h"
00022 #include "kmdidockcontainer.moc"
00023
00024 #include "kdockwidget_private.h"
00025
00026 #include <qwidgetstack.h>
00027 #include <qlayout.h>
00028 #include <qtimer.h>
00029 #include <qtooltip.h>
00030 #include <kmultitabbar.h>
00031 #include <kglobalsettings.h>
00032
00033 #include <kdebug.h>
00034 #include <kiconloader.h>
00035 #include <kapplication.h>
00036 #include <kconfig.h>
00037 #include <klocale.h>
00038
00039
00040 static const char* const kmdi_not_close_xpm[] =
00041 {
00042 "5 5 2 1",
00043 "# c black",
00044 ". c None",
00045 "#####",
00046 "#...#",
00047 "#...#",
00048 "#...#",
00049 "#####"
00050 };
00051
00052 KMdiDockContainer::KMdiDockContainer( QWidget *parent, QWidget *win, int position, int flags )
00053 : QWidget( parent ), KDockContainer()
00054 {
00055 m_tabSwitching = false;
00056 m_block = false;
00057 m_inserted = -1;
00058 m_mainWin = win;
00059 oldtab = -1;
00060 mTabCnt = 0;
00061 m_position = position;
00062 m_previousTab = -1;
00063 m_separatorPos = 17;
00064 m_movingState = NotMoving;
00065 m_startEvent = 0;
00066 kdDebug( 760 ) << k_funcinfo << endl;
00067
00068 QBoxLayout *l;
00069 m_horizontal = ( ( position == KDockWidget::DockTop ) || ( position == KDockWidget::DockBottom ) );
00070
00071
00072 if ( m_horizontal )
00073 l = new QVBoxLayout( this );
00074 else
00075 l = new QHBoxLayout( this );
00076
00077 l->setAutoAdd( false );
00078
00079 m_tb = new KMultiTabBar( m_horizontal ? KMultiTabBar::Horizontal : KMultiTabBar::Vertical, this );
00080
00081 m_tb->setStyle( KMultiTabBar::KMultiTabBarStyle( flags ) );
00082 m_tb->showActiveTabTexts( true );
00083
00084 KMultiTabBar::KMultiTabBarPosition kmtbPos;
00085 switch( position )
00086 {
00087 case KDockWidget::DockLeft:
00088 kmtbPos = KMultiTabBar::Left;
00089 break;
00090 case KDockWidget::DockRight:
00091 kmtbPos = KMultiTabBar::Right;
00092 break;
00093 case KDockWidget::DockTop:
00094 kmtbPos = KMultiTabBar::Top;
00095 break;
00096 case KDockWidget::DockBottom:
00097 kmtbPos = KMultiTabBar::Bottom;
00098 break;
00099 default:
00100 kmtbPos = KMultiTabBar::Right;
00101 break;
00102 }
00103 m_tb->setPosition( kmtbPos );
00104
00105 m_ws = new QWidgetStack( this );
00106
00107 m_ws->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding ) );
00108
00109
00110 if ( position == KDockWidget::DockLeft || position == KDockWidget::DockTop )
00111 {
00112
00113 l->add( m_tb );
00114 l->add( m_ws );
00115 }
00116 else
00117 {
00118
00119 l->add( m_ws );
00120 l->add( m_tb );
00121 }
00122
00123 l->activate();
00124 m_ws->hide();
00125
00126 }
00127
00128 void KMdiDockContainer::setStyle( int style )
00129 {
00130 if ( m_tb )
00131 m_tb->setStyle( KMultiTabBar::KMultiTabBarStyle( style ) );
00132 }
00133
00134 KMdiDockContainer::~KMdiDockContainer()
00135 {
00136 QMap<KDockWidget*, int>::iterator it;
00137 while ( m_map.count() )
00138 {
00139 it = m_map.begin();
00140 KDockWidget *w = it.key();
00141 if ( m_overlapButtons.contains( w ) )
00142 {
00143 ( static_cast<KDockWidgetHeader*>( w->getHeader()->qt_cast( "KDockWidgetHeader" ) ) )->removeButton( m_overlapButtons[w] );
00144 m_overlapButtons.remove( w );
00145 }
00146 m_map.remove( w );
00147 w->undock();
00148 }
00149 deactivated( this );
00150 }
00151
00152
00153 void KMdiDockContainer::init()
00154 {
00155 kdDebug( 760 ) << k_funcinfo << endl;
00156 if ( !m_horizontal )
00157 {
00158 kdDebug( 760 ) << k_funcinfo << "Horizontal tabbar. Setting forced fixed width." << endl;
00159 parentDockWidget()->setForcedFixedWidth( m_tb->width() );
00160 activateOverlapMode( m_tb->width() );
00161 }
00162 else
00163 {
00164 kdDebug( 760 ) << k_funcinfo << "Vertical tabbar. Setting forced fixed height." << endl;
00165 parentDockWidget()->setForcedFixedHeight( m_tb->height() );
00166 activateOverlapMode( m_tb->height() );
00167 }
00168
00169
00170 if ( parentDockWidget() && parentDockWidget()->parent() )
00171 {
00172 KDockSplitter * sp = static_cast<KDockSplitter*>( parentDockWidget()->parent()->qt_cast( "KDockSplitter" ) );
00173 if ( sp )
00174 sp->setSeparatorPosX( m_separatorPos );
00175 }
00176 }
00177
00178 KDockWidget* KMdiDockContainer::parentDockWidget()
00179 {
00180 return ( ( KDockWidget* ) parent() );
00181 }
00182
00183 void KMdiDockContainer::insertWidget ( KDockWidget *dwdg, QPixmap pixmap, const QString &text, int & )
00184 {
00185 kdDebug( 760 ) << k_funcinfo << "Adding a dockwidget to the dock container" << endl;
00186 KDockWidget* w = dwdg;
00187 int tab;
00188 bool alreadyThere = m_map.contains( w );
00189
00190 if ( alreadyThere )
00191 {
00192 tab = m_map[ w ];
00193 if ( m_ws->addWidget( w, tab ) != tab )
00194 kdDebug( 760 ) << "ERROR COULDN'T READD WIDGET" << endl;
00195
00196 kdDebug( 760 ) << k_funcinfo << "Readded widget " << dwdg << endl;
00197 }
00198 else
00199 {
00200 tab = m_ws->addWidget( w );
00201 m_map.insert( w, tab );
00202 m_revMap.insert( tab, w );
00203
00204 if ( ( ( KDockWidget* ) parentWidget() ) ->mayBeShow() )
00205 ( ( KDockWidget* ) parentWidget() ) ->dockBack();
00206
00207 if ( w->getHeader()->qt_cast( "KDockWidgetHeader" ) )
00208 {
00209 kdDebug( 760 ) << k_funcinfo << "The dockwidget we're adding has a header" << endl;
00210 kdDebug( 760 ) << k_funcinfo << "Adding our overlap mode button to it" << endl;
00211
00212 KDockWidgetHeader *hdr = static_cast<KDockWidgetHeader*>( w->getHeader()->qt_cast( "KDockWidgetHeader" ) );
00213 KDockButton_Private *btn = new KDockButton_Private( hdr, "OverlapButton" );
00214
00215 QToolTip::add( btn, i18n( "Switch between overlap and side by side mode", "Overlap" ) );
00216
00217 btn->setToggleButton( true );
00218 btn->setPixmap( const_cast< const char** >( kmdi_not_close_xpm ) );
00219 hdr->addButton( btn );
00220 m_overlapButtons.insert( w, btn );
00221 btn->setOn( !isOverlapMode() );
00222
00223 connect( btn, SIGNAL( clicked() ), this, SLOT( changeOverlapMode() ) );
00224 }
00225
00226 m_tb->appendTab( pixmap.isNull() ? SmallIcon( "misc" ) : pixmap, tab, w->tabPageLabel() );
00227 m_tb->tab( tab )->installEventFilter( this );
00228 kdDebug( 760 ) << k_funcinfo << "Added tab with label " << w->tabPageLabel() <<
00229 " to the tabbar" << endl;
00230
00231 connect( m_tb->tab( tab ), SIGNAL( clicked( int ) ), this, SLOT( tabClicked( int ) ) );
00232
00233 mTabCnt++;
00234 m_inserted = tab;
00235 int dummy = 0;
00236 KDockContainer::insertWidget( w, pixmap, text, dummy );
00237 itemNames.append( w->name() );
00238 tabCaptions.insert( w->name(), w->tabPageLabel() );
00239 tabTooltips.insert( w->name(), w->toolTipString() );
00240 }
00241
00242
00243 }
00244
00245
00246 bool KMdiDockContainer::eventFilter( QObject *obj, QEvent *event )
00247 {
00248 switch ( event->type() )
00249 {
00250 case QEvent::MouseButtonPress:
00251 {
00252 KMultiTabBarTab* kmtbTab = dynamic_cast<KMultiTabBarTab*>( obj );
00253 if ( !obj )
00254 {
00255 kdDebug(760) << k_funcinfo << "Got a mouse button press but we have no tab" << endl;
00256 break;
00257 }
00258
00259 KDockWidget* w = m_revMap[ dynamic_cast<KMultiTabBarTab*>( obj )->id() ];
00260 if ( !w )
00261 {
00262 kdDebug(760) << k_funcinfo << "Got a mouse button press but we have no widget" << endl;
00263 break;
00264 }
00265
00266 if ( !w->getHeader() )
00267 {
00268 kdDebug(760) << k_funcinfo << "Got a mouse button press but we have no header" << endl;
00269 break;
00270 }
00271
00272 KDockWidgetHeader *hdr = static_cast<KDockWidgetHeader*>( w->getHeader()->qt_cast( "KDockWidgetHeader" ) );
00273 if ( !hdr )
00274 {
00275 kdDebug(760) << "Wrong header type in KMdiDockContainer::eventFilter" << endl;
00276 break;
00277 }
00278
00279 m_dockManager = w->dockManager();
00280 m_dragPanel = hdr->dragPanel();
00281
00282 if ( m_dragPanel )
00283 m_movingState = WaitingForMoveStart;
00284
00285 delete m_startEvent;
00286 m_startEvent = new QMouseEvent( * ( ( QMouseEvent* ) event ) );
00287 }
00288 break;
00289 case QEvent::MouseButtonRelease:
00290 if ( m_movingState == Moving )
00291 {
00292 m_movingState = NotMoving;
00293 QApplication::postEvent( m_dragPanel, new QMouseEvent( * ( ( QMouseEvent* ) event ) ) );
00294 delete m_startEvent;
00295 m_startEvent = 0;
00296 }
00297 case QEvent::MouseMove:
00298 if ( m_movingState == WaitingForMoveStart )
00299 {
00300 QPoint p( ( ( QMouseEvent* ) event )->pos() - m_startEvent->pos() );
00301 if ( p.manhattanLength() > KGlobalSettings::dndEventDelay() )
00302 {
00303 m_dockManager->eventFilter( m_dragPanel, m_startEvent );
00304 m_dockManager->eventFilter( m_dragPanel, event );
00305 m_movingState = Moving;
00306 }
00307 }
00308 else if ( m_movingState == Moving )
00309 m_dockManager->eventFilter( m_dragPanel, event );
00310
00311 break;
00312 default:
00313 break;
00314
00315 }
00316 return false;
00317
00318 }
00319
00320 void KMdiDockContainer::showWidget( KDockWidget *w )
00321 {
00322 if ( !m_map.contains( w ) )
00323 return ;
00324
00325 int id = m_map[ w ];
00326 m_tb->setTab( id, true );
00327 tabClicked( id );
00328 }
00329
00330 void KMdiDockContainer::changeOverlapMode()
00331 {
00332 const KDockButton_Private * btn = dynamic_cast<const KDockButton_Private*>( sender() );
00333
00334 if ( !btn )
00335 return ;
00336
00337 if ( !btn->isOn() )
00338 {
00339 kdDebug( 760 ) << k_funcinfo << "Activating overlap mode" << endl;
00340 if ( !m_horizontal )
00341 activateOverlapMode( m_tb->width() );
00342 else
00343 activateOverlapMode( m_tb->height() );
00344
00345 }
00346 else
00347 {
00348 kdDebug( 760 ) << k_funcinfo << "Deactivating overlap mode" << endl;
00349 deactivateOverlapMode();
00350 }
00351
00352 QMap<KDockWidget*, KDockButton_Private*>::iterator it;
00353 for ( it = m_overlapButtons.begin(); it != m_overlapButtons.end(); ++it )
00354 it.data()->setOn( !isOverlapMode() );
00355 }
00356
00357 void KMdiDockContainer::hideIfNeeded()
00358 {
00359 if ( itemNames.count() == 0 )
00360 {
00361 kdDebug( 760 ) << k_funcinfo << "Hiding the dock container" << endl;
00362 ( ( KDockWidget* ) parentWidget() )->undock();
00363 }
00364 }
00365
00366 void KMdiDockContainer::removeWidget( KDockWidget* dwdg )
00367 {
00368 KDockWidget * w = dwdg;
00369 if ( !m_map.contains( w ) )
00370 return;
00371
00372 kdDebug( 760 ) << k_funcinfo << endl;
00373
00374 int id = m_map[ w ];
00375 if ( m_tb->isTabRaised( id ) )
00376 {
00377 m_tb->setTab( id, false );
00378 tabClicked( id );
00379 }
00380
00381 m_tb->removeTab( id );
00382 m_ws->removeWidget( w );
00383 m_map.remove( w );
00384 m_revMap.remove( id );
00385 if ( m_overlapButtons.contains( w ) )
00386 {
00387 ( static_cast<KDockWidgetHeader*>( w->getHeader() ->qt_cast( "KDockWidgetHeader" ) ) )->removeButton( m_overlapButtons[ w ] );
00388 m_overlapButtons.remove( w );
00389 }
00390 KDockContainer::removeWidget( w );
00391 itemNames.remove( w->name() );
00392 tabCaptions.remove( w->name() );
00393 tabTooltips.remove( w->name() );
00394 hideIfNeeded();
00395 }
00396
00397 void KMdiDockContainer::undockWidget( KDockWidget *dwdg )
00398 {
00399 KDockWidget * w = dwdg;
00400
00401 if ( !m_map.contains( w ) )
00402 return ;
00403
00404 int id = m_map[ w ];
00405 if ( m_tb->isTabRaised( id ) )
00406 {
00407 kdDebug( 760 ) << k_funcinfo << "Widget has been undocked, setting tab down" << endl;
00408 m_tb->setTab( id, false );
00409 tabClicked( id );
00410 }
00411 }
00412
00413 void KMdiDockContainer::tabClicked( int t )
00414 {
00415 bool call_makeVisible = !m_tabSwitching;
00416 m_tabSwitching = true;
00417 if ( m_tb->isTabRaised( t ) )
00418 {
00419 kdDebug( 760 ) << k_funcinfo << "Tab " << t << " was just activated" << endl;
00420 if ( m_ws->isHidden() )
00421 {
00422 kdDebug( 760 ) << k_funcinfo << "Showing widgetstack for tab just clicked" << endl;
00423 m_ws->show();
00424 parentDockWidget()->restoreFromForcedFixedSize();
00425 }
00426
00427 if ( !m_ws->widget( t ) )
00428 {
00429 kdDebug( 760 ) << k_funcinfo << "Widget tab was clicked for is not in our stack" << endl;
00430 kdDebug( 760 ) << k_funcinfo << "Docking it back in" << endl;
00431 m_revMap[t]->manualDock( parentDockWidget(), KDockWidget::DockCenter, 20 );
00432 if ( call_makeVisible )
00433 m_revMap[t]->makeDockVisible();
00434 m_tabSwitching = false;
00435 emit activated( this );
00436 return ;
00437 }
00438
00439 if ( m_ws->widget( t ) )
00440 {
00441 m_ws->raiseWidget( t );
00442 KDockWidget * tmpDw = static_cast<KDockWidget*>( m_ws->widget( t )->qt_cast( "KDockWidget" ) );
00443 if ( tmpDw )
00444 {
00445 if ( tmpDw->getWidget() )
00446 tmpDw->getWidget()->setFocus();
00447 }
00448 else
00449 kdDebug( 760 ) << k_funcinfo << "Something really weird is going on" << endl;
00450 }
00451 else
00452 kdDebug( 760 ) << k_funcinfo << "We have no widget to handle in our stack." << endl;
00453
00454 if ( oldtab != t )
00455 m_tb->setTab( oldtab, false );
00456
00457 m_tabSwitching = true;
00458 oldtab = t;
00459 emit activated( this );
00460 }
00461 else
00462 {
00463 kdDebug( 760 ) << k_funcinfo << "Tab " << t << " was just deactiviated" << endl;
00464
00465 if ( parentDockWidget() && parentDockWidget()->parent() )
00466 {
00467 KDockSplitter * sp = static_cast<KDockSplitter*>( parentDockWidget()->parent()->qt_cast( "KDockSplitter" ) );
00468 if ( sp )
00469 m_separatorPos = sp->separatorPos();
00470 }
00471 m_previousTab = t;
00472
00473 if ( m_block )
00474 return ;
00475 emit deactivated( this );
00476 m_block = true;
00477 if ( m_ws->widget( t ) )
00478 {
00479
00480 }
00481 m_block = false;
00482 m_ws->hide ();
00483
00484
00485 kdDebug( 760 ) << k_funcinfo << "Fixed Width:" << m_tb->width() << endl;
00486 if ( !m_horizontal )
00487 parentDockWidget()->setForcedFixedWidth( m_tb->width() );
00488 else
00489 parentDockWidget()->setForcedFixedHeight( m_tb->height() );
00490 }
00491 m_tabSwitching = false;
00492 }
00493
00494 void KMdiDockContainer::setToolTip ( KDockWidget* w, QString &s )
00495 {
00496 kdDebug( 760 ) << k_funcinfo << "Setting tooltip '" << s << "' for widget " << w << endl;
00497 int tabId = m_map[w];
00498 KMultiTabBarTab *mbTab = m_tb->tab( tabId );
00499 QToolTip::remove( mbTab );
00500 QToolTip::add( mbTab, s );
00501 }
00502
00503 void KMdiDockContainer::setPixmap( KDockWidget* widget , const QPixmap& pixmap )
00504 {
00505 int id = m_ws->id( widget );
00506 if ( id == -1 )
00507 return ;
00508 KMultiTabBarTab *tab = m_tb->tab( id );
00509 tab->setIcon( pixmap.isNull() ? SmallIcon( "misc" ) : pixmap );
00510 }
00511
00512 void KMdiDockContainer::save( QDomElement& dockEl )
00513 {
00514 QDomDocument doc = dockEl.ownerDocument();
00515 QDomElement el;
00516 el = doc.createElement( "name" );
00517 el.appendChild( doc.createTextNode( QString( "%1" ).arg( parent() ->name() ) ) );
00518 dockEl.appendChild( el );
00519 el = doc.createElement( "overlapMode" );
00520 el.appendChild( doc.createTextNode( isOverlapMode() ? "true" : "false" ) );
00521 dockEl.appendChild( el );
00522 QPtrList<KMultiTabBarTab>* tl = m_tb->tabs();
00523 QPtrListIterator<KMultiTabBarTab> it( *tl );
00524 QStringList::Iterator it2 = itemNames.begin();
00525 int i = 0;
00526 for ( ;it.current() != 0;++it, ++it2 )
00527 {
00528 el = doc.createElement( "child" );
00529 el.setAttribute( "pos", QString( "%1" ).arg( i ) );
00530 QString s = tabCaptions[ *it2 ];
00531 if ( !s.isEmpty() )
00532 {
00533 el.setAttribute( "tabCaption", s );
00534 }
00535 s = tabTooltips[ *it2 ];
00536 if ( !s.isEmpty() )
00537 {
00538 el.setAttribute( "tabTooltip", s );
00539 }
00540 el.appendChild( doc.createTextNode( *it2 ) );
00541 dockEl.appendChild( el );
00542 if ( m_tb->isTabRaised( it.current() ->id() ) )
00543 {
00544 QDomElement el2 = doc.createElement( "raised" );
00545 el2.appendChild( doc.createTextNode( m_ws->widget( it.current() ->id() ) ->name() ) );
00546 el.appendChild( el2 );
00547 }
00548 ++i;
00549 }
00550
00551
00552 }
00553
00554 void KMdiDockContainer::load( QDomElement& dockEl )
00555 {
00556 QString raise;
00557
00558 for ( QDomNode n = dockEl.firstChild();!n.isNull();n = n.nextSibling() )
00559 {
00560 QDomElement el = n.toElement();
00561 if ( el.isNull() )
00562 continue;
00563 if ( el.tagName() == "overlapMode" )
00564 {
00565 if ( el.attribute( "overlapMode" ) != "false" )
00566 activateOverlapMode( m_tb->width() );
00567 else
00568 deactivateOverlapMode();
00569 }
00570 else if ( el.tagName() == "child" )
00571 {
00572 KDockWidget * dw = ( ( KDockWidget* ) parent() ) ->dockManager() ->getDockWidgetFromName( el.text() );
00573 if ( dw )
00574 {
00575 if ( el.hasAttribute( "tabCaption" ) )
00576 {
00577 dw->setTabPageLabel( el.attribute( "tabCaption" ) );
00578 }
00579 if ( el.hasAttribute( "tabTooltip" ) )
00580 {
00581 dw->setToolTipString( el.attribute( "tabTooltip" ) );
00582 }
00583 dw->manualDock( ( KDockWidget* ) parent(), KDockWidget::DockCenter );
00584 }
00585 }
00586 }
00587
00588 QPtrList<KMultiTabBarTab>* tl = m_tb->tabs();
00589 QPtrListIterator<KMultiTabBarTab> it1( *tl );
00590 m_ws->hide();
00591 if ( !m_horizontal )
00592 parentDockWidget()->setForcedFixedWidth( m_tb->width() );
00593 else
00594 parentDockWidget()->setForcedFixedHeight( m_tb->height() );
00595
00596 for ( ;it1.current() != 0;++it1 )
00597 m_tb->setTab( it1.current() ->id(), false );
00598
00599 kapp->syncX();
00600 m_delayedRaise = -1;
00601
00602 for ( QMap<KDockWidget*, KDockButton_Private*>::iterator it = m_overlapButtons.begin();
00603 it != m_overlapButtons.end();++it )
00604 it.data() ->setOn( !isOverlapMode() );
00605
00606 if ( !raise.isEmpty() )
00607 {
00608 for ( QMap<KDockWidget*, int>::iterator it = m_map.begin();it != m_map.end();++it )
00609 {
00610 if ( it.key() ->name() == raise )
00611 {
00612 m_delayedRaise = it.data();
00613 QTimer::singleShot( 0, this, SLOT( delayedRaise() ) );
00614 kdDebug( 760 ) << k_funcinfo << "raising " << it.key()->name() << endl;
00615 break;
00616 }
00617 }
00618
00619 }
00620 if ( m_delayedRaise == -1 )
00621 QTimer::singleShot( 0, this, SLOT( init() ) );
00622 }
00623
00624 void KMdiDockContainer::save( KConfig* cfg, const QString& group_or_prefix )
00625 {
00626 QString grp = cfg->group();
00627 cfg->deleteGroup( group_or_prefix + QString( "::%1" ).arg( parent() ->name() ) );
00628 cfg->setGroup( group_or_prefix + QString( "::%1" ).arg( parent() ->name() ) );
00629
00630 if ( isOverlapMode() )
00631 cfg->writeEntry( "overlapMode", "true" );
00632 else
00633 cfg->writeEntry( "overlapMode", "false" );
00634
00635
00636 if ( parentDockWidget() && parentDockWidget() ->parent() )
00637 {
00638 KDockSplitter * sp = static_cast<KDockSplitter*>( parentDockWidget() ->
00639 parent() ->qt_cast( "KDockSplitter" ) );
00640 if ( sp )
00641 cfg->writeEntry( "separatorPos", m_separatorPos );
00642 }
00643
00644 QPtrList<KMultiTabBarTab>* tl = m_tb->tabs();
00645 QPtrListIterator<KMultiTabBarTab> it( *tl );
00646 QStringList::Iterator it2 = itemNames.begin();
00647 int i = 0;
00648 for ( ;it.current() != 0;++it, ++it2 )
00649 {
00650
00651 cfg->writeEntry( QString( "widget%1" ).arg( i ), ( *it2 ) );
00652 QString s = tabCaptions[ *it2 ];
00653 if ( !s.isEmpty() )
00654 {
00655 cfg->writeEntry( QString( "widget%1-tabCaption" ).arg( i ), s );
00656 }
00657 s = tabTooltips[ *it2 ];
00658 if ( !s.isEmpty() )
00659 {
00660 cfg->writeEntry( QString( "widget%1-tabTooltip" ).arg( i ), s );
00661 }
00662
00663 if ( m_tb->isTabRaised( it.current() ->id() ) )
00664 cfg->writeEntry( m_ws->widget( it.current() ->id() ) ->name(), true );
00665 ++i;
00666 }
00667 cfg->sync();
00668 cfg->setGroup( grp );
00669
00670 }
00671
00672 void KMdiDockContainer::load( KConfig* cfg, const QString& group_or_prefix )
00673 {
00674 QString grp = cfg->group();
00675 cfg->setGroup( group_or_prefix + QString( "::%1" ).arg( parent() ->name() ) );
00676
00677 if ( cfg->readEntry( "overlapMode" ) != "false" )
00678 activateOverlapMode( m_tb->width() );
00679 else
00680 deactivateOverlapMode();
00681
00682 m_separatorPos = cfg->readNumEntry( "separatorPos", 18 );
00683
00684 int i = 0;
00685 QString raise;
00686 while ( true )
00687 {
00688 QString dwn = cfg->readEntry( QString( "widget%1" ).arg( i ) );
00689 if ( dwn.isEmpty() )
00690 break;
00691 kdDebug( 760 ) << k_funcinfo << "configuring dockwidget :" << dwn << endl;
00692 KDockWidget *dw = ( ( KDockWidget* ) parent() ) ->dockManager() ->getDockWidgetFromName( dwn );
00693 if ( dw )
00694 {
00695 QString s = cfg->readEntry( QString( "widget%1-tabCaption" ).arg( i ) );
00696 if ( !s.isEmpty() )
00697 {
00698 dw->setTabPageLabel( s );
00699 }
00700 s = cfg->readEntry( QString( "widget%1-tabTooltip" ).arg( i ) );
00701 if ( !s.isEmpty() )
00702 {
00703 dw->setToolTipString( s );
00704 }
00705 dw->manualDock( ( KDockWidget* ) parent(), KDockWidget::DockCenter );
00706 }
00707 if ( cfg->readBoolEntry( dwn, false ) )
00708 raise = dwn;
00709 i++;
00710
00711 }
00712
00713 QPtrList<KMultiTabBarTab>* tl = m_tb->tabs();
00714 QPtrListIterator<KMultiTabBarTab> it1( *tl );
00715 m_ws->hide();
00716 if ( !m_horizontal )
00717 parentDockWidget() ->setForcedFixedWidth( m_tb->width() );
00718 else
00719 parentDockWidget() ->setForcedFixedHeight( m_tb->height() );
00720 for ( ;it1.current() != 0;++it1 )
00721 {
00722 m_tb->setTab( it1.current() ->id(), false );
00723 }
00724 kapp->syncX();
00725 m_delayedRaise = -1;
00726
00727 for ( QMap<KDockWidget*, KDockButton_Private*>::iterator it = m_overlapButtons.begin();
00728 it != m_overlapButtons.end();++it )
00729 it.data() ->setOn( !isOverlapMode() );
00730
00731 if ( !raise.isEmpty() )
00732 {
00733 for ( QMap<KDockWidget*, int>::iterator it = m_map.begin();it != m_map.end();++it )
00734 {
00735 if ( it.key() ->name() == raise )
00736 {
00737
00738
00739
00740
00741
00742
00743
00744 m_delayedRaise = it.data();
00745 QTimer::singleShot( 0, this, SLOT( delayedRaise() ) );
00746 kdDebug( 760 ) << k_funcinfo << "raising" << it.key() ->name() << endl;
00747 break;
00748 }
00749 }
00750
00751 }
00752 if ( m_delayedRaise == -1 )
00753 QTimer::singleShot( 0, this, SLOT( init() ) );
00754 cfg->setGroup( grp );
00755
00756 }
00757
00758 void KMdiDockContainer::delayedRaise()
00759 {
00760 m_tb->setTab( m_delayedRaise, true );
00761 tabClicked( m_delayedRaise );
00762 }
00763
00764 void KMdiDockContainer::collapseOverlapped()
00765 {
00766
00767 if ( m_tabSwitching )
00768 return;
00769
00770 if ( isOverlapMode() )
00771 {
00772 QPtrList<KMultiTabBarTab>* tl = m_tb->tabs();
00773 QPtrListIterator<KMultiTabBarTab> it( *tl );
00774 for ( ;it.current();++it )
00775 {
00776 if ( it.current()->isOn() )
00777 {
00778 kdDebug( 760 ) << k_funcinfo << "lowering tab with id " << ( *it )->id() << endl;
00779 it.current()->setState( false );
00780 tabClicked( ( *it )->id() );
00781 }
00782 }
00783 }
00784 }
00785
00786 void KMdiDockContainer::toggle()
00787 {
00788 kdDebug( 760 ) << k_funcinfo << endl;
00789
00790 if ( m_tb->isTabRaised( oldtab ) )
00791 {
00792 kdDebug( 760 ) << k_funcinfo << "lowering tab" << endl;
00793 m_tb->setTab( oldtab, false );
00794 tabClicked( oldtab );
00795 KMdiMainFrm *mainFrm = dynamic_cast<KMdiMainFrm*>( m_mainWin );
00796 if ( mainFrm && mainFrm->activeWindow() )
00797 mainFrm->activeWindow()->setFocus();
00798 }
00799 else
00800 {
00801 kdDebug( 760 ) << k_funcinfo << "raising tab" << endl;
00802 if ( m_tb->tab( m_previousTab ) == 0 )
00803 {
00804 if ( m_tb->tabs() ->count() == 0 )
00805 return ;
00806
00807 m_previousTab = m_tb->tabs() ->getFirst() ->id();
00808 }
00809 m_tb->setTab( m_previousTab, true );
00810 tabClicked( m_previousTab );
00811 }
00812 }
00813
00814 void KMdiDockContainer::prevToolView()
00815 {
00816 kdDebug( 760 ) << k_funcinfo << endl;
00817 QPtrList<KMultiTabBarTab>* tabs = m_tb->tabs();
00818 int pos = tabs->findRef( m_tb->tab( oldtab ) );
00819
00820 if ( pos == -1 )
00821 return ;
00822
00823 pos--;
00824 if ( pos < 0 )
00825 pos = tabs->count() - 1;
00826
00827 KMultiTabBarTab *tab = tabs->at( pos );
00828 if ( !tab )
00829 return ;
00830
00831 m_tb->setTab( tab->id(), true );
00832 tabClicked( tab->id() );
00833 }
00834
00835 void KMdiDockContainer::nextToolView()
00836 {
00837 kdDebug( 760 ) << k_funcinfo << endl;
00838 QPtrList<KMultiTabBarTab>* tabs = m_tb->tabs();
00839 int pos = tabs->findRef( m_tb->tab( oldtab ) );
00840
00841 if ( pos == -1 )
00842 return ;
00843
00844 pos++;
00845 if ( pos >= ( int ) tabs->count() )
00846 pos = 0;
00847
00848 KMultiTabBarTab *tab = tabs->at( pos );
00849 if ( !tab )
00850 return ;
00851
00852 m_tb->setTab( tab->id(), true );
00853 tabClicked( tab->id() );
00854 }
00855
00856