KisKXMLGUI::BuildHelper Class Reference

#include <kxmlguifactory_p.h>

Public Member Functions
void	build (const QDomElement &element)
	BuildHelper (BuildState &state, ContainerNode *node)

Private Member Functions
int	calcMergingIndex (const QDomElement &element, MergingIndexList::Iterator &it, QString &group)
QWidget *	createContainer (QWidget *parent, int index, const QDomElement &element, QAction *&containerAction, KisKXMLGUIBuilder **builder)
bool	processActionElement (const QDomElement &e, int idx)
void	processActionOrCustomElement (const QDomElement &e, bool isActionTag)
void	processContainerElement (const QDomElement &e, const QString &tag, const QString &name)
bool	processCustomElement (const QDomElement &e, int idx)
void	processElement (const QDomElement &element)
void	processMergeElement (const QString &tag, const QString &name, const QDomElement &e)
void	processStateElement (const QDomElement &element)

Private Attributes
ContainerClient *	containerClient
QList< QWidget * >	containerList
QStringList	containerTags
QStringList	customTags
bool	ignoreDefaultMergingIndex
BuildState &	m_state
ContainerNode *	parentNode

Detailed Description

Definition at line 170 of file kxmlguifactory_p.h.

Constructor & Destructor Documentation

BuildHelper()

BuildHelper::BuildHelper	(	BuildState &	state,
		ContainerNode *	node )

Definition at line 544 of file kxmlguifactory_p.cpp.

    : containerClient(0), ignoreDefaultMergingIndex(false), m_state(state),
      parentNode(node)
{
    // create a list of supported container and custom tags
    customTags = m_state.builderCustomTags;
    containerTags = m_state.builderContainerTags;
 
    if (parentNode->builder != m_state.builder) {
        customTags += parentNode->builderCustomTags;
        containerTags += parentNode->builderContainerTags;
    }
 
    if (m_state.clientBuilder) {
        customTags = m_state.clientBuilderCustomTags + customTags;
        containerTags = m_state.clientBuilderContainerTags + containerTags;
    }
 
    m_state.currentDefaultMergingIt = parentNode->findIndex(QStringLiteral("<default>"));
    parentNode->calcMergingIndex(QString(), m_state.currentClientMergingIt,
                                 m_state, /*ignoreDefaultMergingIndex*/ false);
}

References KisKXMLGUI::ContainerNode::builder, KisKXMLGUI::BuildState::builder, KisKXMLGUI::ContainerNode::builderContainerTags, KisKXMLGUI::BuildState::builderContainerTags, KisKXMLGUI::ContainerNode::builderCustomTags, KisKXMLGUI::BuildState::builderCustomTags, KisKXMLGUI::ContainerNode::calcMergingIndex(), KisKXMLGUI::BuildState::clientBuilder, KisKXMLGUI::BuildState::clientBuilderContainerTags, KisKXMLGUI::BuildState::clientBuilderCustomTags, containerTags, KisKXMLGUI::BuildState::currentClientMergingIt, KisKXMLGUI::BuildState::currentDefaultMergingIt, customTags, KisKXMLGUI::ContainerNode::findIndex(), m_state, and parentNode.

Member Function Documentation

build()

void BuildHelper::build

(

const QDomElement &

element

)

Definition at line 567 of file kxmlguifactory_p.cpp.

{
    for (QDomNode n = element.firstChild(); !n.isNull(); n = n.nextSibling()) {
        QDomElement e = n.toElement();
        if (e.isNull()) {
            continue;
        }
        processElement(e);
    }
}

References processElement().

calcMergingIndex()

int BuildHelper::calcMergingIndex ( const QDomElement & element, MergingIndexList::Iterator & it, QString & group )

private

Definition at line 521 of file kxmlguifactory_p.cpp.

{
    const QLatin1String attrGroup("group");
 
    bool haveGroup = false;
    group = element.attribute(attrGroup);
    if (!group.isEmpty()) {
        group.prepend(attrGroup);
        haveGroup = true;
    }
 
    int idx;
    if (haveGroup) {
        idx = parentNode->calcMergingIndex(group, it, m_state, ignoreDefaultMergingIndex);
    } else if (m_state.currentClientMergingIt == parentNode->mergingIndices.end()) {
        idx = parentNode->index;
    } else {
        idx = (*m_state.currentClientMergingIt).value;
    }
 
    return idx;
}

References KisKXMLGUI::ContainerNode::calcMergingIndex(), KisKXMLGUI::BuildState::currentClientMergingIt, ignoreDefaultMergingIndex, KisKXMLGUI::ContainerNode::index, m_state, KisKXMLGUI::ContainerNode::mergingIndices, parentNode, and value().

createContainer()

QWidget * BuildHelper::createContainer ( QWidget * parent, int index, const QDomElement & element, QAction *& containerAction, KisKXMLGUIBuilder ** builder )

