1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Started by DWW, November 1995

    15 // BAFL utilities static class

    16 //

    17 //

    18 

    19 #include "BaUtilsImp.h"

    20 #include <e32hal.h>

    21 #include <bautils.h>

    22 #include <baflpan.h>

    23 #include <baliba.h>

    24 #include <hal.h>

    25 #include <hal_data.h>

    26 #include <utf.h>

    27 

    28 /**

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

    30 Note these two values are tied together.

    31 */

    32 const TInt KInvNameAndMinSuffixLength = 2;

    33 

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

    35 

    36 _LIT(KAllDrives, "YXWVUTSRQPONMLKJIHGFEDCBAZ");

    37 const TInt KDriveAndPathLength = 3;

    38 

    39 // screen calibration stuff

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

    41 _LIT(KScreenCalibrationFileName, "Screen.DAT");

    42 const TInt KScreenCalibrationPathLength = 23;	// folder + filename

    43 

    44 

    45 // #define DO_PROFILING

    46 

    47 #if defined(DO_PROFILING)

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

    49 #include <e32svr.h>

    50 #define FIRST_PROFILE_INDEX	50

    51 #define PROFILE_INDEX_1		(FIRST_PROFILE_INDEX+0)

    52 #define PROFILE_COUNT		1

    53 #endif

    54 

    55 // BaflUtils

    56 

    57 class BaflDir : public CDir

    58 	{

    59 public:

    60 	void RemoveSystem();

    61 	TInt SortByTable(CBaflFileSortTable* aTable);

    62 private:

    63 	TInt MinEntrySize(const TEntry & aEntry);

    64 	};

    65 

    66 

    67 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 };

    68 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 };

    69 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 };

    70 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 };

    71 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 };

    72 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 };

    73 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 };

    74 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 };

    75 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 };

    76 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 };

    77 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 };

    78 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 };

    79 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 };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   118 

   119 /**

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

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

   122 speakers of L2 can readily understand L1 without intentional study 

   123 or extraordinary effort.

   124 

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

   126 to the definition of 'KEquivalentLists' for details.

   127 Each row in the table is formatted like this:

   128 @code

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

   130 @codeend

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

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

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

   134 over L4, and so on.  

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

   136 

   137 BaflUtils::NearestLanguageFileV2 searches language specific resource files 

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

   139  

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

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

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

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

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

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

   146        defined, content of he corresponding entry is returned.     

   147        

   148 @see BaflUtils::NearestLanguageFileV2

   149 */ 

   150 EXPORT_C void 

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

   152 	{

   153 	aEquivalents[0] = aLang;

   154 	aEquivalents[1] = ELangNone;

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

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

   157 		{

   158 		const TLanguage *ptr = KEquivalentLists[i];

   159 		if (ptr[0] == aLang)

   160 			{

   161 			TInt index = 1;

   162 			while (ELangNone != *ptr)

   163 				{

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

   165 				}

   166 			aEquivalents[index] = ELangNone;

   167 			break;

   168 			} // end if ptr[0]

   169 		} // end for i

   170 	}

   171 

   172 /**

   173 NearestLanguageFileV2 is very similar to the existing 'NearestLanguageFile'

   174 function. The only difference between NearestLanguageFile and

   175 NearestLanguageFileV2 is the order in which language specific 

   176 resource files are searched for. 

   177 NearestLanguageFile searches language specific resource files in the 

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

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

   180 it is runtime configurable.

   181 NearestLanguageFileV2 searches for language specific resource files 

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

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

   184 each language that has one or more equivalents.

   185 

   186 @param aFs An active file server session.

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

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

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

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

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

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

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

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

   195 

   196 @see TLanguage

   197 @see BaflUtils::GetEquivalentLanguageList

   198  */

   199 EXPORT_C void 

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

   201 	{

   202 	TNearestLanguageFileFinder finder(aFs);

   203 	TBool goodSuffix=finder.SetFileName(aName);

   204 	

   205 	// Continue only if the suffix is good.

   206 	if(goodSuffix)

   207 		{

   208 		// add preset customised resource drive to drive list  

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

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

   211 		// other drives according to our algorithm

   212 		finder.AddCustomResourceDrive();

   213 		

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

   215 		if (!finder.FindLanguageAndDrive()

   216 			&& KErrNone != finder.FindFirstLanguageFileAndDrive())

   217 			finder.RepairFileName();

   218 		aLanguage = finder.Language();

   219 		}

   220 	else

   221 		{

   222 		aLanguage = ELangNone;

   223 		}

   224 	}

   225 

   226 // TLibAssocBase

   227 

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

   229 	: iLibrary(aLib),iPtr(aPtr)

   230 /**

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

   232 

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

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

   235             Typically, this object will have been created using

   236             the ordinal 1 function from that DLL. */	

   237 	{}

   238 

   239 

   240 

   241 

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

   243 /**

   244 Implements TLibAssoc::Set().

   245 

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

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

   248               Typically, this object will have been created using

   249               the ordinal 1 function from that DLL.

   250 

   251 @see TLibAssoc::Set */

   252 	{

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

   254 	iLibrary=aLib;

   255 	iPtr=aPtr;

   256 	}

   257 

   258 

   259 

   260 

   261 EXPORT_C void TLibAssocBase::DoUnload(TAny* aThis)

   262 /**

   263 Calls Close() on the associated DLL.

   264 

   265 @param aThis An untyped pointer to a TLibAssoc type.

   266 */

   267 	{

   268 	TLibAssocBase& l=*(TLibAssocBase*)aThis;

   269 	l.iPtr=NULL;

   270 	l.iLibrary.Close();

   271 	}

   272 

   273 //

   274 // class BaflUtils

   275 //

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

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

   278 

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

   280 copied to aDest.

   281 

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

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

   284 

   285 @param aDest On return, the truncated string

   286 @param aSrc The string to truncate

   287 @param aTruncationSymbol The truncation character to add */

   288 	{ // static

   289 	TInt maxLength=aDest.MaxLength();

   290 	if (aSrc.Length()<=maxLength)

   291 		aDest.Copy(aSrc);

   292 	else

   293 		{

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

   295 		aDest.Append(aTruncationSymbol);

   296 		}

   297 	}

   298 

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

   300 /** Checks if the specified file exists.

   301 	

   302 @param aFs File server session

   303 @param aFileName File to check

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

   305 	{ // static

   306 	TEntry entry;

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

   308 	}

   309 

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

   311 /** Tests whether a path exists.

   312 

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

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

   315 

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

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

   318 name includes wildcard characters, the function returns EFalse.

   319 

   320 @param aFs A connected session with the file server.

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

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

   323 specified path is badly formed. */

   324 	{ // static

   325 	TParse parse;

   326 	TInt retcode;

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

   328 	if (retcode != KErrNone)

   329 		return EFalse;

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

   331 		return EFalse;

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

   333 		return EFalse;

   334 	TFileName dirName = parse.DriveAndPath();

   335 	if (dirName.Length() > KMaxFileName)

   336 		return(EFalse);

   337     RDir dir;

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

   339 	if (retcode == KErrNone)

   340 		dir.Close();

   341 	return (retcode == KErrNone);

   342 	}

   343 

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

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

   346 	

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

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

   349 returns normally.

   350 

   351 @param aFs File server session

   352 @param aFileName Path to ensure exists

   353 @see RFs::MkDirAll() */

   354 	{ // static

   355 	TInt error=aFileSession.MkDirAll(aFileName);

   356 	if (error!=KErrAlreadyExists)

   357 		User::LeaveIfError(error);

   358 	}

   359 

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

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

   362 

   363 @param aName Thread name

   364 @return Application name

   365 @see RThread */

   366 	{

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

   368 	TChar delimiter=':';

   369 	TInt start=aName.Locate(delimiter);

   370 	if (start<0)

   371 		start=0; // should never happen

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

   373 		start+=2;

   374 	TPtrC rest=aName.Mid(start);

   375 	TInt end=rest.Locate(delimiter);

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

   377 	}

   378 

   379 LOCAL_C TBool IsLanguageExtended(const TLanguage aLanguage)

   380 	{

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

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

   383 		return EFalse;

   384 	else

   385 		return ETrue;

   386 	}

   387 

   388 

   389 LOCAL_C TLanguage BaseLanguage(const TLanguage aLanguage)

   390 	{

   391 	if (IsLanguageExtended(aLanguage))

   392 		return static_cast<TLanguage>(aLanguage & KDialectMask);

   393 	else

   394 		return aLanguage;

   395 	}

   396 

   397 LOCAL_C TLanguage NextLanguage(TLanguage aLanguage)

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

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

   400 @internalAll */

   401 	{

   402 	switch (aLanguage)

   403 		{

   404 		case ELangAustralian:

   405 		case ELangNewZealand:

   406 		case ELangSouthAfricanEnglish:

   407 		case ELangInternationalEnglish:

   408 		case ELangAmerican:

   409 		case ELangEnglish_Apac:

   410 		case ELangEnglish_Taiwan:

   411 		case ELangEnglish_HongKong:

   412 		case ELangEnglish_Prc:

   413 		case ELangEnglish_Japan:

   414 		case ELangEnglish_Thailand:

   415 			return ELangEnglish;

   416 		case ELangCanadianEnglish:

   417 			return ELangAmerican;	// 2-stage downgrade

   418 		case ELangSwissFrench:

   419 		case ELangBelgianFrench:

   420 		case ELangInternationalFrench:

   421 		case ELangCanadianFrench:

   422 			return ELangFrench;

   423 		case ELangSwissGerman:

   424 		case ELangAustrian:

   425 			return ELangGerman;

   426 		case ELangInternationalSpanish:

   427 		case ELangLatinAmericanSpanish:

   428 			return ELangSpanish;

   429 		case ELangSwissItalian:

   430 			return ELangItalian;

   431 		case ELangFinlandSwedish:

   432 			return ELangSwedish;

   433 		case ELangCyprusTurkish:

   434 			return ELangTurkish;

   435 		case ELangBelgianFlemish:

   436 			return ELangDutch;

   437 		case ELangHongKongChinese:

   438 			return ELangTaiwanChinese;

   439 		case ELangCyprusGreek:

   440 			return ELangGreek;

   441 		case ELangMalay_Apac:

   442 			return ELangMalay;

   443 		case ELangBrazilianPortuguese:

   444 			return ELangPortuguese;

   445 		default:

   446 			return ELangNone;	

   447 		}

   448 	}

   449 

   450 

   451 void AddLanguage(TLanguagePath& aPath, TLanguage aNewLanguage)

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

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

   454 on exit. */	

   455 	{

   456 	TLanguage *p = aPath;

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

   458 	while (p != end)

   459 		{

   460 		if (*p == aNewLanguage)

   461 			// language already in list

   462 			break;

   463 		if (*p == ELangNone)

   464 			{

   465 			// found the end of the list

   466 			p[0] = aNewLanguage;

   467 			p[1] = ELangNone;

   468 			break;

   469 			}

   470 		++p;

   471 		}

   472 	return;

   473 	}

   474 

   475 void MakeLanguageDowngradePath(TLanguagePath& aPath,

   476 	TLanguage aCurrent, TLanguage aIdeal, const TLocale& aLocale)

   477 	{

   478 	TInt j = 0;

   479 	if( aIdeal != ELangNone)

   480 		{

   481 		aPath[j++]=aIdeal;	

   482 		}

   483 	aPath[j++] = aCurrent;

   484 	aPath[j++] = ELangNone;

   485 

   486 	if (aCurrent & ~KDialectMask)

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

   488 

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

   490 		{

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

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

   493 		}

   494 

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

   496 		AddLanguage(aPath, aCurrent);

   497 	}

   498 

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

   500 	{

   501 	return iDir.Open(aFs, aMatchPattern,

   502 		KEntryAttReadOnly | KEntryAttHidden | KEntryAttSystem | KEntryAttArchive);

   503 	}

   504 

   505 TInt RRealDirectoryScanner::Next(TEntry& aOut)

   506 	{

   507 	return iDir.Read(aOut);

   508 	}

   509 

   510 void RRealDirectoryScanner::Close()

   511 	{

   512 	iDir.Close();

   513 	}

   514 

   515 /**

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

   517 

   518 @internalComponent

   519 @param			aFilename The filename to parse

   520 				

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

   522 				e.g. x.r491 gives 3.

   523 */

   524 TInt TNearestLanguageFileFinder::CountDigitsFromEnd(const TDesC& aFilename)

   525 	{

   526 	TInt digitCount = 0;

   527 	

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

   529 		{

   530 		++digitCount;

   531 		}

   532 		

   533 	return digitCount;

   534 	}

   535 

   536 

   537 /**

   538 Counts the number of digits at the end of a filename.

   539 

   540 @internalComponent

   541 @param			aFilename The filename to parse

   542 				

   543 @return			Count of the numeric digits at the end of the suffix, 

   544 				e.g. x.r491 gives 3.

   545 				0 if no numeric end of suffix,

   546 				KErrBadName for an invalid filename,

   547 				KErrNotSupported if the filename (minus path) is less

   548 				than or equal to KInvNameAndMinSuffixLength in length

   549 */

   550 TInt TNearestLanguageFileFinder::CountDigitsFromEndInSuffix (const TDesC& aFilename)

   551 	{

   552 	TInt digitCount = 0;

   553 	TInt slashIdx = 0;

   554 	TInt len = aFilename.Length ();

   555 	

   556 	// NOTE: We didn't use TChar here as they are too slow.

   557 	// We also didn't use TParse as they are too large.

   558 	

   559 	// don't work on the path

   560 	for (slashIdx=len-1; slashIdx >= 0 && aFilename[slashIdx] != '\\'; --slashIdx)

   561 	{/*do nothing*/};

   562 	

   563 	// Get new length

   564 	if (slashIdx>=0) {len = len-slashIdx-1;}

   565 

   566 	// Initial test to see if filename legal size.

   567 	if (len > KInvNameAndMinSuffixLength)

   568 		{

   569 		digitCount = CountDigitsFromEnd(aFilename);

   570 

   571 		// Can't store something bigger or we'll panic!

   572 		if (digitCount > KMaxSuffixLength)

   573 			{

   574 			digitCount = KErrBadName;

   575 			}

   576 		else

   577 		// numeric filename, e.g. "1234". 

   578 		// No preceeding alpha character

   579 		if (!(len-digitCount))

   580 			{

   581 			digitCount = KErrBadName;

   582 			}

   583 		}

   584 	else

   585 		{

   586 		digitCount = KErrNotSupported;

   587 		}

   588 		

   589 	return digitCount;

   590 	}

   591 

   592 RDirectoryScanner& TNearestLanguageFileFinder::DirectoryScanner()

   593 	{

   594 	return iDirScanner;

   595 	}

   596 

   597 TBool TNearestLanguageFileFinder::FileExists(const TDesC& aFileName) const

   598 	{

   599 	return BaflUtils::FileExists(iFs, aFileName);

   600 	}

   601 

   602 TBool TNearestLanguageFileFinder::FindDrive()

   603 	{

   604 	ASSERT(iFileName);

   605 	TBool found=EFalse;

   606 	TInt driveLength=iDrives.Length();

   607 	for (TInt drive = 0; drive!=driveLength; ++drive)

   608 		{

   609 		(*iFileName)[0] = iDrives[drive];

   610 		if (FileExists(*iFileName))

   611 			{

   612 			found=ETrue;

   613 			break;

   614 			}

   615 		}

   616 	return found;

   617 	}

   618 

   619 TBool TNearestLanguageFileFinder::AppendLanguageCode(TLanguage aLanguage)

   620 	{

   621 	TInt rest = static_cast<TInt>(aLanguage);

   622 #ifdef _DEBUG

   623 	_LIT(KErrorMessage, "Bafl");

   624 #endif

   625 	__ASSERT_DEBUG(0 <= rest, User::Panic(KErrorMessage,KErrArgument));

   626 	iFileName->SetLength(iBaseLength);

   627 	const TInt remaining = iFileName->MaxLength() - iBaseLength;

   628 	TInt soFar = 0;

   629 	TBuf<1> num;

   630 	num.Append('0');

   631 	TBool appendLangSuccess = ETrue;

   632 	TInt digitCount = 0;

   633 	TInt digit = 0;

   634 	while (rest)

   635 		{

   636 		if (remaining == soFar)

   637 			{

   638 			// no more room in descriptor- return rather than panic,

   639 			// file cannot exist.

   640 			iFileName->SetLength(iBaseLength);

   641 			appendLangSuccess= EFalse;

   642 			break;

   643 			}

   644 		// Convert the number to ASCII by consistantly getting the base 10 remainder to convert.

   645 		// The number is updated minus the remainder for the next iteration.

   646 		// eg (rest = 123) -> (12, r3) -> (1, r2) -> (0, r1)

   647 		// Then insert the ASCII representation of the remainder into the filename end

   648 		// so it appears the correct way round.

   649 		// eg (filename.r) -> (filename.r3) -> (filename.r23) -> (filename.r123)

   650 		digit = rest % 10;

   651 		digitCount++;

   652 		rest /= 10;

   653 		num[0] = static_cast<TText16>(digit + '0');

   654 		iFileName->Insert(iBaseLength, num);

   655 

   656 		// Minimum suffix length is KInvNameAndMinSuffixLength

   657 		// so we have to insert zeros to make this up.

   658 		while (!rest && digitCount < KInvNameAndMinSuffixLength)

   659 			{

   660 			num[0] = static_cast<TText16>('0');

   661 			iFileName->Insert(iBaseLength, num);

   662 			++digitCount;

   663 			}

   664 			

   665 		++soFar;

   666 		}

   667 		

   668 	return appendLangSuccess;

   669 	}

   670 

   671 

   672 TBool TNearestLanguageFileFinder::FindLanguageAndDrive()

   673 /** Search for files across all drives in all languages in the path plus the

   674 language-neutral file. */

   675 	{

   676 	ASSERT(iFileName);

   677 	// No point appending if the suffix is bad

   678 	for (const TLanguage* currentLang = iPath; *currentLang != ELangNone; ++currentLang)

   679 		{

   680 		if (AppendLanguageCode(*currentLang) && FindDrive())

   681 			{

   682 			iLanguage = *currentLang;

   683 			return ETrue;

   684 			}

   685 		}

   686 	// search for language-neutral file

   687 	iFileName->SetLength(iBaseLength);

   688 	iFileName->Append(iSuffix);

   689 	return FindDrive();

   690 	}

   691 

   692 TInt TNearestLanguageFileFinder::LanguageNumberFromFile(const TDesC& aFileName, const TDesC& aStem)

   693 	{

   694 	TInt lang = 0;

   695 	TInt multiplier = 1;

   696 	TInt leadingZeroCount = 0;

   697 	TInt languageNumber = KErrNotFound;

   698 	const TText* firstChar = aFileName.Ptr();

   699 	const TText* lastChar = firstChar + aFileName.Length() - 1;

   700 	const TText* currentChar = lastChar;

   701 	// string cannot contain only numbers, because it must have a ':' in it

   702 	while ('0' <= *currentChar && *currentChar <= '9')

   703 		{

   704 		if (*currentChar == '0')

   705 			leadingZeroCount++;

   706 		else

   707 			{

   708 			leadingZeroCount = 0;

   709 			lang += multiplier * (*currentChar - '0');

   710 			}

   711 		multiplier *= 10;

   712 		--currentChar;

   713 		}

   714 	TInt along=lastChar - currentChar;

   715 	if (2 <= along)

   716 		{

   717 		// We have at least 2 digits at the end.

   718 		// trim of bad leading zeros

   719 		TInt maxTrim = along - 2;

   720 		if (maxTrim < leadingZeroCount)

   721 			{

   722 			leadingZeroCount = maxTrim;

   723 			}

   724 		currentChar += leadingZeroCount;

   725 		// we have at least 2 digits at the end but does the rest of it match the stem?

   726 		TPtrC foundStem(firstChar, currentChar - firstChar + 1);

   727 		//foundStem.CompareF(aStem.Right(foundStem.Length()))

   728 		if (0 == foundStem.CompareF(aStem))

   729 			{

   730 			languageNumber=lang;

   731 			}

   732 		}

   733 	return languageNumber;

   734 	}

   735 

   736 TInt TNearestLanguageFileFinder::FindFirstLanguageFile(RFs& aFs)

   737 	{

   738 	ASSERT(iFileName);

   739 	iFileName->SetLength(iBaseLength);

   740 	TPtrC name(*iFileName);

   741 	TParsePtrC nameToParse(name);

   742 	TPtrC nameStem(nameToParse.NameAndExt());

   743 	iFileName->Append('*');

   744 	TInt bestLanguageMatch = KMaxTInt;

   745 	RDirectoryScanner& scanner = DirectoryScanner();

   746 	TInt err = scanner.Open(aFs, *iFileName);

   747 	if (err != KErrNone)

   748 		{

   749 		return err;

   750 		}

   751 	TEntry entry;

   752 	while (KErrNone == scanner.Next(entry))

   753 		{

   754 		TInt lang = LanguageNumberFromFile(entry.iName, nameStem);

   755 		if (0 < lang && lang < bestLanguageMatch)

   756 			{

   757 			bestLanguageMatch = lang;

   758 			}

   759 		}

   760 	scanner.Close();

   761 	if (bestLanguageMatch != KMaxTInt)

   762 		{

   763 		iLanguage = static_cast<TLanguage>(bestLanguageMatch);

   764 		AppendLanguageCode(static_cast<TLanguage>(bestLanguageMatch));

   765 		return KErrNone;

   766 		}

   767 	return KErrNotFound;

   768 	}

   769 

   770 // Try each drive for any language files

   771 // iFileName must have a directory specifier

   772 TInt TNearestLanguageFileFinder::FindFirstLanguageFileAndDrive()

   773 	{

   774 	ASSERT(iFileName);

   775 	TInt findFirstResult=KErrNotFound;

   776 	TInt driveLength=iDrives.Length();

   777 	for (TInt drive = 0; drive != driveLength; ++drive)

   778 		{

   779 		(*iFileName)[0] = iDrives[drive];

   780 		TInt err = FindFirstLanguageFile(CONST_CAST(RFs&,iFs));

   781 		if (err == KErrNone || err == KErrNoMemory)

   782 			{

   783 			findFirstResult=err;

   784 			break;

   785 			}

   786 		}

   787 	return findFirstResult;

   788 	}

   789 

   790 /**

   791 Invalid filenames are any filename whose length (minus path) must be greater

   792 than KInvNameAndMinSuffixLength, and whose form is purely numerical, i.e. '1234' 

   793 */

   794 TBool TNearestLanguageFileFinder::SetFileName(TFileName& aFileName)

   795 	{

   796 	iDrives.Zero();

   797 	iFileName = &aFileName;

   798 	iOriginalBaseLength = iFileName->Length();

   799 	

   800 	TInt suffixLength = CountDigitsFromEndInSuffix (aFileName);

   801 	

   802 	// No point trying for filenames thats are badly formed

   803 	// or that are too large.

   804 	if (suffixLength >= 0 && 

   805 		KInvNameAndMinSuffixLength < iOriginalBaseLength)

   806 		{

   807 		if (suffixLength > 0)

   808 			{

   809 			// all of suffix to be replaced 

   810 			iSuffix = iFileName->Right(suffixLength);

   811 			iOriginalBaseLength -= suffixLength;

   812 			iFileName->SetLength(iOriginalBaseLength);

   813 			}

   814 		else

   815 			{ 

   816 			// No numerical part to suffix

   817 			TInt periodIdx = 0;

   818 			

   819 			// Search for the period within range KInvNameAndMinSuffixLength 

   820 			// from the end. As this must work for all values of

   821 			// KInvNameAndMinSuffixLength

   822 			for (TInt i = iOriginalBaseLength-1; 

   823 			     !periodIdx && i >= (iOriginalBaseLength-KInvNameAndMinSuffixLength-1);

   824 			     --i)

   825 				{

   826 				if ((*iFileName) [i] == '.')

   827 					{

   828 					periodIdx = i;

   829 					}

   830 				}

   831 			

   832 			// Don't handle files ending in a period.

   833 			// This is because the behaviour is different between Windows

   834 			// and Symbian Fs. In Windows it strips the period off.

   835 			//

   836 			// However, and this shouldn't happen as it is not shown

   837 			// (in the documentation) to be valid.

   838 			// Just try our best.

   839 			if (periodIdx == iOriginalBaseLength-1)

   840 				{

   841 				iSuffix.Zero();

   842 				return EFalse;

   843 				}

   844 			else

   845 			if (periodIdx)

   846 				{

   847 				// If there are KInvNameAndMinSuffixLength chars after the period

   848 				// simply replace them.

   849 				TInt right = iOriginalBaseLength-periodIdx-1;

   850 				iSuffix = iFileName->Right(right);

   851 				iOriginalBaseLength -= right;

   852 				iFileName->SetLength(iOriginalBaseLength);					

   853 				}

   854 			else

   855 				{

   856 				// Make the suffix start from KInvNameAndMinSuffixLength 

   857 				// from the right

   858 				TInt right = KInvNameAndMinSuffixLength;

   859 				iSuffix = iFileName->Right(right);

   860 				iOriginalBaseLength -= right;

   861 				iFileName->SetLength(iOriginalBaseLength);					

   862 				}

   863 			}

   864 		}

   865 	else

   866 		{

   867 		// bad or no suffix - treat the same

   868 		iSuffix.Zero();

   869 		return EFalse;

   870 		}

   871 

   872 	// For filenames with no drive letter prefix and also for filenames

   873 	// shorter than the drive letter length, i.e. with no drive

   874 	// information, insert it.

   875 	// Handles if the user simply enters the drive, e.g. "c:".

   876 	if (iOriginalBaseLength < KMaxDriveName || (*iFileName)[1] != ':')

   877 		{

   878 		// Set up the default if none supplied and make room in the filename 

   879         // array to contain a drive specification. Set initial drive letter to -1

   880         // so the iFileName is repaired before exited 

   881 		iInitialDriveLetter = -1;

   882 		iFileName->Insert(0, _L("_:")); 

   883 		iDrives.Append('Z');

   884 		}

   885 	else

   886 		{

   887 	   // Use the drive supplied inthe aName to NearestLanguageFile()

   888 		iInitialDriveLetter = (*iFileName)[0];

   889 		iDrives.Append(iInitialDriveLetter);

   890 		}

   891 	

   892 	iBaseLength = iFileName->Length();

   893 	

   894 	return ETrue;

   895 	}

   896 

   897 

   898 TLanguage TNearestLanguageFileFinder::Language()

   899 	{

   900 	return iLanguage;

   901 	}

   902 

   903 TNearestLanguageFileFinder::TNearestLanguageFileFinder(

   904 	const RFs& aFs)

   905 	: iFs(aFs), iFileName(0), iLanguage(ELangNone)

   906 	{

   907 	}

   908 

   909 void TNearestLanguageFileFinder::RepairFileName()

   910 	{

   911 	ASSERT(iFileName);

   912 	iFileName->SetLength(iBaseLength);

   913 	if (iInitialDriveLetter == -1)

   914 		iFileName->Delete(0, 2);

   915 	else

   916 		(*iFileName)[0] = static_cast<TText>(iInitialDriveLetter);

   917 	iFileName->SetLength(iOriginalBaseLength);

   918 	iFileName->Append(iSuffix);

   919 	}

   920 

   921 

   922 /**

   923 Add the custom resource drive to the start of the iDrives string.

   924 

   925 The custom resource drive is a preset writeable drive on which customised 

   926 resource files may be present. This drive takes priority over the other 

   927 drives when searching for language files.

   928 

   929 @return KErrNone if iDrives string was successfully modified; KErrAlreadyExists 

   930 if the drive is already present in the string; otherwise one of 

   931 the other system-wide error codes (iDrives will be unmodified). 

   932 */

   933 TInt TNearestLanguageFileFinder::AddCustomResourceDrive()

   934 	{

   935 	TInt drive = GetCustomResourceDriveNumber();

   936 	if (drive<0)

   937 		return drive;

   938 	

   939 	// if drive not already in drive list

   940 	if (iDrives.LocateF('A' + drive) < 0)

   941 		{

   942 		// add it

   943 		_LIT(KDrivePlaceholder, "_");

   944 		iDrives.Insert(0, KDrivePlaceholder);

   945 		iDrives[0] = 'A' + drive;

   946 		return KErrNone;

   947 		}

   948 	else

   949 		return KErrAlreadyExists;

   950 	}

   951 

   952 

   953 void TNearestLanguageFileFinder::AddAllDrives()

   954 	{

   955 	ASSERT(iDrives.Length() < 2);

   956 	if (iDrives.Length() == 0)

   957 		{

   958 		iDrives = KAllDrives;

   959 		return;

   960 		}

   961 	TInt pos = KAllDrives().LocateF(iDrives[0]);

   962 	if (pos < 0)

   963 		{

   964 		iDrives = KAllDrives;

   965 		return;

   966 		}

   967 	iDrives.Append(KAllDrives().Left(pos));

   968 	iDrives.Append(KAllDrives().Mid(pos + 1));

   969 	}

   970 

   971 

   972 /**

   973 Get the value of the custom resource drive.

   974 

   975 The custom resource drive is a preset writeable drive on which customised language resource 

   976 files can reside. The drive number is accessed via the HAL attribute ECustomResourceDrive. 

   977 It is then returned if it has been defined as a valid drive no.

   978 Otherwise for backward compatibility reasons an attempt is then made to access the system 

   979 drive HAL attribute instead. This drive number is returned if it has been defined as a valid 

   980 drive number.  

   981 Otherwise if neither a valid ECustomResourceDrive or ESystemDrive exists then KErrNotFound 

   982 is returned.

   983  

   984 Note that the ESystemDrive HAL attribute has been deprecated. It is accessed here to cater 

   985 for existing implementations which still expect it to be used.

   986  

   987 @return The drive number (corresponding to a TDriveNumber value) if successful; 

   988 KErrNotFound if neither a valid ECustomResourceDrive or a valid ESystemDrive HAL attribute 

   989 is defined;  

   990  

   991 @see HAL::ECustomResourceDrive

   992 @see HAL::ESystemDrive

   993 */

   994 TInt TNearestLanguageFileFinder::GetCustomResourceDriveNumber() const

   995 	{

   996 	TInt drive = KErrNotFound;

   997 	

   998 	// access custom resource drive attribute  

   999 	if (HAL::Get(HAL::ECustomResourceDrive, drive) == KErrNone)

  1000 		{

  1001 		// check that drive is valid

  1002 		if (drive>=EDriveA && drive<=EDriveZ)

  1003 			return drive;	 

  1004 		}

  1005 		    		    

  1006 	// access system drive attribute  

  1007 	// (Note that ESystemDrive is deprecated. It is checked here 

  1008 	// solely for backward compatibility reasons.)		

  1009 	if (HAL::Get(HAL::ESystemDrive, drive) == KErrNone)

  1010 		{

  1011 		// check that drive is valid

  1012 		if (drive>=EDriveA && drive<=EDriveZ)

  1013 				return drive;

  1014 		}		

  1015  

  1016 	return KErrNotFound;

  1017 	}

  1018 

  1019 

  1020 

  1021 /** Get the value of the system drive.

  1022 

  1023 The system drive can be set to one of the built-in read/write drives. Which 

  1024 drive is used is hardware-dependent. On some hardware, there may not be a 

  1025 system drive. The system drive is used as the drive on which localisable files 

  1026 are searched for. This enables a phone to be localised dynamically, using 

  1027 files not in the ROM.

  1028 

  1029 @param aDriveNumber On return, contains the drive number of the system drive.

  1030 @return KErrNone is always returned.

  1031 

  1032 @deprecated This method has been replaced by (and now internally calls) 

  1033 RFs:GetSystemDrive, which always returns a valid drive number.

  1034 

  1035 @see BaflUtils::NearestLanguageFile

  1036 @see RFs::GetSystemDrive

  1037 */

  1038 EXPORT_C TInt BaflUtils::GetSystemDrive(TDriveNumber& aDriveNumber)

  1039 	{

  1040 	aDriveNumber = RFs::GetSystemDrive();

  1041 	return KErrNone;

  1042 	}

  1043 

  1044 

  1045 /** Set most appropriate extension language code for filename and set corresponding language.

  1046 

  1047 Symbian uses numeric values to identify natural languages as specified by the TLanguage enumeration

  1048 defined in e32const.h. These values are used at the end of filename extensions to identify the

  1049 languages pertaining to files which have language specific variants such as resource files.

  1050 For instance filename.r01 and filename.r02 would be the English and French versions of the

  1051 resource file filename.rsc. Language codes can be between 2 to 5 digits in length.

  1052 

  1053 Starting from Symbian OS v7.0 this function constructs and uses a language downgrade path which 

  1054 consists of up to sixteen TLanguage values the first of which is the ideal language followed by 

  1055 the language of the current locale. Up to the next three can be customised using 

  1056 TLocale::SetLanguageDowngrade(). The rest of the language downgrade path is based on a 

  1057 table of language near equivalence which is internal to Symbian.

  1058 

  1059 This function searches the custom resource drive (if set, retrieved from HAL)

  1060 and then searches the optional drive specified in aName or 'Z:' if none is 

  1061 specified in aName. The custom resource drive is retrieved from the HAL 

  1062 attribute ECustomResourceDrive if set, if not set it will retrieve the legacy 

  1063 value set in the legacy HAL attribute ESystemDrive. No custom resource drive 

  1064 is searched if neither are set.  

  1065 Note - setting the custom resource drive will reduce the performance of this 

  1066 routine which will adversely affect device performance e.g. at boot up.

  1067 On NAND Flash based devices use of a composite Z: drive file system made up of multiple 

  1068 ROM images is the preferred mechanism for customising language resources on devices in 

  1069 Symbian OS 9.2 onwards, see Developer Library » Base Porting Guide » Porting: background 

  1070 information » NAND flash » NAND Flash image format. Thus use of the custom resource drive 

  1071 HAL attribute is effectively obsolete.

  1072   

  1073 The last two characters of aName are removed along with any digits which appear before them.

  1074 Then language codes specified in the constructed language downgrade path are appended in turn to 

  1075 aName as a match is searched for in the file system. In case no match is found using the 

  1076 constructed language downgradepath then files in the specified directory are searched for a 

  1077 suitable extension with preference given to the one specified if present. In cases where a 

  1078 match takes place the aName and aLanguage arguments are updated otherwise aName is left 

  1079 unchanged and aLanguage is set to ELangNone.

  1080 

  1081 Here are some examples of correct and incorrect function usage with different aName inputs, 

  1082 file system state and downgrade paths as follows: 

  1083 

  1084 @code

  1085 Following files exist:

  1086 C:\\abc.rsc  - Language Neutral resource file.

  1087 C:\\abc.r01  - Resource file for the English language.

  1088 C:\\abc.r10  - Resource file for the American-English language.

  1089 C:\\abc.r160 - Resource file for the English as appropriate in Japan.

  1090 

  1091 Constructed Downgrade Language Path cases:

  1092 - Case 1. (ELangAmerican -> ELangEnglish -> ELangNone).

  1093 - Case 2. (ELangEnglish_Japan -> ELangEnglish -> ELangNone).

  1094 - Case 3. Same as case 1, However "C:\\abc.r10" is deleted prior to the function call.

  1095 - Case 4. Same as case 1, However both "C:\\abc.r01" and "C:\\abc.r10" are deleted prior to the function call.

  1096 @endcode

  1097 

  1098 @code

  1099 Input aName . . . . Output aName. . . aLanguage . . . . . Description

  1100 --------------------------------------------------------------------------------------------------------------------

  1101 "C:\\abc.rsc" . . . "C:\\abc.r10" . . ELangAmerican . . . Match on first language (Case 1)

  1102 "C:\\abc.r10" . . . "C:\\abc.r10" . . ELangAmerican . . . Match, However it's not the intended use of 

  1103 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . the function (Case 1)

  1104 "C:\\abc.r" . . . . "C:\\abc.r" . . . ELangNone . . . . . The no. of characters in the suffix is less than 

  1105 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . KInvNameAndMinSuffixLength(2)(Case 1)

  1106 "C:\\abc.". . . . . "C:\\abc.". . . . ELangNone . . . . . Invalid Suffix: The filename ends with a period(Case 1)

  1107 "C:\\abc.r123456" . "C:\\abc.r123456" ELangNone . . . . . Invalid Suffix: The no. of digits in the suffix is greater 

  1108 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . than KMaxSuffixLength(5) (Case 1)

  1109 "C:\\abc.10". . . . "C:\\abc.10 . . . ELangNone . . . . . Invalid Suffix: There's no proceeding alphabetical 

  1110 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . characters in the suffix (Case 1)

  1111 "\\abc.rsc" . . . . "\\abc.rsc" . . . ELangNone . . . . . No drive so Z: search, no match (Case 1)

  1112 "C:\\abc.rsc" . . . "C:\\abc.r160". . ELangEnglish_Japan. Match for language file 3 digits long (Case 2)

  1113 "C:\\abc.rsc" . . . "C:\\abc.r01" . . ELangEnglish. . . . Match on second language (Case 3)

  1114 "C:\\abc.rsc" . . . "C:\\abc.rsc" . . ELangNone . . . . . No corresponding langauge file match found (Case 4)

  1115 ---------------------------------------------------------------------------------------------------------------------

  1116 @endcode

  1117 

  1118 @param aFs File server session.

  1119 @param aName Optional drive specification, followed by optional path name,

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

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

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

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

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

  1125 In case of no match it's set to ELangNone.

  1126 @see TLanguage

  1127 @see BaflUtils::GetDowngradePathL

  1128 @see TLocale::SetLanguageDowngrade

  1129 */

  1130 EXPORT_C void BaflUtils::NearestLanguageFile(const RFs& aFs,TFileName& aName, TLanguage& aLanguage)

  1131 	{

  1132 #if defined(DO_PROFILING)

  1133 	RDebug::ProfileReset(FIRST_PROFILE_INDEX, PROFILE_COUNT);

  1134 	RDebug::ProfileStart(PROFILE_INDEX_1);

  1135 #endif