Public Member Functions
void	dump () const

QDomElement	findElementForToolBarItem (const ToolBarItem *item) const

void	initFromFactory (KisKXMLGUIFactory *factory, const QString &defaultToolbar)

void	initOldStyle (const QString &file, bool global, const QString &defaultToolbar)

void	insertActive (ToolBarItem item, ToolBarItem before, bool prepend=false)

	KisKEditToolBarWidgetPrivate (KisKEditToolBarWidget widget, const QString &cName, KisKActionCollection collection)

void	loadActions (const QDomElement &elem)

void	loadToolBarCombo (const QString &defaultToolbar)

QString	loadXMLFile (const QString &_xml_file)

void	moveActive (ToolBarItem item, ToolBarItem before)

void	removeActive (ToolBarItem *item)

void	selectActiveItem (const QString &)

void	setupLayout ()

void	slotActiveSelectionChanged ()

void	slotChangeIconButton ()

void	slotDownButton ()

void	slotDropped (ToolBarListWidget list, int index, ToolBarItem item, bool sourceIsActiveList)

void	slotInactiveSelectionChanged ()

void	slotInsertButton ()

void	slotRemoveButton ()

void	slotToolBarSelected (int index)

void	slotUpButton ()

void	updateLocal (QDomElement &elem)

QString	xmlFile (const QString &xml_file) const

	~KisKEditToolBarWidgetPrivate ()

Public Attributes
ToolBarListWidget *	m_activeList {nullptr}

ToolBarList	m_barList

QToolButton *	m_changeIconAction {nullptr}

KisKActionCollection *	m_collection {nullptr}

QLabel *	m_comboLabel {nullptr}

KSeparator *	m_comboSeparator {nullptr}

QString	m_componentName

QDomElement	m_currentToolBarElem

XmlData *	m_currentXmlData {nullptr}

QToolButton *	m_downAction {nullptr}

QPixmap	m_emptyIcon

KisKXMLGUIFactory *	m_factory {nullptr}

QString	m_globalFile

QLabel *	m_helpArea {nullptr}

ToolBarListWidget *	m_inactiveList {nullptr}

QToolButton *	m_insertAction {nullptr}

bool	m_loadedOnce {false}

QDomDocument	m_localDoc

QString	m_rcFile

QToolButton *	m_removeAction {nullptr}

QComboBox *	m_toolbarCombo {nullptr}

QToolButton *	m_upAction {nullptr}

KisKEditToolBarWidget *	m_widget {nullptr}

QString	m_xmlFile

QList< XmlData >	m_xmlFiles

Detailed Description

Definition at line 417 of file kedittoolbar.cpp.

Constructor & Destructor Documentation

◆ KisKEditToolBarWidgetPrivate()

KDEPrivate::KisKEditToolBarWidgetPrivate::KisKEditToolBarWidgetPrivate	(	KisKEditToolBarWidget *	widget,
		const QString &	cName,
		KisKActionCollection *	collection )

inline

Parameters

collection In the old-style constructor, this is the collection passed to the KisKEditToolBar constructor. In the xmlguifactory-based constructor, we let KisKXMLGUIClient create a dummy one, but it probably isn't used.

Definition at line 427 of file kedittoolbar.cpp.

        : m_collection(collection),
          m_widget(widget),
          m_factory(0),
          m_loadedOnce(false)
    {
        m_componentName = cName;
        m_helpArea = 0L;
        // We want items with an icon to align with items without icon
        // So we use an empty QPixmap for that
        const int iconSize = widget->style()->pixelMetric(QStyle::PM_SmallIconSize);
        m_emptyIcon = QPixmap(iconSize, iconSize);
        m_emptyIcon.fill(Qt::transparent);
    }

References iconSize(), m_componentName, m_emptyIcon, and m_helpArea.

◆ ~KisKEditToolBarWidgetPrivate()

KDEPrivate::KisKEditToolBarWidgetPrivate::~KisKEditToolBarWidgetPrivate ( )

inline

Definition at line 442 of file kedittoolbar.cpp.

443 {

444 }

Member Function Documentation

◆ dump()

void KDEPrivate::KisKEditToolBarWidgetPrivate::dump ( ) const

inline

Definition at line 516 of file kedittoolbar.cpp.

    {
        QList<XmlData>::const_iterator xit = m_xmlFiles.begin();
        for (; xit != m_xmlFiles.end(); ++xit) {
            (*xit).dump();
        }
    }

References m_xmlFiles.

◆ findElementForToolBarItem()

QDomElement KDEPrivate::KisKEditToolBarWidgetPrivate::findElementForToolBarItem ( const ToolBarItem * item ) const

inline

Look for a given item in the current toolbar

Definition at line 496 of file kedittoolbar.cpp.

    {
        //qDebug(240) << "looking for name=" << item->internalName() << "and tag=" << item->internalTag();
        for (QDomNode n = m_currentToolBarElem.firstChild(); !n.isNull(); n = n.nextSibling()) {
            QDomElement elem = n.toElement();
            if ((elem.attribute(QStringLiteral("name")) == item->internalName()) &&
                    (elem.tagName() == item->internalTag())) {
                return elem;
            }
        }
        //qDebug(240) << "no item found in the DOM with name=" << item->internalName() << "and tag=" << item->internalTag();
        return QDomElement();
    }

References KDEPrivate::ToolBarItem::internalName(), KDEPrivate::ToolBarItem::internalTag(), and m_currentToolBarElem.

◆ initFromFactory()

void KisKEditToolBarWidgetPrivate::initFromFactory	(	KisKXMLGUIFactory *	factory,
		const QString &	defaultToolbar )

Definition at line 854 of file kedittoolbar.cpp.

{
    qDebug() << "initFromFactory";
    //TODO: make sure we can call this multiple times?
    if (m_loadedOnce) {
        return;
    }
 
    m_loadedOnce = true;
 
    m_factory = factory;
 
    // add all of the client data
    bool first = true;
    foreach (KisKXMLGUIClient *client, factory->clients()) {
        if (client->xmlFile().isEmpty()) {
            continue;
        }
 
        XmlData::XmlType type = XmlData::Part;
        if (first) {
            type = XmlData::Shell;
            first = false;
            Q_ASSERT(!client->localXMLFile().isEmpty()); // where would we save changes??
        }
 
        XmlData data(type, client->localXMLFile(), client->actionCollection());
        QDomDocument domDoc = client->domDocument();
        data.setDomDocument(domDoc);
        m_xmlFiles.append(data);
 
        //d->m_actionList += client->actionCollection()->actions();
    }
 
#ifndef NDEBUG
    //d->dump();
#endif
 
    // now load in our toolbar combo box
    loadToolBarCombo(defaultToolBar);
    m_widget->adjustSize();
    m_widget->setMinimumSize(m_widget->sizeHint());
 
    m_widget->actionCollection()->addAssociatedWidget(m_widget);
    foreach (QAction *action, m_widget->actionCollection()->actions()) {
        action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
    }
}

