// Copyright (c) 1997-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:

// Started by DWW, November 1995

// BAFL utilities static class

//

//

#include "BaUtilsImp.h"

#include <e32hal.h>

#include <bautils.h>

#include <baflpan.h>

#include <baliba.h>

#include <hal.h>

#include <hal_data.h>

#include <utf.h>

/**

Mimimum length of a filename and mimimum length of a suffix.

Note these two values are tied together.

*/

const TInt KInvNameAndMinSuffixLength = 2;

#define ISDIGIT(c) (c-'0' >= 0 && c-'0' <= 9)

_LIT(KAllDrives, "YXWVUTSRQPONMLKJIHGFEDCBAZ");

const TInt KDriveAndPathLength = 3;

// screen calibration stuff

_LIT(KScreenCalibrationFolder,"\\System\\Data\\");

_LIT(KScreenCalibrationFileName, "Screen.DAT");

const TInt KScreenCalibrationPathLength = 23;	// folder + filename

// #define DO_PROFILING

#if defined(DO_PROFILING)

#pragma message ("------------ N.B. profiling of \"BaflUtils::NearestLanguageFile\" is enabled")

#include <e32svr.h>

#define FIRST_PROFILE_INDEX	50

#define PROFILE_INDEX_1		(FIRST_PROFILE_INDEX+0)

#define PROFILE_COUNT		1

#endif

// BaflUtils

class BaflDir : public CDir

	{

public:

	void RemoveSystem();

	TInt SortByTable(CBaflFileSortTable* aTable);

private:

	TInt MinEntrySize(const TEntry & aEntry);

	};

LOCAL_C const TLanguage dp0[] = { ELangCanadianEnglish, ELangAmerican,ELangEnglish, ELangEnglish_Apac,ELangEnglish_Taiwan,ELangEnglish_HongKong,ELangEnglish_Prc,ELangEnglish_Japan,ELangEnglish_Thailand,ELangEnglish_India,ELangAustralian,ELangNewZealand,ELangInternationalEnglish,ELangSouthAfricanEnglish,ELangNone };

LOCAL_C const TLanguage dp1[] = { ELangAmerican, ELangEnglish,ELangCanadianEnglish, ELangEnglish_Apac,ELangEnglish_Taiwan,ELangEnglish_HongKong,ELangEnglish_Prc,ELangEnglish_Japan,ELangEnglish_Thailand,ELangEnglish_India,ELangAustralian,ELangNewZealand,ELangInternationalEnglish,ELangSouthAfricanEnglish, ELangNone };

LOCAL_C const TLanguage dp2[] = { ELangAustralian, ELangEnglish, ELangAmerican, ELangEnglish_Apac,ELangEnglish_Taiwan,ELangEnglish_HongKong,ELangEnglish_Prc,ELangEnglish_Japan,ELangEnglish_Thailand,ELangEnglish_India,ELangNewZealand,ELangInternationalEnglish,ELangSouthAfricanEnglish, ELangCanadianEnglish,ELangNone };

LOCAL_C const TLanguage dp3[] = { ELangSouthAfricanEnglish, ELangEnglish, ELangAustralian, ELangAmerican, ELangEnglish_Apac,ELangEnglish_Taiwan,ELangEnglish_HongKong,ELangEnglish_Prc,ELangEnglish_Japan,ELangEnglish_Thailand,ELangEnglish_India,ELangNewZealand,ELangInternationalEnglish,ELangCanadianEnglish,ELangNone };

LOCAL_C const TLanguage dp4[] = { ELangInternationalEnglish, ELangEnglish, ELangAustralian, ELangAmerican, ELangEnglish_Apac,ELangEnglish_Taiwan,ELangEnglish_HongKong,ELangEnglish_Prc,ELangEnglish_Japan,ELangEnglish_Thailand,ELangEnglish_India,ELangNewZealand,ELangSouthAfricanEnglish,ELangCanadianEnglish,ELangNone };

LOCAL_C const TLanguage dp5[] = { ELangEnglish_Apac, ELangEnglish, ELangAustralian, ELangAmerican,ELangInternationalEnglish,ELangEnglish_Taiwan,ELangEnglish_HongKong,ELangEnglish_Prc,ELangEnglish_Japan,ELangEnglish_Thailand,ELangEnglish_India,ELangNewZealand,ELangSouthAfricanEnglish,ELangCanadianEnglish,ELangNone };

