Revision control
Copy as Markdown
// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qquickcontextmenu_p.h"
#include <QtCore/qpointer.h>
#include <QtCore/qloggingcategory.h>
#include <QtQml/qqmlcomponent.h>
#include <QtQml/qqmlinfo.h>
#include <QtQuick/qquickwindow.h>
#include <QtQuick/private/qquickitem_p.h>
#include <QtQuickTemplates2/private/qquickdeferredexecute_p_p.h>
#include <QtQuickTemplates2/private/qquickmenu_p.h>
#include <QtQuickTemplates2/private/qquickmenu_p_p.h>
#include <QtQuickTemplates2/private/qquicktextarea_p.h>
#include <QtQuickTemplates2/private/qquicktextfield_p.h>
QT_BEGIN_NAMESPACE
Q_STATIC_LOGGING_CATEGORY(lcContextMenu, "qt.quick.controls.contextmenu")
/*!
\qmltype ContextMenu
\brief The ContextMenu attached type provides a way to open a context menu
in a platform-appropriate manner.
\inqmlmodule QtQuick.Controls
\ingroup qtquickcontrols-menus
\since 6.9
ContextMenu can be attached to any \l {QQuickItem}{item} in order to show a context menu
upon a platform-specific event, such as a right click or the context menu
key.
\snippet qtquickcontrols-contextmenu.qml root
\section1 Sharing context menus
It's possible to share a \l Menu amongst several attached context menu
objects. This allows reusing a single Menu when the items that need
context menus have data in common. For example:
\snippet qtquickcontrols-contextmenu-shared.qml file
\section1 Performance
ContextMenu lazily creates its \c Menu only when it's requested. If it
wasn't for this optimization, the \c Menu would be created when the
containing component is being loaded, which is typically at application
startup.
It is recommended not to give the \c Menu assigned to ContextMenu's \l menu
property an id when it's defined where it's assigned. Doing so prevents
this optimization. For example:
\snippet qtquickcontrols-contextmenu-id.qml root
The example in the \l {Sharing context menus} section works because the
\c Menu is defined separately from its assignment.
\section1 Interaction with other menus
If a \c Menu is opened via e.g. a \l TapHandler or other means, ContextMenu
will not open at the same time. This allows legacy applications that were
written before ContextMenu was introduced to continue working as expected.
\section1 Native menu support
ContextMenu is backed by a native menu on iOS.
\note if you assign your own \l menu, you must set
\l {Popup::popupType}{popupType} to \c {Popup.Native} to ensure native menu
support.
*/
/*!
\qmlsignal QtQuick.Controls::ContextMenu::requested(point position)
This signal is emitted when a context menu is requested.
If it was requested by a right mouse button click, \a position gives the
position of the click relative to the parent.
The example below shows how to programmatically open a context menu:
\snippet qtquickcontrols-contextmenu-onrequested.qml buttonAndMenu
If no menu is set, but this signal is connected, the context menu event
will be accepted and will not propagate.
\sa QContextMenuEvent::pos()
*/
class QQuickContextMenuPrivate : public QObjectPrivate
{
public:
Q_DECLARE_PUBLIC(QQuickContextMenu)
static QQuickContextMenuPrivate *get(QQuickContextMenu *attachedObject)
{
return attachedObject->d_func();
}
void cancelMenu();
void executeMenu(bool complete = false);
bool isRequestedSignalConnected();
QQuickDeferredPointer<QQuickMenu> menu;
bool complete = false;
};
static const QString menuPropertyName = QStringLiteral("menu");
void QQuickContextMenuPrivate::cancelMenu()
{
Q_Q(QQuickContextMenu);
quickCancelDeferred(q, menuPropertyName);
}
void QQuickContextMenuPrivate::executeMenu(bool complete)
{
Q_Q(QQuickContextMenu);
if (menu.wasExecuted())
return;
QQmlEngine *engine = nullptr;
auto *parentItem = qobject_cast<QQuickItem *>(q->parent());
if (parentItem) {
engine = qmlEngine(parentItem);
// In most cases, the above line will work, but if it doesn't,
// it could be because we're attached to the contentItem of the window.
// In that case, we'll be created before the contentItem has a context
// and hence an engine. However, the window will have one, so use that.
if (!engine)
engine = qmlEngine(parentItem->window());
}
if (!menu || complete)
quickBeginAttachedDeferred(q, menuPropertyName, menu, engine);
if (complete)
quickCompleteAttachedDeferred(q, menuPropertyName, menu, engine);
}
bool QQuickContextMenuPrivate::isRequestedSignalConnected()
{
Q_Q(QQuickContextMenu);
IS_SIGNAL_CONNECTED(q, QQuickContextMenu, requested, (QPointF));
}
QQuickContextMenu::QQuickContextMenu(QObject *parent)
: QObject(*(new QQuickContextMenuPrivate), parent)
{
Q_ASSERT(parent);
if (parent->isQuickItemType()) {
auto *itemPriv = QQuickItemPrivate::get(static_cast<QQuickItem *>(parent));
Q_ASSERT(itemPriv);
if (QObject *oldMenu = itemPriv->setContextMenu(this))
qCWarning(lcContextMenu) << this << "replaced" << oldMenu << "on" << parent;
} else {
qmlWarning(parent) << "ContextMenu must be attached to an Item";
}
}
QQuickContextMenu *QQuickContextMenu::qmlAttachedProperties(QObject *object)
{
return new QQuickContextMenu(object);
}
/*!
\qmlproperty Menu QtQuick.Controls::ContextMenu::menu
This property holds the context menu that will be opened. It can be set to
any \l Menu object.
\note The \l Menu assigned to this property cannot be given an id. See
\l {Sharing context menus} for more information.
*/
QQuickMenu *QQuickContextMenu::menu() const
{
auto *d = const_cast<QQuickContextMenuPrivate *>(d_func());
if (!d->menu) {
qCDebug(lcContextMenu) << "creating menu via deferred execution"
<< "- is component complete:" << d->complete;
d->executeMenu(d->complete);
}
return d->menu;
}
void QQuickContextMenu::setMenu(QQuickMenu *menu)
{
Q_D(QQuickContextMenu);
if (!parent()->isQuickItemType())
return;
if (menu == d->menu)
return;
if (!d->menu.isExecuting())
d->cancelMenu();
d->menu = menu;
if (!d->menu.isExecuting())
emit menuChanged();
}
void QQuickContextMenu::classBegin()
{
}
void QQuickContextMenu::componentComplete()
{
Q_D(QQuickContextMenu);
d->complete = true;
}
bool QQuickContextMenu::event(QEvent *event)
{
Q_D(QQuickContextMenu);
switch (event->type()) {
case QEvent::ContextMenu: {
qCDebug(lcContextMenu) << this << "handling" << event << "on behalf of" << parent();
auto *attacheeItem = qobject_cast<QQuickItem *>(parent());
Q_ASSERT(attacheeItem);
const auto *contextMenuEvent = static_cast<QContextMenuEvent *>(event);
const QPoint posRelativeToParent(attacheeItem->mapFromScene(contextMenuEvent->pos()).toPoint());
const bool isRequestedSignalConnected = d->isRequestedSignalConnected();
if (isRequestedSignalConnected)
Q_EMIT requested(posRelativeToParent);
auto *menu = this->menu();
if (!menu) {
if (isRequestedSignalConnected) {
qCDebug(lcContextMenu) << this << "no menu instance but accepting event anyway"
<< "since requested signal has connections";
event->accept();
return true;
}
// No menu set and requested isn't connected; let the event propagate
// onwards and do nothing.
return QObject::event(event);
}
// On platforms like iOS, we want to use the native edit menu.
// TODO: test this on Android and desktop platforms (with popupType: Popup.Native)
if (menu && QQuickMenuPrivate::get(menu)->resolvedPopupType() == QQuickPopup::Native
&& (qobject_cast<const QQuickTextField *>(attacheeItem)
|| qobject_cast<const QQuickTextArea *>(attacheeItem))) {
QQuickMenuPrivate::get(menu)->makeEditMenu();
}
menu->setParentItem(attacheeItem);
qCDebug(lcContextMenu) << this << "showing" << menu << "at" << posRelativeToParent;
menu->popup(posRelativeToParent);
event->accept();
return true;
}
default:
break;
}
return QObject::event(event);
}
QT_END_NAMESPACE
#include "moc_qquickcontextmenu_p.cpp"