KisShortcutsEditorDelegate Class Reference

#include <KisShortcutsDialog_p.h>

Inheritance diagram for KisShortcutsEditorDelegate:

Public Slots
void	hiddenBySearchLine (QTreeWidgetItem *, bool)

Signals
void	shortcutChanged (QVariant, const QModelIndex &)

Public Member Functions
bool	eventFilter (QObject *, QEvent *) override
	KisShortcutsEditorDelegate (QTreeWidget *parent, bool allowLetterShortcuts)
void	setCheckActionCollections (const QList< KisKActionCollection * > checkActionCollections)
QSize	sizeHint (const QStyleOptionViewItem &option, const QModelIndex &index) const override

Private Slots
void	itemActivated (QModelIndex index)
void	itemCollapsed (QModelIndex index)
void	keySequenceChanged (const QKeySequence &)
void	stealShortcut (const QKeySequence &seq, QAction *action)

Private Attributes
bool	m_allowLetterShortcuts
QList< KisKActionCollection * >	m_checkActionCollections
	List of actionCollections to check for conflicts.
QPersistentModelIndex	m_editingIndex
QWidget *	m_editor

Detailed Description

Mixes the KisKShortcutWidget into the treeview used by KisShortcutsEditor. When selecting an shortcut it changes the display from "CTRL-W" to the Widget.

Bug

That delegate uses KExtendableItemDelegate. That means a cell can be expanded. When selected a cell is replaced by a KisShortcutsEditor. When painting the widget KExtendableItemDelegate reparents the widget to the viewport of the itemview it belongs to. The widget is destroyed when the user selects another shortcut or explicitly issues a contractItem event. But when the user clears the model the delegate misses that event and doesn't delete the KShortcutseditor. And remains as a visible artifact in your treeview. Additionally when closing your application you get an assertion failure from KExtendableItemDelegate.

Definition at line 104 of file KisShortcutsDialog_p.h.

Constructor & Destructor Documentation

KisShortcutsEditorDelegate()

KisShortcutsEditorDelegate::KisShortcutsEditorDelegate	(	QTreeWidget *	parent,
		bool	allowLetterShortcuts )

Definition at line 36 of file KisShortcutsEditorDelegate.cpp.

    : KExtendableItemDelegate(parent),
      m_allowLetterShortcuts(allowLetterShortcuts),
      m_editor(0)
{
    Q_ASSERT(qobject_cast<QAbstractItemView *>(parent));
 
    QPixmap pixmap(16, 16);
    pixmap.fill(QColor(Qt::transparent));
    QPainter p(&pixmap);
    QStyleOption option;
    option.rect = pixmap.rect();
 
    bool isRtl = QApplication::isRightToLeft();
    QApplication::style()->drawPrimitive(isRtl ? QStyle::PE_IndicatorArrowLeft : QStyle::PE_IndicatorArrowRight, &option, &p);
    p.end();
    setExtendPixmap(pixmap);
 
    pixmap.fill(QColor(Qt::transparent));
    p.begin(&pixmap);
    QApplication::style()->drawPrimitive(QStyle::PE_IndicatorArrowDown, &option, &p);
    p.end();
    setContractPixmap(pixmap);
 
    parent->installEventFilter(this);
 
    // Listen to activation signals
    // connect(parent, SIGNAL(activated(QModelIndex)), this, SLOT(itemActivated(QModelIndex)));
    connect(parent, SIGNAL(clicked(QModelIndex)), this, SLOT(itemActivated(QModelIndex)));
 
    // Listen to collapse signals
    connect(parent, SIGNAL(collapsed(QModelIndex)), this, SLOT(itemCollapsed(QModelIndex)));
}

References connect(), itemActivated(), itemCollapsed(), and p.

Member Function Documentation

eventFilter()

bool KisShortcutsEditorDelegate::eventFilter ( QObject * o, QEvent * e )

override

Definition at line 218 of file KisShortcutsEditorDelegate.cpp.

