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

#include <basched.h>
#include <eikenv.h>
#include <eikdialg.h>
#include <eikbtpan.h>
#include <eiklbbut.h>
#include <eikcmbut.h>
#include <eikappui.h>
#include <eikapp.h>
#include <eikdoc.h>
#include <eikchlst.h>
#include <eikchred.h>
#include <eikseced.h>
#include <eikcfdlg.h>
#include <eikprogi.h>
#include <eikfpne.h>
#include <eikhopbt.h>
#include <eikchkbx.h>
#include <eikrted.h>
#include <eikgted.h>
#include <eikdlgtb.h>
#include <txtrich.h>
#include <txtglobl.h>
#include <eikdialg.hrh>
#include <eikcmds.hrh>
#include <eikedwin.hrh>
#include <eikon.rsg>
#include <eikclb.h>
#include <eikclbd.h>
#include <eiktxtut.h>
#include <badesca.h>
#include <eiktxlbx.h>
#include <eikfctry.h>

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

//
// Models
//

struct SListModel
    {
    TInt iFruit;
    TInt iVegetables;
    TInt iFlowers;
    TChar iChar;
	TBool iDimVeg;
	TBool iHideFlowers;
	TBool iRemoveFruit;
	TBool iRemoveVeg;
	TBool iRemoveFlowers;
	TBool iAddChar;
	TInt iSecedChoice;
    };

//
// class CEmptyControl
//

class CEmptyControl : public CCoeControl
    {
public:
    void ConstructL(const TRect& aRect);
    };

void CEmptyControl::ConstructL(const TRect& aRect)
    {
    CreateWindowL();
	SetRectL(aRect);
	SetBlank();
	ActivateL();
    }

//
// class CChlstDlg
//

class CChlstDlg : public CEikDialog
    {
public:
    CChlstDlg(SListModel* aModel);
private: // framework
    void PreLayoutDynInitL();
    TBool OkToExitL(TInt aKeycode);
	void HandleControlStateChangeL(TInt aControlId);
	void CheckVegDisplay();
	void CheckFlowersDisplay();
private:
    SListModel* iModel;
    };

CChlstDlg::CChlstDlg(SListModel* aModel)
    {
    iModel=aModel;
    }

void CChlstDlg::PreLayoutDynInitL()
    {
	if (iModel->iAddChar)
		{ // do this bit first, else the 3 below would have to alter dynamically
		InsertLineL(3,R_TDLG_LINE_CHARACTER);
    	SetCharEditor(EDlgChlstChar,iModel->iChar);
		}
	if (iModel->iRemoveFruit)
		DeleteLine(EDlgChlstFruit);
	else
	    SetChoiceListCurrentItem(EDlgChlstFruit,iModel->iFruit);
	if (iModel->iRemoveVeg)
		DeleteLine(EDlgChlstVegetables);
	else
    	SetChoiceListCurrentItem(EDlgChlstVegetables,iModel->iVegetables);
	if (iModel->iRemoveFlowers)
		DeleteLine(EDlgChlstFlowers);
	else
	    SetChoiceListCurrentItem(EDlgChlstFlowers,iModel->iFlowers);
	SetCheckBoxState(EDlgChlstDim,iModel->iDimVeg? CEikButtonBase::ESet: CEikButtonBase::EClear);
	SetCheckBoxState(EDlgChlstHide,iModel->iHideFlowers? CEikButtonBase::ESet: CEikButtonBase::EClear);
	CheckVegDisplay();
	CheckFlowersDisplay();
	if (!iModel->iRemoveFruit)
		SetLineDimmedNow(EDlgChlstFruit,ETrue);
    }

void CChlstDlg::CheckVegDisplay()
	{
	if (!iModel->iRemoveVeg)
		SetLineDimmedNow(EDlgChlstVegetables,CheckBoxState(EDlgChlstDim));
	}

void CChlstDlg::CheckFlowersDisplay()
	{
	if (!iModel->iRemoveFlowers)
		MakeLineVisible(EDlgChlstFlowers,!CheckBoxState(EDlgChlstHide));
	}

void CChlstDlg::HandleControlStateChangeL(TInt aControlId)
	{
	switch (aControlId)
		{
	case EDlgChlstDim:
		CheckVegDisplay();
		break;
	case EDlgChlstHide:
		CheckFlowersDisplay();
		break;
	default:
		break;
		}
	}

