1 files changed, 994 insertions, 0 deletions

diff --git a/microkde/kdeui/kmainwindow.cpp b/microkde/kdeui/kmainwindow.cpp
new file mode 100644
index 0000000..3a2a4d0
--- a/dev/null
+++ b/microkde/kdeui/kmainwindow.cpp
@@ -0,0 +1,994 @@
+ /* 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 )*/
+{
+    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;
+    if ( d->autoSaveSettings )
+    {
+        // Use a timer to save "immediately" user-wise, but not too immediately
+        // (to compress calls and save only once, in case of multiple changes)
+        if ( !d->settingsTimer )
+        {
+           d->settingsTimer = new QTimer( this );
+           connect( d->settingsTimer, SIGNAL( timeout() ), SLOT( saveAutoSaveSettings() ) );
+        }
+        d->settingsTimer->start( 500, true );
+    }
+}
+
+bool KMainWindow::settingsDirty() const
+{
+    return d->settingsDirty;
+}
+
+QString KMainWindow::settingsGroup() const
+{
+    return d->autoSaveGroup;
+}
+
+void KMainWindow::resizeEvent( QResizeEvent * )
+{
+    if ( d->autoSaveWindowSize )
+        setSettingsDirty();
+}
+
+bool KMainWindow::hasMenuBar()
+{
+        return (internalMenuBar());
+}
+
+//US KMenuBar *KMainWindow::menuBar()
+QMenuBar *KMainWindow::menuBar()
+{
+//US    KMenuBar * mb = internalMenuBar();
+    QMenuBar * mb = internalMenuBar();
+    if ( !mb ) {
+//US        mb = new KMenuBar( this );
+        mb = new QMenuBar( this );
+        // trigger a re-layout and trigger a call to the private
+        // setMenuBar method.
+        QMainWindow::menuBar();
+    }
+    return mb;
+}
+
+//US KStatusBar *KMainWindow::statusBar()
+QStatusBar *KMainWindow::statusBar()
+{
+//US    KStatusBar * sb = internalStatusBar();
+    QStatusBar * sb = internalStatusBar();
+    if ( !sb ) {
+//US        sb = new KStatusBar( this );
+        sb = new QStatusBar( this );
+        // trigger a re-layout and trigger a call to the private
+        // setStatusBar method.
+        QMainWindow::statusBar();
+    }
+    return sb;
+}
+
+void KMainWindow::shuttingDown()
+{
+    // Needed for Qt <= 3.0.3 at least to prevent reentrancy
+    // when queryExit() shows a dialog. Check before removing!
+    static bool reentrancy_protection = false;
+    if (!reentrancy_protection)
+    {
+       reentrancy_protection = true;
+       // call the virtual queryExit
+       queryExit();
+       reentrancy_protection = false;
+    }
+
+}
+
+//US KMenuBar *KMainWindow::internalMenuBar()
+QMenuBar *KMainWindow::internalMenuBar()
+{
+//US    QObjectList *l = queryList( "KMenuBar", 0, false, false );
+    QObjectList *l = queryList( "QMenuBar", 0, false, false );
+    if ( !l || !l->first() ) {
+        delete l;
+        return 0;
+    }
+
+//US    KMenuBar *m = (KMenuBar*)l->first();
+    QMenuBar *m = (QMenuBar*)l->first();
+    delete l;
+    return m;
+}
+
+//US KStatusBar *KMainWindow::internalStatusBar()
+QStatusBar *KMainWindow::internalStatusBar()
+{
+//US    QObjectList *l = queryList( "KStatusBar", 0, false, false );
+    QObjectList *l = queryList( "QStatusBar", 0, false, false );
+    if ( !l || !l->first() ) {
+        delete l;
+        return 0;
+    }
+
+//US    KStatusBar *s = (KStatusBar*)l->first();
+    QStatusBar *s = (QStatusBar*)l->first();
+    delete l;
+    return s;
+}
+
+void KMainWindow::childEvent( QChildEvent* e)
+{
+    QMainWindow::childEvent( e );
+}
+
+void KMainWindow::paintEvent( QPaintEvent * )
+{
+    // do nothing
+}
+
+QSize KMainWindow::sizeForCentralWidgetSize(QSize size)
+{
+    KToolBar *tb = (KToolBar*)child( "mainToolBar", "KToolBar" );
+    if (tb && !tb->isHidden()) {
+        switch( tb->barPos() )
+        {
+          case KToolBar::Top:
+          case KToolBar::Bottom:
+            size += QSize(0, tb->sizeHint().height());
+            break;
+
+          case KToolBar::Left:
+          case KToolBar::Right:
+            size += QSize(toolBar()->sizeHint().width(), 0);
+            break;
+
+          case KToolBar::Flat:
+//US            size += QSize(0, 3+kapp->style().pixelMetric( QStyle::PM_DockWindowHandleExtent ));
+            size += QSize(0, tb->sizeHint().height());
+            break;
+
+          default:
+            break;
+        }
+    }
+//US    KMenuBar *mb = menuBar();
+    QMenuBar *mb = menuBar();
+    if (!mb->isHidden()) {
+        size += QSize(0,mb->heightForWidth(size.width()));
+/*US        if (style().styleHint(QStyle::SH_MainWindow_SpaceBelowMenuBar, this))
+           size += QSize( 0, dockWindowsMovable() ? 1 : 2);
+*/           
+           size += QSize( 0, 2);
+    }
+    QStatusBar *sb = internalStatusBar();
+    if( sb && !sb->isHidden() )
+       size += QSize(0, sb->sizeHint().height());
+
+    return size;
+}
+
+// why do we support old gcc versions? using KXMLGUIBuilder::finalizeGUI;
+void KMainWindow::finalizeGUI( KXMLGUIClient *client )
+{ /*US KXMLGUIBuilder::finalizeGUI( client );*/ }
+
+void KMainWindow::virtual_hook( int id, void* data )
+{ /*US KXMLGUIBuilder::virtual_hook( id, data );*/
+  KXMLGUIClient::virtual_hook( id, data ); }