Differential D8641 Diff 22462 src/mnemonicattached.cpp

Changeset View

Standalone View

View Options

src/mnemonicattached.cpp

  • This file was added.
1​/*
2​* Copyright (C) 2017 by Marco Martin <mart@kde.org>
3​*
4​* This program is free software; you can redistribute it and/or modify
5​* it under the terms of the GNU Library General Public License as
6​* published by the Free Software Foundation; either version 2, or
7​* (at your option) any later version.
8​*
9​* This program 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
12​* GNU Library General Public License for more details
13​*
14​* You should have received a copy of the GNU Library General Public
15​* License along with this program; if not, write to the
16​* Free Software Foundation, Inc.,
17​* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18​*/
19​
20​#include "mnemonicattached.h"
21​#include <QQuickItem>
22​#include <QQuickWindow>
23​#include <QQuickRenderControl>
24​#include <QDebug>
25​
26​QHash<QKeySequence, MnemonicAttached *> MnemonicAttached::s_sequenceToObject = QHash<QKeySequence, MnemonicAttached *>();
27​QHash<MnemonicAttached *, QKeySequence> MnemonicAttached::s_objectToSequence = QHash<MnemonicAttached *, QKeySequence>();
28​
29​MnemonicAttached::MnemonicAttached(QObject *parent)
30​ : QObject(parent)
31​{
davidedmundsonUnsubmitted
Done

we can filter the window, instead of the app.

It's massively faster; qapp gets a lot of stuff.

davidedmundson: we can filter the window, instead of the app. It's massively faster; qapp gets a lot of stuff.
32​ QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent);
33​ if (parentItem) {
34​ if (parentItem->window()) {
35​ m_window = parentItem->window();
36​ m_window->installEventFilter(this);
37​ }
38​ connect(parentItem, &QQuickItem::windowChanged, this,
39​ [this](QQuickWindow *window) {
40​ if (m_window) {
41​ QWindow *renderWindow = QQuickRenderControl::renderWindowFor(m_window);
42​ if (renderWindow) {
43​ renderWindow->removeEventFilter(this);
44​ } else {
45​ m_window->removeEventFilter(this);
46​ }
47​ }
48​ m_window = window;
49​ if (m_window) {
50​ QWindow *renderWindow = QQuickRenderControl::renderWindowFor(m_window);
davidedmundsonUnsubmitted
Done

Note that the alt to show is a Breeze special feature for widgets.

davidedmundson: Note that the alt to show is a Breeze special feature for widgets.
martAuthorUnsubmitted
Done

i think it's fine assuming the style supports that... (and assume that the one which is really supported is breeze) i wouldn't know how to detect it from here?

mart: i think it's fine assuming the style supports that... (and assume that the one which is really…
51​ //renderWindow means the widget is rendering somewhere else, like a QQuickWidget
52​ if (renderWindow && renderWindow != m_window) {
53​ renderWindow->installEventFilter(this);
broulikUnsubmitted
Done

Double lookup (contains+value), also below

broulik: Double lookup (contains+value), also below
54​ } else {
55​ m_window->installEventFilter(this);
56​ }
57​ }
58​ });
59​ }
60​}
61​
62​MnemonicAttached::~MnemonicAttached()
63​{
broulikUnsubmitted
Done

isEmpty

broulik: `isEmpty`
64​ if (s_objectToSequence.contains(this)) {
65​ s_sequenceToObject.remove(s_objectToSequence.value(this));
66​ s_objectToSequence.remove(this);
67​ }
68​}
69​
70​bool MnemonicAttached::eventFilter(QObject *watched, QEvent *e)
71​{
72​ Q_UNUSED(watched)
73​
74​ if (m_richTextLabel.length() == 0) {
75​ return false;
76​ }
77​
78​ if (e->type() == QEvent::KeyPress) {
79​ QKeyEvent *ke = static_cast<QKeyEvent *>(e);
80​ if (ke->key() == Qt::Key_Alt) {
81​ m_actualRichTextLabel = m_richTextLabel;
82​ emit richTextLabelChanged();
83​ }
84​
85​ } else if (e->type() == QEvent::KeyRelease) {
86​ QKeyEvent *ke = static_cast<QKeyEvent *>(e);
87​ if (ke->key() == Qt::Key_Alt) {
88​ m_actualRichTextLabel = m_label;
89​ m_actualRichTextLabel.replace(QRegularExpression("\\&[^\\&]"), QString());
90​ emit richTextLabelChanged();
91​ }
92​ }
93​ return false;
94​}
95​
96​//Algorythm adapted from KAccelString
97​void MnemonicAttached::calculateWeights()
98​{
99​ m_weights.clear();
100​
101​ int pos = 0;
102​ bool start_character = true;
103​ bool wanted_character = false;
104​
105​ while (pos < m_label.length()) {
106​ QChar c = m_label[pos];
107​
108​ // skip non typeable characters
109​ if (!c.isLetterOrNumber()) {
110​ start_character = true;
111​ ++pos;
112​ continue;
113​ }
114​
115​ int weight = 1;
116​
117​ // add special weight to first character
118​ if (pos == 0) {
119​ weight += FIRST_CHARACTER_EXTRA_WEIGHT;
120​ }
121​
122​ // add weight to word beginnings
123​ if (start_character) {
124​ weight += WORD_BEGINNING_EXTRA_WEIGHT;
125​ start_character = false;
126​ }
127​
128​ // add weight to word beginnings
129​ if (wanted_character) {
130​ weight += WANTED_ACCEL_EXTRA_WEIGHT;
131​ wanted_character = false;
132​ }
133​
134​ // add decreasing weight to left characters
135​ if (pos < 50) {
136​ weight += (50 - pos);
137​ }
138​
139​ // try to preserve the wanted accelarators
140​ if (c == "&" && (pos == m_label.length() - 1 || m_label[pos+1] != "&")) {
141​ wanted_character = true;
142​ ++pos;
143​ continue;
144​ }
145​
146​ while (m_weights.contains(weight)) {
147​ ++weight;
148​ }
149​
150​ m_weights[weight] = c;
151​
152​ ++pos;
153​ }
154​
155​ //update our maximum weight
156​ if (m_weights.isEmpty()) {
157​ m_weight = m_baseWeight;
158​ } else {
159​ m_weight = m_baseWeight + m_weights.keys().last();
160​ }
161​}
162​
163​void MnemonicAttached::updateSequence()
164​{
165​ //forget about old association
166​ if (s_objectToSequence.contains(this)) {
167​ s_sequenceToObject.remove(s_objectToSequence.value(this));
168​ s_objectToSequence.remove(this);
broulikUnsubmitted
Done

Can we emit this stuff only if actually changed or can this be assumed here?

broulik: Can we emit this stuff only if actually changed or can this be assumed here?
169​ }
170​
171​ calculateWeights();
172​
173​ const QString text = label();
174​
175​ if (!m_enabled) {
176​ m_actualRichTextLabel = text;
177​ m_actualRichTextLabel.replace(QRegularExpression("\\&[^\\&]"), QString());
178​ m_mnemonicLabel = m_actualRichTextLabel;
179​ emit mnemonicLabelChanged();
180​ emit richTextLabelChanged();
181​ return;
182​ }
183​
184​ if (m_weights.isEmpty()) {
185​ return;
186​ }
187​
188​ QMap<int, QChar>::const_iterator i = m_weights.constEnd();
189​ do {
190​ --i;
191​ QChar c = i.value();
192​ QKeySequence ks("Alt+"%c);
193​ MnemonicAttached *otherMa = s_sequenceToObject.value(ks);
194​ Q_ASSERT(otherMa != this);
195​ if (!otherMa || otherMa->m_weight < m_weight) {
196​ //the old shortcut is less valuable than the current: remove it
197​ if (otherMa) {
198​ s_sequenceToObject.remove(otherMa->sequence());
199​ s_objectToSequence.remove(otherMa);
200​ }
201​
202​ s_sequenceToObject[ks] = this;
203​ s_objectToSequence[this] = ks;
204​ m_richTextLabel = text;
205​ m_richTextLabel.replace(QRegularExpression("\\&[^\\&]"), QString());
206​ m_actualRichTextLabel = m_richTextLabel;
207​ m_mnemonicLabel = m_richTextLabel;
208​ m_mnemonicLabel.replace(c, "&" % c);
209​ m_richTextLabel.replace(QString(c), "<u>" % c % "</u>");
210​
211​ //remap the sequence of the previous shortcut
212​ if (otherMa) {
213​ otherMa->updateSequence();
214​ }
215​
216​ break;
217​ }
218​ } while (i != m_weights.constBegin());
219​
220​ if (s_objectToSequence.contains(this)) {
221​ emit sequenceChanged();
222​ }
223​
224​ emit richTextLabelChanged();
225​ emit mnemonicLabelChanged();
226​}
227​
228​void MnemonicAttached::setLabel(const QString &text)
229​{
230​ if (m_label == text) {
broulikUnsubmitted
Done

`!isEmpty?

broulik: `!isEmpty?
231​ return;
232​ }
233​
234​ m_label = text;
235​ updateSequence();
236​ emit labelChanged();
237​}
238​
239​QString MnemonicAttached::richTextLabel() const
240​{
241​ return m_actualRichTextLabel.length() > 0 ? m_actualRichTextLabel : m_label;
242​}
243​
244​QString MnemonicAttached::mnemonicLabel() const
245​{
246​ return m_mnemonicLabel;
247​}
248​
249​QString MnemonicAttached::label() const
250​{
251​ return m_label;
252​}
253​
254​void MnemonicAttached::setEnabled(bool enabled)
255​{
256​ if (m_enabled == enabled) {
257​ return;
258​ }
259​
260​ m_enabled = enabled;
261​ updateSequence();
262​ emit enabledChanged();
263​}
264​
265​bool MnemonicAttached::enabled() const
266​{
267​ return m_enabled;
268​}
269​
270​void MnemonicAttached::setControlType(MnemonicAttached::ControlType controlType)
271​{
272​ if (m_controlType == controlType) {
273​ return;
274​ }
275​
276​ m_controlType = controlType;
277​
278​ switch (controlType) {
279​ case ActionElement:
280​ m_baseWeight = ACTION_ELEMENT_WEIGHT;
281​ break;
282​ case DialogButton:
283​ m_baseWeight = DIALOG_BUTTON_EXTRA_WEIGHT;
284​ break;
285​ case MenuItem:
286​ m_baseWeight = MENU_ITEM_WEIGHT;
287​ break;
288​ case FormLabel:
broulikUnsubmitted
Done

(m_weights.constEnd() - 1).key()? Avoids creating a keys() temporary list

broulik: `(m_weights.constEnd() - 1).key()`? Avoids creating a `keys()` temporary list
289​ m_baseWeight = FORM_LABEL_WEIGHT;
290​ break;
291​ default:
292​ m_baseWeight = SECONDARY_CONTROL_WEIGHT;
293​ break;
294​ }
295​ //update our maximum weight
296​ if (m_weights.isEmpty()) {
297​ m_weight = m_baseWeight;
298​ } else {
299​ m_weight = m_baseWeight + m_weights.keys().last();
300​ }
301​ emit controlTypeChanged();
302​}
303​
304​MnemonicAttached::ControlType MnemonicAttached::controlType() const
305​{
306​ return m_controlType;
307​}
308​
309​QKeySequence MnemonicAttached::sequence()
310​{
311​ return s_objectToSequence.value(this);
312​}
313​
314​MnemonicAttached *MnemonicAttached::qmlAttachedProperties(QObject *object)
315​{
316​ return new MnemonicAttached(object);
317​}
318​
319​#include "moc_mnemonicattached.cpp"