// readwrite.h

// 

// Copyright (c) 2006 - 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 __READWRITE_H__

#define __READWRITE_H__

#include <e32base.h>

#include "server.h"

#include "iocli.h"

#include "object.h"

class CIoConsole;

class CThreadOwner;

class MIoReadWriter

	{

public:

	virtual RIoReadWriteHandle::TMode IorwMode() const = 0;

	};

class MIoReader : public MIoReadWriter

	{

public:

	virtual TBool IorReadPending() const = 0;

	virtual TBool IorReadKeyPending() const = 0;

	virtual TDes& IorReadBuf() = 0;

	virtual void IorDataBuffered(TInt aLength) = 0;

	virtual TBool IorDataIsBuffered() const = 0;

	virtual void IorReadComplete(TInt aError) = 0;

	virtual void IorReadKeyComplete(TInt aError, TUint aKeyCode, TUint aModifiers) = 0;

	virtual TName IorName() = 0;

	virtual void IorReaderChange(TUint aChange) = 0;

	virtual void IorSetConsoleModeComplete(TInt aError) = 0;

	};

class MIoWriter : public MIoReadWriter

	{

public:

	virtual TInt IowWriteLength() const = 0;

	virtual TInt IowWrite(TDes& aBuf) = 0;

	virtual void IowComplete(TInt aError) = 0;

	virtual TName IowName() = 0;

	virtual void IowCursorPos(TInt aError, TPoint aPos) = 0;

	virtual void IowSetCursorPosAbsComplete(TInt aError) = 0;

	virtual void IowSetCursorPosRelComplete(TInt aError) = 0;

	virtual void IowSetCursorHeightComplete(TInt aError) = 0;

	virtual void IowSetTitleComplete(TInt aError) = 0;

	virtual void IowClearScreenComplete(TInt aError) = 0;

	virtual void IowClearToEndOfLineComplete(TInt aError) = 0;

	virtual void IowScreenSize(TInt aError, TSize aSize) = 0;

	virtual void IowSetAttributesComplete(TInt aError) = 0;

	virtual HBufC* IowTitleLC() = 0;

	virtual TBool IowIsStdErr() const { return EFalse; }

	};

class MIoEndPoint

	{

public:

	TBool IoepIsConsole() const;

	virtual TName IoepName() const = 0;

	virtual TBool IoepIsType(RIoHandle::TType aType) const = 0;

	};

class MIoReadEndPoint : public MIoEndPoint

	{

public:

	virtual void IorepAttachL(MIoReader& aReader, RIoEndPoint::TReadMode aMode) = 0;

	virtual void IorepDetach(MIoReader& aReader) = 0;

	virtual void IorepReadL(MIoReader& aReader) = 0;

	virtual void IorepSetForegroundReaderL(MIoReader& aReader) = 0;

	virtual TBool IorepIsForegroundL(const MIoReader& aReader) const = 0;

	virtual void IorepReadKeyL(MIoReader& aReader);

	virtual void IorepSetConsoleModeL(RIoReadWriteHandle::TMode aMode, MIoReader& aReader);

	static TBool AttachedToConsole(const MIoReadEndPoint* aEndPoint);

	};

class MIoWriteEndPoint : public MIoEndPoint

	{

public:

	virtual void IowepAttachL(MIoWriter& aReader) = 0;

	virtual void IowepDetach(MIoWriter& aReader) = 0;

	virtual void IowepWriteL(MIoWriter& aWriter) = 0;

	virtual void IowepWriteCancel(MIoWriter& aWriter) = 0;

	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);

	static TBool AttachedToConsole(const MIoWriteEndPoint* aEndPoint);

protected:

	virtual TPoint IowepCursorPos() const;

	virtual void IowepSetCursorPosAbs(const TPoint& aPoint);

	virtual void IowepSetCursorPosRel(const TPoint& aPoint);

	virtual void IowepSetCursorHeight(TInt aHeight);

	virtual void IowepSetTitle(const TDesC& aTitle);

	virtual void IowepClearScreen();

	virtual void IowepClearToEndOfLine();

	virtual TSize IowepScreenSize() const;

	virtual void IowepSetAttributes(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor);

	};

class CIoReadWriteObject : public CIoObject

	{

public:

	TUint Id() const;

	void SetOwnerL(TThreadId aOwningThread);

	TInt Open(TThreadId aOwningThread);

	void DoDuplicateL(const CIoReadWriteObject& aDuplicate);

	TBool IsOwner(TThreadId aOwningThread) const;

	TBool OpenedByOwner() const;

	void SetConsole(CIoConsole& aConsole);

	CIoConsole* Console();

	const CIoConsole* Console() const;

	MIoEndPoint* EndPoint();

	virtual void SetModeL(const RMsg& aMessage);

protected:

	CIoReadWriteObject(TUint aId);

	void Dump(const TDesC& aData) const;

protected:

	MIoEndPoint* iEndPoint;

	RIoReadWriteHandle::TMode iMode;

private:

	const TUint iId;

	TThreadId iOwningThreadId;

	TBool iOpenedByOwner;

	CIoConsole* iConsole;

	};

