/*

* 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 <eikcmbut.h>

#include <barsread.h>

#include <gulbordr.h>

#include <eikenv.h>

#include <eiklabel.h>

#include <eikimage.h>

#include <eikpanic.h>

#include <LAFCMBUT.H>

#include "gulcolor.h"

#include <AknIconUtils.h>

const TInt KLayoutMask				=0x0007;

const TInt KLayoutAndFontMask		=0x000f;

const TInt KExcessMask				=0x00f0;

const TInt KDisplayContentMask		=0x0f00;

//

// class CEikCommandStack

//

NONSHARABLE_CLASS(CEikCommandStack) : public CBase

	{

public:

	class TStackableCommand

		{

	public:

		TStackableCommand();

		TStackableCommand(TInt aCommandId,HBufC* aText,CFbsBitmap* aBitmap,CFbsBitmap* aMask);

	public:

		void SetBitmapOwner(TBool aOwner);

		void SetDimmed(TBool aDimmed);

		void SetVisible(TBool aVisible);

		inline TBool IsBitmapOwner() const;

		inline TBool IsDimmed() const;

		inline TBool IsVisible() const;

	public:

		TInt iCommandId;

		HBufC* iText;

		CFbsBitmap* iBitmap;

		CFbsBitmap* iMask;

	private:

		enum TFlags

			{

			EBitmapOwner	=0x04,

			EDimmed			=0x08,

			EInvisible		=0x10,

			};

	private:

		TInt iFlags;

		};

public:

	static CEikCommandStack* NewL();

	~CEikCommandStack();

public:

	void AddL(TInt aCommandId,const TDesC* aText,CFbsBitmap* aBitmap,CFbsBitmap* aMask);

	TBool Remove(TInt aCommandId);

	TStackableCommand Pop();

	TInt Level() const;

	TStackableCommand& StackableCommand(TInt aCommandId) const;

	TStackableCommand& StackableCommandByPos(TInt aPos) const;

private:

	TInt Find(TInt aCommandId) const;

	void Delete(TInt aIndex);

private:

	CArrayFix<TStackableCommand>* iCommands;

	};

CEikCommandStack::TStackableCommand::TStackableCommand()

	: iCommandId(0), iText(NULL), iBitmap(NULL), iMask(NULL), iFlags(0)

	{}

CEikCommandStack::TStackableCommand::TStackableCommand(TInt aCommandId,HBufC* aText,

													   CFbsBitmap* aBitmap,CFbsBitmap* aMask)

	: iCommandId(aCommandId), iText(aText), iBitmap(aBitmap), iMask(aMask), iFlags(0)

	{}

void CEikCommandStack::TStackableCommand::SetBitmapOwner(TBool aOwner)

	{

	if (aOwner)

		iFlags|=EBitmapOwner;

	else

		iFlags&=~EBitmapOwner;

	}

void CEikCommandStack::TStackableCommand::SetDimmed(TBool aDimmed)

	{

	if (aDimmed)

		iFlags|=EDimmed;

	else

		iFlags&=~EDimmed;

	}

void CEikCommandStack::TStackableCommand::SetVisible(TBool aVisible)

	{

	if (!aVisible)

		iFlags|=EInvisible;

	else

		iFlags&=~EInvisible;

	}

inline TBool CEikCommandStack::TStackableCommand::IsBitmapOwner() const

	{return iFlags&EBitmapOwner;}

inline TBool CEikCommandStack::TStackableCommand::IsDimmed() const

	{return iFlags&EDimmed;}

inline TBool CEikCommandStack::TStackableCommand::IsVisible() const

	{return !(iFlags&EInvisible);}

CEikCommandStack* CEikCommandStack::NewL()

	{ // static

	CEikCommandStack* self=new(ELeave) CEikCommandStack;

	return self;

	}

CEikCommandStack::~CEikCommandStack()

	{

	if (iCommands)

		{

		for (TInt ii=iCommands->Count()-1;ii>=0;ii--)

			{

			Delete(ii);

			}

		}

	}

void CEikCommandStack::AddL(TInt aCommandId,const TDesC* aText,CFbsBitmap* aBitmap,CFbsBitmap* aMask)

	{

	CArrayFix<TStackableCommand>* commands=NULL;

	if (iCommands)

		{

		commands=iCommands;

		}

	else

		{

		commands=new(ELeave) CArrayFixFlat<TStackableCommand>(1);

		CleanupStack::PushL(commands);

		}

	HBufC* text=NULL;

	if (aText)

		text=aText->AllocLC();

	TStackableCommand cmd(aCommandId,text,aBitmap,aMask);

	commands->AppendL(cmd);

	if (aText)

		CleanupStack::Pop(); // text

	if (!iCommands)

		{

		iCommands=commands;

		CleanupStack::Pop(); // commands

		}

	}

TBool CEikCommandStack::Remove(TInt aCommandId)

	{

	TBool removed=EFalse;

	if (iCommands)

		{

		const TInt index=Find(aCommandId);

		if (index!=KErrNotFound)

			{

			Delete(index);

			removed=ETrue;

			}

		}

	return removed;

	}

TInt CEikCommandStack::Level() const

	{

	return (iCommands? iCommands->Count() : 0);

	}

CEikCommandStack::TStackableCommand& CEikCommandStack::StackableCommand(TInt aCommandId) const

	{

	// __ASSERT_ALWAYS(iCommands,..........

	// search backwards through the array in case there are two commands with the same id

	TInt loop=iCommands->Count();

	TInt index=KErrNotFound;

	while (--loop>=0)

		{

		if ((*iCommands)[loop].iCommandId==aCommandId)

			{

			index=loop;

			break;

			}

		}

	// __ASSERT_ALWAYS(index!=KErrNotFound...

	return (*iCommands)[index];

	}

CEikCommandStack::TStackableCommand& CEikCommandStack::StackableCommandByPos(TInt aPos) const

	{

	// __ASSERT_ALWAYS(iCommands,..........

	// __ASSERT_ALWAYS(aPos>=0 && aPos<iCommands->Count(),...

	return (*iCommands)[aPos];

	}

TInt CEikCommandStack::Find(TInt aCommandId) const

	{

	// __ASSERT_DEBUG(iCommands...

	const TInt count=iCommands->Count();

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

		{

		TInt command=(*iCommands)[ii].iCommandId;

		if (command==aCommandId)

			return ii;

		}

	return KErrNotFound;

	}

CEikCommandStack::TStackableCommand CEikCommandStack::Pop()

	// Relinquishes ownership of text and bitmap resources.

	{

	ASSERT(iCommands);

	ASSERT(iCommands->Count());

	TInt top=iCommands->Count()-1;

	TStackableCommand poppedCommand=(*iCommands)[top];

	iCommands->Delete(top);

	if (iCommands->Count()==0)

		{

		delete iCommands;

		iCommands=NULL;

		}

	return poppedCommand;

	}

void CEikCommandStack::Delete(TInt aIndex)

	{

	ASSERT(iCommands);

	TStackableCommand cmd=(*iCommands)[aIndex];

	delete cmd.iText;

	if (cmd.IsBitmapOwner())

		{

		delete cmd.iBitmap;

		delete cmd.iMask;

		}

	iCommands->Delete(aIndex);

	if (iCommands->Count()==0)

		{

		delete iCommands;

		iCommands=NULL;

		}

	}

//

// class CEikCommandButtonBase

//

EXPORT_C CEikCommandButtonBase::~CEikCommandButtonBase()

	{

	delete iComponents[0];

	delete iComponents[1];

	delete iCommandStack;

	}

EXPORT_C CEikCommandButtonBase::CEikCommandButtonBase()

	{

	__DECLARE_NAME(_S("CEikCommandButton"));

	LafCommandButtonBase::GetDefaultBorder(iBorder);

    iContext = this;

	SetBehavior(EEikButtonStaysClear);

	SetDisplayContent(EBoth); // default if button contains both

	SetExcessSpace(EShare); // default if button contains both

	SetButtonLayout(EFirstRightSecondLeft); // default if button contains both

	SetNonFocusing();

	}

EXPORT_C void CEikCommandButtonBase::SetTextL(const TDesC& aText,CEikAlignedControl*& aComponent)

	{

	if (aComponent==NULL)

		{

		CEikLabel* label=new(ELeave) CEikLabel;

		CleanupStack::PushL(label);

		label->SetContainerWindowL(*this);

		CleanupStack::Pop(); // label

		label->SetFont(iCmdFlags&EDenseFont? iEikonEnv->DenseFont() : iEikonEnv->LegendFont());

		label->SetAllMarginsTo(LafCommandButtonBase::LabelMargin());

		aComponent=label;

		}

	STATIC_CAST(CEikLabel*,aComponent)->SetTextL(aText);

	}

EXPORT_C void CEikCommandButtonBase::SetPictureL(const CFbsBitmap* aMain,const CFbsBitmap* aMask,CEikAlignedControl*& aComponent)

	{

	if (aMain)

		{

		CEikImage* image=new(ELeave) CEikImage;

		CleanupStack::PushL(image);

		image->SetContainerWindowL(*this);

		image->SetPicture(aMain,aMask);

		SetImageAttributes(image);

		if (IsReadyToDraw())

			image->ActivateL(); // won't leave

		if (aComponent)

			{

			const TRect rect(aComponent->Rect());

			if (rect.Width())

				image->SetRect(rect);

			delete aComponent;

			}

		CleanupStack::Pop(); // image

		aComponent=image;

		}

	else if (aComponent)

		{

		delete aComponent;

		aComponent=NULL;

		SetNewComponentExtentL();

		}

	}

EXPORT_C void CEikCommandButtonBase::SetPictureFromFileL(const TDesC& aFilename,TInt aMain,TInt aMask,CEikAlignedControl*& aComponent)

	{

	CEikImage* image=new(ELeave) CEikImage;

	CleanupStack::PushL(image);

	image->SetContainerWindowL(*this);

	image->CreatePictureFromFileL(aFilename,aMain,aMask);

	SetImageAttributes(image);

	if (IsReadyToDraw())

		image->ActivateL(); // won't leave

	if (aComponent)

		{

		const TRect rect(aComponent->Rect());

		if (rect.Width())

			image->SetRect(rect); // won't leave

		delete aComponent;

		}

	CleanupStack::Pop(); // image

	aComponent=image;

	}

EXPORT_C void CEikCommandButtonBase::StartConstructFromResourceL(TResourceReader& aReader)

	{

	if (!iCommandStack)

		{

		iCommandStack=CEikCommandStack::NewL();

		}

	aReader.ReadInt8();

	const TInt behavior=aReader.ReadInt16();

	SetBehavior(STATIC_CAST(TButtonBehavior,behavior));

	if(behavior==EEikButtonStaysClear)

		{

		SetState(EClear);

		}

	else if(behavior==EEikButtonStaysSet)

		{

		SetState(ESet);

		}

	const TInt layout=aReader.ReadInt16();

	SetButtonLayout(STATIC_CAST(TLayout,(layout&KLayoutAndFontMask)));

	SetExcessSpace(STATIC_CAST(TExcess,(layout&KExcessMask)));

	aReader.ReadTPtrC();  // bubble help text 

	aReader.ReadInt32(); // extension link

	}

EXPORT_C void CEikCommandButtonBase::ConstructLabelFromResourceL(TResourceReader& aReader,TWhichComponent aWhich)

	{

	if (!iCommandStack)

		{

		iCommandStack=CEikCommandStack::NewL();

		}

	TPtrC text=aReader.ReadTPtrC();

	if (text.Length())

		{

		SetTextL(text,((CEikAlignedControl*&)(aWhich==EFirst? iComponents[0] : iComponents[1])));

		CEikLabel* label=STATIC_CAST(CEikLabel*,(aWhich==EFirst? iComponents[0] : iComponents[1]));

		label->SetAllMarginsTo(LafCommandButtonBase::LabelMargin());

		label->SetContainerWindowL(*this);

		}

	}

EXPORT_C void CEikCommandButtonBase::ConstructImageFromResourceL(TResourceReader& aReader,TWhichComponent aWhich)

	{

	if (!iCommandStack)

		{

		iCommandStack=CEikCommandStack::NewL();

		}

	TPtrC bitmapFile=aReader.ReadTPtrC();

	const TInt bitmapId=aReader.ReadInt16();

	const TInt bitmapMask=aReader.ReadInt16();

	if (bitmapId!=-1)

		SetPictureFromFileL(bitmapFile,bitmapId,bitmapMask,(aWhich==EFirst? iComponents[0] : iComponents[1]));

	}

TInt CEikCommandButtonBase::ButFlags() const	

	{

	return iCmdFlags;

	}

EXPORT_C void CEikCommandButtonBase::SetDefault(TBool aDefaultButton)

	{

	iDefault = aDefaultButton;

	}

TBool CEikCommandButtonBase::IsDefault() const

	{

	return iDefault;

	}

EXPORT_C TSize CEikCommandButtonBase::MinimumSize()

	{

	TSize size;

	const TSize comp1Size=(iComponents[0] ? iComponents[0]->MinimumSize() : size);

	const TSize comp2Size=(iComponents[1] ? iComponents[1]->MinimumSize() : size);

	size=TSize(iMargins.iLeft + iMargins.iRight,iMargins.iTop + iMargins.iBottom);

    size+=iBorder.SizeDelta();

	if (iComponents[1]==NULL || ((iCmdFlags&KDisplayContentMask)==EFirstOnly))

		size+=comp1Size;

	else if (iComponents[0]==NULL || ((iCmdFlags&KDisplayContentMask)==ESecondOnly))

		size+=comp2Size;

	else if (LayoutIsVertical())

		{

		size.iHeight+=comp1Size.iHeight+comp2Size.iHeight+LafCommandButtonBase::IntraComponentMargin();

		size.iWidth+=Max(comp1Size.iWidth,comp2Size.iWidth);

		}

	else

		{

		size.iWidth+=comp1Size.iWidth+comp2Size.iWidth+LafCommandButtonBase::IntraComponentMargin();

		size.iHeight+=Max(comp1Size.iHeight,comp2Size.iHeight);

		}

	return size;

	}

EXPORT_C void CEikCommandButtonBase::SetDimmed(TBool aDimmed)

	{

	CCoeControl::SetDimmed(aDimmed);

	if (iComponents[0])

		iComponents[0]->SetDimmed(aDimmed);

	if (iComponents[1])

		iComponents[1]->SetDimmed(aDimmed);

	}

EXPORT_C void CEikCommandButtonBase::SetContainerWindowL(const CCoeControl& aContainer)

	{

	CCoeControl::SetContainerWindowL(aContainer);

	if (iComponents[0])

		iComponents[0]->SetContainerWindowL(aContainer);

	if (iComponents[1])

		iComponents[1]->SetContainerWindowL(aContainer);

	}

CEikCommandStack* CEikCommandButtonBase::CommandStack() const

	{

	return iCommandStack;

	}

EXPORT_C void CEikCommandButtonBase::ActivateL()

	{

	iContext=this;

	if (iComponents[0])

		iComponents[0]->CopyControlContextFrom(this);

	if (iComponents[1])

		iComponents[1]->CopyControlContextFrom(this);

	LafCommandButtonBase::GetBorder(iBorder, DrawState(), iButFlags,*this,IsDefault());

	UpdateComponentAlignment();

	CCoeControl::ActivateL();

	}

EXPORT_C void CEikCommandButtonBase::UpdateComponentAlignment()

	{

	const TInt layout=iCmdFlags&KLayoutAndFontMask;

	if (layout==EFirstBottomSecondTop || layout==EFirstTopSecondBottom)

		{

		if (iComponents[0])

			iComponents[0]->SetAlignment(EHCenterVCenter);

		if (iComponents[1])

			iComponents[1]->SetAlignment(EHCenterVCenter);

		}

	else

		{

		if (iComponents[0])

			{

			if (iComponents[1])

				{

				iComponents[0]->SetAlignment(layout==EFirstLeftSecondRight? EHLeftVCenter : EHRightVCenter);

				iComponents[1]->SetAlignment(layout==EFirstLeftSecondRight? EHRightVCenter : EHLeftVCenter);

				}

			else

				iComponents[0]->SetAlignment(EHCenterVCenter);

			}

		else

			iComponents[1]->SetAlignment(EHCenterVCenter);

		}

	}

EXPORT_C void CEikCommandButtonBase::SetButtonLayout(TLayout aLayout)

	{

    iCmdFlags &= (~KLayoutAndFontMask);

	iCmdFlags |= aLayout;

	}

EXPORT_C void CEikCommandButtonBase::SetExcessSpace(TExcess aExcess)

	{

	iCmdFlags&=~KExcessMask;

	iCmdFlags|=aExcess;

	}

EXPORT_C void CEikCommandButtonBase::SetDisplayContent(TDisplayContent aContent)

	{

	iCmdFlags &= (~KDisplayContentMask);