KisToolBar Class Reference

Floatable toolbar with auto resize. More...

#include <ktoolbar.h>

Inheritance diagram for KisToolBar:

Classes
class	Private

Public Member Functions
void	addXMLGUIClient (KisKXMLGUIClient *client)
void	applySettings (const KConfigGroup &cg)
bool	eventFilter (QObject *watched, QEvent *event) override
int	iconSizeDefault () const
	KisToolBar (const QString &objectName, QWidget *parent, bool readConfig=true)
void	loadState (const QDomElement &element)
KisKMainWindow *	mainWindow () const
void	removeXMLGUIClient (KisKXMLGUIClient *client)
void	saveSettings (KConfigGroup &cg)
void	saveState (QDomElement &element) const
void	setIconDimensions (int size)
	~KisToolBar () override

Static Public Member Functions
static void	emitToolbarStyleChanged ()
static void	setToolBarsEditable (bool editable)
static void	setToolBarsLocked (bool locked)
static bool	toolBarsEditable ()
static bool	toolBarsLocked ()
static KisToolBarStateModel *	toolBarStateModel ()

Protected Slots
virtual void	slotMovableChanged (bool movable)

Protected Member Functions
void	actionEvent (QActionEvent *) override
void	contextMenuEvent (QContextMenuEvent *) override
void	dragEnterEvent (QDragEnterEvent *) override
void	dragLeaveEvent (QDragLeaveEvent *) override
void	dragMoveEvent (QDragMoveEvent *) override
void	dropEvent (QDropEvent *) override
void	mouseMoveEvent (QMouseEvent *) override
void	mousePressEvent (QMouseEvent *) override
void	mouseReleaseEvent (QMouseEvent *) override

Private Attributes
Private *const	d

Detailed Description

Floatable toolbar with auto resize.

A KDE-style toolbar.

KisToolBar can be used as a standalone widget, but KisKMainWindow provides easy factories and management of one or more toolbars.

KisToolBar uses a global config group to load toolbar settings on construction. It will reread this config group on a KApplication::appearanceChanged() signal.

Note

If you can't depend on KXmlGui but you want to integrate with KDE, you can use QToolBar with: Set ToolButtonStyle to Qt::ToolButtonFollowStyle, this will make QToolBar use the settings for "Main Toolbar" Additionally set QToolBar::setProperty("otherToolbar", true) to use settings for "Other toolbars" Settings from "Other toolbars" will only work on widget styles derived from KStyle

Author

Reginald Stadlbauer reggi.nosp@m.e@kd.nosp@m.e.org, Stephan Kulow coolo.nosp@m.@kde.nosp@m..org, Sven Radej radej.nosp@m.@kde.nosp@m..org, Hamish Rodda rodda.nosp@m.@kde.nosp@m..org.

Definition at line 46 of file ktoolbar.h.

Constructor & Destructor Documentation

KisToolBar()

KisToolBar::KisToolBar ( const QString & objectName, QWidget * parent, bool readConfig = true )

explicit

Constructor.

This constructor takes care of adding the toolbar to the mainwindow, if parent is a QMainWindow.

Normally KDE applications do not call this directly, they either call KisKMainWindow::toolBar(name), or they use XML-GUI and specify toolbars using XML.

Parameters

objectName	The QObject name of this toolbar, required so that QMainWindow can save and load the toolbar position, and so that KisToolBar can find out if it's the main toolbar.
parent	The standard toolbar parent (usually a KisKMainWindow)
readConfig	whether to apply the configuration (global and application-specific)

Definition at line 799 of file ktoolbar.cpp.

    : QToolBar(parent),
      d(new Private(this))
{
    setObjectName(objectName);
    // mainToolBar -> isMainToolBar = true  -> buttonStyle is configurable
    // others      -> isMainToolBar = false -> ### hardcoded default for buttonStyle !!! should be configurable? -> hidden key added
    d->init(readConfig, objectName == QStringLiteral("mainToolBar"));
 
    // KisToolBar is auto-added to the top area of the main window if parent is a QMainWindow
    if (QMainWindow *mw = qobject_cast<QMainWindow *>(parent)) {
        mw->addToolBar(this);
    }
}

