/*

* Copyright (c) 1997-1999 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 <eikbtpan.h>

#include <eiklbbut.h>

#include <eikcmbut.h>

#include <eiklabel.h>

#include <barsread.h>

#include <coedef.h>

#include <eiklabel.h>

#include <eikcmobs.h>

#include <uikon.hrh>

#include <eikcoctl.rsg>

#include <coemain.h>

#include <eikenv.h>

#include "lafbtpan.h"

#include "laflbbut.h"

#include <eiklbbut.h>

#include <uiklaf/private/lafenv.h>

// const TInt KButtonArrayGranularity=2;

const TInt KVerticalSpaceForNonLabeledButtons=6;

const TInt KEikButtonLabelTopMargin=2;

const TInt KEikButtonLabelBottomMargin=1;

// const TInt KStdMinButtonWidth=50;

#define VERTICAL_BUTTONS_AT_BOTTOM

static TBool AnyButtonHasHotKey(const CEikControlGroup* aGroup, const TInt count)

	{

	TBool hasHotkey=EFalse;

		for(TInt ii=0;ii<count && !hasHotkey;ii++)

			{

			if(static_cast<CEikLabeledButton*>(aGroup->Control(ii))->ShowsHotKey())

			hasHotkey=ETrue;

			}

	return hasHotkey;

	}

EXPORT_C CEikButtonPanel::~CEikButtonPanel()

	{

	if (iControlGroups)

		{

		iControlGroups->ResetAndDestroy();

		delete iControlGroups;

		}

	}

EXPORT_C CEikButtonPanel::CEikButtonPanel()

	: iMinButWidth(LafButtonPanel::MinButtonWidth())

	{

	__DECLARE_NAME(_S("CEikButtonPanel"));

	SetNonFocusing();

	}

void CEikButtonPanel::AppendNewLineL()

	{//private

	CEikControlGroup* controlGroup=new(ELeave) CEikControlGroup();

	CleanupStack::PushL(controlGroup);

	if(LafButtonPanel::ButtonsAllSameSize())

		controlGroup->SetControlsAllSameSize();

	controlGroup->SetControlSpacing(LafButtonPanel::HorGapBetweenButtons(),LafButtonPanel::VerGapBetweenButtons());

	controlGroup->SetContainerWindowL(*this);

	controlGroup->ConstructL(

		static_cast<CEikControlGroup::TStartCorner>(LafButtonPanel::DefaultStartCorner()),

		static_cast<CEikControlGroup::TOrientation>(LafButtonPanel::DefaultOrientation()));

	iControlGroups->AppendL(controlGroup);

	CleanupStack::Pop(); // controlGroup

	iCount++;

	iMinSize=TSize(0,0);

	}

/**

 * Writes the internal state of the control and its components to aStream.

 * Does nothing in release mode.

 * Designed to be overidden and base called by subclasses.

 *

 * @internal

 * @since App-Framework_6.1

 */

#ifndef _DEBUG

EXPORT_C void CEikButtonPanel::WriteInternalStateL(RWriteStream&) const

	{}

#else

EXPORT_C void CEikButtonPanel::WriteInternalStateL(RWriteStream& aWriteStream) const

	{

	_LIT(KEikLitBtpanCtlSt,"<CEikButtonPanel>");

	_LIT(KEikLitBtpanCtlEnd,"<\\CEikButtonPanel>");

	_LIT(KEikLitBtpanCtlMinSize, "<iMinSize>");

	_LIT(KEikLitBtpanCtlMinSizeEnd, "<\\iMinSize>");

	_LIT(KEikLitBtpanCtlButWidth, "<iButWidth>");

	_LIT(KEikLitBtpanCtlButWidthEnd, "<\\iButWidth>");

	_LIT(KEikLitBtpanCtlMinButWidth, "<iMinButWidth>");

	_LIT(KEikLitBtpanCtlMinButWidthEnd, "<\\iMinButWidth>");

	_LIT(KEikLitBtpanCtlCount, "<iCount>");

	_LIT(KEikLitBtpanCtlCountEnd, "<\\iCount>");

	_LIT(KEikLitBtpanCtlObs, "<iCommandObserver>");

	_LIT(KEikLitBtpanCtlObsEnd, "<\\iCommandObserver>");

	aWriteStream << KEikLitBtpanCtlSt;

	aWriteStream << KEikLitBtpanCtlMinSize;

	aWriteStream.WriteInt32L(iMinSize.iWidth);

	aWriteStream.WriteInt32L(iMinSize.iHeight);

	aWriteStream << KEikLitBtpanCtlMinSizeEnd;

	aWriteStream << KEikLitBtpanCtlButWidth;

	aWriteStream.WriteInt32L(iButWidth);

	aWriteStream << KEikLitBtpanCtlButWidthEnd;

	aWriteStream << KEikLitBtpanCtlMinButWidth;

	aWriteStream.WriteInt32L(iMinButWidth);

	aWriteStream << KEikLitBtpanCtlMinButWidthEnd;

	aWriteStream << KEikLitBtpanCtlCount;

	aWriteStream.WriteInt32L(iCount);

	aWriteStream << KEikLitBtpanCtlCountEnd;

	aWriteStream << KEikLitBtpanCtlObs;

	aWriteStream.WriteInt32L((TInt)iCommandObserver);

	aWriteStream << KEikLitBtpanCtlObsEnd;

	CCoeControl::WriteInternalStateL(aWriteStream);

	aWriteStream << KEikLitBtpanCtlEnd;

	}