References KisKXMLGUIClient::actionCollection(), KDEPrivate::KisKEditToolBarWidget::actionCollection(), KisKActionCollection::actions(), KisKActionCollection::addAssociatedWidget(), KisKXMLGUIFactory::clients(), KisKXMLGUIClient::domDocument(), loadToolBarCombo(), KisKXMLGUIClient::localXMLFile(), m_factory, m_loadedOnce, m_widget, m_xmlFiles, KDEPrivate::XmlData::Part, KDEPrivate::XmlData::setDomDocument(), KDEPrivate::XmlData::Shell, and KisKXMLGUIClient::xmlFile().

◆ initOldStyle()

void KisKEditToolBarWidgetPrivate::initOldStyle	(	const QString &	file,
		bool	global,
		const QString &	defaultToolbar )

Definition at line 812 of file kedittoolbar.cpp.

{
    qDebug() << "initOldStyle";
    //TODO: make sure we can call this multiple times?
    if (m_loadedOnce) {
        return;
    }
 
    m_loadedOnce = true;
    //d->m_actionList = collection->actions();
 
    // handle the merging
    if (global) {
        m_widget->loadStandardsXmlFile();    // ui_standards.xmlgui
    }
    const QString localXML = loadXMLFile(resourceFile);
    m_widget->setXML(localXML, global ? true /*merge*/ : false);
 
    // first, get all of the necessary info for our local xml
    XmlData local(XmlData::Local, xmlFile(resourceFile), m_collection);
    QDomDocument domDoc;
    domDoc.setContent(localXML);
    local.setDomDocument(domDoc);
    m_xmlFiles.append(local);
 
    // then, the merged one (ui_standards + local xml)
    XmlData merge(XmlData::Merged, QString(), m_collection);
    merge.setDomDocument(m_widget->domDocument());
    m_xmlFiles.append(merge);
 
#ifndef NDEBUG
    dump();
#endif
 
    // now load in our toolbar combo box
    loadToolBarCombo(defaultToolBar);
    m_widget->adjustSize();
    m_widget->setMinimumSize(m_widget->sizeHint());
}

References KisKXMLGUIClient::domDocument(), dump(), KisKXMLGUIClient::loadStandardsXmlFile(), loadToolBarCombo(), loadXMLFile(), KDEPrivate::XmlData::Local, m_collection, m_loadedOnce, m_widget, m_xmlFiles, KDEPrivate::XmlData::Merged, KDEPrivate::XmlData::setDomDocument(), KisKXMLGUIClient::setXML(), and xmlFile().

◆ insertActive()

void KisKEditToolBarWidgetPrivate::insertActive	(	ToolBarItem *	item,
		ToolBarItem *	before,
		bool	prepend = false )

Definition at line 1409 of file kedittoolbar.cpp.

{
    if (!item) {
        return;
    }
 
    QDomElement new_item;
    // let's handle the separator specially
    if (item->isSeparator()) {
        new_item = m_widget->domDocument().createElement(QStringLiteral("Separator"));
    } else {
        new_item = m_widget->domDocument().createElement(QStringLiteral("Action"));
    }
 
    new_item.setAttribute(QStringLiteral("name"), item->internalName());
 
    Q_ASSERT(!m_currentToolBarElem.isNull());
 
    if (before) {
        // we have the item in the active list which is before the new
        // item.. so let's try our best to add our new item right after it
        QDomElement elem = findElementForToolBarItem(before);
        Q_ASSERT(!elem.isNull());
        m_currentToolBarElem.insertAfter(new_item, elem);
    } else {
        // simply put it at the beginning or the end of the list.
        if (prepend) {
            m_currentToolBarElem.insertBefore(new_item, m_currentToolBarElem.firstChild());
        } else {
            m_currentToolBarElem.appendChild(new_item);
        }
    }
 
    // and set this container as a noMerge
    m_currentToolBarElem.setAttribute(QStringLiteral("noMerge"), QLatin1String("1"));
 
    // update the local doc
    updateLocal(m_currentToolBarElem);
}

References KisKXMLGUIClient::domDocument(), findElementForToolBarItem(), KDEPrivate::ToolBarItem::internalName(), KDEPrivate::ToolBarItem::isSeparator(), m_currentToolBarElem, m_widget, and updateLocal().

◆ loadActions()

void KisKEditToolBarWidgetPrivate::loadActions ( const QDomElement & elem )

Definition at line 1191 of file kedittoolbar.cpp.

