#include <kxmlguifactory_p.h>

Public Member Functions
void	adjustMergingIndices (int offset, const MergingIndexList::Iterator &it)

int	calcMergingIndex (const QString &mergingName, MergingIndexList::Iterator &it, BuildState &state, bool ignoreDefaultMergingIndex)

void	clearChildren ()

	ContainerNode (QWidget _container, const QString &_tagName, const QString &_name, ContainerNode _parent=0L, KisKXMLGUIClient _client=0L, KisKXMLGUIBuilder _builder=0L, QAction *containerAction=0, const QString &_mergingName=QString(), const QString &groupName=QString(), const QStringList &customTags=QStringList(), const QStringList &containerTags=QStringList())

bool	destruct (QDomElement element, BuildState &state)

void	destructChildren (const QDomElement &element, BuildState &state)

ContainerClient *	findChildContainerClient (KisKXMLGUIClient *currentGUIClient, const QString &groupName, const MergingIndexList::Iterator &mergingIdx)

ContainerNode *	findContainer (const QString &_name, bool tag)

ContainerNode *	findContainer (const QString &name, const QString &tagName, const QList< QWidget * > excludeList, KisKXMLGUIClient currClient)

ContainerNode *	findContainerNode (QWidget *container)

MergingIndexList::Iterator	findIndex (const QString &name)

void	plugActionList (BuildState &state)

void	plugActionList (BuildState &state, const MergingIndexList::Iterator &mergingIdxIt)

void	removeChild (ContainerNode *child)

void	removeChild (QMutableListIterator< ContainerNode * > &childIterator)

void	reset ()

void	unplugActionList (BuildState &state)

void	unplugActionList (BuildState &state, const MergingIndexList::Iterator &mergingIdxIt)

void	unplugActions (BuildState &state)

void	unplugClient (ContainerClient *client)

	~ContainerNode ()

Static Public Member Functions
static QDomElement	findElementForChild (const QDomElement &baseElement, ContainerNode *childNode)

Public Attributes
KisKXMLGUIBuilder *	builder

QStringList	builderContainerTags

QStringList	builderCustomTags

QList< ContainerNode * >	children

KisKXMLGUIClient *	client

ContainerClientList	clients

QWidget *	container

QAction *	containerAction

QString	groupName

int	index

MergingIndexList	mergingIndices

QString	mergingName

QString	name

ContainerNode *	parent

QString	tagName

Detailed Description

Definition at line 94 of file kxmlguifactory_p.h.

Constructor & Destructor Documentation

◆ ContainerNode()

ContainerNode::ContainerNode	(	QWidget *	_container,
		const QString &	_tagName,
		const QString &	_name,
		ContainerNode *	_parent = 0L,
		KisKXMLGUIClient *	_client = 0L,
		KisKXMLGUIBuilder *	_builder = 0L,
		QAction *	containerAction = 0,
		const QString &	_mergingName = QString(),
		const QString &	groupName = QString(),
		const QStringList &	customTags = QStringList(),
		const QStringList &	containerTags = QStringList() )

Definition at line 45 of file kxmlguifactory_p.cpp.

    : parent(_parent), client(_client), builder(_builder),
      builderCustomTags(customTags), builderContainerTags(containerTags),
      container(_container), containerAction(_containerAction), tagName(_tagName), name(_name),
      groupName(_groupName), index(0), mergingName(_mergingName)
{
    if (parent) {
        parent->children.append(this);
    }
}

References children, and parent.

◆ ~ContainerNode()

ContainerNode::~ContainerNode ( )

Definition at line 61 of file kxmlguifactory_p.cpp.

{
    qDeleteAll(children);
    qDeleteAll(clients);
}

References children, and clients.

Member Function Documentation

◆ adjustMergingIndices()

void ContainerNode::adjustMergingIndices	(	int	offset,
		const MergingIndexList::Iterator &	it )

Definition at line 312 of file kxmlguifactory_p.cpp.

{
    MergingIndexList::Iterator mergingIt = it;
    MergingIndexList::Iterator mergingEnd = mergingIndices.end();
 
    for (; mergingIt != mergingEnd; ++mergingIt) {
        (*mergingIt).value += offset;
    }
 
    index += offset;
}

References index, and mergingIndices.

◆ calcMergingIndex()

int ContainerNode::calcMergingIndex	(	const QString &	mergingName,
		MergingIndexList::Iterator &	it,
		BuildState &	state,
		bool	ignoreDefaultMergingIndex )