#endif

EXPORT_C void CEikButtonPanel::ConstructL()

	{

	iControlGroups=new(ELeave) CArrayPtrFlat<CEikControlGroup>(1);

	AppendNewLineL();

	}

EXPORT_C void CEikButtonPanel::SetHorizontal()

	{

	for(TInt ii=0;ii<iCount;ii++)

		(*iControlGroups)[ii]->SetControlLayout(CEikControlGroup::EFromTopLeft, CEikControlGroup::ELayHorizontally);

	}

EXPORT_C TInt CEikButtonPanel::ButtonId(CCoeControl* aControl) const

	{

	TInt id=0;

	for(TInt ii=0;ii<iCount;ii++)

		{

		id=(*iControlGroups)[ii]->ControlId(aControl);

		if((*iControlGroups)[ii]->ControlById(id)==aControl)

			break;

		}

	return id; 

	// KErrNotFound is a valid Id, but also used by CEikControlGroup to signify not found!

	}

EXPORT_C CEikCommandButtonBase* CEikButtonPanel::ButtonById(TInt aButtonId) const

	{

	CEikLabeledButton* button=LabeledButtonById(aButtonId);

	return (button ? button->Button() : NULL);

	}

EXPORT_C CEikLabeledButton* CEikButtonPanel::LabeledButtonById(TInt aButtonId) const

	{

	CEikLabeledButton* button=NULL;

	for(TInt ii=0;ii<iCount && !button;ii++)

		{

		button=static_cast<CEikLabeledButton*>((*iControlGroups)[ii]->ControlById(aButtonId));

		}

	return button;

	}

EXPORT_C void CEikButtonPanel::AddButtonL(CEikLabeledButton* aButton,TInt aId)

	{

	AddButtonL(aButton,aId,iCount-1);//last row by default

	}

/**

 * Takes ownership of aButton, with asociated id, aId and adds it to the row of buttons aRow.

 * Creates aRow if it does not already exist. Should not be used for vertical button layout.

 * Leaves in out of memory conditions. 

 *

 * @ since Uikon1.2

 */

EXPORT_C void CEikButtonPanel::AddButtonL(CEikLabeledButton* aButton,TInt aId,TInt aRow)

	{

	CleanupStack::PushL(aButton);

	aButton->SetNonFocusing();

	aButton->SetContainerWindowL(*this);

	aButton->CopyControlContextFrom(this);

	aButton->SetObserver(this);

	for(;aRow>iCount;AppendNewLineL())

		;// no body

	(*iControlGroups)[aRow-1]->AddControlL(aButton,aId);

	CleanupStack::Pop(); // aButton

	ResetMinimumSize();

	}

EXPORT_C void CEikButtonPanel::ActivateL()

	{

	CCoeControl::ActivateL();

	}

