// TBTGRP1.CPP
//
// Copyright (c) 1997-1999 Symbian Ltd.  All rights reserved.
//

#include <basched.h>
#include <badesca.h>
#include <coecntrl.h>
#include <coeccntx.h>
#include <eikctgrp.h>
#include <eikenv.h>
#include <eikappui.h>
#include <eikdoc.h>
#include <eikapp.h>
#include <eikcmbut.h>
#include <eikimage.h>
#include <eikchlst.h>
#include <eikdialg.h>
#include <eikdialg.hrh>
#include <eikcmds.hrh>
#include <eikon.rsg>

#include "tbtgrp1.hrh"
#include <tbtgrp1.rsg>

//
// class CLayoutDialog
//

class CLayoutDialog : public CEikDialog
	{
public:
	CLayoutDialog(CEikControlGroup::TOrientation& aOrientation,
				CEikControlGroup::TStartCorner& aStartCorner,TPoint& aPos);
private: // from CEikDialog
	void PreLayoutDynInitL();
	TBool OkToExitL(TInt aButtonId);
private:
	CEikControlGroup::TOrientation& iOrientation;
	CEikControlGroup::TStartCorner& iStartCorner;
	TPoint& iPos;
	};

CLayoutDialog::CLayoutDialog(CEikControlGroup::TOrientation& aOrientation,
					CEikControlGroup::TStartCorner& aStartCorner,TPoint& aPos)
	: iOrientation(aOrientation),
	iStartCorner(aStartCorner),
	iPos(aPos)
	{}

void CLayoutDialog::PreLayoutDynInitL()
	{
	TInt orientationId=EDlgTBtGrp1Vertical;
	if (iOrientation==CEikControlGroup::ELayHorizontally)
		orientationId=EDlgTBtGrp1Horizontal;
	SetHorOptionButListCurrentSet(EDlgTBtGrp1LayoutOpButList,orientationId);
	TInt cornerId=EDlgTBtGrp1TopLeft;
	switch (iStartCorner)
		{
	case CEikControlGroup::EFromTopLeft:
		break;
	case CEikControlGroup::EFromTopRight:
		cornerId=EDlgTBtGrp1TopRight;
		break;
	case CEikControlGroup::EFromBottomLeft:
		cornerId=EDlgTBtGrp1BottomLeft;
		break;
	case CEikControlGroup::EFromBottomRight:
		cornerId=EDlgTBtGrp1BottomRight;
		break;
		}
	SetHorOptionButListCurrentSet(EDlgTBtGrp1StartCornerOpButList,cornerId);
	SetNumberEditorValue(EDlgTBtGrp1XPos,iPos.iX);
	SetNumberEditorValue(EDlgTBtGrp1YPos,iPos.iY);
	}

TBool CLayoutDialog::OkToExitL(TInt /*aButtonId*/)
	{
	TInt orientationId=HorOptionButListCurrentSet(EDlgTBtGrp1LayoutOpButList);
	if (orientationId==EDlgTBtGrp1Vertical)
		iOrientation=CEikControlGroup::ELayVertically;
	else
		iOrientation=CEikControlGroup::ELayHorizontally;
	TInt cornerId=HorOptionButListCurrentSet(EDlgTBtGrp1StartCornerOpButList);
	switch (cornerId)
		{
	case EDlgTBtGrp1TopLeft:
		iStartCorner=CEikControlGroup::EFromTopLeft;
		break;
	case EDlgTBtGrp1TopRight:
		iStartCorner=CEikControlGroup::EFromTopRight;
		break;
	case EDlgTBtGrp1BottomLeft:
		iStartCorner=CEikControlGroup::EFromBottomLeft;
		break;
	case EDlgTBtGrp1BottomRight:
		iStartCorner=CEikControlGroup::EFromBottomRight;
		break;
		}
	iPos.iX=NumberEditorValue(EDlgTBtGrp1XPos);
	iPos.iY=NumberEditorValue(EDlgTBtGrp1YPos);
	return ETrue;
	}