References d, and KisToolBar::Private::init().

~KisToolBar()

KisToolBar::~KisToolBar ( )

override

Destroys the toolbar.

Definition at line 814 of file ktoolbar.cpp.

{
    delete d->contextLockAction;
    delete d;
}

References KisToolBar::Private::contextLockAction, and d.

Member Function Documentation

actionEvent()

void KisToolBar::actionEvent ( QActionEvent * event )

overrideprotected

Definition at line 1341 of file ktoolbar.cpp.

{
    if (event->type() == QEvent::ActionRemoved) {
        QWidget *widget = widgetForAction(event->action());
        if (widget) {
            widget->removeEventFilter(this);
 
            Q_FOREACH (QWidget *child, widget->findChildren<QWidget *>()) {
                child->removeEventFilter(this);
            }
            // Remove Krita's palette manipulation
            QToolButton *tb = qobject_cast<QToolButton *>(widget);
            if (tb) {
                tb->disconnect(this, SLOT(slotToolButtonToggled(bool)));
            }
        }
    }
 
    QToolBar::actionEvent(event);
 
    if (event->type() == QEvent::ActionAdded) {
        QWidget *widget = widgetForAction(event->action());
        if (widget) {
            widget->installEventFilter(this);
 
            Q_FOREACH (QWidget *child, widget->findChildren<QWidget *>()) {
                child->installEventFilter(this);
            }
            // Center widgets that do not have any use for more space. See bug 165274
            if (!(widget->sizePolicy().horizontalPolicy() & QSizePolicy::GrowFlag)
                    // ... but do not center when using text besides icon in vertical toolbar. See bug 243196
                    && !(orientation() == Qt::Vertical && toolButtonStyle() == Qt::ToolButtonTextBesideIcon)) {
                const int index = layout()->indexOf(widget);
                if (index != -1) {
                    layout()->itemAt(index)->setAlignment(Qt::AlignJustify);
                }
            }
            // NOTE: set a fixed button size, same size as the buttonsize used in kis_paintop_box
            // and toggle highlight color on checked buttons, same as in KisHighlightedButton
            QToolButton *tb = qobject_cast<QToolButton *>(widget);
            if (tb && event->action()->icon().isNull() == false) {
                d->customizeButtonPalette(tb, tb->isChecked());
                connect(tb, SIGNAL(toggled(bool)), this, SLOT(slotToolButtonToggled(bool)));
                widget->setFixedSize(32, 32);
            }
        }
    }
 
    d->adjustSeparatorVisibility();
}

References KisToolBar::Private::adjustSeparatorVisibility(), connect(), KisToolBar::Private::customizeButtonPalette(), and d.

addXMLGUIClient()

void KisToolBar::addXMLGUIClient

(

KisKXMLGUIClient *

client

)

Adds an XML gui client that uses this toolbar

Since

4.8.1

Definition at line 845 of file ktoolbar.cpp.

{
    d->xmlguiClients << client;
}

References d, and KisToolBar::Private::xmlguiClients.

applySettings()

void KisToolBar::applySettings

(

const KConfigGroup &

cg

)

Read the toolbar settings from group configGroup in config and apply them.

Definition at line 1020 of file ktoolbar.cpp.

{
    Q_ASSERT(!cg.name().isEmpty());
 
    if (cg.hasKey("IconSize")) {
        d->iconSizeSettings[Level_UserSettings] = cg.readEntry("IconSize", 0);
    }
    if (cg.hasKey("ToolButtonStyle")) {
        d->toolButtonStyleSettings[Level_UserSettings] = d->toolButtonStyleFromString(cg.readEntry("ToolButtonStyle", QString()));
    }
 
    d->applyCurrentSettings();
}

References KisToolBar::Private::applyCurrentSettings(), d, KisToolBar::Private::iconSizeSettings, Level_UserSettings, KisToolBar::Private::toolButtonStyleFromString(), and KisToolBar::Private::toolButtonStyleSettings.

contextMenuEvent()

void KisToolBar::contextMenuEvent ( QContextMenuEvent * event )

overrideprotected

Definition at line 855 of file ktoolbar.cpp.

{
    QToolBar::contextMenuEvent(event);
}

dragEnterEvent()