private

Definition at line 839 of file kxmlguifactory_p.cpp.

{
    QWidget *res = 0L;
 
    if (m_state.clientBuilder) {
        res = m_state.clientBuilder->createContainer(parent, index, element, containerAction);
 
        if (res) {
            *builder = m_state.clientBuilder;
            return res;
        }
    }
 
    KisKXMLGUIClient *oldClient = m_state.builder->builderClient();
 
    m_state.builder->setBuilderClient(m_state.guiClient);
 
    res = m_state.builder->createContainer(parent, index, element, containerAction);
 
    m_state.builder->setBuilderClient(oldClient);
 
    if (res) {
        *builder = m_state.builder;
    }
 
    return res;
}

References KisKXMLGUI::BuildState::builder, KisKXMLGUIBuilder::builderClient(), KisKXMLGUI::BuildState::clientBuilder, KisKXMLGUIBuilder::createContainer(), KisKXMLGUI::BuildState::guiClient, m_state, and KisKXMLGUIBuilder::setBuilderClient().

processActionElement()

bool BuildHelper::processActionElement ( const QDomElement & e, int idx )

private

Definition at line 624 of file kxmlguifactory_p.cpp.

{
    assert(m_state.guiClient);
 
    // look up the action and plug it in
    QAction *action = m_state.guiClient->action(e);
 
    //qDebug(260) << "BuildHelper::processActionElement " << e.attribute( "name" ) << " -> " << action << " (in " << m_state.guiClient->actionCollection() << ")";
    if (!action) {
        return false;
    }
 
    QAction *before = 0L;
    if (idx >= 0 && idx < parentNode->container->actions().count()) {
        before = parentNode->container->actions()[idx];
    }
 
    parentNode->container->insertAction(before, action);
 
    // save a reference to the plugged action, in order to properly unplug it afterwards.
    containerClient->actions.append(action);
 
    return true;
}

References KisKXMLGUIClient::action(), KisKXMLGUI::ContainerClient::actions, KisKXMLGUI::ContainerNode::container, containerClient, KisKXMLGUI::BuildState::guiClient, m_state, and parentNode.

processActionOrCustomElement()

void BuildHelper::processActionOrCustomElement ( const QDomElement & e, bool isActionTag )

private

Definition at line 597 of file kxmlguifactory_p.cpp.

{
    if (!parentNode->container) {
        return;
    }
 
    MergingIndexList::Iterator it(m_state.currentClientMergingIt);
 
    QString group;
    int idx = calcMergingIndex(e, it, group);
 
    containerClient = parentNode->findChildContainerClient(m_state.guiClient, group, it);
 
    bool guiElementCreated = false;
    if (isActionTag) {
        guiElementCreated = processActionElement(e, idx);
    } else {
        guiElementCreated = processCustomElement(e, idx);
    }
 
    if (guiElementCreated)
        // adjust any following merging indices and the current running index for the container
    {
        parentNode->adjustMergingIndices(1, it);
    }
}

References KisKXMLGUI::ContainerNode::adjustMergingIndices(), calcMergingIndex(), KisKXMLGUI::ContainerNode::container, containerClient, KisKXMLGUI::BuildState::currentClientMergingIt, KisKXMLGUI::ContainerNode::findChildContainerClient(), KisKXMLGUI::BuildState::guiClient, m_state, parentNode, processActionElement(), and processCustomElement().

processContainerElement()

void BuildHelper::processContainerElement ( const QDomElement & e, const QString & tag, const QString & name )

private

Definition at line 773 of file kxmlguifactory_p.cpp.

{
    ContainerNode *containerNode = parentNode->findContainer(name, tag,
                                   &containerList,
                                   m_state.guiClient);
 
    if (!containerNode) {
        MergingIndexList::Iterator it(m_state.currentClientMergingIt);
        QString group;
 
        int idx = calcMergingIndex(e, it, group);
 
        QAction *containerAction;
 
        KisKXMLGUIBuilder *builder;
 
        QWidget *container = createContainer(parentNode->container, idx, e, containerAction, &builder);
 
        // no container? (probably some <text> tag or so ;-)
        if (!container) {
            return;
        }
 
        parentNode->adjustMergingIndices(1, it);
 
        assert(!parentNode->findContainerNode(container));
 
        containerList.append(container);
 
        QString mergingName;
        if (it != parentNode->mergingIndices.end()) {
            mergingName = (*it).mergingName;
        }
 
        QStringList cusTags = m_state.builderCustomTags;
        QStringList conTags = m_state.builderContainerTags;
        if (builder != m_state.builder) {
            cusTags = m_state.clientBuilderCustomTags;
            conTags = m_state.clientBuilderContainerTags;
        }
 
        containerNode = new ContainerNode(container, tag, name, parentNode,
                                          m_state.guiClient, builder, containerAction,
                                          mergingName, group, cusTags, conTags);
    } else {
        if (tag == QStringLiteral("toolbar")) {
            KisToolBar *bar = qobject_cast<KisToolBar *>(containerNode->container);
            if (bar) {
                if (m_state.guiClient && !m_state.guiClient->xmlFile().isEmpty()) {
                    bar->addXMLGUIClient(m_state.guiClient);
                }
            } else {
                qWarning() << "toolbar container is not a KisToolBar";
            }
        }
    }
 
    BuildHelper(m_state, containerNode).build(e);
 
    // and re-calculate running values, for better performance
    m_state.currentDefaultMergingIt = parentNode->findIndex(QStringLiteral("<default>"));
    parentNode->calcMergingIndex(QString(), m_state.currentClientMergingIt,
                                 m_state, ignoreDefaultMergingIndex);
}

