sl@0: // Copyright (c) 1994-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // RWsBuffer class, handles buffering and flushing of window server commands
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include <e32std.h>
sl@0: #include "../SERVER/w32cmd.h"
sl@0: #include "CLIENT.H"
sl@0: #include "w32comm.h"
sl@0: 
sl@0: // Global functions
sl@0: 
sl@0: GLDEF_C void Assert(TW32Assert aAssert)
sl@0: 	{
sl@0: 	_LIT(KW32AssertCategory,"W32 Assert");
sl@0: 	User::Panic(KW32AssertCategory,aAssert);
sl@0: 	}
sl@0: 
sl@0: GLDEF_C void Panic(TW32Panic aPanic)
sl@0: 	{
sl@0: 	_LIT(KW32PanicCategory,"W32");
sl@0: 	User::Panic(KW32PanicCategory,aPanic);
sl@0: 	}
sl@0: 
sl@0: // Public functions
sl@0: 
sl@0: RWsBuffer::RWsBuffer(RWsSession *aSession) : iSession(aSession), iManager(NULL),
sl@0: 	#if defined(__AUTO_FLUSH)
sl@0: 		iAutoFlush(ETrue),
sl@0: 	#else
sl@0: 		iAutoFlush(EFalse),
sl@0: 	#endif
sl@0: 	iBuf(NULL,0,0), iNext(NULL), iPreviousHandle(0), iBufSize(0), iMaxBufSize(EMinBufferSize),
sl@0: 	#if defined(_DEBUG)
sl@0: 	iAppendDataLength(0),
sl@0: 	#endif
sl@0: 	iDirectAcessCount(0), iInvalidBitmapArray(EFalse), iWindowSizeCache(NULL)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: TInt WsFbsDestroyCallBack(TAny* aBitmapHandle)
sl@0: 	{
sl@0: 	TInt* bitmapHandle=static_cast<TInt*>(aBitmapHandle);
sl@0: 	RWsBuffer::FlushAllBuffers(aBitmapHandle ? *bitmapHandle : 0);
sl@0: 
sl@0: 	return(0);
sl@0: 	}
sl@0: 
sl@0: void RWsBuffer::SetCallBack()
sl@0: 	{
sl@0: 	for(RWsBuffer *buffer=(RWsBuffer *)Dll::Tls();buffer;buffer=buffer->iNext)
sl@0: 		if (buffer==this)
sl@0: 			return;	// Already linked
sl@0: 	iNext=(RWsBuffer *)Dll::Tls();
sl@0: 	Dll::SetTls(this);
sl@0: 	if (iNext==NULL)	// First connection so set callback
sl@0: 		RFbsSession::GetSession()->SetCallBack(TCallBack(WsFbsDestroyCallBack,NULL));
sl@0: 	}
sl@0: 
sl@0: void RWsBuffer::CancelCallBack()
sl@0: 	{
sl@0: 	RWsBuffer *buffer=(RWsBuffer *)Dll::Tls();
sl@0: 	if (buffer==this)
sl@0: 		{
sl@0: 		Dll::SetTls(iNext);
sl@0: 		if (iNext==NULL)
sl@0: 			RFbsSession::GetSession()->ResetCallBack();	// Last connection closing so cancel the callback
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		RWsBuffer *prev;
sl@0: 		while(buffer)
sl@0: 			{
sl@0: 			prev=buffer;
sl@0: 			buffer=buffer->iNext;
sl@0: 			if (buffer==this)
sl@0: 				{
sl@0: 				prev->iNext=iNext;
sl@0: 				break;
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void RWsBuffer::Close()
sl@0: 	{
sl@0: 	User::Free((TAny *)iBuf.Ptr());
sl@0: 	if (iWindowSizeCache)
sl@0: 	    {
sl@0: 	    iWindowSizeCache->Close();
sl@0: 	    delete iWindowSizeCache;
sl@0: 	    iWindowSizeCache = NULL;
sl@0: 	    }
sl@0: 	}
sl@0: 
sl@0: void RWsBuffer::Destroy()
sl@0: 	{
sl@0: 	Flush();
sl@0: 	Close();
sl@0: 	delete this;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: TInt RWsBuffer::Flush(const TIpcArgs* aIpcArgs,TBool aRequestFinish)
sl@0: 	{
sl@0: 	iBitmapArray.Reset();
sl@0: 	iInvalidBitmapArray=EFalse;
sl@0: 	if (iBuf.Length()==0)
sl@0: 		{
sl@0: 		return(KErrNone);
sl@0: 		}
sl@0: 	TIpcArgs ipcArgs;
sl@0: 	if (aIpcArgs!=NULL)
sl@0: 		{
sl@0: 		ipcArgs=*aIpcArgs;
sl@0: 		// check that the caller hasn't used the first slot
sl@0: 		ipcArgs.Set(KBufferMessageSlot,TIpcArgs::ENothing);
sl@0: 		__ASSERT_ALWAYS(Mem::Compare(REINTERPRET_CAST(const TUint8*, &ipcArgs), sizeof(TIpcArgs), REINTERPRET_CAST(const TUint8*, aIpcArgs), sizeof(TIpcArgs))==0,Panic(EW32PanicUsingReservedIpcSlot));
sl@0: 		}
sl@0: 	ipcArgs.Set(KBufferMessageSlot,&iBuf);
sl@0: 	TInt ret;
sl@0: 	if(aRequestFinish)
sl@0: 		ret=iSession->DoFlush(ipcArgs);
sl@0: 	else
sl@0: 		ret=iSession->DoSyncMsgBuf(ipcArgs);
sl@0: 	iBuf.Zero();
sl@0: 	iPreviousHandle=0;
sl@0: 	return(ret);
sl@0: 	}
sl@0: 
sl@0: void RWsBuffer::FlushAllBuffers(TInt aBitmapHandle)
sl@0: 	{
sl@0: 	for(RWsBuffer *buffer=(RWsBuffer *)Dll::Tls();buffer;buffer=buffer->iNext)
sl@0: 		{
sl@0: 		if(!aBitmapHandle || buffer->iInvalidBitmapArray || (buffer->iBitmapArray.FindInOrder(aBitmapHandle)!=KErrNotFound))
sl@0: 
sl@0: 			buffer->Flush();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: inline void RWsBuffer::SetAndLimitMaxBufSize(TInt aMaxBufSize)
sl@0: 	{ // apply upper & lower limits to input buffer size
sl@0: 	if (aMaxBufSize < EMinBufferSize)
sl@0: 		{
sl@0: 		iMaxBufSize = EMinBufferSize;
sl@0: 		}
sl@0: 	else if	(aMaxBufSize > EMaxBufferSize)
sl@0: 		{
sl@0: 		iMaxBufSize = EMaxBufferSize;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iMaxBufSize = aMaxBufSize;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void RWsBuffer::SetBufferSizeL(TInt aBufSize)
sl@0: 	{
sl@0: 	SetAndLimitMaxBufSize(aBufSize);
sl@0: 	ReAllocBufferL(iMaxBufSize);
sl@0: 	}
sl@0: 
sl@0: void RWsBuffer::SetMaxBufferSizeL(TInt aMaxBufSize)
sl@0: 	{
sl@0: 	SetAndLimitMaxBufSize(aMaxBufSize);
sl@0: 
sl@0: 	if (iMaxBufSize < iBufSize)
sl@0: 		{ // shrink to new maximum
sl@0: 		ReAllocBufferL(iMaxBufSize);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		 // initial allocation should be (at least) a quarter of the requested size
sl@0: 		TInt minSize = Max( (iMaxBufSize + 3) >> 2, EMinBufferSize);
sl@0: 		if (minSize > iBufSize)
sl@0: 			{ // new or enlarged buffer
sl@0: 			ReAllocBufferL(minSize);
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	__ASSERT_DEBUG((iBufSize >= EMinBufferSize) && (iBufSize <= iMaxBufSize), Assert(EW32AssertBufferLogic));
sl@0: 	}
sl@0: 
sl@0: // Flush() buffer, try to ReAlloc, Leave if the ReAlloc fails.
sl@0: void RWsBuffer::ReAllocBufferL(TInt aNewSize)
sl@0: 	{
sl@0: 	if (aNewSize != iBufSize)
sl@0: 		{
sl@0: 		Flush();
sl@0: 		if (!ReAllocBuffer(aNewSize))
sl@0: 			{
sl@0: 			User::LeaveNoMemory();
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TBool RWsBuffer::ReAllocBuffer(TInt aNewSize)
sl@0: 	{
sl@0: 	TUint8* ptr = const_cast<TUint8*>(iBuf.Ptr());
sl@0: 	__ASSERT_DEBUG((iBufSize == 0) || (ptr != NULL), Assert(EW32AssertBufferLogic));
sl@0: 	const TInt len = iBuf.Length();
sl@0: 	TUint8* newPtr = static_cast<TUint8*>(User::ReAlloc(ptr, aNewSize));
sl@0: 	if (newPtr != NULL)
sl@0: 		{ // realloc was successful
sl@0: 		iBuf.Set(newPtr, len, aNewSize);
sl@0: 		iBufSize = aNewSize;
sl@0: 		return ETrue;
sl@0: 		}
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 
sl@0: /* Expand the buffer, to allow new drawing command to fit.
sl@0:  
sl@0:  Called either when trying to store additional commands to queue for Wserv, or
sl@0:  the trying to send a command bigger than the current buffer size.
sl@0: 
sl@0:  Failure to expand the buffer is a minor problem in the first case but a big 
sl@0:  problem in the second.
sl@0: 
sl@0:  @param aRequiredSpace Size of buffer increase required.
sl@0:  @param aMsgSize If expanding the buffer fails then needs this value to know whether Flush() is good enough.
sl@0:  @return ETrue if there is enough space, EFalse if not.
sl@0:  */
sl@0: void RWsBuffer::GrowBuffer(TInt aRequiredSpace, TInt aMsgSize)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(iBufSize < iMaxBufSize, Assert(EW32AssertBufferLogic));
sl@0: 	// maximum size will be big enough?
sl@0: 	__ASSERT_ALWAYS(aMsgSize <= iMaxBufSize, Panic(EW32PanicDataExceedsBufferLength));
sl@0: 	
sl@0: 	 // double or quad the current size, then limit it
sl@0: 	TInt newSize = Min((iBufSize >= aRequiredSpace) ? iBufSize << 1 : iBufSize << 2, iMaxBufSize);
sl@0: 
sl@0: 	if (!ReAllocBuffer(newSize))
sl@0: 		{ // OOM error
sl@0: 		Flush();
sl@0: 		if (aMsgSize > iBufSize)
sl@0: 			{ // message is too big for buffer
sl@0: 			Panic(EW32PanicDataExceedsBufferLength);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: TBool RWsBuffer::SetAutoFlush(TBool aState)
sl@0: 	{
sl@0: 	TBool old;
sl@0: 
sl@0: 	old=iAutoFlush;
sl@0: #if defined(__AUTO_FLUSH)
sl@0: 	if (aState)
sl@0: #else
sl@0: 	iAutoFlush=aState;
sl@0: 	if (iAutoFlush)
sl@0: #endif
sl@0: 		Flush();
sl@0: 	return(old);
sl@0: 	}
sl@0: 
sl@0: TInt RWsBuffer::DoWrite(TInt aHandle, TUint aOpcode, TBool aFlush, const TIpcArgs* aIpcArgs, const TAny* aData, TInt aLength, const TAny* aData2, TInt aLength2)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(((TUint32) aOpcode) < 0x8000, Assert(EW32AssertIllegalOpcode));
sl@0: 	__ASSERT_DEBUG((aLength&0x3) == 0, Assert(EW32AssertOddLengthData));
sl@0: 	TInt xtra(0);
sl@0: 	if (aLength2>0)
sl@0: 		xtra = PadValue(aLength2);		// Round data upto a multiple of 4
sl@0: 
sl@0: 	const TInt msgSize = aLength + aLength2 + xtra + static_cast<TInt>(sizeof(TWsCmdHeader));
sl@0: 	TInt available = iBuf.MaxLength() - iBuf.Length();
sl@0: 	if (msgSize > available)
sl@0: 		{
sl@0: 		if (iBufSize >= iMaxBufSize)
sl@0: 			{ // buffer is maximum size already
sl@0: 			Flush();
sl@0: 			}
sl@0: 		else
sl@0: 			{ // try to grow buffer
sl@0: 			 if ( (iBuf.Length() + msgSize) > iMaxBufSize)
sl@0: 				{ // growing alone will not make enough extra space
sl@0: 				Flush();
sl@0: 				available = iBufSize;
sl@0: 				}
sl@0: 
sl@0: 			const TInt requiredSpace = msgSize - available;
sl@0: 			if (requiredSpace > 0)
sl@0: 				{
sl@0: 				GrowBuffer(requiredSpace, msgSize);
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	TWsCmdHeader cmdHeader;
sl@0: 	cmdHeader.iBase.iOpcode = (TInt16)aOpcode;
sl@0: 	cmdHeader.iBase.iCmdLength = (TInt16)(aLength + aLength2 + xtra);
sl@0: 
sl@0: 	// For performance reasons we only pass in the handle if it is different
sl@0: 	// from the previous command
sl@0: 	if (aHandle == iPreviousHandle)
sl@0: 		{
sl@0: 		iBuf.Append((TUint8 *)&cmdHeader.iBase,sizeof(cmdHeader.iBase));
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iPreviousHandle = aHandle;
sl@0: 		cmdHeader.iBase.iOpcode|=EWsOpcodeHandle;
sl@0: 		cmdHeader.iDestHandle = aHandle;
sl@0: 		iBuf.Append((TUint8 *)&cmdHeader,sizeof(cmdHeader));
sl@0: 		}
sl@0: 
sl@0: 	if (aLength)
sl@0: 		{
sl@0: 		iBuf.Append((TUint8 *)aData, aLength);
sl@0: 		}
sl@0: 	if (aLength2>0 && aData2!=NULL)
sl@0: 		{
sl@0: 		iBuf.Append((TUint8 *)aData2, aLength2);
sl@0: 		iBuf.AppendFill(0,xtra);
sl@0: 		}
sl@0: #if defined(_DEBUG)
sl@0: 	else if (aLength2>0 && aData2==NULL)
sl@0: 		{
sl@0: 		iAppendDataLength = aLength2;
sl@0: 		}
sl@0: #endif
sl@0: 	if (aFlush)
sl@0: 		{
sl@0: 		return Flush(aIpcArgs);
sl@0: 		}
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: void RWsBuffer::Write(TInt handle,TUint opcode)
sl@0: 	{
sl@0: 	DoWrite(handle, opcode, iAutoFlush, NULL);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Writes data sent in aData of length aLength1 for the specifed aOpcode
sl@0: into wserv buffer. It also takes an TIpcArgs by which you can send additional 
sl@0: data. But one thing needs to be noted that if aIpcArgs has some content then 
sl@0: this function flushes the wserv buffer.
sl@0: 
sl@0: @param aHandle aHandle of class derived from MWsClientClass
sl@0: @param aOpcode Opcode for the current command
sl@0: @param aData Data to be added to the buffer
sl@0: @param aLength Length of the data to be added to buffer
sl@0: @param aIpcArgs Additional data sent from client to server. It has default argument NULL.
sl@0: 				And if some data is sent in aIpcArgs, it flushes wserv buffer
sl@0: */
sl@0: void RWsBuffer::Write(TInt aHandle, TUint aOpcode, const TAny *aData, TInt aLength, const TIpcArgs* aIpcArgs/*=NULL*/)
sl@0: 	{
sl@0: 	TBool flush = (aIpcArgs != NULL ? ETrue : iAutoFlush);	// If aIpcArgs contains data then we do explicit flush
sl@0: 	DoWrite(aHandle, aOpcode, flush, aIpcArgs, aData, aLength);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Writes data sent in aData and aData2 of lengths aLength1 and aLength2 
sl@0: for the specifed aOpcode into wserv buffer. It also takes an TIpcArgs by which 
sl@0: you can send additional data. But one thing needs to be noted that if aIpcArgs 
sl@0: has some content then this function flushes the wserv buffer.
sl@0: 
sl@0: @param aHandle Handle of class derived from MWsClientClass
sl@0: @param aOpcode Opcode for the current command
sl@0: @param aData Data to be added to the buffer
sl@0: @param aLength Length of the data to be added to buffer
sl@0: @param aData2 second Data to be added to the buffer
sl@0: @param aLength2 Length of the second data to be added to buffer
sl@0: @param aIpcArgs Additional data sent from client to server. It has default argument NULL.
sl@0: 				And if some data is sent in aIpcArgs, it flushes wserv buffer
sl@0: */
sl@0: void RWsBuffer::Write(TInt aHandle, TUint aOpcode, const TAny *aData, TInt aLength, const TAny *aData2, TInt aLength2, const TIpcArgs* aIpcArgs/*=NULL*/)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(!((aIpcArgs != NULL) &&  (aLength2 > 0 && aData2 == NULL)), Assert(EW32AssertBufferLogic));
sl@0: 	TBool flush = iAutoFlush;
sl@0: 	if (aLength2 > 0 && aData2 == NULL)
sl@0: 		{
sl@0: 		flush = EFalse;		// if just length2 is sent then we should not flush
sl@0: 		}
sl@0: 	else if (aIpcArgs != NULL)
sl@0: 		{
sl@0: 		flush = ETrue;		// If aIpcArgs contains data then we do explicit flush
sl@0: 		}
sl@0: 	DoWrite(aHandle, aOpcode, flush, aIpcArgs, aData, aLength, aData2, aLength2);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Appends data directly to wserv buffer for the current command. So this function 
sl@0: should be used after adding the current command. 
sl@0: 
sl@0: @param aData Data to be added to the buffer
sl@0: @param aLength Length of the data to be added to buffer. Make sure that its length
sl@0: 		is less than availabe buffer.
sl@0: @param aFinished EFalse, adds data to buffer and disables flushing even if auto flush is on, 
sl@0: 				 basically this notfies that more data is pending to be added.
sl@0: 				 ETrue, adds data to buffer and resume normal service for flushing
sl@0: 				 ie. Signals that this is the last bit of data to be added
sl@0: 
sl@0: Note: When data is added using this API, it pads out buffer to multiple of 4 bytes  
sl@0: */
sl@0: void RWsBuffer::AppendData(const TAny *aData,TInt aLength,TBool aFinished)
sl@0: 	{
sl@0: 	__ASSERT_ALWAYS(iBuf.MaxLength()-iBuf.Length()>=PaddedValue(aLength),Assert(EW32AssertBufferLogic));
sl@0: #if defined(_DEBUG)
sl@0: 	// Check if this function is called only after setting iAppendDataLength
sl@0: 	__ASSERT_DEBUG(iAppendDataLength > 0, Assert(EW32AssertBufferLogic));
sl@0: 	// Check if length passed in is less then iAppendDataLength
sl@0: 	__ASSERT_DEBUG(iAppendDataLength >= aLength, Assert(EW32AssertBufferLogic));
sl@0: 	if (aFinished)
sl@0: 		iAppendDataLength = 0; 
sl@0: 	else
sl@0: 		iAppendDataLength -= aLength;
sl@0: #endif
sl@0: 	iBuf.Append((TUint8*)(aData),aLength);
sl@0: 	iBuf.AppendFill(0,PadValue(iBuf.Length()));		// Padout out buffer to multiple of 4 bytes
sl@0: 	if (aFinished && iAutoFlush)
sl@0: 		Flush(NULL);
sl@0: 	}
sl@0: 
sl@0: TInt RWsBuffer::WriteReply(TInt handle,TUint opcode,const TIpcArgs* aIpcArgs)
sl@0: 	{
sl@0: 	return DoWrite(handle, opcode, ETrue, aIpcArgs);
sl@0: 	}
sl@0: 
sl@0: TInt RWsBuffer::WriteReply(TInt handle,TUint opcode,const TAny *pData, TInt length,const TIpcArgs* aIpcArgs)
sl@0: 	{
sl@0: 	return DoWrite(handle, opcode, ETrue, aIpcArgs, pData, length);
sl@0: 	}
sl@0: 	
sl@0: TInt RWsBuffer::WriteReply(TInt handle,TUint opcode,const TAny *pData,TInt length,const TAny *pData2,TInt length2,const TIpcArgs* aIpcArgs)
sl@0: 	{
sl@0: 	return DoWrite(handle, opcode, ETrue, aIpcArgs, pData, length, pData2, length2);
sl@0: 	}
sl@0: 
sl@0: TInt RWsBuffer::WriteReplyP(TInt aHandle, TUint aOpcode, const TWriteDescriptorType& aReplyBuffer)
sl@0: 	{
sl@0: 	TIpcArgs ipcArgs;
sl@0: 	aReplyBuffer.SetDescriptorOnIpcArgs(ipcArgs);
sl@0: 	return DoWrite(aHandle, aOpcode, ETrue, &ipcArgs);
sl@0: 	}
sl@0: 
sl@0: TInt RWsBuffer::WriteReplyP(TInt aHandle,TUint aOpcode,const TAny *aData,TInt aLength,const TWriteDescriptorType& aReplyBuffer)
sl@0: 	{
sl@0: 	TIpcArgs ipcArgs;
sl@0: 	aReplyBuffer.SetDescriptorOnIpcArgs(ipcArgs);
sl@0: 	return DoWrite(aHandle, aOpcode, ETrue, &ipcArgs, aData, aLength);
sl@0: 	}
sl@0: 
sl@0: TInt RWsBuffer::WriteReplyP(TInt aHandle,TUint aOpcode,const TAny *aData1,TInt aLengthData1,const TAny *aData2,TInt aLengthData2,const TWriteDescriptorType& aReplyBuffer)
sl@0: 	{
sl@0: 	TIpcArgs ipcArgs;
sl@0: 	aReplyBuffer.SetDescriptorOnIpcArgs(ipcArgs);
sl@0: 	return DoWrite(aHandle, aOpcode, ETrue, &ipcArgs, aData1, aLengthData1, aData2, aLengthData2);
sl@0: 	}
sl@0: 
sl@0: TInt RWsBuffer::WriteReplyWs(TUint opcode)
sl@0: //
sl@0: // Do a WriteReply using the sessions handle
sl@0: //
sl@0: 	{
sl@0: 	return(iSession->WriteReply(opcode));
sl@0: 	}
sl@0: 
sl@0: TInt RWsBuffer::WriteReplyWs(const TAny *pData, TInt aLength, TUint aOpcode)
sl@0: //
sl@0: // Do a WriteReply using the sessions handle
sl@0: //
sl@0: 	{
sl@0: 	return(iSession->WriteReply(pData,aLength,aOpcode));
sl@0: 	}
sl@0: 
sl@0: TInt RWsBuffer::WriteReplyWs(const TAny *pData, TInt aLength, const TAny *pData2, TInt aLength2, TUint aOpcode)
sl@0: //
sl@0: // Do a WriteReply using the sessions handle
sl@0: //
sl@0: 	{
sl@0: 	return(iSession->WriteReply(pData,aLength,pData2,aLength2,aOpcode));
sl@0: 	}
sl@0: 
sl@0: TInt RWsBuffer::WriteReplyByProvidingRemoteReadAccess(TInt aHandle,TUint aOpcode,const TAny *aData, TInt aLength,const TReadDescriptorType& aRemoteReadBuffer)
sl@0: 	{
sl@0: 	TIpcArgs ipcArgs;
sl@0: 	aRemoteReadBuffer.SetDescriptorOnIpcArgs(ipcArgs);
sl@0: 	return DoWrite(aHandle, aOpcode, ETrue, &ipcArgs, aData, aLength);
sl@0: 	}
sl@0: 
sl@0: void RWsBuffer::AddToBitmapArray(TInt aBitmapHandle)
sl@0: 	{
sl@0: 	if(aBitmapHandle && !iInvalidBitmapArray)
sl@0: 		{
sl@0: 		if(iBitmapArray.InsertInOrder(aBitmapHandle)==KErrNoMemory)
sl@0: 
sl@0: 			iInvalidBitmapArray=ETrue;
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: void RWsBuffer::SetWsGraphicManager(CWsGraphic::CManager* aManager)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(!WsGraphicManager(),Panic(EW32PanicGraphicInternal));
sl@0: 	iManager = aManager;
sl@0: 	}
sl@0: 
sl@0: CWsGraphic::CManager* RWsBuffer::WsGraphicManager()
sl@0: 	{
sl@0: 	for(RWsBuffer *buffer=(RWsBuffer *)Dll::Tls();buffer;buffer=buffer->iNext)
sl@0: 		if (buffer->iManager)
sl@0: 			return buffer->iManager;	
sl@0: 	return NULL; // does not yet exist
sl@0: 	}
sl@0: 
sl@0: void RWsBuffer::AsyncRequest(TInt aHandle, TUint aOpcode, TRequestStatus& aStatus)
sl@0: 	{
sl@0: 	aStatus = KRequestPending;
sl@0: 	__ASSERT_DEBUG((aOpcode&EWservMessAsynchronousService)==0, Assert(EW32AssertIllegalOpcode));
sl@0: 	Flush(); 
sl@0: 
sl@0: 	const TInt function = EWservMessAsynchronousService | aOpcode;
sl@0: 	TIpcArgs ipcArgs(aHandle);
sl@0: 
sl@0: 	iSession->SendReceive(function, ipcArgs, aStatus);
sl@0: 	}
sl@0: 
sl@0: void RWsBuffer::EnableWindowSizeCacheL()
sl@0:     {
sl@0:     if (iWindowSizeCache == NULL)
sl@0:         {
sl@0:         iWindowSizeCache = new (ELeave) RHashMap<TInt, TWindowSizeCacheEntry>();        
sl@0:         }
sl@0:     }