1/*
2 * SPDX-FileCopyrightText: 2007 Zack Rusin <zack@kde.org>
3 *
4 * SPDX-License-Identifier: LGPL-2.1-or-later
5 */
6#include "speller.h"
7
8#include "loader_p.h"
9#include "settingsimpl_p.h"
10#include "spellerplugin_p.h"
11
12#include "core_debug.h"
13
14#include <QCache>
15
16namespace Sonnet
17{
18class SpellerPrivate
19{
20public:
21 SpellerPrivate()
22 {
23 }
24
25 ~SpellerPrivate()
26 {
27 }
28
29 void init(const QString &lang)
30 {
31 Loader *loader = Loader::openLoader();
32 settings = loader->settings();
33
34 language = lang;
35 m_dict.reset();
36 }
37
38 QSharedPointer<SpellerPlugin> dict() const
39 {
40 if (!m_dict) {
41 m_dict = Loader::openLoader()->cachedSpeller(language);
42 }
43 return m_dict;
44 }
45
46 bool isValid()
47 {
48 if (settings->modified()) {
49 recreateDict();
50 settings->setModified(false);
51 }
52 return !dict().isNull();
53 }
54
55 void recreateDict()
56 {
57 Loader::openLoader()->clearSpellerCache();
58 m_dict.reset(); // created next time dict() is called.
59 }
60
61 mutable QSharedPointer<SpellerPlugin> m_dict;
62 SettingsImpl *settings = nullptr;
63 QString language;
64};
65
66Speller::Speller(const QString &lang)
67 : d(new SpellerPrivate)
68{
69 d->init(lang);
70}
71
72Speller::~Speller()
73{
74 qCDebug(SONNET_LOG_CORE) << "deleting" << this << "for" << d->language;
75}
76
77Speller::Speller(const Speller &speller)
78 : d(new SpellerPrivate)
79{
80 d->language = speller.language();
81 d->init(lang: d->language);
82}
83
84Speller &Speller::operator=(const Speller &speller)
85{
86 d->language = speller.language();
87 d->m_dict.reset();
88 return *this;
89}
90
91bool Speller::isCorrect(const QString &word) const
92{
93 if (!d->isValid()) {
94 return true;
95 }
96 return d->dict()->isCorrect(word);
97}
98
99bool Speller::isMisspelled(const QString &word) const
100{
101 if (!d->isValid()) {
102 return false;
103 }
104 return d->dict()->isMisspelled(word);
105}
106
107QStringList Speller::suggest(const QString &word) const
108{
109 if (!d->isValid()) {
110 return QStringList();
111 }
112 return d->dict()->suggest(word);
113}
114
115bool Speller::checkAndSuggest(const QString &word, QStringList &suggestions) const
116{
117 if (!d->isValid()) {
118 return true;
119 }
120 return d->dict()->checkAndSuggest(word, suggestions);
121}
122
123bool Speller::storeReplacement(const QString &bad, const QString &good)
124{
125 if (!d->isValid()) {
126 return false;
127 }
128 return d->dict()->storeReplacement(bad, good);
129}
130
131bool Speller::addToPersonal(const QString &word)
132{
133 if (!d->isValid()) {
134 return false;
135 }
136 return d->dict()->addToPersonal(word);
137}
138
139bool Speller::addToSession(const QString &word)
140{
141 if (!d->isValid()) {
142 return false;
143 }
144 return d->dict()->addToSession(word);
145}
146
147QString Speller::language() const
148{
149 if (!d->isValid()) {
150 return QString();
151 }
152 return d->dict()->language();
153}
154
155void Speller::save()
156{
157 if (d->settings) {
158 d->settings->save();
159 }
160}
161
162void Speller::restore()
163{
164 if (d->settings) {
165 d->settings->restore();
166 d->recreateDict();
167 }
168}
169
170QStringList Speller::availableBackends() const
171{
172 Loader *l = Loader::openLoader();
173 return l->clients();
174}
175
176QStringList Speller::availableLanguages() const
177{
178 Loader *l = Loader::openLoader();
179 return l->languages();
180}
181
182QStringList Speller::availableLanguageNames() const
183{
184 Loader *l = Loader::openLoader();
185 return l->languageNames();
186}
187
188void Speller::setDefaultLanguage(const QString &lang)
189{
190 if (d->settings->setDefaultLanguage(lang)) {
191 d->settings->save();
192 }
193}
194
195QString Speller::defaultLanguage() const
196{
197 return d->settings->defaultLanguage();
198}
199
200void Speller::setDefaultClient(const QString &client)
201{
202 if (d->settings->setDefaultClient(client)) {
203 d->settings->save();
204 }
205}
206
207QString Speller::defaultClient() const
208{
209 return d->settings->defaultClient();
210}
211
212void Speller::setAttribute(Attribute attr, bool b)
213{
214 switch (attr) {
215 case CheckUppercase:
216 d->settings->setCheckUppercase(b);
217 break;
218 case SkipRunTogether:
219 d->settings->setSkipRunTogether(b);
220 break;
221 case AutoDetectLanguage:
222 d->settings->setAutodetectLanguage(b);
223 break;
224 }
225 d->settings->save();
226}
227
228bool Speller::testAttribute(Attribute attr) const
229{
230 switch (attr) {
231 case CheckUppercase:
232 return d->settings->checkUppercase();
233 case SkipRunTogether:
234 return d->settings->skipRunTogether();
235 case AutoDetectLanguage:
236 return d->settings->autodetectLanguage();
237 }
238 return false;
239}
240
241bool Speller::isValid() const
242{
243 return !d->dict().isNull();
244}
245
246void Speller::setLanguage(const QString &lang)
247{
248 d->language = lang;
249 d->m_dict.reset();
250}
251
252QMap<QString, QString> Sonnet::Speller::availableDictionaries() const
253{
254 Loader *l = Loader::openLoader();
255 const QStringList lst = l->languages();
256 QMap<QString, QString> langs;
257
258 for (const QString &tag : lst) {
259 langs.insert(key: l->languageNameForCode(langCode: tag), value: tag);
260 }
261
262 return langs;
263}
264
265QMap<QString, QString> Speller::preferredDictionaries() const
266{
267 Loader *l = Loader::openLoader();
268 QMap<QString, QString> langs;
269
270 for (const QString &tag : l->settings()->preferredLanguages()) {
271 langs.insert(key: l->languageNameForCode(langCode: tag), value: tag);
272 }
273
274 return langs;
275}
276
277} // namespace Sonnet
278

source code of sonnet/src/core/speller.cpp