LOCAL_C const TLanguage dp6[] = { ELangEnglish_Taiwan, ELangEnglish, ELangAustralian, ELangAmerican, ELangEnglish_Apac,ELangInternationalEnglish,ELangEnglish_HongKong,ELangEnglish_Prc,ELangEnglish_Japan,ELangEnglish_Thailand,ELangEnglish_India,ELangNewZealand,ELangSouthAfricanEnglish,ELangCanadianEnglish,ELangNone };

LOCAL_C const TLanguage dp7[] = { ELangEnglish_HongKong, ELangEnglish, ELangAustralian, ELangAmerican, ELangEnglish_Apac,ELangEnglish_Taiwan,ELangInternationalEnglish,ELangEnglish_Prc,ELangEnglish_Japan,ELangEnglish_Thailand,ELangEnglish_India,ELangNewZealand,ELangSouthAfricanEnglish,ELangCanadianEnglish,ELangNone };

LOCAL_C const TLanguage dp8[] = { ELangEnglish_Prc, ELangEnglish, ELangAustralian, ELangAmerican, ELangEnglish_Apac,ELangEnglish_Taiwan,ELangEnglish_HongKong,ELangInternationalEnglish,ELangEnglish_Japan,ELangEnglish_Thailand,ELangEnglish_India,ELangNewZealand,ELangSouthAfricanEnglish,ELangCanadianEnglish,ELangNone };

LOCAL_C const TLanguage dp9[] = { ELangEnglish_Japan, ELangEnglish, ELangAustralian, ELangAmerican, ELangEnglish_Apac,ELangEnglish_Taiwan,ELangEnglish_HongKong,ELangEnglish_Prc,ELangInternationalEnglish,ELangEnglish_Thailand,ELangEnglish_India,ELangNewZealand,ELangSouthAfricanEnglish,ELangCanadianEnglish,ELangNone };

LOCAL_C const TLanguage dp10[] = { ELangEnglish_Thailand, ELangEnglish, ELangAustralian, ELangAmerican, ELangEnglish_Apac,ELangEnglish_Taiwan,ELangEnglish_HongKong,ELangEnglish_Prc,ELangEnglish_Japan,ELangInternationalEnglish,ELangEnglish_India,ELangNewZealand,ELangSouthAfricanEnglish,ELangCanadianEnglish,ELangNone };

LOCAL_C const TLanguage dp11[] = { ELangEnglish_India, ELangEnglish, ELangAustralian, ELangAmerican, ELangEnglish_Apac,ELangEnglish_Taiwan,ELangEnglish_HongKong,ELangEnglish_Prc,ELangEnglish_Japan,ELangEnglish_Thailand,ELangInternationalEnglish,ELangNewZealand,ELangSouthAfricanEnglish,ELangCanadianEnglish,ELangNone };

LOCAL_C const TLanguage dp12[] = { ELangNewZealand, ELangEnglish, ELangAmerican, ELangEnglish_Apac,ELangEnglish_Taiwan,ELangEnglish_HongKong,ELangEnglish_Prc,ELangEnglish_Japan,ELangEnglish_Thailand,ELangEnglish_India,ELangAustralian,ELangInternationalEnglish,ELangSouthAfricanEnglish, ELangCanadianEnglish,ELangNone };

LOCAL_C const TLanguage dp13[] = { ELangInternationalFrench,ELangFrench,ELangSwissFrench,ELangBelgianFrench,ELangCanadianFrench,ELangNone };

LOCAL_C const TLanguage dp14[] = { ELangBelgianFrench, ELangFrench,ELangInternationalFrench,ELangSwissFrench,ELangCanadianFrench,ELangNone };

LOCAL_C const TLanguage dp15[] = { ELangCanadianFrench, ELangFrench,ELangInternationalFrench,ELangSwissFrench,ELangBelgianFrench,ELangNone };

LOCAL_C const TLanguage dp16[] = { ELangFrench,ELangInternationalFrench,ELangSwissFrench,ELangBelgianFrench,ELangCanadianFrench,ELangNone };

LOCAL_C const TLanguage dp17[] = { ELangSwissFrench,ELangFrench,ELangInternationalFrench,ELangBelgianFrench,ELangCanadianFrench,ELangNone };

LOCAL_C const TLanguage dp18[] = { ELangSwissGerman,ELangGerman,ELangAustrian,ELangNone };

LOCAL_C const TLanguage dp19[] = { ELangAustrian,ELangGerman,ELangSwissGerman,ELangNone };

