Differential D27156 Diff 77274 kcms/fonts/fontsaasettings.cpp

Changeset View

Standalone View

View Options

kcms/fonts/fontsaasettings.cpp

  • This file was added.
1​/**
2​ * Copyright 2020 Benjamin Port <benjamin.port@enioka.com>
3​ *
4​ * This program is free software; you can redistribute it and/or modify
5​ * it under the terms of the GNU General Public License as published by
6​ * the Free Software Foundation; either version 2 of the License, 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 General Public License for more details.
13​ *
14​ * You should have received a copy of the GNU General Public License
15​ * along with this program; if not, write to the Free Software
16​ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17​ */
18​
19​#include "fontsaasettings.h"
20​
21​#include <QDebug>
22​#include <KWindowSystem>
23​
24​#include "kxftconfig.h"
25​
26​namespace {
27​ bool defaultExclude()
28​ {
29​ return false;
30​ }
31​
32​ int defaultExcludeFrom()
33​ {
34​ return 8;
35​ }
36​
37​ int defaultExcludeTo()
38​ {
39​ return 15;
40​ }
41​
42​ bool defaultAntiAliasing()
43​ {
44​ return true;
45​ }
46​
47​ int defaultSubPixel()
48​ {
49​ return KXftConfig::SubPixel::Rgb;
50​ }
51​
52​ int defaultHinting()
53​ {
54​ return KXftConfig::Hint::Slight;
55​ }
56​}
57​
58​
59​class FontAASettingsStore : public QObject
60​{
61​ Q_OBJECT
62​ Q_PROPERTY(bool exclude READ exclude WRITE setExclude)
63​ Q_PROPERTY(int excludeFrom READ excludeFrom WRITE setExcludeFrom)
64​ Q_PROPERTY(int excludeTo READ excludeTo WRITE setExcludeTo)
65​ Q_PROPERTY(bool antiAliasing READ antiAliasing WRITE setAntiAliasing)
66​ Q_PROPERTY(KXftConfig::SubPixel::Type subPixel READ subPixel WRITE setSubPixel)
67​ Q_PROPERTY(KXftConfig::Hint::Style hinting READ hinting WRITE setHinting)
68​public:
69​ FontAASettingsStore(FontsAASettings *parent = nullptr)
70​ : QObject(parent)
71​ , m_settings(parent)
ervinUnsubmitted
Not Done

Wrong indentation

ervin: Wrong indentation
72​ {
73​ load();
74​ }
75​
76​ bool exclude() const
77​ {
78​ return m_exclude;
79​ }
80​
81​ void setExclude(bool exclude)
82​ {
83​ m_exclude = exclude;
84​ }
85​
86​ int excludeFrom() const
87​ {
88​ return m_excludeFrom;
89​ }
90​
91​ void setExcludeFrom(int excludeFrom)
92​ {
93​ m_excludeFrom = excludeFrom;
94​ }
95​
96​ int excludeTo() const
97​ {
98​ return m_excludeTo;
99​ }
100​
101​ void setExcludeTo(int excludeTo)
102​ {
103​ m_excludeTo = excludeTo;
104​ }
105​
106​ bool antiAliasing() const
107​ {
108​ return m_antiAliasing;
109​ }
110​
111​ void setAntiAliasing(bool antiAliasing)
112​ {
113​ if (antiAliasing != m_antiAliasing) {
114​ m_antiAliasingChanged = true;
115​ }
116​ m_antiAliasing = antiAliasing;
117​ }
118​
119​ KXftConfig::SubPixel::Type subPixel() const
120​ {
121​ return m_subPixel;
122​ }
123​
124​ void setSubPixel(KXftConfig::SubPixel::Type subPixel)
125​ {
126​ m_subPixel = subPixel;
127​ }
128​
129​ KXftConfig::Hint::Style hinting() const
130​ {
131​ return m_hinting;
132​ }
133​
134​ void setHinting(KXftConfig::Hint::Style hinting)
135​ {
136​ m_hinting = hinting;
137​ }
138​
139​ void save()
140​ {
141​ KXftConfig xft;
142​ KXftConfig::AntiAliasing::State aaState = KXftConfig::AntiAliasing::NotSet;
143​ if (m_antiAliasingChanged || xft.antiAliasingHasLocalConfig()) {
144​ aaState = m_antiAliasing ? KXftConfig::AntiAliasing::Enabled : KXftConfig::AntiAliasing::Disabled;
145​ }
146​ xft.setAntiAliasing(aaState);
147​
148​ if (m_exclude) {
149​ xft.setExcludeRange(m_excludeFrom, m_excludeTo);
150​ } else {
151​ xft.setExcludeRange(0, 0);
152​ }
153​
154​ KXftConfig::SubPixel::Type spType = static_cast<KXftConfig::SubPixel::Type>(m_subPixel);
155​ if (m_subPixelChanged || xft.subPixelTypeHasLocalConfig()) {
156​ xft.setSubPixelType(spType);
157​ } else {
158​ xft.setSubPixelType(KXftConfig::SubPixel::NotSet);
159​ }
160​
161​ KXftConfig::Hint::Style hStyle = static_cast<KXftConfig::Hint::Style>(m_hinting);
162​ if (m_hintingChanged || xft.hintStyleHasLocalConfig()) {
163​ xft.setHintStyle(hStyle);
164​ } else {
165​ xft.setHintStyle(KXftConfig::Hint::NotSet);
166​ }
167​
168​ // Write to KConfig to sync with krdb
169​ KSharedConfig::Ptr config = KSharedConfig::openConfig("kdeglobals");
170​ KConfigGroup grp(config, "General");
171​
172​ grp.writeEntry("XftSubPixel", KXftConfig::toStr(spType));
173​
174​ if (aaState == KXftConfig::AntiAliasing::NotSet) {
175​ grp.revertToDefault("XftAntialias");
176​ } else {
177​ grp.writeEntry("XftAntialias", aaState == KXftConfig::AntiAliasing::Enabled);
178​ }
179​
180​ QString hs(KXftConfig::toStr(hStyle));
181​ if (hs != grp.readEntry("XftHintStyle")) {
182​ if (KXftConfig::Hint::NotSet == hStyle) {
183​ grp.revertToDefault("XftHintStyle");
184​ } else {
185​ grp.writeEntry("XftHintStyle", hs);
186​ }
187​ }
188​
189​ xft.apply();
190​
191​ m_subPixelChanged = false;
192​ m_hintingChanged = false;
193​ m_antiAliasingChanged = false;
194​ }
195​
196​ void load()
197​ {
198​ double from, to;
199​ KXftConfig xft;
200​
201​ if (xft.getExcludeRange(from, to)) {
202​ setExclude(true);
203​ setExcludeFrom(from);
204​ setExcludeTo(to);
205​ } else {
206​ setExclude(defaultExclude());
207​ setExcludeFrom(defaultExcludeFrom());
208​ setExcludeTo(defaultExcludeTo());
209​ }
210​
211​ // sub pixel
212​ KXftConfig::SubPixel::Type spType = KXftConfig::SubPixel::NotSet;
213​ xft.getSubPixelType(spType);
214​ // if it is not set, we set it to rgb
215​ if (spType == KXftConfig::SubPixel::NotSet) {
216​ spType = KXftConfig::SubPixel::Rgb;
217​ }
218​ setSubPixel(spType);
219​
220​ // hinting
221​ KXftConfig::Hint::Style hStyle = KXftConfig::Hint::NotSet;
222​ xft.getHintStyle(hStyle);
223​ // if it is not set, we set it to slight hinting
224​ if (hStyle == KXftConfig::Hint::NotSet) {
225​ hStyle = KXftConfig::Hint::Slight;
ervinUnsubmitted
Not Done

I'd go for the enums all the way until here of course

ervin: I'd go for the enums all the way until here of course
226​ }
227​ setHinting(hStyle);
228​
229​ KSharedConfig::Ptr config = KSharedConfig::openConfig("kdeglobals");
230​ KConfigGroup cg(config, "General");
231​ const auto aaState = xft.getAntiAliasing();
232​ setAntiAliasing(aaState != KXftConfig::AntiAliasing::Disabled);
233​
234​ m_subPixelChanged = false;
235​ m_hintingChanged = false;
236​ m_antiAliasingChanged = false;
237​ }
238​
239​private:
240​ FontsAASettings *m_settings;
241​ bool m_antiAliasing;
242​ bool m_antiAliasingChanged;
243​ KXftConfig::SubPixel::Type m_subPixel;
244​ bool m_subPixelChanged;
245​ KXftConfig::Hint::Style m_hinting;
246​ bool m_hintingChanged;
247​ bool m_exclude;
248​ int m_excludeFrom;
249​ int m_excludeTo;
250​};
251​
252​
253​FontsAASettings::FontsAASettings(QObject *parent)
254​ : FontsAASettingsBase(parent)
255​ , m_fontAASettingsStore(new FontAASettingsStore(this))
256​{
257​ addItemInternal("exclude", defaultExclude(), &FontsAASettings::excludeChanged);
258​ addItemInternal("excludeFrom", defaultExcludeFrom(), &FontsAASettings::excludeFromChanged);
259​ addItemInternal("excludeTo", defaultExcludeTo(), &FontsAASettings::excludeToChanged);
260​ addItemInternal("antiAliasing", defaultAntiAliasing(), &FontsAASettings::antiAliasingChanged);
261​ addItemInternal("subPixel", defaultSubPixel(), &FontsAASettings::subPixelChanged);
262​ addItemInternal("hinting", defaultHinting(), &FontsAASettings::hintingChanged);
263​
264​ connect(this, &FontsAASettings::forceFontDPIWaylandChanged, this, &FontsAASettings::dpiChanged);
265​ connect(this, &FontsAASettings::forceFontDPIChanged, this, &FontsAASettings::dpiChanged);
266​}
267​
268​void FontsAASettings::addItemInternal(const QByteArray &propertyName, const QVariant &defaultValue, NotifySignalType notifySignal)
269​{
270​ auto item = new KPropertySkeletonItem(m_fontAASettingsStore, propertyName, defaultValue);
271​ addItem(item, propertyName);
272​ item->setNotifyFunction([this, notifySignal] { emit (this->*notifySignal)(); });
273​}
274​
275​bool FontsAASettings::exclude() const
276​{
277​ return findItem("exclude")->property().toBool();
278​}
279​
280​void FontsAASettings::setExclude(bool exclude)
281​{
282​ findItem("exclude")->setProperty(exclude);
283​}
284​
285​int FontsAASettings::excludeFrom() const
286​{
287​ return findItem("excludeFrom")->property().toInt();
288​}
289​
290​void FontsAASettings::setExcludeFrom(int excludeFrom)
291​{
292​ findItem("excludeFrom")->setProperty(excludeFrom);
293​}
294​
295​int FontsAASettings::excludeTo() const
296​{
297​ return findItem("excludeTo")->property().toInt();
298​}
299​
300​void FontsAASettings::setExcludeTo(int excludeTo)
301​{
302​ findItem("excludeTo")->setProperty(excludeTo);
303​}
304​
305​bool FontsAASettings::antiAliasing() const
306​{
crossiUnsubmitted
Done

add space between if and ( please

crossi: add space between `if` and `(` please
307​ return findItem("antiAliasing")->property().toBool();
308​}
309​
310​void FontsAASettings::setAntiAliasing(bool antiAliasing)
311​{
312​ findItem("antiAliasing")->setProperty(antiAliasing);
313​}
314​
315​int FontsAASettings::dpi() const
316​{
317​ if (KWindowSystem::isPlatformWayland()) {
318​ return forceFontDPIWayland();
319​ } else {
320​ return forceFontDPI();
321​ }
322​}
323​
324​void FontsAASettings::setDpi(int newDPI)
325​{
326​ if (dpi() == newDPI) {
327​ return;
328​ }
329​ if (KWindowSystem::isPlatformWayland()) {
330​ setForceFontDPIWayland(newDPI);
331​ } else {
332​ setForceFontDPI(newDPI);
333​ }
334​ emit dpiChanged();
335​}
336​
337​KXftConfig::SubPixel::Type FontsAASettings::subPixel() const
338​{
339​ return findItem("subPixel")->property().value<KXftConfig::SubPixel::Type>();
340​}
341​
342​void FontsAASettings::setSubPixel(KXftConfig::SubPixel::Type subPixel)
343​{
344​ findItem("subPixel")->setProperty(subPixel);
345​}
346​
347​KXftConfig::Hint::Style FontsAASettings::hinting() const
348​{
349​ return findItem("hinting")->property().value<KXftConfig::Hint::Style>();
350​}
351​
352​void FontsAASettings::setHinting(KXftConfig::Hint::Style hinting)
353​{
354​ findItem("hinting")->setProperty(hinting);
355​}
356​
357​bool FontsAASettings::usrSave()
358​{
359​ m_fontAASettingsStore->save();
360​ return FontsAASettingsBase::usrSave();
361​}
362​
363​#include "fontsaasettings.moc"