/*

* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Contains the source for all locale related functionalities

 *     

 *

*/

#include <stdlib.h>

#include <f32file.h>

#include "localeinfo.h"

#include "sysif.h"

#include <e32std_private.h>

#include <e32ldr_private.h>

typedef void (*TLibFn)(TLocale*);

#if (defined(__SYMBIAN32__) && (defined(__WINSCW__) || defined(__WINS__)))

#include "libc_wsd_defs.h"

#include "localetlsinfo.h"

#else

#ifdef SYMBIAN_DISTINCT_LOCALE_MODEL

#define NEW_LANG_VARIANT_DLL_NAME 30

#endif

#endif

#define LC_TIME_MEMORY 1024

#define LC_MONETARY_MEMORY 50

#define LC_NUMERIC_MEMORY 20

#define MONTHS	12

#define WEEKDAYS 7

#define DECIMAL_THOUSAND_DATE_TIME_SEPARATOR 2

#define EURO_CURRENCY 4

#define LOCALE_LENGTH 50

#define CHARACTER_SET_NAME 32

#define TIME_FORMAT_LENGTH 32

#define NON_UNICODE_TEXT_BUFFER_LENGTH 256

#define LANG_VARIANT_DLL_NAME 10

#define MONTH_STR	"%m"

#define DAY_STR		"%d"

#define YEAR_STR 	"%Y"

#define TWELVE_HOUR_STR 	"%I"

#define TWENTY_FOUR_HOUR_STR	"%H"

#define MINUTE_STR	"%M"

#define SECOND_STR	"%S"

#define AMPM_SPACE	" %p"

#define AMPM_NO_SPACE	"%p"

#ifdef SYMBIAN_DISTINCT_LOCALE_MODEL

_LIT(KLanDllName, "elocl_lan.");

_LIT(KRegDllName, "elocl_reg.");

_LIT(KColDllName, "elocl_col.");

#endif

_LIT(KDllName, "elocl");

#ifndef SYMBIAN_OE_ENHANCED_LOCALE_SUPPORT

_LIT(KEuro, "\x20AC");

#endif

_LIT8(KAMPMSpace12hr, "B");

_LIT8(KAMPMSpace, "A");

_LIT8(KAMPMNoSpace12hr, "*B");

_LIT8(KAMPMNoSpace, "*A");

#ifndef EMULATOR

CLocale* CLocale::iNewLocale = NULL;

lc_monetary_T* CLocale::iMonetary_locale = NULL;

lc_numeric_T* CLocale::iNumeric_locale =NULL;

lc_time_T* CLocale::iTime_locale = NULL;

TText8*  numericLocale =  NULL;

TText8* monetaryLocale = NULL;

TText8* timeLocale =  NULL;

static TBuf<LANG_VARIANT_DLL_NAME> DllName;

#ifdef SYMBIAN_DISTINCT_LOCALE_MODEL

static TBuf<NEW_LANG_VARIANT_DLL_NAME> ColDllName;

#endif

#else //EMULATOR

#define iNewLocale ((GetGlobals()->localeptr)->GET_WSD_VAR_NAME(iNewLocale,s))

#define iMonetary_locale ((GetGlobals()->localeptr)->GET_WSD_VAR_NAME(iMonetary_locale,s))

#define iNumeric_locale ((GetGlobals()->localeptr)->GET_WSD_VAR_NAME(iNumeric_locale,s))

#define iTime_locale ((GetGlobals()->localeptr)->GET_WSD_VAR_NAME(iTime_locale,s))

#define numericLocale ((GetGlobals()->localeptr)->GET_WSD_VAR_NAME(numericLocale,s))

#define monetaryLocale ((GetGlobals()->localeptr)->GET_WSD_VAR_NAME(monetaryLocale,s))

#define timeLocale ((GetGlobals()->localeptr)->GET_WSD_VAR_NAME(timeLocale,s))

#define DllName ((GetGlobals()->localeptr)->GET_WSD_VAR_NAME(DllName,s))

