QShortcutMap Class Reference

#include <qshortcutmap_p.h>

Public Functions
int	addShortcut (QObject *owner, const QKeySequence &key, Qt::ShortcutContext context)
	Adds a shortcut to the global map. More...
void	dispatchEvent (QKeyEvent *e)
	Dispatches QShortcutEvents to widgets who grabbed the matched key sequence. More...
bool	hasShortcutForKeySequence (const QKeySequence &seq) const
	Determines if an enabled shortcut has a matcing key sequence. More...
QKeySequence::SequenceMatch	nextState (QKeyEvent *e)
	QShortcutMap ()
	QShortcutMap constructor. More...
int	removeShortcut (int id, QObject *owner, const QKeySequence &key=QKeySequence())
	Removes a shortcut from the global map. More...
void	resetState ()
int	setShortcutAutoRepeat (bool on, int id, QObject *owner, const QKeySequence &key=QKeySequence())
	Changes the auto repeat state of a shortcut to enable. More...
int	setShortcutEnabled (bool enable, int id, QObject *owner, const QKeySequence &key=QKeySequence())
	Changes the enable state of a shortcut to enable. More...
QKeySequence::SequenceMatch	state ()
bool	tryShortcutEvent (QObject *o, QKeyEvent *e)
	Uses ShortcutOverride event to see if any widgets want to override the event. More...
	~QShortcutMap ()
	QShortcutMap destructor. More...

Private Functions
void	clearSequence (QVector< QKeySequence > &ksl)
	Clears seq to an empty QKeySequence. More...
bool	correctContext (Qt::ShortcutContext context, QAction *a, QWidget *active_window) const
bool	correctContext (const QShortcutEntry &item) const
	Returns true if the widget w is a logical sub window of the current top-level widget. More...
bool	correctGraphicsWidgetContext (Qt::ShortcutContext context, QGraphicsWidget *w, QWidget *active_window) const
bool	correctWidgetContext (Qt::ShortcutContext context, QWidget *w, QWidget *active_window) const
void	createNewSequences (QKeyEvent *e, QVector< QKeySequence > &ksl)
	Alters seq to the new sequence state, based on the current sequence state, and the new key event e. More...
QKeySequence::SequenceMatch	find (QKeyEvent *e)
	Returns the next state of the statemachine, based on the new key event e. More...
QKeySequence::SequenceMatch	matches (const QKeySequence &seq1, const QKeySequence &seq2) const
	Basically the same function as QKeySequence::matches(const QKeySequence &seq) const only that is specially handles Key_hyphen as Key_Minus, as people mix these up all the time and they conceptually the same. More...
QVector< const QShortcutEntry * >	matches () const
	Returns the vector of QShortcutEntry's matching the last Identical state. More...
int	translateModifiers (Qt::KeyboardModifiers modifiers)

Properties
QScopedPointer< QShortcutMapPrivate >	d_ptr

Detailed Description

Definition at line 75 of file qshortcutmap_p.h.

Constructors and Destructors

QShortcutMap()

QShortcutMap::QShortcutMap

(

)

QShortcutMap constructor.

Warning

This function is not part of the public interface.

Definition at line 154 of file qshortcutmap.cpp.

    : d_ptr(new QShortcutMapPrivate(this))
{
    resetState();
}

~QShortcutMap()

QShortcutMap::~QShortcutMap

(

)

QShortcutMap destructor.

Warning

This function is not part of the public interface.

Definition at line 166 of file qshortcutmap.cpp.

{
}

Functions

addShortcut()

int QShortcutMap::addShortcut	(	QObject *	owner,
		const QKeySequence &	key,
		Qt::ShortcutContext	context
	)

Adds a shortcut to the global map.

Warning

This function is not part of the public interface.

Returns the id of the newly added shortcut.

Definition at line 177 of file qshortcutmap.cpp.

Referenced by QActionPrivate::redoGrab(), QShortcutPrivate::redoGrab(), and QActionPrivate::redoGrabAlternate().