EXPORT_C void CEikButtonPanel::ConstructFromResourceL(TResourceReader& aReader)

	{

	ConstructL();

	aReader.ReadUint32(); // read past flags - they're only used in CBAs currently

	const TInt count=aReader.ReadInt16();

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

		{

		const TInt id=aReader.ReadInt16();

		CEikLabeledButton* button=new(ELeave) CEikLabeledButton;

		CleanupStack::PushL(button);

		button->CopyControlContextFrom(this);

		button->ConstructFromResourceL(aReader);

		TInt lineNumber=aReader.ReadInt8();

		if (button->ShowsHotKey())

			{

			CEikLabel* label=button->Label();

			label->CopyControlContextFrom(this);

			label->iMargin.iTop=KEikButtonLabelTopMargin;

			label->iMargin.iBottom=KEikButtonLabelBottomMargin;

			}

		CleanupStack::Pop(); // AddButtonL takes ownership

		AddButtonL(button,id,lineNumber);

		}

	}

EXPORT_C void CEikButtonPanel::ResetMinimumSize()

	{

	iMinSize=TSize(0,0);

	}

EXPORT_C void CEikButtonPanel::SetMinButtonWidth(TInt aWidth)

	{

	iMinButWidth=aWidth;

	}

EXPORT_C void CEikButtonPanel::SetCommandObserver(MEikCommandObserver* aCommandObserver)

	{

	iCommandObserver=aCommandObserver;

	}

void CEikButtonPanel::UpdateHotKeyL(TInt aCommandId,CEikLabeledButton::TFlags aFlags,TInt aKeyCode)

	{

	CEikLabeledButton* button=LabeledButtonById(aCommandId);

	if (!button)

		User::Leave(KErrNotFound);

	button->UpdateHotKey(aKeyCode,aFlags);

	}

EXPORT_C TInt CEikButtonPanel::CountComponentControls() const

	{

	return iCount;

	}

EXPORT_C CCoeControl* CEikButtonPanel::ComponentControl(TInt aIndex) const

	{

	return (*iControlGroups)[aIndex];

	}

EXPORT_C void CEikButtonPanel::SizeChanged()

	{

	if(!iMinSize.iWidth)

		SetButtonWidths();

	TInt excess=iSize.iWidth-iMinSize.iWidth;

	TMargins8 margins = LafButtonPanel::Margins();

	TInt gapBetweenButtons=LafButtonPanel::HorGapBetweenButtons();

	if(excess<0)

		AdjustMarginsToFit(margins.iLeft, margins.iRight, gapBetweenButtons);

	TRect groupRect=Rect();

	groupRect.iTl.iX+=margins.iLeft;

	groupRect.iBr.iX-=margins.iRight;

	groupRect.iTl.iY+=margins.iTop;

	#if defined VERTICAL_BUTTONS_AT_BOTTOM

	groupRect.iTl.iY+=(iSize.iHeight-iMinSize.iHeight);

	#endif

	TRect individualRect(groupRect.iTl,TSize(0,0));

	TInt translateBy=0;

	TInt horizontal=0;

	TInt vertical=0;

	CEikControlGroup* group;

	TSize groupMinSize;

	for(TInt ii=0 ; ii<iCount ;ii++)

		{

		group=(*iControlGroups)[ii];

		group->ControlSpacing(horizontal,vertical);

		group->SetControlSpacing(gapBetweenButtons,vertical);

		groupMinSize=group->MinimumSize();

		individualRect=TRect(individualRect.iTl,TSize(groupRect.Width(),groupMinSize.iHeight));

		TRect shiftedRect=individualRect;

		excess=groupRect.Width()-groupMinSize.iWidth;

		if (excess>0)

			{

			TInt shiftLeft=0;

			TInt shiftRight=0;

			LafButtonPanel::TranslateForExcessSpace(excess, shiftLeft, shiftRight);

			shiftedRect.iTl.iX+=shiftLeft;

			shiftedRect.iBr.iX+=shiftRight;

			}

		group->SetRect(shiftedRect);

		translateBy=group->Size().iHeight+LafButtonPanel::InterRowMargin();

		if(LafLabeledButton::ShowHotKey()

			&& group->Orientation()==CEikControlGroup::ELayHorizontally

			&& !(AnyButtonHasHotKey(group,group->ControlArray()->Count())))

			{

			translateBy+=KVerticalSpaceForNonLabeledButtons;

			}

		individualRect.iTl.iY+=translateBy;

		}

	}

