diff -r 000000000000 -r 7f656887cf89 plugins/consoles/consoleproxy/inc/consoleproxy.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/plugins/consoles/consoleproxy/inc/consoleproxy.h Wed Jun 23 15:52:26 2010 +0100 @@ -0,0 +1,284 @@ +// consoleproxy.h +// +// Copyright (c) 2009 - 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 __CONSOLEPROXY_H__ +#define __CONSOLEPROXY_H__ + +#include +#include +#include + +class CConsoleProxyServer; +class TServerParams; + +typedef CConsoleBase* (*TConsoleCreateFunction)(); +typedef CConsoleProxyServer* (*TServerNewL)(TAny*); + +enum TConsoleProxyPanic + { + EConsoleAlreadyCreated = 0, + ENoConsoleInstatiated = 1, + }; + +void Panic(TConsoleProxyPanic aReason); + +class RConsoleProxy : public RSessionBase + { +public: + enum TOpCode + { + EGetServer, + ECreate, + ERead, + EReadKey, + EReadCancel, + EWrite, + EGetCursorPos, + ESetCursorPosAbs, + ESetCursorPosRel, + ESetCursorHeight, + ESetTitle, + EClearScreen, + EClearToEndOfLine, + EGetScreenSize, + EGetKeyCode, + EGetKeyModifiers, + ESetAttributes, + EIsConstructed, + + EOpCodeCustomBase = 1000, + }; +public: + /** + Create a new sub-thread to host a console and connect to it. + + @param aConsoleCreate Function pointer to create the console in the new thread + @param aServer On return, the handle of the server running in the sub thread. Ownership is NOT returned + to the caller. + @param aServerThread On return, the handle to the thread that the server is running in. Ownership is + returned to the caller. + */ + IMPORT_C TInt Connect(TConsoleCreateFunction aConsoleCreate, const TDesC& aThreadNameBase, + TInt aStackSize, TInt aHeapMinSize, TInt aHeapMaxSize, + RServer2& aServer, RThread& aServerThread); + + /** + Create a new sub-thread to host a console and connect to it, using a custom CConsoleProxyServer derived + server. + + @param aServerConstructor NewL of the server class + @param aServerParams Parameters to pass into the server NewL. + @param aServer On return, the handle of the server running in the sub thread. Ownership is NOT returned + to the caller. + @param aServerThread On return, the handle to the thread that the server is running in. Ownership is + returned to the caller. + */ + IMPORT_C TInt Connect(TServerNewL aServerConstructor, TAny* aServerParams, const TDesC& aThreadNameBase, + TInt aStackSize, TInt aHeapMinSize, TInt aHeapMaxSize, + RServer2& aServer, RThread& aServerThread); + + /** + Connects to a console hosted with the given server. + */ + IMPORT_C TInt Connect(RServer2 aServer); + /** + Connect to a console created within another process. + */ + IMPORT_C TInt Connect(const TDesC& aServerName, const TDesC& aServerArgs = KNullDesC); + + IMPORT_C TInt Server(RServer2& aServer); + + IMPORT_C TInt Create(const TDesC& aConsoleTitle, TSize aSize); + IMPORT_C void Read(TRequestStatus& aStatus); + IMPORT_C void Read(TPckg& aKeyCode, TPckg& aKeyModifiers, TRequestStatus& aStatus); + IMPORT_C void ReadCancel(); + IMPORT_C TInt Write(const TDesC& aDescriptor); + IMPORT_C TInt CursorPos(TPoint& aPos) const; + IMPORT_C TInt SetCursorPosAbs(const TPoint& aPoint); + IMPORT_C TInt SetCursorPosRel(const TPoint& aPoint); + IMPORT_C TInt SetCursorHeight(TInt aPercentage); + IMPORT_C TInt SetTitle(const TDesC& aTitle); + IMPORT_C TInt ClearScreen(); + IMPORT_C TInt ClearToEndOfLine(); + IMPORT_C TInt GetScreenSize(TSize& aSize) const; + IMPORT_C TInt GetKeyCode(TKeyCode& aCode) const; + IMPORT_C TInt GetKeyModifiers(TUint& aModifiers) const; + + IMPORT_C void Create(const TDesC& aConsoleTitle, TSize aSize, TRequestStatus& aStatus); + IMPORT_C void Write(const TDesC& aDescriptor, TRequestStatus& aStatus); + IMPORT_C void CursorPos(TPckg& aPoint, TRequestStatus& aStatus) const; + IMPORT_C void SetCursorPosAbs(const TPoint& aPoint, TRequestStatus& aStatus); + IMPORT_C void SetCursorPosRel(const TPoint& aPoint, TRequestStatus& aStatus); + IMPORT_C void SetCursorHeight(TInt aPercentage, TRequestStatus& aStatus); + IMPORT_C void SetTitle(const TDesC& aTitle, TRequestStatus& aStatus); + IMPORT_C void ClearScreen(TRequestStatus& aStatus); + IMPORT_C void ClearToEndOfLine(TRequestStatus& aStatus); + IMPORT_C void GetScreenSize(TPckg& aSize, TRequestStatus& aStatus) const; + IMPORT_C void SetAttributes(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor, TRequestStatus& aStatus); + IMPORT_C TInt IsConstructed(TBool& aLazy); +private: + TInt DoConnect(TServerParams* aParams, const TDesC& aThreadNameBase, + TInt aStackSize, TInt aHeapMinSize, TInt aHeapMaxSize, + RServer2& aServer, RThread& aServerThread); + }; + +class CConsoleProxy : public CConsoleBase + { +public: + /** + Create a CConsoleBase wrapper around an RConsoleProxy. + + @param aProxySession A connected session. The handle will be duplicated by this class, + so ownership is not transferred. + */ + IMPORT_C static CConsoleProxy* NewL(const RConsoleProxy& aProxySession); + IMPORT_C ~CConsoleProxy(); +public: // from CConsoleBase + IMPORT_C virtual TInt Create(const TDesC &aTitle,TSize aSize); + IMPORT_C virtual void Read(TRequestStatus &aStatus); + IMPORT_C virtual void ReadCancel(); + IMPORT_C virtual void Write(const TDesC &aDes); + IMPORT_C virtual TPoint CursorPos() const; + IMPORT_C virtual void SetCursorPosAbs(const TPoint &aPoint); + IMPORT_C virtual void SetCursorPosRel(const TPoint &aPoint); + IMPORT_C virtual void SetCursorHeight(TInt aPercentage); + IMPORT_C virtual void SetTitle(const TDesC &aTitle); + IMPORT_C virtual void ClearScreen(); + IMPORT_C virtual void ClearToEndOfLine(); + IMPORT_C virtual TSize ScreenSize() const; + IMPORT_C virtual TKeyCode KeyCode() const; + IMPORT_C virtual TUint KeyModifiers() const; +protected: + IMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1); + IMPORT_C CConsoleProxy(); + IMPORT_C void ConstructL(const RConsoleProxy& aProxySession); +protected: + RConsoleProxy iConsole; + TKeyCode iKeyCode; + TUint iKeyModifiers; + TPckg iKeyCodePckg; + TPckg iKeyModifiersPckg; + }; + +class CConsoleProxySession; + +class MProxiedConsole + { +public: + IMPORT_C static MProxiedConsole* DefaultL(CConsoleBase* aConsole); +public: + virtual void Open() = 0; + virtual void Close() = 0; + virtual CConsoleBase* Console() = 0; + virtual void Read(CConsoleProxySession& aSession) = 0; + virtual void ReadCancel() = 0; + }; + +class TConsoleProxyServerNewLParams + { +public: + TConsoleProxyServerNewLParams(const TDesC& aName, TInt aAoPriority, TConsoleCreateFunction aConsoleCreate = NULL) + : iName(aName), iAoPriority(aAoPriority), iConsoleCreate(aConsoleCreate) {} +public: + const TDesC& iName; + TInt iAoPriority; + TConsoleCreateFunction iConsoleCreate; + }; + +class CShutdownTimer; + +class CConsoleProxyServer : public CServer2 + { +public: + static CConsoleProxyServer* NewL(TAny* aParams); // aParams is TConsoleProxyServerNewLParams* + IMPORT_C static CConsoleProxyServer* NewL(const TDesC& aName, TInt aAoPriority, TConsoleCreateFunction aConsoleCreate = NULL); + + IMPORT_C virtual ~CConsoleProxyServer(); + + void AddSession(); + void DropSession(); +protected: + IMPORT_C CConsoleProxyServer(TConsoleCreateFunction aConsoleCreate, TInt aAoPriority); + IMPORT_C void ConstructL(const TDesC& aName); + + /** + Called after a timeout when + - no session connects to the server after startup + - the last session disconnects + and stops the active scheduler. Can be over-ridden to change the behaviour in these cases. + */ + IMPORT_C virtual void ShutdownTimerExpired(); + + // from CServer2: + IMPORT_C virtual CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const; +protected: + TConsoleCreateFunction iConsoleCreate; +private: + TInt iSessionCount; + CShutdownTimer* iShutdownTimer; + friend class CShutdownTimer; + }; + +class CConsoleProxySession : public CSession2 + { +public: + IMPORT_C CConsoleProxySession(TConsoleCreateFunction aConsoleCreate); + IMPORT_C CConsoleProxySession(MProxiedConsole* aConsole); + IMPORT_C virtual ~CConsoleProxySession(); + + CConsoleProxyServer* Server() { return (CConsoleProxyServer*)CSession2::Server();} + + + // from CSession2: + IMPORT_C virtual void ServiceL(const RMessage2& aMessage); + IMPORT_C virtual void CreateL(); + + // callback from from MProxiedConsole: + IMPORT_C void ReadComplete(TInt aStatus); +protected: + /** + Creates the console using the given title and size. The console must not already have + been created. + */ + IMPORT_C void DoCreateL(const TDesC& aTitle, const TSize& aSize); + /** + Instantiate the CConsoleBase class, but don't call Create() on it; return it wrapped up + inside a MProxiedConsole derived class. + */ + IMPORT_C virtual MProxiedConsole* InstantiateConsoleL(); + /** + Called just after a console has been successfully Create()'d, to perform any extra + configuration necessary. Default implementation does nothing. + + Note, iConsole will not have been set yet. If this leaves, it causes construction + of the console to fail. + */ + IMPORT_C virtual void ConsoleCreatedL(MProxiedConsole* aConsole); +private: + void CreateL(const RMessage2& aMessage); +protected: + TConsoleCreateFunction iConsoleCreate; + MProxiedConsole* iConsole; + RMessagePtr2 iReadMessage; + enum + { + EReadBasic, + EReadKeys, + } iReadType; + TKeyCode iKeyCode; + TUint iKeyModifiers; + }; + + + + +#endif //__CONSOLEPROXY_H__