TBool CChlstDlg::OkToExitL(TInt /*aKeycode*/)
    {
	if (!iModel->iRemoveFruit)
		iModel->iFruit=ChoiceListCurrentItem(EDlgChlstFruit);
	if (!iModel->iRemoveVeg)
    	iModel->iVegetables=ChoiceListCurrentItem(EDlgChlstVegetables);
	if (!iModel->iRemoveFlowers)
	    iModel->iFlowers=ChoiceListCurrentItem(EDlgChlstFlowers);
	if (iModel->iAddChar)
	    iModel->iChar=CharEditor(EDlgChlstChar);
	iModel->iDimVeg=CheckBoxState(EDlgChlstDim);
	iModel->iHideFlowers=CheckBoxState(EDlgChlstHide);
    return(ETrue);
    }

//
// Class CTestTimer
//

class CTestTimer : public CTimer
	{
public:
	CTestTimer();
	void ConstructL(CEikDialog* aDialog,CEikProgressInfo* aProgInfo1,CEikProgressInfo* aProgInfo2);
	void RunL();
protected:
    CEikDialog* iDialog;
	CEikProgressInfo* iProgInfo1;
	CEikProgressInfo* iProgInfo2;
	TInt iCount1;
	TInt iCount2;
	};

CTestTimer::CTestTimer() : CTimer(EActivePriorityClockTimer)
	{
	}

void CTestTimer::ConstructL(CEikDialog* aDialog,CEikProgressInfo* aProgInfo1,CEikProgressInfo* aProgInfo2)
	{
    CTimer::ConstructL();
	CActiveScheduler::Add(this);
    iDialog=aDialog;
	iProgInfo1=aProgInfo1;
	iProgInfo2=aProgInfo2;
	}

void CTestTimer::RunL()
	{	
	if (++iCount1>10)
		{
		if (!iProgInfo2)
			{
			delete(iDialog);
			return;
			}
		iProgInfo2->IncrementAndDraw(1);
		++iCount2;
		if (iCount2==10)
			iProgInfo2=NULL;
		else
			iCount1=0;
		}
	if (iCount1)
		iProgInfo1->IncrementAndDraw(1);
	else
		iProgInfo1->SetAndDraw(0);
	After(iProgInfo2? 200000: 500000);
	}

//
// class CProgressDialog
//

class CProgressDialog : public CEikDialog
	{
public:
	CProgressDialog(CEikDialog** aSelfPtr);
    ~CProgressDialog();
private: // from CEikDialog
    void PreLayoutDynInitL();
	void SetSizeAndPositionL(const TSize& aSize);
private:
	CTestTimer* iTimer;
	CEikDialog** iSelfPtr;
    };

CProgressDialog::CProgressDialog(CEikDialog** aSelfPtr)
	{
	iSelfPtr=aSelfPtr;
	iEikonEnv->SetBusy(ETrue);
	}
	
CProgressDialog::~CProgressDialog()
	{
	iEikonEnv->SetBusy(EFalse);
	delete(iTimer);
	*iSelfPtr=NULL;
	}

void CProgressDialog::SetSizeAndPositionL(const TSize& aSize)
	{
    SetCornerAndSizeL(EHLeftVBottom,aSize);
	}

void CProgressDialog::PreLayoutDynInitL()
    {
	CEikProgressInfo* progInfo1 = (CEikProgressInfo*) Control(EDlgProgressBar1);
	CEikProgressInfo* progInfo2 = (CEikProgressInfo*) Control(EDlgProgressBar2);
	iTimer=new(ELeave) CTestTimer();
	iTimer->ConstructL(this,progInfo1,progInfo2);
	iTimer->After(500000);
    }

//
// class CSecedDlg
//

class CSecedDlg : public CEikDialog
    {
public:
	CSecedDlg(TInt* aChoice);
private: // framework
    TBool OkToExitL(TInt aKeycode);
	void PreLayoutDynInitL();
	void HandleControlStateChangeL(TInt aControlId);
private: // internal
	void SwitchIn(TInt aNewChoice);
private:
	TInt* ipChoice;
	TInt iChoice;
    };

CSecedDlg::CSecedDlg(TInt* aChoice)
	{
	ipChoice=aChoice;
	}
	