{
    const QLatin1String tagSeparator("Separator");
    const QLatin1String tagMerge("Merge");
    const QLatin1String tagActionList("ActionList");
    const QLatin1String tagAction("Action");
    const QLatin1String attrName("name");
 
    int     sep_num = 0;
    QString sep_name(QStringLiteral("separator_%1"));
 
    // clear our lists
    m_inactiveList->clear();
    m_activeList->clear();
    m_insertAction->setEnabled(false);
    m_removeAction->setEnabled(false);
    m_upAction->setEnabled(false);
    m_downAction->setEnabled(false);
 
    // We'll use this action collection
    KisKActionCollection *actionCollection = m_currentXmlData->actionCollection();
 
    // store the names of our active actions
    QSet<QString> active_list;
 
    // Filtering message requested by translators (scripting).
    KLocalizedString nameFilter = ki18nc("@item:intable Action name in toolbar editor", "%1");
 
    // see if our current action is in this toolbar
    QDomNode n = elem.firstChild();
    for (; !n.isNull(); n = n.nextSibling()) {
        QDomElement it = n.toElement();
        if (it.isNull()) {
            continue;
        }
        if (it.tagName() == tagSeparator) {
            ToolBarItem *act = new ToolBarItem(m_activeList, tagSeparator, sep_name.arg(sep_num++), QString());
            act->setSeparator(true);
            act->setText(SEPARATORSTRING);
            it.setAttribute(attrName, act->internalName());
            continue;
        }
 
        if (it.tagName() == tagMerge) {
            // Merge can be named or not - use the name if there is one
            QString name = it.attribute(attrName);
            ToolBarItem *act = new ToolBarItem(m_activeList, tagMerge, name, i18n("This element will be replaced with all the elements of an embedded component."));
            if (name.isEmpty()) {
                act->setText(i18n("<Merge>"));
            } else {
                act->setText(i18n("<Merge %1>", name));
            }
            continue;
        }
 
        if (it.tagName() == tagActionList) {
            ToolBarItem *act = new ToolBarItem(m_activeList, tagActionList, it.attribute(attrName), i18n("This is a dynamic list of actions. You can move it, but if you remove it you will not be able to re-add it."));
            act->setText(i18n("ActionList: %1", it.attribute(attrName)));
            continue;
        }
 
        // iterate through this client's actions
        // This used to iterate through _all_ actions, but we don't support
        // putting any action into any client...
        foreach (QAction *action, actionCollection->actions()) {
            // do we have a match?
            if (it.attribute(attrName) == action->objectName()) {
                // we have a match!
                ToolBarItem *act = new ToolBarItem(m_activeList, it.tagName(), action->objectName(), action->toolTip());
                act->setText(nameFilter.subs(KLocalizedString::removeAcceleratorMarker(action->iconText())).toString());
                act->setIcon(!action->icon().isNull() ? action->icon() : m_emptyIcon);
                act->setTextAlongsideIconHidden(action->priority() < QAction::NormalPriority);
 
                active_list.insert(action->objectName());
                break;
            }
        }
    }
 
    // go through the rest of the collection
    foreach (QAction *action, actionCollection->actions()) {
        // skip our active ones
        if (active_list.contains(action->objectName())) {
            continue;
        }
 
        ToolBarItem *act = new ToolBarItem(m_inactiveList, tagAction, action->objectName(), action->toolTip());
        act->setText(nameFilter.subs(KLocalizedString::removeAcceleratorMarker(action->text())).toString());
        act->setIcon(!action->icon().isNull() ? action->icon() : m_emptyIcon);
    }
 
    m_inactiveList->sortItems(Qt::AscendingOrder);
 
    // finally, add default separators to the inactive list
    ToolBarItem *act = new ToolBarItem(0L, tagSeparator, sep_name.arg(sep_num++), QString());
    act->setSeparator(true);
    act->setText(SEPARATORSTRING);
    m_inactiveList->insertItem(0, act);
}

References KDEPrivate::XmlData::actionCollection(), KisKActionCollection::actions(), KDEPrivate::ToolBarItem::internalName(), m_activeList, m_currentXmlData, m_downAction, m_emptyIcon, m_inactiveList, m_insertAction, m_removeAction, m_upAction, SEPARATORSTRING, KDEPrivate::ToolBarItem::setSeparator(), and KDEPrivate::ToolBarItem::setTextAlongsideIconHidden().

◆ loadToolBarCombo()

void KisKEditToolBarWidgetPrivate::loadToolBarCombo ( const QString & defaultToolbar )

Definition at line 1149 of file kedittoolbar.cpp.

{
    const QLatin1String attrName("name");
    // just in case, we clear our combo
    m_toolbarCombo->clear();
 
    int defaultToolBarId = -1;
    int count = 0;
    // load in all of the toolbar names into this combo box
    QList<XmlData>::const_iterator xit = m_xmlFiles.constBegin();
    for (; xit != m_xmlFiles.constEnd(); ++xit) {
        // skip the merged one in favor of the local one,
        // so that we can change icons
        // This also makes the app-defined named for "mainToolBar" appear rather than the ui_standards-defined name.
        if ((*xit).type() == XmlData::Merged) {
            continue;
        }
 
        // each xml file may have any number of toolbars
        ToolBarList::const_iterator it = (*xit).barList().begin();
        for (; it != (*xit).barList().constEnd(); ++it) {
            const QString text = (*xit).toolBarText(*it);
            m_toolbarCombo->addItem(text);
            const QString name = (*it).attribute(attrName);
            if (defaultToolBarId == -1 && name == defaultToolBar) {
                defaultToolBarId = count;
            }
            count++;
        }
    }
    const bool showCombo = (count > 1);
    m_comboLabel->setVisible(showCombo);
    m_comboSeparator->setVisible(showCombo);
    m_toolbarCombo->setVisible(showCombo);
    if (defaultToolBarId == -1) {
        defaultToolBarId = 0;
    }
    // we want to the specified item selected and its actions loaded
    m_toolbarCombo->setCurrentIndex(defaultToolBarId);
    slotToolBarSelected(m_toolbarCombo->currentIndex());
}

References m_comboLabel, m_comboSeparator, m_toolbarCombo, m_xmlFiles, KDEPrivate::XmlData::Merged, and slotToolBarSelected().

◆ loadXMLFile()

QString KDEPrivate::KisKEditToolBarWidgetPrivate::loadXMLFile ( const QString & _xml_file )

inline

Load in the specified XML file and dump the raw xml

Definition at line 478 of file kedittoolbar.cpp.

    {
        QString raw_xml;
        QString xml_file = xmlFile(_xml_file);
        //qDebug() << "loadXMLFile xml_file=" << xml_file;
 
        if (!QDir::isRelativePath(xml_file)) {
            raw_xml = KisKXMLGUIFactory::readConfigFile(xml_file);
        } else {
            raw_xml = KisKXMLGUIFactory::readConfigFile(xml_file, m_componentName);
        }
 
        return raw_xml;
    }

References m_componentName, KisKXMLGUIFactory::readConfigFile(), and xmlFile().

◆ moveActive()

void KisKEditToolBarWidgetPrivate::moveActive	(	ToolBarItem *	item,
		ToolBarItem *	before )

Definition at line 1487 of file kedittoolbar.cpp.

{
    QDomElement e = findElementForToolBarItem(item);
 
    if (e.isNull()) {
        return;
    }
 
    // remove item
    m_activeList->takeItem(m_activeList->row(item));
 
    // put it where it's supposed to go
    m_activeList->insertItem(m_activeList->row(before) + 1, item);
 
    // make it selected again
    m_activeList->setCurrentItem(item);
 
    // and do the real move in the DOM
    if (!before) {
        m_currentToolBarElem.insertBefore(e, m_currentToolBarElem.firstChild());
    } else {
        m_currentToolBarElem.insertAfter(e, findElementForToolBarItem((ToolBarItem *)before));
    }
 
    // and set this container as a noMerge
    m_currentToolBarElem.setAttribute(QStringLiteral("noMerge"), QLatin1String("1"));
 
    // update the local doc
    updateLocal(m_currentToolBarElem);
}

References findElementForToolBarItem(), m_activeList, m_currentToolBarElem, and updateLocal().

◆ removeActive()

