/*
* 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: 
*
*/


#include <badesca.h>
#include <eikenv.h>
#include <eikappui.h>
#include <eikon.mbg>

#include "WPOUTLNE.H"
#include <word.rsg>
#include <word.mbg>


const TInt KExpandedBitmapIndex = 0;
const TInt KClosedBitmapIndex = 1;
const TInt KIndentPerLevel=12;
const TInt KMaxParagraphLength = 128;  // If a paragraph is longer than this length, truncate it
const TInt KWaitingTime = 500000;




// TOutlineEntry - constructors
////////////////

TOutlineEntry::TOutlineEntry(TInt aParagraphNo, TInt aOutlineLevel, TInt aParaLen, TInt aParaPos, TBool aChild, TBool aLast)
	: iParagraphNo(aParagraphNo),
	iOutlineLevel(aOutlineLevel),
	iParagraphLength(aParaLen),
	iParagraphPos(aParaPos),
	iIsChild(aChild),
	iLastEntry(aLast)
{
}


TOutlineEntry::TOutlineEntry()
	: iParagraphNo(0),
	iOutlineLevel(0),
	iParagraphLength(0),
	iParagraphPos(0),
	iIsChild(EFalse),
	iLastEntry(EFalse)
{
}

// TOutlineMap - constructor
//////////////

TOutlineMap::TOutlineMap(TInt aIndex, CHierListItem* aPtr)
	: iIndex(aIndex),
	iPtr(aPtr)
{
}


// COutlineMap
//////////////

COutlineMap* COutlineMap::NewL()
{
	COutlineMap* self = new(ELeave) COutlineMap();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
}


void COutlineMap::ConstructL()
{
	// Create table with granularity of 5
	iOutlineMapTable=new(ELeave) COutlineMapTable(5);
}

COutlineMap::~COutlineMap()
{
	// delete the table
	delete iOutlineMapTable;
}


void COutlineMap::BindL(TInt aRef, CHierListItem* aPtr)
{
	TOutlineMap entry(aRef, aPtr);

	// Check to see if either of these already exists
	// When re-expanding elements, the same references can be bound to
	// different pointers, and the same pointers can be bound to different
	// references.

	TInt items = iOutlineMapTable->Count();
	TInt count;

	for (count = 0; count<items; count++)
	{
		TOutlineMap* entry = &(*iOutlineMapTable)[count];
		if (entry->iPtr == aPtr || entry->iIndex == aRef) 
		{
			iOutlineMapTable->Delete(count);
			items--;
			count--;
		}
	}

	iOutlineMapTable->AppendL(entry);
}


TInt COutlineMap::Index(CHierListItem* aPtr)
{
	// Given an item pointer from the list box, return an index into the
	// Outline Table, or -1 if it does not exist

	const TInt items = iOutlineMapTable->Count();
	TInt count;

	for (count=0; count<items; count++)
	{
		TOutlineMap* entry = &(*iOutlineMapTable)[count];
		if (entry->iPtr == aPtr) return entry->iIndex;
	}
	return KErrNotFound;
}


CHierListItem* COutlineMap::Ptr(TInt aIndex)
{
	// Given an index into the Outline table, return a pointer to its
	// entry in the list box, or NULL if it does not exist

	const TInt items = iOutlineMapTable->Count();
	TInt count;

	for (count=0; count<items; count++)
	{
		TOutlineMap* entry = &(*iOutlineMapTable)[count];
		if (entry->iIndex == aIndex) return entry->iPtr;
	}
	return NULL;
}

TBool COutlineMap::IndexPresent(TInt aIndex)
{
	// Returns ETrue if the given index is present in the table

	TInt items = iOutlineMapTable->Count();
	TInt count;

	for (count=0; count<items; count++)
	{
		TOutlineMap* entry = &(*iOutlineMapTable)[count];
		if (entry->iIndex == aIndex) return ETrue;
	}
	return EFalse;

}



/// COutlineHListBox 
////////////////////


COutlineHListBox::COutlineHListBox(CRichText* aText, TInt aCursorPos)
	: iText(aText),
	iCursorPos(aCursorPos)
{
}


TSize COutlineHListBox::MinimumSize()
	{
	// Specify the minimum size of this control 
	// Essential to make the control visible
	TSize size(iSize.iWidth, iSize.iHeight);
	if (!(iListBoxFlags&EScrollBarSizeExcluded) && iSBFrame && iSBFrame->HScrollBarVisibility()!=CEikScrollBarFrame::EOff)
		size.iHeight += CEikScrollBar::DefaultScrollBarBreadth();
	size+=iBorder.SizeDelta();
	return size;
	}


void COutlineHListBox::ConstructFromResourceL(TResourceReader& aReader)
{
	 // Called when creating the control from a dialog
	// Reads the size of the control, then constructs the object
	iSize.iWidth = aReader.ReadInt16();
	iSize.iHeight = aReader.ReadInt16();

	ConstructL();

}


void COutlineHListBox::ConstructL()
	{
	// The NewL constructor will leave if there is nothing to show in outline view,
	// so trap it, display a message, and leave without any error

	TRAPD(ret, iModel = COutlineHListBoxModel::NewL(this, iText);)
	if (ret == KErrNoOutline)
	{
		CEikonEnv::Static()->InfoMsg(R_WORD_NO_OUTLINE);
		User::Leave(KErrNone);
	}

	//  Get the open/close icons from the system
	TFileName resource = _L("*");
	CGulIcon* icon = iEikonEnv->CreateIconL(resource, EMbmWordOpenfdr);
	CleanupStack::PushL(icon);

	CArrayPtrFlat<CGulIcon>* icons = new(ELeave) CArrayPtrFlat<CGulIcon>(2);
	CleanupStack::PushL(icons);

	icons->AppendL(icon);
	icon = iEikonEnv->CreateIconL(resource, EMbmWordClsdfdr);

	CleanupStack::PushL(icon);
	icons->AppendL(icon);
	
	iItemDrawer = new(ELeave) COutlineHListItemDrawer((COutlineHListBoxModel*)iModel, iEikonEnv->NormalFont(), icons);

	CleanupStack::Pop(3);  // Cleanup the two icons and the array

	// Create the initial entries of the list box
	OutlineModel()->CreateRootListL();

	CreateViewL();

	// Expand the tree to show the current cursor position
	TInt item = OutlineModel()->ExpandCurrentPositionL(iCursorPos);

	if (item != -1)
		{
		// This updates the view to show the requested item no.
		iView->SetCurrentItemIndex(item);
		iView->SelectItemL(item);
		iListBoxFlags |= EStateChanged;
		}

	CreateScrollBarFrameL();
	ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);
	}


CListBoxView* COutlineHListBox::MakeViewClassInstanceL()
	{
	return (new(ELeave) COutlineHListBoxView);
	}


TKeyResponse COutlineHListBox::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)
{
	TInt currentItemIndex = iView->CurrentItemIndex();
	COutlineHListBoxModel* listModel = (COutlineHListBoxModel*)iModel;
	CHierListItem* itemToBeExpanded=listModel->Item(currentItemIndex);

	TInt keyCode = aKeyEvent.iCode;

	TBool expandKey = (keyCode == EKeyRightArrow || keyCode == '+');
	TBool collapseKey = (keyCode == EKeyLeftArrow || keyCode == '-');

	const TInt index=CurrentItemIndex();
	CArrayFix<CHierListItem*>* listArray=HlModel()->HierListArray();
	TBool itemHasChildren=EFalse;


	if (expandKey)
	{
		if (!itemToBeExpanded->IsExpanded()) 
		{
			listModel->ExpandItemL(index);
			CArrayFix<CHierListItem*>* newListArray=HlModel()->HierListArray();
			if (index<newListArray->Count()-1)
				itemHasChildren=((*newListArray)[index]->Level()==(*newListArray)[index+1]->Level()-1);

		}
	}

	if (collapseKey)
	{	
		if (itemToBeExpanded->IsExpanded()) 
		{
			if (index<HlModel()->NumberOfItems()-1)
				itemHasChildren=((*listArray)[index]->Level()==(*listArray)[index+1]->Level()-1);
			listModel->CollapseItem(index);

		}
	}

	if (expandKey || collapseKey)
	{
		iView->CalcDataWidth();
		iView->CalcBottomItemIndex();
		UpdateScrollBarsL();
		if (itemHasChildren)
			((CHierarchicalListBoxView*)iView)->DrawFromItem(index);
		else
			((CHierarchicalListBoxView*)iView)->DrawItem(index);
		ReportListBoxEventL(MEikListBoxObserver::EEventItemActioned);

		return EKeyWasConsumed;
	}

	return CEikHierarchicalListBox::OfferKeyEventL(aKeyEvent,aType);
	
}



void COutlineHListBox::ExpandAllItemsL()
{
	CEikonEnv* eikonEnv=CEikonEnv::Static();
	eikonEnv->BusyMsgL(R_WORD_EXPAND_OUTLINE, KWaitingTime);

	COutlineHListBoxModel* listModel = (COutlineHListBoxModel*)iModel;
	TInt originalIndex = CurrentItemIndex();
	CHierListItem* itemPtr=listModel->Item(originalIndex);
	TInt paragraphIndex = listModel->iOutlineMap->Index(itemPtr);

	TInt item=0;



	TInt index = 0;
	iView->SetCurrentItemIndex(0);

	while (index < listModel->NumberOfItems() )
	{
		CArrayFix<CHierListItem*>* listArray=listModel->HierListArray();
		if (!(*listArray)[index]->IsExpanded())
			{
			listModel->ExpandItemL(index);
			CArrayFix<CHierListItem*>* newListArray=listModel->HierListArray();
			}
		item = listModel->GetItemByParagraph(paragraphIndex);
		iView->SetCurrentItemIndex(item);

		index++;
	}


	iView->CalcDataWidth();
	iView->CalcBottomItemIndex();

	item = listModel->GetItemByParagraph(paragraphIndex);
	((CHierarchicalListBoxView*)iView)->ScrollToMakeItemVisible(item);
	((CHierarchicalListBoxView*)iView)->DrawFromItem(iView->TopItemIndex());

	UpdateScrollBarsL();
	ReportListBoxEventL(MEikListBoxObserver::EEventItemActioned);

	eikonEnv->BusyMsgCancel();

}

void COutlineHListBox::CollapseAllItemsL()
{

	CEikonEnv* eikonEnv=CEikonEnv::Static();
	eikonEnv->BusyMsgL(R_WORD_COLLAPSE_OUTLINE, KWaitingTime);

	COutlineHListBoxModel* listModel = (COutlineHListBoxModel*)iModel;
	TInt originalIndex = CurrentItemIndex();
    CHierListItem* itemPtr=listModel->Item(originalIndex);
	TInt paragraphIndex = listModel->iOutlineMap->Index(itemPtr);

	//TInt itemCount = listModel->NumberOfItems();
	TInt index = 0;
	TInt item = 0;

	// Get root parent of this node
	TInt rootParent = 0;
	TInt whilecount = 0;

	TInt childCount = 0;

	while (whilecount<=paragraphIndex)
	{
		if (listModel->iOutlineTable->At(whilecount).iIsChild)
			childCount++;

		if (childCount==0)
			rootParent = whilecount;

		if (listModel->iOutlineTable->At(whilecount).iLastEntry)
			childCount--;

		whilecount++;
	}

	

	while (index < listModel->NumberOfItems() )
	{
		CArrayFix<CHierListItem*>* listArray=listModel->HierListArray();
	if ((*listArray)[index]->IsExpanded())
		{
		HlModel()->CollapseItem(index);
		}

		item = listModel->GetItemByParagraph(rootParent);
		iView->SetCurrentItemIndex(item);


		index++;
	}

	iView->CalcDataWidth();
	iView->CalcBottomItemIndex();

	item = listModel->GetItemByParagraph(paragraphIndex);
	((CHierarchicalListBoxView*)iView)->ScrollToMakeItemVisible(item);
	((CHierarchicalListBoxView*)iView)->DrawFromItem(iView->TopItemIndex());
				
	UpdateScrollBarsL();
	ReportListBoxEventL(MEikListBoxObserver::EEventItemActioned);

	eikonEnv->BusyMsgCancel();

}




// COutlineHListItemDrawer
//////////////////////////

COutlineHListItemDrawer::COutlineHListItemDrawer(COutlineHListBoxModel* aModel, const CFont* aFont,	CArrayPtrFlat<CGulIcon>* aIcons)
	: CHierarchicalListItemDrawer(aModel, aFont, aIcons)
	{}

CGulIcon* COutlineHListItemDrawer::ItemIcon(TInt aItemIndex) const
	{
	if (!iIconArray || aItemIndex <= -1 || aItemIndex >= iModel->NumberOfItems())
		return NULL;
	TInt iconIndex;

	COutlineHListBoxModel* listModel = (COutlineHListBoxModel*)iModel;
    CHierListItem* itemPtr = listModel->Item(aItemIndex);
	TInt paragraphIndex = listModel->iOutlineMap->Index(itemPtr);

	iconIndex = KClosedBitmapIndex;

	if (paragraphIndex < listModel->iOutlineTable->Count() - 1)
	{
		if (listModel->iOutlineTable->At(paragraphIndex+1).iIsChild)
			iconIndex = KExpandedBitmapIndex;
	}
	return (*iIconArray)[iconIndex];
	}


// COutlineHListBoxView
////////////////////////


TInt COutlineHListBoxView::GetParagraphLevel(CHierListItem* aItem) const
{
	COutlineHListBoxModel* listModel = (COutlineHListBoxModel*)iModel;
	TInt paragraphIndex = listModel->iOutlineMap->Index(aItem);
	if (paragraphIndex != KErrNotFound)
	    return (listModel->iOutlineTable->At(paragraphIndex).iOutlineLevel);
	else 
		return 0;
}


void COutlineHListBoxView::DrawItem(TInt aItemIndex) const
	{
	// Modify this items level so that it is draw offset according to its doc level

	COutlineHListBoxModel* listModel = (COutlineHListBoxModel*)iModel;

	CHierListItem* itemToBeDrawn = listModel->Item(aItemIndex);
	TInt paragraphLevel = GetParagraphLevel(itemToBeDrawn) - 1;

	if (RedrawDisabled())
		return;
	const TInt count = iModel->NumberOfItems();

	if (aItemIndex >= 0 && aItemIndex < count && ItemIsVisible(aItemIndex))
		{
		iGc->SetClippingRect(iViewRect);
		const TSize itemSize = ItemSize(aItemIndex, paragraphLevel);
		iItemDrawer->SetItemCellSize(itemSize);
		ClearPreceedingItemRect(aItemIndex, paragraphLevel);
		const TPoint pos=ItemPos(aItemIndex, paragraphLevel);
		TPoint markPos(iViewRect.iTl.iX, pos.iY);
		iItemDrawer->DrawItemMark(ItemIsSelected(aItemIndex), iFlags & EDimmed,markPos);

		DrawItemLinks(aItemIndex, paragraphLevel);

		STATIC_CAST(CHierarchicalListItemDrawer*, iItemDrawer)->DrawActualItem(aItemIndex, TRect(pos,itemSize),
										aItemIndex == iCurrentItemIndex, iFlags & EEmphasized, iFlags & EDimmed, ItemIsSelected(aItemIndex));
		iGc->CancelClippingRect();
		}		
	}