#ifdef SYMBIAN_DISTINCT_LOCALE_MODEL

#define ColDllName ((GetGlobals()->localeptr)->GET_WSD_VAR_NAME(ColDllName,s))

#endif

#endif //EMULATOR

CLocale::CLocale()

	{

	iMonetary_locale = NULL;

	iNumeric_locale = NULL;

	iTime_locale = NULL;

	numericLocale =  NULL;

    monetaryLocale = NULL;

	timeLocale =  NULL;

#ifdef SYMBIAN_DISTINCT_LOCALE_MODEL    

     iOldDllPresent = 0;

#endif

	}

CLocale* CLocale::New()

	{

	CLocale* self = new CLocale();

	if(self)

		{

		TInt ret=KErrNone;

		TRAPD(result,ret = self->ConstructL());

		if(KErrNone != (result | ret))

			{

			delete self;

			self = NULL;

			}

		}

	return self;

	}

TInt CLocale::ConstructL()

	{

	iMonetary_locale = new  lc_monetary_T;

	if(!iMonetary_locale)

		{

		return KErrNoMemory;

		}

	iNumeric_locale = new lc_numeric_T;

	if(!iNumeric_locale)

		{

		return KErrNoMemory;

		}

	iTime_locale = new (ELeave) lc_time_T;

	if(!iTime_locale)

		{

		return KErrNoMemory;

		}

	for(TInt i =0 ; i < MONTHS; i++)

		{

		iTime_locale->mon[i] = NULL;

		iTime_locale->month[i] = NULL;

		iTime_locale->alt_month[i] = NULL;	

		}

	for(TInt i =0 ; i < WEEKDAYS; i++)

		{

		iTime_locale->wday[i] = NULL;

		iTime_locale->weekday[i] = NULL;	

		}

	iTime_locale->X_fmt = NULL;

	iTime_locale->x_fmt = NULL;

	iTime_locale->c_fmt = NULL;

	iTime_locale->am = NULL;

	iTime_locale->pm = NULL;

	iTime_locale->date_fmt = NULL;

	iTime_locale->md_order = NULL;

	iTime_locale->ampm_fmt = NULL;

	iMonetary_locale->int_curr_symbol = NULL;

	iMonetary_locale->currency_symbol  = NULL;

	iMonetary_locale->mon_decimal_point = NULL;

	iMonetary_locale->mon_thousands_sep = NULL;

	iMonetary_locale->mon_grouping = NULL;

	iMonetary_locale->positive_sign = NULL;

	iMonetary_locale->negative_sign = NULL;

	iMonetary_locale->int_frac_digits = iMonetary_locale->frac_digits = NULL;

	iMonetary_locale->p_cs_precedes = iMonetary_locale->int_p_cs_precedes = NULL;

	iMonetary_locale->p_sep_by_space = iMonetary_locale->int_p_sep_by_space = NULL;

	iMonetary_locale->n_cs_precedes = iMonetary_locale->int_n_cs_precedes = NULL;

	iMonetary_locale->n_sep_by_space = iMonetary_locale->int_n_sep_by_space = NULL;

	iMonetary_locale->p_sign_posn = iMonetary_locale->int_p_sign_posn = NULL;

	iMonetary_locale->n_sign_posn = iMonetary_locale->int_n_sign_posn = NULL;

	iNumeric_locale->decimal_point = NULL;

	iNumeric_locale->thousands_sep = NULL;

	iNumeric_locale->grouping = NULL;

	return KErrNone;

	}

CLocale* CLocale::GetInstance()

	{

	// Switch to the backend heap

	RHeap* oldheap = User::SwitchHeap(Backend()->Heap());

	if(NULL == iNewLocale)	

		{

		iNewLocale = New();

		}

	if(numericLocale == NULL )

		{

		numericLocale =  new TText8 [LC_NUMERIC_MEMORY];	

		}

	if(monetaryLocale == NULL)

		{

		monetaryLocale = new TText8[LC_MONETARY_MEMORY];

		}

	if(timeLocale == NULL)

		{

		timeLocale =  new TText8[LC_TIME_MEMORY];

		}

	//Set back the default user heap

	User::SwitchHeap(oldheap);

	return iNewLocale;	

	}

