| -rw-r--r-- | microkde/kdeui/kmainwindow.cpp | 11 | ||||
| -rw-r--r-- | microkde/kdeui/kmainwindow.h | 2 |
2 files changed, 7 insertions, 6 deletions
diff --git a/microkde/kdeui/kmainwindow.cpp b/microkde/kdeui/kmainwindow.cpp index 3ae4c87..fa678f2 100644 --- a/microkde/kdeui/kmainwindow.cpp +++ b/microkde/kdeui/kmainwindow.cpp @@ -1,312 +1,312 @@ /* 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 ) +KMainWindow::KMainWindow( QWidget* parent, const char *name ) : 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 ) { //qDebug("MainWindow::closeEvent "); // 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 @@ -594,402 +594,403 @@ void KMainWindow::saveMainWindowSettings(KConfig *config, const QString &configG 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 * ) +void KMainWindow::resizeEvent( QResizeEvent * e) { if ( d->autoSaveWindowSize ) - setSettingsDirty(); + setSettingsDirty(); + QMainWindow::resizeEvent( e ); } 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 * ) +void KMainWindow::paintEvent( QPaintEvent * e) { - // do nothing + QMainWindow::paintEvent( e ); } 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 ); } diff --git a/microkde/kdeui/kmainwindow.h b/microkde/kdeui/kmainwindow.h index 2aafb9d..2dc8033 100644 --- a/microkde/kdeui/kmainwindow.h +++ b/microkde/kdeui/kmainwindow.h @@ -1,353 +1,353 @@ /* This file is part of the KDE libraries 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. $Id$ */ #ifndef KMAINWINDOW_H #define KMAINWINDOW_H /*US #include "kxmlguifactory.h" #include "kxmlguiclient.h" #include "kxmlguibuilder.h" #include <qmetaobject.h> class KPopupMenu; class KXMLGUIFactory; class KConfig; class KHelpMenu; class KStatusBar; class QStatusBar; class KMenuBar; class KMWSessionManaged; class KAccel; class KToolBarMenuAction; */ class QMenuBar; class QStatusBar; class KMainWindowPrivate; class KAction; #include <ktoolbar.h> #include <ktoolbarhandler.h> #include <kxmlguiclient.h> #include <qmainwindow.h> #include <qptrlist.h> class KActionCollection; class KMainWindow : public QMainWindow, virtual public KXMLGUIClient { Q_OBJECT private: //US create private defaultconstructor KMainWindow() {;}; public: /** * Construct a main window. * * @param parent The widget parent. This is usually 0 but it may also be the window * group leader. In that case, the KMainWindow becomes sort of a * secondary window. * * @param name The object name. For session management and window management to work * properly, all main windows in the application should have a * different name. When passing 0 (the default), KMainWindow will create * a unique name, but it's recommended to explicitly pass a window name that will * also describe the type of the window. If there can be several windows of the same * type, append '#' (hash) to the name, and KMainWindow will append numbers to make * the names unique. For example, for a mail client which has one main window showing * the mails and folders, and which can also have one or more windows for composing * mails, the name for the folders window should be e.g. "mainwindow" and * for the composer windows "composer#". * * @param f Specify the widget flags. The default is * WType_TopLevel and WDestructiveClose. TopLevel indicates that a * main window is a toplevel window, regardless of whether it has a * parent or not. DestructiveClose indicates that a main window is * automatically destroyed when its window is closed. Pass 0 if * you do not want this behavior. * * KMainWindows must be created on the heap with 'new', like: * <pre> KMainWindow *kmw = new KMainWindow (...</pre> **/ //LR remove WDestructiveClose - KMainWindow( QWidget* parent = 0, const char *name = 0, WFlags f = WType_TopLevel /*| WDestructiveClose*/ ); + KMainWindow( QWidget* parent = 0, const char *name = 0 ); //, WFlags f = WType_TopLevel /*| WDestructiveClose*/ ; /** * Destructor. * * Will also destroy the toolbars, and menubar if * needed. */ virtual ~KMainWindow(); /** * Retrieve the standard help menu. * * It contains entires for the * help system (activated by F1), an optional "What's This?" entry * (activated by Shift F1), an application specific dialog box, * and an "About KDE" dialog box. * * Example (adding a standard help menu to your application): * <pre> * KPopupMenu *help = helpMenu( <myTextString> ); * menuBar()->insertItem( i18n("&Help"), help ); * </pre> * * @param aboutAppText The string that is used in the application * specific dialog box. If you leave this string empty the * information in the global @ref KAboutData of the * application will be used to make a standard dialog box. * * @param showWhatsThis Set this to false if you do not want to include * the "What's This" menu entry. * * @return A standard help menu. */ //US KPopupMenu* helpMenu( const QString &aboutAppText = QString::null, //US bool showWhatsThis = TRUE ); /** * Returns the help menu. Creates a standard help menu if none exists yet. * * It contains entries for the * help system (activated by F1), an optional "What's This?" entry * (activated by Shift F1), an application specific dialog box, * and an "About KDE" dialog box. You must create the application * specific dialog box yourself. When the "About application" * menu entry is activated, a signal will trigger the * @ref showAboutApplication slot. See @ref showAboutApplication for more * information. * * Example (adding a help menu to your application): * <pre> * menuBar()->insertItem( i18n("&Help"), customHelpMenu() ); * </pre> * * @param showWhatsThis Set this to @p false if you do not want to include * the "What's This" menu entry. * * @return A standard help menu. */ //US KPopupMenu* customHelpMenu( bool showWhatsThis = TRUE ); /** * @sect Session Management * * Try to restore the toplevel widget as defined by the number (1..X). * * If the session did not contain so high a number, the configuration * is not changed and @p false returned. * * That means clients could simply do the following: * <pre> * if (kapp->isRestored()){ * int n = 1; * while (KMainWindow::canBeRestored(n)){ * (new childMW)->restore(n); * n++; * } * } else { * // create default application as usual * } * </pre> * Note that @ref QWidget::show() is called implicitly in restore. * * With this you can easily restore all toplevel windows of your * application. * * If your application uses different kinds of toplevel * windows, then you can use @ref KMainWindow::classNameOfToplevel(n) * to determine the exact type before calling the childMW * constructor in the example from above. * * If your client has only one kind of toplevel widgets (which * should be pretty usual) then you should use the RESTORE-macro * for backwards compatibility with 3.1 and 3.0 branches: * * <pre> * if (kapp->isRestored()) * RESTORE(childMW) * else { * // create default application as usual * } * </pre> * * The macro expands to the term above but is easier to use and * less code to write. * * For new code or if you have more than one kind of toplevel * widget (each derived from @ref KMainWindow, of course), you can * use the templated @ref kRestoreMainWindows global functions: * * <pre> * if (kapp->isRestored()) * kRestoreMainWindows< childMW1, childMW2, childMW3 >(); * else { * // create default application as usual * } * </pre> * * Currently, these functions are provided for up to three * template arguments. If you need more, tell us. To help you in * deciding whether or not you can use @ref kRestoreMainWindows, a * define KDE_RESTORE_MAIN_WINDOWS_NUM_TEMPLATE_ARGS is provided. * * @see restore() * @see classNameOfToplevel() * **/ static bool canBeRestored( int number ); /** * Returns the @ref className() of the @p number of the toplevel window which * should be restored. * * This is only useful if your application uses * different kinds of toplevel windows. */ static const QString classNameOfToplevel( int number ); /** * Restore the session specified by @p number. * * Returns @p false if this * fails, otherwise returns @p true and shows the window. * You should call @ref canBeRestored() first. * If @p show is true (default), this widget will be shown automatically. */ bool restore( int number, bool show = TRUE ); //US virtual KXMLGUIFactory *guiFactory(); /** * Create a GUI given a local XML file. * * If @p xmlfile is NULL, * then it will try to construct a local XML filename like * appnameui.rc where 'appname' is your app's name. If that file * does not exist, then the XML UI code will only use the global * (standard) XML file for the layout purposes. * * Note that when passing true for the conserveMemory argument subsequent * calls to guiFactory()->addClient/removeClient may not work as expected. * Also retrieving references to containers like popup menus or toolbars using * the container method will not work. * * @param xmlfile The local xmlfile (relative or absolute) * @param _conserveMemory Specify whether createGUI() should call * @ref KXMLGuiClient::conserveMemory() to free all memory * allocated by the @ref QDomDocument and by the KXMLGUIFactory. */ void createGUI( const QString &xmlfile = QString::null, bool _conserveMemory = TRUE ); /** * Enables the build of a standard help menu when calling createGUI(). * * The default behavior is to build one, you must call this function * to disable it */ void setHelpMenuEnabled(bool showHelpMenu = true); /** * Return @p true when the help menu is enabled */ bool isHelpMenuEnabled(); /** * Returns true, if there is a menubar * @since 3.1 */ bool hasMenuBar(); /** * Returns a pointer to the menu bar. * * If there is no menu bar yet one will be created. **/ //US KMenuBar *menuBar(); QMenuBar *menuBar(); /** * Returns a pointer to the status bar. * * If there is no * status bar yet one will be created. */ //US KStatusBar *statusBar(); QStatusBar *statusBar(); /** * List of members of KMainWindow class. */ //US static QPtrList<KMainWindow>* memberList; /** * Returns a pointer to the toolbar with the specified name. * This refers to toolbars created dynamically from the XML UI * framework. If the toolbar does not exist one will be created. * * @param name The internal name of the toolbar. If no name is * specified "mainToolBar" is assumed. * * @return A pointer to the toolbar **/ KToolBar *toolBar( const char *name=0 ); // method for getting rid of KDE-Crap QToolBar *tBar( ); /** * @return An iterator over the list of all toolbars for this window. */ QPtrListIterator<KToolBar> toolBarIterator(); /** * @return A KAccel instance bound to this mainwindow. Used automatically * by KAction to make keybindings work in all cases. */ KAccel *accel(); void setFrameBorderWidth( int ) {} /** * Call this to enable "auto-save" of toolbar/menubar/statusbar settings * (and optionally window size). * If the *bars were moved around/shown/hidden when the window is closed, * saveMainWindowSettings( KGlobal::config(), groupName ) will be called. * * @param groupName a name that identifies this "type of window". * You can have several types of window in the same application. * * @param saveWindowSize set it to true to include the window size * when saving. * * Typically, you will call setAutoSaveSettings() in your * KMainWindow-inherited class constructor, and it will take care * of restoring and saving automatically. Make sure you call this * _after all_ your *bars have been created. |