Found and fixed problem of fastload of KAPI

1 files changed, 1 insertions, 1 deletions

diff --git a/microkde/kdeui/kmainwindow.cpp b/microkde/kdeui/kmainwindow.cpp
index 3a2a4d0..bd5a2cc 100644
--- a/microkde/kdeui/kmainwindow.cpp
+++ b/microkde/kdeui/kmainwindow.cpp
@@ -1,825 +1,825 @@
  /* This file is part of the KDE libraries
      Copyright
      (C) 2000 Reginald Stadlbauer (reggie@kde.org)
      (C) 1997 Stephan Kulow (coolo@kde.org)
      (C) 1997-2000 Sven Radej (radej@kde.org)
      (C) 1997-2000 Matthias Ettrich (ettrich@kde.org)
      (C) 1999 Chris Schlaeger (cs@kde.org)
      (C) 2002 Joseph Wenninger (jowenn@kde.org)
 
      This library is free software; you can redistribute it and/or
      modify it under the terms of the GNU Library General Public
      License version 2 as published by the Free Software Foundation.
 
      This library is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Library General Public License for more details.
 
      You should have received a copy of the GNU Library General Public License
      along with this library; see the file COPYING.LIB.  If not, write to
      the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      Boston, MA 02111-1307, USA.
  */
 #include <qobjectlist.h>
 #include <qstringlist.h>
 #include <qtimer.h>
 #include <qmenubar.h>
 #include <qstatusbar.h>
 #include <qapplication.h>
 
  
 #include "kdebug.h"
 #include "kmainwindow.h"
 #include "kglobalsettings.h"
 #include "kactioncollection.h"
 
 class KMainWindowPrivate {
 public:
 //US    bool showHelpMenu:1;
 
     bool autoSaveSettings:1;
     bool settingsDirty:1;
     bool autoSaveWindowSize:1;
     bool care_about_geometry:1;
     QString autoSaveGroup;
 //US    KAccel * kaccel;
 //US    KMainWindowInterface *m_interface;
     KDEPrivate::ToolBarHandler *toolBarHandler;
     QTimer* settingsTimer;
     KToggleAction *showStatusBarAction;
     QRect defaultWindowSize;
 };
 
 static bool no_query_exit = false;
 
 KMainWindow::KMainWindow( QWidget* parent, const char *name, WFlags f )
