kmainwindow.h

Go to the documentation of this file.

/*
    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)
     (C) 2005-2006 Hamish Rodda (rodda@kde.org)
     (C) 2000-2008 David Faure (faure@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., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.


*/

#ifndef KMAINWINDOW_H
#define KMAINWINDOW_H

#include <kdeui_export.h>

#include <QtGui/QMainWindow>
#include <QtCore/QMetaClassInfo>

class KMenu;
class KConfig;
class KConfigGroup;
class KStatusBar;
class KMenuBar;
class KMWSessionManager;
class KMainWindowPrivate;
class KToolBar;

// internal, not public API, may change any time
#define KDEUI_DECLARE_PRIVATE(classname) \
    inline classname ## Private *k_func() { return reinterpret_cast<classname ## Private *>(k_ptr); } \
    inline const classname ## Private *k_func() const { return reinterpret_cast<classname ## Private *>(k_ptr); } \
    friend class classname ## Private;

// This is mostly from KDE3. TODO KDE5: remove the constructor parameter.
#define KDE_DEFAULT_WINDOWFLAGS 0

class KDEUI_EXPORT KMainWindow : public QMainWindow
{
    friend class KMWSessionManager;
    friend class DockResizeListener;
    KDEUI_DECLARE_PRIVATE(KMainWindow)
    Q_OBJECT
    Q_PROPERTY( bool hasMenuBar READ hasMenuBar )
    Q_PROPERTY( bool autoSaveSettings READ autoSaveSettings )
    Q_PROPERTY( QString autoSaveGroup READ autoSaveGroup )
    Q_PROPERTY( bool initialGeometrySet READ initialGeometrySet )

public:
    explicit KMainWindow( QWidget* parent = 0, Qt::WindowFlags f = KDE_DEFAULT_WINDOWFLAGS );

    virtual ~KMainWindow();

    KMenu* helpMenu( const QString &aboutAppText = QString(),
              bool showWhatsThis = true );

    KMenu* customHelpMenu( bool showWhatsThis = true );

    static bool canBeRestored( int number );

    static const QString classNameOfToplevel( int number );

    bool restore( int number, bool show = true );

     bool hasMenuBar();

    KMenuBar *menuBar();

    KStatusBar *statusBar();


    static QList<KMainWindow*> memberList();

    KToolBar *toolBar( const QString& name = QString() );

    QList<KToolBar*> toolBars() const;

    void setAutoSaveSettings( const QString & groupName = QLatin1String("MainWindow"),
                              bool saveWindowSize = true );

    void setAutoSaveSettings(const KConfigGroup & group,
                             bool saveWindowSize = true);

    void resetAutoSaveSettings();

    bool autoSaveSettings() const;

    QString autoSaveGroup() const;

    KConfigGroup autoSaveConfigGroup() const;

    virtual void applyMainWindowSettings( const KConfigGroup &config, bool forceGlobal = false);

    void saveMainWindowSettings(const KConfigGroup &config);

    bool initialGeometrySet() const;

    void ignoreInitialGeometry();

    QString dbusName() const;

public Q_SLOTS:
    virtual void setCaption( const QString &caption );
    virtual void setCaption( const QString &caption, bool modified );

    virtual void setPlainCaption( const QString &caption );

    void appHelpActivated( void );

    void setSettingsDirty();

protected:
    virtual bool event( QEvent * event );

    virtual void closeEvent ( QCloseEvent *);

    // KDE4 This seems to be flawed to me. Either the app has only one
    // mainwindow, so queryClose() is enough, or if it can have more of them,
    // then the windows should take care of themselves, and queryExit()
    // would be useful only for the annoying 'really quit' dialog, which
    // also doesn't make sense in apps with multiple mainwindows.
    // And saving configuration in something called queryExit()? IMHO
    // one can e.g. use QCoreApplication::aboutToQuit(), which if nothing else
    // has at least better fitting name.
    // See also KApplication::sessionSaving().
    // This stuff should get changed somehow, so that it at least doesn't
    // mess with session management.
    virtual bool queryExit();

    virtual bool queryClose();

    virtual void saveProperties( KConfigGroup & ) {}

    virtual void readProperties( const KConfigGroup & ) {}

    virtual void saveGlobalProperties( KConfig* sessionConfig );

    virtual void readGlobalProperties( KConfig* sessionConfig );
    void savePropertiesInternal( KConfig*, int );
    bool readPropertiesInternal( KConfig*, int );

    bool settingsDirty() const;
    void saveWindowSize( const KConfigGroup &config ) const;
    void restoreWindowSize( const KConfigGroup & config );

    void parseGeometry(bool parsewidth);

protected Q_SLOTS:
    virtual void showAboutApplication();

    void saveAutoSaveSettings();

protected:
    KMainWindow(KMainWindowPrivate &dd, QWidget *parent, Qt::WindowFlags f);

    KMainWindowPrivate * const k_ptr;
private:
    Q_PRIVATE_SLOT(k_func(), void _k_shuttingDown())
    Q_PRIVATE_SLOT(k_func(), void _k_slotSettingsChanged(int))
    Q_PRIVATE_SLOT(k_func(), void _k_slotSaveAutoSaveSize())
};

#define RESTORE(type) { int n = 1;\
    while (KMainWindow::canBeRestored(n)){\
      (new type)->restore(n);\
      n++;}}

#define KDE_RESTORE_MAIN_WINDOWS_NUM_TEMPLATE_ARGS 3

template <typename T>
inline void kRestoreMainWindows() {
  for ( int n = 1 ; KMainWindow::canBeRestored( n ) ; ++n ) {
    const QString className = KMainWindow::classNameOfToplevel( n );
    if ( className == QLatin1String( T::staticMetaObject.className() ) )
      (new T)->restore( n );
  }
}

template <typename T0, typename T1>
inline void kRestoreMainWindows() {
  const char * classNames[2];
  classNames[0] = T0::staticMetaObject.className();
  classNames[1] = T1::staticMetaObject.className();
  for ( int n = 1 ; KMainWindow::canBeRestored( n ) ; ++n ) {
    const QString className = KMainWindow::classNameOfToplevel( n );
    if ( className == QLatin1String( classNames[0] ) )
      (new T0)->restore( n );
    else if ( className == QLatin1String( classNames[1] ) )
      (new T1)->restore( n );
  }
}

template <typename T0, typename T1, typename T2>
inline void kRestoreMainWindows() {
  const char * classNames[3];
  classNames[0] = T0::staticMetaObject.className();
  classNames[1] = T1::staticMetaObject.className();
  classNames[2] = T2::staticMetaObject.className();
  for ( int n = 1 ; KMainWindow::canBeRestored( n ) ; ++n ) {
    const QString className = KMainWindow::classNameOfToplevel( n );
    if ( className == QLatin1String( classNames[0] ) )
      (new T0)->restore( n );
    else if ( className == QLatin1String( classNames[1] ) )
      (new T1)->restore( n );
    else if ( className == QLatin1String( classNames[2] ) )
      (new T2)->restore( n );
  }
}

#endif