void CEikButtonPanel::AdjustMarginsToFit(TInt8& aLeftBorder,TInt8& aRightBorder, TInt& aGapBetweenButtons)

	{

	// let the laf dictate the shrinking policy

	CEikControlGroup* group;

	TFixedArray<LafButtonPanel::TDimensions,KLafButPanMaxLinesOfDlgButtons> array;

	for(TInt ii=0; ii<iCount && ii<KLafButPanMaxLinesOfDlgButtons;ii++)

		{

		group=(*iControlGroups)[ii];

		array[ii].iNumButtons=group->ControlArray()->Count();

		array[ii].iExcess=iSize.iWidth-group->MinimumSize().iWidth;

		}

	LafButtonPanel::ReduceMarginsToFit(array, aLeftBorder, aRightBorder, aGapBetweenButtons);

	}

void CEikButtonPanel::SetButtonWidths()

	{

	if((*iControlGroups)[0]->Orientation()==CEikControlGroup::ELayHorizontally)

		{

		CArrayFix<TEikGroupControl>* array=NULL;

		TInt components;

		TInt width=0;

		if(iMinButWidth!=KLafButPanNoMinButWidth)

			width=iMinButWidth;

		if(LafButtonPanel::ButtonsAllSameSize())

			{

			TInt thisWidth;

			for(TInt ll=0; ll<iCount ; ll++)

				{

				array=(*iControlGroups)[ll]->ControlArray();

				components=array->Count();

				for(TInt mm=0; mm<components;mm++)

					{

					thisWidth=(*array)[mm].iControl->MinimumSize().iWidth;

					if(thisWidth>iButWidth)

						iButWidth=thisWidth;

					}

				}

			if(width<iButWidth)

				width=iButWidth;

			}

		if(width)

			{	

			for(TInt jj=0; jj<iCount ; jj++)

				{

				array=(*iControlGroups)[jj]->ControlArray();

				components=array->Count();

				for(TInt kk=0; kk<components;kk++)

					{

					TEikGroupControl& grpControl=(*array)[kk];

					grpControl.SetLength(Max(width,grpControl.iControl->MinimumSize().iWidth));

					}

				}

			}

		}

	}

EXPORT_C TSize CEikButtonPanel::MinimumSize()

	{

	if (!iMinSize.iWidth)

		{

		SetButtonWidths();

		TMargins8 margins = LafButtonPanel::Margins();

		iMinSize.iHeight=margins.iTop+margins.iBottom;

		iMinSize.iWidth=0;

		iMinSize.iHeight+=(iCount-1)*LafButtonPanel::InterRowMargin();

		CEikControlGroup* group=NULL;

		TSize groupMinSize;

		for(TInt jj=0; jj<iCount; jj++)

			{

			group=(*iControlGroups)[jj];

			TInt count=group->ControlArray()->Count();

			if(LafLabeledButton::ShowHotKey())

				{

				CEikControlGroup::TOrientation orientation=group->Orientation();

				if(orientation==CEikControlGroup::ELayVertically && !LafButtonPanel::ButtonsAllSameSize())

					{

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

						{

						if(!static_cast<CEikLabeledButton*>(group->Control(ii))->ShowsHotKey())

							iMinSize.iHeight+=KVerticalSpaceForNonLabeledButtons;

						}

					}

				else if(orientation==CEikControlGroup::ELayVertically && LafButtonPanel::ButtonsAllSameSize())

					{

					if(!AnyButtonHasHotKey(group,count))

						{

						group->SetControlSpacing(LafButtonPanel::HorGapBetweenButtons(),LafButtonPanel::VerGapBetweenButtons()+KVerticalSpaceForNonLabeledButtons);

						iMinSize.iHeight+=KVerticalSpaceForNonLabeledButtons; // for bottom

						}

					}

				else if(orientation==CEikControlGroup::ELayHorizontally)

					{

					if(!AnyButtonHasHotKey(group,count))

						iMinSize.iHeight+=KVerticalSpaceForNonLabeledButtons;

					}

				}

			groupMinSize=group->MinimumSize();

			iMinSize.iHeight+=groupMinSize.iHeight;

			iMinSize.iWidth=Max(iMinSize.iWidth,groupMinSize.iWidth);

			}

		iMinSize.iWidth+=(margins.iLeft + margins.iRight);

		}

	return(iMinSize);

	}