void CSecedDlg::PreLayoutDynInitL()
	{
	SwitchIn(*ipChoice);
	SetChoiceListCurrentItem(EDlgSecedSwitch,iChoice);
	}

void CSecedDlg::SwitchIn(TInt aNewChoice)
	{
	if (aNewChoice==iChoice)
		return;
	SwitchLineLatency(iChoice+EDlgSecedNumed,aNewChoice+EDlgSecedNumed);
	iChoice=aNewChoice;
	}

void CSecedDlg::HandleControlStateChangeL(TInt aControlId)
	{
	if (aControlId!=EDlgSecedSwitch)
		return;
	SwitchIn(ChoiceListCurrentItem(EDlgSecedSwitch));
	}

TBool CSecedDlg::OkToExitL(TInt /*aKeycode*/)
    {
    TBuf<20> password;
    TBuf<20> copy;
    GetSecretEditorText(password,EDlgSecedPassword);
    GetSecretEditorText(copy,EDlgSecedCopy);
    if (password==copy)
        {
		*ipChoice=iChoice;
		return(ETrue);
		}
    iEikonEnv->InfoMsg(_L("Passwords don't match - try again"));
    ResetSecretEditor(EDlgSecedPassword);
    ResetSecretEditor(EDlgSecedCopy);
	TryChangeFocusToL(EDlgSecedPassword);
    return(EFalse);
    }

//
// class CFpneDialog
//

class CFpneDialog : public CEikDialog
	{
private: // framework
	void PreLayoutDynInitL();
    void HandleControlStateChangeL(TInt aControlId);
	};

void CFpneDialog::PreLayoutDynInitL()
	{
	SetLineDimmedNow(EDlgFpnesFlPtEd,ETrue);
	TInt init2=0;
	((CEikFixedPointEditor*)Control(EDlgFpnesFxPtEd))->SetValueL(&init2);
	((CEikTwipsEditor*)Control(EDlgFpnesTwipsEd))->SetValueL(&init2);
	((CEikHorOptionButtonList*)Control(EDlgFpnesOpButList))->SetButtonById(EDlgFpnesDimFl);
	}

void CFpneDialog::HandleControlStateChangeL(TInt aControlId)
	{
	if (aControlId==EDlgFpnesHideAll)
		{
		TBool visible=(CheckBoxState(aControlId)==CEikButtonBase::EClear);
		MakeLineVisible(EDlgFpnesFlPtEd,visible);
		MakeLineVisible(EDlgFpnesFxPtEd,visible);
		MakeLineVisible(EDlgFpnesTwipsEd,visible);
		}
	else if (aControlId==EDlgFpnesOpButList)
		{
		TInt id=((CEikHorOptionButtonList*)Control(aControlId))->LabeledButtonId();
		SetLineDimmedNow(EDlgFpnesFlPtEd,id==EDlgFpnesDimFl);
		SetLineDimmedNow(EDlgFpnesFxPtEd,id==EDlgFpnesDimFx);
		SetLineDimmedNow(EDlgFpnesTwipsEd,id==EDlgFpnesDimTwips);
		}
	}

//
// class CRTEdDialog
//

class CRTEdDialog : public CEikDialog
	{
public:
	CRTEdDialog(CRichText*& aRichText,CParaFormatLayer*& aRichParaFormatLayer,CCharFormatLayer*& aRichCharFormatLayer);
private: // framework
	void PreLayoutDynInitL();
    TBool OkToExitL(TInt aKeycode);
	void HandleControlStateChangeL(TInt aControlId);
private:
	CRichText*& iRichText;
	CParaFormatLayer*& iRichParaFormatLayer;
	CCharFormatLayer*& iRichCharFormatLayer;
	};


CRTEdDialog::CRTEdDialog(CRichText*& aRichText,CParaFormatLayer*& aRichParaFormatLayer,
						 CCharFormatLayer*& aRichCharFormatLayer)
	: iRichText(aRichText),iRichParaFormatLayer(aRichParaFormatLayer),iRichCharFormatLayer(aRichCharFormatLayer)
	{}
	