LOCAL_C const TLanguage dp20[] = { ELangGerman,ELangSwissGerman,ELangAustrian,ELangNone };

LOCAL_C const TLanguage dp21[] = { ELangSerbian,ELangCroatian,ELangNone };

LOCAL_C const TLanguage dp22[] = { ELangCroatian,ELangSerbian,ELangNone };

LOCAL_C const TLanguage dp23[] = { ELangRomanian,ELangMoldavian,ELangNone };

LOCAL_C const TLanguage dp24[] = { ELangMoldavian,ELangRomanian,ELangNone };

LOCAL_C const TLanguage dp25[] = { ELangBelgianFlemish,ELangDutch,ELangNone };

LOCAL_C const TLanguage dp26[] = { ELangDutch,ELangBelgianFlemish,ELangNone };

LOCAL_C const TLanguage dp27[] = { ELangAfrikaans,ELangDutch,ELangNone };

LOCAL_C const TLanguage dp28[] = { ELangMalay_Apac,ELangMalay,ELangNone };

LOCAL_C const TLanguage dp29[] = { ELangIndonesian_Apac,ELangIndonesian,ELangNone };

LOCAL_C const TLanguage dp30[] = { ELangSpanish,ELangInternationalSpanish,ELangLatinAmericanSpanish,ELangNone };

LOCAL_C const TLanguage dp31[] = { ELangLatinAmericanSpanish,ELangSpanish,ELangInternationalSpanish,ELangNone };

LOCAL_C const TLanguage dp32[] = { ELangInternationalSpanish,ELangSpanish,ELangLatinAmericanSpanish,ELangNone };

LOCAL_C const TLanguage dp33[] = { ELangCyprusGreek,ELangGreek,ELangNone };

LOCAL_C const TLanguage dp34[] = { ELangGreek,ELangCyprusGreek,ELangNone };

LOCAL_C const TLanguage dp35[] = { ELangSwissItalian,ELangItalian,ELangNone };

LOCAL_C const TLanguage dp36[] = { ELangItalian,ELangSwissItalian,ELangNone };

LOCAL_C const TLanguage dp37[] = { ELangBrazilianPortuguese,ELangPortuguese,ELangNone };

LOCAL_C const TLanguage dp38[] = { ELangPortuguese,ELangBrazilianPortuguese,ELangNone };

LOCAL_C const TLanguage dp39[] = { ELangFinlandSwedish,ELangSwedish,ELangNone };

LOCAL_C const TLanguage dp40[] = { ELangSwedish,ELangFinlandSwedish,ELangNone };

LOCAL_C const TLanguage dp41[] = { ELangCyprusTurkish,ELangTurkish,ELangNone };

LOCAL_C const TLanguage dp42[] = { ELangTurkish,ELangCyprusTurkish,ELangNone };

LOCAL_C const TLanguage dp43[] = { ELangHongKongChinese, ELangTaiwanChinese, ELangPrcChinese,ELangNone };

LOCAL_C const TLanguage dp44[] = { ELangTaiwanChinese, ELangHongKongChinese,ELangPrcChinese,ELangNone };

LOCAL_C const TLanguage dp45[] = { ELangPrcChinese, ELangHongKongChinese, ELangTaiwanChinese,ELangNone };

LOCAL_C const TLanguage * const KEquivalentLists[] = { dp0,  dp1,  dp2,  dp3,  dp4,  dp5,  dp6,  

		dp7,  dp8,  dp9,  dp10,  dp11,  dp12,  dp13,  dp14,  dp15,  dp16,  dp17,

		dp18,  dp19,  dp20,  dp21,  dp22,  dp23,  dp24,  dp25,  dp26,  dp27,  

		dp28,  dp29,  dp30,  dp31,  dp32,  dp33,  dp34,  dp35,  dp36,  dp37,  

		dp38,  dp39,  dp40,  dp41,  dp42,  dp43,  dp44,  dp45};

