diff options
Diffstat (limited to 'src/quicktemplates2')
99 files changed, 4888 insertions, 530 deletions
diff --git a/src/quicktemplates2/qquickabstractbutton.cpp b/src/quicktemplates2/qquickabstractbutton.cpp index e819f355..23b73200 100644 --- a/src/quicktemplates2/qquickabstractbutton.cpp +++ b/src/quicktemplates2/qquickabstractbutton.cpp @@ -37,6 +37,8 @@ #include "qquickabstractbutton_p.h" #include "qquickabstractbutton_p_p.h" #include "qquickbuttongroup_p.h" +#include "qquickaction_p.h" +#include "qquickaction_p_p.h" #include <QtGui/qstylehints.h> #include <QtGui/qguiapplication.h> @@ -63,6 +65,56 @@ static const int AUTO_REPEAT_INTERVAL = 100; radio buttons and check boxes. As an abstract control, it has no delegate implementations, leaving them to the types that derive from it. + \section2 Button Icons + + AbstractButton provides the following properties through which icons can + be set: + + \list + \li \l icon.name + \li \l icon.source + \li \l icon.width + \li \l icon.height + \li \l icon.color + \endlist + + For applications that target platforms that support both + \l {QIcon::fromTheme()}{theme icons} and regular icons, + both \l icon.name and \l icon.source can be set to ensure that an icon will + always be found. If the icon is found in the theme, it will always be used; + even if \l icon.source is also set. If the icon is not found, + \l icon.source will be used instead. + + \code + Button { + icon.name: "edit-cut" + icon.source: "qrc:/icons/edit-cut.png" + } + \endcode + + Each \l {Styling Qt Quick Controls 2}{style} sets a default icon size and + color according to their guidelines, but it is possible to override these + by setting the \l icon.width, \l icon.height, and \l icon.color properties. + + The image that is loaded by an icon whose \c width and \c height are not set + depends on the type of icon in use. For theme icons, the closest available + size will be chosen. For regular icons, the behavior is the same as the + \l {Image::}{sourceSize} property of \l Image. + + The icon color is specified by default so that it matches the text color in + different states. In order to use an icon with the original colors, set the + color to \c "transparent". + + \code + Button { + icon.color: "transparent" + icon.source: "qrc:/icons/logo.png" + } + \endcode + + The \l display property can be used to control how the icon and text are + displayed within the button. + \sa ButtonGroup, {Button Controls} */ @@ -126,7 +178,9 @@ QQuickAbstractButtonPrivate::QQuickAbstractButtonPrivate() repeatTimer(0), pressButtons(Qt::NoButton), indicator(nullptr), - group(nullptr) + group(nullptr), + display(QQuickAbstractButton::TextBesideIcon), + action(nullptr) { } @@ -173,7 +227,7 @@ void QQuickAbstractButtonPrivate::handleRelease(const QPointF &point) if (wasPressed) { emit q->released(); if (!wasHeld) - emit q->clicked(); + trigger(); } else { emit q->canceled(); } @@ -249,6 +303,22 @@ void QQuickAbstractButtonPrivate::stopPressRepeat() } } +void QQuickAbstractButtonPrivate::click() +{ + Q_Q(QQuickAbstractButton); + if (effectiveEnable) + emit q->clicked(); +} + +void QQuickAbstractButtonPrivate::trigger() +{ + Q_Q(QQuickAbstractButton); + if (action && action->isEnabled()) + action->trigger(q); // -> click() + else if (effectiveEnable) + emit q->clicked(); +} + void QQuickAbstractButtonPrivate::toggle(bool value) { Q_Q(QQuickAbstractButton); @@ -453,6 +523,8 @@ void QQuickAbstractButton::setChecked(bool checked) setCheckable(true); d->checked = checked; + if (d->action) + d->action->setChecked(checked); setAccessibleProperty("checked", checked); buttonChange(ButtonCheckedChange); emit checkedChanged(); @@ -486,6 +558,8 @@ void QQuickAbstractButton::setCheckable(bool checkable) return; d->checkable = checkable; + if (d->action) + d->action->setCheckable(checkable); setAccessibleProperty("checkable", checkable); buttonChange(ButtonCheckableChange); emit checkableChanged(); @@ -566,6 +640,142 @@ void QQuickAbstractButton::setIndicator(QQuickItem *indicator) } /*! + \qmlpropertygroup QtQuick.Controls::AbstractButton::icon + \qmlproperty string QtQuick.Controls::AbstractButton::icon.name + \qmlproperty url QtQuick.Controls::AbstractButton::icon.source + \qmlproperty int QtQuick.Controls::AbstractButton::icon.width + \qmlproperty int QtQuick.Controls::AbstractButton::icon.height + \qmlproperty color QtQuick.Controls::AbstractButton::icon.color + + This property group was added in QtQuick.Controls 2.3. + + \include qquickicon.qdocinc grouped-properties + + \sa {Button Icons} +*/ + +QQuickIcon QQuickAbstractButton::icon() const +{ + Q_D(const QQuickAbstractButton); + return d->icon; +} + +void QQuickAbstractButton::setIcon(const QQuickIcon &icon) +{ + Q_D(QQuickAbstractButton); + if (d->icon == icon) + return; + + d->icon = icon; + emit iconChanged(); +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty enumeration QtQuick.Controls::AbstractButton::display + + This property determines how the \l icon and \l text are displayed within + the button. + + \table + \header \li Display \li Result + \row \li \c AbstractButton.IconOnly \li \image qtquickcontrols2-button-icononly.png + \row \li \c AbstractButton.TextOnly \li \image qtquickcontrols2-button-textonly.png + \row \li \c AbstractButton.TextBesideIcon \li \image qtquickcontrols2-button-textbesideicon.png + \endtable + + \sa {Control::}{spacing}, {Control::}{padding} +*/ +QQuickAbstractButton::Display QQuickAbstractButton::display() const +{ + Q_D(const QQuickAbstractButton); + return d->display; +} + +void QQuickAbstractButton::setDisplay(Display display) +{ + Q_D(QQuickAbstractButton); + if (display == d->display) + return; + + d->display = display; + emit displayChanged(); +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty Action QtQuick.Controls::AbstractButton::action + + This property holds the button action. + + \sa Action +*/ +QQuickAction *QQuickAbstractButton::action() const +{ + Q_D(const QQuickAbstractButton); + return d->action; +} + +void QQuickAbstractButton::setAction(QQuickAction *action) +{ + Q_D(QQuickAbstractButton); + if (d->action == action) + return; + + if (QQuickAction *oldAction = d->action.data()) { + QQuickActionPrivate::get(oldAction)->unregisterItem(this); + QObjectPrivate::disconnect(oldAction, &QQuickAction::triggered, d, &QQuickAbstractButtonPrivate::click); + + disconnect(oldAction, &QQuickAction::textChanged, this, &QQuickAbstractButton::setText); + disconnect(oldAction, &QQuickAction::iconChanged, this, &QQuickAbstractButton::setIcon); + disconnect(oldAction, &QQuickAction::checkedChanged, this, &QQuickAbstractButton::setChecked); + disconnect(oldAction, &QQuickAction::checkableChanged, this, &QQuickAbstractButton::setCheckable); + disconnect(oldAction, &QQuickAction::enabledChanged, this, &QQuickItem::setEnabled); + } + + if (action) { + QQuickActionPrivate::get(action)->registerItem(this); + QObjectPrivate::connect(action, &QQuickAction::triggered, d, &QQuickAbstractButtonPrivate::click); + + connect(action, &QQuickAction::textChanged, this, &QQuickAbstractButton::setText); + connect(action, &QQuickAction::iconChanged, this, &QQuickAbstractButton::setIcon); + connect(action, &QQuickAction::checkedChanged, this, &QQuickAbstractButton::setChecked); + connect(action, &QQuickAction::checkableChanged, this, &QQuickAbstractButton::setCheckable); + connect(action, &QQuickAction::enabledChanged, this, &QQuickItem::setEnabled); + + QQuickIcon actionIcon = action->icon(); + + QString name = actionIcon.name(); + if (!name.isEmpty()) + d->icon.setName(name); + + QUrl source = actionIcon.source(); + if (!source.isEmpty()) + d->icon.setSource(source); + + int width = actionIcon.width(); + if (width > 0) + d->icon.setWidth(width); + + int height = actionIcon.height(); + if (height) + d->icon.setHeight(height); + + QColor color = actionIcon.color(); + if (color != Qt::transparent) + d->icon.setColor(color); + + setText(action->text()); + setChecked(action->isChecked()); + setCheckable(action->isCheckable()); + setEnabled(action->isEnabled()); + } + + d->action = action; + emit actionChanged(); +} + +/*! \qmlmethod void QtQuick.Controls::AbstractButton::toggle() Toggles the checked state of the button. @@ -609,7 +819,7 @@ void QQuickAbstractButton::keyReleaseEvent(QKeyEvent *event) nextCheckState(); emit released(); - emit clicked(); + d->trigger(); if (d->autoRepeat) d->stopPressRepeat(); @@ -642,7 +852,7 @@ void QQuickAbstractButton::timerEvent(QTimerEvent *event) d->startPressRepeat(); } else if (event->timerId() == d->repeatTimer) { emit released(); - emit clicked(); + d->trigger(); emit pressed(); } } diff --git a/src/quicktemplates2/qquickabstractbutton_p.h b/src/quicktemplates2/qquickabstractbutton_p.h index 72038ee4..25827c9f 100644 --- a/src/quicktemplates2/qquickabstractbutton_p.h +++ b/src/quicktemplates2/qquickabstractbutton_p.h @@ -49,9 +49,11 @@ // #include <QtQuickTemplates2/private/qquickcontrol_p.h> +#include <QtQuickTemplates2/private/qquickicon_p.h> QT_BEGIN_NAMESPACE +class QQuickAction; class QQuickAbstractButtonPrivate; class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickAbstractButton : public QQuickControl @@ -64,6 +66,9 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickAbstractButton : public QQuickContr Q_PROPERTY(bool checkable READ isCheckable WRITE setCheckable NOTIFY checkableChanged FINAL) Q_PROPERTY(bool autoExclusive READ autoExclusive WRITE setAutoExclusive NOTIFY autoExclusiveChanged FINAL) Q_PROPERTY(QQuickItem *indicator READ indicator WRITE setIndicator NOTIFY indicatorChanged FINAL) + Q_PROPERTY(QQuickIcon icon READ icon WRITE setIcon NOTIFY iconChanged FINAL REVISION 3) + Q_PROPERTY(Display display READ display WRITE setDisplay NOTIFY displayChanged FINAL REVISION 3) + Q_PROPERTY(QQuickAction *action READ action WRITE setAction NOTIFY actionChanged FINAL REVISION 3) public: explicit QQuickAbstractButton(QQuickItem *parent = nullptr); @@ -94,6 +99,23 @@ public: QQuickItem *indicator() const; void setIndicator(QQuickItem *indicator); + QQuickIcon icon() const; + void setIcon(const QQuickIcon &icon); + + enum Display { + IconOnly, + TextOnly, + TextBesideIcon, + TextUnderIcon + }; + Q_ENUM(Display) + + Display display() const; + void setDisplay(Display display); + + QQuickAction *action() const; + void setAction(QQuickAction *action); + public Q_SLOTS: void toggle(); @@ -112,6 +134,9 @@ Q_SIGNALS: void checkableChanged(); void autoExclusiveChanged(); void indicatorChanged(); + Q_REVISION(3) void iconChanged(); + Q_REVISION(3) void displayChanged(); + Q_REVISION(3) void actionChanged(); protected: QQuickAbstractButton(QQuickAbstractButtonPrivate &dd, QQuickItem *parent); diff --git a/src/quicktemplates2/qquickabstractbutton_p_p.h b/src/quicktemplates2/qquickabstractbutton_p_p.h index 39af6896..f1fef5e5 100644 --- a/src/quicktemplates2/qquickabstractbutton_p_p.h +++ b/src/quicktemplates2/qquickabstractbutton_p_p.h @@ -53,6 +53,7 @@ QT_BEGIN_NAMESPACE +class QQuickAction; class QQuickButtonGroup; class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickAbstractButtonPrivate : public QQuickControlPrivate @@ -83,6 +84,8 @@ public: QQuickAbstractButton *findCheckedButton() const; QList<QQuickAbstractButton *> findExclusiveButtons() const; + void click(); + void trigger(); void toggle(bool value); QString text; @@ -98,10 +101,13 @@ public: int holdTimer; int delayTimer; int repeatTimer; + QQuickIcon icon; QPointF pressPoint; Qt::MouseButtons pressButtons; QQuickItem *indicator; QQuickButtonGroup *group; + QQuickAbstractButton::Display display; + QPointer<QQuickAction> action; }; QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquickaction.cpp b/src/quicktemplates2/qquickaction.cpp new file mode 100644 index 00000000..fb6d7c3e --- /dev/null +++ b/src/quicktemplates2/qquickaction.cpp @@ -0,0 +1,553 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the Qt Quick Templates 2 module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** 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 http://www.qt.io/terms-conditions. For further +** information use the contact form at http://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.LGPLv3 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.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 later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qquickaction_p.h" +#include "qquickaction_p_p.h" +#include "qquickactiongroup_p.h" +#include "qquickshortcutcontext_p_p.h" + +#include <QtGui/qevent.h> +#include <QtGui/private/qshortcutmap_p.h> +#include <QtGui/private/qguiapplication_p.h> +#include <QtQuick/private/qquickitem_p.h> + +QT_BEGIN_NAMESPACE + +/*! + \qmltype Action + \inherits QtObject + \instantiates QQuickAction + \inqmlmodule QtQuick.Controls + \since 5.10 + \ingroup utilities + \brief Abstract user interface action. + + Action represents an abstract user interface action that can have shortcuts + and can be assigned to menu items and toolbar buttons. + + Actions may contain \l text, an \l icon, and a \l shortcut. Actions are normally + \l triggered by the user via menu items, toolbar buttons, or keyboard shortcuts. + A \l checkable Action toggles its \l checked state when triggered. + + \snippet qtquickcontrols2-action.qml action + + Action is commonly used to implement application commands that can be invoked + via menu items, toolbar buttons, and keyboard shortcuts. Since the user expects + the commands to be performed in the same way, regardless of the user interface + used, it is useful to represent the commands as shareable actions. + + Action can be also used to separate the logic and the visual presentation. For + example, when declaring buttons and menu items in \c .ui.qml files, actions can + be declared elsewhere and assigned from the outside. + + \snippet qtquickcontrols2-action.qml toolbutton + + When an action is paired with buttons and menu items, the \c enabled, \c checkable, + and \c checked states are synced automatically. For example, in a word processor, + if the user clicks a "Bold" toolbar button, the "Bold" menu item will automatically + be checked. Buttons and menu items get their \c text and \c icon from the action by + default. An action-specific \c text or \c icon can be overridden for a specific + control by specifying \c text or \c icon directly on the control. + + \snippet qtquickcontrols2-action.qml menuitem + + Since Action presents a user interface action, it is intended to be assigned to + a \l MenuItem, \l ToolButton, or any other control that inherits \l AbstractButton. + For keyboard shortcuts, the simpler \l Shortcut type is more appropriate. + + \sa MenuItem, ToolButton, Shortcut +*/ + +/*! + \qmlsignal QtQuick.Controls::Action::toggled(QtObject source) + + This signal is emitted when the action is toggled. The \a source argument + identifies the object that toggled the action. + + For example, if the action is assigned to a menu item and a toolbar button, the + action is toggled when the control is toggled, the shortcut is activated, or + when \l toggle() is called directly. +*/ + +/*! + \qmlsignal QtQuick.Controls::Action::triggered(QtObject source) + + This signal is emitted when the action is triggered. The \a source argument + identifies the object that triggered the action. + + For example, if the action is assigned to a menu item and a toolbar button, the + action is triggered when the control is clicked, the shortcut is activated, or + when \l trigger() is called directly. +*/ + +static QKeySequence variantToKeySequence(const QVariant &var) +{ + if (var.type() == QVariant::Int) + return QKeySequence(static_cast<QKeySequence::StandardKey>(var.toInt())); + return QKeySequence::fromString(var.toString()); +} + +QQuickActionPrivate::ShortcutEntry::ShortcutEntry(QObject *target) + : m_shortcutId(0), + m_target(target) +{ +} + +QQuickActionPrivate::ShortcutEntry::~ShortcutEntry() +{ + ungrab(); +} + +QObject *QQuickActionPrivate::ShortcutEntry::target() const +{ + return m_target; +} + +int QQuickActionPrivate::ShortcutEntry::shortcutId() const +{ + return m_shortcutId; +} + +void QQuickActionPrivate::ShortcutEntry::grab(const QKeySequence &shortcut, bool enabled) +{ + if (shortcut.isEmpty()) + return; + + Qt::ShortcutContext context = Qt::WindowShortcut; // TODO + m_shortcutId = QGuiApplicationPrivate::instance()->shortcutMap.addShortcut(m_target, shortcut, context, QQuickShortcutContext::matcher); + + if (!enabled) + QGuiApplicationPrivate::instance()->shortcutMap.setShortcutEnabled(false, m_shortcutId, m_target); +} + +void QQuickActionPrivate::ShortcutEntry::ungrab() +{ + if (!m_shortcutId) + return; + + QGuiApplicationPrivate::instance()->shortcutMap.removeShortcut(m_shortcutId, m_target); + m_shortcutId = 0; +} + +void QQuickActionPrivate::ShortcutEntry::setEnabled(bool enabled) +{ + if (!m_shortcutId) + return; + + QGuiApplicationPrivate::instance()->shortcutMap.setShortcutEnabled(enabled, m_shortcutId, m_target); +} + +QQuickActionPrivate::QQuickActionPrivate() + : explicitEnabled(false), + enabled(true), + checked(false), + checkable(false), + defaultShortcutEntry(nullptr), + group(nullptr) +{ +} + +QVariant QQuickActionPrivate::shortcut() const +{ + return vshortcut; +} + +void QQuickActionPrivate::setShortcut(const QVariant &var) +{ + Q_Q(QQuickAction); + if (vshortcut == var) + return; + + defaultShortcutEntry->ungrab(); + for (QQuickActionPrivate::ShortcutEntry *entry : qAsConst(shortcutEntries)) + entry->ungrab(); + + vshortcut = var.toString(); + keySequence = variantToKeySequence(var); + + defaultShortcutEntry->grab(keySequence, enabled); + for (QQuickActionPrivate::ShortcutEntry *entry : qAsConst(shortcutEntries)) + entry->grab(keySequence, enabled); + + emit q->shortcutChanged(keySequence); +} + +void QQuickActionPrivate::setEnabled(bool enable) +{ + Q_Q(QQuickAction); + if (enabled == enable) + return; + + enabled = enable; + + defaultShortcutEntry->setEnabled(enable); + for (QQuickActionPrivate::ShortcutEntry *entry : qAsConst(shortcutEntries)) + entry->setEnabled(enable); + + emit q->enabledChanged(enable); +} + +bool QQuickActionPrivate::watchItem(QQuickItem *item) +{ + Q_Q(QQuickAction); + if (!item) + return false; + + item->installEventFilter(q); + QQuickItemPrivate::get(item)->addItemChangeListener(this, QQuickItemPrivate::Visibility | QQuickItemPrivate::Destroyed); + return true; +} + +bool QQuickActionPrivate::unwatchItem(QQuickItem *item) +{ + Q_Q(QQuickAction); + if (!item) + return false; + + item->removeEventFilter(q); + QQuickItemPrivate::get(item)->removeItemChangeListener(this, QQuickItemPrivate::Visibility | QQuickItemPrivate::Destroyed); + return true; +} + +void QQuickActionPrivate::registerItem(QQuickItem *item) +{ + if (!watchItem(item)) + return; + + QQuickActionPrivate::ShortcutEntry *entry = new QQuickActionPrivate::ShortcutEntry(item); + if (item->isVisible()) + entry->grab(keySequence, enabled); + shortcutEntries += entry; + + updateDefaultShortcutEntry(); +} + +void QQuickActionPrivate::unregisterItem(QQuickItem *item) +{ + QQuickActionPrivate::ShortcutEntry *entry = findShortcutEntry(item); + if (!entry || !unwatchItem(item)) + return; + + shortcutEntries.removeOne(entry); + delete entry; + + updateDefaultShortcutEntry(); +} + +void QQuickActionPrivate::itemVisibilityChanged(QQuickItem *item) +{ + QQuickActionPrivate::ShortcutEntry *entry = findShortcutEntry(item); + if (!entry) + return; + + if (item->isVisible()) + entry->grab(keySequence, enabled); + else + entry->ungrab(); + + updateDefaultShortcutEntry(); +} + +void QQuickActionPrivate::itemDestroyed(QQuickItem *item) +{ + unregisterItem(item); +} + +bool QQuickActionPrivate::handleShortcutEvent(QObject *object, QShortcutEvent *event) +{ + Q_Q(QQuickAction); + if (event->key() != keySequence) + return false; + + QQuickActionPrivate::ShortcutEntry *entry = findShortcutEntry(object); + if (!entry || event->shortcutId() != entry->shortcutId()) + return false; + + q->trigger(entry->target()); + return true; +} + +QQuickActionPrivate::ShortcutEntry *QQuickActionPrivate::findShortcutEntry(QObject *target) const +{ + Q_Q(const QQuickAction); + if (target == q) + return defaultShortcutEntry; + for (QQuickActionPrivate::ShortcutEntry *entry : shortcutEntries) { + if (entry->target() == target) + return entry; + } + return nullptr; +} + +void QQuickActionPrivate::updateDefaultShortcutEntry() +{ + bool hasActiveShortcutEntries = false; + for (QQuickActionPrivate::ShortcutEntry *entry : qAsConst(shortcutEntries)) { + if (entry->shortcutId()) { + hasActiveShortcutEntries = true; + break; + } + } + + if (hasActiveShortcutEntries) + defaultShortcutEntry->ungrab(); + else if (!defaultShortcutEntry->shortcutId()) + defaultShortcutEntry->grab(keySequence, enabled); +} + +QQuickAction::QQuickAction(QObject *parent) + : QObject(*(new QQuickActionPrivate), parent) +{ + Q_D(QQuickAction); + d->defaultShortcutEntry = new QQuickActionPrivate::ShortcutEntry(this); +} + +QQuickAction::~QQuickAction() +{ + Q_D(QQuickAction); + if (d->group) + d->group->removeAction(this); + + for (QQuickActionPrivate::ShortcutEntry *entry : qAsConst(d->shortcutEntries)) + d->unwatchItem(qobject_cast<QQuickItem *>(entry->target())); + + qDeleteAll(d->shortcutEntries); + delete d->defaultShortcutEntry; +} + +/*! + \qmlproperty string QtQuick.Controls::Action::text + + This property holds a textual description of the action. +*/ +QString QQuickAction::text() const +{ + Q_D(const QQuickAction); + return d->text; +} + +void QQuickAction::setText(const QString &text) +{ + Q_D(QQuickAction); + if (d->text == text) + return; + + d->text = text; + emit textChanged(text); +} + +/*! + \qmlpropertygroup QtQuick.Controls::Action::icon + \qmlproperty string QtQuick.Controls::Action::icon.name + \qmlproperty url QtQuick.Controls::Action::icon.source + \qmlproperty int QtQuick.Controls::Action::icon.width + \qmlproperty int QtQuick.Controls::Action::icon.height + \qmlproperty color QtQuick.Controls::Action::icon.color + + \include qquickicon.qdocinc grouped-properties +*/ +QQuickIcon QQuickAction::icon() const +{ + Q_D(const QQuickAction); + return d->icon; +} + +void QQuickAction::setIcon(const QQuickIcon &icon) +{ + Q_D(QQuickAction); + if (d->icon == icon) + return; + + d->icon = icon; + emit iconChanged(icon); +} + +/*! + \qmlproperty bool QtQuick.Controls::Action::enabled + + This property holds whether the action is enabled. The default value is \c true. +*/ +bool QQuickAction::isEnabled() const +{ + Q_D(const QQuickAction); + return d->enabled && (!d->group || d->group->isEnabled()); +} + +void QQuickAction::setEnabled(bool enabled) +{ + Q_D(QQuickAction); + d->explicitEnabled = true; + d->setEnabled(enabled); +} + +void QQuickAction::resetEnabled() +{ + Q_D(QQuickAction); + if (!d->explicitEnabled) + return; + + d->explicitEnabled = false; + d->setEnabled(true); +} + +/*! + \qmlproperty bool QtQuick.Controls::Action::checked + + This property holds whether the action is checked. + + \sa checkable +*/ +bool QQuickAction::isChecked() const +{ + Q_D(const QQuickAction); + return d->checked; +} + +void QQuickAction::setChecked(bool checked) +{ + Q_D(QQuickAction); + if (d->checked == checked) + return; + + d->checked = checked; + emit checkedChanged(checked); +} + +/*! + \qmlproperty bool QtQuick.Controls::Action::checkable + + This property holds whether the action is checkable. The default value is \c false. + + A checkable action toggles between checked (on) and unchecked (off) when triggered. + + \sa checked +*/ +bool QQuickAction::isCheckable() const +{ + Q_D(const QQuickAction); + return d->checkable; +} + +void QQuickAction::setCheckable(bool checkable) +{ + Q_D(QQuickAction); + if (d->checkable == checkable) + return; + + d->checkable = checkable; + emit checkableChanged(checkable); +} + +/*! + \qmlproperty keysequence QtQuick.Controls::Action::shortcut + + This property holds the action's shortcut. The key sequence can be set + to one of the \l{QKeySequence::StandardKey}{standard keyboard shortcuts}, + or it can be described with a string containing a sequence of up to four + key presses that are needed to trigger the shortcut. + + \code + Action { + sequence: "Ctrl+E,Ctrl+W" + onTriggered: edit.wrapMode = TextEdit.Wrap + } + \endcode +*/ +QKeySequence QQuickAction::shortcut() const +{ + Q_D(const QQuickAction); + return d->keySequence; +} + +void QQuickAction::setShortcut(const QKeySequence &shortcut) +{ + Q_D(QQuickAction); + d->setShortcut(shortcut.toString()); +} + +/*! + \qmlmethod void QtQuick.Controls::Action::toggle(QtObject source = null) + + Toggles the action and emits \l toggled() if enabled, with an optional \a source object defined. +*/ +void QQuickAction::toggle(QObject *source) +{ + Q_D(QQuickAction); + if (!d->enabled) + return; + + if (d->checkable) + setChecked(!d->checked); + + emit toggled(source); +} + +/*! + \qmlmethod void QtQuick.Controls::Action::trigger(QtObject source = null) + + Triggers the action and emits \l triggered() if enabled, with an optional \a source object defined. +*/ +void QQuickAction::trigger(QObject *source) +{ + Q_D(QQuickAction); + if (!d->enabled) + return; + + if (d->checkable) + toggle(source); + + emit triggered(source); +} + +bool QQuickAction::event(QEvent *event) +{ + Q_D(QQuickAction); + if (event->type() != QEvent::Shortcut) + return QObject::event(event); + return d->handleShortcutEvent(this, static_cast<QShortcutEvent *>(event)); +} + +bool QQuickAction::eventFilter(QObject *object, QEvent *event) +{ + Q_D(QQuickAction); + if (event->type() != QEvent::Shortcut) + return false; + return d->handleShortcutEvent(object, static_cast<QShortcutEvent *>(event)); +} + +QT_END_NAMESPACE + +#include "moc_qquickaction_p.cpp" diff --git a/src/quicktemplates2/qquickaction_p.h b/src/quicktemplates2/qquickaction_p.h new file mode 100644 index 00000000..ce989bed --- /dev/null +++ b/src/quicktemplates2/qquickaction_p.h @@ -0,0 +1,122 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the Qt Quick Templates 2 module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** 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 http://www.qt.io/terms-conditions. For further +** information use the contact form at http://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.LGPLv3 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.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 later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQUICKACTION_P_H +#define QQUICKACTION_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtQuickTemplates2/private/qtquicktemplates2global_p.h> +#include <QtQuickTemplates2/private/qquickicon_p.h> +#include <QtCore/qobject.h> +#include <QtQml/qqml.h> + +QT_BEGIN_NAMESPACE + +class QQuickIcon; +class QQuickActionPrivate; + +class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickAction : public QObject +{ + Q_OBJECT + Q_PROPERTY(QString text READ text WRITE setText NOTIFY textChanged FINAL) + Q_PROPERTY(QQuickIcon icon READ icon WRITE setIcon NOTIFY iconChanged FINAL) + Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged RESET resetEnabled FINAL) + Q_PROPERTY(bool checked READ isChecked WRITE setChecked NOTIFY checkedChanged FINAL) + Q_PROPERTY(bool checkable READ isCheckable WRITE setCheckable NOTIFY checkableChanged FINAL) + Q_PRIVATE_PROPERTY(QQuickAction::d_func(), QVariant shortcut READ shortcut WRITE setShortcut NOTIFY shortcutChanged FINAL) + +public: + explicit QQuickAction(QObject *parent = nullptr); + ~QQuickAction(); + + QString text() const; + void setText(const QString &text); + + QQuickIcon icon() const; + void setIcon(const QQuickIcon &icon); + + bool isEnabled() const; + void setEnabled(bool enabled); + void resetEnabled(); + + bool isChecked() const; + void setChecked(bool checked); + + bool isCheckable() const; + void setCheckable(bool checkable); + + QKeySequence shortcut() const; + void setShortcut(const QKeySequence &shortcut); + +public Q_SLOTS: + void toggle(QObject *source = nullptr); + void trigger(QObject *source = nullptr); + +Q_SIGNALS: + void textChanged(const QString &text); + void iconChanged(const QQuickIcon &icon); + void enabledChanged(bool enabled); + void checkedChanged(bool checked); + void checkableChanged(bool checkable); + void shortcutChanged(const QKeySequence &shortcut); + + void toggled(QObject *source = nullptr); + void triggered(QObject *source = nullptr); + +protected: + bool event(QEvent *event) override; + bool eventFilter(QObject *object, QEvent *event) override; + +private: + Q_DISABLE_COPY(QQuickAction) + Q_DECLARE_PRIVATE(QQuickAction) +}; + +QT_END_NAMESPACE + +QML_DECLARE_TYPE(QQuickAction) + +#endif // QQUICKACTION_P_H diff --git a/src/quicktemplates2/qquickaction_p_p.h b/src/quicktemplates2/qquickaction_p_p.h new file mode 100644 index 00000000..08c442ed --- /dev/null +++ b/src/quicktemplates2/qquickaction_p_p.h @@ -0,0 +1,127 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the Qt Quick Templates 2 module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** 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 http://www.qt.io/terms-conditions. For further +** information use the contact form at http://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.LGPLv3 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.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 later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQUICKACTION_P_P_H +#define QQUICKACTION_P_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtCore/private/qobject_p.h> +#include <QtCore/qvariant.h> +#include <QtCore/qstring.h> +#include <QtGui/qkeysequence.h> +#include <QtQuick/private/qquickitemchangelistener_p.h> + +QT_BEGIN_NAMESPACE + +class QShortcutEvent; +class QQuickActionGroup; + +class QQuickActionPrivate : public QObjectPrivate, public QQuickItemChangeListener +{ + Q_DECLARE_PUBLIC(QQuickAction) + +public: + QQuickActionPrivate(); + + static QQuickActionPrivate *get(QQuickAction *action) + { + return action->d_func(); + } + + QVariant shortcut() const; + void setShortcut(const QVariant &shortcut); + + void setEnabled(bool enable); + + bool watchItem(QQuickItem *item); + bool unwatchItem(QQuickItem *item); + + void registerItem(QQuickItem *item); + void unregisterItem(QQuickItem *item); + + void itemVisibilityChanged(QQuickItem *item) override; + void itemDestroyed(QQuickItem *item) override; + + bool handleShortcutEvent(QObject *object, QShortcutEvent *event); + + class ShortcutEntry + { + public: + explicit ShortcutEntry(QObject *target); + ~ShortcutEntry(); + + QObject *target() const; + int shortcutId() const; + + void grab(const QKeySequence &vshortcut, bool enabled); + void ungrab(); + + void setEnabled(bool enabled); + + private: + int m_shortcutId; + QObject *m_target; + }; + + ShortcutEntry *findShortcutEntry(QObject *target) const; + void updateDefaultShortcutEntry(); + + bool explicitEnabled; + bool enabled; + bool checked; + bool checkable; + QString text; + QQuickIcon icon; + QVariant vshortcut; + QKeySequence keySequence; + ShortcutEntry *defaultShortcutEntry; + QVector<ShortcutEntry *> shortcutEntries; + QQuickActionGroup *group; +}; + +QT_END_NAMESPACE + +#endif // QQUICKACTION_P_P_H diff --git a/src/quicktemplates2/qquickactiongroup.cpp b/src/quicktemplates2/qquickactiongroup.cpp new file mode 100644 index 00000000..7a5e17ee --- /dev/null +++ b/src/quicktemplates2/qquickactiongroup.cpp @@ -0,0 +1,474 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the Qt Quick Templates 2 module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** 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 http://www.qt.io/terms-conditions. For further +** information use the contact form at http://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.LGPLv3 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.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 later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qquickactiongroup_p.h" + +#include <QtCore/private/qobject_p.h> +#include <QtCore/qmetaobject.h> +#include <QtCore/qvariant.h> +#include <QtQml/qqmlinfo.h> + +#include "qquickaction_p.h" +#include "qquickaction_p_p.h" + +QT_BEGIN_NAMESPACE + +/*! + \qmltype ActionGroup + \inherits QtObject + \instantiates QQuickActionGroup + \inqmlmodule QtQuick.Controls + \since 5.10 + \ingroup utilities + \brief Groups actions together. + + ActionGroup is a non-visual group of actions. A mutually \l exclusive + action group is used with actions where only one of the options can be + selected at a time. + + The most straight-forward way to use ActionGroup is to declare actions + as children of the group. + + \code + ActionGroup { + id: alignmentGroup + + Action { + checked: true + text: qsTr("Left") + } + + Action { + text: qsTr("Center") + } + + Action { + text: qsTr("Right") + } + } + \endcode + + Alternatively, the \l group attached property allows declaring the actions + elsewhere and assigning them to a specific group. + + \code + ActionGroup { id: alignmentGroup } + + Action { + checked: true + text: qsTr("Left") + ActionGroup.group: alignmentGroup + } + + Action { + text: qsTr("Center") + ActionGroup.group: alignmentGroup + } + + Action { + text: qsTr("Right") + ActionGroup.group: alignmentGroup + } + \endcode + + More advanced use cases can be handled using the \c addAction() and + \c removeAction() methods. + + \sa Action, ButtonGroup +*/ + +/*! + \qmlsignal QtQuick.Controls::ActionGroup::triggered(Action action) + + This signal is emitted when an \a action in the group has been triggered. + + This signal is convenient for implementing a common signal handler for + all actions in the same group. + + \code + ActionGroup { + onTriggered: console.log("triggered:", action.text) + + Action { text: "First" } + Action { text: "Second" } + Action { text: "Third" } + } + \endcode + + \sa Action::triggered() +*/ + +class QQuickActionGroupPrivate : public QObjectPrivate +{ + Q_DECLARE_PUBLIC(QQuickActionGroup) + +public: + QQuickActionGroupPrivate() + : enabled(true), + exclusive(true), + checkedAction(nullptr) + { + } + + void clear(); + void actionTriggered(); + void _q_updateCurrent(); + + static bool changeEnabled(QQuickAction *action, bool enabled); + + static void actions_append(QQmlListProperty<QQuickAction> *prop, QQuickAction *obj); + static int actions_count(QQmlListProperty<QQuickAction> *prop); + static QQuickAction *actions_at(QQmlListProperty<QQuickAction> *prop, int index); + static void actions_clear(QQmlListProperty<QQuickAction> *prop); + + bool enabled; + bool exclusive; + QQuickAction *checkedAction; + QVector<QQuickAction*> actions; +}; + +void QQuickActionGroupPrivate::clear() +{ + for (QQuickAction *action : qAsConst(actions)) { + QQuickActionPrivate::get(action)->group = nullptr; + QObjectPrivate::disconnect(action, &QQuickAction::triggered, this, &QQuickActionGroupPrivate::actionTriggered); + QObjectPrivate::disconnect(action, &QQuickAction::checkedChanged, this, &QQuickActionGroupPrivate::_q_updateCurrent); + } + actions.clear(); +} + +void QQuickActionGroupPrivate::actionTriggered() +{ + Q_Q(QQuickActionGroup); + QQuickAction *action = qobject_cast<QQuickAction*>(q->sender()); + if (action) + emit q->triggered(action); +} + +void QQuickActionGroupPrivate::_q_updateCurrent() +{ + Q_Q(QQuickActionGroup); + if (!exclusive) + return; + QQuickAction *action = qobject_cast<QQuickAction*>(q->sender()); + if (action && action->isChecked()) + q->setCheckedAction(action); + else if (!actions.contains(checkedAction)) + q->setCheckedAction(nullptr); +} + +bool QQuickActionGroupPrivate::changeEnabled(QQuickAction *action, bool enabled) +{ + return action->isEnabled() != enabled && (!enabled || !QQuickActionPrivate::get(action)->explicitEnabled); +} + +void QQuickActionGroupPrivate::actions_append(QQmlListProperty<QQuickAction> *prop, QQuickAction *obj) +{ + QQuickActionGroup *q = static_cast<QQuickActionGroup *>(prop->object); + q->addAction(obj); +} + +int QQuickActionGroupPrivate::actions_count(QQmlListProperty<QQuickAction> *prop) +{ + QQuickActionGroupPrivate *p = static_cast<QQuickActionGroupPrivate *>(prop->data); + return p->actions.count(); +} + +QQuickAction *QQuickActionGroupPrivate::actions_at(QQmlListProperty<QQuickAction> *prop, int index) +{ + QQuickActionGroupPrivate *p = static_cast<QQuickActionGroupPrivate *>(prop->data); + return p->actions.value(index); +} + +void QQuickActionGroupPrivate::actions_clear(QQmlListProperty<QQuickAction> *prop) +{ + QQuickActionGroupPrivate *p = static_cast<QQuickActionGroupPrivate *>(prop->data); + if (!p->actions.isEmpty()) { + p->clear(); + QQuickActionGroup *q = static_cast<QQuickActionGroup *>(prop->object); + // QTBUG-52358: don't clear the checked action immediately + QMetaObject::invokeMethod(q, "_q_updateCurrent", Qt::QueuedConnection); + emit q->actionsChanged(); + } +} + +QQuickActionGroup::QQuickActionGroup(QObject *parent) + : QObject(*(new QQuickActionGroupPrivate), parent) +{ +} + +QQuickActionGroup::~QQuickActionGroup() +{ + Q_D(QQuickActionGroup); + d->clear(); +} + +QQuickActionGroupAttached *QQuickActionGroup::qmlAttachedProperties(QObject *object) +{ + return new QQuickActionGroupAttached(object); +} + +/*! + \qmlproperty Action QtQuick.Controls::ActionGroup::checkedAction + + This property holds the currently selected action in an exclusive group, + or \c null if there is none or the group is non-exclusive. + + By default, it is the first checked action added to an exclusive action group. + + \sa exclusive +*/ +QQuickAction *QQuickActionGroup::checkedAction() const +{ + Q_D(const QQuickActionGroup); + return d->checkedAction; +} + +void QQuickActionGroup::setCheckedAction(QQuickAction *checkedAction) +{ + Q_D(QQuickActionGroup); + if (d->checkedAction == checkedAction) + return; + + if (d->checkedAction) + d->checkedAction->setChecked(false); + d->checkedAction = checkedAction; + if (checkedAction) + checkedAction->setChecked(true); + emit checkedActionChanged(); +} + +/*! + \qmlproperty list<Action> QtQuick.Controls::ActionGroup::actions + \default + + This property holds the list of actions in the group. + + \sa group +*/ +QQmlListProperty<QQuickAction> QQuickActionGroup::actions() +{ + Q_D(QQuickActionGroup); + return QQmlListProperty<QQuickAction>(this, d, + QQuickActionGroupPrivate::actions_append, + QQuickActionGroupPrivate::actions_count, + QQuickActionGroupPrivate::actions_at, + QQuickActionGroupPrivate::actions_clear); +} + +/*! + \qmlproperty bool QtQuick.Controls::ActionGroup::exclusive + + This property holds whether the action group is exclusive. The default value is \c true. + + If this property is \c true, then only one action in the group can be checked at any given time. + The user can trigger any action to check it, and that action will replace the existing one as + the checked action in the group. + + In an exclusive group, the user cannot uncheck the currently checked action by triggering it; + instead, another action in the group must be triggered to set the new checked action for that + group. + + In a non-exclusive group, checking and unchecking actions does not affect the other actions in + the group. Furthermore, the value of the \l checkedAction property is \c null. +*/ +bool QQuickActionGroup::isExclusive() const +{ + Q_D(const QQuickActionGroup); + return d->exclusive; +} + +void QQuickActionGroup::setExclusive(bool exclusive) +{ + Q_D(QQuickActionGroup); + if (d->exclusive == exclusive) + return; + + d->exclusive = exclusive; + emit exclusiveChanged(); +} + +/*! + \qmlproperty bool QtQuick.Controls::ActionGroup::enabled + + This property holds whether the action group is enabled. The default value is \c true. + + If this property is \c false, then all actions in the group are disabled. If this property + is \c true, all actions in the group are enabled, unless explicitly disabled. +*/ +bool QQuickActionGroup::isEnabled() const +{ + Q_D(const QQuickActionGroup); + return d->enabled; +} + +void QQuickActionGroup::setEnabled(bool enabled) +{ + Q_D(QQuickActionGroup); + if (d->enabled == enabled) + return; + + for (QQuickAction *action : qAsConst(d->actions)) { + if (d->changeEnabled(action, enabled)) + emit action->enabledChanged(enabled); + } + + d->enabled = enabled; + emit enabledChanged(); +} + +/*! + \qmlmethod void QtQuick.Controls::ActionGroup::addAction(Action action) + + Adds an \a action to the action group. + + \note Manually adding objects to a action group is typically unnecessary. + The \l actions property and the \l group attached property provide a + convenient and declarative syntax. + + \sa actions, group +*/ +void QQuickActionGroup::addAction(QQuickAction *action) +{ + Q_D(QQuickActionGroup); + if (!action || d->actions.contains(action)) + return; + + const bool enabledChange = d->changeEnabled(action, d->enabled); + + QQuickActionPrivate::get(action)->group = this; + QObjectPrivate::connect(action, &QQuickAction::triggered, d, &QQuickActionGroupPrivate::actionTriggered); + QObjectPrivate::connect(action, &QQuickAction::checkedChanged, d, &QQuickActionGroupPrivate::_q_updateCurrent); + + if (d->exclusive && action->isChecked()) + setCheckedAction(action); + if (enabledChange) + emit action->enabledChanged(action->isEnabled()); + + d->actions.append(action); + emit actionsChanged(); +} + +/*! + \qmlmethod void QtQuick.Controls::ActionGroup::removeAction(Action action) + + Removes an \a action from the action group. + + \note Manually removing objects from a action group is typically unnecessary. + The \l actions property and the \l group attached property provide a + convenient and declarative syntax. + + \sa actions, group +*/ +void QQuickActionGroup::removeAction(QQuickAction *action) +{ + Q_D(QQuickActionGroup); + if (!action || !d->actions.contains(action)) + return; + + const bool enabledChange = d->changeEnabled(action, d->enabled); + + QQuickActionPrivate::get(action)->group = nullptr; + QObjectPrivate::disconnect(action, &QQuickAction::triggered, d, &QQuickActionGroupPrivate::actionTriggered); + QObjectPrivate::disconnect(action, &QQuickAction::checkedChanged, d, &QQuickActionGroupPrivate::_q_updateCurrent); + + if (d->checkedAction == action) + setCheckedAction(nullptr); + if (enabledChange) + emit action->enabledChanged(action->isEnabled()); + + d->actions.removeOne(action); + emit actionsChanged(); +} + +class QQuickActionGroupAttachedPrivate : public QObjectPrivate +{ +public: + QQuickActionGroupAttachedPrivate() : group(nullptr) { } + + QQuickActionGroup *group; +}; + +QQuickActionGroupAttached::QQuickActionGroupAttached(QObject *parent) + : QObject(*(new QQuickActionGroupAttachedPrivate), parent) +{ +} + +/*! + \qmlattachedproperty ActionGroup QtQuick.Controls::ActionGroup::group + + This property attaches an action to an action group. + + \code + ActionGroup { id: group } + + Action { + checked: true + text: qsTr("Option A") + ActionGroup.group: group + } + + Action { + text: qsTr("Option B") + ActionGroup.group: group + } + \endcode + + \sa actions +*/ +QQuickActionGroup *QQuickActionGroupAttached::group() const +{ + Q_D(const QQuickActionGroupAttached); + return d->group; +} + +void QQuickActionGroupAttached::setGroup(QQuickActionGroup *group) +{ + Q_D(QQuickActionGroupAttached); + if (d->group == group) + return; + + if (d->group) + d->group->removeAction(qobject_cast<QQuickAction*>(parent())); + d->group = group; + if (group) + group->addAction(qobject_cast<QQuickAction*>(parent())); + emit groupChanged(); +} + +QT_END_NAMESPACE + +#include "moc_qquickactiongroup_p.cpp" diff --git a/src/quicktemplates2/qquickactiongroup_p.h b/src/quicktemplates2/qquickactiongroup_p.h new file mode 100644 index 00000000..42280831 --- /dev/null +++ b/src/quicktemplates2/qquickactiongroup_p.h @@ -0,0 +1,129 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the Qt Quick Templates 2 module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** 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 http://www.qt.io/terms-conditions. For further +** information use the contact form at http://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.LGPLv3 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.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 later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQUICKACTIONGROUP_P_H +#define QQUICKACTIONGROUP_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtCore/qobject.h> +#include <QtQuickTemplates2/private/qtquicktemplates2global_p.h> +#include <QtQml/qqml.h> + +QT_BEGIN_NAMESPACE + +class QQuickAction; +class QQuickActionGroupPrivate; +class QQuickActionGroupAttached; +class QQuickActionGroupAttachedPrivate; + +class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickActionGroup : public QObject +{ + Q_OBJECT + Q_PROPERTY(QQuickAction *checkedAction READ checkedAction WRITE setCheckedAction NOTIFY checkedActionChanged FINAL) + Q_PROPERTY(QQmlListProperty<QQuickAction> actions READ actions NOTIFY actionsChanged FINAL) + Q_PROPERTY(bool exclusive READ isExclusive WRITE setExclusive NOTIFY exclusiveChanged FINAL) + Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged FINAL) + +public: + explicit QQuickActionGroup(QObject *parent = nullptr); + ~QQuickActionGroup(); + + static QQuickActionGroupAttached *qmlAttachedProperties(QObject *object); + + QQuickAction *checkedAction() const; + void setCheckedAction(QQuickAction *checkedAction); + + QQmlListProperty<QQuickAction> actions(); + + bool isExclusive() const; + void setExclusive(bool exclusive); + + bool isEnabled() const; + void setEnabled(bool enabled); + +public Q_SLOTS: + void addAction(QQuickAction *action); + void removeAction(QQuickAction *action); + +Q_SIGNALS: + void checkedActionChanged(); + void actionsChanged(); + void exclusiveChanged(); + void enabledChanged(); + void triggered(QQuickAction *action); + +private: + Q_DISABLE_COPY(QQuickActionGroup) + Q_DECLARE_PRIVATE(QQuickActionGroup) + + Q_PRIVATE_SLOT(d_func(), void _q_updateCurrent()) +}; + +class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickActionGroupAttached : public QObject +{ + Q_OBJECT + Q_PROPERTY(QQuickActionGroup *group READ group WRITE setGroup NOTIFY groupChanged FINAL) + +public: + explicit QQuickActionGroupAttached(QObject *parent = nullptr); + + QQuickActionGroup *group() const; + void setGroup(QQuickActionGroup *group); + +Q_SIGNALS: + void groupChanged(); + +private: + Q_DISABLE_COPY(QQuickActionGroupAttached) + Q_DECLARE_PRIVATE(QQuickActionGroupAttached) +}; + +QT_END_NAMESPACE + +QML_DECLARE_TYPE(QQuickActionGroup) +QML_DECLARE_TYPEINFO(QQuickActionGroup, QML_HAS_ATTACHED_PROPERTIES) + +#endif // QQUICKACTIONGROUP_P_H diff --git a/src/quicktemplates2/qquickapplicationwindow.cpp b/src/quicktemplates2/qquickapplicationwindow.cpp index e3f16d55..a6523553 100644 --- a/src/quicktemplates2/qquickapplicationwindow.cpp +++ b/src/quicktemplates2/qquickapplicationwindow.cpp @@ -168,6 +168,14 @@ public: } void resolveFont(); + void updatePalette(const QPalette &p); + inline void setPalette_helper(const QPalette &p) { + if (palette.resolve() == p.resolve() && palette == p) + return; + updatePalette(p); + } + void resolvePalette(); + void _q_updateActiveFocus(); void setActiveFocusControl(QQuickItem *item); @@ -181,6 +189,7 @@ public: QQuickOverlay *overlay; QFont font; QLocale locale; + QPalette palette; QQuickItem *activeFocusControl; QQuickApplicationWindow *q_ptr; }; @@ -253,6 +262,52 @@ void QQuickApplicationWindowPrivate::itemImplicitHeightChanged(QQuickItem *item) relayout(); } +void QQuickApplicationWindowPrivate::updateFont(const QFont &f) +{ + Q_Q(QQuickApplicationWindow); + const bool changed = font != f; + font = f; + + QQuickControlPrivate::updateFontRecur(q->QQuickWindow::contentItem(), f); + + const QList<QQuickPopup *> popups = q->findChildren<QQuickPopup *>(); + for (QQuickPopup *popup : popups) + QQuickControlPrivate::get(static_cast<QQuickControl *>(popup->popupItem()))->inheritFont(f); + + if (changed) + emit q->fontChanged(); +} + +void QQuickApplicationWindowPrivate::resolveFont() +{ + QFont resolvedFont = font.resolve(QQuickControlPrivate::themeFont(QPlatformTheme::SystemFont)); + setFont_helper(resolvedFont); +} + +void QQuickApplicationWindowPrivate::updatePalette(const QPalette &p) +{ + Q_Q(QQuickApplicationWindow); + const bool changed = palette != p; + palette = p; + + QQuickItem *rootItem = q->QQuickWindow::contentItem(); + QQuickControlPrivate::updatePaletteRecur(rootItem, p); + + // TODO: internal QQuickPopupManager that provides reliable access to all QQuickPopup instances + const QList<QQuickPopup *> popups = rootItem->findChildren<QQuickPopup *>(); + for (QQuickPopup *popup : popups) + QQuickControlPrivate::get(static_cast<QQuickControl *>(popup->popupItem()))->inheritPalette(p); + + if (changed) + emit q->paletteChanged(); +} + +void QQuickApplicationWindowPrivate::resolvePalette() +{ + QPalette resolvedPalette = palette.resolve(QQuickControlPrivate::themePalette(QPlatformTheme::SystemPalette)); + setPalette_helper(resolvedPalette); +} + void QQuickApplicationWindowPrivate::_q_updateActiveFocus() { Q_Q(QQuickApplicationWindow); @@ -629,28 +684,6 @@ void QQuickApplicationWindow::resetFont() setFont(QFont()); } -void QQuickApplicationWindowPrivate::resolveFont() -{ - QFont resolvedFont = font.resolve(QQuickControlPrivate::themeFont(QPlatformTheme::SystemFont)); - setFont_helper(resolvedFont); -} - -void QQuickApplicationWindowPrivate::updateFont(const QFont &f) -{ - Q_Q(QQuickApplicationWindow); - const bool changed = font != f; - font = f; - - QQuickControlPrivate::updateFontRecur(q->QQuickWindow::contentItem(), f); - - const QList<QQuickPopup *> popups = q->findChildren<QQuickPopup *>(); - for (QQuickPopup *popup : popups) - QQuickControlPrivate::get(static_cast<QQuickControl *>(popup->popupItem()))->inheritFont(f); - - if (changed) - emit q->fontChanged(); -} - /*! \qmlproperty Locale QtQuick.Controls::ApplicationWindow::locale @@ -693,6 +726,43 @@ void QQuickApplicationWindow::resetLocale() setLocale(QLocale()); } +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty palette QtQuick.Controls::ApplicationWindow::palette + + This property holds the palette currently set for the window. + + The default palette depends on the system environment. QGuiApplication maintains a system/theme + palette which serves as a default for all application windows. You can also set the default palette + for windows by passing a custom palette to QGuiApplication::setPalette(), before loading any QML. + + ApplicationWindow propagates explicit palette properties to child controls. If you change a specific + property on the window's palette, that property propagates to all child controls in the window, + overriding any system defaults for that property. + + \sa Control::palette +*/ +QPalette QQuickApplicationWindow::palette() const +{ + Q_D(const QQuickApplicationWindow); + return d->palette; +} + +void QQuickApplicationWindow::setPalette(const QPalette &palette) +{ + Q_D(QQuickApplicationWindow); + if (d->palette.resolve() == palette.resolve() && d->palette == palette) + return; + + QPalette resolvedPalette = palette.resolve(QQuickControlPrivate::themePalette(QPlatformTheme::SystemPalette)); + d->setPalette_helper(resolvedPalette); +} + +void QQuickApplicationWindow::resetPalette() +{ + setPalette(QPalette()); +} + QQuickApplicationWindowAttached *QQuickApplicationWindow::qmlAttachedProperties(QObject *object) { return new QQuickApplicationWindowAttached(object); @@ -710,6 +780,7 @@ void QQuickApplicationWindow::classBegin() d->complete = false; QQuickWindowQmlImpl::classBegin(); d->resolveFont(); + d->resolvePalette(); } void QQuickApplicationWindow::componentComplete() diff --git a/src/quicktemplates2/qquickapplicationwindow_p.h b/src/quicktemplates2/qquickapplicationwindow_p.h index 07ddc67e..8747e70f 100644 --- a/src/quicktemplates2/qquickapplicationwindow_p.h +++ b/src/quicktemplates2/qquickapplicationwindow_p.h @@ -51,6 +51,7 @@ #include <QtQuick/private/qquickwindowmodule_p.h> #include <QtQuickTemplates2/private/qtquicktemplates2global_p.h> #include <QtGui/qfont.h> +#include <QtGui/qpalette.h> #include <QtCore/qlocale.h> QT_BEGIN_NAMESPACE @@ -72,6 +73,7 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickApplicationWindow : public QQuickWi Q_PROPERTY(QQuickOverlay *overlay READ overlay CONSTANT FINAL) Q_PROPERTY(QFont font READ font WRITE setFont RESET resetFont NOTIFY fontChanged FINAL) Q_PROPERTY(QLocale locale READ locale WRITE setLocale RESET resetLocale NOTIFY localeChanged FINAL) + Q_PROPERTY(QPalette palette READ palette WRITE setPalette RESET resetPalette NOTIFY paletteChanged FINAL REVISION 3) Q_CLASSINFO("DefaultProperty", "contentData") public: @@ -102,6 +104,10 @@ public: void setLocale(const QLocale &locale); void resetLocale(); + QPalette palette() const; + void setPalette(const QPalette &palette); + void resetPalette(); + static QQuickApplicationWindowAttached *qmlAttachedProperties(QObject *object); Q_SIGNALS: @@ -111,6 +117,7 @@ Q_SIGNALS: void footerChanged(); void fontChanged(); void localeChanged(); + Q_REVISION(3) void paletteChanged(); protected: bool isComponentComplete() const; diff --git a/src/quicktemplates2/qquickbutton.cpp b/src/quicktemplates2/qquickbutton.cpp index 1a614754..b5a8ac1c 100644 --- a/src/quicktemplates2/qquickbutton.cpp +++ b/src/quicktemplates2/qquickbutton.cpp @@ -77,6 +77,9 @@ QT_BEGIN_NAMESPACE } \endcode + In addition to displaying \l {AbstractButton::}{text}, buttons can also + display an \l [QML]{Button Icons}{icon}. + \sa {Customizing Button}, {Button Controls} */ @@ -119,6 +122,11 @@ QFont QQuickButton::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::PushButtonFont); } +QPalette QQuickButton::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::ButtonPalette); +} + /*! \qmlproperty bool QtQuick.Controls::Button::highlighted diff --git a/src/quicktemplates2/qquickbutton_p.h b/src/quicktemplates2/qquickbutton_p.h index 93fb3c14..f1a34b10 100644 --- a/src/quicktemplates2/qquickbutton_p.h +++ b/src/quicktemplates2/qquickbutton_p.h @@ -81,6 +81,7 @@ protected: void buttonChange(ButtonChange change) override; QFont defaultFont() const override; + QPalette defaultPalette() const override; private: Q_DISABLE_COPY(QQuickButton) diff --git a/src/quicktemplates2/qquickbuttongroup.cpp b/src/quicktemplates2/qquickbuttongroup.cpp index f0813a17..ef35440f 100644 --- a/src/quicktemplates2/qquickbuttongroup.cpp +++ b/src/quicktemplates2/qquickbuttongroup.cpp @@ -154,7 +154,11 @@ class QQuickButtonGroupPrivate : public QObjectPrivate Q_DECLARE_PUBLIC(QQuickButtonGroup) public: - QQuickButtonGroupPrivate() : checkedButton(nullptr) { } + QQuickButtonGroupPrivate() + : exclusive(true), + checkedButton(nullptr) + { + } void clear(); void buttonClicked(); @@ -165,6 +169,7 @@ public: static QQuickAbstractButton *buttons_at(QQmlListProperty<QQuickAbstractButton> *prop, int index); static void buttons_clear(QQmlListProperty<QQuickAbstractButton> *prop); + bool exclusive; QQuickAbstractButton *checkedButton; QVector<QQuickAbstractButton*> buttons; }; @@ -190,6 +195,8 @@ void QQuickButtonGroupPrivate::buttonClicked() void QQuickButtonGroupPrivate::_q_updateCurrent() { Q_Q(QQuickButtonGroup); + if (!exclusive) + return; QQuickAbstractButton *button = qobject_cast<QQuickAbstractButton*>(q->sender()); if (button && button->isChecked()) q->setCheckedButton(button); @@ -246,9 +253,12 @@ QQuickButtonGroupAttached *QQuickButtonGroup::qmlAttachedProperties(QObject *obj /*! \qmlproperty AbstractButton QtQuick.Controls::ButtonGroup::checkedButton - This property holds the currently selected button, or \c null if there is none. + This property holds the currently selected button in an exclusive group, + or \c null if there is none or the group is non-exclusive. + + By default, it is the first checked button added to an exclusive button group. - By default, it is the first checked button added to the button group. + \sa exclusive */ QQuickAbstractButton *QQuickButtonGroup::checkedButton() const { @@ -308,6 +318,38 @@ QQmlListProperty<QQuickAbstractButton> QQuickButtonGroup::buttons() } /*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::ButtonGroup::exclusive + + This property holds whether the button group is exclusive. The default value is \c true. + + If this property is \c true, then only one button in the group can be checked at any given time. + The user can click on any button to check it, and that button will replace the existing one as + the checked button in the group. + + In an exclusive group, the user cannot uncheck the currently checked button by clicking on it; + instead, another button in the group must be clicked to set the new checked button for that group. + + In a non-exclusive group, checking and unchecking buttons does not affect the other buttons in + the group. Furthermore, the value of the \l checkedButton property is \c null. +*/ +bool QQuickButtonGroup::isExclusive() const +{ + Q_D(const QQuickButtonGroup); + return d->exclusive; +} + +void QQuickButtonGroup::setExclusive(bool exclusive) +{ + Q_D(QQuickButtonGroup); + if (d->exclusive == exclusive) + return; + + d->exclusive = exclusive; + emit exclusiveChanged(); +} + +/*! \qmlmethod void QtQuick.Controls::ButtonGroup::addButton(AbstractButton button) Adds a \a button to the button group. @@ -328,7 +370,7 @@ void QQuickButtonGroup::addButton(QQuickAbstractButton *button) QObjectPrivate::connect(button, &QQuickAbstractButton::clicked, d, &QQuickButtonGroupPrivate::buttonClicked); QObjectPrivate::connect(button, &QQuickAbstractButton::checkedChanged, d, &QQuickButtonGroupPrivate::_q_updateCurrent); - if (button->isChecked()) + if (d->exclusive && button->isChecked()) setCheckedButton(button); d->buttons.append(button); diff --git a/src/quicktemplates2/qquickbuttongroup_p.h b/src/quicktemplates2/qquickbuttongroup_p.h index 21deb035..cd46d8f7 100644 --- a/src/quicktemplates2/qquickbuttongroup_p.h +++ b/src/quicktemplates2/qquickbuttongroup_p.h @@ -62,8 +62,9 @@ class QQuickButtonGroupAttachedPrivate; class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickButtonGroup : public QObject { Q_OBJECT - Q_PROPERTY(QQuickAbstractButton *checkedButton READ checkedButton WRITE setCheckedButton NOTIFY checkedButtonChanged) + Q_PROPERTY(QQuickAbstractButton *checkedButton READ checkedButton WRITE setCheckedButton NOTIFY checkedButtonChanged FINAL) Q_PROPERTY(QQmlListProperty<QQuickAbstractButton> buttons READ buttons NOTIFY buttonsChanged FINAL) + Q_PROPERTY(bool exclusive READ isExclusive WRITE setExclusive NOTIFY exclusiveChanged FINAL REVISION 3) public: explicit QQuickButtonGroup(QObject *parent = nullptr); @@ -76,6 +77,9 @@ public: QQmlListProperty<QQuickAbstractButton> buttons(); + bool isExclusive() const; + void setExclusive(bool exclusive); + public Q_SLOTS: void addButton(QQuickAbstractButton *button); void removeButton(QQuickAbstractButton *button); @@ -83,6 +87,7 @@ public Q_SLOTS: Q_SIGNALS: void checkedButtonChanged(); void buttonsChanged(); + Q_REVISION(3) void exclusiveChanged(); Q_REVISION(1) void clicked(QQuickAbstractButton *button); private: diff --git a/src/quicktemplates2/qquickcheckbox.cpp b/src/quicktemplates2/qquickcheckbox.cpp index e0c7faf1..2e0c401a 100644 --- a/src/quicktemplates2/qquickcheckbox.cpp +++ b/src/quicktemplates2/qquickcheckbox.cpp @@ -174,6 +174,11 @@ QFont QQuickCheckBox::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::CheckBoxFont); } +QPalette QQuickCheckBox::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::CheckBoxPalette); +} + void QQuickCheckBox::buttonChange(ButtonChange change) { if (change == ButtonCheckedChange) diff --git a/src/quicktemplates2/qquickcheckbox_p.h b/src/quicktemplates2/qquickcheckbox_p.h index dfd935d3..979f096b 100644 --- a/src/quicktemplates2/qquickcheckbox_p.h +++ b/src/quicktemplates2/qquickcheckbox_p.h @@ -75,6 +75,7 @@ Q_SIGNALS: protected: QFont defaultFont() const override; + QPalette defaultPalette() const override; void buttonChange(ButtonChange change) override; void nextCheckState() override; diff --git a/src/quicktemplates2/qquickcombobox.cpp b/src/quicktemplates2/qquickcombobox.cpp index d987182c..a6f9f6ca 100644 --- a/src/quicktemplates2/qquickcombobox.cpp +++ b/src/quicktemplates2/qquickcombobox.cpp @@ -37,6 +37,7 @@ #include "qquickcombobox_p.h" #include "qquickcontrol_p_p.h" #include "qquickabstractbutton_p.h" +#include "qquickabstractbutton_p_p.h" #include "qquickpopup_p_p.h" #include <QtCore/qregexp.h> @@ -50,6 +51,7 @@ #include <QtQml/private/qqmldelegatemodel_p.h> #include <QtQuick/private/qquickevents_p_p.h> #include <QtQuick/private/qquicktextinput_p.h> +#include <QtQuick/private/qquickitemview_p.h> QT_BEGIN_NAMESPACE @@ -221,6 +223,7 @@ public: void popupVisibleChanged(); void itemClicked(); + void itemHovered(); void createdItem(int index, QObject *object); void modelUpdated(); @@ -253,6 +256,7 @@ public: bool hasDown; bool pressed; bool ownModel; + bool keyNavigating; bool hasDisplayText; bool hasCurrentIndex; int highlightedIndex; @@ -291,6 +295,7 @@ QQuickComboBoxPrivate::QQuickComboBoxPrivate() hasDown(false), pressed(false), ownModel(false), + keyNavigating(false), hasDisplayText(false), hasCurrentIndex(false), highlightedIndex(-1), @@ -341,7 +346,15 @@ void QQuickComboBoxPrivate::popupVisibleChanged() if (isPopupVisible()) QGuiApplication::inputMethod()->reset(); + QQuickItemView *itemView = popup->findChild<QQuickItemView *>(); + if (itemView) + itemView->setHighlightRangeMode(QQuickItemView::NoHighlightRange); + updateHighlightedIndex(); + + if (itemView) + itemView->positionViewAtIndex(highlightedIndex, QQuickItemView::Beginning); + if (!hasDown) { q->setDown(pressed || isPopupVisible()); hasDown = false; @@ -358,6 +371,25 @@ void QQuickComboBoxPrivate::itemClicked() } } +void QQuickComboBoxPrivate::itemHovered() +{ + Q_Q(QQuickComboBox); + if (keyNavigating) + return; + + QQuickAbstractButton *button = qobject_cast<QQuickAbstractButton *>(q->sender()); + if (!button || !button->isHovered() || QQuickAbstractButtonPrivate::get(button)->touchId != -1) + return; + + int index = delegateModel->indexOf(button, nullptr); + if (index != -1) { + setHighlightedIndex(index, Highlight); + + if (QQuickItemView *itemView = popup->findChild<QQuickItemView *>()) + itemView->positionViewAtIndex(index, QQuickItemView::Contain); + } +} + void QQuickComboBoxPrivate::createdItem(int index, QObject *object) { Q_Q(QQuickComboBox); @@ -371,6 +403,7 @@ void QQuickComboBoxPrivate::createdItem(int index, QObject *object) if (button) { button->setFocusPolicy(Qt::NoFocus); connect(button, &QQuickAbstractButton::clicked, this, &QQuickComboBoxPrivate::itemClicked); + connect(button, &QQuickAbstractButton::hoveredChanged, this, &QQuickComboBoxPrivate::itemHovered); } if (index == currentIndex && !q->isEditable()) @@ -1163,6 +1196,9 @@ void QQuickComboBox::setPopup(QQuickPopup *popup) QQuickPopupPrivate::get(popup)->allowVerticalFlip = true; popup->setClosePolicy(QQuickPopup::CloseOnEscape | QQuickPopup::CloseOnPressOutsideParent); QObjectPrivate::connect(popup, &QQuickPopup::visibleChanged, d, &QQuickComboBoxPrivate::popupVisibleChanged); + + if (QQuickItemView *itemView = popup->findChild<QQuickItemView *>()) + itemView->setHighlightRangeMode(QQuickItemView::NoHighlightRange); } d->popup = popup; emit popupChanged(); @@ -1454,14 +1490,17 @@ void QQuickComboBox::keyPressEvent(QKeyEvent *event) event->accept(); break; case Qt::Key_Up: + d->keyNavigating = true; d->decrementCurrentIndex(); event->accept(); break; case Qt::Key_Down: + d->keyNavigating = true; d->incrementCurrentIndex(); event->accept(); break; case Qt::Key_Home: + d->keyNavigating = true; if (d->isPopupVisible()) d->setHighlightedIndex(0, Highlight); else @@ -1469,6 +1508,7 @@ void QQuickComboBox::keyPressEvent(QKeyEvent *event) event->accept(); break; case Qt::Key_End: + d->keyNavigating = true; if (d->isPopupVisible()) d->setHighlightedIndex(count() - 1, Highlight); else @@ -1488,6 +1528,8 @@ void QQuickComboBox::keyReleaseEvent(QKeyEvent *event) { Q_D(QQuickComboBox); QQuickControl::keyReleaseEvent(event); + + d->keyNavigating = false; if (!d->popup || event->isAutoRepeat()) return; @@ -1588,6 +1630,11 @@ QFont QQuickComboBox::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::ComboMenuItemFont); } +QPalette QQuickComboBox::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::ComboBoxPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickComboBox::accessibleRole() const { diff --git a/src/quicktemplates2/qquickcombobox_p.h b/src/quicktemplates2/qquickcombobox_p.h index 851392aa..ce9ff17e 100644 --- a/src/quicktemplates2/qquickcombobox_p.h +++ b/src/quicktemplates2/qquickcombobox_p.h @@ -192,6 +192,7 @@ protected: void localeChange(const QLocale &newLocale, const QLocale &oldLocale) override; QFont defaultFont() const override; + QPalette defaultPalette() const override; #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; diff --git a/src/quicktemplates2/qquickcontainer.cpp b/src/quicktemplates2/qquickcontainer.cpp index 6177d200..9b8298c2 100644 --- a/src/quicktemplates2/qquickcontainer.cpp +++ b/src/quicktemplates2/qquickcontainer.cpp @@ -253,13 +253,17 @@ void QQuickContainerPrivate::insertItem(int index, QQuickItem *item) q->itemAdded(index, item); - if (contentModel->count() == 1 && currentIndex == -1) + int count = contentModel->count(); + for (int i = index + 1; i < count; ++i) + q->itemMoved(i, itemAt(i)); + + if (count == 1 && currentIndex == -1) q->setCurrentIndex(index); updatingCurrent = false; } -void QQuickContainerPrivate::moveItem(int from, int to) +void QQuickContainerPrivate::moveItem(int from, int to, QQuickItem *item) { Q_Q(QQuickContainer); int oldCurrent = currentIndex; @@ -267,6 +271,16 @@ void QQuickContainerPrivate::moveItem(int from, int to) updatingCurrent = true; + q->itemMoved(to, item); + + if (from < to) { + for (int i = from; i < to; ++i) + q->itemMoved(i, itemAt(i)); + } else { + for (int i = from; i > to; --i) + q->itemMoved(i, itemAt(i)); + } + if (from == oldCurrent) q->setCurrentIndex(to); else if (from < oldCurrent && to >= oldCurrent) @@ -300,6 +314,10 @@ void QQuickContainerPrivate::removeItem(int index, QQuickItem *item) q->itemRemoved(index, item); + int count = contentModel->count(); + for (int i = index; i < count; ++i) + q->itemMoved(i, itemAt(i)); + if (currentChanged) emit q->currentIndexChanged(); @@ -476,7 +494,7 @@ void QQuickContainer::insertItem(int index, QQuickItem *item) if (oldIndex < index) --index; if (oldIndex != index) - d->moveItem(oldIndex, index); + d->moveItem(oldIndex, index, item); } else { d->insertItem(index, item); } @@ -497,26 +515,65 @@ void QQuickContainer::moveItem(int from, int to) to = count - 1; if (from != to) - d->moveItem(from, to); + d->moveItem(from, to, d->itemAt(from)); } /*! + \deprecated \qmlmethod void QtQuick.Controls::Container::removeItem(int index) - Removes an item at \a index. + Use Container::removeItem(Item) or Container::takeItem(int) instead. +*/ +void QQuickContainer::removeItem(const QVariant &var) +{ + if (var.userType() == QMetaType::Nullptr) + return; + + if (QQuickItem *item = var.value<QQuickItem *>()) + removeItem(item); + else + takeItem(var.toInt()); +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlmethod void QtQuick.Controls::Container::removeItem(Item item) + + Removes and destroys the specified \a item. +*/ +void QQuickContainer::removeItem(QQuickItem *item) +{ + Q_D(QQuickContainer); + if (!item) + return; + + const int index = d->contentModel->indexOf(item, nullptr); + if (index == -1) + return; + + d->removeItem(index, item); + item->deleteLater(); +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlmethod Item QtQuick.Controls::Container::takeItem(int index) + + Removes and returns the item at \a index. \note The ownership of the item is transferred to the caller. */ -void QQuickContainer::removeItem(int index) +QQuickItem *QQuickContainer::takeItem(int index) { Q_D(QQuickContainer); const int count = d->contentModel->count(); if (index < 0 || index >= count) - return; + return nullptr; QQuickItem *item = itemAt(index); if (item) d->removeItem(index, item); + return item; } /*! @@ -735,6 +792,12 @@ void QQuickContainer::itemAdded(int index, QQuickItem *item) Q_UNUSED(item); } +void QQuickContainer::itemMoved(int index, QQuickItem *item) +{ + Q_UNUSED(index); + Q_UNUSED(item); +} + void QQuickContainer::itemRemoved(int index, QQuickItem *item) { Q_UNUSED(index); diff --git a/src/quicktemplates2/qquickcontainer_p.h b/src/quicktemplates2/qquickcontainer_p.h index 6db45589..5ac585c2 100644 --- a/src/quicktemplates2/qquickcontainer_p.h +++ b/src/quicktemplates2/qquickcontainer_p.h @@ -75,7 +75,9 @@ public: Q_INVOKABLE void addItem(QQuickItem *item); Q_INVOKABLE void insertItem(int index, QQuickItem *item); Q_INVOKABLE void moveItem(int from, int to); - Q_INVOKABLE void removeItem(int index); + Q_INVOKABLE void removeItem(const QVariant &item); // ### Qt 6: remove + void removeItem(QQuickItem *item); // ### Qt 6: Q_INVOKABLE + Q_REVISION(3) Q_INVOKABLE QQuickItem *takeItem(int index); QVariant contentModel() const; QQmlListProperty<QObject> contentData(); @@ -103,6 +105,7 @@ protected: virtual bool isContent(QQuickItem *item) const; virtual void itemAdded(int index, QQuickItem *item); + virtual void itemMoved(int index, QQuickItem *item); virtual void itemRemoved(int index, QQuickItem *item); private: diff --git a/src/quicktemplates2/qquickcontainer_p_p.h b/src/quicktemplates2/qquickcontainer_p_p.h index 38c6b3e4..cbc04f9a 100644 --- a/src/quicktemplates2/qquickcontainer_p_p.h +++ b/src/quicktemplates2/qquickcontainer_p_p.h @@ -66,7 +66,7 @@ public: QQuickItem *itemAt(int index) const; void insertItem(int index, QQuickItem *item); - void moveItem(int from, int to); + void moveItem(int from, int to, QQuickItem *item); void removeItem(int index, QQuickItem *item); void _q_currentIndexChanged(); diff --git a/src/quicktemplates2/qquickcontrol.cpp b/src/quicktemplates2/qquickcontrol.cpp index fb6c17f7..dca50244 100644 --- a/src/quicktemplates2/qquickcontrol.cpp +++ b/src/quicktemplates2/qquickcontrol.cpp @@ -130,8 +130,7 @@ QQuickControlPrivate::QQuickControlPrivate() focusPolicy(Qt::NoFocus), focusReason(Qt::OtherFocusReason), background(nullptr), - contentItem(nullptr), - accessibleAttached(nullptr) + contentItem(nullptr) { #if QT_CONFIG(accessibility) QAccessible::installActivationObserver(this); @@ -316,29 +315,6 @@ QAccessible::Role QQuickControlPrivate::accessibleRole() const Q_Q(const QQuickControl); return q->accessibleRole(); } - -QAccessible::Role QQuickControl::accessibleRole() const -{ - return QAccessible::NoRole; -} - -void QQuickControl::accessibilityActiveChanged(bool active) -{ - Q_D(QQuickControl); - if (d->accessibleAttached || !active) - return; - - d->accessibleAttached = qobject_cast<QQuickAccessibleAttached *>(qmlAttachedPropertiesObject<QQuickAccessibleAttached>(this, true)); - - // QQuickControl relies on the existence of a QQuickAccessibleAttached object. - // However, qmlAttachedPropertiesObject(create=true) creates an instance only - // for items that have been created by a QML engine. Therefore we create the - // object by hand for items created in C++ (QQuickPopupItem, for instance). - if (!d->accessibleAttached) - d->accessibleAttached = new QQuickAccessibleAttached(this); - - d->accessibleAttached->setRole(accessibleRole()); -} #endif /*! @@ -397,11 +373,11 @@ void QQuickControlPrivate::resolveFont() inheritFont(parentFont(q)); } -void QQuickControlPrivate::inheritFont(const QFont &f) +void QQuickControlPrivate::inheritFont(const QFont &font) { Q_Q(QQuickControl); - QFont parentFont = extra.isAllocated() ? extra->font.resolve(f) : f; - parentFont.resolve(extra.isAllocated() ? extra->font.resolve() | f.resolve() : f.resolve()); + QFont parentFont = extra.isAllocated() ? extra->requestedFont.resolve(font) : font; + parentFont.resolve(extra.isAllocated() ? extra->requestedFont.resolve() | font.resolve() : font.resolve()); const QFont defaultFont = q->defaultFont(); const QFont resolvedFont = parentFont.resolve(defaultFont); @@ -414,35 +390,192 @@ void QQuickControlPrivate::inheritFont(const QFont &f) Assign \a font to this control, and propagate it to all children. */ -void QQuickControlPrivate::updateFont(const QFont &f) +void QQuickControlPrivate::updateFont(const QFont &font) { Q_Q(QQuickControl); - QFont old = resolvedFont; - resolvedFont = f; + QFont oldFont = resolvedFont; + resolvedFont = font; - if (old != f) - q->fontChange(f, old); + if (oldFont != font) + q->fontChange(font, oldFont); - QQuickControlPrivate::updateFontRecur(q, f); + QQuickControlPrivate::updateFontRecur(q, font); - if (old != f) + if (oldFont != font) emit q->fontChanged(); } -void QQuickControlPrivate::updateFontRecur(QQuickItem *item, const QFont &f) +void QQuickControlPrivate::updateFontRecur(QQuickItem *item, const QFont &font) +{ + const auto childItems = item->childItems(); + for (QQuickItem *child : childItems) { + if (QQuickControl *control = qobject_cast<QQuickControl *>(child)) + QQuickControlPrivate::get(control)->inheritFont(font); + else if (QQuickLabel *label = qobject_cast<QQuickLabel *>(child)) + QQuickLabelPrivate::get(label)->inheritFont(font); + else if (QQuickTextArea *textArea = qobject_cast<QQuickTextArea *>(child)) + QQuickTextAreaPrivate::get(textArea)->inheritFont(font); + else if (QQuickTextField *textField = qobject_cast<QQuickTextField *>(child)) + QQuickTextFieldPrivate::get(textField)->inheritFont(font); + else + QQuickControlPrivate::updateFontRecur(child, font); + } +} + +/*! + \internal + + Returns the palette that the item inherits from its ancestors and + QGuiApplication::palette. +*/ +QPalette QQuickControlPrivate::parentPalette(const QQuickItem *item) +{ + QQuickItem *p = item->parentItem(); + while (p) { + if (QQuickControl *control = qobject_cast<QQuickControl *>(p)) + return control->palette(); + else if (QQuickLabel *label = qobject_cast<QQuickLabel *>(p)) + return label->palette(); + else if (QQuickTextField *textField = qobject_cast<QQuickTextField *>(p)) + return textField->palette(); + else if (QQuickTextArea *textArea = qobject_cast<QQuickTextArea *>(p)) + return textArea->palette(); + + p = p->parentItem(); + } + + if (QQuickApplicationWindow *window = qobject_cast<QQuickApplicationWindow *>(item->window())) + return window->palette(); + + return themePalette(QPlatformTheme::SystemPalette); +} + +QPalette QQuickControlPrivate::themePalette(QPlatformTheme::Palette type) +{ + if (QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) { + if (const QPalette *palette = theme->palette(type)) { + QPalette p = *palette; + if (type == QPlatformTheme::SystemPalette) + p.resolve(0); + return p; + } + } + + return QPalette(); +} + +/*! + \internal + + Determine which palette is implicitly imposed on this control by its ancestors + and QGuiApplication::palette, resolve this against its own palette (attributes from + the implicit palette are copied over). Then propagate this palette to this + control's children. +*/ +void QQuickControlPrivate::resolvePalette() +{ + Q_Q(QQuickControl); + inheritPalette(parentPalette(q)); +} + +void QQuickControlPrivate::inheritPalette(const QPalette &palette) +{ + Q_Q(QQuickControl); + QPalette parentPalette = extra.isAllocated() ? extra->requestedPalette.resolve(palette) : palette; + parentPalette.resolve(extra.isAllocated() ? extra->requestedPalette.resolve() | palette.resolve() : palette.resolve()); + + const QPalette defaultPalette = q->defaultPalette(); + const QPalette resolvedPalette = parentPalette.resolve(defaultPalette); + + setPalette_helper(resolvedPalette); +} + +/*! + \internal + + Assign \a palette to this control, and propagate it to all children. +*/ +void QQuickControlPrivate::updatePalette(const QPalette &palette) +{ + Q_Q(QQuickControl); + QPalette oldPalette = resolvedPalette; + resolvedPalette = palette; + + if (oldPalette != palette) + q->paletteChange(palette, oldPalette); + + QQuickControlPrivate::updatePaletteRecur(q, palette); + + if (oldPalette != palette) + emit q->paletteChanged(); +} + +void QQuickControlPrivate::updatePaletteRecur(QQuickItem *item, const QPalette &palette) { const auto childItems = item->childItems(); for (QQuickItem *child : childItems) { if (QQuickControl *control = qobject_cast<QQuickControl *>(child)) - QQuickControlPrivate::get(control)->inheritFont(f); + QQuickControlPrivate::get(control)->inheritPalette(palette); else if (QQuickLabel *label = qobject_cast<QQuickLabel *>(child)) - QQuickLabelPrivate::get(label)->inheritFont(f); + QQuickLabelPrivate::get(label)->inheritPalette(palette); else if (QQuickTextArea *textArea = qobject_cast<QQuickTextArea *>(child)) - QQuickTextAreaPrivate::get(textArea)->inheritFont(f); + QQuickTextAreaPrivate::get(textArea)->inheritPalette(palette); else if (QQuickTextField *textField = qobject_cast<QQuickTextField *>(child)) - QQuickTextFieldPrivate::get(textField)->inheritFont(f); + QQuickTextFieldPrivate::get(textField)->inheritPalette(palette); else - QQuickControlPrivate::updateFontRecur(child, f); + QQuickControlPrivate::updatePaletteRecur(child, palette); + } +} + +QLocale QQuickControlPrivate::calcLocale(const QQuickItem *item) +{ + const QQuickItem *p = item; + while (p) { + if (const QQuickControl *control = qobject_cast<const QQuickControl *>(p)) + return control->locale(); + + QVariant v = p->property("locale"); + if (v.isValid() && v.userType() == QMetaType::QLocale) + return v.toLocale(); + + p = p->parentItem(); + } + + if (item) { + if (QQuickApplicationWindow *window = qobject_cast<QQuickApplicationWindow *>(item->window())) + return window->locale(); + } + + return QLocale(); +} + +void QQuickControlPrivate::updateLocale(const QLocale &l, bool e) +{ + Q_Q(QQuickControl); + if (!e && hasLocale) + return; + + QLocale old = q->locale(); + hasLocale = e; + if (old != l) { + bool wasMirrored = q->isMirrored(); + q->localeChange(l, old); + locale = l; + QQuickControlPrivate::updateLocaleRecur(q, l); + emit q->localeChanged(); + if (wasMirrored != q->isMirrored()) + q->mirrorChange(); + } +} + +void QQuickControlPrivate::updateLocaleRecur(QQuickItem *item, const QLocale &l) +{ + const auto childItems = item->childItems(); + for (QQuickItem *child : childItems) { + if (QQuickControl *control = qobject_cast<QQuickControl *>(child)) + QQuickControlPrivate::get(control)->updateLocale(l, false); + else + updateLocaleRecur(child, l); } } @@ -504,58 +637,40 @@ bool QQuickControlPrivate::calcHoverEnabled(const QQuickItem *item) } #endif -QString QQuickControl::accessibleName() const -{ -#if QT_CONFIG(accessibility) - Q_D(const QQuickControl); - if (d->accessibleAttached) - return d->accessibleAttached->name(); -#endif - return QString(); -} - -void QQuickControl::setAccessibleName(const QString &name) +/* + Cancels incubation recursively to avoid "Object destroyed during incubation" (QTBUG-50992) +*/ +static void cancelIncubation(QObject *object, QQmlContext *context) { -#if QT_CONFIG(accessibility) - Q_D(QQuickControl); - if (d->accessibleAttached) - d->accessibleAttached->setName(name); -#else - Q_UNUSED(name) -#endif + const auto children = object->children(); + for (QObject *child : children) + cancelIncubation(child, context); + QQmlIncubatorPrivate::cancel(object, context); } -QVariant QQuickControl::accessibleProperty(const char *propertyName) +void QQuickControlPrivate::destroyDelegate(QObject *delegate, QObject *parent) { -#if QT_CONFIG(accessibility) - Q_D(QQuickControl); - if (d->accessibleAttached) - return QQuickAccessibleAttached::property(this, propertyName); -#endif - Q_UNUSED(propertyName) - return QVariant(); -} + if (!delegate) + return; -bool QQuickControl::setAccessibleProperty(const char *propertyName, const QVariant &value) -{ -#if QT_CONFIG(accessibility) - Q_D(QQuickControl); - if (d->accessibleAttached) - return QQuickAccessibleAttached::setProperty(this, propertyName, value); -#endif - Q_UNUSED(propertyName) - Q_UNUSED(value) - return false; + QQmlContext *context = parent ? qmlContext(parent) : nullptr; + if (context) + cancelIncubation(delegate, context); + delete delegate; } QQuickControl::QQuickControl(QQuickItem *parent) : QQuickItem(*(new QQuickControlPrivate), parent) { + // ### TODO: ItemEnabledChanged? + connect(this, &QQuickItem::enabledChanged, this, &QQuickControl::paletteChanged); } QQuickControl::QQuickControl(QQuickControlPrivate &dd, QQuickItem *parent) : QQuickItem(dd, parent) { + // ### TODO: ItemEnabledChanged? + connect(this, &QQuickItem::enabledChanged, this, &QQuickControl::paletteChanged); } void QQuickControl::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value) @@ -572,6 +687,7 @@ void QQuickControl::itemChange(QQuickItem::ItemChange change, const QQuickItem:: case ItemParentHasChanged: if (value.item) { d->resolveFont(); + d->resolvePalette(); if (!d->hasLocale) d->updateLocale(QQuickControlPrivate::calcLocale(d->parentItem), false); // explicit=false #if QT_CONFIG(quicktemplates2_hover) @@ -634,10 +750,10 @@ QFont QQuickControl::font() const void QQuickControl::setFont(const QFont &font) { Q_D(QQuickControl); - if (d->extra.value().font.resolve() == font.resolve() && d->extra.value().font == font) + if (d->extra.value().requestedFont.resolve() == font.resolve() && d->extra.value().requestedFont == font) return; - d->extra.value().font = font; + d->extra.value().requestedFont = font; d->resolveFont(); } @@ -910,80 +1026,6 @@ void QQuickControl::resetLocale() d->updateLocale(QQuickControlPrivate::calcLocale(d->parentItem), false); // explicit=false } -QLocale QQuickControlPrivate::calcLocale(const QQuickItem *item) -{ - const QQuickItem *p = item; - while (p) { - if (const QQuickControl *control = qobject_cast<const QQuickControl *>(p)) - return control->locale(); - - QVariant v = p->property("locale"); - if (v.isValid() && v.userType() == QMetaType::QLocale) - return v.toLocale(); - - p = p->parentItem(); - } - - if (item) { - if (QQuickApplicationWindow *window = qobject_cast<QQuickApplicationWindow *>(item->window())) - return window->locale(); - } - - return QLocale(); -} - -/* - Cancels incubation recursively to avoid "Object destroyed during incubation" (QTBUG-50992) -*/ -static void cancelIncubation(QObject *object, QQmlContext *context) -{ - const auto children = object->children(); - for (QObject *child : children) - cancelIncubation(child, context); - QQmlIncubatorPrivate::cancel(object, context); -} - -void QQuickControlPrivate::destroyDelegate(QObject *delegate, QObject *parent) -{ - if (!delegate) - return; - - QQmlContext *context = parent ? qmlContext(parent) : nullptr; - if (context) - cancelIncubation(delegate, context); - delete delegate; -} - -void QQuickControlPrivate::updateLocale(const QLocale &l, bool e) -{ - Q_Q(QQuickControl); - if (!e && hasLocale) - return; - - QLocale old = q->locale(); - hasLocale = e; - if (old != l) { - bool wasMirrored = q->isMirrored(); - q->localeChange(l, old); - locale = l; - QQuickControlPrivate::updateLocaleRecur(q, l); - emit q->localeChanged(); - if (wasMirrored != q->isMirrored()) - q->mirrorChange(); - } -} - -void QQuickControlPrivate::updateLocaleRecur(QQuickItem *item, const QLocale &l) -{ - const auto childItems = item->childItems(); - for (QQuickItem *child : childItems) { - if (QQuickControl *control = qobject_cast<QQuickControl *>(child)) - QQuickControlPrivate::get(control)->updateLocale(l, false); - else - updateLocaleRecur(child, l); - } -} - /*! \qmlproperty bool QtQuick.Controls::Control::mirrored \readonly @@ -1277,11 +1319,72 @@ void QQuickControl::setContentItem(QQuickItem *item) d->setContentItem_helper(item, true); } +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty palette QtQuick.Controls::Control::palette + + This property holds the palette currently set for the control. + + This property describes the control's requested palette. The palette is used by the control's + style when rendering standard components, and is available as a means to ensure that custom + controls can maintain consistency with the native platform's native look and feel. It's common + that different platforms, or different styles, define different palettes for an application. + + The default palette depends on the system environment. ApplicationWindow maintains a system/theme + palette which serves as a default for all controls. There may also be special palette defaults for + certain types of controls. You can also set the default palette for controls by passing a custom + palette to QGuiApplication::setPalette(), before loading any QML. + + Control propagates explicit palette properties from parent to children. If you change a specific + property on a control's palette, that property propagates to all of the control's children, + overriding any system defaults for that property. + + \code + Page { + palette.text: "red" + + Column { + Label { + text: qsTr("This will use red color...") + } + + Switch { + text: qsTr("... and so will this") + } + } + } + \endcode +*/ +QPalette QQuickControl::palette() const +{ + Q_D(const QQuickControl); + QPalette palette = d->resolvedPalette; + if (!isEnabled()) + palette.setCurrentColorGroup(QPalette::Disabled); + return palette; +} + +void QQuickControl::setPalette(const QPalette &palette) +{ + Q_D(QQuickControl); + if (d->extra.value().requestedPalette.resolve() == palette.resolve() && d->extra.value().requestedPalette == palette) + return; + + d->extra.value().requestedPalette = palette; + d->resolvePalette(); +} + +void QQuickControl::resetPalette() +{ + setPalette(QPalette()); +} + void QQuickControl::classBegin() { Q_D(QQuickControl); QQuickItem::classBegin(); d->resolveFont(); + d->resolvePalette(); } void QQuickControl::componentComplete() @@ -1296,7 +1399,7 @@ void QQuickControl::componentComplete() setAcceptHoverEvents(QQuickControlPrivate::calcHoverEnabled(d->parentItem)); #endif #if QT_CONFIG(accessibility) - if (!d->accessibleAttached && QAccessible::isActive()) + if (QAccessible::isActive()) accessibilityActiveChanged(true); #endif } @@ -1306,6 +1409,11 @@ QFont QQuickControl::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::SystemFont); } +QPalette QQuickControl::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::SystemPalette); +} + void QQuickControl::focusInEvent(QFocusEvent *event) { QQuickItem::focusInEvent(event); @@ -1491,4 +1599,65 @@ void QQuickControl::localeChange(const QLocale &newLocale, const QLocale &oldLoc Q_UNUSED(oldLocale); } +void QQuickControl::paletteChange(const QPalette &newPalette, const QPalette &oldPalette) +{ + Q_UNUSED(newPalette); + Q_UNUSED(oldPalette); +} + +#if QT_CONFIG(accessibility) +QAccessible::Role QQuickControl::accessibleRole() const +{ + return QAccessible::NoRole; +} + +void QQuickControl::accessibilityActiveChanged(bool active) +{ + if (!active) + return; + + QQuickAccessibleAttached *accessibleAttached = qobject_cast<QQuickAccessibleAttached *>(qmlAttachedPropertiesObject<QQuickAccessibleAttached>(this, true)); + Q_ASSERT(accessibleAttached); + accessibleAttached->setRole(accessibleRole()); +} +#endif + +QString QQuickControl::accessibleName() const +{ +#if QT_CONFIG(accessibility) + if (QQuickAccessibleAttached *accessibleAttached = QQuickAccessibleAttached::attachedProperties(this)) + return accessibleAttached->name(); +#endif + return QString(); +} + +void QQuickControl::setAccessibleName(const QString &name) +{ +#if QT_CONFIG(accessibility) + if (QQuickAccessibleAttached *accessibleAttached = QQuickAccessibleAttached::attachedProperties(this)) + accessibleAttached->setName(name); +#else + Q_UNUSED(name) +#endif +} + +QVariant QQuickControl::accessibleProperty(const char *propertyName) +{ +#if QT_CONFIG(accessibility) + return QQuickAccessibleAttached::property(this, propertyName); +#endif + Q_UNUSED(propertyName) + return QVariant(); +} + +bool QQuickControl::setAccessibleProperty(const char *propertyName, const QVariant &value) +{ +#if QT_CONFIG(accessibility) + return QQuickAccessibleAttached::setProperty(this, propertyName, value); +#endif + Q_UNUSED(propertyName) + Q_UNUSED(value) + return false; +} + QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquickcontrol_p.h b/src/quicktemplates2/qquickcontrol_p.h index 8b52bd02..eaf00ced 100644 --- a/src/quicktemplates2/qquickcontrol_p.h +++ b/src/quicktemplates2/qquickcontrol_p.h @@ -49,6 +49,7 @@ // #include <QtCore/qlocale.h> +#include <QtGui/qpalette.h> #include <QtQuick/qquickitem.h> #include <QtQuickTemplates2/private/qtquicktemplates2global_p.h> @@ -78,6 +79,7 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickControl : public QQuickItem Q_PROPERTY(bool wheelEnabled READ isWheelEnabled WRITE setWheelEnabled NOTIFY wheelEnabledChanged FINAL) Q_PROPERTY(QQuickItem *background READ background WRITE setBackground NOTIFY backgroundChanged FINAL) Q_PROPERTY(QQuickItem *contentItem READ contentItem WRITE setContentItem NOTIFY contentItemChanged FINAL) + Q_PROPERTY(QPalette palette READ palette WRITE setPalette RESET resetPalette NOTIFY paletteChanged FINAL REVISION 3) public: explicit QQuickControl(QQuickItem *parent = nullptr); @@ -143,6 +145,10 @@ public: QQuickItem *contentItem() const; void setContentItem(QQuickItem *item); + QPalette palette() const; + void setPalette(const QPalette &palette); + void resetPalette(); + Q_SIGNALS: void fontChanged(); void availableWidthChanged(); @@ -163,9 +169,11 @@ Q_SIGNALS: void wheelEnabledChanged(); void backgroundChanged(); void contentItemChanged(); + Q_REVISION(3) void paletteChanged(); protected: virtual QFont defaultFont() const; + virtual QPalette defaultPalette() const; QQuickControl(QQuickControlPrivate &dd, QQuickItem *parent); @@ -204,10 +212,11 @@ protected: virtual void paddingChange(const QMarginsF &newPadding, const QMarginsF &oldPadding); virtual void contentItemChange(QQuickItem *newItem, QQuickItem *oldItem); virtual void localeChange(const QLocale &newLocale, const QLocale &oldLocale); + virtual void paletteChange(const QPalette &newPalette, const QPalette &oldPalette); #if QT_CONFIG(accessibility) - virtual void accessibilityActiveChanged(bool active); virtual QAccessible::Role accessibleRole() const; + virtual void accessibilityActiveChanged(bool active); #endif // helper functions which avoid to check QT_CONFIG(accessibility) diff --git a/src/quicktemplates2/qquickcontrol_p_p.h b/src/quicktemplates2/qquickcontrol_p_p.h index 73e1b44c..e990e44f 100644 --- a/src/quicktemplates2/qquickcontrol_p_p.h +++ b/src/quicktemplates2/qquickcontrol_p_p.h @@ -48,7 +48,7 @@ // We mean it. // -#include "qquickcontrol_p.h" +#include <QtQuickTemplates2/private/qquickcontrol_p.h> #include <QtQuick/private/qquickitem_p.h> #include <QtQml/private/qlazilyallocated_p.h> @@ -60,8 +60,6 @@ QT_BEGIN_NAMESPACE -class QQuickAccessibleAttached; - class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickControlPrivate : public QQuickItemPrivate #if QT_CONFIG(accessibility) , public QAccessible::ActivationObserver @@ -104,18 +102,30 @@ public: QAccessible::Role accessibleRole() const override; #endif - void updateFont(const QFont &f); - static void updateFontRecur(QQuickItem *item, const QFont &f); - inline void setFont_helper(const QFont &f) { - if (resolvedFont.resolve() == f.resolve() && resolvedFont == f) + virtual void resolveFont(); + void inheritFont(const QFont &font); + void updateFont(const QFont &font); + static void updateFontRecur(QQuickItem *item, const QFont &font); + inline void setFont_helper(const QFont &font) { + if (resolvedFont.resolve() == font.resolve() && resolvedFont == font) return; - updateFont(f); + updateFont(font); } - virtual void resolveFont(); - void inheritFont(const QFont &f); static QFont parentFont(const QQuickItem *item); static QFont themeFont(QPlatformTheme::Font type); + virtual void resolvePalette(); + void inheritPalette(const QPalette &palette); + void updatePalette(const QPalette &palette); + static void updatePaletteRecur(QQuickItem *item, const QPalette &palette); + inline void setPalette_helper(const QPalette &palette) { + if (resolvedPalette.resolve() == palette.resolve() && resolvedPalette == palette) + return; + updatePalette(palette); + } + static QPalette parentPalette(const QQuickItem *item); + static QPalette themePalette(QPlatformTheme::Palette type); + void updateLocale(const QLocale &l, bool e); static void updateLocaleRecur(QQuickItem *item, const QLocale &l); static QLocale calcLocale(const QQuickItem *item); @@ -130,11 +140,11 @@ public: struct ExtraData { ExtraData(); - QFont font; + QFont requestedFont; + QPalette requestedPalette; }; QLazilyAllocated<ExtraData> extra; - QFont resolvedFont; bool hasTopPadding; bool hasLeftPadding; bool hasRightPadding; @@ -153,11 +163,12 @@ public: qreal bottomPadding; qreal spacing; QLocale locale; + QFont resolvedFont; + QPalette resolvedPalette; Qt::FocusPolicy focusPolicy; Qt::FocusReason focusReason; QQuickItem *background; QQuickItem *contentItem; - QQuickAccessibleAttached *accessibleAttached; }; QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquickdelaybutton.cpp b/src/quicktemplates2/qquickdelaybutton.cpp index f8a495b0..6e0baf56 100644 --- a/src/quicktemplates2/qquickdelaybutton.cpp +++ b/src/quicktemplates2/qquickdelaybutton.cpp @@ -268,4 +268,9 @@ QFont QQuickDelayButton::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::PushButtonFont); } +QPalette QQuickDelayButton::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::ButtonPalette); +} + QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquickdelaybutton_p.h b/src/quicktemplates2/qquickdelaybutton_p.h index 5ac0885d..0927eb4a 100644 --- a/src/quicktemplates2/qquickdelaybutton_p.h +++ b/src/quicktemplates2/qquickdelaybutton_p.h @@ -85,6 +85,7 @@ protected: void nextCheckState() override; QFont defaultFont() const override; + QPalette defaultPalette() const override; private: Q_DISABLE_COPY(QQuickDelayButton) diff --git a/src/quicktemplates2/qquickdialog.cpp b/src/quicktemplates2/qquickdialog.cpp index 3ac99caa..cce1ae47 100644 --- a/src/quicktemplates2/qquickdialog.cpp +++ b/src/quicktemplates2/qquickdialog.cpp @@ -37,6 +37,7 @@ #include "qquickdialog_p.h" #include "qquickdialog_p_p.h" #include "qquickdialogbuttonbox_p.h" +#include "qquickabstractbutton_p.h" #include "qquickpopupitem_p_p.h" QT_BEGIN_NAMESPACE @@ -115,6 +116,69 @@ QT_BEGIN_NAMESPACE \sa accepted() */ +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlsignal QtQuick.Controls::Dialog::applied() + + This signal is emitted when the \c Dialog.Apply standard button is clicked. + + \sa discarded(), reset() +*/ + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlsignal QtQuick.Controls::Dialog::reset() + + This signal is emitted when the \c Dialog.Reset standard button is clicked. + + \sa discarded(), applied() +*/ + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlsignal QtQuick.Controls::Dialog::discarded() + + This signal is emitted when the \c Dialog.Discard standard button is clicked. + + \sa reset(), applied() +*/ + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlsignal QtQuick.Controls::Dialog::helpRequested() + + This signal is emitted when the \c Dialog.Help standard button is clicked. + + \sa accepted(), rejected() +*/ + +QPlatformDialogHelper::ButtonRole QQuickDialogPrivate::buttonRole(QQuickAbstractButton *button) +{ + const QQuickDialogButtonBoxAttached *attached = qobject_cast<QQuickDialogButtonBoxAttached *>(qmlAttachedPropertiesObject<QQuickDialogButtonBox>(button, false)); + return attached ? attached->buttonRole() : QPlatformDialogHelper::InvalidRole; +} + +void QQuickDialogPrivate::handleClick(QQuickAbstractButton *button) +{ + Q_Q(QQuickDialog); + switch (buttonRole(button)) { + case QPlatformDialogHelper::ApplyRole: + emit q->applied(); + break; + case QPlatformDialogHelper::ResetRole: + emit q->reset(); + break; + case QPlatformDialogHelper::DestructiveRole: + emit q->discarded(); + break; + case QPlatformDialogHelper::HelpRole: + emit q->helpRequested(); + break; + default: + break; + } +} + QQuickDialog::QQuickDialog(QObject *parent) : QQuickPopup(*(new QQuickDialogPrivate), parent) { @@ -188,12 +252,14 @@ void QQuickDialog::setHeader(QQuickItem *header) if (QQuickDialogButtonBox *buttonBox = qobject_cast<QQuickDialogButtonBox *>(oldHeader)) { disconnect(buttonBox, &QQuickDialogButtonBox::accepted, this, &QQuickDialog::accept); disconnect(buttonBox, &QQuickDialogButtonBox::rejected, this, &QQuickDialog::reject); + QObjectPrivate::disconnect(buttonBox, &QQuickDialogButtonBox::clicked, d, &QQuickDialogPrivate::handleClick); if (d->buttonBox == buttonBox) d->buttonBox = nullptr; } if (QQuickDialogButtonBox *buttonBox = qobject_cast<QQuickDialogButtonBox *>(header)) { connect(buttonBox, &QQuickDialogButtonBox::accepted, this, &QQuickDialog::accept); connect(buttonBox, &QQuickDialogButtonBox::rejected, this, &QQuickDialog::reject); + QObjectPrivate::connect(buttonBox, &QQuickDialogButtonBox::clicked, d, &QQuickDialogPrivate::handleClick); d->buttonBox = buttonBox; buttonBox->setStandardButtons(d->standardButtons); } @@ -235,12 +301,14 @@ void QQuickDialog::setFooter(QQuickItem *footer) if (QQuickDialogButtonBox *buttonBox = qobject_cast<QQuickDialogButtonBox *>(oldFooter)) { disconnect(buttonBox, &QQuickDialogButtonBox::accepted, this, &QQuickDialog::accept); disconnect(buttonBox, &QQuickDialogButtonBox::rejected, this, &QQuickDialog::reject); + QObjectPrivate::disconnect(buttonBox, &QQuickDialogButtonBox::clicked, d, &QQuickDialogPrivate::handleClick); if (d->buttonBox == buttonBox) d->buttonBox = nullptr; } if (QQuickDialogButtonBox *buttonBox = qobject_cast<QQuickDialogButtonBox *>(footer)) { connect(buttonBox, &QQuickDialogButtonBox::accepted, this, &QQuickDialog::accept); connect(buttonBox, &QQuickDialogButtonBox::rejected, this, &QQuickDialog::reject); + QObjectPrivate::connect(buttonBox, &QQuickDialogButtonBox::clicked, d, &QQuickDialogPrivate::handleClick); d->buttonBox = buttonBox; buttonBox->setStandardButtons(d->standardButtons); } @@ -301,16 +369,59 @@ void QQuickDialog::setStandardButtons(QPlatformDialogHelper::StandardButtons but } /*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlmethod AbstractButton QtQuick.Controls::Dialog::standardButton(StandardButton button) + + Returns the specified standard \a button, or \c null if it does not exist. + + \sa standardButtons +*/ +QQuickAbstractButton *QQuickDialog::standardButton(QPlatformDialogHelper::StandardButton button) const +{ + Q_D(const QQuickDialog); + if (!d->buttonBox) + return nullptr; + return d->buttonBox->standardButton(button); +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty int QtQuick.Controls::Dialog::result + + This property holds the result code. + + Standard result codes: + \value Dialog.Accepted The dialog was accepted. + \value Dialog.Rejected The dialog was rejected. + + \sa accept(), reject(), done() +*/ +int QQuickDialog::result() const +{ + Q_D(const QQuickDialog); + return d->result; +} + +void QQuickDialog::setResult(int result) +{ + Q_D(QQuickDialog); + if (d->result == result) + return; + + d->result = result; + emit resultChanged(); +} + +/*! \qmlmethod void QtQuick.Controls::Dialog::accept() Closes the dialog and emits the \l accepted() signal. - \sa reject() + \sa reject(), done() */ void QQuickDialog::accept() { - close(); - emit accepted(); + done(Accepted); } /*! @@ -318,12 +429,32 @@ void QQuickDialog::accept() Closes the dialog and emits the \l rejected() signal. - \sa accept() + \sa accept(), done() */ void QQuickDialog::reject() { + done(Rejected); +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlmethod void QtQuick.Controls::Dialog::done(int result) + + Closes the dialog, sets the \a result, and emits \l accepted() or + \l rejected() depending on whether the result is \c Dialog.Accepted + or \c Dialog.Rejected, respectively. + + \sa accept(), reject(), result +*/ +void QQuickDialog::done(int result) +{ close(); - emit rejected(); + setResult(result); + + if (result == Accepted) + emit accepted(); + else if (result == Rejected) + emit rejected(); } void QQuickDialog::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) diff --git a/src/quicktemplates2/qquickdialog_p.h b/src/quicktemplates2/qquickdialog_p.h index 97c90a59..8032cf83 100644 --- a/src/quicktemplates2/qquickdialog_p.h +++ b/src/quicktemplates2/qquickdialog_p.h @@ -54,6 +54,7 @@ QT_BEGIN_NAMESPACE class QQuickDialogPrivate; +class QQuickAbstractButton; class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickDialog : public QQuickPopup { @@ -62,6 +63,7 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickDialog : public QQuickPopup Q_PROPERTY(QQuickItem *header READ header WRITE setHeader NOTIFY headerChanged FINAL) Q_PROPERTY(QQuickItem *footer READ footer WRITE setFooter NOTIFY footerChanged FINAL) Q_PROPERTY(QPlatformDialogHelper::StandardButtons standardButtons READ standardButtons WRITE setStandardButtons NOTIFY standardButtonsChanged FINAL) + Q_PROPERTY(int result READ result WRITE setResult NOTIFY resultChanged FINAL REVISION 3) Q_FLAGS(QPlatformDialogHelper::StandardButtons) public: @@ -78,19 +80,32 @@ public: QPlatformDialogHelper::StandardButtons standardButtons() const; void setStandardButtons(QPlatformDialogHelper::StandardButtons buttons); + Q_REVISION(3) Q_INVOKABLE QQuickAbstractButton *standardButton(QPlatformDialogHelper::StandardButton button) const; + + enum StandardCode { Rejected, Accepted }; + Q_ENUM(StandardCode) + + int result() const; + void setResult(int result); public Q_SLOTS: - void accept(); - void reject(); + virtual void accept(); + virtual void reject(); + virtual void done(int result); Q_SIGNALS: void accepted(); void rejected(); + Q_REVISION(3) void applied(); + Q_REVISION(3) void reset(); + Q_REVISION(3) void discarded(); + Q_REVISION(3) void helpRequested(); void titleChanged(); void headerChanged(); void footerChanged(); void standardButtonsChanged(); + Q_REVISION(3) void resultChanged(); protected: void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) override; diff --git a/src/quicktemplates2/qquickdialog_p_p.h b/src/quicktemplates2/qquickdialog_p_p.h index 13885ca9..e26182ac 100644 --- a/src/quicktemplates2/qquickdialog_p_p.h +++ b/src/quicktemplates2/qquickdialog_p_p.h @@ -48,11 +48,14 @@ // We mean it. // +#include <QtQuickTemplates2/private/qquickdialog_p.h> #include <QtQuickTemplates2/private/qquickpopup_p_p.h> #include <QtQuickTemplates2/private/qquickpagelayout_p_p.h> +#include <QtGui/qpa/qplatformdialoghelper.h> QT_BEGIN_NAMESPACE +class QQuickAbstractButton; class QQuickDialogButtonBox; class QQuickDialogPrivate : public QQuickPopupPrivate @@ -60,13 +63,18 @@ class QQuickDialogPrivate : public QQuickPopupPrivate Q_DECLARE_PUBLIC(QQuickDialog) public: - QQuickDialogPrivate() : buttonBox(nullptr) { } + QQuickDialogPrivate() : result(0), buttonBox(nullptr) { } static QQuickDialogPrivate *get(QQuickDialog *dialog) { return dialog->d_func(); } + static QPlatformDialogHelper::ButtonRole buttonRole(QQuickAbstractButton *button); + + void handleClick(QQuickAbstractButton *button); + + int result; QString title; QQuickDialogButtonBox *buttonBox; QScopedPointer<QQuickPageLayout> layout; diff --git a/src/quicktemplates2/qquickdialogbuttonbox.cpp b/src/quicktemplates2/qquickdialogbuttonbox.cpp index 3c422268..7c2f17c4 100644 --- a/src/quicktemplates2/qquickdialogbuttonbox.cpp +++ b/src/quicktemplates2/qquickdialogbuttonbox.cpp @@ -38,6 +38,7 @@ #include "qquickdialogbuttonbox_p_p.h" #include "qquickabstractbutton_p.h" #include "qquickbutton_p.h" +#include "qquickdialog_p_p.h" #include <QtCore/qpointer.h> #include <QtGui/private/qguiapplication_p.h> @@ -122,6 +123,36 @@ QT_BEGIN_NAMESPACE */ /*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlsignal QtQuick.Controls::DialogButtonBox::applied() + + This signal is emitted when a button defined with the \c ApplyRole is + clicked. + + \sa discarded(), reset() +*/ + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlsignal QtQuick.Controls::DialogButtonBox::reset() + + This signal is emitted when a button defined with the \c ResetRole is + clicked. + + \sa discarded(), applied() +*/ + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlsignal QtQuick.Controls::DialogButtonBox::discarded() + + This signal is emitted when a button defined with the \c DiscardRole is + clicked. + + \sa reset(), applied() +*/ + +/*! \qmlsignal QtQuick.Controls::DialogButtonBox::helpRequested() This signal is emitted when a button defined with the \c HelpRole is clicked. @@ -137,12 +168,6 @@ QT_BEGIN_NAMESPACE \sa accepted(), rejected(), helpRequested() */ -static QPlatformDialogHelper::ButtonRole buttonRole(QQuickAbstractButton *button) -{ - const QQuickDialogButtonBoxAttached *attached = qobject_cast<QQuickDialogButtonBoxAttached *>(qmlAttachedPropertiesObject<QQuickDialogButtonBox>(button, false)); - return attached ? attached->buttonRole() : QPlatformDialogHelper::InvalidRole; -} - QQuickDialogButtonBoxPrivate::QQuickDialogButtonBoxPrivate() : alignment(0), position(QQuickDialogButtonBox::Footer), @@ -238,8 +263,8 @@ void QQuickDialogButtonBoxPrivate::updateLayout() struct ButtonLayout { bool operator()(QQuickAbstractButton *first, QQuickAbstractButton *second) { - const QPlatformDialogHelper::ButtonRole firstRole = buttonRole(first); - const QPlatformDialogHelper::ButtonRole secondRole = buttonRole(second); + const QPlatformDialogHelper::ButtonRole firstRole = QQuickDialogPrivate::buttonRole(first); + const QPlatformDialogHelper::ButtonRole secondRole = QQuickDialogPrivate::buttonRole(second); if (firstRole != secondRole && firstRole != QPlatformDialogHelper::InvalidRole && secondRole != QPlatformDialogHelper::InvalidRole) { const int *l = m_layout; @@ -283,7 +308,7 @@ void QQuickDialogButtonBoxPrivate::handleClick() // or change its role. Now changing the role is not possible yet, but arguably // both clicked and accepted/rejected/etc. should be emitted "atomically" // depending on whatever role the button had at the time of the click. - const QPlatformDialogHelper::ButtonRole role = buttonRole(button); + const QPlatformDialogHelper::ButtonRole role = QQuickDialogPrivate::buttonRole(button); QPointer<QQuickDialogButtonBox> guard(q); emit q->clicked(button); @@ -300,6 +325,15 @@ void QQuickDialogButtonBoxPrivate::handleClick() case QPlatformDialogHelper::NoRole: emit q->rejected(); break; + case QPlatformDialogHelper::ApplyRole: + emit q->applied(); + break; + case QPlatformDialogHelper::ResetRole: + emit q->reset(); + break; + case QPlatformDialogHelper::DestructiveRole: + emit q->discarded(); + break; case QPlatformDialogHelper::HelpRole: emit q->helpRequested(); break; diff --git a/src/quicktemplates2/qquickdialogbuttonbox_p.h b/src/quicktemplates2/qquickdialogbuttonbox_p.h index 9bd92c79..5d6e568e 100644 --- a/src/quicktemplates2/qquickdialogbuttonbox_p.h +++ b/src/quicktemplates2/qquickdialogbuttonbox_p.h @@ -98,6 +98,9 @@ Q_SIGNALS: void accepted(); void rejected(); void helpRequested(); + Q_REVISION(3) void applied(); + Q_REVISION(3) void reset(); + Q_REVISION(3) void discarded(); void clicked(QQuickAbstractButton *button); void positionChanged(); diff --git a/src/quicktemplates2/qquickdrawer_p_p.h b/src/quicktemplates2/qquickdrawer_p_p.h index 8547bce5..92de9010 100644 --- a/src/quicktemplates2/qquickdrawer_p_p.h +++ b/src/quicktemplates2/qquickdrawer_p_p.h @@ -48,9 +48,9 @@ // We mean it. // -#include "qquickdrawer_p.h" -#include "qquickpopup_p_p.h" -#include "qquickvelocitycalculator_p_p.h" +#include <QtQuickTemplates2/private/qquickdrawer_p.h> +#include <QtQuickTemplates2/private/qquickpopup_p_p.h> +#include <QtQuickTemplates2/private/qquickvelocitycalculator_p_p.h> QT_BEGIN_NAMESPACE diff --git a/src/quicktemplates2/qquickgroupbox.cpp b/src/quicktemplates2/qquickgroupbox.cpp index 09bd49f6..c227afdc 100644 --- a/src/quicktemplates2/qquickgroupbox.cpp +++ b/src/quicktemplates2/qquickgroupbox.cpp @@ -153,6 +153,11 @@ QFont QQuickGroupBox::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::GroupBoxTitleFont); } +QPalette QQuickGroupBox::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::GroupBoxPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickGroupBox::accessibleRole() const { diff --git a/src/quicktemplates2/qquickgroupbox_p.h b/src/quicktemplates2/qquickgroupbox_p.h index e35db1fc..b74389e4 100644 --- a/src/quicktemplates2/qquickgroupbox_p.h +++ b/src/quicktemplates2/qquickgroupbox_p.h @@ -75,6 +75,7 @@ Q_SIGNALS: protected: QFont defaultFont() const override; + QPalette defaultPalette() const override; #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; diff --git a/src/quicktemplates2/qquickicon.cpp b/src/quicktemplates2/qquickicon.cpp new file mode 100644 index 00000000..0b0127d3 --- /dev/null +++ b/src/quicktemplates2/qquickicon.cpp @@ -0,0 +1,152 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the Qt Quick Templates 2 module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** 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 http://www.qt.io/terms-conditions. For further +** information use the contact form at http://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.LGPLv3 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.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 later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qquickicon_p.h" + +QT_BEGIN_NAMESPACE + +class QQuickIconPrivate : public QSharedData +{ +public: + QQuickIconPrivate() + : width(0), + height(0), + color(Qt::transparent) + { + } + + QString name; + QUrl source; + int width; + int height; + QColor color; +}; + +QQuickIcon::QQuickIcon() + : d(new QQuickIconPrivate) +{ +} + +QQuickIcon::QQuickIcon(const QQuickIcon &other) + : d(other.d) +{ +} + +QQuickIcon::~QQuickIcon() +{ +} + +QQuickIcon &QQuickIcon::operator=(const QQuickIcon &other) +{ + d = other.d; + return *this; +} + +bool QQuickIcon::operator==(const QQuickIcon &other) const +{ + return d == other.d || (d->name == other.d->name + && d->source == other.d->source + && d->width == other.d->width + && d->height == other.d->height + && d->color == other.d->color); +} + +bool QQuickIcon::operator!=(const QQuickIcon &other) const +{ + return !(*this == other); +} + +bool QQuickIcon::isEmpty() const +{ + return d->name.isEmpty() && d->source.isEmpty(); +} + +QString QQuickIcon::name() const +{ + return d->name; +} + +void QQuickIcon::setName(const QString &name) +{ + d->name = name; +} + +QUrl QQuickIcon::source() const +{ + return d->source; +} + +void QQuickIcon::setSource(const QUrl &source) +{ + d->source = source; +} + +int QQuickIcon::width() const +{ + return d->width; +} + +void QQuickIcon::setWidth(int width) +{ + d->width = width; +} + +int QQuickIcon::height() const +{ + return d->height; +} + +void QQuickIcon::setHeight(int height) +{ + d->height = height; +} + +QColor QQuickIcon::color() const +{ + return d->color; +} + +void QQuickIcon::setColor(const QColor &color) +{ + d->color = color; +} + +void QQuickIcon::resetColor() +{ + d->color = Qt::transparent; +} + +QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquickicon_p.h b/src/quicktemplates2/qquickicon_p.h new file mode 100644 index 00000000..6e28f2a9 --- /dev/null +++ b/src/quicktemplates2/qquickicon_p.h @@ -0,0 +1,104 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the Qt Quick Templates 2 module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** 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 http://www.qt.io/terms-conditions. For further +** information use the contact form at http://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.LGPLv3 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.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 later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQUICKICON_P_H +#define QQUICKICON_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtCore/qurl.h> +#include <QtCore/qstring.h> +#include <QtCore/qobjectdefs.h> +#include <QtCore/qshareddata.h> +#include <QtQuickTemplates2/private/qtquicktemplates2global_p.h> +#include <QtGui/qcolor.h> + +QT_BEGIN_NAMESPACE + +class QQuickIconPrivate; + +class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickIcon +{ + Q_GADGET + Q_PROPERTY(QString name READ name WRITE setName FINAL) + Q_PROPERTY(QUrl source READ source WRITE setSource FINAL) + Q_PROPERTY(int width READ width WRITE setWidth FINAL) + Q_PROPERTY(int height READ height WRITE setHeight FINAL) + Q_PROPERTY(QColor color READ color WRITE setColor RESET resetColor FINAL) + +public: + QQuickIcon(); + QQuickIcon(const QQuickIcon &other); + ~QQuickIcon(); + + QQuickIcon& operator=(const QQuickIcon &other); + bool operator==(const QQuickIcon &other) const; + bool operator!=(const QQuickIcon &other) const; + + bool isEmpty() const; + + QString name() const; + void setName(const QString &name); + + QUrl source() const; + void setSource(const QUrl &source); + + int width() const; + void setWidth(int width); + + int height() const; + void setHeight(int height); + + QColor color() const; + void setColor(const QColor &color); + void resetColor(); + +private: + QSharedDataPointer<QQuickIconPrivate> d; +}; + +QT_END_NAMESPACE + +#endif // QQUICKICON_P_H diff --git a/src/quicktemplates2/qquickitemdelegate.cpp b/src/quicktemplates2/qquickitemdelegate.cpp index 1b93c145..6eb04a46 100644 --- a/src/quicktemplates2/qquickitemdelegate.cpp +++ b/src/quicktemplates2/qquickitemdelegate.cpp @@ -57,7 +57,8 @@ QT_BEGIN_NAMESPACE ItemDelegate inherits its API from AbstractButton. For instance, you can set \l {AbstractButton::text}{text}, and react to \l {AbstractButton::clicked}{clicks} - using the AbstractButton API. + using the AbstractButton API. In addition to displaying text, item delegates + can also display an \l [QML]{Button Icons}{icon}. \snippet qtquickcontrols2-itemdelegate.qml 1 @@ -125,6 +126,11 @@ QFont QQuickItemDelegate::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::ItemViewFont); } +QPalette QQuickItemDelegate::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::ItemViewPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickItemDelegate::accessibleRole() const { diff --git a/src/quicktemplates2/qquickitemdelegate_p.h b/src/quicktemplates2/qquickitemdelegate_p.h index a162ddee..5d52f764 100644 --- a/src/quicktemplates2/qquickitemdelegate_p.h +++ b/src/quicktemplates2/qquickitemdelegate_p.h @@ -70,6 +70,7 @@ Q_SIGNALS: protected: QFont defaultFont() const override; + QPalette defaultPalette() const override; #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; diff --git a/src/quicktemplates2/qquicklabel.cpp b/src/quicktemplates2/qquicklabel.cpp index 45c7e5a4..8d964745 100644 --- a/src/quicktemplates2/qquicklabel.cpp +++ b/src/quicktemplates2/qquicklabel.cpp @@ -79,8 +79,7 @@ QT_BEGIN_NAMESPACE */ QQuickLabelPrivate::QQuickLabelPrivate() - : background(nullptr), - accessibleAttached(nullptr) + : background(nullptr) { #if QT_CONFIG(accessibility) QAccessible::installActivationObserver(this); @@ -108,25 +107,76 @@ void QQuickLabelPrivate::resolveFont() inheritFont(QQuickControlPrivate::parentFont(q)); } -void QQuickLabelPrivate::inheritFont(const QFont &f) +void QQuickLabelPrivate::inheritFont(const QFont &font) { - Q_Q(QQuickLabel); - QFont parentFont = font.resolve(f); - parentFont.resolve(font.resolve() | f.resolve()); + QFont parentFont = extra.isAllocated() ? extra->requestedFont.resolve(font) : font; + parentFont.resolve(extra.isAllocated() ? extra->requestedFont.resolve() | font.resolve() : font.resolve()); const QFont defaultFont = QQuickControlPrivate::themeFont(QPlatformTheme::LabelFont); const QFont resolvedFont = parentFont.resolve(defaultFont); - const bool changed = resolvedFont != sourceFont; - q->QQuickText::setFont(resolvedFont); - if (changed) + setFont_helper(resolvedFont); +} + +/*! + \internal + + Assign \a font to this control, and propagate it to all children. +*/ +void QQuickLabelPrivate::updateFont(const QFont &font) +{ + Q_Q(QQuickLabel); + QFont oldFont = sourceFont; + q->QQuickText::setFont(font); + + QQuickControlPrivate::updateFontRecur(q, font); + + if (oldFont != font) emit q->fontChanged(); } +/*! + \internal + + Determine which palette is implicitly imposed on this control by its ancestors + and QGuiApplication::palette, resolve this against its own palette (attributes from + the implicit palette are copied over). Then propagate this palette to this + control's children. +*/ +void QQuickLabelPrivate::resolvePalette() +{ + Q_Q(QQuickLabel); + inheritPalette(QQuickControlPrivate::parentPalette(q)); +} + +void QQuickLabelPrivate::inheritPalette(const QPalette &palette) +{ + QPalette parentPalette = extra.isAllocated() ? extra->requestedPalette.resolve(palette) : palette; + parentPalette.resolve(extra.isAllocated() ? extra->requestedPalette.resolve() | palette.resolve() : palette.resolve()); + + const QPalette defaultPalette = QQuickControlPrivate::themePalette(QPlatformTheme::LabelPalette); + const QPalette resolvedPalette = parentPalette.resolve(defaultPalette); + + setPalette_helper(resolvedPalette); +} + +void QQuickLabelPrivate::updatePalette(const QPalette &palette) +{ + Q_Q(QQuickLabel); + QPalette oldPalette = resolvedPalette; + resolvedPalette = palette; + + QQuickControlPrivate::updatePaletteRecur(q, palette); + + if (oldPalette != palette) + emit q->paletteChanged(); +} + void QQuickLabelPrivate::textChanged(const QString &text) { #if QT_CONFIG(accessibility) - if (accessibleAttached) + Q_Q(QQuickLabel); + if (QQuickAccessibleAttached *accessibleAttached = QQuickAccessibleAttached::attachedProperties(q)) accessibleAttached->setName(text); #else Q_UNUSED(text) @@ -136,17 +186,14 @@ void QQuickLabelPrivate::textChanged(const QString &text) #if QT_CONFIG(accessibility) void QQuickLabelPrivate::accessibilityActiveChanged(bool active) { - if (accessibleAttached || !active) + if (!active) return; Q_Q(QQuickLabel); - accessibleAttached = qobject_cast<QQuickAccessibleAttached *>(qmlAttachedPropertiesObject<QQuickAccessibleAttached>(q, true)); - if (accessibleAttached) { - accessibleAttached->setRole(accessibleRole()); - accessibleAttached->setName(text); - } else { - qWarning() << "QQuickLabel: " << q << " QQuickAccessibleAttached object creation failed!"; - } + QQuickAccessibleAttached *accessibleAttached = qobject_cast<QQuickAccessibleAttached *>(qmlAttachedPropertiesObject<QQuickAccessibleAttached>(q, true)); + Q_ASSERT(accessibleAttached); + accessibleAttached->setRole(accessibleRole()); + accessibleAttached->setName(text); } QAccessible::Role QQuickLabelPrivate::accessibleRole() const @@ -160,6 +207,9 @@ QQuickLabel::QQuickLabel(QQuickItem *parent) { Q_D(QQuickLabel); QObjectPrivate::connect(this, &QQuickText::textChanged, d, &QQuickLabelPrivate::textChanged); + + // ### TODO: ItemEnabledChanged? + connect(this, &QQuickItem::enabledChanged, this, &QQuickLabel::paletteChanged); } QFont QQuickLabel::font() const @@ -170,10 +220,10 @@ QFont QQuickLabel::font() const void QQuickLabel::setFont(const QFont &font) { Q_D(QQuickLabel); - if (d->font.resolve() == font.resolve() && d->font == font) + if (d->extra.value().requestedFont.resolve() == font.resolve() && d->extra.value().requestedFont == font) return; - d->font = font; + d->extra.value().requestedFont = font; d->resolveFont(); } @@ -210,11 +260,44 @@ void QQuickLabel::setBackground(QQuickItem *background) emit backgroundChanged(); } +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty palette QtQuick.Controls::Label::palette + + This property holds the palette currently set for the label. + + \sa Control::palette +*/ +QPalette QQuickLabel::palette() const +{ + Q_D(const QQuickLabel); + QPalette palette = d->resolvedPalette; + if (!isEnabled()) + palette.setCurrentColorGroup(QPalette::Disabled); + return palette; +} + +void QQuickLabel::setPalette(const QPalette &palette) +{ + Q_D(QQuickLabel); + if (d->extra.value().requestedPalette.resolve() == palette.resolve() && d->extra.value().requestedPalette == palette) + return; + + d->extra.value().requestedPalette = palette; + d->resolvePalette(); +} + +void QQuickLabel::resetPalette() +{ + setPalette(QPalette()); +} + void QQuickLabel::classBegin() { Q_D(QQuickLabel); QQuickText::classBegin(); d->resolveFont(); + d->resolvePalette(); } void QQuickLabel::componentComplete() @@ -222,7 +305,7 @@ void QQuickLabel::componentComplete() Q_D(QQuickLabel); QQuickText::componentComplete(); #if QT_CONFIG(accessibility) - if (!d->accessibleAttached && QAccessible::isActive()) + if (QAccessible::isActive()) d->accessibilityActiveChanged(true); #endif } @@ -231,8 +314,10 @@ void QQuickLabel::itemChange(QQuickItem::ItemChange change, const QQuickItem::It { Q_D(QQuickLabel); QQuickText::itemChange(change, value); - if (change == ItemParentHasChanged && value.item) + if (change == ItemParentHasChanged && value.item) { d->resolveFont(); + d->resolvePalette(); + } } void QQuickLabel::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) diff --git a/src/quicktemplates2/qquicklabel_p.h b/src/quicktemplates2/qquicklabel_p.h index 04172900..a102c89a 100644 --- a/src/quicktemplates2/qquicklabel_p.h +++ b/src/quicktemplates2/qquicklabel_p.h @@ -48,6 +48,7 @@ // We mean it. // +#include <QtGui/qpalette.h> #include <QtQuick/private/qquicktext_p.h> #include <QtQuickTemplates2/private/qtquicktemplates2global_p.h> @@ -60,6 +61,7 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickLabel : public QQuickText Q_OBJECT Q_PROPERTY(QFont font READ font WRITE setFont NOTIFY fontChanged) // override Q_PROPERTY(QQuickItem *background READ background WRITE setBackground NOTIFY backgroundChanged FINAL) + Q_PROPERTY(QPalette palette READ palette WRITE setPalette RESET resetPalette NOTIFY paletteChanged FINAL REVISION 3) public: explicit QQuickLabel(QQuickItem *parent = nullptr); @@ -70,9 +72,14 @@ public: QQuickItem *background() const; void setBackground(QQuickItem *background); + QPalette palette() const; + void setPalette(const QPalette &palette); + void resetPalette(); + Q_SIGNALS: void fontChanged(); void backgroundChanged(); + Q_REVISION(3) void paletteChanged(); protected: void classBegin() override; diff --git a/src/quicktemplates2/qquicklabel_p_p.h b/src/quicktemplates2/qquicklabel_p_p.h index c24c855b..a8214d77 100644 --- a/src/quicktemplates2/qquicklabel_p_p.h +++ b/src/quicktemplates2/qquicklabel_p_p.h @@ -48,6 +48,7 @@ // We mean it. // +#include <QtQml/private/qlazilyallocated_p.h> #include <QtQuick/private/qquicktext_p_p.h> #if QT_CONFIG(accessibility) @@ -56,8 +57,6 @@ QT_BEGIN_NAMESPACE -class QQuickAccessibleAttached; - class QQuickLabelPrivate : public QQuickTextPrivate #if QT_CONFIG(accessibility) , public QAccessible::ActivationObserver @@ -75,7 +74,22 @@ public: } void resolveFont(); - void inheritFont(const QFont &f); + void inheritFont(const QFont &font); + void updateFont(const QFont &font); + inline void setFont_helper(const QFont &font) { + if (sourceFont.resolve() == font.resolve() && sourceFont == font) + return; + updateFont(font); + } + + void resolvePalette(); + void inheritPalette(const QPalette &palette); + void updatePalette(const QPalette &palette); + inline void setPalette_helper(const QPalette &palette) { + if (resolvedPalette.resolve() == palette.resolve() && resolvedPalette == palette) + return; + updatePalette(palette); + } void textChanged(const QString &text); @@ -84,9 +98,14 @@ public: QAccessible::Role accessibleRole() const override; #endif - QFont font; + struct ExtraData { + QFont requestedFont; + QPalette requestedPalette; + }; + QLazilyAllocated<ExtraData> extra; + + QPalette resolvedPalette; QQuickItem *background; - QQuickAccessibleAttached *accessibleAttached; }; QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquickmenu.cpp b/src/quicktemplates2/qquickmenu.cpp index e6f22e2b..fa6b88ef 100644 --- a/src/quicktemplates2/qquickmenu.cpp +++ b/src/quicktemplates2/qquickmenu.cpp @@ -36,10 +36,20 @@ #include "qquickmenu_p.h" #include "qquickmenu_p_p.h" -#include "qquickmenuitem_p.h" -#include "qquickcontrol_p_p.h" +#include "qquickmenuitem_p_p.h" +#include "qquickpopupitem_p_p.h" +#include "qquickaction_p.h" #include <QtGui/qevent.h> +#include <QtGui/qcursor.h> +#include <QtGui/qpa/qplatformintegration.h> +#include <QtGui/private/qguiapplication_p.h> +#include <QtQml/qqmlcontext.h> +#include <QtQml/qqmlcomponent.h> +#include <QtQml/private/qqmlengine_p.h> +#include <QtQml/private/qv4scopedvalue_p.h> +#include <QtQml/private/qv4variantobject_p.h> +#include <QtQml/private/qv4qobjectwrapper_p.h> #include <QtQml/private/qqmlobjectmodel_p.h> #include <QtQuick/private/qquickitem_p.h> #include <QtQuick/private/qquickitemchangelistener_p.h> @@ -67,6 +77,37 @@ QT_BEGIN_NAMESPACE \li Popup menus; for example, a menu that is shown after clicking a button \endlist + When used as a context menu, the recommended way of opening the menu is to call + \l popup(). Unless a position is explicitly specified, the menu is positioned at + the mouse cursor on desktop platforms that have a mouse cursor available, and + otherwise centered over its parent item. + + \code + MouseArea { + anchors.fill: parent + acceptedButtons: Qt.LeftButton | Qt.RightButton + onClicked: { + if (mouse.button === Qt.RightButton) + contextMenu.popup() + } + onPressAndHold: { + if (mouse.source === Qt.MouseEventNotSynthesized) + contextMenu.popup() + } + + Menu { + id: contextMenu + MenuItem { text: "Cut" } + MenuItem { text: "Copy" } + MenuItem { text: "Paste" } + } + } + \endcode + + When used as a popup menu, it is easiest to specify the position by specifying + the desired \l {Popup::}{x} and \l {Popup::}{y} coordinates using the respective + properties, and call \l {Popup::}{open()} to open the menu. + \code Button { id: fileButton @@ -90,6 +131,17 @@ QT_BEGIN_NAMESPACE } \endcode + Since QtQuick.Controls 2.3 (Qt 5.10), it is also possible to declare + Action objects inside Menu: + + \code + Menu { + Action { text: "Cut" } + Action { text: "Copy" } + Action { text: "Paste" } + } + \endcode + Typically, menu items are statically declared as children of the menu, but Menu also provides API to \l {addItem}{add}, \l {insertItem}{insert}, \l {moveItem}{move} and \l {removeItem}{remove} items dynamically. The @@ -104,7 +156,8 @@ QT_BEGIN_NAMESPACE QQuickMenuPrivate::QQuickMenuPrivate() : contentItem(nullptr), - contentModel(nullptr) + contentModel(nullptr), + delegate(nullptr) { Q_Q(QQuickMenu); contentModel = new QQmlObjectModel(q); @@ -129,9 +182,11 @@ void QQuickMenuPrivate::insertItem(int index, QQuickItem *item) QQuickMenuItem *menuItem = qobject_cast<QQuickMenuItem *>(item); if (menuItem) { Q_Q(QQuickMenu); + QQuickMenuItemPrivate::get(menuItem)->setMenu(q); QObjectPrivate::connect(menuItem, &QQuickMenuItem::pressed, this, &QQuickMenuPrivate::onItemPressed); QObject::connect(menuItem, &QQuickMenuItem::triggered, q, &QQuickPopup::close); QObjectPrivate::connect(menuItem, &QQuickItem::activeFocusChanged, this, &QQuickMenuPrivate::onItemActiveFocusChanged); + QObjectPrivate::connect(menuItem, &QQuickControl::hoveredChanged, this, &QQuickMenuPrivate::onItemHovered); } } @@ -151,10 +206,36 @@ void QQuickMenuPrivate::removeItem(int index, QQuickItem *item) QQuickMenuItem *menuItem = qobject_cast<QQuickMenuItem *>(item); if (menuItem) { Q_Q(QQuickMenu); + QQuickMenuItemPrivate::get(menuItem)->setMenu(nullptr); QObjectPrivate::disconnect(menuItem, &QQuickMenuItem::pressed, this, &QQuickMenuPrivate::onItemPressed); QObject::disconnect(menuItem, &QQuickMenuItem::triggered, q, &QQuickPopup::close); QObjectPrivate::disconnect(menuItem, &QQuickItem::activeFocusChanged, this, &QQuickMenuPrivate::onItemActiveFocusChanged); + QObjectPrivate::disconnect(menuItem, &QQuickControl::hoveredChanged, this, &QQuickMenuPrivate::onItemHovered); + } +} + +QQuickItem *QQuickMenuPrivate::createItem(QQuickAction *action) +{ + Q_Q(QQuickMenu); + if (!delegate) + return nullptr; + + QQmlContext *creationContext = delegate->creationContext(); + if (!creationContext) + creationContext = qmlContext(q); + QQmlContext *context = new QQmlContext(creationContext, q); + context->setContextObject(q); + + QObject *object = delegate->beginCreate(context); + if (QQuickItem *item = qobject_cast<QQuickItem *>(object)) { + if (QQuickAbstractButton *button = qobject_cast<QQuickAbstractButton*>(object)) + button->setAction(action); + delegate->completeCreate(); + return item; } + + delete object; + return nullptr; } void QQuickMenuPrivate::resizeItem(QQuickItem *item) @@ -226,6 +307,18 @@ void QQuickMenuPrivate::onItemPressed() item->forceActiveFocus(); } +void QQuickMenuPrivate::onItemHovered() +{ + Q_Q(QQuickMenu); + QQuickAbstractButton *button = qobject_cast<QQuickAbstractButton *>(q->sender()); + if (!button || !button->isHovered() || QQuickAbstractButtonPrivate::get(button)->touchId != -1) + return; + + int index = contentModel->indexOf(button, nullptr); + if (index != -1) + setCurrentIndex(index); +} + void QQuickMenuPrivate::onItemActiveFocusChanged() { Q_Q(QQuickMenu); @@ -248,13 +341,29 @@ int QQuickMenuPrivate::currentIndex() const void QQuickMenuPrivate::setCurrentIndex(int index) { contentItem->setProperty("currentIndex", index); + + QQuickMenuItem *newCurrentItem = contentItem->property("currentItem").value<QQuickMenuItem *>(); + + if (currentItem != newCurrentItem) { + if (currentItem) + currentItem->setHighlighted(false); + if (newCurrentItem) + newCurrentItem->setHighlighted(true); + currentItem = newCurrentItem; + } } void QQuickMenuPrivate::contentData_append(QQmlListProperty<QObject> *prop, QObject *obj) { QQuickMenuPrivate *p = static_cast<QQuickMenuPrivate *>(prop->data); QQuickMenu *q = static_cast<QQuickMenu *>(prop->object); + QQuickItem *item = qobject_cast<QQuickItem *>(obj); + if (!item) { + if (QQuickAction *action = qobject_cast<QQuickAction *>(obj)) + item = p->createItem(action); + } + if (item) { if (QQuickItemPrivate::get(item)->isTransparentForPositioner()) { QQuickItemPrivate::get(item)->addItemChangeListener(p, QQuickItemPrivate::SiblingOrder); @@ -358,22 +467,61 @@ void QQuickMenu::moveItem(int from, int to) } /*! + \deprecated \qmlmethod void QtQuick.Controls::Menu::removeItem(int index) - Removes the item at \a index. + Use Menu::removeItem(Item) or Menu::takeItem(int) instead. +*/ +void QQuickMenu::removeItem(const QVariant &var) +{ + if (var.userType() == QMetaType::Nullptr) + return; + + if (QQuickItem *item = var.value<QQuickItem *>()) + removeItem(item); + else + takeItem(var.toInt()); +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlmethod void QtQuick.Controls::Menu::removeItem(Item item) + + Removes and destroys the specified \a item. +*/ +void QQuickMenu::removeItem(QQuickItem *item) +{ + Q_D(QQuickMenu); + if (!item) + return; + + const int index = d->contentModel->indexOf(item, nullptr); + if (index == -1) + return; + + d->removeItem(index, item); + item->deleteLater(); +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlmethod MenuItem QtQuick.Controls::Menu::takeItem(int index) + + Removes and returns the item at \a index. \note The ownership of the item is transferred to the caller. */ -void QQuickMenu::removeItem(int index) +QQuickItem *QQuickMenu::takeItem(int index) { Q_D(QQuickMenu); const int count = d->contentModel->count(); if (index < 0 || index >= count) - return; + return nullptr; QQuickItem *item = itemAt(index); if (item) d->removeItem(index, item); + return item; } /*! @@ -449,7 +597,139 @@ void QQuickMenu::setTitle(QString &title) if (title == d->title) return; d->title = title; - emit titleChanged(); + emit titleChanged(title); +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty Component QtQuick.Controls::Menu::delegate + + This property holds the component that is used to create items + to present actions. + + \code + Menu { + Action { text: "Cut" } + Action { text: "Copy" } + Action { text: "Paste" } + } + \endcode + + \sa Action +*/ +QQmlComponent *QQuickMenu::delegate() const +{ + Q_D(const QQuickMenu); + return d->delegate; +} + +void QQuickMenu::setDelegate(QQmlComponent *delegate) +{ + Q_D(QQuickMenu); + if (d->delegate == delegate) + return; + + d->delegate = delegate; + emit delegateChanged(); +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlmethod void QtQuick.Controls::Menu::popup(MenuItem item = null) + + Opens the menu at the mouse cursor on desktop platforms that have a mouse cursor + available, and otherwise centers the menu over its parent item. + + The menu can be optionally aligned to a specific menu \a item. + + \sa Popup::open() +*/ + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlmethod void QtQuick.Controls::Menu::popup(point pos, MenuItem item = null) + + Opens the menu at the specified position \a pos in the popups coordinate system, + that is, a coordinate relative to its parent item. + + The menu can be optionally aligned to a specific menu \a item. + + \sa Popup::open() +*/ + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlmethod void QtQuick.Controls::Menu::popup(real x, real y, MenuItem item = null) + + Opens the menu at the specified position \a x, \a y in the popups coordinate system, + that is, a coordinate relative to its parent item. + + The menu can be optionally aligned to a specific menu \a item. + + \sa Popup::open() +*/ +void QQuickMenu::popup(QQmlV4Function *args) +{ + Q_D(QQuickMenu); + const int len = args->length(); + if (len > 3) { + args->v4engine()->throwTypeError(); + return; + } + + QV4::ExecutionEngine *v4 = args->v4engine(); + QV4::Scope scope(v4); + + QQmlNullableValue<QPointF> pos; + QQuickMenuItem *menuItem = nullptr; + + if (len > 0) { + // MenuItem item + QV4::ScopedValue lastArg(scope, (*args)[len - 1]); + const QV4::QObjectWrapper *obj = lastArg->as<QV4::QObjectWrapper>(); + if (obj) + menuItem = qobject_cast<QQuickMenuItem *>(obj->object()); + } + + if (len >= 2) { + // real x, real y + QV4::ScopedValue firstArg(scope, (*args)[0]); + QV4::ScopedValue secondArg(scope, (*args)[1]); + if (firstArg->isNumber() && secondArg->isNumber()) + pos = QPointF(firstArg->asDouble(), secondArg->asDouble()); + } + + if (pos.isNull && len >= 1) { + // point pos + QV4::ScopedValue firstArg(scope, (*args)[0]); + const QVariant var = v4->toVariant(firstArg, -1); + if (var.userType() == QMetaType::QPointF) + pos = var.toPointF(); + } + + // Unless the position has been explicitly specified, position the menu at + // the mouse cursor on desktop platforms that have a mouse cursor available + // and support multiple windows. +#if QT_CONFIG(cursor) + if (QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::MultipleWindows)) { + if (pos.isNull && d->parentItem) + pos = d->parentItem->mapFromGlobal(QCursor::pos()); + if (menuItem) + pos.value.ry() -= d->popupItem->mapFromItem(menuItem, QPointF(0, 0)).y(); + } +#endif + + // As a fallback, center the menu over its parent item. + if (pos.isNull && d->parentItem) + pos = QPointF((d->parentItem->width() - width()) / 2, (d->parentItem->height() - height()) / 2); + + if (!pos.isNull) + setPosition(pos); + + if (menuItem) + d->setCurrentIndex(d->contentModel->indexOf(menuItem, nullptr)); + + open(); } void QQuickMenu::componentComplete() @@ -531,6 +811,11 @@ QFont QQuickMenu::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::MenuFont); } +QPalette QQuickMenu::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::MenuPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickMenu::accessibleRole() const { diff --git a/src/quicktemplates2/qquickmenu_p.h b/src/quicktemplates2/qquickmenu_p.h index 6d1a4985..04186f1a 100644 --- a/src/quicktemplates2/qquickmenu_p.h +++ b/src/quicktemplates2/qquickmenu_p.h @@ -55,6 +55,7 @@ QT_BEGIN_NAMESPACE +class QQmlComponent; class QQuickMenuItem; class QQuickMenuPrivate; @@ -63,7 +64,8 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickMenu : public QQuickPopup Q_OBJECT Q_PROPERTY(QVariant contentModel READ contentModel CONSTANT FINAL) Q_PROPERTY(QQmlListProperty<QObject> contentData READ contentData FINAL) - Q_PROPERTY(QString title READ title WRITE setTitle NOTIFY titleChanged) + Q_PROPERTY(QString title READ title WRITE setTitle NOTIFY titleChanged FINAL) + Q_PROPERTY(QQmlComponent *delegate READ delegate WRITE setDelegate NOTIFY delegateChanged FINAL REVISION 3) Q_CLASSINFO("DefaultProperty", "contentData") public: @@ -73,7 +75,9 @@ public: Q_INVOKABLE void addItem(QQuickItem *item); Q_INVOKABLE void insertItem(int index, QQuickItem *item); Q_INVOKABLE void moveItem(int from, int to); - Q_INVOKABLE void removeItem(int index); + Q_INVOKABLE void removeItem(const QVariant &item); // ### Qt 6: remove + void removeItem(QQuickItem *item); // ### Qt 6: Q_INVOKABLE + Q_REVISION(3) Q_INVOKABLE QQuickItem *takeItem(int index); QVariant contentModel() const; QQmlListProperty<QObject> contentData(); @@ -81,6 +85,11 @@ public: QString title() const; void setTitle(QString &title); + QQmlComponent *delegate() const; + void setDelegate(QQmlComponent *delegate); + + Q_REVISION(3) Q_INVOKABLE void popup(QQmlV4Function *args); + protected: void componentComplete() override; void contentItemChange(QQuickItem *newItem, QQuickItem *oldItem) override; @@ -88,10 +97,12 @@ protected: void keyReleaseEvent(QKeyEvent *event) override; Q_SIGNALS: - void titleChanged(); + void titleChanged(const QString &title); + Q_REVISION(3) void delegateChanged(); protected: QFont defaultFont() const override; + QPalette defaultPalette() const override; #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; diff --git a/src/quicktemplates2/qquickmenu_p_p.h b/src/quicktemplates2/qquickmenu_p_p.h index 504bc74d..b9e0512b 100644 --- a/src/quicktemplates2/qquickmenu_p_p.h +++ b/src/quicktemplates2/qquickmenu_p_p.h @@ -55,7 +55,11 @@ QT_BEGIN_NAMESPACE +class QQuickMenu; +class QQuickAction; +class QQmlComponent; class QQmlObjectModel; +class QQuickMenuItem; class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickMenuPrivate : public QQuickPopupPrivate { @@ -68,6 +72,7 @@ public: void insertItem(int index, QQuickItem *item); void moveItem(int from, int to); void removeItem(int index, QQuickItem *item); + QQuickItem *createItem(QQuickAction *action); void resizeItem(QQuickItem *item); void resizeItems(); @@ -79,6 +84,7 @@ public: void itemGeometryChanged(QQuickItem *, QQuickGeometryChange change, const QRectF &diff) override; void onItemPressed(); + void onItemHovered(); void onItemActiveFocusChanged(); int currentIndex() const; @@ -89,9 +95,11 @@ public: static QObject *contentData_at(QQmlListProperty<QObject> *prop, int index); static void contentData_clear(QQmlListProperty<QObject> *prop); + QPointer<QQuickMenuItem> currentItem; QQuickItem *contentItem; // TODO: cleanup QVector<QObject *> contentData; QQmlObjectModel *contentModel; + QQmlComponent *delegate; QString title; }; diff --git a/src/quicktemplates2/qquickmenuitem.cpp b/src/quicktemplates2/qquickmenuitem.cpp index e15640fb..3ef03caf 100644 --- a/src/quicktemplates2/qquickmenuitem.cpp +++ b/src/quicktemplates2/qquickmenuitem.cpp @@ -35,7 +35,7 @@ ****************************************************************************/ #include "qquickmenuitem_p.h" -#include "qquickabstractbutton_p_p.h" +#include "qquickmenuitem_p_p.h" #include <QtGui/qpa/qplatformtheme.h> #include <QtQuick/private/qquickevents_p_p.h> @@ -55,6 +55,10 @@ QT_BEGIN_NAMESPACE providing a familiar way to respond to menu items being \l triggered, for example. + MenuItem inherits its API from AbstractButton. For instance, you can set + \l {AbstractButton::text}{text} and \l [QML]{Button Icons}{icon} using the + AbstractButton API + \code Button { id: fileButton @@ -83,19 +87,20 @@ QT_BEGIN_NAMESPACE \sa {Customizing MenuItem}, {Menu Controls} */ -class QQuickMenuItemPrivate : public QQuickAbstractButtonPrivate +QQuickMenuItemPrivate::QQuickMenuItemPrivate() + : highlighted(false), + menu(nullptr) { - Q_DECLARE_PUBLIC(QQuickMenuItem) - -public: - QQuickMenuItemPrivate(); - - bool highlighted; -}; +} -QQuickMenuItemPrivate::QQuickMenuItemPrivate() - : highlighted(false) +void QQuickMenuItemPrivate::setMenu(QQuickMenu *newMenu) { + Q_Q(QQuickMenuItem); + if (menu == newMenu) + return; + + menu = newMenu; + emit q->menuChanged(); } /*! @@ -110,18 +115,12 @@ QQuickMenuItem::QQuickMenuItem(QQuickItem *parent) connect(this, &QQuickAbstractButton::clicked, this, &QQuickMenuItem::triggered); } -QFont QQuickMenuItem::defaultFont() const -{ - return QQuickControlPrivate::themeFont(QPlatformTheme::MenuItemFont); -} - /*! \qmlproperty bool QtQuick.Controls::MenuItem::highlighted - This property holds whether the menu item is highlighted. + This property holds whether the menu item is highlighted by the user. - A menu item can be highlighted in order to draw the user's attention - towards it. It has no effect on keyboard interaction. + A menu item can be highlighted by mouse hover or keyboard navigation. The default value is \c false. */ @@ -141,6 +140,30 @@ void QQuickMenuItem::setHighlighted(bool highlighted) emit highlightedChanged(); } +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty Menu QtQuick.Controls::MenuItem::menu + \readonly + + This property holds the menu that contains this menu item, + or \c null if the item is not in a menu. +*/ +QQuickMenu *QQuickMenuItem::menu() const +{ + Q_D(const QQuickMenuItem); + return d->menu; +} + +QFont QQuickMenuItem::defaultFont() const +{ + return QQuickControlPrivate::themeFont(QPlatformTheme::MenuItemFont); +} + +QPalette QQuickMenuItem::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::MenuPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickMenuItem::accessibleRole() const { diff --git a/src/quicktemplates2/qquickmenuitem_p.h b/src/quicktemplates2/qquickmenuitem_p.h index 76f41f9d..92b42488 100644 --- a/src/quicktemplates2/qquickmenuitem_p.h +++ b/src/quicktemplates2/qquickmenuitem_p.h @@ -52,12 +52,14 @@ QT_BEGIN_NAMESPACE +class QQuickMenu; class QQuickMenuItemPrivate; class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickMenuItem : public QQuickAbstractButton { Q_OBJECT Q_PROPERTY(bool highlighted READ isHighlighted WRITE setHighlighted NOTIFY highlightedChanged FINAL) + Q_PROPERTY(QQuickMenu *menu READ menu NOTIFY menuChanged FINAL REVISION 3) public: explicit QQuickMenuItem(QQuickItem *parent = nullptr); @@ -65,12 +67,16 @@ public: bool isHighlighted() const; void setHighlighted(bool highlighted); + QQuickMenu *menu() const; + Q_SIGNALS: void triggered(); void highlightedChanged(); + Q_REVISION(3) void menuChanged(); protected: QFont defaultFont() const override; + QPalette defaultPalette() const override; #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; diff --git a/src/quicktemplates2/qquickmenuitem_p_p.h b/src/quicktemplates2/qquickmenuitem_p_p.h new file mode 100644 index 00000000..f1cded91 --- /dev/null +++ b/src/quicktemplates2/qquickmenuitem_p_p.h @@ -0,0 +1,78 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the Qt Quick Templates 2 module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** 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 http://www.qt.io/terms-conditions. For further +** information use the contact form at http://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.LGPLv3 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.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 later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQUICKMENUITEM_P_P_H +#define QQUICKMENUITEM_P_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtQuickTemplates2/private/qquickmenuitem_p.h> +#include <QtQuickTemplates2/private/qquickabstractbutton_p_p.h> + +QT_BEGIN_NAMESPACE + +class QQuickMenu; + +class QQuickMenuItemPrivate : public QQuickAbstractButtonPrivate +{ + Q_DECLARE_PUBLIC(QQuickMenuItem) + +public: + QQuickMenuItemPrivate(); + + static QQuickMenuItemPrivate *get(QQuickMenuItem *item) + { + return item->d_func(); + } + + void setMenu(QQuickMenu *menu); + + bool highlighted; + QQuickMenu *menu; +}; + +QT_END_NAMESPACE + +#endif // QQUICKMENUITEM_P_P_H diff --git a/src/quicktemplates2/qquickmenuseparator.cpp b/src/quicktemplates2/qquickmenuseparator.cpp index 366f0a27..f80cc775 100644 --- a/src/quicktemplates2/qquickmenuseparator.cpp +++ b/src/quicktemplates2/qquickmenuseparator.cpp @@ -35,6 +35,7 @@ ****************************************************************************/ #include "qquickmenuseparator_p.h" +#include "qquickcontrol_p_p.h" QT_BEGIN_NAMESPACE @@ -70,6 +71,11 @@ QQuickMenuSeparator::QQuickMenuSeparator(QQuickItem *parent) { } +QPalette QQuickMenuSeparator::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::MenuPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickMenuSeparator::accessibleRole() const { diff --git a/src/quicktemplates2/qquickmenuseparator_p.h b/src/quicktemplates2/qquickmenuseparator_p.h index 42147f77..002b68ba 100644 --- a/src/quicktemplates2/qquickmenuseparator_p.h +++ b/src/quicktemplates2/qquickmenuseparator_p.h @@ -60,6 +60,8 @@ public: explicit QQuickMenuSeparator(QQuickItem *parent = nullptr); protected: + QPalette defaultPalette() const override; + #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; #endif diff --git a/src/quicktemplates2/qquickoverlay_p_p.h b/src/quicktemplates2/qquickoverlay_p_p.h index 5008aa09..05177a49 100644 --- a/src/quicktemplates2/qquickoverlay_p_p.h +++ b/src/quicktemplates2/qquickoverlay_p_p.h @@ -48,7 +48,7 @@ // We mean it. // -#include "qquickoverlay_p.h" +#include <QtQuickTemplates2/private/qquickoverlay_p.h> #include <QtQuick/private/qquickitem_p.h> #include <QtQuick/private/qquickitemchangelistener_p.h> diff --git a/src/quicktemplates2/qquickpalette.cpp b/src/quicktemplates2/qquickpalette.cpp new file mode 100644 index 00000000..018d6fdc --- /dev/null +++ b/src/quicktemplates2/qquickpalette.cpp @@ -0,0 +1,326 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the Qt Quick Templates 2 module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** 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 http://www.qt.io/terms-conditions. For further +** information use the contact form at http://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.LGPLv3 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.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 later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qquickpalette_p.h" + +QT_BEGIN_NAMESPACE + +QColor QQuickPalette::alternateBase() const +{ + return v.color(QPalette::AlternateBase); +} + +void QQuickPalette::setAlternateBase(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::AlternateBase, color); +} + +void QQuickPalette::resetAlternateBase() +{ + v.resolve(v.resolve() & ~(1 << QPalette::AlternateBase)); +} + +QColor QQuickPalette::base() const +{ + return v.color(QPalette::Base); +} + +void QQuickPalette::setBase(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::Base, color); +} + +void QQuickPalette::resetBase() +{ + v.resolve(v.resolve() & ~(1 << QPalette::Base)); +} + +QColor QQuickPalette::brightText() const +{ + return v.color(QPalette::BrightText); +} + +void QQuickPalette::setBrightText(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::BrightText, color); +} + +void QQuickPalette::resetBrightText() +{ + v.resolve(v.resolve() & ~(1 << QPalette::BrightText)); +} + +QColor QQuickPalette::button() const +{ + return v.color(QPalette::Button); +} + +void QQuickPalette::setButton(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::Button, color); +} + +void QQuickPalette::resetButton() +{ + v.resolve(v.resolve() & ~(1 << QPalette::Button)); +} + +QColor QQuickPalette::buttonText() const +{ + return v.color(QPalette::ButtonText); +} + +void QQuickPalette::setButtonText(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::ButtonText, color); +} + +void QQuickPalette::resetButtonText() +{ + v.resolve(v.resolve() & ~(1 << QPalette::ButtonText)); +} + +QColor QQuickPalette::dark() const +{ + return v.color(QPalette::Dark); +} + +void QQuickPalette::setDark(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::Dark, color); +} + +void QQuickPalette::resetDark() +{ + v.resolve(v.resolve() & ~(1 << QPalette::Dark)); +} + +QColor QQuickPalette::highlight() const +{ + return v.color(QPalette::Highlight); +} + +void QQuickPalette::setHighlight(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::Highlight, color); +} + +void QQuickPalette::resetHighlight() +{ + v.resolve(v.resolve() & ~(1 << QPalette::Highlight)); +} + +QColor QQuickPalette::highlightedText() const +{ + return v.color(QPalette::HighlightedText); +} + +void QQuickPalette::setHighlightedText(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::HighlightedText, color); +} + +void QQuickPalette::resetHighlightedText() +{ + v.resolve(v.resolve() & ~(1 << QPalette::HighlightedText)); +} + +QColor QQuickPalette::light() const +{ + return v.color(QPalette::Light); +} + +void QQuickPalette::setLight(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::Light, color); +} + +void QQuickPalette::resetLight() +{ + v.resolve(v.resolve() & ~(1 << QPalette::Light)); +} + +QColor QQuickPalette::link() const +{ + return v.color(QPalette::Link); +} + +void QQuickPalette::setLink(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::Link, color); +} + +void QQuickPalette::resetLink() +{ + v.resolve(v.resolve() & ~(1 << QPalette::Link)); +} + +QColor QQuickPalette::linkVisited() const +{ + return v.color(QPalette::LinkVisited); +} + +void QQuickPalette::setLinkVisited(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::LinkVisited, color); +} + +void QQuickPalette::resetLinkVisited() +{ + v.resolve(v.resolve() & ~(1 << QPalette::LinkVisited)); +} + +QColor QQuickPalette::mid() const +{ + return v.color(QPalette::Mid); +} + +void QQuickPalette::setMid(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::Mid, color); +} + +void QQuickPalette::resetMid() +{ + v.resolve(v.resolve() & ~(1 << QPalette::Mid)); +} + +QColor QQuickPalette::midlight() const +{ + return v.color(QPalette::Midlight); +} + +void QQuickPalette::setMidlight(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::Midlight, color); +} + +void QQuickPalette::resetMidlight() +{ + v.resolve(v.resolve() & ~(1 << QPalette::Midlight)); +} + +QColor QQuickPalette::shadow() const +{ + return v.color(QPalette::Shadow); +} + +void QQuickPalette::setShadow(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::Shadow, color); +} + +void QQuickPalette::resetShadow() +{ + v.resolve(v.resolve() & ~(1 << QPalette::Shadow)); +} + +QColor QQuickPalette::text() const +{ + return v.color(QPalette::Text); +} + +void QQuickPalette::setText(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::Text, color); +} + +void QQuickPalette::resetText() +{ + v.resolve(v.resolve() & ~(1 << QPalette::Text)); +} + +QColor QQuickPalette::toolTipBase() const +{ + return v.color(QPalette::ToolTipBase); +} + +void QQuickPalette::setToolTipBase(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::ToolTipBase, color); +} + +void QQuickPalette::resetToolTipBase() +{ + v.resolve(v.resolve() & ~(1 << QPalette::ToolTipBase)); +} + +QColor QQuickPalette::toolTipText() const +{ + return v.color(QPalette::ToolTipText); +} + +void QQuickPalette::setToolTipText(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::ToolTipText, color); +} + +void QQuickPalette::resetToolTipText() +{ + v.resolve(v.resolve() & ~(1 << QPalette::ToolTipText)); +} + +QColor QQuickPalette::window() const +{ + return v.color(QPalette::Window); +} + +void QQuickPalette::setWindow(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::Window, color); +} + +void QQuickPalette::resetWindow() +{ + v.resolve(v.resolve() & ~(1 << QPalette::Window)); +} + +QColor QQuickPalette::windowText() const +{ + return v.color(QPalette::WindowText); +} + +void QQuickPalette::setWindowText(const QColor &color) +{ + v.setColor(QPalette::All, QPalette::WindowText, color); +} + +void QQuickPalette::resetWindowText() +{ + v.resolve(v.resolve() & ~(1 << QPalette::WindowText)); +} + +QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquickpalette_p.h b/src/quicktemplates2/qquickpalette_p.h new file mode 100644 index 00000000..d43e78a6 --- /dev/null +++ b/src/quicktemplates2/qquickpalette_p.h @@ -0,0 +1,163 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the Qt Quick Templates 2 module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** 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 http://www.qt.io/terms-conditions. For further +** information use the contact form at http://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.LGPLv3 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.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 later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQUICKPALETTE_P_H +#define QQUICKPALETTE_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtGui/qcolor.h> +#include <QtGui/qpalette.h> +#include <QtQuickTemplates2/private/qtquicktemplates2global_p.h> + +QT_BEGIN_NAMESPACE + +class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickPalette +{ + Q_GADGET + Q_PROPERTY(QColor alternateBase READ alternateBase WRITE setAlternateBase RESET resetAlternateBase FINAL) + Q_PROPERTY(QColor base READ base WRITE setBase RESET resetBase FINAL) + Q_PROPERTY(QColor brightText READ brightText WRITE setBrightText RESET resetBrightText FINAL) + Q_PROPERTY(QColor button READ button WRITE setButton RESET resetButton FINAL) + Q_PROPERTY(QColor buttonText READ buttonText WRITE setButtonText RESET resetButtonText FINAL) + Q_PROPERTY(QColor dark READ dark WRITE setDark RESET resetDark FINAL) + Q_PROPERTY(QColor highlight READ highlight WRITE setHighlight RESET resetHighlight FINAL) + Q_PROPERTY(QColor highlightedText READ highlightedText WRITE setHighlightedText RESET resetHighlightedText FINAL) + Q_PROPERTY(QColor light READ light WRITE setLight RESET resetLight FINAL) + Q_PROPERTY(QColor link READ link WRITE setLink RESET resetLink FINAL) + Q_PROPERTY(QColor linkVisited READ linkVisited WRITE setLinkVisited RESET resetLinkVisited FINAL) + Q_PROPERTY(QColor mid READ mid WRITE setMid RESET resetMid FINAL) + Q_PROPERTY(QColor midlight READ midlight WRITE setMidlight RESET resetMidlight FINAL) + Q_PROPERTY(QColor shadow READ shadow WRITE setShadow RESET resetShadow FINAL) + Q_PROPERTY(QColor text READ text WRITE setText RESET resetText FINAL) + Q_PROPERTY(QColor toolTipBase READ toolTipBase WRITE setToolTipBase RESET resetToolTipBase FINAL) + Q_PROPERTY(QColor toolTipText READ toolTipText WRITE setToolTipText RESET resetToolTipText FINAL) + Q_PROPERTY(QColor window READ window WRITE setWindow RESET resetWindow FINAL) + Q_PROPERTY(QColor windowText READ windowText WRITE setWindowText RESET resetWindowText FINAL) + +public: + QColor alternateBase() const; + void setAlternateBase(const QColor &color); + void resetAlternateBase(); + + QColor base() const; + void setBase(const QColor &color); + void resetBase(); + + QColor brightText() const; + void setBrightText(const QColor &color); + void resetBrightText(); + + QColor button() const; + void setButton(const QColor &color); + void resetButton(); + + QColor buttonText() const; + void setButtonText(const QColor &color); + void resetButtonText(); + + QColor dark() const; + void setDark(const QColor &color); + void resetDark(); + + QColor highlight() const; + void setHighlight(const QColor &color); + void resetHighlight(); + + QColor highlightedText() const; + void setHighlightedText(const QColor &color); + void resetHighlightedText(); + + QColor light() const; + void setLight(const QColor &color); + void resetLight(); + + QColor link() const; + void setLink(const QColor &color); + void resetLink(); + + QColor linkVisited() const; + void setLinkVisited(const QColor &color); + void resetLinkVisited(); + + QColor mid() const; + void setMid(const QColor &color); + void resetMid(); + + QColor midlight() const; + void setMidlight(const QColor &color); + void resetMidlight(); + + QColor shadow() const; + void setShadow(const QColor &color); + void resetShadow(); + + QColor text() const; + void setText(const QColor &color); + void resetText(); + + QColor toolTipBase() const; + void setToolTipBase(const QColor &color); + void resetToolTipBase(); + + QColor toolTipText() const; + void setToolTipText(const QColor &color); + void resetToolTipText(); + + QColor window() const; + void setWindow(const QColor &color); + void resetWindow(); + + QColor windowText() const; + void setWindowText(const QColor &color); + void resetWindowText(); + +private: + QPalette v; +}; + +QT_END_NAMESPACE + +#endif // QQUICKPALETTE_P_H diff --git a/src/quicktemplates2/qquickpopup.cpp b/src/quicktemplates2/qquickpopup.cpp index 54f45767..9e0015fa 100644 --- a/src/quicktemplates2/qquickpopup.cpp +++ b/src/quicktemplates2/qquickpopup.cpp @@ -461,6 +461,7 @@ bool QQuickPopupPrivate::prepareExitTransition() } transitionState = ExitTransition; emit q->aboutToHide(); + emit q->openedChanged(); } return true; } @@ -471,6 +472,7 @@ void QQuickPopupPrivate::finalizeEnterTransition() if (focus) popupItem->setFocus(true); transitionState = NoTransition; + emit q->openedChanged(); emit q->opened(); } @@ -577,6 +579,7 @@ void QQuickPopupPrivate::setWindow(QQuickWindow *newWindow) QQuickControlPrivate *p = QQuickControlPrivate::get(popupItem); p->resolveFont(); + p->resolvePalette(); if (QQuickApplicationWindow *appWindow = qobject_cast<QQuickApplicationWindow *>(newWindow)) p->updateLocale(appWindow->locale(), false); // explicit=false } @@ -667,6 +670,7 @@ QQuickPopup::~QQuickPopup() setParentItem(nullptr); d->popupItem->ungrabShortcut(); delete d->popupItem; + d->popupItem = nullptr; } /*! @@ -1361,6 +1365,53 @@ void QQuickPopup::resetFont() d->popupItem->resetFont(); } + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty palette QtQuick.Controls::Popup::palette + + This property holds the palette currently set for the popup. + + Popup propagates explicit palette properties to its children. If you change a specific + property on a popup's palette, that property propagates to all of the popup's children, + overriding any system defaults for that property. + + \code + Popup { + palette.text: "red" + + Column { + Label { + text: qsTr("This will use red color...") + } + + Switch { + text: qsTr("... and so will this") + } + } + } + \endcode + + \sa Control::palette, ApplicationWindow::palette +*/ +QPalette QQuickPopup::palette() const +{ + Q_D(const QQuickPopup); + return d->popupItem->palette(); +} + +void QQuickPopup::setPalette(const QPalette &palette) +{ + Q_D(QQuickPopup); + d->popupItem->setPalette(palette); +} + +void QQuickPopup::resetPalette() +{ + Q_D(QQuickPopup); + d->popupItem->resetPalette(); +} + QQuickWindow *QQuickPopup::window() const { Q_D(const QQuickPopup); @@ -1659,7 +1710,7 @@ void QQuickPopup::resetDim() This property holds whether the popup is visible. The default value is \c false. - \sa open(), close() + \sa open(), close(), opened */ bool QQuickPopup::isVisible() const { @@ -1684,6 +1735,21 @@ void QQuickPopup::setVisible(bool visible) } /*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::Popup::opened + + This property holds whether the popup is fully open. The popup is considered opened + when it's visible and neither the \l enter nor \l exit transitions are running. + + \sa open(), close(), visible +*/ +bool QQuickPopup::isOpened() const +{ + Q_D(const QQuickPopup); + return d->transitionState == QQuickPopupPrivate::NoTransition && isVisible(); +} + +/*! \qmlproperty real QtQuick.Controls::Popup::opacity This property holds the opacity of the popup. Opacity is specified as a number between @@ -2117,6 +2183,13 @@ void QQuickPopup::paddingChange(const QMarginsF &newPadding, const QMarginsF &ol emit availableHeightChanged(); } +void QQuickPopup::paletteChange(const QPalette &newPalette, const QPalette &oldPalette) +{ + Q_UNUSED(newPalette); + Q_UNUSED(oldPalette); + emit paletteChanged(); +} + void QQuickPopup::spacingChange(qreal newSpacing, qreal oldSpacing) { Q_UNUSED(newSpacing); @@ -2129,6 +2202,11 @@ QFont QQuickPopup::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::SystemFont); } +QPalette QQuickPopup::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::SystemPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickPopup::accessibleRole() const { diff --git a/src/quicktemplates2/qquickpopup_p.h b/src/quicktemplates2/qquickpopup_p.h index 04179f08..bf41e7d0 100644 --- a/src/quicktemplates2/qquickpopup_p.h +++ b/src/quicktemplates2/qquickpopup_p.h @@ -53,6 +53,7 @@ #include <QtGui/qevent.h> #include <QtCore/qlocale.h> #include <QtGui/qfont.h> +#include <QtGui/qpalette.h> #include <QtQuickTemplates2/private/qtquicktemplates2global_p.h> #include <QtQml/qqml.h> #include <QtQml/qqmllist.h> @@ -97,6 +98,7 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickPopup : public QObject, public QQml Q_PROPERTY(qreal bottomPadding READ bottomPadding WRITE setBottomPadding RESET resetBottomPadding NOTIFY bottomPaddingChanged FINAL) Q_PROPERTY(QLocale locale READ locale WRITE setLocale RESET resetLocale NOTIFY localeChanged FINAL) Q_PROPERTY(QFont font READ font WRITE setFont RESET resetFont NOTIFY fontChanged FINAL) + Q_PROPERTY(QPalette palette READ palette WRITE setPalette RESET resetPalette NOTIFY paletteChanged FINAL REVISION 3) Q_PROPERTY(QQuickItem *parent READ parentItem WRITE setParentItem NOTIFY parentChanged FINAL) Q_PROPERTY(QQuickItem *background READ background WRITE setBackground NOTIFY backgroundChanged FINAL) Q_PROPERTY(QQuickItem *contentItem READ contentItem WRITE setContentItem NOTIFY contentItemChanged FINAL) @@ -108,10 +110,11 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickPopup : public QObject, public QQml Q_PROPERTY(bool modal READ isModal WRITE setModal NOTIFY modalChanged FINAL) Q_PROPERTY(bool dim READ dim WRITE setDim RESET resetDim NOTIFY dimChanged FINAL) Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged FINAL) + Q_PROPERTY(bool opened READ isOpened NOTIFY openedChanged FINAL REVISION 3) Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity NOTIFY opacityChanged FINAL) Q_PROPERTY(qreal scale READ scale WRITE setScale NOTIFY scaleChanged FINAL) Q_PROPERTY(ClosePolicy closePolicy READ closePolicy WRITE setClosePolicy NOTIFY closePolicyChanged FINAL) - Q_PROPERTY(TransformOrigin transformOrigin READ transformOrigin WRITE setTransformOrigin) + Q_PROPERTY(TransformOrigin transformOrigin READ transformOrigin WRITE setTransformOrigin FINAL) Q_PROPERTY(QQuickTransition *enter READ enter WRITE setEnter NOTIFY enterChanged FINAL) Q_PROPERTY(QQuickTransition *exit READ exit WRITE setExit NOTIFY exitChanged FINAL) Q_CLASSINFO("DefaultProperty", "contentData") @@ -207,6 +210,10 @@ public: void setFont(const QFont &font); void resetFont(); + QPalette palette() const; + void setPalette(const QPalette &palette); + void resetPalette(); + QQuickWindow *window() const; QQuickItem *popupItem() const; @@ -240,6 +247,8 @@ public: bool isVisible() const; virtual void setVisible(bool visible); + bool isOpened() const; + qreal opacity() const; void setOpacity(qreal opacity); @@ -311,6 +320,7 @@ Q_SIGNALS: void bottomPaddingChanged(); void fontChanged(); void localeChanged(); + Q_REVISION(3) void paletteChanged(); void parentChanged(); void backgroundChanged(); void contentItemChanged(); @@ -321,6 +331,7 @@ Q_SIGNALS: void modalChanged(); void dimChanged(); void visibleChanged(); + Q_REVISION(3) void openedChanged(); void opacityChanged(); void scaleChanged(); void closePolicyChanged(); @@ -366,9 +377,11 @@ protected: virtual void itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &data); virtual void marginsChange(const QMarginsF &newMargins, const QMarginsF &oldMargins); virtual void paddingChange(const QMarginsF &newPadding, const QMarginsF &oldPadding); + virtual void paletteChange(const QPalette &newPalette, const QPalette &oldPalette); virtual void spacingChange(qreal newSpacing, qreal oldSpacing); virtual QFont defaultFont() const; + virtual QPalette defaultPalette() const; #if QT_CONFIG(accessibility) virtual QAccessible::Role accessibleRole() const; diff --git a/src/quicktemplates2/qquickpopup_p_p.h b/src/quicktemplates2/qquickpopup_p_p.h index ce64d49e..857bb6ae 100644 --- a/src/quicktemplates2/qquickpopup_p_p.h +++ b/src/quicktemplates2/qquickpopup_p_p.h @@ -48,8 +48,8 @@ // We mean it. // -#include "qquickpopup_p.h" -#include "qquickcontrol_p.h" +#include <QtQuickTemplates2/private/qquickpopup_p.h> +#include <QtQuickTemplates2/private/qquickcontrol_p.h> #include <QtCore/private/qobject_p.h> #include <QtQuick/qquickitem.h> diff --git a/src/quicktemplates2/qquickpopupitem.cpp b/src/quicktemplates2/qquickpopupitem.cpp index 952c2db6..27b800f0 100644 --- a/src/quicktemplates2/qquickpopupitem.cpp +++ b/src/quicktemplates2/qquickpopupitem.cpp @@ -56,6 +56,7 @@ public: void implicitHeightChanged() override; void resolveFont() override; + void resolvePalette() override; QQuickItem *getContentItem() override; @@ -92,6 +93,14 @@ void QQuickPopupItemPrivate::resolveFont() inheritFont(themeFont(QPlatformTheme::SystemFont)); } +void QQuickPopupItemPrivate::resolvePalette() +{ + if (QQuickApplicationWindow *window = qobject_cast<QQuickApplicationWindow *>(popup->window())) + inheritPalette(window->palette()); + else + inheritPalette(themePalette(QPlatformTheme::SystemPalette)); +} + QQuickItem *QQuickPopupItemPrivate::getContentItem() { Q_Q(QQuickPopupItem); @@ -294,12 +303,25 @@ void QQuickPopupItem::paddingChange(const QMarginsF &newPadding, const QMarginsF d->popup->paddingChange(newPadding, oldPadding); } +void QQuickPopupItem::paletteChange(const QPalette &newPalette, const QPalette &oldPalette) +{ + Q_D(QQuickPopupItem); + QQuickControl::paletteChange(newPalette, oldPalette); + d->popup->paletteChange(newPalette, oldPalette); +} + QFont QQuickPopupItem::defaultFont() const { Q_D(const QQuickPopupItem); return d->popup->defaultFont(); } +QPalette QQuickPopupItem::defaultPalette() const +{ + Q_D(const QQuickPopupItem); + return d->popup->defaultPalette(); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickPopupItem::accessibleRole() const { diff --git a/src/quicktemplates2/qquickpopupitem_p_p.h b/src/quicktemplates2/qquickpopupitem_p_p.h index d5447383..97f6415f 100644 --- a/src/quicktemplates2/qquickpopupitem_p_p.h +++ b/src/quicktemplates2/qquickpopupitem_p_p.h @@ -48,7 +48,7 @@ // We mean it. // -#include "qquickcontrol_p.h" +#include <QtQuickTemplates2/private/qquickcontrol_p.h> QT_BEGIN_NAMESPACE @@ -93,8 +93,10 @@ protected: void localeChange(const QLocale &newLocale, const QLocale &oldLocale) override; void itemChange(ItemChange change, const ItemChangeData &data) override; void paddingChange(const QMarginsF &newPadding, const QMarginsF &oldPadding) override; + void paletteChange(const QPalette &newPalette, const QPalette &oldPalette) override; QFont defaultFont() const override; + QPalette defaultPalette() const override; #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; diff --git a/src/quicktemplates2/qquickradiobutton.cpp b/src/quicktemplates2/qquickradiobutton.cpp index c923fbbf..86be3ed6 100644 --- a/src/quicktemplates2/qquickradiobutton.cpp +++ b/src/quicktemplates2/qquickradiobutton.cpp @@ -102,6 +102,11 @@ QFont QQuickRadioButton::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::RadioButtonFont); } +QPalette QQuickRadioButton::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::RadioButtonPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickRadioButton::accessibleRole() const { diff --git a/src/quicktemplates2/qquickradiobutton_p.h b/src/quicktemplates2/qquickradiobutton_p.h index 0fe4eb70..ea372687 100644 --- a/src/quicktemplates2/qquickradiobutton_p.h +++ b/src/quicktemplates2/qquickradiobutton_p.h @@ -61,6 +61,7 @@ public: protected: QFont defaultFont() const override; + QPalette defaultPalette() const override; #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; diff --git a/src/quicktemplates2/qquickrangeslider.cpp b/src/quicktemplates2/qquickrangeslider.cpp index 276e8d0c..c1cf13db 100644 --- a/src/quicktemplates2/qquickrangeslider.cpp +++ b/src/quicktemplates2/qquickrangeslider.cpp @@ -783,6 +783,8 @@ void QQuickRangeSlider::setSnapMode(SnapMode mode) Possible values: \value Qt.Horizontal Horizontal (default) \value Qt.Vertical Vertical + + \sa horizontal, vertical */ Qt::Orientation QQuickRangeSlider::orientation() const { @@ -801,6 +803,36 @@ void QQuickRangeSlider::setOrientation(Qt::Orientation orientation) } /*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::RangeSlider::horizontal + \readonly + + This property holds whether the slider is horizontal. + + \sa orientation +*/ +bool QQuickRangeSlider::isHorizontal() const +{ + Q_D(const QQuickRangeSlider); + return d->orientation == Qt::Horizontal; +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::RangeSlider::vertical + \readonly + + This property holds whether the slider is vertical. + + \sa orientation +*/ +bool QQuickRangeSlider::isVertical() const +{ + Q_D(const QQuickRangeSlider); + return d->orientation == Qt::Vertical; +} + +/*! \since QtQuick.Controls 2.2 (Qt 5.9) \qmlproperty bool QtQuick.Controls::RangeSlider::live diff --git a/src/quicktemplates2/qquickrangeslider_p.h b/src/quicktemplates2/qquickrangeslider_p.h index 439a0d45..82d61b37 100644 --- a/src/quicktemplates2/qquickrangeslider_p.h +++ b/src/quicktemplates2/qquickrangeslider_p.h @@ -60,11 +60,13 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickRangeSlider : public QQuickControl Q_OBJECT Q_PROPERTY(qreal from READ from WRITE setFrom NOTIFY fromChanged FINAL) Q_PROPERTY(qreal to READ to WRITE setTo NOTIFY toChanged FINAL) - Q_PROPERTY(QQuickRangeSliderNode *first READ first CONSTANT) - Q_PROPERTY(QQuickRangeSliderNode *second READ second CONSTANT) + Q_PROPERTY(QQuickRangeSliderNode *first READ first CONSTANT FINAL) + Q_PROPERTY(QQuickRangeSliderNode *second READ second CONSTANT FINAL) Q_PROPERTY(qreal stepSize READ stepSize WRITE setStepSize NOTIFY stepSizeChanged FINAL) Q_PROPERTY(SnapMode snapMode READ snapMode WRITE setSnapMode NOTIFY snapModeChanged FINAL) Q_PROPERTY(Qt::Orientation orientation READ orientation WRITE setOrientation NOTIFY orientationChanged FINAL) + Q_PROPERTY(bool horizontal READ isHorizontal NOTIFY orientationChanged FINAL REVISION 3) + Q_PROPERTY(bool vertical READ isVertical NOTIFY orientationChanged FINAL REVISION 3) Q_PROPERTY(bool live READ live WRITE setLive NOTIFY liveChanged FINAL REVISION 2) public: @@ -95,6 +97,9 @@ public: Qt::Orientation orientation() const; void setOrientation(Qt::Orientation orientation); + bool isHorizontal() const; + bool isVertical() const; + bool live() const; void setLive(bool live); diff --git a/src/quicktemplates2/qquickscrollbar.cpp b/src/quicktemplates2/qquickscrollbar.cpp index 87ff4b0a..e75fed5a 100644 --- a/src/quicktemplates2/qquickscrollbar.cpp +++ b/src/quicktemplates2/qquickscrollbar.cpp @@ -438,6 +438,8 @@ void QQuickScrollBar::setPressed(bool pressed) This property is automatically set when the scroll bar is \l {Attaching ScrollBar to a Flickable}{attached to a flickable}. + + \sa horizontal, vertical */ Qt::Orientation QQuickScrollBar::orientation() const { @@ -559,6 +561,36 @@ void QQuickScrollBar::setPolicy(Policy policy) } /*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::ScrollBar::horizontal + \readonly + + This property holds whether the scroll bar is horizontal. + + \sa orientation +*/ +bool QQuickScrollBar::isHorizontal() const +{ + Q_D(const QQuickScrollBar); + return d->orientation == Qt::Horizontal; +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::ScrollBar::vertical + \readonly + + This property holds whether the scroll bar is vertical. + + \sa orientation +*/ +bool QQuickScrollBar::isVertical() const +{ + Q_D(const QQuickScrollBar); + return d->orientation == Qt::Vertical; +} + +/*! \qmlmethod void QtQuick.Controls::ScrollBar::increase() Increases the position by \l stepSize or \c 0.1 if stepSize is \c 0.0. diff --git a/src/quicktemplates2/qquickscrollbar_p.h b/src/quicktemplates2/qquickscrollbar_p.h index 28c48428..9b417a2b 100644 --- a/src/quicktemplates2/qquickscrollbar_p.h +++ b/src/quicktemplates2/qquickscrollbar_p.h @@ -67,6 +67,8 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickScrollBar : public QQuickControl Q_PROPERTY(SnapMode snapMode READ snapMode WRITE setSnapMode NOTIFY snapModeChanged FINAL REVISION 2) Q_PROPERTY(bool interactive READ isInteractive WRITE setInteractive RESET resetInteractive NOTIFY interactiveChanged FINAL REVISION 2) Q_PROPERTY(Policy policy READ policy WRITE setPolicy NOTIFY policyChanged FINAL REVISION 2) + Q_PROPERTY(bool horizontal READ isHorizontal NOTIFY orientationChanged FINAL REVISION 3) + Q_PROPERTY(bool vertical READ isVertical NOTIFY orientationChanged FINAL REVISION 3) public: explicit QQuickScrollBar(QQuickItem *parent = nullptr); @@ -112,6 +114,9 @@ public: Policy policy() const; void setPolicy(Policy policy); + bool isHorizontal() const; + bool isVertical() const; + public Q_SLOTS: void increase(); void decrease(); diff --git a/src/quicktemplates2/qquickscrollindicator.cpp b/src/quicktemplates2/qquickscrollindicator.cpp index 347c2a68..d14138af 100644 --- a/src/quicktemplates2/qquickscrollindicator.cpp +++ b/src/quicktemplates2/qquickscrollindicator.cpp @@ -276,6 +276,8 @@ void QQuickScrollIndicator::setActive(bool active) This property is automatically set when the scroll indicator is \l {Attaching ScrollIndicator to a Flickable}{attached to a flickable}. + + \sa horizontal, vertical */ Qt::Orientation QQuickScrollIndicator::orientation() const { @@ -295,6 +297,36 @@ void QQuickScrollIndicator::setOrientation(Qt::Orientation orientation) emit orientationChanged(); } +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::ScrollIndicator::horizontal + \readonly + + This property holds whether the scroll indicator is horizontal. + + \sa orientation +*/ +bool QQuickScrollIndicator::isHorizontal() const +{ + Q_D(const QQuickScrollIndicator); + return d->orientation == Qt::Horizontal; +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::ScrollIndicator::vertical + \readonly + + This property holds whether the scroll indicator is vertical. + + \sa orientation +*/ +bool QQuickScrollIndicator::isVertical() const +{ + Q_D(const QQuickScrollIndicator); + return d->orientation == Qt::Vertical; +} + class QQuickScrollIndicatorAttachedPrivate : public QObjectPrivate, public QQuickItemChangeListener { public: diff --git a/src/quicktemplates2/qquickscrollindicator_p.h b/src/quicktemplates2/qquickscrollindicator_p.h index bc6c5418..6f08ef31 100644 --- a/src/quicktemplates2/qquickscrollindicator_p.h +++ b/src/quicktemplates2/qquickscrollindicator_p.h @@ -63,6 +63,8 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickScrollIndicator : public QQuickCont Q_PROPERTY(qreal position READ position WRITE setPosition NOTIFY positionChanged FINAL) Q_PROPERTY(bool active READ isActive WRITE setActive NOTIFY activeChanged FINAL) Q_PROPERTY(Qt::Orientation orientation READ orientation WRITE setOrientation NOTIFY orientationChanged FINAL) + Q_PROPERTY(bool horizontal READ isHorizontal NOTIFY orientationChanged FINAL REVISION 3) + Q_PROPERTY(bool vertical READ isVertical NOTIFY orientationChanged FINAL REVISION 3) public: explicit QQuickScrollIndicator(QQuickItem *parent = nullptr); @@ -78,6 +80,9 @@ public: Qt::Orientation orientation() const; void setOrientation(Qt::Orientation orientation); + bool isHorizontal() const; + bool isVertical() const; + public Q_SLOTS: void setSize(qreal size); void setPosition(qreal position); diff --git a/src/quicktemplates2/qquickslider.cpp b/src/quicktemplates2/qquickslider.cpp index 27b4a981..b5bf5e52 100644 --- a/src/quicktemplates2/qquickslider.cpp +++ b/src/quicktemplates2/qquickslider.cpp @@ -479,6 +479,36 @@ void QQuickSlider::setPressed(bool pressed) } /*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::Slider::horizontal + \readonly + + This property holds whether the slider is horizontal. + + \sa orientation +*/ +bool QQuickSlider::isHorizontal() const +{ + Q_D(const QQuickSlider); + return d->orientation == Qt::Horizontal; +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::Slider::vertical + \readonly + + This property holds whether the slider is vertical. + + \sa orientation +*/ +bool QQuickSlider::isVertical() const +{ + Q_D(const QQuickSlider); + return d->orientation == Qt::Vertical; +} + +/*! \qmlproperty enumeration QtQuick.Controls::Slider::orientation This property holds the orientation. @@ -486,6 +516,8 @@ void QQuickSlider::setPressed(bool pressed) Possible values: \value Qt.Horizontal Horizontal (default) \value Qt.Vertical Vertical + + \sa horizontal, vertical */ Qt::Orientation QQuickSlider::orientation() const { diff --git a/src/quicktemplates2/qquickslider_p.h b/src/quicktemplates2/qquickslider_p.h index 865902ab..21a880f5 100644 --- a/src/quicktemplates2/qquickslider_p.h +++ b/src/quicktemplates2/qquickslider_p.h @@ -66,6 +66,8 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickSlider : public QQuickControl Q_PROPERTY(SnapMode snapMode READ snapMode WRITE setSnapMode NOTIFY snapModeChanged FINAL) Q_PROPERTY(bool live READ live WRITE setLive NOTIFY liveChanged FINAL REVISION 2) Q_PROPERTY(bool pressed READ isPressed WRITE setPressed NOTIFY pressedChanged FINAL) + Q_PROPERTY(bool horizontal READ isHorizontal NOTIFY orientationChanged FINAL REVISION 3) + Q_PROPERTY(bool vertical READ isVertical NOTIFY orientationChanged FINAL REVISION 3) Q_PROPERTY(Qt::Orientation orientation READ orientation WRITE setOrientation NOTIFY orientationChanged FINAL) Q_PROPERTY(QQuickItem *handle READ handle WRITE setHandle NOTIFY handleChanged FINAL) @@ -103,6 +105,9 @@ public: bool isPressed() const; void setPressed(bool pressed); + bool isHorizontal() const; + bool isVertical() const; + Qt::Orientation orientation() const; void setOrientation(Qt::Orientation orientation); diff --git a/src/quicktemplates2/qquickspinbox.cpp b/src/quicktemplates2/qquickspinbox.cpp index dbb67c43..f7458011 100644 --- a/src/quicktemplates2/qquickspinbox.cpp +++ b/src/quicktemplates2/qquickspinbox.cpp @@ -108,6 +108,7 @@ class QQuickSpinBoxPrivate : public QQuickControlPrivate public: QQuickSpinBoxPrivate() : editable(false), + wrap(false), from(0), to(99), value(0), @@ -121,9 +122,10 @@ public: { } - int boundValue(int value) const; + int boundValue(int value, bool wrap) const; void updateValue(); - bool setValue(int value); + bool setValue(int value, bool wrap); + bool stepBy(int steps); int effectiveStepSize() const; @@ -143,6 +145,7 @@ public: void handleUngrab() override; bool editable; + bool wrap; int from; int to; int value; @@ -157,9 +160,20 @@ public: Qt::InputMethodHints inputMethodHints; }; -int QQuickSpinBoxPrivate::boundValue(int value) const +int QQuickSpinBoxPrivate::boundValue(int value, bool wrap) const { - return from > to ? qBound(to, value, from) : qBound(from, value, to); + bool inverted = from > to; + if (!wrap) + return inverted ? qBound(to, value, from) : qBound(from, value, to); + + int f = inverted ? to : from; + int t = inverted ? from : to; + if (value < f) + value = t; + else if (value > t) + value = f; + + return value; } void QQuickSpinBoxPrivate::updateValue() @@ -174,7 +188,7 @@ void QQuickSpinBoxPrivate::updateValue() QJSValue loc(v4, QQmlLocale::wrap(v4, locale)); QJSValue val = q->valueFromText().call(QJSValueList() << text.toString() << loc); const int oldValue = value; - q->setValue(val.toInt()); + setValue(val.toInt(), /* allowWrap = */ false); if (oldValue != value) emit q->valueModified(); } @@ -182,11 +196,11 @@ void QQuickSpinBoxPrivate::updateValue() } } -bool QQuickSpinBoxPrivate::setValue(int newValue) +bool QQuickSpinBoxPrivate::setValue(int newValue, bool allowWrap) { Q_Q(QQuickSpinBox); if (q->isComponentComplete()) - newValue = boundValue(newValue); + newValue = boundValue(newValue, allowWrap); if (value == newValue) return false; @@ -200,6 +214,11 @@ bool QQuickSpinBoxPrivate::setValue(int newValue) return true; } +bool QQuickSpinBoxPrivate::stepBy(int steps) +{ + return setValue(value + steps, wrap); +} + int QQuickSpinBoxPrivate::effectiveStepSize() const { return from > to ? -1 * stepSize : stepSize; @@ -217,7 +236,7 @@ void QQuickSpinBoxPrivate::updateUpEnabled() if (!upIndicator) return; - upIndicator->setEnabled(from < to ? value < to : value > to); + upIndicator->setEnabled(wrap || (from < to ? value < to : value > to)); } bool QQuickSpinBoxPrivate::downEnabled() const @@ -232,7 +251,7 @@ void QQuickSpinBoxPrivate::updateDownEnabled() if (!downIndicator) return; - downIndicator->setEnabled(from < to ? value > from : value < from); + downIndicator->setEnabled(wrap || (from < to ? value > from : value < from)); } void QQuickSpinBoxPrivate::updateHover(const QPointF &pos) @@ -373,7 +392,7 @@ void QQuickSpinBox::setFrom(int from) d->from = from; emit fromChanged(); if (isComponentComplete()) { - if (!d->setValue(d->value)) { + if (!d->setValue(d->value, /* allowWrap = */ false)) { d->updateUpEnabled(); d->updateDownEnabled(); } @@ -402,7 +421,7 @@ void QQuickSpinBox::setTo(int to) d->to = to; emit toChanged(); if (isComponentComplete()) { - if (!d->setValue(d->value)) { + if (!d->setValue(d->value, /* allowWrap = */false)) { d->updateUpEnabled(); d->updateDownEnabled(); } @@ -423,7 +442,7 @@ int QQuickSpinBox::value() const void QQuickSpinBox::setValue(int value) { Q_D(QQuickSpinBox); - d->setValue(value); + d->setValue(value, /* allowWrap = */ false); } /*! @@ -695,6 +714,34 @@ bool QQuickSpinBox::isInputMethodComposing() const } /*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::SpinBox::wrap + + This property holds whether the spinbox wraps. The default value is \c false. + + If wrap is \c true, stepping past \l to changes the value to \l from and vice versa. +*/ +bool QQuickSpinBox::wrap() const +{ + Q_D(const QQuickSpinBox); + return d->wrap; +} + +void QQuickSpinBox::setWrap(bool wrap) +{ + Q_D(QQuickSpinBox); + if (d->wrap == wrap) + return; + + d->wrap = wrap; + if (d->value == d->from || d->value == d->to) { + d->updateUpEnabled(); + d->updateDownEnabled(); + } + emit wrapChanged(); +} + +/*! \qmlmethod void QtQuick.Controls::SpinBox::increase() Increases the value by \l stepSize, or \c 1 if stepSize is not defined. @@ -704,7 +751,7 @@ bool QQuickSpinBox::isInputMethodComposing() const void QQuickSpinBox::increase() { Q_D(QQuickSpinBox); - setValue(d->value + d->effectiveStepSize()); + d->stepBy(d->effectiveStepSize()); } /*! @@ -717,7 +764,7 @@ void QQuickSpinBox::increase() void QQuickSpinBox::decrease() { Q_D(QQuickSpinBox); - setValue(d->value - d->effectiveStepSize()); + d->stepBy(-d->effectiveStepSize()); } void QQuickSpinBox::focusInEvent(QFocusEvent *event) @@ -820,7 +867,7 @@ void QQuickSpinBox::wheelEvent(QWheelEvent *event) const int oldValue = d->value; const QPointF angle = event->angleDelta(); const qreal delta = (qFuzzyIsNull(angle.y()) ? angle.x() : angle.y()) / QWheelEvent::DefaultDeltasPerStep; - setValue(oldValue + qRound(d->effectiveStepSize() * delta)); + d->stepBy(qRound(d->effectiveStepSize() * delta)); if (d->value != oldValue) emit valueModified(); event->setAccepted(d->value != oldValue); @@ -867,6 +914,11 @@ QFont QQuickSpinBox::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::EditorFont); } +QPalette QQuickSpinBox::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::TextLineEditPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickSpinBox::accessibleRole() const { diff --git a/src/quicktemplates2/qquickspinbox_p.h b/src/quicktemplates2/qquickspinbox_p.h index bd0d1ab2..13ba89a9 100644 --- a/src/quicktemplates2/qquickspinbox_p.h +++ b/src/quicktemplates2/qquickspinbox_p.h @@ -73,6 +73,7 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickSpinBox : public QQuickControl Q_PROPERTY(QQuickSpinButton *down READ down CONSTANT FINAL) Q_PROPERTY(Qt::InputMethodHints inputMethodHints READ inputMethodHints WRITE setInputMethodHints NOTIFY inputMethodHintsChanged FINAL REVISION 2) Q_PROPERTY(bool inputMethodComposing READ isInputMethodComposing NOTIFY inputMethodComposingChanged FINAL REVISION 2) + Q_PROPERTY(bool wrap READ wrap WRITE setWrap NOTIFY wrapChanged FINAL REVISION 3) public: explicit QQuickSpinBox(QQuickItem *parent = nullptr); @@ -109,6 +110,9 @@ public: bool isInputMethodComposing() const; + bool wrap() const; + void setWrap(bool wrap); + public Q_SLOTS: void increase(); void decrease(); @@ -125,6 +129,7 @@ Q_SIGNALS: Q_REVISION(2) void valueModified(); Q_REVISION(2) void inputMethodHintsChanged(); Q_REVISION(2) void inputMethodComposingChanged(); + Q_REVISION(3) void wrapChanged(); protected: void focusInEvent(QFocusEvent *event) override; @@ -143,6 +148,7 @@ protected: void contentItemChange(QQuickItem *newItem, QQuickItem *oldItem) override; QFont defaultFont() const override; + QPalette defaultPalette() const override; #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; diff --git a/src/quicktemplates2/qquickstackview.cpp b/src/quicktemplates2/qquickstackview.cpp index ea4e36d0..674e6ee1 100644 --- a/src/quicktemplates2/qquickstackview.cpp +++ b/src/quicktemplates2/qquickstackview.cpp @@ -516,8 +516,9 @@ void QQuickStackView::push(QQmlV4Function *args) if (!d->elements.isEmpty()) exit = d->elements.top(); + int oldDepth = d->elements.count(); if (d->pushElements(elements)) { - emit depthChanged(); + d->depthChange(d->elements.count(), oldDepth); QQuickStackElement *enter = d->elements.top(); d->startTransition(QQuickStackTransition::pushEnter(operation, enter, this), QQuickStackTransition::pushExit(operation, exit, this), @@ -574,6 +575,7 @@ void QQuickStackView::pop(QQmlV4Function *args) return; } + int oldDepth = d->elements.count(); QQuickStackElement *exit = d->elements.pop(); QQuickStackElement *enter = d->elements.top(); @@ -612,7 +614,7 @@ void QQuickStackView::pop(QQmlV4Function *args) d->removing.insert(exit); previousItem = exit->item; } - emit depthChanged(); + d->depthChange(d->elements.count(), oldDepth); d->startTransition(QQuickStackTransition::popExit(operation, exit, this), QQuickStackTransition::popEnter(operation, enter, this), operation == Immediate); @@ -752,14 +754,13 @@ void QQuickStackView::replace(QQmlV4Function *args) return; } - int depth = d->elements.count(); + int oldDepth = d->elements.count(); QQuickStackElement* exit = nullptr; if (!d->elements.isEmpty()) exit = d->elements.pop(); if (exit != target ? d->replaceElements(target, elements) : d->pushElements(elements)) { - if (depth != d->elements.count()) - emit depthChanged(); + d->depthChange(d->elements.count(), oldDepth); if (exit) { exit->removal = true; d->removing.insert(exit); @@ -780,20 +781,51 @@ void QQuickStackView::replace(QQmlV4Function *args) } /*! - \qmlmethod void QtQuick.Controls::StackView::clear() + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::StackView::empty + \readonly + + This property holds whether the stack is empty. + + \sa depth +*/ +bool QQuickStackView::isEmpty() const +{ + Q_D(const QQuickStackView); + return d->elements.isEmpty(); +} - Removes all items from the stack. No animations are applied. +/*! + \qmlmethod void QtQuick.Controls::StackView::clear(transition) + + Removes all items from the stack. + + Since QtQuick.Controls 2.3, a \a transition can be optionally specified. Supported transitions: + + \value StackView.Immediate Clear the stack immediately without any transition (default). + \value StackView.PushTransition Clear the stack with a push transition. + \value StackView.ReplaceTransition Clear the stack with a replace transition. + \value StackView.PopTransition Clear the stack with a pop transition. */ -void QQuickStackView::clear() +void QQuickStackView::clear(Operation operation) { Q_D(QQuickStackView); if (d->elements.isEmpty()) return; + if (operation != Immediate) { + QQuickStackElement *exit = d->elements.pop(); + exit->removal = true; + d->removing.insert(exit); + d->startTransition(QQuickStackTransition::popExit(operation, exit, this), + QQuickStackTransition::popEnter(operation, nullptr, this), false); + } + + int oldDepth = d->elements.count(); d->setCurrentItem(nullptr); qDeleteAll(d->elements); d->elements.clear(); - emit depthChanged(); + d->depthChange(0, oldDepth); } /*! @@ -990,6 +1022,7 @@ void QQuickStackView::componentComplete() QScopedValueRollback<QString> rollback(d->operation, QStringLiteral("initialItem")); QQuickStackElement *element = nullptr; QString error; + int oldDepth = d->elements.count(); if (QObject *o = d->initialItem.value<QObject *>()) element = QQuickStackElement::fromObject(o, this, &error); else if (d->initialItem.canConvert<QString>()) @@ -997,7 +1030,7 @@ void QQuickStackView::componentComplete() if (!error.isEmpty()) { d->warn(error); } else if (d->pushElement(element)) { - emit depthChanged(); + d->depthChange(d->elements.count(), oldDepth); d->setCurrentItem(element); element->setStatus(QQuickStackView::Active); } diff --git a/src/quicktemplates2/qquickstackview_p.cpp b/src/quicktemplates2/qquickstackview_p.cpp index 3c983d6b..f4405246 100644 --- a/src/quicktemplates2/qquickstackview_p.cpp +++ b/src/quicktemplates2/qquickstackview_p.cpp @@ -297,4 +297,15 @@ void QQuickStackViewPrivate::setBusy(bool b) emit q->busyChanged(); } +void QQuickStackViewPrivate::depthChange(int newDepth, int oldDepth) +{ + Q_Q(QQuickStackView); + if (newDepth == oldDepth) + return; + + emit q->depthChanged(); + if (newDepth == 0 || oldDepth == 0) + emit q->emptyChanged(); +} + QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquickstackview_p.h b/src/quicktemplates2/qquickstackview_p.h index b74a162d..21c20f3a 100644 --- a/src/quicktemplates2/qquickstackview_p.h +++ b/src/quicktemplates2/qquickstackview_p.h @@ -72,6 +72,7 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickStackView : public QQuickControl Q_PROPERTY(QQuickTransition *pushExit READ pushExit WRITE setPushExit NOTIFY pushExitChanged FINAL) Q_PROPERTY(QQuickTransition *replaceEnter READ replaceEnter WRITE setReplaceEnter NOTIFY replaceEnterChanged FINAL) Q_PROPERTY(QQuickTransition *replaceExit READ replaceExit WRITE setReplaceExit NOTIFY replaceExitChanged FINAL) + Q_PROPERTY(bool empty READ isEmpty NOTIFY emptyChanged FINAL REVISION 3) public: explicit QQuickStackView(QQuickItem *parent = nullptr); @@ -134,8 +135,10 @@ public: Q_INVOKABLE void pop(QQmlV4Function *args); Q_INVOKABLE void replace(QQmlV4Function *args); + bool isEmpty() const; + public Q_SLOTS: - void clear(); + void clear(Operation operation = Immediate); Q_SIGNALS: void busyChanged(); @@ -147,6 +150,7 @@ Q_SIGNALS: void pushExitChanged(); void replaceEnterChanged(); void replaceExitChanged(); + Q_REVISION(3) void emptyChanged(); protected: void componentComplete() override; diff --git a/src/quicktemplates2/qquickstackview_p_p.h b/src/quicktemplates2/qquickstackview_p_p.h index 81ca9164..d86f35cd 100644 --- a/src/quicktemplates2/qquickstackview_p_p.h +++ b/src/quicktemplates2/qquickstackview_p_p.h @@ -92,6 +92,7 @@ public: void viewItemTransitionFinished(QQuickItemViewTransitionableItem *item) override; void setBusy(bool busy); + void depthChange(int newDepth, int oldDepth); bool busy; QString operation; diff --git a/src/quicktemplates2/qquickswipedelegate_p.h b/src/quicktemplates2/qquickswipedelegate_p.h index 5ba0604d..a9900eb8 100644 --- a/src/quicktemplates2/qquickswipedelegate_p.h +++ b/src/quicktemplates2/qquickswipedelegate_p.h @@ -60,7 +60,7 @@ class QQuickSwipeDelegateAttachedPrivate; class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickSwipeDelegate : public QQuickItemDelegate { Q_OBJECT - Q_PROPERTY(QQuickSwipe *swipe READ swipe CONSTANT) + Q_PROPERTY(QQuickSwipe *swipe READ swipe CONSTANT FINAL) public: explicit QQuickSwipeDelegate(QQuickItem *parent = nullptr); diff --git a/src/quicktemplates2/qquickswipeview.cpp b/src/quicktemplates2/qquickswipeview.cpp index f6efc7e4..ce586363 100644 --- a/src/quicktemplates2/qquickswipeview.cpp +++ b/src/quicktemplates2/qquickswipeview.cpp @@ -121,6 +121,32 @@ public: Qt::Orientation orientation; }; +class QQuickSwipeViewAttachedPrivate : public QObjectPrivate +{ + Q_DECLARE_PUBLIC(QQuickSwipeViewAttached) + +public: + QQuickSwipeViewAttachedPrivate() + : swipeView(nullptr), + index(-1), + currentIndex(-1) + { + } + + static QQuickSwipeViewAttachedPrivate *get(QQuickSwipeViewAttached *attached) + { + return attached->d_func(); + } + + void update(QQuickSwipeView *newView, int newIndex); + void updateCurrentIndex(); + void setCurrentIndex(int i); + + QQuickSwipeView *swipeView; + int index; + int currentIndex; +}; + void QQuickSwipeViewPrivate::resizeItems() { Q_Q(QQuickSwipeView); @@ -190,6 +216,8 @@ void QQuickSwipeView::setInteractive(bool interactive) Possible values: \value Qt.Horizontal Horizontal (default) \value Qt.Vertical Vertical + + \sa horizontal, vertical */ Qt::Orientation QQuickSwipeView::orientation() const { @@ -209,6 +237,36 @@ void QQuickSwipeView::setOrientation(Qt::Orientation orientation) emit orientationChanged(); } +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::SwipeView::horizontal + \readonly + + This property holds whether the swipe view is horizontal. + + \sa orientation +*/ +bool QQuickSwipeView::isHorizontal() const +{ + Q_D(const QQuickSwipeView); + return d->orientation == Qt::Horizontal; +} + +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty bool QtQuick.Controls::SwipeView::vertical + \readonly + + This property holds whether the swipe view is vertical. + + \sa orientation +*/ +bool QQuickSwipeView::isVertical() const +{ + Q_D(const QQuickSwipeView); + return d->orientation == Qt::Vertical; +} + QQuickSwipeViewAttached *QQuickSwipeView::qmlAttachedProperties(QObject *object) { return new QQuickSwipeViewAttached(object); @@ -221,12 +279,29 @@ void QQuickSwipeView::geometryChanged(const QRectF &newGeometry, const QRectF &o d->resizeItems(); } -void QQuickSwipeView::itemAdded(int, QQuickItem *item) +void QQuickSwipeView::itemAdded(int index, QQuickItem *item) { Q_D(QQuickSwipeView); QQuickItemPrivate::get(item)->setCulled(true); // QTBUG-51078, QTBUG-51669 if (isComponentComplete()) item->setSize(QSizeF(d->contentItem->width(), d->contentItem->height())); + QQuickSwipeViewAttached *attached = qobject_cast<QQuickSwipeViewAttached *>(qmlAttachedPropertiesObject<QQuickSwipeView>(item)); + if (attached) + QQuickSwipeViewAttachedPrivate::get(attached)->update(this, index); +} + +void QQuickSwipeView::itemMoved(int index, QQuickItem *item) +{ + QQuickSwipeViewAttached *attached = qobject_cast<QQuickSwipeViewAttached *>(qmlAttachedPropertiesObject<QQuickSwipeView>(item)); + if (attached) + QQuickSwipeViewAttachedPrivate::get(attached)->update(this, index); +} + +void QQuickSwipeView::itemRemoved(int, QQuickItem *item) +{ + QQuickSwipeViewAttached *attached = qobject_cast<QQuickSwipeViewAttached *>(qmlAttachedPropertiesObject<QQuickSwipeView>(item)); + if (attached) + QQuickSwipeViewAttachedPrivate::get(attached)->update(nullptr, -1); } #if QT_CONFIG(accessibility) @@ -283,85 +358,11 @@ QAccessible::Role QQuickSwipeView::accessibleRole() const It is attached to each child item of the SwipeView. */ -class QQuickSwipeViewAttachedPrivate : public QObjectPrivate, public QQuickItemChangeListener -{ - Q_DECLARE_PUBLIC(QQuickSwipeViewAttached) -public: - QQuickSwipeViewAttachedPrivate() - : item(nullptr), - swipeView(nullptr), - index(-1), - currentIndex(-1) - { - } - - ~QQuickSwipeViewAttachedPrivate() { - } - - void updateView(QQuickItem *parent); - - void itemChildAdded(QQuickItem *, QQuickItem *) override; - void itemChildRemoved(QQuickItem *, QQuickItem *) override; - void itemParentChanged(QQuickItem *, QQuickItem *) override; - void itemDestroyed(QQuickItem *) override; - - void updateIndex(); - void updateCurrentIndex(); - - void setView(QQuickSwipeView *view); - void setIndex(int i); - void setCurrentIndex(int i); - - QQuickItem *item; - QQuickSwipeView *swipeView; - int index; - int currentIndex; -}; - -void QQuickSwipeViewAttachedPrivate::updateIndex() -{ - setIndex(swipeView ? QQuickSwipeViewPrivate::get(swipeView)->contentModel->indexOf(item, nullptr) : -1); -} - void QQuickSwipeViewAttachedPrivate::updateCurrentIndex() { setCurrentIndex(swipeView ? swipeView->currentIndex() : -1); } -void QQuickSwipeViewAttachedPrivate::setView(QQuickSwipeView *view) -{ - if (view == swipeView) - return; - - if (swipeView) { - QQuickItemPrivate *p = QQuickItemPrivate::get(swipeView); - p->removeItemChangeListener(this, QQuickItemPrivate::Children); - - disconnect(swipeView, &QQuickSwipeView::currentIndexChanged, - this, &QQuickSwipeViewAttachedPrivate::updateCurrentIndex); - disconnect(swipeView, &QQuickSwipeView::contentChildrenChanged, - this, &QQuickSwipeViewAttachedPrivate::updateIndex); - } - - swipeView = view; - - if (swipeView) { - QQuickItemPrivate *p = QQuickItemPrivate::get(swipeView); - p->addItemChangeListener(this, QQuickItemPrivate::Children); - - connect(swipeView, &QQuickSwipeView::currentIndexChanged, - this, &QQuickSwipeViewAttachedPrivate::updateCurrentIndex); - connect(swipeView, &QQuickSwipeView::contentChildrenChanged, - this, &QQuickSwipeViewAttachedPrivate::updateIndex); - } - - Q_Q(QQuickSwipeViewAttached); - emit q->viewChanged(); - - updateIndex(); - updateCurrentIndex(); -} - void QQuickSwipeViewAttachedPrivate::setCurrentIndex(int i) { if (i == currentIndex) @@ -381,79 +382,37 @@ void QQuickSwipeViewAttachedPrivate::setCurrentIndex(int i) emit q->isPreviousItemChanged(); } -void QQuickSwipeViewAttachedPrivate::setIndex(int i) +void QQuickSwipeViewAttachedPrivate::update(QQuickSwipeView *newView, int newIndex) { - if (i == index) - return; - - index = i; Q_Q(QQuickSwipeViewAttached); - emit q->indexChanged(); -} + int oldIndex = index; + QQuickSwipeView *oldView = swipeView; -void QQuickSwipeViewAttachedPrivate::updateView(QQuickItem *parent) -{ - // parent can be, e.g.: - // - The contentItem of a ListView (typically the case) - // - A non-visual or weird type like TestCase, when child items are created from components - // wherein the attached properties are used - // - null, when the item was removed with removeItem() - QQuickSwipeView *view = nullptr; - if (parent) { - view = qobject_cast<QQuickSwipeView*>(parent); - if (!view) { - if (parent->parentItem() && parent->parentItem()->property("contentItem").isValid()) { - // The parent is the contentItem of some kind of view. - view = qobject_cast<QQuickSwipeView*>(parent->parentItem()->parentItem()); - } + index = newIndex; + swipeView = newView; + + if (oldView != newView) { + if (oldView) { + disconnect(oldView, &QQuickSwipeView::currentIndexChanged, + this, &QQuickSwipeViewAttachedPrivate::updateCurrentIndex); } + if (newView) { + connect(newView, &QQuickSwipeView::currentIndexChanged, + this, &QQuickSwipeViewAttachedPrivate::updateCurrentIndex); + } + emit q->viewChanged(); } + if (oldIndex != newIndex) + emit q->indexChanged(); - setView(view); -} - -void QQuickSwipeViewAttachedPrivate::itemChildAdded(QQuickItem *, QQuickItem *) -{ - updateIndex(); -} - -void QQuickSwipeViewAttachedPrivate::itemChildRemoved(QQuickItem *, QQuickItem *) -{ - updateIndex(); -} - -void QQuickSwipeViewAttachedPrivate::itemParentChanged(QQuickItem *, QQuickItem *parent) -{ - updateView(parent); -} - -void QQuickSwipeViewAttachedPrivate::itemDestroyed(QQuickItem *item) -{ - QQuickItemPrivate::get(item)->removeItemChangeListener(this, QQuickItemPrivate::Parent | QQuickItemPrivate::Destroyed); + updateCurrentIndex(); } QQuickSwipeViewAttached::QQuickSwipeViewAttached(QObject *parent) : QObject(*(new QQuickSwipeViewAttachedPrivate), parent) { - Q_D(QQuickSwipeViewAttached); - d->item = qobject_cast<QQuickItem *>(parent); - if (d->item) { - if (d->item->parentItem()) - d->updateView(d->item->parentItem()); - - QQuickItemPrivate *p = QQuickItemPrivate::get(d->item); - p->addItemChangeListener(d, QQuickItemPrivate::Parent | QQuickItemPrivate::Destroyed); - } else if (parent) { + if (!qobject_cast<QQuickItem *>(parent)) qmlWarning(parent) << "SwipeView: attached properties must be accessed from within a child item"; - } -} - -QQuickSwipeViewAttached::~QQuickSwipeViewAttached() -{ - Q_D(QQuickSwipeViewAttached); - QQuickItem *item = qobject_cast<QQuickItem *>(parent()); - if (item) - QQuickItemPrivate::get(item)->removeItemChangeListener(d, QQuickItemPrivate::Parent | QQuickItemPrivate::Destroyed); } QQuickSwipeView *QQuickSwipeViewAttached::view() const diff --git a/src/quicktemplates2/qquickswipeview_p.h b/src/quicktemplates2/qquickswipeview_p.h index e07ed7f0..543cb6aa 100644 --- a/src/quicktemplates2/qquickswipeview_p.h +++ b/src/quicktemplates2/qquickswipeview_p.h @@ -60,6 +60,8 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickSwipeView : public QQuickContainer Q_OBJECT Q_PROPERTY(bool interactive READ isInteractive WRITE setInteractive NOTIFY interactiveChanged FINAL REVISION 1) Q_PROPERTY(Qt::Orientation orientation READ orientation WRITE setOrientation NOTIFY orientationChanged FINAL REVISION 2) + Q_PROPERTY(bool horizontal READ isHorizontal NOTIFY orientationChanged FINAL REVISION 3) + Q_PROPERTY(bool vertical READ isVertical NOTIFY orientationChanged FINAL REVISION 3) public: explicit QQuickSwipeView(QQuickItem *parent = nullptr); @@ -70,6 +72,9 @@ public: Qt::Orientation orientation() const; void setOrientation(Qt::Orientation orientation); + bool isHorizontal() const; + bool isVertical() const; + static QQuickSwipeViewAttached *qmlAttachedProperties(QObject *object); Q_SIGNALS: @@ -79,6 +84,8 @@ Q_SIGNALS: protected: void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) override; void itemAdded(int index, QQuickItem *item) override; + void itemMoved(int index, QQuickItem *item) override; + void itemRemoved(int index, QQuickItem *item) override; #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; @@ -102,7 +109,6 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickSwipeViewAttached : public QObject public: explicit QQuickSwipeViewAttached(QObject *parent = nullptr); - ~QQuickSwipeViewAttached(); int index() const; bool isCurrentItem() const; diff --git a/src/quicktemplates2/qquickswitch.cpp b/src/quicktemplates2/qquickswitch.cpp index f9bbff25..da1f0408 100644 --- a/src/quicktemplates2/qquickswitch.cpp +++ b/src/quicktemplates2/qquickswitch.cpp @@ -231,4 +231,10 @@ void QQuickSwitch::buttonChange(ButtonChange change) QQuickAbstractButton::buttonChange(change); } +QPalette QQuickSwitch::defaultPalette() const +{ + // ### TODO: add QPlatformTheme::SwitchPalette + return QQuickControlPrivate::themePalette(QPlatformTheme::CheckBoxPalette); +} + QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquickswitch_p.h b/src/quicktemplates2/qquickswitch_p.h index 12e20bde..0faaf114 100644 --- a/src/quicktemplates2/qquickswitch_p.h +++ b/src/quicktemplates2/qquickswitch_p.h @@ -83,6 +83,8 @@ protected: void nextCheckState() override; void buttonChange(ButtonChange change) override; + QPalette defaultPalette() const override; + private: Q_DISABLE_COPY(QQuickSwitch) Q_DECLARE_PRIVATE(QQuickSwitch) diff --git a/src/quicktemplates2/qquicktabbar.cpp b/src/quicktemplates2/qquicktabbar.cpp index 65a4a863..814d14ea 100644 --- a/src/quicktemplates2/qquicktabbar.cpp +++ b/src/quicktemplates2/qquicktabbar.cpp @@ -116,6 +116,28 @@ public: QQuickTabBar::Position position; }; +class QQuickTabBarAttachedPrivate : public QObjectPrivate +{ + Q_DECLARE_PUBLIC(QQuickTabBarAttached) + +public: + QQuickTabBarAttachedPrivate() + : index(-1), + tabBar(nullptr) + { + } + + static QQuickTabBarAttachedPrivate *get(QQuickTabBarAttached *attached) + { + return attached->d_func(); + } + + void update(QQuickTabBar *tabBar, int index); + + int index; + QQuickTabBar *tabBar; +}; + QQuickTabBarPrivate::QQuickTabBarPrivate() : updatingLayout(false), hasContentWidth(false), @@ -152,38 +174,47 @@ void QQuickTabBarPrivate::updateLayout() qreal maxHeight = 0; qreal totalWidth = 0; qreal reservedWidth = 0; + int resizableCount = 0; - QVector<QQuickItem *> resizableItems; - resizableItems.reserve(count); + QVector<QQuickItem *> allItems; + allItems.reserve(count); for (int i = 0; i < count; ++i) { QQuickItem *item = q->itemAt(i); if (item) { QQuickItemPrivate *p = QQuickItemPrivate::get(item); if (!p->widthValid) { - resizableItems += item; + ++resizableCount; totalWidth += item->implicitWidth(); } else { reservedWidth += item->width(); totalWidth += item->width(); } maxHeight = qMax(maxHeight, item->implicitHeight()); + allItems += item; } } const qreal totalSpacing = qMax(0, count - 1) * spacing; totalWidth += totalSpacing; - if (!resizableItems.isEmpty()) { - const qreal itemWidth = (contentItem->width() - reservedWidth - totalSpacing) / resizableItems.count(); + const qreal itemWidth = (contentItem->width() - reservedWidth - totalSpacing) / qMax(1, resizableCount); - updatingLayout = true; - for (QQuickItem *item : qAsConst(resizableItems)) { + updatingLayout = true; + for (QQuickItem *item : qAsConst(allItems)) { + QQuickItemPrivate *p = QQuickItemPrivate::get(item); + if (!p->widthValid) { item->setWidth(itemWidth); - QQuickItemPrivate::get(item)->widthValid = false; + p->widthValid = false; + } + if (!p->heightValid) { + item->setHeight(hasContentHeight ? contentHeight : maxHeight); + p->heightValid = false; + } else { + item->setY((maxHeight - item->height()) / 2); } - updatingLayout = false; } + updatingLayout = false; bool contentWidthChange = false; if (!hasContentWidth && !qFuzzyCompare(contentWidth, totalWidth)) { @@ -342,6 +373,11 @@ void QQuickTabBar::resetContentHeight() d->updateLayout(); } +QQuickTabBarAttached *QQuickTabBar::qmlAttachedProperties(QObject *object) +{ + return new QQuickTabBarAttached(object); +} + void QQuickTabBar::updatePolish() { Q_D(QQuickTabBar); @@ -376,20 +412,38 @@ void QQuickTabBar::itemAdded(int index, QQuickItem *item) QQuickItemPrivate::get(item)->setCulled(true); // QTBUG-55129 if (QQuickTabButton *button = qobject_cast<QQuickTabButton *>(item)) QObjectPrivate::connect(button, &QQuickTabButton::checkedChanged, d, &QQuickTabBarPrivate::updateCurrentIndex); + QQuickTabBarAttached *attached = qobject_cast<QQuickTabBarAttached *>(qmlAttachedPropertiesObject<QQuickTabBar>(item)); + if (attached) + QQuickTabBarAttachedPrivate::get(attached)->update(this, index); if (isComponentComplete()) polish(); } +void QQuickTabBar::itemMoved(int index, QQuickItem *item) +{ + QQuickTabBarAttached *attached = qobject_cast<QQuickTabBarAttached *>(qmlAttachedPropertiesObject<QQuickTabBar>(item)); + if (attached) + QQuickTabBarAttachedPrivate::get(attached)->update(this, index); +} + void QQuickTabBar::itemRemoved(int index, QQuickItem *item) { Q_D(QQuickTabBar); Q_UNUSED(index); if (QQuickTabButton *button = qobject_cast<QQuickTabButton *>(item)) QObjectPrivate::disconnect(button, &QQuickTabButton::checkedChanged, d, &QQuickTabBarPrivate::updateCurrentIndex); + QQuickTabBarAttached *attached = qobject_cast<QQuickTabBarAttached *>(qmlAttachedPropertiesObject<QQuickTabBar>(item)); + if (attached) + QQuickTabBarAttachedPrivate::get(attached)->update(nullptr, -1); if (isComponentComplete()) polish(); } +QPalette QQuickTabBar::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::TabBarPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickTabBar::accessibleRole() const { @@ -397,4 +451,87 @@ QAccessible::Role QQuickTabBar::accessibleRole() const } #endif +/*! + \qmlattachedproperty int QtQuick.Controls::TabBar::index + \since QtQuick.Controls 2.3 (Qt 5.10) + \readonly + + This attached property holds the index of each tab button in the TabBar. + + It is attached to each tab button of the TabBar. +*/ + +/*! + \qmlattachedproperty TabBar QtQuick.Controls::TabBar::tabBar + \since QtQuick.Controls 2.3 (Qt 5.10) + \readonly + + This attached property holds the tab bar that manages this tab button. + + It is attached to each tab button of the TabBar. +*/ + +/*! + \qmlattachedproperty enumeration QtQuick.Controls::TabBar::position + \since QtQuick.Controls 2.3 (Qt 5.10) + \readonly + + This attached property holds the position of the tab bar. + + It is attached to each tab button of the TabBar. + + Possible values: + \value TabBar.Header The tab bar is at the top, as a window or page header. + \value TabBar.Footer The tab bar is at the bottom, as a window or page footer. +*/ + +void QQuickTabBarAttachedPrivate::update(QQuickTabBar *newTabBar, int newIndex) +{ + Q_Q(QQuickTabBarAttached); + const int oldIndex = index; + const QQuickTabBar *oldTabBar = tabBar; + const QQuickTabBar::Position oldPos = q->position(); + + index = newIndex; + tabBar = newTabBar; + + if (oldTabBar != newTabBar) { + if (oldTabBar) + QObject::disconnect(oldTabBar, &QQuickTabBar::positionChanged, q, &QQuickTabBarAttached::positionChanged); + if (newTabBar) + QObject::connect(newTabBar, &QQuickTabBar::positionChanged, q, &QQuickTabBarAttached::positionChanged); + emit q->tabBarChanged(); + } + + if (oldIndex != newIndex) + emit q->indexChanged(); + if (oldPos != q->position()) + emit q->positionChanged(); +} + +QQuickTabBarAttached::QQuickTabBarAttached(QObject *parent) + : QObject(*(new QQuickTabBarAttachedPrivate), parent) +{ +} + +int QQuickTabBarAttached::index() const +{ + Q_D(const QQuickTabBarAttached); + return d->index; +} + +QQuickTabBar *QQuickTabBarAttached::tabBar() const +{ + Q_D(const QQuickTabBarAttached); + return d->tabBar; +} + +QQuickTabBar::Position QQuickTabBarAttached::position() const +{ + Q_D(const QQuickTabBarAttached); + if (!d->tabBar) + return QQuickTabBar::Header; + return d->tabBar->position(); +} + QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquicktabbar_p.h b/src/quicktemplates2/qquicktabbar_p.h index 0ffd53d5..0e4a3c58 100644 --- a/src/quicktemplates2/qquicktabbar_p.h +++ b/src/quicktemplates2/qquicktabbar_p.h @@ -53,6 +53,8 @@ QT_BEGIN_NAMESPACE class QQuickTabBarPrivate; +class QQuickTabBarAttached; +class QQuickTabBarAttachedPrivate; class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickTabBar : public QQuickContainer { @@ -81,6 +83,8 @@ public: void setContentHeight(qreal height); void resetContentHeight(); + static QQuickTabBarAttached *qmlAttachedProperties(QObject *object); + Q_SIGNALS: void positionChanged(); Q_REVISION(2) void contentWidthChanged(); @@ -92,8 +96,11 @@ protected: void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) override; bool isContent(QQuickItem *item) const override; void itemAdded(int index, QQuickItem *item) override; + void itemMoved(int index, QQuickItem *item) override; void itemRemoved(int index, QQuickItem *item) override; + QPalette defaultPalette() const override; + #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; #endif @@ -103,8 +110,33 @@ private: Q_DECLARE_PRIVATE(QQuickTabBar) }; +class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickTabBarAttached : public QObject +{ + Q_OBJECT + Q_PROPERTY(int index READ index NOTIFY indexChanged FINAL) + Q_PROPERTY(QQuickTabBar *tabBar READ tabBar NOTIFY tabBarChanged FINAL) + Q_PROPERTY(QQuickTabBar::Position position READ position NOTIFY positionChanged FINAL) + +public: + explicit QQuickTabBarAttached(QObject *parent = nullptr); + + int index() const; + QQuickTabBar *tabBar() const; + QQuickTabBar::Position position() const; + +Q_SIGNALS: + void indexChanged(); + void tabBarChanged(); + void positionChanged(); + +private: + Q_DISABLE_COPY(QQuickTabBarAttached) + Q_DECLARE_PRIVATE(QQuickTabBarAttached) +}; + QT_END_NAMESPACE QML_DECLARE_TYPE(QQuickTabBar) +QML_DECLARE_TYPEINFO(QQuickTabBar, QML_HAS_ATTACHED_PROPERTIES) #endif // QQUICKTABBAR_P_H diff --git a/src/quicktemplates2/qquicktabbutton.cpp b/src/quicktemplates2/qquicktabbutton.cpp index 9afe5363..617d4aea 100644 --- a/src/quicktemplates2/qquicktabbutton.cpp +++ b/src/quicktemplates2/qquicktabbutton.cpp @@ -75,6 +75,11 @@ QFont QQuickTabButton::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::TabButtonFont); } +QPalette QQuickTabButton::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::TabBarPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickTabButton::accessibleRole() const { diff --git a/src/quicktemplates2/qquicktabbutton_p.h b/src/quicktemplates2/qquicktabbutton_p.h index 49ecee50..9ca9df9f 100644 --- a/src/quicktemplates2/qquicktabbutton_p.h +++ b/src/quicktemplates2/qquicktabbutton_p.h @@ -61,6 +61,7 @@ public: protected: QFont defaultFont() const override; + QPalette defaultPalette() const override; #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; diff --git a/src/quicktemplates2/qquicktextarea.cpp b/src/quicktemplates2/qquicktextarea.cpp index 4a171603..eec25848 100644 --- a/src/quicktemplates2/qquicktextarea.cpp +++ b/src/quicktemplates2/qquicktextarea.cpp @@ -138,7 +138,6 @@ QQuickTextAreaPrivate::QQuickTextAreaPrivate() #endif background(nullptr), focusReason(Qt::OtherFocusReason), - accessibleAttached(nullptr), flickable(nullptr) { #if QT_CONFIG(accessibility) @@ -189,21 +188,71 @@ void QQuickTextAreaPrivate::resolveFont() inheritFont(QQuickControlPrivate::parentFont(q)); } -void QQuickTextAreaPrivate::inheritFont(const QFont &f) +void QQuickTextAreaPrivate::inheritFont(const QFont &font) { - Q_Q(QQuickTextArea); - QFont parentFont = font.resolve(f); - parentFont.resolve(font.resolve() | f.resolve()); + QFont parentFont = extra.isAllocated() ? extra->requestedFont.resolve(font) : font; + parentFont.resolve(extra.isAllocated() ? extra->requestedFont.resolve() | font.resolve() : font.resolve()); const QFont defaultFont = QQuickControlPrivate::themeFont(QPlatformTheme::EditorFont); const QFont resolvedFont = parentFont.resolve(defaultFont); - const bool changed = resolvedFont != sourceFont; - q->QQuickTextEdit::setFont(resolvedFont); - if (changed) + setFont_helper(resolvedFont); +} + +/*! + \internal + + Assign \a font to this control, and propagate it to all children. +*/ +void QQuickTextAreaPrivate::updateFont(const QFont &font) +{ + Q_Q(QQuickTextArea); + QFont oldFont = sourceFont; + q->QQuickTextEdit::setFont(font); + + QQuickControlPrivate::updateFontRecur(q, font); + + if (oldFont != font) emit q->fontChanged(); } +/*! + \internal + + Determine which palette is implicitly imposed on this control by its ancestors + and QGuiApplication::palette, resolve this against its own palette (attributes from + the implicit palette are copied over). Then propagate this palette to this + control's children. +*/ +void QQuickTextAreaPrivate::resolvePalette() +{ + Q_Q(QQuickTextArea); + inheritPalette(QQuickControlPrivate::parentPalette(q)); +} + +void QQuickTextAreaPrivate::inheritPalette(const QPalette &palette) +{ + QPalette parentPalette = extra.isAllocated() ? extra->requestedPalette.resolve(palette) : palette; + parentPalette.resolve(extra.isAllocated() ? extra->requestedPalette.resolve() | palette.resolve() : palette.resolve()); + + const QPalette defaultPalette = QQuickControlPrivate::themePalette(QPlatformTheme::TextEditPalette); + const QPalette resolvedPalette = parentPalette.resolve(defaultPalette); + + setPalette_helper(resolvedPalette); +} + +void QQuickTextAreaPrivate::updatePalette(const QPalette &palette) +{ + Q_Q(QQuickTextArea); + QPalette oldPalette = resolvedPalette; + resolvedPalette = palette; + + QQuickControlPrivate::updatePaletteRecur(q, palette); + + if (oldPalette != palette) + emit q->paletteChanged(); +} + #if QT_CONFIG(quicktemplates2_hover) void QQuickTextAreaPrivate::updateHoverEnabled(bool enabled, bool xplicit) { @@ -360,7 +409,7 @@ void QQuickTextAreaPrivate::readOnlyChanged(bool isReadOnly) { Q_UNUSED(isReadOnly); #if QT_CONFIG(accessibility) - if (accessibleAttached) + if (QQuickAccessibleAttached *accessibleAttached = QQuickAccessibleAttached::attachedProperties(q_func())) accessibleAttached->set_readOnly(isReadOnly); #endif #if QT_CONFIG(cursor) @@ -371,18 +420,15 @@ void QQuickTextAreaPrivate::readOnlyChanged(bool isReadOnly) #if QT_CONFIG(accessibility) void QQuickTextAreaPrivate::accessibilityActiveChanged(bool active) { - if (accessibleAttached || !active) + if (!active) return; Q_Q(QQuickTextArea); - accessibleAttached = qobject_cast<QQuickAccessibleAttached *>(qmlAttachedPropertiesObject<QQuickAccessibleAttached>(q, true)); - if (accessibleAttached) { - accessibleAttached->setRole(accessibleRole()); - accessibleAttached->set_readOnly(q->isReadOnly()); - accessibleAttached->setDescription(placeholder); - } else { - qWarning() << "QQuickTextArea: " << q << " QQuickAccessibleAttached object creation failed!"; - } + QQuickAccessibleAttached *accessibleAttached = qobject_cast<QQuickAccessibleAttached *>(qmlAttachedPropertiesObject<QQuickAccessibleAttached>(q, true)); + Q_ASSERT(accessibleAttached); + accessibleAttached->setRole(accessibleRole()); + accessibleAttached->set_readOnly(q->isReadOnly()); + accessibleAttached->setDescription(placeholder); } QAccessible::Role QQuickTextAreaPrivate::accessibleRole() const @@ -404,6 +450,9 @@ QQuickTextArea::QQuickTextArea(QQuickItem *parent) #endif QObjectPrivate::connect(this, &QQuickTextEdit::readOnlyChanged, d, &QQuickTextAreaPrivate::readOnlyChanged); + + // ### TODO: ItemEnabledChanged? + connect(this, &QQuickItem::enabledChanged, this, &QQuickTextArea::paletteChanged); } QQuickTextAreaAttached *QQuickTextArea::qmlAttachedProperties(QObject *object) @@ -419,10 +468,10 @@ QFont QQuickTextArea::font() const void QQuickTextArea::setFont(const QFont &font) { Q_D(QQuickTextArea); - if (d->font.resolve() == font.resolve() && d->font == font) + if (d->extra.value().requestedFont.resolve() == font.resolve() && d->extra.value().requestedFont == font) return; - d->font = font; + d->extra.value().requestedFont = font; d->resolveFont(); } @@ -479,8 +528,8 @@ void QQuickTextArea::setPlaceholderText(const QString &text) d->placeholder = text; #if QT_CONFIG(accessibility) - if (d->accessibleAttached) - d->accessibleAttached->setDescription(text); + if (QQuickAccessibleAttached *accessibleAttached = QQuickAccessibleAttached::attachedProperties(this)) + accessibleAttached->setDescription(text); #endif emit placeholderTextChanged(); } @@ -590,11 +639,44 @@ bool QQuickTextArea::contains(const QPointF &point) const return QQuickTextEdit::contains(point); } +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty palette QtQuick.Controls::TextArea::palette + + This property holds the palette currently set for the text area. + + \sa Control::palette +*/ +QPalette QQuickTextArea::palette() const +{ + Q_D(const QQuickTextArea); + QPalette palette = d->resolvedPalette; + if (!isEnabled()) + palette.setCurrentColorGroup(QPalette::Disabled); + return palette; +} + +void QQuickTextArea::setPalette(const QPalette &palette) +{ + Q_D(QQuickTextArea); + if (d->extra.value().requestedPalette.resolve() == palette.resolve() && d->extra.value().requestedPalette == palette) + return; + + d->extra.value().requestedPalette = palette; + d->resolvePalette(); +} + +void QQuickTextArea::resetPalette() +{ + setPalette(QPalette()); +} + void QQuickTextArea::classBegin() { Q_D(QQuickTextArea); QQuickTextEdit::classBegin(); d->resolveFont(); + d->resolvePalette(); } void QQuickTextArea::componentComplete() @@ -606,7 +688,7 @@ void QQuickTextArea::componentComplete() setAcceptHoverEvents(QQuickControlPrivate::calcHoverEnabled(d->parentItem)); #endif #if QT_CONFIG(accessibility) - if (!d->accessibleAttached && QAccessible::isActive()) + if (QAccessible::isActive()) d->accessibilityActiveChanged(true); #endif } @@ -617,6 +699,7 @@ void QQuickTextArea::itemChange(QQuickItem::ItemChange change, const QQuickItem: QQuickTextEdit::itemChange(change, value); if (change == ItemParentHasChanged && value.item) { d->resolveFont(); + d->resolvePalette(); #if QT_CONFIG(quicktemplates2_hover) if (!d->explicitHoverEnabled) d->updateHoverEnabled(QQuickControlPrivate::calcHoverEnabled(d->parentItem), false); // explicit=false diff --git a/src/quicktemplates2/qquicktextarea_p.h b/src/quicktemplates2/qquicktextarea_p.h index af7c1d13..6193e3ca 100644 --- a/src/quicktemplates2/qquicktextarea_p.h +++ b/src/quicktemplates2/qquicktextarea_p.h @@ -48,6 +48,7 @@ // We mean it. // +#include <QtGui/qpalette.h> #include <QtQuick/private/qquicktextedit_p.h> #include <QtQuickTemplates2/private/qtquicktemplates2global_p.h> @@ -69,6 +70,7 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickTextArea : public QQuickTextEdit Q_PROPERTY(Qt::FocusReason focusReason READ focusReason WRITE setFocusReason NOTIFY focusReasonChanged FINAL) Q_PROPERTY(bool hovered READ isHovered NOTIFY hoveredChanged FINAL REVISION 1) Q_PROPERTY(bool hoverEnabled READ isHoverEnabled WRITE setHoverEnabled RESET resetHoverEnabled NOTIFY hoverEnabledChanged FINAL REVISION 1) + Q_PROPERTY(QPalette palette READ palette WRITE setPalette RESET resetPalette NOTIFY paletteChanged FINAL REVISION 3) public: explicit QQuickTextArea(QQuickItem *parent = nullptr); @@ -96,6 +98,10 @@ public: bool contains(const QPointF &point) const override; + QPalette palette() const; + void setPalette(const QPalette &palette); + void resetPalette(); + Q_SIGNALS: void fontChanged(); void implicitWidthChanged3(); @@ -108,6 +114,7 @@ Q_SIGNALS: void pressAndHold(QQuickMouseEvent *event); Q_REVISION(1) void pressed(QQuickMouseEvent *event); Q_REVISION(1) void released(QQuickMouseEvent *event); + Q_REVISION(3) void paletteChanged(); protected: void classBegin() override; diff --git a/src/quicktemplates2/qquicktextarea_p_p.h b/src/quicktemplates2/qquicktextarea_p_p.h index ef2c7237..32f53c4f 100644 --- a/src/quicktemplates2/qquicktextarea_p_p.h +++ b/src/quicktemplates2/qquicktextarea_p_p.h @@ -48,11 +48,12 @@ // We mean it. // +#include <QtQml/private/qlazilyallocated_p.h> #include <QtQuick/private/qquicktextedit_p_p.h> #include <QtQuick/private/qquickitemchangelistener_p.h> #include <QtQuickTemplates2/private/qquickpresshandler_p_p.h> -#include "qquicktextarea_p.h" +#include <QtQuickTemplates2/private/qquicktextarea_p.h> #if QT_CONFIG(accessibility) #include <QtGui/qaccessible.h> @@ -61,7 +62,6 @@ QT_BEGIN_NAMESPACE class QQuickFlickable; -class QQuickAccessibleAttached; class QQuickTextAreaPrivate : public QQuickTextEditPrivate, public QQuickItemChangeListener #if QT_CONFIG(accessibility) @@ -80,8 +80,24 @@ public: } void resizeBackground(); + void resolveFont(); - void inheritFont(const QFont &f); + void inheritFont(const QFont &font); + void updateFont(const QFont &font); + inline void setFont_helper(const QFont &font) { + if (sourceFont.resolve() == font.resolve() && sourceFont == font) + return; + updateFont(font); + } + + void resolvePalette(); + void inheritPalette(const QPalette &palette); + void updatePalette(const QPalette &palette); + inline void setPalette_helper(const QPalette &palette) { + if (resolvedPalette.resolve() == palette.resolve() && resolvedPalette == palette) + return; + updatePalette(palette); + } #if QT_CONFIG(quicktemplates2_hover) void updateHoverEnabled(bool h, bool e); @@ -112,12 +128,18 @@ public: bool hovered; bool explicitHoverEnabled; #endif - QFont font; + + struct ExtraData { + QFont requestedFont; + QPalette requestedPalette; + }; + QLazilyAllocated<ExtraData> extra; + + QPalette resolvedPalette; QQuickItem *background; QString placeholder; Qt::FocusReason focusReason; QQuickPressHandler pressHandler; - QQuickAccessibleAttached *accessibleAttached; QQuickFlickable *flickable; }; diff --git a/src/quicktemplates2/qquicktextfield.cpp b/src/quicktemplates2/qquicktextfield.cpp index 96f5cc37..1c350165 100644 --- a/src/quicktemplates2/qquicktextfield.cpp +++ b/src/quicktemplates2/qquicktextfield.cpp @@ -118,8 +118,7 @@ QQuickTextFieldPrivate::QQuickTextFieldPrivate() explicitHoverEnabled(false), #endif background(nullptr), - focusReason(Qt::OtherFocusReason), - accessibleAttached(nullptr) + focusReason(Qt::OtherFocusReason) { #if QT_CONFIG(accessibility) QAccessible::installActivationObserver(this); @@ -163,21 +162,71 @@ void QQuickTextFieldPrivate::resolveFont() inheritFont(QQuickControlPrivate::parentFont(q)); } -void QQuickTextFieldPrivate::inheritFont(const QFont &f) +void QQuickTextFieldPrivate::inheritFont(const QFont &font) { - Q_Q(QQuickTextField); - QFont parentFont = font.resolve(f); - parentFont.resolve(font.resolve() | f.resolve()); + QFont parentFont = extra.isAllocated() ? extra->requestedFont.resolve(font) : font; + parentFont.resolve(extra.isAllocated() ? extra->requestedFont.resolve() | font.resolve() : font.resolve()); const QFont defaultFont = QQuickControlPrivate::themeFont(QPlatformTheme::EditorFont); const QFont resolvedFont = parentFont.resolve(defaultFont); - const bool changed = resolvedFont != sourceFont; - q->QQuickTextInput::setFont(resolvedFont); - if (changed) + setFont_helper(resolvedFont); +} + +/*! + \internal + + Assign \a font to this control, and propagate it to all children. +*/ +void QQuickTextFieldPrivate::updateFont(const QFont &font) +{ + Q_Q(QQuickTextField); + QFont oldFont = sourceFont; + q->QQuickTextInput::setFont(font); + + QQuickControlPrivate::updateFontRecur(q, font); + + if (oldFont != font) emit q->fontChanged(); } +/*! + \internal + + Determine which palette is implicitly imposed on this control by its ancestors + and QGuiApplication::palette, resolve this against its own palette (attributes from + the implicit palette are copied over). Then propagate this palette to this + control's children. +*/ +void QQuickTextFieldPrivate::resolvePalette() +{ + Q_Q(QQuickTextField); + inheritPalette(QQuickControlPrivate::parentPalette(q)); +} + +void QQuickTextFieldPrivate::inheritPalette(const QPalette &palette) +{ + QPalette parentPalette = extra.isAllocated() ? extra->requestedPalette.resolve(palette) : palette; + parentPalette.resolve(extra.isAllocated() ? extra->requestedPalette.resolve() | palette.resolve() : palette.resolve()); + + const QPalette defaultPalette = QQuickControlPrivate::themePalette(QPlatformTheme::TextLineEditPalette); + const QPalette resolvedPalette = parentPalette.resolve(defaultPalette); + + setPalette_helper(resolvedPalette); +} + +void QQuickTextFieldPrivate::updatePalette(const QPalette &palette) +{ + Q_Q(QQuickTextField); + QPalette oldPalette = resolvedPalette; + resolvedPalette = palette; + + QQuickControlPrivate::updatePaletteRecur(q, palette); + + if (oldPalette != palette) + emit q->paletteChanged(); +} + #if QT_CONFIG(quicktemplates2_hover) void QQuickTextFieldPrivate::updateHoverEnabled(bool enabled, bool xplicit) { @@ -223,7 +272,7 @@ void QQuickTextFieldPrivate::readOnlyChanged(bool isReadOnly) { Q_UNUSED(isReadOnly); #if QT_CONFIG(accessibility) - if (accessibleAttached) + if (QQuickAccessibleAttached *accessibleAttached = QQuickAccessibleAttached::attachedProperties(q_func())) accessibleAttached->set_readOnly(isReadOnly); #endif #if QT_CONFIG(cursor) @@ -234,7 +283,7 @@ void QQuickTextFieldPrivate::readOnlyChanged(bool isReadOnly) void QQuickTextFieldPrivate::echoModeChanged(QQuickTextField::EchoMode echoMode) { #if QT_CONFIG(accessibility) - if (accessibleAttached) + if (QQuickAccessibleAttached *accessibleAttached = QQuickAccessibleAttached::attachedProperties(q_func())) accessibleAttached->set_passwordEdit((echoMode == QQuickTextField::Password || echoMode == QQuickTextField::PasswordEchoOnEdit) ? true : false); #else Q_UNUSED(echoMode) @@ -244,19 +293,16 @@ void QQuickTextFieldPrivate::echoModeChanged(QQuickTextField::EchoMode echoMode) #if QT_CONFIG(accessibility) void QQuickTextFieldPrivate::accessibilityActiveChanged(bool active) { - if (accessibleAttached || !active) + if (!active) return; Q_Q(QQuickTextField); - accessibleAttached = qobject_cast<QQuickAccessibleAttached *>(qmlAttachedPropertiesObject<QQuickAccessibleAttached>(q, true)); - if (accessibleAttached) { - accessibleAttached->setRole(accessibleRole()); - accessibleAttached->set_readOnly(m_readOnly); - accessibleAttached->set_passwordEdit((m_echoMode == QQuickTextField::Password || m_echoMode == QQuickTextField::PasswordEchoOnEdit) ? true : false); - accessibleAttached->setDescription(placeholder); - } else { - qWarning() << "QQuickTextField: " << q << " QQuickAccessibleAttached object creation failed!"; - } + QQuickAccessibleAttached *accessibleAttached = qobject_cast<QQuickAccessibleAttached *>(qmlAttachedPropertiesObject<QQuickAccessibleAttached>(q, true)); + Q_ASSERT(accessibleAttached); + accessibleAttached->setRole(accessibleRole()); + accessibleAttached->set_readOnly(m_readOnly); + accessibleAttached->set_passwordEdit((m_echoMode == QQuickTextField::Password || m_echoMode == QQuickTextField::PasswordEchoOnEdit) ? true : false); + accessibleAttached->setDescription(placeholder); } QAccessible::Role QQuickTextFieldPrivate::accessibleRole() const @@ -278,6 +324,9 @@ QQuickTextField::QQuickTextField(QQuickItem *parent) #endif QObjectPrivate::connect(this, &QQuickTextInput::readOnlyChanged, d, &QQuickTextFieldPrivate::readOnlyChanged); QObjectPrivate::connect(this, &QQuickTextInput::echoModeChanged, d, &QQuickTextFieldPrivate::echoModeChanged); + + // ### TODO: ItemEnabledChanged? + connect(this, &QQuickItem::enabledChanged, this, &QQuickTextField::paletteChanged); } QFont QQuickTextField::font() const @@ -288,10 +337,10 @@ QFont QQuickTextField::font() const void QQuickTextField::setFont(const QFont &font) { Q_D(QQuickTextField); - if (d->font.resolve() == font.resolve() && d->font == font) + if (d->extra.value().requestedFont.resolve() == font.resolve() && d->extra.value().requestedFont == font) return; - d->font = font; + d->extra.value().requestedFont = font; d->resolveFont(); } @@ -348,8 +397,8 @@ void QQuickTextField::setPlaceholderText(const QString &text) d->placeholder = text; #if QT_CONFIG(accessibility) - if (d->accessibleAttached) - d->accessibleAttached->setDescription(text); + if (QQuickAccessibleAttached *accessibleAttached = QQuickAccessibleAttached::attachedProperties(this)) + accessibleAttached->setDescription(text); #endif emit placeholderTextChanged(); } @@ -451,11 +500,44 @@ void QQuickTextField::resetHoverEnabled() #endif } +/*! + \since QtQuick.Controls 2.3 (Qt 5.10) + \qmlproperty palette QtQuick.Controls::TextField::palette + + This property holds the palette currently set for the text field. + + \sa Control::palette +*/ +QPalette QQuickTextField::palette() const +{ + Q_D(const QQuickTextField); + QPalette palette = d->resolvedPalette; + if (!isEnabled()) + palette.setCurrentColorGroup(QPalette::Disabled); + return palette; +} + +void QQuickTextField::setPalette(const QPalette &palette) +{ + Q_D(QQuickTextField); + if (d->extra.value().requestedPalette.resolve() == palette.resolve() && d->extra.value().requestedPalette == palette) + return; + + d->extra.value().requestedPalette = palette; + d->resolvePalette(); +} + +void QQuickTextField::resetPalette() +{ + setPalette(QPalette()); +} + void QQuickTextField::classBegin() { Q_D(QQuickTextField); QQuickTextInput::classBegin(); d->resolveFont(); + d->resolvePalette(); } void QQuickTextField::componentComplete() @@ -467,7 +549,7 @@ void QQuickTextField::componentComplete() setAcceptHoverEvents(QQuickControlPrivate::calcHoverEnabled(d->parentItem)); #endif #if QT_CONFIG(accessibility) - if (!d->accessibleAttached && QAccessible::isActive()) + if (QAccessible::isActive()) d->accessibilityActiveChanged(true); #endif } @@ -478,6 +560,7 @@ void QQuickTextField::itemChange(QQuickItem::ItemChange change, const QQuickItem QQuickTextInput::itemChange(change, value); if (change == ItemParentHasChanged && value.item) { d->resolveFont(); + d->resolvePalette(); #if QT_CONFIG(quicktemplates2_hover) if (!d->explicitHoverEnabled) d->updateHoverEnabled(QQuickControlPrivate::calcHoverEnabled(d->parentItem), false); // explicit=false diff --git a/src/quicktemplates2/qquicktextfield_p.h b/src/quicktemplates2/qquicktextfield_p.h index 24e6ce53..0629a158 100644 --- a/src/quicktemplates2/qquicktextfield_p.h +++ b/src/quicktemplates2/qquicktextfield_p.h @@ -48,6 +48,7 @@ // We mean it. // +#include <QtGui/qpalette.h> #include <QtQuick/private/qquicktextinput_p.h> #include <QtQuickTemplates2/private/qtquicktemplates2global_p.h> @@ -68,6 +69,7 @@ class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickTextField : public QQuickTextInput Q_PROPERTY(Qt::FocusReason focusReason READ focusReason WRITE setFocusReason NOTIFY focusReasonChanged FINAL) Q_PROPERTY(bool hovered READ isHovered NOTIFY hoveredChanged FINAL REVISION 1) Q_PROPERTY(bool hoverEnabled READ isHoverEnabled WRITE setHoverEnabled RESET resetHoverEnabled NOTIFY hoverEnabledChanged FINAL REVISION 1) + Q_PROPERTY(QPalette palette READ palette WRITE setPalette RESET resetPalette NOTIFY paletteChanged FINAL REVISION 3) public: explicit QQuickTextField(QQuickItem *parent = nullptr); @@ -91,6 +93,10 @@ public: void setHoverEnabled(bool enabled); void resetHoverEnabled(); + QPalette palette() const; + void setPalette(const QPalette &palette); + void resetPalette(); + Q_SIGNALS: void fontChanged(); void implicitWidthChanged3(); @@ -103,6 +109,7 @@ Q_SIGNALS: void pressAndHold(QQuickMouseEvent *event); Q_REVISION(1) void pressed(QQuickMouseEvent *event); Q_REVISION(1) void released(QQuickMouseEvent *event); + Q_REVISION(3) void paletteChanged(); protected: void classBegin() override; diff --git a/src/quicktemplates2/qquicktextfield_p_p.h b/src/quicktemplates2/qquicktextfield_p_p.h index 31ccb361..65767452 100644 --- a/src/quicktemplates2/qquicktextfield_p_p.h +++ b/src/quicktemplates2/qquicktextfield_p_p.h @@ -48,10 +48,11 @@ // We mean it. // +#include <QtQml/private/qlazilyallocated_p.h> #include <QtQuick/private/qquicktextinput_p_p.h> #include <QtQuickTemplates2/private/qquickpresshandler_p_p.h> -#include "qquicktextfield_p.h" +#include <QtQuickTemplates2/private/qquicktextfield_p.h> #if QT_CONFIG(accessibility) #include <QtGui/qaccessible.h> @@ -59,8 +60,6 @@ QT_BEGIN_NAMESPACE -class QQuickAccessibleAttached; - class QQuickTextFieldPrivate : public QQuickTextInputPrivate #if QT_CONFIG(accessibility) , public QAccessible::ActivationObserver @@ -76,8 +75,24 @@ public: return static_cast<QQuickTextFieldPrivate *>(QObjectPrivate::get(item)); } void resizeBackground(); + void resolveFont(); - void inheritFont(const QFont &f); + void inheritFont(const QFont &font); + void updateFont(const QFont &font); + inline void setFont_helper(const QFont &font) { + if (sourceFont.resolve() == font.resolve() && sourceFont == font) + return; + updateFont(font); + } + + void resolvePalette(); + void inheritPalette(const QPalette &palette); + void updatePalette(const QPalette &palette); + inline void setPalette_helper(const QPalette &palette) { + if (resolvedPalette.resolve() == palette.resolve() && resolvedPalette == palette) + return; + updatePalette(palette); + } #if QT_CONFIG(quicktemplates2_hover) void updateHoverEnabled(bool h, bool e); @@ -101,12 +116,18 @@ public: bool hovered; bool explicitHoverEnabled; #endif - QFont font; + + struct ExtraData { + QFont requestedFont; + QPalette requestedPalette; + }; + QLazilyAllocated<ExtraData> extra; + + QPalette resolvedPalette; QQuickItem *background; QString placeholder; Qt::FocusReason focusReason; QQuickPressHandler pressHandler; - QQuickAccessibleAttached *accessibleAttached; }; QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquicktoolbar.cpp b/src/quicktemplates2/qquicktoolbar.cpp index 9f5f210e..99775c6a 100644 --- a/src/quicktemplates2/qquicktoolbar.cpp +++ b/src/quicktemplates2/qquicktoolbar.cpp @@ -141,6 +141,11 @@ void QQuickToolBar::setPosition(Position position) emit positionChanged(); } +QPalette QQuickToolBar::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::ToolButtonPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickToolBar::accessibleRole() const { diff --git a/src/quicktemplates2/qquicktoolbar_p.h b/src/quicktemplates2/qquicktoolbar_p.h index 58192ff9..b919c615 100644 --- a/src/quicktemplates2/qquicktoolbar_p.h +++ b/src/quicktemplates2/qquicktoolbar_p.h @@ -75,6 +75,8 @@ Q_SIGNALS: void positionChanged(); protected: + QPalette defaultPalette() const override; + #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; #endif diff --git a/src/quicktemplates2/qquicktoolbutton.cpp b/src/quicktemplates2/qquicktoolbutton.cpp index 5ef25e3e..8c9e9bca 100644 --- a/src/quicktemplates2/qquicktoolbutton.cpp +++ b/src/quicktemplates2/qquicktoolbutton.cpp @@ -59,7 +59,8 @@ QT_BEGIN_NAMESPACE ToolButton inherits its API from AbstractButton. For instance, you can set \l {AbstractButton::text}{text}, and react to \l {AbstractButton::clicked}{clicks} - using the AbstractButton API. + using the AbstractButton API. In addition to displaying text, tool buttons + can also display an \l [QML]{Button Icons}{icon}. \sa ToolBar, {Customizing ToolButton}, {Button Controls} */ @@ -74,4 +75,9 @@ QFont QQuickToolButton::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::ToolButtonFont); } +QPalette QQuickToolButton::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::ToolButtonPalette); +} + QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquicktoolbutton_p.h b/src/quicktemplates2/qquicktoolbutton_p.h index 06745cd9..0e376f7b 100644 --- a/src/quicktemplates2/qquicktoolbutton_p.h +++ b/src/quicktemplates2/qquicktoolbutton_p.h @@ -61,6 +61,7 @@ public: protected: QFont defaultFont() const override; + QPalette defaultPalette() const override; }; QT_END_NAMESPACE diff --git a/src/quicktemplates2/qquicktoolseparator.cpp b/src/quicktemplates2/qquicktoolseparator.cpp index 4da63907..2ec7799f 100644 --- a/src/quicktemplates2/qquicktoolseparator.cpp +++ b/src/quicktemplates2/qquicktoolseparator.cpp @@ -133,6 +133,11 @@ bool QQuickToolSeparator::isVertical() const return d->orientation == Qt::Vertical; } +QPalette QQuickToolSeparator::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::ToolButtonPalette); +} + #if QT_CONFIG(accessibility) QAccessible::Role QQuickToolSeparator::accessibleRole() const { diff --git a/src/quicktemplates2/qquicktoolseparator_p.h b/src/quicktemplates2/qquicktoolseparator_p.h index 055f475c..2108cc5b 100644 --- a/src/quicktemplates2/qquicktoolseparator_p.h +++ b/src/quicktemplates2/qquicktoolseparator_p.h @@ -74,6 +74,8 @@ Q_SIGNALS: void orientationChanged(); protected: + QPalette defaultPalette() const override; + #if QT_CONFIG(accessibility) QAccessible::Role accessibleRole() const override; #endif diff --git a/src/quicktemplates2/qquicktooltip.cpp b/src/quicktemplates2/qquicktooltip.cpp index bf83a725..1aeb9914 100644 --- a/src/quicktemplates2/qquicktooltip.cpp +++ b/src/quicktemplates2/qquicktooltip.cpp @@ -279,6 +279,11 @@ QFont QQuickToolTip::defaultFont() const return QQuickControlPrivate::themeFont(QPlatformTheme::TipLabelFont); } +QPalette QQuickToolTip::defaultPalette() const +{ + return QQuickControlPrivate::themePalette(QPlatformTheme::ToolTipPalette); +} + void QQuickToolTip::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &data) { Q_D(QQuickToolTip); @@ -353,7 +358,7 @@ QQuickToolTip *QQuickToolTipAttachedPrivate::instance(bool create) const if (!tip && create) { // TODO: a cleaner way to create the instance? QQml(Meta)Type? QQmlComponent component(engine); - component.setData("import QtQuick.Controls 2.2; ToolTip { }", QUrl()); + component.setData("import QtQuick.Controls 2.3; ToolTip { }", QUrl()); QObject *object = component.create(); if (object) diff --git a/src/quicktemplates2/qquicktooltip_p.h b/src/quicktemplates2/qquicktooltip_p.h index bdfbe362..60b02502 100644 --- a/src/quicktemplates2/qquicktooltip_p.h +++ b/src/quicktemplates2/qquicktooltip_p.h @@ -86,6 +86,7 @@ Q_SIGNALS: protected: QFont defaultFont() const override; + QPalette defaultPalette() const override; void itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &data) override; void timerEvent(QTimerEvent *event) override; diff --git a/src/quicktemplates2/qquicktumbler_p.h b/src/quicktemplates2/qquicktumbler_p.h index b71a7636..f536f58c 100644 --- a/src/quicktemplates2/qquicktumbler_p.h +++ b/src/quicktemplates2/qquicktumbler_p.h @@ -128,7 +128,7 @@ class QQuickTumblerAttachedPrivate; class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickTumblerAttached : public QObject { Q_OBJECT - Q_PROPERTY(QQuickTumbler *tumbler READ tumbler CONSTANT) + Q_PROPERTY(QQuickTumbler *tumbler READ tumbler CONSTANT FINAL) Q_PROPERTY(qreal displacement READ displacement NOTIFY displacementChanged FINAL) public: diff --git a/src/quicktemplates2/qtquicktemplates2global_p.h b/src/quicktemplates2/qtquicktemplates2global_p.h index b7f54bb6..e5ee3f2e 100644 --- a/src/quicktemplates2/qtquicktemplates2global_p.h +++ b/src/quicktemplates2/qtquicktemplates2global_p.h @@ -49,6 +49,7 @@ // #include <QtCore/qglobal.h> +#include <QtQml/private/qqmlglobal_p.h> #include <QtQuickTemplates2/private/qtquicktemplates2-config_p.h> QT_BEGIN_NAMESPACE diff --git a/src/quicktemplates2/quicktemplates2.pri b/src/quicktemplates2/quicktemplates2.pri index a7570ec5..47d8589d 100644 --- a/src/quicktemplates2/quicktemplates2.pri +++ b/src/quicktemplates2/quicktemplates2.pri @@ -3,6 +3,8 @@ INCLUDEPATH += $$PWD HEADERS += \ $$PWD/qquickabstractbutton_p.h \ $$PWD/qquickabstractbutton_p_p.h \ + $$PWD/qquickaction_p.h \ + $$PWD/qquickactiongroup_p.h \ $$PWD/qquickapplicationwindow_p.h \ $$PWD/qquickbusyindicator_p.h \ $$PWD/qquickbutton_p.h \ @@ -26,6 +28,7 @@ HEADERS += \ $$PWD/qquickframe_p.h \ $$PWD/qquickframe_p_p.h \ $$PWD/qquickgroupbox_p.h \ + $$PWD/qquickicon_p.h \ $$PWD/qquickitemdelegate_p.h \ $$PWD/qquickitemdelegate_p_p.h \ $$PWD/qquicklabel_p.h \ @@ -33,12 +36,14 @@ HEADERS += \ $$PWD/qquickmenu_p.h \ $$PWD/qquickmenu_p_p.h \ $$PWD/qquickmenuitem_p.h \ + $$PWD/qquickmenuitem_p_p.h \ $$PWD/qquickmenuseparator_p.h \ $$PWD/qquickoverlay_p.h \ $$PWD/qquickoverlay_p_p.h \ $$PWD/qquickpage_p.h \ $$PWD/qquickpageindicator_p.h \ $$PWD/qquickpagelayout_p_p.h \ + $$PWD/qquickpalette_p.h \ $$PWD/qquickpane_p.h \ $$PWD/qquickpane_p_p.h \ $$PWD/qquickpopup_p.h \ @@ -82,6 +87,8 @@ HEADERS += \ SOURCES += \ $$PWD/qquickabstractbutton.cpp \ + $$PWD/qquickaction.cpp \ + $$PWD/qquickactiongroup.cpp \ $$PWD/qquickapplicationwindow.cpp \ $$PWD/qquickbusyindicator.cpp \ $$PWD/qquickbutton.cpp \ @@ -98,6 +105,7 @@ SOURCES += \ $$PWD/qquickdrawer.cpp \ $$PWD/qquickframe.cpp \ $$PWD/qquickgroupbox.cpp \ + $$PWD/qquickicon.cpp \ $$PWD/qquickitemdelegate.cpp \ $$PWD/qquicklabel.cpp \ $$PWD/qquickmenu.cpp \ @@ -107,6 +115,7 @@ SOURCES += \ $$PWD/qquickpage.cpp \ $$PWD/qquickpageindicator.cpp \ $$PWD/qquickpagelayout.cpp \ + $$PWD/qquickpalette.cpp \ $$PWD/qquickpane.cpp \ $$PWD/qquickpopup.cpp \ $$PWD/qquickpopupitem.cpp \ |