{
    Q_ASSERT_X(owner, "QShortcutMap::addShortcut", "All shortcuts need an owner");
    Q_ASSERT_X(!key.isEmpty(), "QShortcutMap::addShortcut", "Cannot add keyless shortcuts to map");
    Q_D(QShortcutMap);

    QShortcutEntry newEntry(owner, key, context, --(d->currentId), true);
    QList<QShortcutEntry>::iterator it = qUpperBound(d->sequences.begin(), d->sequences.end(), newEntry);
    d->sequences.insert(it, newEntry); // Insert sorted
#if defined(DEBUG_QSHORTCUTMAP)
    qDebug().nospace()
        << "QShortcutMap::addShortcut(" << owner << ", "
        << key << ", " << context << ") = " << d->currentId;
#endif
    return d->currentId;
}

clearSequence()

void QShortcutMap::clearSequence ( QVector< QKeySequence > &  ksl )

private

Clears seq to an empty QKeySequence.

Warning

This function is not part of the public interface.

Same as doing (the slower)

key = QKeySequence();

Definition at line 584 of file qshortcutmap.cpp.

Referenced by find(), nextState(), and resetState().

{
    ksl.clear();
    d_func()->newEntries.clear();
}

correctContext() [1/2]

bool QShortcutMap::correctContext ( Qt::ShortcutContext  context, QAction *  a, QWidget *  active_window  ) const

private

Definition at line 827 of file qshortcutmap.cpp.

Referenced by correctContext(), find(), and hasShortcutForKeySequence().

{
    const QList<QWidget *> &widgets = a->d_func()->widgets;
#if defined(DEBUG_QSHORTCUTMAP)
    if (widgets.isEmpty())
        qDebug() << a << "not connected to any widgets; won't trigger";
#endif
    for (int i = 0; i < widgets.size(); ++i) {
        QWidget *w = widgets.at(i);
#ifndef QT_NO_MENU
        if (QMenu *menu = qobject_cast<QMenu *>(w)) {
            QAction *a = menu->menuAction();
            if (correctContext(context, a, active_window))
                return true;
        } else
#endif
            if (correctWidgetContext(context, w, active_window))
                return true;
    }

#ifndef QT_NO_GRAPHICSVIEW
    const QList<QGraphicsWidget *> &graphicsWidgets = a->d_func()->graphicsWidgets;
#if defined(DEBUG_QSHORTCUTMAP)
    if (graphicsWidgets.isEmpty())
        qDebug() << a << "not connected to any widgets; won't trigger";
#endif
    for (int i = 0; i < graphicsWidgets.size(); ++i) {
        QGraphicsWidget *w = graphicsWidgets.at(i);
        if (correctGraphicsWidgetContext(context, w, active_window))
            return true;
    }
#endif
    return false;
}

correctContext() [2/2]

bool QShortcutMap::correctContext ( const QShortcutEntry &  item ) const

private

Returns true if the widget w is a logical sub window of the current top-level widget.

Warning

This function is not part of the public interface.

Definition at line 675 of file qshortcutmap.cpp.

                                                                  {
    Q_ASSERT_X(item.owner, "QShortcutMap", "Shortcut has no owner. Illegal map state!");

    QWidget *active_window = QApplication::activeWindow();

    // popups do not become the active window,
    // so we fake it here to get the correct context
    // for the shortcut system.
    if (QApplication::activePopupWidget())
        active_window = QApplication::activePopupWidget();

    if (!active_window)
        return false;
#ifndef QT_NO_ACTION
    if (QAction *a = qobject_cast<QAction *>(item.owner))
        return correctContext(item.context, a, active_window);
#endif
#ifndef QT_NO_GRAPHICSVIEW
    if (QGraphicsWidget *gw = qobject_cast<QGraphicsWidget *>(item.owner))
        return correctGraphicsWidgetContext(item.context, gw, active_window);
#endif
    QWidget *w = qobject_cast<QWidget *>(item.owner);
    if (!w) {
        QShortcut *s = qobject_cast<QShortcut *>(item.owner);
        w = s->parentWidget();
    }
    return correctWidgetContext(item.context, w, active_window);
}

correctGraphicsWidgetContext()

bool QShortcutMap::correctGraphicsWidgetContext ( Qt::ShortcutContext  context, QGraphicsWidget *  w, QWidget *  active_window  ) const

