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

#include <eikenv.h>
#include <coecntrl.h>
#include <basched.h>
#include <eikappui.h>
#include <eikdef.h>
#include <eikcmds.hrh>
#include <eikapp.h>
#include <eikdoc.h>
#include <eikdialg.hrh>
#include <eiktxlbx.h>
#include <eiktxlbm.h>
#include <apgwgnam.h>
#include <apgtask.h>

#include "TPLPBAK.hrh"
#include <TPLPBAK.rsg>
#include <eikon.rsg>

#include "TBACKCLI.H"

const TUid KUidPlpBackAppVal = {241};

//
// CPlpBakDocument
//
class CBackupClient;
class CPlpBakDocument : public CEikDocument
	{
public:
	static CPlpBakDocument *NewL(CEikApplication& aApp);
	//
	~CPlpBakDocument();
private: // from CApaDocument
	CPlpBakDocument(CEikApplication& aApp);
	void ConstructL();
	//
	CEikAppUi* CreateAppUiL();
	//
	//	New stuff !
	//
public:
	void GetDocumentListL();
	void StopDocument(const TDesC& aDoc);
	void CheckDocument(const TDesC& aDoc);
	void OwnerInfo();
protected:
	CBackupClient	*iClient;
	};

//
// class TPlpBakContainer
//

class TPlpBakContainer : public CCoeControl
    {
public:
    void ConstructL(const TRect &aRect);
    ~TPlpBakContainer();
	//
	void FillListBoxL(CDesCArray *anArray);
	TPtrC CurrentDocument();
private: // framework
	virtual TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType);
    virtual void Draw(const TRect& aRect) const;
    virtual TInt CountComponentControls() const;
    virtual CCoeControl* ComponentControl(TInt aIndex) const;
private:
	CEikTextListBox*iListBox;
    };

void TPlpBakContainer::ConstructL(const TRect &aRect)
    {
    CreateWindowL();
    Window().SetShadowDisabled(ETrue);
    Window().SetBackgroundColor(KRgbGray);
    EnableDragEvents();
    SetRectL(aRect);
    ActivateL();
    }

TPlpBakContainer::~TPlpBakContainer()
    {
	delete iListBox;
    }

TKeyResponse TPlpBakContainer::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
    {
	if (iListBox)
		return iListBox->OfferKeyEventL(aKeyEvent, aType);
	return EKeyWasConsumed;
    }


TInt TPlpBakContainer::CountComponentControls() const
    {
    return(0);
    }

CCoeControl* TPlpBakContainer::ComponentControl(TInt /*aIndex*/) const
    {
	return NULL;
    }

void TPlpBakContainer::Draw(const TRect& /*aRect*/) const
    {
    iEikonEnv->FillTexturedRect(Rect());
    }

TPtrC TPlpBakContainer::CurrentDocument()
	{
	TPtrC ret (_L(""));
	if (iListBox->CurrentItemIndex()>0)
		ret.Set(iListBox->Model()->ItemText(iListBox->CurrentItemIndex()));
	return ret;
	}


void TPlpBakContainer::FillListBoxL(CDesCArray *anArray)
	{
	if (iListBox)
		delete iListBox;
	iListBox=0;
	iListBox=new(ELeave)CEikTextListBox;
	iListBox->ConstructL(this);
	iListBox->CreateScrollBarFrameL();
	iListBox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);
	TRect rect=Rect();
	rect.Shrink(10,10);
	iListBox->SetRectL(rect);
	iListBox->ActivateL();
	//
	//
    iListBox->SetFocus(ETrue, EDrawNow);
	CDesCArray *mda=((CDesCArray *)iListBox->Model()->ItemTextArray());
	mda->Reset();
	//
	for (int ii=0; ii<anArray->Count(); ii++)
		{
		mda->AppendL(anArray->operator[](ii));
		}
	iListBox->HandleItemAdditionL();
	iListBox->DrawNow();
	}

//
// CPlpBakAppUi
//

class CPlpBakAppUi : public CEikAppUi, public MBackupObserver
    {
public:
    ~CPlpBakAppUi();
    void ConstructL();
private: // framework
	virtual void HandleCommandL(TInt aCommand);
private:
	void DoListOpenFilesL();
	void DoStopSelectedL();
	void DoCheckSelectedL();
	void DoOwnerInfoL();
protected:
	virtual TBool OnListOpenFiles(TInt aRes, CDesCArray *aArray);
	virtual void OnStopDocument(TInt aRes);
	virtual void OnCheckDocument(TInt aRes, TBool aIsRun);
	virtual void OnRetreiveOwnerInfo(TInt aRes, const TDesC& aInfo);
private:
    TPlpBakContainer* iContainer;
    };

CPlpBakAppUi::~CPlpBakAppUi()
    {
    delete iContainer;
    }

void CPlpBakAppUi::ConstructL()
    {
	BaseConstructL();
    iContainer=new(ELeave) TPlpBakContainer;
    iContainer->ConstructL(ClientRect());
    AddToStackL(iContainer);
    }