Definition at line 491 of file kxmlguifactory_p.cpp.

{
    MergingIndexList::Iterator mergingIt;
 
    if (mergingName.isEmpty()) {
        mergingIt = findIndex(state.clientName);
    } else {
        mergingIt = findIndex(mergingName);
    }
 
    MergingIndexList::Iterator mergingEnd = mergingIndices.end();
    it = mergingEnd;
 
    if ((mergingIt == mergingEnd && state.currentDefaultMergingIt == mergingEnd) ||
            ignoreDefaultMergingIndex) {
        return index;
    }
 
    if (mergingIt != mergingEnd) {
        it = mergingIt;
    } else {
        it = state.currentDefaultMergingIt;
    }
 
    return (*it).value;
}

References KisKXMLGUI::BuildState::clientName, KisKXMLGUI::BuildState::currentDefaultMergingIt, findIndex(), index, mergingIndices, and mergingName.

◆ clearChildren()

void KisKXMLGUI::ContainerNode::clearChildren ( )

inline

Definition at line 125 of file kxmlguifactory_p.h.

    {
        qDeleteAll(children);
        children.clear();
    }

References children.

◆ destruct()

bool ContainerNode::destruct	(	QDomElement	element,
		BuildState &	state )

Definition at line 325 of file kxmlguifactory_p.cpp.

{
    destructChildren(element, state);
 
    unplugActions(state);
 
    // remove all merging indices the client defined
    QMutableListIterator<MergingIndex> cmIt = mergingIndices;
    while (cmIt.hasNext())
        if (cmIt.next().clientName == state.clientName) {
            cmIt.remove();
        }
 
    // ### check for merging index count, too?
    if (clients.count() == 0 && children.count() == 0 && container &&
            client == state.guiClient) {
        QWidget *parentContainer = 0L;
 
        if (parent && parent->container) {
            parentContainer = parent->container;
        }
 
        assert(builder);
 
        builder->removeContainer(container, parentContainer, element, containerAction);
 
        client = 0L;
 
        return true;
    }
 
    if (client == state.guiClient) {
        client = 0L;
    }
 
    return false;
 
}

References builder, children, client, KisKXMLGUI::BuildState::clientName, clients, container, containerAction, destructChildren(), KisKXMLGUI::BuildState::guiClient, mergingIndices, parent, KisKXMLGUIBuilder::removeContainer(), and unplugActions().

◆ destructChildren()

void ContainerNode::destructChildren	(	const QDomElement &	element,
		BuildState &	state )

Definition at line 364 of file kxmlguifactory_p.cpp.

{
    QMutableListIterator<ContainerNode *> childIt = children;
    while (childIt.hasNext()) {
        ContainerNode *childNode = childIt.peekNext();
 
        QDomElement childElement = findElementForChild(element, childNode);
 
        // destruct returns true in case the container really got deleted
        if (childNode->destruct(childElement, state)) {
            removeChild(childIt);
        } else {
            childIt.next();
        }
    }
}

References children, destruct(), findElementForChild(), and removeChild().

◆ findChildContainerClient()

ContainerClient * ContainerNode::findChildContainerClient	(	KisKXMLGUIClient *	currentGUIClient,
		const QString &	groupName,
		const MergingIndexList::Iterator &	mergingIdx )

Definition at line 185 of file kxmlguifactory_p.cpp.

{
    if (!clients.isEmpty()) {
        Q_FOREACH (ContainerClient *client, clients)
            if (client->client == currentGUIClient) {
                if (groupName.isEmpty()) {
                    return client;
                }
 
                if (groupName == client->groupName) {
                    return client;
                }
            }
    }
 
    ContainerClient *client = new ContainerClient;
    client->client = currentGUIClient;
    client->groupName = groupName;
 
    if (mergingIdx != mergingIndices.end()) {
        client->mergingName = (*mergingIdx).mergingName;
    }
 
    clients.append(client);
 
    return client;
}

References client, clients, groupName, and mergingIndices.

◆ findContainer() [1/2]

ContainerNode * ContainerNode::findContainer	(	const QString &	_name,
		bool	tag )

Definition at line 117 of file kxmlguifactory_p.cpp.

{
    if ((tag && tagName == _name) ||
            (!tag && name == _name)) {
        return this;
    }
 
    Q_FOREACH (ContainerNode *child, children) {
        ContainerNode *res = child->findContainer(_name, tag);
        if (res) {
            return res;
        }
    }
 
    return 0;
}

