QShortcutMap Class Reference

#include <qshortcutmap_p.h>

Collaboration diagram for QShortcutMap:

[legend]List of all members.

---

Detailed Description

Definition at line 53 of file qshortcutmap_p.h.

Public Member Functions
	QShortcutMap ()
	~QShortcutMap ()
int	addShortcut (QObject *owner, const QKeySequence &key, Qt::ShortcutContext context)
int	removeShortcut (int id, QObject *owner, const QKeySequence &key=QKeySequence())
int	setShortcutEnabled (bool enable, int id, QObject *owner, const QKeySequence &key=QKeySequence())
int	setShortcutAutoRepeat (bool on, int id, QObject *owner, const QKeySequence &key=QKeySequence())
void	resetState ()
QKeySequence::SequenceMatch	nextState (QKeyEvent *e)
QKeySequence::SequenceMatch	state ()
void	dispatchEvent (QKeyEvent *e)
bool	tryShortcutEvent (QWidget *w, QKeyEvent *e)
Private Member Functions
bool	correctContext (Qt::ShortcutContext context, QWidget *w, QWidget *active_window)
bool	correctContext (Qt::ShortcutContext context, QAction *a, QWidget *active_window)
QKeySequence::SequenceMatch	find (QKeyEvent *e)
QKeySequence::SequenceMatch	matches (const QKeySequence &seq1, const QKeySequence &seq2) const
QVector< const QShortcutEntry * >	matches () const
void	createNewSequences (QKeyEvent *e, QVector< QKeySequence > &ksl)
void	clearSequence (QVector< QKeySequence > &ksl)
bool	correctContext (const QShortcutEntry &item)
int	translateModifiers (Qt::KeyboardModifiers modifiers)
Private Attributes
QShortcutMapPrivate *	d_ptr

---

Constructor & Destructor Documentation

QShortcutMap::QShortcutMap

(

)

Definition at line 123 of file qshortcutmap.cpp.

References d_ptr, and resetState().

{
    d_ptr = new QShortcutMapPrivate(this);
    Q_ASSERT(d_ptr != 0);
    resetState();
}

Here is the call graph for this function:

QShortcutMap::~QShortcutMap

(

)

Definition at line 133 of file qshortcutmap.cpp.

References d_ptr.

{
    delete d_ptr;
    d_ptr = 0;
}

---

Member Function Documentation

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

Definition at line 143 of file qshortcutmap.cpp.

References d, key, QDebug::nospace(), owner, qDebug(), and qUpperBound().

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;
}

Here is the call graph for this function:

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

Definition at line 169 of file qshortcutmap.cpp.

References d, i, QShortcutEntry::id, key, QShortcutEntry::keyseq, QDebug::nospace(), owner, QShortcutEntry::owner, and qDebug().

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;
}

Here is the call graph for this function:

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

Definition at line 215 of file qshortcutmap.cpp.

References d, i, QShortcutEntry::id, key, QShortcutEntry::keyseq, QDebug::nospace(), owner, QShortcutEntry::owner, and qDebug().

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;
}

Here is the call graph for this function:

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

Definition at line 253 of file qshortcutmap.cpp.

References d, i, QShortcutEntry::id, key, QShortcutEntry::keyseq, QDebug::nospace(), owner, QShortcutEntry::owner, and qDebug().

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

{
    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;
}

Here is the call graph for this function:

void QShortcutMap::resetState

(

)

Definition at line 286 of file qshortcutmap.cpp.

References clearSequence(), d, and QKeySequence::NoMatch.

Referenced by QShortcutMap(), and tryShortcutEvent().

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

Here is the call graph for this function:

QKeySequence::SequenceMatch QShortcutMap::nextState

(

QKeyEvent *

e

)

Definition at line 355 of file qshortcutmap.cpp.

References QEvent::accept(), clearSequence(), d, QKeySequence::ExactMatch, find(), QKeyEvent::key(), Qt::Key_Alt, Qt::Key_Backtab, Qt::Key_Shift, Qt::Key_Tab, QKeyEvent::modifiers(), QKeySequence::NoMatch, QDebug::nospace(), QKeySequence::PartialMatch, qDebug(), Qt::ShiftModifier, QKeyEvent::text(), and QEvent::type().

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::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);
        }
#if 0
        // ### This is not needed anymore, kill it when qkeymapper is done...
        // If still no result, try removing the Shift modifier
        if (result == QKeySequence::NoMatch) {
            QKeyEvent pe = QKeyEvent(e->type(), e->key(),
                                     e->modifiers()&~Qt::ShiftModifier, e->text());
            result = find(&pe);
        }
#endif
    }

    // 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;
}

Here is the call graph for this function:

QKeySequence::SequenceMatch QShortcutMap::state

(

)

Definition at line 296 of file qshortcutmap.cpp.

References d.

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

void QShortcutMap::dispatchEvent

(

QKeyEvent *

e

)

Definition at line 709 of file qshortcutmap.cpp.

References d, QShortcutEntry::enabled, i, QKeyEvent::isAutoRepeat(), next, QDebug::nospace(), qDebug(), and QCoreApplication::sendEvent().

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);
}

Here is the call graph for this function:

bool QShortcutMap::tryShortcutEvent	(	QWidget *	w,
		QKeyEvent *	e
	)

Definition at line 308 of file qshortcutmap.cpp.

References QEvent::accept(), d, dispatchEvent(), QKeySequence::ExactMatch, QEvent::ignore(), QEvent::isAccepted(), nextState(), QKeySequence::NoMatch, QKeySequence::PartialMatch, resetState(), QCoreApplication::sendSpontaneousEvent(), QEvent::ShortcutOverride, QEvent::t, and w.

