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