/**

This function gets the list of languages that are 'equivalent' to the

given language. We say language L1 is equivalent to language L2 if 

speakers of L2 can readily understand L1 without intentional study 

or extraordinary effort.

The equivalence relationship is defined in a static table. Please refer 

to the definition of 'KEquivalentLists' for details.

Each row in the table is formatted like this:

@code

L1, L2, L3, ..., Ln, ELangNone

@codeend

In which L2, ..., Ln are equivalents of L1, and ELangNone marks the end of an

entry. The list is ordered. Compared with L3, L2 is nearer to L1. When choosing

an equivalent of L1, L2 shall be preferred over L3, L3 shall be preferred 

over L4, and so on.  

L1 is always returned as the ‘nearest equivalent’ of L1 itself.

BaflUtils::NearestLanguageFileV2 searches language specific resource files 

according to the 'equivalent' relationship returned by this function.

@param aLang The language whose equivalents needs to be found out.

@param aEquivalents On return, this array contains the ordered list of 

       languages that are equivalent to the given language. If there is no 

       entry for the given language in the table, this array will contain 

       two elements on return: the first is the given language itself 

       and the 2nd one is ELangNone. For any language that has equivalents 

       defined, content of he corresponding entry is returned.     

@see BaflUtils::NearestLanguageFileV2

*/ 

EXPORT_C void 

BaflUtils::GetEquivalentLanguageList(TLanguage aLang, TLanguagePath& aEquivalents) 

	{

	aEquivalents[0] = aLang;

	aEquivalents[1] = ELangNone;

	const TInt len = sizeof(KEquivalentLists) / sizeof(KEquivalentLists[0]);

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

		{

		const TLanguage *ptr = KEquivalentLists[i];

		if (ptr[0] == aLang)

			{

			TInt index = 1;

			while (ELangNone != *ptr)

				{

				aEquivalents[index++] = (TLanguage)*(++ptr);

				}

			aEquivalents[index] = ELangNone;

			break;

			} // end if ptr[0]

		} // end for i

	}

/**

NearestLanguageFileV2 is very similar to the existing 'NearestLanguageFile'

function. The only difference between NearestLanguageFile and

NearestLanguageFileV2 is the order in which language specific 

resource files are searched for. 

NearestLanguageFile searches language specific resource files in the 

order defined by the 'downgrade path' of the given language. Content of the 

downgrade path is dependent on the current active locale, and parts of 

it is runtime configurable.

NearestLanguageFileV2 searches for language specific resource files 

in the order defined by the 'language equivalence table', which is a  

static data table fixed at build time. There is one entry in the table for 

each language that has one or more equivalents.

@param aFs An active file server session.

@param aName Name of the language-neutral resource file name which consist of

an optional drive specification, followed by an optional path name,

followed by basename for filename, followed by a period and extension.

On return, in case of a match, this is replaced by the language-specific version

which consists of the last two characters of the extension plus any preceding

numeric characters being replaced by the language code. Remains unchanged when there's no match 

@param aLanguage On return, in case of a match, this is replaced by the corresponding language.

  In case of no match, it is set to ELangNone.  

@see TLanguage

@see BaflUtils::GetEquivalentLanguageList

 */

EXPORT_C void 

BaflUtils::NearestLanguageFileV2(const RFs& aFs,TFileName& aName, TLanguage& aLanguage)

	{

	TNearestLanguageFileFinder finder(aFs);

	TBool goodSuffix=finder.SetFileName(aName);

	// Continue only if the suffix is good.

	if(goodSuffix)

		{

		// add preset customised resource drive to drive list  

		// Note that errors returned from AddCustomResourceDrive are ignored. This is because if 

		// a custom resource drive has not been found we still want to continue on with searching 

		// other drives according to our algorithm

		finder.AddCustomResourceDrive();

		GetEquivalentLanguageList(User::Language(), finder.iPath);

		if (!finder.FindLanguageAndDrive()

			&& KErrNone != finder.FindFirstLanguageFileAndDrive())

			finder.RepairFileName();

		aLanguage = finder.Language();

		}

	else

		{

		aLanguage = ELangNone;

		}

	}

// TLibAssocBase

EXPORT_C TLibAssocBase::TLibAssocBase(const RLibrary& aLib,TAny* aPtr)

	: iLibrary(aLib),iPtr(aPtr)

/**

Constructs the object taking the specified DLL and a class instance.

@param aLib A reference to a DLL that has already been opened.

@param aPtr An untyped pointer to an object to be associated with the DLL.

            Typically, this object will have been created using

            the ordinal 1 function from that DLL. */	

	{}

EXPORT_C void TLibAssocBase::Set(const RLibrary& aLib,TAny* aPtr)

/**

Implements TLibAssoc::Set().

@param aLib   A reference to a DLL that has already been opened.

@param aClass A pointer to an object to be associated with the DLL.

              Typically, this object will have been created using

              the ordinal 1 function from that DLL.

@see TLibAssoc::Set */

	{

	__ASSERT_ALWAYS(iLibrary.Handle()==KNullHandle&&iPtr==NULL,Panic(EBafPanicLibAssocAlreadySet));

	iLibrary=aLib;

	iPtr=aPtr;

	}