//
// class CSizeDialog
//

class CSizeDialog : public CEikDialog
	{
public:
	CSizeDialog(TSize& aSize,TInt& aLines,TBool& aDistEvenly);
private: // from CEikDialog
	void PreLayoutDynInitL();
	TBool OkToExitL(TInt aButtonId);
	void PrepareForFocusTransitionL();
private:
	TSize& iSize;
	TInt& iLines;
	TBool& iDistEvenly;
	};

CSizeDialog::CSizeDialog(TSize& aSize,TInt& aLines,TBool& aDistEvenly)
	: iSize(aSize), iLines(aLines), iDistEvenly(aDistEvenly)
	{}

void CSizeDialog::PreLayoutDynInitL()
	{
	SetNumberEditorValue(EDlgTBtGrp1Width,iSize.iWidth);
	SetNumberEditorValue(EDlgTBtGrp1Height,iSize.iHeight);
	SetNumberEditorValue(EDlgTBtGrp1Lines,iLines);
	SetCheckBoxState(EDlgTBtGrp1DistEven,(iDistEvenly? CEikButtonBase::ESet : CEikButtonBase::EClear));
	if (iLines==1)
		SetLineDimmedNow(EDlgTBtGrp1DistEven,ETrue);
	}

TBool CSizeDialog::OkToExitL(TInt /*aButtonId*/)
	{
	iSize.iWidth=NumberEditorValue(EDlgTBtGrp1Width);
	iSize.iHeight=NumberEditorValue(EDlgTBtGrp1Height);
	iLines=NumberEditorValue(EDlgTBtGrp1Lines);
	iDistEvenly=(CheckBoxState(EDlgTBtGrp1DistEven)==CEikButtonBase::ESet);
	return ETrue;
	}

void CSizeDialog::PrepareForFocusTransitionL()
	{
	CEikForm::PrepareForFocusTransitionL();
	if (IdOfFocusControl()==EDlgTBtGrp1Lines)
		SetLineDimmedNow(EDlgTBtGrp1DistEven,NumberEditorValue(EDlgTBtGrp1Lines)==1);
	}


//
// class CLengthDialog
//

class CLengthDialog : public CEikDialog
	{
public:
	CLengthDialog(TInt& aLength,TInt& aBreadth,TInt& aLines,TBool& aDistEvenly);
private: // from CEikDialog
	void PreLayoutDynInitL();
	TBool OkToExitL(TInt aButtonId);
	void PrepareForFocusTransitionL();
private:
	TInt& iLength;
	TInt& iBreadth;
	TInt& iLines;
	TBool& iDistEvenly;
	};

CLengthDialog::CLengthDialog(TInt& aLength,TInt& aBreadth,TInt& aLines,TBool& aDistEvenly)
	: iLength(aLength), iBreadth(aBreadth), iLines(aLines), iDistEvenly(aDistEvenly)
	{}

void CLengthDialog::PreLayoutDynInitL()
	{
	SetNumberEditorValue(EDlgTBtGrp1Length,iLength);
	SetNumberEditorValue(EDlgTBtGrp1Breadth,iBreadth);
	SetNumberEditorValue(EDlgTBtGrp1Lines,iLines);
	SetCheckBoxState(EDlgTBtGrp1DistEven,(iDistEvenly? CEikButtonBase::ESet : CEikButtonBase::EClear));
	if (iLines==1)
		SetLineDimmedNow(EDlgTBtGrp1DistEven,ETrue);
	}

TBool CLengthDialog::OkToExitL(TInt /*aButtonId*/)
	{
	iLength=NumberEditorValue(EDlgTBtGrp1Length);
	iBreadth=NumberEditorValue(EDlgTBtGrp1Breadth);
	iLines=NumberEditorValue(EDlgTBtGrp1Lines);
	iDistEvenly=(CheckBoxState(EDlgTBtGrp1DistEven)==CEikButtonBase::ESet);
	return ETrue;
	}

