// Copyright (c) 2005-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:

 //

 // Win32 dependent code for debugging wserv offscreenbuffer and UI surface on emulator

 //

 #include "osbwin.h"

 #include "_windows.h"

 TInt CDebugOsbWin::iId=0;

 const TInt KMaxBuffer=32;

 HBITMAP* TheBitmap[KMaxBuffer];

 HWND* TheWindow[KMaxBuffer];

 // Application window specific messages

 #define WMA_RESIZE		(WM_APP + 0)

 struct TWin32Info

 	{

 	HWND iHwnd;

 	HDC iHdc;

 	HBITMAP iHbitmap;

 	BITMAPINFO* iBitmapInfo;

 	};

 EXPORT_C CDebugOsbWin* CDebugOsbWin::NewL(const TDesC& aName, TSize aSize)

 	{

 	CDebugOsbWin* self = new(ELeave) CDebugOsbWin(aName, aSize);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CDebugOsbWin::CDebugOsbWin(const TDesC& aName, TSize aSize):

 	iThreadCreated(EFalse), iSize(aSize), iName(aName)

 	{}

 EXPORT_C CDebugOsbWin::~CDebugOsbWin()

 	{

 	iSem.Close();

 	if (iThreadCreated)

 		{

 		iThread.Terminate(0);

 		iThread.Close();

 		}

 	if (iWin32)

 		{

 		if (iWin32->iHbitmap)

 			DeleteObject(iWin32->iHbitmap);

 		if (iWin32->iBitmapInfo)

 			User::Free(iWin32->iBitmapInfo);

 		if (iWin32->iHwnd && iWin32->iHdc)

 			ReleaseDC(iWin32->iHwnd,iWin32->iHdc);

 		delete iWin32;

 		}

 	if (iPalette)

 		delete iPalette;

 	--CDebugOsbWin::iId;

 	}

 void CDebugOsbWin::ConstructL()

 	{

 	if (iId>=KMaxBuffer)

 		User::Leave(KErrNoMemory);

 	iPalette=CPalette::NewDefaultL(EColor256);

 	iWin32=new(ELeave) TWin32Info;

 	// store window handle and bitmap association to global table

 	TheWindow[iId]=&(iWin32->iHwnd);

 	TheBitmap[iId]=&(iWin32->iHbitmap);

 	_LIT(KIdFormat, " (%d)");

 	iName.AppendFormat(KIdFormat, iId);

 	++iId;

 	iSem.CreateLocal(0);

 	const TInt KHeapSize=0x4000;

 	User::LeaveIfError(iThread.Create(iName,CDebugOsbWin::ThreadMain,KDefaultStackSize,KHeapSize,KHeapSize,this));

 	iThread.SetPriority(EPriorityMuchLess);

 	iThread.Resume();

 	iThreadCreated=ETrue;

 	iSem.Wait();

 	// iHwnd initialized by WinMain

 	iWin32->iHdc=GetDC(iWin32->iHwnd);

 	SetMapMode(iWin32->iHdc,MM_TEXT);

 	SetROP2(iWin32->iHdc,R2_COPYPEN);

 	TInt byteSize=iSize.iWidth*iSize.iHeight*3;

 	iWin32->iBitmapInfo=(BITMAPINFO*)User::Alloc(sizeof(BITMAPINFO));

 	User::LeaveIfNull(iWin32->iBitmapInfo);

 	iWin32->iBitmapInfo->bmiHeader.biBitCount=24;

 	iWin32->iBitmapInfo->bmiHeader.biSize=sizeof(BITMAPINFOHEADER);

 	iWin32->iBitmapInfo->bmiHeader.biWidth=iSize.iWidth;

 	iWin32->iBitmapInfo->bmiHeader.biHeight=-iSize.iHeight;//top-down DIB

 	iWin32->iBitmapInfo->bmiHeader.biPlanes=1;

 	iWin32->iBitmapInfo->bmiHeader.biCompression=BI_RGB;

 	iWin32->iHbitmap=CreateDIBSection(iWin32->iHdc,iWin32->iBitmapInfo,DIB_RGB_COLORS,(TAny**)&iBitmapBits,NULL,0);

 	User::LeaveIfNull(iWin32->iHbitmap);

 	Mem::Fill(iBitmapBits,byteSize,0xff);

 	}

 EXPORT_C void CDebugOsbWin::Refresh(TSize aSize, TDisplayMode aDisplayMode, const TUint32* aDataAddress)

 	{

 	TBool hasResized = EFalse;

 	// When screen is rotated, the size can change as width and height are swapped.

 	if (iSize != aSize)

 		{

 		iSize = aSize;

 		iWin32->iBitmapInfo->bmiHeader.biWidth = aSize.iWidth;

 		iWin32->iBitmapInfo->bmiHeader.biHeight = -aSize.iHeight; //top-down DIB

 		hasResized = ETrue;

 		}

 	switch (aDisplayMode)

 		{

 		case EGray4:

 			Copy2Bpp(aDataAddress);

 			break;

 		case EColor256:

 			Copy8Bpp(aDataAddress);

 			break;

 		case EColor4K:

 			Copy12Bpp(aDataAddress);

 			break;

 		case EColor64K:

 			Copy16Bpp(aDataAddress);

 			break;

 		case EColor16M:

 			Copy24Bpp(aDataAddress);

 			break;

 		case EColor16MU:

 		case EColor16MA:

 		case EColor16MAP:	// Should really have alpha divided out

 			CopyU24Bpp(aDataAddress);

 			break;

 		default:

 			return;

 		}

 	SetDIBitsToDevice(iWin32->iHdc,0,0,iSize.iWidth,iSize.iHeight,0,0,0,iSize.iHeight,iBitmapBits,

 		((LPBITMAPINFO)iWin32->iBitmapInfo),DIB_RGB_COLORS);

 	if (hasResized)

 		{

 		// This will cause a redraw so no need to invalidate.

 		PostMessage(iWin32->iHwnd, WMA_RESIZE, iSize.iWidth + iHExtra, iSize.iHeight + iVExtra);

 		}

 	else

 		{

 		InvalidateRect(iWin32->iHwnd,NULL,FALSE);

 		}

 	}

 void CDebugOsbWin::Copy2Bpp(const TUint32* aDataAddress)

 	{

 	const TUint8 gray[]={0,85,170,255};

 	const TUint8* src=(const TUint8*)aDataAddress;

 	TUint8* dest=iBitmapBits;

 	const TInt width=iSize.iWidth>>2;

 	for (TInt row=0;row<iSize.iHeight;++row)

 		{

 		for (TInt col=0;col<width;++col)

 			{

 			TUint8 p1=*src++;

 			TUint8 p2=TUint8((p1>>2) & 0x03);

 			TUint8 p3=TUint8((p1>>4) & 0x03);

 			TUint8 p4=TUint8((p1>>6) & 0x03);

 			p1&=0x03;

 			dest[0]=dest[1]=dest[2]=gray[p1];

 			dest[3]=dest[4]=dest[5]=gray[p2];

 			dest[6]=dest[7]=dest[8]=gray[p3];

 			dest[9]=dest[10]=dest[11]=gray[p4];

 			dest+=12; // 1 byte source equals to 4 destination pixels

 			}

 		}

 	}

 void CDebugOsbWin::Copy8Bpp(const TUint32* aDataAddress)

 	{

 	if (!iPalette)

 		return;

 	const TUint8* src=(const TUint8*)aDataAddress;

 	TUint8* dest=iBitmapBits;

 	for (TInt row=0;row<iSize.iHeight;++row)

 		{

 		for (TInt col=0;col<iSize.iWidth;++col)

 			{

 			const TRgb rgb(iPalette->GetEntry(*src++));

 			dest[0]=TUint8(rgb.Blue());

 			dest[1]=TUint8(rgb.Green());

 			dest[2]=TUint8(rgb.Red());

 			dest+=3;

 			}

 		}

 	}

 void CDebugOsbWin::Copy12Bpp(const TUint32* aDataAddress)

 	{

 	const TUint16* src=(const TUint16*)aDataAddress;

 	TUint8* dest=iBitmapBits;

 	for (TInt row=0;row<iSize.iHeight;++row)

 		{

 		for (TInt col=0;col<iSize.iWidth;++col)

 			{

 			dest[0]=TUint8((*src & 0x00f));

 			dest[0]|=dest[0] << 4;

 			dest[1]=TUint8((*src & 0x0f0));

 			dest[1]|=dest[1] >> 4;

 			dest[2]=TUint8((*src & 0xf00)>>4);

 			dest[2]|=dest[2] >> 4;

 			++src;

 			dest+=3;

 			}

 		}

 	}

 void CDebugOsbWin::Copy16Bpp(const TUint32* aDataAddress)

 	{

 	const TUint16* src=(const TUint16*)aDataAddress;

 	TUint8* dest=iBitmapBits;

 	for (TInt row=0;row<iSize.iHeight;++row)

 		{

 		for (TInt col=0;col<iSize.iWidth;++col)

 			{

 			dest[0]=TUint8((*src & 0x001f)<<3);

 			dest[0]=TUint8(dest[0]+(dest[0]>>5));

 			dest[1]=TUint8((*src & 0x07e0)>>3);

 			dest[1]=TUint8(dest[1]+(dest[1]>>6));

 			dest[2]=TUint8((*src & 0xf800)>>8);

 			dest[2]=TUint8(dest[2]+(dest[2]>>5));

 			++src;

 			dest+=3;

 			}

 		}

 	}

 void CDebugOsbWin::CopyU24Bpp(const TUint32* aDataAddress)

 	{

 	const TUint8* src=(const TUint8*)aDataAddress;

 	TUint8* dest=iBitmapBits;

 	for (TInt row=0;row<iSize.iHeight;++row)

 		{

 		for (TInt col=0;col<iSize.iWidth;++col)

 			{

 			dest[0]=*src++;

 			dest[1]=*src++;

 			dest[2]=*src++;

 			++src; // unpack, takes 4 bytes per pixel

 			dest+=3;

 			}

 		}

 	}

 void CDebugOsbWin::Copy24Bpp(const TUint32* aDataAddress)

 	{

 	const TUint8* src = (const TUint8*)aDataAddress;

 	Mem::Copy(iBitmapBits, src, 3 * iSize.iWidth * iSize.iHeight);

 	}

 HBITMAP* GetBitmap(HWND aHwnd)

 	{

 	TInt i;

 	for (i=0;i<CDebugOsbWin::iId;++i)

 		{

 		if (*(TheWindow[i])==aHwnd)

 			return TheBitmap[i];

 		}

 	return NULL;

 	}

 TInt32 APIENTRY WindowProc(HWND aHwnd,TUint aMsg,TUint aWparam,TInt32 aLparam)

 	{

 	switch (aMsg)

 		{

 		case WM_PAINT:

 			{

 			HBITMAP* hBitmap=GetBitmap(aHwnd);

 			if (hBitmap)

 				{

 				PAINTSTRUCT p;

 				BeginPaint(aHwnd,&p);

 		   		HDC hdcBits;

 				BITMAP bm;

 	    		hdcBits=CreateCompatibleDC(p.hdc);

 				GetObject(*hBitmap,sizeof(BITMAP),&bm);

 	    		SelectObject(hdcBits,*hBitmap);

 				RECT windowRect;

 				GetClientRect(aHwnd,&windowRect);

 				BitBlt(p.hdc,0,0,windowRect.right-windowRect.left,windowRect.bottom-windowRect.top,hdcBits,0,0,SRCCOPY);

 				DeleteDC(hdcBits);

 	 			EndPaint(aHwnd,&p);

 				}

 			}

 			return 0;

 		case WMA_RESIZE:

 			{

 			RECT rc;

 			GetWindowRect(aHwnd, &rc);

 			MoveWindow(aHwnd, rc.left, rc.top, aWparam, aLparam, TRUE);

 			}

 			break;

 		default:

 			return DefWindowProc(aHwnd,aMsg,aWparam,aLparam);

 		}

 	return 1;

 	}

 TInt CDebugOsbWin::ThreadMain(TAny* aArg)

     {

     CDebugOsbWin* self=(CDebugOsbWin*)aArg;

     if (!self || !self->iWin32)

     	return KErrArgument;

     TWin32Info* win32=self->iWin32;

     TSize size=self->iSize;

     WNDCLASS wndclass;

     const TText *szAppName=self->iName.Ptr();

     wndclass.style=CS_HREDRAW|CS_VREDRAW;

     wndclass.lpfnWndProc=WindowProc;

     wndclass.cbClsExtra=0;

     wndclass.cbWndExtra=0;

     wndclass.hInstance=NULL;

     wndclass.hIcon=LoadIcon(NULL, IDI_APPLICATION);

     wndclass.hCursor=LoadCursor(NULL, IDC_ARROW);

     wndclass.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH);

     wndclass.lpszMenuName=NULL;

     wndclass.lpszClassName=(LPCTSTR)szAppName;

 	self->iHExtra = GetSystemMetrics(SM_CXFIXEDFRAME) * 2;

 	self->iVExtra = GetSystemMetrics(SM_CYFIXEDFRAME) * 2 + GetSystemMetrics(SM_CYCAPTION);

     RegisterClass(&wndclass);

 	win32->iHwnd=CreateWindow((LPCTSTR)szAppName,

                     (LPCTSTR)szAppName,

                     WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,

                     CW_USEDEFAULT,

                     (CDebugOsbWin::iId-1)*(size.iHeight+30),

                     size.iWidth+self->iHExtra,

                     size.iHeight+self->iVExtra,

                     NULL,

                     NULL,

                     NULL,

                     NULL);

     ShowWindow(win32->iHwnd, SW_SHOWNORMAL);

     UpdateWindow(win32->iHwnd);

 	// Now ConstructL can continue with ready to use HWND

 	self->iSem.Signal();

 	MSG msg;

 	// Can't use normal win32 loop. Theoritically, GetMessage with specific HWND param should do, but

 	// somehow it's still messing emulator main message loop.

 	// The standard win32 loop in debug log to window (deblogwn.cpp) doesn't  seem to work on 9.1

 	while (1)

 		{

 		if (PeekMessage(&msg,win32->iHwnd,0,0,PM_REMOVE))

 			DispatchMessage(&msg);

 		User::After(300*1000);

 		}

 	return KErrNone;

     }