TSize COutlineHListBoxView::ItemSize(TInt aItemIndex, TInt aParagraphLevel) const
	{
	COutlineHListBoxModel* listModel = (COutlineHListBoxModel*)iModel;

	if (! listModel->Item(aItemIndex))
		return TSize(0, 0);
	const TInt indent=aParagraphLevel*KIndentPerLevel;
	return TSize(Max(iViewRect.Width()-indent, DataWidth()), iItemHeight);
	}

TPoint COutlineHListBoxView::ItemPos(TInt aItemIndex, TInt aParagraphLevel) const
	{
	// assumes aItemIndex is currently visible
	TInt indentLevel=0;
	COutlineHListBoxModel* listModel = (COutlineHListBoxModel*)iModel;

	if (aItemIndex>-1 && aItemIndex<listModel->NumberOfItems())
		indentLevel=aParagraphLevel;
	TPoint pos(-iHScrollOffset + iViewRect.iTl.iX + indentLevel*KIndentPerLevel,
					iViewRect.iTl.iY + (aItemIndex-iTopItemIndex)*iItemHeight);
	return pos;
	}

void COutlineHListBoxView::ClearPreceedingItemRect(TInt aItemIndex, TInt aParagraphLevel) const
	{
	const TInt indentLevel=aParagraphLevel;
	TPoint startPoint=ItemPos(aItemIndex, aParagraphLevel);
	startPoint.iX-=indentLevel*KIndentPerLevel;
	const TRect blankRect(startPoint,TPoint(startPoint.iX+indentLevel*KIndentPerLevel,startPoint.iY+iItemHeight));
	iItemDrawer->ClearRect(blankRect);
	}


void COutlineHListBoxView::DrawItemLinks(TInt aItemIndex, TInt aParagraphLevel) const
	{
	
	COutlineHListBoxModel* listModel = (COutlineHListBoxModel*)iModel;
	
	CHierListItem* itemToBeDrawn=listModel->Item(aItemIndex);
	const TInt itemLevel=itemToBeDrawn->Level();
	if (!itemLevel)
		return;
	TPoint startPoint=ItemPos(aItemIndex, itemLevel);

	TInt parentLevel = itemLevel;

	CHierListItem* parent = itemToBeDrawn->Parent();
	if (parent)
	{
		parentLevel = GetParagraphLevel(parent);
		startPoint=ItemPos(aItemIndex, parentLevel);
	}

	startPoint.iX-=KIndentPerLevel/2;


	iGc->SetPenStyle(CGraphicsContext::ESolidPen);
	iGc->SetPenColor(0);
	if (itemLevel)
		{
		const TPoint horizLineStart=startPoint+TPoint(0,iItemHeight/2);
		iGc->MoveTo(horizLineStart);
		iGc->DrawLineTo(TPoint(horizLineStart.iX+(KIndentPerLevel*(aParagraphLevel-parentLevel))+KIndentPerLevel/2,horizLineStart.iY));
		}


	TInt lineIndentLevel=itemLevel;
	TInt count=-1;



	while (lineIndentLevel--)
		{
		count++;
		
		if (lineIndentLevel+1<itemLevel)
			{
			parent=itemToBeDrawn->Parent();
			if (count>1)
				{
				TInt parentsToFind=count-1;
				while (parentsToFind--)
					parent=parent->Parent();
				}
			if (!(parent->HasFurtherSibling()))
				{
				parentLevel = GetParagraphLevel(parent);
				startPoint=ItemPos(aItemIndex,parentLevel);	
				startPoint.iX-=KIndentPerLevel/2;
				continue;
				}
			else
				{
				if (parent->Parent()) parent=parent->Parent();
				parentLevel = GetParagraphLevel(parent);
				startPoint=ItemPos(aItemIndex,parentLevel);	
				startPoint.iX-=KIndentPerLevel/2;
				}
			}



		TInt vertLineLength=iItemHeight;
		if (lineIndentLevel+1==itemLevel)
			{
			if (!itemToBeDrawn->HasFurtherSibling())
				vertLineLength/=2;
			}
		iGc->MoveTo(startPoint);
		iGc->DrawLineTo(TPoint(startPoint.iX,startPoint.iY+vertLineLength));
		
		startPoint.iX-=KIndentPerLevel;
		}
		
	}





