// 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;

    }