summaryrefslogtreecommitdiffstats
path: root/tdeui/kxmlguifactory.cpp
diff options
context:
space:
mode:
authorTimothy Pearson <kb9vqf@pearsoncomputing.net>2011-11-06 15:56:40 -0600
committerTimothy Pearson <kb9vqf@pearsoncomputing.net>2011-11-06 15:56:40 -0600
commite16866e072f94410321d70daedbcb855ea878cac (patch)
treeee3f52eabde7da1a0e6ca845fb9c2813cf1558cf /tdeui/kxmlguifactory.cpp
parenta58c20c1a7593631a1b50213c805507ebc16adaf (diff)
downloadtdelibs-e16866e072f94410321d70daedbcb855ea878cac.tar.gz
tdelibs-e16866e072f94410321d70daedbcb855ea878cac.zip
Actually move the kde files that were renamed in the last commit
Diffstat (limited to 'tdeui/kxmlguifactory.cpp')
-rw-r--r--tdeui/kxmlguifactory.cpp614
1 files changed, 614 insertions, 0 deletions
diff --git a/tdeui/kxmlguifactory.cpp b/tdeui/kxmlguifactory.cpp
new file mode 100644
index 000000000..2714b1207
--- /dev/null
+++ b/tdeui/kxmlguifactory.cpp
@@ -0,0 +1,614 @@
+/* This file is part of the KDE libraries
+ Copyright (C) 1999,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 as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ 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 "kxmlguifactory.h"
+#include "kxmlguifactory_p.h"
+#include "kxmlguiclient.h"
+#include "kxmlguibuilder.h"
+
+#include <assert.h>
+
+#include <tqdir.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
+#include <tqwidget.h>
+#include <tqdatetime.h>
+#include <tqvariant.h>
+
+#include <kaction.h>
+#include <kdebug.h>
+#include <kinstance.h>
+#include <kglobal.h>
+#include <kshortcut.h>
+#include <kstandarddirs.h>
+#include <kkeydialog.h>
+
+using namespace KXMLGUI;
+
+/*
+ * TODO: - make more use of TQValueList instead of QPtrList
+ */
+
+class KXMLGUIFactoryPrivate : public BuildState
+{
+public:
+ KXMLGUIFactoryPrivate()
+ {
+ static const TQString &defaultMergingName = KGlobal::staticQString( "<default>" );
+ static const TQString &actionList = KGlobal::staticQString( "actionlist" );
+ static const TQString &name = KGlobal::staticQString( "name" );
+
+ m_rootNode = new ContainerNode( 0L, TQString::null, 0L );
+ m_defaultMergingName = defaultMergingName;
+ tagActionList = actionList;
+ attrName = name;
+ }
+ ~KXMLGUIFactoryPrivate()
+ {
+ delete m_rootNode;
+ }
+
+ void pushState()
+ {
+ m_stateStack.push( *this );
+ }
+
+ void popState()
+ {
+ BuildState::operator=( m_stateStack.pop() );
+ }
+
+ ContainerNode *m_rootNode;
+
+ TQString m_defaultMergingName;
+
+ /*
+ * Contains the container which is searched for in ::container .
+ */
+ TQString m_containerName;
+
+ /*
+ * List of all clients
+ */
+ TQPtrList<KXMLGUIClient> m_clients;
+
+ TQString tagActionList;
+
+ TQString attrName;
+
+ BuildStateStack m_stateStack;
+};
+
+TQString KXMLGUIFactory::readConfigFile( const TQString &filename, const KInstance *instance )
+{
+ return readConfigFile( filename, false, instance );
+}
+
+TQString KXMLGUIFactory::readConfigFile( const TQString &filename, bool never_null, const KInstance *_instance )
+{
+ const KInstance *instance = _instance ? _instance : KGlobal::instance();
+ TQString xml_file;
+
+ if (!TQDir::isRelativePath(filename))
+ xml_file = filename;
+ else
+ {
+ xml_file = locate("data", TQString::tqfromLatin1(instance->instanceName() + '/' ) + filename);
+ if ( !TQFile::exists( xml_file ) )
+ xml_file = locate( "data", filename );
+ }
+
+ TQFile file( xml_file );
+ if ( !file.open( IO_ReadOnly ) )
+ {
+ kdError(240) << "No such XML file " << filename << endl;
+ if ( never_null )
+ return TQString::tqfromLatin1( "<!DOCTYPE kpartgui>\n<kpartgui name=\"empty\">\n</kpartgui>" );
+ else
+ return TQString::null;
+ }
+
+#if QT_VERSION <= 0x030302
+ // Work around bug in TQString::fromUtf8 (which calls strlen).
+ TQByteArray buffer(file.size() + 1);
+ buffer = file.readAll();
+ if(!buffer.isEmpty())
+ buffer[ buffer.size() - 1 ] = '\0';
+ else
+ return TQString::null;
+#else
+ TQByteArray buffer(file.readAll());
+#endif
+ return TQString::fromUtf8(buffer.data(), buffer.size());
+}
+
+bool KXMLGUIFactory::saveConfigFile( const TQDomDocument& doc,
+ const TQString& filename, const KInstance *_instance )
+{
+ const KInstance *instance = _instance ? _instance : KGlobal::instance();
+ TQString xml_file(filename);
+
+ if (TQDir::isRelativePath(xml_file))
+ xml_file = locateLocal("data", TQString::tqfromLatin1( instance->instanceName() + '/' )
+ + filename);
+
+ TQFile file( xml_file );
+ if ( !file.open( IO_WriteOnly ) )
+ {
+ kdError(240) << "Could not write to " << filename << endl;
+ return false;
+ }
+
+ // write out our document
+ TQTextStream ts(&file);
+ ts.setEncoding( TQTextStream::UnicodeUTF8 );
+ ts << doc;
+
+ file.close();
+ return true;
+}
+
+TQString KXMLGUIFactory::documentToXML( const TQDomDocument& doc )
+{
+ TQString str;
+ TQTextStream ts(&str, IO_WriteOnly);
+ ts.setEncoding( TQTextStream::UnicodeUTF8 );
+ ts << doc;
+ return str;
+}
+
+TQString KXMLGUIFactory::elementToXML( const TQDomElement& elem )
+{
+ TQString str;
+ TQTextStream ts(&str, IO_WriteOnly);
+ ts.setEncoding( TQTextStream::UnicodeUTF8 );
+ ts << elem;
+ return str;
+}
+
+void KXMLGUIFactory::removeDOMComments( TQDomNode &node )
+{
+ TQDomNode n = node.firstChild();
+ while ( !n.isNull() )
+ {
+ if ( n.nodeType() == TQDomNode::CommentNode )
+ {
+ TQDomNode tmp = n;
+ n = n.nextSibling();
+ node.removeChild( tmp );
+ }
+ else
+ {
+ TQDomNode tmp = n;
+ n = n.nextSibling();
+ removeDOMComments( tmp );
+ }
+ }
+}
+
+KXMLGUIFactory::KXMLGUIFactory( KXMLGUIBuilder *builder, TQObject *parent, const char *name )
+ : TQObject( parent, name )
+{
+ d = new KXMLGUIFactoryPrivate;
+ d->builder = builder;
+ d->guiClient = 0;
+ if ( d->builder )
+ {
+ d->builderContainerTags = d->builder->containerTags();
+ d->builderCustomTags = d->builder->customTags();
+ }
+}
+
+KXMLGUIFactory::~KXMLGUIFactory()
+{
+ delete d;
+}
+
+void KXMLGUIFactory::addClient( KXMLGUIClient *client )
+{
+ kdDebug(1002) << "KXMLGUIFactory::addClient( " << client << " )" << endl; // ellis
+ static const TQString &actionPropElementName = KGlobal::staticQString( "ActionProperties" );
+
+ if ( client->factory() ) {
+ if ( client->factory() == this )
+ return;
+ else
+ client->factory()->removeClient( client ); //just in case someone does stupid things ;-)
+ }
+
+ d->pushState();
+
+// TQTime dt; dt.start();
+
+ d->guiClient = client;
+
+ // add this client to our client list
+ if ( !d->m_clients.containsRef( client ) )
+ d->m_clients.append( client );
+ else
+ kdDebug(1002) << "XMLGUI client already added " << client << endl;
+
+ // Tell the client that plugging in is process and
+ // let it know what builder widget its mainwindow shortcuts
+ // should be attached to.
+ client->beginXMLPlug( d->builder->widget() );
+
+ // try to use the build document for building the client's GUI, as the build document
+ // contains the correct container state information (like toolbar positions, sizes, etc.) .
+ // if there is non available, then use the "real" document.
+ TQDomDocument doc = client->xmlguiBuildDocument();
+ if ( doc.documentElement().isNull() )
+ doc = client->domDocument();
+
+ TQDomElement docElement = doc.documentElement();
+
+ d->m_rootNode->index = -1;
+
+ // cache some variables
+
+ d->clientName = docElement.attribute( d->attrName );
+ d->clientBuilder = client->clientBuilder();
+
+ if ( d->clientBuilder )
+ {
+ d->clientBuilderContainerTags = d->clientBuilder->containerTags();
+ d->clientBuilderCustomTags = d->clientBuilder->customTags();
+ }
+ else
+ {
+ d->clientBuilderContainerTags.clear();
+ d->clientBuilderCustomTags.clear();
+ }
+
+ // process a possibly existing actionproperties section
+
+ TQDomElement actionPropElement = docElement.namedItem( actionPropElementName ).toElement();
+ if ( actionPropElement.isNull() )
+ actionPropElement = docElement.namedItem( actionPropElementName.lower() ).toElement();
+
+ if ( !actionPropElement.isNull() )
+ applyActionProperties( actionPropElement );
+
+ BuildHelper( *d, d->m_rootNode ).build( docElement );
+
+ // let the client know that we built its GUI.
+ client->setFactory( this );
+
+ // call the finalizeGUI method, to fix up the positions of toolbars for example.
+ // ### FIXME : obey client builder
+ // --- Well, toolbars have a bool "positioned", so it doesn't really matter,
+ // if we call positionYourself on all of them each time. (David)
+ d->builder->finalizeGUI( d->guiClient );
+
+ // reset some variables, for safety
+ d->BuildState::reset();
+
+ client->endXMLPlug();
+
+ d->popState();
+
+ emit clientAdded( client );
+
+ // build child clients
+ if ( client->childClients()->count() > 0 )
+ {
+ const TQPtrList<KXMLGUIClient> *children = client->childClients();
+ TQPtrListIterator<KXMLGUIClient> childIt( *children );
+ for (; childIt.current(); ++childIt )
+ addClient( childIt.current() );
+ }
+
+// kdDebug() << "addClient took " << dt.elapsed() << endl;
+}
+
+void KXMLGUIFactory::removeClient( KXMLGUIClient *client )
+{
+ kdDebug(1002) << "KXMLGUIFactory::removeClient( " << client << " )" << endl; // ellis
+
+ // don't try to remove the client's GUI if we didn't build it
+ if ( !client || client->factory() != this )
+ return;
+
+ // remove this client from our client list
+ d->m_clients.removeRef( client );
+
+ // remove child clients first
+ if ( client->childClients()->count() > 0 )
+ {
+ const TQPtrList<KXMLGUIClient> *children = client->childClients();
+ TQPtrListIterator<KXMLGUIClient> childIt( *children );
+ childIt.toLast();
+ for (; childIt.current(); --childIt )
+ removeClient( childIt.current() );
+ }
+
+ kdDebug(1002) << "KXMLGUIFactory::removeServant, calling removeRecursive" << endl;
+
+ d->pushState();
+
+ // cache some variables
+
+ d->guiClient = client;
+ d->clientName = client->domDocument().documentElement().attribute( d->attrName );
+ d->clientBuilder = client->clientBuilder();
+
+ client->setFactory( 0L );
+
+ // if we don't have a build document for that client, yet, then create one by
+ // cloning the original document, so that saving container information in the
+ // DOM tree does not touch the original document.
+ TQDomDocument doc = client->xmlguiBuildDocument();
+ if ( doc.documentElement().isNull() )
+ {
+ doc = client->domDocument().cloneNode( true ).toDocument();
+ client->setXMLGUIBuildDocument( doc );
+ }
+
+ d->m_rootNode->destruct( doc.documentElement(), *d );
+
+ d->builder->finalizeGUI( d->guiClient ); //JoWenn
+
+ // reset some variables
+ d->BuildState::reset();
+
+ // This will destruct the KAccel object built around the given widget.
+ client->prepareXMLUnplug( d->builder->widget() );
+
+ d->popState();
+
+ emit clientRemoved( client );
+}
+
+TQPtrList<KXMLGUIClient> KXMLGUIFactory::clients() const
+{
+ return d->m_clients;
+}
+
+TQWidget *KXMLGUIFactory::container( const TQString &containerName, KXMLGUIClient *client,
+ bool useTagName )
+{
+ d->pushState();
+ d->m_containerName = containerName;
+ d->guiClient = client;
+
+ TQWidget *result = findRecursive( d->m_rootNode, useTagName );
+
+ d->guiClient = 0L;
+ d->m_containerName = TQString::null;
+
+ d->popState();
+
+ return result;
+}
+
+TQPtrList<TQWidget> KXMLGUIFactory::containers( const TQString &tagName )
+{
+ return findRecursive( d->m_rootNode, tagName );
+}
+
+void KXMLGUIFactory::reset()
+{
+ d->m_rootNode->reset();
+
+ d->m_rootNode->clearChildren();
+}
+
+void KXMLGUIFactory::resetContainer( const TQString &containerName, bool useTagName )
+{
+ if ( containerName.isEmpty() )
+ return;
+
+ ContainerNode *container = d->m_rootNode->findContainer( containerName, useTagName );
+
+ if ( !container )
+ return;
+
+ ContainerNode *parent = container->parent;
+ if ( !parent )
+ return;
+
+ // resetInternal( container );
+
+ parent->removeChild( container );
+}
+
+TQWidget *KXMLGUIFactory::findRecursive( KXMLGUI::ContainerNode *node, bool tag )
+{
+ if ( ( ( !tag && node->name == d->m_containerName ) ||
+ ( tag && node->tagName == d->m_containerName ) ) &&
+ ( !d->guiClient || node->client == d->guiClient ) )
+ return node->container;
+
+ TQPtrListIterator<ContainerNode> it( node->children );
+ for (; it.current(); ++it )
+ {
+ TQWidget *cont = findRecursive( it.current(), tag );
+ if ( cont )
+ return cont;
+ }
+
+ return 0L;
+}
+
+TQPtrList<TQWidget> KXMLGUIFactory::findRecursive( KXMLGUI::ContainerNode *node,
+ const TQString &tagName )
+{
+ TQPtrList<TQWidget> res;
+
+ if ( node->tagName == tagName.lower() )
+ res.append( node->container );
+
+ TQPtrListIterator<KXMLGUI::ContainerNode> it( node->children );
+ for (; it.current(); ++it )
+ {
+ TQPtrList<TQWidget> lst = findRecursive( it.current(), tagName );
+ TQPtrListIterator<TQWidget> wit( lst );
+ for (; wit.current(); ++wit )
+ res.append( wit.current() );
+ }
+
+ return res;
+}
+
+void KXMLGUIFactory::plugActionList( KXMLGUIClient *client, const TQString &name,
+ const TQPtrList<KAction> &actionList )
+{
+ d->pushState();
+ d->guiClient = client;
+ d->actionListName = name;
+ d->actionList = actionList;
+ d->clientName = client->domDocument().documentElement().attribute( d->attrName );
+
+ d->m_rootNode->plugActionList( *d );
+
+ d->BuildState::reset();
+ d->popState();
+}
+
+void KXMLGUIFactory::unplugActionList( KXMLGUIClient *client, const TQString &name )
+{
+ d->pushState();
+ d->guiClient = client;
+ d->actionListName = name;
+ d->clientName = client->domDocument().documentElement().attribute( d->attrName );
+
+ d->m_rootNode->unplugActionList( *d );
+
+ d->BuildState::reset();
+ d->popState();
+}
+
+void KXMLGUIFactory::applyActionProperties( const TQDomElement &actionPropElement )
+{
+ static const TQString &tagAction = KGlobal::staticQString( "action" );
+
+ for (TQDomNode n = actionPropElement.firstChild();
+ !n.isNull(); n = n.nextSibling() )
+ {
+ TQDomElement e = n.toElement();
+ if ( e.tagName().lower() != tagAction )
+ continue;
+
+ KAction *action = d->guiClient->action( e );
+ if ( !action )
+ continue;
+
+ configureAction( action, e.attributes() );
+ }
+}
+
+void KXMLGUIFactory::configureAction( KAction *action, const TQDomNamedNodeMap &attributes )
+{
+ for ( uint i = 0; i < attributes.length(); i++ )
+ {
+ TQDomAttr attr = attributes.item( i ).toAttr();
+ if ( attr.isNull() )
+ continue;
+
+ configureAction( action, attr );
+ }
+}
+
+void KXMLGUIFactory::configureAction( KAction *action, const TQDomAttr &attribute )
+{
+ static const TQString &attrShortcut = KGlobal::staticQString( "shortcut" );
+
+ TQString attrName = attribute.name();
+ // If the attribute is a deprecated "accel", change to "shortcut".
+ if ( attrName.lower() == "accel" )
+ attrName = attrShortcut;
+
+ TQVariant propertyValue;
+
+ TQVariant::Type propertyType = action->property( attrName.latin1() ).type();
+
+ if ( propertyType == TQVariant::Int )
+ propertyValue = TQVariant( attribute.value().toInt() );
+ else if ( propertyType == TQVariant::UInt )
+ propertyValue = TQVariant( attribute.value().toUInt() );
+ else
+ propertyValue = TQVariant( attribute.value() );
+
+ action->setProperty( attrName.latin1(), propertyValue );
+}
+
+
+int KXMLGUIFactory::configureShortcuts(bool bAllowLetterShortcuts , bool bSaveSettings )
+{
+ KKeyDialog dlg( bAllowLetterShortcuts, tqt_dynamic_cast<TQWidget*>(parent()) );
+ TQPtrListIterator<KXMLGUIClient> it( d->m_clients );
+ KXMLGUIClient *client;
+ while( (client=it.current()) !=0 )
+ {
+ ++it;
+ if(!client->xmlFile().isEmpty())
+ dlg.insert( client->actionCollection() );
+ }
+ return dlg.configure(bSaveSettings);
+}
+
+TQDomElement KXMLGUIFactory::actionPropertiesElement( TQDomDocument& doc )
+{
+ const TQString tagActionProp = TQString::tqfromLatin1("ActionProperties");
+ // first, lets see if we have existing properties
+ TQDomElement elem;
+ TQDomNode it = doc.documentElement().firstChild();
+ for( ; !it.isNull(); it = it.nextSibling() ) {
+ TQDomElement e = it.toElement();
+ if( e.tagName() == tagActionProp ) {
+ elem = e;
+ break;
+ }
+ }
+
+ // if there was none, create one
+ if( elem.isNull() ) {
+ elem = doc.createElement( tagActionProp );
+ doc.documentElement().appendChild( elem );
+ }
+ return elem;
+}
+
+TQDomElement KXMLGUIFactory::findActionByName( TQDomElement& elem, const TQString& sName, bool create )
+{
+ static const TQString& attrName = KGlobal::staticQString( "name" );
+ static const TQString& tagAction = KGlobal::staticQString( "Action" );
+ for( TQDomNode it = elem.firstChild(); !it.isNull(); it = it.nextSibling() ) {
+ TQDomElement e = it.toElement();
+ if( e.attribute( attrName ) == sName )
+ return e;
+ }
+
+ if( create ) {
+ TQDomElement act_elem = elem.ownerDocument().createElement( tagAction );
+ act_elem.setAttribute( attrName, sName );
+ elem.appendChild( act_elem );
+ return act_elem;
+ }
+ return TQDomElement();
+}
+
+void KXMLGUIFactory::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+#include "kxmlguifactory.moc"
+
+/* vim: et sw=4
+ */