// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <kernel/kern_priv.h>

#include <kernel/kernel.h>

#include <winsdef.h>

#include <emulator.h>

#include <pixelformats.h>

#include "gui.h"

#include "display_chan.h"

#define WIN32_LEAN_AND_MEAN

#pragma warning( disable : 4201 ) // nonstandard extension used : nameless struct/union

#include <windows.h>

#pragma warning( default : 4201 ) // nonstandard extension used : nameless struct/union

#ifndef DD_TRACE

#ifdef DD_TRACE_ENABLED

#define DD_TRACE(X) X

#else

#define DD_TRACE(X)

#endif

#endif

DDisplayChannel::DDisplayChannel() :

		iVSync(&DDisplayChannel::VSyncTimerFn, this),

		iVSyncDfc(&DDisplayChannel::VSyncDfcFn, this, Kern::DfcQue0(), KDfcPriority),

		iPostedBuffer((TUint)KBufferNotSet),

		iGetBuffer((TUint)KFirstCompositionBuffer),

		iDisplayStateSpinner(0),

		iVersion(KDisplayChMajorVersionNumber, 

			     KDisplayChMinorVersionNumber, 

			     KDisplayChBuildVersionNumber)

	{

	DD_TRACE(Kern::Printf("DDisplayChannel Creation");)

	}

DDisplayChannel::~DDisplayChannel()

	{

	DD_TRACE(Kern::Printf("DDisplayChannel Destruction");)

	//clean up.

	NKern::ThreadEnterCS();

	Kern::Free(iBuffer);

	NKern::ThreadLeaveCS();

	}

/**

  Second stage constructor called by the kernel's device driver framework.

  This is called in the context of the user thread (client) which requested the creation of a Logical Channel

  (E.g. through a call to RBusLogicalChannel::DoCreate)

  The thread is in a critical section.

  @param aUnit The unit argument supplied by the client to RBusLogicalChannel::DoCreate

  @param aInfo The info argument supplied by the client to RBusLogicalChannel::DoCreate

  @param aVer The version argument supplied by the client to RBusLogicalChannel::DoCreate

  @return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DDisplayChannel::DoCreate(TInt aUnit, const TDesC8* /*aInfo*/, const TVersion& aVer)

	{

	// Check version

	if (!Kern::QueryVersionSupported(iDevice->iVersion, aVer))

		{

		return KErrNotSupported;

		}

	iScreenNumber = aUnit;	/*aUnit?*/

	SetDfcQ(Kern::DfcQue0());

	iMsgQ.Receive();

	// Ask the GUI code to initialize the rest of the object.

	return Kern::HalFunction(EHalGroupEmulator, EEmulatorHalSetDisplayChannel,

			(TAny*)iScreenNumber, this);

	}

void DDisplayChannel::ValidateSpecificInfo(TInt aBytesPerPixel, RDisplayChannel::TOrientationSpecificInfo& aInfo)

	{

	__ASSERT_DEBUG(aInfo.iWidth > 0 && aInfo.iHeight > 0, Panic(EDisplayPanicInvalidDimensions));

	__ASSERT_DEBUG(aInfo.iOffsetBetweenLines > 0, Panic(EDisplayPanicInvalidStride));

	__ASSERT_DEBUG(aInfo.iWidth * aBytesPerPixel <= (TUint)aInfo.iOffsetBetweenLines, Panic(EDisplayPanicInvalidStride));

	//this is just to stop compiler complaining..

	(TAny)aBytesPerPixel;

	(TAny)aInfo;

	}

/**

Finish creating the display channel object.

@param aInfo			Display description object

@param aRotation		Initial rotation

@param aHwnd			Associated window handle

@param aFrameBuffers	Array of one or more pointers to frame buffers

@param aResolution		Initial resolution

@param aTwips           Size in twips

@return	KErrNone if successful, or a system-wide error otherwise.

*/

TInt DDisplayChannel::Initialize(RDisplayChannel::TDisplayInfo& aInfo, 

		                         RDisplayChannel::TDisplayRotation aRotation,

		                         HWND aHwnd, RPointerArray<TAny>& aFrameBuffers, 

		                         RPointerArray<TBufferAddressA>& aChunks,

								 TScreenBuffer& aDsaBuffer,

		                         TSize aResolution, 

		                         TSize aTwips,

		                         const RDisplayChannel::TPixelFormat aPixelFormatArray[],

								 const TInt aPixelFormatArraySize,

								 const RDisplayChannel::TBufferFormat& aBufferFormat)

	{

	__ASSERT_DEBUG(aInfo.iBitsPerPixel >= 12 && aInfo.iBitsPerPixel <= 32, Panic(EDisplayPanicInvalidBitDepth));

	__ASSERT_DEBUG(aInfo.iRefreshRateHz > 0, Panic(EDisplayPanicInvalidRefreshRate));

	__ASSERT_DEBUG(aInfo.iAvailableRotations & aRotation, Panic(EDisplayPanicInvalidRotation));

	__ASSERT_DEBUG(aInfo.iNormal.iWidth == aInfo.iFlipped.iHeight, Panic(EDisplayPanicInvalidDimensions));

	__ASSERT_DEBUG(aInfo.iNormal.iHeight == aInfo.iFlipped.iWidth, Panic(EDisplayPanicInvalidDimensions));

	__ASSERT_DEBUG(aRotation == RDisplayChannel::ERotationNormal ||

					aRotation == RDisplayChannel::ERotation90CW ||

					aRotation == RDisplayChannel::ERotation180 ||

					aRotation == RDisplayChannel::ERotation270CW, Panic(EDisplayPanicInvalidRotation));

	__ASSERT_DEBUG(aFrameBuffers.Count() > 0, Panic(EDisplayPanicInvalidFrameBuffers));

	__ASSERT_DEBUG(aHwnd, Panic(EDisplayPanicInvalidWindowHandle));

	ValidateSpecificInfo((aInfo.iBitsPerPixel > 16) ? 4 : 2, aInfo.iNormal);

	ValidateSpecificInfo((aInfo.iBitsPerPixel > 16) ? 4 : 2, aInfo.iFlipped);

	// aFrameBuffers includes the legacy buffer at index 0.

	iNumCompositionBuffers = aFrameBuffers.Count() - 1;

	iTotalBuffers = KFirstCompositionBuffer + iNumCompositionBuffers;

	iBuffer = (TBufferInfo*)Kern::AllocZ(iTotalBuffers * sizeof(TBufferInfo));

	iChunks = (TBufferAddressA*)Kern::AllocZ(iTotalBuffers * sizeof(TBufferAddressA));

	if (!iBuffer)

		{

		return KErrNoMemory;

		}

	aInfo.iNumCompositionBuffers = iNumCompositionBuffers;

	for (TUint index = 0; index < iNumCompositionBuffers; index++)

		{

		iBuffer[index + KFirstCompositionBuffer].iAddress = aFrameBuffers[index + 1];

		iChunks[index + KFirstCompositionBuffer].iChunk = aChunks[index + 1]->iChunk;

		}

	iChannelInfo = aInfo;

	iDisplayRotation = iCurrentRotation = aRotation;

	iDisplayResolution = iCurrentResolution = aResolution;

	iCurrentTwips = aTwips;

	iHwnd = aHwnd;

	// Ensure the VSync DFC is on the same queue as the message handling.

	iVSyncTicks = NKern::TimerTicks(1000 / aInfo.iRefreshRateHz);

    iVSync.OneShot(iVSyncTicks);

	if (aDsaBuffer.iMemChunks.Count() != 0)

		{	

		iBuffer[KLegacyBuffer].iAddress = aDsaBuffer.iFrameBuffers[0];

		}

	else

		{

		iBuffer[KLegacyBuffer].iAddress = NULL;

		}

	iPixelFormatArray = aPixelFormatArray;

	iPixelFormatArraySize = aPixelFormatArraySize;

	// copy the initial buffer format

	iInitialBufferFormat = aBufferFormat;

	iDisplayBufferFormat = iInitialBufferFormat;

	iCurrentBufferFormat = iDisplayBufferFormat;

	return KErrNone;

	}

/**

Set the address of the legacy buffer. 

@param aAddress			Pointer to the legacy buffer. 

*/

void DDisplayChannel::SetLegacyBuffer(void *aAddress)

	{ 

	iBuffer[KLegacyBuffer].iAddress = aAddress;

	}

/**

Handle a message on this display for the logical channel.

@param aMsg	The message to process. The iValue member of this distinguishes the

		message type:

		iValue == ECloseMsg, channel close message

		iValue == KMaxTInt, a 'DoCancel' message

		iValue >= 0, a 'DoControl' message with function number equal to iValue

		iValue < 0, a 'DoRequest' message with function number equal to ~iValue

*/

