Differential D27840 Diff 80305 src/qmlcontrols/kcmcontrols/settingstatebindingprivate.cpp

Changeset View

Standalone View

View Options

src/qmlcontrols/kcmcontrols/settingstatebindingprivate.cpp

  • This file was added.
1​/*
2​ * Copyright 2020 Kevin Ottens <kevin.ottens@enioka.com>
3​ *
4​ * This library is free software; you can redistribute it and/or
5​ * modify it under the terms of the GNU Library General Public
6​ * License as published by the Free Software Foundation; either
7​ * version 2 of the License, or (at your option) any later version.
8​ *
9​ * This library is distributed in the hope that it will be useful,
10​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
11​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12​ * Library General Public License for more details.
13​ *
14​ * You should have received a copy of the GNU Library General Public License
15​ * along with this library; see the file COPYING.LIB. If not, write to
16​ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17​ * Boston, MA 02110-1301, USA.
18​ */
19​
20​#include "settingstatebindingprivate.h"
21​
22​#include <QGuiApplication>
23​#include <QQmlContext>
24​
25​namespace {
26​constexpr const char *bindingProperty = "__SettingStateBindingPrivate_binding";
27​constexpr const char *hasBindingProperty = "__SettingStateBindingPrivate_hasBinding";
28​
29​QByteArray itemClassName(QQuickItem *item)
30​{
31​ // Split since some exported types will be of the form: Foo_QMLTYPE_XX
broulikUnsubmitted
Done

Odd. Wouldn't we just get QQuickRowLayout et al? Or is that if you do a custom item with a Layout as a base?

broulik: Odd. Wouldn't we just get `QQuickRowLayout` et al? Or is that if you do a custom item with a…
ervinAuthorUnsubmitted
Not Done

Or if you make something like Kirigami.FormLayout which has Item as base... obviously it's mostly an heuristic so can't be 100% perfect.

ervin: Or if you make something like Kirigami.FormLayout which has Item as base... obviously it's…
32​ const auto className = QByteArray(item->metaObject()->className()).split('_').first();
33​ return className;
34​}
35​
36​bool isLayout(QQuickItem *item)
37​{
38​ const auto className = itemClassName(item);
39​ // We pretend StackLayout to not be a layout so that
40​ // later on the positioning of one tab isn't polluted
41​ // by the elemends from another tab.
42​ if (className.endsWith("StackLayout")) {
43​ return false;
44​ } else {
45​ return className.endsWith("Layout")
46​ || className.endsWith("Column")
47​ || className.endsWith("Row")
48​ || className.endsWith("Grid");
49​ }
50​}
51​
52​bool isView(QQuickItem *item)
53​{
54​ const auto className = itemClassName(item);
55​ return className.contains("GridView")
56​ || className.endsWith("ListView");
57​}
58​
59​bool hasNonOverlayIndicator(QQuickItem *item)
60​{
61​ if (!item->property(hasBindingProperty).toBool()) {
62​ return false;
63​ }
64​
65​ const auto binding = item->property(bindingProperty).value<SettingStateBindingPrivate *>();
66​ return !binding->isIndicatorAsOverlay();
67​}
68​
69​QList<QQuickItem *> findDescendantItems(QQuickItem *item)
70​{
71​ const auto children = item->childItems();
72​ auto result = children;
73​ for (auto child : children) {
74​ result += findDescendantItems(child);
75​ }
76​ return result;
77​}
78​
79​QQuickItem *findOuterLayout(QQuickItem *item)
80​{
81​ if (!item->parentItem()) {
82​ return item;
83​ } else if (isLayout(item) && !isLayout(item->parentItem())) {
broulikUnsubmitted
Done

Too bad QQuickItemChangeListener is private.

Also, does any of this need event compression?

broulik: Too bad `QQuickItemChangeListener` is private. Also, does any of this need event compression?
ervinAuthorUnsubmitted
Not Done

That really didn't feel like it required event compression to be honest at least I couldn't perceive any visible impact.

ervin: That really didn't feel like it required event compression to be honest at least I couldn't…
84​ return item;
85​ } else {
86​ return findOuterLayout(item->parentItem());
87​ }
88​}
89​
90​QQuickItem *findOuterView(QQuickItem *item)
91​{
broulikUnsubmitted
Done

Check if it actually changed before emitting

broulik: Check if it actually changed before emitting
ervinAuthorUnsubmitted
Not Done

Well it will have changed in 90% of the cases and checking means doing the computation anyway, which will happen when the getter is called. We'd pay the price twice.

An option is of course to cache the result of the getter to the price of higher complexity. Again I didn't perceive any visible impact on use. Should I go for it anyway?

Note I'm not at all denying this implementation is in some way inefficient, I'm just pointing out the trade off in term of readability and maintainability of the system.

ervin: Well it will have changed in 90% of the cases and checking means doing the computation anyway…
92​ // This is mostly useful for situations where
93​ // the target is a GridViewInternal for some
94​ // reason but really what we need is finding the GridView
95​ if (!isView(item)) {
96​ return nullptr;
97​ } else {
98​ const auto parentView = findOuterView(item->parentItem());
99​ if (!parentView) {
100​ return item;
101​ } else {
102​ return parentView;
103​ }
104​ }
105​}
106​
107​}
108​
broulikUnsubmitted
Done