EXPORT_C void CEikButtonPanel::HandleControlEventL(CCoeControl* aControl,TCoeEvent aEventType)

	{

	if (aEventType==EEventStateChanged)

		iCommandObserver->ProcessCommandL(ButtonId(aControl));

	}

EXPORT_C CEikCommandButtonBase* CEikButtonPanel::ButtonForKey(TInt aChar,TInt& aButtonId) const

	{

	const TCharF foldedChar(aChar);

	const TUint foldedCharCode=TUint(foldedChar);

	TInt count=0;

	CEikControlGroup* group=NULL;

	CEikCommandButtonBase* match=NULL;

	for(TInt jj=0;jj<iCount && !match;jj++)

		{

		group=(*iControlGroups)[jj];

		count=group->ControlArray()->Count();

		for (TInt ii=0;ii<count && !match ;++ii)

			{

			CEikLabeledButton* button=static_cast<CEikLabeledButton*>(group->Control(ii));

			if ((foldedChar==TCharF(button->HotKeyCode()))

				||((button->Button()->IsDefault())&&(LafEnv::IsDefaultKey(foldedCharCode))))

				{

				aButtonId=group->ControlId(group->Control(ii));

				if (button->IsVisible())

					match=button->Button();

				}

			}

		}

	return match;

	}

EXPORT_C void CEikButtonPanel::MakeButtonVisible(TInt aButtonId,TBool aVisible)

	{

	TInt count=0;

	CEikControlGroup* group=NULL;

	for(TInt jj=0;jj<iCount;jj++)

		{

		group=(*iControlGroups)[jj];

		count=group->ControlArray()->Count();

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

			{

			CEikLabeledButton* button=static_cast<CEikLabeledButton*>(group->Control(ii));

			if (group->ControlId(group->Control(ii))==aButtonId)

				{

				button->MakeVisible(aVisible);

				return;

				}

			}

		}

	}

void CEikButtonPanel::SetCommandL(TInt aPosition,TInt aCommandId,const TDesC* aText,const CFbsBitmap* aBitmap,const CFbsBitmap* aMask)

	{

	TInt groupIndex=0;

	CEikLabeledButton* lBut=LabeledButtonByPosition(aPosition,groupIndex);

	CEikCommandButtonBase* button=static_cast<CEikCommandButtonBase*>(lBut->Button());

	static_cast<CEikCommandButton*>(button)->SetCommandL(aCommandId, aText, aBitmap, aMask);

	TInt ignore=0;

	(*((*iControlGroups)[groupIndex])->ControlArray())[RelativePosition(aPosition,ignore)].iId=aCommandId;

	}

void CEikButtonPanel::SetCommandL(TInt aPosition,TInt aResourceId)

	{

	TResourceReader reader;

	iEikonEnv->CreateResourceReaderLC(reader,aResourceId);

	const TInt id=reader.ReadInt16(); // id

	const TInt type=reader.ReadInt16(); // buttontype

	if (type==EEikCtCommandButton)

		{

		CEikCommandButton* button=new(ELeave) CEikCommandButton;

		CleanupStack::PushL(button);

		button->ConstructFromResourceL(reader);

		/*TInt hotKeyCode=*/reader.ReadInt32();

		/*TInt lButFlags=*/reader.ReadInt8();

		SetCommandL(aPosition, id, button->Label()->Text(), NULL, NULL); 

		CleanupStack::PopAndDestroy();

		}

	CleanupStack::PopAndDestroy();

	}

void CEikButtonPanel::SetCommandSetL(TInt aResourceId)

	{

	TResourceReader reader;

	iEikonEnv->CreateResourceReaderLC(reader,aResourceId);

	const TInt count=reader.ReadInt16();

	TInt ii;

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

		{

		const TInt id=reader.ReadInt16(); // id

		const TInt type=reader.ReadInt16(); // buttontype

		if (type==EEikCtCommandButton)

			{

			CEikCommandButton* button=new(ELeave) CEikCommandButton;

			CleanupStack::PushL(button);

			button->ConstructFromResourceL(reader);

			/*TInt hotKeyCode=*/reader.ReadInt32();

			/*TInt lButFlags=*/reader.ReadInt8();

			SetCommandL(ii, id, button->Label()->Text(), NULL, NULL); 

			CleanupStack::PopAndDestroy();

			DimCommand(id,EFalse);

			}