haiku.git

/*
 * Copyright 2003-2012, Haiku. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Axel Dörfler, axeld@pinc-software.de
 *		Oliver Tappe, zooey@hirschkaefer.de
 */


#include <unicode/uversion.h>
#include <LocaleRoster.h>

#include <assert.h>
#include <ctype.h>

#include <new>

#include <Autolock.h>
#include <Bitmap.h>
#include <Catalog.h>
#include <Entry.h>
#include <FormattingConventions.h>
#include <fs_attr.h>
#include <IconUtils.h>
#include <Language.h>
#include <Locale.h>
#include <LocaleRosterData.h>
#include <MutableLocaleRoster.h>
#include <Node.h>
#include <Roster.h>
#include <String.h>
#include <TimeZone.h>

#include <ICUWrapper.h>
#include <locks.h>

// ICU includes
#include <unicode/locdspnm.h>
#include <unicode/locid.h>
#include <unicode/timezone.h>


using BPrivate::CatalogAddOnInfo;
using BPrivate::MutableLocaleRoster;
U_NAMESPACE_USE


/*
 * several attributes/resource-IDs used within the Locale Kit:
 */
const char* BLocaleRoster::kCatLangAttr = "BEOS:LOCALE_LANGUAGE";
	// name of catalog language, lives in every catalog file
const char* BLocaleRoster::kCatSigAttr = "BEOS:LOCALE_SIGNATURE";
	// catalog signature, lives in every catalog file
const char* BLocaleRoster::kCatFingerprintAttr = "BEOS:LOCALE_FINGERPRINT";
	// catalog fingerprint, may live in catalog file

const char* BLocaleRoster::kEmbeddedCatAttr = "BEOS:LOCALE_EMBEDDED_CATALOG";
	// attribute which contains flattened data of embedded catalog
	// this may live in an app- or add-on-file
int32 BLocaleRoster::kEmbeddedCatResId = 0xCADA;
	// a unique value used to identify the resource (=> embedded CAtalog DAta)
	// which contains flattened data of embedded catalog.
	// this may live in an app- or add-on-file


static const char*
country_code_for_language(const BLanguage& language)
{
	if (language.IsCountrySpecific())
		return language.CountryCode();

	// TODO: implement for real! For now, we just map some well known
	// languages to countries to make FirstBootPrompt happy.
	switch ((tolower(language.Code()[0]) << 8) | tolower(language.Code()[1])) {
		case 'be':	// Belarus
			return "BY";
		case 'cs':	// Czech Republic
			return "CZ";
		case 'da':	// Denmark
			return "DK";
		case 'el':	// Greece
			return "GR";
		case 'en':	// United Kingdom
			return "GB";
		case 'hi':	// India
			return "IN";
		case 'ja':	// Japan
			return "JP";
		case 'ko':	// South Korea
			return "KR";
		case 'nb':	// Norway
			return "NO";
		case 'pa':	// Pakistan
			return "PK";
		case 'sv':	// Sweden
			return "SE";
		case 'uk':	// Ukraine
			return "UA";
		case 'zh':	// China
			return "CN";

		// Languages with a matching country name
		case 'de':	// Germany
		case 'es':	// Spain
		case 'fi':	// Finland
		case 'fr':	// France
		case 'hr':	// Croatia
		case 'hu':	// Hungary
		case 'it':	// Italy
		case 'lt':	// Lithuania
		case 'nl':	// Netherlands
		case 'pl':	// Poland
		case 'pt':	// Portugal
		case 'ro':	// Romania
		case 'ru':	// Russia
		case 'sk':	// Slovakia
			return language.Code();
	}

	return NULL;
}


// #pragma mark -


BLocaleRoster::BLocaleRoster()
	:
	fData(new(std::nothrow) BPrivate::LocaleRosterData(BLanguage("en_US"),
		BFormattingConventions("en_US")))
{
}


BLocaleRoster::~BLocaleRoster()
{
	delete fData;
}


/*static*/ BLocaleRoster*
BLocaleRoster::Default()
{
	return MutableLocaleRoster::Default();
}


