// persistentconsole.h
// 
// Copyright (c) 2008 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//

#ifndef __PERSISTENTCONSOLE_H__
#define __PERSISTENTCONSOLE_H__

#include <e32base.h>
#include "console.h"

class TConsoleTitleSetter : public MIoWriter
	{
public:
	TConsoleTitleSetter(HBufC*& aTitle);
private: //from MIoReadWriter:
	virtual RIoReadWriteHandle::TMode IorwMode() const;
private: //from MIoWriter:
	virtual TInt IowWriteLength() const;
	virtual TInt IowWrite(TDes& aBuf);
	virtual void IowComplete(TInt aError);
	virtual TName IowName();
	virtual void IowCursorPos(TInt aError, TPoint aPos);
	virtual void IowSetCursorPosAbsComplete(TInt aError);
	virtual void IowSetCursorPosRelComplete(TInt aError);
	virtual void IowSetCursorHeightComplete(TInt aError);
	virtual void IowSetTitleComplete(TInt aError);
	virtual void IowClearScreenComplete(TInt aError);
	virtual void IowClearToEndOfLineComplete(TInt aError);
	virtual void IowScreenSize(TInt aError, TSize aSize);
	virtual void IowSetAttributesComplete(TInt aError);
	virtual HBufC* IowTitleLC();
private:
	HBufC*& iTitle;
	};


