/*

* 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

	{