private

Definition at line 767 of file qshortcutmap.cpp.

Referenced by correctContext(), and correctWidgetContext().

{
    bool visible = w->isVisible();
#ifdef Q_WS_MAC
    if (!qApp->testAttribute(Qt::AA_DontUseNativeMenuBar) && qobject_cast<QMenuBar *>(w))
        visible = true;
#endif

    if (!visible || !w->isEnabled() || !w->scene())
        return false;

    if (context == Qt::ApplicationShortcut) {
        // Applicationwide shortcuts are always reachable unless their owner
        // is shadowed by modality. In QGV there's no modality concept, but we
        // must still check if all views are shadowed.
        QList<QGraphicsView *> views = w->scene()->views();
        for (int i = 0; i < views.size(); ++i) {
            if (QApplicationPrivate::tryModalHelper(views.at(i), 0))
                return true;
        }
        return false;
    }

    if (context == Qt::WidgetShortcut)
        return static_cast<QGraphicsItem *>(w) == w->scene()->focusItem();

    if (context == Qt::WidgetWithChildrenShortcut) {
        const QGraphicsItem *ti = w->scene()->focusItem();
        if (ti && ti->isWidget()) {
            const QGraphicsWidget *tw = static_cast<const QGraphicsWidget *>(ti);
            while (tw && tw != w && (tw->windowType() == Qt::Widget || tw->windowType() == Qt::Popup))
                tw = tw->parentWidget();
            return tw == w;
        }
        return false;
    }

    // Below is Qt::WindowShortcut context

    // Find the active view (if any).
    QList<QGraphicsView *> views = w->scene()->views();
    QGraphicsView *activeView = 0;
    for (int i = 0; i < views.size(); ++i) {
        QGraphicsView *view = views.at(i);
        if (view->window() == active_window) {
            activeView = view;
            break;
        }
    }
    if (!activeView)
        return false;

    // The shortcut is reachable if owned by a windowless widget, or if the
    // widget's window is the same as the focus item's window.
    QGraphicsWidget *a = w->scene()->activeWindow();
    return !w->window() || a == w->window();
}

correctWidgetContext()

bool QShortcutMap::correctWidgetContext ( Qt::ShortcutContext  context, QWidget *  w, QWidget *  active_window  ) const

private

Definition at line 704 of file qshortcutmap.cpp.

Referenced by correctContext().

{
    bool visible = w->isVisible();    
#ifdef Q_WS_MAC
    if (!qApp->testAttribute(Qt::AA_DontUseNativeMenuBar) && qobject_cast<QMenuBar *>(w))
        visible = true;
#endif

    if (!visible || !w->isEnabled())
        return false;

    if (context == Qt::ApplicationShortcut)
        return QApplicationPrivate::tryModalHelper(w, 0); // true, unless w is shadowed by a modal dialog

    if (context == Qt::WidgetShortcut)
        return w == QApplication::focusWidget();

    if (context == Qt::WidgetWithChildrenShortcut) {
        const QWidget *tw = QApplication::focusWidget();
        while (tw && tw != w && (tw->windowType() == Qt::Widget || tw->windowType() == Qt::Popup))
            tw = tw->parentWidget();
        return tw == w;
    }

    // Below is Qt::WindowShortcut context
    QWidget *tlw = w->window();
#ifndef QT_NO_GRAPHICSVIEW
    if (QWExtra *topData = tlw->d_func()->extra) {
        if (topData->proxyWidget) {
            bool res = correctGraphicsWidgetContext(context, (QGraphicsWidget *)topData->proxyWidget, active_window);
            return res;
        }
    }
#endif

    /* if a floating tool window is active, keep shortcuts on the
     * parent working */
    if (active_window != tlw && active_window && active_window->windowType() == Qt::Tool && active_window->parentWidget()) {
        active_window = active_window->parentWidget()->window();
    }

    if (active_window  != tlw)
        return false;

    /* if we live in a MDI subwindow, ignore the event if we are
       not the active document window */
    const QWidget* sw = w;
    while (sw && !(sw->windowType() == Qt::SubWindow) && !sw->isWindow())
        sw = sw->parentWidget();
    if (sw && (sw->windowType() == Qt::SubWindow)) {
        QWidget *focus_widget = QApplication::focusWidget();
        while (focus_widget && focus_widget != sw)
            focus_widget = focus_widget->parentWidget();
        return sw == focus_widget;
    }

#if defined(DEBUG_QSHORTCUTMAP)
    qDebug().nospace() << "..true [Pass-through]";
#endif
    return true;
}