// COutlineHListBoxModel
////////////////////////


COutlineHListBoxModel* COutlineHListBoxModel::NewL(COutlineHListBox* aParent,CRichText* aText)
{
	COutlineHListBoxModel* self = new (ELeave) COutlineHListBoxModel;

	CleanupStack::PushL(self);

	self->iParent=aParent;
	self->iText=aText;
	self->ConstructL();

	CleanupStack::Pop();
	return self;
}


void COutlineHListBoxModel::ConstructL()
{
	 iOutlineTable = new (ELeave)COutlineTable(2);
	 iOutlineMap=COutlineMap::NewL();

	 // Construct the Outline table from the document
	 CreateEntryTableL();

}

COutlineHListBoxModel::~COutlineHListBoxModel()
	{
	delete iOutlineMap;

	delete iOutlineTable;

	}


TInt COutlineHListBoxModel::CurrentCharPosition()
{
	// This returns the character position in the document of the currently
	// selected item in the listbox

	// Get the current item's entry
	TInt item = iParent->CurrentItemIndex();

	CHierListItem* itemPtr=Item(item);
	TInt paragraphIndex = iOutlineMap->Index(itemPtr);
	
	return (iOutlineTable->At(paragraphIndex).iParagraphPos);
}


void COutlineHListBoxModel::CreateEntryTableL()
{
	/* The scans through the document and creates the table which is then
	   used by the outline control.
	   Each entry in the table references one paragraph in the document that contains
	   an outline level greater than zero. (Only styles have outline levels).
	   For each of these paragraphs, the following information is stored:
	   Paragraph no. in the document,
		Character position of start of paragraph, length of paragraph (or a maximum of
		128 - used to generate the text of each node in the control),
		the outline level of the paragraph.
	   Two boolean values are also stored:
		isChild is True if the entry is the first child of a previous entry
		lastEntry is True if this entry is the last entry at the current outline level
		These two values are used to decide the structure of the tree
	*/

	   

	TInt paragraphPos=0;
	TInt paragraphLength=0;
	TInt outlineLevel=0;
	TInt lastOutlineLevel = 0;
	TBool isChild=EFalse;
//	TBool lastEntry=ETrue;
	TBool styleChanges=EFalse;

	TInt entryCount = 0;

	TInt paragraphCount = iText->ParagraphCount();

	TInt count;
	TInt whileCount;
	TInt parentLevel;


 	const CParaFormatLayer* paragraphStyle;
	//
	CEikonEnv* eikonEnv=CEikonEnv::Static();

	eikonEnv->BusyMsgL(R_WORD_OUTLINE, KWaitingTime);

	for (count=0; count<paragraphCount; count++)
	{
		// Get position of this paragraph
		paragraphPos = iText->CharPosOfParagraph(paragraphLength, count);
		if (paragraphLength>KMaxParagraphLength) paragraphLength=KMaxParagraphLength;

		// Discard paragraphs with no text (length will be 1 because of paragraph delimiter)
		if (paragraphLength>1) 
		{
		paragraphStyle=iText->ParagraphStyle(styleChanges, paragraphPos, paragraphLength-1);
		if (paragraphStyle->SenseBase())
		{
 		 outlineLevel=((CParagraphStyle*)paragraphStyle)->OutlineLevel();
		 if (outlineLevel>0) 
		 {
			isChild = (lastOutlineLevel < outlineLevel && lastOutlineLevel>0);

			iOutlineTable->AppendL(TOutlineEntry(count,outlineLevel,paragraphLength-1,paragraphPos,isChild,EFalse));	
			entryCount++;
			lastOutlineLevel=outlineLevel;
		 }
		}

		}

	}


	// Now look through to find the final nodes at each level

	if (entryCount) 
	{
		TInt childCount;

		for (count=1; count<entryCount-1; count++)
		{
			lastOutlineLevel = iOutlineTable->At(count).iOutlineLevel;
			
			// Get parent level
			whileCount = count;
			childCount = 0;
			while (whileCount>0)
			{	
				if (iOutlineTable->At(whileCount).iIsChild) childCount++;
				if (iOutlineTable->At(whileCount).iLastEntry) childCount--;
				if (childCount == 1) break;
				whileCount--;
			}
			// Check if this node is at the top level already
			if (whileCount==0) continue;
			else parentLevel = iOutlineTable->At(whileCount-1).iOutlineLevel;

			whileCount = count+1;

			while (whileCount<entryCount)
			{
				outlineLevel = iOutlineTable->At(whileCount).iOutlineLevel;
				if (outlineLevel <= lastOutlineLevel && outlineLevel>parentLevel) break;
				if (outlineLevel <= parentLevel) 
				{
					iOutlineTable->At(count).iLastEntry = ETrue;
					break;
				}
				whileCount++;
			}
		}

		iOutlineTable->At(entryCount-1).iLastEntry = ETrue;


	}
	else 
		{
		eikonEnv->BusyMsgCancel();
		User::Leave(KErrNoOutline);
		}

	eikonEnv->BusyMsgCancel();

}

