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

//

#include "HLPMODEL.H"

// System includes

#include <coehelp.h>

#include <txtrich.h>

#include <bautils.h>

// User includes

#include "hlppict.h"

#include "HLPSRCH.H"

#include "hlppanic.h"

#include "Hlpsqlconsts.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "hlpmodel_internal.h"

#endif

// For searching for help files

_LIT(KHlpFileSpec,			"*.h*");

_LIT(KDefaultHelpExtension, ".hlp");

_LIT(KHlpFileSearchPath,	"\\Resource\\Help\\");

#ifdef __SHOW_LOADING_INFO__

_LIT(KFormat1, "\n%S %d: %c:%S%S");

_LIT(KFormat2, "\n%S %d: %c:%S%S");

_LIT(KCompareNewListWithMasterList, "compare master list");

_LIT(KDeleteEntry, "deleting");

_LIT(KGetNearestLanguageFile, "getting nearest languuage file for");

_LIT(KAddNewEntryToMasterList, "adding to master list");

_LIT(KLoadMasterList, "Loading");

_LIT(KFoundEntry, "Found entry during dir scan");

_LIT(KDuplicateEntry, "entry discarded as duplicate");

_LIT(KAddNewEntry, "entry added to list");

#endif

// Typedefs

typedef CArrayPtrFlat<CHlpFileEntry> CHlpFileList;

// Constants

const TInt KHlpModelNumericValueSize = 32;

// Average number of pictures per Help Topic

const TInt KAverageNumberOfPicturesInHelpTopic = 3;

#define UNUSED_VAR(a) a = a

//

// ----> CHlpFileEntry (header)

//

class CHlpFileEntry : public CBase

	{

public:

	static CHlpFileEntry* NewLC(TDriveUnit aDrive, const TDesC& aFile);

	inline TDriveUnit Drive() const { return iDrive; }

	inline const TDesC& FileName() const { return iFile; }

	inline const TDesC& Name() const { return iName; }

	void GetFullNameAndPath(TDes& aName) const;

private:

	CHlpFileEntry(TDriveUnit aDrive, const TDesC& aFile);

private:

	TName iName;

	TName iFile;

	TDriveUnit iDrive;

	};

//

// ----> Static utility function (source)

//

//#define __SHOW_LOADING_INFO__

#ifdef __SHOW_LOADING_INFO__

static void PrintEntryL(const TDesC& aPrompt, const CHlpFileEntry& aEntry, TInt aNumber = -1)

	{

	TFileName pFileName(aEntry.FileName());

	TChar driveLetter = '?';

	RFs::DriveToChar(aEntry.Drive(), driveLetter);

	HBufC* buf = HBufC::NewLC(aPrompt.Length() + pFileName.Length() + KHlpFileSearchPath().Length() + 40);

	TDes pBuf(buf->Des());

	if	(aNumber >= KErrNone)

		pBuf.Format(KFormat1, &aPrompt, aNumber, driveLetter, &KHlpFileSearchPath(), &pFileName);

	else

		pBuf.Format(KFormat2, &aPrompt, driveLetter, &KHlpFileSearchPath(), &pFileName);

	RDebug::Print(pBuf);

	CleanupStack::PopAndDestroy();

	}

#define __PRINT_FILE(aPrompt, aEntry)				(PrintEntryL(aPrompt, aEntry))

#define __PRINT_FILE_NO(aPrompt, aEntry, aNumber)	(PrintEntryL(aPrompt, aEntry, aNumber))

#else

#define __PRINT_FILE(aPrompt, aEntry)

#define __PRINT_FILE_NO(aPrompt, aEntry, aNumber)

#endif

//

// ----> CHlpFileEntry (source)

//

CHlpFileEntry::CHlpFileEntry(TDriveUnit aDrive, const TDesC& aFile)

:iFile(aFile)

,iDrive(aDrive)

	{

	TParsePtrC parser(iFile);

	iName.Copy(parser.Name());

	}

CHlpFileEntry* CHlpFileEntry::NewLC(TDriveUnit aDrive, const TDesC& aFile)

	{

	CHlpFileEntry* self = new(ELeave) CHlpFileEntry(aDrive, aFile);

	CleanupStack::PushL(self);

	return self;

	}