createNewSequences()

void QShortcutMap::createNewSequences ( QKeyEvent *  e, QVector< QKeySequence > &  ksl  )

private

Alters seq to the new sequence state, based on the current sequence state, and the new key event e.

Warning

This function is not part of the public interface.

Definition at line 597 of file qshortcutmap.cpp.

Referenced by find().

{
    Q_D(QShortcutMap);
    QList<int> possibleKeys = QKeyMapper::possibleKeys(e);
    int pkTotal = possibleKeys.count();
    if (!pkTotal)
        return;

    int ssActual = d->currentSequences.count();
    int ssTotal = qMax(1, ssActual);
    // Resize to possible permutations of the current sequence(s).
    ksl.resize(pkTotal * ssTotal);

    int index = ssActual ? d->currentSequences.at(0).count() : 0;
    for (int pkNum = 0; pkNum < pkTotal; ++pkNum) {
        for (int ssNum = 0; ssNum < ssTotal; ++ssNum) {
            int i = (pkNum * ssTotal) + ssNum;
            QKeySequence &curKsl = ksl[i];
            if (ssActual) {
                const QKeySequence &curSeq = d->currentSequences.at(ssNum);
                curKsl.setKey(curSeq[0], 0);
                curKsl.setKey(curSeq[1], 1);
                curKsl.setKey(curSeq[2], 2);
                curKsl.setKey(curSeq[3], 3);
            } else {
                curKsl.setKey(0, 0);
                curKsl.setKey(0, 1);
                curKsl.setKey(0, 2);
                curKsl.setKey(0, 3);
            }
            curKsl.setKey(possibleKeys.at(pkNum), index);
        }
    }
}

dispatchEvent()

void QShortcutMap::dispatchEvent

(

QKeyEvent *

e

)

Dispatches QShortcutEvents to widgets who grabbed the matched key sequence.

Warning

This function is not part of the public interface.

Definition at line 898 of file qshortcutmap.cpp.

Referenced by tryShortcutEvent().

{
    Q_D(QShortcutMap);
    if (!d->identicals.size())
        return;

    const QKeySequence &curKey = d->identicals.at(0)->keyseq;
    if (d->prevSequence != curKey) {
        d->ambigCount = 0;
        d->prevSequence = curKey;
    }
    // Find next
    const QShortcutEntry *current = 0, *next = 0;
    int i = 0, enabledShortcuts = 0;
    while(i < d->identicals.size()) {
        current = d->identicals.at(i);
        if (current->enabled || !next){
            ++enabledShortcuts;
            if (enabledShortcuts > d->ambigCount + 1)
                break;
            next = current;
        }
        ++i;
    }
    d->ambigCount = (d->identicals.size() == i ? 0 : d->ambigCount + 1);
    // Don't trigger shortcut if we're autorepeating and the shortcut is
    // grabbed with not accepting autorepeats.
    if (!next || (e->isAutoRepeat() && !next->autorepeat))
        return;
    // Dispatch next enabled
#if defined(DEBUG_QSHORTCUTMAP)
    qDebug().nospace()
        << "QShortcutMap::dispatchEvent(): Sending QShortcutEvent(\""
        << (QString)next->keyseq << "\", " << next->id << ", "
        << (bool)(enabledShortcuts>1) << ") to object(" << next->owner << ')';
#endif
    QShortcutEvent se(next->keyseq, next->id, enabledShortcuts>1);
    QApplication::sendEvent(const_cast<QObject *>(next->owner), &se);
}

find()

QKeySequence::SequenceMatch QShortcutMap::find ( QKeyEvent *  e )

private

Returns the next state of the statemachine, based on the new key event e.

Warning

This function is not part of the public interface.

Matches are appended to the vector of identicals, which can be access through matches().

See also