void DDisplayChannel::HandleMsg(TMessageBase* aMsg)

	{

	iMsg = (TThreadMessage*)aMsg;

	TInt id = iMsg->iValue;

	TInt r = KErrNone;

    if (id == (TInt)ECloseMsg)

       {

       iVSync.Cancel();

	   iWaitForPostRequest.Complete(KErrCancel);

	   iWaitForDisplayConnect.Complete(KErrCancel);

       if (iBuffer)

	       	{

    		// Unhook display channel from the GUI code if initialized.

    		if (iBuffer[KLegacyBuffer].iAddress)

	       		{

    		      	Kern::HalFunction(EHalGroupEmulator, EEmulatorHalSetDisplayChannel,

	   					(TAny*)iScreenNumber, NULL);

        	   		PostMessage(iHwnd, WMU_SET_DISPLAY_BUFFER, 0, 0);

		      	    InvalidateRect(iHwnd, NULL, FALSE);

    			}

	       	RDisplayChannel::TBufferId index = iTotalBuffers;

    		while (index-- > 0)

	       		{

		          	iBuffer[index].iRequest.Complete(KErrCancel);

        			if (IsUserBuffer(index))

		          		{

        				// Close chunk

		          		if (iBuffer[index].iChunk)

        					{

		              			NKern::ThreadEnterCS();

            					Kern::ChunkClose(iBuffer[index].iChunk);

            					NKern::ThreadLeaveCS();

        					}

				        }

			     }

            }

			iMsg->Complete(KErrNone, EFalse);

			return;

        }

	if (id < 0)

		{

		DoRequest(~id);

		r = KErrNone;

		}

	else

		{

		r = (id == KMaxTInt) ? DoCancel(iMsg->Int0()) : DoControl(id);

		}

	iMsg->Complete(r, (id != ECloseMsg));

	}

/**

Process synchronous 'control' requests. Parameters are in the first two

arguments of iMsg.

*/

