tdemainwindow.h

/*
    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., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 
 
*/
 
#ifndef TDEMAINWINDOW_H
#define TDEMAINWINDOW_H
 
#include "kxmlguifactory.h"
#include "kxmlguiclient.h"
#include "kxmlguibuilder.h"
#include <tqmainwindow.h>
#include <tqmetaobject.h>
#include <tdetoolbar.h>
 
class TDEPopupMenu;
class KXMLGUIFactory;
class TDEConfig;
class KHelpMenu;
class KStatusBar;
class TQStatusBar;
class KMenuBar;
class KMWSessionManaged;
class TDEMainWindowPrivate;
class TDEAccel;
class TDEToolBarMenuAction;
class DCOPObject;
 
#define KDE_DEFAULT_WINDOWFLAGS WType_TopLevel | WDestructiveClose
 
 
class TDEUI_EXPORT TDEMainWindow : public TQMainWindow, public KXMLGUIBuilder, virtual public KXMLGUIClient
{
    friend class KMWSessionManaged;
    TQ_OBJECT
 
public:
#ifdef qdoc
    TDEMainWindow( TQWidget* parent = 0, const char *name = 0, WFlags f = WType_TopLevel | WDestructiveClose );
#else
    TDEMainWindow( TQWidget* parent = 0, const char *name = 0, WFlags f = (WFlags)(WType_TopLevel | WDestructiveClose) );
#endif
 
    enum CreationFlags
    {
        NoDCOPObject = 1,
        NewRefCountMode = 2
    };
 
#ifdef qdoc
    TDEMainWindow( int cflags, TQWidget* parent = 0, const char *name = 0, WFlags f = WType_TopLevel | WDestructiveClose );
#else
    TDEMainWindow( int cflags, TQWidget* parent = 0, const char *name = 0, WFlags f = (WFlags)(WType_TopLevel | WDestructiveClose) );
#endif
 
    virtual ~TDEMainWindow();
 
    TDEPopupMenu* helpMenu( const TQString &aboutAppText = TQString::null,
              bool showWhatsThis = true );
 
    TDEPopupMenu* customHelpMenu( bool showWhatsThis = true );
 
    static bool canBeRestored( int number );
 
    // KDE 4 return TQCString - TQObject::className() returns const char*
    static const TQString classNameOfToplevel( int number );
 
    // KDE4 remove this method if this has been fixed in Qt
    virtual void show();
 
    // KDE4 remove this method if this has been fixed in Qt
    virtual void hide();
 
    bool restore( int number, bool show = true );
 
    virtual KXMLGUIFactory *guiFactory();
 
    void createGUI( const TQString &xmlfile = TQString::null, bool _conserveMemory = true );
 
    void setHelpMenuEnabled(bool showHelpMenu = true);
 
    bool isHelpMenuEnabled();
 
 
     bool hasMenuBar();
 
    KMenuBar *menuBar();
 
    KStatusBar *statusBar();
 
    static TQPtrList<TDEMainWindow>* memberList;
 
    //KDE4: replace with memberList() and make memberList member private
    static TQPtrList<TDEMainWindow>* getMemberList();
 
    TDEToolBar *toolBar( const char *name=0 );
 
    TQPtrListIterator<TDEToolBar> toolBarIterator();
 
    TDEAccel *accel();
 
    void setFrameBorderWidth( int ) {}
 
    void setAutoSaveSettings( const TQString & groupName = TQString::fromLatin1("MainWindow"),
                              bool saveWindowSize = true );
 
    void resetAutoSaveSettings();
 
    bool autoSaveSettings() const;
 
    TQString autoSaveGroup() const;
 
    void applyMainWindowSettings(TDEConfig *config, const TQString &groupName, bool force);
    // KDE4 merge with force=false
    void applyMainWindowSettings(TDEConfig *config, const TQString &groupName = TQString::null);
 
    void saveMainWindowSettings(TDEConfig *config, const TQString &groupName = TQString::null);
 
    void setStandardToolBarMenuEnabled( bool enable );
    bool isStandardToolBarMenuEnabled() const;
 
 
    void createStandardStatusBarAction();
 
    enum StandardWindowOptions
    {
        ToolBar = 1,
 
        Keys = 2,
 
        StatusBar = 4,
 
        Save = 8,
 