void CRTEdDialog::HandleControlStateChangeL(TInt aControlId)
	{
	if (aControlId==EDlgGTxtTBar)
		{
		const TInt ctrlId=STATIC_CAST(CEikDialogToolBar*,Control(aControlId))->StateChangeControlId();
		CEikGlobalTextEditor::TFontStyleFlags fontFlag=CEikGlobalTextEditor::EStandard;
		switch (ctrlId)
			{
		case EEikCidFontBoldBut:
			fontFlag=CEikGlobalTextEditor::EBold;
			break;
		case EEikCidFontItalicBut:
			fontFlag=CEikGlobalTextEditor::EItalic;
			break;
		case EEikCidFontUnderlineBut:
			fontFlag=CEikGlobalTextEditor::EUnderline;
			break;
			}
		STATIC_CAST(CEikGlobalTextEditor*,Control(EDlgGTEdEditor))->BoldItalicUnderlineEventL(fontFlag);
		}
	}

void CRTEdDialog::PreLayoutDynInitL()
	{
	CEikRichTextEditor* ed=(CEikRichTextEditor*)Control(EDlgRTEdEditor);
	ed->SetDocumentContentL(*iRichText);
	ed->SetButtonGroup(STATIC_CAST(CEikDialogToolBar*,Control(EDlgRTxtTBar)));
	}

TBool CRTEdDialog::OkToExitL(TInt /*aKeycode*/)
    {
	delete iRichText;
	delete iRichParaFormatLayer;
	delete iRichCharFormatLayer;
	CEikRichTextEditor* edwin=STATIC_CAST(CEikRichTextEditor*,Control(EDlgRTEdEditor));
	edwin->SetDocumentOwnership(CEikEdwin::EDoesNotOwnText);
	iRichText=edwin->RichText();
	iRichText->SetPictureFactory(iRichText->PictureFactory(),NULL);
	iRichParaFormatLayer=((CParaFormatLayer*)iRichText->GlobalParaFormatLayer());
	iRichCharFormatLayer=((CCharFormatLayer*)iRichText->GlobalCharFormatLayer());
    return(ETrue);
    }


//
// class CJezarDialog
//

class CJezarDialog : public CEikDialog
	{
protected:
	void PreLayoutDynInitL();
	};

void CJezarDialog::PreLayoutDynInitL()
	{
	SetLineDimmedNow(EDlgChlstFruit,ETrue);
	SetLineDimmedNow(EDlgChlstVegetables,ETrue);
	ButtonPanel()->LabeledButtonById(EEikBidCancel)->MakeVisible(EFalse);
	TBool visible = ButtonPanel()->ButtonById(EEikBidCancel)->IsVisible();
	}


//
// class CFocusJumpingDialog
//

class CFocusJumpingDialog : public CEikDialog
	{
public:
	CFocusJumpingDialog(TInt* aFocusItem);
private: // framework
	void PreLayoutDynInitL();
	TBool OkToExitL(TInt aButtonId);
	void SetInitialCurrentLine();
	void PageChangedL(TInt aControlId);
private:
	TInt* iFocusItem;
	TBool iJumpButtonVisible;
	};

CFocusJumpingDialog::CFocusJumpingDialog(TInt* aFocusItem)
	{
	iFocusItem=aFocusItem;
	}

void CFocusJumpingDialog::PreLayoutDynInitL()
	{
	STATIC_CAST(CEikChoiceList*,Control(EDlgFocusItem2))->SetFontL(iEikonEnv->AnnotationFont());
	STATIC_CAST(CEikChoiceList*,Control(EDlgFocusItem3))->SetFontL(iEikonEnv->AnnotationFont());
	MakePanelButtonVisible(EEikBidSpace,EFalse);
	// SetLineDimmedNow(ESillyDateEditor,ETrue);
	MakeLineVisible(ESillyDateEditor, EFalse);
	}

void CFocusJumpingDialog::SetInitialCurrentLine()
	{
	TryChangeFocusToL(1+(*iFocusItem));
	}

TBool CFocusJumpingDialog::OkToExitL(TInt aControlId)
	{
	TInt focusItemId=IdOfFocusControl();
	if (aControlId==EEikBidOk)
		{
		*iFocusItem=focusItemId-1;
		return(ETrue);
		}
	if (focusItemId > 0)
		{
		TInt nextFocusItemId=ChoiceListCurrentItem(focusItemId);
		TryChangeFocusToL(1+nextFocusItemId);
		}
	return(EFalse);
	}