void CLocale::DeleteInstance()

	{

	// Switch to the backend heap so that deletes happen from there

	RHeap* oldheap = User::SwitchHeap(Backend()->Heap());

	delete [] timeLocale;

	timeLocale =NULL;

	delete []  numericLocale;

	numericLocale = NULL;

	delete [] monetaryLocale;

	monetaryLocale = NULL;

	delete  iMonetary_locale;

	iMonetary_locale = NULL;

	delete iNumeric_locale;

	iNumeric_locale = NULL;

	delete iTime_locale;

	iTime_locale = NULL;

	delete iNewLocale;

	iNewLocale = NULL;

	//Set back to the default user heap

	User::SwitchHeap(oldheap);

	}

TText* CLocale::SetLocale(TDesC& aLocale)	

	{

		//Check whether locale is supported

		TText* retVal = NULL;

		TInt r;

#ifdef SYMBIAN_DISTINCT_LOCALE_MODEL 

		// load the new locale dll if not present check for the old dll

		r = LoadNewLocaleDll( aLocale );

        if ( r  ==  KErrNone ) 

        {

            retVal = (TText*) aLocale.Ptr();

            iOldDllPresent = 0;

            return retVal;

        }

#endif

    if(!LoadLocale(aLocale))

    {

        return NULL;

    }

    RLoader loader;

    r = loader.Connect();

    if(KErrNone == r)

        {

            //Load the language variant DLL 

            TInt size = KNumLocaleExports * sizeof(TLibraryFunction);

            TPtr8 functionListBuf((TUint8*) iData, size, size);

            r = loader.SendReceive(ELoadLocale, TIpcArgs(0, (const TDesC*)&DllName, &functionListBuf) );

            if(KErrNone == r)

            {

                ((TLibFn)iData[FnLocaleData])(&iLocale);

                retVal = (TText*) aLocale.Ptr();

#ifdef SYMBIAN_DISTINCT_LOCALE_MODEL 

                iOldDllPresent = 1;

#endif

            }

            loader.Close();

        }

    return retVal;

}

#ifdef SYMBIAN_OE_ENHANCED_LOCALE_SUPPORT

#ifdef SYMBIAN_DISTINCT_LOCALE_MODEL

TInt  CLocale::GetSystemLocale(TDesC& aLanDllName,TDesC& aRegDllName)

    {

        RLoader loader;

        TInt retVal = -1;

        TInt r = loader.Connect();

        if(KErrNone == r)

            {

            TInt size = KNumLocaleExports * sizeof(TLibraryFunction);

            TPtr8 functionListBuf1((TUint8*) iDataLanguage, size, size);

            r = loader.SendReceive(ELoadLocale, TIpcArgs(0, (const TDesC*)&aLanDllName, &functionListBuf1) );

            if(KErrNone != r)

                return retVal;

            TPtr8 functionListBuf2((TUint8*) iDataRegion, size, size);

            r = loader.SendReceive(ELoadLocale, TIpcArgs(0, (const TDesC*)&aRegDllName, &functionListBuf2) );

            ((TLibFn)iDataRegion[FnLocaleDataV2])(&iLocale);

            if(KErrNone != r)

                return retVal;

            retVal = 0;

            loader.Close();

            }

        return retVal;

    }

#endif

//Load the system dll settings