void KisToolBar::dragEnterEvent ( QDragEnterEvent * event )

overrideprotected

Definition at line 1055 of file ktoolbar.cpp.

{
    if (toolBarsEditable() && event->proposedAction() & (Qt::CopyAction | Qt::MoveAction) &&
            event->mimeData()->hasFormat(QStringLiteral("application/x-kde-action-list"))) {
        QByteArray data = event->mimeData()->data(QStringLiteral("application/x-kde-action-list"));
 
        QDataStream stream(data);
 
        QStringList actionNames;
 
        stream >> actionNames;
 
        Q_FOREACH (const QString &actionName, actionNames) {
            Q_FOREACH (KisKActionCollection *ac, KisKActionCollection::allCollections()) {
                QAction *newAction = ac->action(actionName);
                if (newAction) {
                    d->actionsBeingDragged.append(newAction);
                    break;
                }
            }
        }
 
        if (d->actionsBeingDragged.count()) {
            QAction *overAction = actionAt(event->pos());
 
            QFrame *dropIndicatorWidget = new QFrame(this);
            dropIndicatorWidget->resize(8, height() - 4);
            dropIndicatorWidget->setFrameShape(QFrame::VLine);
            dropIndicatorWidget->setLineWidth(3);
 
            d->dropIndicatorAction = insertWidget(overAction, dropIndicatorWidget);
 
            insertAction(overAction, d->dropIndicatorAction);
 
            event->acceptProposedAction();
            return;
        }
    }
 
    QToolBar::dragEnterEvent(event);
}

References KisKActionCollection::action(), KisToolBar::Private::actionsBeingDragged, KisKActionCollection::allCollections(), d, KisToolBar::Private::dropIndicatorAction, and toolBarsEditable().

dragLeaveEvent()

void KisToolBar::dragLeaveEvent ( QDragLeaveEvent * event )

overrideprotected

Definition at line 1136 of file ktoolbar.cpp.

{
    // Want to clear this even if toolBarsEditable was changed mid-drag (unlikely)
    delete d->dropIndicatorAction;
    d->dropIndicatorAction = 0L;
    d->actionsBeingDragged.clear();
 
    if (toolBarsEditable()) {
        event->accept();
        return;
    }
 
    QToolBar::dragLeaveEvent(event);
}

References KisToolBar::Private::actionsBeingDragged, d, KisToolBar::Private::dropIndicatorAction, and toolBarsEditable().

dragMoveEvent()

void KisToolBar::dragMoveEvent ( QDragMoveEvent * event )

overrideprotected

Definition at line 1097 of file ktoolbar.cpp.

{
    if (toolBarsEditable())
        Q_FOREVER {
        if (d->dropIndicatorAction)
            {
                QAction *overAction = 0L;
                Q_FOREACH (QAction *action, actions()) {
                    // want to make it feel that half way across an action you're dropping on the other side of it
                    QWidget *widget = widgetForAction(action);
                    if (event->pos().x() < widget->pos().x() + (widget->width() / 2)) {
                        overAction = action;
                        break;
                    }
                }
 
                if (overAction != d->dropIndicatorAction) {
                    // Check to see if the indicator is already in the right spot
                    int dropIndicatorIndex = actions().indexOf(d->dropIndicatorAction);
                    if (dropIndicatorIndex + 1 < actions().count()) {
                        if (actions()[ dropIndicatorIndex + 1 ] == overAction) {
                            break;
                        }
                    } else if (!overAction) {
                        break;
                    }
 
                    insertAction(overAction, d->dropIndicatorAction);
                }
 
                event->accept();
                return;
            }
            break;
        }
 
    QToolBar::dragMoveEvent(event);
}

References d, KisToolBar::Private::dropIndicatorAction, and toolBarsEditable().

dropEvent()

void KisToolBar::dropEvent ( QDropEvent * event )

overrideprotected

Definition at line 1151 of file ktoolbar.cpp.

{
    if (toolBarsEditable()) {
        Q_FOREACH (QAction *action, d->actionsBeingDragged) {
            if (actions().contains(action)) {
                removeAction(action);
            }
            insertAction(d->dropIndicatorAction, action);
        }
    }
 
    // Want to clear this even if toolBarsEditable was changed mid-drag (unlikely)
    delete d->dropIndicatorAction;
    d->dropIndicatorAction = 0L;
    d->actionsBeingDragged.clear();
 
    if (toolBarsEditable()) {
        event->accept();
        return;
    }
 
    QToolBar::dropEvent(event);
}

References KisToolBar::Private::actionsBeingDragged, d, KisToolBar::Private::dropIndicatorAction, and toolBarsEditable().

emitToolbarStyleChanged()

void KisToolBar::emitToolbarStyleChanged ( )

static

Emits a dbus signal to tell all toolbars in all applications, that the user settings have changed.

Since

5.0

Definition at line 1414 of file ktoolbar.cpp.

{
#ifdef HAVE_DBUS
    QDBusMessage message = QDBusMessage::createSignal(QStringLiteral("/KisToolBar"), QStringLiteral("org.kde.KisToolBar"), QStringLiteral("styleChanged"));
    QDBusConnection::sessionBus().send(message);
#endif
}

eventFilter()

bool KisToolBar::eventFilter ( QObject * watched, QEvent * event )

override

Reimplemented to support context menu activation on disabled tool buttons.

Definition at line 1242 of file ktoolbar.cpp.

{
    // Generate context menu events for disabled buttons too...
    if (event->type() == QEvent::MouseButtonPress) {
        QMouseEvent *me = static_cast<QMouseEvent *>(event);
        if (me->buttons() & Qt::RightButton)
            if (QWidget *ww = qobject_cast<QWidget *>(watched))
                if (ww->parent() == this && !ww->isEnabled()) {
                    QCoreApplication::postEvent(this, new QContextMenuEvent(QContextMenuEvent::Mouse, me->pos(), me->globalPos()));
                }
 
    } else if (event->type() == QEvent::ParentChange) {
        // Make sure we're not leaving stale event filters around,
        // when a child is reparented somewhere else
        if (QWidget *ww = qobject_cast<QWidget *>(watched)) {
            if (!this->isAncestorOf(ww)) {
                // New parent is not a subwidget - remove event filter
                ww->removeEventFilter(this);
                Q_FOREACH (QWidget *child, ww->findChildren<QWidget *>()) {
                    child->removeEventFilter(this);
                }
            }
        }
    }
 
    QToolButton *tb;
    if ((tb = qobject_cast<QToolButton *>(watched))) {
        const QList<QAction *> tbActions = tb->actions();
        if (!tbActions.isEmpty()) {
            // Handle MMB on toolbar buttons
            if (event->type() == QEvent::MouseButtonPress || event->type() == QEvent::MouseButtonRelease) {
                QMouseEvent *me = static_cast<QMouseEvent *>(event);
                if (me->button() == Qt::MiddleButton /*&&
                                                 act->receivers(SIGNAL(triggered(Qt::MouseButtons,Qt::KeyboardModifiers)))*/) {
                    QAction *act = tbActions.first();
                    if (me->type() == QEvent::MouseButtonPress) {
                        tb->setDown(act->isEnabled());
                    } else {
                        tb->setDown(false);
                        if (act->isEnabled()) {
                            QMetaObject::invokeMethod(act, "triggered", Qt::DirectConnection,
                                                      Q_ARG(Qt::MouseButtons, me->button()),
                                                      Q_ARG(Qt::KeyboardModifiers, QApplication::keyboardModifiers()));
                        }
                    }
                }
            }
 
            // CJK languages use more verbose accelerator marker: they add a Latin
            // letter in parenthesis, and put accelerator on that. Hence, the default
            // removal of ampersand only may not be enough there, instead the whole
            // parenthesis construct should be removed. Use KLocalizedString's method to do this.
            if (event->type() == QEvent::Show || event->type() == QEvent::Paint || event->type() == QEvent::EnabledChange) {
                QAction *act = tb->defaultAction();
                if (act) {
                    const QString text = KLocalizedString::removeAcceleratorMarker(act->iconText().isEmpty() ? act->text() : act->iconText());
                    const QString toolTip = KLocalizedString::removeAcceleratorMarker(act->toolTip());
                    // Filtering messages requested by translators (scripting).
                    tb->setText(i18nc("@action:intoolbar Text label of toolbar button", "%1", text));
                    tb->setToolTip(i18nc("@info:tooltip Tooltip of toolbar button", "%1", toolTip));
                }
            }
        }
    }
 
    // Redirect mouse events to the toolbar when drag + drop editing is enabled
    if (toolBarsEditable()) {
        if (QWidget *ww = qobject_cast<QWidget *>(watched)) {
            switch (event->type()) {
            case QEvent::MouseButtonPress: {
                QMouseEvent *me = static_cast<QMouseEvent *>(event);
                QMouseEvent newEvent(me->type(), mapFromGlobal(ww->mapToGlobal(me->pos())), me->globalPos(),
                                     me->button(), me->buttons(), me->modifiers());
                mousePressEvent(&newEvent);
                return true;
            }
            case QEvent::MouseMove: {
                QMouseEvent *me = static_cast<QMouseEvent *>(event);
                QMouseEvent newEvent(me->type(), mapFromGlobal(ww->mapToGlobal(me->pos())), me->globalPos(),
                                     me->button(), me->buttons(), me->modifiers());
                mouseMoveEvent(&newEvent);
                return true;
            }
            case QEvent::MouseButtonRelease: {
                QMouseEvent *me = static_cast<QMouseEvent *>(event);
                QMouseEvent newEvent(me->type(), mapFromGlobal(ww->mapToGlobal(me->pos())), me->globalPos(),
                                     me->button(), me->buttons(), me->modifiers());
                mouseReleaseEvent(&newEvent);
                return true;
            }
            default:
                break;
            }
        }
    }
 
    return QToolBar::eventFilter(watched, event);
}