TInt DDisplayChannel::DoControl(TInt aFunction)

	{

	DD_TRACE(Kern::Printf(">DDisplayChannel::DoControl fn=%d\n", aFunction);)

	TInt r = KErrNotSupported;

	TPckgBuf<RDisplayChannel::TDisplayInfo> pkg(iChannelInfo);

	switch(aFunction)

		{

		case RDisplayChannel::ECtrlGetDisplayInfo:

			// a1: TDisplayInfo* info [out]

			Kern::KUDesPut(*(TDes8*)iMsg->Ptr0(), pkg); ///*&iChannelInfo*/);

			r = KErrNone;

			break;

		case RDisplayChannel::ECtrlOpen:

			// Everything is done in Construct

			r = KErrNone;

			break;

		case RDisplayChannel::ECtrlClose:

			// Nothing to do?

			r = KErrNone;

			break;

		case RDisplayChannel::ECtrlPostCompositionBuffer:

			// a1: const TRegionFix<KMaxRectangles>* region [in]

			// a2: TPostCount* post count [out]

			r = PostCompositionBuffer(iMsg->Ptr0(), (RDisplayChannel::TPostCount*)iMsg->Ptr1());

			break;

		case RDisplayChannel::ECtrlPostLegacyBuffer:

			// a1: const TRegionFix<KMaxRectangles>* region [in]

			// a2: TPostCount* post count [out]

			r = PostLegacyBuffer(iMsg->Ptr0(), (RDisplayChannel::TPostCount*)iMsg->Ptr1());

			break;

		case RDisplayChannel::ECtrlRegisterUserBuffer:

			// a1: { TInt Chunk handle, TInt offset }* [in]

			// a2: TInt* buffer ID [out]

			{

			__ASSERT_DEBUG(iMsg->Ptr0(), Panic(EDisplayPanicNullArgument));

			TInt arg[2];

			kumemget(arg, iMsg->Ptr0(), sizeof(arg));

			r = RegisterUserBuffer(arg[0], arg[1], (RDisplayChannel::TBufferId*)iMsg->Ptr1());

			}

			break;

		case RDisplayChannel::ECtrlDeregisterUserBuffer:

			// a1: TBufferId* buffer ID [in]

			r = DeregisterUserBuffer((RDisplayChannel::TBufferId*)iMsg->Ptr0());

			break;

		case RDisplayChannel::ECtrlSetRotation:

			// a1: TDisplayRotation* new rotation [in]

			// a2: TBool* display config has changed [out]

			r = SetRotation((RDisplayChannel::TDisplayRotation*)iMsg->Ptr0(), (TBool*)iMsg->Ptr1());

			break;

		case RDisplayChannel::ECtrlCurrentRotation:

			// a1: TDisplayRotation* current rotation [out]

			r = SafePut(iMsg->Ptr0(), &iCurrentRotation, sizeof(iCurrentRotation));

			break;

		case ECloseMsg:

			r = KErrNone;

			break;

	    case RDisplayChannel::ECtrlGetCompositionBufferInfo:

    	    {

    	    TInt arg[2];

    	    TInt index = *((TInt*)(iMsg->Ptr0()));

            r = Kern::MakeHandleAndOpen(iMsg->Client(), iChunks[index + KFirstCompositionBuffer].iChunk);

            if(r >= 0)

                {

	            arg[0] = r;

	            arg[1] = 0;

				SafePut(iMsg->Ptr1(),&arg,(sizeof(TInt)*2));

                r = KErrNone;

                }

             }

    	    break;

    	 // added to v1.0

	    case RDisplayChannel::ECtrlVersion:

			r = SafePut(iMsg->Ptr0(), &iVersion, sizeof(iVersion));

	    	break;

    	//v1_1

	    case RDisplayChannel::ECtrlNumberOfResolutions:

	    	{

	    	r = NumberOfResolutions();

	    	}

	    	break;

	    case RDisplayChannel::ECtrlGetResolutions:

	    	{

	    	r = GetResolutions();

	    	if(r == KErrCorrupt) //Resolution list changed during GetResolutions

	    		{//second go

	    		r = GetResolutions();

	    		}

	    	}

	    	break;

	    case RDisplayChannel::ECtrlSetResolution:

	    	{

	    	r = SetResolution((TSize*)iMsg->Ptr0());

	    	}

	    	break;

	    case RDisplayChannel::ECtrlGetResolution:

	    	{

	    	r = GetResolution((TSize*)iMsg->Ptr0());

	    	}

	    	break;

	    case RDisplayChannel::ECtrlGetTwips:

	    	{

	    	r = GetTwips((TSize*)iMsg->Ptr0());

	    	}

	    	break;

	    case RDisplayChannel::ECtrlNumberOfPixelFormats:

			r = iPixelFormatArraySize;

	    	break;

	    case RDisplayChannel::ECtrlGetPixelFormats:

	    	r = GetPixelFormats();

	    	break;

	    case RDisplayChannel::ECtrlSetBufferFormat:

	    	r = SetBufferFormat((RDisplayChannel::TBufferFormat*)iMsg->Ptr0());

	    	break;

	    case RDisplayChannel::ECtrlGetBufferFormat:

			r = SafePut(iMsg->Ptr0(), &iCurrentBufferFormat, sizeof(iCurrentBufferFormat));

	    	break;

	    case RDisplayChannel::ECtrlNextPlaneOffset:

	    	// we support, for moment only packed pixel formats

	    	r = NextPlaneOffset((RDisplayChannel::TBufferFormat*)iMsg->Ptr0(), NULL);

	    	break;

	    case RDisplayChannel::ECtrlNextLineOffset:

	    	// use the internal current resolution and current rotation

	    	r = NextLineOffset((RDisplayChannel::TBufferFormat*)iMsg->Ptr0(), NULL);

	    	break;

	    case RDisplayChannel::ECtrlNextPlaneOffsetExtended:

	    	// we support, for moment only packed pixel formats

	    	r = NextPlaneOffset((RDisplayChannel::TBufferFormat*)iMsg->Ptr0(),

	    			            (RDisplayChannel::TBufferFormatContext*)iMsg->Ptr1());

	    	break;

	    case RDisplayChannel::ECtrlNextLineOffsetExtended:

	    	r = NextLineOffset((RDisplayChannel::TBufferFormat*)iMsg->Ptr0(),

	    			           (RDisplayChannel::TBufferFormatContext*)iMsg->Ptr1());

	    	break;

		}

	DD_TRACE(Kern::Printf("<DDisplayChannel::DoControl result=%d\n",r);)

	return r;

	}

TInt DDisplayChannel::GetIndexForSize(const TSize& aSize,TInt& aSpinnerOut)

	{

	TInt numberOfResolutions = 0;

	TInt spinner1 = 0;

	TInt r = Kern::HalFunction(EHalGroupDisplay, EDisplayHalNumberOfResolutions, &numberOfResolutions, &spinner1, iScreenNumber);

	if(r < KErrNone)

		return r;

	TVideoInfoV01 info;

	TPckg<TVideoInfoV01> infoPckg(info);

	for (TInt res=0;res<numberOfResolutions;res++)

		{

		//pass info package to be filled in, also sending the config to read, and the screen within that

		Kern::HalFunction(EHalGroupDisplay, EDisplayHalSpecificScreenInfo, (TAny*)&res, (TAny*)&infoPckg, iScreenNumber);

		if (info.iSizeInPixels.iWidth==aSize.iWidth && info.iSizeInPixels.iHeight==aSize.iHeight)

			{

			r = Kern::HalFunction(EHalGroupDisplay, EDisplayHalNumberOfResolutions, &numberOfResolutions, &aSpinnerOut, iScreenNumber);

			if(r < KErrNone)

				return r;

			if (aSpinnerOut!=spinner1)

				{

				return KErrCorrupt;

				}

			else

				{

				return res;

				}

			}

		}

	return KErrArgument;

	}

