KisKXMLGUIClientPrivate Class Reference

Public Member Functions
QDomElement	findMatchingElement (const QDomElement &base, const QDomElement &additive)
bool	isEmptyContainer (const QDomElement &base, KisKActionCollection *actionCollection) const
	KisKXMLGUIClientPrivate ()
bool	mergeXML (QDomElement &base, QDomElement &additive, KisKActionCollection *actionCollection)
	~KisKXMLGUIClientPrivate ()

Public Attributes
KisKActionCollection *	m_actionCollection
QMap< QString, KisKXMLGUIClient::StateChange >	m_actionsStateMap
QDomDocument	m_buildDocument
KisKXMLGUIBuilder *	m_builder
QList< KisKXMLGUIClient * >	m_children
QString	m_componentName
QDomDocument	m_doc
QPointer< KisKXMLGUIFactory >	m_factory
QString	m_localXMLFile
KisKXMLGUIClient *	m_parent
QStringList	m_textTagNames
QString	m_xmlFile

Detailed Description

Definition at line 33 of file kxmlguiclient.cpp.

Constructor & Destructor Documentation

KisKXMLGUIClientPrivate()

KisKXMLGUIClientPrivate::KisKXMLGUIClientPrivate ( )

inline

Definition at line 36 of file kxmlguiclient.cpp.

        : m_componentName(QCoreApplication::applicationName()),
          m_actionCollection(0),
          m_parent(0L),
          m_builder(0L)
    {
        m_textTagNames.append(QLatin1String("text"));
        m_textTagNames.append(QLatin1String("Text"));
        m_textTagNames.append(QLatin1String("title"));
    }

References m_textTagNames.

~KisKXMLGUIClientPrivate()

KisKXMLGUIClientPrivate::~KisKXMLGUIClientPrivate ( )

inline

Definition at line 46 of file kxmlguiclient.cpp.

    {
    }

Member Function Documentation

findMatchingElement()

QDomElement KisKXMLGUIClientPrivate::findMatchingElement	(	const QDomElement &	base,
		const QDomElement &	additive )

Definition at line 604 of file kxmlguiclient.cpp.

{
    QDomNode n = additive.firstChild();
    while (!n.isNull()) {
        QDomElement e = n.toElement();
        n = n.nextSibling(); // Advance now so that we can safely delete e -- TODO we don't, so simplify this
        if (e.isNull()) {
            continue;
        }
 
        const QString tag = e.tagName();
        // skip all action and merge tags as we will never use them
        if (equalstr(tag, QLatin1String("Action"))
                || equalstr(tag, QLatin1String("MergeLocal"))) {
            continue;
        }
 
        // now see if our tags are equivalent
        if (equalstr(tag, base.tagName()) &&
                e.attribute(QStringLiteral("name")) == base.attribute(QStringLiteral("name"))) {
            return e;
        }
    }
 
    // nope, return a (now) null element
    return QDomElement();
}

References equalstr().

isEmptyContainer()

bool KisKXMLGUIClientPrivate::isEmptyContainer	(	const QDomElement &	base,
		KisKActionCollection *	actionCollection ) const

Definition at line 551 of file kxmlguiclient.cpp.

{
    // 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)
    QDomNode n = base.firstChild();
    while (!n.isNull()) {
        const QDomElement e = n.toElement();
        n = n.nextSibling(); // Advance now so that we can safely delete e
        if (e.isNull()) {
            continue;
        }
 
        const QString tag = e.tagName();
 
        if (equalstr(tag, QLatin1String("Action"))) {
            // 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(QStringLiteral("name")))) {
                return false;
            }
        } else if (equalstr(tag, QLatin1String("Separator"))) {
            // 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
            const QString weakAttr = e.attribute(QStringLiteral("weakSeparator"));
            if (weakAttr.isEmpty() || weakAttr.toInt() != 1) {
                return false;
            }
        }
 
        else if (equalstr(tag, QLatin1String("merge"))) {
            continue;
        }
 
        // a text tag is NOT enough to spare this container
        else if (equalstr(tag, QLatin1String("text"))) {
            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 {
            return false;
        }
    }
 
    return true; // I'm empty, please delete me.
}

References KisKActionCollection::action(), and equalstr().

mergeXML()

bool KisKXMLGUIClientPrivate::mergeXML	(	QDomElement &	base,
		QDomElement &	additive,
		KisKActionCollection *	actionCollection )

Definition at line 372 of file kxmlguiclient.cpp.