class CIoReadObject : public CIoReadWriteObject, public MIoReader

	{

public:

	static CIoReadObject* NewLC(TInt aId);

	virtual ~CIoReadObject();

	void DuplicateL(const CIoReadObject& aDuplicate);

	void AttachL(MIoReadEndPoint& aEndPoint, RIoEndPoint::TReadMode aMode);

	void SetReadMode(RIoReadHandle::TReadMode aMode);

	void SetToForegroundL();

	TBool IsForegroundL() const;

	void ReadL(const RMsg& aMessage);

	void ReadCancel(const CIoSession& aSession);

	void SetLineSeparatorL(const RMsg& aMessage);

	void ReadKeyL(const RMsg& aMessage);

	void ReadKeyCancel(const CIoSession& aSession);

	void CaptureKeyL(const RMsg& aMessage);

	void CancelCaptureKey(const RMsg& aMessage);

	void CaptureAllKeys(const RMsg& aMessage);

	void CancelCaptureAllKeys(const RMsg& aMessage);

	void NotifyChange(const RMsg& aMessage);

	void CancelNotifyChange(const CIoSession& aSession);

public: // From CIoObject.

	virtual TBool IsType(RIoHandle::TType aType) const;

	virtual void SessionClosed(const CIoSession& aSession);

public: // From CIoReadWriteObject.

	virtual void SetModeL(const RMsg& aMessage);

public: // From MIoReadWriter.

	virtual RIoReadWriteHandle::TMode IorwMode() const;

private: // From MIoReader.

	virtual TBool IorReadPending() const;

	virtual TBool IorReadKeyPending() const;

	virtual TDes& IorReadBuf();

	virtual void IorDataBuffered(TInt aLength);

	virtual TBool IorDataIsBuffered() const;

	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:

	CIoReadObject(TInt aId);

	void ProcessRead();

	void AllocateBufferL(TInt aLength);

	void TryToCompleteRead();

	void CompleteRead(TInt aError, TInt aLength);

	void CompleteReadKey(TInt aError, RIoConsoleReadHandle::TConsoleKey& aConsoleKey);

	MIoReadEndPoint* ReadEndPoint() const;

	void CancelSetMode(const CIoSession& aSession);

private:

	class TCapturedKey

		{

	public:

		TCapturedKey(TUint aKeyCode, TUint aModifierMask, TUint aModifiers);

	public:

		TUint iKeyCode;

		TUint iModifierMask;

		TUint iModifiers;

		};

private:

	RIoReadHandle::TReadMode iReadMode;

	TInt iMaxReadLength;

	RMsg iReadMessage;

	RMsg iReadKeyMessage;

	HBufC* iBuf;

	TPtr iPtr;

	HBufC* iLineSeparator; // NULL means use default "\n"

	RArray<TCapturedKey> iCapturedKeys;

	RArray<RIoConsoleReadHandle::TConsoleKey> iKeyBuffer;

	TBool iCaptureAllKeys;

	TInt iCompleteErr; // non-zero if we have completed reading

	RMsg iChangeNotifyMessage;

	RMsg iSetModeMessage;

	};

class CIoWriteObject : public CIoReadWriteObject, public MIoWriter

	{

public:

	static CIoWriteObject* NewLC(TInt aId);

	~CIoWriteObject();

	void DuplicateL(const CIoWriteObject& aDuplicate);

	void AttachL(MIoWriteEndPoint& aEndPoint);

	void WriteL(const RMsg& aMessage);

	void WriteCancel(const CIoSession& aSession);

	void CursorPosL(const RMsg& aMessage);

	void SetCursorPosAbsL(const RMsg& aMessage);

	void SetCursorPosRelL(const RMsg& aMessage);

	void SetCursorHeightL(const RMsg& aMessage);

	void SetTitleL(const RMsg& aMessage);

	void ClearScreen(const RMsg& aMessage);

	void ClearToEndOfLine(const RMsg& aMessage);

	void ScreenSizeL(const RMsg& aMessage);

	void SetAttributesL(const RMsg& aMessage);

	void SetIsStdErr(TBool aFlag);

public: // From CIoObject.

	virtual TBool IsType(RIoHandle::TType aType) const;

	virtual void SessionClosed(const CIoSession& aSession);

public: // 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 RIoWriteHandle::TMode IowWriteMode() const;

	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();

	virtual TBool IowIsStdErr() const;

private:

	CIoWriteObject(TInt aId);

	MIoWriteEndPoint* WriteEndPoint() const;

protected:

	TInt iOffset;

	TInt iWriteLength;

	RMsg iWriteMessage;

	RMsg iGetCursorPosMsg;

	RMsg iSetCursorPosAbsMsg;

	RMsg iSetCursorPosRelMsg;

	RMsg iSetCursorHeightMsg;

	RMsg iSetTitleMsg;

	RMsg iClearScreenMsg;

	RMsg iClearToEndOfLineMsg;

	RMsg iGetScreenSizeMsg;

	RMsg iSetAttributesMsg;

	TBool iTriedConsoleScreenSize;

	TBool iIsStdErr;

	};

#endif // __READWRITE_H__