klocale.cpp
// -*- c-basic-offset: 2 -*-
/* This file is part of the KDE libraries
Copyright (c) 1997,2001 Stephan Kulow <coolo@kde.org>
Copyright (c) 1999 Preston Brown <pbrown@kde.org>
Copyright (c) 1999-2002 Hans Petter Bieker <bieker@kde.org>
Copyright (c) 2002 Lukas Tinkl <lukas@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include <config.h>
#include <stdlib.h> // getenv
#include <qtextcodec.h>
#include <qfile.h>
#include <qprinter.h>
#include <qdatetime.h>
#include <qfileinfo.h>
#include <qregexp.h>
#include "kcatalogue.h"
#include "kglobal.h"
#include "kstandarddirs.h"
#include "ksimpleconfig.h"
#include "kinstance.h"
#include "kconfig.h"
#include "kdebug.h"
#include "kcalendarsystem.h"
#include "kcalendarsystemfactory.h"
#include "klocale.h"
#ifdef Q_WS_WIN
#include <windows.h>
#endif
static const char * const SYSTEM_MESSAGES = "kdelibs";
static const char *maincatalogue = 0;
class KLocalePrivate
{
public:
int weekStartDay;
bool nounDeclension;
bool dateMonthNamePossessive;
QStringList languageList;
QStringList catalogNames; // list of all catalogs (regardless of language)
QValueList<KCatalogue> catalogues; // list of all loaded catalogs, contains one instance per catalog name and language
QString encoding;
QTextCodec * codecForEncoding;
KConfig * config;
bool formatInited;
int /*QPrinter::PageSize*/ pageSize;
KLocale::MeasureSystem measureSystem;
QStringList langTwoAlpha;
KConfig *languages;
QString calendarType;
KCalendarSystem * calendar;
bool utf8FileEncoding;
QString appName;
#ifdef Q_WS_WIN
char win32SystemEncoding[3+7]; //"cp " + lang ID
#endif
};
static KLocale *this_klocale = 0;
KLocale::KLocale( const QString & catalog, KConfig * config )
{
d = new KLocalePrivate;
d->config = config;
d->languages = 0;
d->calendar = 0;
d->formatInited = false;
initEncoding(0);
initFileNameEncoding(0);
KConfig *cfg = d->config;
this_klocale = this;
if (!cfg) cfg = KGlobal::instance()->config();
this_klocale = 0;
Q_ASSERT( cfg );
d->appName = catalog;
initLanguageList( cfg, config == 0);
initMainCatalogues(catalog);
}
QString KLocale::_initLanguage(KConfigBase *config)
{
if (this_klocale)
{
// ### HPB Why this cast??
this_klocale->initLanguageList((KConfig *) config, true);
// todo: adapt current catalog list: remove unused languages, insert main catalogs, if not already found
return this_klocale->language();
}
return QString::null;
}
void KLocale::initMainCatalogues(const QString & catalog)
{
// Use the first non-null string.
QString mainCatalogue = catalog;
if (maincatalogue)
mainCatalogue = QString::fromLatin1(maincatalogue);
if (mainCatalogue.isEmpty()) {
kdDebug(173) << "KLocale instance created called without valid "
<< "catalog! Give an argument or call setMainCatalogue "
<< "before init" << endl;
}
else {
// do not use insertCatalogue here, that would already trigger updateCatalogs
d->catalogNames.append( mainCatalogue ); // application catalog
d->catalogNames.append( SYSTEM_MESSAGES ); // always include kdelibs.mo
d->catalogNames.append( "kio" ); // always include kio.mo
updateCatalogues(); // evaluate this for all languages
}
}
void KLocale::initLanguageList(KConfig * config, bool useEnv)
{
KConfigGroupSaver saver(config, "Locale");
m_country = config->readEntry( "Country" );
if ( m_country.isEmpty() )
m_country = defaultCountry();
// Reset the list and add the new languages
QStringList languageList;
if ( useEnv )
languageList += QStringList::split
(':', QFile::decodeName( ::getenv("KDE_LANG") ));
languageList += config->readListEntry("Language", ':');
// same order as setlocale use
if ( useEnv )
{
// HPB: Only run splitLocale on the environment variables..
QStringList langs;
langs << QFile::decodeName( ::getenv("LC_ALL") );
langs << QFile::decodeName( ::getenv("LC_MESSAGES") );
langs << QFile::decodeName( ::getenv("LANG") );
for ( QStringList::Iterator it = langs.begin();
it != langs.end();
++it )
{
QString ln, ct, chrset;
splitLocale(*it, ln, ct, chrset);
if (!ct.isEmpty()) {
langs.insert(it, ln + '_' + ct);
if (!chrset.isEmpty())
langs.insert(it, ln + '_' + ct + '.' + chrset);
}
langs.insert(it, ln);
}
languageList += langs;
}
// now we have a language list -- let's use the first OK language
setLanguage( languageList );
}
void KLocale::initPluralTypes()
{
for ( QValueList<KCatalogue>::Iterator it = d->catalogues.begin();
it != d->catalogues.end();
++it )
{
QString language = (*it).language();
int pt = pluralType( language );
(*it).setPluralType( pt );
}
}
int KLocale::pluralType( const QString & language )
{
for ( QValueList<KCatalogue>::ConstIterator it = d->catalogues.begin();
it != d->catalogues.end();
++it )
{
if ( ((*it).name() == SYSTEM_MESSAGES ) && ((*it).language() == language )) {
return pluralType( *it );
}
}
// kdelibs.mo does not seem to exist for this language
return -1;
}
int KLocale::pluralType( const KCatalogue& catalog )
{
const char* pluralFormString =
I18N_NOOP("_: Dear translator, please do not translate this string "
"in any form, but pick the _right_ value out of "
"NoPlural/TwoForms/French... If not sure what to do mail "
"thd@kde.org and coolo@kde.org, they will tell you. "
"Better leave that out if unsure, the programs will "
"crash!!\nDefinition of PluralForm - to be set by the "
"translator of kdelibs.po");
QString pf (catalog.translate( pluralFormString));
if ( pf.isEmpty() ) {
return -1;
}
else if ( pf == "NoPlural" )
return 0;
else if ( pf == "TwoForms" )
return 1;
else if ( pf == "French" )
return 2;
else if ( pf == "OneTwoRest" )
return 3;
else if ( pf == "Russian" )
return 4;
else if ( pf == "Polish" )
return 5;
else if ( pf == "Slovenian" )
return 6;
else if ( pf == "Lithuanian" )
return 7;
else if ( pf == "Czech" )
return 8;
else if ( pf == "Slovak" )
return 9;
else if ( pf == "Maltese" )
return 10;
else if ( pf == "Arabic" )
return 11;
else if ( pf == "Balcan" )
return 12;
else if ( pf == "Macedonian" )
return 13;
else if ( pf == "Gaeilge" )
return 14;
else {
kdWarning(173) << "Definition of PluralForm is none of "
<< "NoPlural/"
<< "TwoForms/"
<< "French/"
<< "OneTwoRest/"
<< "Russian/"
<< "Polish/"
<< "Slovenian/"
<< "Lithuanian/"
<< "Czech/"
<< "Slovak/"
<< "Arabic/"
<< "Balcan/"
<< "Macedonian/"
<< "Gaeilge/"
<< "Maltese: " << pf << endl;
exit(1);
}
}
void KLocale::doFormatInit() const
{
if ( d->formatInited ) return;
KLocale * that = const_cast<KLocale *>(this);
that->initFormat();
d->formatInited = true;
}
void KLocale::initFormat()
{
KConfig *config = d->config;
if (!config) config = KGlobal::instance()->config();
Q_ASSERT( config );
kdDebug(173) << "KLocale::initFormat" << endl;
// make sure the config files are read using the correct locale
// ### Why not add a KConfigBase::setLocale( const KLocale * )?
// ### Then we could remove this hack
KLocale *lsave = KGlobal::_locale;
KGlobal::_locale = this;
KConfigGroupSaver saver(config, "Locale");
KSimpleConfig entry(locate("locale",
QString::fromLatin1("l10n/%1/entry.desktop")
.arg(m_country)), true);
entry.setGroup("KCM Locale");
// Numeric
#define readConfigEntry(key, default, save) \
save = entry.readEntry(key, QString::fromLatin1(default)); \
save = config->readEntry(key, save);
#define readConfigNumEntry(key, default, save, type) \
save = (type)entry.readNumEntry(key, default); \
save = (type)config->readNumEntry(key, save);
#define readConfigBoolEntry(key, default, save) \
save = entry.readBoolEntry(key, default); \
save = config->readBoolEntry(key, save);
readConfigEntry("DecimalSymbol", ".", m_decimalSymbol);
readConfigEntry("ThousandsSeparator", ",", m_thousandsSeparator);
m_thousandsSeparator.replace( QString::fromLatin1("$0"), QString::null );
//kdDebug(173) << "m_thousandsSeparator=" << m_thousandsSeparator << endl;
readConfigEntry("PositiveSign", "", m_positiveSign);
readConfigEntry("NegativeSign", "-", m_negativeSign);
// Monetary
readConfigEntry("CurrencySymbol", "$", m_currencySymbol);
readConfigEntry("MonetaryDecimalSymbol", ".", m_monetaryDecimalSymbol);
readConfigEntry("MonetaryThousandsSeparator", ",",
m_monetaryThousandsSeparator);
m_monetaryThousandsSeparator.replace(QString::fromLatin1("$0"), QString::null);
readConfigNumEntry("FracDigits", 2, m_fracDigits, int);
readConfigBoolEntry("PositivePrefixCurrencySymbol", true,
m_positivePrefixCurrencySymbol);
readConfigBoolEntry("NegativePrefixCurrencySymbol", true,
m_negativePrefixCurrencySymbol);
readConfigNumEntry("PositiveMonetarySignPosition", (int)BeforeQuantityMoney,
m_positiveMonetarySignPosition, SignPosition);
readConfigNumEntry("NegativeMonetarySignPosition", (int)ParensAround,
m_negativeMonetarySignPosition, SignPosition);
// Date and time
readConfigEntry("TimeFormat", "%H:%M:%S", m_timeFormat);
readConfigEntry("DateFormat", "%A %d %B %Y", m_dateFormat);
readConfigEntry("DateFormatShort", "%Y-%m-%d", m_dateFormatShort);
readConfigNumEntry("WeekStartDay", 1, d->weekStartDay, int);
// other
readConfigNumEntry("PageSize", (int)QPrinter::A4, d->pageSize, int);
readConfigNumEntry("MeasureSystem", (int)Metric, d->measureSystem,
MeasureSystem);
readConfigEntry("CalendarSystem", "gregorian", d->calendarType);
delete d->calendar;
d->calendar = 0; // ### HPB Is this the correct place?
//Grammatical
//Precedence here is l10n / i18n / config file
KSimpleConfig language(locate("locale",
QString::fromLatin1("%1/entry.desktop")
.arg(m_language)), true);
language.setGroup("KCM Locale");
#define read3ConfigBoolEntry(key, default, save) \
save = entry.readBoolEntry(key, default); \
save = language.readBoolEntry(key, save); \
save = config->readBoolEntry(key, save);
read3ConfigBoolEntry("NounDeclension", false, d->nounDeclension);
read3ConfigBoolEntry("DateMonthNamePossessive", false,
d->dateMonthNamePossessive);
// end of hack
KGlobal::_locale = lsave;
}
bool KLocale::setCountry(const QString & country)
{
// Check if the file exists too??
if ( country.isEmpty() )
return false;
m_country = country;
d->formatInited = false;
return true;
}
QString KLocale::catalogueFileName(const QString & language,
const KCatalogue & catalog)
{
QString path = QString::fromLatin1("%1/LC_MESSAGES/%2.mo")
.arg( language )
.arg( catalog.name() );
return locate( "locale", path );
}
bool KLocale::setLanguage(const QString & language)
{
if ( d->languageList.contains( language ) ) {
d->languageList.remove( language );
}
d->languageList.prepend( language ); // let us consider this language to be the most important one
m_language = language; // remember main language for shortcut evaluation
// important when called from the outside and harmless when called before populating the
// catalog name list
updateCatalogues();
d->formatInited = false;
return true; // Maybe the mo-files for this language are empty, but in principle we can speak all languages
}
bool KLocale::setLanguage(const QStringList & languages)
{
QStringList languageList( languages );
// This list might contain
// 1) some empty strings that we have to eliminate
// 2) duplicate entries like in de:fr:de, where we have to keep the first occurrance of a language in order
// to preserve the order of precenence of the user => iterate backwards
// 3) languages into which the application is not translated. For those languages we should not even load kdelibs.mo or kio.po.
// these langugage have to be dropped. Otherwise we get strange side effects, e.g. with Hebrew:
// the right/left switch for languages that write from
// right to left (like Hebrew or Arabic) is set in kdelibs.mo. If you only have kdelibs.mo
// but nothing from appname.mo, you get a mostly English app with layout from right to left.
// That was considered to be a bug by the Hebrew translators.
for( QStringList::Iterator it = languageList.fromLast();
it != languageList.begin(); --it )
{
// kdDebug() << "checking " << (*it) << endl;
bool bIsTranslated = isApplicationTranslatedInto( *it );
if ( languageList.contains(*it) > 1 || (*it).isEmpty() || (!bIsTranslated) ) {
// kdDebug() << "removing " << (*it) << endl;
it = languageList.remove( it );
}
}
// now this has left the first element of the list unchecked.
// The question why this is the case is left as an exercise for the reader...
// Besides the list might have been empty all the way, so check that too.
if ( languageList.begin() != languageList.end() ) {
QStringList::Iterator it = languageList.begin(); // now pointing to the first element
// kdDebug() << "checking " << (*it) << endl;
if( (*it).isEmpty() || !(isApplicationTranslatedInto( *it )) ) {
// kdDebug() << "removing " << (*it) << endl;
languageList.remove( it ); // that's what the iterator was for...
}
}
if ( languageList.isEmpty() ) {
// user picked no language, so we assume he/she speaks English.
languageList.append( defaultLanguage() );
}
m_language = languageList.first(); // keep this for shortcut evaluations
d->languageList = languageList; // keep this new list of languages to use
d->langTwoAlpha.clear(); // Flush cache
// important when called from the outside and harmless when called before populating the
// catalog name list
updateCatalogues();
return true; // we found something. Maybe it's only English, but we found something
}
bool KLocale::isApplicationTranslatedInto( const QString & language)
{
if ( language.isEmpty() ) {
return false;
}
if ( language == defaultLanguage() ) {
// en_us is always "installed"
return true;
}
QString appName = d->appName;
if (maincatalogue) {
appName = QString::fromLatin1(maincatalogue);
}
// sorry, catalogueFileName requires catalog object,k which we do not have here
// path finding was supposed to be moved completely to KCatalogue. The interface cannot
// be changed that far during deep freeze. So in order to fix the bug now, we have
// duplicated code for file path evaluation. Cleanup will follow later. We could have e.g.
// a static method in KCataloge that can translate between these file names.
// a stat
QString sFileName = QString::fromLatin1("%1/LC_MESSAGES/%2.mo")
.arg( language )
.arg( appName );
// kdDebug() << "isApplicationTranslatedInto: filename " << sFileName << endl;
QString sAbsFileName = locate( "locale", sFileName );
// kdDebug() << "isApplicationTranslatedInto: absname " << sAbsFileName << endl;
return ! sAbsFileName.isEmpty();
}
void KLocale::splitLocale(const QString & aStr,
QString & language,
QString & country,
QString & chrset)
{
QString str = aStr;
// just in case, there is another language appended
int f = str.find(':');
if (f >= 0)
str.truncate(f);
country = QString::null;
chrset = QString::null;
language = QString::null;
f = str.find('.');
if (f >= 0)
{
chrset = str.mid(f + 1);
str.truncate(f);
}
f = str.find('_');
if (f >= 0)
{
country = str.mid(f + 1);
str.truncate(f);
}
language = str;
}
QString KLocale::language() const
{
return m_language;
}
QString KLocale::country() const
{
return m_country;
}
QString KLocale::monthName(int i, bool shortName) const
{
if ( shortName )
switch ( i )
{
case 1: return translate("January", "Jan");
case 2: return translate("February", "Feb");
case 3: return translate("March", "Mar");
case 4: return translate("April", "Apr");
case 5: return translate("May short", "May");
case 6: return translate("June", "Jun");
case 7: return translate("July", "Jul");
case 8: return translate("August", "Aug");
case 9: return translate("September", "Sep");
case 10: return translate("October", "Oct");
case 11: return translate("November", "Nov");
case 12: return translate("December", "Dec");
}
else
switch (i)
{
case 1: return translate("January");
case 2: return translate("February");
case 3: return translate("March");
case 4: return translate("April");
case 5: return translate("May long", "May");
case 6: return translate("June");
case 7: return translate("July");
case 8: return translate("August");
case 9: return translate("September");
case 10: return translate("October");
case 11: return translate("November");
case 12: return translate("December");
}
return QString::null;
}
QString KLocale::monthNamePossessive(int i, bool shortName) const
{
if ( shortName )
switch ( i )
{
case 1: return translate("of January", "of Jan");
case 2: return translate("of February", "of Feb");
case 3: return translate("of March", "of Mar");
case 4: return translate("of April", "of Apr");
case 5: return translate("of May short", "of May");
case 6: return translate("of June", "of Jun");
case 7: return translate("of July", "of Jul");
case 8: return translate("of August", "of Aug");
case 9: return translate("of September", "of Sep");
case 10: return translate("of October", "of Oct");
case 11: return translate("of November", "of Nov");
case 12: return translate("of December", "of Dec");
}
else
switch (i)
{
case 1: return translate("of January");
case 2: return translate("of February");
case 3: return translate("of March");
case 4: return translate("of April");
case 5: return translate("of May long", "of May");
case 6: return translate("of June");
case 7: return translate("of July");
case 8: return translate("of August");
case 9: return translate("of September");
case 10: return translate("of October");
case 11: return translate("of November");
case 12: return translate("of December");
}
return QString::null;
}
QString KLocale::weekDayName (int i, bool shortName) const
{
return calendar()->weekDayName(i, shortName);
}
void KLocale::insertCatalogue( const QString & catalog )
{
if ( !d->catalogNames.contains( catalog) ) {
d->catalogNames.append( catalog );
}
updateCatalogues( ); // evaluate the changed list and generate the neccessary KCatalog objects
}
void KLocale::updateCatalogues( )
{
// some changes have occured. Maybe we have learned or forgotten some languages.
// Maybe the language precedence has changed.
// Maybe we have learned or forgotten some catalog names.
// Now examine the list of KCatalogue objects and change it according to the new circumstances.
// this could be optimized: try to reuse old KCatalog objects, but remember that the order of
// catalogs might have changed: e.g. in this fashion
// 1) move all catalogs into a temporary list
// 2) iterate over all languages and catalog names
// 3.1) pick the catalog from the saved list, if it already exists
// 3.2) else create a new catalog.
// but we will do this later.
for ( QValueList<KCatalogue>::Iterator it = d->catalogues.begin();
it != d->catalogues.end(); )
{
it = d->catalogues.remove(it);
}
// now iterate over all languages and all wanted catalog names and append or create them in the right order
// the sequence must be e.g. nds/appname nds/kdelibs nds/kio de/appname de/kdelibs de/kio etc.
// and not nds/appname de/appname nds/kdelibs de/kdelibs etc. Otherwise we would be in trouble with a language
// sequende nds,en_US, de. In this case en_US must hide everything below in the language list.
for ( QStringList::ConstIterator itLangs = d->languageList.begin();
itLangs != d->languageList.end(); ++itLangs)
{
for ( QStringList::ConstIterator itNames = d->catalogNames.begin();
itNames != d->catalogNames.end(); ++itNames)
{
KCatalogue cat( *itNames, *itLangs ); // create Catalog for this name and this language
d->catalogues.append( cat );
}
}
initPluralTypes(); // evaluate the plural type for all languages and remember this in each KCatalogue
}
void KLocale::removeCatalogue(const QString &catalog)
{
if ( d->catalogNames.contains( catalog )) {
d->catalogNames.remove( catalog );
if (KGlobal::_instance)
updateCatalogues(); // walk through the KCatalogue instances and weed out everything we no longer need
}
}
void KLocale::setActiveCatalogue(const QString &catalog)
{
if ( d->catalogNames.contains( catalog ) ) {
d->catalogNames.remove( catalog );
d->catalogNames.prepend( catalog );
updateCatalogues(); // walk through the KCatalogue instances and adapt to the new order
}
}
KLocale::~KLocale()
{
delete d->calendar;
delete d->languages;
delete d;
d = 0L;
}
QString KLocale::translate_priv(const char *msgid,
const char *fallback,
const char **translated,
int* pluralType ) const
{
if ( pluralType) {
*pluralType = -1; // unless we find something more precise
}
if (!msgid || !msgid[0])
{
kdWarning() << "KLocale: trying to look up \"\" in catalog. "
<< "Fix the program" << endl;
return QString::null;
}
if ( useDefaultLanguage() ) { // shortcut evaluation if en_US is main language: do not consult the catalogs
return QString::fromUtf8( fallback );
}
for ( QValueList<KCatalogue>::ConstIterator it = d->catalogues.begin();
it != d->catalogues.end();
++it )
{
// shortcut evaluation: once we have arrived at en_US (default language) we cannot consult
// the catalog as it will not have an assiciated mo-file. For this default language we can
// immediately pick the fallback string.
if ( (*it).language() == defaultLanguage() ) {
return QString::fromUtf8( fallback );
}
const char * text = (*it).translate( msgid );
if ( text )
{
// we found it
if (translated) {
*translated = text;
}
if ( pluralType) {
*pluralType = (*it).pluralType(); // remember the plural type information from the catalog that was used
}
return QString::fromUtf8( text );
}
}
// Always use UTF-8 if the string was not found
return QString::fromUtf8( fallback );
}
QString KLocale::translate(const char* msgid) const
{
return translate_priv(msgid, msgid);
}
QString KLocale::translate( const char *index, const char *fallback) const
{
if (!index || !index[0] || !fallback || !fallback[0])
{
kdDebug(173) << "KLocale: trying to look up \"\" in catalog. "
<< "Fix the program" << endl;
return QString::null;
}
if ( useDefaultLanguage() )
return QString::fromUtf8( fallback );
char *newstring = new char[strlen(index) + strlen(fallback) + 5];
sprintf(newstring, "_: %s\n%s", index, fallback);
// as copying QString is very fast, it looks slower as it is ;/
QString r = translate_priv(newstring, fallback);
delete [] newstring;
return r;
}
static QString put_n_in(const QString &orig, unsigned long n)
{
QString ret = orig;
int index = ret.find("%n");
if (index == -1)
return ret;
ret.replace(index, 2, QString::number(n));
return ret;
}
#define EXPECT_LENGTH(x) \
if (forms.count() != x) { \
kdError() << "translation of \"" << singular << "\" doesn't contain " << x << " different plural forms as expected\n"; \
return QString( "BROKEN TRANSLATION %1" ).arg( singular ); }
QString KLocale::translate( const char *singular, const char *plural,
unsigned long n ) const
{
if (!singular || !singular[0] || !plural || !plural[0])
{
kdWarning() << "KLocale: trying to look up \"\" in catalog. "
<< "Fix the program" << endl;
return QString::null;
}
char *newstring = new char[strlen(singular) + strlen(plural) + 6];
sprintf(newstring, "_n: %s\n%s", singular, plural);
// as copying QString is very fast, it looks slower as it is ;/
int pluralType = -1;
QString r = translate_priv(newstring, 0, 0, &pluralType);
delete [] newstring;
if ( r.isEmpty() || useDefaultLanguage() || pluralType == -1) {
if ( n == 1 ) {
return put_n_in( QString::fromUtf8( singular ), n );
} else {
QString tmp = QString::fromUtf8( plural );
#ifndef NDEBUG
if (tmp.find("%n") == -1) {
kdDebug() << "the message for i18n should contain a '%n'! " << plural << endl;
}
#endif
return put_n_in( tmp, n );
}
}
QStringList forms = QStringList::split( "\n", r, false );
switch ( pluralType ) {
case 0: // NoPlural
EXPECT_LENGTH( 1 );
return put_n_in( forms[0], n);
case 1: // TwoForms
EXPECT_LENGTH( 2 );
if ( n == 1 )
return put_n_in( forms[0], n);
else
return put_n_in( forms[1], n);
case 2: // French
EXPECT_LENGTH( 2 );
if ( n == 1 || n == 0 )
return put_n_in( forms[0], n);
else
return put_n_in( forms[1], n);
case 3: // OneTwoRest
EXPECT_LENGTH( 3 );
if ( n == 1 )
return put_n_in( forms[0], n);
else if ( n == 2 )
return put_n_in( forms[1], n);
else
return put_n_in( forms[2], n);
case 4: // Russian, corrected by mok
EXPECT_LENGTH( 3 );
if ( n%10 == 1 && n%100 != 11)
return put_n_in( forms[0], n); // odin fail
else if (( n%10 >= 2 && n%10 <=4 ) && (n%100<10 || n%100>20))
return put_n_in( forms[1], n); // dva faila
else
return put_n_in( forms[2], n); // desyat' failov
case 5: // Polish
EXPECT_LENGTH( 3 );
if ( n == 1 )
return put_n_in( forms[0], n);
else if ( n%10 >= 2 && n%10 <=4 && (n%100<10 || n%100>=20) )
return put_n_in( forms[1], n);
else
return put_n_in( forms[2], n);
case 6: // Slovenian
EXPECT_LENGTH( 4 );
if ( n%100 == 1 )
return put_n_in( forms[1], n); // ena datoteka
else if ( n%100 == 2 )
return put_n_in( forms[2], n); // dve datoteki
else if ( n%100 == 3 || n%100 == 4 )
return put_n_in( forms[3], n); // tri datoteke
else
return put_n_in( forms[0], n); // sto datotek
case 7: // Lithuanian
EXPECT_LENGTH( 3 );
if ( n%10 == 0 || (n%100>=11 && n%100<=19) )
return put_n_in( forms[2], n);
else if ( n%10 == 1 )
return put_n_in( forms[0], n);
else
return put_n_in( forms[1], n);
case 8: // Czech - use modern form which is equivalent to Slovak
case 9: // Slovak
EXPECT_LENGTH( 3 );
if ( n == 1 )
return put_n_in( forms[0], n);
else if (( n >= 2 ) && ( n <= 4 ))
return put_n_in( forms[1], n);
else
return put_n_in( forms[2], n);
case 10: // Maltese
EXPECT_LENGTH( 4 );
if ( n == 1 )
return put_n_in( forms[0], n );
else if ( ( n == 0 ) || ( n%100 > 0 && n%100 <= 10 ) )
return put_n_in( forms[1], n );
else if ( n%100 > 10 && n%100 < 20 )
return put_n_in( forms[2], n );
else
return put_n_in( forms[3], n );
case 11: // Arabic
EXPECT_LENGTH( 4 );
if (n == 1)
return put_n_in(forms[0], n);
else if (n == 2)
return put_n_in(forms[1], n);
else if ( n < 11)
return put_n_in(forms[2], n);
else
return put_n_in(forms[3], n);
case 12: // Balcan
EXPECT_LENGTH( 3 );
if (n != 11 && n % 10 == 1)
return put_n_in(forms[0], n);
else if (n / 10 != 1 && n % 10 >= 2 && n % 10 <= 4)
return put_n_in(forms[1], n);
else
return put_n_in(forms[2], n);
case 13: // Macedonian
EXPECT_LENGTH(3);
if (n % 10 == 1)
return put_n_in(forms[0], n);
else if (n % 10 == 2)
return put_n_in(forms[1], n);
else
return put_n_in(forms[2], n);
case 14: // Gaeilge
EXPECT_LENGTH(5);
if (n == 1) // "ceann amhain"
return put_n_in(forms[0], n);
else if (n == 2) // "dha cheann"
return put_n_in(forms[1], n);
else if (n < 7) // "%n cinn"
return put_n_in(forms[2], n);
else if (n < 11) // "%n gcinn"
return put_n_in(forms[3], n);
else // "%n ceann"
return put_n_in(forms[4], n);
}
kdFatal() << "The function should have been returned in another way\n";
return QString::null;
}
QString KLocale::translateQt( const char *context, const char *source,
const char *message) const
{
if (!source || !source[0]) {
kdWarning() << "KLocale: trying to look up \"\" in catalog. "
<< "Fix the program" << endl;
return QString::null;
}
if ( useDefaultLanguage() ) {
return QString::null;
}
char *newstring = 0;
const char *translation = 0;
QString r;
if ( message && message[0]) {
char *newstring = new char[strlen(source) + strlen(message) + 5];
sprintf(newstring, "_: %s\n%s", source, message);
const char *translation = 0;
// as copying QString is very fast, it looks slower as it is ;/
r = translate_priv(newstring, source, &translation);
delete [] newstring;
if (translation)
return r;
}
if ( context && context[0] && message && message[0]) {
newstring = new char[strlen(context) + strlen(message) + 5];
sprintf(newstring, "_: %s\n%s", context, message);
// as copying QString is very fast, it looks slower as it is ;/
r = translate_priv(newstring, source, &translation);
delete [] newstring;
if (translation)
return r;
}
r = translate_priv(source, source, &translation);
if (translation)
return r;
return QString::null;
}
bool KLocale::nounDeclension() const
{
doFormatInit();
return d->nounDeclension;
}
bool KLocale::dateMonthNamePossessive() const
{
doFormatInit();
return d->dateMonthNamePossessive;
}
int KLocale::weekStartDay() const
{
doFormatInit();
return d->weekStartDay;
}
bool KLocale::weekStartsMonday() const //deprecated
{
doFormatInit();
return (d->weekStartDay==1);
}
QString KLocale::decimalSymbol() const
{
doFormatInit();
return m_decimalSymbol;
}
QString KLocale::thousandsSeparator() const
{
doFormatInit();
return m_thousandsSeparator;
}
QString KLocale::currencySymbol() const
{
doFormatInit();
return m_currencySymbol;
}
QString KLocale::monetaryDecimalSymbol() const
{
doFormatInit();
return m_monetaryDecimalSymbol;
}
QString KLocale::monetaryThousandsSeparator() const
{
doFormatInit();
return m_monetaryThousandsSeparator;
}
QString KLocale::positiveSign() const
{
doFormatInit();
return m_positiveSign;
}
QString KLocale::negativeSign() const
{
doFormatInit();
return m_negativeSign;
}
int KLocale::fracDigits() const
{
doFormatInit();
return m_fracDigits;
}
bool KLocale::positivePrefixCurrencySymbol() const
{
doFormatInit();
return m_positivePrefixCurrencySymbol;
}
bool KLocale::negativePrefixCurrencySymbol() const
{
doFormatInit();
return m_negativePrefixCurrencySymbol;
}
KLocale::SignPosition KLocale::positiveMonetarySignPosition() const
{
doFormatInit();
return m_positiveMonetarySignPosition;
}
KLocale::SignPosition KLocale::negativeMonetarySignPosition() const
{
doFormatInit();
return m_negativeMonetarySignPosition;
}
static inline void put_it_in( QChar *buffer, uint& index, const QString &s )
{
for ( uint l = 0; l < s.length(); l++ )
buffer[index++] = s.at( l );
}
static inline void put_it_in( QChar *buffer, uint& index, int number )
{
buffer[index++] = number / 10 + '0';
buffer[index++] = number % 10 + '0';
}
// insert (thousands)-"separator"s into the non-fractional part of str
static void _insertSeparator(QString &str, const QString &separator,
const QString &decimalSymbol)
{
// leave fractional part untouched
QString mainPart = str.section(decimalSymbol, 0, 0);
QString fracPart = str.section(decimalSymbol, 1, 1,
QString::SectionIncludeLeadingSep);
for (int pos = mainPart.length() - 3; pos > 0; pos -= 3)
mainPart.insert(pos, separator);
str = mainPart + fracPart;
}
QString KLocale::formatMoney(double num,
const QString & symbol,
int precision) const
{
// some defaults
QString currency = symbol.isNull()
? currencySymbol()
: symbol;
if (precision < 0) precision = fracDigits();
// the number itself
bool neg = num < 0;
QString res = QString::number(neg?-num:num, 'f', precision);
// Replace dot with locale decimal separator
res.replace(QChar('.'), monetaryDecimalSymbol());
// Insert the thousand separators
_insertSeparator(res, monetaryThousandsSeparator(), monetaryDecimalSymbol());
// set some variables we need later
int signpos = neg
? negativeMonetarySignPosition()
: positiveMonetarySignPosition();
QString sign = neg
? negativeSign()
: positiveSign();
switch (signpos)
{
case ParensAround:
res.prepend('(');
res.append (')');
break;
case BeforeQuantityMoney:
res.prepend(sign);
break;
case AfterQuantityMoney:
res.append(sign);
break;
case BeforeMoney:
currency.prepend(sign);
break;
case AfterMoney:
currency.append(sign);
break;
}
if (neg?negativePrefixCurrencySymbol():
positivePrefixCurrencySymbol())
{
res.prepend(' ');
res.prepend(currency);
} else {
res.append (' ');
res.append (currency);
}
return res;
}
QString KLocale::formatMoney(const QString &numStr) const
{
return formatMoney(numStr.toDouble());
}
QString KLocale::formatNumber(double num, int precision) const
{
if (precision == -1) precision = 2;
// no need to round since QString::number does this for us
return formatNumber(QString::number(num, 'f', precision), false, 0);
}
QString KLocale::formatLong(long num) const
{
return formatNumber((double)num, 0);
}
QString KLocale::formatNumber(const QString &numStr) const
{
return formatNumber(numStr, true, 2);
}
// increase the digit at 'position' by one
static void _inc_by_one(QString &str, int position)
{
for (int i = position; i >= 0; i--)
{
char last_char = str[i].latin1();
switch(last_char)
{
case '0':
str[i] = '1';
break;
case '1':
str[i] = '2';
break;
case '2':
str[i] = '3';
break;
case '3':
str[i] = '4';
break;
case '4':
str[i] = '5';
break;
case '5':
str[i] = '6';
break;
case '6':
str[i] = '7';
break;
case '7':
str[i] = '8';
break;
case '8':
str[i] = '9';
break;
case '9':
str[i] = '0';
if (i == 0) str.prepend('1');
continue;
case '.':
continue;
}
break;
}
}
// Cut off if more digits in fractional part than 'precision'
static void _round(QString &str, int precision)
{
int decimalSymbolPos = str.find('.');
if (decimalSymbolPos == -1)
if (precision == 0) return;
else if (precision > 0) // add dot if missing (and needed)
{
str.append('.');
decimalSymbolPos = str.length() - 1;
}
// fill up with more than enough zeroes (in case fractional part too short)
str.append(QString().fill('0', precision));
// Now decide whether to round up or down
char last_char = str[decimalSymbolPos + precision + 1].latin1();
switch (last_char)
{
case '0':
case '1':
case '2':
case '3':
case '4':
// nothing to do, rounding down
break;
case '5':
case '6':
case '7':
case '8':
case '9':
_inc_by_one(str, decimalSymbolPos + precision);
break;
default:
break;
}
decimalSymbolPos = str.find('.');
str.truncate(decimalSymbolPos + precision + 1);
// if precision == 0 delete also '.'
if (precision == 0) str = str.section('.', 0, 0);
}
QString KLocale::formatNumber(const QString &numStr, bool round,
int precision) const
{
QString tmpString = numStr;
if ((round && precision < 0) ||
! QRegExp("^[+-]?\\d+(\\.\\d+)*(e[+-]?\\d+)?$").exactMatch(tmpString))
return numStr;
// Skip the sign (for now)
bool neg = (tmpString[0] == '-');
if (neg || tmpString[0] == '+') tmpString.remove(0, 1);
// Split off exponential part (including 'e'-symbol)
QString mantString = tmpString.section('e', 0, 0,
QString::SectionCaseInsensitiveSeps);
QString expString = tmpString.section('e', 1, 1,
QString::SectionCaseInsensitiveSeps |
QString::SectionIncludeLeadingSep);
if (round) _round(mantString, precision);
// Replace dot with locale decimal separator
mantString.replace(QChar('.'), decimalSymbol());
// Insert the thousand separators
_insertSeparator(mantString, thousandsSeparator(), decimalSymbol());
// How can we know where we should put the sign?
mantString.prepend(neg?negativeSign():positiveSign());
return mantString + expString;
}
QString KLocale::formatDate(const QDate &pDate, bool shortFormat) const
{
const QString rst = shortFormat?dateFormatShort():dateFormat();
QString buffer;
if ( ! pDate.isValid() ) return buffer;
bool escape = false;
int year = calendar()->year(pDate);
int month = calendar()->month(pDate);
for ( uint format_index = 0; format_index < rst.length(); ++format_index )
{
if ( !escape )
{
if ( rst.at( format_index ).unicode() == '%' )
escape = true;
else
buffer.append(rst.at(format_index));
}
else
{
switch ( rst.at( format_index ).unicode() )
{
case '%':
buffer.append('%');
break;
case 'Y':
buffer.append(calendar()->yearString(pDate, false));
break;
case 'y':
buffer.append(calendar()->yearString(pDate, true));
break;
case 'n':
buffer.append(calendar()->monthString(pDate, true));
break;
case 'e':
buffer.append(calendar()->dayString(pDate, true));
break;
case 'm':
buffer.append(calendar()->monthString(pDate, false));
break;
case 'b':
if (d->nounDeclension && d->dateMonthNamePossessive)
buffer.append(calendar()->monthNamePossessive(month, year, true));
else
buffer.append(calendar()->monthName(month, year, true));
break;
case 'B':
if (d->nounDeclension && d->dateMonthNamePossessive)
buffer.append(calendar()->monthNamePossessive(month, year, false));
else
buffer.append(calendar()->monthName(month, year, false));
break;
case 'd':
buffer.append(calendar()->dayString(pDate, false));
break;
case 'a':
buffer.append(calendar()->weekDayName(pDate, true));
break;
case 'A':
buffer.append(calendar()->weekDayName(pDate, false));
break;
default:
buffer.append(rst.at(format_index));
break;
}
escape = false;
}
}
return buffer;
}
void KLocale::setMainCatalogue(const char *catalog)
{
maincatalogue = catalog;
}
double KLocale::readNumber(const QString &_str, bool * ok) const
{
QString str = _str.stripWhiteSpace();
bool neg = str.find(negativeSign()) == 0;
if (neg)
str.remove( 0, negativeSign().length() );
/* will hold the scientific notation portion of the number.
Example, with 2.34E+23, exponentialPart == "E+23"
*/
QString exponentialPart;
int EPos;
EPos = str.find('E', 0, false);
if (EPos != -1)
{
exponentialPart = str.mid(EPos);
str = str.left(EPos);
}
int pos = str.find(decimalSymbol());
QString major;
QString minor;
if ( pos == -1 )
major = str;
else
{
major = str.left(pos);
minor = str.mid(pos + decimalSymbol().length());
}
// Remove thousand separators
int thlen = thousandsSeparator().length();
int lastpos = 0;
while ( ( pos = major.find( thousandsSeparator() ) ) > 0 )
{
// e.g. 12,,345,,678,,922 Acceptable positions (from the end) are 5, 10, 15... i.e. (3+thlen)*N
int fromEnd = major.length() - pos;
if ( fromEnd % (3+thlen) != 0 // Needs to be a multiple, otherwise it's an error
|| pos - lastpos > 3 // More than 3 digits between two separators -> error
|| pos == 0 // Can't start with a separator
|| (lastpos>0 && pos-lastpos!=3)) // Must have exactly 3 digits between two separators
{
if (ok) *ok = false;
return 0.0;
}
lastpos = pos;
major.remove( pos, thlen );
}
if (lastpos>0 && major.length()-lastpos!=3) // Must have exactly 3 digits after the last separator
{
if (ok) *ok = false;
return 0.0;
}
QString tot;
if (neg) tot = '-';
tot += major + '.' + minor + exponentialPart;
return tot.toDouble(ok);
}
double KLocale::readMoney(const QString &_str, bool * ok) const
{
QString str = _str.stripWhiteSpace();
bool neg = false;
bool currencyFound = false;
QString symbol = currencySymbol();
// First try removing currency symbol from either end
int pos = str.find(symbol);
if ( pos == 0 || pos == (int) str.length()-symbol.length() )
{
str.remove(pos,symbol.length());
str = str.stripWhiteSpace();
currencyFound = true;
}
if (str.isEmpty())
{
if (ok) *ok = false;
return 0;
}
// Then try removing negative sign from either end
// (with a special case for parenthesis)
if (negativeMonetarySignPosition() == ParensAround)
{
if (str[0] == '(' && str[str.length()-1] == ')')
{
neg = true;
str.remove(str.length()-1,1);
str.remove(0,1);
}
}
else
{
int i1 = str.find(negativeSign());
if ( i1 == 0 || i1 == (int) str.length()-1 )
{
neg = true;
str.remove(i1,negativeSign().length());
}
}
if (neg) str = str.stripWhiteSpace();
// Finally try again for the currency symbol, if we didn't find
// it already (because of the negative sign being in the way).
if ( !currencyFound )
{
pos = str.find(symbol);
if ( pos == 0 || pos == (int) str.length()-symbol.length() )
{
str.remove(pos,symbol.length());
str = str.stripWhiteSpace();
}
}
// And parse the rest as a number
pos = str.find(monetaryDecimalSymbol());
QString major;
QString minior;
if (pos == -1)
major = str;
else
{
major = str.left(pos);
minior = str.mid(pos + monetaryDecimalSymbol().length());
}
// Remove thousand separators
int thlen = monetaryThousandsSeparator().length();
int lastpos = 0;
while ( ( pos = major.find( monetaryThousandsSeparator() ) ) > 0 )
{
// e.g. 12,,345,,678,,922 Acceptable positions (from the end) are 5, 10, 15... i.e. (3+thlen)*N
int fromEnd = major.length() - pos;
if ( fromEnd % (3+thlen) != 0 // Needs to be a multiple, otherwise it's an error
|| pos - lastpos > 3 // More than 3 digits between two separators -> error
|| pos == 0 // Can't start with a separator
|| (lastpos>0 && pos-lastpos!=3)) // Must have exactly 3 digits between two separators
{
if (ok) *ok = false;
return 0.0;
}
lastpos = pos;
major.remove( pos, thlen );
}
if (lastpos>0 && major.length()-lastpos!=3) // Must have exactly 3 digits after the last separator
{
if (ok) *ok = false;
return 0.0;
}
QString tot;
if (neg) tot = '-';
tot += major + '.' + minior;
return tot.toDouble(ok);
}
static int readInt(const QString &str, uint &pos)
{
if (!str.at(pos).isDigit()) return -1;
int result = 0;
for (; str.length() > pos && str.at(pos).isDigit(); pos++)
{
result *= 10;
result += str.at(pos).digitValue();
}
return result;
}
QDate KLocale::readDate(const QString &intstr, bool* ok) const
{
QDate date;
date = readDate(intstr, ShortFormat, ok);
if (date.isValid()) return date;
return readDate(intstr, NormalFormat, ok);
}
QDate KLocale::readDate(const QString &intstr, ReadDateFlags flags, bool* ok) const
{
QString fmt = ((flags & ShortFormat) ? dateFormatShort() : dateFormat()).simplifyWhiteSpace();
return readDate( intstr, fmt, ok );
}
QDate KLocale::readDate(const QString &intstr, const QString &fmt, bool* ok) const
{
//kdDebug() << "KLocale::readDate intstr=" << intstr << " fmt=" << fmt << endl;
QString str = intstr.simplifyWhiteSpace().lower();
int day = -1, month = -1;
// allow the year to be omitted if not in the format
int year = calendar()->year(QDate::currentDate());
uint strpos = 0;
uint fmtpos = 0;
int iLength; // Temporary variable used when reading input
bool error = false;
while (fmt.length() > fmtpos && str.length() > strpos && !error)
{
QChar c = fmt.at(fmtpos++);
if (c != '%') {
if (c.isSpace() && str.at(strpos).isSpace())
strpos++;
else if (c != str.at(strpos++))
error = true;
}
else
{
int j;
// remove space at the beginning
if (str.length() > strpos && str.at(strpos).isSpace())
strpos++;
c = fmt.at(fmtpos++);
switch (c)
{
case 'a':
case 'A':
error = true;
j = 1;
while (error && (j < 8)) {
QString s = calendar()->weekDayName(j, c == 'a').lower();
int len = s.length();
if (str.mid(strpos, len) == s)
{
strpos += len;
error = false;
}
j++;
}
break;
case 'b':
case 'B':
error = true;
if (d->nounDeclension && d->dateMonthNamePossessive) {
j = 1;
while (error && (j < 13)) {
QString s = calendar()->monthNamePossessive(j, year, c == 'b').lower();
int len = s.length();
if (str.mid(strpos, len) == s) {
month = j;
strpos += len;
error = false;
}
j++;
}
}
j = 1;
while (error && (j < 13)) {
QString s = calendar()->monthName(j, year, c == 'b').lower();
int len = s.length();
if (str.mid(strpos, len) == s) {
month = j;
strpos += len;
error = false;
}
j++;
}
break;
case 'd':
case 'e':
day = calendar()->dayStringToInteger(str.mid(strpos), iLength);
strpos += iLength;
error = iLength <= 0;
break;
case 'n':
case 'm':
month = calendar()->monthStringToInteger(str.mid(strpos), iLength);
strpos += iLength;
error = iLength <= 0;
break;
case 'Y':
case 'y':
year = calendar()->yearStringToInteger(str.mid(strpos), iLength);
strpos += iLength;
error = iLength <= 0;
break;
}
}
}
/* for a match, we should reach the end of both strings, not just one of
them */
if ( fmt.length() > fmtpos || str.length() > strpos )
{
error = true;
}
//kdDebug(173) << "KLocale::readDate day=" << day << " month=" << month << " year=" << year << endl;
if ( year != -1 && month != -1 && day != -1 && !error)
{
if (ok) *ok = true;
QDate result;
calendar()->setYMD(result, year, month, day);
return result;
}
else
{
if (ok) *ok = false;
return QDate(); // invalid date
}
}
QTime KLocale::readTime(const QString &intstr, bool *ok) const
{
QTime _time;
_time = readTime(intstr, WithSeconds, ok);
if (_time.isValid()) return _time;
return readTime(intstr, WithoutSeconds, ok);
}
QTime KLocale::readTime(const QString &intstr, ReadTimeFlags flags, bool *ok) const
{
QString str = intstr.simplifyWhiteSpace().lower();
QString Format = timeFormat().simplifyWhiteSpace();
if (flags & WithoutSeconds)
Format.remove(QRegExp(".%S"));
int hour = -1, minute = -1;
int second = ( (flags & WithoutSeconds) == 0 ) ? -1 : 0; // don't require seconds
bool g_12h = false;
bool pm = false;
uint strpos = 0;
uint Formatpos = 0;
while (Format.length() > Formatpos || str.length() > strpos)
{
if ( !(Format.length() > Formatpos && str.length() > strpos) ) goto error;
QChar c = Format.at(Formatpos++);
if (c != '%')
{
if (c.isSpace())
strpos++;
else if (c != str.at(strpos++))
goto error;
continue;
}
// remove space at the beginning
if (str.length() > strpos && str.at(strpos).isSpace())
strpos++;
c = Format.at(Formatpos++);
switch (c)
{
case 'p':
{
QString s;
s = translate("pm").lower();
int len = s.length();
if (str.mid(strpos, len) == s)
{
pm = true;
strpos += len;
}
else
{
s = translate("am").lower();
len = s.length();
if (str.mid(strpos, len) == s) {
pm = false;
strpos += len;
}
else
goto error;
}
}
break;
case 'k':
case 'H':
g_12h = false;
hour = readInt(str, strpos);
if (hour < 0 || hour > 23)
goto error;
break;
case 'l':
case 'I':
g_12h = true;
hour = readInt(str, strpos);
if (hour < 1 || hour > 12)
goto error;
break;
case 'M':
minute = readInt(str, strpos);
if (minute < 0 || minute > 59)
goto error;
break;
case 'S':
second = readInt(str, strpos);
if (second < 0 || second > 59)
goto error;
break;
}
}
if (g_12h) {
hour %= 12;
if (pm) hour += 12;
}
if (ok) *ok = true;
return QTime(hour, minute, second);
error:
if (ok) *ok = false;
// ######## KDE4: remove this
return QTime(-1, -1, -1); // return invalid date if it didn't work
}
//BIC: merge with below
QString KLocale::formatTime(const QTime &pTime, bool includeSecs) const
{
return formatTime( pTime, includeSecs, false );
}
QString KLocale::formatTime(const QTime &pTime, bool includeSecs, bool isDuration) const
{
const QString rst = timeFormat();
// only "pm/am" here can grow, the rest shrinks, but
// I'm rather safe than sorry
QChar *buffer = new QChar[rst.length() * 3 / 2 + 30];
uint index = 0;
bool escape = false;
int number = 0;
for ( uint format_index = 0; format_index < rst.length(); format_index++ )
{
if ( !escape )
{
if ( rst.at( format_index ).unicode() == '%' )
escape = true;
else
buffer[index++] = rst.at( format_index );
}
else
{
switch ( rst.at( format_index ).unicode() )
{
case '%':
buffer[index++] = '%';
break;
case 'H':
put_it_in( buffer, index, pTime.hour() );
break;
case 'I':
if ( isDuration )
put_it_in( buffer, index, pTime.hour() );
else
put_it_in( buffer, index, ( pTime.hour() + 11) % 12 + 1 );
break;
case 'M':
put_it_in( buffer, index, pTime.minute() );
break;
case 'S':
if (includeSecs)
put_it_in( buffer, index, pTime.second() );
else if ( index > 0 )
{
// we remove the separator sign before the seconds and
// assume that works everywhere
--index;
break;
}
break;
case 'k':
number = pTime.hour();
case 'l':
// to share the code
if ( rst.at( format_index ).unicode() == 'l' )
number = isDuration ? pTime.hour() : (pTime.hour() + 11) % 12 + 1;
if ( number / 10 )
buffer[index++] = number / 10 + '0';
buffer[index++] = number % 10 + '0';
break;
case 'p':
if ( !isDuration )
{
QString s;
if ( pTime.hour() >= 12 )
put_it_in( buffer, index, translate("pm") );
else
put_it_in( buffer, index, translate("am") );
}
break;
default:
buffer[index++] = rst.at( format_index );
break;
}
escape = false;
}
}
QString ret( buffer, index );
delete [] buffer;
if ( isDuration ) // eliminate trailing-space due to " %p"
return ret.stripWhiteSpace();
else
return ret;
}
bool KLocale::use12Clock() const
{
if ((timeFormat().contains(QString::fromLatin1("%I")) > 0) ||
(timeFormat().contains(QString::fromLatin1("%l")) > 0))
return true;
else
return false;
}
QString KLocale::languages() const
{
return d->languageList.join( QString::fromLatin1(":") );
}
QStringList KLocale::languageList() const
{
return d->languageList;
}
QString KLocale::formatDateTime(const QDateTime &pDateTime,
bool shortFormat,
bool includeSeconds) const
{
return translate("concatenation of dates and time", "%1 %2")
.arg( formatDate( pDateTime.date(), shortFormat ) )
.arg( formatTime( pDateTime.time(), includeSeconds ) );
}
QString i18n(const char* text)
{
register KLocale *instance = KGlobal::locale();
if (instance)
return instance->translate(text);
return QString::fromUtf8(text);
}
QString i18n(const char* index, const char *text)
{
register KLocale *instance = KGlobal::locale();
if (instance)
return instance->translate(index, text);
return QString::fromUtf8(text);
}
QString i18n(const char* singular, const char* plural, unsigned long n)
{
register KLocale *instance = KGlobal::locale();
if (instance)
return instance->translate(singular, plural, n);
if (n == 1)
return put_n_in(QString::fromUtf8(singular), n);
else
return put_n_in(QString::fromUtf8(plural), n);
}
void KLocale::initInstance()
{
if (KGlobal::_locale)
return;
KInstance *app = KGlobal::instance();
if (app) {
KGlobal::_locale = new KLocale(QString::fromLatin1(app->instanceName()));
// only do this for the global instance
QTextCodec::setCodecForLocale(KGlobal::_locale->codecForEncoding());
}
else
kdDebug(173) << "no app name available using KLocale - nothing to do\n";
}
QString KLocale::langLookup(const QString &fname, const char *rtype)
{
QStringList search;
// assemble the local search paths
const QStringList localDoc = KGlobal::dirs()->resourceDirs(rtype);
// look up the different languages
for (int id=localDoc.count()-1; id >= 0; --id)
{
QStringList langs = KGlobal::locale()->languageList();
langs.append( "en" );
langs.remove( defaultLanguage() );
QStringList::ConstIterator lang;
for (lang = langs.begin(); lang != langs.end(); ++lang)
search.append(QString("%1%2/%3").arg(localDoc[id]).arg(*lang).arg(fname));
}
// try to locate the file
QStringList::Iterator it;
for (it = search.begin(); it != search.end(); ++it)
{
kdDebug(173) << "Looking for help in: " << *it << endl;
QFileInfo info(*it);
if (info.exists() && info.isFile() && info.isReadable())
return *it;
}
return QString::null;
}
bool KLocale::useDefaultLanguage() const
{
return language() == defaultLanguage();
}
void KLocale::initEncoding(KConfig *)
{
const int mibDefault = 4; // ISO 8859-1
// This all made more sense when we still had the EncodingEnum config key.
setEncoding( QTextCodec::codecForLocale()->mibEnum() );
if ( !d->codecForEncoding )
{
kdWarning(173) << " Defaulting to ISO 8859-1 encoding." << endl;
setEncoding(mibDefault);
}
Q_ASSERT( d->codecForEncoding );
}
void KLocale::initFileNameEncoding(KConfig *)
{
// If the following environment variable is set, assume all filenames
// are in UTF-8 regardless of the current C locale.
d->utf8FileEncoding = getenv("KDE_UTF8_FILENAMES") != 0;
if (d->utf8FileEncoding)
{
QFile::setEncodingFunction(KLocale::encodeFileNameUTF8);
QFile::setDecodingFunction(KLocale::decodeFileNameUTF8);
}
// Otherwise, stay with QFile's default filename encoding functions
// which, on Unix platforms, use the locale's codec.
}
QCString KLocale::encodeFileNameUTF8( const QString & fileName )
{
return fileName.utf8();
}
QString KLocale::decodeFileNameUTF8( const QCString & localFileName )
{
return QString::fromUtf8(localFileName);
}
void KLocale::setDateFormat(const QString & format)
{
doFormatInit();
m_dateFormat = format.stripWhiteSpace();
}
void KLocale::setDateFormatShort(const QString & format)
{
doFormatInit();
m_dateFormatShort = format.stripWhiteSpace();
}
void KLocale::setDateMonthNamePossessive(bool possessive)
{
doFormatInit();
d->dateMonthNamePossessive = possessive;
}
void KLocale::setTimeFormat(const QString & format)
{
doFormatInit();
m_timeFormat = format.stripWhiteSpace();
}
void KLocale::setWeekStartsMonday(bool start) //deprecated
{
doFormatInit();
if (start)
d->weekStartDay = 1;
else
d->weekStartDay = 7;
}
void KLocale::setWeekStartDay(int day)
{
doFormatInit();
if (day>7 || day<1)
d->weekStartDay = 1; //Monday is default
else
d->weekStartDay = day;
}
QString KLocale::dateFormat() const
{
doFormatInit();
return m_dateFormat;
}
QString KLocale::dateFormatShort() const
{
doFormatInit();
return m_dateFormatShort;
}
QString KLocale::timeFormat() const
{
doFormatInit();
return m_timeFormat;
}
void KLocale::setDecimalSymbol(const QString & symbol)
{
doFormatInit();
m_decimalSymbol = symbol.stripWhiteSpace();
}
void KLocale::setThousandsSeparator(const QString & separator)
{
doFormatInit();
// allow spaces here
m_thousandsSeparator = separator;
}
void KLocale::setPositiveSign(const QString & sign)
{
doFormatInit();
m_positiveSign = sign.stripWhiteSpace();
}
void KLocale::setNegativeSign(const QString & sign)
{
doFormatInit();
m_negativeSign = sign.stripWhiteSpace();
}
void KLocale::setPositiveMonetarySignPosition(SignPosition signpos)
{
doFormatInit();
m_positiveMonetarySignPosition = signpos;
}
void KLocale::setNegativeMonetarySignPosition(SignPosition signpos)
{
doFormatInit();
m_negativeMonetarySignPosition = signpos;
}
void KLocale::setPositivePrefixCurrencySymbol(bool prefix)
{
doFormatInit();
m_positivePrefixCurrencySymbol = prefix;
}
void KLocale::setNegativePrefixCurrencySymbol(bool prefix)
{
doFormatInit();
m_negativePrefixCurrencySymbol = prefix;
}
void KLocale::setFracDigits(int digits)
{
doFormatInit();
m_fracDigits = digits;
}
void KLocale::setMonetaryThousandsSeparator(const QString & separator)
{
doFormatInit();
// allow spaces here
m_monetaryThousandsSeparator = separator;
}
void KLocale::setMonetaryDecimalSymbol(const QString & symbol)
{
doFormatInit();
m_monetaryDecimalSymbol = symbol.stripWhiteSpace();
}
void KLocale::setCurrencySymbol(const QString & symbol)
{
doFormatInit();
m_currencySymbol = symbol.stripWhiteSpace();
}
int KLocale::pageSize() const
{
doFormatInit();
return d->pageSize;
}
void KLocale::setPageSize(int pageSize)
{
// #### check if it's in range??
doFormatInit();
d->pageSize = pageSize;
}
KLocale::MeasureSystem KLocale::measureSystem() const
{
doFormatInit();
return d->measureSystem;
}
void KLocale::setMeasureSystem(MeasureSystem value)
{
doFormatInit();
d->measureSystem = value;
}
QString KLocale::defaultLanguage()
{
return QString::fromLatin1("en_US");
}
QString KLocale::defaultCountry()
{
return QString::fromLatin1("C");
}
const char * KLocale::encoding() const
{
#ifdef Q_WS_WIN
if (0==qstrcmp("System", codecForEncoding()->name()))
{
//win32 returns "System" codec name here but KDE apps expect a real name:
strcpy(d->win32SystemEncoding, "cp ");
if (GetLocaleInfoA( MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), SORT_DEFAULT),
LOCALE_IDEFAULTANSICODEPAGE, d->win32SystemEncoding+3, sizeof(d->win32SystemEncoding)-3-1 ))
{
return d->win32SystemEncoding;
}
}
#endif
return codecForEncoding()->name();
}
int KLocale::encodingMib() const
{
return codecForEncoding()->mibEnum();
}
int KLocale::fileEncodingMib() const
{
if (d->utf8FileEncoding)
return 106;
return codecForEncoding()->mibEnum();
}
QTextCodec * KLocale::codecForEncoding() const
{
return d->codecForEncoding;
}
bool KLocale::setEncoding(int mibEnum)
{
QTextCodec * codec = QTextCodec::codecForMib(mibEnum);
if (codec)
d->codecForEncoding = codec;
return codec != 0;
}
QStringList KLocale::languagesTwoAlpha() const
{
if (d->langTwoAlpha.count())
return d->langTwoAlpha;
const QStringList &origList = languageList();
QStringList result;
KConfig config(QString::fromLatin1("language.codes"), true, false);
config.setGroup("TwoLetterCodes");
for ( QStringList::ConstIterator it = origList.begin();
it != origList.end();
++it )
{
QString lang = *it;
QStringList langLst;
if (config.hasKey( lang ))
langLst = config.readListEntry( lang );
else
{
int i = lang.find('_');
if (i >= 0)
lang.truncate(i);
langLst << lang;
}
for ( QStringList::ConstIterator langIt = langLst.begin();
langIt != langLst.end();
++langIt )
{
if ( !(*langIt).isEmpty() && !result.contains( *langIt ) )
result += *langIt;
}
}
d->langTwoAlpha = result;
return result;
}
QStringList KLocale::allLanguagesTwoAlpha() const
{
if (!d->languages)
d->languages = new KConfig("all_languages", true, false, "locale");
return d->languages->groupList();
}
QString KLocale::twoAlphaToLanguageName(const QString &code) const
{
if (!d->languages)
d->languages = new KConfig("all_languages", true, false, "locale");
QString groupName = code;
const int i = groupName.find('_');
groupName.replace(0, i, groupName.left(i).lower());
d->languages->setGroup(groupName);
return d->languages->readEntry("Name");
}
QStringList KLocale::allCountriesTwoAlpha() const
{
QStringList countries;
QStringList paths = KGlobal::dirs()->findAllResources("locale", "l10n/*/entry.desktop");
for(QStringList::ConstIterator it = paths.begin();
it != paths.end(); ++it)
{
QString code = (*it).mid((*it).length()-16, 2);
if (code != "/C")
countries.append(code);
}
return countries;
}
QString KLocale::twoAlphaToCountryName(const QString &code) const
{
KConfig cfg("l10n/"+code.lower()+"/entry.desktop", true, false, "locale");
cfg.setGroup("KCM Locale");
return cfg.readEntry("Name");
}
void KLocale::setCalendar(const QString & calType)
{
doFormatInit();
d->calendarType = calType;
delete d->calendar;
d->calendar = 0;
}
QString KLocale::calendarType() const
{
doFormatInit();
return d->calendarType;
}
const KCalendarSystem * KLocale::calendar() const
{
doFormatInit();
// Check if it's the correct calendar?!?
if ( !d->calendar )
d->calendar = KCalendarSystemFactory::create( d->calendarType, this );
return d->calendar;
}
KLocale::KLocale(const KLocale & rhs)
{
d = new KLocalePrivate;
*this = rhs;
}
KLocale & KLocale::operator=(const KLocale & rhs)
{
// Numbers and money
m_decimalSymbol = rhs.m_decimalSymbol;
m_thousandsSeparator = rhs.m_thousandsSeparator;
m_currencySymbol = rhs.m_currencySymbol;
m_monetaryDecimalSymbol = rhs.m_monetaryDecimalSymbol;
m_monetaryThousandsSeparator = rhs.m_monetaryThousandsSeparator;
m_positiveSign = rhs.m_positiveSign;
m_negativeSign = rhs.m_negativeSign;
m_fracDigits = rhs.m_fracDigits;
m_positivePrefixCurrencySymbol = rhs.m_positivePrefixCurrencySymbol;
m_negativePrefixCurrencySymbol = rhs.m_negativePrefixCurrencySymbol;
m_positiveMonetarySignPosition = rhs.m_positiveMonetarySignPosition;
m_negativeMonetarySignPosition = rhs.m_negativeMonetarySignPosition;
// Date and time
m_timeFormat = rhs.m_timeFormat;
m_dateFormat = rhs.m_dateFormat;
m_dateFormatShort = rhs.m_dateFormatShort;
m_language = rhs.m_language;
m_country = rhs.m_country;
// the assignment operator works here
*d = *rhs.d;
d->languages = 0; // Don't copy languages
d->calendar = 0; // Don't copy the calendar
return *this;
}
bool KLocale::setCharset(const QString & ) { return true; }
QString KLocale::charset() const { return QString::fromLatin1("UTF-8"); }
// KDE4: remove
#if 0
void nothing() { i18n("&Next"); }
#endif
KLocale::allCountriesTwoAlpha
QStringList allCountriesTwoAlpha() const
Returns list of all known country codes.
Definition: klocale.cpp:2354
KLocale::setNegativeSign
void setNegativeSign(const QString &sign)
Changes the sign used to identify a negative number.
Definition: klocale.cpp:2160
KCalendarSystem::month
virtual int month(const QDate &date) const =0
Gets specific calendar type month for a given gregorian date.
KLocale::setDateFormat
void setDateFormat(const QString &format)
Changes the current date format.
Definition: klocale.cpp:2081
KConfigBase::readListEntry
int readListEntry(const QString &pKey, QStrList &list, char sep= ',') const
Reads a list of strings.
Definition: kconfigbase.cpp:435
KLocale::setDateFormatShort
void setDateFormatShort(const QString &format)
Changes the current short date format.
Definition: klocale.cpp:2087
KInstance::instanceName
QCString instanceName() const
Returns the name of the instance.
Definition: kinstance.cpp:263
KLocale::setMeasureSystem
void setMeasureSystem(MeasureSystem value)
Changes the preferred measuring system.
Definition: klocale.cpp:2234
KGlobal::locale
static KLocale * locale()
Returns the global locale object.
Definition: kglobal.cpp:88
KLocale::translate
QString translate(const char *index) const
Translates the string into the corresponding string in the national language, if available.
Definition: klocale.cpp:753
KCalendarSystem::weekDayName
virtual QString weekDayName(int weekDay, bool shortName=false) const =0
Gets specific calendar type week day name If an invalid week day is specified, QString::null is retur...
Definition: kcalendarsystem.cpp:119
KLocale::fileEncodingMib
int fileEncodingMib() const
Returns the file encoding.
Definition: klocale.cpp:2272
KCalendarSystem::monthStringToInteger
virtual int monthStringToInteger(const QString &sNum, int &iLength) const
Converts a month literal of a part of a string into a integer starting at the beginning of the string...
Definition: kcalendarsystem.cpp:109
KLocale::positivePrefixCurrencySymbol
bool positivePrefixCurrencySymbol() const
If and only if the currency symbol precedes a positive value, this will be true.
Definition: klocale.cpp:1063
KLocale::translateQt
QString translateQt(const char *context, const char *sourceText, const char *message) const
Translates a message as a QTranslator is supposed to.
Definition: klocale.cpp:947
KLocale::langLookup
static QString langLookup(const QString &fname, const char *rtype="html")
Finds localized resource in resourceDir( rtype ) + <lang> + fname.
Definition: klocale.cpp:2004
KLocale::setThousandsSeparator
void setThousandsSeparator(const QString &separator)
Changes the separator used to group digits when formating numbers.
Definition: klocale.cpp:2147
KLocale::use12Clock
bool use12Clock() const
Use this to determine if the user wants a 12 hour clock.
Definition: klocale.cpp:1933
KLocale::setWeekStartsMonday
void setWeekStartsMonday(bool start) KDE_DEPRECATED
Definition: klocale.cpp:2105
KLocale::setCalendar
void setCalendar(const QString &calendarType)
Changes the current calendar system to the calendar specified.
Definition: klocale.cpp:2375
KLocale::MeasureSystem
MeasureSystem
The Metric system will give you information in mm, while the Imperial system will give you informatio...
Definition: klocale.h:1012
KConfigBase::hasKey
bool hasKey(const QString &key) const
Checks whether the key has an entry in the currently active group.
Definition: kconfigbase.cpp:109
KCatalogue::translate
const char * translate(const char *msgid) const
Retrieves a translation of the specified message id.
Definition: kcatalogue.cpp:140
KLocale::formatLong
QString formatLong(long num) const
Given an integer, converts that to a numeric string containing the localized numeric equivalent...
Definition: klocale.cpp:1187
KCalendarSystem::monthNamePossessive
virtual QString monthNamePossessive(int month, int year, bool shortName=false) const =0
Returns a string containing the possessive form of the month name.
KInstance::config
KConfig * config() const
Returns the general config object ("appnamerc").
Definition: kinstance.cpp:177
KLocale::languagesTwoAlpha
QStringList languagesTwoAlpha() const
Returns the preferred languages as ISO 639-1 codes.
Definition: klocale.cpp:2293
KCalendarSystemFactory::create
static KCalendarSystem * create(const QString &calType=QString::fromLatin1("gregorian"), const KLocale *locale=0)
Gets specific calendar type number of days in previous month for a given date.
Definition: kcalendarsystemfactory.cpp:43
KLocale::formatDate
QString formatDate(const QDate &pDate, bool shortFormat=false) const
Returns a string formatted to the current locale's conventions regarding dates.
Definition: klocale.cpp:1322
KLocale::removeCatalogue
void removeCatalogue(const QString &catalog)
Removes a catalog for translation lookup.
Definition: klocale.cpp:678
KLocale::readDate
QDate readDate(const QString &str, bool *ok=0) const
Converts a localized date string to a QDate.
Definition: klocale.cpp:1581
klocale.h
KLocale::decimalSymbol
QString decimalSymbol() const
Returns what a decimal point should look like ("." or "," etc.) according to the current locale or us...
Definition: klocale.cpp:1015
KLocale::setCountry
bool setCountry(const QString &country)
Changes the current country.
Definition: klocale.cpp:382
KCatalogue::name
QString name() const
Returns the name of the catalog.
Definition: kcatalogue.cpp:96
KLocale::setDateMonthNamePossessive
void setDateMonthNamePossessive(bool possessive)
Changes the form of month name used in dates.
Definition: klocale.cpp:2093
KLocale::twoAlphaToLanguageName
QString twoAlphaToLanguageName(const QString &code) const
Convert a ISO 639-1 code to a human readable form.
Definition: klocale.cpp:2341
KCalendarSystem
CalendarSystem abstract class, default derived kde gregorian class and factory class.
Definition: kcalendarsystem.h:42
KLocale::monetaryThousandsSeparator
QString monetaryThousandsSeparator() const
Returns what a thousands separator for monetary values should look like ("," or " " etc...
Definition: klocale.cpp:1039
KLocale::defaultCountry
static QString defaultCountry()
Returns the name of the default country.
Definition: klocale.cpp:2245
KLocale::insertCatalogue
void insertCatalogue(const QString &catalog)
Adds another catalog to search for translation lookup.
Definition: klocale.cpp:629
KLocale::dateFormatShort
QString dateFormatShort() const
Returns the currently selected short date format.
Definition: klocale.cpp:2129
KLocale::setLanguage
bool setLanguage(const QString &language)
Changes the current language.
Definition: klocale.cpp:405
KLocale::calendar
const KCalendarSystem * calendar() const
Returns a pointer to the calendar system object.
Definition: klocale.cpp:2392
KCalendarSystem::monthName
virtual QString monthName(int month, int year, bool shortName=false) const =0
Gets specific calendar type month name for a given month number If an invalid month is specified...
KGlobal::dirs
static KStandardDirs * dirs()
Returns the application standard dirs object.
Definition: kglobal.cpp:54
KLocale::setPositiveSign
void setPositiveSign(const QString &sign)
Changes the sign used to identify a positive number.
Definition: klocale.cpp:2154
KLocale::codecForEncoding
QTextCodec * codecForEncoding() const
Returns the user's preferred encoding.
Definition: klocale.cpp:2279
KLocale::readNumber
double readNumber(const QString &numStr, bool *ok=0) const
Converts a localized numeric string to a double.
Definition: klocale.cpp:1402
KLocale::i18n
QString i18n(const char *text)
Definition: klocale.cpp:1961
KLocale::negativeMonetarySignPosition
SignPosition negativeMonetarySignPosition() const
Denotes where to place a negative sign in relation to a monetary value.
Definition: klocale.cpp:1081
KLocale::setNegativePrefixCurrencySymbol
void setNegativePrefixCurrencySymbol(bool prefix)
Changes the position where the currency symbol should be printed for negative monetary values...
Definition: klocale.cpp:2184
KLocale::setMonetaryDecimalSymbol
void setMonetaryDecimalSymbol(const QString &symbol)
Changes the symbol used to identify the decimal pointer for monetary values.
Definition: klocale.cpp:2203
KLocale::setActiveCatalogue
void setActiveCatalogue(const QString &catalog)
Sets the active catalog for translation lookup.
Definition: klocale.cpp:687
KLocale::negativePrefixCurrencySymbol
bool negativePrefixCurrencySymbol() const
If and only if the currency symbol precedes a negative value, this will be true.
Definition: klocale.cpp:1069
KLocale::formatDateTime
QString formatDateTime(const QDateTime &pDateTime, bool shortFormat=true, bool includeSecs=false) const
Returns a string formated to the current locale's conventions regarding both date and time...
Definition: klocale.cpp:1952
KLocale::I18N_NOOP
#define I18N_NOOP(x)
Definition: klocale.h:52
KInstance
Access to KDE global objects for use in shared libraries.
Definition: kinstance.h:43
KLocale::weekDayName
QString weekDayName(int i, bool shortName=false) const KDE_DEPRECATED
Definition: klocale.cpp:624
KCatalogue
This class abstracts a gettext message catalog.
Definition: kcatalogue.h:37
KLocale::language
QString language() const
Returns the language used by this object.
Definition: klocale.cpp:538
KLocale::languages
QString languages() const KDE_DEPRECATED
Definition: klocale.cpp:1942
KLocale::country
QString country() const
Returns the country code of the country where the user lives.
Definition: klocale.cpp:543
KConfigGroupSaver
Helper class to facilitate working with KConfig / KSimpleConfig groups.
Definition: kconfigbase.h:2057
KLocale::monthName
QString monthName(int i, bool shortName=false) const KDE_DEPRECATED
Definition: klocale.cpp:548
KLocale::setTimeFormat
void setTimeFormat(const QString &format)
Changes the current time format.
Definition: klocale.cpp:2099
KLocale::twoAlphaToCountryName
QString twoAlphaToCountryName(const QString &code) const
Convert a country code to a human readable form.
Definition: klocale.cpp:2368
KLocale::setPositivePrefixCurrencySymbol
void setPositivePrefixCurrencySymbol(bool prefix)
Changes the position where the currency symbol should be printed for positive monetary values...
Definition: klocale.cpp:2178
KConfigBase
KDE Configuration Management abstract base class.
Definition: kconfigbase.h:70
KGlobal::instance
static KInstance * instance()
Returns the global instance.
Definition: kglobal.cpp:82
KLocale::monthNamePossessive
QString monthNamePossessive(int i, bool shortName=false) const KDE_DEPRECATED
Definition: klocale.cpp:586
KStandardDirs::findAllResources
QStringList findAllResources(const char *type, const QString &filter=QString::null, bool recursive=false, bool unique=false) const
Tries to find all resources with the specified type.
Definition: kstandarddirs.cpp:676
KLocale::readTime
QTime readTime(const QString &str, bool *ok=0) const
Converts a localized time string to a QTime.
Definition: klocale.cpp:1726
KLocale::dateFormat
QString dateFormat() const
Returns the currently selected date format.
Definition: klocale.cpp:2123
KLocale::setCharset
bool setCharset(const QString &charset) KDE_DEPRECATED
Definition: klocale.cpp:2442
KLocale::pageSize
int pageSize() const
Returns the preferred page size for printing.
Definition: klocale.cpp:2215
KLocale::currencySymbol
QString currencySymbol() const
Returns what the symbol denoting currency in the current locale as as defined by user settings should...
Definition: klocale.cpp:1027
KLocale::allLanguagesTwoAlpha
QStringList allLanguagesTwoAlpha() const
Returns list of all known ISO 639-1 codes.
Definition: klocale.cpp:2333
KLocale::setCurrencySymbol
void setCurrencySymbol(const QString &symbol)
Changes the current currency symbol.
Definition: klocale.cpp:2209
KStandardDirs::resourceDirs
QStringList resourceDirs(const char *type) const
This function is used internally by almost all other function as it serves and fills the directories ...
Definition: kstandarddirs.cpp:783
KLocale::KLocale
KLocale(const QString &catalog, KConfig *config=0)
Constructs a KLocale with the given catalog name.
Definition: klocale.cpp:83
KLocale::operator=
KLocale & operator=(const KLocale &rhs)
Assignment operator.
Definition: klocale.cpp:2410
KCalendarSystem::yearStringToInteger
virtual int yearStringToInteger(const QString &sNum, int &iLength) const
Converts a year literal of a part of a string into a integer starting at the beginning of the string...
Definition: kcalendarsystem.cpp:114
KLocale::nounDeclension
bool nounDeclension() const
Use this to determine whether nouns are declined in locale's language.
Definition: klocale.cpp:991
KLocale::splitLocale
static void splitLocale(const QString &str, QString &language, QString &country, QString &charset)
Returns the parts of the parameter str understood as language setting the format is language_COUNTRY...
Definition: klocale.cpp:505
KLocale::dateMonthNamePossessive
bool dateMonthNamePossessive() const
Use this to determine whether in dates a possessive form of month name is preferred ("of January" rat...
Definition: klocale.cpp:997
KLocale::setMonetaryThousandsSeparator
void setMonetaryThousandsSeparator(const QString &separator)
Changes the separator used to group digits when formating monetary values.
Definition: klocale.cpp:2196
KLocale::setPageSize
void setPageSize(int paperFormat)
Changes the preferred page size when printing.
Definition: klocale.cpp:2221
KConfig
Access KDE Configuration entries.
Definition: kconfig.h:43
KLocale::languageList
QStringList languageList() const
Returns the languages selected by user.
Definition: klocale.cpp:1947
KLocale::~KLocale
~KLocale()
Destructor.
Definition: klocale.cpp:696
KLocale::measureSystem
MeasureSystem measureSystem() const
Returns which measuring system we use.
Definition: klocale.cpp:2228
KLocale
KLocale provides support for country specific stuff like the national language.
Definition: klocale.h:124
KLocale::setPositiveMonetarySignPosition
void setPositiveMonetarySignPosition(SignPosition signpos)
Changes the sign position used for positive monetary values.
Definition: klocale.cpp:2166
KLocale::SignPosition
SignPosition
Various positions for where to place the positive or negative sign when they are related to a monetar...
Definition: klocale.h:267
KConfigBase::readEntry
QString readEntry(const QString &pKey, const QString &aDefault=QString::null) const
Reads the value of an entry specified by pKey in the current group.
Definition: kconfigbase.cpp:203
KLocale::setMainCatalogue
static void setMainCatalogue(const char *catalog)
Use this as main catalog for all KLocales, if not the appname will be used.
Definition: klocale.cpp:1397
KLocale::positiveSign
QString positiveSign() const
Returns what a positive sign should look like ("+", " ", etc.) according to the current locale or use...
Definition: klocale.cpp:1045
KLocale::negativeSign
QString negativeSign() const
Returns what a negative sign should look like ("-", etc.) according to the current locale or user set...
Definition: klocale.cpp:1051
KLocale::setDecimalSymbol
void setDecimalSymbol(const QString &symbol)
Changes the symbol used to identify the decimal pointer.
Definition: klocale.cpp:2141
KLocale::positiveMonetarySignPosition
SignPosition positiveMonetarySignPosition() const
Returns the position of a positive sign in relation to a monetary value.
Definition: klocale.cpp:1075
KLocale::fracDigits
int fracDigits() const
The number of fractional digits to include in numeric/monetary values (usually 2).
Definition: klocale.cpp:1057
KLocale::weekStartsMonday
bool weekStartsMonday() const KDE_DEPRECATED
Definition: klocale.cpp:1009
KLocale::weekStartDay
int weekStartDay() const
Use this to determine which day is the first day of the week.
Definition: klocale.cpp:1003
KLocale::formatTime
QString formatTime(const QTime &pTime, bool includeSecs, bool isDuration) const
Returns a string formatted to the current locale's conventions regarding times.
Definition: klocale.cpp:1847
KCalendarSystem::dayStringToInteger
virtual int dayStringToInteger(const QString &sNum, int &iLength) const
Converts a day literal of a part of a string into a integer starting at the beginning of the string...
Definition: kcalendarsystem.cpp:104
KLocale::setWeekStartDay
void setWeekStartDay(int day)
Changes how KLocale defines the first day in week.
Definition: klocale.cpp:2114
endl
kndbgstream & endl(kndbgstream &s)
Does nothing.
Definition: kdebug.h:583
KSimpleConfig
KDE Configuration entries.
Definition: ksimpleconfig.h:41
KLocale::formatNumber
QString formatNumber(double num, int precision=-1) const
Given a double, converts that to a numeric string containing the localized numeric equivalent...
Definition: klocale.cpp:1180
KLocale::setEncoding
bool setEncoding(int mibEnum)
Changes the current encoding.
Definition: klocale.cpp:2284
KLocale::charset
QString charset() const KDE_DEPRECATED
Definition: klocale.cpp:2443
KConfigBase::setGroup
void setGroup(const QString &group)
Specifies the group in which keys will be read and written.
Definition: kconfigbase.cpp:79
KCalendarSystem::year
virtual int year(const QDate &date) const =0
Gets specific calendar type year for a given gregorian date.
KLocale::formatMoney
QString formatMoney(double num, const QString &currency=QString::null, int digits=-1) const
Given a double, converts that to a numeric string containing the localized monetary equivalent...
Definition: klocale.cpp:1114
KLocale::setNegativeMonetarySignPosition
void setNegativeMonetarySignPosition(SignPosition signpos)
Changes the sign position used for negative monetary values.
Definition: klocale.cpp:2172
KLocale::calendarType
QString calendarType() const
Returns the name of the calendar system that is currently being used by the system.
Definition: klocale.cpp:2385
KLocale::setFracDigits
void setFracDigits(int digits)
Changes the number of digits used when formating numbers.
Definition: klocale.cpp:2190
KLocale::defaultLanguage
static QString defaultLanguage()
Returns the name of the internal language.
Definition: klocale.cpp:2240
KLocale::encoding
const char * encoding() const
Returns the user's preferred encoding.
Definition: klocale.cpp:2250
KLocale::readMoney
double readMoney(const QString &numStr, bool *ok=0) const
Converts a localized monetary string to a double.
Definition: klocale.cpp:1467
KLocale::monetaryDecimalSymbol
QString monetaryDecimalSymbol() const
Returns what a decimal point should look like ("." or "," etc.) for monetary values, according to the current locale or user settings.
Definition: klocale.cpp:1033
KCalendarSystem::setYMD
virtual bool setYMD(QDate &date, int y, int m, int d) const =0
Changes the date's year, month and day.
KLocale::thousandsSeparator
QString thousandsSeparator() const
Returns what the thousands separator should look like ("," or "." etc.) according to the current loca...
Definition: klocale.cpp:1021
KLocale::timeFormat
QString timeFormat() const
Returns the currently selected time format.
Definition: klocale.cpp:2135
KLocale::encodingMib
int encodingMib() const
Returns the user's preferred encoding.
Definition: klocale.cpp:2267

KDE Home | KDE Accessibility Home | Description of Access Keys