{
    Q_D(QShortcutMap);

    bool wasAccepted = e->isAccepted();
    if (d->currentState == QKeySequence::NoMatch) {
        ushort orgType = e->t;
        e->t = QEvent::ShortcutOverride;
        e->ignore();
        QApplication::sendSpontaneousEvent(w, e);
        e->t = orgType;
        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;
}

Here is the call graph for this function:

bool QShortcutMap::correctContext	(	Qt::ShortcutContext	context,
		QWidget *	w,
		QWidget *	active_window
	)			[private]

Definition at line 616 of file qshortcutmap.cpp.

References Qt::ApplicationShortcut, QApplication::focusWidget(), QWidget::isWindow(), QDebug::nospace(), QWidget::parentWidget(), qDebug(), Qt::SubWindow, Qt::Tool, QApplicationPrivate::tryModalHelper(), w, Qt::WidgetShortcut, QWidget::window(), and QWidget::windowType().

Referenced by correctContext(), and find().

{
    if (!w->isVisible() || !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();

    QWidget *tlw = w->window();

    /* 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;
}

Here is the call graph for this function:

bool QShortcutMap::correctContext	(	Qt::ShortcutContext	context,
		QAction *	a,
		QWidget *	active_window
	)			[private]

Definition at line 657 of file qshortcutmap.cpp.

References a, QList< T >::at(), correctContext(), i, QList< T >::isEmpty(), qDebug(), QList< T >::size(), and w.

{
    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 (correctContext(context, w, active_window))
                return true;
    }
    return false;
}

Here is the call graph for this function:

QKeySequence::SequenceMatch QShortcutMap::find

(

QKeyEvent *

e

)

[private]

Definition at line 408 of file qshortcutmap.cpp.

References QVector< T >::at(), QVector< T >::clear(), clearSequence(), correctContext(), QVector< T >::count(), createNewSequences(), d, QKeySequence::ExactMatch, i, QKeyEvent::key(), Qt::Key_unknown, QString::length(), matches(), QKeySequence::NoMatch, QKeySequence::PartialMatch, qDebug(), qLowerBound(), qMax(), and QKeyEvent::text().

Referenced by nextState().

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

    static QVector<QKeySequence> newEntries;
    createNewSequences(e, newEntries);
#if defined(DEBUG_QSHORTCUTMAP)
    qDebug() << "Possible shortcut keysequences:" << newEntries;
#endif

    // Should never happen
    if (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 = newEntries.count()-1; i >= 0 ; --i) {
        QShortcutEntry entry(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 (" << newEntries << "), clearing keysequence list";
#endif
        }
        if (oneKSResult && oneKSResult >= result) {
            okEntries << newEntries.at(i);
#if defined(DEBUG_QSHORTCUTMAP)
            qDebug() << "Added ok keysequence" << 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);
}

Here is the call graph for this function:

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

Definition at line 559 of file qshortcutmap.cpp.

References QKeySequence::count(), QKeySequence::ExactMatch, i, Qt::Key_hyphen, Qt::Key_Minus, Qt::Key_unknown, Qt::KeyboardModifierMask, match(), QKeySequence::NoMatch, and QKeySequence::PartialMatch.

{
    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;
}

Here is the call graph for this function:

QVector< const QShortcutEntry * > QShortcutMap::matches

(

)

const [private]

Definition at line 700 of file qshortcutmap.cpp.

References d.

Referenced by find().

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

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

Definition at line 518 of file qshortcutmap.cpp.

References QList< T >::at(), QList< T >::count(), d, i, index, QKeyMapper::possibleKeys(), qMax(), QVector< T >::resize(), and QKeySequence::setKey().

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);
            }
            // Filtering keycode here with 0xdfffffff to ignore the Keypad modifier
            curKsl.setKey(possibleKeys.at(pkNum) & 0xdfffffff, index);
        }
    }
}

Here is the call graph for this function:

void QShortcutMap::clearSequence

(

QVector< QKeySequence > &

ksl

)

[private]

Definition at line 509 of file qshortcutmap.cpp.

References QVector< T >::clear().

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

{
    ksl.clear();
}

Here is the call graph for this function:

bool QShortcutMap::correctContext

(

const QShortcutEntry &

item

)

[private]

Definition at line 591 of file qshortcutmap.cpp.

References a, QShortcutEntry::context, correctContext(), QShortcutEntry::owner, qApp, qobject_cast< QWidget * >(), s, and w.

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

    QWidget *active_window = qApp->activeWindow();

    // popups do not become the active window,
    // so we fake it here to get the correct context
    // for the shortcut system.
    if (qApp->activePopupWidget())
        active_window = qApp->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
    QWidget *w = qobject_cast<QWidget *>(item.owner);
    if (!w) {
        QShortcut *s = qobject_cast<QShortcut *>(item.owner);
        w = s->parentWidget();
    }
    return correctContext(item.context, w, active_window);
}

Here is the call graph for this function:

int QShortcutMap::translateModifiers

(

Qt::KeyboardModifiers

modifiers

)

[private]

Definition at line 683 of file qshortcutmap.cpp.

References Qt::ALT, Qt::AltModifier, Qt::ControlModifier, Qt::CTRL, Qt::META, Qt::MetaModifier, Qt::SHIFT, and Qt::ShiftModifier.

{
    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;
}

---

Member Data Documentation

QShortcutMapPrivate* QShortcutMap::d_ptr [private]

Definition at line 80 of file qshortcutmap_p.h.

Referenced by QShortcutMap(), and ~QShortcutMap().

---

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

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

---