void COutlineHListBoxModel::ScanHeading(TDes& aText)
	{
	// Scan the heading
	for (TInt pos=0; pos < aText.Length(); pos++)
		// Replace this charater with a normal space
		if (aText[pos] == CEditableText::ENonBreakingSpace)
			aText[pos] = ' ';
	}

void COutlineHListBoxModel::CreateRootListL()
{
	// This creates entries in the list box for all entries in the outline
	// table which are not children of any other nodes 

	iHierListArray=new(ELeave)CArrayFixSeg<CHierListItem*>(5);
	CHierListItem* item;

	TInt count;

	TBuf<128> text;

	TInt paragraphCount = iOutlineTable->Count();
	TInt paragraphPos;
	TInt paragraphLength;
	TBool lastEntry;
	TBool isChild;

	TInt childCount = 0;

	for (count=0; count<paragraphCount; count++)
	{
		paragraphPos= iOutlineTable->At(count).iParagraphPos;
		paragraphLength= iOutlineTable->At(count).iParagraphLength;
		lastEntry= iOutlineTable->At(count).iLastEntry;
		isChild= iOutlineTable->At(count).iIsChild;

		if (isChild) childCount++;

		if (!isChild && childCount < 1)
		{
				iText->Extract(text, paragraphPos, paragraphLength);
				// Scan th heading
				ScanHeading(text);
				item = new(ELeave)CHierListItem((TInt16)0);
				CleanupStack::PushL(item);
				item->SetTextL(text);
	
				AddItemL(item, -1, -1);
				iOutlineMap->BindL(count, item);
				CleanupStack::Pop(); // Pop item
		}
		if (lastEntry) childCount--;

	}

}


void COutlineHListBoxModel::ExpandItemL(TInt aItemIndex)
{
	// This creates nodes for all immediate children of the given index

	CHierListItem* itemToBeExpanded=Item(aItemIndex);
	if (itemToBeExpanded->IsExpanded())
		return;

	TInt newItemIndex = aItemIndex;

	TInt index;
	TInt count;
	TBuf<128> text;

	TInt paragraphCount = iOutlineTable->Count();
	TInt paragraphPos;
	TInt paragraphLength;
	TBool lastEntry;
	TBool isChild;
	TInt childCount = 0;
	CHierListItem* item;

	index = iOutlineMap->Index(itemToBeExpanded);


	if (index != KErrNotFound)
	{
			for (count=index+1; count<paragraphCount; count++)
			{
				lastEntry= iOutlineTable->At(count).iLastEntry;
				isChild= iOutlineTable->At(count).iIsChild;


				if (isChild) childCount++;

				if (childCount == 1)
				{
						paragraphPos= iOutlineTable->At(count).iParagraphPos;
						paragraphLength= iOutlineTable->At(count).iParagraphLength;

						iText->Extract(text, paragraphPos, paragraphLength);
						ScanHeading(text);
						item = new(ELeave)CHierListItem((TInt16)0);
						CleanupStack::PushL(item);
						item->SetTextL(text);

						AddItemL(item, aItemIndex, newItemIndex++);

						iOutlineMap->BindL(count, item);
						CleanupStack::Pop(); // pop item
						itemToBeExpanded->SetExpanded();	
				}
				if (lastEntry) childCount--;	
				if (childCount == 0) break;
			}
	}
}



TInt COutlineHListBoxModel::GetItemByParagraph(TInt aPara)
{
	// Given a paragraph number in the Outline Table, this returns
	// the item number in the list box.
	
		CHierListItem* thisPtr = iOutlineMap->Ptr(aPara);
		TInt size = HierListArray()->Count();
		TInt count;
		TInt item = -1;

		for (count=0; count<size; count++)
		{
			if (HierListArray()->At(count) == thisPtr) 
			{
				item = count;
				break;
			}
		}
		return item;
}


TInt COutlineHListBoxModel::ExpandCurrentPositionL(TInt aCursorPos)
{
	// This finds out which paragraph the cursor is currently at
	// then expands its parents

	TInt paragraphNo = iText->ParagraphNumberForPos(aCursorPos);
	TInt count=0;
	TInt stylePara = -1;
	TInt paragraphCount = iOutlineTable->Count();

	// Find out which style entry is above this position

	for (count=0; count<paragraphCount; count++)
	{
		if (iOutlineTable->At(count).iParagraphNo > paragraphNo) break;
		stylePara = count;
	}


	return (ExpandParagraphL(stylePara));

}

TInt COutlineHListBoxModel::ExpandParagraphL(TInt aPara)
{
	// This looks to see if the paragraphs parent node is expand, and if not,
	// expand it by recursion.
	// The maximum iteration level is the number of levels deep the initial node is,
	// and is unlikely to be more than 2 or 3 levels.
	// The theoretical maximum is 99 levels, (as the UI only support entry of level 0-99)


	// Check that this paragraph has not been expanded

	if (iOutlineMap->IndexPresent(aPara) || aPara == -1) return GetItemByParagraph(aPara);

	// If this node is a first child, then try to open the previous node
	// since it must be it's parent

	if (iOutlineTable->At(aPara).iIsChild)
	{
		ExpandParagraphL(aPara-1); 
		// Node aPara-1 is now guaranteed to exist, so open it up
		TInt item = GetItemByParagraph(aPara-1);

		if (item != -1) ExpandItemL(item);

		return GetItemByParagraph(aPara);
	}
		

	// Need to look a bit further up since this node has siblings

	TInt childCount = 0;
	TInt para = aPara - 1;
	TBool child;

	while (aPara >= 0)
	{
		if (iOutlineTable->At(para).iLastEntry) childCount++;
		child = iOutlineTable->At(para).iIsChild;

		if (child && childCount == 0)
		{
			// para is a child of the same level, so open its parent
			ExpandParagraphL(para-1); 
			TInt item = GetItemByParagraph(para-1);
			if (item != -1) ExpandItemL(item);
			return GetItemByParagraph(aPara);
		}

		if (child) childCount--;

		para--;
	}

	return 0;
}