References KisToolBar::addXMLGUIClient(), KisKXMLGUI::ContainerNode::adjustMergingIndices(), KisKXMLGUI::BuildState::builder, KisKXMLGUI::BuildState::builderContainerTags, KisKXMLGUI::BuildState::builderCustomTags, BuildHelper(), calcMergingIndex(), KisKXMLGUI::ContainerNode::calcMergingIndex(), KisKXMLGUI::BuildState::clientBuilderContainerTags, KisKXMLGUI::BuildState::clientBuilderCustomTags, KisKXMLGUI::ContainerNode::container, containerList, createContainer(), KisKXMLGUI::BuildState::currentClientMergingIt, KisKXMLGUI::BuildState::currentDefaultMergingIt, KisKXMLGUI::ContainerNode::findContainer(), KisKXMLGUI::ContainerNode::findContainerNode(), KisKXMLGUI::ContainerNode::findIndex(), KisKXMLGUI::BuildState::guiClient, ignoreDefaultMergingIndex, m_state, KisKXMLGUI::ContainerNode::mergingIndices, parentNode, and KisKXMLGUIClient::xmlFile().

processCustomElement()

bool BuildHelper::processCustomElement ( const QDomElement & e, int idx )

private

Definition at line 649 of file kxmlguifactory_p.cpp.

{
    assert(parentNode->builder);
 
    QAction *action = parentNode->builder->createCustomElement(parentNode->container, idx, e);
    if (!action) {
        return false;
    }
 
    containerClient->customElements.append(action);
    return true;
}

References KisKXMLGUI::ContainerNode::builder, KisKXMLGUI::ContainerNode::container, containerClient, KisKXMLGUIBuilder::createCustomElement(), KisKXMLGUI::ContainerClient::customElements, and parentNode.

processElement()

void BuildHelper::processElement ( const QDomElement & element )

private

Definition at line 578 of file kxmlguifactory_p.cpp.

{
    QString tag(e.tagName().toLower());
    QString currName(e.attribute(QStringLiteral("name")));
 
    bool isActionTag = (tag == QStringLiteral("action"));
 
    if (isActionTag || customTags.indexOf(tag) != -1) {
        processActionOrCustomElement(e, isActionTag);
    } else if (containerTags.indexOf(tag) != -1) {
        processContainerElement(e, tag, currName);
    } else if (tag == QStringLiteral("merge") || tag == QLatin1String("definegroup")
               || tag == QStringLiteral("actionlist")) {
        processMergeElement(tag, currName, e);
    } else if (tag == QStringLiteral("state")) {
        processStateElement(e);
    }
}

References containerTags, customTags, processActionOrCustomElement(), processContainerElement(), processMergeElement(), and processStateElement().

processMergeElement()

void BuildHelper::processMergeElement ( const QString & tag, const QString & name, const QDomElement & e )

private

Definition at line 706 of file kxmlguifactory_p.cpp.

