Differential D27540 Diff 79656 src/settingsstatusindicator.cpp

Changeset View

Standalone View

View Options

src/settingsstatusindicator.cpp

  • This file was added.
1​/*
2​ * This file is part of the KDE libraries
3​ * Copyright (C) 2020 Kevin Ottens <kevin.ottens@enioka.com>
4​ *
5​ * This library is free software; you can redistribute it and/or
6​ * modify it under the terms of the GNU Library General Public
7​ * License as published by the Free Software Foundation; either
8​ * version 2 of the License, or (at your option) any later version.
9​ *
10​ * This library is distributed in the hope that it will be useful,
11​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
12​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13​ * Library General Public License for more details.
14​ *
15​ * You should have received a copy of the GNU Library General Public License
16​ * along with this library; see the file COPYING.LIB. If not, write to
17​ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18​ * Boston, MA 02110-1301, USA.
19​ */
20​
21​#include "settingsstatusindicator_p.h"
22​
23​#include <QEvent>
24​#include <QIcon>
25​#include <QPainter>
26​#include <QRegularExpression>
27​#include <QVariant>
28​
29​namespace {
30​constexpr const int INDICATOR_ICON_SIZE = 16;
31​constexpr const int INDICATOR_SIZE = INDICATOR_ICON_SIZE + 8;
32​
33​constexpr const char *originalPosProperty = "originalPos";
34​constexpr const char *originalWidthProperty = "originalWidth";
35​
36​bool isWidgetAtParentEdge(QWidget *widget)
37​{
38​ const auto leftToRight = widget->isLeftToRight();
39​ if (leftToRight) {
40​ const auto right = widget->pos().x() + widget->width();
41​ const auto parentWidth = widget->parentWidget()->width();
42​ return right == parentWidth;
43​ } else {
44​ return widget->pos().x() == 0;
45​ }
46​}
47​
48​int widgetForcedWidth(QWidget *widget)
49​{
50​ // We actually respect the minimum size hint to avoid the widget looking odd
51​ // worst case scenario the indicator isn't visible if the widget is ending at the very
52​ // edge of the window and is already too small to be resized, it's a very unlikely case
53​ // though, when reaching the edge it's often greedy in space anyway
54​ return qMax(widget->width() - INDICATOR_SIZE, widget->minimumSizeHint().width());
55​}
56​
57​int widgetExpectedWidth(QWidget *widget)
58​{
59​ if (isWidgetAtParentEdge(widget)) {
60​ return widgetForcedWidth(widget);
61​ } else {
62​ return widget->width();
63​ }
64​}
65​
66​}
67​
68​SettingStatusIndicator::SettingStatusIndicator(QWidget *parent)
69​ : QToolButton(parent)
70​{
71​ setAutoRaise(true);
72​ setIconSize({INDICATOR_ICON_SIZE, INDICATOR_ICON_SIZE});
73​ setIcon(QIcon::fromTheme("edit-reset"));
74​ setFocusPolicy(Qt::NoFocus);
75​ setVisible(true);
76​}
davidedmundsonUnsubmitted
Done

This is equivalent to calling showFullScreen(), showMaximized(), or setVisible(true), depending on the platform's default behavior for the window flags.

For X and wayland it's setVisible(true)

but we shouldn't count on it.

davidedmundson: >This is equivalent to calling showFullScreen(), showMaximized(), or setVisible(true)…
ervinAuthorUnsubmitted
Not Done

I don't think it matters for widgets which have a parent and not the Qt::Window window flag, but OK, switching to setVisible() instead of show/hide.