/**

Process asynchronous requests. TRequestStatus is at iMsg->Ptr0(), and the other

two parameters are in iMsg->Ptr1() and iMsg->Ptr2().

*/

void DDisplayChannel::DoRequest(TInt aFunction)

	{

	DD_TRACE(Kern::Printf(">DDisplayChannel::DoRequest fn=%d\n", aFunction);)

	TInt r = KErrNotSupported;

	switch(aFunction)

		{

		case RDisplayChannel::EReqGetCompositionBuffer:

			// a1: TAny** buffer address [out]

			r = GetCompositionBuffer(static_cast<TAny**>(iMsg->Ptr1()));

			break;

		case RDisplayChannel::EReqPostUserBuffer:

			// a1: { TBufferId* buffer ID, const TRegionFix<KMaxRectangles>* region }* [in]

			// a2: TPostCount* post count [out]

			{

			TAny* arg[2];

			__ASSERT_DEBUG(iMsg->Ptr1(), Panic(EDisplayPanicNullArgument));

			kumemget(arg, iMsg->Ptr1(), sizeof(arg));

			r = PostUserBuffer(reinterpret_cast<RDisplayChannel::TBufferId*>(arg[0]), arg[1],

					reinterpret_cast<RDisplayChannel::TPostCount*>(iMsg->Ptr2()));

			}

			break;

		case RDisplayChannel::EReqWaitForPost:

			// a1: TInt* post to wait for [in]

			r = WaitForPost(static_cast<RDisplayChannel::TPostCount*>(iMsg->Ptr1()));

			break;

	    	//v1_1

		case RDisplayChannel::EReqWaitForDisplayConnect:

			r = WaitForDisplayConnect();

			break;

		}

	DD_TRACE(Kern::Printf("<DDisplayChannel::DoRequest result=%d\n",r);)

	if (r != KRequestPending)

		{

		TRequestStatus* status = reinterpret_cast<TRequestStatus*>(iMsg->Ptr0());

		Kern::RequestComplete(iMsg->Client(), status, r);

		}

	}

/**

Process asynchronous request cancellations

*/

TInt DDisplayChannel::DoCancel(TInt aRequestMask)

	{

	DD_TRACE(Kern::Printf(">DDisplayChannel::DoCancel mask=%x\n", aRequestMask);)

	if (aRequestMask & (1 << RDisplayChannel::ECtrlCancelGetCompositionBuffer))

		{

		if (IsCompositionBuffer(iGetBuffer))

			{

			iBuffer[iGetBuffer].iRequest.Complete(KErrCancel);

			}

		}

	if (aRequestMask & (1 << RDisplayChannel::ECtrlCancelPostUserBuffer))

		{

		if (IsUserBuffer(iPostedBuffer))

			{

			iBuffer[iPostedBuffer].iRequest.Complete(KErrCancel);

			}

		}

	if (aRequestMask & (1 << RDisplayChannel::ECtrlCancelWaitForPost))

		{

		iWaitForPostRequest.Complete(KErrCancel);

		}

	if (aRequestMask & (1 << RDisplayChannel::ECtrlCancelWaitForDisplayConnect))

		{

		iWaitForDisplayConnect.Complete(KErrCancel);

		}

	DD_TRACE(Kern::Printf("<DDisplayChannel::DoCancel\n",r);)

	return KErrNone;

	}

/**

Get the number of resolutions on this screen

@return Number of resolutions if successful, otherwise a system wide error code.

*/

TInt DDisplayChannel::NumberOfResolutions()

	{

	TInt numberOfResolutions = 0;

	TInt error = Kern::HalFunction(EHalGroupDisplay, EDisplayHalNumberOfResolutions, &numberOfResolutions, NULL, iScreenNumber);

	if (error != KErrNone)

		{

		return error;

		}

	return numberOfResolutions;

	}

/**

Safely write from kernel to user memory.

@param aDst	Pointer to destination, user memory.

@param aSrc	Pointer to source, kernel memory.

@param aBytes	Number of bytes to write.

@return KErrNone if successful, KErrArgument if either pointer is NULL.

*/

TInt DDisplayChannel::SafePut(TAny* aDst, TAny* aSrc, TInt aBytes)

	{

	if (!aDst || !aSrc)

		{

		return KErrArgument;

		}

	kumemput(aDst, aSrc, aBytes);

	return KErrNone;

	}

/**

Driver panic.

@param	aPanic	The cause of the panic.

*/

void DDisplayChannel::Panic(TDisplayPanic aPanic)

	{

	Kern::Fault("DISPLAY", aPanic);

	}

