1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge QGuiShortcut and QShortcut again in QtGui

Browse Source 
QShortcut has only one widget specific feature, which is whatsThis; that
is just a QString, so the setters and getters can just as well be in
QtGui.

The widgets specific implementation of shortcut matching and of showing
the whatsThis balloon stays in QtWidgets, in the private implementation.
Using virtual functions in the private we can override the empty default
in QtGui, and by adding a virtual factory function in QGuiApplication,
the correct private is instantiated depending on the kind of application
running.

Change-Id: I09ae4a5482f9fb70940c5e2bfe76d3d7fd710afc
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
This commit is contained in:
Volker Hilsheimer 2020-03-19 16:45:15 +01:00
parent bcaff2b06f
commit d975ad4ed7
18 changed files with 597 additions and 700 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/gui/CMakeLists.txt
View File

@ -465,7 +465,7 @@ qt_extend_target(Gui CONDITION QT_FEATURE_draganddrop
qt_extend_target(Gui CONDITION QT_FEATURE_shortcut
SOURCES
kernel/qguishortcut.cpp kernel/qguishortcut.h kernel/qguishortcut_p.h
kernel/qshortcut.cpp kernel/qshortcut.h kernel/qshortcut_p.h
kernel/qkeysequence.cpp kernel/qkeysequence.h kernel/qkeysequence_p.h
kernel/qshortcutmap.cpp kernel/qshortcutmap_p.h
)

6
src/gui/kernel/kernel.pri
View File

@ -167,13 +167,13 @@ qtConfig(opengl) {
qtConfig(shortcut) {
HEADERS += \
kernel/qguishortcut.h \
kernel/qguishortcut_p.h \
kernel/qshortcut.h \
kernel/qshortcut_p.h \
kernel/qshortcutmap_p.h \
kernel/qkeysequence.h \
kernel/qkeysequence_p.h
SOURCES += \
kernel/qguishortcut.cpp \
kernel/qshortcut.cpp \
kernel/qshortcutmap.cpp \
kernel/qkeysequence.cpp
}

6
src/gui/kernel/qguiapplication_p.h
View File

@ -81,6 +81,9 @@ class QInputDeviceManager;
#ifndef QT_NO_ACTION
class QActionPrivate;
#endif
#if QT_CONFIG(shortcut)
class QShortcutPrivate;
#endif
class Q_GUI_EXPORT QGuiApplicationPrivate : public QCoreApplicationPrivate
{
@ -332,6 +335,9 @@ public:
#ifndef QT_NO_ACTION
virtual QActionPrivate *createActionPrivate() const;
#endif
#ifndef QT_NO_SHORTCUT
virtual QShortcutPrivate *createShortcutPrivate() const;
#endif
protected:
virtual void notifyThemeChanged();

354
src/gui/kernel/qguishortcut.cpp
View File

@ -1,354 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qguishortcut.h"
#include "qguishortcut_p.h"
#include <qevent.h>
#include <qguiapplication.h>
#include <qwindow.h>
#include <private/qguiapplication_p.h>
#include <qpa/qplatformmenu.h>
QT_BEGIN_NAMESPACE
#define QAPP_CHECK(functionName) \
if (Q_UNLIKELY(!qApp)) { \
qWarning("QGuiShortcut: Initialize QGuiApplication before calling '" functionName "'."); \
return; \
}
/*!
\class QGuiShortcut
\brief The QGuiShortcut class is a base class for handling keyboard shortcuts.
\ingroup events
\inmodule QtGui
\since 6.0
The QGuiShortcut class is a base class for classes providing a way of
connecting keyboard shortcuts to Qt's \l{signals and slots} mechanism,
so that objects can be informed when a shortcut is executed. The shortcut
can be set up to contain all the key presses necessary to
describe a keyboard shortcut, including the states of modifier
keys such as \uicontrol Shift, \uicontrol Ctrl, and \uicontrol Alt.
\target mnemonic
\sa QShortcutEvent, QKeySequence, QAction
*/
/*!
\fn void QGuiShortcut::activated()
This signal is emitted when the user types the shortcut's key
sequence.
\sa activatedAmbiguously()
*/
/*!
\fn void QGuiShortcut::activatedAmbiguously()
When a key sequence is being typed at the keyboard, it is said to
be ambiguous as long as it matches the start of more than one
shortcut.
When a shortcut's key sequence is completed,
activatedAmbiguously() is emitted if the key sequence is still
ambiguous (i.e., it is the start of one or more other shortcuts).
The activated() signal is not emitted in this case.
\sa activated()
*/
static bool simpleContextMatcher(QObject *object, Qt::ShortcutContext context)
{
auto guiShortcut = qobject_cast<QGuiShortcut *>(object);
if (QGuiApplication::applicationState() != Qt::ApplicationActive || guiShortcut == nullptr)
return false;
if (context == Qt::ApplicationShortcut)
return true;
auto focusWindow = QGuiApplication::focusWindow();
if (!focusWindow)
return false;
auto window = qobject_cast<const QWindow *>(guiShortcut->parent());
if (!window)
return false;
if (focusWindow == window && focusWindow->isTopLevel())
return context == Qt::WindowShortcut || context == Qt::WidgetWithChildrenShortcut;
return focusWindow->isAncestorOf(window, QWindow::ExcludeTransients);
}
QShortcutMap::ContextMatcher QGuiShortcutPrivate::contextMatcher() const
{
return simpleContextMatcher;
}
void QGuiShortcutPrivate::redoGrab(QShortcutMap &map)
{
Q_Q(QGuiShortcut);
if (Q_UNLIKELY(!parent)) {
qWarning("QGuiShortcut: No window parent defined");
return;
}
if (sc_id)
map.removeShortcut(sc_id, q);
if (sc_sequence.isEmpty())
return;
sc_id = map.addShortcut(q, sc_sequence, sc_context, contextMatcher());
if (!sc_enabled)
map.setShortcutEnabled(false, sc_id, q);
if (!sc_autorepeat)
map.setShortcutAutoRepeat(false, sc_id, q);
}
/*!
Constructs a QGuiShortcut object for the \a parent window. Since no
shortcut key sequence is specified, the shortcut will not emit any
signals.
\sa setKey()
*/
QGuiShortcut::QGuiShortcut(QWindow *parent)
: QGuiShortcut(*new QGuiShortcutPrivate, parent)
{
}
/*!
Constructs a QGuiShortcut object for the \a parent window. The shortcut
operates on its parent, listening for \l{QShortcutEvent}s that
match the \a key sequence. Depending on the ambiguity of the
event, the shortcut will call the \a member function, or the \a
ambiguousMember function, if the key press was in the shortcut's
\a context.
*/
QGuiShortcut::QGuiShortcut(const QKeySequence &key, QWindow *parent,
const char *member, const char *ambiguousMember,
Qt::ShortcutContext context)
: QGuiShortcut(*new QGuiShortcutPrivate, key, parent, member, ambiguousMember, context)
{
}
/*!
\internal
*/
QGuiShortcut::QGuiShortcut(QGuiShortcutPrivate &dd, QObject *parent)
: QObject(dd, parent)
{
Q_ASSERT(parent != nullptr);
}
/*!
\internal
*/
QGuiShortcut::QGuiShortcut(QGuiShortcutPrivate &dd,
const QKeySequence &key, QObject *parent,
const char *member, const char *ambiguousMember,
Qt::ShortcutContext context)
: QGuiShortcut(dd, parent)
{
QAPP_CHECK("QGuiShortcut");
Q_D(QGuiShortcut);
d->sc_context = context;
d->sc_sequence = key;
d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
if (member)
connect(this, SIGNAL(activated()), parent, member);
if (ambiguousMember)
connect(this, SIGNAL(activatedAmbiguously()), parent, ambiguousMember);
}
/*!
Destroys the shortcut.
*/
QGuiShortcut::~QGuiShortcut()
{
Q_D(QGuiShortcut);
if (qApp)
QGuiApplicationPrivate::instance()->shortcutMap.removeShortcut(d->sc_id, this);
}
/*!
\property QGuiShortcut::key
\brief the shortcut's key sequence
This is a key sequence with an optional combination of Shift, Ctrl,
and Alt. The key sequence may be supplied in a number of ways:
\snippet code/src_gui_kernel_qshortcut.cpp 1
By default, this property contains an empty key sequence.
*/
void QGuiShortcut::setKey(const QKeySequence &key)
{
Q_D(QGuiShortcut);
if (d->sc_sequence == key)
return;
QAPP_CHECK("setKey");
d->sc_sequence = key;
d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
}
QKeySequence QGuiShortcut::key() const
{
Q_D(const QGuiShortcut);
return d->sc_sequence;
}
/*!
\property QGuiShortcut::enabled
\brief whether the shortcut is enabled
An enabled shortcut emits the activated() or activatedAmbiguously()
signal when a QShortcutEvent occurs that matches the shortcut's
key() sequence.
If the application is in \c WhatsThis mode the shortcut will not emit
the signals, but will show the "What's This?" text instead.
By default, this property is \c true.
\sa whatsThis
*/
void QGuiShortcut::setEnabled(bool enable)
{
Q_D(QGuiShortcut);
if (d->sc_enabled == enable)
return;
QAPP_CHECK("setEnabled");
d->sc_enabled = enable;
QGuiApplicationPrivate::instance()->shortcutMap.setShortcutEnabled(enable, d->sc_id, this);
}
bool QGuiShortcut::isEnabled() const
{
Q_D(const QGuiShortcut);
return d->sc_enabled;
}
/*!
\property QGuiShortcut::context
\brief the context in which the shortcut is valid
A shortcut's context decides in which circumstances a shortcut is
allowed to be triggered. The normal context is Qt::WindowShortcut,
which allows the shortcut to trigger if the parent (the widget
containing the shortcut) is a subwidget of the active top-level
window.
By default, this property is set to Qt::WindowShortcut.
*/
void QGuiShortcut::setContext(Qt::ShortcutContext context)
{
Q_D(QGuiShortcut);
if (d->sc_context == context)
return;
QAPP_CHECK("setContext");
d->sc_context = context;
d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
}
Qt::ShortcutContext QGuiShortcut::context() const
{
Q_D(const QGuiShortcut);
return d->sc_context;
}
/*!
\property QGuiShortcut::autoRepeat
\brief whether the shortcut can auto repeat
If true, the shortcut will auto repeat when the keyboard shortcut
combination is held down, provided that keyboard auto repeat is
enabled on the system.
The default value is true.
*/
void QGuiShortcut::setAutoRepeat(bool on)
{
Q_D(QGuiShortcut);
if (d->sc_autorepeat == on)
return;
QAPP_CHECK("setAutoRepeat");
d->sc_autorepeat = on;
QGuiApplicationPrivate::instance()->shortcutMap.setShortcutAutoRepeat(on, d->sc_id, this);
}
bool QGuiShortcut::autoRepeat() const
{
Q_D(const QGuiShortcut);
return d->sc_autorepeat;
}
/*!
Returns the shortcut's ID.
\sa QShortcutEvent::shortcutId()
*/
int QGuiShortcut::id() const
{
Q_D(const QGuiShortcut);
return d->sc_id;
}
/*!
\internal
*/
bool QGuiShortcut::event(QEvent *e)
{
Q_D(QGuiShortcut);
if (d->sc_enabled && e->type() == QEvent::Shortcut) {
auto se = static_cast<QShortcutEvent *>(e);
if (se->shortcutId() == d->sc_id && se->key() == d->sc_sequence
&& !d->handleWhatsThis()) {
if (se->isAmbiguous())
emit activatedAmbiguously();
else
emit activated();
return true;
}
}
return QObject::event(e);
}
QT_END_NAMESPACE
#include "moc_qguishortcut.cpp"

98
src/gui/kernel/qguishortcut.h
View File

@ -1,98 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QGUISHORTCUT_H
#define QGUISHORTCUT_H
#include <QtGui/qtguiglobal.h>
#include <QtGui/qkeysequence.h>
#include <QtCore/qobject.h>
QT_REQUIRE_CONFIG(shortcut);
QT_BEGIN_NAMESPACE
class QGuiShortcutPrivate;
class QWindow;
class Q_GUI_EXPORT QGuiShortcut : public QObject
{
Q_OBJECT
Q_DECLARE_PRIVATE(QGuiShortcut)
Q_PROPERTY(QKeySequence key READ key WRITE setKey)
Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)
Q_PROPERTY(bool autoRepeat READ autoRepeat WRITE setAutoRepeat)
Q_PROPERTY(Qt::ShortcutContext context READ context WRITE setContext)
public:
explicit QGuiShortcut(QWindow *parent);
explicit QGuiShortcut(const QKeySequence& key, QWindow *parent,
const char *member = nullptr, const char *ambiguousMember = nullptr,
Qt::ShortcutContext context = Qt::WindowShortcut);
~QGuiShortcut();
void setKey(const QKeySequence& key);
QKeySequence key() const;
void setEnabled(bool enable);
bool isEnabled() const;
void setContext(Qt::ShortcutContext context);
Qt::ShortcutContext context() const;
void setAutoRepeat(bool on);
bool autoRepeat() const;
int id() const;
Q_SIGNALS:
void activated();
void activatedAmbiguously();
protected:
QGuiShortcut(QGuiShortcutPrivate &dd, QObject *parent);
QGuiShortcut(QGuiShortcutPrivate &dd, const QKeySequence& key, QObject *parent,
const char *member, const char *ambiguousMember,
Qt::ShortcutContext context);
bool event(QEvent *e) override;
};
QT_END_NAMESPACE
#endif // QGUISHORTCUT_H

483
src/gui/kernel/qshortcut.cpp Normal file
View File

@ -0,0 +1,483 @@
/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qshortcut.h"
#include "qshortcut_p.h"
#include <qevent.h>
#include <qguiapplication.h>
#include <qwindow.h>
#include <private/qguiapplication_p.h>
#include <qpa/qplatformmenu.h>
QT_BEGIN_NAMESPACE
#define QAPP_CHECK(functionName) \
if (Q_UNLIKELY(!qApp)) { \
qWarning("QShortcut: Initialize QGuiApplication before calling '" functionName "'."); \
return; \
}
/*!
\class QShortcut
\brief The QShortcut class is used to create keyboard shortcuts.
\ingroup events
\inmodule QtGui
The QShortcut class provides a way of connecting keyboard
shortcuts to Qt's \l{signals and slots} mechanism, so that
objects can be informed when a shortcut is executed. The shortcut
can be set up to contain all the key presses necessary to
describe a keyboard shortcut, including the states of modifier
keys such as \uicontrol Shift, \uicontrol Ctrl, and \uicontrol Alt.
\target mnemonic
In widget applications, certain widgets can use '&' in front of a character.
This will automatically create a mnemonic (a shortcut) for that character,
e.g. "E&xit" will create the shortcut \uicontrol Alt+X (use '&&'
to display an actual ampersand). The widget might consume and perform
an action on a given shortcut. On X11 the ampersand will not be
shown and the character will be underlined. On Windows, shortcuts
are normally not displayed until the user presses the \uicontrol Alt
key, but this is a setting the user can change. On Mac, shortcuts
are disabled by default. Call \l qt_set_sequence_auto_mnemonic() to
enable them. However, because mnemonic shortcuts do not fit in
with Aqua's guidelines, Qt will not show the shortcut character
underlined.
For applications that use menus, it may be more convenient to
use the convenience functions provided in the QMenu class to
assign keyboard shortcuts to menu items as they are created.
Alternatively, shortcuts may be associated with other types of
actions in the QAction class.
The simplest way to create a shortcut for a particular widget is
to construct the shortcut with a key sequence. For example:
\snippet code/src_gui_kernel_qshortcut.cpp 0
When the user types the \l{QKeySequence}{key sequence}
for a given shortcut, the shortcut's activated() signal is
emitted. (In the case of ambiguity, the activatedAmbiguously()
signal is emitted.) A shortcut is "listened for" by Qt's event
loop when the shortcut's parent widget is receiving events.
A shortcut's key sequence can be set with setKey() and retrieved
with key(). A shortcut can be enabled or disabled with
setEnabled(), and can have "What's This?" help text set with
setWhatsThis().
\sa QShortcutEvent, QKeySequence, QAction
*/
/*!
\fn void QShortcut::activated()
This signal is emitted when the user types the shortcut's key
sequence.
\sa activatedAmbiguously()
*/
/*!
\fn void QShortcut::activatedAmbiguously()
When a key sequence is being typed at the keyboard, it is said to
be ambiguous as long as it matches the start of more than one
shortcut.
When a shortcut's key sequence is completed,
activatedAmbiguously() is emitted if the key sequence is still
ambiguous (i.e., it is the start of one or more other shortcuts).
The activated() signal is not emitted in this case.
\sa activated()
*/
static bool simpleContextMatcher(QObject *object, Qt::ShortcutContext context)
{
auto guiShortcut = qobject_cast<QShortcut *>(object);
if (QGuiApplication::applicationState() != Qt::ApplicationActive || guiShortcut == nullptr)
return false;
if (context == Qt::ApplicationShortcut)
return true;
auto focusWindow = QGuiApplication::focusWindow();
if (!focusWindow)
return false;
auto window = qobject_cast<const QWindow *>(guiShortcut->parent());
if (!window)
return false;
if (focusWindow == window && focusWindow->isTopLevel())
return context == Qt::WindowShortcut || context == Qt::WidgetWithChildrenShortcut;
return focusWindow->isAncestorOf(window, QWindow::ExcludeTransients);
}
QShortcutMap::ContextMatcher QShortcutPrivate::contextMatcher() const
{
return simpleContextMatcher;
}
void QShortcutPrivate::redoGrab(QShortcutMap &map)
{
Q_Q(QShortcut);
if (Q_UNLIKELY(!parent)) {
qWarning("QShortcut: No window parent defined");
return;
}
if (sc_id)
map.removeShortcut(sc_id, q);
if (sc_sequence.isEmpty())
return;
sc_id = map.addShortcut(q, sc_sequence, sc_context, contextMatcher());
if (!sc_enabled)
map.setShortcutEnabled(false, sc_id, q);
if (!sc_autorepeat)
map.setShortcutAutoRepeat(false, sc_id, q);
}
QShortcutPrivate *QGuiApplicationPrivate::createShortcutPrivate() const
{
return new QShortcutPrivate;
}
/*!
Constructs a QShortcut object for the \a parent, which should be a
QWindow or a QWidget.
Since no shortcut key sequence is specified, the shortcut will not emit any
signals.
\sa setKey()
*/
QShortcut::QShortcut(QObject *parent)
: QObject(*QGuiApplicationPrivate::instance()->createShortcutPrivate(), parent)
{
Q_ASSERT(parent != nullptr);
}
/*!
Constructs a QShortcut object for the \a parent, which should be a
QWindow or a QWidget.
The shortcut operates on its parent, listening for \l{QShortcutEvent}s that
match the \a key sequence. Depending on the ambiguity of the event, the
shortcut will call the \a member function, or the \a ambiguousMember function,
if the key press was in the shortcut's \a context.
*/
QShortcut::QShortcut(const QKeySequence &key, QObject *parent,
const char *member, const char *ambiguousMember,
Qt::ShortcutContext context)
: QShortcut(parent)
{
Q_D(QShortcut);
d->sc_context = context;
d->sc_sequence = key;
d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
if (member)
connect(this, SIGNAL(activated()), parent, member);
if (ambiguousMember)
connect(this, SIGNAL(activatedAmbiguously()), parent, ambiguousMember);
}
/*!
\fn template<typename Functor>
QShortcut(const QKeySequence &key, QObject *parent,
Functor functor,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
\since 5.15
\overload
This is a QShortcut convenience constructor which connects the shortcut's
\l{QShortcut::activated()}{activated()} signal to the \a functor.
*/
/*!
\fn template<typename Functor>
QShortcut(const QKeySequence &key, QObject *parent,
const QObject *context, Functor functor,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
\since 5.15
\overload
This is a QShortcut convenience constructor which connects the shortcut's
\l{QShortcut::activated()}{activated()} signal to the \a functor.
The \a functor can be a pointer to a member function of the \a context object.
If the \a context object is destroyed, the \a functor will not be called.
*/
/*!
\fn template<typename Functor, typename FunctorAmbiguous>
QShortcut(const QKeySequence &key, QObject *parent,
const QObject *context1, Functor functor,
FunctorAmbiguous functorAmbiguous,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
\since 5.15
\overload
This is a QShortcut convenience constructor which connects the shortcut's
\l{QShortcut::activated()}{activated()} signal to the \a functor and
\l{QShortcut::activatedAmbiguously()}{activatedAmbiguously()}
signal to the \a FunctorAmbiguous.
The \a functor and \a FunctorAmbiguous can be a pointer to a member
function of the \a context object.
If the \a context object is destroyed, the \a functor and
\a FunctorAmbiguous will not be called.
*/
/*!
\fn template<typename Functor, typename FunctorAmbiguous>
QShortcut(const QKeySequence &key, QObject *parent,
const QObject *context1, Functor functor,
const QObject *context2, FunctorAmbiguous functorAmbiguous,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
\since 5.15
\overload
This is a QShortcut convenience constructor which connects the shortcut's
\l{QShortcut::activated()}{activated()} signal to the \a functor and
\l{QShortcut::activatedAmbiguously()}{activatedAmbiguously()}
signal to the \a FunctorAmbiguous.
The \a functor can be a pointer to a member function of the
\a context1 object.
The \a FunctorAmbiguous can be a pointer to a member function of the
\a context2 object.
If the \a context1 object is destroyed, the \a functor will not be called.
If the \a context2 object is destroyed, the \a FunctorAmbiguous
will not be called.
*/
/*!
Destroys the shortcut.
*/
QShortcut::~QShortcut()
{
Q_D(QShortcut);
if (qApp)
QGuiApplicationPrivate::instance()->shortcutMap.removeShortcut(d->sc_id, this);
}
/*!
\property QShortcut::key
\brief the shortcut's key sequence
This is a key sequence with an optional combination of Shift, Ctrl,
and Alt. The key sequence may be supplied in a number of ways:
\snippet code/src_gui_kernel_qshortcut.cpp 1
By default, this property contains an empty key sequence.
*/
void QShortcut::setKey(const QKeySequence &key)
{
Q_D(QShortcut);
if (d->sc_sequence == key)
return;
QAPP_CHECK("setKey");
d->sc_sequence = key;
d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
}
QKeySequence QShortcut::key() const
{
Q_D(const QShortcut);
return d->sc_sequence;
}
/*!
\property QShortcut::enabled
\brief whether the shortcut is enabled
An enabled shortcut emits the activated() or activatedAmbiguously()
signal when a QShortcutEvent occurs that matches the shortcut's
key() sequence.
If the application is in \c WhatsThis mode the shortcut will not emit
the signals, but will show the "What's This?" text instead.
By default, this property is \c true.
\sa whatsThis
*/
void QShortcut::setEnabled(bool enable)
{
Q_D(QShortcut);
if (d->sc_enabled == enable)
return;
QAPP_CHECK("setEnabled");
d->sc_enabled = enable;
QGuiApplicationPrivate::instance()->shortcutMap.setShortcutEnabled(enable, d->sc_id, this);
}
bool QShortcut::isEnabled() const
{
Q_D(const QShortcut);
return d->sc_enabled;
}
/*!
\property QShortcut::context
\brief the context in which the shortcut is valid
A shortcut's context decides in which circumstances a shortcut is
allowed to be triggered. The normal context is Qt::WindowShortcut,
which allows the shortcut to trigger if the parent (the widget
containing the shortcut) is a subwidget of the active top-level
window.
By default, this property is set to Qt::WindowShortcut.
*/
void QShortcut::setContext(Qt::ShortcutContext context)
{
Q_D(QShortcut);
if (d->sc_context == context)
return;
QAPP_CHECK("setContext");
d->sc_context = context;
d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
}
Qt::ShortcutContext QShortcut::context() const
{
Q_D(const QShortcut);
return d->sc_context;
}
/*!
\property QShortcut::autoRepeat
\brief whether the shortcut can auto repeat
If true, the shortcut will auto repeat when the keyboard shortcut
combination is held down, provided that keyboard auto repeat is
enabled on the system.
The default value is true.
*/
void QShortcut::setAutoRepeat(bool on)
{
Q_D(QShortcut);
if (d->sc_autorepeat == on)
return;
QAPP_CHECK("setAutoRepeat");
d->sc_autorepeat = on;
QGuiApplicationPrivate::instance()->shortcutMap.setShortcutAutoRepeat(on, d->sc_id, this);
}
bool QShortcut::autoRepeat() const
{
Q_D(const QShortcut);
return d->sc_autorepeat;
}
/*!
\property QShortcut::whatsThis
\brief the shortcut's "What's This?" help text
The text will be shown when a widget application is in "What's
This?" mode and the user types the shortcut key() sequence.
To set "What's This?" help on a menu item (with or without a
shortcut key), set the help on the item's action.
By default, this property contains an empty string.
This property has no effect in applications that don't use
widgets.
\sa QWhatsThis::inWhatsThisMode(), QAction::setWhatsThis()
*/
void QShortcut::setWhatsThis(const QString &text)
{
Q_D(QShortcut);
d->sc_whatsthis = text;
}
QString QShortcut::whatsThis() const
{
Q_D(const QShortcut);
return d->sc_whatsthis;
}
/*!
Returns the shortcut's ID.
\sa QShortcutEvent::shortcutId()
*/
int QShortcut::id() const
{
Q_D(const QShortcut);
return d->sc_id;
}
/*!
\fn QWidget *QShortcut::parentWidget() const
Returns the shortcut's parent widget.
*/
/*!
\internal
*/
bool QShortcut::event(QEvent *e)
{
Q_D(QShortcut);
if (d->sc_enabled && e->type() == QEvent::Shortcut) {
auto se = static_cast<QShortcutEvent *>(e);
if (se->shortcutId() == d->sc_id && se->key() == d->sc_sequence
&& !d->handleWhatsThis()) {
if (se->isAmbiguous())
emit activatedAmbiguously();
else
emit activated();
return true;
}
}
return QObject::event(e);
}
QT_END_NAMESPACE
#include "moc_qshortcut.cpp"

73
src/widgets/kernel/qshortcut.h → src/gui/kernel/qshortcut.h
View File

@ -3,7 +3,7 @@
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtWidgets module of the Qt Toolkit.
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
@ -40,47 +40,53 @@
#ifndef QSHORTCUT_H
#define QSHORTCUT_H
#include <QtWidgets/qtwidgetsglobal.h>
#include <QtWidgets/qwidget.h>
#include <QtGui/qguishortcut.h>
#include <QtGui/qtguiglobal.h>
#include <QtGui/qkeysequence.h>
#include <QtCore/qobject.h>
QT_REQUIRE_CONFIG(shortcut);
QT_BEGIN_NAMESPACE
class QShortcutPrivate;
class Q_WIDGETS_EXPORT QShortcut : public QGuiShortcut
class QWindow;
class Q_GUI_EXPORT QShortcut : public QObject
{
Q_OBJECT
Q_PROPERTY(QString whatsThis READ whatsThis WRITE setWhatsThis)
Q_DECLARE_PRIVATE(QShortcut)
Q_PROPERTY(QKeySequence key READ key WRITE setKey)
Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)
Q_PROPERTY(bool autoRepeat READ autoRepeat WRITE setAutoRepeat)
Q_PROPERTY(Qt::ShortcutContext context READ context WRITE setContext)
public:
explicit QShortcut(QWidget *parent);
explicit QShortcut(const QKeySequence& key, QWidget *parent,
explicit QShortcut(QObject *parent);
explicit QShortcut(const QKeySequence& key, QObject *parent,
const char *member = nullptr, const char *ambiguousMember = nullptr,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
Qt::ShortcutContext context = Qt::WindowShortcut);
#ifdef Q_CLANG_QDOC
template<typename Functor>
QShortcut(const QKeySequence &key, QWidget *parent,
QShortcut(const QKeySequence &key, QObject *parent,
Functor functor,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
template<typename Functor>
QShortcut(const QKeySequence &key, QWidget *parent,
QShortcut(const QKeySequence &key, QObject *parent,
const QObject *context, Functor functor,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
template<typename Functor, typename FunctorAmbiguous>
QShortcut(const QKeySequence &key, QWidget *parent,
QShortcut(const QKeySequence &key, QObject *parent,
const QObject *context1, Functor functor,
FunctorAmbiguous functorAmbiguous,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
template<typename Functor, typename FunctorAmbiguous>
QShortcut(const QKeySequence &key, QWidget *parent,
QShortcut(const QKeySequence &key, QObject *parent,
const QObject *context1, Functor functor,
const QObject *context2, FunctorAmbiguous functorAmbiguous,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
#else
template<typename Func1>
QShortcut(const QKeySequence &key, QWidget *parent,
QShortcut(const QKeySequence &key, QObject *parent,
Func1 slot1,
Qt::ShortcutContext context = Qt::WindowShortcut)
: QShortcut(key, parent, static_cast<const char*>(nullptr), static_cast<const char*>(nullptr), context)
@ -88,7 +94,7 @@ public:
connect(this, &QShortcut::activated, std::move(slot1));
}
template<class Obj1, typename Func1>
QShortcut(const QKeySequence &key, QWidget *parent,
QShortcut(const QKeySequence &key, QObject *parent,
const Obj1 *object1, Func1 slot1,
Qt::ShortcutContext context = Qt::WindowShortcut,
typename std::enable_if<QtPrivate::IsPointerToTypeDerivedFromQObject<Obj1*>::Value>::type* = 0)
@ -97,7 +103,7 @@ public:
connect(this, &QShortcut::activated, object1, std::move(slot1));
}
template<class Obj1, typename Func1, typename Func2>
QShortcut(const QKeySequence &key, QWidget *parent,
QShortcut(const QKeySequence &key, QObject *parent,
const Obj1 *object1, Func1 slot1, Func2 slot2,
Qt::ShortcutContext context = Qt::WindowShortcut,
typename std::enable_if<QtPrivate::IsPointerToTypeDerivedFromQObject<Obj1*>::Value>::type* = 0)
@ -107,7 +113,7 @@ public:
connect(this, &QShortcut::activatedAmbiguously, object1, std::move(slot2));
}
template<class Obj1, typename Func1, class Obj2, typename Func2>
QShortcut(const QKeySequence &key, QWidget *parent,
QShortcut(const QKeySequence &key, QObject *parent,
const Obj1 *object1, Func1 slot1,
const Obj2 *object2, Func2 slot2,
Qt::ShortcutContext context = Qt::WindowShortcut,
@ -119,13 +125,42 @@ public:
connect(this, &QShortcut::activatedAmbiguously, object2, std::move(slot2));
}
#endif
~QShortcut();
void setKey(const QKeySequence& key);
QKeySequence key() const;
void setEnabled(bool enable);
bool isEnabled() const;
void setContext(Qt::ShortcutContext context);
Qt::ShortcutContext context() const;
void setAutoRepeat(bool on);
bool autoRepeat() const;
int id() const;
void setWhatsThis(const QString &text);
QString whatsThis() const;
inline QWidget *parentWidget() const
{ return static_cast<QWidget *>(QObject::parent()); }
#if QT_DEPRECATED_SINCE(6,0)
#ifdef Q_CLANG_QDOC
QWidget *parentWidget() const;
#else
template<typename T = QWidget*>
inline T parentWidget() const
{ return static_cast<T>(QObject::parent()); }
#endif
#endif
Q_SIGNALS:
void activated();
void activatedAmbiguously();
protected:
bool event(QEvent *e) override;
};
QT_END_NAMESPACE

17
src/gui/kernel/qguishortcut_p.h → src/gui/kernel/qshortcut_p.h
View File

@ -1,6 +1,6 @@
/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Copyright (C) 2020 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtGui module of the Qt Toolkit.
@ -37,8 +37,8 @@
**
****************************************************************************/
#ifndef QGUISHORTCUT_P_H
#define QGUISHORTCUT_P_H
#ifndef QSHORTCUT_P_H
#define QSHORTCUT_P_H
//
// W A R N I N G
@ -52,7 +52,7 @@
//
#include <QtGui/private/qtguiglobal_p.h>
#include "qguishortcut.h"
#include "qshortcut.h"
#include <QtGui/qkeysequence.h>
#include <QtCore/qstring.h>
@ -70,16 +70,17 @@ class QShortcutMap;
\internal
Private data accessed through d-pointer.
*/
class Q_GUI_EXPORT QGuiShortcutPrivate : public QObjectPrivate
class Q_GUI_EXPORT QShortcutPrivate : public QObjectPrivate
{
Q_DECLARE_PUBLIC(QGuiShortcut)
Q_DECLARE_PUBLIC(QShortcut)
public:
QGuiShortcutPrivate() = default;
QShortcutPrivate() = default;
virtual QShortcutMap::ContextMatcher contextMatcher() const;
virtual bool handleWhatsThis() { return false; }
QKeySequence sc_sequence;
QString sc_whatsthis;
Qt::ShortcutContext sc_context = Qt::WindowShortcut;
bool sc_enabled = true;
bool sc_autorepeat = true;
@ -89,4 +90,4 @@ public:
QT_END_NAMESPACE
#endif // QGUISHORTCUT_P_H
#endif // QSHORTCUT_P_H

2
src/tools/uic/qclass_lib_map.h
View File

@ -727,7 +727,7 @@ QT_CLASS_LIB(QWidgetItemV2, QtWidgets, qlayoutitem.h)
QT_CLASS_LIB(QPalette, QtGui, qpalette.h)
QT_CLASS_LIB(QColorGroup, QtWidgets, qpalette.h)
QT_CLASS_LIB(QSessionManager, QtGui, qsessionmanager.h)
QT_CLASS_LIB(QShortcut, QtWidgets, qshortcut.h)
QT_CLASS_LIB(QShortcut, QtGui, qshortcut.h)
QT_CLASS_LIB(QSizePolicy, QtWidgets, qsizepolicy.h)
QT_CLASS_LIB(QStackedLayout, QtWidgets, qstackedlayout.h)
QT_CLASS_LIB(QToolTip, QtWidgets, qtooltip.h)

2
src/widgets/CMakeLists.txt
View File

@ -334,7 +334,7 @@ qt_extend_target(Widgets CONDITION QT_FEATURE_formlayout
qt_extend_target(Widgets CONDITION QT_FEATURE_shortcut
SOURCES
kernel/qshortcut.cpp kernel/qshortcut.h
kernel/qshortcut_widgets.cpp
)
qt_extend_target(Widgets CONDITION QT_FEATURE_tooltip

3
src/widgets/kernel/kernel.pri
View File

@ -71,8 +71,7 @@ qtConfig(formlayout) {
}
qtConfig(shortcut) {
HEADERS += kernel/qshortcut.h
SOURCES += kernel/qshortcut.cpp
SOURCES += kernel/qshortcut_widgets.cpp
}
qtConfig(tooltip) {

3
src/widgets/kernel/qapplication_p.h
View File

@ -120,6 +120,9 @@ public:
#ifndef QT_NO_ACTION
QActionPrivate *createActionPrivate() const override;
#endif
#ifndef QT_NO_SHORTCUT
QShortcutPrivate *createShortcutPrivate() const override;
#endif
//modality
bool isWindowBlocked(QWindow *window, QWindow **blockingWindow = nullptr) const override;

212
src/widgets/kernel/qshortcut.cpp → src/widgets/kernel/qshortcut_widgets.cpp
View File

@ -38,6 +38,8 @@
****************************************************************************/
#include "qshortcut.h"
#include "private/qshortcut_p.h"
#include "private/qwidget_p.h"
#include <qevent.h>
@ -52,7 +54,6 @@
#endif
#include <qapplication.h>
#include <private/qapplication_p.h>
#include "private/qguishortcut_p.h"
#include <private/qshortcutmap_p.h>
#if QT_CONFIG(action)
# include <private/qaction_p.h>
@ -326,223 +327,32 @@ static bool correctActionContext(Qt::ShortcutContext context, QAction *a, QWidge
}
#endif // QT_CONFIG(action)
/*!
\class QShortcut
\brief The QShortcut class is used to create keyboard shortcuts.
\ingroup events
\inmodule QtWidgets
The QShortcut class provides a way of connecting keyboard
shortcuts to Qt's \l{signals and slots} mechanism, so that
objects can be informed when a shortcut is executed. The shortcut
can be set up to contain all the key presses necessary to
describe a keyboard shortcut, including the states of modifier
keys such as \uicontrol Shift, \uicontrol Ctrl, and \uicontrol Alt.
\target mnemonic
On certain widgets, using '&' in front of a character will
automatically create a mnemonic (a shortcut) for that character,
e.g. "E&xit" will create the shortcut \uicontrol Alt+X (use '&&' to
display an actual ampersand). The widget might consume and perform
an action on a given shortcut. On X11 the ampersand will not be
shown and the character will be underlined. On Windows, shortcuts
are normally not displayed until the user presses the \uicontrol Alt
key, but this is a setting the user can change. On Mac, shortcuts
are disabled by default. Call \l qt_set_sequence_auto_mnemonic() to
enable them. However, because mnemonic shortcuts do not fit in
with Aqua's guidelines, Qt will not show the shortcut character
underlined.
For applications that use menus, it may be more convenient to
use the convenience functions provided in the QMenu class to
assign keyboard shortcuts to menu items as they are created.
Alternatively, shortcuts may be associated with other types of
actions in the QAction class.
The simplest way to create a shortcut for a particular widget is
to construct the shortcut with a key sequence. For example:
\snippet code/src_gui_kernel_qshortcut.cpp 0
When the user types the \l{QKeySequence}{key sequence}
for a given shortcut, the shortcut's activated() signal is
emitted. (In the case of ambiguity, the activatedAmbiguously()
signal is emitted.) A shortcut is "listened for" by Qt's event
loop when the shortcut's parent widget is receiving events.
A shortcut's key sequence can be set with setKey() and retrieved
with key(). A shortcut can be enabled or disabled with
setEnabled(), and can have "What's This?" help text set with
setWhatsThis().
\sa QShortcutEvent, QKeySequence, QAction
*/
/*!
\fn QWidget *QShortcut::parentWidget() const
Returns the shortcut's parent widget.
*/
/*
\internal
Private data accessed through d-pointer.
*/
class QShortcutPrivate : public QGuiShortcutPrivate
class QtWidgetsShortcutPrivate : public QShortcutPrivate
{
Q_DECLARE_PUBLIC(QShortcut)
public:
QShortcutPrivate() = default;
QtWidgetsShortcutPrivate() = default;
QShortcutMap::ContextMatcher contextMatcher() const override
{ return qWidgetShortcutContextMatcher; }
bool handleWhatsThis() override;
QString sc_whatsthis;
};
bool QShortcutPrivate::handleWhatsThis()
bool QtWidgetsShortcutPrivate::handleWhatsThis()
{
#if QT_CONFIG(whatsthis)
const bool result = QWhatsThis::inWhatsThisMode();
if (result)
if (QWhatsThis::inWhatsThisMode()) {
QWhatsThis::showText(QCursor::pos(), sc_whatsthis);
return result;
#else
return false;
return true;
}
#endif
return false;
}
/*!
Constructs a QShortcut object for the \a parent widget. Since no
shortcut key sequence is specified, the shortcut will not emit any
signals.
\sa setKey()
*/
QShortcut::QShortcut(QWidget *parent)
: QGuiShortcut(*new QShortcutPrivate, parent)
QShortcutPrivate *QApplicationPrivate::createShortcutPrivate() const
{
return new QtWidgetsShortcutPrivate;
}
/*!
Constructs a QShortcut object for the \a parent widget. The shortcut
operates on its parent, listening for \l{QShortcutEvent}s that
match the \a key sequence. Depending on the ambiguity of the
event, the shortcut will call the \a member function, or the \a
ambiguousMember function, if the key press was in the shortcut's
\a shortcutContext.
*/
QShortcut::QShortcut(const QKeySequence &key, QWidget *parent,
const char *member, const char *ambiguousMember,
Qt::ShortcutContext shortcutContext)
: QGuiShortcut(*new QShortcutPrivate, key, parent, member, ambiguousMember, shortcutContext)
{
}
/*!
\fn template<typename Functor>
QShortcut(const QKeySequence &key, QWidget *parent,
Functor functor,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
\since 5.15
\overload
This is a QShortcut convenience constructor which connects the shortcut's
\l{QShortcut::activated()}{activated()} signal to the \a functor.
*/
/*!
\fn template<typename Functor>
QShortcut(const QKeySequence &key, QWidget *parent,
const QObject *context, Functor functor,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
\since 5.15
\overload
This is a QShortcut convenience constructor which connects the shortcut's
\l{QShortcut::activated()}{activated()} signal to the \a functor.
The \a functor can be a pointer to a member function of the \a context object.
If the \a context object is destroyed, the \a functor will not be called.
*/
/*!
\fn template<typename Functor, typename FunctorAmbiguous>
QShortcut(const QKeySequence &key, QWidget *parent,
const QObject *context1, Functor functor,
FunctorAmbiguous functorAmbiguous,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
\since 5.15
\overload
This is a QShortcut convenience constructor which connects the shortcut's
\l{QShortcut::activated()}{activated()} signal to the \a functor and
\l{QShortcut::activatedAmbiguously()}{activatedAmbiguously()}
signal to the \a FunctorAmbiguous.
The \a functor and \a FunctorAmbiguous can be a pointer to a member
function of the \a context object.
If the \a context object is destroyed, the \a functor and
\a FunctorAmbiguous will not be called.
*/
/*!
\fn template<typename Functor, typename FunctorAmbiguous>
QShortcut(const QKeySequence &key, QWidget *parent,
const QObject *context1, Functor functor,
const QObject *context2, FunctorAmbiguous functorAmbiguous,
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
\since 5.15
\overload
This is a QShortcut convenience constructor which connects the shortcut's
\l{QShortcut::activated()}{activated()} signal to the \a functor and
\l{QShortcut::activatedAmbiguously()}{activatedAmbiguously()}
signal to the \a FunctorAmbiguous.
The \a functor can be a pointer to a member function of the
\a context1 object.
The \a FunctorAmbiguous can be a pointer to a member function of the
\a context2 object.
If the \a context1 object is destroyed, the \a functor will not be called.
If the \a context2 object is destroyed, the \a FunctorAmbiguous
will not be called.
*/
/*!
\property QShortcut::whatsThis
\brief the shortcut's "What's This?" help text
The text will be shown when the application is in "What's
This?" mode and the user types the shortcut key() sequence.
To set "What's This?" help on a menu item (with or without a
shortcut key), set the help on the item's action.
By default, this property contains an empty string.
\sa QWhatsThis::inWhatsThisMode(), QAction::setWhatsThis()
*/
void QShortcut::setWhatsThis(const QString &text)
{
Q_D(QShortcut);
d->sc_whatsthis = text;
}
QString QShortcut::whatsThis() const
{
Q_D(const QShortcut);
return d->sc_whatsthis;
}
/*!
Destroys the shortcut.
*/
QShortcut::~QShortcut() = default;
QT_END_NAMESPACE

4
tests/auto/gui/kernel/kernel.pro
View File

@ -11,7 +11,6 @@ SUBDIRS=\
qguieventdispatcher \
qguieventloop \
qguimetatype \
qguishortcut \
qguitimer \
qguivariant \
qhighdpiscaling \
@ -22,6 +21,7 @@ SUBDIRS=\
qmouseevent_modal \
qpalette \
qscreen \
qshortcut \
qsurfaceformat \
qtouchevent \
qwindow \
@ -34,7 +34,7 @@ win32:!winrt:qtHaveModule(network): SUBDIRS += noqteventloop
!qtConfig(shortcut): SUBDIRS -= \
qkeysequence \
qguishortcut \
qshortcut \
qguimetatype \
qguivariant

4
tests/auto/gui/kernel/qguishortcut/qguishortcut.pro
View File

@ -1,4 +0,0 @@
CONFIG += testcase
TARGET = tst_qguishortcut
QT += testlib
SOURCES += tst_qguishortcut.cpp

12
tests/auto/gui/kernel/qshortcut/CMakeLists.txt Normal file
View File

@ -0,0 +1,12 @@
# Generated from qshortcut.pro.
#####################################################################
## tst_qshortcut Test:
#####################################################################
add_qt_test(tst_qshortcut
SOURCES
tst_qshortcut.cpp
PUBLIC_LIBRARIES
Qt::Gui
)

4
tests/auto/gui/kernel/qshortcut/qshortcut.pro Normal file
View File

@ -0,0 +1,4 @@
CONFIG += testcase
TARGET = tst_qshortcut
QT += testlib
SOURCES += tst_qshortcut.cpp

12
tests/auto/gui/kernel/qguishortcut/tst_qguishortcut.cpp → tests/auto/gui/kernel/qshortcut/tst_qshortcut.cpp
View File

@ -28,13 +28,13 @@
#include <QtTest/QtTest>
#include <QtGui/qguiapplication.h>
#include <QtGui/qguishortcut.h>
#include <QtGui/qshortcut.h>
#include <QtGui/qpainter.h>
#include <QtGui/qrasterwindow.h>
#include <QtGui/qscreen.h>
#include <QtGui/qwindow.h>
class tst_QGuiShortcut : public QObject
class tst_QShortcut : public QObject
{
Q_OBJECT
public:
@ -66,17 +66,17 @@ static void sendKey(QWindow *target, Qt::Key k, char c, Qt::KeyboardModifiers mo
QTest::sendKeyEvent(QTest::Release, target, k, c, modifiers);
}
void tst_QGuiShortcut::trigger()
void tst_QShortcut::trigger()
{
ColoredWindow w(Qt::yellow);
w.setTitle(QTest::currentTestFunction());
w.resize(QGuiApplication::primaryScreen()->size() / 4);
new QGuiShortcut(Qt::CTRL + Qt::Key_Q, &w, SLOT(close()));
new QShortcut(Qt::CTRL + Qt::Key_Q, &w, SLOT(close()));
w.show();
QVERIFY(QTest::qWaitForWindowExposed(&w));
sendKey(&w, Qt::Key_Q, 'q', Qt::ControlModifier);
QTRY_VERIFY(!w.isVisible());
}
QTEST_MAIN(tst_QGuiShortcut)
#include "tst_qguishortcut.moc"
QTEST_MAIN(tst_QShortcut)
#include "tst_qshortcut.moc"