-    : QMainWindow( parent, name, f )/*US, KXMLGUIBuilder( this ), helpMenu2( 0 ), factory_( 0 )*/
+    : QMainWindow( parent, name ) /*LR, f ) with the default widget flag we cannot have fastload */ /*US, KXMLGUIBuilder( this ), helpMenu2( 0 ), factory_( 0 )*/
 {
     mQToolBar = 0;
     initKMainWindow(name);
 }
 
 void KMainWindow::parseGeometry(bool parsewidth)
 {
 //US the following code is not getting used in the embedded version !! So disable it for now   
 /*US    
     
     assert ( !kapp->geometryArgument().isNull() );
     assert ( d->care_about_geometry );
 
 #ifndef Q_WS_QWS
     // FIXME: (E) Implement something similar for Qt Embedded (or decide we don't need it)
     int x, y;
     int w, h;
     int m = XParseGeometry( kapp->geometryArgument().latin1(), &x, &y, (unsigned int*)&w, (unsigned int*)&h);
     if (parsewidth) {
         QSize minSize = minimumSize();
         QSize maxSize = maximumSize();
         if ( (m & WidthValue) == 0 )
             w = width();
         if ( (m & HeightValue) == 0 )
             h = height();
          w = QMIN(w,maxSize.width());
          h = QMIN(h,maxSize.height());
          w = QMAX(w,minSize.width());
          h = QMAX(h,minSize.height());
          resize(w, h);
     } else {
         if ( parsewidth && (m & XValue) == 0 )
             x = geometry().x();
         if ( parsewidth && (m & YValue) == 0 )
             y = geometry().y();
         if ( (m & XNegative) )
             x = KApplication::desktop()->width()  + x - w;
         if ( (m & YNegative) )
             y = KApplication::desktop()->height() + y - h;
         move(x, y);
     }
 #endif
 */    
 }
 
 KMainWindow::~KMainWindow()
 {
     delete d->settingsTimer;
     QMenuBar* mb = internalMenuBar();
     delete mb;
 //US    delete d->m_interface;
     
     delete d;
 //US    memberList->remove( this );
 }
 
 void KMainWindow::initKMainWindow(const char *name)
 {
     setDockMenuEnabled( FALSE );
 //US     mHelpMenu = 0;
     
 //US    kapp->setTopWidget( this );
     actionCollection()->setWidget( this );
 //US    connect(kapp, SIGNAL(shutDown()), this, SLOT(shuttingDown()));
 //US    if( !memberList )
 //US        memberList = new QPtrList<KMainWindow>;
 /*US    
 
     if ( !ksm )
         ksm = ksmd.setObject(new KMWSessionManaged());
     // set a unique object name. Required by session management.
     QCString objname;
     QCString s;
     int unusedNumber;
     if ( !name )
         { // no name given
         objname = kapp->instanceName() + "-mainwindow#";
         s = objname + '1'; // start adding number immediately
         unusedNumber = 1;
         }
     else if( name[ strlen( name ) - 1 ] == '#' )
         { // trailing # - always add a number
         objname = name;
         s = objname + '1'; // start adding number immediately
         unusedNumber = 1;
         }
     else
         {
         objname = name;
         s = objname;
         unusedNumber = 0; // add numbers only when needed
         }
     for(;;) {
         QWidgetList* list = kapp->topLevelWidgets();
         QWidgetListIt it( *list );
         bool found = false;
         for( QWidget* w = it.current();
              w != NULL;
              ++it, w = it.current())
             if( w != this && w->name() == s )
                 {
                 found = true;
                 break;
                 }
         delete list;
         if( !found )
             break;
         s.setNum( ++unusedNumber );
         s = objname + s;
     }
     setName( s );
     memberList->append( this );
 */
     
     d = new KMainWindowPrivate;
 //US    d->showHelpMenu = true;
     d->settingsDirty = false;
     d->autoSaveSettings = false;
     d->autoSaveWindowSize = true; // for compatibility
 //US    d->kaccel = actionCollection()->kaccel();
     d->toolBarHandler = 0;
     d->settingsTimer = 0;
     d->showStatusBarAction = NULL;
 /*US    
     if ((d->care_about_geometry == beeing_first)) {
         beeing_first = false;
         if ( kapp->geometryArgument().isNull() ) // if there is no geometry, it doesn't mater
             d->care_about_geometry = false;
         else
             parseGeometry(false);
     }
 */    
     d->care_about_geometry = false;
 
 //US    setCaption( kapp->caption() );
     // attach dcop interface
 //US    d->m_interface = new KMainWindowInterface(this);
 
 //US    if (!kapp->authorize("movable_toolbars"))
 //US        setDockWindowsMovable(false);
 }
 
 KAction *KMainWindow::toolBarMenuAction()
 {
   if ( !d->toolBarHandler )
     return 0;
 
   return d->toolBarHandler->toolBarMenuAction();
 }
 
 bool KMainWindow::canBeRestored( int number )
 {
 /*US we do not have and want to save sessioninformation. Use info from the default 
 application config.
 */
 //US    if ( !kapp->isRestored() )
 //US        return FALSE;
 //US    KConfig *config = kapp->sessionConfig();
     KConfig *config = KGlobal::config();
     if ( !config )
         return FALSE;
     config->setGroup( QString::fromLatin1("Number") );
     int n = config->readNumEntry( QString::fromLatin1("NumberOfWindows") , 1 );
     return number >= 1 && number <= n;
 
 }
 
 const QString KMainWindow::classNameOfToplevel( int number )
 {
 /*US we do not have and want to save sessioninformation. Use info from the default 
 application config.
 */
 //US    if ( !kapp->isRestored() )
 //US        return QString::null;
 //US    KConfig *config = kapp->sessionConfig();
     KConfig *config = KGlobal::config();
     if ( !config )
         return QString::null;
     QString s;
     s.setNum( number );
     s.prepend( QString::fromLatin1("WindowProperties") );
     config->setGroup( s );
     if ( !config->hasKey( QString::fromLatin1("ClassName") ) )
         return QString::null;
     else
         return config->readEntry( QString::fromLatin1("ClassName") );
 }
 
 bool KMainWindow::restore( int number, bool show )
 {
 /*US we do not have and want to save sessioninformation. Use info from the default 
 application config.
 */
     if ( !canBeRestored( number ) )
         return FALSE;
 //US    KConfig *config = kapp->sessionConfig();
     KConfig *config = KGlobal::config();
 
     if ( readPropertiesInternal( config, number ) ){
         if ( show )
             KMainWindow::show();
         return FALSE;
     }
     return FALSE;
     
 }
 
 void KMainWindow::setCaption( const QString &caption )
 {
 //US    setPlainCaption( kapp->makeStdCaption(caption) );
     setPlainCaption( caption );
 }
 
 void KMainWindow::setCaption( const QString &caption, bool modified )
 {
 //US    setPlainCaption( kapp->makeStdCaption(caption, true, modified) );
     setPlainCaption( caption + "modified:" );
 }
 
 void KMainWindow::setPlainCaption( const QString &caption )
 {
     QMainWindow::setCaption( caption );
 #ifndef Q_WS_QWS
 //US the following is disabled for the embedded version
 //US    NETWinInfo info( qt_xdisplay(), winId(), qt_xrootwin(), 0 );
 //US    info.setName( caption.utf8().data() );
 #endif
 }
 
 void KMainWindow::slotStateChanged(const QString &newstate)
 {
   stateChanged(newstate, KXMLGUIClient::StateNoReverse);
 }
 
 /*
  * Get rid of this for KDE 4.0
  */
 void KMainWindow::slotStateChanged(const QString &newstate,
                                    KXMLGUIClient::ReverseStateChange reverse)
 {
   stateChanged(newstate, reverse);
 }
 
 void KMainWindow::closeEvent ( QCloseEvent *e )
 {
     // Save settings if auto-save is enabled, and settings have changed
     if (d->settingsDirty && d->autoSaveSettings)
         saveAutoSaveSettings();
 
     if (queryClose()) {
         e->accept();
 
         int not_withdrawn = 0;
 /*US        
         QPtrListIterator<KMainWindow> it(*KMainWindow::memberList);
         for (it.toFirst(); it.current(); ++it){
             if ( !it.current()->isHidden() && it.current()->isTopLevel() && it.current() != this )
                 not_withdrawn++;
         }
 */
         if ( !no_query_exit && not_withdrawn <= 0 ) { // last window close accepted?
 /*US            
             if ( queryExit() && !kapp->sessionSaving()) {            // Yes, Quit app?
                 // don't call queryExit() twice
                 disconnect(kapp, SIGNAL(shutDown()), this, SLOT(shuttingDown()));
                 kapp->deref();             // ...and quit aplication.
             }  else {
                 // cancel closing, it's stupid to end up with no windows at all....
                 e->ignore();
             }
 */
 //US we have no sessionmanagement. Simply close app.
             if ( queryExit() ) {            // Yes, Quit app?
             qDebug("KMainWindow::closeEvent: Exit application ???");
                 // don't call queryExit() twice
 //US                disconnect(kapp, SIGNAL(shutDown()), this, SLOT(shuttingDown()));
             } 
             
         }
     }
 }
 
 bool KMainWindow::queryExit()
 {
     return TRUE;
 }
 
 bool KMainWindow::queryClose()
 {
     return TRUE;
 }
 
 void KMainWindow::saveGlobalProperties( KConfig*  )
 {
 }
 
 void KMainWindow::readGlobalProperties( KConfig*  )
 {
 }
 
 void KMainWindow::savePropertiesInternal( KConfig *config, int number )
 {
     bool oldASWS = d->autoSaveWindowSize;
     d->autoSaveWindowSize = true; // make saveMainWindowSettings save the window size
 
     QString s;
     s.setNum(number);
     s.prepend(QString::fromLatin1("WindowProperties"));
     config->setGroup(s);
 
     // store objectName, className, Width and Height  for later restoring
     // (Only useful for session management)
     config->writeEntry(QString::fromLatin1("ObjectName"), name());
     config->writeEntry(QString::fromLatin1("ClassName"), className());
 
     saveMainWindowSettings(config); // Menubar, statusbar and Toolbar settings.
 
     s.setNum(number);
     config->setGroup(s);
     saveProperties(config);
 
     d->autoSaveWindowSize = oldASWS;
 }
 
 void KMainWindow::setStandardToolBarMenuEnabled( bool enable )
 {
   if ( enable )
   {
     if ( d->toolBarHandler )
       return;
 
   d->toolBarHandler = new KDEPrivate::ToolBarHandler( this );
 
 /*US  if ( factory() )
     factory()->addClient( d->toolBarHandler );
 */    
   }
   else
   {
     if ( !d->toolBarHandler )
       return;
 /*US
     if ( factory() )
       factory()->removeClient( d->toolBarHandler );
 */
     delete d->toolBarHandler;
     d->toolBarHandler = 0;
   }
   
 }
 
 bool KMainWindow::isStandardToolBarMenuEnabled() const
 {
     return ( d->toolBarHandler != 0 );
 }
 
 void KMainWindow::createStandardStatusBarAction(){
   if(!d->showStatusBarAction){
     d->showStatusBarAction = KStdAction::showStatusbar(this, SLOT(setSettingsDirty()), actionCollection());
     connect(d->showStatusBarAction, SIGNAL(toggled(bool)), statusBar(), SLOT(setShown(bool)));
     if(internalStatusBar())
       d->showStatusBarAction->setChecked(!internalStatusBar()->isHidden());
   }
 }
 
 QToolBar *KMainWindow::tBar(  )
 {
     if  ( ! mQToolBar )
       mQToolBar =   new QToolBar( this );
     return mQToolBar;
 }
 
 KToolBar *KMainWindow::toolBar( const char * name )
 {
    
     if (!name)
        name = "mainToolBar";
     KToolBar *tb = (KToolBar*)child( name, "KToolBar" );
     if ( tb )
         return tb;
     bool honor_mode = (name == "mainToolBar");
 
 /*US
     if ( builderClient() )
         return new KToolBar(this, name, honor_mode); // XMLGUI constructor
     else
 */    
       return new KToolBar(this, Top, false, name, honor_mode ); // non-XMLGUI
 }
 
 QPtrListIterator<KToolBar> KMainWindow::toolBarIterator()
 {
     toolbarList.clear();
     QPtrList<QToolBar> lst;
     for ( int i = (int)QMainWindow::Unmanaged; i <= (int)Minimized; ++i ) {
         lst = toolBars( (ToolBarDock)i );
         for ( QToolBar *tb = lst.first(); tb; tb = lst.next() ) {
             if ( !tb->inherits( "KToolBar" ) )
                 continue;
             toolbarList.append( (KToolBar*)tb );
         }
     }
     return QPtrListIterator<KToolBar>( toolbarList );
 }
 
 void KMainWindow::setAutoSaveSettings( const QString & groupName, bool saveWindowSize )
 {
     d->autoSaveSettings = true;
     d->autoSaveGroup = groupName;
     d->autoSaveWindowSize = saveWindowSize;
     // Get notified when the user moves a toolbar around
 //US    connect( this, SIGNAL( dockWindowPositionChanged( QDockWindow * ) ),
 //US             this, SLOT( setSettingsDirty() ) );
     connect( this, SIGNAL( toolBarPositionChanged(QToolBar *) ),
              this, SLOT( setSettingsDirty() ) );
 
              
     // Get default values
 //US    int scnum = QApplication::desktop()->screenNumber(parentWidget());
 //US    QRect desk = QApplication::desktop()->screenGeometry(scnum);
     QRect desk = KGlobalSettings::desktopGeometry(0);
     
     d->defaultWindowSize = QRect(desk.width(), width(), desk.height(), height());
     // Now read the previously saved settings
     applyMainWindowSettings( KGlobal::config(), groupName );
 }
 
 
 void KMainWindow::resetAutoSaveSettings()
 {
     d->autoSaveSettings = false;
     if ( d->settingsTimer )
         d->settingsTimer->stop();
 }
 
 bool KMainWindow::autoSaveSettings() const
 {
     return d->autoSaveSettings;
 }
 
 QString KMainWindow::autoSaveGroup() const
 {
     return d->autoSaveGroup;
 }
 
 void KMainWindow::saveAutoSaveSettings()
 {
     ASSERT( d->autoSaveSettings );
     //kdDebug(200) << "KMainWindow::saveAutoSaveSettings -> saving settings" << endl;
     saveMainWindowSettings( KGlobal::config(), d->autoSaveGroup );
     KGlobal::config()->sync();
     d->settingsDirty = false;
     if ( d->settingsTimer )
         d->settingsTimer->stop();
 }
 
 void KMainWindow::createGUI( const QString &xmlfile, bool _conserveMemory )
 {
     // disabling the updates prevents unnecessary redraws
     setUpdatesEnabled( false );
 
     // just in case we are rebuilding, let's remove our old client
 //US    guiFactory()->removeClient( this );
 
     // make sure to have an empty GUI
     QMenuBar* mb = internalMenuBar();
     if ( mb )
         mb->clear();
 
     (void)toolBarIterator(); // make sure toolbarList is most-up-to-date
     toolbarList.setAutoDelete( true );
     toolbarList.clear();
     toolbarList.setAutoDelete( false );
 /*US
     // don't build a help menu unless the user ask for it
     if (d->showHelpMenu) {
         // we always want a help menu
         if (helpMenu2 == 0)
             helpMenu2 = new KHelpMenu(this, instance()->aboutData(), true,
                                       actionCollection());
     }
 
     // we always want to load in our global standards file
     setXMLFile( locate( "config", "ui/ui_standards.rc", instance() ) );
 
     // now, merge in our local xml file.  if this is null, then that
     // means that we will be only using the global file
     if ( !xmlfile.isNull() ) {
         setXMLFile( xmlfile, true );
     } else {
         QString auto_file(instance()->instanceName() + "ui.rc");
         setXMLFile( auto_file, true );
     }
 
     // make sure we don't have any state saved already
     setXMLGUIBuildDocument( QDomDocument() );
 
     // do the actual GUI building
     guiFactory()->addClient( this );
 
     // try and get back *some* of our memory
     if ( _conserveMemory )
     {
       // before freeing the memory allocated by the DOM document we also
       // free all memory allocated internally in the KXMLGUIFactory for
       // the menubar and the toolbars . This however implies that we
       // have to take care of deleting those widgets ourselves. For
       // destruction this is no problem, but when rebuilding we have
       // to take care of that (and we want to rebuild the GUI when
       // using stuff like the toolbar editor ).
       // In addition we have to take care of not removing containers
       // like popupmenus, defined in the XML document.
       // this code should probably go into a separate method in KMainWindow.
       // there's just one problem: I'm bad in finding names ;-) , so
       // I skipped this ;-)
 
       QDomDocument doc = domDocument();
 
       QDomElement e = doc.documentElement().firstChild().toElement();
       for (; !e.isNull(); e = e.nextSibling().toElement() ) {
           if ( e.tagName().lower() == "toolbar" )
               factory_->resetContainer( e.attribute( "name" ) );
           else if ( e.tagName().lower() == "menubar" )
               factory_->resetContainer( e.tagName(), true );
       }
 
       conserveMemory();
     }
 */
     setUpdatesEnabled( true );
     updateGeometry();
 }
 
 void KMainWindow::saveMainWindowSettings(KConfig *config, const QString &configGroup)
 {
     kdDebug(200) << "KMainWindow::saveMainWindowSettings " << configGroup << endl;
 //US    QStrList entryList;
     QStringList entryList;
     QString oldGroup;
 
     if (!configGroup.isEmpty())
     {
        oldGroup = config->group();
        config->setGroup(configGroup);
     }
 
     // Called by session management - or if we want to save the window size anyway
     if ( d->autoSaveWindowSize )
         saveWindowSize( config );
 
     QStatusBar* sb = internalStatusBar();
     if (sb) {
         entryList.clear();
         if ( sb->isHidden() )
             entryList.append("Disabled");
         else
             entryList.append("Enabled");
 
 	if(sb->isHidden())
 //US	  config->writeEntry(QString::fromLatin1("StatusBar"), entryList, ';');
 	  config->writeEntry(QString::fromLatin1("StatusBar"), entryList);
 	else
 	  config->deleteEntry(QString::fromLatin1("StatusBar"));
     }
 
     QMenuBar* mb = internalMenuBar();
     if (mb) {
         entryList.clear();
         if ( mb->isHidden() )
             entryList.append("Disabled");
         else
             entryList.append("Enabled");
 
 	// By default we don't hide.
 	if(mb->isHidden())
 //US	  config->writeEntry(QString::fromLatin1("MenuBar"), entryList, ';');
 	  config->writeEntry(QString::fromLatin1("MenuBar"), entryList);
 	else
 	  config->deleteEntry(QString::fromLatin1("MenuBar"));
     }
 
     int n = 1; // Toolbar counter. toolbars are counted from 1,
     KToolBar *toolbar = 0;
     QPtrListIterator<KToolBar> it( toolBarIterator() );
     while ( ( toolbar = it.current() ) ) {
         ++it;
         QString group;
         if (!configGroup.isEmpty())
         {
            // Give a number to the toolbar, but prefer a name if there is one,
            // because there's no real guarantee on the ordering of toolbars
            group = (!::qstrcmp(toolbar->name(), "unnamed") ? QString::number(n) : QString(" ")+toolbar->name());
            group.prepend(" Toolbar");
            group.prepend(configGroup);
         }
         toolbar->saveSettings(config, group);
         n++;
     }
     if (!configGroup.isEmpty())
        config->setGroup(oldGroup);
 }
 
 bool KMainWindow::readPropertiesInternal( KConfig *config, int number )
 {
     if ( number == 1 )
         readGlobalProperties( config );
 
     // in order they are in toolbar list
     QString s;
     s.setNum(number);
     s.prepend(QString::fromLatin1("WindowProperties"));
 
     config->setGroup(s);
 
     // restore the object name (window role)
     if ( config->hasKey(QString::fromLatin1("ObjectName" )) )
         setName( config->readEntry(QString::fromLatin1("ObjectName")).latin1()); // latin1 is right here
 
     applyMainWindowSettings(config); // Menubar, statusbar and toolbar settings.
 
     s.setNum(number);
     config->setGroup(s);
     readProperties(config);
     return true;
 }
 
 void KMainWindow::applyMainWindowSettings(KConfig *config, const QString &configGroup)
 {
     kdDebug(200) << "KMainWindow::applyMainWindowSettings" << endl;
     QString entry;
 //US    QStrList entryList;
     QStringList entryList;
     int i = 0; // Number of entries in list
 
     if (!configGroup.isEmpty())
        config->setGroup(configGroup);
 
     restoreWindowSize(config);
 
     QStatusBar* sb = internalStatusBar();
     if (sb) {
         entryList.clear();
 //US        i = config->readListEntry (QString::fromLatin1("StatusBar"), entryList, ';');
         entryList = config->readListEntry (QString::fromLatin1("StatusBar"));
         entry = entryList.first();
         if (entry == QString::fromLatin1("Disabled"))
            sb->hide();
         else
            sb->show();
 	if(d->showStatusBarAction)
 	   d->showStatusBarAction->setChecked(!sb->isHidden());
     }
 
     QMenuBar* mb = internalMenuBar();
     if (mb) {
         entryList.clear();
 //US        i = config->readListEntry (QString::fromLatin1("MenuBar"), entryList, ';');
         entryList = config->readListEntry (QString::fromLatin1("MenuBar"));
         entry = entryList.first();
         if (entry==QString::fromLatin1("Disabled"))
         {
             mb->hide(); 
         } else
         {
             mb->show();
         }
     }
 
         int n = 1; // Toolbar counter. toolbars are counted from 1,
         KToolBar *toolbar;
         QPtrListIterator<KToolBar> it( toolBarIterator() ); // must use own iterator
 
         for ( ; it.current(); ++it) {
             toolbar= it.current();
             QString group;
             if (!configGroup.isEmpty())
             {
                // Give a number to the toolbar, but prefer a name if there is one,
                // because there's no real guarantee on the ordering of toolbars
                group = (!::qstrcmp(toolbar->name(), "unnamed") ? QString::number(n) : QString(" ")+toolbar->name());
                group.prepend(" Toolbar");
                group.prepend(configGroup);
             }
             toolbar->applySettings(config, group);
             n++;
         }
 
     finalizeGUI( true );
     }
 
 void KMainWindow::finalizeGUI( bool force )
 {
     //kdDebug(200) << "KMainWindow::finalizeGUI force=" << force << endl;
     // The whole reason for this is that moveToolBar relies on the indexes
     // of the other toolbars, so in theory it should be called only once per
     // toolbar, but in increasing order of indexes.
     // Since we can't do that immediately, we move them, and _then_
     // we call positionYourself again for each of them, but this time
     // the toolbariterator should give them in the proper order.
     // Both the XMLGUI and applySettings call this, hence "force" for the latter.
     QPtrListIterator<KToolBar> it( toolBarIterator() );
     for ( ; it.current() ; ++ it )
             it.current()->positionYourself( force );
 
     d->settingsDirty = false;
 }
 
 void KMainWindow::saveWindowSize( KConfig * config ) const
 {
 /*US  
   int scnum = QApplication::desktop()->screenNumber(parentWidget());
   QRect desk = QApplication::desktop()->screenGeometry(scnum);
 */
   QRect desk = KGlobalSettings::desktopGeometry(0);
   
   QRect size( desk.width(), width(), desk.height(), height() );
   if(size != d->defaultWindowSize){
     config->writeEntry(QString::fromLatin1("Width %1").arg(desk.width()), width() );
     config->writeEntry(QString::fromLatin1("Height %1").arg(desk.height()), height() );
   }
   else{
     config->deleteEntry(QString::fromLatin1("Width %1").arg(desk.width()));
     config->deleteEntry(QString::fromLatin1("Height %1").arg(desk.height()));
   }
 }
 
 void KMainWindow::restoreWindowSize( KConfig * config )
 {
     if (d->care_about_geometry) {
         parseGeometry(true);
     } else {
         // restore the size
 /*US        int scnum = QApplication::desktop()->screenNumber(parentWidget());
         QRect desk = QApplication::desktop()->screenGeometry(scnum);
 */        
         QRect desk = KGlobalSettings::desktopGeometry(0);
         
         QSize size( config->readNumEntry( QString::fromLatin1("Width %1").arg(desk.width()), 0 ),
                     config->readNumEntry( QString::fromLatin1("Height %1").arg(desk.height()), 0 ) );
         if (size.isEmpty()) {
             // try the KDE 2.0 way
             size = QSize( config->readNumEntry( QString::fromLatin1("Width"), 0 ),
                           config->readNumEntry( QString::fromLatin1("Height"), 0 ) );
             if (!size.isEmpty()) {
                 // make sure the other resolutions don't get old settings
                 config->writeEntry( QString::fromLatin1("Width"), 0 );
                 config->writeEntry( QString::fromLatin1("Height"), 0 );
             }
         }
         if ( !size.isEmpty() )
             resize( size );
     }
 }
 
 bool KMainWindow::initialGeometrySet() const
 {
     return d->care_about_geometry;
 }
 
 void KMainWindow::ignoreInitialGeometry()
 {
     d->care_about_geometry = false;
 }
 
 void KMainWindow::setSettingsDirty()
 {
     //kdDebug(200) << "KMainWindow::setSettingsDirty" << endl;
     d->settingsDirty = true;