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
#include <kedittoolbar.h>
00046
#include <kmainwindow.h>
00047
00048
#include <klocale.h>
00049
#include <kstandarddirs.h>
00050
#include <kstaticdeleter.h>
00051
#if defined Q_WS_X11 && ! defined K_WS_QTONLY
00052
#include <netwm.h>
00053
#endif
00054
00055
#include <stdlib.h>
00056
#include <ctype.h>
00057
#include <assert.h>
00058
00059
class KMainWindowPrivate {
00060
public:
00061
bool showHelpMenu:1;
00062
00063
bool autoSaveSettings:1;
00064
bool settingsDirty:1;
00065
bool autoSaveWindowSize:1;
00066
bool care_about_geometry:1;
00067
bool shuttingDown:1;
00068
QString autoSaveGroup;
00069
KAccel * kaccel;
00070
KMainWindowInterface *m_interface;
00071
KDEPrivate::ToolBarHandler *toolBarHandler;
00072
QTimer* settingsTimer;
00073
KToggleAction *showStatusBarAction;
00074
QRect defaultWindowSize;
00075
QPtrList<QDockWindow> hiddenDockWindows;
00076 };
00077
00078 QPtrList<KMainWindow>*
KMainWindow::memberList = 0L;
00079
static bool no_query_exit =
false;
00080
static KMWSessionManaged* ksm = 0;
00081
static KStaticDeleter<KMWSessionManaged> ksmd;
00082
00083
class KMWSessionManaged :
public KSessionManaged
00084 {
00085
public:
00086 KMWSessionManaged()
00087 {
00088 };
00089 ~KMWSessionManaged()
00090 {
00091 }
00092
bool saveState(
QSessionManager& )
00093 {
00094
KConfig* config =
KApplication::kApplication()->
sessionConfig();
00095
if (
KMainWindow::memberList->first() ){
00096
00097
00098
KMainWindow::memberList->first()->saveGlobalProperties(config);
00099 }
00100
00101
QPtrListIterator<KMainWindow> it(*
KMainWindow::memberList);
00102
int n = 0;
00103
for (it.toFirst(); it.current(); ++it){
00104 n++;
00105 it.current()->savePropertiesInternal(config, n);
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->testWState( Qt::WState_ForceHide ) ) {
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->testWState( Qt::WState_ForceHide ) ) {
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 int KMainWindow::configureToolbars()
00425 {
00426
saveMainWindowSettings(KGlobal::config());
00427
KEditToolbar dlg(
actionCollection(),
xmlFile(),
true,
this);
00428 connect(&dlg, SIGNAL(newToolbarConfig()), SLOT(
saveNewToolbarConfig()));
00429
return dlg.exec();
00430 }
00431
00432 void KMainWindow::saveNewToolbarConfig()
00433 {
00434
createGUI(
xmlFile());
00435
applyMainWindowSettings( KGlobal::config() );
00436 }
00437
00438 void KMainWindow::setupGUI(
int options,
const QString & xmlfile ) {
00439
if( options &
Keys ){
00440
KStdAction::keyBindings(guiFactory(),
00441 SLOT(configureShortcuts()),
actionCollection());
00442 }
00443
00444
if( (options &
StatusBar) && internalStatusBar() ){
00445
createStandardStatusBarAction();
00446 }
00447
00448
if( options &
ToolBar ){
00449
setStandardToolBarMenuEnabled(
true );
00450
KStdAction::configureToolbars(
this,
00451 SLOT(
configureToolbars() ),
actionCollection());
00452 }
00453
00454
if( options &
Create ){
00455
createGUI(xmlfile);
00456 }
00457
00458
if( options &
Save ){
00459
00460
00461
00462
00463
if(!isShown())
00464 adjustSize();
00465
setAutoSaveSettings();
00466 }
00467
00468 }
00469
00470 void KMainWindow::createGUI(
const QString &xmlfile,
bool _conserveMemory )
00471 {
00472
00473 setUpdatesEnabled(
false );
00474
00475
00476 guiFactory()->
removeClient(
this );
00477
00478
00479
QMenuBar* mb = internalMenuBar();
00480
if ( mb )
00481 mb->clear();
00482
00483 (
void)
toolBarIterator();
00484 toolbarList.setAutoDelete(
true );
00485 toolbarList.clear();
00486 toolbarList.setAutoDelete(
false );
00487
00488
00489
if (d->showHelpMenu) {
00490
00491
if (helpMenu2 == 0)
00492 helpMenu2 =
new KHelpMenu(
this,
instance()->aboutData(),
true,
00493
actionCollection());
00494 }
00495
00496
00497
setXMLFile(
locate(
"config",
"ui/ui_standards.rc",
instance() ) );
00498
00499
00500
00501
if ( !xmlfile.isNull() ) {
00502
setXMLFile( xmlfile,
true );
00503 }
else {
00504
QString auto_file(
instance()->instanceName() +
"ui.rc");
00505
setXMLFile( auto_file,
true );
00506 }
00507
00508
00509 setXMLGUIBuildDocument(
QDomDocument() );
00510
00511
00512 guiFactory()->
addClient(
this );
00513
00514
00515
if ( _conserveMemory )
00516 {
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
QDomDocument doc =
domDocument();
00531
00532
for(
QDomNode n = doc.documentElement().firstChild();
00533 !n.isNull(); n = n.nextSibling())
00534 {
00535
QDomElement e = n.toElement();
00536
00537
if ( e.tagName().lower() ==
"toolbar" )
00538 factory_->
resetContainer( e.attribute(
"name" ) );
00539
else if ( e.tagName().lower() ==
"menubar" )
00540 factory_->
resetContainer( e.tagName(),
true );
00541 }
00542
00543
conserveMemory();
00544 }
00545
00546 setUpdatesEnabled(
true );
00547 updateGeometry();
00548 }
00549
00550 void KMainWindow::setHelpMenuEnabled(
bool showHelpMenu)
00551 {
00552 d->showHelpMenu = showHelpMenu;
00553 }
00554
00555 bool KMainWindow::isHelpMenuEnabled()
00556 {
00557
return d->showHelpMenu;
00558 }
00559
00560 void KMainWindow::setCaption(
const QString &caption )
00561 {
00562
setPlainCaption( kapp->makeStdCaption(caption) );
00563 }
00564
00565 void KMainWindow::setCaption(
const QString &caption,
bool modified )
00566 {
00567
setPlainCaption( kapp->makeStdCaption(caption,
true, modified) );
00568 }
00569
00570 void KMainWindow::setPlainCaption(
const QString &caption )
00571 {
00572 QMainWindow::setCaption( caption );
00573
#if defined Q_WS_X11 && ! defined K_WS_QTONLY
00574
00575
NETWinInfo info( qt_xdisplay(), winId(), qt_xrootwin(), 0 );
00576 info.
setName( caption.utf8().data() );
00577
#endif
00578
}
00579
00580 void KMainWindow::appHelpActivated(
void )
00581 {
00582
if( mHelpMenu == 0 ) {
00583 mHelpMenu =
new KHelpMenu(
this );
00584
if ( mHelpMenu == 0 )
00585
return;
00586 }
00587 mHelpMenu->
appHelpActivated();
00588 }
00589
00590 void KMainWindow::slotStateChanged(
const QString &newstate)
00591 {
00592
stateChanged(newstate, KXMLGUIClient::StateNoReverse);
00593 }
00594
00595
00596
00597
00598 void KMainWindow::slotStateChanged(
const QString &newstate,
00599 KXMLGUIClient::ReverseStateChange reverse)
00600 {
00601
stateChanged(newstate, reverse);
00602 }
00603
00604
00605
00606
00607
00608
00609
00610
00611
00612
00613
00614 void KMainWindow::closeEvent (
QCloseEvent *e )
00615 {
00616
00617
if (d->settingsDirty && d->autoSaveSettings)
00618
saveAutoSaveSettings();
00619
00620
if (
queryClose()) {
00621 e->accept();
00622
00623
int not_withdrawn = 0;
00624
QPtrListIterator<KMainWindow> it(*
KMainWindow::memberList);
00625
for (it.toFirst(); it.current(); ++it){
00626
if ( !it.current()->isHidden() && it.current()->isTopLevel() && it.current() !=
this )
00627 not_withdrawn++;
00628 }
00629
00630
if ( !no_query_exit && not_withdrawn <= 0 ) {
00631
if (
queryExit() && !kapp->sessionSaving() && !d->shuttingDown ) {
00632
00633 disconnect(kapp, SIGNAL(shutDown()),
this, SLOT(shuttingDown()));
00634 d->shuttingDown =
true;
00635 kapp->deref();
00636 }
else {
00637
00638 e->ignore();
00639 }
00640 }
00641 }
00642 }
00643
00644 bool KMainWindow::queryExit()
00645 {
00646
return true;
00647 }
00648
00649 bool KMainWindow::queryClose()
00650 {
00651
return true;
00652 }
00653
00654 void KMainWindow::saveGlobalProperties(
KConfig* )
00655 {
00656 }
00657
00658 void KMainWindow::readGlobalProperties(
KConfig* )
00659 {
00660 }
00661
00662
#if defined(KDE_COMPAT)
00663
void KMainWindow::updateRects()
00664 {
00665 }
00666
#endif
00667
00668 void KMainWindow::showAboutApplication()
00669 {
00670 }
00671
00672
void KMainWindow::savePropertiesInternal(
KConfig *config,
int number )
00673 {
00674
bool oldASWS = d->autoSaveWindowSize;
00675 d->autoSaveWindowSize =
true;
00676
00677
QString s;
00678 s.setNum(number);
00679 s.prepend(QString::fromLatin1(
"WindowProperties"));
00680 config->
setGroup(s);
00681
00682
00683
00684 config->
writeEntry(QString::fromLatin1(
"ObjectName"), name());
00685 config->
writeEntry(QString::fromLatin1(
"ClassName"), className());
00686
00687
saveMainWindowSettings(config);
00688
00689 s.setNum(number);
00690 config->
setGroup(s);
00691
saveProperties(config);
00692
00693 d->autoSaveWindowSize = oldASWS;
00694 }
00695
00696 void KMainWindow::saveMainWindowSettings(
KConfig *config,
const QString &configGroup)
00697 {
00698
kdDebug(200) <<
"KMainWindow::saveMainWindowSettings " << configGroup <<
endl;
00699
QString oldGroup;
00700
00701
if (!configGroup.isEmpty())
00702 {
00703 oldGroup = config->
group();
00704 config->
setGroup(configGroup);
00705 }
00706
00707
00708
if ( d->autoSaveWindowSize )
00709
saveWindowSize( config );
00710
00711
QStatusBar* sb = internalStatusBar();
00712
if (sb) {
00713
if(!config->
hasDefault(
"StatusBar") && !sb->isHidden() )
00714 config->
revertToDefault(
"StatusBar");
00715
else
00716 config->
writeEntry(
"StatusBar", sb->isHidden() ?
"Disabled" :
"Enabled");
00717 }
00718
00719
QMenuBar* mb = internalMenuBar();
00720
if (mb) {
00721
QString MenuBar = QString::fromLatin1(
"MenuBar");
00722
if(!config->
hasDefault(
"MenuBar") && !mb->isHidden() )
00723 config->
revertToDefault(
"MenuBar");
00724
else
00725 config->
writeEntry(
"MenuBar", mb->isHidden() ?
"Disabled" :
"Enabled");
00726 }
00727
00728
int n = 1;
00729
KToolBar *toolbar = 0;
00730
QPtrListIterator<KToolBar> it(
toolBarIterator() );
00731
while ( ( toolbar = it.current() ) ) {
00732 ++it;
00733
QString group;
00734
if (!configGroup.isEmpty())
00735 {
00736
00737
00738 group = (!::qstrcmp(toolbar->name(),
"unnamed") ? QString::number(n) :
QString(
" ")+toolbar->name());
00739 group.prepend(
" Toolbar");
00740 group.prepend(configGroup);
00741 }
00742 toolbar->
saveSettings(config, group);
00743 n++;
00744 }
00745
if (!configGroup.isEmpty())
00746 config->
setGroup(oldGroup);
00747 }
00748
00749 void KMainWindow::setStandardToolBarMenuEnabled(
bool enable )
00750 {
00751
if ( enable ) {
00752
if ( d->toolBarHandler )
00753
return;
00754
00755 d->toolBarHandler =
new KDEPrivate::ToolBarHandler(
this );
00756
00757
if (
factory() )
00758
factory()->
addClient( d->toolBarHandler );
00759 }
else {
00760
if ( !d->toolBarHandler )
00761
return;
00762
00763
if (
factory() )
00764
factory()->
removeClient( d->toolBarHandler );
00765
00766
delete d->toolBarHandler;
00767 d->toolBarHandler = 0;
00768 }
00769 }
00770
00771 bool KMainWindow::isStandardToolBarMenuEnabled()
const
00772
{
00773
return ( d->toolBarHandler != 0 );
00774 }
00775
00776 void KMainWindow::createStandardStatusBarAction(){
00777
if(!d->showStatusBarAction){
00778 d->showStatusBarAction =
KStdAction::showStatusbar(
this, SLOT(
setSettingsDirty()),
actionCollection());
00779
KStatusBar *sb =
statusBar();
00780 connect(d->showStatusBarAction, SIGNAL(toggled(
bool)), sb, SLOT(setShown(
bool)));
00781 d->showStatusBarAction->setChecked(sb->isHidden());
00782 }
00783 }
00784
00785
bool KMainWindow::readPropertiesInternal(
KConfig *config,
int number )
00786 {
00787
if ( number == 1 )
00788
readGlobalProperties( config );
00789
00790
00791
QString s;
00792 s.setNum(number);
00793 s.prepend(QString::fromLatin1(
"WindowProperties"));
00794
00795 config->
setGroup(s);
00796
00797
00798
if ( config->
hasKey(QString::fromLatin1(
"ObjectName" )) )
00799 setName( config->
readEntry(QString::fromLatin1(
"ObjectName")).latin1());
00800
00801
applyMainWindowSettings(config);
00802
00803 s.setNum(number);
00804 config->
setGroup(s);
00805
readProperties(config);
00806
return true;
00807 }
00808
00809
void KMainWindow::applyMainWindowSettings(
KConfig *config,
const QString &configGroup)
00810 {
00811
return applyMainWindowSettings(config,configGroup,
false);
00812 }
00813
00814 void KMainWindow::applyMainWindowSettings(
KConfig *config,
const QString &configGroup,
bool force)
00815 {
00816
kdDebug(200) <<
"KMainWindow::applyMainWindowSettings" <<
endl;
00817
if (!configGroup.isEmpty())
00818 config->
setGroup(configGroup);
00819
00820
restoreWindowSize(config);
00821
00822
QStatusBar* sb = internalStatusBar();
00823
if (sb) {
00824
QString entry = config->
readEntry(
"StatusBar",
"Enabled");
00825
if ( entry ==
"Disabled" )
00826 sb->hide();
00827
else
00828 sb->show();
00829
if(d->showStatusBarAction)
00830 d->showStatusBarAction->setChecked(!sb->isHidden());
00831 }
00832
00833
QMenuBar* mb = internalMenuBar();
00834
if (mb) {
00835
QString entry = config->
readEntry (
"MenuBar",
"Enabled");
00836
if ( entry ==
"Disabled" )
00837 mb->hide();
00838
else
00839 mb->show();
00840 }
00841
00842
int n = 1;
00843
KToolBar *toolbar;
00844
QPtrListIterator<KToolBar> it(
toolBarIterator() );
00845
00846
for ( ; it.current(); ++it) {
00847 toolbar= it.current();
00848
QString group;
00849
if (!configGroup.isEmpty())
00850 {
00851
00852
00853 group = (!::qstrcmp(toolbar->name(),
"unnamed") ? QString::number(n) :
QString(
" ")+toolbar->name());
00854 group.prepend(
" Toolbar");
00855 group.prepend(configGroup);
00856 }
00857 toolbar->
applySettings(config, group, force);
00858 n++;
00859 }
00860
00861
finalizeGUI(
true );
00862 }
00863
00864
void KMainWindow::finalizeGUI(
bool force )
00865 {
00866
00867
00868
00869
00870
00871
00872
00873
00874
QPtrListIterator<KToolBar> it(
toolBarIterator() );
00875
for ( ; it.current() ; ++ it )
00876 it.current()->positionYourself( force );
00877
00878 d->settingsDirty =
false;
00879 }
00880
00881 void KMainWindow::saveWindowSize(
KConfig * config )
const
00882
{
00883
#if defined Q_WS_X11 && ! defined K_WS_QTONLY
00884
int scnum = QApplication::desktop()->screenNumber(parentWidget());
00885
QRect desk = QApplication::desktop()->screenGeometry(scnum);
00886
00887
KWin::WindowInfo info =
KWin::windowInfo( winId(), NET::WMState );
00888
int w = info.
state() & NET::MaxHoriz ? desk.width() + 1 : width();
00889
int h = info.
state() & NET::MaxVert ? desk.height() + 1 : height();
00890
QRect size( desk.width(), w, desk.height(), h );
00891
#else
00892
int w = 500;
00893
int h = 500;
00894
QRect desk( 100, 100, 200, 200 );
00895
QRect size( 100, 100, 200, 200 );
00896
#endif
00897
bool defaultSize = (size == d->defaultWindowSize);
00898
QString widthString = QString::fromLatin1(
"Width %1").arg(desk.width());
00899
QString heightString = QString::fromLatin1(
"Height %1").arg(desk.height());
00900
if (!config->
hasDefault(widthString) && defaultSize)
00901 config->
revertToDefault(widthString);
00902
else
00903 config->
writeEntry(widthString, w );
00904
00905
if (!config->
hasDefault(heightString) && defaultSize)
00906 config->
revertToDefault(heightString);
00907
else
00908 config->
writeEntry(heightString, h );
00909 }
00910
00911 void KMainWindow::restoreWindowSize(
KConfig * config )
00912 {
00913
if (d->care_about_geometry) {
00914
parseGeometry(
true);
00915 }
else {
00916
00917
int scnum = QApplication::desktop()->screenNumber(parentWidget());
00918
QRect desk = QApplication::desktop()->screenGeometry(scnum);
00919
if ( d->defaultWindowSize.isNull() )
00920 d->defaultWindowSize =
QRect(desk.width(), width(), desk.height(), height());
00921
QSize size( config->
readNumEntry( QString::fromLatin1(
"Width %1").arg(desk.width()), 0 ),
00922 config->
readNumEntry( QString::fromLatin1(
"Height %1").arg(desk.height()), 0 ) );
00923
if (size.isEmpty()) {
00924
00925 size =
QSize( config->
readNumEntry( QString::fromLatin1(
"Width"), 0 ),
00926 config->
readNumEntry( QString::fromLatin1(
"Height"), 0 ) );
00927
if (!size.isEmpty()) {
00928
00929 config->
writeEntry( QString::fromLatin1(
"Width"), 0 );
00930 config->
writeEntry( QString::fromLatin1(
"Height"), 0 );
00931 }
00932 }
00933
if ( !size.isEmpty() ) {
00934
int state = ( size.width() > desk.width() ? NET::MaxHoriz : 0 )
00935 | ( size.height() > desk.height() ? NET::MaxVert : 0 );
00936
if(( state & NET::Max ) == NET::Max )
00937 ;
00938
else if(( state & NET::MaxHoriz ) == NET::MaxHoriz )
00939 resize( width(), size.height());
00940
else if(( state & NET::MaxVert ) == NET::MaxVert )
00941 resize( size.width(), height());
00942
else
00943 resize( size );
00944
00945
KWin::setState( winId(), state );
00946 }
00947 }
00948 }
00949
00950 bool KMainWindow::initialGeometrySet()
const
00951
{
00952
return d->care_about_geometry;
00953 }
00954
00955
void KMainWindow::ignoreInitialGeometry()
00956 {
00957 d->care_about_geometry =
false;
00958 }
00959
00960 void KMainWindow::setSettingsDirty()
00961 {
00962
00963 d->settingsDirty =
true;
00964
if ( d->autoSaveSettings )
00965 {
00966
00967
00968
if ( !d->settingsTimer )
00969 {
00970 d->settingsTimer =
new QTimer(
this );
00971 connect( d->settingsTimer, SIGNAL( timeout() ), SLOT(
saveAutoSaveSettings() ) );
00972 }
00973 d->settingsTimer->start( 500,
true );
00974 }
00975 }
00976
00977 bool KMainWindow::settingsDirty()
const
00978
{
00979
return d->settingsDirty;
00980 }
00981
00982 QString KMainWindow::settingsGroup()
const
00983
{
00984
return d->autoSaveGroup;
00985 }
00986
00987 void KMainWindow::setAutoSaveSettings(
const QString & groupName,
bool saveWindowSize )
00988 {
00989 d->autoSaveSettings =
true;
00990 d->autoSaveGroup = groupName;
00991 d->autoSaveWindowSize = saveWindowSize;
00992
00993 connect(
this, SIGNAL( dockWindowPositionChanged(
QDockWindow * ) ),
00994
this, SLOT(
setSettingsDirty() ) );
00995
00996
00997
applyMainWindowSettings( KGlobal::config(), groupName );
00998 }
00999
01000 void KMainWindow::resetAutoSaveSettings()
01001 {
01002 d->autoSaveSettings =
false;
01003
if ( d->settingsTimer )
01004 d->settingsTimer->stop();
01005 }
01006
01007 bool KMainWindow::autoSaveSettings()
const
01008
{
01009
return d->autoSaveSettings;
01010 }
01011
01012 QString KMainWindow::autoSaveGroup()
const
01013
{
01014
return d->autoSaveGroup;
01015 }
01016
01017 void KMainWindow::saveAutoSaveSettings()
01018 {
01019 Q_ASSERT( d->autoSaveSettings );
01020
01021
saveMainWindowSettings( KGlobal::config(), d->autoSaveGroup );
01022
KGlobal::config()->
sync();
01023 d->settingsDirty =
false;
01024
if ( d->settingsTimer )
01025 d->settingsTimer->stop();
01026 }
01027
01028
void KMainWindow::resizeEvent(
QResizeEvent * )
01029 {
01030
if ( d->autoSaveWindowSize )
01031
setSettingsDirty();
01032 }
01033
01034 bool KMainWindow::hasMenuBar()
01035 {
01036
return (internalMenuBar());
01037 }
01038
01039 KMenuBar *
KMainWindow::menuBar()
01040 {
01041
KMenuBar * mb = internalMenuBar();
01042
if ( !mb ) {
01043 mb =
new KMenuBar(
this );
01044
01045
01046 QMainWindow::menuBar();
01047 }
01048
return mb;
01049 }
01050
01051 KStatusBar *
KMainWindow::statusBar()
01052 {
01053
KStatusBar * sb = internalStatusBar();
01054
if ( !sb ) {
01055 sb =
new KStatusBar(
this );
01056
01057
01058 QMainWindow::statusBar();
01059 }
01060
return sb;
01061 }
01062
01063
void KMainWindow::shuttingDown()
01064 {
01065
01066
01067
static bool reentrancy_protection =
false;
01068
if (!reentrancy_protection)
01069 {
01070 reentrancy_protection =
true;
01071
01072
queryExit();
01073 reentrancy_protection =
false;
01074 }
01075
01076 }
01077
01078
KMenuBar *KMainWindow::internalMenuBar()
01079 {
01080
QObjectList *l = queryList(
"KMenuBar", 0,
false,
false );
01081
if ( !l || !l->first() ) {
01082
delete l;
01083
return 0;
01084 }
01085
01086
KMenuBar *m = (
KMenuBar*)l->first();
01087
delete l;
01088
return m;
01089 }
01090
01091
KStatusBar *KMainWindow::internalStatusBar()
01092 {
01093
QObjectList *l = queryList(
"KStatusBar", 0,
false,
false );
01094
if ( !l || !l->first() ) {
01095
delete l;
01096
return 0;
01097 }
01098
01099
KStatusBar *s = (
KStatusBar*)l->first();
01100
delete l;
01101
return s;
01102 }
01103
01104
void KMainWindow::childEvent(
QChildEvent* e)
01105 {
01106 QMainWindow::childEvent( e );
01107 }
01108
01109 KToolBar *
KMainWindow::toolBar(
const char * name )
01110 {
01111
if (!name)
01112 name =
"mainToolBar";
01113
KToolBar *tb = (
KToolBar*)child( name,
"KToolBar" );
01114
if ( tb )
01115
return tb;
01116
bool honor_mode = (name ==
"mainToolBar");
01117
01118
if ( builderClient() )
01119
return new KToolBar(
this, name, honor_mode);
01120
else
01121
return new KToolBar(
this, DockTop,
false, name, honor_mode );
01122 }
01123
01124 QPtrListIterator<KToolBar> KMainWindow::toolBarIterator()
01125 {
01126 toolbarList.clear();
01127
QPtrList<QToolBar> lst;
01128
for (
int i = (
int)QMainWindow::DockUnmanaged; i <= (
int)DockMinimized; ++i ) {
01129 lst = toolBars( (ToolBarDock)i );
01130
for (
QToolBar *tb = lst.first(); tb; tb = lst.next() ) {
01131
if ( !tb->inherits(
"KToolBar" ) )
01132
continue;
01133 toolbarList.append( (
KToolBar*)tb );
01134 }
01135 }
01136
return QPtrListIterator<KToolBar>( toolbarList );
01137 }
01138
01139 KAccel *
KMainWindow::accel()
01140 {
01141
if ( !d->kaccel )
01142 d->kaccel =
new KAccel(
this,
"kmw-kaccel" );
01143
return d->kaccel;
01144 }
01145
01146
void KMainWindow::paintEvent(
QPaintEvent * pe )
01147 {
01148 QMainWindow::paintEvent(pe);
01149 }
01150
01151 QSize KMainWindow::sizeForCentralWidgetSize(
QSize size)
01152 {
01153
KToolBar *tb = (
KToolBar*)child(
"mainToolBar",
"KToolBar" );
01154
if (tb && !tb->isHidden()) {
01155
switch( tb->
barPos() )
01156 {
01157
case KToolBar::Top:
01158
case KToolBar::Bottom:
01159 size +=
QSize(0, tb->
sizeHint().height());
01160
break;
01161
01162
case KToolBar::Left:
01163
case KToolBar::Right:
01164 size +=
QSize(
toolBar()->sizeHint().width(), 0);
01165
break;
01166
01167
case KToolBar::Flat:
01168 size += QSize(0, 3+kapp->style().pixelMetric( QStyle::PM_DockWindowHandleExtent ));
01169
break;
01170
01171
default:
01172
break;
01173 }
01174 }
01175
KMenuBar *mb = internalMenuBar();
01176
if (mb && !mb->isHidden()) {
01177 size +=
QSize(0,mb->heightForWidth(size.width()));
01178
if (style().styleHint(QStyle::SH_MainWindow_SpaceBelowMenuBar,
this))
01179 size +=
QSize( 0, dockWindowsMovable() ? 1 : 2);
01180 }
01181
QStatusBar *sb = internalStatusBar();
01182
if( sb && !sb->isHidden() )
01183 size +=
QSize(0, sb->sizeHint().height());
01184
01185
return size;
01186 }
01187
01188
01189
01190 void KMainWindow::finalizeGUI(
KXMLGUIClient *client )
01191 { KXMLGUIBuilder::finalizeGUI( client ); }
01192
01193
void KMainWindow::virtual_hook(
int id,
void* data )
01194 { KXMLGUIBuilder::virtual_hook(
id, data );
01195 KXMLGUIClient::virtual_hook(
id, data ); }
01196
01197
01198
01199
#include "kmainwindow.moc"
01200