void CPlpBakAppUi::HandleCommandL(TInt aCommand)
	{
	switch (aCommand)
		{
		//
		//	Eikon basic commands
		//
	case EEikCmdExit:
		CBaActiveScheduler::Exit();
		//
		//	TPLPBACK commands
		//
	case EPlpCmdListOpenFiles:
		DoListOpenFilesL();
		break;
	case EPlpCmdStopSelFile:
		DoStopSelectedL();
		break;
	case EPlpCmdIsSelFileRunning:
		DoCheckSelectedL();
		break;
	case EPlpCmdOwnerInfo:
		DoOwnerInfoL();
		break;
	default:
		iEikonEnv->InfoMsg(_L("Not implemented in TPLPBAK"));
		break;
		}
	}

void CPlpBakAppUi::DoListOpenFilesL()
	{
	((CPlpBakDocument*)Document())->GetDocumentListL();
	}

void CPlpBakAppUi::DoStopSelectedL()
	{
	((CPlpBakDocument*)Document())->StopDocument(iContainer->CurrentDocument());
	}

void CPlpBakAppUi::DoCheckSelectedL()
	{
	((CPlpBakDocument*)Document())->CheckDocument(iContainer->CurrentDocument());
	}

void CPlpBakAppUi::DoOwnerInfoL()
	{
	((CPlpBakDocument*)Document())->OwnerInfo();
	}


TBool CPlpBakAppUi::OnListOpenFiles(TInt aRes, CDesCArray *aArray)
	{
	if(aRes==0)
		{
		iContainer->FillListBoxL(aArray);
		}
	return EFalse;
	}

void CPlpBakAppUi::OnStopDocument(TInt aRes)
	{

	TInt wgId=0;
	CApaWindowGroupName::FindByCaption(_L("TPLPBAK"), iCoeEnv->WsSession(), wgId);
	if(wgId>=0)
		{
		TApaTask Task(iCoeEnv->WsSession());
		Task.SetWgId(wgId);
		Task.BringToForeground();
		}

	TBuf<64> Msg;
	Msg.Format(_L("Stop document (%d)"), aRes);
	iEikonEnv->InfoMsg(Msg);
	}

void CPlpBakAppUi::OnCheckDocument(TInt aRes, TBool aIsRun)
	{
	if (aRes)
		{
		TBuf<64> Msg;
		Msg.Format(_L("Error %d checking document"), aRes);
		iEikonEnv->InfoMsg(Msg);
		}
	else
		{
		if (aIsRun)
			iEikonEnv->InfoMsg(_L("The document is running"));
		else
			iEikonEnv->InfoMsg(_L("Document not found"));
		}
	}

void CPlpBakAppUi::OnRetreiveOwnerInfo(TInt aRes, const TDesC &aInfo)
	{
	if (aRes)
		{
		TBuf<64> Msg;
		Msg.Format(_L("Error %d Owner Info"), aRes);
		iEikonEnv->InfoMsg(Msg);
		}
	else
		{
		iEikonEnv->InfoMsg(aInfo);
		}
	}

//
//
//

CPlpBakDocument::CPlpBakDocument(CEikApplication& aApp)
: CEikDocument(aApp)
	{
	}

CPlpBakDocument::~CPlpBakDocument()
	{
	delete iClient;
	}

CPlpBakDocument * CPlpBakDocument::NewL(CEikApplication& aApp)
	{
	CPlpBakDocument *Doc=new(ELeave)CPlpBakDocument(aApp);
	CleanupStack::PushL(Doc);
	Doc->ConstructL();
	CleanupStack::Pop();
	return Doc;
	}

void CPlpBakDocument::ConstructL()
	{
	}


CEikAppUi* CPlpBakDocument::CreateAppUiL()
	{
    return(new(ELeave) CPlpBakAppUi);
	}

//
//
//
void CPlpBakDocument::GetDocumentListL()
	{
	if (!iClient)
		iClient=CBackupClient::NewL((CPlpBakAppUi*)iAppUi);

	iClient->ListOpenFilesL();
	}

void CPlpBakDocument::StopDocument(const TDesC &aDoc)
	{
	if (!iClient)
		iClient=CBackupClient::NewL((CPlpBakAppUi*)iAppUi);
	iClient->StopDocumentL(aDoc);
	}

void CPlpBakDocument::CheckDocument(const TDesC &aDoc)
	{
	if (!iClient)
		iClient=CBackupClient::NewL((CPlpBakAppUi*)iAppUi);
	iClient->CheckDocumentL(aDoc);
	}

void CPlpBakDocument::OwnerInfo()
	{
	if (!iClient)
		iClient=CBackupClient::NewL((CPlpBakAppUi*)iAppUi);
	iClient->RetreiveOwnerInfoL();
	}


//
// CPlpBakApplication
//

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

CApaDocument* CPlpBakApplication::CreateDocumentL()
	{
	return CPlpBakDocument::NewL(*this);
	}

TUid CPlpBakApplication::AppDllUid() const
	{
	return KUidPlpBackAppVal;
	}

//
// EXPORTed functions
//

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

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