void CFocusJumpingDialog::PageChangedL(TInt aControlId)
	{
	TBool visible=ETrue;
	if (aControlId==EDlgFocusPage1)
		visible=EFalse;
	if (visible!=iJumpButtonVisible)
		{
		MakePanelButtonVisible(EEikBidSpace,visible);
		iJumpButtonVisible=visible;
		}
	}

//
// class CGraySelectorDlg
//

class CGraySelectorDlg : public CEikDialog
    {
public:
    CGraySelectorDlg(TRgb* aColor);
private: // framework
    void PreLayoutDynInitL();
    TBool OkToExitL(TInt aKeycode);
private:
    TRgb* iColor;
    };

CGraySelectorDlg::CGraySelectorDlg(TRgb* aColor)
    {
    iColor=aColor;
    }

void CGraySelectorDlg::PreLayoutDynInitL()
    {
    SetGraySelectorColor(EDlgGray4Selector,*iColor);
    SetGraySelectorColor(EDlgGray16Selector,*(iColor+1));
    }

TBool CGraySelectorDlg::OkToExitL(TInt /*aKeycode*/)
    {
    *iColor=GraySelectorColor(EDlgGray4Selector);
    *(iColor+1)=GraySelectorColor(EDlgGray16Selector);
    return(ETrue);
    }

//
// class CRTEdDialog
//

class CGTEdDialog : public CEikDialog
	{
public:
	CGTEdDialog(CGlobalText*& aGlobalText,CParaFormatLayer*& aGlobalParaFormatLayer,
					CCharFormatLayer*& aGlobalCharFormatLayer);
private: // framework
	void PreLayoutDynInitL();
    TBool OkToExitL(TInt aKeycode);
	void HandleControlStateChangeL(TInt aControlId);
private:
	CGlobalText*& iGlobalText;
	CParaFormatLayer*& iGlobalParaFormatLayer;
	CCharFormatLayer*& iGlobalCharFormatLayer;
	};


CGTEdDialog::CGTEdDialog(CGlobalText*& aGlobalText,CParaFormatLayer*& aGlobalParaFormatLayer,
						 CCharFormatLayer*& aGlobalCharFormatLayer)
	: iGlobalText(aGlobalText),
	iGlobalParaFormatLayer(aGlobalParaFormatLayer),
	iGlobalCharFormatLayer(aGlobalCharFormatLayer)
	{}
	
void CGTEdDialog::HandleControlStateChangeL(TInt aControlId)
	{
	if (aControlId==EDlgGTxtTBar)
		{
		const TInt ctrlId=STATIC_CAST(CEikDialogToolBar*,Control(aControlId))->StateChangeControlId();
		CEikGlobalTextEditor::TFontStyleFlags fontFlag=CEikGlobalTextEditor::EStandard;
		switch (ctrlId)
			{
		case EEikCidFontBoldBut:
			fontFlag=CEikGlobalTextEditor::EBold;
			break;
		case EEikCidFontItalicBut:
			fontFlag=CEikGlobalTextEditor::EItalic;
			break;
		case EEikCidFontUnderlineBut:
			fontFlag=CEikGlobalTextEditor::EUnderline;
			break;
			}
		STATIC_CAST(CEikGlobalTextEditor*,Control(EDlgGTEdEditor))->BoldItalicUnderlineEventL(fontFlag);
		}
	}

void CGTEdDialog::PreLayoutDynInitL()
	{
	CEikGlobalTextEditor* ed=(CEikGlobalTextEditor*)Control(EDlgGTEdEditor);
	ed->SetDocumentContentL(*iGlobalText);
	ed->SetButtonGroup(STATIC_CAST(CEikDialogToolBar*,Control(EDlgGTxtTBar)));
	}

TBool CGTEdDialog::OkToExitL(TInt /*aKeycode*/)
    {
	delete iGlobalText;
	delete iGlobalParaFormatLayer;
	delete iGlobalCharFormatLayer;
	CEikGlobalTextEditor* edwin=STATIC_CAST(CEikGlobalTextEditor*,Control(EDlgGTEdEditor));
	edwin->SetDocumentOwnership(CEikEdwin::EDoesNotOwnText);
	iGlobalText=edwin->GlobalText();
	iGlobalParaFormatLayer=((CParaFormatLayer*)iGlobalText->GlobalParaFormatLayer());
	iGlobalCharFormatLayer=((CCharFormatLayer*)iGlobalText->GlobalCharFormatLayer());
    return(ETrue);
	}

