00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
#include "kxmlguiclient.h"
00021
#include "kxmlguifactory.h"
00022
#include "kxmlguibuilder.h"
00023
00024
#include <qdir.h>
00025
#include <qfile.h>
00026
#include <qdom.h>
00027
#include <qtextstream.h>
00028
#include <qregexp.h>
00029
#include <qguardedptr.h>
00030
00031
#include <kinstance.h>
00032
#include <kstandarddirs.h>
00033
#include <kdebug.h>
00034
#include <kaction.h>
00035
#include <kapplication.h>
00036
00037
#include <assert.h>
00038
00039
class KXMLGUIClientPrivate
00040 {
00041
public:
00042 KXMLGUIClientPrivate()
00043 {
00044 m_instance =
KGlobal::instance();
00045 m_parent = 0L;
00046 m_builder = 0L;
00047 m_actionCollection = 0;
00048 }
00049 ~KXMLGUIClientPrivate()
00050 {
00051 }
00052
00053
KInstance *m_instance;
00054
00055
QDomDocument m_doc;
00056
KActionCollection *m_actionCollection;
00057
QDomDocument m_buildDocument;
00058
QGuardedPtr<KXMLGUIFactory> m_factory;
00059
KXMLGUIClient *m_parent;
00060
00061
QPtrList<KXMLGUIClient> m_children;
00062
KXMLGUIBuilder *m_builder;
00063
QString m_xmlFile;
00064
QString m_localXMLFile;
00065 };
00066
00067 KXMLGUIClient::KXMLGUIClient()
00068 {
00069 d =
new KXMLGUIClientPrivate;
00070 }
00071
00072 KXMLGUIClient::KXMLGUIClient(
KXMLGUIClient *parent )
00073 {
00074 d =
new KXMLGUIClientPrivate;
00075 parent->
insertChildClient(
this );
00076 }
00077
00078 KXMLGUIClient::~KXMLGUIClient()
00079 {
00080
if ( d->m_parent )
00081 d->m_parent->removeChildClient(
this );
00082
00083
QPtrListIterator<KXMLGUIClient> it( d->m_children );
00084
for ( ; it.current(); ++it ) {
00085 assert( it.current()->d->m_parent ==
this );
00086 it.current()->d->m_parent = 0;
00087 }
00088
00089
delete d->m_actionCollection;
00090
delete d;
00091 }
00092
00093 KAction *
KXMLGUIClient::action(
const char *name )
const
00094
{
00095
KAction* act =
actionCollection()->
action( name );
00096
if ( !act ) {
00097
QPtrListIterator<KXMLGUIClient> childIt( d->m_children );
00098
for (; childIt.current(); ++childIt ) {
00099 act = childIt.current()->actionCollection()->action( name );
00100
if ( act )
00101
break;
00102 }
00103 }
00104
return act;
00105 }
00106
00107 KActionCollection *
KXMLGUIClient::actionCollection()
const
00108
{
00109
if ( !d->m_actionCollection )
00110 {
00111 d->m_actionCollection =
new KActionCollection(
00112
"KXMLGUIClient-KActionCollection",
this );
00113 }
00114
return d->m_actionCollection;
00115 }
00116
00117 KAction *
KXMLGUIClient::action(
const QDomElement &element )
const
00118
{
00119
static const QString &attrName = KGlobal::staticQString(
"name" );
00120
return actionCollection()->
action( element.attribute( attrName ).latin1() );
00121 }
00122
00123 KInstance *
KXMLGUIClient::instance()
const
00124
{
00125
return d->m_instance;
00126 }
00127
00128 QDomDocument KXMLGUIClient::domDocument()
const
00129
{
00130
return d->m_doc;
00131 }
00132
00133 QString KXMLGUIClient::xmlFile()
const
00134
{
00135
return d->m_xmlFile;
00136 }
00137
00138
QString KXMLGUIClient::localXMLFile()
const
00139
{
00140
if ( !d->m_localXMLFile.isEmpty() )
00141
return d->m_localXMLFile;
00142
00143
if ( !QDir::isRelativePath(d->m_xmlFile) )
00144
return QString::null;
00145
00146
return locateLocal(
"data", QString::fromLatin1(
instance()->instanceName() +
'/' ) + d->m_xmlFile );
00147 }
00148
00149
00150 void KXMLGUIClient::reloadXML()
00151 {
00152
QString file(
xmlFile() );
00153
if ( !file.isEmpty() )
00154
setXMLFile( file );
00155 }
00156
00157 void KXMLGUIClient::setInstance(
KInstance *instance )
00158 {
00159 d->m_instance = instance;
00160
actionCollection()->
setInstance( instance );
00161
if ( d->m_builder )
00162 d->m_builder->setBuilderClient(
this );
00163 }
00164
00165 void KXMLGUIClient::setXMLFile(
const QString& _file,
bool merge,
bool setXMLDoc )
00166 {
00167
00168
if ( !_file.isNull() ) {
00169 d->m_xmlFile = _file;
00170
actionCollection()->
setXMLFile( _file );
00171 }
00172
00173
if ( !setXMLDoc )
00174
return;
00175
00176
QString file = _file;
00177
if ( QDir::isRelativePath(file) )
00178 {
00179
QString doc;
00180
00181
QString filter = QString::fromLatin1(
instance()->instanceName() +
'/' ) + _file;
00182
00183
QStringList allFiles =
instance()->
dirs()->
findAllResources(
"data", filter ) +
instance()->
dirs()->
findAllResources(
"data", _file );
00184
00185 file = findMostRecentXMLFile( allFiles, doc );
00186
00187
if ( file.isEmpty() )
00188 {
00189
00190
00191
00192
00193
00194
00195
if ( !_file.isEmpty() )
00196
kdWarning() <<
"KXMLGUIClient::setXMLFile: cannot find .rc file " << _file <<
endl;
00197
00198
setXML( QString::null,
true );
00199
return;
00200 }
00201
else if ( !doc.isEmpty() )
00202 {
00203
setXML( doc, merge );
00204
return;
00205 }
00206 }
00207
00208
QString xml = KXMLGUIFactory::readConfigFile( file );
00209
setXML( xml, merge );
00210 }
00211
00212
void KXMLGUIClient::setLocalXMLFile(
const QString &file )
00213 {
00214 d->m_localXMLFile = file;
00215 }
00216
00217 void KXMLGUIClient::setXML(
const QString &document,
bool merge )
00218 {
00219
QDomDocument doc;
00220 doc.setContent( document );
00221
setDOMDocument( doc, merge );
00222 }
00223
00224 void KXMLGUIClient::setDOMDocument(
const QDomDocument &document,
bool merge )
00225 {
00226
if ( merge )
00227 {
00228
QDomElement base = d->m_doc.documentElement();
00229
00230
QDomElement e = document.documentElement();
00231
00232
00233 mergeXML(base, e,
actionCollection());
00234
00235
00236
00237 base = d->m_doc.documentElement();
00238
00239
00240
if ( base.isNull() )
00241 d->m_doc = document;
00242 }
00243
else
00244 {
00245 d->m_doc = document;
00246 }
00247
00248 setXMLGUIBuildDocument(
QDomDocument() );
00249 }
00250
00251
bool KXMLGUIClient::mergeXML(
QDomElement &base,
const QDomElement &additive,
KActionCollection *actionCollection )
00252 {
00253
static const QString &tagAction = KGlobal::staticQString(
"Action" );
00254
static const QString &tagMerge = KGlobal::staticQString(
"Merge" );
00255
static const QString &tagSeparator = KGlobal::staticQString(
"Separator" );
00256
static const QString &attrName = KGlobal::staticQString(
"name" );
00257
static const QString &attrAppend = KGlobal::staticQString(
"append" );
00258
static const QString &attrWeakSeparator = KGlobal::staticQString(
"weakSeparator" );
00259
static const QString &tagMergeLocal = KGlobal::staticQString(
"MergeLocal" );
00260
static const QString &tagText = KGlobal::staticQString(
"text" );
00261
static const QString &attrAlreadyVisited = KGlobal::staticQString(
"alreadyVisited" );
00262
static const QString &attrNoMerge = KGlobal::staticQString(
"noMerge" );
00263
static const QString &attrOne = KGlobal::staticQString(
"1" );
00264
00265
00266
00267
00268
00269
00270
if ( additive.attribute(attrNoMerge) == attrOne )
00271 {
00272 base.parentNode().replaceChild(additive, base);
00273
return true;
00274 }
00275
00276
QString tag;
00277
00278
00279
QDomNode n = base.firstChild();
00280
while ( !n.isNull() )
00281 {
00282
QDomElement e = n.toElement();
00283 n = n.nextSibling();
00284
if (e.isNull())
00285
continue;
00286
00287 tag = e.tagName();
00288
00289
00290
00291
if ( tag == tagAction )
00292 {
00293
QCString name = e.attribute( attrName ).utf8();
00294
if ( !actionCollection->
action( name ) ||
00295 (kapp && !kapp->authorizeKAction(name)))
00296 {
00297
00298 base.removeChild( e );
00299
continue;
00300 }
00301 }
00302
00303
00304
00305
else if ( tag == tagSeparator )
00306 {
00307 e.setAttribute( attrWeakSeparator, (uint)1 );
00308
00309
00310
00311
00312
QDomElement prev = e.previousSibling().toElement();
00313
if ( prev.isNull() ||
00314 ( prev.tagName() == tagSeparator && !prev.attribute( attrWeakSeparator ).isNull() ) ||
00315 ( prev.tagName() == tagText ) )
00316 {
00317
00318 base.removeChild( e );
00319
continue;
00320 }
00321 }
00322
00323
00324
00325
00326
else if ( tag == tagMergeLocal )
00327 {
00328
QDomNode it = additive.firstChild();
00329
while ( !it.isNull() )
00330 {
00331
QDomElement newChild = it.toElement();
00332 it = it.nextSibling();
00333
if (newChild.isNull() )
00334
continue;
00335
00336
if ( newChild.tagName() == tagText )
00337
continue;
00338
00339
if ( newChild.attribute( attrAlreadyVisited ) == attrOne )
00340
continue;
00341
00342
QString itAppend( newChild.attribute( attrAppend ) );
00343
QString elemName( e.attribute( attrName ) );
00344
00345
if ( ( itAppend.isNull() && elemName.isEmpty() ) ||
00346 ( itAppend == elemName ) )
00347 {
00348
00349
00350
00351
QDomElement matchingElement = findMatchingElement( newChild, base );
00352
if ( matchingElement.isNull() || newChild.tagName() == tagSeparator )
00353 base.insertBefore( newChild, e );
00354 }
00355 }
00356
00357 base.removeChild( e );
00358
continue;
00359 }
00360
00361
00362
00363
00364
00365
else if ( tag != tagMerge )
00366 {
00367
00368
if ( tag == tagText )
00369
continue;
00370
00371
QDomElement matchingElement = findMatchingElement( e, additive );
00372
00373
if ( !matchingElement.isNull() )
00374 {
00375 matchingElement.setAttribute( attrAlreadyVisited, (uint)1 );
00376
00377
if ( mergeXML( e, matchingElement, actionCollection ) )
00378 {
00379 base.removeChild( e );
00380
continue;
00381 }
00382
00383
00384
const QDomNamedNodeMap attribs = matchingElement.attributes();
00385
const uint attribcount = attribs.count();
00386
00387
for(uint i = 0; i < attribcount; ++i)
00388 {
00389
const QDomNode node = attribs.item(i);
00390 e.setAttribute(node.nodeName(), node.nodeValue());
00391 }
00392
00393
continue;
00394 }
00395
else
00396 {
00397
00398
00399
00400
00401
00402
if ( mergeXML( e,
QDomElement(), actionCollection ) )
00403 base.removeChild( e );
00404
continue;
00405 }
00406 }
00407 }
00408
00409
00410
00411 n = additive.firstChild();
00412
while ( !n.isNull() )
00413 {
00414
QDomElement e = n.toElement();
00415 n = n.nextSibling();
00416
if (e.isNull())
00417
continue;
00418
00419
QDomElement matchingElement = findMatchingElement( e, base );
00420
00421
if ( matchingElement.isNull() )
00422 {
00423 base.appendChild( e );
00424 }
00425 }
00426
00427
00428
00429
QDomElement last = base.lastChild().toElement();
00430
if ( (last.tagName() == tagSeparator) && (!last.attribute( attrWeakSeparator ).isNull()) )
00431 {
00432 base.removeChild( last );
00433 }
00434
00435
00436
00437
00438
bool deleteMe =
true;
00439
00440 n = base.firstChild();
00441
while ( !n.isNull() )
00442 {
00443
QDomElement e = n.toElement();
00444 n = n.nextSibling();
00445
if (e.isNull())
00446
continue;
00447
00448 tag = e.tagName();
00449
00450
if ( tag == tagAction )
00451 {
00452
00453
00454
00455
if ( actionCollection->
action( e.attribute( attrName ).utf8() ) )
00456 {
00457 deleteMe =
false;
00458
break;
00459 }
00460 }
00461
else if ( tag == tagSeparator )
00462 {
00463
00464
00465
00466
QString weakAttr = e.attribute( attrWeakSeparator );
00467
if ( weakAttr.isEmpty() || weakAttr.toInt() != 1 )
00468 {
00469 deleteMe =
false;
00470
break;
00471 }
00472 }
00473
00474
00475
else if ( tag == tagMerge )
00476 {
00477
00478
00479
continue;
00480 }
00481
00482
00483
else if ( tag == tagText )
00484 {
00485
continue;
00486 }
00487
00488
00489
00490
00491
00492
else
00493 {
00494 deleteMe =
false;
00495
break;
00496 }
00497 }
00498
00499
return deleteMe;
00500 }
00501
00502
QDomElement KXMLGUIClient::findMatchingElement(
const QDomElement &base,
const QDomElement &additive )
00503 {
00504
static const QString &tagAction =
KGlobal::staticQString(
"Action" );
00505
static const QString &tagMergeLocal =
KGlobal::staticQString(
"MergeLocal" );
00506
static const QString &attrName =
KGlobal::staticQString(
"name" );
00507
00508
QDomNode n = additive.firstChild();
00509
while ( !n.isNull() )
00510 {
00511
QDomElement e = n.toElement();
00512 n = n.nextSibling();
00513
if (e.isNull())
00514
continue;
00515
00516
00517
if ( ( e.tagName() == tagAction ) || ( e.tagName() == tagMergeLocal ) )
00518 {
00519
continue;
00520 }
00521
00522
00523
if ( ( e.tagName() == base.tagName() ) &&
00524 ( e.attribute( attrName ) == base.attribute( attrName ) ) )
00525 {
00526
return e;
00527 }
00528 }
00529
00530
00531
return QDomElement();
00532 }
00533
00534 void KXMLGUIClient::conserveMemory()
00535 {
00536 d->m_doc =
QDomDocument();
00537 d->m_buildDocument =
QDomDocument();
00538 }
00539
00540
void KXMLGUIClient::setXMLGUIBuildDocument(
const QDomDocument &doc )
00541 {
00542 d->m_buildDocument = doc;
00543 }
00544
00545
QDomDocument KXMLGUIClient::xmlguiBuildDocument()
const
00546
{
00547
return d->m_buildDocument;
00548 }
00549
00550 void KXMLGUIClient::setFactory(
KXMLGUIFactory *factory )
00551 {
00552 d->m_factory = factory;
00553 }
00554
00555 KXMLGUIFactory *
KXMLGUIClient::factory()
const
00556
{
00557
return d->m_factory;
00558 }
00559
00560 KXMLGUIClient *
KXMLGUIClient::parentClient()
const
00561
{
00562
return d->m_parent;
00563 }
00564
00565 void KXMLGUIClient::insertChildClient(
KXMLGUIClient *child )
00566 {
00567
if ( child->
d->m_parent )
00568 child->
d->m_parent->removeChildClient( child );
00569 d->m_children.append( child );
00570 child->
d->m_parent =
this;
00571 }
00572
00573 void KXMLGUIClient::removeChildClient(
KXMLGUIClient *child )
00574 {
00575 assert( d->m_children.containsRef( child ) );
00576 d->m_children.removeRef( child );
00577 child->
d->m_parent = 0;
00578 }
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588 const QPtrList<KXMLGUIClient> *
KXMLGUIClient::childClients()
00589 {
00590
return &d->m_children;
00591 }
00592
00593 void KXMLGUIClient::setClientBuilder(
KXMLGUIBuilder *builder )
00594 {
00595 d->m_builder = builder;
00596
if ( builder )
00597 builder->
setBuilderInstance(
instance() );
00598 }
00599
00600 KXMLGUIBuilder *
KXMLGUIClient::clientBuilder()
const
00601
{
00602
return d->m_builder;
00603 }
00604
00605 void KXMLGUIClient::plugActionList(
const QString &name,
const QPtrList<KAction> &actionList )
00606 {
00607
if ( !d->m_factory )
00608
return;
00609
00610 d->m_factory->plugActionList(
this, name, actionList );
00611 }
00612
00613 void KXMLGUIClient::unplugActionList(
const QString &name )
00614 {
00615
if ( !d->m_factory )
00616
return;
00617
00618 d->m_factory->unplugActionList(
this, name );
00619 }
00620
00621
QString KXMLGUIClient::findMostRecentXMLFile(
const QStringList &files,
QString &doc )
00622 {
00623
00624
QValueList<DocStruct> allDocuments;
00625
00626 QStringList::ConstIterator it = files.begin();
00627 QStringList::ConstIterator end = files.end();
00628
for (; it != end; ++it )
00629 {
00630
00631
QString data = KXMLGUIFactory::readConfigFile( *it );
00632 DocStruct d;
00633 d.file = *it;
00634 d.data = data;
00635 allDocuments.append( d );
00636 }
00637
00638
QValueList<DocStruct>::Iterator best = allDocuments.end();
00639 uint bestVersion = 0;
00640
00641
QValueList<DocStruct>::Iterator docIt = allDocuments.begin();
00642
QValueList<DocStruct>::Iterator docEnd = allDocuments.end();
00643
for (; docIt != docEnd; ++docIt )
00644 {
00645
QString versionStr = findVersionNumber( (*docIt).data );
00646
if ( versionStr.isEmpty() )
00647
continue;
00648
00649
bool ok =
false;
00650 uint
version = versionStr.toUInt( &ok );
00651
if ( !ok )
00652
continue;
00653
00654
00655
if (
version > bestVersion )
00656 {
00657 best = docIt;
00658
00659 bestVersion =
version;
00660 }
00661 }
00662
00663
if ( best != docEnd )
00664 {
00665
if ( best != allDocuments.begin() )
00666 {
00667
QValueList<DocStruct>::Iterator local = allDocuments.begin();
00668
00669
00670
QDomDocument document;
00671 document.setContent( (*local).data );
00672
00673 ActionPropertiesMap properties = extractActionProperties( document );
00674
00675
00676
00677
00678
if ( !properties.isEmpty() )
00679 {
00680
00681
00682 document.setContent( (*best).data );
00683
00684 storeActionProperties( document, properties );
00685
00686 (*local).data = document.toString();
00687
00688 best = local;
00689
00690
00691
QFile f( (*local).file );
00692
if ( f.open( IO_WriteOnly ) )
00693 {
00694
QCString utf8data = (*local).data.utf8();
00695 f.writeBlock( utf8data.data(), utf8data.length() );
00696 f.close();
00697 }
00698 }
00699
else
00700 {
00701
QString f = (*local).file;
00702
QString backup = f + QString::fromLatin1(
".backup" );
00703
QDir dir;
00704 dir.rename( f, backup );
00705 }
00706 }
00707 doc = (*best).data;
00708
return (*best).file;
00709 }
00710
else if ( files.count() > 0 )
00711 {
00712
00713 doc = (*allDocuments.begin()).data;
00714
return (*allDocuments.begin()).file;
00715 }
00716
00717
return QString::null;
00718 }
00719
00720
00721
00722
QString KXMLGUIClient::findVersionNumber(
const QString &xml )
00723 {
00724
enum { ST_START, ST_AFTER_OPEN, ST_AFTER_GUI,
00725 ST_EXPECT_VERSION, ST_VERSION_NUM} state = ST_START;
00726
for (
unsigned int pos = 0; pos < xml.length(); pos++)
00727 {
00728
switch (state)
00729 {
00730
case ST_START:
00731
if (xml[pos] ==
'<')
00732 state = ST_AFTER_OPEN;
00733
break;
00734
case ST_AFTER_OPEN:
00735 {
00736
00737
int guipos = xml.find(
"gui", pos,
false );
00738
if (guipos == -1)
00739
return QString::null;
00740
00741 pos = guipos + 2;
00742 state = ST_AFTER_GUI;
00743
break;
00744 }
00745
case ST_AFTER_GUI:
00746 state = ST_EXPECT_VERSION;
00747
break;
00748
case ST_EXPECT_VERSION:
00749 {
00750
int verpos = xml.find(
"version=\"", pos,
false );
00751
if (verpos == -1)
00752
return QString::null;
00753
00754 pos = verpos + 8;
00755 state = ST_VERSION_NUM;
00756
break;
00757 }
00758
case ST_VERSION_NUM:
00759 {
00760
unsigned int endpos;
00761
for (endpos = pos; endpos < xml.length(); endpos++)
00762 {
00763
if (xml[endpos].unicode() >=
'0' && xml[endpos].unicode() <=
'9')
00764
continue;
00765
if (xml[endpos].unicode() ==
'"')
00766
break;
00767
else
00768 {
00769 endpos = xml.length();
00770 }
00771 }
00772
00773
if (endpos != pos && endpos < xml.length() )
00774 {
00775
QString matchCandidate = xml.mid(pos, endpos - pos);
00776
return matchCandidate;
00777 }
00778
00779 state = ST_EXPECT_VERSION;
00780
break;
00781 }
00782 }
00783 }
00784
00785
return QString::null;
00786 }
00787
00788
KXMLGUIClient::ActionPropertiesMap KXMLGUIClient::extractActionProperties(
const QDomDocument &doc )
00789 {
00790 ActionPropertiesMap properties;
00791
00792
QDomElement actionPropElement = doc.documentElement().namedItem(
"ActionProperties" ).toElement();
00793
00794
if ( actionPropElement.isNull() )
00795
return properties;
00796
00797
QDomNode n = actionPropElement.firstChild();
00798
while(!n.isNull())
00799 {
00800
QDomElement e = n.toElement();
00801 n = n.nextSibling();
00802
if ( e.isNull() )
00803
continue;
00804
00805
if ( e.tagName().lower() !=
"action" )
00806
continue;
00807
00808
QString actionName = e.attribute(
"name" );
00809
00810
if ( actionName.isEmpty() )
00811
continue;
00812
00813
QMap<QString, QMap<QString, QString> >::Iterator propIt = properties.find( actionName );
00814
if ( propIt == properties.end() )
00815 propIt = properties.insert( actionName,
QMap<QString, QString>() );
00816
00817
const QDomNamedNodeMap attributes = e.attributes();
00818
const uint attributeslength = attributes.length();
00819
00820
for ( uint i = 0; i < attributeslength; ++i )
00821 {
00822
const QDomAttr attr = attributes.item( i ).toAttr();
00823
00824
if ( attr.isNull() )
00825
continue;
00826
00827
const QString name = attr.name();
00828
00829
if (
name ==
"name" ||
name.isEmpty() )
00830
continue;
00831
00832 (*propIt)[
name ] = attr.value();
00833 }
00834
00835 }
00836
00837
return properties;
00838 }
00839
00840
void KXMLGUIClient::storeActionProperties(
QDomDocument &doc,
const ActionPropertiesMap &properties )
00841 {
00842
QDomElement actionPropElement = doc.documentElement().namedItem(
"ActionProperties" ).toElement();
00843
00844
if ( actionPropElement.isNull() )
00845 {
00846 actionPropElement = doc.createElement(
"ActionProperties" );
00847 doc.documentElement().appendChild( actionPropElement );
00848 }
00849
00850
while ( !actionPropElement.firstChild().isNull() )
00851 actionPropElement.removeChild( actionPropElement.firstChild() );
00852
00853 ActionPropertiesMap::ConstIterator it = properties.begin();
00854 ActionPropertiesMap::ConstIterator
end = properties.end();
00855
for (; it !=
end; ++it )
00856 {
00857
QDomElement action = doc.createElement(
"Action" );
00858
action.setAttribute(
"name", it.key() );
00859 actionPropElement.appendChild( action );
00860
00861
QMap<QString, QString> attributes = (*it);
00862
QMap<QString, QString>::ConstIterator attrIt = attributes.begin();
00863
QMap<QString, QString>::ConstIterator attrEnd = attributes.end();
00864
for (; attrIt != attrEnd; ++attrIt )
00865
action.setAttribute( attrIt.key(), attrIt.data() );
00866 }
00867 }
00868
00869
void KXMLGUIClient::addStateActionEnabled(
const QString& state,
00870
const QString& action)
00871 {
00872 StateChange stateChange = getActionsToChangeForState(state);
00873
00874 stateChange.actionsToEnable.append( action );
00875
00876
00877 m_actionsStateMap.replace( state, stateChange );
00878 }
00879
00880
00881
void KXMLGUIClient::addStateActionDisabled(
const QString& state,
00882
const QString& action)
00883 {
00884 StateChange stateChange = getActionsToChangeForState(state);
00885
00886 stateChange.actionsToDisable.append( action );
00887
00888
00889 m_actionsStateMap.replace( state, stateChange );
00890 }
00891
00892
00893 KXMLGUIClient::StateChange KXMLGUIClient::getActionsToChangeForState(
const QString& state)
00894 {
00895
return m_actionsStateMap[state];
00896 }
00897
00898
00899 void KXMLGUIClient::stateChanged(
const QString &newstate, KXMLGUIClient::ReverseStateChange reverse)
00900 {
00901 StateChange stateChange = getActionsToChangeForState(newstate);
00902
00903
bool setTrue = (reverse == StateNoReverse);
00904
bool setFalse = !setTrue;
00905
00906
00907
00908
for ( QStringList::Iterator it = stateChange.actionsToEnable.begin();
00909 it != stateChange.actionsToEnable.end(); ++it ) {
00910
00911
KAction *
action =
actionCollection()->
action((*it).latin1());
00912
if (action) action->setEnabled(setTrue);
00913 }
00914
00915
00916
00917
for ( QStringList::Iterator it = stateChange.actionsToDisable.begin();
00918 it != stateChange.actionsToDisable.end(); ++it ) {
00919
00920
KAction *
action =
actionCollection()->
action((*it).latin1());
00921
if (action) action->setEnabled(setFalse);
00922 }
00923
00924 }
00925
00926 void KXMLGUIClient::beginXMLPlug(
QWidget *w )
00927 {
00928
actionCollection()->
beginXMLPlug( w );
00929
QPtrListIterator<KXMLGUIClient> childIt( d->m_children );
00930
for (; childIt.current(); ++childIt )
00931 childIt.current()->actionCollection()->beginXMLPlug( w );
00932 }
00933
00934 void KXMLGUIClient::endXMLPlug()
00935 {
00936
actionCollection()->
endXMLPlug();
00937
QPtrListIterator<KXMLGUIClient> childIt( d->m_children );
00938
for (; childIt.current(); ++childIt )
00939 childIt.current()->actionCollection()->endXMLPlug();
00940 }
00941
00942 void KXMLGUIClient::prepareXMLUnplug(
QWidget * )
00943 {
00944
actionCollection()->
prepareXMLUnplug();
00945
QPtrListIterator<KXMLGUIClient> childIt( d->m_children );
00946
for (; childIt.current(); ++childIt )
00947 childIt.current()->actionCollection()->prepareXMLUnplug();
00948 }
00949
00950
void KXMLGUIClient::virtual_hook(
int,
void* )
00951 { }