//

//

//

void CHlpFileEntry::GetFullNameAndPath(TDes& aName) const

	{

	TChar driveLetter = '?';

	RFs::DriveToChar(Drive(), driveLetter);

	aName.Zero();

	aName.Append(driveLetter);

	aName.Append(':');

	aName.Append(KHlpFileSearchPath);

	aName.Append(FileName());

	}

//

// ----> CHlpModel

//

CHlpModel::CHlpModel(RFs& aFs, MHlpModelObserver& aObserver)

:	iFsSession(aFs), iObserver(&aObserver)

	{

	}

EXPORT_C CHlpModel::~CHlpModel()

/** Destructor. */

	{

	if	(iDatabases)

		iDatabases->ResetAndDestroy();

	NotifyHelpModelDestructionToPictures();

	if	(iPictures)

		iPictures->Reset();

	delete iDatabases;

	delete iPictures;

	delete iSearch;

	delete iCriterion;

	delete iZoomFactors;

	}

void CHlpModel::NotifyHelpModelDestructionToPictures()

	{

	if	(!iPictures)

		return;

	const TInt count = iPictures->Count();

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

		{

		CHlpPicture& picture = *iPictures->At(i);

		picture.HandleHelpModelDestruction();

		}

	}

void CHlpModel::ConstructL()

	{

	iDatabases = new(ELeave) CHlpDatabases(2);

	iPictures = new(ELeave) CArrayPtrFlat<CHlpPicture>(KAverageNumberOfPicturesInHelpTopic);

	iSearch = CHlpSQLSearch::NewL(*this);

	// There must always be 3 default zoom ratios present in the array...

	iZoomFactors = new(ELeave) CArrayFixFlat<TInt>(3);

	iZoomFactors->AppendL(KHlpModelZoomFactorSmall);

	iZoomFactors->AppendL(KHlpModelZoomFactorMedium);

	iZoomFactors->AppendL(KHlpModelZoomFactorLarge);

	}

EXPORT_C CHlpModel* CHlpModel::NewL(RFs& aFs, MHlpModelObserver* aObserver)