//
// class CColumnListBoxDialog
//
	
class CColumnListBoxDialog : public CEikDialog
	{
private:
	void PreLayoutDynInitL();
	void DoCalcColumnWidths();
	CEikColumnListBox* ListBox() const;
	};

const TInt KColLbxCount=4;

void CColumnListBoxDialog::PreLayoutDynInitL()
	{
	DoCalcColumnWidths();
	}

CEikColumnListBox* CColumnListBoxDialog::ListBox() const
	{
	return((CEikColumnListBox*)Control(EDlgColLbx));
	}

void CColumnListBoxDialog::DoCalcColumnWidths()
	{
	CColumnListBoxModel* model=ListBox()->Model();
	CColumnListBoxData* columnData=model->ColumnData();

	MDesCArray* listArray=model->ItemTextArray();
	TInt count=listArray->MdcaCount();
	
	columnData->SetColumnFontL(0,iEikonEnv->NormalFont());
	columnData->SetColumnFontL(1,iEikonEnv->LegendFont());
	columnData->SetColumnFontL(2,iEikonEnv->AnnotationFont());
	columnData->SetColumnFontL(3,iEikonEnv->AnnotationFont());
	
	const CFont* font=columnData->ColumnFont(0);
	TPtrC text;
	TInt width;
	for (TInt column=0;column<KColLbxCount;column++)
		{
		width=0;
		const CFont* colFont=columnData->ColumnFont(column);
		if(colFont)
			font=colFont;
		for (TInt index=0;index<count;index++)
			{
			TPtrC row(listArray->MdcaPoint(index));
			TextUtils::ColumnText(text,column,&row);
			width=Max(width,font->TextWidthInPixels(text)+5);
			}
		columnData->SetColumnWidthPixelL(column,width);
		}

	columnData->SetColumnAlignmentL(1,CGraphicsContext::ERight);
	columnData->SetColumnAlignmentL(2,CGraphicsContext::ECenter);
	}

//
// class CSimpleAppUi
//

class CSimpleAppUi : public CEikAppUi
    {
public:
    void ConstructL();
    ~CSimpleAppUi();
private: // framework
    void HandleCommandL(TInt aCommand);
	void HandleKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType);
private: // menu commands
    void CmdDlgChlstL();
    void CmdDlgSecedL();
    void CmdFileOpenDlgL();
    void CmdFileSaveDlgL();
	void CmdProgressDlgL();
	void CmdFpnesDlgL();
	void CmdRTEdDlgL();
	void CmdGraySelDlgL();
	void CmdGTEdDlgL();
	void CmdAutoDialogL();
	void CmdFocusDialogL();
	void CmdJezarDialogL();
	void CmdColumnLbxL();
private:
    CEmptyControl* iEmptyControl;
    SListModel iLists;
	CRichText* iRichText;
	CParaFormatLayer* iRichParaFormatLayer;
	CCharFormatLayer* iRichCharFormatLayer;
	CGlobalText* iGlobalText;
	CParaFormatLayer* iGlobalParaFormatLayer;
	CCharFormatLayer* iGlobalCharFormatLayer;
	TRgb iColor[2];
	TInt iAutoNumber;
	TReal iAutoReal;
	TBuf<10> iAutoText;
	TInt iFocusDialogFocusItem;
	CEikDialog* iProgressDialog;
    };

void CSimpleAppUi::ConstructL()
    {
    BaseConstructL();
    iEmptyControl=new(ELeave) CEmptyControl;
    iEmptyControl->ConstructL(ClientRect());
    iRichParaFormatLayer=CEikonEnv::NewDefaultParaFormatLayerL();
    iRichCharFormatLayer=CEikonEnv::NewDefaultCharFormatLayerL();
	iRichText=CRichText::NewL(iRichParaFormatLayer,iRichCharFormatLayer);
    iGlobalParaFormatLayer=CEikonEnv::NewDefaultParaFormatLayerL();
    iGlobalCharFormatLayer=CEikonEnv::NewDefaultCharFormatLayerL();
	iGlobalText=CGlobalText::NewL(iGlobalParaFormatLayer,iGlobalCharFormatLayer);
	iColor[0]=KRgbBlack;
	iColor[1]=KRgbBlack;
	iLists.iChar='c';
    }