status_t
BLocaleRoster::Refresh()
{
	return fData->Refresh();
}


status_t
BLocaleRoster::GetDefaultTimeZone(BTimeZone* timezone) const
{
	if (!timezone)
		return B_BAD_VALUE;

	BAutolock lock(fData->fLock);
	if (!lock.IsLocked())
		return B_ERROR;

	*timezone = fData->fDefaultTimeZone;

	return B_OK;
}


const BLocale*
BLocaleRoster::GetDefaultLocale() const
{
	return &fData->fDefaultLocale;
}


status_t
BLocaleRoster::GetLanguage(const char* languageCode,
	BLanguage** _language) const
{
	if (_language == NULL || languageCode == NULL || languageCode[0] == '\0')
		return B_BAD_VALUE;

	BLanguage* language = new(std::nothrow) BLanguage(languageCode);
	if (language == NULL)
		return B_NO_MEMORY;

	*_language = language;
	return B_OK;
}


status_t
BLocaleRoster::GetPreferredLanguages(BMessage* languages) const
{
	if (!languages)
		return B_BAD_VALUE;

	BAutolock lock(fData->fLock);
	if (!lock.IsLocked())
		return B_ERROR;

	*languages = fData->fPreferredLanguages;

	return B_OK;
}


/**
 * \brief Fills \c message with 'language'-fields containing the language-
 * ID(s) of all available languages.
 */
status_t
BLocaleRoster::GetAvailableLanguages(BMessage* languages) const
{
	if (!languages)
		return B_BAD_VALUE;

	int32_t localeCount;
	const Locale* icuLocaleList = Locale::getAvailableLocales(localeCount);

	for (int i = 0; i < localeCount; i++)
		languages->AddString("language", icuLocaleList[i].getName());

	return B_OK;
}


status_t
BLocaleRoster::GetAvailableCountries(BMessage* countries) const
{
	if (!countries)
		return B_BAD_VALUE;

	int32 i;
	const char* const* countryList = uloc_getISOCountries();

	for (i = 0; countryList[i] != NULL; i++)
		countries->AddString("country", countryList[i]);

	return B_OK;
}


status_t
BLocaleRoster::GetAvailableTimeZones(BMessage* timeZones) const
{
	if (!timeZones)
		return B_BAD_VALUE;

	status_t status = B_OK;

	StringEnumeration* zoneList = TimeZone::createEnumeration();

	UErrorCode icuStatus = U_ZERO_ERROR;
	int32 count = zoneList->count(icuStatus);
	if (U_SUCCESS(icuStatus)) {
		for (int i = 0; i < count; ++i) {
			const char* zoneID = zoneList->next(NULL, icuStatus);
			if (zoneID == NULL || !U_SUCCESS(icuStatus)) {
				status = B_ERROR;
				break;
			}
 			timeZones->AddString("timeZone", zoneID);
		}
	} else
		status = B_ERROR;

	delete zoneList;

	return status;
}


status_t
BLocaleRoster::GetAvailableTimeZonesWithRegionInfo(BMessage* timeZones) const
{
	if (!timeZones)
		return B_BAD_VALUE;

	status_t status = B_OK;

	UErrorCode icuStatus = U_ZERO_ERROR;

	StringEnumeration* zoneList = TimeZone::createTimeZoneIDEnumeration(
		UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, icuStatus);

	int32 count = zoneList->count(icuStatus);
	if (U_SUCCESS(icuStatus)) {
		for (int i = 0; i < count; ++i) {
			const char* zoneID = zoneList->next(NULL, icuStatus);
			if (zoneID == NULL || !U_SUCCESS(icuStatus)) {
				status = B_ERROR;
				break;
			}
			timeZones->AddString("timeZone", zoneID);

			char region[5];
			icuStatus = U_ZERO_ERROR;
			TimeZone::getRegion(zoneID, region, 5, icuStatus);
			if (!U_SUCCESS(icuStatus)) {
				status = B_ERROR;
				break;
			}
			timeZones->AddString("region", region);
		}
	} else
		status = B_ERROR;

	delete zoneList;

	return status;
}


