diff -r 000000000000 -r 7f656887cf89 libraries/iosrv/server/console.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libraries/iosrv/server/console.h Wed Jun 23 15:52:26 2010 +0100 @@ -0,0 +1,419 @@ +// console.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 __CONSOLE_H__ +#define __CONSOLE_H__ + +#include +#include +#include "endpoint.h" +#include "readwrite.h" + +class CLazyConsole; + +class RIoConsoleProxy : public RConsoleProxy + { +public: + enum TOpCode + { + ESetConsoleSizeDetect = RConsoleProxy::EOpCodeCustomBase, + ESetLazyConstruct, + ESetConsoleMode, + ESetUnderlyingConsole, + EOpenExistingConsole, + EWriteStdErr, + }; +public: + TInt SetConsoleSizeDetect(); + TInt SetLazyConstruct(); + void SetConsoleMode(RIoReadWriteHandle::TMode aMode, TRequestStatus& aStatus); + void SetUnderlyingConsole(const RIoConsoleProxy& aUnderlyingSession, TRequestStatus& aStatus); + TInt OpenExisting(); + void WriteStdErr(const TDesC& aDescriptor, TRequestStatus& aStatus); + }; + +class CIoConsole : public CIoEndPoint + { +public: + static CIoConsole* NewLC(const TDesC& aImplementation, const TDesC& aTitle, const TSize& aSize, const TIoConfig& aConfig, CIoConsole* aUnderlying, TUint aOptions); + ~CIoConsole(); + const TDesC& Implementation() const; +public: // From CIoObject. + virtual TBool IsType(RIoHandle::TType aType) const; +public: // From CIoEndPoint. + virtual void HandleReaderDetached(MIoReader& aReader); + virtual void HandleWriterDetached(MIoWriter& aWriter); +public: // From MIoReadEndPoint. + virtual void IorepReadL(MIoReader& aReader); + virtual void IorepReadKeyL(MIoReader& aReader); + virtual void IorepSetConsoleModeL(RIoReadWriteHandle::TMode aMode, MIoReader& aReader); +public: // 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); +protected: + CIoConsole(const TIoConfig& aConfig); +private: + class TConsoleRequest; +private: + void ConstructL(const TDesC& aImplementation, const TDesC& aTitle, const TSize& aSize, CIoConsole* aUnderlying, TUint aOptions); + void ReadComplete(TInt aError); + void ReadComplete(TUint aKeyCode, TUint aModifiers); + void QueueReaderIfRequired(); + void CreateComplete(TInt aError); + void NewRequest(TConsoleRequest* aRequest) const; + void CheckQueue() const; + void ConsoleDied(); + template void HandleReadWriterDetached(T& aReadWriter); +private: + class CConsoleReader : public CActive + { + public: + static CConsoleReader* NewL(CIoConsole& aConsole); + ~CConsoleReader(); + void QueueRead(); + private: + CConsoleReader(CIoConsole& aConsole); + private: // From CActive. + virtual void RunL(); + virtual void DoCancel(); + private: + CIoConsole& iConsole; + TKeyCode iKeyCode; + TUint iKeyModifiers; + TPckg iKeyCodePckg; + TPckg iKeyModifiersPckg; + }; + + class TConsoleRequest + { + public: + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus) = 0; + virtual void PrepareL(); + virtual void CompleteD(TInt aError) = 0; + virtual TBool OriginatedFrom(MIoReader& aReader) const; + virtual TBool OriginatedFrom(MIoWriter& aWriter) const; + }; + + class TConsoleWriterRequest : public TConsoleRequest + { + protected: + TConsoleWriterRequest(MIoWriter& aWriter); + private: // From TConsoleRequest. + virtual TBool OriginatedFrom(MIoWriter& aWriter) const; + protected: + MIoWriter& iWriter; + }; + + class TConsoleReaderRequest : public TConsoleRequest + { + protected: + TConsoleReaderRequest(MIoReader& aReader); + private: // From TConsoleRequest. + virtual TBool OriginatedFrom(MIoReader& aReader) const; + protected: + MIoReader& iReader; + }; + + class TConsoleCreateRequest : public TConsoleRequest + { + public: + TConsoleCreateRequest(CIoConsole& aOwner); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void CompleteD(TInt aError); + private: + CIoConsole& iOwner; + }; + + class TConsoleWriteRequest : public TConsoleWriterRequest + { + public: + TConsoleWriteRequest(MIoWriter& aWriter); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void PrepareL(); + virtual void CompleteD(TInt aError); + private: + HBufC* iBuf; + }; + + class TConsoleCursorPosRequest : public TConsoleWriterRequest + { + public: + TConsoleCursorPosRequest(MIoWriter& aWriter); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void CompleteD(TInt aError); + private: + TPoint iPos; + TPckg iPosPckg; + }; + + class TConsoleSetCursorPosAbsRequest : public TConsoleWriterRequest + { + public: + TConsoleSetCursorPosAbsRequest(MIoWriter& aWriter, const TPoint& aPoint); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void CompleteD(TInt aError); + private: + TPoint iPoint; + }; + + class TConsoleSetCursorPosRelRequest : public TConsoleWriterRequest + { + public: + TConsoleSetCursorPosRelRequest(MIoWriter& aWriter, const TPoint& aPoint); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void CompleteD(TInt aError); + private: + TPoint iPoint; + }; + + class TConsoleSetCursorHeightRequest : public TConsoleWriterRequest + { + public: + TConsoleSetCursorHeightRequest(MIoWriter& aWriter, TInt aHeight); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void CompleteD(TInt aError); + private: + TInt iHeight; + }; + + class TConsoleSetTitleRequest : public TConsoleWriterRequest + { + public: + TConsoleSetTitleRequest(MIoWriter& aWriter); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void PrepareL(); + virtual void CompleteD(TInt aError); + private: + HBufC* iTitle; + }; + + class TConsoleClearScreenRequest : public TConsoleWriterRequest + { + public: + TConsoleClearScreenRequest(MIoWriter& aWriter); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void CompleteD(TInt aError); + }; + + class TConsoleClearToEndOfLineRequest : public TConsoleWriterRequest + { + public: + TConsoleClearToEndOfLineRequest(MIoWriter& aWriter); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void CompleteD(TInt aError); + }; + + class TConsoleScreenSizeRequest : public TConsoleWriterRequest + { + public: + TConsoleScreenSizeRequest(MIoWriter& aWriter, const TIoConfig& aConfig); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void CompleteD(TInt aError); + private: + const TIoConfig& iConfig; + TSize iSize; + TPckg iSizeBuf; + }; + + class TConsoleSetAttributesRequest : public TConsoleWriterRequest + { + public: + TConsoleSetAttributesRequest(MIoWriter& aWriter, TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void CompleteD(TInt aError); + private: + TUint iAttributes; + ConsoleAttributes::TColor iForegroundColor; + ConsoleAttributes::TColor iBackgroundColor; + }; + + class TConsoleSetUnderlyingRequest : public TConsoleRequest + { + public: + TConsoleSetUnderlyingRequest(CIoConsole& aUnderlyingConsole); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void PrepareL(); + virtual void CompleteD(TInt aError); + private: + CIoConsole& iConsole; + RIoConsoleProxy iSession; + }; + friend class TConsoleSetUnderlyingRequest; + + class TConsoleSetModeRequest : public TConsoleReaderRequest + { + public: + TConsoleSetModeRequest(MIoReader& aReader, CIoConsole& aConsole, RIoReadWriteHandle::TMode aMode); + virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus); + virtual void CompleteD(TInt aError); + private: + CIoConsole& iConsole; + RIoReadWriteHandle::TMode iMode; + }; + friend class TConsoleSetModeRequest; + + class CConsoleRequest : public CActive + { + public: + CConsoleRequest(CIoConsole& aConsole); + + void Service(TConsoleRequest* aRequest); + ~CConsoleRequest(); + const TConsoleRequest* CurrentRequest() const; + void Abort(); + private: + void Complete(TConsoleRequest* aRequest, TInt aError); + private: // from CActive + virtual void RunL(); + virtual void DoCancel(); + private: + CIoConsole& iConsole; + TConsoleRequest* iCurrentRequest; + }; + + class CServerDeathWatcher : public CActive + { + public: + CServerDeathWatcher(RServer2& aServer, RThread& aThread); + ~CServerDeathWatcher(); + private: + virtual void RunL(); + virtual void DoCancel(); + private: + RServer2& iServer; + RThread& iThread; + }; + friend class TConsoleCreateRequest; + friend class CConsoleRequest; + friend class CConsoleReader; + friend class TConsoleDetectSizeRequest; +protected: + const TIoConfig& iConfig; + RIoConsoleProxy iConsole; + CConsoleReader* iReader; + mutable TSize iDetectedSize; + mutable TBool iSizeDetected; + HBufC* iImplementation; + TSize iCreationSize; + HBufC* iCreationTitle; + TInt iCreateStatus; + mutable RArray iRequestQueue; + CConsoleRequest* iRequestAo; + RServer2 iThreadServer; + RThread iServerThread; + CServerDeathWatcher* iThreadWatcher; + }; + +class CIoConsoleProxyServer : public CConsoleProxyServer + { +public: + static CIoConsoleProxyServer* NewL(TConsoleCreateFunction aConsoleCreate, RLibrary& aConsoleLibrary); + virtual CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const; + ~CIoConsoleProxyServer(); + MProxiedConsole* TheConsole() const; + void SetTheConsole(MProxiedConsole* aConsole); +private: + CIoConsoleProxyServer(TConsoleCreateFunction aConsoleCreate, const RLibrary& aConsoleLibrary); +private: + RLibrary iConsoleLibrary; + MProxiedConsole* iTheConsole; + }; + +CConsoleProxyServer* CIoConsoleProxyServerNewL(TAny* aParams); + +class CIoConsoleProxySession : public CConsoleProxySession + { +public: + CIoConsoleProxySession(TConsoleCreateFunction aConsoleCreate); + ~CIoConsoleProxySession(); +public: // from CConsoleProxySession: + virtual void ServiceL(const RMessage2& aMessage); + virtual MProxiedConsole* InstantiateConsoleL(); + virtual void ConsoleCreatedL(MProxiedConsole* aConsole); +private: + enum TFlag + { + ELazy = 0x01, + EAutoDetectSize = 0x02, + ESupportsStdErr = 0x04, + }; +private: + CIoConsoleProxyServer* Server() { return (CIoConsoleProxyServer*)CConsoleProxySession::Server();} + void DetectSizeL(const RMessage2& aMessage); + void SetModeL(const RMessage2& aMessage); + void SetUnderlyingConsoleL(const RMessage2& aMessage); + void OpenExistingL(const RMessage2& aMessage); + + TBool GetFlag(TFlag aFlag); + void SetFlag(TFlag aFlag, TBool aSet); +private: + CConsoleProxy* iUnderlyingConsole; + TUint iFlags; + TSize iDetectedSize; + }; + +class CWriteOnlyConsoleProxy : public CConsoleProxy + { +public: + static CConsoleProxy* NewL(const RConsoleProxy& aProxySession); +public: // from CConsoleProxy: + virtual void Read(TRequestStatus &aStatus); + virtual void ReadCancel(); + virtual TKeyCode KeyCode() const; + virtual TUint KeyModifiers() const; +private: + CWriteOnlyConsoleProxy(); + }; + +class CLazyConsole : public CConsoleBase + { +public: + CLazyConsole(TConsoleCreateFunction aConsoleCreate, TBool aAutoDetectSize); + ~CLazyConsole(); +public: // from CConsoleBase + virtual TInt Create(const TDesC &aTitle,TSize aSize); + virtual void Read(TRequestStatus &aStatus); + virtual void ReadCancel(); + virtual void Write(const TDesC &aDes); + virtual TPoint CursorPos() const; + virtual void SetCursorPosAbs(const TPoint &aPoint); + virtual void SetCursorPosRel(const TPoint &aPoint); + virtual void SetCursorHeight(TInt aPercentage); + virtual void SetTitle(const TDesC &aTitle); + virtual void ClearScreen(); + virtual void ClearToEndOfLine(); + virtual TSize ScreenSize() const; + virtual TKeyCode KeyCode() const; + virtual TUint KeyModifiers() const; + virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1); +private: + TInt CheckCreated() const; +private: + TConsoleCreateFunction iConsoleCreate; + TBool iSizeAutoDetect; + RBuf iTitle; + TSize iSize; + mutable TSize iDetectedSize; + mutable TInt iCreateError; + mutable CConsoleBase* iConsole; + }; + +#endif //__CONSOLE_H__