References mouseMoveEvent(), mousePressEvent(), mouseReleaseEvent(), and toolBarsEditable().

iconSizeDefault()

int KisToolBar::iconSizeDefault

(

)

const

Returns the default size for this type of toolbar.

Returns

the default size for this type of toolbar.

Definition at line 1045 of file ktoolbar.cpp.

{
    return 22;
}

loadState()

void KisToolBar::loadState

(

const QDomElement &

element

)

Load state from an XML element, called by KisKXMLGUIBuilder.

Definition at line 860 of file ktoolbar.cpp.

{
    QMainWindow *mw = mainWindow();
    if (!mw) {
        return;
    }
 
    {
        QDomNode textNode = element.namedItem(QStringLiteral("text"));
        QByteArray domain;
        QByteArray text;
        QByteArray context;
        if (textNode.isElement()) {
            QDomElement textElement = textNode.toElement();
            domain = textElement.attribute(QStringLiteral("translationDomain")).toUtf8();
            text = textElement.text().toUtf8();
            context = textElement.attribute(QStringLiteral("context")).toUtf8();
        } else {
            textNode = element.namedItem(QStringLiteral("Text"));
            if (textNode.isElement()) {
                QDomElement textElement = textNode.toElement();
                domain = textElement.attribute(QStringLiteral("translationDomain")).toUtf8();
                text = textElement.text().toUtf8();
                context = textElement.attribute(QStringLiteral("context")).toUtf8();
            }
        }
 
        if (domain.isEmpty()) {
            domain = element.ownerDocument().documentElement().attribute(QStringLiteral("translationDomain")).toUtf8();
            if (domain.isEmpty()) {
                domain = KLocalizedString::applicationDomain();
            }
        }
        QString i18nText;
        if (!text.isEmpty() && !context.isEmpty()) {
            i18nText = i18ndc(domain.constData(), context.constData(), text.constData());
        } else if (!text.isEmpty()) {
            i18nText = i18nd(domain.constData(), text.constData());
        }
 
        if (!i18nText.isEmpty()) {
            setWindowTitle(i18nText);
        }
    }
 
    /*
      This method is called in order to load toolbar settings from XML.
      However this can be used in two rather different cases:
      - for the initial loading of the app's XML. In that case the settings
      are only the defaults (Level_AppXML), the user's KConfig settings will override them
 
      - for later re-loading when switching between parts in KisKXMLGUIFactory.
      In that case the XML contains the final settings, not the defaults.
      We do need the defaults, and the toolbar might have been completely
      deleted and recreated meanwhile. So we store the app-default settings
      into the XML.
    */
    bool loadingAppDefaults = true;
    if (element.hasAttribute(QStringLiteral("tempXml"))) {
        // this isn't the first time, so the app-xml defaults have been saved into the (in-memory) XML
        loadingAppDefaults = false;
        const QString iconSizeDefault = element.attribute(QStringLiteral("iconSizeDefault"));
        if (!iconSizeDefault.isEmpty()) {
            d->iconSizeSettings[Level_AppXML] = iconSizeDefault.toInt();
        }
        const QString toolButtonStyleDefault = element.attribute(QStringLiteral("toolButtonStyleDefault"));
        if (!toolButtonStyleDefault.isEmpty()) {
            d->toolButtonStyleSettings[Level_AppXML] = d->toolButtonStyleFromString(toolButtonStyleDefault);
        }
    } else {
        // loading app defaults
        bool newLine = false;
        QString attrNewLine = element.attribute(QStringLiteral("newline")).toLower();
        if (!attrNewLine.isEmpty()) {
            newLine = attrNewLine == QStringLiteral("true");
        }
        if (newLine && mw) {
            mw->insertToolBarBreak(this);
        }
 
    }
 
    int newIconSize = -1;
    if (element.hasAttribute(QStringLiteral("iconSize"))) {
        bool ok;
        newIconSize = element.attribute(QStringLiteral("iconSize")).trimmed().toInt(&ok);
        if (!ok) {
            newIconSize = -1;
        }
    }
    if (newIconSize != -1) {
        d->iconSizeSettings[loadingAppDefaults ? Level_AppXML : Level_UserSettings] = newIconSize;
    }
 
    const QString newToolButtonStyle = element.attribute(QStringLiteral("iconText"));
    if (!newToolButtonStyle.isEmpty()) {
        d->toolButtonStyleSettings[loadingAppDefaults ? Level_AppXML : Level_UserSettings] = d->toolButtonStyleFromString(newToolButtonStyle);
    }
 
    bool hidden = false;
    {
        QString attrHidden = element.attribute(QStringLiteral("hidden")).toLower();
        if (!attrHidden.isEmpty()) {
            hidden = attrHidden  == QStringLiteral("true");
        }
    }
 
    Qt::ToolBarArea pos = Qt::NoToolBarArea;
    {
        QString attrPosition = element.attribute(QStringLiteral("position")).toLower();
        if (!attrPosition.isEmpty()) {
            pos = KisToolBar::Private::positionFromString(attrPosition);
        }
    }
    if (pos != Qt::NoToolBarArea) {
        mw->addToolBar(pos, this);
    }
 
    setVisible(!hidden);
 
    d->applyCurrentSettings();
}