status_t
BLocaleRoster::GetAvailableTimeZonesForCountry(BMessage* timeZones,
	const char* countryCode) const
{
	if (!timeZones)
		return B_BAD_VALUE;

	status_t status = B_OK;

	StringEnumeration* zoneList = TimeZone::createEnumeration(countryCode);
		// countryCode == NULL will yield all timezones not bound to a country

	UErrorCode icuStatus = U_ZERO_ERROR;
	int32 count = zoneList->count(icuStatus);
	if (U_SUCCESS(icuStatus)) {
		for (int i = 0; i < count; ++i) {
			const char* zoneID = zoneList->next(NULL, icuStatus);
			if (zoneID == NULL || !U_SUCCESS(icuStatus)) {
				status = B_ERROR;
				break;
			}
			timeZones->AddString("timeZone", zoneID);
		}
	} else
		status = B_ERROR;

	delete zoneList;

	return status;
}


status_t
BLocaleRoster::GetFlagIconForCountry(BBitmap* flagIcon, const char* countryCode)
{
	if (countryCode == NULL)
		return B_BAD_VALUE;

	BAutolock lock(fData->fLock);
	if (!lock.IsLocked())
		return B_ERROR;

	BResources* resources;
	status_t status = fData->GetResources(&resources);
	if (status != B_OK)
		return status;

	// Normalize the country code: 2 letters uppercase
	// filter things out so that "pt_BR" gives the flag for brazil

	int codeLength = strlen(countryCode);
	if (codeLength < 2)
		return B_BAD_VALUE;

	char normalizedCode[8];
	strcpy(normalizedCode, "flag-");
	normalizedCode[5] = tolower(countryCode[codeLength - 2]);
	normalizedCode[6] = tolower(countryCode[codeLength - 1]);
	normalizedCode[7] = '\0';

	size_t size;
	const void* buffer = resources->LoadResource(B_VECTOR_ICON_TYPE,
		normalizedCode, &size);
	if (buffer == NULL || size == 0)
		return B_NAME_NOT_FOUND;

	return BIconUtils::GetVectorIcon(static_cast<const uint8*>(buffer), size,
		flagIcon);
}


status_t
BLocaleRoster::GetFlagIconForLanguage(BBitmap* flagIcon,
	const char* languageCode)
{
	if (languageCode == NULL || languageCode[0] == '\0'
		|| languageCode[1] == '\0')
		return B_BAD_VALUE;

	BAutolock lock(fData->fLock);
	if (!lock.IsLocked())
		return B_ERROR;

	BResources* resources;
	status_t status = fData->GetResources(&resources);
	if (status != B_OK)
		return status;

	// Normalize the language code: first two letters, lowercase

	char normalizedCode[3];
	normalizedCode[0] = tolower(languageCode[0]);
	normalizedCode[1] = tolower(languageCode[1]);
	normalizedCode[2] = '\0';

	size_t size;
	const void* buffer = resources->LoadResource(B_VECTOR_ICON_TYPE,
		normalizedCode, &size);
	if (buffer != NULL && size != 0) {
		return BIconUtils::GetVectorIcon(static_cast<const uint8*>(buffer),
			size, flagIcon);
	}

	// There is no language flag, try to get the default country's flag for
	// the language instead.

	BLanguage language(languageCode);
	const char* countryCode = country_code_for_language(language);
	if (countryCode == NULL)
		return B_NAME_NOT_FOUND;

	return GetFlagIconForCountry(flagIcon, countryCode);
}


status_t
BLocaleRoster::GetAvailableCatalogs(BMessage*  languageList,
	const char* sigPattern,	const char* langPattern, int32 fingerprint) const
{
	if (languageList == NULL)
		return B_BAD_VALUE;

	BAutolock lock(fData->fLock);
	if (!lock.IsLocked())
		return B_ERROR;

	int32 count = fData->fCatalogAddOnInfos.CountItems();
	for (int32 i = 0; i < count; ++i) {
		CatalogAddOnInfo* info
			= (CatalogAddOnInfo*)fData->fCatalogAddOnInfos.ItemAt(i);

		if (!info->fLanguagesFunc)
			continue;

		info->fLanguagesFunc(languageList, sigPattern, langPattern,
			fingerprint);
	}

	return B_OK;
}