References children, findContainer(), name, and tagName.

◆ findContainer() [2/2]

ContainerNode * ContainerNode::findContainer	(	const QString &	name,
		const QString &	tagName,
		const QList< QWidget * > *	excludeList,
		KisKXMLGUIClient *	currClient )

Definition at line 139 of file kxmlguifactory_p.cpp.

{
    ContainerNode *res = 0L;
    ContainerNodeList::ConstIterator nIt = children.constBegin();
 
    if (!name.isEmpty()) {
        for (; nIt != children.constEnd(); ++nIt)
            if ((*nIt)->name == name &&
                    !excludeList->contains((*nIt)->container)) {
                res = *nIt;
                break;
            }
 
        return res;
    }
 
    if (!tagName.isEmpty())
        for (; nIt != children.constEnd(); ++nIt) {
            if ((*nIt)->tagName == tagName &&
                    !excludeList->contains((*nIt)->container)
                    /*
                     * It is a bad idea to also compare the client, because
                     * we don't want to do so in situations like these:
                     *
                     * <MenuBar>
                     *   <Menu>
                     *     ...
                     *
                     * other client:
                     * <MenuBar>
                     *   <Menu>
                     *    ...
                     *
                    && (*nIt)->client == currClient )
                    */
               ) {
                res = *nIt;
                break;
            }
        }
 
    return res;
}

References children, name, and tagName.

◆ findContainerNode()

ContainerNode * ContainerNode::findContainerNode ( QWidget * container )

Definition at line 102 of file kxmlguifactory_p.cpp.

{
    Q_FOREACH (ContainerNode *child, children)
        if (child->container == container) {
            return child;
        }
 
    return 0L;
}

References children, and container.

◆ findElementForChild()

QDomElement ContainerNode::findElementForChild	(	const QDomElement &	baseElement,
		ContainerNode *	childNode )

static

Definition at line 381 of file kxmlguifactory_p.cpp.

{
    // ### slow
    for (QDomNode n = baseElement.firstChild(); !n.isNull();
            n = n.nextSibling()) {
        QDomElement e = n.toElement();
        if (e.tagName().toLower() == childNode->tagName &&
                e.attribute(QStringLiteral("name")) == childNode->name) {
            return e;
        }
    }
 
    return QDomElement();
}

References name, and tagName.

◆ findIndex()

MergingIndexList::Iterator ContainerNode::findIndex ( const QString & name )

Definition at line 87 of file kxmlguifactory_p.cpp.

{
    MergingIndexList::Iterator it(mergingIndices.begin());
    MergingIndexList::Iterator end(mergingIndices.end());
    for (; it != end; ++it)
        if ((*it).mergingName == name) {
            return it;
        }
    return it;
}

References mergingIndices, and name.

◆ plugActionList() [1/2]

void ContainerNode::plugActionList ( BuildState & state )

Definition at line 215 of file kxmlguifactory_p.cpp.

{
    MergingIndexList::Iterator mIt(mergingIndices.begin());
    MergingIndexList::Iterator mEnd(mergingIndices.end());
    for (; mIt != mEnd; ++mIt) {
        plugActionList(state, mIt);
    }
 
    Q_FOREACH (ContainerNode *child, children) {
        child->plugActionList(state);
    }
}

References children, mergingIndices, and plugActionList().

◆ plugActionList() [2/2]

void ContainerNode::plugActionList	(	BuildState &	state,
		const MergingIndexList::Iterator &	mergingIdxIt )

Definition at line 228 of file kxmlguifactory_p.cpp.

{
    static const QString &tagActionList = QString::fromLatin1("actionlist");
 
    MergingIndex mergingIdx = *mergingIdxIt;
 
    QString k(mergingIdx.mergingName);
 
    if (k.indexOf(tagActionList) == -1) {
        return;
    }
 
    k = k.mid(tagActionList.length());
 
    if (mergingIdx.clientName != state.clientName) {
        return;
    }
 
    if (k != state.actionListName) {
        return;
    }
 
    ContainerClient *client = findChildContainerClient(state.guiClient,
                              QString(),
                              mergingIndices.end());
 
    client->actionLists.insert(k, state.actionList);
 
    state.actionList.plug(container, mergingIdx.value);
 
    adjustMergingIndices(state.actionList.count(), mergingIdxIt);
}

