diff options
Diffstat (limited to 'tdeui/kxmlguiclient.cpp')
| -rw-r--r-- | tdeui/kxmlguiclient.cpp | 951 |
1 files changed, 951 insertions, 0 deletions
diff --git a/tdeui/kxmlguiclient.cpp b/tdeui/kxmlguiclient.cpp new file mode 100644 index 000000000..dd7458ede --- /dev/null +++ b/tdeui/kxmlguiclient.cpp @@ -0,0 +1,951 @@ +/* This file is part of the KDE libraries + Copyright (C) 2000 Simon Hausmann <hausmann@kde.org> + Copyright (C) 2000 Kurt Granroth <granroth@kde.org> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License version 2 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "kxmlguiclient.h" +#include "kxmlguifactory.h" +#include "kxmlguibuilder.h" + +#include <tqdir.h> +#include <tqfile.h> +#include <tqdom.h> +#include <tqtextstream.h> +#include <tqregexp.h> +#include <tqguardedptr.h> + +#include <kinstance.h> +#include <kstandarddirs.h> +#include <kdebug.h> +#include <kaction.h> +#include <kapplication.h> + +#include <assert.h> + +class KXMLGUIClientPrivate +{ +public: + KXMLGUIClientPrivate() + { + m_instance = KGlobal::instance(); + m_parent = 0L; + m_builder = 0L; + m_actionCollection = 0; + } + ~KXMLGUIClientPrivate() + { + } + + KInstance *m_instance; + + TQDomDocument m_doc; + KActionCollection *m_actionCollection; + TQDomDocument m_buildDocument; + TQGuardedPtr<KXMLGUIFactory> m_factory; + KXMLGUIClient *m_parent; + //TQPtrList<KXMLGUIClient> m_supers; + TQPtrList<KXMLGUIClient> m_children; + KXMLGUIBuilder *m_builder; + TQString m_xmlFile; + TQString m_localXMLFile; +}; + +KXMLGUIClient::KXMLGUIClient() +{ + d = new KXMLGUIClientPrivate; +} + +KXMLGUIClient::KXMLGUIClient( KXMLGUIClient *parent ) +{ + d = new KXMLGUIClientPrivate; + parent->insertChildClient( this ); +} + +KXMLGUIClient::~KXMLGUIClient() +{ + if ( d->m_parent ) + d->m_parent->removeChildClient( this ); + + TQPtrListIterator<KXMLGUIClient> it( d->m_children ); + for ( ; it.current(); ++it ) { + assert( it.current()->d->m_parent == this ); + it.current()->d->m_parent = 0; + } + + delete d->m_actionCollection; + delete d; +} + +KAction *KXMLGUIClient::action( const char *name ) const +{ + KAction* act = actionCollection()->action( name ); + if ( !act ) { + TQPtrListIterator<KXMLGUIClient> childIt( d->m_children ); + for (; childIt.current(); ++childIt ) { + act = childIt.current()->actionCollection()->action( name ); + if ( act ) + break; + } + } + return act; +} + +KActionCollection *KXMLGUIClient::actionCollection() const +{ + if ( !d->m_actionCollection ) + { + d->m_actionCollection = new KActionCollection( + "KXMLGUIClient-KActionCollection", this ); + } + return d->m_actionCollection; +} + +KAction *KXMLGUIClient::action( const TQDomElement &element ) const +{ + static const TQString &attrName = KGlobal::staticQString( "name" ); + return actionCollection()->action( element.attribute( attrName ).latin1() ); +} + +KInstance *KXMLGUIClient::instance() const +{ + return d->m_instance; +} + +TQDomDocument KXMLGUIClient::domDocument() const +{ + return d->m_doc; +} + +TQString KXMLGUIClient::xmlFile() const +{ + return d->m_xmlFile; +} + +TQString KXMLGUIClient::localXMLFile() const +{ + if ( !d->m_localXMLFile.isEmpty() ) + return d->m_localXMLFile; + + if ( !TQDir::isRelativePath(d->m_xmlFile) ) + return TQString::null; // can't save anything here + + return locateLocal( "data", TQString::tqfromLatin1( instance()->instanceName() + '/' ) + d->m_xmlFile ); +} + + +void KXMLGUIClient::reloadXML() +{ + TQString file( xmlFile() ); + if ( !file.isEmpty() ) + setXMLFile( file ); +} + +void KXMLGUIClient::setInstance( KInstance *instance ) +{ + d->m_instance = instance; + actionCollection()->setInstance( instance ); + if ( d->m_builder ) + d->m_builder->setBuilderClient( this ); +} + +void KXMLGUIClient::setXMLFile( const TQString& _file, bool merge, bool setXMLDoc ) +{ + // store our xml file name + if ( !_file.isNull() ) { + d->m_xmlFile = _file; + actionCollection()->setXMLFile( _file ); + } + + if ( !setXMLDoc ) + return; + + TQString file = _file; + if ( TQDir::isRelativePath(file) ) + { + TQString doc; + + TQString filter = TQString::tqfromLatin1( instance()->instanceName() + '/' ) + _file; + + TQStringList allFiles = instance()->dirs()->findAllResources( "data", filter ) + instance()->dirs()->findAllResources( "data", _file ); + + file = findMostRecentXMLFile( allFiles, doc ); + + if ( file.isEmpty() ) + { + // this might or might not be an error. for the time being, + // let's treat this as if it isn't a problem and the user just + // wants the global standards file + + // however if a non-empty file gets passed and we can't find it we might + // inform the developer using some debug output + if ( !_file.isEmpty() ) + kdWarning() << "KXMLGUIClient::setXMLFile: cannot find .rc file " << _file << endl; + + setXML( TQString::null, true ); + return; + } + else if ( !doc.isEmpty() ) + { + setXML( doc, merge ); + return; + } + } + + TQString xml = KXMLGUIFactory::readConfigFile( file ); + setXML( xml, merge ); +} + +void KXMLGUIClient::setLocalXMLFile( const TQString &file ) +{ + d->m_localXMLFile = file; +} + +void KXMLGUIClient::setXML( const TQString &document, bool merge ) +{ + TQDomDocument doc; + doc.setContent( document ); + setDOMDocument( doc, merge ); +} + +void KXMLGUIClient::setDOMDocument( const TQDomDocument &document, bool merge ) +{ + if ( merge ) + { + TQDomElement base = d->m_doc.documentElement(); + + TQDomElement e = document.documentElement(); + + // merge our original (global) xml with our new one + mergeXML(base, e, actionCollection()); + + // reassign our pointer as mergeXML might have done something + // strange to it + base = d->m_doc.documentElement(); + + // we want some sort of failsafe.. just in case + if ( base.isNull() ) + d->m_doc = document; + } + else + { + d->m_doc = document; + } + + setXMLGUIBuildDocument( TQDomDocument() ); +} + +bool KXMLGUIClient::mergeXML( TQDomElement &base, const TQDomElement &additive, KActionCollection *actionCollection ) +{ + static const TQString &tagAction = KGlobal::staticQString( "Action" ); + static const TQString &tagMerge = KGlobal::staticQString( "Merge" ); + static const TQString &tagSeparator = KGlobal::staticQString( "Separator" ); + static const TQString &attrName = KGlobal::staticQString( "name" ); + static const TQString &attrAppend = KGlobal::staticQString( "append" ); + static const TQString &attrWeakSeparator = KGlobal::staticQString( "weakSeparator" ); + static const TQString &tagMergeLocal = KGlobal::staticQString( "MergeLocal" ); + static const TQString &tagText = KGlobal::staticQString( "text" ); + static const TQString &attrAlreadyVisited = KGlobal::staticQString( "alreadyVisited" ); + static const TQString &attrNoMerge = KGlobal::staticQString( "noMerge" ); + static const TQString &attrOne = KGlobal::staticQString( "1" ); + + // there is a possibility that we don't want to merge in the + // additive.. rather, we might want to *replace* the base with the + // additive. this can be for any container.. either at a file wide + // level or a simple container level. we look for the 'noMerge' + // tag, in any event and just replace the old with the new + if ( additive.attribute(attrNoMerge) == attrOne ) // ### use toInt() instead? (Simon) + { + base.parentNode().replaceChild(additive, base); + return true; + } + + TQString tag; + + // iterate over all elements in the container (of the global DOM tree) + TQDomNode n = base.firstChild(); + while ( !n.isNull() ) + { + TQDomElement e = n.toElement(); + n = n.nextSibling(); // Advance now so that we can safely delete e + if (e.isNull()) + continue; + + tag = e.tagName(); + + // if there's an action tag in the global tree and the action is + // not implemented, then we remove the element + if ( tag == tagAction ) + { + TQCString name = e.attribute( attrName ).utf8(); // WABA + if ( !actionCollection->action( name.data() ) || + (kapp && !kapp->authorizeKAction(name))) + { + // remove this child as we aren't using it + base.removeChild( e ); + continue; + } + } + + // if there's a separator defined in the global tree, then add an + // attribute, specifying that this is a "weak" separator + else if ( tag == tagSeparator ) + { + e.setAttribute( attrWeakSeparator, (uint)1 ); + + // okay, hack time. if the last item was a weak separator OR + // this is the first item in a container, then we nuke the + // current one + TQDomElement prev = e.previousSibling().toElement(); + if ( prev.isNull() || + ( prev.tagName() == tagSeparator && !prev.attribute( attrWeakSeparator ).isNull() ) || + ( prev.tagName() == tagText ) ) + { + // the previous element was a weak separator or didn't exist + base.removeChild( e ); + continue; + } + } + + // the MergeLocal tag lets us specify where non-standard elements + // of the local tree shall be merged in. After inserting the + // elements we delete this element + else if ( tag == tagMergeLocal ) + { + TQDomNode it = additive.firstChild(); + while ( !it.isNull() ) + { + TQDomElement newChild = it.toElement(); + it = it.nextSibling(); + if (newChild.isNull() ) + continue; + + if ( newChild.tagName() == tagText ) + continue; + + if ( newChild.attribute( attrAlreadyVisited ) == attrOne ) + continue; + + TQString itAppend( newChild.attribute( attrAppend ) ); + TQString elemName( e.attribute( attrName ) ); + + if ( ( itAppend.isNull() && elemName.isEmpty() ) || + ( itAppend == elemName ) ) + { + // first, see if this new element matches a standard one in + // the global file. if it does, then we skip it as it will + // be merged in, later + TQDomElement matchingElement = findMatchingElement( newChild, base ); + if ( matchingElement.isNull() || newChild.tagName() == tagSeparator ) + base.insertBefore( newChild, e ); + } + } + + base.removeChild( e ); + continue; + } + + // in this last case we check for a separator tag and, if not, we + // can be sure that its a container --> proceed with child nodes + // recursively and delete the just proceeded container item in + // case its empty (if the recursive call returns true) + else if ( tag != tagMerge ) + { + // handle the text tag + if ( tag == tagText ) + continue; + + TQDomElement matchingElement = findMatchingElement( e, additive ); + + if ( !matchingElement.isNull() ) + { + matchingElement.setAttribute( attrAlreadyVisited, (uint)1 ); + + if ( mergeXML( e, matchingElement, actionCollection ) ) + { + base.removeChild( e ); + continue; + } + + // Merge attributes + const TQDomNamedNodeMap attribs = matchingElement.attributes(); + const uint attribcount = attribs.count(); + + for(uint i = 0; i < attribcount; ++i) + { + const TQDomNode node = attribs.item(i); + e.setAttribute(node.nodeName(), node.nodeValue()); + } + + continue; + } + else + { + // this is an important case here! We reach this point if the + // "local" tree does not contain a container definition for + // this container. However we have to call mergeXML recursively + // and make it check if there are actions implemented for this + // container. *If* none, then we can remove this container now + if ( mergeXML( e, TQDomElement(), actionCollection ) ) + base.removeChild( e ); + continue; + } + } + } + + //here we append all child elements which were not inserted + //previously via the LocalMerge tag + n = additive.firstChild(); + while ( !n.isNull() ) + { + TQDomElement e = n.toElement(); + n = n.nextSibling(); // Advance now so that we can safely delete e + if (e.isNull()) + continue; + + TQDomElement matchingElement = findMatchingElement( e, base ); + + if ( matchingElement.isNull() ) + { + base.appendChild( e ); + } + } + + // do one quick check to make sure that the last element was not + // a weak separator + TQDomElement last = base.lastChild().toElement(); + if ( (last.tagName() == tagSeparator) && (!last.attribute( attrWeakSeparator ).isNull()) ) + { + base.removeChild( last ); + } + + // now we check if we are empty (in which case we return "true", to + // indicate the caller that it can delete "us" (the base element + // argument of "this" call) + bool deleteMe = true; + + n = base.firstChild(); + while ( !n.isNull() ) + { + TQDomElement e = n.toElement(); + n = n.nextSibling(); // Advance now so that we can safely delete e + if (e.isNull()) + continue; + + tag = e.tagName(); + + if ( tag == tagAction ) + { + // if base contains an implemented action, then we must not get + // deleted (note that the actionCollection contains both, + // "global" and "local" actions + if ( actionCollection->action( e.attribute( attrName ).utf8().data() ) ) + { + deleteMe = false; + break; + } + } + else if ( tag == tagSeparator ) + { + // if we have a separator which has *not* the weak attribute + // set, then it must be owned by the "local" tree in which case + // we must not get deleted either + TQString weakAttr = e.attribute( attrWeakSeparator ); + if ( weakAttr.isEmpty() || weakAttr.toInt() != 1 ) + { + deleteMe = false; + break; + } + } + + // in case of a merge tag we have unlimited lives, too ;-) + else if ( tag == tagMerge ) + { +// deleteMe = false; +// break; + continue; + } + + // a text tag is NOT enough to spare this container + else if ( tag == tagText ) + { + continue; + } + + // what's left are non-empty containers! *don't* delete us in this + // case (at this position we can be *sure* that the container is + // *not* empty, as the recursive call for it was in the first loop + // which deleted the element in case the call returned "true" + else + { + deleteMe = false; + break; + } + } + + return deleteMe; +} + +TQDomElement KXMLGUIClient::findMatchingElement( const TQDomElement &base, const TQDomElement &additive ) +{ + static const TQString &tagAction = KGlobal::staticQString( "Action" ); + static const TQString &tagMergeLocal = KGlobal::staticQString( "MergeLocal" ); + static const TQString &attrName = KGlobal::staticQString( "name" ); + + TQDomNode n = additive.firstChild(); + while ( !n.isNull() ) + { + TQDomElement e = n.toElement(); + n = n.nextSibling(); // Advance now so that we can safely delete e + if (e.isNull()) + continue; + + // skip all action and merge tags as we will never use them + if ( ( e.tagName() == tagAction ) || ( e.tagName() == tagMergeLocal ) ) + { + continue; + } + + // now see if our tags are equivalent + if ( ( e.tagName() == base.tagName() ) && + ( e.attribute( attrName ) == base.attribute( attrName ) ) ) + { + return e; + } + } + + // nope, return a (now) null element + return TQDomElement(); +} + +void KXMLGUIClient::conserveMemory() +{ + d->m_doc = TQDomDocument(); + d->m_buildDocument = TQDomDocument(); +} + +void KXMLGUIClient::setXMLGUIBuildDocument( const TQDomDocument &doc ) +{ + d->m_buildDocument = doc; +} + +TQDomDocument KXMLGUIClient::xmlguiBuildDocument() const +{ + return d->m_buildDocument; +} + +void KXMLGUIClient::setFactory( KXMLGUIFactory *factory ) +{ + d->m_factory = factory; +} + +KXMLGUIFactory *KXMLGUIClient::factory() const +{ + return d->m_factory; +} + +KXMLGUIClient *KXMLGUIClient::parentClient() const +{ + return d->m_parent; +} + +void KXMLGUIClient::insertChildClient( KXMLGUIClient *child ) +{ + if ( child->d->m_parent ) + child->d->m_parent->removeChildClient( child ); + d->m_children.append( child ); + child->d->m_parent = this; +} + +void KXMLGUIClient::removeChildClient( KXMLGUIClient *child ) +{ + assert( d->m_children.containsRef( child ) ); + d->m_children.removeRef( child ); + child->d->m_parent = 0; +} + +/*bool KXMLGUIClient::addSuperClient( KXMLGUIClient *super ) +{ + if ( d->m_supers.contains( super ) ) + return false; + d->m_supers.append( super ); + return true; +}*/ + +const TQPtrList<KXMLGUIClient> *KXMLGUIClient::childClients() +{ + return &d->m_children; +} + +void KXMLGUIClient::setClientBuilder( KXMLGUIBuilder *builder ) +{ + d->m_builder = builder; + if ( builder ) + builder->setBuilderInstance( instance() ); +} + +KXMLGUIBuilder *KXMLGUIClient::clientBuilder() const +{ + return d->m_builder; +} + +void KXMLGUIClient::plugActionList( const TQString &name, const TQPtrList<KAction> &actionList ) +{ + if ( !d->m_factory ) + return; + + d->m_factory->plugActionList( this, name, actionList ); +} + +void KXMLGUIClient::unplugActionList( const TQString &name ) +{ + if ( !d->m_factory ) + return; + + d->m_factory->unplugActionList( this, name ); +} + +TQString KXMLGUIClient::findMostRecentXMLFile( const TQStringList &files, TQString &doc ) +{ + + TQValueList<DocStruct> allDocuments; + + TQStringList::ConstIterator it = files.begin(); + TQStringList::ConstIterator end = files.end(); + for (; it != end; ++it ) + { + //kdDebug() << "KXMLGUIClient::findMostRecentXMLFile " << *it << endl; + TQString data = KXMLGUIFactory::readConfigFile( *it ); + DocStruct d; + d.file = *it; + d.data = data; + allDocuments.append( d ); + } + + TQValueList<DocStruct>::Iterator best = allDocuments.end(); + uint bestVersion = 0; + + TQValueList<DocStruct>::Iterator docIt = allDocuments.begin(); + TQValueList<DocStruct>::Iterator docEnd = allDocuments.end(); + for (; docIt != docEnd; ++docIt ) + { + TQString versionStr = findVersionNumber( (*docIt).data ); + if ( versionStr.isEmpty() ) + continue; + + bool ok = false; + uint version = versionStr.toUInt( &ok ); + if ( !ok ) + continue; + //kdDebug() << "FOUND VERSION " << version << endl; + + if ( version > bestVersion ) + { + best = docIt; + //kdDebug() << "best version is now " << version << endl; + bestVersion = version; + } + } + + if ( best != docEnd ) + { + if ( best != allDocuments.begin() ) + { + TQValueList<DocStruct>::Iterator local = allDocuments.begin(); + + // load the local document and extract the action properties + TQDomDocument document; + document.setContent( (*local).data ); + + ActionPropertiesMap properties = extractActionProperties( document ); + + // in case the document has a ActionProperties section + // we must not delete it but copy over the global doc + // to the local and insert the ActionProperties section + if ( !properties.isEmpty() ) + { + // now load the global one with the higher version number + // into memory + document.setContent( (*best).data ); + // and store the properties in there + storeActionProperties( document, properties ); + + (*local).data = document.toString(); + // make sure we pick up the new local doc, when we return later + best = local; + + // write out the new version of the local document + TQFile f( (*local).file ); + if ( f.open( IO_WriteOnly ) ) + { + TQCString utf8data = (*local).data.utf8(); + f.writeBlock( utf8data.data(), utf8data.length() ); + f.close(); + } + } + else + { + TQString f = (*local).file; + TQString backup = f + TQString::tqfromLatin1( ".backup" ); + TQDir dir; + dir.rename( f, backup ); + } + } + doc = (*best).data; + return (*best).file; + } + else if ( files.count() > 0 ) + { + //kdDebug() << "returning first one..." << endl; + doc = (*allDocuments.begin()).data; + return (*allDocuments.begin()).file; + } + + return TQString::null; +} + + + +TQString KXMLGUIClient::findVersionNumber( const TQString &xml ) +{ + enum { ST_START, ST_AFTER_OPEN, ST_AFTER_GUI, + ST_EXPECT_VERSION, ST_VERSION_NUM} state = ST_START; + for (unsigned int pos = 0; pos < xml.length(); pos++) + { + switch (state) + { + case ST_START: + if (xml[pos] == '<') + state = ST_AFTER_OPEN; + break; + case ST_AFTER_OPEN: + { + //Jump to gui.. + int guipos = xml.find("gui", pos, false /*case-insensitive*/); + if (guipos == -1) + return TQString::null; //Reject + + pos = guipos + 2; //Position at i, so we're moved ahead to the next character by the ++; + state = ST_AFTER_GUI; + break; + } + case ST_AFTER_GUI: + state = ST_EXPECT_VERSION; + break; + case ST_EXPECT_VERSION: + { + int verpos = xml.find("version=\"", pos, false /*case-insensitive*/); + if (verpos == -1) + return TQString::null; //Reject + + pos = verpos + 8; //v = 0, e = +1, r = +2, s = +3 , i = +4, o = +5, n = +6, = = +7, " = + 8 + state = ST_VERSION_NUM; + break; + } + case ST_VERSION_NUM: + { + unsigned int endpos; + for (endpos = pos; endpos < xml.length(); endpos++) + { + if (xml[endpos].tqunicode() >= '0' && xml[endpos].tqunicode() <= '9') + continue; //Number.. + if (xml[endpos].tqunicode() == '"') //End of parameter + break; + else //This shouldn't be here.. + { + endpos = xml.length(); + } + } + + if (endpos != pos && endpos < xml.length() ) + { + TQString matchCandidate = xml.mid(pos, endpos - pos); //Don't include " ". + return matchCandidate; + } + + state = ST_EXPECT_VERSION; //Try to match a well-formed version.. + break; + } //case.. + } //switch + } //for + + return TQString::null; +} + +KXMLGUIClient::ActionPropertiesMap KXMLGUIClient::extractActionProperties( const TQDomDocument &doc ) +{ + ActionPropertiesMap properties; + + TQDomElement actionPropElement = doc.documentElement().namedItem( "ActionProperties" ).toElement(); + + if ( actionPropElement.isNull() ) + return properties; + + TQDomNode n = actionPropElement.firstChild(); + while(!n.isNull()) + { + TQDomElement e = n.toElement(); + n = n.nextSibling(); // Advance now so that we can safely delete e + if ( e.isNull() ) + continue; + + if ( e.tagName().lower() != "action" ) + continue; + + TQString actionName = e.attribute( "name" ); + + if ( actionName.isEmpty() ) + continue; + + TQMap<TQString, TQMap<TQString, TQString> >::Iterator propIt = properties.find( actionName ); + if ( propIt == properties.end() ) + propIt = properties.insert( actionName, TQMap<TQString, TQString>() ); + + const TQDomNamedNodeMap attributes = e.attributes(); + const uint attributeslength = attributes.length(); + + for ( uint i = 0; i < attributeslength; ++i ) + { + const TQDomAttr attr = attributes.item( i ).toAttr(); + + if ( attr.isNull() ) + continue; + + const TQString name = attr.name(); + + if ( name == "name" || name.isEmpty() ) + continue; + + (*propIt)[ name ] = attr.value(); + } + + } + + return properties; +} + +void KXMLGUIClient::storeActionProperties( TQDomDocument &doc, const ActionPropertiesMap &properties ) +{ + TQDomElement actionPropElement = doc.documentElement().namedItem( "ActionProperties" ).toElement(); + + if ( actionPropElement.isNull() ) + { + actionPropElement = doc.createElement( "ActionProperties" ); + doc.documentElement().appendChild( actionPropElement ); + } + + while ( !actionPropElement.firstChild().isNull() ) + actionPropElement.removeChild( actionPropElement.firstChild() ); + + ActionPropertiesMap::ConstIterator it = properties.begin(); + ActionPropertiesMap::ConstIterator end = properties.end(); + for (; it != end; ++it ) + { + TQDomElement action = doc.createElement( "Action" ); + action.setAttribute( "name", it.key() ); + actionPropElement.appendChild( action ); + + TQMap<TQString, TQString> attributes = (*it); + TQMap<TQString, TQString>::ConstIterator attrIt = attributes.begin(); + TQMap<TQString, TQString>::ConstIterator attrEnd = attributes.end(); + for (; attrIt != attrEnd; ++attrIt ) + action.setAttribute( attrIt.key(), attrIt.data() ); + } +} + +void KXMLGUIClient::addStateActionEnabled(const TQString& state, + const TQString& action) +{ + StateChange stateChange = getActionsToChangeForState(state); + + stateChange.actionsToEnable.append( action ); + //kdDebug() << "KXMLGUIClient::addStateActionEnabled( " << state << ", " << action << ")" << endl; + + m_actionsStateMap.replace( state, stateChange ); +} + + +void KXMLGUIClient::addStateActionDisabled(const TQString& state, + const TQString& action) +{ + StateChange stateChange = getActionsToChangeForState(state); + + stateChange.actionsToDisable.append( action ); + //kdDebug() << "KXMLGUIClient::addStateActionDisabled( " << state << ", " << action << ")" << endl; + + m_actionsStateMap.replace( state, stateChange ); +} + + +KXMLGUIClient::StateChange KXMLGUIClient::getActionsToChangeForState(const TQString& state) +{ + return m_actionsStateMap[state]; +} + + +void KXMLGUIClient::stateChanged(const TQString &newstate, KXMLGUIClient::ReverseStateChange reverse) +{ + StateChange stateChange = getActionsToChangeForState(newstate); + + bool setTrue = (reverse == StateNoReverse); + bool setFalse = !setTrue; + + // Enable actions which need to be enabled... + // + for ( TQStringList::Iterator it = stateChange.actionsToEnable.begin(); + it != stateChange.actionsToEnable.end(); ++it ) { + + KAction *action = actionCollection()->action((*it).latin1()); + if (action) action->setEnabled(setTrue); + } + + // and disable actions which need to be disabled... + // + for ( TQStringList::Iterator it = stateChange.actionsToDisable.begin(); + it != stateChange.actionsToDisable.end(); ++it ) { + + KAction *action = actionCollection()->action((*it).latin1()); + if (action) action->setEnabled(setFalse); + } + +} + +void KXMLGUIClient::beginXMLPlug( TQWidget *w ) +{ + actionCollection()->beginXMLPlug( w ); + TQPtrListIterator<KXMLGUIClient> childIt( d->m_children ); + for (; childIt.current(); ++childIt ) + childIt.current()->actionCollection()->beginXMLPlug( w ); +} + +void KXMLGUIClient::endXMLPlug() +{ + actionCollection()->endXMLPlug(); + TQPtrListIterator<KXMLGUIClient> childIt( d->m_children ); + for (; childIt.current(); ++childIt ) + childIt.current()->actionCollection()->endXMLPlug(); +} + +void KXMLGUIClient::prepareXMLUnplug( TQWidget * ) +{ + actionCollection()->prepareXMLUnplug(); + TQPtrListIterator<KXMLGUIClient> childIt( d->m_children ); + for (; childIt.current(); ++childIt ) + childIt.current()->actionCollection()->prepareXMLUnplug(); +} + +void KXMLGUIClient::virtual_hook( int, void* ) +{ /*BASE::virtual_hook( id, data );*/ } |