{
    if (o == m_editor) {
        //Prevent clicks in the empty part of the editor widget from closing the editor
        //because they would propagate to the itemview and be interpreted as a click in
        //an item's rect. That in turn would lead to an itemActivated() call, closing
        //the current editor.
 
        switch (e->type()) {
        case QEvent::MouseButtonPress:
        case QEvent::MouseButtonRelease:
        case QEvent::MouseButtonDblClick:
            return true;
        default:
            return false;
        }
    } else if (o == parent()) {
        // Make left/right cursor keys switch items instead of operate the scroll bar
        // (subclassing QtreeView/Widget would be cleaner but much more of a hassle)
        // Note that in our case we know that the selection mode is SingleSelection,
        // so we don't have to ask QAbstractItemView::selectionCommand() et al.
 
        if (e->type() != QEvent::KeyPress) {
            return false;
        }
        QKeyEvent *ke = static_cast<QKeyEvent *>(e);
        QTreeWidget *view = static_cast<QTreeWidget *>(parent());
        QItemSelectionModel *selection = view->selectionModel();
        QModelIndex index = selection->currentIndex();
 
        switch (ke->key()) {
        case Qt::Key_Space:
        case Qt::Key_Select:
            // we are not using the standard "open editor" mechanism of QAbstractItemView,
            // so let's emulate that here.
            itemActivated(index);
            return true;
        case Qt::Key_Left:
            index = index.sibling(index.row(), index.column() - 1);
            break;
        case Qt::Key_Right:
            index = index.sibling(index.row(), index.column() + 1);
            break;
        default:
            return false;
        }
        // a cursor key was pressed
        if (index.isValid()) {
            selection->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
            //### using PositionAtCenter for now;
            // EnsureVisible has no effect which seems to be a bug.
            view->scrollTo(index, QAbstractItemView::PositionAtCenter);
        }
        return true;
    }
    return false;
}

References itemActivated(), and m_editor.

hiddenBySearchLine

void KisShortcutsEditorDelegate::hiddenBySearchLine ( QTreeWidgetItem * item, bool hidden )

slot

Definition at line 206 of file KisShortcutsEditorDelegate.cpp.

{
    if (!hidden || !item) {
        return;
    }
    QTreeWidget *view = static_cast<QTreeWidget *>(parent());
    QTreeWidgetItem *editingItem = ::itemFromIndex(view, m_editingIndex);
    if (editingItem == item) {
        itemActivated(m_editingIndex); //this will *close* the item's editor because it's already open
    }
}

References itemActivated(), and m_editingIndex.

itemActivated

void KisShortcutsEditorDelegate::itemActivated ( QModelIndex index )

privateslot

Definition at line 111 of file KisShortcutsEditorDelegate.cpp.

{
    //As per our constructor our parent *is* a QTreeWidget
    QTreeWidget *view = static_cast<QTreeWidget *>(parent());
 
    KisShortcutsEditorItem *item = ::itemFromIndex(view, index);
    if (!item) {
        //that probably was a non-leaf (type() !=ActionItem) item
        return;
    }
 
    int column = index.column();
    if (column == Name) {
        // If clicking the name try to activate the Primary column
        if (!view->header()->isSectionHidden(LocalPrimary)) {
            column = LocalPrimary;
        } else {
            // do nothing.
        }
        index = index.sibling(index.row(), column);
        view->selectionModel()->select(index, QItemSelectionModel::SelectCurrent);
    }
 
    // Check if the models wants us to edit the item at index
    if (!index.data(ShowExtensionIndicatorRole).value<bool>()) {
        return;
    }
 
    if (!isExtended(index)) {
        //we only want maximum ONE extender open at any time.
        if (m_editingIndex.isValid()) {
            KisShortcutsEditorItem *oldItem = ::itemFromIndex(view, m_editingIndex);
            Q_ASSERT(oldItem); //here we really expect nothing but a real KisShortcutsEditorItem
 
            oldItem->setNameBold(false);
            contractItem(m_editingIndex);
        }
 
        m_editingIndex = index;
        QWidget *viewport = static_cast<QAbstractItemView *>(parent())->viewport();
 
        if (column >= LocalPrimary && column <= Id) {
            ShortcutEditWidget *editor =
                new ShortcutEditWidget(viewport,
                                       index.data(DefaultShortcutRole).value<QKeySequence>(),
                                       index.data(ShortcutRole).value<QKeySequence>(),
                                       m_allowLetterShortcuts);
 
 
            m_editor = editor;
 
            editor->setCheckActionCollections(m_checkActionCollections);
 
            connect(m_editor, SIGNAL(keySequenceChanged(QKeySequence)),
                    this, SLOT(keySequenceChanged(QKeySequence)));
            connect(m_editor, SIGNAL(stealShortcut(QKeySequence,QAction*)),
                    this, SLOT(stealShortcut(QKeySequence,QAction*)));
        } else {
            return;
        }
 
        m_editor->installEventFilter(this);
        item->setNameBold(true);
        extendItem(m_editor, index);
 
    } else {
        //the item is extended, and clicking on it again closes it
        item->setNameBold(false);
        contractItem(index);
        view->selectionModel()->select(index, QItemSelectionModel::Clear);
        m_editingIndex = QModelIndex();
        m_editor = 0;
    }
}

References connect(), DefaultShortcutRole, Id, keySequenceChanged(), LocalPrimary, m_allowLetterShortcuts, m_checkActionCollections, m_editingIndex, m_editor, Name, KisShortcutsEditorItem::setNameBold(), ShortcutRole, and stealShortcut().

itemCollapsed