CSimpleAppUi::~CSimpleAppUi()
    {
    delete(iEmptyControl);
	delete(iRichText);
	delete(iGlobalText);
	delete(iRichParaFormatLayer);
	delete(iRichCharFormatLayer);
	delete(iGlobalParaFormatLayer);
	delete(iGlobalCharFormatLayer);
	delete(iProgressDialog);
    }

void CSimpleAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
	{
	if (iProgressDialog)
		iProgressDialog->OfferKeyEventL(aKeyEvent,aType);
	}

void CSimpleAppUi::HandleCommandL(TInt aCommand)
    {
    switch (aCommand)
        {
    case EEikCmdExit:
        CBaActiveScheduler::Exit();
        break;
    case EAppCmdDlgChlst:
        CmdDlgChlstL();
        break;
    case EAppCmdDlgSeced:
        CmdDlgSecedL();
        break;
    case EAppCmdFileOpenDlg:
        CmdFileOpenDlgL();
        break;
    case EAppCmdFileSaveDlg:
        CmdFileSaveDlgL();
        break;
	case EAppCmdBusyForever:
		iEikonEnv->InfoMsg(_L("Going busy forever"));
		FOREVER
			;
		break;
	case EAppCmdProgress:
		CmdProgressDlgL();
		break;
	case EAppCmdFpnes:
		CmdFpnesDlgL();				
		break; 
	case EAppCmdRTEd:
		CmdRTEdDlgL();
		break;
	case EAppCmdGraySel:
		CmdGraySelDlgL();
		break;
	case EAppCmdGTEd:
		CmdGTEdDlgL();
		break;
	case EAppCmdAutoDialog:
		CmdAutoDialogL();
		break;
	case EAppCmdFocusDialog:
		CmdFocusDialogL();
		break;
	case EAppCmdJezarDialog:
		CmdJezarDialogL();
		break;
	case EAppCmdColumnLbx:
		CmdColumnLbxL();
		break;
        }
    }

void CSimpleAppUi::CmdColumnLbxL()
	{
	CEikDialog* dialog=new(ELeave) CColumnListBoxDialog;
	dialog->ExecuteLD(R_TDLG_COLUMN_DIALOG);
	}

void CSimpleAppUi::CmdFocusDialogL()
	{
	CEikDialog* dialog=new(ELeave) CFocusJumpingDialog(&iFocusDialogFocusItem);
	dialog->ExecuteLD(R_TDLG_DIALOG_FOCUS);
	}

void CSimpleAppUi::CmdJezarDialogL()
	{
	CEikDialog* dialog=new(ELeave) CJezarDialog();
	dialog->ExecuteLD(R_TDLG_DIALOG_JEZAR);
	}

void CSimpleAppUi::CmdAutoDialogL()
	{
	CEikDialog* dialog=new(ELeave) CEikDialog;
	dialog->ConstructAutoDialogLC(EEikDialogFlagWait,R_EIK_BUTTONS_CANCEL_OK);
	dialog->SetTitleL(_L("Auto dialog"));
	dialog->AddAutoNumberEditorL(_L("Number editor"),101,0,300,&iAutoNumber);
	dialog->AddAutoFloatEditorL(_L("Float editor"),102,TReal(0),TReal(300),&iAutoReal);
	dialog->AddAutoTextEditorL(_L("Text editor"),103,0,8,1,&iAutoText);
	dialog->RunLD();
	}

void CSimpleAppUi::CmdDlgChlstL()
    {
	CEikDialog* preDialog=new(ELeave) CEikDialog;
	preDialog->PrepareLC(R_TDLG_DIALOG_PRE_CHLST);
	preDialog->DeclareAutoCheckBox(EPreChlstRemoveFruit,(CEikButtonBase::TState*)&iLists.iRemoveFruit);
	preDialog->DeclareAutoCheckBox(EPreChlstRemoveVeg,(CEikButtonBase::TState*)&iLists.iRemoveVeg);
	preDialog->DeclareAutoCheckBox(EPreChlstRemoveFlowers,(CEikButtonBase::TState*)&iLists.iRemoveFlowers);
	preDialog->DeclareAutoCheckBox(EPreChlstAddChar,(CEikButtonBase::TState*)&iLists.iAddChar);
	if (!preDialog->RunLD())
		return;
    CEikDialog* dialog=new(ELeave) CChlstDlg(&iLists);
    dialog->ExecuteLD(R_TDLG_DIALOG_CHLST);
    }