References KisToolBar::Private::applyCurrentSettings(), d, iconSizeDefault(), KisToolBar::Private::iconSizeSettings, Level_AppXML, Level_UserSettings, mainWindow(), KisToolBar::Private::positionFromString(), KisToolBar::Private::toolButtonStyleFromString(), and KisToolBar::Private::toolButtonStyleSettings.

mainWindow()

KisKMainWindow * KisToolBar::mainWindow

(

)

const

Returns the main window that this toolbar is docked with.

Definition at line 1034 of file ktoolbar.cpp.

{
    return qobject_cast<KisKMainWindow *>(const_cast<QObject *>(parent()));
}

mouseMoveEvent()

void KisToolBar::mouseMoveEvent ( QMouseEvent * event )

overrideprotected

Definition at line 1189 of file ktoolbar.cpp.

{
    if (!toolBarsEditable() || !d->dragAction) {
        return QToolBar::mouseMoveEvent(event);
    }
 
    if ((event->pos() - d->dragStartPosition).manhattanLength() < QApplication::startDragDistance()) {
        event->accept();
        return;
    }
 
    QDrag *drag = new QDrag(this);
    QMimeData *mimeData = new QMimeData;
 
    QByteArray data;
    {
        QDataStream stream(&data, QIODevice::WriteOnly);
 
        QStringList actionNames;
        actionNames << d->dragAction->objectName();
 
        stream << actionNames;
    }
 
    mimeData->setData(QStringLiteral("application/x-kde-action-list"), data);
 
    drag->setMimeData(mimeData);
 
    Qt::DropAction dropAction = drag->exec(Qt::MoveAction);
 
    if (dropAction == Qt::MoveAction)
        // Only remove from this toolbar if it was moved to another toolbar
        // Otherwise the receiver moves it.
        if (drag->target() != this) {
            removeAction(d->dragAction);
        }
 
    d->dragAction = 0L;
    event->accept();
}