/**

Client panic.

@param	aPanic	The cause of the panic.

*/

void DDisplayChannel::ClientPanic(RDisplayChannel::TPanic aPanic)

	{

	_LIT(KLitDisplayChannel, "DISPLAYCHANNEL");

	Kern::ThreadKill(iClient, EExitPanic, aPanic, KLitDisplayChannel);

	}

/**

VSync is emulated by using a nanokernel timer to call this function at the

frame rate.

*/

void DDisplayChannel::VSyncTimerFn(TAny* aDisplayChannel)

	{

	reinterpret_cast<DDisplayChannel*>(aDisplayChannel)->DoVSyncTimer();

	}

/**

Instance function called on the timer thread. Queues the VSyncDfc to run on its

thread.

*/

void DDisplayChannel::DoVSyncTimer(void)

	{

	iVSyncDfc.Add();

	iVSync.Again(iVSyncTicks);

	}

/**

DFC function to post the current buffer to the display.

@param aDisplayImpl	The display object to be posted.

*/

void DDisplayChannel::VSyncDfcFn(TAny* aDisplayChannel)

	{

	reinterpret_cast<DDisplayChannel*>(aDisplayChannel)->DoVSync();

	}

/**

Post the current buffer to the display. Signal waiting threads under various

conditions. This is run off the same DFC queue as message handling, so there is

no need to protect the fields.

*/

void DDisplayChannel::DoVSync(void)

	{

	if(iWaitForDisplayConnect.iStatus)

		{

		TInt currentSpinner;

		Kern::HalFunction(EHalGroupDisplay, EDisplayHalGetStateSpinner, &currentSpinner, NULL, iScreenNumber);

		//display state changed

		if(currentSpinner != iDisplayStateSpinner)

			iWaitForDisplayConnect.Complete(KErrNone);

		}

	if (IsValidBuffer(iPostedBuffer))

		{

		// Complete any outstanding request for the buffer which was displayed.

		// This either signifies the user or composition buffer becoming

		// available 

		if (iDisplayBuffer != iPostedBuffer)

			{

			iBuffer[iDisplayBuffer].iRequest.Complete(KErrNone);

			}

		iDisplayBuffer = (RDisplayChannel::TBufferId)iPostedBuffer;

		iPostedBuffer = (RDisplayChannel::TBufferId)KBufferNotSet;

		// Update the pixel pointer used when painting the client window		

		PostMessage(iHwnd, WMU_SET_DISPLAY_BUFFER, 0,

				(LPARAM)iBuffer[iDisplayBuffer].iAddress);

		// check if the buffer format is modified

	if ((iDisplayBufferFormat.iSize.iHeight != iNewBufferFormat.iSize.iHeight) || 

		(iDisplayBufferFormat.iSize.iWidth != iNewBufferFormat.iSize.iWidth) ||

		(iDisplayBufferFormat.iPixelFormat != iNewBufferFormat.iPixelFormat))

		{

		// We post in one messages everything, but we got to pack the size

		// speculate that the maximum width and height can be represented in 16 bit

		TUint aggregateSize = ((TUint)iNewBufferFormat.iSize.iHeight << 16) & 0xffff0000; 

		aggregateSize += (TUint)iNewBufferFormat.iSize.iWidth & 0x0000ffff;

		PostMessage(iHwnd, 

				    WMU_SET_BUFFER_FORMAT, 

				    aggregateSize, 

				    iNewBufferFormat.iPixelFormat);

		iDisplayBufferFormat = iNewBufferFormat;

		}

		if (iDisplayRotation != iNewRotation)

			{

			iDisplayRotation = iNewRotation;

			TUint flip;

			switch (iDisplayRotation)

				{

				case RDisplayChannel::ERotation90CW:

					flip = EEmulatorFlipLeft;

					break;

				case RDisplayChannel::ERotation180:

					flip = EEmulatorFlipInvert;

					break;

				case RDisplayChannel::ERotation270CW:

					flip = EEmulatorFlipRight;

					break;

				default:	// Normal

					flip = EEmulatorFlipRestore;

					break;

				}

			PostMessage(iHwnd, WM_FLIP_MESSAGE, flip, NULL);

			iPostedRectCount = 0;	// Force full invalidation

			}

		if (iDisplayResolution.iWidth != iNewResolution.iWidth ||

				iDisplayResolution.iHeight != iNewResolution.iHeight)

			{

			iDisplayResolution = iNewResolution;

			PostMessage(iHwnd, WMU_SET_DISPLAY_SIZE, 

					iDisplayResolution.iWidth, iDisplayResolution.iHeight);

			}

		// Invalidate the window contents where necessary

		TInt count = iPostedRectCount;

		if (count)

			{

			// Order of invalidation is immaterial

			while (count--)

				{

				InvalidateRect(iHwnd, &iPostedRect[count], FALSE);

				}

			iPostedRectCount = 0;

			}

		else

			{

			InvalidateRect(iHwnd, NULL, FALSE);

			}

		// Use differences to allow for wraparound

		if ((TInt)(iWaitForPost - iLastPostCount) > 0 && (TInt)(iPostCount - iWaitForPost) >= 0)

			{

			// Post waited for is now being displayed or was dropped

			iWaitForPostRequest.Complete(KErrNone);

			}

		iLastPostCount = iPostCount;

		}

	}

