Page Menu
Home
Phorge
Search
Configure Global Search
Log In
Files
F16569348
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Flag For Later
Award Token
Size
198 KB
Referenced Files
None
Subscribers
None
View Options
diff --git a/kdecore/localization/klocale.cpp b/kdecore/localization/klocale.cpp
index 499bf112d6..02aa77a499 100644
--- a/kdecore/localization/klocale.cpp
+++ b/kdecore/localization/klocale.cpp
@@ -1,782 +1,787 @@
/* 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>
Copyright (C) 2007 Bernhard Loos <nhuh.put@web.de>
Copyright (C) 2009, 2010 John Layt <john@layt.net>
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 "klocale.h"
#if defined Q_WS_WIN
#include "klocale_win_p.h"
#elif defined Q_OS_MAC
#include "klocale_mac_p.h"
#else
#include "klocale_unix_p.h"
#endif
#include <QtCore/QDateTime>
#include <QtCore/QTextCodec>
#include "kcatalog_p.h"
#include "kglobal.h"
#include "kconfig.h"
#include "kdebug.h"
#include "kdatetime.h"
#include "kcalendarsystem.h"
#include "kdayperiod_p.h"
#include "kcurrencycode.h"
#include "kcatalogname_p.h"
#include "common_helpers_p.h"
KLocale::KLocale(const QString &catalog, KSharedConfig::Ptr config)
#if defined Q_WS_WIN
: d(new KLocaleWindowsPrivate(this, catalog, config))
#elif defined Q_OS_MAC
: d(new KLocaleMacPrivate(this, catalog, config))
#else
: d(new KLocaleUnixPrivate(this, catalog, config))
#endif
{
}
KLocale::KLocale(const QString& catalog, const QString &language, const QString &country, KConfig *config)
#if defined Q_WS_WIN
: d(new KLocaleWindowsPrivate(this, catalog, language, country, config))
#elif defined Q_OS_MAC
: d(new KLocaleMacPrivate(this, catalog, language, country, config))
#else
: d(new KLocaleUnixPrivate(this, catalog, language, country, config))
#endif
{
}
KLocale::~KLocale()
{
delete d;
}
bool KLocale::setCountry(const QString &country, KConfig *config)
{
return d->setCountry(country, config);
}
bool KLocale::setCountryDivisionCode(const QString &countryDivisionCode)
{
return d->setCountryDivisionCode(countryDivisionCode);
}
bool KLocale::setLanguage(const QString &language, KConfig *config)
{
return d->setLanguage(language, config);
}
bool KLocale::setLanguage(const QStringList &languages)
{
return d->setLanguage(languages);
}
void KLocale::setCurrencyCode(const QString &newCurrencyCode)
{
d->setCurrencyCode(newCurrencyCode);
}
bool KLocale::isApplicationTranslatedInto(const QString &lang)
{
return d->isApplicationTranslatedInto(lang);
}
void KLocale::splitLocale(const QString &locale, QString &language, QString &country, QString &modifier,
QString &charset)
{
KLocalePrivate::splitLocale(locale, language, country, modifier, charset);
}
QString KLocale::language() const
{
return d->language();
}
QString KLocale::country() const
{
return d->country();
}
QString KLocale::countryDivisionCode() const
{
return d->countryDivisionCode();
}
KCurrencyCode *KLocale::currency() const
{
return d->currency();
}
QString KLocale::currencyCode() const
{
return d->currencyCode();
}
void KLocale::insertCatalog(const QString &catalog)
{
d->insertCatalog(catalog);
}
void KLocale::removeCatalog(const QString &catalog)
{
d->removeCatalog(catalog);
}
void KLocale::setActiveCatalog(const QString &catalog)
{
d->setActiveCatalog(catalog);
}
void KLocale::translateRawFrom(const char *catname, const char *ctxt, const char *singular, const char *plural,
unsigned long n, QString *lang, QString *trans) const
{
d->translateRawFrom(catname, ctxt, singular, plural, n, lang, trans);
}
//Convenience versions
void KLocale::translateRawFrom(const char *catname, const char *msg, QString *lang, QString *trans) const
{
d->translateRawFrom(catname, 0, msg, 0, 0, lang, trans);
}
void KLocale::translateRaw(const char *msg, QString *lang, QString *trans) const
{
d->translateRawFrom(0, 0, msg, 0, 0, lang, trans);
}
void KLocale::translateRawFrom(const char *catname, const char *ctxt, const char *msg, QString *lang,
QString *trans) const
{
d->translateRawFrom(catname, ctxt, msg, 0, 0, lang, trans);
}
void KLocale::translateRaw(const char *ctxt, const char *msg, QString *lang, QString *trans) const
{
d->translateRawFrom(0, ctxt, msg, 0, 0, lang, trans);
}
void KLocale::translateRawFrom(const char *catname, const char *singular, const char *plural,
unsigned long n, QString *lang, QString *trans) const
{
d->translateRawFrom(catname, 0, singular, plural, n, lang, trans);
}
void KLocale::translateRaw(const char *singular, const char *plural, unsigned long n, QString *lang,
QString *trans) const
{
d->translateRawFrom(0, 0, singular, plural, n, lang, trans);
}
void KLocale::translateRaw(const char *ctxt, const char *singular, const char *plural,
unsigned long n, QString *lang, QString *trans) const
{
d->translateRawFrom(0, ctxt, singular, plural, n, lang, trans);
}
QString KLocale::translateQt(const char *context, const char *sourceText, const char *comment) const
{
return d->translateQt(context, sourceText, comment);
}
QList<KLocale::DigitSet> KLocale::allDigitSetsList() const
{
return d->allDigitSetsList();
}
QString KLocale::digitSetToName(KLocale::DigitSet digitSet, bool withDigits) const
{
return d->digitSetToName(digitSet, withDigits);
}
QString KLocale::convertDigits(const QString &str, DigitSet digitSet, bool ignoreContext) const
{
return d->convertDigits(str, digitSet, ignoreContext);
}
bool KLocale::nounDeclension() const
{
return d->nounDeclension();
}
bool KLocale::dateMonthNamePossessive() const
{
return d->dateMonthNamePossessive();
}
int KLocale::weekStartDay() const
{
return d->weekStartDay();
}
int KLocale::workingWeekStartDay() const
{
return d->workingWeekStartDay();
}
int KLocale::workingWeekEndDay() const
{
return d->workingWeekEndDay();
}
int KLocale::weekDayOfPray() const
{
return d->weekDayOfPray();
}
int KLocale::decimalPlaces() const
{
return d->decimalPlaces();
}
QString KLocale::decimalSymbol() const
{
return d->decimalSymbol();
}
QString KLocale::thousandsSeparator() const
{
return d->thousandsSeparator();
}
QString KLocale::currencySymbol() const
{
return d->currencySymbol();
}
QString KLocale::monetaryDecimalSymbol() const
{
return d->monetaryDecimalSymbol();
}
QString KLocale::monetaryThousandsSeparator() const
{
return d->monetaryThousandsSeparator();
}
QString KLocale::positiveSign() const
{
return d->positiveSign();
}
QString KLocale::negativeSign() const
{
return d->negativeSign();
}
int KLocale::fracDigits() const
{
return monetaryDecimalPlaces();
}
int KLocale::monetaryDecimalPlaces() const
{
return d->monetaryDecimalPlaces();
}
bool KLocale::positivePrefixCurrencySymbol() const
{
return d->positivePrefixCurrencySymbol();
}
bool KLocale::negativePrefixCurrencySymbol() const
{
return d->negativePrefixCurrencySymbol();
}
KLocale::SignPosition KLocale::positiveMonetarySignPosition() const
{
return d->positiveMonetarySignPosition();
}
KLocale::SignPosition KLocale::negativeMonetarySignPosition() const
{
return d->negativeMonetarySignPosition();
}
QString KLocale::formatMoney(double num, const QString &symbol, int precision) const
{
return d->formatMoney(num, symbol, precision);
}
QString KLocale::formatNumber(double num, int precision) const
{
return d->formatNumber(num, precision);
}
QString KLocale::formatLong(long num) const
{
return d->formatLong(num);
}
QString KLocale::formatNumber(const QString &numStr, bool round, int precision) const
{
return d->formatNumber(numStr, round, precision);
}
QString KLocale::formatByteSize(double size, int precision, KLocale::BinaryUnitDialect dialect,
KLocale::BinarySizeUnits specificUnit) const
{
return d->formatByteSize(size, precision, dialect, specificUnit);
}
QString KLocale::formatByteSize(double size) const
{
return d->formatByteSize(size);
}
KLocale::BinaryUnitDialect KLocale::binaryUnitDialect() const
{
return d->binaryUnitDialect();
}
void KLocale::setBinaryUnitDialect(KLocale::BinaryUnitDialect newDialect)
{
d->setBinaryUnitDialect(newDialect);
}
QString KLocale::formatDuration(unsigned long mSec) const
{
return d->formatDuration(mSec);
}
QString KLocale::prettyFormatDuration(unsigned long mSec) const
{
return d->prettyFormatDuration(mSec);
}
QString KLocale::formatDate(const QDate &date, KLocale::DateFormat format) const
{
return d->formatDate(date, format);
}
void KLocale::setMainCatalog(const char *catalog)
{
KLocalePrivate::setMainCatalog(catalog);
}
double KLocale::readNumber(const QString &_str, bool * ok) const
{
return d->readNumber(_str, ok);
}
double KLocale::readMoney(const QString &_str, bool *ok) const
{
return d->readMoney(_str, ok);
}
QDate KLocale::readDate(const QString &intstr, bool *ok) const
{
return d->readDate(intstr, ok);
}
QDate KLocale::readDate(const QString &intstr, ReadDateFlags flags, bool *ok) const
{
return d->readDate(intstr, flags, ok);
}
QDate KLocale::readDate(const QString &intstr, const QString &fmt, bool *ok) const
{
return d->readDate(intstr, fmt, ok);
}
QTime KLocale::readTime(const QString &intstr, bool *ok) const
{
return d->readTime(intstr, ok);
}
QTime KLocale::readTime(const QString &intstr, KLocale::ReadTimeFlags flags, bool *ok) const
{
return d->readTime(intstr, flags, ok);
}
QTime KLocale::readLocaleTime(const QString &intstr, bool *ok, TimeFormatOptions options,
TimeProcessingOptions processing) const
{
return d->readLocaleTime(intstr, ok, options, processing);
}
QString KLocale::formatTime(const QTime &time, bool includeSecs, bool isDuration) const
{
return d->formatTime(time, includeSecs, isDuration);
}
QString KLocale::formatLocaleTime(const QTime &time, TimeFormatOptions options) const
{
return d->formatLocaleTime(time, options);
}
bool KLocale::use12Clock() const
{
return d->use12Clock();
}
QString KLocale::dayPeriodText(const QTime &time, DateTimeComponentFormat format) const
{
return d->dayPeriodForTime(time).periodName(format);
}
QStringList KLocale::languageList() const
{
return d->languageList();
}
QStringList KLocale::currencyCodeList() const
{
return d->currencyCodeList();
}
/* Just copy in for now to keep diff clean, remove later
QString KLocalePrivate::formatDateTime(const KLocale *locale, const QDateTime &dateTime, KLocale::DateFormat format,
bool includeSeconds, int daysTo, int secsTo)
{
}
*/
QString KLocale::formatDateTime(const QDateTime &dateTime, KLocale::DateFormat format, bool includeSeconds) const
{
return d->formatDateTime(dateTime, format, includeSeconds);
}
QString KLocale::formatDateTime(const KDateTime &dateTime, KLocale::DateFormat format, DateTimeFormatOptions options) const
{
return d->formatDateTime(dateTime, format, options);
}
QString KLocale::langLookup(const QString &fname, const char *rtype)
{
return KLocalePrivate::langLookup(fname, rtype);
}
void KLocale::setDateFormat(const QString &format)
{
d->setDateFormat(format);
}
void KLocale::setDateFormatShort(const QString &format)
{
d->setDateFormatShort(format);
}
void KLocale::setDateMonthNamePossessive(bool possessive)
{
d->setDateMonthNamePossessive(possessive);
}
void KLocale::setTimeFormat(const QString &format)
{
d->setTimeFormat(format);
}
void KLocale::setWeekStartDay(int day)
{
d->setWeekStartDay(day);
}
void KLocale::setWorkingWeekStartDay(int day)
{
d->setWorkingWeekStartDay(day);
}
void KLocale::setWorkingWeekEndDay(int day)
{
d->setWorkingWeekEndDay(day);
}
void KLocale::setWeekDayOfPray(int day)
{
d->setWeekDayOfPray(day);
}
QString KLocale::dateFormat() const
{
return d->dateFormat();
}
QString KLocale::dateFormatShort() const
{
return d->dateFormatShort();
}
QString KLocale::timeFormat() const
{
return d->timeFormat();
}
void KLocale::setDecimalPlaces(int digits)
{
d->setDecimalPlaces(digits);
}
void KLocale::setDecimalSymbol(const QString &symbol)
{
d->setDecimalSymbol(symbol);
}
void KLocale::setThousandsSeparator(const QString &separator)
{
d->setThousandsSeparator(separator);
}
void KLocale::setPositiveSign(const QString &sign)
{
d->setPositiveSign(sign);
}
void KLocale::setNegativeSign(const QString &sign)
{
d->setNegativeSign(sign);
}
void KLocale::setPositiveMonetarySignPosition(KLocale::SignPosition signpos)
{
d->setPositiveMonetarySignPosition(signpos);
}
void KLocale::setNegativeMonetarySignPosition(KLocale::SignPosition signpos)
{
d->setNegativeMonetarySignPosition(signpos);
}
void KLocale::setPositivePrefixCurrencySymbol(bool prefix)
{
d->setPositivePrefixCurrencySymbol(prefix);
}
void KLocale::setNegativePrefixCurrencySymbol(bool prefix)
{
d->setNegativePrefixCurrencySymbol(prefix);
}
void KLocale::setFracDigits(int digits)
{
setMonetaryDecimalPlaces(digits);
}
void KLocale::setMonetaryDecimalPlaces(int digits)
{
d->setMonetaryDecimalPlaces(digits);
}
void KLocale::setMonetaryThousandsSeparator(const QString &separator)
{
d->setMonetaryThousandsSeparator(separator);
}
void KLocale::setMonetaryDecimalSymbol(const QString &symbol)
{
d->setMonetaryDecimalSymbol(symbol);
}
void KLocale::setCurrencySymbol(const QString & symbol)
{
d->setCurrencySymbol(symbol);
}
int KLocale::pageSize() const
{
return d->pageSize();
}
void KLocale::setPageSize(int size)
{
d->setPageSize(size);
}
KLocale::MeasureSystem KLocale::measureSystem() const
{
return d->measureSystem();
}
void KLocale::setMeasureSystem(KLocale::MeasureSystem value)
{
d->setMeasureSystem(value);
}
QString KLocale::defaultLanguage()
{
return KLocalePrivate::defaultLanguage();
}
QString KLocale::defaultCountry()
{
return KLocalePrivate::defaultCountry();
}
QString KLocale::defaultCurrencyCode()
{
return KLocalePrivate::defaultCurrencyCode();
}
bool KLocale::useTranscript() const
{
return d->useTranscript();
}
const QByteArray KLocale::encoding() const
{
return d->encoding();
}
int KLocale::encodingMib() const
{
return d->encodingMib();
}
int KLocale::fileEncodingMib() const
{
return d->fileEncodingMib();
}
QTextCodec *KLocale::codecForEncoding() const
{
return d->codecForEncoding();
}
bool KLocale::setEncoding(int mibEnum)
{
return d->setEncoding(mibEnum);
}
QStringList KLocale::allLanguagesList() const
{
return d->allLanguagesList();
}
QStringList KLocale::installedLanguages() const
{
return d->installedLanguages();
}
QString KLocale::languageCodeToName(const QString &language) const
{
return d->languageCodeToName(language);
}
QStringList KLocale::allCountriesList() const
{
return d->allCountriesList();
}
QString KLocale::countryCodeToName(const QString &country) const
{
return d->countryCodeToName(country);
}
void KLocale::setCalendar(const QString &calendarType)
{
d->setCalendar(calendarType);
}
void KLocale::setCalendarSystem(KLocale::CalendarSystem calendarSystem)
{
d->setCalendarSystem(calendarSystem);
}
QString KLocale::calendarType() const
{
return d->calendarType();
}
KLocale::CalendarSystem KLocale::calendarSystem() const
{
return d->calendarSystem();
}
const KCalendarSystem * KLocale::calendar() const
{
return d->calendar();
}
void KLocale::setWeekNumberSystem(KLocale::WeekNumberSystem weekNumberSystem)
{
d->setWeekNumberSystem(weekNumberSystem);
}
KLocale::WeekNumberSystem KLocale::weekNumberSystem()
{
return d->weekNumberSystem();
}
KLocale::WeekNumberSystem KLocale::weekNumberSystem() const
{
return d->weekNumberSystem();
}
KLocale::KLocale(const KLocale &rhs)
: d(new KLocalePrivate(*rhs.d))
{
d->q = this;
}
KLocale & KLocale::operator=(const KLocale & rhs)
{
// the assignment operator works here
*d = *rhs.d;
d->q = this;
return *this;
}
void KLocale::copyCatalogsTo(KLocale *locale)
{
d->copyCatalogsTo(locale);
}
QString KLocale::localizedFilePath(const QString &filePath) const
{
return d->localizedFilePath(filePath);
}
QString KLocale::removeAcceleratorMarker(const QString &label) const
{
return d->removeAcceleratorMarker(label);
}
void KLocale::setDigitSet(KLocale::DigitSet digitSet)
{
d->setDigitSet(digitSet);
}
KLocale::DigitSet KLocale::digitSet() const
{
return d->digitSet();
}
void KLocale::setMonetaryDigitSet(KLocale::DigitSet digitSet)
{
d->setMonetaryDigitSet(digitSet);
}
KLocale::DigitSet KLocale::monetaryDigitSet() const
{
return d->monetaryDigitSet();
}
void KLocale::setDateTimeDigitSet(KLocale::DigitSet digitSet)
{
d->setDateTimeDigitSet(digitSet);
}
KLocale::DigitSet KLocale::dateTimeDigitSet() const
{
return d->dateTimeDigitSet();
}
+
+void KLocale::reparseConfiguration()
+{
+ d->initFormat();
+}
diff --git a/kdecore/localization/klocale.h b/kdecore/localization/klocale.h
index 3495431a6b..3a05b5e856 100644
--- a/kdecore/localization/klocale.h
+++ b/kdecore/localization/klocale.h
@@ -1,2129 +1,2137 @@
/* This file is part of the KDE libraries
Copyright (C) 1997 Stephan Kulow <coolo@kde.org>
Copyright (C) 1999-2003 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.
*/
#ifndef KLOCALE_H
#define KLOCALE_H
#include <kdecore_export.h>
#include <klocalizedstring.h>
#include <ksharedconfig.h>
#include <QtCore/QString>
#include <QtCore/QList>
class QStringList;
class QTextCodec;
class QDate;
class QTime;
class QDateTime;
class KDateTime;
class KCalendarSystem;
class KCurrencyCode;
class KDayPeriod;
class KLocalePrivate;
/**
* \file klocale.h
*/
/**
*
* KLocale provides support for country specific stuff like
* the national language.
*
* KLocale supports translating, as well as specifying the format
* for numbers, currency, time, and date.
*
* Use KGlobal::locale() to get pointer to the global KLocale object,
* containing the applications current locale settings.
*
* For example, to format the date May 17, 1995 in the current locale, use:
*
* \code
* QString date = KGlobal::locale()->formatDate(QDate(1995,5,17));
* \endcode
*
* @author Stephan Kulow <coolo@kde.org>, Preston Brown <pbrown@kde.org>,
* Hans Petter Bieker <bieker@kde.org>, Lukas Tinkl <lukas.tinkl@suse.cz>
* @short class for supporting locale settings and national language
*/
class KDECORE_EXPORT KLocale
{
public:
/**
* Constructs a KLocale with the given catalog name
*
* The constructor looks for an entry Language in the group Locale in the
* configuration file.
*
* If no configuration file is specified, it will also look for languages
* using the environment variables (KDE_LANG, LC_MESSAGES, LC_ALL, LANG),
* as well as the global configuration file. If KLocale is not able to use
* any of the specified languages, the default language (en_US) will be
* used.
*
* If you specify a configuration file, it has to be valid until the KLocale
* object is destroyed. Note that a setLocale() will be performed on the
* config using the current locale language, which may cause a sync()
* and reparseConfiguration() which will save any changes you have made and
* load any changes other shared copies have made.
*
* @param catalog the name of the main language file
* @param config a configuration file with a Locale group detailing
* locale-related preferences (such as language and
* formatting options).
*/
explicit KLocale(const QString& catalog, KSharedConfig::Ptr config = KSharedConfig::Ptr());
/**
* Constructs a KLocale with the given catalog name
*
* Allows you to override the language and, optionally, the
* country of this locale.
*
* If you specify a configuration file, a setLocale() will be performed on
* the config using the current locale language, which may cause a sync()
* and reparseConfiguration() which will save any changes you have made.
*
* @param catalog the name of the main language file
* @param language the ISO Language Code for the locale, e.g. "en" for English
* @param country the ISO Country Code for the locale, e.g. "us" for USA
* @param config a configuration file with a Locale group detailing
* locale-related preferences (such as language and
* formatting options).
*/
KLocale(const QString& catalog, const QString &language, const QString &country = QString(),
KConfig *config = 0);
/**
* Copy constructor
*/
KLocale(const KLocale & rhs);
/**
* Assignment operator
*/
KLocale& operator= (const KLocale & rhs);
/**
* Destructor
*/
virtual ~KLocale();
/**
* @since 4.5
*
* Raw translation from a message catalog.
* If catalog name is null or empty,
* all loaded catalogs are searched for the translation.
*
* Never use this directly to get message translations. See the i18n and ki18n
* family of calls related to KLocalizedString.
*
* @param catname the catalog name. Must be UTF-8 encoded.
* @param msg the message. Must not be null or empty. Must be UTF-8 encoded.
* @param lang language in which the translation was found. If no translation
* was found, KLocale::defaultLanguage() is reported. If null,
* the language is not reported.
* @param trans raw translation, or original if not found. If no translation
* was found, original message is reported. If null, the
* translation is not reported.
*
* @see KLocalizedString
*/
void translateRawFrom(const char* catname, const char* msg, QString *lang, QString *trans) const;
/**
* Like translateRawFrom, with implicit lookup through all loaded catalogs.
*
* @deprecated Use translateRawFrom with null or empty catalog name.
*/
void translateRaw(const char* msg, QString *lang, QString *trans) const;
/**
* @since 4.5
*
* Raw translation from a message catalog, with given context.
* Context + message are used as the lookup key in the catalog.
* If catalog name is null or empty,
* all loaded catalogs are searched for the translation.
*
* Never use this directly to get message translations. See i18n* and ki18n*
* calls related to KLocalizedString.
*
* @param catname the catalog name. Must be UTF-8 encoded.
* @param ctxt the context. Must not be null. Must be UTF-8 encoded.
* @param msg the message. Must not be null or empty. Must be UTF-8 encoded.
* @param lang language in which the translation was found. If no translation
* was found, KLocale::defaultLanguage() is reported. If null,
* the language is not reported.
* @param trans raw translation, or original if not found. If no translation
* was found, original message is reported. If null, the
* translation is not reported.
*
* @see KLocalizedString
*/
void translateRawFrom(const char *catname, const char *ctxt, const char *msg, QString *lang, QString *trans) const;
/**
* Like translateRawFrom, with implicit lookup through all loaded catalogs.
*
* @deprecated Use translateRawFrom with null or empty catalog name.
*/
void translateRaw(const char *ctxt, const char *msg, QString *lang, QString *trans) const;
/**
* @since 4.5
*
* Raw translation from a message catalog, with given singular/plural form.
* Singular form is used as the lookup key in the catalog.
* If catalog name is null or empty,
* all loaded catalogs are searched for the translation.
*
* Never use this directly to get message translations. See i18n* and ki18n*
* calls related to KLocalizedString.
*
* @param catname the catalog name. Must be UTF-8 encoded.
* @param singular the singular form. Must not be null or empty. Must be UTF-8 encoded.
* @param plural the plural form. Must not be null. Must be UTF-8 encoded.
* @param n number on which the forms are decided.
* @param lang language in which the translation was found. If no translation
* was found, KLocale::defaultLanguage() is reported. If null,
* the language is not reported.
* @param trans raw translation, or original if not found. If no translation
* was found, original message is reported (either plural or
* singular, as determined by @p n ). If null, the
* translation is not reported.
*
* @see KLocalizedString
*/
void translateRawFrom(const char *catname, const char *singular, const char *plural, unsigned long n,
QString *lang, QString *trans) const;
/**
* Like translateRawFrom, with implicit lookup through all loaded catalogs.
*
* @deprecated Use translateRawFrom with null or empty catalog name.
*/
void translateRaw(const char *singular, const char *plural, unsigned long n, QString *lang,
QString *trans) const;
/**
* @since 4.5
*
* Raw translation from a message catalog, with given context and
* singular/plural form.
* Context + singular form is used as the lookup key in the catalog.
* If catalog name is null or empty,
* all loaded catalogs are searched for the translation.
*
* Never use this directly to get message translations. See i18n* and ki18n*
* calls related to KLocalizedString.
*
* @param catname the catalog name. Must be UTF-8 encoded.
* @param ctxt the context. Must not be null. Must be UTF-8 encoded.
* @param singular the singular form. Must not be null or empty. Must be UTF-8 encoded.
* @param plural the plural form. Must not be null. Must be UTF-8 encoded.
* @param n number on which the forms are decided.
* @param lang language in which the translation was found. If no translation
* was found, KLocale::defaultLanguage() is reported. If null,
* the language is not reported.
* @param trans raw translation, or original if not found. If no translation
* was found, original message is reported (either plural or
* singular, as determined by @p n ). If null, the
* translation is not reported.
*
* @see KLocalizedString
*/
void translateRawFrom(const char *catname, const char *ctxt, const char *singular, const char *plural,
unsigned long n, QString *lang, QString *trans) const;
/**
* Like translateRawFrom, with implicit lookup through all loaded catalogs.
*
* @deprecated Use translateRawFrom with null or empty catalog name.
*/
void translateRaw(const char *ctxt, const char *singular, const char *plural, unsigned long n,
QString *lang, QString *trans) const;
/**
* Changes the current encoding.
*
* @param mibEnum The mib of the preferred codec
*
* @return True on success.
*/
bool setEncoding(int mibEnum);
/**
* Various positions for where to place the positive or negative
* sign when they are related to a monetary value.
*/
enum SignPosition {
/**
* Put parantheses around the quantity, e.g. "$ (217)"
*/
ParensAround = 0,
/**
* Prefix the quantity with the sign, e.g. "$ -217"
*/
BeforeQuantityMoney = 1,
/**
* Suffix the quanitity with the sign, e.g. "$ 217-"
*/
AfterQuantityMoney = 2,
/**
* Prefix the currency symbol with the sign, e.g. "-$ 217"
*/
BeforeMoney = 3,
/**
* Suffix the currency symbol with the sign, e.g. "$- 217"
*/
AfterMoney = 4
};
/**
* @since 4.3
*
* The set of digit characters used to display and enter numbers.
*/
enum DigitSet {
ArabicDigits, /**< 0123456789 (European and some Asian
languages and western Arabic dialects) */
ArabicIndicDigits, /**< ٠١٢٣٤٥٦٧٨٩ (eastern Arabic dialects) */
EasternArabicIndicDigits, /**< ۰۱۲۳۴۵۶۷۸۹ (Persian and Urdu) */
DevenagariDigits, /**< ०१२३४५६७८९ (Hindi) */
BengaliDigits, /**< ০১২৩৪৫৬৭৮৯ (Bengali and Assamese) */
GujaratiDigits, /**< ૦૧૨૩૪૫૬૭૮૯ (Gujarati) */
GurmukhiDigits, /**< ੦੧੨੩੪੫੬੭੮੯ (Punjabi) */
KannadaDigits, /**< ೦೧೨೩೪೫೬೭೮೯ (Kannada) */
KhmerDigits, /**< ០១២៣៤៥៦៧៨៩ (Khmer) */
MalayalamDigits, /**< ൦൧൨൩൪൫൬൭൮൯ (Malayalam) */
OriyaDigits, /**< ୦୧୨୩୪୫୬୭୮୯ (Oriya) */
TamilDigits, /**< ௦௧௨௩௪௫௬௭௮ (Tamil) */
TeluguDigits, /**< ౦౧౨౩౪౫౬౭౯ (Telugu) */
ThaiDigits /**< ๐๑๒๓๔๕๖๗๘๙ (Thai) */
// The following Decimal Digit Sets are defined in Unicode but the associated
// languages are not yet translated in KDE, so are not yet enabled.
// The script names are taken from the Unicode standard, the associated
// languages from Wikipedia.
// BalineseDigits, /**< ᭐᭑᭒᭓᭔᭕᭖᭗᭘᭙ (Balinese) */
// ChamDigits, /**< ꩐꩑꩒꩓꩔꩕꩖꩗꩘꩙ (Cham) */
// JavaneseDigits, /**< ꧐꧑꧒꧓꧔꧕꧖꧗꧘꧙ (Javanese) */
// KayahLiDigits, /**< ꤀꤁꤂꤃꤄꤅꤆꤇꤈꤉ (Kayah) */
// LaoDigits, /**< ໐໑໒໓໔໕໖໗໘໙ (Lao) */
// LepchaDigits, /**< ᱀᱁᱂᱃᱄᱅᱆᱇᱈᱉ (Lepcha) */
// LimbuDigits, /**< ᥆᥇᥈᥉᥊᥋᥌᥍᥎᥏ (Limbu) */
// MeeteiMayekDigits, /**< ꯰꯱꯲꯳꯴꯵꯶꯷꯸꯹ (Meitei) */
// MongolianDigits, /**< ᠐᠑᠒᠓᠔᠕᠖᠗᠘᠙ (Mongolian) */
// MyanmarDigits, /**< ၀၁၂၃၄၅၆၇၈၉ (Myanmar/Burmese ) */
// MyanmarShanDigits, /**< ႐႑႒႓႔႕႖႗႘႙ (Shan) */
// NewTaiLueDigits, /**< ᧐᧑᧒᧓᧔᧕᧖᧗᧘᧙ (Tai Lü) */
// NKoDigits, /**< ߀߁߂߃߄߅߆߇߈߉ (Mande and N'Ko) */
// OlChikiDigits, /**< ᱐᱑᱒᱓᱔᱕᱖᱗᱘᱙ (Santali) */
// OsmanyaDigits, /**< ҠҡҢңҤҥҦҧҨҩ (Somali) */
// SaurashtraDigits, /**< ꣐꣑꣒꣓꣔꣕꣖꣗꣘꣙ (Saurashtra) */
// SundaneseDigits, /**< ᮰᮱᮲᮳᮴᮵᮶᮷᮸᮹ (Sundanese) */
// TaiThamDigits, /**< ᪐᪑᪒᪓᪔᪕᪖᪗᪘᪙ (Tai Lü) */
// TibetanDigits, /**< ༠༡༢༣༤༥༦༧༨༩ (Tibetan) */
// VaiDigits, /**< ꘠꘡꘢꘣꘤꘥꘦꘧꘨꘩ (Vai) */
};
/**
* @since 4.3
*
* Convert a digit set identifier to a human readable, localized name.
*
* @param digitSet the digit set identifier
* @param withDigits whether to add the digits themselves to the name
*
* @return the human readable and localized name of the digit set
*
* @see DigitSet
*/
QString digitSetToName(DigitSet digitSet, bool withDigits = false) const;
/**
* @since 4.3
*
* Provides list of all known digit set identifiers.
*
* @return list of all digit set identifiers
* @see DigitSet
* @see digitSetToName
*/
QList<DigitSet> allDigitSetsList() const;
/**
* Returns what a decimal point should look like ("." or "," etc.)
* according to the current locale or user settings.
*
* @return The decimal symbol used by locale.
*/
QString decimalSymbol() const;
/**
* Returns what the thousands separator should look
* like ("," or "." etc.)
* according to the current locale or user settings.
*
* @return The thousands separator used by locale.
*/
QString thousandsSeparator() const;
/**
* @since 4.3
*
* Returns the identifier of the digit set used to display numbers.
*
* @return the digit set identifier
* @see DigitSet
* @see digitSetToName
*/
DigitSet digitSet() const;
/**
* @since 4.4
*
* Returns the ISO 4217 Currency Code for the current locale
*
* @return The default ISO Currency Code used by locale.
*/
QString currencyCode() const;
/**
* @since 4.4
*
* Returns the Currency Code object for the current locale
*
* @return The default Currency Code object used by locale.
*/
KCurrencyCode *currency() const;
/**
* Returns what the symbol denoting currency in the current locale
* as as defined by user settings should look like.
*
* @return The default currency symbol used by locale.
*/
QString currencySymbol() const;
/**
* Returns what a decimal point should look like ("." or "," etc.)
* for monetary values, according to the current locale or user
* settings.
*
* @return The monetary decimal symbol used by locale.
*/
QString monetaryDecimalSymbol() const;
/**
* Returns what a thousands separator for monetary values should
* look like ("," or " " etc.) according to the current locale or
* user settings.
*
* @return The monetary thousands separator used by locale.
*/
QString monetaryThousandsSeparator() const;
/**
* Returns what a positive sign should look like ("+", " ", etc.)
* according to the current locale or user settings.
*
* @return The positive sign used by locale.
*/
QString positiveSign() const;
/**
* Returns what a negative sign should look like ("-", etc.)
* according to the current locale or user settings.
*
* @return The negative sign used by locale.
*/
QString negativeSign() const;
/**
* @deprecated use decimalPlaces() or monetaryDecimalPlaces()
*
* The number of fractional digits to include in monetary values (usually 2).
*
* @return Default number of fractional digits used by locale.
*/
KDE_DEPRECATED int fracDigits() const;
/**
* @since 4.4
*
* The number of decimal places to include in numeric values (usually 2).
*
* @return Default number of numeric decimal places used by locale.
*/
int decimalPlaces() const;
/**
* @since 4.4
*
* The number of decimal places to include in monetary values (usually 2).
*
* @return Default number of monetary decimal places used by locale.
*/
int monetaryDecimalPlaces() const;
/**
* If and only if the currency symbol precedes a positive value,
* this will be true.
*
* @return Where to print the currency symbol for positive numbers.
*/
bool positivePrefixCurrencySymbol() const;
/**
* If and only if the currency symbol precedes a negative value,
* this will be true.
*
* @return True if the currency symbol precedes negative numbers.
*/
bool negativePrefixCurrencySymbol() const;
/**
* Returns the position of a positive sign in relation to a
* monetary value.
*
* @return Where/how to print the positive sign.
* @see SignPosition
*/
SignPosition positiveMonetarySignPosition() const;
/**
* Denotes where to place a negative sign in relation to a
* monetary value.
*
* @return Where/how to print the negative sign.
* @see SignPosition
*/
SignPosition negativeMonetarySignPosition() const;
/**
* @since 4.3
*
* Retuns the digit set used to display monetary values.
*
* @return the digit set identifier
* @see DigitSet
* @see digitSetToName
*/
DigitSet monetaryDigitSet() const;
/**
* Given a double, converts that to a numeric string containing
* the localized monetary equivalent.
*
* e.g. given 123456, return "$ 123,456.00".
*
* If precision isn't specified or is < 0, then the default monetaryDecimalPlaces() is used.
*
* @param num The number we want to format
* @param currency The currency symbol you want.
* @param precision Number of decimal places displayed
*
* @return The number of money as a localized string
* @see monetaryDecimalPlaces()
*/
QString formatMoney(double num, const QString ¤cy = QString(), int precision = -1) const;
/**
* Given a double, converts that to a numeric string containing
* the localized numeric equivalent.
*
* e.g. given 123456.78F, return "123,456.78" (for some European country).
*
* If precision isn't specified or is < 0, then the default decimalPlaces() is used.
*
* This function is a wrapper that is provided for convenience.
*
* @param num The number to convert
* @param precision Number of decimal places used.
*
* @return The number as a localized string
* @see formatNumber(const QString, bool, int)
* @see decimalPlaces()
*/
QString formatNumber(double num, int precision = -1) const;
/**
* Given a string representing a number, converts that to a numeric
* string containing the localized numeric equivalent.
*
* e.g. given 123456.78F, return "123,456.78" (for some European country).
*
* If precision isn't specified or is < 0, then the default decimalPlaces() is used.
*
* @param numStr The number to format, as a string.
* @param round Round fractional digits. (default true)
* @param precision Number of fractional digits used for rounding. Unused if round=false.
*
* @return The number as a localized string
*/
QString formatNumber(const QString &numStr, bool round = true, int precision = -1) const;
/**
* Given an integer, converts that to a numeric string containing
* the localized numeric equivalent.
*
* e.g. given 123456L, return "123,456" (for some European country).
*
* @param num The number to convert
*
* @return The number as a localized string
*/
QString formatLong(long num) const;
/**
* These binary units are used in KDE by the formatByteSize()
* functions.
*
* NOTE: There are several different units standards:
* 1) SI (i.e. metric), powers-of-10.
* 2) IEC, powers-of-2, with specific units KiB, MiB, etc.
* 3) JEDEC, powers-of-2, used for solid state memory sizing which
* is why you see flash cards labels as e.g. 4GB. These (ab)use
* the metric units. Although JEDEC only defines KB, MB, GB, if
* JEDEC is selected all units will be powers-of-2 with metric
* prefixes for clarity in the event of sizes larger than 1024 GB.
*
* Although 3 different dialects are possible this enum only uses
* metric names since adding all 3 different names of essentially the same
* unit would be pointless. Use BinaryUnitDialect to control the exact
* units returned.
*
* @since 4.4
* @see binaryUnitDialect
*/
enum BinarySizeUnits {
/// Auto-choose a unit such that the result is in the range [0, 1000 or 1024)
DefaultBinaryUnits = -1,
// The first real unit must be 0 for the current implementation!
UnitByte, ///< B 1 byte
UnitKiloByte, ///< KiB/KB/kB 1024/1000 bytes.
UnitMegaByte, ///< MiB/MB/MB 2^20/10^06 bytes.
UnitGigaByte, ///< GiB/GB/GB 2^30/10^09 bytes.
UnitTeraByte, ///< TiB/TB/TB 2^40/10^12 bytes.
UnitPetaByte, ///< PiB/PB/PB 2^50/10^15 bytes.
UnitExaByte, ///< EiB/EB/EB 2^60/10^18 bytes.
UnitZettaByte, ///< ZiB/ZB/ZB 2^70/10^21 bytes.
UnitYottaByte, ///< YiB/YB/YB 2^80/10^24 bytes.
UnitLastUnit = UnitYottaByte
};
/**
* This enum chooses what dialect is used for binary units.
*
* Note: Although JEDEC abuses the metric prefixes and can therefore be
* confusing, it has been used to describe *memory* sizes for quite some time
* and programs should therefore use either Default, JEDEC, or IEC 60027-2
* for memory sizes.
*
* On the other hand network transmission rates are typically in metric so
* Default, Metric, or IEC (which is unambiguous) should be chosen.
*
* Normally choosing DefaultBinaryUnits is the best option as that uses
* the user's selection for units.
*
* @since 4.4
* @see binaryUnitDialect
* @see setBinaryUnitDialect
*/
enum BinaryUnitDialect {
DefaultBinaryDialect = -1, ///< Used if no specific preference
IECBinaryDialect, ///< KDE Default, KiB, MiB, etc. 2^(10*n)
JEDECBinaryDialect, ///< KDE 3.5 default, KB, MB, etc. 2^(10*n)
MetricBinaryDialect, ///< SI Units, kB, MB, etc. 10^(3*n)
LastBinaryDialect = MetricBinaryDialect
};
/**
* Converts @p size from bytes to the string representation using the
* user's default binary unit dialect. The default unit dialect is
* IEC 60027-2.
*
* Example:
* formatByteSize(1024) returns "1.0 KiB" by default.
*
* @param size size in bytes
* @return converted size as a string - e.g. 123.4 KiB , 12.0 MiB
* @see BinaryUnitDialect
* @todo KDE 5: Remove in favor of overload added in KDE 4.4.
*/
QString formatByteSize(double size) const;
/**
* @since 4.4
*
* Converts @p size from bytes to the appropriate string representation
* using the binary unit dialect @p dialect and the specific units @p specificUnit.
*
* Example:
* formatByteSize(1000, unit, KLocale::BinaryUnitKilo) returns:
* for KLocale::MetricBinaryUnits, "1.0 kB",
* for KLocale::IECBinaryUnits, "0.9 KiB",
* for KLocale::JEDECBinaryUnits, "0.9 KB".
*
* @param size size in bytes
* @param precision number of places after the decimal point to use. KDE uses
* 1 by default so when in doubt use 1.
* @param dialect binary unit standard to use. Use DefaultBinaryUnits to
* use the localized user selection unless you need to use a specific
* unit type (such as displaying a flash memory size in JEDEC).
* @param specificUnit specific unit size to use in result. Use
* DefaultBinarySize to automatically select a unit that will return
* a sanely-sized number.
* @return converted size as a translated string including the units.
* E.g. "1.23 KiB", "2 GB" (JEDEC), "4.2 kB" (Metric).
*/
QString formatByteSize(double size, int precision,
BinaryUnitDialect dialect = KLocale::DefaultBinaryDialect,
BinarySizeUnits specificUnit = KLocale::DefaultBinaryUnits) const;
/**
* Returns the user's default binary unit dialect.
*
* @since 4.4
* @return User's default binary unit dialect
* @see BinaryUnitDialect
*/
BinaryUnitDialect binaryUnitDialect() const;
/**
* Sets @p newDialect to be the default dialect for this locale (and only
* this locale). Newly created KLocale objects will continue to default
* to the user's choice.
*
* @param newDialect the new dialect to set as default for this locale object.
* @since 4.4
*/
void setBinaryUnitDialect(BinaryUnitDialect newDialect);
/**
* Given a number of milliseconds, converts that to a string containing
* the localized equivalent
*
* e.g. given formatDuration(60000), returns "1.0 minutes"
*
* @param mSec Time duration in milliseconds
* @return converted duration as a string - e.g. "5.5 seconds" "23.0 minutes"
*/
QString formatDuration(unsigned long mSec) const;
/**
* Given a number of milliseconds, converts that to a pretty string containing
* the localized equivalent.
*
* e.g. given prettyFormatDuration(60001) returns "1 minute"
* given prettyFormatDuration(62005) returns "1 minute and 2 seconds"
* given prettyFormatDuration(90060000) returns "1 day and 1 hour"
*
* @param mSec Time duration in milliseconds
* @return converted duration as a string.
* Units not interesting to the user, for example seconds or minutes when the first
* unit is day, are not returned because they are irrelevant. The same applies for
* seconds when the first unit is hour.
* @since 4.2
*/
QString prettyFormatDuration(unsigned long mSec) const;
/**
* @deprecated
*
* Use this to determine whether nouns are declined in
* locale's language. This property should remain
* read-only (no setter function)
*
* @return If nouns are declined
*/
KDE_DEPRECATED bool nounDeclension() const;
//KDE5 move to KDateTime namespace
/**
* @since 4.6
*
* Available Calendar Systems
*
* @see setCalendarSystem()
* @see calendarSystem()
*/
enum CalendarSystem {
QDateCalendar = 1, /**< KDE Default, hybrid of Gregorian and Julian as used by QDate */
//BahaiCalendar = 2, /**< Baha'i Calendar */
//BuddhistLunarCalendar = 3, /**< Buddhist Lunar Calendar*/
//ChineseCalendar = 4, /**< Chinese Calendar */
CopticCalendar = 5, /**< Coptic Calendar as used Coptic Church and some parts of Egypt */
EthiopianCalendar = 6, /**< Ethiopian Calendar, aka Ethiopic Calendar */
//EthiopianAmeteAlemCalendar = 7, /**< Ethiopian Amete Alem version, aka Ethiopic Amete Alem */
GregorianCalendar = 8, /**< Gregorian Calendar, pure proleptic implementation */
HebrewCalendar = 9, /**< Hebrew Calendar, aka Jewish Calendar */
//HinduCalendar = 10, /**< Hindu Lunar Calendar */
//IslamicLunarCalendar = 11, /**< Islamic Lunar Calendar */
IslamicCivilCalendar = 12, /**< Islamic Civil Calendar, aka Hijri, not the Lunar Calendar */
//IslamicUmAlQuraCalendar = 13, /**< Islamic Lunar Calendar, Um Al Qura varient used in Saudi Arabia */
IndianNationalCalendar = 14, /**< Indian National Calendar, not the Lunar Calendar */
//Iso8601Calendar = 15, /**< ISO 8601 Standard Calendar */
JalaliCalendar = 16, /**< Jalali Calendar, aka Persian or Iranian, also used in Afghanistan */
//JalaliBirashkCalendar = 17, /**< Jalali Calendar, Birashk Algorythm variant */
//Jalali33YearCalendar = 18, /**< Jalali Calendar, 33 Year cycle variant */
JapaneseCalendar= 19, /**< Japanese Calendar, Gregorian calculation using Japanese Era (Nengô) */
//JucheCalendar = 20, /**< Juche Calendar, used in North Korea */
JulianCalendar = 21, /**< Julian Calendar, as used in Orthodox Churches */
MinguoCalendar= 22, /**< Minguo Calendar, aka ROC, Republic of China or Taiwanese */
ThaiCalendar = 23 /**< Thai Calendar, aka Buddhist or Thai Buddhist */
};
//KDE5 move to KDateTime namespace
/**
* @since 4.6
*
* System used for Week Numbers
*
* @see setWeekNumberSystem()
* @see weekNumberSystem()
*/
enum WeekNumberSystem {
DefaultWeekNumber = -1, /**< The system locale default */
IsoWeekNumber = 0, /**< ISO Week Number */
FirstFullWeek = 1, /**< Week 1 starts on the first Week Start Day in year ends after 7 days */
FirstPartialWeek = 2, /**< Week 1 starts Jan 1st ends day before first Week Start Day in year */
SimpleWeek = 3 /**< Week 1 starts Jan 1st ends after 7 days */
};
//KDE5 move to KDateTime namespace
/**
* @since 4.4
*
* Standard used for Date Time Format String
*/
enum DateTimeFormatStandard {
KdeFormat, /**< KDE Standard */
PosixFormat, /**< POSIX Standard */
UnicodeFormat /**< UNICODE Standard (Qt/Java/OSX/Windows) */
};
//KDE5 move to KDateTime namespace
/**
* @since 4.6
*
* Mode to use when parsing a Date Time input string
*/
enum DateTimeParseMode {
LiberalParsing /**< Parse Date/Time liberally. So long as the
input string contains at least a reconizable
month and day the input will be accepted. */
//ModerateParsing, /**< Parse Date/Time with modeate tolerance.
// The date components in the format must all
// occur in the input and in the same order,
// but the spacing and the componants themselves
// may vary from the strict format. */
//StrictParsing /**< Parse Date/Time strictly to the format. */
};
//KDE5 move to KDateTime namespace
/**
* @since 4.6
*
* The various Components that make up a Date / Time
* In the future the Components may be combined as flags for dynamic
* generation of Date Formats.
*
* @see KCalendarSystem
* @see KLocalizedDate
* @see DateTimeComponentFormat
*/
enum DateTimeComponent {
Year = 0x1, /**< The Year portion of a date, may be number or name */
YearName = 0x2, /**< The Year Name portion of a date */
Month = 0x4, /**< The Month portion of a date, may be number or name */
MonthName = 0x8, /**< The Month Name portion of a date */
Day = 0x10, /**< The Day portion of a date, may be number or name */
DayName = 0x20, /**< The Day Name portion of a date */
JulianDay = 0x40, /**< The Julian Day of a date */
EraName = 0x80, /**< The Era Name portion of a date */
EraYear = 0x100, /**< The Era and Year portion of a date */
YearInEra = 0x200, /**< The Year In Era portion of a date */
DayOfYear = 0x400, /**< The Day Of Year portion of a date, may be number or name */
DayOfYearName = 0x800, /**< The Day Of Year Name portion of a date */
DayOfWeek = 0x1000, /**< The Day Of Week / Weekday portion of a date, may be number or name */
DayOfWeekName = 0x2000, /**< The Day Of Week Name / Weekday Name portion of a date */
Week = 0x4000, /**< The Week Number portion of a date */
WeekYear = 0x8000, /**< The Week Year portion of a date */
MonthsInYear = 0x10000, /**< The Months In Year portion of a date */
WeeksInYear = 0x20000, /**< The Weeks In Year portion of a date */
DaysInYear = 0x40000, /**< The Days In Year portion of a date */
DaysInMonth = 0x80000, /**< The Days In Month portion of a date */
DaysInWeek = 0x100000, /**< The Days In Week portion of a date */
Hour = 0x200000, /**< The Hours portion of a date */
Minute = 0x400000, /**< The Minutes portion of a date */
Second = 0x800000, /**< The Seconds portion of a date */
Millisecond = 0x1000000, /**< The Milliseconds portion of a date */
DayPeriod = 0x2000000, /**< The Day Period portion of a date, e.g. AM/PM */
DayPeriodHour = 0x4000000, /**< The Day Period Hour portion of a date */
Timezone = 0x8000000, /**< The Time Zone portion of a date, may be offset or name */
TimezoneName = 0x10000000, /**< The Time Zone Name portion of a date */
UnixTime = 0x20000000 /**< The UNIX Time portion of a date */
};
Q_DECLARE_FLAGS(DateTimeComponents, DateTimeComponent)
//KDE5 move to KDateTime namespace
/**
* @since 4.6
*
* Format used for individual Date/Time Components when converted to/from a string
* Largely equivalent to the UNICODE CLDR format width definitions 1..5
*
* @see DateTimeComponentFormat
*/
enum DateTimeComponentFormat {
DefaultComponentFormat = -1, /**< The system locale default for the componant */
ShortNumber = 0, /**< Number at its natural width, e.g. 2 for the 2nd*/
LongNumber, /**< Number padded to a required width, e.g. 02 for the 2nd*/
//OrdinalNumber /**< Ordinal number format, e.g. "2nd" for the 2nd */
NarrowName = 3, /**< Narrow text format, may not be unique, e.g. M for Monday */
ShortName, /**< Short text format, e.g. Mon for Monday */
LongName /**< Long text format, e.g. Monday for Monday */
};
//KDE5 move to KDateTime namespace
/**
* Format for date string.
*/
enum DateFormat {
ShortDate, /**< Locale Short date format, e.g. 08-04-2007 */
LongDate, /**< Locale Long date format, e.g. Sunday 08 April 2007 */
FancyShortDate, /**< Same as ShortDate for dates a week or more ago. For more
recent dates, it is represented as Today, Yesterday, or
the weekday name. */
FancyLongDate, /**< Same as LongDate for dates a week or more ago. For more
recent dates, it is represented as Today, Yesterday, or
the weekday name. */
IsoDate, /**< ISO-8601 Date format YYYY-MM-DD, e.g. 2009-12-31 */
IsoWeekDate, /**< ISO-8601 Week Date format YYYY-Www-D, e.g. 2009-W01-1 */
IsoOrdinalDate /**< ISO-8601 Ordinal Date format YYYY-DDD, e.g. 2009-001 */
};
//KDE5 move to KDateTime namespace
/**
* Returns a string formatted to the current locale's conventions
* regarding dates.
*
* @param date the date to be formatted
* @param format category of date format to use
*
* @return the date as a string
*/
QString formatDate(const QDate &date, DateFormat format = LongDate) const;
//KDE5 move to KDateTime namespace
/**
* Returns a string formatted to the current locale's conventions
* regarding both date and time.
*
* @param dateTime the date and time to be formatted
* @param format category of date format to use
* @param includeSecs if @c true, the string will include the seconds part
* of the time; otherwise, the seconds will be omitted
*
* @return the date and time as a string
*/
QString formatDateTime(const QDateTime &dateTime, DateFormat format = ShortDate,
bool includeSecs = false) const;
//KDE5 move to KDateTime namespace
/**
* Options for formatting date-time values.
*/
enum DateTimeFormatOption {
TimeZone = 0x01, /**< Include a time zone string */
Seconds = 0x02 /**< Include the seconds value */
};
Q_DECLARE_FLAGS(DateTimeFormatOptions, DateTimeFormatOption)
//KDE5 move to KDateTime namespace
/**
* Returns a string formatted to the current locale's conventions
* regarding both date and time.
*
* @param dateTime the date and time to be formatted
* @param format category of date format to use
* @param options additional output options
*
* @return The date and time as a string
*/
QString formatDateTime(const KDateTime &dateTime, DateFormat format = ShortDate,
DateTimeFormatOptions options = 0) const;
/**
* Use this to determine whether in dates a possessive form of month
* name is preferred ("of January" rather than "January")
*
* @return If possessive form should be used
*/
bool dateMonthNamePossessive() const;
/**
* @deprecated replaced by formatLocaleTime()
*
* Returns a string formatted to the current locale's conventions
* regarding times.
*
* @param pTime The time to be formatted.
* @param includeSecs if true, seconds are included in the output,
* otherwise only hours and minutes are formatted.
* @param isDuration if true, the given time is a duration, not a clock time.
* This means "am/pm" shouldn't be displayed.
*
* @return The time as a string
*/
QString formatTime(const QTime &pTime, bool includeSecs = false, bool isDuration = false) const;
//KDE5 move to KDateTime namespace
/**
* @since 4.4
*
* Format flags for readLocaleTime() and formatLocaleTime()
*/
enum TimeFormatOption {
TimeDefault = 0x0, ///< Default formatting using seconds and the format
///< as specified by the locale.
TimeWithoutSeconds = 0x1, ///< Exclude the seconds part of the time from display
TimeWithoutAmPm = 0x2, ///< Read/format time string without am/pm suffix but
///< keep the 12/24h format as specified by locale time
///< format, eg. "07.33.05" instead of "07.33.05 pm" for
///< time format "%I.%M.%S %p".
TimeDuration = 0x6, ///< Read/format time string as duration. This will strip
///< the am/pm suffix and read/format times with an hour
///< value of 0-23 hours, eg. "19.33.05" instead of
///< "07.33.05 pm" for time format "%I.%M.%S %p".
///< This automatically implies @c TimeWithoutAmPm.
TimeFoldHours = 0xE ///< Read/format time string as duration. This will not
///< not output the hours part of the duration but will
///< add the hours (times sixty) to the number of minutes,
///< eg. "70.23" instead of "01.10.23" for time format
///< "%I.%M.%S %p".
};
Q_DECLARE_FLAGS(TimeFormatOptions, TimeFormatOption)
//KDE5 move to KDateTime namespace
/**
* @since 4.4
*
* Returns a string formatted to the current locale's conventions
* regarding times.
*
* @param pTime the time to be formatted
* @param options format option to use when formatting the time
* @return The time as a string
*/
QString formatLocaleTime(const QTime &pTime,
TimeFormatOptions options = KLocale::TimeDefault) const;
/**
* @since 4.3
*
* Returns the identifier of the digit set used to display dates and time.
*
* @return the digit set identifier
* @see DigitSet
* @see digitSetToName
*/
DigitSet dateTimeDigitSet() const;
/**
* Use this to determine if the user wants a 12 hour clock.
*
* @return If the user wants 12h clock
*/
bool use12Clock() const;
/**
* @since 4.6
*
* Returns the Day Period matching the time given
*
* @param time the time to return the day period for
* @param format the format to return teh day period in
* @return the Day Period for the given time
*/
QString dayPeriodText(const QTime &time, DateTimeComponentFormat format = DefaultComponentFormat) const;
/**
* Use this to determine which day is the first day of the week.
*
* @return an integer (Monday=1..Sunday=7)
*/
int weekStartDay() const;
/**
* Use this to determine which day is the first working day of the week.
*
* @since 4.2
* @return an integer (Monday=1..Sunday=7)
*/
int workingWeekStartDay() const;
/**
* Use this to determine which day is the last working day of the week.
*
* @since 4.2
* @return an integer (Monday=1..Sunday=7)
*/
int workingWeekEndDay() const;
/**
* Use this to determine which day is reserved for religious observance
*
* @since 4.2
* @return day number (None = 0, Monday = 1, ..., Sunday = 7)
*/
int weekDayOfPray() const;
/**
* Returns a pointer to the calendar system object.
*
* @return the current calendar system instance
*/
const KCalendarSystem * calendar() const;
//KDE5 remove
/**
* @deprecated use calendarSystem() instead
*
* Returns the name of the calendar system that is currently being
* used by the system.
*
* @see calendarSystem()
* @return the name of the calendar system
*/
KDE_DEPRECATED QString calendarType() const;
/**
* @since 4.6
*
* Returns the type of Calendar System used in this Locale
*
* @see KLocale::CalendarSystem
* @see KCalendarSystem
* @return the type of Calendar System
*/
KLocale::CalendarSystem calendarSystem() const;
//KDE5 remove
/**
* @deprecated use setCalendarSystem() instead
*
* Changes the current calendar system to the calendar specified.
* If the calendar system specified is not found, gregorian will be used.
*
* @see setCalendarSystem()
* @param calendarType the name of the calendar type
*/
KDE_DEPRECATED void setCalendar(const QString & calendarType);
/**
* @since 4.6
*
* Sets the type of Calendar System to use in this Locale
*
* @see KLocale::CalendarSystem
* @see KCalendarSystem
* @param calendarSystem the Calendar System to use
*/
void setCalendarSystem(KLocale::CalendarSystem calendarSystem);
/**
* @since 4.6
*
* Sets the type of Week Number System to use in this Locale
*
* @see Klocale::WeekNumberSystem
* @see weekNumberSystem()
* @param weekNumberSystem the Week Number System to use
*/
void setWeekNumberSystem(KLocale::WeekNumberSystem weekNumberSystem);
//KDE5 remove in favour of const version
/**
* @since 4.6
*
* Returns the type of Week Number System used in this Locale
*
* @see Klocale::WeekNumberSystem
* @see setWeekNumberSystem()
* @returns the Week Number System used
*/
KLocale::WeekNumberSystem weekNumberSystem();
/**
* @since 4.7
*
* Returns the type of Week Number System used in this Locale
*
* @see Klocale::WeekNumberSystem
* @see setWeekNumberSystem()
* @returns the Week Number System used
*/
KLocale::WeekNumberSystem weekNumberSystem() const;
/**
* Converts a localized monetary string to a double.
*
* @param numStr the string we want to convert.
* @param ok the boolean that is set to false if it's not a number.
* If @p ok is 0, it will be ignored
*
* @return The string converted to a double
*/
double readMoney(const QString &numStr, bool * ok = 0) const;
/**
* Converts a localized numeric string to a double.
*
* @param numStr the string we want to convert.
* @param ok the boolean that is set to false if it's not a number.
* If @p ok is 0, it will be ignored
*
* @return The string converted to a double
*/
double readNumber(const QString &numStr, bool * ok = 0) const;
//KDE5 move to KDateTime namespace
/**
* Converts a localized date string to a QDate. This method will try all
* ReadDateFlag formats in preferred order to read a valid date.
*
* The bool pointed by ok will be invalid if the date entered was not valid.
*
* @param str the string we want to convert.
* @param ok the boolean that is set to false if it's not a valid date.
* If @p ok is 0, it will be ignored
*
* @return The string converted to a QDate
* @see KCalendarSystem::readDate()
*/
QDate readDate(const QString &str, bool* ok = 0) const;
//KDE5 move to KDateTime namespace
/**
* Converts a localized date string to a QDate, using the specified format.
* You will usually not want to use this method.
* @see KCalendarSystem::readDate()
*/
QDate readDate(const QString &intstr, const QString &fmt, bool* ok = 0) const;
//KDE5 move to KDateTime namespace
/**
* Flags for readDate()
*/
enum ReadDateFlags {
NormalFormat = 1, /**< Only accept a date string in
the locale LongDate format */
ShortFormat = 2, /**< Only accept a date string in
the locale ShortDate format */
IsoFormat = 4, /**< Only accept a date string in
ISO date format (YYYY-MM-DD) */
IsoWeekFormat = 8, /**< Only accept a date string in
ISO Week date format (YYYY-Www-D) */
IsoOrdinalFormat = 16 /**< Only accept a date string in
ISO Week date format (YYYY-DDD) */
};
//KDE5 move to KDateTime namespace
/**
* Converts a localized date string to a QDate.
* This method is stricter than readDate(str,&ok): it will only accept
* a date in a specific format, depending on @p flags.
*
* @param str the string we want to convert.
* @param flags what format the the date string will be in
* @param ok the boolean that is set to false if it's not a valid date.
* If @p ok is 0, it will be ignored
*
* @return The string converted to a QDate
* @see KCalendarSystem::readDate()
*/
QDate readDate(const QString &str, ReadDateFlags flags, bool *ok = 0) const;
/**
* Converts a localized time string to a QTime.
* This method will try to parse it with seconds, then without seconds.
* The bool pointed to by @p ok will be set to false if the time entered was
* not valid.
*
* @param str the string we want to convert.
* @param ok the boolean that is set to false if it's not a valid time.
* If @p ok is 0, it will be ignored
*
* @return The string converted to a QTime
*/
QTime readTime(const QString &str, bool* ok = 0) const;
/**
* Flags for the old version of readTime()
*
* @deprecated replaced by TimeFormatOptions
*/
enum ReadTimeFlags {
WithSeconds = 0, ///< Only accept a time string with seconds. Default (no flag set)
WithoutSeconds = 1 ///< Only accept a time string without seconds.
}; // (maybe use this enum as a bitfield, if adding independent features?)
/**
* @deprecated replaced readLocaleTime()
*
* Converts a localized time string to a QTime.
* This method is stricter than readTime(str,&ok): it will either accept
* a time with seconds or a time without seconds.
* Use this method when the format is known by the application.
*
* @param str the string we want to convert.
* @param flags whether the time string is expected to contain seconds or not.
* @param ok the boolean that is set to false if it's not a valid time.
* If @p ok is 0, it will be ignored
*
* @return The string converted to a QTime
*/
QTime readTime(const QString &str, ReadTimeFlags flags, bool *ok = 0) const;
/**
* Additional processing options for readLocaleTime().
*
* @remarks This is currently used as an enum but declared as a flag
* to be extensible
*/
enum TimeProcessingOption {
ProcessStrict = 0x1, ///< Process time in a strict manner, ie.
///< a read time string has to exactly match
///< the defined time format.
ProcessNonStrict = 0x2 ///< Process time in a lax manner, ie.
///< allow spaces in the time-format to be
///< left out when entering a time string.
};
Q_DECLARE_FLAGS(TimeProcessingOptions, TimeProcessingOption)
/**
* @since 4.4
*
* Converts a localized time string to a QTime.
* This method is stricter than readTime(str, &ok) in that it will either
* accept a time with seconds or a time without seconds.
*
* @param str the string we want to convert
* @param ok the boolean that is set to false if it's not a valid time.
* If @p ok is 0, it will be ignored.
* @param options format option to apply when formatting the time
* @param processing if set to @c ProcessStrict, checking will be strict
* and the read time string has to have the exact time format
* specified. If set to @c ProcessNonStrict processing the time
* is lax and spaces in the time string can be left out.
*
* @return The string converted to a QTime
*/
QTime readLocaleTime(const QString &str, bool *ok = 0,
TimeFormatOptions options = KLocale::TimeDefault,
TimeProcessingOptions processing = ProcessNonStrict) const;
/**
* Returns the language code used by this object. The domain AND the
* library translation must be available in this language.
* defaultLanguage() is returned by default, if no other available.
*
* Use languageCodeToName(language) to get human readable, localized
* language name.
*
* @return the currently used language code
*
* @see languageCodeToName
*/
QString language() const;
/**
* Returns the country code of the country where the user lives.
*
* The returned code complies with the ISO 3166-1 alpha-2 standard,
* except by KDE convention it is returned in lowercase whereas the
* official standard is uppercase.
* See http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2 for details.
*
* defaultCountry() is returned by default, if no other available,
* this will always be uppercase 'C'.
*
* Use countryCodeToName(country) to get human readable, localized
* country names.
*
* @return the country code for the user
*
* @see countryCodeToName
*/
QString country() const;
/**
* @since 4.6
*
* Returns the Country Division Code of the Country where the user lives.
* When no value is set, then the Country Code will be returned.
*
* The returned code complies with the ISO 3166-2 standard.
* See http://en.wikipedia.org/wiki/ISO_3166-2 for details.
*
* Note that unlike country() this method will return the correct case,
* i.e. normally uppercase..
*
* In KDE 4.6 it is the apps responsibility to obtain a translation for the
* code, translation and other services will be priovided in KDE 4.7.
*
* @return the Country Division Code for the user
* @see setCountryDivisionCode
*/
QString countryDivisionCode() const;
/**
* Returns the language codes selected by user, ordered by decreasing
* priority.
*
* Use languageCodeToName(language) to get human readable, localized
* language name.
*
* @return list of language codes
*
* @see languageCodeToName
*/
QStringList languageList() const;
/**
* @since 4.4
*
* Returns the ISO Currency Codes used in the locale, ordered by decreasing
* priority.
*
* Use KCurrency::currencyCodeToName(currencyCode) to get human readable,
* localized language name.
*
* @return list of ISO Currency Codes
*
* @see currencyCodeToName
*/
QStringList currencyCodeList() const;
/**
* Returns the user's preferred encoding.
*
* @return The name of the preferred encoding
*
* @see codecForEncoding
* @see encodingMib
*/
const QByteArray encoding() const;
/**
* Returns the user's preferred encoding.
*
* @return The Mib of the preferred encoding
*
* @see encoding
* @see codecForEncoding
*/
int encodingMib() const;
/**
* Returns the user's preferred encoding. Should never be NULL.
*
* @return The codec for the preferred encoding
*
* @see encoding
* @see encodingMib
*/
QTextCodec * codecForEncoding() const;
/**
* Returns the file encoding.
*
* @return The Mib of the file encoding
*
* @see QFile::encodeName
* @see QFile::decodeName
*/
int fileEncodingMib() const;
/**
* Changes the current date format.
*
* The format of the date is a string which contains variables that will
* be replaced:
* @li %Y with the whole year (e.g. "2004" for "2004")
* @li %y with the lower 2 digits of the year (e.g. "04" for "2004")
* @li %n with the month (January="1", December="12")
* @li %m with the month with two digits (January="01", December="12")
* @li %e with the day of the month (e.g. "1" on the first of march)
* @li %d with the day of the month with two digits (e.g. "01" on the first of march)
* @li %b with the short form of the month (e.g. "Jan" for January)
* @li %B with the long form of the month (e.g. "January")
* @li %a with the short form of the weekday (e.g. "Wed" for Wednesday)
* @li %A with the long form of the weekday (e.g. "Wednesday" for Wednesday)
*
* Everything else in the format string will be taken as is.
* For example, March 20th 1989 with the format "%y:%m:%d" results
* in "89:03:20".
*
* @param format The new date format
*/
void setDateFormat(const QString & format);
/**
* Changes the current short date format.
*
* The format of the date is a string which contains variables that will
* be replaced:
* @li %Y with the whole year (e.g. "1984" for "1984")
* @li %y with the lower 2 digits of the year (e.g. "84" for "1984")
* @li %n with the month (January="1", December="12")
* @li %m with the month with two digits (January="01", December="12")
* @li %e with the day of the month (e.g. "1" on the first of march)
* @li %d with the day of the month with two digits(e.g. "01" on the first of march)
* @li %b with the short form of the month (e.g. "Jan" for January)
* @li %B with the long form of the month (e.g. "January")
* @li %a with the short form of the weekday (e.g. "Wed" for Wednesday)
* @li %A with the long form of the weekday (e.g. "Wednesday" for Wednesday)
*
* Everything else in the format string will be taken as is.
* For example, March 20th 1989 with the format "%y:%m:%d" results
* in "89:03:20".
*
* @param format The new short date format
*/
void setDateFormatShort(const QString & format);
/**
* Changes the form of month name used in dates.
*
* @param possessive True if possessive forms should be used
*/
void setDateMonthNamePossessive(bool possessive);
/**
* Changes the current time format.
*
* The format of the time is string a which contains variables that will
* be replaced:
* @li %H with the hour in 24h format and 2 digits (e.g. 5pm is "17", 5am is "05")
* @li %k with the hour in 24h format and one digits (e.g. 5pm is "17", 5am is "5")
* @li %I with the hour in 12h format and 2 digits (e.g. 5pm is "05", 5am is "05")
* @li %l with the hour in 12h format and one digits (e.g. 5pm is "5", 5am is "5")
* @li %M with the minute with 2 digits (e.g. the minute of 07:02:09 is "02")
* @li %S with the seconds with 2 digits (e.g. the minute of 07:02:09 is "09")
* @li %p with pm or am (e.g. 17.00 is "pm", 05.00 is "am")
*
* Everything else in the format string will be taken as is.
* For example, 5.23pm with the format "%H:%M" results
* in "17:23".
*
* @param format The new time format
*/
void setTimeFormat(const QString & format);
/**
* @since 4.3
*
* Set digit characters used to display dates and time.
*
* @param digitSet the digit set identifier
* @see DigitSet
*/
void setDateTimeDigitSet(DigitSet digitSet);
/**
* Changes how KLocale defines the first day in week.
*
* @param day first day of the week (Monday=1..Sunday=7) as integer
*/
void setWeekStartDay(int day);
/**
* Changes how KLocale defines the first working day in week.
*
* @since 4.2
* @param day first working day of the week (Monday=1..Sunday=7) as integer
*/
void setWorkingWeekStartDay(int day);
/**
* Changes how KLocale defines the last working day in week.
*
* @since 4.2
* @param day last working day of the week (Monday=1..Sunday=7) as integer
*/
void setWorkingWeekEndDay(int day);
/**
* Changes how KLocale defines the day reserved for religious observance.
*
* @since 4.2
* @param day day of the week for religious observance (None=0,Monday=1..Sunday=7) as integer
*/
void setWeekDayOfPray(int day);
/**
* Returns the currently selected date format.
*
* @return Current date format.
* @see setDateFormat()
*/
QString dateFormat() const;
/**
* Returns the currently selected short date format.
*
* @return Current short date format.
* @see setDateFormatShort()
*/
QString dateFormatShort() const;
/**
* Returns the currently selected time format.
*
* @return Current time format.
* @see setTimeFormat()
*/
QString timeFormat() const;
/**
* Changes the symbol used to identify the decimal pointer.
*
* @param symbol The new decimal symbol.
*/
void setDecimalSymbol(const QString & symbol);
/**
* Changes the separator used to group digits when formating numbers.
*
* @param separator The new thousands separator.
*/
void setThousandsSeparator(const QString & separator);
/**
* Changes the sign used to identify a positive number. Normally this is
* left blank.
*
* @param sign Sign used for positive numbers.
*/
void setPositiveSign(const QString & sign);
/**
* Changes the sign used to identify a negative number.
*
* @param sign Sign used for negative numbers.
*/
void setNegativeSign(const QString & sign);
/**
* @since 4.3
*
* Changes the set of digit characters used to display numbers.
*
* @param digitSet the digit set identifier
* @see DigitSet
*/
void setDigitSet(DigitSet digitSet);
/**
* Changes the sign position used for positive monetary values.
*
* @param signpos The new sign position
*/
void setPositiveMonetarySignPosition(SignPosition signpos);
/**
* Changes the sign position used for negative monetary values.
*
* @param signpos The new sign position
*/
void setNegativeMonetarySignPosition(SignPosition signpos);
/**
* Changes the position where the currency symbol should be printed for
* positive monetary values.
*
* @param prefix True if the currency symbol should be prefixed instead of
* postfixed
*/
void setPositivePrefixCurrencySymbol(bool prefix);
/**
* Changes the position where the currency symbol should be printed for
* negative monetary values.
*
* @param prefix True if the currency symbol should be prefixed instead of
* postfixed
*/
void setNegativePrefixCurrencySymbol(bool prefix);
/**
* @deprecated use setDecimalPlaces() or setMonetaryDecimalPlaces()
*
* Changes the number of digits used when formating numbers.
*
* @param digits The default number of digits to use.
*/
KDE_DEPRECATED void setFracDigits(int digits);
/**
* @since 4.4
*
* Changes the number of decimal places used when formating numbers.
*
* @param digits The default number of digits to use.
*/
void setDecimalPlaces(int digits);
/**
* @since 4.4
*
* Changes the number of decimal places used when formating money.
*
* @param digits The default number of digits to use.
*/
void setMonetaryDecimalPlaces(int digits);
/**
* Changes the separator used to group digits when formating monetary values.
*
* @param separator The new thousands separator.
*/
void setMonetaryThousandsSeparator(const QString & separator);
/**
* Changes the symbol used to identify the decimal pointer for monetary
* values.
*
* @param symbol The new decimal symbol.
*/
void setMonetaryDecimalSymbol(const QString & symbol);
/**
* @since 4.4
*
* Changes the current ISO Currency Code.
*
* @param newCurrencyCode The new Currency Code
*/
void setCurrencyCode(const QString &newCurrencyCode);
/**
* Changes the current currency symbol.
*
* This symbol should be consistant with the selected Currency Code
*
* @param symbol The new currency symbol
* @see currencyCode, KCurrency::currencySymbols
*/
void setCurrencySymbol(const QString & symbol);
/**
* @since 4.3
*
* Set digit characters used to display monetary values.
*
* @param digitSet the digit set identifier
* @see DigitSet
*/
void setMonetaryDigitSet(DigitSet digitSet);
/**
* Returns the preferred page size for printing.
*
* @return The preferred page size, cast it to QPrinter::PageSize
*/
int pageSize() const;
/**
* Changes the preferred page size when printing.
*
* @param paperFormat the new preferred page size in the format QPrinter::PageSize
*/
void setPageSize(int paperFormat);
/**
* The Metric system will give you information in mm, while the
* Imperial system will give you information in inches.
*/
enum MeasureSystem {
Metric, ///< Metric system (used e.g. in Europe)
Imperial ///< Imperial system (used e.g. in the United States)
};
/**
* Returns which measuring system we use.
*
* @return The preferred measuring system
*/
MeasureSystem measureSystem() const;
/**
* Changes the preferred measuring system.
*
* @return value The preferred measuring system
*/
void setMeasureSystem(MeasureSystem value);
/**
* Adds another catalog to search for translation lookup.
* This function is useful for extern libraries and/or code,
* that provide their own messages.
*
* If the catalog does not exist for the chosen language,
* it will be ignored and en_US will be used.
*
* @param catalog The catalog to add.
*/
void insertCatalog(const QString& catalog);
/**
* Removes a catalog for translation lookup.
* @param catalog The catalog to remove.
* @see insertCatalog()
*/
void removeCatalog(const QString &catalog);
/**
* Sets the active catalog for translation lookup.
* @param catalog The catalog to activate.
*/
void setActiveCatalog(const QString &catalog);
/**
* Translates a message as a QTranslator is supposed to.
* The parameters are similar to i18n(), but the result
* value has other semantics (it can be QString())
*/
QString translateQt(const char *context, const char *sourceText, const char *comment) const;
/**
* Provides list of all known language codes.
*
* Use languageCodeToName(language) to get human readable, localized
* language names.
*
* @return list of all language codes
*
* @see languageCodeToName
* @see installedLanguages
*/
QStringList allLanguagesList() const;
/**
* @since 4.6
*
* Provides list of all installed KDE Language Translations.
*
* Use languageCodeToName(language) to get human readable, localized
* language names.
*
* @return list of all installed language codes
*
* @see languageCodeToName
*/
QStringList installedLanguages() const;
/**
* Convert a known language code to a human readable, localized form.
* If an unknown language code is supplied, empty string is returned;
* this will never happen if the code has been obtained by one of the
* KLocale methods.
*
* @param language the language code
*
* @return the human readable and localized form if the code is known,
* empty otherwise
*
* @see language
* @see languageList
* @see allLanguagesList
* @see installedLanguages
*/
QString languageCodeToName(const QString &language) const;
/**
* Provides list of all known country codes.
*
* Use countryCodeToName(country) to get human readable, localized
* country names.
*
* @return a list of all country codes
*
* @see countryCodeToName
*/
QStringList allCountriesList() const;
/**
* Convert a known country code to a human readable, localized form.
*
* If an unknown country code is supplied, empty string is returned;
* this will never happen if the code has been obtained by one of the
* KLocale methods.
*
* @param country the country code
*
* @return the human readable and localized form of the country name
*
* @see country
* @see allCountriesList
*/
QString countryCodeToName(const QString &country) const;
/**
* Parses locale string into distinct parts.
* The format of locale is language_COUNTRY@modifier.CHARSET
*
* @param locale the locale string to split
* @param language set to the language part of the locale
* @param country set to the country part of the locale
* @param modifier set to the modifer part of the locale
* @param charset set to the charset part of the locale
*/
static void splitLocale(const QString &locale, QString &language, QString &country,
QString &modifier, QString &charset);
/**
* Use this as main catalog for *all* KLocales, if not the appname
* will be used. This function is best to be the very first instruction
* in your program's main function as it only has an effect before the
* first KLocale object is created.
*
* @param catalog Catalog to override all other main Catalogs.
*/
static void setMainCatalog(const char *catalog);
/**
* @deprecated
*
* Finds localized resource in resourceDir( rtype ) + \<lang> + fname.
*
* Since KDE 4.1, this service is provided in a slightly different form,
* automatically by e.g. KStandardDirs::locate() and other KDE core classes
* dealing with paths. For manual use, it is replaced by localizedFilePath().
*
* @param fname relative path to find
* @param rtype resource type to use
*
* @return path to localized resource
*
* @see localizedFilePath
*/
static QString langLookup(const QString &fname, const char *rtype = "html");
/**
* Returns the name of the internal language.
*
* @return Name of the default language
*/
static QString defaultLanguage();
/**
* Returns the code of the default country, i.e. "C"
*
* This function will not provide a sensible value to use in your app,
* please use country() instead.
*
* @see country
*
* @return Name of the default country
*/
static QString defaultCountry();
/**
* @since 4.4
*
* Returns the ISO Code of the default currency.
*
* @return ISO Currency Code of the default currency
*/
static QString defaultCurrencyCode();
/**
* Reports whether evaluation of translation scripts is enabled.
*
* @return true if script evaluation is enabled, false otherwise.
*/
bool useTranscript() const;
/**
* Checks whether or not the active catalog is found for the given language.
*
* @param language language to check
*/
bool isApplicationTranslatedInto(const QString & language);
/**
* Copies the catalogs of this object to an other KLocale object.
*
* @param locale the destination KLocale object
*/
void copyCatalogsTo(KLocale *locale);
/**
* Changes the current country. The current country will be left
* unchanged if failed. It will force a reload of the country specific
* configuration.
*
* An empty country value will set the country to the system default.
*
* If you specify a configuration file, a setLocale() will be performed on
* the config using the current locale language, which may cause a sync()
* and reparseConfiguration() which will save any changes you have made.
*
* @param country the ISO 3166 country code
* @param config a configuration file with a Locale group detailing
* locale-related preferences (such as language and
* formatting options).
*
* @return @c true on success, @c false on failure
*/
bool setCountry(const QString & country, KConfig *config);
/**
* @since 4.6
*
* Sets the Country Division Code of the Country where the user lives.
*
* The code must comply with the ISO 3166-2 standard.
* See http://en.wikipedia.org/wiki/ISO_3166-2 for details.
*
* In KDE 4.6 it is the apps responsibility to validate the input,
* full validation and other services will be provided in KDE 4.7.
*
* @param countryDivision the Country Division Code for the user
* @return @c true on success, @c false on failure
* @see countryDivisionCode
*/
bool setCountryDivisionCode(const QString & countryDivision);
/**
* Changes the current language. The current language will be left
* unchanged if failed. It will force a reload of the country specific
* configuration as well.
*
* If you specify a configuration file, a setLocale() will be performed on
* the config using the current locale language, which may cause a sync()
* and reparseConfiguration() which will save any changes you have made.
*
* @param language the language code
* @param config a configuration file with a Locale group detailing
* locale-related preferences (such as language and
* formatting options).
*
* @return true on success
*/
bool setLanguage(const QString &language, KConfig *config);
/**
* Changes the list of preferred languages for the locale. The first valid
* language in the list will be used, or the default language (en_US)
* if none of the specified languages were available.
*
* @param languages the list of language codes
*
* @return true if one of the specified languages were used
*/
bool setLanguage(const QStringList &languages);
/**
* @since 4.1
*
* Tries to find a path to the localized file for the given original path.
* This is intended mainly for non-text resources (images, sounds, etc.),
* whereas text resources should be handled in more specific ways.
*
* The possible localized paths are checked in turn by priority of set
* languages, in form of dirname/l10n/ll/basename, where dirname and
* basename are those of the original path, and ll is the language code.
*
* KDE core classes which resolve paths internally (e.g. KStandardDirs)
* will usually perform this lookup behind the scene.
* In general, you should pipe resource paths through this method only
* on explicit translators' request, or when a resource is an obvious
* candidate for localization (e.g. a splash screen or a custom icon
* with some text drawn on it).
*
* @param filePath path to the original file
*
* @return path to the localized file if found, original path otherwise
*/
QString localizedFilePath(const QString &filePath) const;
/**
* @since 4.2
*
* Removes accelerator marker from a UI text label.
*
* Accelerator marker is not always a plain ampersand (&),
* so it is not enough to just remove it by @c QString::remove().
* The label may contain escaped markers ("&&") which must be resolved
* and skipped, as well as CJK-style markers ("Foo (&F)") where
* the whole parenthesis construct should be removed.
* Therefore always use this function to remove accelerator marker
* from UI labels.
*
* @param label UI label which may contain an accelerator marker
* @return label without the accelerator marker
*/
QString removeAcceleratorMarker(const QString &label) const;
/**
* @since 4.3
*
* Convert all digits in the string to the given digit set.
*
* Conversion is normally not performed if the given digit set
* is not appropriate in the current locale and language context.
* Unconditional conversion may be requested by setting
* @p ignoreContext to @c true.
*
* @param str the string to convert
* @param digitSet the digit set identifier
* @param ignoreContext unconditional conversion if @c true
*
* @return string with converted digits
*
* @see DigitSet
*/
QString convertDigits(const QString &str, DigitSet digitSet,
bool ignoreContext = false) const;
+ /**
+ * @since 4.8
+ *
+ * Reparse locale configuration files for the current selected
+ * language.
+ */
+ void reparseConfiguration();
+
private:
friend class KLocalePrivate;
friend class KLocaleTest;
friend class KDateTimeFormatter;
KLocalePrivate * const d;
};
Q_DECLARE_OPERATORS_FOR_FLAGS(KLocale::DateTimeFormatOptions)
Q_DECLARE_OPERATORS_FOR_FLAGS(KLocale::DateTimeComponents)
Q_DECLARE_OPERATORS_FOR_FLAGS(KLocale::TimeFormatOptions)
Q_DECLARE_OPERATORS_FOR_FLAGS(KLocale::TimeProcessingOptions)
#endif
diff --git a/kdecore/localization/klocale_p.h b/kdecore/localization/klocale_p.h
index 4ed8e3f4fb..af4a768904 100644
--- a/kdecore/localization/klocale_p.h
+++ b/kdecore/localization/klocale_p.h
@@ -1,1230 +1,1230 @@
/* This file is part of the KDE libraries
* Copyright 2009 David Faure <faure@kde.org>
* Copyright 2010 John Layt <john@layt.net>
*
* 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.
*/
#ifndef KLOCALE_P_H
#define KLOCALE_P_H
#include "klocale.h"
class QMutex;
class KCatalog;
class KDayPeriod;
// Used by both KLocale and KLocalizedString, since they call each other.
QMutex* kLocaleMutex();
class KLocalePrivate
{
public:
/**
* Constructors
*
* This class should not be instantited directly, it is intended as a base class for each
* platform to provide a common KDE fallback implementation. Instead use the relevant
* derived system class for Unix, Win, or Mac which will prefer the local platform settings
* where possible.
*/
KLocalePrivate(KLocale *q_ptr);
/**
* Copy constructor
*/
KLocalePrivate(const KLocalePrivate &rhs);
/**
* Assignment operator
*/
KLocalePrivate &operator=(const KLocalePrivate &rhs);
/**
* Destructor
*/
virtual ~KLocalePrivate();
/**************************
** Initialization **
**************************/
+ /**
+ * Reads the format configuration from disk.
+ */
+ virtual void initFormat();
+
protected:
/**
* @internal Returns config object
*/
KConfig *config();
/**
* @internal Copies object members
*/
virtual void copy(const KLocalePrivate &rhs);
- /**
- * @internal Reads the format configuration from disk.
- */
- virtual void initFormat();
-
/**
* @internal Main init function, needs to be called by appropriate child constructor.
*/
virtual void init(const QString& catalogName, const QString &language, const QString &country,
KSharedConfig::Ptr persistantconfig, KConfig *tempConfig);
/**
* @internal Init config.
*/
virtual void initConfig(KConfig *config);
/**************************
** Country settings **
**************************/
protected:
/**
* @internal Initializes the country if not already explicitly set when calling the constructor
* Will default to any value set in the config, otherwise will attempt to use the host system
* country, or finally fall back to the default C.
*/
virtual void initCountry(const QString &country, const QString &configCountry);
/**
* @internal Returns the host system country ISO code
* If country could not be determined then may return an empty string or "C"
*/
virtual QString systemCountry() const;
public:
/**
* @internal Sets the Locale Country
* The worker of the same-name KLocale API function.
*/
virtual bool setCountry(const QString &country, KConfig *config);
/**
* @internal Returns the Locale ISO Country Code
* The worker of the same-name KLocale API function.
*/
virtual QString country() const;
/**
* @internal Returns the name of the default country.
* The worker of the same-name KLocale API function.
*/
static QString defaultCountry();
/**
* @internal Returns a list of all known country codes.
* The worker of the same-name KLocale API function.
*/
virtual QStringList allCountriesList() const;
/**
* @internal Convert a known country code to a human readable, localized form.
* The worker of the same-name KLocale API function.
*/
virtual QString countryCodeToName(const QString &country) const;
/**
* @internal Sets the Country Division Code
* The worker of the same-name KLocale API function.
*/
bool setCountryDivisionCode(const QString & countryDivision);
/**
* @internal Returns the Country Division Code
* The worker of the same-name KLocale API function.
*/
QString countryDivisionCode() const;
/**************************
** Language settings **
**************************/
protected:
/**
* @internal Converts a language variable in a list of languages
*/
static void getLanguagesFromVariable(QStringList &list, const char *variable, bool isLanguageList = false);
/**
* @internal Returns the list of host system languages
*/
virtual QStringList systemLanguageList() const;
/**
* @internal Initializes the list of valid languages from the user's point of view. This is the
* list of languages that the user picks in kcontrol. The config object should be valid and
* contain the global entries.
*
* @param language The defualt language to use
* @param configLanguages The "Language" setting from the current config
* @param useEnv Whether to use the envvars
*/
virtual void initLanguageList(const QString &language, const QString &configLanguages, bool useEnv);
/**
* @internal function used to determine if we are using the en_US translation
*/
virtual bool useDefaultLanguage() const;
public:
/**
* @internal Sets the Locale Language
* The worker of the same-name KLocale API function.
*/
virtual bool setLanguage(const QString &language, KConfig *config);
/**
* @internal Sets the list of preferred languages for the locale.
* The worker of the same-name KLocale API function.
*/
virtual bool setLanguage(const QStringList &languages);
/**
* @internal Returns the Locale Language
* The worker of the same-name KLocale API function.
*/
virtual QString language() const;
/**
* @internal Returns the language codes selected by user
* The worker of the same-name KLocale API function.
*/
virtual QStringList languageList() const;
/**
* @internal Returns a list of all known language codes.
* The worker of the same-name KLocale API function.
*/
virtual QStringList allLanguagesList();
/**
* @internal Returns a list of all installed KDE languages.
* The worker of the same-name KLocale API function.
*/
virtual QStringList installedLanguages();
/**
* @internal Returns the name of the internal language.
* The worker of the same-name KLocale API function.
*/
static QString defaultLanguage();
/**
* @internal Convert a known language code to a human readable, localized form.
* The worker of the same-name KLocale API function.
*/
virtual QString languageCodeToName(const QString &language);
/**
* @deprecated
* @internal Returns if nouns are declined in the locale language.
* The worker of the same-name KLocale API function.
*/
virtual bool nounDeclension() const;
/**
* @deprecated
* @internal Finds localized resource in resourceDir( rtype ) + \<lang> + fname.
* The worker of the same-name KLocale API function.
*/
static QString langLookup(const QString &fname, const char *rtype = "html");
/**
* @internal Returns whether evaluation of translation scripts is enabled.
* The worker of the same-name KLocale API function.
*/
virtual bool useTranscript() const;
/**************************
** Catalog settings **
**************************/
protected:
/**
* @internal Initializes the catalogs appname, kdelibs and kio for all chosen languages.
*/
virtual void initMainCatalogs();
/**
* @internal evaluate the list of catalogs and check that all instances for all languages are
* loaded and that they are sorted according to the catalog names
*
* Callers must lock the mutex first.
*/
virtual void updateCatalogs();
public:
/**
* @internal Set the main catalog for *all* KLocales
* The worker of the same-name KLocale API function.
*/
static void setMainCatalog(const char *catalog);
/**
* Sets the active catalog for translation lookup.
* @param catalog The catalog to activate.
*/
virtual void setActiveCatalog(const QString &catalog);
/**
* @internal Adds another catalog to search for translation lookup.
* The worker of the same-name KLocale API function.
*/
virtual void insertCatalog(const QString &catalog);
/**
* @internal Removes a catalog for translation lookup.
* The worker of the same-name KLocale API function.
*/
virtual void removeCatalog(const QString &catalog);
/**
* @internal Copies the catalogs of this object to an other KLocale object.
* The worker of the same-name KLocale API function.
*/
virtual void copyCatalogsTo(KLocale *locale);
/**
* @internal Function used by the translate versions
* The worker of the same-name KLocale API function.
*/
virtual void translateRawFrom(const char *catname, const char *msgctxt, const char *msgid, const char *msgid_plural = 0,
unsigned long n = 0, QString *language = 0, QString *translation = 0) const;
/**
* @internal Translates a message as a QTranslator is supposed to.
* The worker of the same-name KLocale API function.
*/
virtual QString translateQt(const char *context, const char *sourceText, const char *comment) const;
/**
* @internal Checks whether or not the active catalog is found for the given language.
* The worker of the same-name KLocale API function.
*/
virtual bool isApplicationTranslatedInto(const QString &language);
/***************************
** Calendar settings **
***************************/
protected:
/**
* @internal Converts a CalendarType into a CalendarSystem
*/
virtual KLocale::CalendarSystem calendarTypeToCalendarSystem(const QString &calendarType) const;
/**
* @internal Converts a CalendarSystem into a CalendarType
*/
virtual QString calendarSystemToCalendarType(KLocale::CalendarSystem) const;
public:
/**
* @internal Sets the current calendar system to the calendar specified.
* The worker of the same-name KLocale API function.
*/
virtual void setCalendar(const QString &calendarType);
/**
* @internal Sets the current calendar system to the calendar specified.
* The worker of the same-name KLocale API function.
*/
virtual void setCalendarSystem(KLocale::CalendarSystem);
/**
* @internal Returns the name of the calendar system that is currently being used by the system.
* The worker of the same-name KLocale API function.
*/
virtual QString calendarType() const;
/**
* @internal Returns the type of the calendar system that is currently being used by the system.
* The worker of the same-name KLocale API function.
*/
KLocale::CalendarSystem calendarSystem() const;
/**
* @internal Returns a pointer to the calendar system object.
* The worker of the same-name KLocale API function.
*/
virtual const KCalendarSystem *calendar();
/**
* @internal Sets the Week Number System to use
* The worker of the same-name KLocale API function.
*/
void setWeekNumberSystem(KLocale::WeekNumberSystem weekNumberSystem);
/**
* @internal Returns the Week Number System used
* The worker of the same-name KLocale API function.
*/
KLocale::WeekNumberSystem weekNumberSystem();
/**
* @internal Changes how KLocale defines the first day in week.
* The worker of the same-name KLocale API function.
*/
virtual void setWeekStartDay(int day);
/**
* @internal Returns which day is the first day of the week.
* The worker of the same-name KLocale API function.
*/
virtual int weekStartDay() const;
/**
* @internal Changes how KLocale defines the first working day in week.
* The worker of the same-name KLocale API function.
*/
virtual void setWorkingWeekStartDay(int day);
/**
* @internal Returns which day is the first working day of the week.
* The worker of the same-name KLocale API function.
*/
virtual int workingWeekStartDay() const;
/**
* @internal Changes how KLocale defines the last working day in week.
* The worker of the same-name KLocale API function.
*/
virtual void setWorkingWeekEndDay(int day);
/**
* @internal Returns which day is the last working day of the week.
* The worker of the same-name KLocale API function.
*/
virtual int workingWeekEndDay() const;
/**
* @internal Changes how KLocale defines the day reserved for religious observance.
* The worker of the same-name KLocale API function.
*/
virtual void setWeekDayOfPray(int day);
/**
* @internal Returns which day is reserved for religious observance
* The worker of the same-name KLocale API function.
*/
virtual int weekDayOfPray() const;
/***************************
** Date/Time settings **
***************************/
protected:
/**
* @internal initialises the Day Periods
*/
virtual void initDayPeriods(const KConfigGroup &cg);
public:
/**
* @internal Sets the current date format.
* The worker of the same-name KLocale API function.
*/
virtual void setDateFormat(const QString &format);
/**
* @internal Returns the currently selected date format.
* The worker of the same-name KLocale API function.
*/
virtual QString dateFormat() const;
/**
* @internal Sets the current short date format.
* The worker of the same-name KLocale API function.
*/
virtual void setDateFormatShort(const QString &format);
/**
* @internal Returns the currently selected short date format.
* The worker of the same-name KLocale API function.
*/
virtual QString dateFormatShort() const;
/**
* @internal Changes the current time format.
* The worker of the same-name KLocale API function.
*/
virtual void setTimeFormat(const QString &format);
/**
* @internal Returns the currently selected time format.
* The worker of the same-name KLocale API function.
*/
virtual QString timeFormat() const;
/**
* @internal Set digit characters used to display dates and time.
* The worker of the same-name KLocale API function.
*/
virtual void setDateTimeDigitSet(KLocale::DigitSet digitSet);
/**
* @internal Returns the identifier of the digit set used to display dates and time.
* The worker of the same-name KLocale API function.
*/
virtual KLocale::DigitSet dateTimeDigitSet() const;
/**
* @internal Sets of the possessive form of month name should be used in dates.
* The worker of the same-name KLocale API function.
*/
virtual void setDateMonthNamePossessive(bool possessive);
/**
* @internal Returns if possessive form of month name should be used
* The worker of the same-name KLocale API function.
*/
virtual bool dateMonthNamePossessive() const;
/**
* @internal Returns if the user wants 12h clock
* The worker of the same-name KLocale API function.
*/
virtual bool use12Clock() const;
/**
* @internal
* The worker of the same-name KLocale API function.
*/
virtual void setDayPeriods(const QList<KDayPeriod> &dayPeriods);
/**
* @internal
* The worker of the same-name KLocale API function.
*/
virtual QList<KDayPeriod> dayPeriods() const;
/**
* @internal
* The worker of the same-name KLocale API function.
*/
virtual KDayPeriod dayPeriodForTime(const QTime &time) const;
/**
* @internal Returns a string formatted to the current locale's conventions
* The worker of the same-name KLocale API function.
*/
virtual QString formatDate(const QDate &date, KLocale::DateFormat format = KLocale::LongDate);
/**
* @internal Converts a localized date string to a QDate.
* The worker of the same-name KLocale API function.
*/
virtual QDate readDate(const QString &str, bool *ok = 0);
/**
* @internal Converts a localized date string to a QDate, using the specified format.
* The worker of the same-name KLocale API function.
*/
virtual QDate readDate(const QString &intstr, const QString &fmt, bool *ok = 0);
/**
* @internal Converts a localized date string to a QDate.
* The worker of the same-name KLocale API function.
*/
virtual QDate readDate(const QString &str, KLocale::ReadDateFlags flags, bool *ok = 0);
/**
* @deprecated replaced by formatLocaleTime()
* @internal Returns a string formatted to the current locale's conventions regarding times.
* The worker of the same-name KLocale API function.
*/
virtual QString formatTime(const QTime &pTime, bool includeSecs = false, bool isDuration = false) const;
/**
* @internal Returns a string formatted to the current locale's conventions regarding times.
* The worker of the same-name KLocale API function.
*/
virtual QString formatLocaleTime(const QTime &pTime, KLocale::TimeFormatOptions options = KLocale::TimeDefault) const;
/**
* @internal Converts a localized time string to a QTime.
* The worker of the same-name KLocale API function.
*/
virtual QTime readTime(const QString &str, bool *ok = 0) const;
/**
* @deprecated replaced by readLocaleTime()
* @internal Converts a localized time string to a QTime.
* The worker of the same-name KLocale API function.
*/
virtual QTime readTime(const QString &str, KLocale::ReadTimeFlags flags, bool *ok = 0) const;
/**
* @internal Converts a localized time string to a QTime.
* The worker of the same-name KLocale API function.
*/
virtual QTime readLocaleTime(const QString &str, bool *ok = 0,
KLocale::TimeFormatOptions options = KLocale::TimeDefault,
KLocale::TimeProcessingOptions processing = KLocale::ProcessNonStrict) const;
/**
* @internal Formats a date/time according to specified format.
* The worker of the same-name KLocale API function.
*/
static QString formatDateTime(const KLocale *locale, const QDateTime &dateTime, KLocale::DateFormat,
bool includeSeconds, int daysToNow, int secsToNow);
/**
* @internal Return the date and time as a string
* The worker of the same-name KLocale API function.
*/
virtual QString formatDateTime(const QDateTime &dateTime, KLocale::DateFormat format = KLocale::ShortDate,
bool includeSecs = false) const;
/**
* @internal Return the date and time as a string
* The worker of the same-name KLocale API function.
*/
virtual QString formatDateTime(const KDateTime &dateTime, KLocale::DateFormat format = KLocale::ShortDate,
KLocale::DateTimeFormatOptions options = 0);
/**
* @internal Returns converted duration as a string
* The worker of the same-name KLocale API function.
*/
virtual QString formatDuration(unsigned long mSec) const;
/**
* @internal Returns converted duration as a string.
* The worker of the same-name KLocale API function.
*/
virtual QString prettyFormatDuration(unsigned long mSec) const;
/***************************
** Digit Set settings **
***************************/
protected:
/**
* @internal Converts a number string in any digit set into Arabic digits
*/
static QString toArabicDigits(const QString &str);
/**
* @internal Returns the digits for a digit set as a string, e.g. "0123456789"
*/
static QString digitSetString(KLocale::DigitSet digitSet);
public:
/**
* @internal Provides list of all known digit set identifiers.
* The worker of the same-name KLocale API function.
*/
virtual QList<KLocale::DigitSet> allDigitSetsList() const;
/**
* @internal Convert a digit set identifier to a human readable, localized name.
* The worker of the same-name KLocale API function.
*/
virtual QString digitSetToName(KLocale::DigitSet digitSet, bool withDigits = false) const;
/**
* @internal Convert all digits in the string to the given digit set.
* The worker of the same-name KLocale API function.
*/
virtual QString convertDigits(const QString &str, KLocale::DigitSet digitSet, bool ignoreContext = false) const;
/***************************
** Number settings **
***************************/
public:
/**
* @internal Sets the number of decimal places used when formating numbers.
* The worker of the same-name KLocale API function.
*/
virtual void setDecimalPlaces(int digits);
/**
* @internal Returns the number of numeric decimal places used by locale.
* The worker of the same-name KLocale API function.
*/
virtual int decimalPlaces() const;
/**
* @internal Sets the symbol used to identify the decimal pointer.
* The worker of the same-name KLocale API function.
*/
virtual void setDecimalSymbol(const QString &symbol);
/**
* @internal Returns the decimal symbol used by locale.
* The worker of the same-name KLocale API function.
*/
virtual QString decimalSymbol() const;
/**
* @internal Sets the separator used to group digits when formating numbers.
* The worker of the same-name KLocale API function.
* KDE5 Rename to setNumericDigitGroupSeparator()
*/
virtual void setThousandsSeparator(const QString &separator);
/**
* @internal Returns the digit group separator used by locale.
* The worker of the same-name KLocale API function.
* KDE5 Rename to numericDigitGroupSeparator()
*/
virtual QString thousandsSeparator() const;
/**
* @internal Sets the digit grouping to apply to numbers
* For now internal only api designed for processing efficiency, if needed publicly then may
* need to review if this is the best way.
*/
virtual void setNumericDigitGrouping(QList<int> groupList);
/**
* @internal Returns the digit grouping to apply to numbers
* For now internal only api designed for processing efficiency, if needed publicly then may
* need to review if this is the best way.
*/
virtual QList<int> numericDigitGrouping() const;
/**
* @internal Sets the sign used to identify a positive number.
* The worker of the same-name KLocale API function.
*/
virtual void setPositiveSign(const QString &sign);
/**
* @internal Returns the positive sign used by locale.
* The worker of the same-name KLocale API function.
*/
virtual QString positiveSign() const;
/**
* @internal Sets the sign used to identify a negative number.
* The worker of the same-name KLocale API function.
*/
virtual void setNegativeSign(const QString &sign);
/**
* @internal Returns the negative sign used by locale.
* The worker of the same-name KLocale API function.
*/
virtual QString negativeSign() const;
/**
* @internal Sets the set of digit characters used to display numbers.
* The worker of the same-name KLocale API function.
*/
virtual void setDigitSet(KLocale::DigitSet digitSet);
/**
* @internal Returns the identifier of the digit set used to display numbers.
* The worker of the same-name KLocale API function.
*/
virtual KLocale::DigitSet digitSet() const;
/**
* @internal Returns a number as a localized string
* The worker of the same-name KLocale API function.
*/
virtual QString formatNumber(double num, int precision = -1) const;
/**
* @internal Returns a number as a localized string
* The worker of the same-name KLocale API function.
*/
virtual QString formatNumber(const QString &numStr, bool round = true, int precision = -1) const;
/**
* @internal Returns a number as a localized string
* The worker of the same-name KLocale API function.
*/
virtual QString formatLong(long num) const;
/**
* @internal Converts a localized numeric string to a double.
* The worker of the same-name KLocale API function.
*/
virtual double readNumber(const QString &numStr, bool *ok = 0) const;
/**************************
** Currency settings **
**************************/
protected:
/**
* @internal Initialises the Currency
*/
virtual void initCurrency();
public:
/**
* @internal Sets the Locale Currency Code
* The worker of the same-name KLocale API function.
*/
virtual void setCurrencyCode(const QString &newCurrencyCode);
/**
* @internal Returns the Locale ISO Currency Code
* The worker of the same-name KLocale API function.
*/
virtual QString currencyCode() const;
/**
* @internal Returns the Locale Currency object
* The worker of the same-name KLocale API function.
*/
virtual KCurrencyCode *currency();
/**
* @internal Returns the ISO Code of the default currency.
* The worker of the same-name KLocale API function.
*/
static QString defaultCurrencyCode();
/**
* @internal Returns the ISO Currency Codes used in the locale
* The worker of the same-name KLocale API function.
*/
virtual QStringList currencyCodeList() const;
/***************************
** Money settings **
***************************/
public:
/**
* @internal Sets the current currency symbol.
* The worker of the same-name KLocale API function.
*/
virtual void setCurrencySymbol(const QString &symbol);
/**
* @internal Returns the default currency symbol used by locale.
* The worker of the same-name KLocale API function.
*/
virtual QString currencySymbol() const;
/**
* @internal Sets the symbol used to identify the decimal pointer for monetary values.
* The worker of the same-name KLocale API function.
*/
virtual void setMonetaryDecimalSymbol(const QString &symbol);
/**
* @internal Returns the monetary decimal symbol used by locale.
* The worker of the same-name KLocale API function.
*/
virtual QString monetaryDecimalSymbol() const;
/**
* @internal Sets the separator used to group digits when formating monetary values.
* The worker of the same-name KLocale API function.
* KDE5 Rename to setMonetaryDigitGroupSeparator()
*/
virtual void setMonetaryThousandsSeparator(const QString &separator);
/**
* @internal Returns the monetary thousands separator used by locale.
* The worker of the same-name KLocale API function.
* KDE5 Rename to monetaryDigitGroupSeparator()
*/
virtual QString monetaryThousandsSeparator() const;
/**
* @internal Sets the digit grouping to apply to numbers
* For now internal only api designed for processing efficiency, if needed publicly then may
* need to review if this is the best way.
*/
virtual void setMonetaryDigitGrouping(QList<int> groupList);
/**
* @internal Returns the digit grouping to apply to numbers
* For now internal only api designed for processing efficiency, if needed publicly then may
* need to review if this is the best way.
*/
virtual QList<int> monetaryDigitGrouping() const;
/**
* @internal Sets the number of decimal places used when formating money.
* The worker of the same-name KLocale API function.
*/
virtual void setMonetaryDecimalPlaces(int digits);
/**
* @internal Returns the number of monetary decimal places used by locale.
* The worker of the same-name KLocale API function.
*/
virtual int monetaryDecimalPlaces() const;
/**
* @internal Sets the position where the currency symbol should be printed for
* positive monetary values.
* The worker of the same-name KLocale API function.
*/
virtual void setPositivePrefixCurrencySymbol(bool prefix);
/**
* @internal Returns where to print the currency symbol for positive numbers.
* The worker of the same-name KLocale API function.
*/
virtual bool positivePrefixCurrencySymbol() const;
/**
* @internal Sets the position where the currency symbol should be printed for
* negative monetary values.
* The worker of the same-name KLocale API function.
*/
virtual void setNegativePrefixCurrencySymbol(bool prefix);
/**
* @internal Returns if the currency symbol precedes negative numbers.
* The worker of the same-name KLocale API function.
*/
virtual bool negativePrefixCurrencySymbol() const;
/**
* @internal Sets the sign position used for positive monetary values.
* The worker of the same-name KLocale API function.
*/
virtual void setPositiveMonetarySignPosition(KLocale::SignPosition signpos);
/**
* @internal Returns where/how to print the positive sign.
* The worker of the same-name KLocale API function.
*/
virtual KLocale::SignPosition positiveMonetarySignPosition() const;
/**
* @internal Sets the sign position used for negative monetary values.
* The worker of the same-name KLocale API function.
*/
virtual void setNegativeMonetarySignPosition(KLocale::SignPosition signpos);
/**
* @internal Returns where/how to print the negative sign.
* The worker of the same-name KLocale API function.
*/
virtual KLocale::SignPosition negativeMonetarySignPosition() const;
/**
* @internal Set digit characters used to display monetary values.
* The worker of the same-name KLocale API function.
*/
virtual void setMonetaryDigitSet(KLocale::DigitSet digitSet);
/**
* @internal Retuns the digit set used to display monetary values.
* The worker of the same-name KLocale API function.
*/
virtual KLocale::DigitSet monetaryDigitSet() const;
/**
* @internal Returns an amount of money as a localized string
* The worker of the same-name KLocale API function.
*/
virtual QString formatMoney(double num, const QString ¤cy = QString(), int precision = -1) const;
/**
* @internal Converts a localized monetary string to a double.
* The worker of the same-name KLocale API function.
*/
virtual double readMoney(const QString &numStr, bool *ok = 0) const;
/***************************
** Units settings **
***************************/
protected:
/**
* @internal
* @return list of translated binary unit for @p dialect.
*/
QList<QString> dialectUnitsList(KLocale::BinaryUnitDialect dialect);
enum DurationType {
DaysDurationType = 0,
HoursDurationType,
MinutesDurationType,
SecondsDurationType
};
/**
* @internal Formats a duration according to the given type and number
*/
static QString formatSingleDuration(KLocalePrivate::DurationType durationType, int n);
public:
/**
* @internal Returns the user's default binary unit dialect.
* The worker of the same-name KLocale API function.
*/
virtual KLocale::BinaryUnitDialect binaryUnitDialect() const;
/**
* @internal Sets the default dialect for this locale
* The worker of the same-name KLocale API function.
*/
virtual void setBinaryUnitDialect(KLocale::BinaryUnitDialect newDialect);
/**
* @internal Returns converted size as a string
* The worker of the same-name KLocale API function.
*/
virtual QString formatByteSize(double size);
/**
* @internal Returns converted size as a translated string including the units.
* The worker of the same-name KLocale API function.
*/
virtual QString formatByteSize(double size, int precision,
KLocale::BinaryUnitDialect dialect = KLocale::DefaultBinaryDialect,
KLocale:: BinarySizeUnits specificUnit = KLocale::DefaultBinaryUnits);
/**
* @internal Sets the preferred page size when printing.
* The worker of the same-name KLocale API function.
*/
virtual void setPageSize(int paperFormat);
/**
* @internal Returns the preferred page size for printing.
* The worker of the same-name KLocale API function.
*/
virtual int pageSize() const;
/**
* @internal Sets the preferred measuring system.
* The worker of the same-name KLocale API function.
*/
virtual void setMeasureSystem(KLocale::MeasureSystem value);
/**
* @internal Returns which measuring system we use.
* The worker of the same-name KLocale API function.
*/
virtual KLocale::MeasureSystem measureSystem() const;
/***************************
** Encoding settings **
***************************/
protected:
/**
* @internal Figures out which encoding the user prefers.
*/
virtual void initEncoding();
/**
* @internal Figures out which encoding the user prefers for filenames
* and sets up the appropriate QFile encoding and decoding functions.
*/
virtual void initFileNameEncoding();
/**
* @internal Returns the system codeset.
*/
virtual QByteArray systemCodeset() const;
/**
* @internal A QFile filename encoding function (QFile::encodeFn).
*/
static QByteArray encodeFileNameUTF8(const QString &fileName);
/**
* @internal QFile filename decoding function (QFile::decodeFn).
*/
static QString decodeFileNameUTF8(const QByteArray &localFileName);
public:
/**
* @internal Sets the current encoding
* The worker of the same-name KLocale API function.
*/
virtual bool setEncoding(int mibEnum);
/**
* @internal Returns the user's preferred encoding.
* The worker of the same-name KLocale API function.
*/
virtual const QByteArray encoding();
/**
* @internal Returns the user's preferred encoding.
* The worker of the same-name KLocale API function.
*/
virtual int encodingMib() const;
/**
* @internal Returns the file encoding.
* The worker of the same-name KLocale API function.
*/
virtual int fileEncodingMib() const;
/**
* @internal Returns the user's preferred encoding.
* The worker of the same-name KLocale API function.
*/
virtual QTextCodec *codecForEncoding() const;
/***************************
** Utilities **
***************************/
public:
/**
* @internal Parses locale string into distinct parts.
* The worker of the same-name KLocale API function.
*/
static void splitLocale(const QString &locale, QString &language, QString &country,
QString &modifier, QString &charset);
/**
* @internal Tries to find a path to the localized file for the given original path.
* The worker of the same-name KLocale API function.
*/
virtual QString localizedFilePath(const QString &filePath) const;
/**
* @internal Removes accelerator marker from a UI text label.
* The worker of the same-name KLocale API function.
*/
virtual QString removeAcceleratorMarker(const QString &label) const;
private:
/**
* @internal COnvert digit group format string to digit group list
*/
QList<int> digitGroupFormatToList(const QString &digitGroupFormat) const;
/**
* @internal Insert digit group separator
*/
QString formatDigitGroup(const QString &number, const QString &groupSeparator, const QString &decimalSeperator, QList<int> groupList) const;
/**
* @internal Remove digit group separator, return ok if valid format
*/
QString parseDigitGroup(const QString &number, const QString &groupSeparator, const QString &decimalSeperator, QList<int> groupList, bool *ok) const;
public:
// Parent KLocale, public needed for copy ctor
KLocale *q;
private:
// Config file containing locale config
KSharedConfig::Ptr m_config;
// Country settings
QString m_country;
QString m_countryDivisionCode;
// Language settings
QString m_language;
KConfig *m_languages;
QStringList m_languageList;
bool m_languageSensitiveDigits; // FIXME: Temporary until full language-sensitivity implemented.
bool m_nounDeclension;
// Catalog settings
QString m_catalogName; // catalogName ("app name") used by this KLocale object
QList<KCatalogName> m_catalogNames; // list of all catalogs (regardless of language)
QList<KCatalog> m_catalogs; // list of all found catalogs, one instance per catalog name and language
int m_numberOfSysCatalogs; // number of catalogs that each app draws from
bool m_useTranscript; // indicates if scripted messages are to be executed
// Calendar settings
KLocale::CalendarSystem m_calendarSystem;
KCalendarSystem *m_calendar;
KLocale::WeekNumberSystem m_weekNumberSystem;
int m_weekStartDay;
int m_workingWeekStartDay;
int m_workingWeekEndDay;
int m_weekDayOfPray;
// Date/Time settings
QString m_dateFormat;
QString m_dateFormatShort;
QString m_timeFormat;
KLocale::DigitSet m_dateTimeDigitSet;
bool m_dateMonthNamePossessive;
mutable QList<KDayPeriod> m_dayPeriods;
// Number settings
int m_decimalPlaces;
QString m_decimalSymbol;
QString m_thousandsSeparator;
QList<int> m_numericDigitGrouping;
QString m_positiveSign;
QString m_negativeSign;
KLocale::DigitSet m_digitSet;
// Currency settings
QString m_currencyCode;
KCurrencyCode *m_currency;
QStringList m_currencyCodeList;
// Money settings
QString m_currencySymbol;
QString m_monetaryDecimalSymbol;
QString m_monetaryThousandsSeparator;
QList<int> m_monetaryDigitGrouping;
int m_monetaryDecimalPlaces;
KLocale::SignPosition m_positiveMonetarySignPosition;
KLocale::SignPosition m_negativeMonetarySignPosition;
bool m_positivePrefixCurrencySymbol;
bool m_negativePrefixCurrencySymbol;
KLocale::DigitSet m_monetaryDigitSet;
// Units settings
KLocale::BinaryUnitDialect m_binaryUnitDialect;
QList<QString> m_byteSizeFmt;
int m_pageSize;
KLocale::MeasureSystem m_measureSystem;
// Encoding settings
QString m_encoding;
QTextCodec *m_codecForEncoding;
bool m_utf8FileEncoding;
};
#endif /* KLOCALE_P_H */
diff --git a/kdeui/kernel/kglobalsettings.cpp b/kdeui/kernel/kglobalsettings.cpp
index 819b3149fa..6f26582b5c 100644
--- a/kdeui/kernel/kglobalsettings.cpp
+++ b/kdeui/kernel/kglobalsettings.cpp
@@ -1,1154 +1,1158 @@
/* This file is part of the KDE libraries
Copyright (C) 2000, 2006 David Faure <faure@kde.org>
Copyright 2008 Friedrich W. H. Kossebau <kossebau@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 version 2 as published by the Free Software Foundation.
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 "kglobalsettings.h"
#include <config.h>
#include <kconfig.h>
#include <kdebug.h>
#include <kglobal.h>
+#include <klocale.h>
#include <kstandarddirs.h>
#include <kprotocolinfo.h>
#include <kcolorscheme.h>
#include <kstyle.h>
#include <QtGui/QColor>
#include <QtGui/QCursor>
#include <QtGui/QDesktopWidget>
#include <QtCore/QDir>
#include <QtGui/QFont>
#include <QtGui/QFontDatabase>
#include <QtGui/QFontInfo>
#include <QtGui/QKeySequence>
#include <QtGui/QPixmap>
#include <QtGui/QPixmapCache>
#include <QApplication>
#include <QtDBus/QtDBus>
#include <QtGui/QStyleFactory>
#include <QDesktopServices>
#include "qplatformdefs.h"
// next two needed so we can set their palettes
#include <QtGui/QToolTip>
#include <QtGui/QWhatsThis>
#ifdef Q_WS_WIN
#include <windows.h>
#include <kkernel_win.h>
static QRgb qt_colorref2qrgb(COLORREF col)
{
return qRgb(GetRValue(col),GetGValue(col),GetBValue(col));
}
#endif
#ifdef Q_WS_X11
#include <X11/Xlib.h>
#ifdef HAVE_XCURSOR
#include <X11/Xcursor/Xcursor.h>
#endif
#include "fixx11h.h"
#include <QX11Info>
#endif
#include <stdlib.h>
#include <kconfiggroup.h>
//static QColor *_buttonBackground = 0;
static KGlobalSettings::GraphicEffects _graphicEffects = KGlobalSettings::NoEffects;
// TODO: merge this with KGlobalSettings::Private
//
// F. Kossebau: KDE5: think to make all methods static and not expose an object,
// making KGlobalSettings rather a namespace
// D. Faure: how would people connect to signals, then?
class KGlobalSettingsData
{
public:
// if adding a new type here also add an entry to DefaultFontData
enum FontTypes
{
GeneralFont = 0,
FixedFont,
ToolbarFont,
MenuFont,
WindowTitleFont,
TaskbarFont ,
SmallestReadableFont,
FontTypesCount
};
public:
KGlobalSettingsData();
~KGlobalSettingsData();
public:
static KGlobalSettingsData* self();
public: // access, is not const due to caching
QFont font( FontTypes fontType );
QFont largeFont( const QString& text );
KGlobalSettings::KMouseSettings& mouseSettings();
public:
void dropFontSettingsCache();
void dropMouseSettingsCache();
protected:
QFont* mFonts[FontTypesCount];
QFont* mLargeFont;
KGlobalSettings::KMouseSettings* mMouseSettings;
};
KGlobalSettingsData::KGlobalSettingsData()
: mLargeFont( 0 ),
mMouseSettings( 0 )
{
for( int i=0; i<FontTypesCount; ++i )
mFonts[i] = 0;
}
KGlobalSettingsData::~KGlobalSettingsData()
{
for( int i=0; i<FontTypesCount; ++i )
delete mFonts[i];
delete mLargeFont;
delete mMouseSettings;
}
K_GLOBAL_STATIC( KGlobalSettingsData, globalSettingsDataSingleton )
inline KGlobalSettingsData* KGlobalSettingsData::self()
{
return globalSettingsDataSingleton;
}
class KGlobalSettings::Private
{
public:
Private(KGlobalSettings *q)
: q(q), activated(false), paletteCreated(false)
{
kdeFullSession = !qgetenv("KDE_FULL_SESSION").isEmpty();
}
QPalette createApplicationPalette(const KSharedConfigPtr &config);
QPalette createNewApplicationPalette(const KSharedConfigPtr &config);
void _k_slotNotifyChange(int, int);
void propagateQtSettings();
void kdisplaySetPalette();
void kdisplaySetStyle();
void kdisplaySetFont();
void applyGUIStyle();
/**
* @internal
*
* Ensures that cursors are loaded from the theme KDE is configured
* to use. Note that calling this function doesn't cause existing
* cursors to be reloaded. Reloading already created cursors is
* handled by the KCM when a cursor theme is applied.
*
* It is not necessary to call this function when KGlobalSettings
* is initialized.
*/
void applyCursorTheme();
/**
* drop cached values for settings that aren't in any of the previous groups
*/
static void rereadOtherSettings();
KGlobalSettings *q;
bool activated;
bool paletteCreated;
bool kdeFullSession;
QPalette applicationPalette;
};
KGlobalSettings* KGlobalSettings::self()
{
K_GLOBAL_STATIC(KGlobalSettings, s_self)
return s_self;
}
KGlobalSettings::KGlobalSettings()
: QObject(0), d(new Private(this))
{
}
KGlobalSettings::~KGlobalSettings()
{
delete d;
}
void KGlobalSettings::activate()
{
activate(ApplySettings | ListenForChanges);
}
void KGlobalSettings::activate(ActivateOptions options)
{
if (!d->activated) {
d->activated = true;
if (options & ListenForChanges) {
QDBusConnection::sessionBus().connect( QString(), "/KGlobalSettings", "org.kde.KGlobalSettings",
"notifyChange", this, SLOT(_k_slotNotifyChange(int,int)) );
}
if (options & ApplySettings) {
d->kdisplaySetStyle(); // implies palette setup
d->kdisplaySetFont();
d->propagateQtSettings();
}
}
}
int KGlobalSettings::dndEventDelay()
{
KConfigGroup g( KGlobal::config(), "General" );
return g.readEntry("StartDragDist", QApplication::startDragDistance());
}
bool KGlobalSettings::singleClick()
{
KConfigGroup g( KGlobal::config(), "KDE" );
return g.readEntry("SingleClick", KDE_DEFAULT_SINGLECLICK );
}
bool KGlobalSettings::smoothScroll()
{
KConfigGroup g( KGlobal::config(), "KDE" );
return g.readEntry("SmoothScroll", KDE_DEFAULT_SMOOTHSCROLL );
}
KGlobalSettings::TearOffHandle KGlobalSettings::insertTearOffHandle()
{
int tearoff;
bool effectsenabled;
KConfigGroup g( KGlobal::config(), "KDE" );
effectsenabled = g.readEntry( "EffectsEnabled", false);
tearoff = g.readEntry("InsertTearOffHandle", KDE_DEFAULT_INSERTTEAROFFHANDLES);
return effectsenabled ? (TearOffHandle) tearoff : Disable;
}
bool KGlobalSettings::changeCursorOverIcon()
{
KConfigGroup g( KGlobal::config(), "KDE" );
return g.readEntry("ChangeCursor", KDE_DEFAULT_CHANGECURSOR);
}
int KGlobalSettings::autoSelectDelay()
{
KConfigGroup g( KGlobal::config(), "KDE" );
return g.readEntry("AutoSelectDelay", KDE_DEFAULT_AUTOSELECTDELAY);
}
KGlobalSettings::Completion KGlobalSettings::completionMode()
{
int completion;
KConfigGroup g( KGlobal::config(), "General" );
completion = g.readEntry("completionMode", -1);
if ((completion < (int) CompletionNone) ||
(completion > (int) CompletionPopupAuto))
{
completion = (int) CompletionPopup; // Default
}
return (Completion) completion;
}
bool KGlobalSettings::showContextMenusOnPress ()
{
KConfigGroup g(KGlobal::config(), "ContextMenus");
return g.readEntry("ShowOnPress", true);
}
#ifndef KDE_NO_DEPRECATED
int KGlobalSettings::contextMenuKey ()
{
KConfigGroup g(KGlobal::config(), "Shortcuts");
QString s = g.readEntry ("PopupMenuContext", "Menu");
// this is a bit of a code duplication with KShortcut,
// but seeing as that is all in kdeui these days there's little choice.
// this is faster for what we're really after here anyways
// (less allocations, only processing the first item always, etc)
if (s == QLatin1String("none")) {
return QKeySequence()[0];
}
const QStringList shortCuts = s.split(';');
if (shortCuts.count() < 1) {
return QKeySequence()[0];
}
s = shortCuts.at(0);
if ( s.startsWith( QLatin1String("default(") ) ) {
s = s.mid( 8, s.length() - 9 );
}
return QKeySequence::fromString(s)[0];
}
#endif
// NOTE: keep this in sync with kdebase/workspace/kcontrol/colors/colorscm.cpp
QColor KGlobalSettings::inactiveTitleColor()
{
#ifdef Q_WS_WIN
return qt_colorref2qrgb(GetSysColor(COLOR_INACTIVECAPTION));
#else
KConfigGroup g( KGlobal::config(), "WM" );
return g.readEntry( "inactiveBackground", QColor(224,223,222) );
#endif
}
// NOTE: keep this in sync with kdebase/workspace/kcontrol/colors/colorscm.cpp
QColor KGlobalSettings::inactiveTextColor()
{
#ifdef Q_WS_WIN
return qt_colorref2qrgb(GetSysColor(COLOR_INACTIVECAPTIONTEXT));
#else
KConfigGroup g( KGlobal::config(), "WM" );
return g.readEntry( "inactiveForeground", QColor(75,71,67) );
#endif
}
// NOTE: keep this in sync with kdebase/workspace/kcontrol/colors/colorscm.cpp
QColor KGlobalSettings::activeTitleColor()
{
#ifdef Q_WS_WIN
return qt_colorref2qrgb(GetSysColor(COLOR_ACTIVECAPTION));
#else
KConfigGroup g( KGlobal::config(), "WM" );
return g.readEntry( "activeBackground", QColor(48,174,232));
#endif
}
// NOTE: keep this in sync with kdebase/workspace/kcontrol/colors/colorscm.cpp
QColor KGlobalSettings::activeTextColor()
{
#ifdef Q_WS_WIN
return qt_colorref2qrgb(GetSysColor(COLOR_CAPTIONTEXT));
#else
KConfigGroup g( KGlobal::config(), "WM" );
return g.readEntry( "activeForeground", QColor(255,255,255) );
#endif
}
int KGlobalSettings::contrast()
{
KConfigGroup g( KGlobal::config(), "KDE" );
return g.readEntry( "contrast", 5 );
}
qreal KGlobalSettings::contrastF(const KSharedConfigPtr &config)
{
if (config) {
KConfigGroup g( config, "KDE" );
return 0.1 * g.readEntry( "contrast", 7 );
}
return 0.1 * (qreal)contrast();
}
bool KGlobalSettings::shadeSortColumn()
{
KConfigGroup g( KGlobal::config(), "General" );
return g.readEntry( "shadeSortColumn", KDE_DEFAULT_SHADE_SORT_COLUMN );
}
bool KGlobalSettings::allowDefaultBackgroundImages()
{
KConfigGroup g( KGlobal::config(), "General" );
return g.readEntry( "allowDefaultBackgroundImages", KDE_DEFAULT_ALLOW_DEFAULT_BACKGROUND_IMAGES );
}
struct KFontData
{
const char* ConfigGroupKey;
const char* ConfigKey;
const char* FontName;
int Size;
int Weight;
QFont::StyleHint StyleHint;
};
// NOTE: keep in sync with kdebase/workspace/kcontrol/fonts/fonts.cpp
static const char GeneralId[] = "General";
static const char DefaultFont[] = "Sans Serif";
#ifdef Q_WS_MAC
static const char DefaultMacFont[] = "Lucida Grande";
#endif
static const KFontData DefaultFontData[KGlobalSettingsData::FontTypesCount] =
{
#ifdef Q_WS_MAC
{ GeneralId, "font", DefaultMacFont, 13, -1, QFont::SansSerif },
{ GeneralId, "fixed", "Monaco", 10, -1, QFont::TypeWriter },
{ GeneralId, "toolBarFont", DefaultMacFont, 11, -1, QFont::SansSerif },
{ GeneralId, "menuFont", DefaultMacFont, 13, -1, QFont::SansSerif },
#elif defined(Q_WS_MAEMO_5) || defined(MEEGO_EDITION_HARMATTAN)
{ GeneralId, "font", DefaultFont, 16, -1, QFont::SansSerif },
{ GeneralId, "fixed", "Monospace", 16, -1, QFont::TypeWriter },
{ GeneralId, "toolBarFont", DefaultFont, 16, -1, QFont::SansSerif },
{ GeneralId, "menuFont", DefaultFont, 16, -1, QFont::SansSerif },
#else
{ GeneralId, "font", DefaultFont, 9, -1, QFont::SansSerif },
{ GeneralId, "fixed", "Monospace", 9, -1, QFont::TypeWriter },
{ GeneralId, "toolBarFont", DefaultFont, 8, -1, QFont::SansSerif },
{ GeneralId, "menuFont", DefaultFont, 9, -1, QFont::SansSerif },
#endif
{ "WM", "activeFont", DefaultFont, 8, -1, QFont::SansSerif },
{ GeneralId, "taskbarFont", DefaultFont, 9, -1, QFont::SansSerif },
{ GeneralId, "smallestReadableFont", DefaultFont, 8, -1, QFont::SansSerif }
};
QFont KGlobalSettingsData::font( FontTypes fontType )
{
QFont* cachedFont = mFonts[fontType];
if (!cachedFont)
{
const KFontData& fontData = DefaultFontData[fontType];
cachedFont = new QFont( fontData.FontName, fontData.Size, fontData.Weight );
cachedFont->setStyleHint( fontData.StyleHint );
const KConfigGroup configGroup( KGlobal::config(), fontData.ConfigGroupKey );
*cachedFont = configGroup.readEntry( fontData.ConfigKey, *cachedFont );
mFonts[fontType] = cachedFont;
}
return *cachedFont;
}
QFont KGlobalSettings::generalFont()
{
return KGlobalSettingsData::self()->font( KGlobalSettingsData::GeneralFont );
}
QFont KGlobalSettings::fixedFont()
{
return KGlobalSettingsData::self()->font( KGlobalSettingsData::FixedFont );
}
QFont KGlobalSettings::toolBarFont()
{
return KGlobalSettingsData::self()->font( KGlobalSettingsData::ToolbarFont );
}
QFont KGlobalSettings::menuFont()
{
return KGlobalSettingsData::self()->font( KGlobalSettingsData::MenuFont );
}
QFont KGlobalSettings::windowTitleFont()
{
return KGlobalSettingsData::self()->font( KGlobalSettingsData::WindowTitleFont );
}
QFont KGlobalSettings::taskbarFont()
{
return KGlobalSettingsData::self()->font( KGlobalSettingsData::TaskbarFont );
}
QFont KGlobalSettings::smallestReadableFont()
{
return KGlobalSettingsData::self()->font( KGlobalSettingsData::SmallestReadableFont );
}
QFont KGlobalSettingsData::largeFont( const QString& text )
{
QFontDatabase db;
QStringList fam = db.families();
// Move a bunch of preferred fonts to the front.
// most preferred last
static const char* const PreferredFontNames[] =
{
"Arial",
"Sans Serif",
"Verdana",
"Tahoma",
"Lucida Sans",
"Lucidux Sans",
"Nimbus Sans",
"Gothic I"
};
static const unsigned int PreferredFontNamesCount = sizeof(PreferredFontNames)/sizeof(const char*);
for( unsigned int i=0; i<PreferredFontNamesCount; ++i )
{
const QString fontName (PreferredFontNames[i]);
if (fam.removeAll(fontName)>0)
fam.prepend(fontName);
}
if (mLargeFont) {
fam.prepend(mLargeFont->family());
delete mLargeFont;
}
for(QStringList::ConstIterator it = fam.constBegin();
it != fam.constEnd(); ++it)
{
if (db.isSmoothlyScalable(*it) && !db.isFixedPitch(*it))
{
QFont font(*it);
font.setPixelSize(75);
QFontMetrics metrics(font);
int h = metrics.height();
if ((h < 60) || ( h > 90))
continue;
bool ok = true;
for(int i = 0; i < text.length(); i++)
{
if (!metrics.inFont(text[i]))
{
ok = false;
break;
}
}
if (!ok)
continue;
font.setPointSize(48);
mLargeFont = new QFont(font);
return *mLargeFont;
}
}
mLargeFont = new QFont( font(GeneralFont) );
mLargeFont->setPointSize(48);
return *mLargeFont;
}
QFont KGlobalSettings::largeFont( const QString& text )
{
return KGlobalSettingsData::self()->largeFont( text );
}
void KGlobalSettingsData::dropFontSettingsCache()
{
for( int i=0; i<FontTypesCount; ++i )
{
delete mFonts[i];
mFonts[i] = 0;
}
delete mLargeFont;
mLargeFont = 0;
}
KGlobalSettings::KMouseSettings& KGlobalSettingsData::mouseSettings()
{
if (!mMouseSettings)
{
mMouseSettings = new KGlobalSettings::KMouseSettings;
KGlobalSettings::KMouseSettings& s = *mMouseSettings; // for convenience
#ifndef Q_WS_WIN
KConfigGroup g( KGlobal::config(), "Mouse" );
QString setting = g.readEntry("MouseButtonMapping");
if (setting == "RightHanded")
s.handed = KGlobalSettings::KMouseSettings::RightHanded;
else if (setting == "LeftHanded")
s.handed = KGlobalSettings::KMouseSettings::LeftHanded;
else
{
#ifdef Q_WS_X11
// get settings from X server
// This is a simplified version of the code in input/mouse.cpp
// Keep in sync !
s.handed = KGlobalSettings::KMouseSettings::RightHanded;
unsigned char map[20];
int num_buttons = XGetPointerMapping(QX11Info::display(), map, 20);
if( num_buttons == 2 )
{
if ( (int)map[0] == 1 && (int)map[1] == 2 )
s.handed = KGlobalSettings::KMouseSettings::RightHanded;
else if ( (int)map[0] == 2 && (int)map[1] == 1 )
s.handed = KGlobalSettings::KMouseSettings::LeftHanded;
}
else if( num_buttons >= 3 )
{
if ( (int)map[0] == 1 && (int)map[2] == 3 )
s.handed = KGlobalSettings::KMouseSettings::RightHanded;
else if ( (int)map[0] == 3 && (int)map[2] == 1 )
s.handed = KGlobalSettings::KMouseSettings::LeftHanded;
}
#else
// FIXME: Implement on other platforms
#endif
}
#endif //Q_WS_WIN
}
#ifdef Q_WS_WIN
//not cached
#ifndef _WIN32_WCE
mMouseSettings->handed = (GetSystemMetrics(SM_SWAPBUTTON) ?
KGlobalSettings::KMouseSettings::LeftHanded :
KGlobalSettings::KMouseSettings::RightHanded);
#else
// There is no mice under wince
mMouseSettings->handed =KGlobalSettings::KMouseSettings::RightHanded;
#endif
#endif
return *mMouseSettings;
}
// KDE5: make this a const return?
KGlobalSettings::KMouseSettings & KGlobalSettings::mouseSettings()
{
return KGlobalSettingsData::self()->mouseSettings();
}
void KGlobalSettingsData::dropMouseSettingsCache()
{
#ifndef Q_WS_WIN
delete mMouseSettings;
mMouseSettings = 0;
#endif
}
QString KGlobalSettings::desktopPath()
{
QString path = QDesktopServices::storageLocation( QDesktopServices::DesktopLocation );
return path.isEmpty() ? QDir::homePath() : path;
}
// Autostart is not a XDG path, so we have our own code for it.
QString KGlobalSettings::autostartPath()
{
QString s_autostartPath;
KConfigGroup g( KGlobal::config(), "Paths" );
s_autostartPath = KGlobal::dirs()->localkdedir() + "Autostart/";
s_autostartPath = g.readPathEntry( "Autostart" , s_autostartPath );
s_autostartPath = QDir::cleanPath( s_autostartPath );
if ( !s_autostartPath.endsWith( '/' ) ) {
s_autostartPath.append( QLatin1Char( '/' ) );
}
return s_autostartPath;
}
QString KGlobalSettings::documentPath()
{
QString path = QDesktopServices::storageLocation( QDesktopServices::DocumentsLocation );
return path.isEmpty() ? QDir::homePath() : path;
}
QString KGlobalSettings::downloadPath()
{
// Qt 4.4.1 does not have DOWNLOAD, so we based on old code for now
QString downloadPath = QDir::homePath();
#ifndef Q_WS_WIN
const QString xdgUserDirs = KGlobal::dirs()->localxdgconfdir() + QLatin1String( "user-dirs.dirs" );
if( QFile::exists( xdgUserDirs ) ) {
KConfig xdgUserConf( xdgUserDirs, KConfig::SimpleConfig );
KConfigGroup g( &xdgUserConf, "" );
downloadPath = g.readPathEntry( "XDG_DOWNLOAD_DIR", downloadPath ).remove( '"' );
if ( downloadPath.isEmpty() ) {
downloadPath = QDir::homePath();
}
}
#endif
downloadPath = QDir::cleanPath( downloadPath );
if ( !downloadPath.endsWith( '/' ) ) {
downloadPath.append( QLatin1Char( '/' ) );
}
return downloadPath;
}
QString KGlobalSettings::videosPath()
{
QString path = QDesktopServices::storageLocation( QDesktopServices::MoviesLocation );
return path.isEmpty() ? QDir::homePath() : path;
}
QString KGlobalSettings::picturesPath()
{
QString path = QDesktopServices::storageLocation( QDesktopServices::PicturesLocation );
return path.isEmpty() ? QDir::homePath() :path;
}
QString KGlobalSettings::musicPath()
{
QString path = QDesktopServices::storageLocation( QDesktopServices::MusicLocation );
return path.isEmpty() ? QDir::homePath() : path;
}
bool KGlobalSettings::isMultiHead()
{
#ifdef Q_WS_WIN
return GetSystemMetrics(SM_CMONITORS) > 1;
#else
QByteArray multiHead = qgetenv("KDE_MULTIHEAD");
if (!multiHead.isEmpty()) {
return (multiHead.toLower() == "true");
}
return false;
#endif
}
bool KGlobalSettings::wheelMouseZooms()
{
KConfigGroup g( KGlobal::config(), "KDE" );
return g.readEntry( "WheelMouseZooms", KDE_DEFAULT_WHEEL_ZOOM );
}
QRect KGlobalSettings::splashScreenDesktopGeometry()
{
QDesktopWidget *dw = QApplication::desktop();
if (dw->isVirtualDesktop()) {
KConfigGroup group(KGlobal::config(), "Windows");
int scr = group.readEntry("Unmanaged", -3);
if (group.readEntry("XineramaEnabled", true) && scr != -2) {
if (scr == -3)
scr = dw->screenNumber(QCursor::pos());
return dw->screenGeometry(scr);
} else {
return dw->geometry();
}
} else {
return dw->geometry();
}
}
QRect KGlobalSettings::desktopGeometry(const QPoint& point)
{
QDesktopWidget *dw = QApplication::desktop();
if (dw->isVirtualDesktop()) {
KConfigGroup group(KGlobal::config(), "Windows");
if (group.readEntry("XineramaEnabled", true) &&
group.readEntry("XineramaPlacementEnabled", true)) {
return dw->screenGeometry(dw->screenNumber(point));
} else {
return dw->geometry();
}
} else {
return dw->geometry();
}
}
QRect KGlobalSettings::desktopGeometry(const QWidget* w)
{
QDesktopWidget *dw = QApplication::desktop();
if (dw->isVirtualDesktop()) {
KConfigGroup group(KGlobal::config(), "Windows");
if (group.readEntry("XineramaEnabled", true) &&
group.readEntry("XineramaPlacementEnabled", true)) {
if (w)
return dw->screenGeometry(dw->screenNumber(w));
else return dw->screenGeometry(-1);
} else {
return dw->geometry();
}
} else {
return dw->geometry();
}
}
bool KGlobalSettings::showIconsOnPushButtons()
{
KConfigGroup g( KGlobal::config(), "KDE" );
return g.readEntry("ShowIconsOnPushButtons",
KDE_DEFAULT_ICON_ON_PUSHBUTTON);
}
bool KGlobalSettings::naturalSorting()
{
KConfigGroup g( KGlobal::config(), "KDE" );
return g.readEntry("NaturalSorting",
KDE_DEFAULT_NATURAL_SORTING);
}
KGlobalSettings::GraphicEffects KGlobalSettings::graphicEffectsLevel()
{
// This variable stores whether _graphicEffects has the default value because it has not been
// loaded yet, or if it has been loaded from the user settings or defaults and contains a valid
// value.
static bool _graphicEffectsInitialized = false;
if (!_graphicEffectsInitialized) {
_graphicEffectsInitialized = true;
Private::rereadOtherSettings();
}
return _graphicEffects;
}
KGlobalSettings::GraphicEffects KGlobalSettings::graphicEffectsLevelDefault()
{
// For now, let always enable animations by default. The plan is to make
// this code a bit smarter. (ereslibre)
return ComplexAnimationEffects;
}
bool KGlobalSettings::showFilePreview(const KUrl &url)
{
KConfigGroup g(KGlobal::config(), "PreviewSettings");
QString protocol = url.protocol();
bool defaultSetting = KProtocolInfo::showFilePreview( protocol );
return g.readEntry(protocol, defaultSetting );
}
bool KGlobalSettings::opaqueResize()
{
KConfigGroup g( KGlobal::config(), "KDE" );
return g.readEntry("OpaqueResize", KDE_DEFAULT_OPAQUE_RESIZE);
}
int KGlobalSettings::buttonLayout()
{
KConfigGroup g( KGlobal::config(), "KDE" );
return g.readEntry("ButtonLayout", KDE_DEFAULT_BUTTON_LAYOUT);
}
void KGlobalSettings::emitChange(ChangeType changeType, int arg)
{
QDBusMessage message = QDBusMessage::createSignal("/KGlobalSettings", "org.kde.KGlobalSettings", "notifyChange" );
QList<QVariant> args;
args.append(static_cast<int>(changeType));
args.append(arg);
message.setArguments(args);
QDBusConnection::sessionBus().send(message);
#ifdef Q_WS_X11
if (qApp && qApp->type() != QApplication::Tty) {
//notify non-kde qt applications of the change
extern void qt_x11_apply_settings_in_all_apps();
qt_x11_apply_settings_in_all_apps();
}
#endif
}
void KGlobalSettings::Private::_k_slotNotifyChange(int changeType, int arg)
{
switch(changeType) {
case StyleChanged:
if (activated) {
KGlobal::config()->reparseConfiguration();
kdisplaySetStyle();
}
break;
case ToolbarStyleChanged:
KGlobal::config()->reparseConfiguration();
emit q->toolbarAppearanceChanged(arg);
break;
case PaletteChanged:
if (activated) {
KGlobal::config()->reparseConfiguration();
paletteCreated = false;
kdisplaySetPalette();
}
break;
case FontChanged:
KGlobal::config()->reparseConfiguration();
KGlobalSettingsData::self()->dropFontSettingsCache();
if (activated) {
kdisplaySetFont();
}
break;
case SettingsChanged: {
KGlobal::config()->reparseConfiguration();
rereadOtherSettings();
SettingsCategory category = static_cast<SettingsCategory>(arg);
if (category == SETTINGS_MOUSE) {
KGlobalSettingsData::self()->dropMouseSettingsCache();
}
if (category == SETTINGS_QT) {
if (activated) {
propagateQtSettings();
}
} else {
+ if (category == SETTINGS_LOCALE) {
+ KGlobal::locale()->reparseConfiguration();
+ }
emit q->settingsChanged(category);
}
break;
}
case IconChanged:
QPixmapCache::clear();
KGlobal::config()->reparseConfiguration();
emit q->iconChanged(arg);
break;
case CursorChanged:
applyCursorTheme();
break;
case BlockShortcuts:
// FIXME KAccel port
//KGlobalAccel::blockShortcuts(arg);
emit q->blockShortcuts(arg); // see kwin
break;
case NaturalSortingChanged:
emit q->naturalSortingChanged();
break;
default:
kWarning(240) << "Unknown type of change in KGlobalSettings::slotNotifyChange: " << changeType;
}
}
// Set by KApplication
QString kde_overrideStyle;
void KGlobalSettings::Private::applyGUIStyle()
{
//Platform plugin only loaded on X11 systems
#ifdef Q_WS_X11
if (!kde_overrideStyle.isEmpty()) {
const QLatin1String currentStyleName(qApp->style()->metaObject()->className());
if (0 != kde_overrideStyle.compare(currentStyleName, Qt::CaseInsensitive) &&
0 != (QString(kde_overrideStyle + QLatin1String("Style"))).compare(currentStyleName, Qt::CaseInsensitive)) {
qApp->setStyle(kde_overrideStyle);
}
} else {
emit q->kdisplayStyleChanged();
}
#else
const QLatin1String currentStyleName(qApp->style()->metaObject()->className());
if (kde_overrideStyle.isEmpty()) {
const QString &defaultStyle = KStyle::defaultStyle();
const KConfigGroup pConfig(KGlobal::config(), "General");
const QString &styleStr = pConfig.readEntry("widgetStyle", defaultStyle);
if (styleStr.isEmpty() ||
// check whether we already use the correct style to return then
// (workaround for Qt misbehavior to avoid double style initialization)
0 == (QString(styleStr + QLatin1String("Style"))).compare(currentStyleName, Qt::CaseInsensitive) ||
0 == styleStr.compare(currentStyleName, Qt::CaseInsensitive)) {
return;
}
QStyle* sp = QStyleFactory::create( styleStr );
if (sp && currentStyleName == sp->metaObject()->className()) {
delete sp;
return;
}
// If there is no default style available, try falling back any available style
if ( !sp && styleStr != defaultStyle)
sp = QStyleFactory::create( defaultStyle );
if ( !sp )
sp = QStyleFactory::create( QStyleFactory::keys().first() );
qApp->setStyle(sp);
} else if (0 != kde_overrideStyle.compare(currentStyleName, Qt::CaseInsensitive) &&
0 != (QString(kde_overrideStyle + QLatin1String("Style"))).compare(currentStyleName, Qt::CaseInsensitive)) {
qApp->setStyle(kde_overrideStyle);
}
emit q->kdisplayStyleChanged();
#endif //Q_WS_X11
}
QPalette KGlobalSettings::createApplicationPalette(const KSharedConfigPtr &config)
{
return self()->d->createApplicationPalette(config);
}
QPalette KGlobalSettings::createNewApplicationPalette(const KSharedConfigPtr &config)
{
return self()->d->createNewApplicationPalette(config);
}
QPalette KGlobalSettings::Private::createApplicationPalette(const KSharedConfigPtr &config)
{
// This method is typically called once by KQGuiPlatformPlugin::palette and once again
// by kdisplaySetPalette(), so we cache the palette to save time.
if (config == KGlobal::config() && paletteCreated) {
return applicationPalette;
}
return createNewApplicationPalette(config);
}
QPalette KGlobalSettings::Private::createNewApplicationPalette(const KSharedConfigPtr &config)
{
QPalette palette;
QPalette::ColorGroup states[3] = { QPalette::Active, QPalette::Inactive,
QPalette::Disabled };
// TT thinks tooltips shouldn't use active, so we use our active colors for all states
KColorScheme schemeTooltip(QPalette::Active, KColorScheme::Tooltip, config);
for ( int i = 0; i < 3 ; i++ ) {
QPalette::ColorGroup state = states[i];
KColorScheme schemeView(state, KColorScheme::View, config);
KColorScheme schemeWindow(state, KColorScheme::Window, config);
KColorScheme schemeButton(state, KColorScheme::Button, config);
KColorScheme schemeSelection(state, KColorScheme::Selection, config);
palette.setBrush( state, QPalette::WindowText, schemeWindow.foreground() );
palette.setBrush( state, QPalette::Window, schemeWindow.background() );
palette.setBrush( state, QPalette::Base, schemeView.background() );
palette.setBrush( state, QPalette::Text, schemeView.foreground() );
palette.setBrush( state, QPalette::Button, schemeButton.background() );
palette.setBrush( state, QPalette::ButtonText, schemeButton.foreground() );
palette.setBrush( state, QPalette::Highlight, schemeSelection.background() );
palette.setBrush( state, QPalette::HighlightedText, schemeSelection.foreground() );
palette.setBrush( state, QPalette::ToolTipBase, schemeTooltip.background() );
palette.setBrush( state, QPalette::ToolTipText, schemeTooltip.foreground() );
palette.setColor( state, QPalette::Light, schemeWindow.shade( KColorScheme::LightShade ) );
palette.setColor( state, QPalette::Midlight, schemeWindow.shade( KColorScheme::MidlightShade ) );
palette.setColor( state, QPalette::Mid, schemeWindow.shade( KColorScheme::MidShade ) );
palette.setColor( state, QPalette::Dark, schemeWindow.shade( KColorScheme::DarkShade ) );
palette.setColor( state, QPalette::Shadow, schemeWindow.shade( KColorScheme::ShadowShade ) );
palette.setBrush( state, QPalette::AlternateBase, schemeView.background( KColorScheme::AlternateBackground) );
palette.setBrush( state, QPalette::Link, schemeView.foreground( KColorScheme::LinkText ) );
palette.setBrush( state, QPalette::LinkVisited, schemeView.foreground( KColorScheme::VisitedText ) );
}
if (config == KGlobal::config()) {
paletteCreated = true;
applicationPalette = palette;
}
return palette;
}
void KGlobalSettings::Private::kdisplaySetPalette()
{
#if !defined(Q_WS_MAEMO_5) && !defined(Q_OS_WINCE) && !defined(MEEGO_EDITION_HARMATTAN)
if (!kdeFullSession) {
return;
}
if (qApp->type() == QApplication::GuiClient) {
QApplication::setPalette( q->createApplicationPalette() );
}
emit q->kdisplayPaletteChanged();
emit q->appearanceChanged();
#endif
}
void KGlobalSettings::Private::kdisplaySetFont()
{
#if !defined(Q_WS_MAEMO_5) && !defined(Q_OS_WINCE) && !defined(MEEGO_EDITION_HARMATTAN)
if (!kdeFullSession) {
return;
}
if (qApp->type() == QApplication::GuiClient) {
KGlobalSettingsData* data = KGlobalSettingsData::self();
QApplication::setFont( data->font(KGlobalSettingsData::GeneralFont) );
const QFont menuFont = data->font( KGlobalSettingsData::MenuFont );
QApplication::setFont( menuFont, "QMenuBar" );
QApplication::setFont( menuFont, "QMenu" );
QApplication::setFont( menuFont, "KPopupTitle" );
QApplication::setFont( data->font(KGlobalSettingsData::ToolbarFont), "QToolBar" );
}
emit q->kdisplayFontChanged();
emit q->appearanceChanged();
#endif
}
void KGlobalSettings::Private::kdisplaySetStyle()
{
if (qApp->type() == QApplication::GuiClient) {
applyGUIStyle();
// Reread palette from config file.
kdisplaySetPalette();
}
}
void KGlobalSettings::Private::rereadOtherSettings()
{
KConfigGroup g( KGlobal::config(), "KDE-Global GUI Settings" );
// Asking for hasKey we do not ask for graphicEffectsLevelDefault() that can
// contain some very slow code. If we can save that time, do it. (ereslibre)
if (g.hasKey("GraphicEffectsLevel")) {
_graphicEffects = ((GraphicEffects) g.readEntry("GraphicEffectsLevel", QVariant((int) NoEffects)).toInt());
return;
}
_graphicEffects = KGlobalSettings::graphicEffectsLevelDefault();
}
void KGlobalSettings::Private::applyCursorTheme()
{
#if defined(Q_WS_X11) && defined(HAVE_XCURSOR)
KConfig config("kcminputrc");
KConfigGroup g(&config, "Mouse");
QString theme = g.readEntry("cursorTheme", QString());
int size = g.readEntry("cursorSize", -1);
// Default cursor size is 16 points
if (size == -1)
{
QApplication *app = static_cast<QApplication*>(QApplication::instance());
size = app->desktop()->screen(0)->logicalDpiY() * 16 / 72;
}
// Note that in X11R7.1 and earlier, calling XcursorSetTheme()
// with a NULL theme would cause Xcursor to use "default", but
// in 7.2 and later it will cause it to revert to the theme that
// was configured when the application was started.
XcursorSetTheme(QX11Info::display(), theme.isNull() ?
"default" : QFile::encodeName(theme));
XcursorSetDefaultSize(QX11Info::display(), size);
emit q->cursorChanged();
#endif
}
void KGlobalSettings::Private::propagateQtSettings()
{
KConfigGroup cg( KGlobal::config(), "KDE" );
int num = cg.readEntry("CursorBlinkRate", QApplication::cursorFlashTime());
if ((num != 0) && (num < 200))
num = 200;
if (num > 2000)
num = 2000;
QApplication::setCursorFlashTime(num);
num = cg.readEntry("DoubleClickInterval", QApplication::doubleClickInterval());
QApplication::setDoubleClickInterval(num);
num = cg.readEntry("StartDragTime", QApplication::startDragTime());
QApplication::setStartDragTime(num);
num = cg.readEntry("StartDragDist", QApplication::startDragDistance());
QApplication::setStartDragDistance(num);
num = cg.readEntry("WheelScrollLines", QApplication::wheelScrollLines());
QApplication::setWheelScrollLines(num);
bool showIcons = cg.readEntry("ShowIconsInMenuItems", !QApplication::testAttribute(Qt::AA_DontShowIconsInMenus));
QApplication::setAttribute(Qt::AA_DontShowIconsInMenus, !showIcons);
// KDE5: this seems fairly pointless
emit q->settingsChanged(SETTINGS_QT);
}
#include "kglobalsettings.moc"
diff --git a/kdeui/kernel/kglobalsettings.h b/kdeui/kernel/kglobalsettings.h
index cb8f7e2ac0..6b7614640b 100644
--- a/kdeui/kernel/kglobalsettings.h
+++ b/kdeui/kernel/kglobalsettings.h
@@ -1,692 +1,693 @@
/* This file is part of the KDE libraries
Copyright (C) 2000,2006 David Faure <faure@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 version 2 as published by the Free Software Foundation.
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.
*/
#ifndef _KGLOBALSETTINGS_H
#define _KGLOBALSETTINGS_H
#include <kdeui_export.h>
#include <ksharedconfig.h>
#include <QtCore/QObject>
#include <QtCore/QString>
#include <QtGui/QPalette>
#define KDE_DEFAULT_SINGLECLICK true
#define KDE_DEFAULT_SMOOTHSCROLL true
#define KDE_DEFAULT_INSERTTEAROFFHANDLES 0
#define KDE_DEFAULT_AUTOSELECTDELAY -1
#define KDE_DEFAULT_CHANGECURSOR true
#define KDE_DEFAULT_LARGE_CURSOR false
#define KDE_DEFAULT_WHEEL_ZOOM false
#ifdef Q_WS_MAEMO_5
#define KDE_DEFAULT_ICON_ON_PUSHBUTTON false
#else
#define KDE_DEFAULT_ICON_ON_PUSHBUTTON true
#endif
#define KDE_DEFAULT_OPAQUE_RESIZE true
#define KDE_DEFAULT_BUTTON_LAYOUT 0
#define KDE_DEFAULT_SHADE_SORT_COLUMN true
#define KDE_DEFAULT_ALLOW_DEFAULT_BACKGROUND_IMAGES true
#define KDE_DEFAULT_NATURAL_SORTING true
class KUrl;
class QColor;
class QFont;
class QPoint;
class QRect;
class QWidget;
/**
* Access the KDE global configuration.
*
* @author David Faure \<faure@kde.org\>
*/
class KDEUI_EXPORT KGlobalSettings : public QObject
{
Q_OBJECT
public:
~KGlobalSettings();
/**
* Returns a threshold in pixels for drag & drop operations.
* As long as the mouse movement has not exceeded this number
* of pixels in either X or Y direction no drag operation may
* be started. This prevents spurious drags when the user intended
* to click on something but moved the mouse a bit while doing so.
*
* For this to work you must save the position of the mouse (oldPos)
* in the QWidget::mousePressEvent().
* When the position of the mouse (newPos)
* in a QWidget::mouseMoveEvent() exceeds this threshold
* you may start a drag
* which should originate from oldPos.
*
* Example code:
* \code
* void KColorCells::mousePressEvent( QMouseEvent *e )
* {
* mOldPos = e->pos();
* }
*
* void KColorCells::mouseMoveEvent( QMouseEvent *e )
* {
* if( !(e->state() && LeftButton)) return;
*
* int delay = KGlobalSettings::dndEventDelay();
* QPoint newPos = e->pos();
* if(newPos.x() > mOldPos.x()+delay || newPos.x() < mOldPos.x()-delay ||
* newPos.y() > mOldPos.y()+delay || newPos.y() < mOldPos.y()-delay)
* {
* // Drag color object
* int cell = posToCell(mOldPos); // Find color at mOldPos
* if ((cell != -1) && colors[cell].isValid())
* {
* KColorDrag *d = KColorDrag::makeDrag( colors[cell], this);
* d->dragCopy();
* }
* }
* }
* \endcode
* @return the threshold for drag & drop in pixels
*/
static int dndEventDelay();
/**
* Returns whether KDE runs in single (default) or double click
* mode.
* see http://developer.kde.org/documentation/standards/kde/style/mouse/index.html
* @return true if single click mode, or false if double click mode.
**/
static bool singleClick();
/**
* Returns if item views should force smooth scrolling.
* @return true if smooth scrolling is enabled for item view, false otherwise.
* @since 4.2
*/
static bool smoothScroll();
/**
* This enum describes the return type for insertTearOffHandle() whether to insert
* a handle or not. Applications who independently want to use handles in their popup menus
* should test for Application level before calling the appropriate function in KMenu.
**/
enum TearOffHandle {
Disable = 0, ///< disable tear-off handles
ApplicationLevel, ///< enable on application level
Enable ///< enable tear-off handles
};
/**
* Returns whether tear-off handles are inserted in KMenus.
* @return whether tear-off handles are inserted in KMenus.
**/
static TearOffHandle insertTearOffHandle();
/**
* Checks whether the cursor changes over icons.
* @return the KDE setting for "change cursor over icon"
*/
static bool changeCursorOverIcon();
/**
* Returns the KDE setting for the auto-select option.
*
* @return the auto-select delay or -1 if auto-select is disabled.
*/
static int autoSelectDelay();
/**
* Returns the KDE setting for the shortcut key to open
* context menus.
*
* @return the key that pops up context menus.
* @deprecated Simply reimplement QWidget::contextMenuEvent() instead.
*/
#ifndef KDE_NO_DEPRECATED
static KDE_DEPRECATED int contextMenuKey ();
#endif
/**
* Returns the KDE setting for context menus.
*
* @return whether context menus should be shown on button press
* or button release (click).
*/
static bool showContextMenusOnPress ();
/**
* This enum describes the completion mode used for by the KCompletion class.
* See <a href="http://developer.kde.org/documentation/standards/kde/style/keys/completion.html">
* the styleguide</a>.
**/
enum Completion {
/**
* No completion is used.
*/
CompletionNone=1,
/**
* Text is automatically filled in whenever possible.
*/
CompletionAuto,
/**
* Same as automatic except shortest match is used for completion.
*/
CompletionMan,
/**
* Complete text much in the same way as a typical *nix shell would.
*/
CompletionShell,
/**
* Lists all possible matches in a popup list-box to choose from.
*/
CompletionPopup,
/**
* Lists all possible matches in a popup list-box to choose from, and automatically
* fill the result whenever possible.
*/
CompletionPopupAuto
};
/**
* Returns the preferred completion mode setting.
*
* @return Completion. Default is @p CompletionPopup.
*/
static Completion completionMode();
/**
* Describes the mouse settings.
*/
struct KMouseSettings
{
enum { RightHanded = 0, LeftHanded = 1 };
int handed; // left or right
};
/**
* This returns the current mouse settings.
* On Windows, settings are retrieved from the system.
* @return the current mouse settings
*/
static KMouseSettings & mouseSettings();
/**
* The path to the desktop directory of the current user.
* @return the user's desktop directory
*/
static QString desktopPath();
/**
* The path to the autostart directory of the current user.
* @return the path of the autostart directory
*/
static QString autostartPath();
/**
* The path where documents are stored of the current user.
* @return the path of the document directory
*/
static QString documentPath();
/**
* The path where music are stored of the current user.
* @return the path of the music directory
*/
static QString musicPath();
/**
* The path where videos are stored of the current user.
* @return the path of the video directory
*/
static QString videosPath();
/**
* The path where download are stored of the current user.
* @return the path of the download directory
*/
static QString downloadPath();
/**
* The path where pictures are stored of the current user.
* @return the path of the pictures directory
*/
static QString picturesPath();
/**
* The default color to use for inactive titles.
* @return the inactive title color
*/
static QColor inactiveTitleColor();
/**
* The default color to use for inactive texts.
* @return the inactive text color
*/
static QColor inactiveTextColor();
/**
* The default color to use for active titles.
* @return the active title color
*/
static QColor activeTitleColor();
/**
* The default color to use for active texts.
* @return the active text color
*/
static QColor activeTextColor();
/**
* Returns the contrast for borders.
* @return the contrast (between 0 for minimum and 10 for maximum
* contrast)
*/
static int contrast();
/**
* Returns the contrast for borders as a floating point value.
* @param config pointer to the config from which to read the contrast
* setting (the default is to use KGlobal::config())
* @return the contrast (between 0.0 for minimum and 1.0 for maximum
* contrast)
*/
static qreal contrastF(const KSharedConfigPtr &config = KSharedConfigPtr());
/**
* Returns if the sorted column in a K3ListView shall be drawn with a
* shaded background color.
* @return true if the sorted column shall be shaded
*/
static bool shadeSortColumn();
/**
* Returns if default background images are allowed by the color scheme.
* A "default" background image is just that, i.e. the user has not
* actively selected a background image to use.
* @return true if default background images may be used
*/
static bool allowDefaultBackgroundImages();
/**
* Returns the default general font.
* @return the default general font.
*/
static QFont generalFont();
/**
* Returns the default fixed font.
* @return the default fixed font.
*/
static QFont fixedFont();
/**
* Returns the default toolbar font.
* @return the default toolbar font.
*/
static QFont toolBarFont();
/**
* Returns the default menu font.
* @return the default menu font.
*/
static QFont menuFont();
/**
* Returns the default window title font.
* @return the default window title font.
*/
static QFont windowTitleFont();
/**
* Returns the default taskbar font.
* @return the default taskbar font.
*/
static QFont taskbarFont();
/**
* Returns a font of approx. 48 pt. capable of showing @p text.
* @param text the text to test
* @return the font that is capable to show the text with 48 pt
*/
static QFont largeFont(const QString &text = QString());
/**
* Returns the smallest readable font. This can be used in dockers,
* rulers and other places where space is at a premium.
*/
static QFont smallestReadableFont();
/**
* Returns if the user specified multihead. In case the display
* has multiple screens, the return value of this function specifies
* if the user wants KDE to run on all of them or just on the primary
* On Windows, settings are retrieved from the system.
* @return true if the user chose multi head
*/
static bool isMultiHead();
/**
* Typically, QScrollView derived classes can be scrolled fast by
* holding down the Ctrl-button during wheel-scrolling.
* But QTextEdit and derived classes perform zooming instead of fast
* scrolling.
*
* This value determines whether the user wants to zoom or scroll fast
* with Ctrl-wheelscroll.
* @return true if the user wishes to zoom with the mouse wheel,
* false for scrolling
*/
static bool wheelMouseZooms();
/**
* This function returns the desktop geometry for an application's splash
* screen. It takes into account the user's display settings (number of
* screens, Xinerama, etc), and the user's preferences (if KDE should be
* Xinerama aware).
*
* @return the geometry to use for the desktop. Note that it might not
* start at (0,0).
*/
static QRect splashScreenDesktopGeometry();
/**
* This function returns the desktop geometry for an application that needs
* to set the geometry of a widget on the screen manually. It takes into
* account the user's display settings (number of screens, Xinerama, etc),
* and the user's preferences (if KDE should be Xinerama aware).
*
* Note that this can break in multi-head (not Xinerama) mode because this
* point could be on multiple screens. Use with care.
*
* @param point a reference point for the widget, for instance one that the
* widget should be adjacent or on top of.
*
* @return the geometry to use for the desktop. Note that it might not
* start at (0,0).
*/
static QRect desktopGeometry(const QPoint& point);
/**
* This function returns the desktop geometry for an application that needs
* to set the geometry of a widget on the screen manually. It takes into
* account the user's display settings (number of screens, Xinerama, etc),
* and the user's preferences (if KDE should be Xinerama aware).
*
* @param w the widget in question. This is used to determine which screen
* to use in Xinerama or multi-head mode.
*
* @return the geometry to use for the desktop. Note that it might not
* start at (0,0).
*/
static QRect desktopGeometry(const QWidget* w);
/**
* This function determines if the user wishes to see icons on the
* push buttons.
*
* @return Returns true if user wants to show icons.
*/
static bool showIconsOnPushButtons();
/**
* Returns true, if user visible strings should be sorted in a natural way:
* image 1.jpg
* image 2.jpg
* image 10.jpg
* image 11.jpg
* If false is returned, the strings are sorted by their unicode values:
* image 1.jpg
* image 10.jpg
* image 11.jpg
* image 2.jpg
*
* @since 4.4
*/
static bool naturalSorting();
enum GraphicEffect {
NoEffects = 0x0000, ///< GUI with no effects at all.
GradientEffects = 0x0001, ///< GUI with only gradients enabled.
SimpleAnimationEffects = 0x0002, ///< GUI with simple animations enabled.
ComplexAnimationEffects = 0x0006 ///< GUI with complex animations enabled.
///< Note that ComplexAnimationsEffects implies SimpleAnimationEffects.
};
Q_DECLARE_FLAGS(GraphicEffects, GraphicEffect)
/**
* This function determines the desired level of effects on the GUI.
*
* @since 4.1
*/
static GraphicEffects graphicEffectsLevel();
/**
* This function determines the default level of effects on the GUI
* depending on the system capabilities.
*
* @since 4.1
*/
static GraphicEffects graphicEffectsLevelDefault();
/**
* This function determines if the user wishes to see previews
* for the selected url
*
* @return Returns true if user wants to show previews.
*/
static bool showFilePreview(const KUrl &);
/**
* Whether the user wishes to use opaque resizing. Primarily
* intended for QSplitter::setOpaqueResize()
*
* @return Returns true if user wants to use opaque resizing.
*/
static bool opaqueResize();
/**
* The layout scheme to use for dialog buttons
*
* @return Returns the number of the scheme to use.
*/
static int buttonLayout();
/**
* Used to obtain the QPalette that will be used to set the application palette.
*
* This is only useful for configuration modules such as krdb and should not be
* used in normal circumstances.
* @param config KConfig from which to load the colors (passed as-is to
* ::KColorScheme).
*
* @return the QPalette
*/
static QPalette createApplicationPalette(const KSharedConfigPtr &config = KSharedConfigPtr());
/**
* Used to obtain the QPalette that will be used to set the application palette.
*
* This is only useful for configuration modules such as krdb and should not be
* used in normal circumstances.
* @param config KConfig from which to load the colors (passed as-is to
* ::KColorScheme).
*
* @note The difference between this and the previous is that this never caches.
* @since 4.6.3
*
* @return the QPalette
*/
static QPalette createNewApplicationPalette(const KSharedConfigPtr &config = KSharedConfigPtr());
/**
* An identifier for change signals.
* \see emitChange
*/
enum ChangeType { PaletteChanged = 0, FontChanged, StyleChanged,
SettingsChanged, IconChanged, CursorChanged,
ToolbarStyleChanged, ClipboardConfigChanged,
BlockShortcuts, NaturalSortingChanged };
/**
* Notifies all KDE applications on the current display of a change.
*
* This is typically called by kcontrol modules after changing the corresponding
* config file. Do not call this from a normal KDE application.
*/
static void emitChange(ChangeType changeType, int arg = 0);
/**
* Return the KGlobalSettings singleton.
* This is used to connect to its signals, to be notified of changes.
*/
static KGlobalSettings* self();
/**
* Specifies options passed to activate().
*
* @since 4.6
*/
enum ActivateOption {
ApplySettings = 0x1, ///< Make all globally applicable settings take effect.
ListenForChanges = 0x2 ///< Listen for changes to the settings.
};
Q_DECLARE_FLAGS(ActivateOptions, ActivateOption)
/**
* Makes all globally applicable settings take effect
* and starts listening for changes to these settings.
*
* This is usually called only by the KApplication constructor.
*
* @since 4.3.3
*/
void activate(); //KDE5: Merge with the overloaded method below
/**
* @overload
*
* @since 4.6
*/
void activate(ActivateOptions options);
/**
* Valid values for the settingsChanged signal
*/
enum SettingsCategory { SETTINGS_MOUSE, SETTINGS_COMPLETION, SETTINGS_PATHS,
- SETTINGS_POPUPMENU, SETTINGS_QT, SETTINGS_SHORTCUTS };
+ SETTINGS_POPUPMENU, SETTINGS_QT, SETTINGS_SHORTCUTS,
+ SETTINGS_LOCALE };
Q_SIGNALS:
/**
* Emitted when the application has changed its palette due to a KControl request.
*
* Normally, widgets will update their palette automatically, but you
* should connect to this to program special behavior.
*
* Note: If you derive from a QWidget-based class, a faster method is to
* reimplement QWidget::changeEvent() and catch QEvent::PaletteChange.
* This is the preferred way to get informed about palette updates.
*/
void kdisplayPaletteChanged();
/**
* Emitted when the application has changed its GUI style in response to a KControl request.
*
* Normally, widgets will update their styles automatically (as they would
* respond to an explicit setGUIStyle() call), but you should connect to
* this to program special behavior.
*
* Note: If you derive from a QWidget-based class, a faster method is to
* reimplement QWidget::changeEvent() and catch QEvent::StyleChange.
* This is the preferred way to get informed about style updates.
*/
void kdisplayStyleChanged();
/**
* Emitted when the application has changed its font in response to a KControl request.
*
* Normally widgets will update their fonts automatically, but you should
* connect to this to monitor global font changes, especially if you are
* using explicit fonts.
*
* Note: If you derive from a QWidget-based class, a faster method is to
* reimplement QWidget::changeEvent() and catch QEvent::FontChange.
* This is the preferred way to get informed about font updates.
*/
void kdisplayFontChanged();
/**
* Emitted when the application has changed either its GUI style, its font or its palette
* in response to a kdisplay request. Normally, widgets will update their styles
* automatically, but you should connect to this to program special
* behavior.
*/
void appearanceChanged();
/**
* Emitted when the settings for toolbars have been changed. KToolBar will know what to do.
*/
void toolbarAppearanceChanged(int);
/**
* Emitted when the global settings have been changed.
* KGlobalSettings takes care of calling reparseConfiguration on KGlobal::config()
* so that applications/classes using this only have to re-read the configuration
* @param category the category among the SettingsCategory enum.
*/
void settingsChanged(int category);
/**
* Emitted when the global icon settings have been changed.
* @param group the new group
*/
void iconChanged(int group);
/**
* Emitted when the cursor theme has been changed.
*/
void cursorChanged();
/**
* Emitted by BlockShortcuts
*/
void blockShortcuts(int data);
/**
* Emitted when the natural sorting has been changed.
* @since 4.4
*/
void naturalSortingChanged();
private:
friend class KApplication;
KGlobalSettings();
class Private;
Private* const d;
Q_PRIVATE_SLOT(d, void _k_slotNotifyChange(int, int))
};
Q_DECLARE_OPERATORS_FOR_FLAGS(KGlobalSettings::GraphicEffects)
Q_DECLARE_OPERATORS_FOR_FLAGS(KGlobalSettings::ActivateOptions)
#endif
File Metadata
Details
Attached
Mime Type
text/x-diff
Expires
Fri, Nov 1, 8:22 AM (1 d, 7 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
10074954
Default Alt Text
(198 KB)
Attached To
Mode
rKL kdelibs
Attached
Detach File
Event Timeline
Log In to Comment