void KisKEditToolBarWidgetPrivate::removeActive ( ToolBarItem * item )

Definition at line 1449 of file kedittoolbar.cpp.

{
    if (!item) {
        return;
    }
 
    // we're modified, so let this change
    Q_EMIT m_widget->enableOk(true);
 
    // now iterate through to find the child to nuke
    QDomElement elem = findElementForToolBarItem(item);
    if (!elem.isNull()) {
        // nuke myself!
        m_currentToolBarElem.removeChild(elem);
 
        // and set this container as a noMerge
        m_currentToolBarElem.setAttribute(QStringLiteral("noMerge"), QLatin1String("1"));
 
        // update the local doc
        updateLocal(m_currentToolBarElem);
    }
}

References KDEPrivate::KisKEditToolBarWidget::enableOk(), findElementForToolBarItem(), m_currentToolBarElem, m_widget, and updateLocal().

◆ selectActiveItem()

void KisKEditToolBarWidgetPrivate::selectActiveItem ( const QString & internalName )

Definition at line 1390 of file kedittoolbar.cpp.

{
    int activeItemCount = m_activeList->count();
    for (int i = 0; i < activeItemCount; i++) {
        ToolBarItem *item = static_cast<ToolBarItem *>(m_activeList->item(i));
        if (item->internalName() == internalName) {
            m_activeList->setCurrentItem(item);
            break;
        }
    }
}

References KDEPrivate::ToolBarItem::internalName(), and m_activeList.

◆ setupLayout()

void KisKEditToolBarWidgetPrivate::setupLayout ( )

Definition at line 997 of file kedittoolbar.cpp.

{
    // the toolbar name combo
    m_comboLabel = new QLabel(i18n("&Toolbar:"), m_widget);
    m_toolbarCombo = new QComboBox(m_widget);
    m_comboLabel->setBuddy(m_toolbarCombo);
    m_comboSeparator = new KSeparator(m_widget);
    QObject::connect(m_toolbarCombo, SIGNAL(activated(int)),
                     m_widget,       SLOT(slotToolBarSelected(int)));
 
//  QPushButton *new_toolbar = new QPushButton(i18n("&New"), this);
//  new_toolbar->setPixmap(BarIcon("document-new", KisIconUtils::SizeSmall));
//  new_toolbar->setEnabled(false); // disabled until implemented
//  QPushButton *del_toolbar = new QPushButton(i18n("&Delete"), this);
//  del_toolbar->setPixmap(BarIcon("edit-delete", KisIconUtils::SizeSmall));
//  del_toolbar->setEnabled(false); // disabled until implemented
 
    // our list of inactive actions
    QLabel *inactive_label = new QLabel(i18n("A&vailable actions:"), m_widget);
    m_inactiveList = new ToolBarListWidget(m_widget);
    m_inactiveList->setDragEnabled(true);
    m_inactiveList->setActiveList(false);
    m_inactiveList->setMinimumSize(180, 250);
    m_inactiveList->setDropIndicatorShown(false); // #165663
    inactive_label->setBuddy(m_inactiveList);
    QObject::connect(m_inactiveList, SIGNAL(itemSelectionChanged()),
                     m_widget,       SLOT(slotInactiveSelectionChanged()));
    QObject::connect(m_inactiveList, SIGNAL(itemDoubleClicked(QListWidgetItem*)),
                     m_widget,       SLOT(slotInsertButton()));
    QObject::connect(m_inactiveList, SIGNAL(dropped(ToolBarListWidget*,int,ToolBarItem*,bool)),
                     m_widget,       SLOT(slotDropped(ToolBarListWidget*,int,ToolBarItem*,bool)));
 
    {
        QScroller *scroller = KisKineticScroller::createPreconfiguredScroller(m_inactiveList);
        if (scroller) {
            QObject::connect(scroller, &QScroller::stateChanged, m_widget, [&](QScroller::State state) {
                KisKineticScroller::updateCursor(m_widget, state);
            });
        }
    }
 
    KListWidgetSearchLine *inactiveListSearchLine = new KListWidgetSearchLine(m_widget, m_inactiveList);
    inactiveListSearchLine->setPlaceholderText(i18nc("Filter as in showing only matching items", "Filter"));
 
    // our list of active actions
    QLabel *active_label = new QLabel(i18n("Curr&ent actions:"), m_widget);
    m_activeList = new ToolBarListWidget(m_widget);
    m_activeList->setDragEnabled(true);
    m_activeList->setActiveList(true);
    // With Qt-4.1 only setting MiniumWidth results in a 0-width icon column ...
    m_activeList->setMinimumSize(m_inactiveList->minimumWidth(), 100);
    active_label->setBuddy(m_activeList);
 
    QObject::connect(m_activeList, SIGNAL(itemSelectionChanged()),
                     m_widget,     SLOT(slotActiveSelectionChanged()));
    QObject::connect(m_activeList, SIGNAL(itemDoubleClicked(QListWidgetItem*)),
                     m_widget,     SLOT(slotRemoveButton()));
    QObject::connect(m_activeList, SIGNAL(dropped(ToolBarListWidget*,int,ToolBarItem*,bool)),
                     m_widget,     SLOT(slotDropped(ToolBarListWidget*,int,ToolBarItem*,bool)));
    {
        QScroller *scroller = KisKineticScroller::createPreconfiguredScroller(m_activeList);
        if (scroller) {
            QObject::connect(scroller, &QScroller::stateChanged, m_widget, [&](QScroller::State state) {
                KisKineticScroller::updateCursor(m_widget, state);
            });
        }
    }
 
    // Edit Icon Button under active actions
    m_changeIconAction = new QToolButton(m_widget);
    m_changeIconAction->setIcon(KisIconUtils::loadIcon(QStringLiteral("preferences-desktop-icons")));
    m_changeIconAction->setText(i18n("Change Icon..."));
    m_changeIconAction->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
    m_changeIconAction->setEnabled(false);
 
    QObject::connect(m_changeIconAction, SIGNAL(clicked()), m_widget, SLOT(slotChangeIconButton()));
 
    KListWidgetSearchLine *activeListSearchLine = new KListWidgetSearchLine(m_widget, m_activeList);
    activeListSearchLine->setPlaceholderText(i18n("Filter"));
 
    // The buttons in the middle
 
    m_upAction     = new QToolButton(m_widget);
    m_upAction->setIcon(KisIconUtils::loadIcon(QStringLiteral("arrow-up")));
    m_upAction->setEnabled(false);
    m_upAction->setAutoRepeat(true);
    QObject::connect(m_upAction, SIGNAL(clicked()), m_widget, SLOT(slotUpButton()));
 
    m_insertAction = new QToolButton(m_widget);
    m_insertAction->setIcon(KisIconUtils::loadIcon(QApplication::isRightToLeft() ? QStringLiteral("arrow-left") : QLatin1String("arrow-right")));
    m_insertAction->setEnabled(false);
    QObject::connect(m_insertAction, SIGNAL(clicked()), m_widget, SLOT(slotInsertButton()));
 
    m_removeAction = new QToolButton(m_widget);
    m_removeAction->setIcon(KisIconUtils::loadIcon(QApplication::isRightToLeft() ? QStringLiteral("arrow-right") : QLatin1String("arrow-left")));
    m_removeAction->setEnabled(false);
    QObject::connect(m_removeAction, SIGNAL(clicked()), m_widget, SLOT(slotRemoveButton()));
 
    m_downAction   = new QToolButton(m_widget);
    m_downAction->setIcon(KisIconUtils::loadIcon(QStringLiteral("arrow-down")));
    m_downAction->setEnabled(false);
    m_downAction->setAutoRepeat(true);
    QObject::connect(m_downAction, SIGNAL(clicked()), m_widget, SLOT(slotDownButton()));
 
    m_helpArea = new QLabel(m_widget);
    m_helpArea->setWordWrap(true);
 
    // now start with our layouts
    QVBoxLayout *top_layout = new QVBoxLayout(m_widget);
    top_layout->setContentsMargins(0, 0, 0, 0);
 
    QVBoxLayout *name_layout = new QVBoxLayout();
    QHBoxLayout *list_layout = new QHBoxLayout();
 
    QVBoxLayout *inactive_layout = new QVBoxLayout();
    QVBoxLayout *active_layout = new QVBoxLayout();
 
    QGridLayout *button_layout = new QGridLayout();
 
    name_layout->addWidget(m_comboLabel);
    name_layout->addWidget(m_toolbarCombo);
//  name_layout->addWidget(new_toolbar);
//  name_layout->addWidget(del_toolbar);
 
    button_layout->setSpacing(0);
    button_layout->setRowStretch(0, 10);
    button_layout->addWidget(m_upAction, 1, 1);
    button_layout->addWidget(m_removeAction, 2, 0);
    button_layout->addWidget(m_insertAction, 2, 2);
    button_layout->addWidget(m_downAction, 3, 1);
    button_layout->setRowStretch(4, 10);
 
    inactive_layout->addWidget(inactive_label);
    inactive_layout->addWidget(inactiveListSearchLine);
    inactive_layout->addWidget(m_inactiveList, 1);
 
    active_layout->addWidget(active_label);
    active_layout->addWidget(activeListSearchLine);
    active_layout->addWidget(m_activeList, 1);
    active_layout->addWidget(m_changeIconAction);
 
    list_layout->addLayout(inactive_layout);
    list_layout->addLayout(button_layout);
    list_layout->addLayout(active_layout);
 
    top_layout->addLayout(name_layout);
    top_layout->addWidget(m_comboSeparator);
    top_layout->addLayout(list_layout, 10);
    top_layout->addWidget(m_helpArea);
    top_layout->addWidget(new KSeparator(m_widget));
}