{
    const QLatin1String tagAction("Action");
    const QLatin1String tagMerge("Merge");
    const QLatin1String tagSeparator("Separator");
    const QLatin1String tagMergeLocal("MergeLocal");
    const QLatin1String tagText("text");
    const QLatin1String attrAppend("append");
    const QString       attrName(QStringLiteral("name"));
    const QString       attrWeakSeparator(QStringLiteral("weakSeparator"));
    const QString       attrAlreadyVisited(QStringLiteral("alreadyVisited"));
    const QString       attrNoMerge(QStringLiteral("noMerge"));
    const QLatin1String attrOne("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;
    } else {
        // Merge attributes
        {
            const QDomNamedNodeMap attribs = additive.attributes();
            const uint attribcount = attribs.count();
 
            for (uint i = 0; i < attribcount; ++i) {
                const QDomNode node = attribs.item(i);
                base.setAttribute(node.nodeName(), node.nodeValue());
            }
        }
 
        // iterate over all elements in the container (of the global DOM tree)
        QDomNode n = base.firstChild();
        while (!n.isNull()) {
            QDomElement e = n.toElement();
            n = n.nextSibling(); // Advance now so that we can safely delete e
            if (e.isNull()) {
                continue;
            }
 
            const QString 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 (equalstr(tag, tagAction)) {
                const QString name =  e.attribute(attrName);
                if (!actionCollection->action(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 (equalstr(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
                QDomElement prev = e.previousSibling().toElement();
                if (prev.isNull() ||
                        (equalstr(prev.tagName(), tagSeparator) && !prev.attribute(attrWeakSeparator).isNull()) ||
                        (equalstr(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 (equalstr(tag, tagMergeLocal)) {
                QDomNode it = additive.firstChild();
                while (!it.isNull()) {
                    QDomElement newChild = it.toElement();
                    it = it.nextSibling();
                    if (newChild.isNull()) {
                        continue;
                    }
 
                    if (equalstr(newChild.tagName(), tagText)) {
                        continue;
                    }
 
                    if (newChild.attribute(attrAlreadyVisited) == attrOne) {
                        continue;
                    }
 
                    QString itAppend(newChild.attribute(attrAppend));
                    QString 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
                        QDomElement matchingElement = findMatchingElement(newChild, base);
                        if (matchingElement.isNull() || equalstr(newChild.tagName(), tagSeparator)) {
                            base.insertBefore(newChild, e);
                        }
                    }
                }
 
                base.removeChild(e);
                continue;
            }
 
            else if (equalstr(tag, tagText)) {
                continue;
            } else if (equalstr(tag, tagMerge)) {
                continue;
            }
 
            // in this last case we check for a separator tag and, if not, we
            // can be sure that it is a container --> proceed with child nodes
            // recursively and delete the just proceeded container item in
            // case it is empty (if the recursive call returns true)
            else {
                QDomElement matchingElement = findMatchingElement(e, additive);
                if (!matchingElement.isNull()) {
                    matchingElement.setAttribute(attrAlreadyVisited, (uint)1);
 
                    if (mergeXML(e, matchingElement, actionCollection)) {
                        base.removeChild(e);
                        additive.removeChild(matchingElement); // make sure we don't append it below
                        continue;
                    }
 
                    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
                    QDomElement dummy;
                    if (mergeXML(e, dummy, 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()) {
            QDomElement e = n.toElement();
            n = n.nextSibling(); // Advance now so that we can safely delete e
            if (e.isNull()) {
                continue;
            }
 
            QDomElement 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
        QDomElement last = base.lastChild().toElement();
        if (equalstr(last.tagName(), tagSeparator) &&
                (!last.attribute(attrWeakSeparator).isNull())) {
            base.removeChild(last);
        }
    }
 
    return isEmptyContainer(base, actionCollection);
}

References KisKActionCollection::action(), equalstr(), findMatchingElement(), isEmptyContainer(), and mergeXML().

Member Data Documentation

m_actionCollection

KisKActionCollection* KisKXMLGUIClientPrivate::m_actionCollection

Definition at line 61 of file kxmlguiclient.cpp.

m_actionsStateMap

QMap<QString, KisKXMLGUIClient::StateChange> KisKXMLGUIClientPrivate::m_actionsStateMap

Definition at line 73 of file kxmlguiclient.cpp.

m_buildDocument

QDomDocument KisKXMLGUIClientPrivate::m_buildDocument

Definition at line 62 of file kxmlguiclient.cpp.

m_builder

KisKXMLGUIBuilder* KisKXMLGUIClientPrivate::m_builder

Definition at line 67 of file kxmlguiclient.cpp.

m_children

QList<KisKXMLGUIClient *> KisKXMLGUIClientPrivate::m_children

Definition at line 66 of file kxmlguiclient.cpp.

m_componentName

QString KisKXMLGUIClientPrivate::m_componentName

Definition at line 58 of file kxmlguiclient.cpp.

m_doc

QDomDocument KisKXMLGUIClientPrivate::m_doc

Definition at line 60 of file kxmlguiclient.cpp.

m_factory

QPointer<KisKXMLGUIFactory> KisKXMLGUIClientPrivate::m_factory

Definition at line 63 of file kxmlguiclient.cpp.

m_localXMLFile

QString KisKXMLGUIClientPrivate::m_localXMLFile

Definition at line 69 of file kxmlguiclient.cpp.

m_parent

KisKXMLGUIClient* KisKXMLGUIClientPrivate::m_parent

Definition at line 64 of file kxmlguiclient.cpp.

m_textTagNames

QStringList KisKXMLGUIClientPrivate::m_textTagNames

Definition at line 70 of file kxmlguiclient.cpp.

m_xmlFile

QString KisKXMLGUIClientPrivate::m_xmlFile

Definition at line 68 of file kxmlguiclient.cpp.

---

The documentation for this class was generated from the following file:

• libs/widgetutils/xmlgui/kxmlguiclient.cpp