References KisKXMLGUI::BuildState::actionList, KisKXMLGUI::BuildState::actionListName, adjustMergingIndices(), client, KisKXMLGUI::MergingIndex::clientName, KisKXMLGUI::BuildState::clientName, container, findChildContainerClient(), KisKXMLGUI::BuildState::guiClient, mergingIndices, KisKXMLGUI::MergingIndex::mergingName, KisKXMLGUI::ActionList::plug(), and KisKXMLGUI::MergingIndex::value.

◆ removeChild() [1/2]

void ContainerNode::removeChild ( ContainerNode * child )

Definition at line 67 of file kxmlguifactory_p.cpp.

{
    MergingIndexList::Iterator mergingIt = findIndex(child->mergingName);
    adjustMergingIndices(-1, mergingIt);
    children.removeAll(child);
    delete child;
}

References adjustMergingIndices(), children, findIndex(), and mergingName.

◆ removeChild() [2/2]

void ContainerNode::removeChild ( QMutableListIterator< ContainerNode * > & childIterator )

Definition at line 75 of file kxmlguifactory_p.cpp.

{
    MergingIndexList::Iterator mergingIt = findIndex(childIterator.peekNext()->mergingName);
    adjustMergingIndices(-1, mergingIt);
    delete childIterator.next();
    childIterator.remove();
}

References adjustMergingIndices(), and findIndex().

◆ reset()

void ContainerNode::reset ( )

Definition at line 480 of file kxmlguifactory_p.cpp.

{
    Q_FOREACH (ContainerNode *child, children) {
        child->reset();
    }
 
    if (client) {
        client->setFactory(0L);
    }
}

References children, client, reset(), and KisKXMLGUIClient::setFactory().

◆ unplugActionList() [1/2]

void ContainerNode::unplugActionList ( BuildState & state )

Definition at line 261 of file kxmlguifactory_p.cpp.

{
    MergingIndexList::Iterator mIt(mergingIndices.begin());
    MergingIndexList::Iterator mEnd(mergingIndices.end());
    for (; mIt != mEnd; ++mIt) {
        unplugActionList(state, mIt);
    }
 
    Q_FOREACH (ContainerNode *child, children) {
        child->unplugActionList(state);
    }
}

References children, mergingIndices, and unplugActionList().

◆ unplugActionList() [2/2]

void ContainerNode::unplugActionList	(	BuildState &	state,
		const MergingIndexList::Iterator &	mergingIdxIt )

Definition at line 274 of file kxmlguifactory_p.cpp.

{
    static const QString &tagActionList = QString::fromLatin1("actionlist");
 
    MergingIndex mergingIdx = *mergingIdxIt;
 
    QString k = mergingIdx.mergingName;
 
    if (k.indexOf(tagActionList) == -1) {
        return;
    }
 
    k = k.mid(tagActionList.length());
 
    if (mergingIdx.clientName != state.clientName) {
        return;
    }
 
    if (k != state.actionListName) {
        return;
    }
 
    ContainerClient *client = findChildContainerClient(state.guiClient,
                              QString(),
                              mergingIndices.end());
 
    ActionListMap::Iterator lIt(client->actionLists.find(k));
    if (lIt == client->actionLists.end()) {
        return;
    }
 
    lIt.value().unplug(container);
 
    adjustMergingIndices(-int(lIt.value().count()), mergingIdxIt);
 
    client->actionLists.erase(lIt);
}

References KisKXMLGUI::BuildState::actionListName, adjustMergingIndices(), client, KisKXMLGUI::MergingIndex::clientName, KisKXMLGUI::BuildState::clientName, container, findChildContainerClient(), KisKXMLGUI::BuildState::guiClient, mergingIndices, and KisKXMLGUI::MergingIndex::mergingName.

◆ unplugActions()

void ContainerNode::unplugActions ( BuildState & state )

Definition at line 397 of file kxmlguifactory_p.cpp.

{
    if (!container) {
        return;
    }
 
    QMutableListIterator<ContainerClient *> clientIt(clients);
 
    /*
        Disabled because it means in KisToolBar::saveState isHidden is always true then,
        which is clearly wrong.
 
    if ( clients.count() == 1 && clientIt.current()->client == client &&
         client == state.guiClient )
        container->hide(); // this container is going to die, that's for sure.
                           // in this case let's just hide it, which makes the
                           // destruction faster
     */
 
    while (clientIt.hasNext())
        //only unplug the actions of the client we want to remove, as the container might be owned
        //by a different client
        if (clientIt.peekNext()->client == state.guiClient) {
            unplugClient(clientIt.peekNext());
            delete clientIt.next();
            clientIt.remove();
        } else {
            clientIt.next();
        }
}