void CLengthDialog::PrepareForFocusTransitionL()
	{
	CEikForm::PrepareForFocusTransitionL();
	if (IdOfFocusControl()==EDlgTBtGrp1Lines)
		SetLineDimmedNow(EDlgTBtGrp1DistEven,NumberEditorValue(EDlgTBtGrp1Lines)==1);
	}


//
// class CControlInfoDialog(hasLength,lengths,stretches,ctrlNums)
//

class CControlInfoDialog : public CEikDialog
	{
public:
	CControlInfoDialog(TBool& aAllSameSize,CArrayFix<TBool>* aHasLength,CArrayFix<TInt>* aLengths,
						CArrayFix<TBool>* aStretches,CDesCArray* aCtrlNums);
private: // from CEikDialog
	void PreLayoutDynInitL();
	void HandleControlStateChangeL(TInt aControlId);
private: // from CEikForm
	void PrepareForFocusTransitionL();
private:
	TBool& iAllSameSize;
	CArrayFix<TBool>* iHasLength;
	CArrayFix<TInt>* iLengths;
	CArrayFix<TBool>* iStretches;
	CDesCArray* iCtrlNums;
	};

CControlInfoDialog::CControlInfoDialog(TBool& aAllSameSize,CArrayFix<TBool>* aHasLength,CArrayFix<TInt>* aLengths,
						CArrayFix<TBool>* aStretches,CDesCArray* aCtrlNums)
	: iAllSameSize(aAllSameSize),
	iHasLength(aHasLength),
	iLengths(aLengths),
	iStretches(aStretches),
	iCtrlNums(aCtrlNums)
	{}

void CControlInfoDialog::PreLayoutDynInitL()
	{
	CEikButtonBase::TState state=(iAllSameSize? CEikButtonBase::ESet : CEikButtonBase::EClear);
	SetCheckBoxState(EDlgTBtGrp1CtrlsSameSize,state);
	CEikChoiceList* chList=(CEikChoiceList*)Control(EDlgTBtGrp1CtrlList);
	chList->SetArrayL(iCtrlNums);
	chList->SetArrayExternalOwnership(ETrue);
	// current item index will always start at 0
	if ((*iHasLength)[0])
		state=CEikButtonBase::ESet;
	else
		state=CEikButtonBase::EClear;
	SetCheckBoxState(EDlgTBtGrp1HasSetLength,state);
	SetNumberEditorValue(EDlgTBtGrp1CtrlLength,(*iLengths)[0]);
	if ((*iStretches)[0])
		state=CEikButtonBase::ESet;
	else
		state=CEikButtonBase::EClear;
	SetCheckBoxState(EDlgTBtGrp1Stretchable,state);
	if (iAllSameSize)
		{
		SetLineDimmedNow(EDlgTBtGrp1CtrlList,ETrue);
		SetLineDimmedNow(EDlgTBtGrp1HasSetLength,ETrue);
		SetLineDimmedNow(EDlgTBtGrp1CtrlLength,ETrue);
		SetLineDimmedNow(EDlgTBtGrp1Stretchable,ETrue);
		}
	}

void CControlInfoDialog::PrepareForFocusTransitionL()
	{
	CEikForm::PrepareForFocusTransitionL();
	if (IdOfFocusControl()==EDlgTBtGrp1CtrlLength)
		{
		const TInt index=ChoiceListCurrentItem(EDlgTBtGrp1CtrlList);
		iLengths->InsertL(index+1,NumberEditorValue(EDlgTBtGrp1CtrlLength));
		iLengths->Delete(index,1);
		}
	}

