00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "kxmlguifactory_p.h"
00021 #include "kxmlguiclient.h"
00022 #include "kxmlguibuilder.h"
00023
00024 #include <qwidget.h>
00025
00026 #include <kglobal.h>
00027 #include <kdebug.h>
00028
00029 #include <assert.h>
00030
00031 using namespace KXMLGUI;
00032
00033 void ActionList::plug( QWidget *container, int index ) const
00034 {
00035 ActionListIt it( *this );
00036 for (; it.current(); ++it )
00037 it.current()->plug( container, index++ );
00038 }
00039
00040 void ActionList::unplug( QWidget *container ) const
00041 {
00042 ActionListIt it( *this );
00043 for (; it.current(); ++it )
00044 it.current()->unplug( container );
00045 }
00046
00047 ContainerNode::ContainerNode( QWidget *_container, const QString &_tagName,
00048 const QString &_name, ContainerNode *_parent,
00049 KXMLGUIClient *_client, KXMLGUIBuilder *_builder,
00050 int id, const QString &_mergingName,
00051 const QString &_groupName, const QStringList &customTags,
00052 const QStringList &containerTags )
00053 : parent( _parent ), client( _client ), builder( _builder ),
00054 builderCustomTags( customTags ), builderContainerTags( containerTags ),
00055 container( _container ), containerId( id ), tagName( _tagName ), name( _name ),
00056 groupName( _groupName ), index( 0 ), mergingName( _mergingName )
00057 {
00058 children.setAutoDelete( true );
00059 clients.setAutoDelete( true );
00060
00061 if ( parent )
00062 parent->children.append( this );
00063 }
00064
00065 void ContainerNode::removeChild( ContainerNode *child )
00066 {
00067 MergingIndexList::Iterator mergingIt = findIndex( child->mergingName );
00068 adjustMergingIndices( -1, mergingIt );
00069 children.removeRef( child );
00070 }
00071
00072
00073
00074
00075
00076 MergingIndexList::Iterator ContainerNode::findIndex( const QString &name )
00077 {
00078 MergingIndexList::Iterator it( mergingIndices.begin() );
00079 MergingIndexList::Iterator end( mergingIndices.end() );
00080 for (; it != end; ++it )
00081 if ( (*it).mergingName == name )
00082 return it;
00083 return it;
00084 }
00085
00086
00087
00088
00089
00090 ContainerNode *ContainerNode::findContainerNode( QWidget *container )
00091 {
00092 ContainerNodeListIt it( children );
00093
00094 for (; it.current(); ++it )
00095 if ( it.current()->container == container )
00096 return it.current();
00097
00098 return 0L;
00099 }
00100
00101
00102
00103
00104
00105
00106 ContainerNode *ContainerNode::findContainer( const QString &_name, bool tag )
00107 {
00108 if ( ( tag && tagName == _name ) ||
00109 ( !tag && name == _name ) )
00110 return this;
00111
00112 ContainerNodeListIt it( children );
00113 for (; it.current(); ++it )
00114 {
00115 ContainerNode *res = it.current()->findContainer( _name, tag );
00116 if ( res )
00117 return res;
00118 }
00119
00120 return 0;
00121 }
00122
00123
00124
00125
00126
00127
00128 ContainerNode *ContainerNode::findContainer( const QString &name, const QString &tagName,
00129 const QPtrList<QWidget> *excludeList,
00130 KXMLGUIClient * )
00131 {
00132 ContainerNode *res = 0L;
00133 ContainerNodeListIt nIt( children );
00134
00135 if ( !name.isEmpty() )
00136 {
00137 for (; nIt.current(); ++nIt )
00138 if ( nIt.current()->name == name &&
00139 !excludeList->containsRef( nIt.current()->container ) )
00140 {
00141 res = nIt.current();
00142 break;
00143 }
00144
00145 return res;
00146 }
00147
00148 if ( !tagName.isEmpty() )
00149 for (; nIt.current(); ++nIt )
00150 {
00151 if ( nIt.current()->tagName == tagName &&
00152 !excludeList->containsRef( nIt.current()->container )
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168 )
00169 {
00170 res = nIt.current();
00171 break;
00172 }
00173 }
00174
00175 return res;
00176 }
00177
00178 ContainerClient *ContainerNode::findChildContainerClient( KXMLGUIClient *currentGUIClient,
00179 const QString &groupName,
00180 const MergingIndexList::Iterator &mergingIdx )
00181 {
00182 if ( !clients.isEmpty() )
00183 {
00184 ContainerClientListIt clientIt( clients );
00185
00186 for (; clientIt.current(); ++clientIt )
00187 if ( clientIt.current()->client == currentGUIClient )
00188 {
00189 if ( groupName.isEmpty() )
00190 return clientIt.current();
00191
00192 if ( groupName == clientIt.current()->groupName )
00193 return clientIt.current();
00194 }
00195 }
00196
00197 ContainerClient *client = new ContainerClient;
00198 client->client = currentGUIClient;
00199 client->groupName = groupName;
00200
00201 if ( mergingIdx != mergingIndices.end() )
00202 client->mergingName = (*mergingIdx).mergingName;
00203
00204 clients.append( client );
00205
00206 return client;
00207 }
00208
00209 void ContainerNode::plugActionList( BuildState &state )
00210 {
00211 MergingIndexList::Iterator mIt( mergingIndices.begin() );
00212 MergingIndexList::Iterator mEnd( mergingIndices.end() );
00213 for (; mIt != mEnd; ++mIt )
00214 plugActionList( state, mIt );
00215
00216 QPtrListIterator<ContainerNode> childIt( children );
00217 for (; childIt.current(); ++childIt )
00218 childIt.current()->plugActionList( state );
00219 }
00220
00221 void ContainerNode::plugActionList( BuildState &state, const MergingIndexList::Iterator &mergingIdxIt )
00222 {
00223 static const QString &tagActionList = KGlobal::staticQString( "actionlist" );
00224
00225 MergingIndex mergingIdx = *mergingIdxIt;
00226
00227 QString k( mergingIdx.mergingName );
00228
00229 if ( k.find( tagActionList ) == -1 )
00230 return;
00231
00232 k = k.mid( tagActionList.length() );
00233
00234 if ( mergingIdx.clientName != state.clientName )
00235 return;
00236
00237 if ( k != state.actionListName )
00238 return;
00239
00240 ContainerClient *client = findChildContainerClient( state.guiClient,
00241 QString::null,
00242 mergingIndices.end() );
00243
00244 client->actionLists.insert( k, state.actionList );
00245
00246 state.actionList.plug( container, mergingIdx.value );
00247
00248 adjustMergingIndices( state.actionList.count(), mergingIdxIt );
00249 }
00250
00251 void ContainerNode::unplugActionList( BuildState &state )
00252 {
00253 MergingIndexList::Iterator mIt( mergingIndices.begin() );
00254 MergingIndexList::Iterator mEnd( mergingIndices.end() );
00255 for (; mIt != mEnd; ++mIt )
00256 unplugActionList( state, mIt );
00257
00258 QPtrListIterator<ContainerNode> childIt( children );
00259 for (; childIt.current(); ++childIt )
00260 childIt.current()->unplugActionList( state );
00261 }
00262
00263 void ContainerNode::unplugActionList( BuildState &state, const MergingIndexList::Iterator &mergingIdxIt )
00264 {
00265 static const QString &tagActionList = KGlobal::staticQString( "actionlist" );
00266
00267 MergingIndex mergingIdx = *mergingIdxIt;
00268
00269 QString k = mergingIdx.mergingName;
00270
00271 if ( k.find( tagActionList ) == -1 )
00272 return;
00273
00274 k = k.mid( tagActionList.length() );
00275
00276 if ( mergingIdx.clientName != state.clientName )
00277 return;
00278
00279 if ( k != state.actionListName )
00280 return;
00281
00282 ContainerClient *client = findChildContainerClient( state.guiClient,
00283 QString::null,
00284 mergingIndices.end() );
00285
00286 ActionListMap::Iterator lIt( client->actionLists.find( k ) );
00287 if ( lIt == client->actionLists.end() )
00288 return;
00289
00290 lIt.data().unplug( container );
00291
00292 adjustMergingIndices( -int(lIt.data().count()), mergingIdxIt );
00293
00294 client->actionLists.remove( lIt );
00295 }
00296
00297 void ContainerNode::adjustMergingIndices( int offset,
00298 const MergingIndexList::Iterator &it )
00299 {
00300 MergingIndexList::Iterator mergingIt = it;
00301 MergingIndexList::Iterator mergingEnd = mergingIndices.end();
00302
00303 for (; mergingIt != mergingEnd; ++mergingIt )
00304 (*mergingIt).value += offset;
00305
00306 index += offset;
00307 }
00308
00309 bool ContainerNode::destruct( QDomElement element, BuildState &state )
00310 {
00311 destructChildren( element, state );
00312
00313 unplugActions( state );
00314
00315
00316 MergingIndexList::Iterator cmIt = mergingIndices.begin();
00317 while ( cmIt != mergingIndices.end() )
00318 if ( (*cmIt).clientName == state.clientName )
00319 cmIt = mergingIndices.remove( cmIt );
00320 else
00321 ++cmIt;
00322
00323
00324 if ( clients.count() == 0 && children.count() == 0 && container &&
00325 client == state.guiClient )
00326 {
00327 QWidget *parentContainer = 0L;
00328
00329 if ( parent && parent->container )
00330 parentContainer = parent->container;
00331
00332 assert( builder );
00333
00334 builder->removeContainer( container, parentContainer, element, containerId );
00335
00336 client = 0L;
00337
00338 return true;
00339 }
00340
00341 if ( client == state.guiClient )
00342 client = 0L;
00343
00344 return false;
00345
00346 }
00347
00348 void ContainerNode::destructChildren( const QDomElement &element, BuildState &state )
00349 {
00350 QPtrListIterator<ContainerNode> childIt( children );
00351 while ( childIt.current() )
00352 {
00353 ContainerNode *childNode = childIt.current();
00354
00355 QDomElement childElement = findElementForChild( element, childNode );
00356
00357
00358 if ( childNode->destruct( childElement, state ) )
00359 removeChild( childNode );
00360 else
00361 ++childIt;
00362 }
00363 }
00364
00365 QDomElement ContainerNode::findElementForChild( const QDomElement &baseElement,
00366 ContainerNode *childNode )
00367 {
00368 static const QString &attrName = KGlobal::staticQString( "name" );
00369
00370
00371 for ( QDomNode n = baseElement.firstChild(); !n.isNull();
00372 n = n.nextSibling() )
00373 {
00374 QDomElement e = n.toElement();
00375 if ( e.tagName().lower() == childNode->tagName &&
00376 e.attribute( attrName ) == childNode->name )
00377 return e;
00378 }
00379
00380 return QDomElement();
00381 }
00382
00383 void ContainerNode::unplugActions( BuildState &state )
00384 {
00385 if ( !container )
00386 return;
00387
00388 ContainerClientListIt clientIt( clients );
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401 while ( clientIt.current() )
00402
00403
00404 if ( clientIt.current()->client == state.guiClient )
00405 {
00406 unplugClient( clientIt.current() );
00407 clients.removeRef( clientIt.current() );
00408 }
00409 else
00410 ++clientIt;
00411 }
00412
00413 void ContainerNode::unplugClient( ContainerClient *client )
00414 {
00415 static const QString &tagActionList = KGlobal::staticQString( "actionlist" );
00416
00417 assert( builder );
00418
00419
00420
00421 QValueList<int>::ConstIterator custIt = client->customElements.begin();
00422 QValueList<int>::ConstIterator custEnd = client->customElements.end();
00423 for (; custIt != custEnd; ++custIt )
00424 builder->removeCustomElement( container, *custIt );
00425
00426 client->actions.unplug( container );
00427
00428
00429
00430 MergingIndexList::Iterator mergingIt = findIndex( client->mergingName );
00431
00432 adjustMergingIndices( - int( client->actions.count()
00433 + client->customElements.count() ),
00434 mergingIt );
00435
00436
00437
00438 ActionListMap::ConstIterator alIt = client->actionLists.begin();
00439 ActionListMap::ConstIterator alEnd = client->actionLists.end();
00440 for (; alIt != alEnd; ++alIt )
00441 {
00442 alIt.data().unplug( container );
00443
00444
00445
00446 QString mergingKey = alIt.key();
00447 mergingKey.prepend( tagActionList );
00448
00449 MergingIndexList::Iterator mIt = findIndex( mergingKey );
00450 if ( mIt == mergingIndices.end() )
00451 continue;
00452
00453 adjustMergingIndices( -int(alIt.data().count()), mIt );
00454
00455
00456
00457 mergingIndices.remove( mIt );
00458 }
00459 }
00460
00461 void ContainerNode::reset()
00462 {
00463 QPtrListIterator<ContainerNode> childIt( children );
00464 for (; childIt.current(); ++childIt )
00465 childIt.current()->reset();
00466
00467 if ( client )
00468 client->setFactory( 0L );
00469 }
00470
00471 int ContainerNode::calcMergingIndex( const QString &mergingName,
00472 MergingIndexList::Iterator &it,
00473 BuildState &state,
00474 bool ignoreDefaultMergingIndex )
00475 {
00476 MergingIndexList::Iterator mergingIt;
00477
00478 if ( mergingName.isEmpty() )
00479 mergingIt = findIndex( state.clientName );
00480 else
00481 mergingIt = findIndex( mergingName );
00482
00483 MergingIndexList::Iterator mergingEnd = mergingIndices.end();
00484 it = mergingEnd;
00485
00486 if ( ( mergingIt == mergingEnd && state.currentDefaultMergingIt == mergingEnd ) ||
00487 ignoreDefaultMergingIndex )
00488 return index;
00489
00490 if ( mergingIt != mergingEnd )
00491 it = mergingIt;
00492 else
00493 it = state.currentDefaultMergingIt;
00494
00495 return (*it).value;
00496 }
00497
00498 int BuildHelper::calcMergingIndex( const QDomElement &element, MergingIndexList::Iterator &it, QString &group )
00499 {
00500 static const QString &attrGroup = KGlobal::staticQString( "group" );
00501
00502 bool haveGroup = false;
00503 group = element.attribute( attrGroup );
00504 if ( !group.isEmpty() ) {
00505 group.prepend( attrGroup );
00506 haveGroup = true;
00507 }
00508
00509 int idx;
00510 if ( haveGroup )
00511 idx = parentNode->calcMergingIndex( group, it, m_state, ignoreDefaultMergingIndex );
00512 else if ( m_state.currentClientMergingIt == parentNode->mergingIndices.end() )
00513 idx = parentNode->index;
00514 else
00515 idx = (*m_state.currentClientMergingIt).value;
00516
00517 return idx;
00518 }
00519
00520 BuildHelper::BuildHelper( BuildState &state, ContainerNode *node )
00521 : containerClient( 0 ), ignoreDefaultMergingIndex( false ), m_state( state ),
00522 parentNode( node )
00523 {
00524 static const QString &defaultMergingName = KGlobal::staticQString( "<default>" );
00525
00526
00527 customTags = m_state.builderCustomTags;
00528 containerTags = m_state.builderContainerTags;
00529
00530 if ( parentNode->builder != m_state.builder )
00531 {
00532 customTags += parentNode->builderCustomTags;
00533 containerTags += parentNode->builderContainerTags;
00534 }
00535
00536 if ( m_state.clientBuilder ) {
00537 customTags = m_state.clientBuilderCustomTags + customTags;
00538 containerTags = m_state.clientBuilderContainerTags + containerTags;
00539 }
00540
00541 m_state.currentDefaultMergingIt = parentNode->findIndex( defaultMergingName );
00542 parentNode->calcMergingIndex( QString::null, m_state.currentClientMergingIt,
00543 m_state, false );
00544 }
00545
00546 void BuildHelper::build( const QDomElement &element )
00547 {
00548 for (QDomNode n = element.firstChild(); !n.isNull(); n = n.nextSibling() )
00549 {
00550 QDomElement e = n.toElement();
00551 if (e.isNull()) continue;
00552 processElement( e );
00553 }
00554 }
00555
00556 void BuildHelper::processElement( const QDomElement &e )
00557 {
00558
00559 static const QString &tagAction = KGlobal::staticQString( "action" );
00560 static const QString &tagMerge = KGlobal::staticQString( "merge" );
00561 static const QString &tagState = KGlobal::staticQString( "state" );
00562 static const QString &tagDefineGroup = KGlobal::staticQString( "definegroup" );
00563 static const QString &tagActionList = KGlobal::staticQString( "actionlist" );
00564 static const QString &attrName = KGlobal::staticQString( "name" );
00565
00566 QString tag( e.tagName().lower() );
00567 QString currName( e.attribute( attrName ) );
00568
00569 bool isActionTag = ( tag == tagAction );
00570
00571 if ( isActionTag || customTags.findIndex( tag ) != -1 )
00572 processActionOrCustomElement( e, isActionTag );
00573 else if ( containerTags.findIndex( tag ) != -1 )
00574 processContainerElement( e, tag, currName );
00575 else if ( tag == tagMerge || tag == tagDefineGroup || tag == tagActionList )
00576 processMergeElement( tag, currName, e );
00577 else if ( tag == tagState )
00578 processStateElement( e );
00579 }
00580
00581 void BuildHelper::processActionOrCustomElement( const QDomElement &e, bool isActionTag )
00582 {
00583 if ( !parentNode->container )
00584 return;
00585
00586 MergingIndexList::Iterator it( m_state.currentClientMergingIt );
00587
00588 QString group;
00589 int idx = calcMergingIndex( e, it, group );
00590
00591 containerClient = parentNode->findChildContainerClient( m_state.guiClient, group, it );
00592
00593 bool guiElementCreated = false;
00594 if ( isActionTag )
00595 guiElementCreated = processActionElement( e, idx );
00596 else
00597 guiElementCreated = processCustomElement( e, idx );
00598
00599 if ( guiElementCreated )
00600
00601 parentNode->adjustMergingIndices( 1, it );
00602 }
00603
00604 bool BuildHelper::processActionElement( const QDomElement &e, int idx )
00605 {
00606 assert( m_state.guiClient );
00607
00608
00609 KAction *action = m_state.guiClient->action( e );
00610
00611
00612 if ( !action )
00613 return false;
00614
00615 action->plug( parentNode->container, idx );
00616
00617
00618 containerClient->actions.append( action );
00619
00620 return true;
00621 }
00622
00623 bool BuildHelper::processCustomElement( const QDomElement &e, int idx )
00624 {
00625 assert( parentNode->builder );
00626
00627 int id = parentNode->builder->createCustomElement( parentNode->container, idx, e );
00628 if ( id == 0 )
00629 return false;
00630
00631 containerClient->customElements.append( id );
00632 return true;
00633 }
00634
00635 void BuildHelper::processStateElement( const QDomElement &element )
00636 {
00637 QString stateName = element.attribute( "name" );
00638
00639 if ( !stateName || !stateName.length() ) return;
00640
00641 for (QDomNode n = element.firstChild(); !n.isNull(); n = n.nextSibling() )
00642 {
00643 QDomElement e = n.toElement();
00644 if (e.isNull()) continue;
00645
00646 QString tagName = e.tagName().lower();
00647
00648 if ( tagName != "enable" && tagName != "disable" )
00649 continue;
00650
00651 bool processingActionsToEnable = (tagName == "enable");
00652
00653
00654 for (QDomNode n2 = n.firstChild(); !n2.isNull(); n2 = n2.nextSibling() )
00655 {
00656 QDomElement actionEl = n2.toElement();
00657 if ( actionEl.tagName().lower() != "action" ) continue;
00658
00659 QString actionName = actionEl.attribute( "name" );
00660 if ( !actionName || !actionName.length() ) return;
00661
00662 if ( processingActionsToEnable )
00663 m_state.guiClient->addStateActionEnabled( stateName, actionName );
00664 else
00665 m_state.guiClient->addStateActionDisabled( stateName, actionName );
00666
00667 }
00668 }
00669 }
00670
00671 void BuildHelper::processMergeElement( const QString &tag, const QString &name, const QDomElement &e )
00672 {
00673 static const QString &tagDefineGroup = KGlobal::staticQString( "definegroup" );
00674 static const QString &tagActionList = KGlobal::staticQString( "actionlist" );
00675 static const QString &defaultMergingName = KGlobal::staticQString( "<default>" );
00676 static const QString &attrGroup = KGlobal::staticQString( "group" );
00677
00678 QString mergingName( name );
00679 if ( mergingName.isEmpty() )
00680 {
00681 if ( tag == tagDefineGroup )
00682 {
00683 kdError(1000) << "cannot define group without name!" << endl;
00684 return;
00685 }
00686 if ( tag == tagActionList )
00687 {
00688 kdError(1000) << "cannot define actionlist without name!" << endl;
00689 return;
00690 }
00691 mergingName = defaultMergingName;
00692 }
00693
00694 if ( tag == tagDefineGroup )
00695 mergingName.prepend( attrGroup );
00696
00697 else if ( tag == tagActionList )
00698 mergingName.prepend( tagActionList );
00699
00700 if ( parentNode->findIndex( mergingName ) != parentNode->mergingIndices.end() )
00701 return;
00702
00703 MergingIndexList::Iterator mIt( parentNode->mergingIndices.end() );
00704
00705 QString group( e.attribute( attrGroup ) );
00706 if ( !group.isEmpty() )
00707 group.prepend( attrGroup );
00708
00709
00710
00711
00712
00713 MergingIndex newIdx;
00714 newIdx.value = parentNode->calcMergingIndex( group, mIt, m_state, ignoreDefaultMergingIndex );
00715 newIdx.mergingName = mergingName;
00716 newIdx.clientName = m_state.clientName;
00717
00718
00719 if ( mIt != parentNode->mergingIndices.end() )
00720 parentNode->mergingIndices.insert( ++mIt, newIdx );
00721 else
00722 parentNode->mergingIndices.append( newIdx );
00723
00724 if ( mergingName == defaultMergingName )
00725
00726 ignoreDefaultMergingIndex = true;
00727
00728
00729 m_state.currentDefaultMergingIt = parentNode->findIndex( defaultMergingName );
00730 parentNode->calcMergingIndex( QString::null, m_state.currentClientMergingIt,
00731 m_state, ignoreDefaultMergingIndex );
00732 }
00733
00734 void BuildHelper::processContainerElement( const QDomElement &e, const QString &tag,
00735 const QString &name )
00736 {
00737 static const QString &defaultMergingName = KGlobal::staticQString( "<default>" );
00738
00739 ContainerNode *containerNode = parentNode->findContainer( name, tag,
00740 &containerList,
00741 m_state.guiClient );
00742
00743 if ( !containerNode )
00744 {
00745 MergingIndexList::Iterator it( m_state.currentClientMergingIt );
00746 QString group;
00747
00748 int idx = calcMergingIndex( e, it, group );
00749
00750 int id;
00751
00752 KXMLGUIBuilder *builder;
00753
00754 QWidget *container = createContainer( parentNode->container, idx, e, id, &builder );
00755
00756
00757 if ( !container )
00758 return;
00759
00760 parentNode->adjustMergingIndices( 1, it );
00761
00762 assert( !parentNode->findContainerNode( container ) );
00763
00764 containerList.append( container );
00765
00766 QString mergingName;
00767 if ( it != parentNode->mergingIndices.end() )
00768 mergingName = (*it).mergingName;
00769
00770 QStringList cusTags = m_state.builderCustomTags;
00771 QStringList conTags = m_state.builderContainerTags;
00772 if ( builder != m_state.builder )
00773 {
00774 cusTags = m_state.clientBuilderCustomTags;
00775 conTags = m_state.clientBuilderContainerTags;
00776 }
00777
00778 containerNode = new ContainerNode( container, tag, name, parentNode,
00779 m_state.guiClient, builder, id,
00780 mergingName, group, cusTags, conTags );
00781 }
00782
00783 BuildHelper( m_state, containerNode ).build( e );
00784
00785
00786 m_state.currentDefaultMergingIt = parentNode->findIndex( defaultMergingName );
00787 parentNode->calcMergingIndex( QString::null, m_state.currentClientMergingIt,
00788 m_state, ignoreDefaultMergingIndex );
00789 }
00790
00791 QWidget *BuildHelper::createContainer( QWidget *parent, int index,
00792 const QDomElement &element, int &id,
00793 KXMLGUIBuilder **builder )
00794 {
00795 QWidget *res = 0L;
00796
00797 if ( m_state.clientBuilder )
00798 {
00799 res = m_state.clientBuilder->createContainer( parent, index, element, id );
00800
00801 if ( res )
00802 {
00803 *builder = m_state.clientBuilder;
00804 return res;
00805 }
00806 }
00807
00808 KInstance *oldInstance = m_state.builder->builderInstance();
00809 KXMLGUIClient *oldClient = m_state.builder->builderClient();
00810
00811 m_state.builder->setBuilderClient( m_state.guiClient );
00812
00813 res = m_state.builder->createContainer( parent, index, element, id );
00814
00815 m_state.builder->setBuilderInstance( oldInstance );
00816 m_state.builder->setBuilderClient( oldClient );
00817
00818 if ( res )
00819 *builder = m_state.builder;
00820
00821 return res;
00822 }
00823
00824 void BuildState::reset()
00825 {
00826 clientName = QString::null;
00827 actionListName = QString::null;
00828 actionList.clear();
00829 guiClient = 0;
00830 clientBuilder = 0;
00831
00832 currentDefaultMergingIt = currentClientMergingIt = MergingIndexList::Iterator();
00833 }
00834
00835
00836