Differential D8641 Diff 23008 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​ QHash<MnemonicAttached *, QKeySequence>::iterator i = s_objectToSequence.find(this);
65​ if (i != s_objectToSequence.end()) {
66​ s_sequenceToObject.remove(i.value());
67​ s_objectToSequence.erase(i);
68​ }
69​}
70​
71​bool MnemonicAttached::eventFilter(QObject *watched, QEvent *e)
72​{
73​ Q_UNUSED(watched)
74​
75​ if (m_richTextLabel.isEmpty()) {
76​ return false;
77​ }
78​
79​ if (e->type() == QEvent::KeyPress) {
80​ QKeyEvent *ke = static_cast<QKeyEvent *>(e);
81​ if (ke->key() == Qt::Key_Alt) {
82​ m_actualRichTextLabel = m_richTextLabel;
83​ emit richTextLabelChanged();
84​ }
85​
86​ } else if (e->type() == QEvent::KeyRelease) {
87​ QKeyEvent *ke = static_cast<QKeyEvent *>(e);
88​ if (ke->key() == Qt::Key_Alt) {
89​ m_actualRichTextLabel = m_label;
90​ m_actualRichTextLabel.replace(QRegularExpression("\\&[^\\&]"), QString());
91​ emit richTextLabelChanged();
92​ }
93​ }
94​ return false;
95​}
96​
97​//Algorythm adapted from KAccelString
98​void MnemonicAttached::calculateWeights()
99​{
100​ m_weights.clear();
101​
102​ int pos = 0;
103​ bool start_character = true;
104​ bool wanted_character = false;
105​
106​ while (pos < m_label.length()) {
107​ QChar c = m_label[pos];
108​
109​ // skip non typeable characters
110​ if (!c.isLetterOrNumber()) {
111​ start_character = true;
112​ ++pos;
113​ continue;
114​ }
115​
116​ int weight = 1;
117​
118​ // add special weight to first character
119​ if (pos == 0) {
120​ weight += FIRST_CHARACTER_EXTRA_WEIGHT;
121​ }
122​
123​ // add weight to word beginnings
124​ if (start_character) {
125​ weight += WORD_BEGINNING_EXTRA_WEIGHT;
126​ start_character = false;
127​ }
128​
129​ // add weight to word beginnings
130​ if (wanted_character) {
131​ weight += WANTED_ACCEL_EXTRA_WEIGHT;
132​ wanted_character = false;
133​ }
134​
135​ // add decreasing weight to left characters
136​ if (pos < 50) {
137​ weight += (50 - pos);
138​ }
139​
140​ // try to preserve the wanted accelarators
141​ if (c == "&" && (pos == m_label.length() - 1 || m_label[pos+1] != "&")) {
142​ wanted_character = true;
143​ ++pos;
144​ continue;
145​ }
146​
147​ while (m_weights.contains(weight)) {
148​ ++weight;
149​ }
150​
151​ m_weights[weight] = c;
152​
153​ ++pos;
154​ }
155​
156​ //update our maximum weight
157​ if (m_weights.isEmpty()) {
158​ m_weight = m_baseWeight;
159​ } else {
160​ m_weight = m_baseWeight + m_weights.keys().last();
161​ }
162​}
163​
164​void MnemonicAttached::updateSequence()
165​{
166​ //forget about old association
167​ QHash<MnemonicAttached *, QKeySequence>::iterator objIt = s_objectToSequence.find(this);
168​ if (objIt != s_objectToSequence.end()) {
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​ s_sequenceToObject.remove(objIt.value());
170​ s_objectToSequence.erase(objIt);
171​ }
172​
173​ calculateWeights();
174​
175​ const QString text = label();
176​
177​ if (!m_enabled) {
178​ m_actualRichTextLabel = text;
179​ m_actualRichTextLabel.replace(QRegularExpression("\\&[^\\&]"), QString());
180​ //was the label already completely plain text? try to limit signal emission
181​ if (m_mnemonicLabel != m_actualRichTextLabel) {
182​ m_mnemonicLabel = m_actualRichTextLabel;
183​ emit mnemonicLabelChanged();
184​ emit richTextLabelChanged();
185​ }
186​ return;
187​ }
188​
189​ if (m_weights.isEmpty()) {
190​ return;
191​ }
192​
193​ QMap<int, QChar>::const_iterator i = m_weights.constEnd();
194​ do {
195​ --i;
196​ QChar c = i.value();
197​ QKeySequence ks("Alt+"%c);
198​ MnemonicAttached *otherMa = s_sequenceToObject.value(ks);
199​ Q_ASSERT(otherMa != this);
200​ if (!otherMa || otherMa->m_weight < m_weight) {
201​ //the old shortcut is less valuable than the current: remove it
202​ if (otherMa) {
203​ s_sequenceToObject.remove(otherMa->sequence());
204​ s_objectToSequence.remove(otherMa);
205​ }
206​
207​ s_sequenceToObject[ks] = this;
208​ s_objectToSequence[this] = ks;
209​ m_richTextLabel = text;
210​ m_richTextLabel.replace(QRegularExpression("\\&[^\\&]"), QString());
211​ m_actualRichTextLabel = m_richTextLabel;
212​ m_mnemonicLabel = m_richTextLabel;
213​ m_mnemonicLabel.replace(c, "&" % c);
214​ m_richTextLabel.replace(QString(c), "<u>" % c % "</u>");
215​
216​ //remap the sequence of the previous shortcut
217​ if (otherMa) {
218​ otherMa->updateSequence();
219​ }
220​
221​ break;
222​ }
223​ } while (i != m_weights.constBegin());
224​
225​ if (s_objectToSequence.contains(this)) {
226​ emit sequenceChanged();
227​ } else {
228​ m_actualRichTextLabel = text;
229​ m_actualRichTextLabel.replace(QRegularExpression("\\&[^\\&]"), QString());
230​ m_mnemonicLabel = m_actualRichTextLabel;
broulikUnsubmitted
Done

`!isEmpty?

broulik: `!isEmpty?
231​ }
232​
233​ emit richTextLabelChanged();
234​ emit mnemonicLabelChanged();
235​}
236​
237​void MnemonicAttached::setLabel(const QString &text)
238​{
239​ if (m_label == text) {
240​ return;
241​ }
242​
243​ m_label = text;
244​ updateSequence();
245​ emit labelChanged();
246​}
247​
248​QString MnemonicAttached::richTextLabel() const
249​{
250​ return !m_actualRichTextLabel.isEmpty() ? m_actualRichTextLabel : m_label;
251​}
252​
253​QString MnemonicAttached::mnemonicLabel() const
254​{
255​ return m_mnemonicLabel;
256​}
257​
258​QString MnemonicAttached::label() const
259​{
260​ return m_label;
261​}
262​
263​void MnemonicAttached::setEnabled(bool enabled)
264​{
265​ if (m_enabled == enabled) {
266​ return;
267​ }
268​
269​ m_enabled = enabled;
270​ updateSequence();
271​ emit enabledChanged();
272​}
273​
274​bool MnemonicAttached::enabled() const
275​{
276​ return m_enabled;
277​}
278​
279​void MnemonicAttached::setControlType(MnemonicAttached::ControlType controlType)
280​{
281​ if (m_controlType == controlType) {
282​ return;
283​ }
284​
285​ m_controlType = controlType;
286​
287​ switch (controlType) {
288​ case ActionElement:
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 = ACTION_ELEMENT_WEIGHT;
290​ break;
291​ case DialogButton:
292​ m_baseWeight = DIALOG_BUTTON_EXTRA_WEIGHT;
293​ break;
294​ case MenuItem:
295​ m_baseWeight = MENU_ITEM_WEIGHT;
296​ break;
297​ case FormLabel:
298​ m_baseWeight = FORM_LABEL_WEIGHT;
299​ break;
300​ default:
301​ m_baseWeight = SECONDARY_CONTROL_WEIGHT;
302​ break;
303​ }
304​ //update our maximum weight
305​ if (m_weights.isEmpty()) {
306​ m_weight = m_baseWeight;
307​ } else {
308​ m_weight = m_baseWeight + (m_weights.constEnd() - 1).key();
309​ }
310​ emit controlTypeChanged();
311​}
312​
313​MnemonicAttached::ControlType MnemonicAttached::controlType() const
314​{
315​ return m_controlType;
316​}
317​
318​QKeySequence MnemonicAttached::sequence()
319​{
320​ return s_objectToSequence.value(this);
321​}
322​
323​MnemonicAttached *MnemonicAttached::qmlAttachedProperties(QObject *object)
324​{
325​ return new MnemonicAttached(object);
326​}
327​
328​#include "moc_mnemonicattached.cpp"