• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.14.38 API Reference
  • KDE Home
  • Contact Us
 

KDECore

  • kdecore
  • sonnet
loader.cpp
Go to the documentation of this file.
1// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*-
21#include "loader_p.h"
22#include "settings_p.h"
23#include "client_p.h"
24#include "spellerplugin_p.h"
25
26#include <klocale.h>
27#include <kservicetypetrader.h>
28
29#include <kconfig.h>
30#include <kdebug.h>
31
32#include <QtCore/QHash>
33#include <QtCore/QMap>
34
35#define DEFAULT_CONFIG_FILE "sonnetrc"
36
37namespace Sonnet
38{
39
40class Loader::Private
41{
42public:
43 KService::List plugins;
44 Settings *settings;
45
46 // <language, Clients with that language >
47 QMap<QString, QList<Client*> > languageClients;
48 QStringList clients;
49
50 QStringList languagesNameCache;
51};
52
53K_GLOBAL_STATIC(Loader, s_loader)
54
55Loader *Loader::openLoader()
56{
57 if (s_loader.isDestroyed()) {
58 return 0;
59 }
60
61 return s_loader;
62}
63
64Loader::Loader()
65 :d(new Private)
66{
67 d->settings = new Settings(this);
68 KConfig config(QString::fromLatin1(DEFAULT_CONFIG_FILE));
69 d->settings->restore(&config);
70 loadPlugins();
71}
72
73Loader::~Loader()
74{
75 //kDebug()<<"Removing loader : "<< this;
76 d->plugins.clear();
77 delete d->settings; d->settings = 0;
78 delete d;
79}
80
81SpellerPlugin *Loader::createSpeller(const QString& language,
82 const QString& clientName) const
83{
84 QString pclient = clientName;
85 QString plang = language;
86
87 if (plang.isEmpty()) {
88 plang = d->settings->defaultLanguage();
89 }
90
91 const QList<Client*> lClients = d->languageClients[plang];
92
93 if (lClients.isEmpty()) {
94 kError()<<"No language dictionaries for the language : "
95 << plang <<endl;
96 return 0;
97 }
98
99 QListIterator<Client*> itr(lClients);
100 while (itr.hasNext()) {
101 Client* item = itr.next();
102 if (!pclient.isEmpty()) {
103 if (pclient == item->name()) {
104 SpellerPlugin *dict = item->createSpeller(plang);
105 return dict;
106 }
107 } else {
108 //the first one is the one with the highest
109 //reliability
110 SpellerPlugin *dict = item->createSpeller(plang);
111 return dict;
112 }
113 }
114
115 return 0;
116}
117
118QStringList Loader::clients() const
119{
120 return d->clients;
121}
122
123QStringList Loader::languages() const
124{
125 return d->languageClients.keys();
126}
127
128QString Loader::languageNameForCode(const QString &langCode) const
129{
130 QString currentDictionary = langCode, // e.g. en_GB-ize-wo_accents
131 lISOName, // language ISO name
132 cISOName, // country ISO name
133 variantName, // dictionary variant name e.g. w_accents
134 localizedLang, // localized language
135 localizedCountry; // localized country
136 QByteArray variantEnglish; // dictionary variant in English
137
138 int underscorePos, // position of "_" char
139 minusPos, // position of "-" char
140 variantCount = 0; // used to iterate over variantList
141
142 struct variantListType
143 {
144 const char* variantShortName;
145 const char* variantEnglishName;
146 };
147
148 const variantListType variantList[] = {
149 { "40", I18N_NOOP2("dictionary variant", "40") }, // what does 40 mean?
150 { "60", I18N_NOOP2("dictionary variant", "60") }, // what does 60 mean?
151 { "80", I18N_NOOP2("dictionary variant", "80") }, // what does 80 mean?
152 { "ise", I18N_NOOP2("dictionary variant", "-ise suffixes") },
153 { "ize", I18N_NOOP2("dictionary variant", "-ize suffixes") },
154 { "ise-w_accents", I18N_NOOP2("dictionary variant", "-ise suffixes and with accents") },
155 { "ise-wo_accents", I18N_NOOP2("dictionary variant", "-ise suffixes and without accents") },
156 { "ize-w_accents", I18N_NOOP2("dictionary variant", "-ize suffixes and with accents") },
157 { "ize-wo_accents", I18N_NOOP2("dictionary variant", "-ize suffixes and without accents") },
158 { "lrg", I18N_NOOP2("dictionary variant", "large") },
159 { "med", I18N_NOOP2("dictionary variant", "medium") },
160 { "sml", I18N_NOOP2("dictionary variant", "small") },
161 { "variant_0", I18N_NOOP2("dictionary variant", "variant 0") },
162 { "variant_1", I18N_NOOP2("dictionary variant", "variant 1") },
163 { "variant_2", I18N_NOOP2("dictionary variant", "variant 2") },
164 { "wo_accents", I18N_NOOP2("dictionary variant", "without accents") },
165 { "w_accents", I18N_NOOP2("dictionary variant", "with accents") },
166 { "ye", I18N_NOOP2("dictionary variant", "with ye") },
167 { "yeyo", I18N_NOOP2("dictionary variant", "with yeyo") },
168 { "yo", I18N_NOOP2("dictionary variant", "with yo") },
169 { "extended", I18N_NOOP2("dictionary variant", "extended") },
170 { 0, 0 }
171 };
172
173 minusPos = currentDictionary.indexOf(QLatin1Char('-'));
174 underscorePos = currentDictionary.indexOf(QLatin1Char('_'));
175 if (underscorePos != -1 && underscorePos <= 3) {
176 cISOName = currentDictionary.mid(underscorePos + 1, 2);
177 lISOName = currentDictionary.left(underscorePos);
178 if ( minusPos != -1 )
179 variantName = currentDictionary.right(
180 currentDictionary.length() - minusPos - 1);
181 } else {
182 if ( minusPos != -1 ) {
183 variantName = currentDictionary.right(
184 currentDictionary.length() - minusPos - 1);
185 lISOName = currentDictionary.left(minusPos);
186 }
187 else
188 lISOName = currentDictionary;
189 }
190 localizedLang = KGlobal::locale()->languageCodeToName(lISOName);
191 if (localizedLang.isEmpty())
192 localizedLang = lISOName;
193 if (!cISOName.isEmpty()) {
194 if (!KGlobal::locale()->countryCodeToName(cISOName).isEmpty())
195 localizedCountry = KGlobal::locale()->countryCodeToName(cISOName);
196 else
197 localizedCountry = cISOName;
198 }
199 if (!variantName.isEmpty()) {
200 while (variantList[variantCount].variantShortName != 0)
201 if (QLatin1String(variantList[variantCount].variantShortName) == variantName)
202 break;
203 else
204 variantCount++;
205 if (variantList[variantCount].variantShortName != 0)
206 variantEnglish = variantList[variantCount].variantEnglishName;
207 else
208 variantEnglish = variantName.toLatin1();
209 }
210 if (!cISOName.isEmpty() && !variantName.isEmpty())
211 return i18nc(
212 "dictionary name. %1-language, %2-country and %3 variant name",
213 "%1 (%2) [%3]", localizedLang, localizedCountry,
214 i18nc( "dictionary variant", variantEnglish));
215 else if (!cISOName.isEmpty())
216 return i18nc(
217 "dictionary name. %1-language and %2-country name",
218 "%1 (%2)", localizedLang, localizedCountry);
219 else if (!variantName.isEmpty())
220 return i18nc(
221 "dictionary name. %1-language and %2-variant name",
222 "%1 [%2]", localizedLang,
223 i18nc("dictionary variant", variantEnglish));
224 else
225 return localizedLang;
226}
227
228QStringList Loader::languageNames() const
229{
230 /* For whatever reason languages() might change. So,
231 * to be in sync with it let's do the following check.
232 */
233 if (d->languagesNameCache.count() == languages().count() )
234 return d->languagesNameCache;
235
236 QStringList allLocalizedDictionaries;
237 const QStringList allDictionaries = languages();
238
239 for (QStringList::ConstIterator it = allDictionaries.begin();
240 it != allDictionaries.end(); ++it) {
241 allLocalizedDictionaries.append(languageNameForCode(*it));
242 }
243 // cache the list
244 d->languagesNameCache = allLocalizedDictionaries;
245 return allLocalizedDictionaries;
246}
247
248Settings* Loader::settings() const
249{
250 return d->settings;
251}
252
253void Loader::loadPlugins()
254{
255 d->plugins = KServiceTypeTrader::self()->query(QString::fromLatin1("Sonnet/SpellClient"));
256
257 for (KService::List::const_iterator itr = d->plugins.constBegin();
258 itr != d->plugins.constEnd(); ++itr ) {
259 loadPlugin((*itr));
260 }
261}
262
263void Loader::loadPlugin(const KSharedPtr<KService> &service)
264{
265 QString error;
266
267 Client *client = service->createInstance<Client>(this,
268 QVariantList(),
269 &error);
270
271 if (client) {
272 const QStringList languages = client->languages();
273 d->clients.append(client->name());
274
275 for (QStringList::const_iterator itr = languages.begin();
276 itr != languages.end(); ++itr) {
277 if (!d->languageClients[*itr].isEmpty() &&
278 client->reliability() <
279 d->languageClients[*itr].first()->reliability())
280 d->languageClients[*itr].append(client);
281 else
282 d->languageClients[*itr].prepend(client);
283 }
284
285 //kDebug() << "Successfully loaded plugin:" << service->entryPath();
286 } else {
287 kDebug() << error;
288 }
289}
290
291void Loader::changed()
292{
293 emit configurationChanged();
294}
295
296}
297
298#include "loader_p.moc"
KConfig
The central class of the KDE configuration data system.
Definition: kconfig.h:71
KLocale::languageCodeToName
QString languageCodeToName(const QString &language) const
Convert a known language code to a human readable, localized form.
Definition: klocale.cpp:670
KLocale::countryCodeToName
QString countryCodeToName(const QString &country) const
Convert a known country code to a human readable, localized form.
Definition: klocale.cpp:680
KServiceTypeTrader::self
static KServiceTypeTrader * self()
This is a static pointer to the KServiceTypeTrader singleton.
Definition: kservicetypetrader.cpp:37
KServiceTypeTrader::query
KService::List query(const QString &servicetype, const QString &constraint=QString()) const
The main function in the KServiceTypeTrader class.
Definition: kservicetypetrader.cpp:134
KSharedPtr
Can be used to control the lifetime of an object that has derived QSharedData.
Definition: ksharedptr.h:64
QList< Ptr >
QMap
QStringList
QString
Sonnet::Client
Definition: client_p.h:44
Sonnet::Client::name
virtual QString name() const =0
Sonnet::Client::createSpeller
virtual SpellerPlugin * createSpeller(const QString &language)=0
Returns a dictionary for the given language.
Sonnet::Loader
Class used to deal with dictionaries.
Definition: loader_p.h:46
Sonnet::Loader::~Loader
~Loader()
Definition: loader.cpp:73
Sonnet::Loader::changed
void changed()
Definition: loader.cpp:291
Sonnet::Loader::languageNameForCode
QString languageNameForCode(const QString &langCode) const
Definition: loader.cpp:128
Sonnet::Loader::clients
QStringList clients() const
Returns names of all supported clients (e.g.
Definition: loader.cpp:118
Sonnet::Loader::settings
Settings * settings() const
Returns the Settings object used by the loader.
Definition: loader.cpp:248
Sonnet::Loader::createSpeller
SpellerPlugin * createSpeller(const QString &language=QString(), const QString &client=QString()) const
Returns dictionary for the given language and preferred client.
Definition: loader.cpp:81
Sonnet::Loader::Settings
friend class Settings
Definition: loader_p.h:115
Sonnet::Loader::configurationChanged
void configurationChanged()
Signal is emitted whenever the Settings object associated with this Loader changes.
Sonnet::Loader::languageNames
QStringList languageNames() const
Returns a localized list of names of supported languages.
Definition: loader.cpp:228
Sonnet::Loader::languages
QStringList languages() const
Returns a list of supported languages.
Definition: loader.cpp:123
Sonnet::Loader::Loader
Loader()
Definition: loader.cpp:64
Sonnet::Settings
Settings class.
Definition: settings_p.h:38
Sonnet::SpellerPlugin
Class is returned by from Loader.
Definition: spellerplugin_p.h:39
client_p.h
K_GLOBAL_STATIC
#define K_GLOBAL_STATIC(TYPE, NAME)
This macro makes it easy to use non-POD types as global statics.
Definition: kglobal.h:221
kDebug
#define kDebug
Definition: kdebug.h:316
kError
static QDebug kError(bool cond, int area=KDE_DEFAULT_DEBUG_AREA)
Definition: kdebug.h:187
kconfig.h
kdebug.h
klocale.h
i18nc
QString i18nc(const char *ctxt, const char *text)
Returns a localized version of a string and a context.
Definition: klocalizedstring.h:797
I18N_NOOP2
#define I18N_NOOP2(comment, x)
If the string is too ambiguous to be translated well to a non-english language, use this instead of I...
Definition: klocalizedstring.h:72
kservicetypetrader.h
DEFAULT_CONFIG_FILE
#define DEFAULT_CONFIG_FILE
Copyright (C) 2003 Zack Rusin zack@kde.org
Definition: loader.cpp:35
loader_p.h
KGlobal::locale
KLocale * locale()
Returns the global locale object.
Definition: kglobal.cpp:170
Sonnet
The sonnet namespace.
Definition: backgroundchecker.h:34
settings_p.h
spellerplugin_p.h
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Mon Feb 20 2023 00:00:00 by doxygen 1.9.6 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KDECore

Skip menu "KDECore"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Modules
  • Related Pages

kdelibs-4.14.38 API Reference

Skip menu "kdelibs-4.14.38 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal