Sonnet

speller.cpp
1 /*
2  * SPDX-FileCopyrightText: 2007 Zack Rusin <[email protected]>
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 
16 namespace Sonnet
17 {
18 class SpellerPrivate
19 {
20 public:
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  updateDict();
36  }
37 
38  void updateDict()
39  {
40  dict = Loader::openLoader()->cachedSpeller(language);
41  }
42 
43  bool isValid()
44  {
45  if (settings->modified()) {
46  recreateDict();
47  settings->setModified(false);
48  }
49  return !dict.isNull();
50  }
51 
52  void recreateDict()
53  {
54  Loader::openLoader()->clearSpellerCache();
55  updateDict();
56  }
57 
59  SettingsImpl *settings = nullptr;
60  QString language;
61 };
62 
63 Speller::Speller(const QString &lang)
64  : d(new SpellerPrivate)
65 {
66  d->init(lang);
67 }
68 
69 Speller::~Speller()
70 {
71  qCDebug(SONNET_LOG_CORE) << "deleting" << this << "for" << d->language;
72  delete d;
73 }
74 
75 Speller::Speller(const Speller &speller)
76  : d(new SpellerPrivate)
77 {
78  d->language = speller.language();
79  d->init(d->language);
80 }
81 
82 Speller &Speller::operator=(const Speller &speller)
83 {
84  d->language = speller.language();
85  d->updateDict();
86  return *this;
87 }
88 
89 bool Speller::isCorrect(const QString &word) const
90 {
91  if (!d->isValid()) {
92  return true;
93  }
94  return d->dict->isCorrect(word);
95 }
96 
97 bool Speller::isMisspelled(const QString &word) const
98 {
99  if (!d->isValid()) {
100  return false;
101  }
102  return d->dict->isMisspelled(word);
103 }
104 
105 QStringList Speller::suggest(const QString &word) const
106 {
107  if (!d->isValid()) {
108  return QStringList();
109  }
110  return d->dict->suggest(word);
111 }
112 
113 bool Speller::checkAndSuggest(const QString &word, QStringList &suggestions) const
114 {
115  if (!d->isValid()) {
116  return true;
117  }
118  return d->dict->checkAndSuggest(word, suggestions);
119 }
120 
121 bool Speller::storeReplacement(const QString &bad, const QString &good)
122 {
123  if (!d->isValid()) {
124  return false;
125  }
126  return d->dict->storeReplacement(bad, good);
127 }
128 
129 bool Speller::addToPersonal(const QString &word)
130 {
131  if (!d->isValid()) {
132  return false;
133  }
134  return d->dict->addToPersonal(word);
135 }
136 
137 bool Speller::addToSession(const QString &word)
138 {
139  if (!d->isValid()) {
140  return false;
141  }
142  return d->dict->addToSession(word);
143 }
144 
145 QString Speller::language() const
146 {
147  if (!d->isValid()) {
148  return QString();
149  }
150  return d->dict->language();
151 }
152 
153 void Speller::save()
154 {
155  if (d->settings) {
156  d->settings->save();
157  }
158 }
159 
160 void Speller::restore()
161 {
162  if (d->settings) {
163  d->settings->restore();
164  d->recreateDict();
165  }
166 }
167 
168 QStringList Speller::availableBackends() const
169 {
170  Loader *l = Loader::openLoader();
171  return l->clients();
172 }
173 
174 QStringList Speller::availableLanguages() const
175 {
176  Loader *l = Loader::openLoader();
177  return l->languages();
178 }
179 
180 QStringList Speller::availableLanguageNames() const
181 {
182  Loader *l = Loader::openLoader();
183  return l->languageNames();
184 }
185 
186 void Speller::setDefaultLanguage(const QString &lang)
187 {
188  if (d->settings->setDefaultLanguage(lang)) {
189  d->settings->save();
190  }
191 }
192 
193 QString Speller::defaultLanguage() const
194 {
195  return d->settings->defaultLanguage();
196 }
197 
198 void Speller::setDefaultClient(const QString &client)
199 {
200  if (d->settings->setDefaultClient(client)) {
201  d->settings->save();
202  }
203 }
204 
205 QString Speller::defaultClient() const
206 {
207  return d->settings->defaultClient();
208 }
209 
210 void Speller::setAttribute(Attribute attr, bool b)
211 {
212  switch (attr) {
213  case CheckUppercase:
214  d->settings->setCheckUppercase(b);
215  break;
216  case SkipRunTogether:
217  d->settings->setSkipRunTogether(b);
218  break;
219  case AutoDetectLanguage:
220  d->settings->setAutodetectLanguage(b);
221  break;
222  }
223  d->settings->save();
224 }
225 
226 bool Speller::testAttribute(Attribute attr) const
227 {
228  switch (attr) {
229  case CheckUppercase:
230  return d->settings->checkUppercase();
231  case SkipRunTogether:
232  return d->settings->skipRunTogether();
233  case AutoDetectLanguage:
234  return d->settings->autodetectLanguage();
235  }
236  return false;
237 }
238 
239 bool Speller::isValid() const
240 {
241  return !d->dict.isNull();
242 }
243 
244 void Speller::setLanguage(const QString &lang)
245 {
246  d->language = lang;
247  d->updateDict();
248 }
249 
251 {
252  Loader *l = Loader::openLoader();
253  const QStringList lst = l->languages();
255 
256  for (const QString &tag : lst) {
257  langs.insert(l->languageNameForCode(tag), tag);
258  }
259 
260  return langs;
261 }
262 
264 {
265  Loader *l = Loader::openLoader();
267 
268  for (const QString &tag : l->settings()->preferredLanguages()) {
269  langs.insert(l->languageNameForCode(tag), tag);
270  }
271 
272  return langs;
273 }
274 
275 } // namespace Sonnet
bool isNull() const const
QCA_EXPORT void init()
QMap::iterator insert(const Key &key, const T &value)
The sonnet namespace.
bool isValid(QStringView ifopt)
QMap< QString, QString > availableDictionaries() const
Definition: speller.cpp:250
QMap< QString, QString > preferredDictionaries() const
Definition: speller.cpp:263
This file is part of the KDE documentation.
Documentation copyright © 1996-2022 The KDE developers.
Generated on Wed Sep 28 2022 04:06:04 by doxygen 1.8.17 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.