ervin: I don't think it matters for widgets which have a parent and not the Qt::Window window flag…
77​
78​SettingStatusIndicator::~SettingStatusIndicator()
79​{
80​ setTrackedWidget(nullptr); // This will neatly reset the width offset
81​}
82​
83​void SettingStatusIndicator::setTrackedWidget(QWidget *widget)
84​{
85​ if (m_trackedWidget == widget) {
86​ return;
87​ }
88​
89​ if (m_trackedWidget) {
90​ resetWidthOffset();
91​ m_trackedWidget->removeEventFilter(this);
92​ }
93​
94​ m_trackedWidget = widget;
95​ if (!m_trackedWidget) {
96​ return;
97​ }
98​
99​ forceWidthOffset();
100​ applyLayout();
101​ setVisible(m_trackedWidget->isVisible());
102​ m_trackedWidget->installEventFilter(this);
103​}
104​
105​bool SettingStatusIndicator::eventFilter(QObject *watched, QEvent *event)
106​{
107​ Q_UNUSED(watched)
108​ if (event->type() == QEvent::Resize && !m_forcingSize) {
109​ if (forceWidthOffset()) {
110​ return true;
111​ }
112​ }
113​
114​ switch (event->type()) {
115​ case QEvent::Resize:
116​ case QEvent::Move:
117​ applyLayout();
118​ break;
119​ case QEvent::Show:
120​ setVisible(true);
121​ break;
122​ case QEvent::Hide:
123​ setVisible(false);
124​ break;
125​ default:
126​ break;
127​ }
128​
129​ return false;
130​}
131​
132​bool SettingStatusIndicator::forceWidthOffset()
133​{
134​ // Force resizing only when necessary
135​ if (!isWidgetAtParentEdge(m_trackedWidget)) {
136​ return false;
137​ }
138​
139​ m_forcingSize = true;
140​ m_trackedWidget->setProperty(originalWidthProperty, m_trackedWidget->width());
141​ m_trackedWidget->setProperty(originalPosProperty, m_trackedWidget->pos());
142​ m_trackedWidget->resize(widgetForcedWidth(m_trackedWidget), m_trackedWidget->height());
143​ if (!m_trackedWidget->isLeftToRight()) {
144​ m_trackedWidget->move(m_trackedWidget->pos() + QPoint(INDICATOR_SIZE, 0));
145​ }
146​ m_forcingSize = false;
147​ return true;
148​}
149​
150​void SettingStatusIndicator::resetWidthOffset()
151​{
152​ const auto originalWidth = m_trackedWidget->property(originalWidthProperty);
153​ const auto originalPos = m_trackedWidget->property(originalPosProperty);
154​ if (originalWidth.isValid()) {
155​ Q_ASSERT(originalPos.isValid());
156​ m_forcingSize = true;
157​
158​ auto size = m_trackedWidget->size();
159​ size.setWidth(originalWidth.toInt());
160​ m_trackedWidget->resize(size);
161​ m_trackedWidget->move(originalPos.toPoint());
162​
163​ m_trackedWidget->setProperty(originalWidthProperty, QVariant());
164​ m_trackedWidget->setProperty(originalPosProperty, QVariant());
165​
166​ m_forcingSize = false;
167​ }
168​}
169​
170​void SettingStatusIndicator::applyLayout()
171​{
172​ resize(INDICATOR_SIZE, INDICATOR_SIZE);
173​
174​ const auto leftToRight = m_trackedWidget->isLeftToRight();
175​ auto x = leftToRight ? m_trackedWidget->pos().x() + m_trackedWidget->width()
176​ : m_trackedWidget->pos().x() - width();
davidedmundsonUnsubmitted
Done

unused?

davidedmundson: unused?
ervinAuthorUnsubmitted
Not Done

I'm not sure how you end up to this conclusion, it's written two below if we are at the window edge, and it's used in the move call at the end.

ervin: I'm not sure how you end up to this conclusion, it's written two below if we are at the window…
177​ const auto y = m_trackedWidget->pos().y() + (m_trackedWidget->height() - height()) / 2.0f;
178​
179​ // We didn't get resized which means we're not at the border of the window
180​ // then we try to vertically line up with other indicators
181​ const auto originalWidth = m_trackedWidget->property(originalWidthProperty);
182​ if (!originalWidth.isValid() || m_trackedWidget->width() == originalWidth.toInt()) {
183​ const auto re = QRegularExpression("^kcfg_");
184​ const auto children = m_trackedWidget->parentWidget()->findChildren<QWidget*>(re, Qt::FindDirectChildrenOnly);
185​ const auto xValues = [=] {
davidedmundsonUnsubmitted
Done

Can we be sure the tracked widget always has a parent widget?

If someone doesn't use layouts a widget might not have a parent.

davidedmundson: Can we be sure the tracked widget always has a parent widget? If someone doesn't use layouts a…
ervinAuthorUnsubmitted
Not Done

Well that'd mean the tracked widget is a window... it's pretty much an impossibility IMO.

ervin: Well that'd mean the tracked widget is a window... it's pretty much an impossibility IMO.
186​ auto result = QVector<int>();
187​ result.reserve(children.size());
188​ std::transform(children.cbegin(), children.cend(),
189​ std::back_inserter(result),
190​ [=](QWidget *w) {
191​ const auto localX = leftToRight ? widgetExpectedWidth(w) : -width();
192​ return w->pos().x() + localX;
193​ });
davidedmundsonUnsubmitted
Done

that's not true for the RTL case where the widget is expected to resize.

It would be w->pos().x() + w->width() - widgetExpectedWidth(w)

davidedmundson: that's not true for the RTL case where the widget is expected to resize. It would be w->pos…
ervinAuthorUnsubmitted
Not Done

Either I misunderstood what you meant or you got the math wrong on that one.

What you're proposing (or what I understood you're proposing) breaks the "RTL + widget at edge" case in my tests. The line I wrote is working perfectly fine for my tests with desktoppath and qtquicksettings both in LTR and RTL modes.

ervin: Either I misunderstood what you meant or you got the math wrong on that one. What you're…
194​ return result;
195​ }();
196​ if (leftToRight) {
197​ x = *std::max_element(xValues.cbegin(), xValues.cend());
198​ } else {
199​ x = *std::min_element(xValues.cbegin(), xValues.cend());
200​ }
201​ }
202​
203​ move(x, y);
204​}