// streams.cpp
//
// Copyright (c) 2002 Symbian Ltd.  All rights reserved.
//

#include "streams.h"

#include <eikenv.h>
#include <eikon.rsg>
#include <eikdialg.h>
#include <eikedwin.h>
#include <eikfsel.h>
#include <s32file.h>

const TInt KStreamsMaxReadInBufLength=10000;

/**
	CExampleWriteFileDialog
*/
class CExampleWriteFileDialog : public CEikDialog
	{
public:
	CExampleWriteFileDialog(CExampleAppUi* aAppUi);
private:
	// from CEikDialog
	void PreLayoutDynInitL(); // initialization
	TBool OkToExitL(TInt aKeycode); // termination
private:
	CExampleAppUi* iAppUi;
	};

CExampleWriteFileDialog::CExampleWriteFileDialog(CExampleAppUi* aAppUi)
	: iAppUi(aAppUi)
	{
	}

void CExampleWriteFileDialog::PreLayoutDynInitL()
	{
	CEikFileNameEditor* fnamed= static_cast<CEikFileNameEditor*>(Control(EExampleControlIdFileName));
	fnamed->SetTextL(iAppUi->iFileName);
	CEikEdwin* edwin=static_cast<CEikEdwin*>(Control(EExampleControlIdText));
	edwin->SetTextL(iAppUi->iText);
	}

TBool CExampleWriteFileDialog::OkToExitL(TInt /* aKeycode */) // termination
	{
	// get file name
	CEikEdwin* edwin=static_cast<CEikEdwin*>(Control(EExampleControlIdFileName));
	HBufC* fileName=edwin->GetTextInHBufL();
	// check it's even been specified
	if (!fileName)
		{
		TryChangeFocusToL(EExampleControlIdFileName);
		iEikonEnv->LeaveWithInfoMsg(R_EIK_TBUF_NO_FILENAME_SPECIFIED);
		}
	CleanupStack::PushL(fileName);
	// check it's a valid filename
	if (!iCoeEnv->FsSession().IsValidName(*fileName))
		{
		TryChangeFocusToL(EExampleControlIdFileName);
		iEikonEnv->LeaveWithInfoMsg(R_EIK_TBUF_INVALID_FILE_NAME);
		}
	// get the text string
	edwin=static_cast<CEikEdwin*>(Control(EExampleControlIdText));
	HBufC* text=edwin->GetTextInHBufL();
	if (!text)
		text=HBufC::NewL(0);
	CleanupStack::PushL(text);
	// ensure the directories etc needed for the file exist
	TInt err=iCoeEnv->FsSession().MkDirAll(*fileName);
	if (err!=KErrNone && err!=KErrAlreadyExists)
		User::Leave(err);
	// check whether it's going to be possible to create the file for writing
	RFile file;
	err=file.Create(iCoeEnv->FsSession(), *fileName, EFileWrite);
	if (err!=KErrNone && err!=KErrAlreadyExists)
		User::Leave(err); // no need to close file, since it didn't open
	// check whether the user wants to replace the file, if it already exists
	if (err==KErrAlreadyExists)
		{
		if (iEikonEnv->QueryWinL(R_EIK_TBUF_FILE_REPLACE_CONFIRM))
			User::LeaveIfError(file.Replace(iCoeEnv->FsSession(), *fileName, EFileWrite));
		else
			iEikonEnv->LeaveWithInfoMsg(0); // let user try again
		}
	file.Close();
	// finished with user interaction: communicate parameters and return
	delete iAppUi->iFileName;
	iAppUi->iFileName=fileName;
	delete iAppUi->iText;
	iAppUi->iText=text;
	CleanupStack::Pop(2); // text, fileName
	return ETrue;
	}

/**
	CExampleReadFileDialog
*/
class CExampleReadFileDialog : public CEikDialog
	{
public:
	CExampleReadFileDialog(CExampleAppUi* aAppUi);
private:
	// from CEikDialog
	void PreLayoutDynInitL(); // initialization
	TBool OkToExitL(TInt aKeycode); // termination
private:
	CExampleAppUi* iAppUi;
	};

