kmdi Library API Documentation

kmdidockcontainer.cpp

00001 /* This file is part of the KDE project
00002  Copyright (C) 2002 Christoph Cullmann <cullmann@kde.org>
00003  Copyright (C) 2002,2003 Joseph Wenninger <jowenn@kde.org>
00004 
00005  This library is free software; you can redistribute it and/or
00006  modify it under the terms of the GNU Library General Public
00007  License version 2 as published by the Free Software Foundation.
00008 
00009  This library is distributed in the hope that it will be useful,
00010  but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012  Library General Public License for more details.
00013 
00014  You should have received a copy of the GNU Library General Public License
00015  along with this library; see the file COPYING.LIB.  If not, write to
00016  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00017  Boston, MA 02111-1307, USA.
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 //TODO: Well, this is already defined in kdeui/kdockwidget.cpp
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 ); //vertical layout for top and bottom docks
00074     else
00075         l = new QHBoxLayout( this ); //horizontal layout for left and right docks
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     //layout the tabbar
00110     if ( position == KDockWidget::DockLeft || position == KDockWidget::DockTop )
00111     {
00112         //add the tabbar then the widget stack
00113         l->add( m_tb );
00114         l->add( m_ws );
00115     }
00116     else
00117     {
00118         //add the widget stack then the tabbar
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     // try to restore splitter size
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     //FB  m_ws->raiseWidget(tab);
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; //we don't have this widget in our container
00371 
00372     kdDebug( 760 ) << k_funcinfo << endl;
00373     //lower the tab. ( TODO: needed? )
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         // try save splitter position
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         //    oldtab=-1;
00473         if ( m_block )
00474             return ;
00475         emit deactivated( this );
00476         m_block = true;
00477         if ( m_ws->widget( t ) )
00478         {
00479             //    ((KDockWidget*)m_ws->widget(t))->undock();
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() ); // strange why it worked before at all
00488         else
00489             parentDockWidget()->setForcedFixedHeight( m_tb->height() ); // strange why it worked before at all
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     // try to save the splitter position
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         //    cfg->writeEntry(QString("widget%1").arg(i),m_ws->widget(it.current()->id())->name());
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         //    kdDebug(760)<<"****************************************Saving: "<<m_ws->widget(it.current()->id())->name()<<endl;
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                 /*        tabClicked(it.data());
00738                         m_tb->setTab(it.data(),true);
00739                         tabClicked(it.data());
00740                         m_ws->raiseWidget(it.key());
00741                         kapp->sendPostedEvents();
00742                         kapp->syncX();*/
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     //don't collapse if we're switching tabs
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 ; //can never happen here, but who knows
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 ; //can never happen here, but who knows
00851     
00852     m_tb->setTab( tab->id(), true );
00853     tabClicked( tab->id() );
00854 }
00855 
00856 // kate: space-indent off; tab-width 4; replace-tabs off; indent-mode csands;
KDE Logo
This file is part of the documentation for kmdi Library Version 3.4.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Fri Jul 21 13:15:04 2006 by doxygen 1.4.0 written by Dimitri van Heesch, © 1997-2003