00001  
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
00023 
00024 #include "config.h"
00025 
00026 #include "kmainwindow.h"
00027 #include "kmainwindowiface.h"
00028 #include "ktoolbarhandler.h"
00029 #include <qsessionmanager.h>
00030 #include <qobjectlist.h>
00031 #include <qstyle.h>
00032 #include <qlayout.h>
00033 #include <qwidgetlist.h>
00034 #include <qtimer.h>
00035 
00036 #include <kaccel.h>
00037 #include <kaction.h>
00038 #include <kapplication.h>
00039 #include <kconfig.h>
00040 #include <kdebug.h>
00041 #include <khelpmenu.h>
00042 #include <kmenubar.h>
00043 #include <kstatusbar.h>
00044 #include <kwin.h>
00045 
00046 #include <klocale.h>
00047 #include <kstandarddirs.h>
00048 #include <kstaticdeleter.h>
00049 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00050 #include <netwm.h>
00051 #endif
00052 
00053 #include <stdlib.h>
00054 #include <ctype.h>
00055 #include <assert.h>
00056 
00057 class KMainWindowPrivate {
00058 public:
00059     bool showHelpMenu:1;
00060 
00061     bool autoSaveSettings:1;
00062     bool settingsDirty:1;
00063     bool autoSaveWindowSize:1;
00064     bool care_about_geometry:1;
00065     bool shuttingDown:1;
00066     QString autoSaveGroup;
00067     KAccel * kaccel;
00068     KMainWindowInterface *m_interface;
00069     KDEPrivate::ToolBarHandler *toolBarHandler;
00070     QTimer* settingsTimer;
00071     KToggleAction *showStatusBarAction;
00072     QRect defaultWindowSize;
00073     QPtrList<QDockWindow> hiddenDockWindows;
00074 };
00075 
00076 QPtrList<KMainWindow>* KMainWindow::memberList = 0L;
00077 static bool no_query_exit = false;
00078 static KMWSessionManaged* ksm = 0;
00079 static KStaticDeleter<KMWSessionManaged> ksmd;
00080 
00081 class KMWSessionManaged : public KSessionManaged
00082 {
00083 public:
00084     KMWSessionManaged()
00085     {
00086     };
00087     ~KMWSessionManaged()
00088     {
00089     }
00090     bool saveState( QSessionManager& )
00091     {
00092         KConfig* config = KApplication::kApplication()->sessionConfig();
00093         if ( KMainWindow::memberList->first() ){
00094             
00095             
00096             KMainWindow::memberList->first()->saveGlobalProperties(config);
00097         }
00098 
00099         QPtrListIterator<KMainWindow> it(*KMainWindow::memberList);
00100         int n = 0;
00101         for (it.toFirst(); it.current(); ++it){
00102             if( it.current()->isVisible()) {
00103                 n++;
00104                 it.current()->savePropertiesInternal(config, n);
00105             }
00106         }
00107         config->setGroup(QString::fromLatin1("Number"));
00108         config->writeEntry(QString::fromLatin1("NumberOfWindows"), n );
00109         return true;
00110     }
00111 
00112     bool commitData( QSessionManager& sm )
00113     {
00114         
00115         if ( sm.allowsInteraction() ) {
00116             bool canceled = false;
00117             QPtrListIterator<KMainWindow> it(*KMainWindow::memberList);
00118             ::no_query_exit = true;
00119             for (it.toFirst(); it.current() && !canceled;){
00120                 KMainWindow *window = *it;
00121                 ++it; 
00122                 if ( window->isVisible()) {
00123                     QCloseEvent e;
00124                     QApplication::sendEvent( window, &e );
00125                     canceled = !e.isAccepted();
00126             
00127 
00128 
00129 
00130 
00131 
00132 
00133 
00134 
00135 
00136 
00137 
00138 
00139 
00140                 }
00141             }
00142             ::no_query_exit = false;
00143             if (canceled)
00144                return false;
00145 
00146             KMainWindow* last = 0;
00147             for (it.toFirst(); it.current() && !canceled; ++it){
00148                 KMainWindow *window = *it;
00149                 if ( window->isVisible()) {
00150                     last = window;
00151                 }
00152             }
00153             if ( last )
00154                 return last->queryExit();
00155             
00156             return true;
00157         }
00158 
00159         
00160         return true;
00161     }
00162 };
00163 
00164 static bool being_first = true;
00165 
00166 KMainWindow::KMainWindow( QWidget* parent, const char *name, WFlags f )
00167     : QMainWindow( parent, name, f ), KXMLGUIBuilder( this ), helpMenu2( 0 ), factory_( 0 )
00168 {
00169     initKMainWindow(name, 0);
00170 }
00171 
00172 KMainWindow::KMainWindow( int cflags, QWidget* parent, const char *name, WFlags f )
00173     : QMainWindow( parent, name, f ), KXMLGUIBuilder( this ), helpMenu2( 0 ), factory_( 0 )
00174 {
00175     initKMainWindow(name, cflags);
00176 }
00177 
00178 void KMainWindow::initKMainWindow(const char *name, int cflags)
00179 {
00180     setDockMenuEnabled( false );
00181     mHelpMenu = 0;
00182     kapp->setTopWidget( this );
00183     actionCollection()->setWidget( this );
00184     connect(kapp, SIGNAL(shutDown()), this, SLOT(shuttingDown()));
00185     if( !memberList )
00186         memberList = new QPtrList<KMainWindow>;
00187 
00188     if ( !ksm )
00189         ksm = ksmd.setObject(ksm, new KMWSessionManaged());
00190     
00191     QCString objname;
00192     QCString s;
00193     int unusedNumber;
00194     if ( !name )
00195         { 
00196         objname = kapp->instanceName() + "-mainwindow#";
00197         s = objname + '1'; 
00198         unusedNumber = 1;
00199         }
00200     else if( name[ strlen( name ) - 1 ] == '#' )
00201         { 
00202         objname = name;
00203         s = objname + '1'; 
00204         unusedNumber = 1;
00205         }
00206     else
00207         {
00208         objname = name;
00209         s = objname;
00210         unusedNumber = 0; 
00211         }
00212     for(;;) {
00213         QWidgetList* list = kapp->topLevelWidgets();
00214         QWidgetListIt it( *list );
00215         bool found = false;
00216         for( QWidget* w = it.current();
00217              w != NULL;
00218              ++it, w = it.current())
00219             if( w != this && w->name() == s )
00220                 {
00221                 found = true;
00222                 break;
00223                 }
00224         delete list;
00225         if( !found )
00226             break;
00227         s.setNum( ++unusedNumber );
00228         s = objname + s;
00229     }
00230     setName( s );
00231 
00232     memberList->append( this );
00233 
00234     d = new KMainWindowPrivate;
00235     d->showHelpMenu = true;
00236     d->settingsDirty = false;
00237     d->autoSaveSettings = false;
00238     d->autoSaveWindowSize = true; 
00239     d->kaccel = actionCollection()->kaccel();
00240     d->toolBarHandler = 0;
00241     d->settingsTimer = 0;
00242     d->showStatusBarAction = NULL;
00243     d->shuttingDown = false;
00244     if ((d->care_about_geometry = being_first)) {
00245         being_first = false;
00246         if ( kapp->geometryArgument().isNull() ) 
00247             d->care_about_geometry = false;
00248         else
00249             parseGeometry(false);
00250     }
00251 
00252     setCaption( kapp->caption() );
00253     if ( cflags & NoDCOPObject)
00254         d->m_interface = 0;
00255     else
00256         d->m_interface = new KMainWindowInterface(this);
00257 
00258     if (!kapp->authorize("movable_toolbars"))
00259         setDockWindowsMovable(false);
00260 }
00261 
00262 KAction *KMainWindow::toolBarMenuAction()
00263 {
00264     if ( !d->toolBarHandler )
00265     return 0;
00266 
00267     return d->toolBarHandler->toolBarMenuAction();
00268 }
00269 
00270 void KMainWindow::parseGeometry(bool parsewidth)
00271 {
00272     assert ( !kapp->geometryArgument().isNull() );
00273     assert ( d->care_about_geometry );
00274 
00275 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00276 
00277     
00278     int x, y;
00279     int w, h;
00280     int m = XParseGeometry( kapp->geometryArgument().latin1(), &x, &y, (unsigned int*)&w, (unsigned int*)&h);
00281     if (parsewidth) {
00282         QSize minSize = minimumSize();
00283         QSize maxSize = maximumSize();
00284         if ( (m & WidthValue) == 0 )
00285             w = width();
00286         if ( (m & HeightValue) == 0 )
00287             h = height();
00288          w = QMIN(w,maxSize.width());
00289          h = QMIN(h,maxSize.height());
00290          w = QMAX(w,minSize.width());
00291          h = QMAX(h,minSize.height());
00292          resize(w, h);
00293     } else {
00294         if ( parsewidth && (m & XValue) == 0 )
00295             x = geometry().x();
00296         if ( parsewidth && (m & YValue) == 0 )
00297             y = geometry().y();
00298         if ( (m & XNegative) )
00299             x = KApplication::desktop()->width()  + x - w;
00300         if ( (m & YNegative) )
00301             y = KApplication::desktop()->height() + y - h;
00302         move(x, y);
00303     }
00304 #endif
00305 }
00306 
00307 KMainWindow::~KMainWindow()
00308 {
00309     delete d->settingsTimer;
00310     QMenuBar* mb = internalMenuBar();
00311     delete mb;
00312     delete d->m_interface;
00313     delete d;
00314     memberList->remove( this );
00315 }
00316 
00317 KPopupMenu* KMainWindow::helpMenu( const QString &aboutAppText, bool showWhatsThis )
00318 {
00319     if( mHelpMenu == 0 ) {
00320         if ( aboutAppText.isEmpty() )
00321             mHelpMenu = new KHelpMenu( this, instance()->aboutData(), showWhatsThis);
00322         else
00323             mHelpMenu = new KHelpMenu( this, aboutAppText, showWhatsThis );
00324 
00325         if ( mHelpMenu == 0 )
00326             return 0;
00327         connect( mHelpMenu, SIGNAL( showAboutApplication() ),
00328                  this, SLOT( showAboutApplication() ) );
00329     }
00330 
00331     return mHelpMenu->menu();
00332 }
00333 
00334 KPopupMenu* KMainWindow::customHelpMenu( bool showWhatsThis )
00335 {
00336     if( mHelpMenu == 0 ) {
00337         mHelpMenu = new KHelpMenu( this, QString::null, showWhatsThis );
00338         connect( mHelpMenu, SIGNAL( showAboutApplication() ),
00339                  this, SLOT( showAboutApplication() ) );
00340     }
00341 
00342     return mHelpMenu->menu();
00343 }
00344 
00345 bool KMainWindow::canBeRestored( int number )
00346 {
00347     if ( !kapp->isRestored() )
00348         return false;
00349     KConfig *config = kapp->sessionConfig();
00350     if ( !config )
00351         return false;
00352     config->setGroup( QString::fromLatin1("Number") );
00353     int n = config->readNumEntry( QString::fromLatin1("NumberOfWindows") , 1 );
00354     return number >= 1 && number <= n;
00355 }
00356 
00357 const QString KMainWindow::classNameOfToplevel( int number )
00358 {
00359     if ( !kapp->isRestored() )
00360         return QString::null;
00361     KConfig *config = kapp->sessionConfig();
00362     if ( !config )
00363         return QString::null;
00364     QString s;
00365     s.setNum( number );
00366     s.prepend( QString::fromLatin1("WindowProperties") );
00367     config->setGroup( s );
00368     if ( !config->hasKey( QString::fromLatin1("ClassName") ) )
00369         return QString::null;
00370     else
00371         return config->readEntry( QString::fromLatin1("ClassName") );
00372 }
00373 
00374 void KMainWindow::show()
00375 {
00376     QMainWindow::show();
00377 
00378     for ( QPtrListIterator<QDockWindow> it( d->hiddenDockWindows ); it.current(); ++it )
00379     it.current()->show();
00380 
00381     d->hiddenDockWindows.clear();
00382 }
00383 
00384 void KMainWindow::hide()
00385 {
00386     if ( isVisible() ) {
00387 
00388         d->hiddenDockWindows.clear();
00389 
00390         QObjectList *list = queryList( "QDockWindow" );
00391         for( QObjectListIt it( *list ); it.current(); ++it ) {
00392             QDockWindow *dw = (QDockWindow*)it.current();
00393             if ( dw->isTopLevel() && dw->isVisible() ) {
00394                 d->hiddenDockWindows.append( dw );
00395                 dw->hide();
00396             }
00397         }
00398         delete list;
00399     }
00400 
00401     QWidget::hide();
00402 }
00403 
00404 bool KMainWindow::restore( int number, bool show )
00405 {
00406     if ( !canBeRestored( number ) )
00407         return false;
00408     KConfig *config = kapp->sessionConfig();
00409     if ( readPropertiesInternal( config, number ) ){
00410         if ( show )
00411             KMainWindow::show();
00412         return false;
00413     }
00414     return false;
00415 }
00416 
00417 KXMLGUIFactory *KMainWindow::guiFactory()
00418 {
00419     if ( !factory_ )
00420         factory_ = new KXMLGUIFactory( this, this, "guifactory" );
00421     return factory_;
00422 }
00423 
00424 void KMainWindow::createGUI( const QString &xmlfile, bool _conserveMemory )
00425 {
00426     
00427     setUpdatesEnabled( false );
00428 
00429     
00430     guiFactory()->removeClient( this );
00431 
00432     
00433     QMenuBar* mb = internalMenuBar();
00434     if ( mb )
00435         mb->clear();
00436 
00437     (void)toolBarIterator(); 
00438     toolbarList.setAutoDelete( true );
00439     toolbarList.clear();
00440     toolbarList.setAutoDelete( false );
00441 
00442     
00443     if (d->showHelpMenu) {
00444         
00445         if (helpMenu2 == 0)
00446             helpMenu2 = new KHelpMenu(this, instance()->aboutData(), true,
00447                                       actionCollection());
00448     }
00449 
00450     
00451     setXMLFile( locate( "config", "ui/ui_standards.rc", instance() ) );
00452 
00453     
00454     
00455     if ( !xmlfile.isNull() ) {
00456         setXMLFile( xmlfile, true );
00457     } else {
00458         QString auto_file(instance()->instanceName() + "ui.rc");
00459         setXMLFile( auto_file, true );
00460     }
00461 
00462     
00463     setXMLGUIBuildDocument( QDomDocument() );
00464 
00465     
00466     guiFactory()->addClient( this );
00467 
00468     
00469     if ( _conserveMemory )
00470     {
00471       
00472       
00473       
00474       
00475       
00476       
00477       
00478       
00479       
00480       
00481       
00482       
00483 
00484       QDomDocument doc = domDocument();
00485 
00486       QDomElement e = doc.documentElement().firstChild().toElement();
00487       for (; !e.isNull(); e = e.nextSibling().toElement() ) {
00488           if ( e.tagName().lower() == "toolbar" )
00489               factory_->resetContainer( e.attribute( "name" ) );
00490           else if ( e.tagName().lower() == "menubar" )
00491               factory_->resetContainer( e.tagName(), true );
00492       }
00493 
00494       conserveMemory();
00495     }
00496 
00497     setUpdatesEnabled( true );
00498     updateGeometry();
00499 }
00500 
00501 void KMainWindow::setHelpMenuEnabled(bool showHelpMenu)
00502 {
00503     d->showHelpMenu = showHelpMenu;
00504 }
00505 
00506 bool KMainWindow::isHelpMenuEnabled()
00507 {
00508     return d->showHelpMenu;
00509 }
00510 
00511 void KMainWindow::setCaption( const QString &caption )
00512 {
00513     setPlainCaption( kapp->makeStdCaption(caption) );
00514 }
00515 
00516 void KMainWindow::setCaption( const QString &caption, bool modified )
00517 {
00518     setPlainCaption( kapp->makeStdCaption(caption, true, modified) );
00519 }
00520 
00521 void KMainWindow::setPlainCaption( const QString &caption )
00522 {
00523     QMainWindow::setCaption( caption );
00524 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00525 
00526     NETWinInfo info( qt_xdisplay(), winId(), qt_xrootwin(), 0 );
00527     info.setName( caption.utf8().data() );
00528 #endif
00529 }
00530 
00531 void KMainWindow::appHelpActivated( void )
00532 {
00533     if( mHelpMenu == 0 ) {
00534         mHelpMenu = new KHelpMenu( this );
00535         if ( mHelpMenu == 0 )
00536             return;
00537     }
00538     mHelpMenu->appHelpActivated();
00539 }
00540 
00541 void KMainWindow::slotStateChanged(const QString &newstate)
00542 {
00543   stateChanged(newstate, KXMLGUIClient::StateNoReverse);
00544 }
00545 
00546 
00547 
00548 
00549 void KMainWindow::slotStateChanged(const QString &newstate,
00550                                    KXMLGUIClient::ReverseStateChange reverse)
00551 {
00552   stateChanged(newstate, reverse);
00553 }
00554 
00555 
00556 
00557 
00558 
00559 
00560 
00561 
00562 
00563 
00564 
00565 void KMainWindow::closeEvent ( QCloseEvent *e )
00566 {
00567     
00568     if (d->settingsDirty && d->autoSaveSettings)
00569         saveAutoSaveSettings();
00570 
00571     if (queryClose()) {
00572         e->accept();
00573 
00574         int not_withdrawn = 0;
00575         QPtrListIterator<KMainWindow> it(*KMainWindow::memberList);
00576         for (it.toFirst(); it.current(); ++it){
00577             if ( !it.current()->isHidden() && it.current()->isTopLevel() && it.current() != this )
00578                 not_withdrawn++;
00579         }
00580 
00581         if ( !no_query_exit && not_withdrawn <= 0 ) { 
00582             if ( queryExit() && !kapp->sessionSaving() && !d->shuttingDown ) { 
00583                 
00584                 disconnect(kapp, SIGNAL(shutDown()), this, SLOT(shuttingDown()));
00585                 d->shuttingDown = true;
00586                 kapp->deref();             
00587             }  else {
00588                 
00589                 e->ignore();
00590             }
00591         }
00592     }
00593 }
00594 
00595 bool KMainWindow::queryExit()
00596 {
00597     return true;
00598 }
00599 
00600 bool KMainWindow::queryClose()
00601 {
00602     return true;
00603 }
00604 
00605 void KMainWindow::saveGlobalProperties( KConfig*  )
00606 {
00607 }
00608 
00609 void KMainWindow::readGlobalProperties( KConfig*  )
00610 {
00611 }
00612 
00613 #if defined(KDE_COMPAT)
00614 void KMainWindow::updateRects()
00615 {
00616 }
00617 #endif
00618 
00619 void KMainWindow::showAboutApplication()
00620 {
00621 }
00622 
00623 void KMainWindow::savePropertiesInternal( KConfig *config, int number )
00624 {
00625     bool oldASWS = d->autoSaveWindowSize;
00626     d->autoSaveWindowSize = true; 
00627 
00628     QString s;
00629     s.setNum(number);
00630     s.prepend(QString::fromLatin1("WindowProperties"));
00631     config->setGroup(s);
00632 
00633     
00634     
00635     config->writeEntry(QString::fromLatin1("ObjectName"), name());
00636     config->writeEntry(QString::fromLatin1("ClassName"), className());
00637 
00638     saveMainWindowSettings(config); 
00639 
00640     s.setNum(number);
00641     config->setGroup(s);
00642     saveProperties(config);
00643 
00644     d->autoSaveWindowSize = oldASWS;
00645 }
00646 
00647 void KMainWindow::saveMainWindowSettings(KConfig *config, const QString &configGroup)
00648 {
00649     kdDebug(200) << "KMainWindow::saveMainWindowSettings " << configGroup << endl;
00650     QString oldGroup;
00651 
00652     if (!configGroup.isEmpty())
00653     {
00654        oldGroup = config->group();
00655        config->setGroup(configGroup);
00656     }
00657 
00658     
00659     if ( d->autoSaveWindowSize )
00660         saveWindowSize( config );
00661 
00662     QStatusBar* sb = internalStatusBar();
00663     if (sb) {
00664        if(!config->hasDefault("StatusBar") && !sb->isHidden() )
00665            config->revertToDefault("StatusBar");
00666        else
00667            config->writeEntry("StatusBar", sb->isHidden() ? "Disabled" : "Enabled");
00668     }
00669 
00670     QMenuBar* mb = internalMenuBar();
00671     if (mb) {
00672        QString MenuBar = QString::fromLatin1("MenuBar");
00673        if(!config->hasDefault("MenuBar") && !mb->isHidden() )
00674            config->revertToDefault("MenuBar");
00675        else
00676            config->writeEntry("MenuBar", mb->isHidden() ? "Disabled" : "Enabled");
00677     }
00678 
00679     int n = 1; 
00680     KToolBar *toolbar = 0;
00681     QPtrListIterator<KToolBar> it( toolBarIterator() );
00682     while ( ( toolbar = it.current() ) ) {
00683         ++it;
00684         QString group;
00685         if (!configGroup.isEmpty())
00686         {
00687            
00688            
00689            group = (!::qstrcmp(toolbar->name(), "unnamed") ? QString::number(n) : QString(" ")+toolbar->name());
00690            group.prepend(" Toolbar");
00691            group.prepend(configGroup);
00692         }
00693         toolbar->saveSettings(config, group);
00694         n++;
00695     }
00696     if (!configGroup.isEmpty())
00697        config->setGroup(oldGroup);
00698 }
00699 
00700 void KMainWindow::setStandardToolBarMenuEnabled( bool enable )
00701 {
00702     if ( enable ) {
00703         if ( d->toolBarHandler )
00704             return;
00705 
00706     d->toolBarHandler = new KDEPrivate::ToolBarHandler( this );
00707 
00708     if ( factory() )
00709         factory()->addClient( d->toolBarHandler );
00710     } else {
00711         if ( !d->toolBarHandler )
00712             return;
00713 
00714         if ( factory() )
00715             factory()->removeClient( d->toolBarHandler );
00716 
00717         delete d->toolBarHandler;
00718         d->toolBarHandler = 0;
00719     }
00720 }
00721 
00722 bool KMainWindow::isStandardToolBarMenuEnabled() const
00723 {
00724     return ( d->toolBarHandler != 0 );
00725 }
00726 
00727 void KMainWindow::createStandardStatusBarAction(){
00728   if(!d->showStatusBarAction){
00729     d->showStatusBarAction = KStdAction::showStatusbar(this, SLOT(setSettingsDirty()), actionCollection());
00730     KStatusBar *sb = statusBar(); 
00731     connect(d->showStatusBarAction, SIGNAL(toggled(bool)), sb, SLOT(setShown(bool)));
00732     d->showStatusBarAction->setChecked(sb->isHidden());
00733   }
00734 }
00735 
00736 bool KMainWindow::readPropertiesInternal( KConfig *config, int number )
00737 {
00738     if ( number == 1 )
00739         readGlobalProperties( config );
00740 
00741     
00742     QString s;
00743     s.setNum(number);
00744     s.prepend(QString::fromLatin1("WindowProperties"));
00745 
00746     config->setGroup(s);
00747 
00748     
00749     if ( config->hasKey(QString::fromLatin1("ObjectName" )) )
00750         setName( config->readEntry(QString::fromLatin1("ObjectName")).latin1()); 
00751 
00752     applyMainWindowSettings(config); 
00753 
00754     s.setNum(number);
00755     config->setGroup(s);
00756     readProperties(config);
00757     return true;
00758 }
00759 
00760 void KMainWindow::applyMainWindowSettings(KConfig *config, const QString &configGroup)
00761 {
00762     kdDebug(200) << "KMainWindow::applyMainWindowSettings" << endl;
00763     if (!configGroup.isEmpty())
00764        config->setGroup(configGroup);
00765 
00766     restoreWindowSize(config);
00767 
00768     QStatusBar* sb = internalStatusBar();
00769     if (sb) {
00770         QString entry = config->readEntry("StatusBar", "Enabled");
00771         if ( entry == "Disabled" )
00772            sb->hide();
00773         else
00774            sb->show();
00775         if(d->showStatusBarAction)
00776             d->showStatusBarAction->setChecked(!sb->isHidden());
00777     }
00778 
00779     QMenuBar* mb = internalMenuBar();
00780     if (mb) {
00781         QString entry = config->readEntry ("MenuBar", "Enabled");
00782         if ( entry == "Disabled" )
00783            mb->hide();
00784         else
00785            mb->show();
00786     }
00787 
00788     int n = 1; 
00789     KToolBar *toolbar;
00790     QPtrListIterator<KToolBar> it( toolBarIterator() ); 
00791 
00792     for ( ; it.current(); ++it) {
00793         toolbar= it.current();
00794         QString group;
00795         if (!configGroup.isEmpty())
00796         {
00797            
00798            
00799            group = (!::qstrcmp(toolbar->name(), "unnamed") ? QString::number(n) : QString(" ")+toolbar->name());
00800            group.prepend(" Toolbar");
00801            group.prepend(configGroup);
00802         }
00803         toolbar->applySettings(config, group);
00804         n++;
00805     }
00806 
00807     finalizeGUI( true );
00808 }
00809 
00810 void KMainWindow::finalizeGUI( bool force )
00811 {
00812     
00813     
00814     
00815     
00816     
00817     
00818     
00819     
00820     QPtrListIterator<KToolBar> it( toolBarIterator() );
00821     for ( ; it.current() ; ++ it )
00822             it.current()->positionYourself( force );
00823 
00824     d->settingsDirty = false;
00825 }
00826 
00827 void KMainWindow::saveWindowSize( KConfig * config ) const
00828 {
00829 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00830   int scnum = QApplication::desktop()->screenNumber(parentWidget());
00831   QRect desk = QApplication::desktop()->screenGeometry(scnum);
00832   
00833   KWin::WindowInfo info = KWin::windowInfo( winId(), NET::WMState );
00834   int w = info.state() & NET::MaxHoriz ? desk.width() + 1 : width();
00835   int h = info.state() & NET::MaxVert ? desk.height() + 1 : height();
00836   QRect size( desk.width(), w, desk.height(), h );
00837 #else
00838   int w = 500;
00839   int h = 500;
00840   QRect desk( 100, 100, 200, 200 ); 
00841   QRect size( 100, 100, 200, 200 ); 
00842 #endif
00843   bool defaultSize = (size == d->defaultWindowSize);
00844   QString widthString = QString::fromLatin1("Width %1").arg(desk.width());
00845   QString heightString = QString::fromLatin1("Height %1").arg(desk.height());
00846   if (!config->hasDefault(widthString) && defaultSize)
00847      config->revertToDefault(widthString);
00848   else
00849      config->writeEntry(widthString, w );
00850 
00851   if (!config->hasDefault(heightString) && defaultSize)
00852      config->revertToDefault(heightString);
00853   else
00854      config->writeEntry(heightString, h );
00855 }
00856 
00857 void KMainWindow::restoreWindowSize( KConfig * config )
00858 {
00859     if (d->care_about_geometry) {
00860         parseGeometry(true);
00861     } else {
00862         
00863         int scnum = QApplication::desktop()->screenNumber(parentWidget());
00864         QRect desk = QApplication::desktop()->screenGeometry(scnum);
00865         QSize size( config->readNumEntry( QString::fromLatin1("Width %1").arg(desk.width()), 0 ),
00866                     config->readNumEntry( QString::fromLatin1("Height %1").arg(desk.height()), 0 ) );
00867         if (size.isEmpty()) {
00868             
00869             size = QSize( config->readNumEntry( QString::fromLatin1("Width"), 0 ),
00870                           config->readNumEntry( QString::fromLatin1("Height"), 0 ) );
00871             if (!size.isEmpty()) {
00872                 
00873                 config->writeEntry( QString::fromLatin1("Width"), 0 );
00874                 config->writeEntry( QString::fromLatin1("Height"), 0 );
00875             }
00876         }
00877         if ( !size.isEmpty() ) {
00878             int state = ( size.width() > desk.width() ? NET::MaxHoriz : 0 )
00879                         | ( size.height() > desk.height() ? NET::MaxVert : 0 );
00880             if(( state & NET::Max ) == NET::Max )
00881                 ; 
00882             else if(( state & NET::MaxHoriz ) == NET::MaxHoriz )
00883                 resize( width(), size.height());
00884             else if(( state & NET::MaxVert ) == NET::MaxVert )
00885                 resize( size.width(), height());
00886             else
00887                 resize( size );
00888             
00889             KWin::setState( winId(), state );
00890         }
00891     }
00892 }
00893 
00894 bool KMainWindow::initialGeometrySet() const
00895 {
00896     return d->care_about_geometry;
00897 }
00898 
00899 void KMainWindow::ignoreInitialGeometry()
00900 {
00901     d->care_about_geometry = false;
00902 }
00903 
00904 void KMainWindow::setSettingsDirty()
00905 {
00906     
00907     d->settingsDirty = true;
00908     if ( d->autoSaveSettings )
00909     {
00910         
00911         
00912         if ( !d->settingsTimer )
00913         {
00914            d->settingsTimer = new QTimer( this );
00915            connect( d->settingsTimer, SIGNAL( timeout() ), SLOT( saveAutoSaveSettings() ) );
00916         }
00917         d->settingsTimer->start( 500, true );
00918     }
00919 }
00920 
00921 bool KMainWindow::settingsDirty() const
00922 {
00923     return d->settingsDirty;
00924 }
00925 
00926 QString KMainWindow::settingsGroup() const
00927 {
00928     return d->autoSaveGroup;
00929 }
00930 
00931 void KMainWindow::setAutoSaveSettings( const QString & groupName, bool saveWindowSize )
00932 {
00933     d->autoSaveSettings = true;
00934     d->autoSaveGroup = groupName;
00935     d->autoSaveWindowSize = saveWindowSize;
00936     
00937     connect( this, SIGNAL( dockWindowPositionChanged( QDockWindow * ) ),
00938              this, SLOT( setSettingsDirty() ) );
00939 
00940     
00941     int scnum = QApplication::desktop()->screenNumber(parentWidget());
00942     QRect desk = QApplication::desktop()->screenGeometry(scnum);
00943     d->defaultWindowSize = QRect(desk.width(), width(), desk.height(), height());
00944     
00945     applyMainWindowSettings( KGlobal::config(), groupName );
00946 }
00947 
00948 void KMainWindow::resetAutoSaveSettings()
00949 {
00950     d->autoSaveSettings = false;
00951     if ( d->settingsTimer )
00952         d->settingsTimer->stop();
00953 }
00954 
00955 bool KMainWindow::autoSaveSettings() const
00956 {
00957     return d->autoSaveSettings;
00958 }
00959 
00960 QString KMainWindow::autoSaveGroup() const
00961 {
00962     return d->autoSaveGroup;
00963 }
00964 
00965 void KMainWindow::saveAutoSaveSettings()
00966 {
00967     Q_ASSERT( d->autoSaveSettings );
00968     
00969     saveMainWindowSettings( KGlobal::config(), d->autoSaveGroup );
00970     KGlobal::config()->sync();
00971     d->settingsDirty = false;
00972     if ( d->settingsTimer )
00973         d->settingsTimer->stop();
00974 }
00975 
00976 void KMainWindow::resizeEvent( QResizeEvent * )
00977 {
00978     if ( d->autoSaveWindowSize )
00979         setSettingsDirty();
00980 }
00981 
00982 bool KMainWindow::hasMenuBar()
00983 {
00984     return (internalMenuBar());
00985 }
00986 
00987 KMenuBar *KMainWindow::menuBar()
00988 {
00989     KMenuBar * mb = internalMenuBar();
00990     if ( !mb ) {
00991         mb = new KMenuBar( this );
00992         
00993         
00994         QMainWindow::menuBar();
00995     }
00996     return mb;
00997 }
00998 
00999 KStatusBar *KMainWindow::statusBar()
01000 {
01001     KStatusBar * sb = internalStatusBar();
01002     if ( !sb ) {
01003         sb = new KStatusBar( this );
01004         
01005         
01006         QMainWindow::statusBar();
01007     }
01008     return sb;
01009 }
01010 
01011 void KMainWindow::shuttingDown()
01012 {
01013     
01014     
01015     static bool reentrancy_protection = false;
01016     if (!reentrancy_protection)
01017     {
01018        reentrancy_protection = true;
01019        
01020        queryExit();
01021        reentrancy_protection = false;
01022     }
01023 
01024 }
01025 
01026 KMenuBar *KMainWindow::internalMenuBar()
01027 {
01028     QObjectList *l = queryList( "KMenuBar", 0, false, false );
01029     if ( !l || !l->first() ) {
01030         delete l;
01031         return 0;
01032     }
01033 
01034     KMenuBar *m = (KMenuBar*)l->first();
01035     delete l;
01036     return m;
01037 }
01038 
01039 KStatusBar *KMainWindow::internalStatusBar()
01040 {
01041     QObjectList *l = queryList( "KStatusBar", 0, false, false );
01042     if ( !l || !l->first() ) {
01043         delete l;
01044         return 0;
01045     }
01046 
01047     KStatusBar *s = (KStatusBar*)l->first();
01048     delete l;
01049     return s;
01050 }
01051 
01052 void KMainWindow::childEvent( QChildEvent* e)
01053 {
01054     QMainWindow::childEvent( e );
01055 }
01056 
01057 KToolBar *KMainWindow::toolBar( const char * name )
01058 {
01059     if (!name)
01060        name = "mainToolBar";
01061     KToolBar *tb = (KToolBar*)child( name, "KToolBar" );
01062     if ( tb )
01063         return tb;
01064     bool honor_mode = (name == "mainToolBar");
01065 
01066     if ( builderClient() )
01067         return new KToolBar(this, name, honor_mode); 
01068     else
01069         return new KToolBar(this, DockTop, false, name, honor_mode ); 
01070 }
01071 
01072 QPtrListIterator<KToolBar> KMainWindow::toolBarIterator()
01073 {
01074     toolbarList.clear();
01075     QPtrList<QToolBar> lst;
01076     for ( int i = (int)QMainWindow::DockUnmanaged; i <= (int)DockMinimized; ++i ) {
01077         lst = toolBars( (ToolBarDock)i );
01078         for ( QToolBar *tb = lst.first(); tb; tb = lst.next() ) {
01079             if ( !tb->inherits( "KToolBar" ) )
01080                 continue;
01081             toolbarList.append( (KToolBar*)tb );
01082         }
01083     }
01084     return QPtrListIterator<KToolBar>( toolbarList );
01085 }
01086 
01087 KAccel * KMainWindow::accel()
01088 {
01089     if ( !d->kaccel )
01090         d->kaccel = new KAccel( this, "kmw-kaccel" );
01091     return d->kaccel;
01092 }
01093 
01094 void KMainWindow::paintEvent( QPaintEvent * )
01095 {
01096     
01097 }
01098 
01099 QSize KMainWindow::sizeForCentralWidgetSize(QSize size)
01100 {
01101     KToolBar *tb = (KToolBar*)child( "mainToolBar", "KToolBar" );
01102     if (tb && !tb->isHidden()) {
01103         switch( tb->barPos() )
01104         {
01105           case KToolBar::Top:
01106           case KToolBar::Bottom:
01107             size += QSize(0, tb->sizeHint().height());
01108             break;
01109 
01110           case KToolBar::Left:
01111           case KToolBar::Right:
01112             size += QSize(toolBar()->sizeHint().width(), 0);
01113             break;
01114 
01115           case KToolBar::Flat:
01116             size += QSize(0, 3+kapp->style().pixelMetric( QStyle::PM_DockWindowHandleExtent ));
01117             break;
01118 
01119           default:
01120             break;
01121         }
01122     }
01123     KMenuBar *mb = internalMenuBar();
01124     if (mb && !mb->isHidden()) {
01125         size += QSize(0,mb->heightForWidth(size.width()));
01126         if (style().styleHint(QStyle::SH_MainWindow_SpaceBelowMenuBar, this))
01127            size += QSize( 0, dockWindowsMovable() ? 1 : 2);
01128     }
01129     QStatusBar *sb = internalStatusBar();
01130     if( sb && !sb->isHidden() )
01131        size += QSize(0, sb->sizeHint().height());
01132 
01133     return size;
01134 }
01135 
01136 
01137 
01138 void KMainWindow::finalizeGUI( KXMLGUIClient *client )
01139 { KXMLGUIBuilder::finalizeGUI( client ); }
01140 
01141 void KMainWindow::virtual_hook( int id, void* data )
01142 { KXMLGUIBuilder::virtual_hook( id, data );
01143   KXMLGUIClient::virtual_hook( id, data ); }
01144 
01145 
01146 
01147 #include "kmainwindow.moc"
01148