MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/graphics/windowing/windowserver/nga/CLIENT/CLIENT.H
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 1999-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Window server client side local header file

    15 // 

    16 //

    17 

    18 #ifndef __CLIENT_H__

    19 #define __CLIENT_H__

    20 

    21 #include <e32hashtab.h>

    22 

    23 #if defined(_DEBUG) && defined(__WINS__)

    24 //#define __AUTO_FLUSH		//Define this for test purposes only, it hard codes auto flushing

    25 #endif

    26 

    27 /** Panics the client. This will result in the client thread being destroyed. */ 

    28 GLREF_C void Panic(TW32Panic aPanic); 

    29 GLREF_C void Assert(TW32Assert aPanic); 

    30 

    31 class TReadDescriptorType;

    32 class TWriteDescriptorType;

    33 

    34 class RWsBuffer

    35 	{

    36 	friend class RWsSession;

    37 public:

    38 	enum bufferSizes

    39 		{

    40 		EDefBufferSize=EClientBufferSize,

    41 		EMinBufferSize=EClientBufferSize,

    42 		EMaxBufferSize=EClientBufferMaxSize

    43 		};

    44 public:

    45 	RWsBuffer(RWsSession *aSession);

    46 	void Close();

    47 	void Destroy();

    48 	TInt Open();

    49 	TInt Connect(TUint32 handle);

    50 	TInt WriteReplyWs(TUint opcode);

    51 	TInt WriteReplyWs(const TAny *pData, TInt length,TUint opcode);

    52 	TInt WriteReplyWs(const TAny *pData, TInt length, const TAny *pData2, TInt length2, TUint opcode);

    53 	void SetBufferSizeL(TInt aBufSize);

    54 	void SetMaxBufferSizeL(TInt aMaxBufSize);

    55 	TInt Flush(const TIpcArgs* aIpcArgs=NULL,TBool aRequestFinish=EFalse);

    56 	TBool SetAutoFlush(TBool aState);

    57 	void Write(TInt aHandle, TUint aOpcode, const TAny *aData, TInt aLength, const TAny *aData2, TInt aLength2, const TIpcArgs* aIpcArgs=NULL);

    58 	void Write(TInt aHandle, TUint aOpcode, const TAny *aData, TInt aLength, const TIpcArgs* aIpcArgs=NULL);

    59 	void Write(TInt handle,TUint opcode);

    60 	void AppendData(const TAny *aData, TInt aLength, TBool aFinished);

    61 	TInt WriteReply(TInt handle,TUint opcode, const TIpcArgs* aIpcArgs=NULL);

    62 	TInt WriteReply(TInt handle,TUint opcode,const TAny *buf, TInt bufLen, const TIpcArgs* aIpcArgs=NULL);

    63 	TInt WriteReply(TInt handle,TUint opcode,const TAny *buf, TInt bufLen,const TAny *buf2, TInt buflen2, const TIpcArgs* aIpcArgs=NULL);

    64 	TInt WriteReplyP(TInt aHandle,TUint aOpcode,const TWriteDescriptorType& aReplyBuffer);

    65 	TInt WriteReplyP(TInt aHandle,TUint aOpcode,const TAny *aData,TInt aLength,const TWriteDescriptorType& aReplyBuffer);

    66 	TInt WriteReplyP(TInt aHandle,TUint aOpcode,const TAny *aData1,TInt aLengthData1,const TAny *aData2,TInt aLengthData2,const TWriteDescriptorType& aReplyBuffer);

    67 	TInt WriteReplyByProvidingRemoteReadAccess(TInt aHandle,TUint aOpcode,const TAny *aData, TInt aLength,const TReadDescriptorType& aRemoteReadBuffer);

    68 

    69 	inline TInt BufferSize() const;

    70 	inline TBool IsEmpty() const;

    71 	inline RWsSession* Session() {return iSession;}

    72 	static void FlushAllBuffers(TInt aBitmapHandle);

    73 	void SetCallBack();

    74 	void CancelCallBack();

    75 	void AddToBitmapArray(TInt aBitmapHandle);

    76 	

    77 	void SetWsGraphicManager(CWsGraphic::CManager* aManager);

    78 	static CWsGraphic::CManager* WsGraphicManager();

    79 

    80 	void AsyncRequest(TInt aHandle, TUint aOpcode, TRequestStatus& aStatus);

    81 

    82 	void EnableWindowSizeCacheL();

    83 	inline TBool WindowSizeCacheEnabled() const;

    84 	inline void MarkWindowSizeCacheDirty(TInt aHandle);

    85 	inline void RefreshWindowSizeCache(TInt aHandle, const TSize& aNewSize);

    86 	inline TInt CachedWindowSize(TInt aHandle, TSize& aSize);

    87 	inline void DestroyWindowSizeCacheEntry(TInt aHandle);	

    88     

    89 private:

    90 	TInt DoWrite(TInt aHandle, TUint aOpcode, TBool aFlush, const TIpcArgs* aIpcArgs, const TAny* aData1=NULL, TInt aLength1=0, const TAny* aData2=NULL, TInt aLength2=0);

    91 	inline void SetAndLimitMaxBufSize(TInt aMaxBufSize);

    92 	void ReAllocBufferL(TInt aNewSize);

    93 	TBool ReAllocBuffer(TInt aNewSize);

    94 	void GrowBuffer(TInt aRequiredSpace, TInt aMsgSize);

    95 

    96 private:

    97 	RWsSession *iSession;

    98 	CWsGraphic::CManager* iManager;

    99 	TBool iAutoFlush;

   100 	TPtr8 iBuf;

   101 	RWsBuffer *iNext;

   102 	TInt iPreviousHandle;

   103 	TInt iBufSize;				// current buffer size, DoWrite can expand this up to iMaxBufize

   104 	TInt iMaxBufSize;			// maximum buffer size, set by SetBufferSizeL or SetMaxBufferSizeL

   105 #if defined(_DEBUG)

   106 	TInt iAppendDataLength;

   107 #endif

   108 private:		//Added here as adding it to RWsSession breaks BC.

   109 	TInt iDirectAcessCount;

   110 	RArray<TInt> iBitmapArray;

   111 	TBool iInvalidBitmapArray;

   112 

   113 	class TWindowSizeCacheEntry

   114 	    {

   115 	public:

   116 	    inline TWindowSizeCacheEntry(const TSize& aSize);

   117 	public:

   118 	    TSize iSize;

   119 	    TBool iDirty;

   120 	    };

   121 	

   122 	RHashMap<TInt, TWindowSizeCacheEntry>* iWindowSizeCache;

   123 	};

   124 

   125 

   126 inline TInt RWsBuffer::BufferSize() const

   127 	{return(iBuf.MaxLength());}

   128 

   129 inline TBool RWsBuffer::IsEmpty() const

   130 	{return iBuf.Length()==0;}

   131 

   132 inline RWsBuffer::TWindowSizeCacheEntry::TWindowSizeCacheEntry(const TSize& aSize)

   133     : iSize(aSize), iDirty(EFalse)

   134     {

   135     }

   136 

   137 inline TBool RWsBuffer::WindowSizeCacheEnabled() const

   138     {

   139     return iWindowSizeCache ? ETrue : EFalse;

   140     }

   141 

   142 inline void RWsBuffer::MarkWindowSizeCacheDirty(TInt aHandle)

   143     {

   144     __ASSERT_ALWAYS(iWindowSizeCache != NULL, Assert(EW32AssertWindowSizeCacheFailure));

   145     RWsBuffer::TWindowSizeCacheEntry* entry = iWindowSizeCache->Find(aHandle);

   146     if (entry != NULL)

   147         {

   148         entry->iDirty = ETrue;

   149         }

   150     }

   151 

   152 inline void RWsBuffer::RefreshWindowSizeCache(TInt aHandle, const TSize& aNewSize)

   153     {

   154     __ASSERT_ALWAYS(iWindowSizeCache != NULL, Assert(EW32AssertWindowSizeCacheFailure));

   155     RWsBuffer::TWindowSizeCacheEntry* entry = iWindowSizeCache->Find(aHandle);

   156     if (entry == NULL)

   157         {

   158         iWindowSizeCache->Insert(aHandle, RWsBuffer::TWindowSizeCacheEntry(aNewSize));

   159         }

   160     else

   161         {

   162         entry->iSize = aNewSize;

   163         entry->iDirty = EFalse;

   164         }

   165     }

   166 

   167 inline TInt RWsBuffer::CachedWindowSize(TInt aHandle, TSize& aSize)

   168     {

   169     __ASSERT_ALWAYS(iWindowSizeCache != NULL, Assert(EW32AssertWindowSizeCacheFailure));

   170     RWsBuffer::TWindowSizeCacheEntry* entry = iWindowSizeCache->Find(aHandle);

   171     if ( entry && !(entry->iDirty) )

   172         {

   173         aSize = entry->iSize;

   174         return KErrNone;

   175         }

   176     else

   177         {

   178         // return KErrNotFound when either entry not found for aHandle, or entry is dirty

   179         return KErrNotFound;

   180         }

   181     }

   182 

   183 inline void RWsBuffer::DestroyWindowSizeCacheEntry(TInt aHandle)

   184     {

   185     __ASSERT_ALWAYS(iWindowSizeCache != NULL, Assert(EW32AssertWindowSizeCacheFailure));

   186     TInt err = iWindowSizeCache->Remove(aHandle);

   187     // If there is a window size cache entry, then err == KErrNone.

   188     // Otherwise, there isn't a size cache entry, and err == KErrNotFound.

   189     __ASSERT_DEBUG(err == KErrNone || err == KErrNotFound, Assert(EW32AssertWindowSizeCacheFailure));

   190     }

   191 

   192 

   193 #endif
Symaptic