CExampleReadFileDialog::CExampleReadFileDialog(CExampleAppUi* aAppUi)
	: iAppUi(aAppUi)
	{
	}

void CExampleReadFileDialog::PreLayoutDynInitL()
	{
	CEikFileNameEditor* fnamed=static_cast<CEikFileNameEditor*>(Control(EExampleControlIdFileName));
	fnamed->SetTextL(iAppUi->iFileName);
	}

TBool CExampleReadFileDialog::OkToExitL(TInt /* aKeycode */) // termination
	{
	// get file name
	CEikFileNameEditor* fnamed=static_cast<CEikFileNameEditor*>(Control(EExampleControlIdFileName));
	HBufC* fileName=fnamed->GetTextInHBufL();
	// check it's even been specified
	if (!fileName)
		{
		TryChangeFocusToL(EExampleControlIdFileName);
		iEikonEnv->LeaveWithInfoMsg(R_EIK_TBUF_NO_FILENAME_SPECIFIED);
		}
	CleanupStack::PushL(fileName);
	// check it's a valid filename
	if (!iCoeEnv->FsSession().IsValidName(*fileName))
		{
		TryChangeFocusToL(EExampleControlIdFileName);
		iEikonEnv->LeaveWithInfoMsg(R_EIK_TBUF_INVALID_FILE_NAME);
		}
	// check whether it's going to be possible to create the file for reading
	RFile file;
	User::LeaveIfError(file.Open(iCoeEnv->FsSession(), *fileName, EFileRead));
	file.Close();
	// finished with user interaction: communicate parameters and return
	delete iAppUi->iFileName;
	iAppUi->iFileName=fileName;
	CleanupStack::Pop(); // fileName
	return ETrue;
	}

/**
	CExampleParseDialog
*/
class CExampleParseDialog : public CEikDialog
	{
public:
	CExampleParseDialog(CExampleAppUi* aAppUi);
private:
	// from CEikDialog
	void PreLayoutDynInitL(); // initialization
private:
	CExampleAppUi* iAppUi;
	};

CExampleParseDialog::CExampleParseDialog(CExampleAppUi* aAppUi)
	: iAppUi(aAppUi)
	{
	}

void CExampleParseDialog::PreLayoutDynInitL()
	{
	TParsePtrC parser(*iAppUi->iFileName);

	CEikEdwin* edwin=static_cast<CEikEdwin*>(Control(EExampleControlIdDrive));	
	const TDesC& drive=parser.Drive();
	edwin->SetTextL(&drive);

	edwin=static_cast<CEikEdwin*>(Control(EExampleControlIdPath));
	const TDesC& path=parser.Path();
	edwin->SetTextL(&path);
	
	edwin=static_cast<CEikEdwin*>(Control(EExampleControlIdName));
	const TDesC& name=parser.Name();
	edwin->SetTextL(&name);

	edwin=static_cast<CEikEdwin*>(Control(EExampleControlIdExtension));
	const TDesC& ext=parser.Ext();
	edwin->SetTextL(&ext);
	}

/**
	CExampleAppView
*/
void CExampleAppView::ConstructL(const TRect& aRect, CExampleAppUi* aAppUi)
	{
	iAppUi=aAppUi;
	CreateWindowL();
	SetRect(aRect);
	ActivateL();
	}

CExampleAppView::~CExampleAppView()
	{
	}

void CExampleAppView::Draw(const TRect& /*aRect*/) const
	{
	CWindowGc& gc = SystemGc();
	TRect rect=Rect();
	gc.DrawRect(rect);
	gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
	gc.SetBrushColor(KRgbWhite);
	const CFont* font=iEikonEnv->TitleFont();
	gc.UseFont(font);
	TInt baseline=rect.Height()/2 + font->AscentInPixels()/2;
	const TDesC* text=iAppUi->iText;
	if (!text)	
		{text=&KNullDesC;}
	gc.DrawText(*text, rect, baseline, CGraphicsContext::ECenter);
	gc.DiscardFont();
	}