class CIoPersistentConsole
		: public CIoConsole
	{
	class TIoWriterProxy;
	class TIoReaderProxy;
public:
	static CIoPersistentConsole* NewLC(const TDesC& aName, const TDesC& aTitle, CIoServer& aServer, const RMsg& aMessage);
	virtual ~CIoPersistentConsole();
	
	TBool CanConnectReaderL(const MIoReadEndPoint& aReader) const;
	void AttachTransientReaderL(MIoReadEndPoint& aReader, CIoSession* aDetachOnClose);
	void DetachTransientReader();
	const MIoReadEndPoint* TransientReader() const;
	TBool CanConnectWriterL(const MIoWriteEndPoint& aWriter) const;
	void AttachTransientWriterL(MIoWriteEndPoint& aWriter, CIoSession* aDetachOnClose);
	void DetachTransientWriter();
	const MIoWriteEndPoint* TransientWriter() const;
	MIoWriteEndPoint* TransientWriter();
	
	void NotifyReadDetachL(const RMsg& aMessage);
	void CancelNotifyReadDetach(TRequestStatus* aClientStatus);
	void NotifyWriteDetachL(const RMsg& aMessage);
	void CancelNotifyWriteDetach(TRequestStatus* aClientStatus);
	
	TName TransientReaderName();
	TName TransientWriterName();
	
	TThreadId Creator();
	
	// From CObject:
	virtual TName Name() const;
	// From CIoObject.
	virtual TBool IsType(RIoHandle::TType aType) const;
	virtual void SessionClosed(const CIoSession& aSession);
	virtual void ClosedBy(const CIoSession& aSession);
	// From MIoReadEndPoint.
	virtual void IorepReadL(MIoReader& aReader);
	virtual void IorepReadKeyL(MIoReader& aReader);
	virtual void IorepSetConsoleModeL(RIoReadWriteHandle::TMode aMode, MIoReader& aReader);
	// From MIoWriteEndPoint.
	virtual void IowepWriteL(MIoWriter& aWriter);
	virtual void IowepWriteCancel(MIoWriter& aWriter);
	virtual void IowepCursorPosL(MIoWriter& aWriter) const;
	virtual void IowepSetCursorPosAbsL(const TPoint& aPoint, MIoWriter& aWriter);
	virtual void IowepSetCursorPosRelL(const TPoint& aPoint, MIoWriter& aWriter);
	virtual void IowepSetCursorHeightL(TInt aPercentage, MIoWriter& aWriter);
	virtual void IowepSetTitleL(MIoWriter& aWriter);
	virtual void IowepClearScreenL(MIoWriter& aWriter);
	virtual void IowepClearToEndOfLineL(MIoWriter& aWriter);
	virtual void IowepScreenSizeL(MIoWriter& aWriter) const;
	virtual void IowepSetAttributesL(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor, MIoWriter& aWriter);
private:
	// from CIoEndPoint:
	virtual TInt HandleReaderAttached(MIoReader& aReader);
	virtual void HandleReaderDetached(MIoReader& aReader);
	virtual void ForegroundReaderChanged();
	virtual TInt HandleWriterAttached(MIoWriter& aWriter);
	virtual void HandleWriterDetached(MIoWriter& aWriter);
	virtual void HandleForegroundReaderChanged();
	
	void SendReadDetachNotifications();
	void SendWriteDetachNotifications();
	
	TInt ReaderProxyIndex(MIoReader* aReader) const;
	TInt WriterProxyIndex(MIoWriter* aWriter) const;
	TIoWriterProxy& GetWriterProxy(MIoWriter* aWriter) const;
	TIoReaderProxy& GetReaderProxy(MIoReader* aReader) const;
private:
	CIoPersistentConsole(CIoServer& aServer);
	void ConstructL(const TDesC& aName, const TDesC& aTitle, const RMsg& aMessage);

	class TIoWriterProxy : public MIoWriter
		{
	public:
		TIoWriterProxy(MIoWriter& aWriter, CIoPersistentConsole& aOwner);
		void TransientWriterAttached(MIoWriteEndPoint& aWriteEndPoint);
		void TransientWriterDetach(MIoWriteEndPoint& aWriteEndPoint);
		
		void WriteL(MIoWriteEndPoint* aEndPoint);
		void WriteCancel(MIoWriteEndPoint* aEndPoint);
		MIoWriter& ClientWriter() const;
		void GetCursorPosL(MIoWriteEndPoint* aEndPoint);
		void SetCursorPosAbsL(const TPoint& aPos, MIoWriteEndPoint* aEndPoint);
		void SetCursorPosRelL(const TPoint& aPos, MIoWriteEndPoint* aEndPoint);
		void SetCursorHeightL(TInt aPercentage, MIoWriteEndPoint* aEndPoint);
		void SetTitleL(MIoWriteEndPoint* aEndPoint);
		void ClearScreenL(MIoWriteEndPoint* aEndPoint);
		void ClearToEndOfLineL(MIoWriteEndPoint* aEndPoint);
		void GetScreenSizeL(MIoWriteEndPoint* aEndPoint);
		void SetAttributesL(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor, MIoWriteEndPoint* aEndPoint);

		// from MIoReadWriter
		virtual RIoReadWriteHandle::TMode IorwMode() const;
		
		// from MIoWriter
		virtual TInt IowWriteLength() const;
		virtual TInt IowWrite(TDes& aBuf);
		virtual void IowComplete(TInt aError);
		virtual TName IowName();
		virtual void IowCursorPos(TInt aError, TPoint aPos);
		virtual void IowSetCursorPosAbsComplete(TInt aError);
		virtual void IowSetCursorPosRelComplete(TInt aError);
		virtual void IowSetCursorHeightComplete(TInt aError);
		virtual void IowSetTitleComplete(TInt aError);
		virtual void IowClearScreenComplete(TInt aError);
		virtual void IowClearToEndOfLineComplete(TInt aError);
		virtual void IowScreenSize(TInt aError, TSize aSize);
		virtual void IowSetAttributesComplete(TInt aError);
		virtual HBufC* IowTitleLC();
	private:
		enum TFlags
			{
			EWritePending			= 0x0001,
			EGetCursorPosPending	= 0x0002,
			ESetCursorPosAbsPending	= 0x0004,
			ESetCursorPosRelPending	= 0x0008,
			EClearScreenPending		= 0x0010,
			EClearToEndOfLinePending= 0x0020,
			EGetScreenSizePending	= 0x0040,
			EDetaching				= 0x0080,
			ESetCursorHeightPending = 0x0100,
			ESetTitlePending		= 0x0200,
			ESetAttributesPending	= 0x0400
			};
	private:
		TBool GetFlag(TFlags aFlag);
		void SetFlag(TFlags aFlag);
		void ClearFlag(TFlags aFlag);
	private:
		MIoWriter& iWriter;
		CIoPersistentConsole& iOwner;
		TUint iFlags;
		TPoint iSetCursPosAbsPoint;
		TPoint iSetCursPosRelPoint;
		TInt iSetCursorHeight;
		TUint iAttributes;
		ConsoleAttributes::TColor iForegroundColor;
		ConsoleAttributes::TColor iBackgroundColor;
		};
		
	class TIoReaderProxy : public MIoReader
		{
	public:
		TIoReaderProxy(MIoReader& aReader, CIoPersistentConsole& aOwner);
		void TransientReaderAttached(MIoReadEndPoint& aReader);
		
		void ReadL(MIoReadEndPoint* aEndPoint);
		void ReadKeyL(MIoReadEndPoint* aEndPoint);
		void SetConsoleModeL(MIoReadEndPoint* aEndPoint, RIoReadWriteHandle::TMode aMode);
		MIoReader& ClientReader() const;

		// from MIoReadWriter
		virtual RIoReadWriteHandle::TMode IorwMode() const;
		
		// from MIoReader
		virtual TBool IorReadPending() const;
		virtual TBool IorReadKeyPending() const;
		virtual TDes& IorReadBuf();
		virtual void IorDataBuffered(TInt aLength);
		virtual TBool IorDataIsBuffered() const;
		virtual TBool IorIsKeyCaptured(TUint aKeyCode, TUint aModifiers);
		virtual void IorReadComplete(TInt aError);
		virtual void IorReadKeyComplete(TInt aError, TUint aKeyCode, TUint aModifiers);
		virtual TName IorName();
		virtual void IorReaderChange(TUint aChange);
		virtual void IorSetConsoleModeComplete(TInt aError);
	private:
		MIoReader& iReader;
		CIoPersistentConsole& iOwner;
		TBool iDetaching;
		TBool iSetConsoleModePending;
		RIoReadWriteHandle::TMode iSetConsoleMode;
		};
private:
	CIoServer& iServer;
	RThread iCreator;
	TName iName; // name for the persistent console, used to identify it
	HBufC* iTitle; // title for the console, passed to CConsoleBase::SetTitle
	MIoReadEndPoint* iTransientReadEndPoint;
	CIoSession* iReadEndPointDetachOnClose;
	MIoWriteEndPoint* iTransientWriteEndPoint;
	CIoSession* iWriteEndPointDetachOnClose;
	
	RPointerArray<TIoWriterProxy> iWriterProxies;
	RPointerArray<TIoReaderProxy> iReaderProxies;
	
	RIoReadWriteHandle::TMode iPersistentConsoleMode;
	
	RArray<RMsg> iReadDetachNotifications;
	RArray<RMsg> iWriteDetachNotifications;
	
	TConsoleTitleSetter iTitleSetter;
	};
	
#endif //__PERSISTENTCONSOLE_H__