bool
BLocaleRoster::IsFilesystemTranslationPreferred() const
{
	BAutolock lock(fData->fLock);
	if (!lock.IsLocked())
		return B_ERROR;

	return fData->fIsFilesystemTranslationPreferred;
}


/*!	\brief Looks up a localized filename from a catalog.
	\param localizedFileName A pre-allocated BString object for the result
		of the lookup.
	\param ref An entry_ref with an attribute holding data for catalog lookup.
	\param traverse A boolean to decide if symlinks are to be traversed.
	\return
	- \c B_OK: success
	- \c B_ENTRY_NOT_FOUND: failure. Attribute not found, entry not found
		in catalog, etc
	- other error codes: failure

	Attribute format:  "signature:context:string"
	(no colon in any of signature, context and string)

	Lookup is done for the top preferred language, only.
	Lookup fails if a comment is present in the catalog entry.
*/
status_t
BLocaleRoster::GetLocalizedFileName(BString& localizedFileName,
	const entry_ref& ref, bool traverse)
{
	BString signature;
	BString context;
	BString string;

	status_t status = _PrepareCatalogEntry(ref, signature, context, string,
		traverse);

	if (status != B_OK)
		return status;

	// Try to get entry_ref for signature from above
	BRoster roster;
	entry_ref catalogRef;
	// The signature is missing application/
	signature.Prepend("application/");
	status = roster.FindApp(signature, &catalogRef);
	if (status != B_OK)
		return status;

	BCatalog catalog(catalogRef);
	const char* temp = catalog.GetString(string, context);

	if (temp == NULL)
		return B_ENTRY_NOT_FOUND;

	localizedFileName = temp;
	return B_OK;
}


static status_t
_InitializeCatalog(void* param)
{
	BCatalog* catalog = (BCatalog*)param;

	// figure out image (shared object) from catalog address
	image_info info;
	int32 cookie = 0;
	bool found = false;

	while (get_next_image_info(0, &cookie, &info) == B_OK) {
		if ((char*)info.data < (char*)catalog && (char*)info.data
				+ info.data_size > (char*)catalog) {
			found = true;
			break;
		}
	}

	if (!found)
		return B_NAME_NOT_FOUND;

	// load the catalog for this mimetype
	entry_ref ref;
	if (BEntry(info.name).GetRef(&ref) == B_OK && catalog->SetTo(ref) == B_OK)
		return B_OK;
	
	return B_ERROR;
}


BCatalog*
BLocaleRoster::_GetCatalog(BCatalog* catalog, int32* catalogInitStatus)
{
	// This function is used in the translation macros, so it can't return a
	// status_t. Maybe it could throw exceptions ?

	__init_once(catalogInitStatus, _InitializeCatalog, catalog);
	return catalog;
}


status_t
BLocaleRoster::_PrepareCatalogEntry(const entry_ref& ref, BString& signature,
	BString& context, BString& string, bool traverse)
{
	BEntry entry(&ref, traverse);
	if (!entry.Exists())
		return B_ENTRY_NOT_FOUND;

	BNode node(&entry);
	status_t status = node.InitCheck();
	if (status != B_OK)
		return status;

	status = node.ReadAttrString("SYS:NAME", &signature);
	if (status != B_OK)
		return status;

	int32 first = signature.FindFirst(':');
	int32 last = signature.FindLast(':');
	if (first == last)
		return B_ENTRY_NOT_FOUND;

	context = signature;
	string = signature;

	signature.Truncate(first);
	context.Truncate(last);
	context.Remove(0, first + 1);
	string.Remove(0, last + 1);

	if (signature.Length() == 0 || context.Length() == 0
		|| string.Length() == 0)
		return B_ENTRY_NOT_FOUND;

	return B_OK;
}