summaryrefslogtreecommitdiffabout
path: root/microkde/kdeui/kmainwindow.cpp
authorzautrix <zautrix>2004-06-26 19:01:18 (UTC)
committer zautrix <zautrix>2004-06-26 19:01:18 (UTC)
commitb9aad1f15dc600e4dbe4c62d3fcced6363188ba3 (patch) (side-by-side diff)
tree2c3d4004fb21c72cba65793859f9bcd8ffd3a49c /microkde/kdeui/kmainwindow.cpp
downloadkdepimpi-b9aad1f15dc600e4dbe4c62d3fcced6363188ba3.zip
kdepimpi-b9aad1f15dc600e4dbe4c62d3fcced6363188ba3.tar.gz
kdepimpi-b9aad1f15dc600e4dbe4c62d3fcced6363188ba3.tar.bz2
Initial revision
Diffstat (limited to 'microkde/kdeui/kmainwindow.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r--microkde/kdeui/kmainwindow.cpp994
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 ); }