        Create = 16
    };
 
    void setupGUI( int options = ToolBar | Keys | StatusBar | Save | Create, const TQString& xmlfile = TQString::null );
 
    void setupGUI( TQSize defaultSize, int options = ToolBar | Keys | StatusBar | Save | Create, const TQString& xmlfile = TQString::null );
 
    TDEAction *toolBarMenuAction();
 
    void setupToolbarMenuActions();
 
    // why do we support old gcc versions? using KXMLGUIBuilder::finalizeGUI;
    virtual void finalizeGUI( KXMLGUIClient *client );
 
    void finalizeGUI( bool force );
 
    bool initialGeometrySet() const;
 
    void ignoreInitialGeometry();
 
    // KDE4 to be removed
    TQSize sizeForCentralWidgetSize(TQSize size) TDE_DEPRECATED;
 
    // KDE4 remove
    virtual void setIcon( const TQPixmap & );
 
public slots:
   int configureToolbars(); // TODO KDE4: make virtual and reimplement in KParts::MainWindow
 
    virtual void setCaption( const TQString &caption );
    virtual void setCaption( const TQString &caption, bool modified );
 
    virtual void setPlainCaption( const TQString &caption );
 
    void appHelpActivated( void );
 
    virtual void slotStateChanged(const TQString &newstate);
 
    void slotStateChanged(const TQString &newstate,
                          KXMLGUIClient::ReverseStateChange); // KDE 4.0: remove this
 
 
//     void slotStateChanged(const TQString &newstate,
//                           bool reverse); // KDE 4.0: enable this
 
    void setSettingsDirty();
 
protected:
    void paintEvent( TQPaintEvent* e );
    void childEvent( TQChildEvent* e);
    void resizeEvent( TQResizeEvent* e);
    virtual void closeEvent ( TQCloseEvent *);
 
    // 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 TDEApplication::shutDown(), which if nothing else
    // has at least better fitting name.
    // See also TDEApplication::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( TDEConfig* ) {}
 
    virtual void readProperties( TDEConfig* ) {}
 
    virtual void saveGlobalProperties( TDEConfig* sessionConfig );
 
    virtual void readGlobalProperties( TDEConfig* sessionConfig );
    void savePropertiesInternal( TDEConfig*, int );
    bool readPropertiesInternal( TDEConfig*, int );
 
    bool settingsDirty() const;
    TQString settingsGroup() const;
    void saveWindowSize( TDEConfig * config ) const;
    void restoreWindowSize( TDEConfig * config );
 
    void parseGeometry(bool parsewidth);
 
protected slots:
   void saveNewToolbarConfig(); // TODO KDE4: make virtual and reimplement in KParts::MainWindow
 
    virtual void showAboutApplication();
 
    void saveAutoSaveSettings();
 
private slots:
    void shuttingDown();
 
private:
    KMenuBar *internalMenuBar();
    KStatusBar *internalStatusBar();
    KHelpMenu *mHelpMenu, *helpMenu2;
    KXMLGUIFactory *factory_;
    TQPtrList<TDEToolBar> toolbarList;
protected:
    virtual void virtual_hook( int id, void* data );
private:
    TDEMainWindowPrivate *d;
    void initTDEMainWindow(const char *name, int cflags);
};
 
#define RESTORE(type) { int n = 1;\
    while (TDEMainWindow::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 ; TDEMainWindow::canBeRestored( n ) ; ++n ) {
    const TQString className = TDEMainWindow::classNameOfToplevel( n );
    if ( className == TQString::fromLatin1( 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 ; TDEMainWindow::canBeRestored( n ) ; ++n ) {
    const TQString className = TDEMainWindow::classNameOfToplevel( n );
    if ( className == TQString::fromLatin1( classNames[0] ) )
      (new T0)->restore( n );
    else if ( className == TQString::fromLatin1( 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 ; TDEMainWindow::canBeRestored( n ) ; ++n ) {
    const TQString className = TDEMainWindow::classNameOfToplevel( n );
    if ( className == TQString::fromLatin1( classNames[0] ) )
      (new T0)->restore( n );
    else if ( className == TQString::fromLatin1( classNames[1] ) )
      (new T1)->restore( n );
    else if ( className == TQString::fromLatin1( classNames[2] ) )
      (new T2)->restore( n );
  }
}
 
#endif