Diffstat (limited to 'microkde/kdeui/kmainwindow.cpp') (more/less context) (ignore whitespace changes)
| -rw-r--r-- | microkde/kdeui/kmainwindow.cpp | 994 |
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 ); } |