Check if it actually changed before emitting

broulik: Check if it actually changed before emitting
ervinAuthorUnsubmitted
Not Done

Same answer than the previous such case.

ervin: Same answer than the previous such case.
109​QQuickItem *SettingStateBindingPrivate::target() const
110​{
111​ return m_target;
112​}
113​
114​void SettingStateBindingPrivate::setTarget(QQuickItem *target)
115​{
116​ if (m_target == target) {
117​ return;
118​ }
119​
120​ if (m_target) {
121​ m_target->setProperty(hasBindingProperty, QVariant());
122​ m_target->setProperty(bindingProperty, QVariant());
123​ disconnect(m_target);
124​
125​ const auto outerView = findOuterView(m_target);
126​ if (outerView) {
127​ disconnect(outerView);
128​ }
129​ }
130​
131​ m_target = target;
132​ if (m_target) {
133​ m_target->setProperty(hasBindingProperty, true);
134​ m_target->setProperty(bindingProperty, QVariant::fromValue(this));
135​ connect(m_target, &QQuickItem::parentChanged, this, &SettingStateBindingPrivate::triggerCoordChanges);
136​ connect(m_target, &QQuickItem::widthChanged, this, &SettingStateBindingPrivate::triggerCoordChanges);
137​ connect(m_target, &QQuickItem::heightChanged, this, &SettingStateBindingPrivate::triggerCoordChanges);
138​ connect(m_target, &QQuickItem::xChanged, this, &SettingStateBindingPrivate::triggerCoordChanges);
139​ connect(m_target, &QQuickItem::yChanged, this, &SettingStateBindingPrivate::triggerCoordChanges);
140​
141​ // For indicators which are in overlay mode, they need to change position
142​ // when scrollbars are shown/hidden
143​ const auto outerView = findOuterView(m_target);
144​ const auto view = outerView? outerView : m_target.data();
145​ connect(view, &QQuickItem::visibleChildrenChanged, this, &SettingStateBindingPrivate::triggerCoordChanges);
146​ }
147​
148​ emit targetChanged();
149​ triggerCoordChanges();
150​}
151​
152​QQuickItem *SettingStateBindingPrivate::indicator() const
153​{
154​ return m_indicator;
155​}
156​
157​void SettingStateBindingPrivate::setIndicator(QQuickItem *indicator)
158​{
159​ if (m_indicator == indicator) {
160​ return;
161​ }
162​
163​ m_indicator = indicator;
164​
165​ emit indicatorChanged();
166​ triggerCoordChanges();
167​}
168​
169​bool SettingStateBindingPrivate::isIndicatorAsOverlay() const
170​{
171​ return m_indicatorAsOverlay;
172​}
173​
174​void SettingStateBindingPrivate::setIndicatorAsOverlay(bool asOverlay)
175​{
176​ if (m_indicatorAsOverlay == asOverlay) {
177​ return;
178​ }
179​
180​ m_indicatorAsOverlay = asOverlay;
181​
182​ emit indicatorAsOverlayChanged();
183​ triggerCoordChanges();
184​}
185​
186​qreal SettingStateBindingPrivate::leftCoord() const
187​{
188​ if (!m_target || !m_indicator) {
189​ return 0.0;
190​ }
191​
192​ if (m_indicatorAsOverlay) {
193​ return overlayLeftCoord();
194​ } else {
195​ return formLeftCoord();
196​ }
197​}
198​
199​qreal SettingStateBindingPrivate::formLeftCoord() const
200​{
201​ const auto parent = m_indicator->parentItem();
202​ const auto outerLayout = findOuterLayout(m_target);
203​
204​ const auto siblings = [=] {
205​ auto result = findDescendantItems(outerLayout);
206​ result.erase(std::remove_if(result.begin(), result.end(),
207​ [=](QQuickItem *item) {
208​ return !hasNonOverlayIndicator(item);
209​ }),
210​ result.end());
211​ return result;
212​ }();
213​
214​ const auto leftToRight = QGuiApplication::layoutDirection() == Qt::LeftToRight;
215​ const auto xValues = [=] {
216​ auto result = QVector<qreal>();
217​ result.reserve(siblings.size());
218​ std::transform(siblings.cbegin(), siblings.cend(),
219​ std::back_inserter(result),
220​ [=](QQuickItem *item) {
221​ const auto localX = leftToRight ? item->width() : -m_indicator->width();
222​ return parent->mapFromItem(item, {localX, 0.0}).x();
223​ });
224​ return result;
225​ }();
226​ if (leftToRight) {
227​ return *std::max_element(xValues.cbegin(), xValues.cend());
228​ } else {
229​ return *std::min_element(xValues.cbegin(), xValues.cend());
230​ }
231​}
232​
233​qreal SettingStateBindingPrivate::overlayLeftCoord() const
234​{
235​ const auto parent = m_indicator->parentItem();
236​ const auto leftToRight = QGuiApplication::layoutDirection() == Qt::LeftToRight;
237​
238​ const auto localX = leftToRight ? m_target->width() : -m_indicator->width();
239​ const auto parentX = parent->mapFromItem(m_target, {localX, 0.0}).x();
240​
241​ const auto outerView = findOuterView(m_target);
242​
243​ // Heuristic to find the vertical scroll bars which are visible and which
244​ // might overlap with the indicator if left on the board of a view
245​ const auto verticalScrollbars = [=] {
246​ auto result = findDescendantItems(outerView? outerView : m_target.data());
247​ result.erase(std::remove_if(result.begin(), result.end(),
248​ [=](QQuickItem *item) {
249​ if (!item->isVisible()
250​ || itemClassName(item) != "ScrollBar"
251​ || item->width() > item->height()) {
252​ return true;
253​ }
254​
255​ const auto localSbX = leftToRight ? item->width() : -m_indicator->width();
256​ const auto parentSbX = parent->mapFromItem(item, {localSbX, 0.0}).x();
257​ return qAbs(parentSbX - parentX) > m_indicator->width();
258​ }),
259​ result.end());
260​ return result;
261​ }();
262​ Q_ASSERT(verticalScrollbars.size() <= 1);
263​
264​ const auto scrollbarWidth = verticalScrollbars.isEmpty() ? 0.0 : verticalScrollbars.first()->width();
265​ return parentX + (leftToRight? -1.0 : 1.0) * scrollbarWidth;
266​}
267​
268​void SettingStateBindingPrivate::triggerCoordChanges()
269​{
270​ const auto outerLayout = findOuterLayout(m_target);
271​ const auto items = findDescendantItems(outerLayout);
272​
273​ for (auto item : items) {
274​ const auto binding = item->property(bindingProperty).value<SettingStateBindingPrivate *>();
275​ if (binding) {
276​ emit binding->leftCoordChanged();
277​ }
278​ }
279​}