void KisShortcutsEditorDelegate::itemCollapsed ( QModelIndex index )

privateslot

When the user collapses a hole subtree of shortcuts then remove eventually extended items. Else we get that artifact bug. See above.

Definition at line 187 of file KisShortcutsEditorDelegate.cpp.

{
    if (!m_editingIndex.isValid()) {
        return;
    }
 
    const QAbstractItemModel *model = index.model();
    for (int row = 0; row < model->rowCount(index); ++row) {
        for (int col = 0; col < index.model()->columnCount(index); ++col) {
            QModelIndex colIndex = model->index(row, col, index);
 
            if (colIndex == m_editingIndex) {
                itemActivated(m_editingIndex); //this will *close* the item's editor because it's already open
            }
        }
    }
}

References itemActivated(), and m_editingIndex.

keySequenceChanged

void KisShortcutsEditorDelegate::keySequenceChanged ( const QKeySequence & seq )

privateslot

Definition at line 277 of file KisShortcutsEditorDelegate.cpp.

{
    QVariant ret = QVariant::fromValue(seq);
    Q_EMIT shortcutChanged(ret, m_editingIndex);
}

References m_editingIndex, and shortcutChanged().

setCheckActionCollections()

void KisShortcutsEditorDelegate::setCheckActionCollections

(

const QList< KisKActionCollection * >

checkActionCollections

)

Set a list of action collections to check against for conflicting shortcuts.

See also

KisKKeySequenceWidget::setCheckActionCollections

Definition at line 283 of file KisShortcutsEditorDelegate.cpp.

{
    m_checkActionCollections = checkActionCollections;
}

References m_checkActionCollections.

shortcutChanged

void KisShortcutsEditorDelegate::shortcutChanged ( QVariant , const QModelIndex &  )

signal

sizeHint()

QSize KisShortcutsEditorDelegate::sizeHint ( const QStyleOptionViewItem & option, const QModelIndex & index ) const

override

Definition at line 102 of file KisShortcutsEditorDelegate.cpp.

{
    QSize ret(KExtendableItemDelegate::sizeHint(option, index));
    ret.rheight() += 4;
    return ret;
}

stealShortcut

void KisShortcutsEditorDelegate::stealShortcut ( const QKeySequence & seq, QAction * action )

privateslot

If the user allowed stealing a shortcut we want to be able to undo that.

Definition at line 70 of file KisShortcutsEditorDelegate.cpp.

{
    QTreeWidget *view = static_cast<QTreeWidget *>(parent());
 
    // Iterate over all items
    QTreeWidgetItemIterator it(view, QTreeWidgetItemIterator::NoChildren);
 
    for (; (*it); ++it) {
        KisShortcutsEditorItem *item = dynamic_cast<KisShortcutsEditorItem *>(*it);
        if (item && (item->data(0, ObjectRole).value<QObject*>() == dynamic_cast<QObject*>(action))) {
 
            // We found the action, snapshot the current state. Steal the
            // shortcut. We will save the change later.
            const QList<QKeySequence> cut = action->shortcuts();
            const QKeySequence primary = cut.isEmpty() ? QKeySequence() : cut.at(0);
            const QKeySequence alternate = cut.size() <= 1 ? QKeySequence() : cut.at(1);
 
            if (primary.matches(seq) != QKeySequence::NoMatch
                    || seq.matches(primary) != QKeySequence::NoMatch) {
                item->setKeySequence(LocalPrimary, QKeySequence());
            }
 
            if (alternate.matches(seq) != QKeySequence::NoMatch
                    || seq.matches(alternate) != QKeySequence::NoMatch) {
                item->setKeySequence(LocalAlternate, QKeySequence());
            }
            break;
        }
    }
 
}

References KisShortcutsEditorItem::data(), LocalAlternate, LocalPrimary, ObjectRole, and KisShortcutsEditorItem::setKeySequence().

Member Data Documentation

m_allowLetterShortcuts

bool KisShortcutsEditorDelegate::m_allowLetterShortcuts

private

Definition at line 122 of file KisShortcutsDialog_p.h.

m_checkActionCollections

QList<KisKActionCollection *> KisShortcutsEditorDelegate::m_checkActionCollections

private

List of actionCollections to check for conflicts.

Definition at line 126 of file KisShortcutsDialog_p.h.

m_editingIndex

QPersistentModelIndex KisShortcutsEditorDelegate::m_editingIndex

mutableprivate

Definition at line 121 of file KisShortcutsDialog_p.h.

m_editor

QWidget* KisShortcutsEditorDelegate::m_editor

private

Definition at line 123 of file KisShortcutsDialog_p.h.

---

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

• libs/widgetutils/xmlgui/KisShortcutsDialog_p.h
• libs/widgetutils/xmlgui/KisShortcutsEditorDelegate.cpp