EXPORT_C void TLibAssocBase::DoUnload(TAny* aThis)

/**

Calls Close() on the associated DLL.

@param aThis An untyped pointer to a TLibAssoc type.

*/

	{

	TLibAssocBase& l=*(TLibAssocBase*)aThis;

	l.iPtr=NULL;

	l.iLibrary.Close();

	}

//

// class BaflUtils

//

EXPORT_C void BaflUtils::CopyWithTruncation(TDes& aDest,const TDesC& aSrc,TChar aTruncationSymbol)

/** Copies a descriptor, abbreviating it to fit the destination descriptor.

If aSrc is less than the maximum length of aDest, then the string is simply 

copied to aDest.

If this is not so, then the left-most characters of aSrc are copied to aDest, 

up to aDest's maximum length-1. aDest's final character is set to be aTruncationSymbol.

@param aDest On return, the truncated string

@param aSrc The string to truncate

@param aTruncationSymbol The truncation character to add */

	{ // static

	TInt maxLength=aDest.MaxLength();

	if (aSrc.Length()<=maxLength)

		aDest.Copy(aSrc);

	else

		{

		aDest.Copy(aSrc.Left(maxLength-1));

		aDest.Append(aTruncationSymbol);

		}

	}

EXPORT_C TBool BaflUtils::FileExists(const RFs& aFileSession,const TDesC& aFileName)

/** Checks if the specified file exists.

@param aFs File server session

@param aFileName File to check

@return ETrue if the file exists, otherwise EFalse */

	{ // static

	TEntry entry;

	return(aFileSession.Entry(aFileName,entry)==KErrNone);

	}

EXPORT_C TBool BaflUtils::PathExists(RFs& aFs,const TDesC& aPath)

/** Tests whether a path exists.

The path should contain a drive letter and a directory, or EFalse is returned. 

EFalse is also returned if it contains a filename or filename extension.

If the path is badly formed, for instance if it contains illegal characters, 

or any directory name consists of a single or double dot, or any directory 

name includes wildcard characters, the function returns EFalse.

@param aFs A connected session with the file server.

@param aPath The path to test for. It should end in a backslash.

@return ETrue if the path exists, EFalse if not. EFalse is also returned if the 

specified path is badly formed. */

	{ // static

	TParse parse;

	TInt retcode;

	retcode = parse.Set(aPath, NULL, NULL);

	if (retcode != KErrNone)

		return EFalse;

	if ((! parse.DrivePresent()) || (parse.NameOrExtPresent()))

		return EFalse;

	if (parse.Path().Length() == 0)

		return EFalse;

	TFileName dirName = parse.DriveAndPath();

	if (dirName.Length() > KMaxFileName)

		return(EFalse);

    RDir dir;

    retcode = dir.Open(aFs,dirName,0);

	if (retcode == KErrNone)

		dir.Close();

	return (retcode == KErrNone);

	}

EXPORT_C void BaflUtils::EnsurePathExistsL(RFs& aFileSession,const TDesC& aFileName)

/** Makes one or more directories, if they do not already exist. 

Any valid path component in the specified path that does not already exist 

is created as a directory. If the specified path already exists, the function 

returns normally.

@param aFs File server session

@param aFileName Path to ensure exists

@see RFs::MkDirAll() */

	{ // static

	TInt error=aFileSession.MkDirAll(aFileName);

	if (error!=KErrAlreadyExists)

		User::LeaveIfError(error);

	}

EXPORT_C TPtrC BaflUtils::ExtractAppNameFromFullName(const TFullName &aName)

/** Gets the application name from a full thread name.

@param aName Thread name

@return Application name

@see RThread */

	{

	// static - return the app name (after first :: before next ::, if any) from a full thread name

	TChar delimiter=':';

	TInt start=aName.Locate(delimiter);

	if (start<0)

		start=0; // should never happen

	else if (aName.Length()>start+2)

		start+=2;

	TPtrC rest=aName.Mid(start);

	TInt end=rest.Locate(delimiter);

	return end<0 ? rest : rest.Left(end);

	}

LOCAL_C TBool IsLanguageExtended(const TLanguage aLanguage)

	{

	// For compatibility reasons, ELangNone is 0xFFFF. However, it's not an extended language.

	if ((aLanguage==ELangNone) || ((static_cast<TUint>(aLanguage))<=KDialectMask))

		return EFalse;

	else

		return ETrue;

	}