void CControlInfoDialog::HandleControlStateChangeL(TInt aControlId)
	{
	const TInt index=ChoiceListCurrentItem(EDlgTBtGrp1CtrlList);
	switch (aControlId)
		{
	case EDlgTBtGrp1CtrlsSameSize:
		iAllSameSize=(CheckBoxState(EDlgTBtGrp1CtrlsSameSize)==CEikButtonBase::ESet);
		SetLineDimmedNow(EDlgTBtGrp1CtrlList,iAllSameSize);
		SetLineDimmedNow(EDlgTBtGrp1HasSetLength,iAllSameSize);
		SetLineDimmedNow(EDlgTBtGrp1CtrlLength,iAllSameSize);
		SetLineDimmedNow(EDlgTBtGrp1Stretchable,iAllSameSize);
		break;
	case EDlgTBtGrp1CtrlList:
		{
		CEikButtonBase::TState state=CEikButtonBase::EClear;
		if ((*iHasLength)[index])
			state=CEikButtonBase::ESet;
		SetCheckBoxState(EDlgTBtGrp1HasSetLength,state);
		SetNumberEditorValue(EDlgTBtGrp1CtrlLength,(*iLengths)[index]);
		if ((*iStretches)[index])
			state=CEikButtonBase::ESet;
		else
			state=CEikButtonBase::EClear;
		SetCheckBoxState(EDlgTBtGrp1Stretchable,state);
		break;
		}
	case EDlgTBtGrp1HasSetLength:
		{
		const TBool set=(CheckBoxState(EDlgTBtGrp1HasSetLength)==CEikButtonBase::ESet);
		iHasLength->InsertL(index+1,set);
		iHasLength->Delete(index,1);
		break;
		}
	case EDlgTBtGrp1Stretchable:
		{
		const TBool set=(CheckBoxState(EDlgTBtGrp1Stretchable)==CEikButtonBase::ESet);
		iStretches->InsertL(index+1,set);
		iStretches->Delete(index,1);
		break;
		}
	default:
		;
		}
	}


//
// class CTestContainer
//

const TInt KMaxBitmaps=8;

class CTestControlGroup;

class CTestContainer : public CCoeControl
    {
public:
    void ConstructL();
    ~CTestContainer();
	void RunSpacingDialogL();
	void RunLayoutDialogL();
	void RunSizeDialogL();
	void RunLengthDialogL();
	void RunControlInfoDialogL();
private: // from CCoeControl
    TInt CountComponentControls() const;
    CCoeControl* ComponentControl(TInt aIndex) const;
	void Draw(const TRect& aRect) const;
private: // new functions
    void CreateButtonsL();
	void AddButtonL(const TDesC& aText,CFbsBitmap* aMain,CFbsBitmap* aMask=NULL);
private:
    CTestControlGroup* iButtons;
	CFbsBitmap* iBitmap[KMaxBitmaps];
    };

// CTestControlGroup

class CTestControlGroup : public CEikControlGroup, public MCoeControlBrushContext
	{
friend class CTestContainer;
public:
	CTestControlGroup();
	TInt HSpacing() const;
	TInt VSpacing() const;
	TInt Lines() const;
	TInt Breadth() const;
	TInt Length() const;
	CEikControlGroup::TStartCorner TstStartCorner() const;
	CEikControlGroup::TOrientation TstOrientation() const;
	TBool DistEvenly() const;
	TBool SameSize();
	void SetLength(TInt aLength);
	void SetBreadth(TInt aBreadth);
	void SetLayout(TInt aFlags);
	void ClearLayout(TInt aFlags);
public:
	enum { EAllCtrlsSameSize=0x80 }; // deliberately the same as EAllSameSize in CEikControlGroup
	};

CTestControlGroup::CTestControlGroup()
	{
	iContext=this;
	iBrushStyle=CGraphicsContext::ESolidBrush;
	iBrushColor=KRgbWhite;
	}

TInt CTestControlGroup::HSpacing() const
	{ return iHSpacing; }
TInt CTestControlGroup::VSpacing() const
	{ return iVSpacing; }
TInt CTestControlGroup::Lines() const
	{ return iLines; }