/**
	App UI
*/
void CExampleAppUi::ConstructL()
    {
	CQikAppUi::ConstructL();

    iAppView=new(ELeave) CExampleAppView;
    iAppView->ConstructL(ClientRect(), this);
	iFileName=iEikonEnv->AllocReadResourceL(R_EXAMPLE_INITIAL_FILE);
	iText=iEikonEnv->AllocReadResourceL(R_EXAMPLE_TEXT_HELLO);
    }

CExampleAppUi::~CExampleAppUi()
	{
	delete iText;
	delete iFileName;
    delete iAppView;
	}

void CExampleAppUi::HandleCommandL(TInt aCommand)
	{
	switch (aCommand)
		{
	case EStreamsExampleCmdWriteFile:
		CmdWriteFileL();
		break;
	case EStreamsExampleCmdReadFile:
		CmdReadFileL();
		break;
	case EStreamsExampleCmdParse:
		CmdParseFileNameL();
		break;
	case EEikCmdExit: 
		Exit();
		break;
		}
	}

void CExampleAppUi::CmdWriteFileL()
	{
	// use a dialog to get parameters and verify them
	CEikDialog* dialog=new(ELeave) CExampleWriteFileDialog(this);
	if (!dialog->ExecuteLD(R_EXAMPLE_WRITE_FILE_DIALOG))
		return;
	// write file under a trap
	TRAPD(err, WriteFileL());
	if (err)
		{
		delete iText;
		iText=0;
		iCoeEnv->FsSession().Delete(*iFileName); // don't check errors here!
		iAppView->DrawNow();
		User::Leave(err);
		}
	// update view
	iAppView->DrawNow();
	}

void CExampleAppUi::WriteFileL()
	{
	// create a write stream on the file
	RFileWriteStream writer;
	writer.PushL(); // writer on cleanup stack
	User::LeaveIfError(writer.Replace(iCoeEnv->FsSession(), *iFileName, EFileWrite));
	// write the text
	writer << *iText;
	writer.CommitL();
	// finish
	CleanupStack::PopAndDestroy(); // writer
	}

void CExampleAppUi::CmdReadFileL()
	{
	// use a dialog to get parameters and verify them
	CEikDialog* dialog=new(ELeave) CExampleReadFileDialog(this);
	if (!dialog->ExecuteLD(R_EXAMPLE_READ_FILE_DIALOG))
		return;
	// create a read stream on the file
	RFileReadStream reader;
	reader.PushL(); // reader on cleanup stack
	User::LeaveIfError(reader.Open(iCoeEnv->FsSession(), *iFileName, EFileRead));
	// read the text
	HBufC* string=HBufC::NewL(reader, KStreamsMaxReadInBufLength);
	delete iText;
	iText=string;
	// finish
	CleanupStack::PopAndDestroy(); // reader
	// update view
	iAppView->DrawNow();
	} 

void CExampleAppUi::CmdParseFileNameL()
	{
	CEikDialog* dialog=new(ELeave) CExampleParseDialog(this);
	dialog->ExecuteLD(R_EXAMPLE_PARSE_DIALOG);
	}

// document

CExampleDocument::CExampleDocument(CEikApplication& aApp)
		: CQikDocument(aApp)
	{
	}

CEikAppUi* CExampleDocument::CreateAppUiL()
	{
    return new(ELeave) CExampleAppUi;
	}

// application

TUid CExampleApplication::AppDllUid() const
	{
	return KUidExample;
	}

CApaDocument* CExampleApplication::CreateDocumentL()
	{
	return new (ELeave) CExampleDocument(*this);
	}

// Plymorphic dynamicaly loaded library factory 

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

GLDEF_C TInt E32Dll(TDllReason)
	{
	return KErrNone;
	}