/**

Set the status object for this request and the thread to complete it on, if not

already set.

@param aStatus	The new request status.

@param aThread	The thread on which to complete.

@return EFalse if the status is already set, or ETrue if the status has now been

set.

*/

TBool DDisplayChannel::TRequest::SetStatus(TThreadMessage& aMsg)

	{

	if (iStatus)

		{

		__ASSERT_DEBUG(iThread, Kern::PanicCurrentThread(RDisplayChannel::Name(), EDisplayPanicNullThreadOnSet));

		return EFalse;	// In use

		}

	__ASSERT_DEBUG(!iThread, Kern::PanicCurrentThread(RDisplayChannel::Name(), EDisplayPanicThreadAlreadySet));

	DThread* thread = aMsg.Client();

	TInt r = thread->Open();

	__ASSERT_DEBUG( r == KErrNone, Kern::PanicCurrentThread(RDisplayChannel::Name(), EDisplayPanicThreadOpenFailed));

	(TAny)r;

	iThread = thread;

	iStatus = reinterpret_cast<TRequestStatus*>(aMsg.Ptr0());

	return ETrue;

	}

/**

Complete the request with the given result. If the status has not been set, or

has already been completed, this does nothing.

@param aResult	The result of the asynchronous request.

*/

void DDisplayChannel::TRequest::Complete(TInt aResult)

	{

	if (iStatus)

		{

    	__ASSERT_DEBUG(iThread, Kern::PanicCurrentThread(RDisplayChannel::Name(), EDisplayPanicNullThreadOnComplete));

		Kern::RequestComplete(iThread, iStatus, aResult);

		Kern::SafeClose((DObject*&)iThread, NULL);

		}

	}

/**

Post the current composition buffer to the display on the next frame tick.

@param aRegion	NULL if the entire buffer has changed, or a user pointer to up

to TDisplayInfo::KMaxRectagles areas that have changed.

@param aPostCount	User pointer to an integer to receive the new post count.

@return KErrNone, or a system-wide error code

*/

TInt DDisplayChannel::PostCompositionBuffer(TAny* aRegion, RDisplayChannel::TPostCount* aPostCount)

	{

	if (!IsCompositionBuffer(iGetBuffer))

		{

		return KErrNotSupported;

		}

	if (iWaitForPost == iPostCount)

		{

		// Complete wait for post (dropped)

		iWaitForPostRequest.Complete(KErrNone);

		}

	if (IsUserBuffer(iPostedBuffer))

		{

		// Complete the user post request (not displayed)

		iBuffer[iPostedBuffer].iRequest.Complete(KErrCancel);

		}

	iPostedBuffer = iGetBuffer;

	iGetBuffer = NextCompositionBuffer(iGetBuffer);

	if (iNumCompositionBuffers > 2 && iGetBuffer == iDisplayBuffer)

		{

		// With more than two buffers, there must always be one available with

		// no waiting required, so find it.

		iGetBuffer = NextCompositionBuffer(iGetBuffer);

		}

	// Get the region

	if (aRegion)

		{

		// Set iPostedRect(Count) from aRegion.

		Panic(EDisplayPanicNotYetImplemented);

		}

	// What to do about wrapping?

	iPostCount++;

	iNewRotation = iCurrentRotation;

	iNewResolution = iCurrentResolution;

	iNewBufferFormat = iCurrentBufferFormat;

	SafePut(aPostCount, &iPostCount, sizeof(iPostCount));

	return KErrNone;

	}

/**

Post the legacy buffer to the display on the next frame tick.

@param aRegion	NULL if the entire buffer has changed, or a user pointer to up

to TDisplayInfo::KMaxRectagles areas that have changed.

@param aPostCount	User pointer to an integer to receive the new post count.

@return KErrNone, or a system-wide error code

*/