LOCAL_C TLanguage BaseLanguage(const TLanguage aLanguage)

	{

	if (IsLanguageExtended(aLanguage))

		return static_cast<TLanguage>(aLanguage & KDialectMask);

	else

		return aLanguage;

	}

LOCAL_C TLanguage NextLanguage(TLanguage aLanguage)

/** Returns the next best language to use after aLanguage,

based on Symbian's base table of language near-equivalence.

@internalAll */

	{

	switch (aLanguage)

		{

		case ELangAustralian:

		case ELangNewZealand:

		case ELangSouthAfricanEnglish:

		case ELangInternationalEnglish:

		case ELangAmerican:

		case ELangEnglish_Apac:

		case ELangEnglish_Taiwan:

		case ELangEnglish_HongKong:

		case ELangEnglish_Prc:

		case ELangEnglish_Japan:

		case ELangEnglish_Thailand:

			return ELangEnglish;

		case ELangCanadianEnglish:

			return ELangAmerican;	// 2-stage downgrade

		case ELangSwissFrench:

		case ELangBelgianFrench:

		case ELangInternationalFrench:

		case ELangCanadianFrench:

			return ELangFrench;

		case ELangSwissGerman:

		case ELangAustrian:

			return ELangGerman;

		case ELangInternationalSpanish:

		case ELangLatinAmericanSpanish:

			return ELangSpanish;

		case ELangSwissItalian:

			return ELangItalian;

		case ELangFinlandSwedish:

			return ELangSwedish;

		case ELangCyprusTurkish:

			return ELangTurkish;

		case ELangBelgianFlemish:

			return ELangDutch;

		case ELangHongKongChinese:

			return ELangTaiwanChinese;

		case ELangCyprusGreek:

			return ELangGreek;

		case ELangMalay_Apac:

			return ELangMalay;

		case ELangBrazilianPortuguese:

			return ELangPortuguese;

		default:

			return ELangNone;	

		}

	}

void AddLanguage(TLanguagePath& aPath, TLanguage aNewLanguage)

/** Add language to the language path if there is space.

The first empty slot must have "ELangNone" in it. This will also be true

on exit. */	

	{

	TLanguage *p = aPath;

	const TLanguage *end = &(aPath[KMaxDowngradeLanguages]);

	while (p != end)

		{

		if (*p == aNewLanguage)

			// language already in list

			break;

		if (*p == ELangNone)

			{

			// found the end of the list

			p[0] = aNewLanguage;

			p[1] = ELangNone;

			break;

			}

		++p;

		}

	return;

	}

void MakeLanguageDowngradePath(TLanguagePath& aPath,

	TLanguage aCurrent, TLanguage aIdeal, const TLocale& aLocale)

	{

	TInt j = 0;

	if( aIdeal != ELangNone)

		{

		aPath[j++]=aIdeal;	

		}

	aPath[j++] = aCurrent;

	aPath[j++] = ELangNone;

	if (aCurrent & ~KDialectMask)

		AddLanguage(aPath, static_cast<TLanguage>(aCurrent & KDialectMask));

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

		{

		AddLanguage(aPath, aLocale.LanguageDowngrade(i));

		AddLanguage(aPath, BaseLanguage(aLocale.LanguageDowngrade(i)));

		}

	while (ELangNone != (aCurrent = NextLanguage(BaseLanguage(aCurrent))))  

		AddLanguage(aPath, aCurrent);

	}

TInt RRealDirectoryScanner::Open(RFs& aFs, const TDesC& aMatchPattern)

	{

	return iDir.Open(aFs, aMatchPattern,

		KEntryAttReadOnly | KEntryAttHidden | KEntryAttSystem | KEntryAttArchive);

	}

TInt RRealDirectoryScanner::Next(TEntry& aOut)

	{

	return iDir.Read(aOut);

	}

void RRealDirectoryScanner::Close()

	{

	iDir.Close();

	}

/**

Simply counts the number of numerical characters at the end of the name passed.

@internalComponent

@param			aFilename The filename to parse

@return			Count of the numeric digits at the end of the name passed, 

				e.g. x.r491 gives 3.

*/

TInt TNearestLanguageFileFinder::CountDigitsFromEnd(const TDesC& aFilename)

	{

	TInt digitCount = 0;

	for (TInt idx = aFilename.Length()-1; idx>=0 && ISDIGIT (aFilename [idx]); --idx)