TInt CLocale::GetSystemLocale(TDesC& aDllName)	

	{

		RLoader loader;

		TInt retVal = -1;

		TInt r = loader.Connect();

		if(KErrNone == r)

			{

			//Load the language variant DLL 

			TInt size = KNumLocaleExports * sizeof(TLibraryFunction);

          	TPtr8 functionListBuf((TUint8*) iData, size, size);

          	r = loader.SendReceive(ELoadLocale, TIpcArgs(0, (const TDesC*)&aDllName, &functionListBuf) );

			if(KErrNone == r)

				{

            	((TLibFn)iData[FnLocaleData])(&iLocale);

            	retVal = 0;

				}

			loader.Close();

			}

		return retVal;

	}

#endif

TInt CLocale::MonetaryLoadLocaleL(const char* localeName)

{

    #ifdef SYMBIAN_OE_ENHANCED_LOCALE_SUPPORT

        TInt charsetID=-1;

        if(localeName)

        {

            charsetID = GetCharcaterSetIDL(localeName);

            if(charsetID == -1)

            {

                return -1;

            }

        }

    #else

        TInt charsetID = GetCharcaterSetIDL(localeName);

        if(charsetID == -1)

        {

            return -1;

        }

    #endif

    #ifdef SYMBIAN_OE_ENHANCED_LOCALE_SUPPORT

	    else

        {

        //update the iLocale with the system locale settings

            iLocale.Refresh();	

        }

    #endif

    #ifndef SYMBIAN_OE_ENHANCED_LOCALE_SUPPORT

        //Retreive monetary information from language variant DLL

        Mem::Copy(&iLocaleSettings.iCurrencySymbol[0], (const TAny*) iData[FnCurrencySymbol](), sizeof(TText) * (KMaxCurrencySymbol+1));	

    #endif

        TLocalePos aCurrencySymbolPosition = iLocale.CurrencySymbolPosition();

        TLocale::TNegativeCurrencyFormat aNegativeCurrencyFormat = iLocale.NegativeCurrencyFormat();

        TBool aCurrencySpaceBetween = iLocale.CurrencySpaceBetween();

        TBool aNegativeCurrencySymbolOpposite = iLocale.NegativeCurrencySymbolOpposite();

        TBool aNegativeLoseSpace = iLocale.NegativeLoseSpace();

        TBool aCurrencyTriadsAllowed = iLocale.CurrencyTriadsAllowed();

        TInt currencyDecimalPlaces = iLocale.CurrencyDecimalPlaces();

        iThousandsSeparator= iLocale.ThousandsSeparator();

        iDecimalSeparator = iLocale.DecimalSeparator();

        TText8* temp = monetaryLocale;

        //Set the decimal separator

        const TText* dec_point = (const TText*) &iDecimalSeparator;

        if(dec_point)

        {

            const TPtrC dec(dec_point);

            TBuf8<DECIMAL_THOUSAND_DATE_TIME_SEPARATOR> decimal;

            decimal.Copy(dec);

            strncpy((char*) monetaryLocale, (char*) decimal.Ptr(), decimal.Length());

            monetaryLocale[decimal.Length()] = '\0';

            iMonetary_locale->mon_decimal_point = (const char*) monetaryLocale;

            monetaryLocale += decimal.Length() + 1;

        }

        //Set thousand separator

        const TText* thous_sep = (const TText*) &iThousandsSeparator;

        if(thous_sep)

        {

            const TPtrC thousand(thous_sep);

            TBuf8<DECIMAL_THOUSAND_DATE_TIME_SEPARATOR> thousand_sep;

            thousand_sep.Copy(thousand);

            strncpy((char*) monetaryLocale, (char*) thousand_sep.Ptr(), thousand_sep.Length());

            monetaryLocale[thousand_sep.Length()] = '\0';

            iMonetary_locale->mon_thousands_sep = (const char*) monetaryLocale;

            monetaryLocale += thousand_sep.Length() + 1;

        }

    #ifdef SYMBIAN_OE_ENHANCED_LOCALE_SUPPORT

        TBuf<KMaxCurrencySymbol> CurrencySymbol;

        if(localeName)

        {

#ifdef  SYMBIAN_DISTINCT_LOCALE_MODEL

        if( iOldDllPresent ) // old style dll is loaded

            {

                Mem::Copy(&iLocaleSettings.iCurrencySymbol[0], (const TAny*) iData[FnCurrencySymbol](), sizeof(TText) * (KMaxCurrencySymbol+1));

            }

        else

            {

                Mem::Copy(&iLocaleSettings.iCurrencySymbol[0], (const TAny*) iDataRegion[FnCurrencySymbolV2](), sizeof(TText) * (KMaxCurrencySymbol+1));

            }

#else

        Mem::Copy(&iLocaleSettings.iCurrencySymbol[0], (const TAny*) iData[FnCurrencySymbol](), sizeof(TText) * (KMaxCurrencySymbol+1));

#endif

        //Set Currency information

        const TText16* cur = iLocaleSettings.iCurrencySymbol;

        const TPtrC currency(cur);

        CurrencySymbol.Copy(currency);

        }

        else

        {

        TCurrencySymbol cur;

        const TPtrC currency(cur);

        CurrencySymbol.Copy(currency);

        }

        strncpy((char*) monetaryLocale, (char*) CurrencySymbol.Ptr(), CurrencySymbol.Length());

        monetaryLocale[CurrencySymbol.Length()] = '\0';

            iMonetary_locale->currency_symbol = (const char*) monetaryLocale;

            monetaryLocale += strlen((char*) monetaryLocale) + 1;

    #else	

        //Set Currency information

        const TText16* currency = iLocaleSettings.iCurrencySymbol;

        if(currency)

        {

            TBuf<EURO_CURRENCY> euroSymbol(currency);

            char* temp = strchr(localeName, '.');

            temp = temp + 1;

            if(!euroSymbol.Compare(KEuro) && !strcmp(temp, "ISO-8859-1"))

            {

                strcpy((char*) monetaryLocale,"\x80");

                monetaryLocale[1] = '\0';					

            }

            else

            {

                ConvertToMultiByteL((TText8*)monetaryLocale, currency, charsetID);	

            }

            iMonetary_locale->currency_symbol = (const char*) monetaryLocale;

            monetaryLocale += strlen((char*) monetaryLocale) + 1;

        }

    #endif

        //Set grouping information

        strcpy((char*) monetaryLocale,(aCurrencyTriadsAllowed? "\003":""));

        monetaryLocale[strlen((char*) monetaryLocale)] = '\0';

        iMonetary_locale->mon_grouping = (const char*) monetaryLocale;

        monetaryLocale += strlen((char*) monetaryLocale) + 1;

        //Set currency decimal places

        iMonetary_locale->int_frac_digits =	iMonetary_locale->frac_digits = (const char*) monetaryLocale;

        *monetaryLocale++ = currencyDecimalPlaces;

        *monetaryLocale++ = '\0';

        //Set the currency symbol position for a monetary quantity with non-negative value 

        iMonetary_locale->p_cs_precedes = (const char*) monetaryLocale;

        iMonetary_locale->int_p_cs_precedes = iMonetary_locale->p_cs_precedes;

        *monetaryLocale++ = (ELocaleBefore == aCurrencySymbolPosition)?1:0;

        *monetaryLocale++ = '\0';

        //Set the currency symbol position for a monetary quantity with negative value		

        iMonetary_locale->n_cs_precedes = (const char*) monetaryLocale;

        iMonetary_locale->int_n_cs_precedes = iMonetary_locale->n_cs_precedes;

        *monetaryLocale++ = aNegativeCurrencySymbolOpposite?0:1;

        *monetaryLocale++ ='\0';

        //Set the currency symbol separated by space or not for a monetary quantity with non-negative value

        iMonetary_locale->p_sep_by_space = (const char*) monetaryLocale;

        iMonetary_locale->int_p_sep_by_space = iMonetary_locale->p_sep_by_space;

        *monetaryLocale++ = aCurrencySpaceBetween?1:0;	

        *monetaryLocale++ ='\0';

        //Set the currency symbol separated by space or not for a monetary quantity with negative value