References KisKineticScroller::createPreconfiguredScroller(), KisIconUtils::loadIcon(), m_activeList, m_changeIconAction, m_comboLabel, m_comboSeparator, m_downAction, m_helpArea, m_inactiveList, m_insertAction, m_removeAction, m_toolbarCombo, m_upAction, m_widget, KDEPrivate::ToolBarListWidget::setActiveList(), slotActiveSelectionChanged(), slotChangeIconButton(), slotDownButton(), slotDropped(), slotInactiveSelectionChanged(), slotInsertButton(), slotRemoveButton(), slotToolBarSelected(), slotUpButton(), and KisKineticScroller::updateCursor().

◆ slotActiveSelectionChanged()

void KisKEditToolBarWidgetPrivate::slotActiveSelectionChanged ( )

Definition at line 1354 of file kedittoolbar.cpp.

{
    ToolBarItem *toolitem = 0;
    if (!m_activeList->selectedItems().isEmpty()) {
        toolitem = static_cast<ToolBarItem *>(m_activeList->selectedItems().first());
    }
 
    m_removeAction->setEnabled(toolitem);
    m_changeIconAction->setEnabled(toolitem && !toolitem->isSeparator());
 
    if (toolitem) {
        m_upAction->setEnabled(toolitem->index() != 0);
        m_downAction->setEnabled(toolitem->index() != toolitem->listWidget()->count() - 1);
 
        QString statusText = toolitem->statusText();
        m_helpArea->setText(i18nc("@label Action tooltip in toolbar editor, below the action list", "%1", statusText));
    } else {
        m_upAction->setEnabled(false);
        m_downAction->setEnabled(false);
        m_helpArea->setText(QString());
    }
}

References KDEPrivate::ToolBarItem::index(), KDEPrivate::ToolBarItem::isSeparator(), m_activeList, m_changeIconAction, m_downAction, m_helpArea, m_removeAction, m_upAction, and KDEPrivate::ToolBarItem::statusText().

◆ slotChangeIconButton()

void KisKEditToolBarWidgetPrivate::slotChangeIconButton ( )

Definition at line 1533 of file kedittoolbar.cpp.