TInt CTestControlGroup::Breadth() const
	{ return iBreadth; }
TInt CTestControlGroup::Length() const
	{ return iLength; }
CEikControlGroup::TStartCorner CTestControlGroup::TstStartCorner() const
	{ return StartCorner(); }
CEikControlGroup::TOrientation CTestControlGroup::TstOrientation() const
	{ return Orientation(); }
TBool CTestControlGroup::DistEvenly() const
	{ return DistributeEvenly(); }
TBool CTestControlGroup::SameSize()
	{ return AllSameSize(); }
void CTestControlGroup::SetLength(TInt aLength)
	{ iLength=aLength; }
void CTestControlGroup::SetBreadth(TInt aBreadth)
	{ iBreadth=aBreadth; }
void CTestControlGroup::SetLayout(TInt aFlags)
	{ iLayout|=aFlags; }
void CTestControlGroup::ClearLayout(TInt aFlags)
	{ iLayout&=~aFlags; }
//

void CTestContainer::ConstructL()
    {
    CreateWindowL();
    Window().SetShadowDisabled(ETrue);
    EnableDragEvents();
    CreateButtonsL();
    SetExtentToWholeScreenL();
    ActivateL();
    }

CTestContainer::~CTestContainer()
    {
    for (TInt ii=0; ii<KMaxBitmaps; ii++)
			delete iBitmap[ii];
    delete(iButtons);
    }

void CTestContainer::CreateButtonsL()
    {
	TPtrC filename=_L("z:\\System\\Test\\tbtgrp1.mbm");
	TInt index=0;
	for (; index<KMaxBitmaps; index++)
		iBitmap[index]=iEikonEnv->CreateBitmapL(filename,index);
	iButtons=new(ELeave) CTestControlGroup;
	iButtons->ConstructL(CEikControlGroup::EFromTopLeft,CEikControlGroup::ELayHorizontally);
	iButtons->SetContainerWindowL(*this);
	AddButtonL(_L("First"),iBitmap[0],iBitmap[1]);
	AddButtonL(_L("Second"),iBitmap[2],iBitmap[3]);
	AddButtonL(_L("Third"),NULL);
	AddButtonL(_L("Fourth"),iBitmap[4],iBitmap[5]);
	AddButtonL(_L("Fifth"),iBitmap[6],iBitmap[7]);
	AddButtonL(_L(""),iBitmap[0],iBitmap[1]);
	AddButtonL(_L("Seventh"),iBitmap[2],iBitmap[3]);
	AddButtonL(_L("Eighth"),NULL);
	AddButtonL(_L("Ninth"),iBitmap[0],iBitmap[1]);
	iButtons->SetLengthInPixels(iEikonEnv->ScreenDevice()->SizeInPixels().iWidth); // initially, since horizontally laid out
	iButtons->SetNumberOfLines(2,EFalse);
	iButtons->SetControlsAllSameSize();
	iButtons->SetExtentL(TPoint(),iButtons->MinimumSize());
    }

void CTestContainer::AddButtonL(const TDesC& aText,CFbsBitmap* aMain,CFbsBitmap* aMask)
	{
	CEikCommandButton* button=new(ELeave) CEikCommandButton;
	CleanupStack::PushL(button);
	button->SetContainerWindowL(*this);
	if (aText.Length())
		button->SetTextL(aText);
	if (aMain)
		{
		button->SetPictureL(aMain,aMask);
		button->Picture()->SetPictureOwnedExternally(ETrue);
		if (aText.Length()==0)
			button->Picture()->iAlignment=EHRightVBottom;
		}
	iButtons->AddControlL(button,0);
	CleanupStack::Pop();
	}

TInt CTestContainer::CountComponentControls() const
    {
    return (iButtons? 1 : 0);
    }

CCoeControl* CTestContainer::ComponentControl(TInt aIndex) const
    {
	if (aIndex==0)
		return iButtons;
	return NULL;
    }