TInt DDisplayChannel::PostLegacyBuffer(TAny* aRegion, RDisplayChannel::TPostCount* aPostCount)

	{

	if (iWaitForPost == iPostCount)

		{

		// Complete wait for post (dropped)

		iWaitForPostRequest.Complete(KErrNone);

		}

	if (IsUserBuffer(iPostedBuffer))

		{

		iBuffer[iPostedBuffer].iRequest.Complete(KErrCancel);

		}

	// iBuffer should NOT be NULL here!

	__ASSERT_ALWAYS(iBuffer[KLegacyBuffer].iAddress, Panic(EDisplayPanicNoLegacyBuffer));

	iPostedBuffer = KLegacyBuffer;

	// Get the region into iRegion

	if (aRegion)

		{

		// Set iPostedRect(Count) from aRegion.

		Panic(EDisplayPanicNotYetImplemented);

		}

	iPostCount++;

	iNewRotation = iCurrentRotation;

	iNewResolution = iCurrentResolution;

	iNewBufferFormat = iCurrentBufferFormat;

	SafePut(aPostCount, &iPostCount, sizeof(iPostCount));

	return KErrNone;

	}

/**

Asynchronously request the current composition buffer. Completes immediately

if not already being displayed, or an error occurs.

@param aStatus	The request status to be completed.

@param aAddress	The user pointer to the location to put the address.

*/

TInt DDisplayChannel::GetCompositionBuffer(TAny** aAddress)

	{

	if (!IsCompositionBuffer(iGetBuffer))

		{

		// No composition buffers available for use.

		return KErrNotSupported;

		}

	// The address won't change, so may as well set it now.

	TUint idx = iGetBuffer - KFirstCompositionBuffer;

	if (SafePut(aAddress, &idx, sizeof(TUint)) != KErrNone)

		{

		return KErrArgument;

		}

	if (iNumCompositionBuffers > 1 && iGetBuffer == iDisplayBuffer)

		{

		// Multi-buffer case, and buffer is currently being displayed

		if (iBuffer[iGetBuffer].iRequest.SetStatus(*iMsg))

			{

			return KRequestPending;

			}

		// Already set

		return KErrInUse;

		}

	return KErrNone;

	}

/**

Post a user buffer to the display on the next frame tick.

@param aBufferId	The ID of the user buffer to post.

@param aRegion	NULL if the entire buffer has changed, or a user pointer to up

to TDisplayInfo::KMaxRectagles areas that have changed.

@return KErrNone, or a system-wide error code

*/

TInt DDisplayChannel::PostUserBuffer(RDisplayChannel::TBufferId* aBufferId, TAny* aRegion, RDisplayChannel::TPostCount* aPostCount)

	{

	RDisplayChannel::TBufferId bufferId;

	bufferId = reinterpret_cast <RDisplayChannel::TBufferId> (aBufferId);

	if (!IsUserBuffer(bufferId))

		{

		// Not a user buffer.

		return KErrArgument;

		}

	if (!iBuffer[bufferId].iChunk)

		{

		// User buffer not initialised.

		return KErrArgument;

		}

	if (iWaitForPost == iPostCount)

		{

		// Complete wait for post (dropped)

		iWaitForPostRequest.Complete(KErrNone);

		}

	if (IsUserBuffer(iPostedBuffer))

		{

		// Complete the user post request (not displayed)

		iBuffer[iPostedBuffer].iRequest.Complete(KErrCancel);

		}

	if (bufferId == iDisplayBuffer)	//pathological case

		{

		// Complete the current display buffer as we are superceding it with the same one

		iBuffer[bufferId].iRequest.Complete(KErrNone);

		}

	// Only one buffer can be posted at any time, and if it were this user

	// buffer, the request will have just been completed, so this shouldn't fail.

	TBool isSet = iBuffer[bufferId].iRequest.SetStatus(*iMsg);

	__ASSERT_DEBUG(isSet, Panic(EDisplayPanicInUse));

	(TAny)isSet;

	iPostedBuffer = bufferId;

	// Get the region

	if (aRegion)

		{

		// Set iPostedRect(Count) from aRegion.

		Panic(EDisplayPanicNotYetImplemented);

		}

	iPostCount++;

	iNewRotation = iCurrentRotation;

	iNewResolution = iCurrentResolution;

	iNewBufferFormat = iCurrentBufferFormat;

	SafePut(aPostCount, &iPostCount, sizeof(iPostCount));

	return KRequestPending;

	}

/**

Asynchronous request notification when the given post count is reached (or

passed).

@param aStatus	The request status to be completed.

@param aPostCount	The count to wait for.

*/

TInt DDisplayChannel::WaitForPost(RDisplayChannel::TPostCount* aPostCount)

	{

	TInt postCount;

	kumemget(&postCount, aPostCount, sizeof(RDisplayChannel::TPostCount));