pwmpi windows management fixes

2 files changed, 4 insertions, 2 deletions

diff --git a/microkde/kdeui/kmainwindow.cpp b/microkde/kdeui/kmainwindow.cpp
index bd5a2cc..3ae4c87 100644
--- a/microkde/kdeui/kmainwindow.cpp
+++ b/microkde/kdeui/kmainwindow.cpp
@@ -175,256 +175,257 @@ void KMainWindow::initKMainWindow(const char *name)
     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        
         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 )
diff --git a/microkde/kdeui/kmainwindow.h b/microkde/kdeui/kmainwindow.h
index e76e732..2aafb9d 100644
--- a/microkde/kdeui/kmainwindow.h
+++ b/microkde/kdeui/kmainwindow.h
@@ -1,224 +1,225 @@
 /*
     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:
+
 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>
      **/
-    KMainWindow( QWidget* parent = 0, const char *name = 0, WFlags f = WType_TopLevel | WDestructiveClose );
+    //LR remove  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 );