KI18n

klocalizedcontext.cpp
1/*
2 SPDX-FileCopyrightText: 2013 Marco Martin <mart@kde.org>
3
4 SPDX-License-Identifier: LGPL-2.0-or-later
5*/
6
7// Undefine this because we don't want our i18n*() method names to be turned into i18nd*()
8#undef TRANSLATION_DOMAIN
9
10#include "klocalizedcontext.h"
11
12#include <klocalizedstring.h>
13
14#include "ki18n_logging.h"
15
16class KLocalizedContextPrivate
17{
18public:
19 QString m_translationDomain;
20};
21
22KLocalizedContext::KLocalizedContext(QObject *parent)
23 : QObject(parent)
24 , d(new KLocalizedContextPrivate)
25{
26}
27
28KLocalizedContext::~KLocalizedContext() = default;
29
30QString KLocalizedContext::translationDomain() const
31{
32 return d->m_translationDomain;
33}
34
35void KLocalizedContext::setTranslationDomain(const QString &domain)
36{
37 if (domain != d->m_translationDomain) {
38 d->m_translationDomain = domain;
39 Q_EMIT translationDomainChanged(domain);
40 }
41}
42
43static void subsVariant(KLocalizedString &trMessage, const QVariant &value)
44{
45 switch (value.userType()) {
46 case QMetaType::QString:
47 trMessage = trMessage.subs(value.toString());
48 break;
49 case QMetaType::Int:
50 trMessage = trMessage.subs(value.toInt());
51 break;
52 case QMetaType::Double:
53 trMessage = trMessage.subs(value.toDouble());
54 break;
55 case QMetaType::Char:
56 trMessage = trMessage.subs(value.toChar());
57 break;
58 default:
59 if (value.canConvert<QString>()) {
60 trMessage = trMessage.subs(value.toString());
61 } else {
62 trMessage = trMessage.subs(QStringLiteral("???"));
63 qCWarning(KI18N) << "couldn't convert" << value << "to translate";
64 }
65 }
66}
67
68static void resolveMessage(KLocalizedString &trMessage,
69 const QVariant &param1,
70 const QVariant &param2,
71 const QVariant &param3,
72 const QVariant &param4,
73 const QVariant &param5,
74 const QVariant &param6,
75 const QVariant &param7,
76 const QVariant &param8,
77 const QVariant &param9,
78 const QVariant &param10 = QVariant())
79{
80 if (param1.isValid()) {
81 subsVariant(trMessage, param1);
82 }
83 if (param2.isValid()) {
84 subsVariant(trMessage, param2);
85 }
86 if (param3.isValid()) {
87 subsVariant(trMessage, param3);
88 }
89 if (param4.isValid()) {
90 subsVariant(trMessage, param4);
91 }
92 if (param5.isValid()) {
93 subsVariant(trMessage, param5);
94 }
95 if (param6.isValid()) {
96 subsVariant(trMessage, param6);
97 }
98 if (param7.isValid()) {
99 subsVariant(trMessage, param7);
100 }
101 if (param8.isValid()) {
102 subsVariant(trMessage, param8);
103 }
104 if (param9.isValid()) {
105 subsVariant(trMessage, param9);
106 }
107 if (param10.isValid()) {
108 subsVariant(trMessage, param10);
109 }
110}
111
112static void resolvePlural(KLocalizedString &trMessage, const QVariant &param)
113{
114 trMessage = trMessage.subs(param.toInt());
115}
116
117QString KLocalizedContext::i18n(const QString &message,
118 const QVariant &param1,
119 const QVariant &param2,
120 const QVariant &param3,
121 const QVariant &param4,
122 const QVariant &param5,
123 const QVariant &param6,
124 const QVariant &param7,
125 const QVariant &param8,
126 const QVariant &param9,
127 const QVariant &param10) const
128{
129 if (message.isEmpty()) {
130 qCWarning(KI18N) << "i18n() needs at least one parameter";
131 return QString();
132 }
133
134 KLocalizedString trMessage;
135 if (!d->m_translationDomain.isEmpty()) {
136 trMessage = ki18nd(d->m_translationDomain.toUtf8().constData(), message.toUtf8().constData());
137 } else {
138 trMessage = ki18n(message.toUtf8().constData());
139 }
140
141 resolveMessage(trMessage, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
142
143 return trMessage.toString();
144}
145
146QString KLocalizedContext::i18nc(const QString &context,
147 const QString &message,
148 const QVariant &param1,
149 const QVariant &param2,
150 const QVariant &param3,
151 const QVariant &param4,
152 const QVariant &param5,
153 const QVariant &param6,
154 const QVariant &param7,
155 const QVariant &param8,
156 const QVariant &param9,
157 const QVariant &param10) const
158{
159 if (context.isEmpty() || message.isEmpty()) {
160 qCWarning(KI18N) << "i18nc() needs at least two arguments";
161 return QString();
162 }
163
164 KLocalizedString trMessage;
165 if (!d->m_translationDomain.isEmpty()) {
166 trMessage = ki18ndc(d->m_translationDomain.toUtf8().constData(), context.toUtf8().constData(), message.toUtf8().constData());
167 } else {
168 trMessage = ki18nc(context.toUtf8().constData(), message.toUtf8().constData());
169 }
170
171 resolveMessage(trMessage, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
172
173 return trMessage.toString();
174}
175
176QString KLocalizedContext::i18np(const QString &singular,
177 const QString &plural,
178 const QVariant &param1,
179 const QVariant &param2,
180 const QVariant &param3,
181 const QVariant &param4,
182 const QVariant &param5,
183 const QVariant &param6,
184 const QVariant &param7,
185 const QVariant &param8,
186 const QVariant &param9,
187 const QVariant &param10) const
188{
189 if (singular.isEmpty() || plural.isEmpty()) {
190 qCWarning(KI18N) << "i18np() needs at least two arguments";
191 return QString();
192 }
193
194 KLocalizedString trMessage;
195 if (!d->m_translationDomain.isEmpty()) {
196 trMessage = ki18ndp(d->m_translationDomain.toUtf8().constData(), singular.toUtf8().constData(), plural.toUtf8().constData());
197 } else {
198 trMessage = ki18np(singular.toUtf8().constData(), plural.toUtf8().constData());
199 }
200
201 resolvePlural(trMessage, param1);
202 resolveMessage(trMessage, param2, param3, param4, param5, param6, param7, param8, param9, param10);
203
204 return trMessage.toString();
205}
206
207QString KLocalizedContext::i18ncp(const QString &context,
208 const QString &singular,
209 const QString &plural,
210 const QVariant &param1,
211 const QVariant &param2,
212 const QVariant &param3,
213 const QVariant &param4,
214 const QVariant &param5,
215 const QVariant &param6,
216 const QVariant &param7,
217 const QVariant &param8,
218 const QVariant &param9,
219 const QVariant &param10) const
220{
221 if (context.isEmpty() || singular.isEmpty() || plural.isEmpty()) {
222 qCWarning(KI18N) << "i18ncp() needs at least three arguments";
223 return QString();
224 }
225
226 KLocalizedString trMessage;
227 if (!d->m_translationDomain.isEmpty()) {
228 trMessage =
229 ki18ndcp(d->m_translationDomain.toUtf8().constData(), context.toUtf8().constData(), singular.toUtf8().constData(), plural.toUtf8().constData());
230 } else {
231 trMessage = ki18ncp(context.toUtf8().constData(), singular.toUtf8().constData(), plural.toUtf8().constData());
232 }
233
234 resolvePlural(trMessage, param1);
235 resolveMessage(trMessage, param2, param3, param4, param5, param6, param7, param8, param9, param10);
236
237 return trMessage.toString();
238}
239
240QString KLocalizedContext::i18nd(const QString &domain,
241 const QString &message,
242 const QVariant &param1,
243 const QVariant &param2,
244 const QVariant &param3,
245 const QVariant &param4,
246 const QVariant &param5,
247 const QVariant &param6,
248 const QVariant &param7,
249 const QVariant &param8,
250 const QVariant &param9,
251 const QVariant &param10) const
252{
253 if (domain.isEmpty() || message.isEmpty()) {
254 qCWarning(KI18N) << "i18nd() needs at least two parameters";
255 return QString();
256 }
257
258 KLocalizedString trMessage = ki18nd(domain.toUtf8().constData(), message.toUtf8().constData());
259
260 resolveMessage(trMessage, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
261
262 return trMessage.toString();
263}
264
265QString KLocalizedContext::i18ndc(const QString &domain,
266 const QString &context,
267 const QString &message,
268 const QVariant &param1,
269 const QVariant &param2,
270 const QVariant &param3,
271 const QVariant &param4,
272 const QVariant &param5,
273 const QVariant &param6,
274 const QVariant &param7,
275 const QVariant &param8,
276 const QVariant &param9,
277 const QVariant &param10) const
278{
279 if (domain.isEmpty() || context.isEmpty() || message.isEmpty()) {
280 qCWarning(KI18N) << "i18ndc() needs at least three arguments";
281 return QString();
282 }
283
284 KLocalizedString trMessage = ki18ndc(domain.toUtf8().constData(), context.toUtf8().constData(), message.toUtf8().constData());
285
286 resolveMessage(trMessage, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
287
288 return trMessage.toString();
289}
290
291QString KLocalizedContext::i18ndp(const QString &domain,
292 const QString &singular,
293 const QString &plural,
294 const QVariant &param1,
295 const QVariant &param2,
296 const QVariant &param3,
297 const QVariant &param4,
298 const QVariant &param5,
299 const QVariant &param6,
300 const QVariant &param7,
301 const QVariant &param8,
302 const QVariant &param9,
303 const QVariant &param10) const
304{
305 if (domain.isEmpty() || singular.isEmpty() || plural.isEmpty()) {
306 qCWarning(KI18N) << "i18ndp() needs at least three arguments";
307 return QString();
308 }
309
310 KLocalizedString trMessage = ki18ndp(domain.toUtf8().constData(), singular.toUtf8().constData(), plural.toUtf8().constData());
311
312 resolvePlural(trMessage, param1);
313 resolveMessage(trMessage, param2, param3, param4, param5, param6, param7, param8, param9, param10);
314
315 return trMessage.toString();
316}
317
318QString KLocalizedContext::i18ndcp(const QString &domain,
319 const QString &context,
320 const QString &singular,
321 const QString &plural,
322 const QVariant &param1,
323 const QVariant &param2,
324 const QVariant &param3,
325 const QVariant &param4,
326 const QVariant &param5,
327 const QVariant &param6,
328 const QVariant &param7,
329 const QVariant &param8,
330 const QVariant &param9,
331 const QVariant &param10) const
332{
333 if (domain.isEmpty() || context.isEmpty() || singular.isEmpty() || plural.isEmpty()) {
334 qCWarning(KI18N) << "i18ndcp() needs at least four arguments";
335 return QString();
336 }
337
338 KLocalizedString trMessage =
339 ki18ndcp(domain.toUtf8().constData(), context.toUtf8().constData(), singular.toUtf8().constData(), plural.toUtf8().constData());
340
341 resolvePlural(trMessage, param1);
342 resolveMessage(trMessage, param2, param3, param4, param5, param6, param7, param8, param9, param10);
343
344 return trMessage.toString();
345}
346
347/////////////////////////
348
349QString KLocalizedContext::xi18n(const QString &message,
350 const QVariant &param1,
351 const QVariant &param2,
352 const QVariant &param3,
353 const QVariant &param4,
354 const QVariant &param5,
355 const QVariant &param6,
356 const QVariant &param7,
357 const QVariant &param8,
358 const QVariant &param9,
359 const QVariant &param10) const
360{
361 if (message.isEmpty()) {
362 qCWarning(KI18N) << "xi18n() needs at least one parameter";
363 return QString();
364 }
365
366 KLocalizedString trMessage;
367 if (!d->m_translationDomain.isEmpty()) {
368 trMessage = kxi18nd(d->m_translationDomain.toUtf8().constData(), message.toUtf8().constData());
369 } else {
370 trMessage = kxi18n(message.toUtf8().constData());
371 }
372
373 resolveMessage(trMessage, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
374
375 return trMessage.toString();
376}
377
378QString KLocalizedContext::xi18nc(const QString &context,
379 const QString &message,
380 const QVariant &param1,
381 const QVariant &param2,
382 const QVariant &param3,
383 const QVariant &param4,
384 const QVariant &param5,
385 const QVariant &param6,
386 const QVariant &param7,
387 const QVariant &param8,
388 const QVariant &param9,
389 const QVariant &param10) const
390{
391 if (context.isEmpty() || message.isEmpty()) {
392 qCWarning(KI18N) << "xi18nc() needs at least two arguments";
393 return QString();
394 }
395
396 KLocalizedString trMessage;
397 if (!d->m_translationDomain.isEmpty()) {
398 trMessage = kxi18ndc(d->m_translationDomain.toUtf8().constData(), context.toUtf8().constData(), message.toUtf8().constData());
399 } else {
400 trMessage = kxi18nc(context.toUtf8().constData(), message.toUtf8().constData());
401 }
402
403 resolveMessage(trMessage, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
404
405 return trMessage.toString();
406}
407
408QString KLocalizedContext::xi18np(const QString &singular,
409 const QString &plural,
410 const QVariant &param1,
411 const QVariant &param2,
412 const QVariant &param3,
413 const QVariant &param4,
414 const QVariant &param5,
415 const QVariant &param6,
416 const QVariant &param7,
417 const QVariant &param8,
418 const QVariant &param9,
419 const QVariant &param10) const
420{
421 if (singular.isEmpty() || plural.isEmpty()) {
422 qCWarning(KI18N) << "xi18np() needs at least two arguments";
423 return QString();
424 }
425
426 KLocalizedString trMessage;
427 if (!d->m_translationDomain.isEmpty()) {
428 trMessage = kxi18ndp(d->m_translationDomain.toUtf8().constData(), singular.toUtf8().constData(), plural.toUtf8().constData());
429 } else {
430 trMessage = kxi18np(singular.toUtf8().constData(), plural.toUtf8().constData());
431 }
432
433 resolvePlural(trMessage, param1);
434 resolveMessage(trMessage, param2, param3, param4, param5, param6, param7, param8, param9, param10);
435
436 return trMessage.toString();
437}
438
439QString KLocalizedContext::xi18ncp(const QString &context,
440 const QString &singular,
441 const QString &plural,
442 const QVariant &param1,
443 const QVariant &param2,
444 const QVariant &param3,
445 const QVariant &param4,
446 const QVariant &param5,
447 const QVariant &param6,
448 const QVariant &param7,
449 const QVariant &param8,
450 const QVariant &param9,
451 const QVariant &param10) const
452{
453 if (context.isEmpty() || singular.isEmpty() || plural.isEmpty()) {
454 qCWarning(KI18N) << "xi18ncp() needs at least three arguments";
455 return QString();
456 }
457
458 KLocalizedString trMessage;
459 if (!d->m_translationDomain.isEmpty()) {
460 trMessage =
461 kxi18ndcp(d->m_translationDomain.toUtf8().constData(), context.toUtf8().constData(), singular.toUtf8().constData(), plural.toUtf8().constData());
462 } else {
463 trMessage = kxi18ncp(context.toUtf8().constData(), singular.toUtf8().constData(), plural.toUtf8().constData());
464 }
465
466 resolvePlural(trMessage, param1);
467 resolveMessage(trMessage, param2, param3, param4, param5, param6, param7, param8, param9, param10);
468
469 return trMessage.toString();
470}
471
472QString KLocalizedContext::xi18nd(const QString &domain,
473 const QString &message,
474 const QVariant &param1,
475 const QVariant &param2,
476 const QVariant &param3,
477 const QVariant &param4,
478 const QVariant &param5,
479 const QVariant &param6,
480 const QVariant &param7,
481 const QVariant &param8,
482 const QVariant &param9,
483 const QVariant &param10) const
484{
485 if (domain.isEmpty() || message.isEmpty()) {
486 qCWarning(KI18N) << "xi18nd() needs at least two parameters";
487 return QString();
488 }
489
490 KLocalizedString trMessage = kxi18nd(domain.toUtf8().constData(), message.toUtf8().constData());
491
492 resolveMessage(trMessage, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
493
494 return trMessage.toString();
495}
496
497QString KLocalizedContext::xi18ndc(const QString &domain,
498 const QString &context,
499 const QString &message,
500 const QVariant &param1,
501 const QVariant &param2,
502 const QVariant &param3,
503 const QVariant &param4,
504 const QVariant &param5,
505 const QVariant &param6,
506 const QVariant &param7,
507 const QVariant &param8,
508 const QVariant &param9,
509 const QVariant &param10) const
510{
511 if (domain.isEmpty() || context.isEmpty() || message.isEmpty()) {
512 qCWarning(KI18N) << "x18ndc() needs at least three arguments";
513 return QString();
514 }
515
516 KLocalizedString trMessage = kxi18ndc(domain.toUtf8().constData(), context.toUtf8().constData(), message.toUtf8().constData());
517
518 resolveMessage(trMessage, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
519
520 return trMessage.toString();
521}
522
523QString KLocalizedContext::xi18ndp(const QString &domain,
524 const QString &singular,
525 const QString &plural,
526 const QVariant &param1,
527 const QVariant &param2,
528 const QVariant &param3,
529 const QVariant &param4,
530 const QVariant &param5,
531 const QVariant &param6,
532 const QVariant &param7,
533 const QVariant &param8,
534 const QVariant &param9,
535 const QVariant &param10) const
536{
537 if (domain.isEmpty() || singular.isEmpty() || plural.isEmpty()) {
538 qCWarning(KI18N) << "xi18ndp() needs at least three arguments";
539 return QString();
540 }
541
542 KLocalizedString trMessage = kxi18ndp(domain.toUtf8().constData(), singular.toUtf8().constData(), plural.toUtf8().constData());
543
544 resolvePlural(trMessage, param1);
545 resolveMessage(trMessage, param2, param3, param4, param5, param6, param7, param8, param9, param10);
546
547 return trMessage.toString();
548}
549
550QString KLocalizedContext::xi18ndcp(const QString &domain,
551 const QString &context,
552 const QString &singular,
553 const QString &plural,
554 const QVariant &param1,
555 const QVariant &param2,
556 const QVariant &param3,
557 const QVariant &param4,
558 const QVariant &param5,
559 const QVariant &param6,
560 const QVariant &param7,
561 const QVariant &param8,
562 const QVariant &param9,
563 const QVariant &param10) const
564{
565 if (domain.isEmpty() || context.isEmpty() || singular.isEmpty() || plural.isEmpty()) {
566 qCWarning(KI18N) << "xi18ndcp() needs at least four arguments";
567 return QString();
568 }
569
570 KLocalizedString trMessage =
571 kxi18ndcp(domain.toUtf8().constData(), context.toUtf8().constData(), singular.toUtf8().constData(), plural.toUtf8().constData());
572
573 resolvePlural(trMessage, param1);
574 resolveMessage(trMessage, param2, param3, param4, param5, param6, param7, param8, param9, param10);
575
576 return trMessage.toString();
577}
578
579#include "moc_klocalizedcontext.cpp"
KLocalizedContext::translationDomain
QString translationDomain
This property only needs to be specified if the context is being run on a library.
Definition klocalizedcontext.h:49
KLocalizedString
Class for producing and handling localized messages.
Definition klocalizedstring.h:47
KLocalizedString::toString
QString toString() const
Finalize the translation.
Definition klocalizedstring.cpp:476
KLocalizedString::subs
KLocalizedString subs(int a, int fieldWidth=0, int base=10, QChar fillChar=QLatin1Char(' ')) const
Substitute an int argument into the message.
Definition klocalizedstring.cpp:1081
QByteArray::constData
const char * constData() const const
QObject::Q_EMIT
Q_EMITQ_EMIT
QString::isEmpty
bool isEmpty() const const
QString::toUtf8
QByteArray toUtf8() const const
QVariant::canConvert
bool canConvert() const const
QVariant::isValid
bool isValid() const const
QVariant::toChar
QChar toChar() const const
QVariant::toDouble
double toDouble(bool *ok) const const
QVariant::toInt
int toInt(bool *ok) const const
QVariant::toString
QString toString() const const
QVariant::userType
int userType() const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Fri Oct 11 2024 12:10:09 by doxygen 1.12.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.