matches

Definition at line 483 of file qshortcutmap.cpp.

Referenced by nextState().

{
    Q_D(QShortcutMap);
    if (!d->sequences.count())
        return QKeySequence::NoMatch;

    createNewSequences(e, d->newEntries);
#if defined(DEBUG_QSHORTCUTMAP)
    qDebug() << "Possible shortcut key sequences:" << d->newEntries;
#endif

    // Should never happen
    if (d->newEntries == d->currentSequences) {
        Q_ASSERT_X(e->key() != Qt::Key_unknown || e->text().length(),
                   "QShortcutMap::find", "New sequence to find identical to previous");
        return QKeySequence::NoMatch;
    }

    // Looking for new identicals, scrap old
    d->identicals.resize(0);

    bool partialFound = false;
    bool identicalDisabledFound = false;
    QVector<QKeySequence> okEntries;
    int result = QKeySequence::NoMatch;
    for (int i = d->newEntries.count()-1; i >= 0 ; --i) {
        QShortcutEntry entry(d->newEntries.at(i)); // needed for searching
        QList<QShortcutEntry>::ConstIterator itEnd = d->sequences.constEnd();
        QList<QShortcutEntry>::ConstIterator it =
             qLowerBound(d->sequences.constBegin(), itEnd, entry);

        int oneKSResult = QKeySequence::NoMatch;
        int tempRes = QKeySequence::NoMatch;
        do {
            if (it == itEnd)
                break;
            tempRes = matches(entry.keyseq, (*it).keyseq);
            oneKSResult = qMax(oneKSResult, tempRes);
            if (tempRes != QKeySequence::NoMatch && correctContext(*it)) {
                if (tempRes == QKeySequence::ExactMatch) {
                    if ((*it).enabled)
                        d->identicals.append(&*it);
                    else
                        identicalDisabledFound = true;
                } else if (tempRes == QKeySequence::PartialMatch) {
                    // We don't need partials, if we have identicals
                    if (d->identicals.size())
                        break;
                    // We only care about enabled partials, so we don't consume
                    // key events when all partials are disabled!
                    partialFound |= (*it).enabled;
                }
            }
            ++it;
            // If we got a valid match on this run, there might still be more keys to check against,
            // so we'll loop once more. If we get NoMatch, there's guaranteed no more possible
            // matches in the shortcutmap.
        } while (tempRes != QKeySequence::NoMatch);

        // If the type of match improves (ergo, NoMatch->Partial, or Partial->Exact), clear the
        // previous list. If this match is equal or better than the last match, append to the list
        if (oneKSResult > result) {
            okEntries.clear();
#if defined(DEBUG_QSHORTCUTMAP)
            qDebug() << "Found better match (" << d->newEntries << "), clearing key sequence list";
#endif
        }
        if (oneKSResult && oneKSResult >= result) {
            okEntries << d->newEntries.at(i);
#if defined(DEBUG_QSHORTCUTMAP)
            qDebug() << "Added ok key sequence" << d->newEntries;
#endif
        }
    }

    if (d->identicals.size()) {
        result = QKeySequence::ExactMatch;
    } else if (partialFound) {
        result = QKeySequence::PartialMatch;
    } else if (identicalDisabledFound) {
        result = QKeySequence::ExactMatch;
    } else {
        clearSequence(d->currentSequences);
        result = QKeySequence::NoMatch;
    }
    if (result != QKeySequence::NoMatch)
        d->currentSequences = okEntries;
#if defined(DEBUG_QSHORTCUTMAP)
    qDebug() << "Returning shortcut match == " << result;
#endif
    return QKeySequence::SequenceMatch(result);
}

hasShortcutForKeySequence()

bool QShortcutMap::hasShortcutForKeySequence

(

const QKeySequence &

seq

)

const

Determines if an enabled shortcut has a matcing key sequence.

Warning

This function is not part of the public interface.

Definition at line 456 of file qshortcutmap.cpp.

{
    Q_D(const QShortcutMap);
    QShortcutEntry entry(seq); // needed for searching
    QList<QShortcutEntry>::ConstIterator itEnd = d->sequences.constEnd();
    QList<QShortcutEntry>::ConstIterator it = qLowerBound(d->sequences.constBegin(), itEnd, entry);

    for (;it != itEnd; ++it) {
        if (matches(entry.keyseq, (*it).keyseq) == QKeySequence::ExactMatch && correctContext(*it) && (*it).enabled) {
            return true;
        }
    }

    //end of the loop: we didn't find anything
    return false;
}

matches() [1/2]

QKeySequence::SequenceMatch QShortcutMap::matches ( const QKeySequence &  seq1, const QKeySequence &  seq2  ) const

private

Basically the same function as QKeySequence::matches(const QKeySequence &seq) const only that is specially handles Key_hyphen as Key_Minus, as people mix these up all the time and they conceptually the same.

Warning

This function is not part of the public interface.

Definition at line 640 of file qshortcutmap.cpp.

{
    uint userN = seq1.count(),
        seqN = seq2.count();

    if (userN > seqN)
        return QKeySequence::NoMatch;

    // If equal in length, we have a potential ExactMatch sequence,
    // else we already know it can only be partial.
    QKeySequence::SequenceMatch match = (userN == seqN
                                            ? QKeySequence::ExactMatch
                                            : QKeySequence::PartialMatch);

    for (uint i = 0; i < userN; ++i) {
        int userKey = seq1[i],
            sequenceKey = seq2[i];
        if ((userKey & Qt::Key_unknown) == Qt::Key_hyphen)
            userKey = (userKey & Qt::KeyboardModifierMask) | Qt::Key_Minus;
        if ((sequenceKey & Qt::Key_unknown) == Qt::Key_hyphen)
            sequenceKey = (sequenceKey & Qt::KeyboardModifierMask) | Qt::Key_Minus;
        if (userKey != sequenceKey)
            return QKeySequence::NoMatch;
    }
    return match;
}

matches() [2/2]

QVector< const QShortcutEntry * > QShortcutMap::matches ( ) const

private

Returns the vector of QShortcutEntry's matching the last Identical state.

Warning

This function is not part of the public interface.

Definition at line 886 of file qshortcutmap.cpp.

Referenced by find(), and hasShortcutForKeySequence().

{
    Q_D(const QShortcutMap);
    return d->identicals;
}

nextState()

QKeySequence::SequenceMatch QShortcutMap::nextState

(

QKeyEvent *

e

)

Warning

This function is not part of the public interface. Returns the next state of the statemachine If return value is SequenceMatch::ExactMatch, then a call to matches() will return a QObjects* list of all matching objects for the last matching sequence.

Definition at line 406 of file qshortcutmap.cpp.

Referenced by tryShortcutEvent().

{
    Q_D(QShortcutMap);
    // Modifiers can NOT be shortcuts...
    if (e->key() >= Qt::Key_Shift &&
        e->key() <= Qt::Key_Alt)
        return d->currentState;

    QKeySequence::SequenceMatch result = QKeySequence::NoMatch;

    // We start fresh each time..
    d->identicals.resize(0);

    result = find(e);
    if (result == QKeySequence::NoMatch && (e->modifiers() & Qt::KeypadModifier)) {
        // Try to find a match without keypad modifier
        QKeyEvent event = *e;
        event.setModifiers(e->modifiers() & ~Qt::KeypadModifier);
        result = find(&event);
    }
    if (result == QKeySequence::NoMatch && e->modifiers() & Qt::ShiftModifier) {
        // If Shift + Key_Backtab, also try Shift + Qt::Key_Tab
        if (e->key() == Qt::Key_Backtab) {
            QKeyEvent pe = QKeyEvent(e->type(), Qt::Key_Tab, e->modifiers(), e->text());
            result = find(&pe);
        }
    }

    // Should we eat this key press?
    if (d->currentState == QKeySequence::PartialMatch
        || (d->currentState == QKeySequence::ExactMatch && d->identicals.count()))
        e->accept();
    // Does the new state require us to clean up?
    if (result == QKeySequence::NoMatch)
        clearSequence(d->currentSequences);
    d->currentState = result;

#if defined(DEBUG_QSHORTCUTMAP)
    qDebug().nospace() << "QShortcutMap::nextState(" << e << ") = " << result;
#endif
    return result;
}