References d, KisToolBar::Private::dragAction, KisToolBar::Private::dragStartPosition, and toolBarsEditable().

mousePressEvent()

void KisToolBar::mousePressEvent ( QMouseEvent * event )

overrideprotected

Definition at line 1175 of file ktoolbar.cpp.

{
    if (toolBarsEditable() && event->button() == Qt::LeftButton) {
        if (QAction *action = actionAt(event->pos())) {
            d->dragAction = action;
            d->dragStartPosition = event->pos();
            event->accept();
            return;
        }
    }
 
    QToolBar::mousePressEvent(event);
}

References d, KisToolBar::Private::dragAction, KisToolBar::Private::dragStartPosition, and toolBarsEditable().

mouseReleaseEvent()

void KisToolBar::mouseReleaseEvent ( QMouseEvent * event )

overrideprotected

Definition at line 1230 of file ktoolbar.cpp.

{
    // Want to clear this even if toolBarsEditable was changed mid-drag (unlikely)
    if (d->dragAction) {
        d->dragAction = 0L;
        event->accept();
        return;
    }
 
    QToolBar::mouseReleaseEvent(event);
}

References d, and KisToolBar::Private::dragAction.

removeXMLGUIClient()

void KisToolBar::removeXMLGUIClient

(

KisKXMLGUIClient *

client

)

Removes an XML gui client that uses this toolbar

Since

4.8.5

Definition at line 850 of file ktoolbar.cpp.

{
    d->xmlguiClients.remove(client);
}

References d, and KisToolBar::Private::xmlguiClients.

saveSettings()

void KisToolBar::saveSettings

(

KConfigGroup &

cg

)

Save the toolbar settings to group configGroup in config.

Definition at line 820 of file ktoolbar.cpp.

{
    Q_ASSERT(!cg.name().isEmpty());
 
    const int currentIconSize = iconSize().width();
    //qDebug() << objectName() << currentIconSize << d->iconSizeSettings.toString() << "defaultValue=" << d->iconSizeSettings.defaultValue();
    if (!cg.hasDefault("IconSize") && currentIconSize == d->iconSizeSettings.defaultValue()) {
        cg.revertToDefault("IconSize");
        d->iconSizeSettings[Level_UserSettings] = Unset;
    } else {
        cg.writeEntry("IconSize", currentIconSize);
        d->iconSizeSettings[Level_UserSettings] = currentIconSize;
    }
 
    const Qt::ToolButtonStyle currentToolButtonStyle = toolButtonStyle();
    if (!cg.hasDefault("ToolButtonStyle") && currentToolButtonStyle == d->toolButtonStyleSettings.defaultValue()) {
        cg.revertToDefault("ToolButtonStyle");
        d->toolButtonStyleSettings[Level_UserSettings] = Unset;
    } else {
        cg.writeEntry("ToolButtonStyle", d->toolButtonStyleToString(currentToolButtonStyle));
        d->toolButtonStyleSettings[Level_UserSettings] = currentToolButtonStyle;
    }
}

References d, KisToolBar::Private::IntSetting::defaultValue(), iconSize(), KisToolBar::Private::iconSizeSettings, Level_UserSettings, KisToolBar::Private::toolButtonStyleSettings, KisToolBar::Private::toolButtonStyleToString(), and Unset.

saveState()

void KisToolBar::saveState

(

QDomElement &

element

)

const

Save state into an XML element, called by KisKXMLGUIBuilder.

Definition at line 985 of file ktoolbar.cpp.

