1 // console.h

     2 // 

     3 // Copyright (c) 2006 - 2010 Accenture. All rights reserved.

     4 // This component and the accompanying materials are made available

     5 // under the terms of the "Eclipse Public License v1.0"

     6 // which accompanies this distribution, and is available

     7 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 // 

     9 // Initial Contributors:

    10 // Accenture - Initial contribution

    11 //

    12 

    13 #ifndef __CONSOLE_H__

    14 #define __CONSOLE_H__

    15 

    16 #include <e32base.h>

    17 #include <fshell/consoleproxy.h>

    18 #include "endpoint.h"

    19 #include "readwrite.h"

    20 

    21 class CLazyConsole;

    22 

    23 class RIoConsoleProxy : public RConsoleProxy

    24 	{

    25 public:

    26 	enum TOpCode

    27 		{

    28 		ESetConsoleSizeDetect = RConsoleProxy::EOpCodeCustomBase,

    29 		ESetLazyConstruct,

    30 		ESetConsoleMode,

    31 		ESetUnderlyingConsole,

    32 		EOpenExistingConsole,

    33 		EWriteStdErr,

    34 		};

    35 public:

    36 	TInt SetConsoleSizeDetect();

    37 	TInt SetLazyConstruct();

    38 	void SetConsoleMode(RIoReadWriteHandle::TMode aMode, TRequestStatus& aStatus);

    39 	void SetUnderlyingConsole(const RIoConsoleProxy& aUnderlyingSession, TRequestStatus& aStatus);

    40 	TInt OpenExisting();

    41 	void WriteStdErr(const TDesC& aDescriptor, TRequestStatus& aStatus);

    42 	};

    43 	

    44 class CIoConsole : public CIoEndPoint

    45 	{

    46 public:

    47 	static CIoConsole* NewLC(const TDesC& aImplementation, const TDesC& aTitle, const TSize& aSize, const TIoConfig& aConfig, CIoConsole* aUnderlying, TUint aOptions);

    48 	~CIoConsole();

    49 	const TDesC& Implementation() const;

    50 public: // From CIoObject.

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

    52 public: // From CIoEndPoint.

    53 	virtual void HandleReaderDetached(MIoReader& aReader);

    54 	virtual void HandleWriterDetached(MIoWriter& aWriter);

    55 public: // From MIoReadEndPoint.

    56 	virtual void IorepReadL(MIoReader& aReader);

    57 	virtual void IorepReadKeyL(MIoReader& aReader);

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

    59 public: // From MIoWriteEndPoint.

    60 	virtual void IowepWriteL(MIoWriter& aWriter);

    61 	virtual void IowepWriteCancel(MIoWriter& aWriter);

    62 	virtual void IowepCursorPosL(MIoWriter& aWriter) const;

    63 	virtual void IowepSetCursorPosAbsL(const TPoint& aPoint, MIoWriter& aWriter);

    64 	virtual void IowepSetCursorPosRelL(const TPoint& aPoint, MIoWriter& aWriter);

    65 	virtual void IowepSetCursorHeightL(TInt aPercentage, MIoWriter& aWriter);

    66 	virtual void IowepSetTitleL(MIoWriter& aWriter);

    67 	virtual void IowepClearScreenL(MIoWriter& aWriter);

    68 	virtual void IowepClearToEndOfLineL(MIoWriter& aWriter);

    69 	virtual void IowepScreenSizeL(MIoWriter& aWriter) const;

    70 	virtual void IowepSetAttributesL(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor, MIoWriter& aWriter);

    71 protected:

    72 	CIoConsole(const TIoConfig& aConfig);

    73 private:

    74 	class TConsoleRequest;

    75 private:

    76 	void ConstructL(const TDesC& aImplementation, const TDesC& aTitle, const TSize& aSize, CIoConsole* aUnderlying, TUint aOptions);

    77 	void ReadComplete(TInt aError);

    78 	void ReadComplete(TUint aKeyCode, TUint aModifiers);

    79 	void QueueReaderIfRequired();

    80 	void CreateComplete(TInt aError);

    81 	void NewRequest(TConsoleRequest* aRequest) const;

    82 	void CheckQueue() const;

    83 	void ConsoleDied();

    84 	template <class T> void HandleReadWriterDetached(T& aReadWriter);

    85 private:

    86 	class CConsoleReader : public CActive

    87 		{

    88 	public:

    89 		static CConsoleReader* NewL(CIoConsole& aConsole);

    90 		~CConsoleReader();

    91 		void QueueRead();

    92 	private:

    93 		CConsoleReader(CIoConsole& aConsole);

    94 	private: // From CActive.

    95 		virtual void RunL();

    96 		virtual void DoCancel();

    97 	private:

    98 		CIoConsole& iConsole;

    99 		TKeyCode iKeyCode;

   100 		TUint iKeyModifiers;

   101 		TPckg<TKeyCode> iKeyCodePckg;

   102 		TPckg<TUint> iKeyModifiersPckg;

   103 		};

   104 		

   105 	class TConsoleRequest

   106 		{

   107 	public:

   108 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus) = 0;

   109 		virtual void PrepareL();

   110 		virtual void CompleteD(TInt aError) = 0;

   111 		virtual TBool OriginatedFrom(MIoReader& aReader) const;

   112 		virtual TBool OriginatedFrom(MIoWriter& aWriter) const;

   113 		};

   114 	

   115 	class TConsoleWriterRequest : public TConsoleRequest

   116 		{

   117 	protected:

   118 		TConsoleWriterRequest(MIoWriter& aWriter);

   119 	private: // From TConsoleRequest.

   120 		virtual TBool OriginatedFrom(MIoWriter& aWriter) const;

   121 	protected:

   122 		MIoWriter& iWriter;

   123 		};

   124 	

   125 	class TConsoleReaderRequest : public TConsoleRequest

   126 		{

   127 	protected:

   128 		TConsoleReaderRequest(MIoReader& aReader);

   129 	private: // From TConsoleRequest.

   130 		virtual TBool OriginatedFrom(MIoReader& aReader) const;

   131 	protected:

   132 		MIoReader& iReader;

   133 		};

   134 	

   135 	class TConsoleCreateRequest : public TConsoleRequest

   136 		{

   137 	public:

   138 		TConsoleCreateRequest(CIoConsole& aOwner);

   139 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   140 		virtual void CompleteD(TInt aError);

   141 	private:

   142 		CIoConsole& iOwner;

   143 		};

   144 	

   145 	class TConsoleWriteRequest : public TConsoleWriterRequest

   146 		{

   147 	public:

   148 		TConsoleWriteRequest(MIoWriter& aWriter);

   149 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   150 		virtual void PrepareL();

   151 		virtual void CompleteD(TInt aError);

   152 	private:

   153 		HBufC* iBuf;

   154 		};

   155 	

   156 	class TConsoleCursorPosRequest : public TConsoleWriterRequest

   157 		{

   158 	public:

   159 		TConsoleCursorPosRequest(MIoWriter& aWriter);

   160 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   161 		virtual void CompleteD(TInt aError);

   162 	private:

   163 		TPoint iPos;

   164 		TPckg<TPoint> iPosPckg;

   165 		};

   166 		

   167 	class TConsoleSetCursorPosAbsRequest : public TConsoleWriterRequest

   168 		{

   169 	public:

   170 		TConsoleSetCursorPosAbsRequest(MIoWriter& aWriter, const TPoint& aPoint);

   171 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   172 		virtual void CompleteD(TInt aError);

   173 	private:

   174 		TPoint iPoint;

   175 		};

   176 		

   177 	class TConsoleSetCursorPosRelRequest : public TConsoleWriterRequest

   178 		{

   179 	public:

   180 		TConsoleSetCursorPosRelRequest(MIoWriter& aWriter, const TPoint& aPoint);

   181 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   182 		virtual void CompleteD(TInt aError);

   183 	private:

   184 		TPoint iPoint;

   185 		};

   186 	

   187 	class TConsoleSetCursorHeightRequest : public TConsoleWriterRequest

   188 		{

   189 	public:

   190 		TConsoleSetCursorHeightRequest(MIoWriter& aWriter, TInt aHeight);

   191 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   192 		virtual void CompleteD(TInt aError);

   193 	private:

   194 		TInt iHeight;

   195 		};

   196 		

   197 	class TConsoleSetTitleRequest : public TConsoleWriterRequest

   198 		{

   199 	public:

   200 		TConsoleSetTitleRequest(MIoWriter& aWriter);

   201 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   202 		virtual void PrepareL();

   203 		virtual void CompleteD(TInt aError);

   204 	private:

   205 		HBufC* iTitle;

   206 		};

   207 		

   208 	class TConsoleClearScreenRequest : public TConsoleWriterRequest

   209 		{

   210 	public:

   211 		TConsoleClearScreenRequest(MIoWriter& aWriter);

   212 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   213 		virtual void CompleteD(TInt aError);

   214 		};

   215 	

   216 	class TConsoleClearToEndOfLineRequest : public TConsoleWriterRequest

   217 		{

   218 	public:

   219 		TConsoleClearToEndOfLineRequest(MIoWriter& aWriter);

   220 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   221 		virtual void CompleteD(TInt aError);

   222 		};

   223 		

   224 	class TConsoleScreenSizeRequest : public TConsoleWriterRequest

   225 		{

   226 	public:

   227 		TConsoleScreenSizeRequest(MIoWriter& aWriter, const TIoConfig& aConfig);

   228 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   229 		virtual void CompleteD(TInt aError);

   230 	private:

   231 		const TIoConfig& iConfig;

   232 		TSize iSize;

   233 		TPckg<TSize> iSizeBuf;

   234 		};

   235 		

   236 	class TConsoleSetAttributesRequest : public TConsoleWriterRequest

   237 		{

   238 	public:

   239 		TConsoleSetAttributesRequest(MIoWriter& aWriter, TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor);

   240 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   241 		virtual void CompleteD(TInt aError);

   242 	private:

   243 		TUint iAttributes;

   244 		ConsoleAttributes::TColor iForegroundColor;

   245 		ConsoleAttributes::TColor iBackgroundColor;

   246 		};

   247 		

   248 	class TConsoleSetUnderlyingRequest : public TConsoleRequest

   249 		{

   250 	public:

   251 		TConsoleSetUnderlyingRequest(CIoConsole& aUnderlyingConsole);

   252 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   253 		virtual void PrepareL();

   254 		virtual void CompleteD(TInt aError);

   255 	private:

   256 		CIoConsole& iConsole;

   257 		RIoConsoleProxy iSession;

   258 		};

   259 	friend class TConsoleSetUnderlyingRequest;

   260 	

   261 	class TConsoleSetModeRequest : public TConsoleReaderRequest

   262 		{

   263 	public:

   264 		TConsoleSetModeRequest(MIoReader& aReader, CIoConsole& aConsole, RIoReadWriteHandle::TMode aMode);

   265 		virtual void Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus);

   266 		virtual void CompleteD(TInt aError);

   267 	private:

   268 		CIoConsole& iConsole;

   269 		RIoReadWriteHandle::TMode iMode;

   270 		};

   271 	friend class TConsoleSetModeRequest;

   272 		

   273 	class CConsoleRequest : public CActive

   274 		{

   275 	public:

   276 		CConsoleRequest(CIoConsole& aConsole);

   277 		

   278 		void Service(TConsoleRequest* aRequest);

   279 		~CConsoleRequest();

   280 		const TConsoleRequest* CurrentRequest() const;

   281 		void Abort();

   282 	private:

   283 		void Complete(TConsoleRequest* aRequest, TInt aError);

   284 	private: // from CActive

   285 		virtual void RunL();

   286 		virtual void DoCancel();

   287 	private:

   288 		CIoConsole& iConsole;

   289 		TConsoleRequest* iCurrentRequest;

   290 		};

   291 		

   292 	class CServerDeathWatcher : public CActive

   293 		{

   294 	public:

   295 		CServerDeathWatcher(RServer2& aServer, RThread& aThread);

   296 		~CServerDeathWatcher();

   297 	private:

   298 		virtual void RunL();

   299 		virtual void DoCancel();

   300 	private:

   301 		RServer2& iServer;

   302 		RThread& iThread;

   303 		};

   304 	friend class TConsoleCreateRequest;

   305 	friend class CConsoleRequest;

   306 	friend class CConsoleReader;

   307 	friend class TConsoleDetectSizeRequest;

   308 protected:

   309 	const TIoConfig& iConfig;

   310 	RIoConsoleProxy iConsole;

   311 	CConsoleReader* iReader;

   312 	mutable TSize iDetectedSize;

   313 	mutable TBool iSizeDetected;

   314 	HBufC* iImplementation;

   315 	TSize iCreationSize;

   316 	HBufC* iCreationTitle;

   317 	TInt iCreateStatus;

   318 	mutable RArray<TConsoleRequest*> iRequestQueue;

   319 	CConsoleRequest* iRequestAo;

   320 	RServer2 iThreadServer;

   321 	RThread iServerThread;

   322 	CServerDeathWatcher* iThreadWatcher;

   323 	};

   324 	

   325 class CIoConsoleProxyServer : public CConsoleProxyServer

   326 	{

   327 public:

   328 	static CIoConsoleProxyServer* NewL(TConsoleCreateFunction aConsoleCreate, RLibrary& aConsoleLibrary);

   329 	virtual CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;

   330 	~CIoConsoleProxyServer();

   331 	MProxiedConsole* TheConsole() const;

   332 	void SetTheConsole(MProxiedConsole* aConsole);

   333 private:

   334 	CIoConsoleProxyServer(TConsoleCreateFunction aConsoleCreate, const RLibrary& aConsoleLibrary);

   335 private:

   336 	RLibrary iConsoleLibrary;

   337 	MProxiedConsole* iTheConsole;

   338 	};

   339 

   340 CConsoleProxyServer* CIoConsoleProxyServerNewL(TAny* aParams);

   341 

   342 class CIoConsoleProxySession : public CConsoleProxySession

   343 	{

   344 public:

   345 	CIoConsoleProxySession(TConsoleCreateFunction aConsoleCreate);

   346 	~CIoConsoleProxySession();

   347 public: // from CConsoleProxySession:

   348 	virtual void ServiceL(const RMessage2& aMessage);

   349 	virtual MProxiedConsole* InstantiateConsoleL();

   350 	virtual void ConsoleCreatedL(MProxiedConsole* aConsole);

   351 private:

   352 	enum TFlag

   353 		{

   354 		ELazy				= 0x01,

   355 		EAutoDetectSize		= 0x02,

   356 		ESupportsStdErr		= 0x04,

   357 		};

   358 private:

   359 	CIoConsoleProxyServer* Server() { return (CIoConsoleProxyServer*)CConsoleProxySession::Server();}

   360 	void DetectSizeL(const RMessage2& aMessage);

   361 	void SetModeL(const RMessage2& aMessage);

   362 	void SetUnderlyingConsoleL(const RMessage2& aMessage);

   363 	void OpenExistingL(const RMessage2& aMessage);

   364 	

   365 	TBool GetFlag(TFlag aFlag);

   366 	void SetFlag(TFlag aFlag, TBool aSet);

   367 private:

   368 	CConsoleProxy* iUnderlyingConsole;

   369 	TUint iFlags;

   370 	TSize iDetectedSize;

   371 	};

   372 	

   373 class CWriteOnlyConsoleProxy : public CConsoleProxy

   374 	{

   375 public:

   376 	static CConsoleProxy* NewL(const RConsoleProxy& aProxySession);

   377 public: // from CConsoleProxy:

   378 	virtual void Read(TRequestStatus &aStatus);

   379 	virtual void ReadCancel();

   380 	virtual TKeyCode KeyCode() const;

   381 	virtual TUint KeyModifiers() const;

   382 private:

   383 	CWriteOnlyConsoleProxy();

   384 	};

   385 	

   386 class CLazyConsole : public CConsoleBase

   387 	{

   388 public:

   389 	CLazyConsole(TConsoleCreateFunction aConsoleCreate, TBool aAutoDetectSize);

   390 	~CLazyConsole();

   391 public: // from CConsoleBase

   392 	virtual TInt Create(const TDesC &aTitle,TSize aSize);

   393 	virtual void Read(TRequestStatus &aStatus);

   394 	virtual void ReadCancel();

   395 	virtual void Write(const TDesC &aDes);

   396 	virtual TPoint CursorPos() const;

   397 	virtual void SetCursorPosAbs(const TPoint &aPoint);

   398 	virtual void SetCursorPosRel(const TPoint &aPoint);

   399 	virtual void SetCursorHeight(TInt aPercentage);

   400 	virtual void SetTitle(const TDesC &aTitle);

   401 	virtual void ClearScreen();

   402 	virtual void ClearToEndOfLine();

   403 	virtual TSize ScreenSize() const;

   404 	virtual TKeyCode KeyCode() const;

   405 	virtual TUint KeyModifiers() const;

   406 	virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);

   407 private:

   408 	TInt CheckCreated() const;

   409 private:

   410 	TConsoleCreateFunction iConsoleCreate;

   411 	TBool iSizeAutoDetect;

   412 	RBuf iTitle;

   413 	TSize iSize;

   414 	mutable TSize iDetectedSize;

   415 	mutable TInt iCreateError;

   416 	mutable CConsoleBase* iConsole;

   417 	};

   418 

   419 #endif //__CONSOLE_H__