removeShortcut()

int QShortcutMap::removeShortcut	(	int	id,
		QObject *	owner,
		const QKeySequence &	key = QKeySequence()
	)

Removes a shortcut from the global map.

Warning

This function is not part of the public interface.

If owner is 0, all entries in the map with the key sequence specified is removed. If key is null, all sequences for owner is removed from the map. If id is 0, any identical key sequences owned by owner are removed. Returns the number of sequences removed from the map.

Definition at line 206 of file qshortcutmap.cpp.

Referenced by QActionPrivate::redoGrab(), QShortcutPrivate::redoGrab(), and QActionPrivate::redoGrabAlternate().

{
    Q_D(QShortcutMap);
    int itemsRemoved = 0;
    bool allOwners = (owner == 0);
    bool allKeys = key.isEmpty();
    bool allIds = id == 0;

    // Special case, remove everything
    if (allOwners && allKeys && id == 0) {
        itemsRemoved = d->sequences.size();
        d->sequences.clear();
        return itemsRemoved;
    }

    int i = d->sequences.size()-1;
    while (i>=0)
    {
        const QShortcutEntry &entry = d->sequences.at(i);
        int entryId = entry.id;
        if ((allOwners || entry.owner == owner)
            && (allIds || entry.id == id)
            && (allKeys || entry.keyseq == key)) {
            d->sequences.removeAt(i);
            ++itemsRemoved;
        }
        if (id == entryId)
            return itemsRemoved;
        --i;
    }
#if defined(DEBUG_QSHORTCUTMAP)
    qDebug().nospace()
        << "QShortcutMap::removeShortcut(" << id << ", " << owner << ", "
        << key << ") = " << itemsRemoved;
#endif
    return itemsRemoved;
}

resetState()

void QShortcutMap::resetState

(

)

Warning

This function is not part of the public interface. Resets the state of the statemachine to NoMatch

Definition at line 329 of file qshortcutmap.cpp.

Referenced by QShortcutMap(), and tryShortcutEvent().

{
    Q_D(QShortcutMap);
    d->currentState = QKeySequence::NoMatch;
    clearSequence(d->currentSequences);
}

setShortcutAutoRepeat()

int QShortcutMap::setShortcutAutoRepeat	(	bool	on,
		int	id,
		QObject *	owner,
		const QKeySequence &	key = QKeySequence()
	)

Changes the auto repeat state of a shortcut to enable.

Warning

This function is not part of the public interface.

If owner is 0, all entries in the map with the key sequence specified is removed. If key is null, all sequences for owner is removed from the map. If id is 0, any identical key sequences owned by owner are changed. Returns the number of sequences which are matched in the map.

Definition at line 296 of file qshortcutmap.cpp.

Referenced by QActionPrivate::redoGrab(), QShortcutPrivate::redoGrab(), and QActionPrivate::redoGrabAlternate().

{
    Q_D(QShortcutMap);
    int itemsChanged = 0;
    bool allOwners = (owner == 0);
    bool allKeys = key.isEmpty();
    bool allIds = id == 0;

    int i = d->sequences.size()-1;
    while (i>=0)
    {
        QShortcutEntry entry = d->sequences.at(i);
        if ((allOwners || entry.owner == owner)
            && (allIds || entry.id == id)
            && (allKeys || entry.keyseq == key)) {
                d->sequences[i].autorepeat = on;
                ++itemsChanged;
        }
        if (id == entry.id)
            return itemsChanged;
        --i;
    }
#if defined(DEBUG_QSHORTCUTMAP)
    qDebug().nospace()
        << "QShortcutMap::setShortcutAutoRepeat(" << on << ", " << id << ", "
        << owner << ", " << key << ") = " << itemsChanged;
#endif
    return itemsChanged;
}

setShortcutEnabled()

int QShortcutMap::setShortcutEnabled	(	bool	enable,
		int	id,
		QObject *	owner,
		const QKeySequence &	key = QKeySequence()
	)

Changes the enable state of a shortcut to enable.

Warning

This function is not part of the public interface.