void CTestContainer::Draw(const TRect& aRect) const
	{
	CWindowGc& gc=SystemGc();
	gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
	gc.SetBrushColor(KRgbGray);
	gc.SetPenStyle(CGraphicsContext::ENullPen);
	gc.DrawRect(aRect);
	gc.SetPenStyle(CGraphicsContext::ESolidPen);
	gc.SetBrushStyle(CGraphicsContext::ENullBrush);
	}

void CTestContainer::RunSpacingDialogL()
	{
	CEikDialog* dialog=new(ELeave) CEikDialog;
	dialog->ConstructAutoDialogLC(EEikDialogFlagWait,R_EIK_BUTTONS_CANCEL_OK);
	dialog->SetTitleL(_L("Spacing"));
	TInt hSpacing=iButtons->HSpacing();
	TInt vSpacing=iButtons->VSpacing();
	dialog->AddAutoNumberEditorL(_L("Horizontal"),101,0,20,&hSpacing);
	dialog->AddAutoNumberEditorL(_L("Vertical"),102,0,20,&vSpacing);
	if (dialog->RunLD())
		{
		iButtons->SetControlSpacing(hSpacing,vSpacing);
		iButtons->SetExtentL(iButtons->Position(),iButtons->MinimumSize());
		DrawNow();
		}
	}

void CTestContainer::RunLayoutDialogL()
	{
	CEikControlGroup::TOrientation orientation=iButtons->TstOrientation();
	CEikControlGroup::TStartCorner startCorner=iButtons->TstStartCorner();
	TPoint pos=iButtons->Position();
	CEikDialog* dialog=new(ELeave) CLayoutDialog(orientation,startCorner,pos);
	if (dialog->ExecuteLD(R_TBTGRP1_LAYOUT_DIALOG))
		{
		iButtons->SetControlLayout(startCorner,orientation);
		iButtons->SetPosition(pos);
		iButtons->SetExtentL(pos,iButtons->MinimumSize());
		DrawNow();
		}
	}

void CTestContainer::RunSizeDialogL()
	{
	TSize size=iButtons->Size();
	TInt lines=iButtons->Lines();
	TBool distEvenly=iButtons->DistEvenly();
	CEikDialog* dialog=new(ELeave) CSizeDialog(size,lines,distEvenly);
	if (dialog->ExecuteLD(R_TBTGRP1_SIZE_DIALOG))
		{
		iButtons->SetLength(0);
		iButtons->SetBreadth(0);
		iButtons->SetNumberOfLines(lines,distEvenly);
		iButtons->SetSizeL(size);
		DrawNow();
		}
	}

void CTestContainer::RunLengthDialogL()
	{
	TInt length=iButtons->Length();
	TInt breadth=iButtons->Breadth();
	TInt lines=iButtons->Lines();
	TBool distEvenly=iButtons->DistEvenly();
	CEikDialog* dialog=new(ELeave) CLengthDialog(length,breadth,lines,distEvenly);
	if (dialog->ExecuteLD(R_TBTGRP1_LENGTH_DIALOG))
		{
		iButtons->SetLength(length);
		iButtons->SetBreadth(breadth);
		iButtons->SetNumberOfLines(lines,distEvenly);
		iButtons->SetSizeL(iButtons->MinimumSize());
		DrawNow();
		}
	}