/** Allocates and creates a help model object.

@param aFs Open file server handle

@param aObserver Client callback interface to handle messages from the help

model

@return New help model object */

	{

	CHlpModel* self = CHlpModel::NewLC(aFs, aObserver);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CHlpModel* CHlpModel::NewLC(RFs& aFs, MHlpModelObserver* aObserver)

/** Allocates and creates a help model object, leaving the object on the cleanup

stack.

@param aFs Open file server handle

@param aObserver Client callback interface to handle messages from the help

model

@return New help model object */

	{

	CHlpModel* self = new(ELeave) CHlpModel(aFs, *aObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

//

//

//

EXPORT_C void CHlpModel::OpenL()

/** Opens all the help files in \\Resource\\Help. */

	{

	CHlpFileList* masterList = new(ELeave) CHlpFileList(5);

	CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfCHlpFileEntry,masterList));

	TInt i = EDriveY;

	FOREVER

		{

		// Make sure we go from Y -> A, then do Z last

		if	(i < EDriveA)

			i = EDriveZ;

		if	(DiskPresent(i))

			{

			// This generates a list for a specific directory on the specified drive.

			CHlpFileList* list = BuildListForDriveLC(TDriveUnit(i), iFsSession);

			TInt newListCount = list->Count();

			if(newListCount)

				{

				// compare the new list with our master list to check for duplicates

				TInt masterCount = masterList->Count();

				for(TInt j=masterCount-1; j>=0; j--)

					{

					CHlpFileEntry* entry = masterList->At(j);

					__PRINT_FILE_NO(KCompareNewListWithMasterList, *entry, j);

					newListCount = list->Count();

					for(TInt k=newListCount-1; k>=0; k--)

						{

						CHlpFileEntry* newEntry = list->At(k);

						if	(entry->FileName().CompareF(newEntry->FileName()) == 0)

							{

							// Names same, so nearest language file already in master list

							__PRINT_FILE_NO(KDeleteEntry, *newEntry, k);

							delete newEntry;

							list->Delete(k);

							}

						}

					}

				}

			// At this point, anything that is left in the new list should

			// have it's nearest language file added to the master list...

			newListCount = list->Count();

			for(TInt k=newListCount-1; k>=0; k--)

				{

				//get nearest language file

				__PRINT_FILE_NO(KGetNearestLanguageFile, *list->At(k), k);

				TChar driveLetter = '?';

				RFs::DriveToChar(list->At(k)->Drive(), driveLetter);

				TFileName fileName;

				fileName.Append(driveLetter);

				fileName.Append(':');

				fileName.Append(KHlpFileSearchPath);

				fileName.Append(list->At(k)->Name());

				fileName.Append(KDefaultHelpExtension);

				BaflUtils::NearestLanguageFile(iFsSession, fileName);

				//get drive and filename+extension of nearest language file

				TParsePtrC parser(fileName);

				if	(!parser.ExtPresent())

					User::Leave(KErrCorrupt);

				TPtrC drive=parser.Drive();

				TPtrC name=parser.NameAndExt();

				//create new CHlpFileEntry

				CHlpFileEntry* entry = CHlpFileEntry::NewLC(drive, name);

				__PRINT_FILE(KAddNewEntryToMasterList, *entry);

				//add to master list

				masterList->AppendL(entry);

				CleanupStack::Pop(entry);

				}

			list->ResetAndDestroy();

			CleanupStack::PopAndDestroy(list);

			}

		if	(i-- == EDriveZ)

			break;

		}

	// The code below validates the masterList of help files and filters out unnecessary files based on the criteria specified below -

	// i)   In case of two files - abc.hlp and abc.h01 - present in the master list,since abc.h01 is the latest version, it

	//      will be picked. In other words abc.hlp will be removed from the list.

	// ii)  if two files for different language code exist, both should remain in masterList

	// iii) if the system language is changed, the file as per the new language should be retained and

	//      default file with .hlp extension should be removed from the masterList

	TLanguage language;

	language = User::Language(); //gets the default language

	TInt languageCode;

	languageCode = language; // integer equivalent of the language code. For example, ELangEnglish is 01

	for(TInt i=masterList->Count()-1; i >= 0; i--)

		{

		CHlpFileEntry* newEntry = masterList->At(i);

		TPtrC ptrFile (newEntry->FileName());

		TBufC<8> fileExtension(ptrFile.Right(2));

		TLex lex(fileExtension);

		TInt lexIntValue;

		lex.Val(lexIntValue);

		TParse parser;

		TBool hlpFlag = ETrue;

		User::LeaveIfError(parser.Set(ptrFile, NULL, NULL));

		if(lexIntValue != language)

			{

			// Get the filename with language code in file extension

			TBuf<256> fileName(newEntry->Name());

			TBuf<10> name;

			name.Format(_L(".h%02d"),languageCode);

			fileName.Append(name);

			// Get the filename with the .hlp extension

			TBuf<256> defaultFileName(newEntry->Name());

			TBuf<10> defaultName;

			defaultName.Format(_L(".hlp"));

			defaultFileName.Append(defaultName);

			//Check the file against all the files in the list

			for(TInt j = masterList->Count()-1; j >=0 ; j--)

				{

				CHlpFileEntry* entry = masterList->At(j);

				// If two files with same name exist, delete one from the masterList

				// and reset hlpFlag to EFalse

				if(entry->FileName().CompareF(fileName)==0)

					{

					masterList->Delete(i);

					hlpFlag = EFalse;

					break;

					}

				}

				if( (hlpFlag) && (parser.Ext().CompareF(KDefaultHelpExtension)!=0))

					{

					for(TInt k = masterList->Count()-1; k >=0 ; k--)

						{

						CHlpFileEntry* entry = masterList->At(k);

						if(entry->FileName().CompareF(defaultFileName)==0)

							{

							masterList->Delete(i);

							break;

							}

						}

					}

				}

			}

	// Load the master list

	TFileName file;

	TInt count = masterList->Count();

	for (i=0; i<count; i++)

		{

		masterList->At(i)->GetFullNameAndPath(file);

		__PRINT_FILE_NO(KLoadMasterList, *masterList->At(i), i);

		// This will leave with KErrArgument if it's a bad file

		TRAPD(error, OpenFileL(file));

		UNUSED_VAR(error); // used to suppress build warnings

		}

	CleanupStack::PopAndDestroy(masterList);

	}

TBool CHlpModel::DiskPresent(TInt aDrive) const

	{

	TDriveList list;

	if	(iFsSession.DriveList(list) < KErrNone)

		return EFalse;

	TDriveInfo info;

	TInt error = iFsSession.Drive(info, aDrive);

	if	(error < KErrNone)

		return EFalse;

	return (list[aDrive] && info.iType != EMediaNotPresent);

	}

void CHlpModel::ResetAndDestroyArrayOfCHlpFileEntry(TAny* aObject)

	{

	CArrayPtr<CHlpFileEntry>* array=REINTERPRET_CAST(CArrayPtr<CHlpFileEntry>*,aObject);

	if (array)

		array->ResetAndDestroy();

	delete array;

	}

CHlpFileList* CHlpModel::BuildListForDriveLC(TDriveUnit aDrive, RFs& aFsSession) const

//

//	Generate a list of help files for the specified drive

//

	{

	CHlpFileList* list = new(ELeave) CHlpFileList(5);

	CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfCHlpFileEntry,list));

	// Generate the folder spec to search in

	TFileName searchSpec;

	TChar driveLetter;

	User::LeaveIfError(RFs::DriveToChar(aDrive, driveLetter));

	searchSpec.Append(driveLetter);

	searchSpec.Append(':');

	searchSpec.Append(KHlpFileSearchPath);

	searchSpec.Append(KHlpFileSpec);

	CDir* dirList;

	TFindFile finder(aFsSession);

	TInt ret = finder.FindWildByPath(searchSpec, NULL, dirList);

	if	(ret < KErrNone)

		{

		if	(ret == KErrNotFound)

			return list;

		else

			User::Leave(ret);

		}

	CleanupStack::PushL(dirList);

	// Add files to help file list

	TInt dirCount = dirList->Count();

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

		{

		CHlpFileEntry* newEntry = CHlpFileEntry::NewLC(aDrive, (*dirList)[i].iName);

		__PRINT_FILE_NO(KFoundEntry, *newEntry, i);

		//check if new file already in the list

		TBool foundMatch=EFalse;

		TInt existingEntryCount=list->Count();

		for(TInt j=existingEntryCount-1; j>=0; j--)

			{

			if(list->At(j)->Name().CompareF(newEntry->Name())==0)

				{

				__PRINT_FILE_NO(KDuplicateEntry, *newEntry, i);

				foundMatch=ETrue;

				}

			}

		if(!foundMatch)

			{

			__PRINT_FILE_NO(KAddNewEntry, *newEntry, i);

			list->AppendL(newEntry);

			CleanupStack::Pop(newEntry);

			}

		else

			CleanupStack::PopAndDestroy(newEntry);

		}

	CleanupStack::PopAndDestroy(dirList);

	return list;

	}

EXPORT_C void CHlpModel::CloseL()

/** Closes all open help files. */

	{

	const TInt KDatabaseCount = DatabaseCount();

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

		iDatabases->At(i)->Close();

	iDatabases->ResetAndDestroy();

	}

//

//

//

/**

Opens a specified help file.

@param aFileName Help file to open

*/

EXPORT_C void CHlpModel::OpenFileL(const TDesC& aFileName)

	{

	TEntry entry;

	User::LeaveIfError(iFsSession.Entry(aFileName, entry));

	if	(entry.IsDir())

		{

		return; // don't try and open directories as help files ;)

		}

	TParsePtrC parser(aFileName);

	if (parser.Path() != KHlpFileSearchPath)

		{ // given file is outside \\Resource\\Help\\ directory.

		User::Leave(KErrArgument);

		}

	if	(!(entry[0] == KPermanentFileStoreLayoutUid && entry[1] == KUidHlpApp))