If owner is 0, all entries in the map with the key sequence specified is removed. If key is null, all sequences for owner is removed from the map. If id is 0, any identical key sequences owned by owner are changed. Returns the number of sequences which are matched in the map.

Definition at line 255 of file qshortcutmap.cpp.

Referenced by QActionPrivate::redoGrab(), QShortcutPrivate::redoGrab(), QActionPrivate::redoGrabAlternate(), and QActionPrivate::setShortcutEnabled().

{
    Q_D(QShortcutMap);
    int itemsChanged = 0;
    bool allOwners = (owner == 0);
    bool allKeys = key.isEmpty();
    bool allIds = id == 0;

    int i = d->sequences.size()-1;
    while (i>=0)
    {
        QShortcutEntry entry = d->sequences.at(i);
        if ((allOwners || entry.owner == owner)
            && (allIds || entry.id == id)
            && (allKeys || entry.keyseq == key)) {
            d->sequences[i].enabled = enable;
            ++itemsChanged;
        }
        if (id == entry.id)
            return itemsChanged;
        --i;
    }
#if defined(DEBUG_QSHORTCUTMAP)
    qDebug().nospace()
        << "QShortcutMap::setShortcutEnabled(" << enable << ", " << id << ", "
        << owner << ", " << key << ") = " << itemsChanged;
#endif
    return itemsChanged;
}

state()

QKeySequence::SequenceMatch QShortcutMap::state

(

)

Warning

This function is not part of the public interface. Returns the current state of the statemachine

Definition at line 339 of file qshortcutmap.cpp.

{
    Q_D(QShortcutMap);
    return d->currentState;
}

translateModifiers()

int QShortcutMap::translateModifiers ( Qt::KeyboardModifiers  modifiers )

private

Warning

This function is not part of the public interface. Converts keyboard button states into modifier states

Definition at line 866 of file qshortcutmap.cpp.

{
    int result = 0;
    if (modifiers & Qt::ShiftModifier)
        result |= Qt::SHIFT;
    if (modifiers & Qt::ControlModifier)
        result |= Qt::CTRL;
    if (modifiers & Qt::MetaModifier)
        result |= Qt::META;
    if (modifiers & Qt::AltModifier)
        result |= Qt::ALT;
    return result;
}

tryShortcutEvent()

bool QShortcutMap::tryShortcutEvent	(	QObject *	o,
		QKeyEvent *	e
	)

Uses ShortcutOverride event to see if any widgets want to override the event.

Warning

This function is not part of the public interface. If not, uses nextState(QKeyEvent) to check for a grabbed Shortcut, and dispatchEvent() is found an identical.

See also

nextState dispatchEvent

Definition at line 354 of file qshortcutmap.cpp.

{
    Q_D(QShortcutMap);

    if (e->key() == Qt::Key_unknown)
        return false;

    bool wasAccepted = e->isAccepted();
    bool wasSpontaneous = e->spont;
    if (d->currentState == QKeySequence::NoMatch) {
        ushort orgType = e->t;
        e->t = QEvent::ShortcutOverride;
        e->ignore();
        QApplication::sendEvent(o, e);
        e->t = orgType;
        e->spont = wasSpontaneous;
        if (e->isAccepted()) {
            if (!wasAccepted)
                e->ignore();
            return false;
        }
    }

    QKeySequence::SequenceMatch result = nextState(e);
    bool stateWasAccepted = e->isAccepted();
    if (wasAccepted)
        e->accept();
    else
        e->ignore();

    int identicalMatches = d->identicals.count();

    switch(result) {
    case QKeySequence::NoMatch:
        return stateWasAccepted;
    case QKeySequence::ExactMatch:
        resetState();
        dispatchEvent(e);
    default:
    break;
    }
    // If nextState is QKeySequence::ExactMatch && identicals.count == 0
    // we've only found disabled shortcuts
    return identicalMatches > 0 || result == QKeySequence::PartialMatch;
}

Properties

d_ptr

QScopedPointer<QShortcutMapPrivate> QShortcutMap::d_ptr

private

Definition at line 108 of file qshortcutmap_p.h.

---

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

• /src/gui/kernel/qshortcutmap_p.h
• /src/gui/kernel/qshortcutmap.cpp