References clients, container, KisKXMLGUI::BuildState::guiClient, and unplugClient().

◆ unplugClient()

void ContainerNode::unplugClient ( ContainerClient * client )

Definition at line 428 of file kxmlguifactory_p.cpp.

{
    assert(builder);
 
    // now quickly remove all custom elements (i.e. separators) and unplug all actions
 
    QList<QAction *>::ConstIterator custIt = client->customElements.constBegin();
    QList<QAction *>::ConstIterator custEnd = client->customElements.constEnd();
    for (; custIt != custEnd; ++custIt) {
        builder->removeCustomElement(container, *custIt);
    }
 
    KisToolBar *bar = qobject_cast<KisToolBar *>(container);
    if (bar) {
        bar->removeXMLGUIClient(client->client);
    }
 
    client->actions.unplug(container);
 
    // now adjust all merging indices
 
    MergingIndexList::Iterator mergingIt = findIndex(client->mergingName);
 
    adjustMergingIndices(- int(client->actions.count()
                               + client->customElements.count()),
                         mergingIt);
 
    // unplug all actionlists
 
    ActionListMap::ConstIterator alIt = client->actionLists.constBegin();
    ActionListMap::ConstIterator alEnd = client->actionLists.constEnd();
    for (; alIt != alEnd; ++alIt) {
        alIt.value().unplug(container);
 
        // construct the merging index key (i.e. like named merging) , find the
        // corresponding merging index and adjust all indices
        QString mergingKey = alIt.key();
        mergingKey.prepend(QStringLiteral("actionlist"));
 
        MergingIndexList::Iterator mIt = findIndex(mergingKey);
        if (mIt == mergingIndices.end()) {
            continue;
        }
 
        adjustMergingIndices(-int(alIt.value().count()), mIt);
 
        // remove the actionlists' merging index
        // ### still needed? we clean up below anyway?
        mergingIndices.erase(mIt);
    }
}

References adjustMergingIndices(), builder, client, container, findIndex(), mergingIndices, KisKXMLGUIBuilder::removeCustomElement(), and KisToolBar::removeXMLGUIClient().

Member Data Documentation

◆ builder

KisKXMLGUIBuilder* KisKXMLGUI::ContainerNode::builder

Definition at line 106 of file kxmlguifactory_p.h.

◆ builderContainerTags

QStringList KisKXMLGUI::ContainerNode::builderContainerTags

Definition at line 108 of file kxmlguifactory_p.h.

◆ builderCustomTags

QStringList KisKXMLGUI::ContainerNode::builderCustomTags

Definition at line 107 of file kxmlguifactory_p.h.

◆ children

QList<ContainerNode *> KisKXMLGUI::ContainerNode::children

Definition at line 118 of file kxmlguifactory_p.h.

◆ client

KisKXMLGUIClient* KisKXMLGUI::ContainerNode::client

Definition at line 105 of file kxmlguifactory_p.h.

◆ clients

ContainerClientList KisKXMLGUI::ContainerNode::clients

Definition at line 117 of file kxmlguifactory_p.h.

◆ container

QWidget* KisKXMLGUI::ContainerNode::container

Definition at line 109 of file kxmlguifactory_p.h.

◆ containerAction

QAction* KisKXMLGUI::ContainerNode::containerAction

Definition at line 110 of file kxmlguifactory_p.h.

◆ groupName

QString KisKXMLGUI::ContainerNode::groupName

Definition at line 115 of file kxmlguifactory_p.h.

◆ index

int KisKXMLGUI::ContainerNode::index

Definition at line 120 of file kxmlguifactory_p.h.

◆ mergingIndices

MergingIndexList KisKXMLGUI::ContainerNode::mergingIndices

Definition at line 121 of file kxmlguifactory_p.h.

◆ mergingName

QString KisKXMLGUI::ContainerNode::mergingName

Definition at line 123 of file kxmlguifactory_p.h.

◆ name

QString KisKXMLGUI::ContainerNode::name

Definition at line 113 of file kxmlguifactory_p.h.

◆ parent

ContainerNode* KisKXMLGUI::ContainerNode::parent

Definition at line 104 of file kxmlguifactory_p.h.

◆ tagName

QString KisKXMLGUI::ContainerNode::tagName

Definition at line 112 of file kxmlguifactory_p.h.

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

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

Public Member Functions

Static Public Member Functions

Public Attributes