зеркало из https://github.com/mozilla/gecko-dev.git
344 строки
9.9 KiB
C++
344 строки
9.9 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/**
|
|
* This is a shared part of the OSPreferences API implementation.
|
|
* It defines helper methods and public methods that are calling
|
|
* platform-specific private methods.
|
|
*/
|
|
|
|
#include "OSPreferences.h"
|
|
|
|
#include "mozilla/ClearOnShutdown.h"
|
|
#include "mozilla/Services.h"
|
|
#include "nsIObserverService.h"
|
|
#include "unicode/udat.h"
|
|
#include "unicode/udatpg.h"
|
|
|
|
using namespace mozilla::intl;
|
|
|
|
NS_IMPL_ISUPPORTS(OSPreferences, mozIOSPreferences)
|
|
|
|
mozilla::StaticRefPtr<OSPreferences> OSPreferences::sInstance;
|
|
|
|
OSPreferences* OSPreferences::GetInstance() {
|
|
if (!sInstance) {
|
|
sInstance = new OSPreferences();
|
|
ClearOnShutdown(&sInstance);
|
|
}
|
|
return sInstance;
|
|
}
|
|
|
|
void OSPreferences::Refresh() {
|
|
nsTArray<nsCString> newLocales;
|
|
ReadSystemLocales(newLocales);
|
|
|
|
if (mSystemLocales != newLocales) {
|
|
mSystemLocales = std::move(newLocales);
|
|
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
|
|
if (obs) {
|
|
obs->NotifyObservers(nullptr, "intl:system-locales-changed", nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method should be called by every method of OSPreferences that
|
|
* retrieves a locale id from external source.
|
|
*
|
|
* It attempts to retrieve as much of the locale ID as possible, cutting
|
|
* out bits that are not understood (non-strict behavior of ICU).
|
|
*
|
|
* It returns true if the canonicalization was successful.
|
|
*/
|
|
bool OSPreferences::CanonicalizeLanguageTag(nsCString& aLoc) {
|
|
char langTag[512];
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
int32_t langTagLen = uloc_toLanguageTag(aLoc.get(), langTag,
|
|
sizeof(langTag) - 1, false, &status);
|
|
|
|
if (U_FAILURE(status)) {
|
|
return false;
|
|
}
|
|
|
|
aLoc.Assign(langTag, langTagLen);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* This method retrieves from ICU the best pattern for a given date/time style.
|
|
*/
|
|
bool OSPreferences::GetDateTimePatternForStyle(DateTimeFormatStyle aDateStyle,
|
|
DateTimeFormatStyle aTimeStyle,
|
|
const nsACString& aLocale,
|
|
nsAString& aRetVal) {
|
|
UDateFormatStyle timeStyle = UDAT_NONE;
|
|
UDateFormatStyle dateStyle = UDAT_NONE;
|
|
|
|
switch (aTimeStyle) {
|
|
case DateTimeFormatStyle::None:
|
|
timeStyle = UDAT_NONE;
|
|
break;
|
|
case DateTimeFormatStyle::Short:
|
|
timeStyle = UDAT_SHORT;
|
|
break;
|
|
case DateTimeFormatStyle::Medium:
|
|
timeStyle = UDAT_MEDIUM;
|
|
break;
|
|
case DateTimeFormatStyle::Long:
|
|
timeStyle = UDAT_LONG;
|
|
break;
|
|
case DateTimeFormatStyle::Full:
|
|
timeStyle = UDAT_FULL;
|
|
break;
|
|
case DateTimeFormatStyle::Invalid:
|
|
timeStyle = UDAT_NONE;
|
|
break;
|
|
}
|
|
|
|
switch (aDateStyle) {
|
|
case DateTimeFormatStyle::None:
|
|
dateStyle = UDAT_NONE;
|
|
break;
|
|
case DateTimeFormatStyle::Short:
|
|
dateStyle = UDAT_SHORT;
|
|
break;
|
|
case DateTimeFormatStyle::Medium:
|
|
dateStyle = UDAT_MEDIUM;
|
|
break;
|
|
case DateTimeFormatStyle::Long:
|
|
dateStyle = UDAT_LONG;
|
|
break;
|
|
case DateTimeFormatStyle::Full:
|
|
dateStyle = UDAT_FULL;
|
|
break;
|
|
case DateTimeFormatStyle::Invalid:
|
|
dateStyle = UDAT_NONE;
|
|
break;
|
|
}
|
|
|
|
const int32_t kPatternMax = 160;
|
|
UChar pattern[kPatternMax];
|
|
|
|
nsAutoCString locale;
|
|
if (aLocale.IsEmpty()) {
|
|
AutoTArray<nsCString, 10> regionalPrefsLocales;
|
|
LocaleService::GetInstance()->GetRegionalPrefsLocales(regionalPrefsLocales);
|
|
locale.Assign(regionalPrefsLocales[0]);
|
|
} else {
|
|
locale.Assign(aLocale);
|
|
}
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UDateFormat* df = udat_open(timeStyle, dateStyle, locale.get(), nullptr, -1,
|
|
nullptr, -1, &status);
|
|
if (U_FAILURE(status)) {
|
|
return false;
|
|
}
|
|
|
|
int32_t patsize = udat_toPattern(df, false, pattern, kPatternMax, &status);
|
|
udat_close(df);
|
|
if (U_FAILURE(status)) {
|
|
return false;
|
|
}
|
|
aRetVal.Assign((const char16_t*)pattern, patsize);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* This method retrieves from ICU the best skeleton for a given date/time style.
|
|
*
|
|
* This is useful for cases where an OS does not provide its own patterns,
|
|
* but provide ability to customize the skeleton, like alter hourCycle setting.
|
|
*
|
|
* The returned value is a skeleton that matches the styles.
|
|
*/
|
|
bool OSPreferences::GetDateTimeSkeletonForStyle(DateTimeFormatStyle aDateStyle,
|
|
DateTimeFormatStyle aTimeStyle,
|
|
const nsACString& aLocale,
|
|
nsAString& aRetVal) {
|
|
nsAutoString pattern;
|
|
if (!GetDateTimePatternForStyle(aDateStyle, aTimeStyle, aLocale, pattern)) {
|
|
return false;
|
|
}
|
|
|
|
const int32_t kSkeletonMax = 160;
|
|
UChar skeleton[kSkeletonMax];
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
int32_t skelsize =
|
|
udatpg_getSkeleton(nullptr, (const UChar*)pattern.BeginReading(),
|
|
pattern.Length(), skeleton, kSkeletonMax, &status);
|
|
if (U_FAILURE(status)) {
|
|
return false;
|
|
}
|
|
|
|
aRetVal.Assign((const char16_t*)skeleton, skelsize);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* This function is a counterpart to GetDateTimeSkeletonForStyle.
|
|
*
|
|
* It takes a skeleton and returns the best available pattern for a given locale
|
|
* that represents the provided skeleton.
|
|
*
|
|
* For example:
|
|
* "Hm" skeleton for "en-US" will return "H:m"
|
|
*/
|
|
bool OSPreferences::GetPatternForSkeleton(const nsAString& aSkeleton,
|
|
const nsACString& aLocale,
|
|
nsAString& aRetVal) {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UDateTimePatternGenerator* pg =
|
|
udatpg_open(PromiseFlatCString(aLocale).get(), &status);
|
|
if (U_FAILURE(status)) {
|
|
return false;
|
|
}
|
|
|
|
int32_t len =
|
|
udatpg_getBestPattern(pg, (const UChar*)aSkeleton.BeginReading(),
|
|
aSkeleton.Length(), nullptr, 0, &status);
|
|
if (status == U_BUFFER_OVERFLOW_ERROR) { // expected
|
|
aRetVal.SetLength(len);
|
|
status = U_ZERO_ERROR;
|
|
udatpg_getBestPattern(pg, (const UChar*)aSkeleton.BeginReading(),
|
|
aSkeleton.Length(), (UChar*)aRetVal.BeginWriting(),
|
|
len, &status);
|
|
}
|
|
|
|
udatpg_close(pg);
|
|
|
|
return U_SUCCESS(status);
|
|
}
|
|
|
|
/**
|
|
* This function returns a pattern that should be used to join date and time
|
|
* patterns into a single date/time pattern string.
|
|
*
|
|
* It's useful for OSes that do not provide an API to retrieve such combined
|
|
* pattern.
|
|
*
|
|
* An example output is "{1}, {0}".
|
|
*/
|
|
bool OSPreferences::GetDateTimeConnectorPattern(const nsACString& aLocale,
|
|
nsAString& aRetVal) {
|
|
bool result = false;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UDateTimePatternGenerator* pg =
|
|
udatpg_open(PromiseFlatCString(aLocale).get(), &status);
|
|
if (U_SUCCESS(status)) {
|
|
int32_t resultSize;
|
|
const UChar* value = udatpg_getDateTimeFormat(pg, &resultSize);
|
|
MOZ_ASSERT(resultSize >= 0);
|
|
|
|
aRetVal.Assign((char16_t*)value, resultSize);
|
|
result = true;
|
|
}
|
|
udatpg_close(pg);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* mozIOSPreferences methods
|
|
*/
|
|
NS_IMETHODIMP
|
|
OSPreferences::GetSystemLocales(nsTArray<nsCString>& aRetVal) {
|
|
if (!mSystemLocales.IsEmpty()) {
|
|
aRetVal = mSystemLocales;
|
|
return NS_OK;
|
|
}
|
|
|
|
if (ReadSystemLocales(aRetVal)) {
|
|
mSystemLocales = aRetVal;
|
|
return NS_OK;
|
|
}
|
|
|
|
// If we failed to get the system locale, we still need
|
|
// to return something because there are tests out there that
|
|
// depend on system locale to be set.
|
|
aRetVal.AppendElement(NS_LITERAL_CSTRING("en-US"));
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
OSPreferences::GetSystemLocale(nsACString& aRetVal) {
|
|
if (!mSystemLocales.IsEmpty()) {
|
|
aRetVal = mSystemLocales[0];
|
|
} else {
|
|
AutoTArray<nsCString, 10> locales;
|
|
GetSystemLocales(locales);
|
|
if (!locales.IsEmpty()) {
|
|
aRetVal = locales[0];
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
OSPreferences::GetRegionalPrefsLocales(nsTArray<nsCString>& aRetVal) {
|
|
if (!mRegionalPrefsLocales.IsEmpty()) {
|
|
aRetVal = mRegionalPrefsLocales;
|
|
return NS_OK;
|
|
}
|
|
|
|
if (ReadRegionalPrefsLocales(aRetVal)) {
|
|
mRegionalPrefsLocales = aRetVal;
|
|
return NS_OK;
|
|
}
|
|
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
static OSPreferences::DateTimeFormatStyle ToDateTimeFormatStyle(
|
|
int32_t aTimeFormat) {
|
|
switch (aTimeFormat) {
|
|
// See mozIOSPreferences.idl for the integer values here.
|
|
case 0:
|
|
return OSPreferences::DateTimeFormatStyle::None;
|
|
case 1:
|
|
return OSPreferences::DateTimeFormatStyle::Short;
|
|
case 2:
|
|
return OSPreferences::DateTimeFormatStyle::Medium;
|
|
case 3:
|
|
return OSPreferences::DateTimeFormatStyle::Long;
|
|
case 4:
|
|
return OSPreferences::DateTimeFormatStyle::Full;
|
|
}
|
|
return OSPreferences::DateTimeFormatStyle::Invalid;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
OSPreferences::GetDateTimePattern(int32_t aDateFormatStyle,
|
|
int32_t aTimeFormatStyle,
|
|
const nsACString& aLocale,
|
|
nsAString& aRetVal) {
|
|
DateTimeFormatStyle dateStyle = ToDateTimeFormatStyle(aDateFormatStyle);
|
|
if (dateStyle == DateTimeFormatStyle::Invalid) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
DateTimeFormatStyle timeStyle = ToDateTimeFormatStyle(aTimeFormatStyle);
|
|
if (timeStyle == DateTimeFormatStyle::Invalid) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
// If the user is asking for None on both, date and time style,
|
|
// let's exit early.
|
|
if (timeStyle == DateTimeFormatStyle::None &&
|
|
dateStyle == DateTimeFormatStyle::None) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!ReadDateTimePattern(dateStyle, timeStyle, aLocale, aRetVal)) {
|
|
if (!GetDateTimePatternForStyle(dateStyle, timeStyle, aLocale, aRetVal)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|