void CSimpleAppUi::CmdDlgSecedL()
    {
    CEikDialog* dialog=new(ELeave) CSecedDlg(&iLists.iSecedChoice);
    dialog->ExecuteLD(R_TDLG_DIALOG_SECED);
    }

void CSimpleAppUi::CmdFileOpenDlgL()
    {
	TFileName fileName(_L("c:\\System\\foo"));
    CEikFileOpenDialog* dialog = new(ELeave) CEikFileOpenDialog(&fileName);
    if (dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN))
        iEikonEnv->InfoMsg(R_TDLG_TBUF_FILE_CHOSEN,&fileName);

	fileName = _L("c:\\Documents\\Work\\Psion\\Eikon Work");
    dialog = new(ELeave) CEikFileOpenDialog(&fileName);
    if (dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN))
        iEikonEnv->InfoMsg(R_TDLG_TBUF_FILE_CHOSEN,&fileName);

	fileName = _L("c:\\Documents\\Work\\Hp\\Explorer Work");
    dialog = new(ELeave) CEikFileOpenDialog(&fileName);
    if (dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN))
        iEikonEnv->InfoMsg(R_TDLG_TBUF_FILE_CHOSEN,&fileName);

	fileName = _L("c:\\Documents\\Work\\Casio\\Secret Work");
    dialog = new(ELeave) CEikFileOpenDialog(&fileName);
    if (dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN))
        iEikonEnv->InfoMsg(R_TDLG_TBUF_FILE_CHOSEN,&fileName);

	fileName = _L("c:\\Documents\\Work\\Microsoft\\*");
    dialog = new(ELeave) CEikFileOpenDialog(&fileName);
    if (dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN))
        iEikonEnv->InfoMsg(R_TDLG_TBUF_FILE_CHOSEN,&fileName);
    }

void CSimpleAppUi::CmdFileSaveDlgL()
    {
	TFileName fileName(_L("c:\\foo"));
    CEikDialog* dialog=new(ELeave) CEikFileSaveAsDialog(&fileName);
    if (dialog->ExecuteLD(R_EIK_DIALOG_FILE_SAVEAS))
        iEikonEnv->InfoMsg(R_TDLG_TBUF_FILE_CHOSEN,&fileName);
    }

void CSimpleAppUi::CmdProgressDlgL()
	{
	if (iProgressDialog)
		delete(iProgressDialog);
	else
		{
		iProgressDialog=new(ELeave) CProgressDialog(&iProgressDialog);
		iProgressDialog->ExecuteLD(R_TDLG_PROGRESS);
		}
	}

void CSimpleAppUi::CmdFpnesDlgL()
	{
	CEikDialog* dialog=new(ELeave) CFpneDialog;
	dialog->ExecuteLD(R_TDLG_FPNES);
	}

void CSimpleAppUi::CmdRTEdDlgL()
	{
	CEikDialog* dialog=new(ELeave) CRTEdDialog(iRichText,iRichParaFormatLayer,iRichCharFormatLayer);
	dialog->ExecuteLD(R_TDLG_RTXTED);
	}

void CSimpleAppUi::CmdGraySelDlgL()
	{
	CEikDialog* dialog=new(ELeave) CGraySelectorDlg(iColor);
	dialog->ExecuteLD(R_TDLG_GRAY_SELECTORS);
	}

void CSimpleAppUi::CmdGTEdDlgL()
	{
	CEikDialog* dialog=new(ELeave) CGTEdDialog(iGlobalText,iGlobalParaFormatLayer,iGlobalCharFormatLayer);
	dialog->ExecuteLD(R_TDLG_GTXTED);
	}

//
// CSimpleDocument
//

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

CEikAppUi* CSimpleDocument::CreateAppUiL()
	{
    return(new(ELeave) CSimpleAppUi);
	}

//
// CSimpleApplication
//

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

const TUid KUidSimpleApp={201};

TUid CSimpleApplication::AppDllUid() const
	{
	return(KUidSimpleApp);
	}

CApaDocument* CSimpleApplication::CreateDocumentL()
	{
	return(new(ELeave) CSimpleDocument(*this));
	}

//
// EXPORTed functions
//

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

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