{
    ToolBarItem *toolitem = m_activeList->currentItem();
    KIS_SAFE_ASSERT_RECOVER_RETURN(toolitem && !toolitem->isSeparator());
 
    QDomElement elem = findElementForToolBarItem(toolitem);
    KIS_SAFE_ASSERT_RECOVER_RETURN(!elem.isNull());
 
    QStringList loadedIcons = KisIconUtils::allUniqueLoadedIconNames();
 
    // Dialog UI
    QDialog dialog(m_widget);
    dialog.setWindowTitle(i18n("Choose Icon"));
    dialog.resize(480, 500);
 
    QVBoxLayout *layout = new QVBoxLayout(&dialog);
 
    // Filter input
    QLineEdit *filterEdit = new QLineEdit(&dialog);
    filterEdit->setPlaceholderText(i18n("Filter icons..."));
    layout->addWidget(filterEdit);
 
    // Icon list
    QListWidget *list = new QListWidget(&dialog);
    list->setViewMode(QListView::ListMode); // icon + text side by side
    list->setIconSize(QSize(22, 22));
    list->setResizeMode(QListWidget::Adjust);
    list->setSelectionMode(QAbstractItemView::SingleSelection);
    QScroller *scroller = KisKineticScroller::createPreconfiguredScroller(list);
    if (scroller) {
        QObject::connect(scroller, &QScroller::stateChanged, m_widget, [&](QScroller::State state) {
            KisKineticScroller::updateCursor(m_widget, state);
        });
    }
 
    // Fill the list
    for (const QString &iconName : loadedIcons) {
        QListWidgetItem *item = new QListWidgetItem(
            KisIconUtils::loadIcon(iconName),
            iconName,
            list
        );
        item->setData(Qt::UserRole, iconName);
    }
    layout->addWidget(list);
 
    // OK/Cancel buttons
    QDialogButtonBox *backButton = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &dialog);
    layout->addWidget(backButton);
 
    QObject::connect(backButton, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
    QObject::connect(backButton, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
 
    // Filter logic
    QObject::connect(filterEdit, &QLineEdit::textChanged, &dialog, [&list](const QString &text) {
        for (int i = 0; i < list->count(); ++i) {
            QListWidgetItem *item = list->item(i);
            bool match = item->text().contains(text, Qt::CaseInsensitive);
            item->setHidden(!match);
        }
    });
 
    // Optional: pre-select current icon
    QString currentIconName = elem.attribute(QStringLiteral("icon"));
    for (int i = 0; i < list->count(); ++i) {
        if (list->item(i)->data(Qt::UserRole).toString() == currentIconName) {
            list->setCurrentItem(list->item(i));
            break;
        }
    }
 
    // Execute
    if (dialog.exec() == QDialog::Accepted && list->currentItem()) {
        QString chosenIconName = list->currentItem()->data(Qt::UserRole).toString();
 
        toolitem->setIcon(KisIconUtils::loadIcon(chosenIconName));
 
        // Update XML in the toolbar DOM
        // Ensure (ActionIconOverrides) exist
        QDomDocument doc = m_widget->domDocument();
        QDomElement root = doc.documentElement();
        QDomElement overridesElem = root.namedItem(QStringLiteral("ActionIconOverrides")).toElement();
        if (overridesElem.isNull()) {
            overridesElem = doc.createElement(QStringLiteral("ActionIconOverrides"));
            root.appendChild(overridesElem);
        }
 
        // Find Action in overrides or create new
        QString actionName = toolitem->internalName();
        QDomElement overrideAction;
        for (QDomNode child = overridesElem.firstChild(); !child.isNull(); child = child.nextSibling()) {
            QDomElement childElement = child.toElement();
            if (childElement.attribute(QStringLiteral("name")) == actionName) {
                overrideAction = childElement;
                break;
            }
        }
        if (overrideAction.isNull()) {
            overrideAction = doc.createElement(QStringLiteral("Action"));
            overrideAction.setAttribute(QStringLiteral("name"), actionName);
            overridesElem.appendChild(overrideAction);
        }
 
        // Set icon override
        overrideAction.setAttribute(QStringLiteral("icon"), chosenIconName);
 
        // Mark document modified
        m_currentToolBarElem.setAttribute(QStringLiteral("noMerge"), QLatin1String("1"));
        updateLocal(m_currentToolBarElem);
        m_currentXmlData->m_isModified = true;
        m_activeList->update();
 
        Q_EMIT m_widget->enableOk(true);
    }
}

References KisIconUtils::allUniqueLoadedIconNames(), KisKineticScroller::createPreconfiguredScroller(), KDEPrivate::ToolBarListWidget::currentItem(), KisKXMLGUIClient::domDocument(), KDEPrivate::KisKEditToolBarWidget::enableOk(), findElementForToolBarItem(), KDEPrivate::ToolBarItem::internalName(), KDEPrivate::ToolBarItem::isSeparator(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisIconUtils::loadIcon(), m_activeList, m_currentToolBarElem, m_currentXmlData, KDEPrivate::XmlData::m_isModified, m_widget, KisKineticScroller::updateCursor(), and updateLocal().

◆ slotDownButton()

void KisKEditToolBarWidgetPrivate::slotDownButton ( )

Definition at line 1518 of file kedittoolbar.cpp.

{
    ToolBarItem *item = m_activeList->currentItem();
    KIS_SAFE_ASSERT_RECOVER_RETURN(item);
 
    // make sure we're not the bottom item already
    int newRow = item->listWidget()->row(item) + 1;
    KIS_SAFE_ASSERT_RECOVER_RETURN(newRow < item->listWidget()->count());
 
    // we're modified, so let this change
    Q_EMIT m_widget->enableOk(true);
 
    moveActive(item, static_cast<ToolBarItem *>(item->listWidget()->item(newRow)));
}

References KDEPrivate::ToolBarListWidget::currentItem(), KDEPrivate::KisKEditToolBarWidget::enableOk(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_activeList, m_widget, and moveActive().

◆ slotDropped()

void KisKEditToolBarWidgetPrivate::slotDropped	(	ToolBarListWidget *	list,
		int	index,
		ToolBarItem *	item,
		bool	sourceIsActiveList )

Definition at line 1690 of file kedittoolbar.cpp.

{
    //qDebug() << "slotDropped list=" << (list==m_activeList?"activeList":"inactiveList")
    //         << "index=" << index << "sourceIsActiveList=" << sourceIsActiveList;
    if (list == m_activeList) {
        ToolBarItem *after = index > 0 ? static_cast<ToolBarItem *>(list->item(index - 1)) : 0;
        //qDebug() << "after" << after->text() << after->internalTag();
        if (sourceIsActiveList) {
            // has been dragged within the active list (moved).
            moveActive(item, after);
        } else {
            // dragged from the inactive list to the active list
            insertActive(item, after, true);
        }
    } else if (list == m_inactiveList) {
        // has been dragged to the inactive list -> remove from the active list.
        removeActive(item);
    }
 
    delete item; // not needed anymore. must be deleted before slotToolBarSelected clears the lists
 
    // we're modified, so let this change
    Q_EMIT m_widget->enableOk(true);
 
    slotToolBarSelected(m_toolbarCombo->currentIndex());
}

References KDEPrivate::KisKEditToolBarWidget::enableOk(), insertActive(), m_activeList, m_inactiveList, m_toolbarCombo, m_widget, moveActive(), removeActive(), and slotToolBarSelected().

◆ slotInactiveSelectionChanged()

void KisKEditToolBarWidgetPrivate::slotInactiveSelectionChanged ( )

Definition at line 1342 of file kedittoolbar.cpp.

{
    if (m_inactiveList->selectedItems().count()) {
        m_insertAction->setEnabled(true);
        QString statusText = static_cast<ToolBarItem *>(m_inactiveList->selectedItems().first())->statusText();
        m_helpArea->setText(i18nc("@label Action tooltip in toolbar editor, below the action list", "%1", statusText));
    } else {
        m_insertAction->setEnabled(false);
        m_helpArea->setText(QString());
    }
}

References m_helpArea, m_inactiveList, and m_insertAction.

◆ slotInsertButton()

void KisKEditToolBarWidgetPrivate::slotInsertButton ( )

Definition at line 1377 of file kedittoolbar.cpp.

{
    QString internalName = static_cast<ToolBarItem *>(m_inactiveList->currentItem())->internalName();
 
    insertActive(m_inactiveList->currentItem(), m_activeList->currentItem(), false);
    // we're modified, so let this change
    Q_EMIT m_widget->enableOk(true);
 
    slotToolBarSelected(m_toolbarCombo->currentIndex());
 
    selectActiveItem(internalName);
}

References KDEPrivate::ToolBarListWidget::currentItem(), KDEPrivate::KisKEditToolBarWidget::enableOk(), insertActive(), m_activeList, m_inactiveList, m_toolbarCombo, m_widget, selectActiveItem(), and slotToolBarSelected().

◆ slotRemoveButton()

void KisKEditToolBarWidgetPrivate::slotRemoveButton ( )

Definition at line 1402 of file kedittoolbar.cpp.

{
    removeActive(m_activeList->currentItem());
 
    slotToolBarSelected(m_toolbarCombo->currentIndex());
}

References KDEPrivate::ToolBarListWidget::currentItem(), m_activeList, m_toolbarCombo, removeActive(), and slotToolBarSelected().

◆ slotToolBarSelected()

void KisKEditToolBarWidgetPrivate::slotToolBarSelected ( int index )

Definition at line 1296 of file kedittoolbar.cpp.

{
    // We need to find the XmlData and toolbar element for this index
    // To do that, we do the same iteration as the one which filled in the combobox.
 
    int toolbarNumber = 0;
    QList<XmlData>::iterator xit = m_xmlFiles.begin();
    for (; xit != m_xmlFiles.end(); ++xit) {
 
        // skip the merged one in favor of the local one,
        // so that we can change icons
        if ((*xit).type() == XmlData::Merged) {
            continue;
        }
 
        // each xml file may have any number of toolbars
        ToolBarList::Iterator it = (*xit).barList().begin();
        for (; it != (*xit).barList().end(); ++it) {
 
            // is this our toolbar?
            if (toolbarNumber == index) {
 
                // save our current settings
                m_currentXmlData = & (*xit);
                m_currentToolBarElem = *it;
 
                //qDebug() << "found toolbar" << m_currentXmlData->toolBarText(*it) << "m_currentXmlData set to";
                m_currentXmlData->dump();
 
                // If this is a Merged xmldata, clicking the "change icon" button would assert...
                Q_ASSERT(m_currentXmlData->type() != XmlData::Merged);
 
                // load in our values
                loadActions(m_currentToolBarElem);
 
                if ((*xit).type() == XmlData::Part || (*xit).type() == XmlData::Shell) {
                    m_widget->setDOMDocument((*xit).domDocument());
                }
                return;
            }
            ++toolbarNumber;
 
        }
    }
}

References KDEPrivate::XmlData::dump(), loadActions(), m_currentToolBarElem, m_currentXmlData, m_widget, m_xmlFiles, KDEPrivate::XmlData::Merged, KDEPrivate::XmlData::Part, KisKXMLGUIClient::setDOMDocument(), KDEPrivate::XmlData::Shell, and KDEPrivate::XmlData::type().

◆ slotUpButton()

void KisKEditToolBarWidgetPrivate::slotUpButton ( )

Definition at line 1472 of file kedittoolbar.cpp.

{
    ToolBarItem *item = m_activeList->currentItem();
    KIS_SAFE_ASSERT_RECOVER_RETURN(item);
 
    int row = item->listWidget()->row(item) - 1;
    // make sure we're not the top item already
    KIS_SAFE_ASSERT_RECOVER_RETURN(row >= 0);
 
    // we're modified, so let this change
    Q_EMIT m_widget->enableOk(true);
 
    moveActive(item, static_cast<ToolBarItem *>(item->listWidget()->item(row - 1)));
}

References KDEPrivate::ToolBarListWidget::currentItem(), KDEPrivate::KisKEditToolBarWidget::enableOk(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_activeList, m_widget, and moveActive().

◆ updateLocal()

void KisKEditToolBarWidgetPrivate::updateLocal ( QDomElement & elem )

Definition at line 1649 of file kedittoolbar.cpp.

{
    QList<XmlData>::Iterator xit = m_xmlFiles.begin();
    for (; xit != m_xmlFiles.end(); ++xit) {
        if ((*xit).type() == XmlData::Merged) {
            continue;
        }
 
        if ((*xit).type() == XmlData::Shell ||
                (*xit).type() == XmlData::Part) {
            if (m_currentXmlData->xmlFile() == (*xit).xmlFile()) {
                (*xit).m_isModified = true;
                return;
            }
 
            continue;
        }
 
        (*xit).m_isModified = true;
        const QLatin1String attrName("name");
        ToolBarList::Iterator it = (*xit).barList().begin();
        for (; it != (*xit).barList().end(); ++it) {
            QString name((*it).attribute(attrName));
            QString tag((*it).tagName());
            if ((tag != elem.tagName()) || (name != elem.attribute(attrName))) {
                continue;
            }
 
            QDomElement toolbar = (*xit).domDocument().documentElement().toElement();
            toolbar.replaceChild(elem, (*it));
            return;
        }
 
        // just append it
        QDomElement toolbar = (*xit).domDocument().documentElement().toElement();
        Q_ASSERT(!toolbar.isNull());
        toolbar.appendChild(elem);
    }
}

References m_currentXmlData, m_xmlFiles, KDEPrivate::XmlData::Merged, KDEPrivate::XmlData::Part, KDEPrivate::XmlData::Shell, and KDEPrivate::XmlData::xmlFile().

◆ xmlFile()

QString KDEPrivate::KisKEditToolBarWidgetPrivate::xmlFile ( const QString & xml_file ) const

inline

Definition at line 470 of file kedittoolbar.cpp.

    {
        return xml_file.isEmpty() ? m_componentName + QStringLiteral("ui.xmlgui") : xml_file;
    }

References m_componentName.

Member Data Documentation

◆ m_activeList

ToolBarListWidget* KDEPrivate::KisKEditToolBarWidgetPrivate::m_activeList {nullptr}

Definition at line 552 of file kedittoolbar.cpp.

552{nullptr};

◆ m_barList

ToolBarList KDEPrivate::KisKEditToolBarWidgetPrivate::m_barList

Definition at line 550 of file kedittoolbar.cpp.

◆ m_changeIconAction

QToolButton* KDEPrivate::KisKEditToolBarWidgetPrivate::m_changeIconAction {nullptr}

Definition at line 532 of file kedittoolbar.cpp.

532{nullptr};

◆ m_collection

KisKActionCollection* KDEPrivate::KisKEditToolBarWidgetPrivate::m_collection {nullptr}

Definition at line 535 of file kedittoolbar.cpp.

535{nullptr};

◆ m_comboLabel

QLabel* KDEPrivate::KisKEditToolBarWidgetPrivate::m_comboLabel {nullptr}

Definition at line 556 of file kedittoolbar.cpp.

556{nullptr};

◆ m_comboSeparator

KSeparator* KDEPrivate::KisKEditToolBarWidgetPrivate::m_comboSeparator {nullptr}

Definition at line 557 of file kedittoolbar.cpp.

557{nullptr};

◆ m_componentName

QString KDEPrivate::KisKEditToolBarWidgetPrivate::m_componentName

Definition at line 538 of file kedittoolbar.cpp.

◆ m_currentToolBarElem

QDomElement KDEPrivate::KisKEditToolBarWidgetPrivate::m_currentToolBarElem

Definition at line 543 of file kedittoolbar.cpp.

◆ m_currentXmlData

XmlData* KDEPrivate::KisKEditToolBarWidgetPrivate::m_currentXmlData {nullptr}

Definition at line 542 of file kedittoolbar.cpp.

542{nullptr};

◆ m_downAction

QToolButton* KDEPrivate::KisKEditToolBarWidgetPrivate::m_downAction {nullptr}

Definition at line 530 of file kedittoolbar.cpp.

530{nullptr};

◆ m_emptyIcon

QPixmap KDEPrivate::KisKEditToolBarWidgetPrivate::m_emptyIcon

Definition at line 540 of file kedittoolbar.cpp.

◆ m_factory

KisKXMLGUIFactory* KDEPrivate::KisKEditToolBarWidgetPrivate::m_factory {nullptr}

Definition at line 537 of file kedittoolbar.cpp.

537{nullptr};

◆ m_globalFile

QString KDEPrivate::KisKEditToolBarWidgetPrivate::m_globalFile

Definition at line 546 of file kedittoolbar.cpp.

◆ m_helpArea

QLabel* KDEPrivate::KisKEditToolBarWidgetPrivate::m_helpArea {nullptr}

Definition at line 558 of file kedittoolbar.cpp.

558{nullptr};

◆ m_inactiveList

ToolBarListWidget* KDEPrivate::KisKEditToolBarWidgetPrivate::m_inactiveList {nullptr}

Definition at line 551 of file kedittoolbar.cpp.

551{nullptr};

◆ m_insertAction

QToolButton* KDEPrivate::KisKEditToolBarWidgetPrivate::m_insertAction {nullptr}

Definition at line 529 of file kedittoolbar.cpp.

529{nullptr};

◆ m_loadedOnce

bool KDEPrivate::KisKEditToolBarWidgetPrivate::m_loadedOnce {false}

Definition at line 559 of file kedittoolbar.cpp.

559{false};

◆ m_localDoc

QDomDocument KDEPrivate::KisKEditToolBarWidgetPrivate::m_localDoc

Definition at line 548 of file kedittoolbar.cpp.

◆ m_rcFile

QString KDEPrivate::KisKEditToolBarWidgetPrivate::m_rcFile

Definition at line 547 of file kedittoolbar.cpp.

◆ m_removeAction

QToolButton* KDEPrivate::KisKEditToolBarWidgetPrivate::m_removeAction {nullptr}

Definition at line 528 of file kedittoolbar.cpp.

528{nullptr};

◆ m_toolbarCombo

QComboBox* KDEPrivate::KisKEditToolBarWidgetPrivate::m_toolbarCombo {nullptr}

Definition at line 525 of file kedittoolbar.cpp.

525{nullptr};

◆ m_upAction

QToolButton* KDEPrivate::KisKEditToolBarWidgetPrivate::m_upAction {nullptr}

Definition at line 527 of file kedittoolbar.cpp.

527{nullptr};

◆ m_widget

KisKEditToolBarWidget* KDEPrivate::KisKEditToolBarWidgetPrivate::m_widget {nullptr}

Definition at line 536 of file kedittoolbar.cpp.

536{nullptr};

◆ m_xmlFile

QString KDEPrivate::KisKEditToolBarWidgetPrivate::m_xmlFile

Definition at line 545 of file kedittoolbar.cpp.

◆ m_xmlFiles

QList<XmlData> KDEPrivate::KisKEditToolBarWidgetPrivate::m_xmlFiles

Definition at line 554 of file kedittoolbar.cpp.

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

libs/widgetutils/xmlgui/kedittoolbar.cpp

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ KisKEditToolBarWidgetPrivate()

◆ ~KisKEditToolBarWidgetPrivate()

Member Function Documentation

◆ dump()

◆ findElementForToolBarItem()

◆ initFromFactory()

◆ initOldStyle()

◆ insertActive()

◆ loadActions()

◆ loadToolBarCombo()

◆ loadXMLFile()

◆ moveActive()

◆ removeActive()

◆ selectActiveItem()

◆ setupLayout()

◆ slotActiveSelectionChanged()

◆ slotChangeIconButton()

◆ slotDownButton()

◆ slotDropped()

◆ slotInactiveSelectionChanged()

◆ slotInsertButton()

◆ slotRemoveButton()

◆ slotToolBarSelected()

◆ slotUpButton()

◆ updateLocal()

◆ xmlFile()

Member Data Documentation

◆ m_activeList

◆ m_barList

◆ m_changeIconAction

◆ m_collection

◆ m_comboLabel

◆ m_comboSeparator

◆ m_componentName

◆ m_currentToolBarElem

◆ m_currentXmlData

◆ m_downAction

◆ m_emptyIcon

◆ m_factory

◆ m_globalFile

◆ m_helpArea

◆ m_inactiveList

◆ m_insertAction

◆ m_loadedOnce

◆ m_localDoc

◆ m_rcFile

◆ m_removeAction

◆ m_toolbarCombo

◆ m_upAction

◆ m_widget

◆ m_xmlFile

◆ m_xmlFiles