{
    Q_ASSERT(!current.isNull());
 
    current.setAttribute(QStringLiteral("tempXml"), QLatin1String("true"));
 
    current.setAttribute(QStringLiteral("noMerge"), QLatin1String("1"));
    current.setAttribute(QStringLiteral("position"), d->getPositionAsString().toLower());
    current.setAttribute(QStringLiteral("hidden"), isHidden() ? QLatin1String("true") : QLatin1String("false"));
 
    const int currentIconSize = iconSize().width();
    if (currentIconSize == d->iconSizeSettings.defaultValue()) {
        current.removeAttribute(QStringLiteral("iconSize"));
    } else {
        current.setAttribute(QStringLiteral("iconSize"), iconSize().width());
    }
 
    if (toolButtonStyle() == d->toolButtonStyleSettings.defaultValue()) {
        current.removeAttribute(QStringLiteral("iconText"));
    } else {
        current.setAttribute(QStringLiteral("iconText"), d->toolButtonStyleToString(toolButtonStyle()));
    }
 
    // Note: if this method is used by more than KisKXMLGUIBuilder, e.g. to save XML settings to *disk*,
    // then the stuff below shouldn't always be done. This is not the case currently though.
    if (d->iconSizeSettings[Level_AppXML] != Unset) {
        current.setAttribute(QStringLiteral("iconSizeDefault"), d->iconSizeSettings[Level_AppXML]);
    }
    if (d->toolButtonStyleSettings[Level_AppXML] != Unset) {
        const Qt::ToolButtonStyle bs = static_cast<Qt::ToolButtonStyle>(d->toolButtonStyleSettings[Level_AppXML]);
        current.setAttribute(QStringLiteral("toolButtonStyleDefault"), d->toolButtonStyleToString(bs));
    }
}

References d, KisToolBar::Private::IntSetting::defaultValue(), KisToolBar::Private::getPositionAsString(), iconSize(), KisToolBar::Private::iconSizeSettings, Level_AppXML, KisToolBar::Private::toolButtonStyleSettings, KisToolBar::Private::toolButtonStyleToString(), and Unset.

setIconDimensions()

void KisToolBar::setIconDimensions

(

int

size

)

Convenience function to set icon size

Definition at line 1039 of file ktoolbar.cpp.

{
    QToolBar::setIconSize(QSize(size, size));
    d->iconSizeSettings[Level_UserSettings] = size;
}

References d, KisToolBar::Private::iconSizeSettings, and Level_UserSettings.

setToolBarsEditable()

void KisToolBar::setToolBarsEditable ( bool editable )

static

Enable or disable toolbar editing via drag & drop of actions. This is called by KisKEditToolbar and should generally be set to disabled whenever KisKEditToolbar is not active.

Definition at line 1397 of file ktoolbar.cpp.

{
    if (KisToolBar::Private::s_editable != editable) {
        KisToolBar::Private::s_editable = editable;
    }
}

References KisToolBar::Private::s_editable.

setToolBarsLocked()

void KisToolBar::setToolBarsLocked ( bool locked )

static

Allows you to lock and unlock all toolbars (i.e., disallow/allow moving of the toolbars).

Definition at line 1404 of file ktoolbar.cpp.

{
    s_toolBarsModel->settoolBarsLocked(locked);
}

slotMovableChanged

void KisToolBar::slotMovableChanged ( bool movable )

protectedvirtualslot

Definition at line 1050 of file ktoolbar.cpp.

{
    setMovable(movable);
}

toolBarsEditable()

bool KisToolBar::toolBarsEditable ( )

static

Returns whether the toolbars are currently editable (drag & drop of actions).

Definition at line 1392 of file ktoolbar.cpp.

{
    return KisToolBar::Private::s_editable;
}

References KisToolBar::Private::s_editable.

toolBarsLocked()

bool KisToolBar::toolBarsLocked ( )

static

Returns whether the toolbars are locked (i.e., moving of the toolbars disallowed).

Definition at line 1409 of file ktoolbar.cpp.

{
    return s_toolBarsModel->toolBarsLocked();
}

toolBarStateModel()

KisToolBarStateModel * KisToolBar::toolBarStateModel ( )

static

Definition at line 1422 of file ktoolbar.cpp.

{
    return s_toolBarsModel;
}

Member Data Documentation

d

Private* const KisToolBar::d

private

Definition at line 177 of file ktoolbar.h.

---

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

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