void CTestContainer::RunControlInfoDialogL()
	{
	TBool sameSize=iButtons->SameSize();
	CArrayFix<TBool>* hasLength=new(ELeave) CArrayFixFlat<TBool>(5);
	CleanupStack::PushL(hasLength);
	CArrayFix<TInt>* lengths=new(ELeave) CArrayFixFlat<TInt>(5);
	CleanupStack::PushL(lengths);
	CArrayFixFlat<TBool>* stretches=new(ELeave) CArrayFixFlat<TBool>(5);
	CleanupStack::PushL(stretches);
	CDesCArray* ctrlNums=new(ELeave) CDesCArrayFlat(5);
	CleanupStack::PushL(ctrlNums);
	const TInt count=iButtons->iControlArray->Count();
	for (TInt ii=0;ii<count;ii++)
		{
		TEikGroupControl ctrl=(*(iButtons->iControlArray))[ii];
		hasLength->AppendL(ctrl.IsLengthSet());
		lengths->AppendL(ctrl.Length());
		stretches->AppendL(ctrl.IsStretchable());
		TBuf<2> num;
		num.Num(ii);
		ctrlNums->AppendL(num);
		}
	CEikDialog* dialog=new(ELeave) CControlInfoDialog(sameSize,hasLength,lengths,stretches,ctrlNums);
	if (dialog->ExecuteLD(R_TBTGRP1_CONTROLS_DIALOG))
		{
		if (sameSize)
			iButtons->SetLayout(CTestControlGroup::EAllCtrlsSameSize);
		else
			{
			iButtons->ClearLayout(CTestControlGroup::EAllCtrlsSameSize);
			for (TInt ii=0;ii<count;ii++)
				{
				TEikGroupControl ctrl=(*(iButtons->iControlArray))[ii];
				TEikGroupControl newCtrl;
				newCtrl.iControl=ctrl.iControl;
				if ((*hasLength)[ii])
					newCtrl.SetLength((*lengths)[ii]);
				if ((*stretches)[ii])
					newCtrl.SetStretchable();
				iButtons->iControlArray->Delete(ii);
				iButtons->iControlArray->InsertL(ii,newCtrl);
				}
			}
		iButtons->LayoutControlsL();
		DrawNow();
		}
	CleanupStack::PopAndDestroy(4);
	}


//
// CButAppUi
//

class CButAppUi : public CEikAppUi
    {
public:
    ~CButAppUi();
    void ConstructL();
private: // framework
    void HandleCommandL(TInt aCommand);
private:
    CTestContainer* iContainer;
    };

CButAppUi::~CButAppUi()
    {
    delete(iContainer);
    }
    
void CButAppUi::ConstructL()
    {
    BaseConstructL();
    iContainer=new(ELeave) CTestContainer;
    iContainer->ConstructL();
    }

void CButAppUi::HandleCommandL(TInt aCommand)
	{
	switch (aCommand)
		{
	case EEikCmdExit :
		CBaActiveScheduler::Exit();
	case EAppCmdSpacingDlg:
		iContainer->RunSpacingDialogL();
		break;
	case EAppCmdLayoutDlg:
		iContainer->RunLayoutDialogL();
		break;
	case EAppCmdSizeDlg:
		iContainer->RunSizeDialogL();
		break;
	case EAppCmdLengthDlg:
		iContainer->RunLengthDialogL();
		break;
	case EAppCmdCtrlInfoDlg:
		iContainer->RunControlInfoDialogL();
		break;
		}
	}

//
// CButDocument
//

class CButDocument : public CEikDocument
	{
public:
	CButDocument(CEikApplication& aApp): CEikDocument(aApp) { }
private: // from CApaDocument
	CEikAppUi* CreateAppUiL();
	};

CEikAppUi* CButDocument::CreateAppUiL()
	{
    return(new(ELeave) CButAppUi);
	}

//
// CButApplication
//

class CButApplication : public CEikApplication
	{
private: // from CApaApplication
	CApaDocument* CreateDocumentL();
	TUid AppDllUid() const;
	};

const TUid KUidButApp={211};

TUid CButApplication::AppDllUid() const
	{
	return(KUidButApp);
	}

CApaDocument* CButApplication::CreateDocumentL()
	{
	return(new(ELeave) CButDocument(*this));
	}

//
// EXPORTed functions
//

EXPORT_C CApaApplication* NewApplication()
	{
	return(new CButApplication);
	}

GLDEF_C TInt E32Dll(TDllReason)
	{
	return(KErrNone);
	}