{
    const QLatin1String tagDefineGroup("definegroup");
    const QLatin1String tagActionList("actionlist");
    const QLatin1String defaultMergingName("<default>");
    const QLatin1String attrGroup("group");
 
    QString mergingName(name);
    if (mergingName.isEmpty()) {
        if (tag == tagDefineGroup) {
            qCritical() << "cannot define group without name!" << Qt::endl;
            return;
        }
        if (tag == tagActionList) {
            qCritical() << "cannot define actionlist without name!" << Qt::endl;
            return;
        }
        mergingName = defaultMergingName;
    }
 
    if (tag == tagDefineGroup) {
        mergingName.prepend(attrGroup);    //avoid possible name clashes by prepending
    }
    // "group" to group definitions
    else if (tag == tagActionList) {
        mergingName.prepend(tagActionList);
    }
 
    if (parentNode->findIndex(mergingName) != parentNode->mergingIndices.end()) {
        return;    //do not allow the redefinition of merging indices!
    }
 
    MergingIndexList::Iterator mIt(parentNode->mergingIndices.end());
 
    QString group(e.attribute(attrGroup));
    if (!group.isEmpty()) {
        group.prepend(attrGroup);
    }
 
    // calculate the index of the new merging index. Usually this does not need any calculation,
    // we just want the last available index (i.e. append) . But in case the <Merge> tag appears
    // "inside" another <Merge> tag from a previously build client, then we have to use the
    // "parent's" index. That's why we call calcMergingIndex here.
    MergingIndex newIdx;
    newIdx.value = parentNode->calcMergingIndex(group, mIt, m_state, ignoreDefaultMergingIndex);
    newIdx.mergingName = mergingName;
    newIdx.clientName = m_state.clientName;
 
    // if that merging index is "inside" another one, then append it right after the "parent" .
    if (mIt != parentNode->mergingIndices.end()) {
        parentNode->mergingIndices.insert(++mIt, newIdx);
    } else {
        parentNode->mergingIndices.append(newIdx);
    }
 
    if (mergingName == defaultMergingName)
 
    {
        ignoreDefaultMergingIndex = true;
    }
 
    // re-calculate the running default and client merging indices.
    m_state.currentDefaultMergingIt = parentNode->findIndex(defaultMergingName);
    parentNode->calcMergingIndex(QString(), m_state.currentClientMergingIt,
                                 m_state, ignoreDefaultMergingIndex);
}

References KisKXMLGUI::ContainerNode::calcMergingIndex(), KisKXMLGUI::MergingIndex::clientName, KisKXMLGUI::BuildState::clientName, KisKXMLGUI::BuildState::currentClientMergingIt, KisKXMLGUI::BuildState::currentDefaultMergingIt, KisKXMLGUI::ContainerNode::findIndex(), ignoreDefaultMergingIndex, m_state, KisKXMLGUI::ContainerNode::mergingIndices, KisKXMLGUI::MergingIndex::mergingName, parentNode, and KisKXMLGUI::MergingIndex::value.

processStateElement()

void BuildHelper::processStateElement ( const QDomElement & element )

private

Definition at line 662 of file kxmlguifactory_p.cpp.

{
    QString stateName = element.attribute(QStringLiteral("name"));
 
    if (stateName.isNull() || !stateName.length()) {
        return;
    }
 
    for (QDomNode n = element.firstChild(); !n.isNull(); n = n.nextSibling()) {
        QDomElement e = n.toElement();
        if (e.isNull()) {
            continue;
        }
 
        QString tagName = e.tagName().toLower();
 
        if (tagName != QStringLiteral("enable") && tagName != QLatin1String("disable")) {
            continue;
        }
 
        bool processingActionsToEnable = (tagName == QStringLiteral("enable"));
 
        // process action names
        for (QDomNode n2 = n.firstChild(); !n2.isNull(); n2 = n2.nextSibling()) {
            QDomElement actionEl = n2.toElement();
            if (actionEl.tagName().toLower() != QStringLiteral("action")) {
                continue;
            }
 
            QString actionName = actionEl.attribute(QStringLiteral("name"));
            if (actionName.isEmpty()) {
                return;
            }
 
            if (processingActionsToEnable) {
                m_state.guiClient->addStateActionEnabled(stateName, actionName);
            } else {
                m_state.guiClient->addStateActionDisabled(stateName, actionName);
            }
 
        }
    }
}

References KisKXMLGUIClient::addStateActionDisabled(), KisKXMLGUIClient::addStateActionEnabled(), KisKXMLGUI::BuildState::guiClient, and m_state.

Member Data Documentation

containerClient

ContainerClient* KisKXMLGUI::BuildHelper::containerClient

private

Definition at line 202 of file kxmlguifactory_p.h.

containerList

QList<QWidget *> KisKXMLGUI::BuildHelper::containerList

private

Definition at line 200 of file kxmlguifactory_p.h.

containerTags

QStringList KisKXMLGUI::BuildHelper::containerTags

private

Definition at line 198 of file kxmlguifactory_p.h.

customTags

QStringList KisKXMLGUI::BuildHelper::customTags

private

Definition at line 197 of file kxmlguifactory_p.h.

ignoreDefaultMergingIndex

bool KisKXMLGUI::BuildHelper::ignoreDefaultMergingIndex

private

Definition at line 204 of file kxmlguifactory_p.h.

m_state

BuildState& KisKXMLGUI::BuildHelper::m_state

private

Definition at line 206 of file kxmlguifactory_p.h.

parentNode

ContainerNode* KisKXMLGUI::BuildHelper::parentNode

private

Definition at line 208 of file kxmlguifactory_p.h.

---

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

• libs/widgetutils/xmlgui/kxmlguifactory_p.h
• libs/widgetutils/xmlgui/kxmlguifactory_p.cpp