// Copyright (c) 1995-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:
// wins\specific\multitouch.cpp
// 
//
#include "multitouch.h"
#include "resource.h"

#define KDefaultMaxProximity -100
#define KDefaultMaxPressure 5000
#define KDefaultPressureStep 500
#define KDefaultProximityStep 5

// Static members
DMultiMouse DMultiMouse::iMice[KMaxMice];
int DMultiMouse::iNumMice = 0;
DMultiMouse* DMultiMouse::iPrimary = 0;
int DMultiMouse::iMouseId = 0;
int DMultiTouch::iNumberOfMice = 0;
bool DMultiTouch::iMultiTouchSupported= FALSE;
bool DMultiTouch::iMultiTouchCreated= FALSE;
bool DMultiTouch::iMultiTouchTempEnabled= FALSE;

// Function pointers for raw input APIs
TYPEOF_RegisterRawInputDevices pfnRegisterRawInputDevices= NULL;
TYPEOF_GetRawInputData pfnGetRawInputData= NULL;
TYPEOF_GetRawInputDeviceList pfnGetRawInputDeviceList=NULL;

/**
 *  Initialise the proximity and pressure information if undefined by the user
 */
DMultiTouch::DMultiTouch(TInt aProximityStep, TInt aPressureStep)
	{
	iZMaxRange = KDefaultMaxProximity;
	iMaxPressure = KDefaultMaxPressure;
	iProximityStep = (aProximityStep == -1) ? KDefaultProximityStep : aProximityStep;
	iPressureStep = (aPressureStep == -1) ? KDefaultPressureStep : aPressureStep;
	}

/** 
 * Register all the mice 
*/
BOOL DMultiTouch::Register()
	{
	RAWINPUTDEVICE device;
	device.usUsagePage = 0x01;
	device.usUsage = 0x02;
	device.dwFlags = RIDEV_NOLEGACY; // adds HID mouse and also ignores legacy mouse messages
	device.hwndTarget = 0;
	ShowCursors();
	return pfnRegisterRawInputDevices(&device, 1, sizeof(RAWINPUTDEVICE));
	}

/**
 * Unregister mice devices
 */
BOOL DMultiTouch::UnRegister()
	{
	RAWINPUTDEVICE device;
	device.usUsagePage = 0x01;
	device.usUsage = 0x02;
	device.dwFlags = RIDEV_REMOVE;
	device.hwndTarget = NULL;
	HideCursors();
	return pfnRegisterRawInputDevices(&device, 1, sizeof(RAWINPUTDEVICE));
	}


/* * Handle multi-input Window messages
 */
void DMultiTouch::OnWmInput(HWND aHWnd,TUint aMessage,TUint aWParam,TUint aLParam,HWND aParentHwnd)
	{
	RAWINPUT ri;
	UINT dwSize = sizeof(ri);
	if (pfnGetRawInputData((HRAWINPUT)aLParam, RID_INPUT, &ri, &dwSize, sizeof(RAWINPUTHEADER))==(UINT)-1)
		{
		OutputDebugString(TEXT("GetRawInputData has an error !\n"));
		}
	else if (ri.header.dwType == RIM_TYPEMOUSE) 
		{
		DMultiMouse* mouse = DMultiMouse::Find(ri.header.hDevice);
		if (mouse)
			{
			if (!DMultiMouse::iPrimary)
				{
				DMultiMouse::iPrimary = mouse;
				DMultiMouse::iPrimary->iIsPrimary = TRUE;
				}
			mouse->HandleRawMouseEvent(ri.data.mouse, aParentHwnd);
			}
		}
	DefWindowProcA(aHWnd, aMessage, aWParam, aLParam);
	}

void DMultiTouch::HideCursors()
	{
	for (int ii=0; ii<DMultiMouse::iNumMice; ii++)
		{
		DMultiMouse::iMice[ii].iCursorWnd.Hide();
		}
	}

void DMultiTouch::ShowCursors()
	{
	for (int ii=0; ii<DMultiMouse::iNumMice; ii++)
		{
		DMultiMouse::iMice[ii].iCursorWnd.Show();
		}
	}

/**
 * The cursor window procedure
 */
static LRESULT CALLBACK CursorWndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
	{
	if (msg==WM_PAINT)
		{
		PAINTSTRUCT ps;
		HDC hdc = BeginPaint(hwnd, &ps);
		CursorWindow* wnd = (CursorWindow*)GetWindowLong(hwnd, GWL_USERDATA);
		DrawIconEx(hdc,0,0, wnd->iCursor,0,0,0,NULL, DI_NORMAL | DI_DEFAULTSIZE);
		EndPaint(hwnd, &ps);
		return 0;
		}
	return DefWindowProc(hwnd, msg, wp, lp);
	}

CursorWindow::CursorWindow(): iHwnd(NULL),iCursor(NULL),iNumber(0)
	{
	}

HWND CursorWindow::Create(HMODULE hm, HWND hwndParent, int number)
	{
	// Create the window
	static ATOM atom = NULL;
	if (!atom) 
		{
		WNDCLASSEX wcex;
		ZeroMemory(&wcex, sizeof(wcex));
		wcex.cbSize = sizeof(WNDCLASSEX); 
		wcex.style			= CS_OWNDC;
		wcex.lpfnWndProc	= (WNDPROC)CursorWndProc;
		wcex.hInstance		= (HINSTANCE)hm;
		wcex.lpszClassName	= TEXT("CursorWndClass");
		wcex.hbrBackground = CreateSolidBrush(RGB(255,0,0));//Background color is also for the number
		atom = RegisterClassEx(&wcex);
		}
	iHwnd = CreateWindowA((LPCSTR)atom, NULL, WS_CHILD|WS_CLIPSIBLINGS, 0,0,64,64, hwndParent, NULL, hm, NULL);
	SetWindowLong(iHwnd, GWL_USERDATA, (LONG)this);
	iNumber = number;
	return iHwnd;
	}

void CursorWindow::Show()
	{
	ShowWindow(iHwnd, SW_NORMAL);
	}

void CursorWindow::Hide()
	{
	ShowWindow(iHwnd, SW_HIDE);
	}

BOOL CursorWindow::SetCursor(HCURSOR hc)
	{
	// Duplicate the cursor (because we're going to draw a number on the mask)
	if (iCursor) 
		{
		DestroyCursor(iCursor);
		iCursor = NULL;
		}
	iCursor = CopyCursor(hc);

	// Get information about the cursor, and select its mask bitmap into a temporary DC.
	ICONINFO ii;
	GetIconInfo(iCursor, &ii);
	iHotspot.x = ii.xHotspot;
	iHotspot.y = ii.yHotspot;
	HDC hdc = CreateCompatibleDC(NULL);
	SelectObject(hdc, ii.hbmMask);

	// Get the cursor's pixel size	
	BITMAPINFO bmi;
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biBitCount = 0;
	GetDIBits(hdc, ii.hbmMask, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
	int cx = bmi.bmiHeader.biWidth;
	int cy = bmi.bmiHeader.biHeight;

	// Monochrome cursors have a double-height hbmMask. The top half contains the AND 
	// bitmap (which we do want) and the bottom half contains the XOR bitmap (which we 
	// dont want). Colour cursors have a single normal-height AND mask.
	BOOL isMonochrome = (ii.hbmColor==NULL);
	int cyy = isMonochrome ? (cy>>1) : cy; 

	// Draw the number into the mask
	char ach[4];
	int ld = iNumber/10;
	int rd = iNumber % 10;
	if (ld > 0)
		{
		wsprintf((LPTSTR)ach, (LPCTSTR)TEXT("%d%d"), ld,rd);
		}
	else 
		{
		wsprintf((LPTSTR)ach, (LPCTSTR)TEXT("%d"), rd);
		}

	HFONT hf = CreateFontA(12,0, 0,0,FW_THIN, FALSE,FALSE,FALSE, 0,DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, 0, "Arial");
	SelectObject(hdc, hf);
	SetBkMode(hdc, TRANSPARENT);
	TextOutA(hdc, 0,cyy-12, ach, 2);
	DeleteObject(hf);

	// Get the bits of the mask (in 32-bit colour)
	HANDLE heap = GetProcessHeap();
	bmi.bmiHeader.biBitCount = 32;
	DWORD* bits = (DWORD*)HeapAlloc(heap, 0, cx*cy*4);
	GetDIBits(hdc, ii.hbmMask, 0, cy, bits, &bmi, DIB_RGB_COLORS);

	// Set the window to the size of the cursor
	SetWindowPos(iHwnd, NULL,0,0,cx,cyy, SWP_NOMOVE);

	// Create a cursor-shaped region by starting out with an empty region
	// and ORing in each zero-valued mask pixel.
	HRGN rgn = CreateRectRgn(0,0,0,0);
	for (int y=0 ; y<cyy ; y++) 
		{
		for (int x=0 ; x<cx ; x++) 
			{
			if (bits[(cy-y-1)*cx+x]==0) 
				{
				HRGN rgnPix = CreateRectRgn(x,y, x+1,y+1);
				CombineRgn(rgn, rgn, rgnPix, RGN_OR);
				DeleteObject(rgnPix);
				}
			}
		}

	// Cleanup
	HeapFree(heap, 0, bits);
	DeleteDC(hdc);

	// Set the window's clipping region to the cursor-shaped region
	SetWindowRgn(iHwnd, rgn, TRUE);
	return TRUE;
	}
	
void CursorWindow::GetPosition(POINT& pt)
	{
	pt.x = 0;
	pt.y = 0;
	MapWindowPoints(iHwnd, GetParent(iHwnd), &pt, 1);
	pt.x += iHotspot.x;
	pt.y += iHotspot.y;
	}

void CursorWindow::SetPosition(POINT& pt)
	{
	SetWindowPos(iHwnd, NULL, pt.x - iHotspot.x, pt.y - iHotspot.y, 0, 0, SWP_NOSIZE);
	}

/** 
 * Add the mouse device to the collection
 */
TInt DMultiMouse::Add(RAWINPUTDEVICELIST& aDev)
	{
	if (iNumMice < KMaxMice)
		{
		DMultiMouse& mouse = iMice[iNumMice];
		mouse.iDevice = aDev.hDevice;
		iNumMice++;
		return KErrNone;
		}
	else
		{
		return KErrOverflow;
		}
	}

DMultiMouse::DMultiMouse() :
	iX(-1), iY(-1), iZ(0), iDevice(0),iId(-1) 
	{
	}

DMultiMouse* DMultiMouse::Find(HANDLE aHandle)
	{
	for (TInt ii=0; ii<iNumMice; ii++)
		{
		DMultiMouse& mouse = iMice[ii];
		if (mouse.iDevice == aHandle)
			return &mouse;
		}
	return NULL;
	}

void DMultiMouse::HandleRawMouseEvent(RAWMOUSE& aEvent, HWND aWnd)
	{
	// give this pointer an id, if it doesn't already have one
	if (iId == -1)
		{
		iId = iMouseId++;
		}

	// Create the cursor window and set the cursor if not done yet
	if (iCursorWnd.iHwnd == NULL)
		{
		iCursorWnd.Create((HINSTANCE)0, aWnd,iId);
		iCursorWnd.SetCursor(LoadCursorA(NULL, (LPCSTR)IDC_ARROW));
		}

	CorrectSystemMouse();
			
	// recalc mouse position
	if (iX == -1)
		{
		// initial position
		iX = iPrimary->iX;
		iY = iPrimary->iY;
		}

	if (aEvent.usFlags & MOUSE_MOVE_ABSOLUTE)
		{
		// absolute position info can update all pointers
		iX = aEvent.lLastX;
		iY = aEvent.lLastY;
		}
	else if (!iIsPrimary)
			{
			// relative position info updates non-primary pointers,
			iX += aEvent.lLastX;
			iY += aEvent.lLastY;
			}

	// Show the cursor window
	ShowMousePos(aWnd);

	TInt message = WM_MOUSEMOVE;

	// get button state
	if (aEvent.usButtonFlags & RI_MOUSE_LEFT_BUTTON_DOWN)
		{
		message = WM_LBUTTONDOWN;
		iZ = 0;
		}
	
	if (aEvent.usButtonFlags & RI_MOUSE_LEFT_BUTTON_UP)
		{
		message = WM_LBUTTONUP;
		iZ = 0;
		}
	
	if (aEvent.usButtonFlags & RI_MOUSE_RIGHT_BUTTON_DOWN)
		{
		message = WM_RBUTTONDOWN;
		}
	
	if (aEvent.usButtonFlags & RI_MOUSE_RIGHT_BUTTON_UP)
		{
		message = WM_RBUTTONUP;
		}
	
	if (aEvent.usButtonFlags & RI_MOUSE_WHEEL)
		{
		message = WM_MOUSEWHEEL;
		if ((TInt16)(aEvent.usButtonData&0x8000)== 0) // positive number
			{
			if (iZ < TheMultiTouch->iMaxPressure)
				{
				if (iZ>=0)
					{ // pressure range 
					iZ += TheMultiTouch->iPressureStep;//Pressure step
					if (iZ > TheMultiTouch->iMaxPressure)
						{
						iZ = TheMultiTouch->iMaxPressure;
						}
					}
				else
					{ // proximity range
					iZ += TheMultiTouch->iProximityStep; //Proximity step
					}
				}
			}
		else
			{
			if (iZ > TheMultiTouch->iZMaxRange)
				{
				if (iZ <= 0)
					{// proximity range 
					iZ -= TheMultiTouch->iProximityStep;//Proximity step
					if (iZ < TheMultiTouch->iZMaxRange)
						{
						iZ = TheMultiTouch->iZMaxRange;
						}
					}
				else
					{// pressure range
					iZ -= TheMultiTouch->iPressureStep;//Pressure step
					}
				}
			}
		}
	
	MultiTouchWndPointer(message, iX, iY, iZ, iId);
	
	}

/**
 * Show the cursor window when the cursor is inside the client area
 */
void DMultiMouse::ShowMousePos(HWND aHWnd)
	{
	RECT client = {0,0,0,0};
	if(aHWnd)
		{
		GetWindowRect(aHWnd, &client); 
		POINT pt = {iX-client.left,iY-client.top};
		iCursorWnd.SetPosition(pt);
		}
	iCursorWnd.Show();
	}

void DMultiMouse::CorrectSystemMouse()
	{
	if (iIsPrimary)
		{
		POINT pos;
		if (GetCursorPos(&pos)) // if failed, pos contains garbage.
			{
			iX = pos.x;
			iY = pos.y;	
			}
		}
	else
		{
		SetCursorPos(iPrimary->iX,iPrimary->iY);
		}
	}
	
/** 
 * a static function to check how many mice are connected 
*/
bool DMultiTouch::Init()
	{
	HMODULE hModule = GetModuleHandleA("user32.dll");
	if(hModule == NULL)
		return FALSE;
	
	OSVERSIONINFO osvi;
	ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	
	GetVersionEx(&osvi);
	// Check for Win 2K or higher version
	if (osvi.dwMajorVersion < 5)
		{
		return FALSE;
		}
	
	// Not supported on Win2K
	if ((osvi.dwMajorVersion == 5) && (osvi.dwMinorVersion == 0))
		{
		return FALSE;
		}
		
	pfnRegisterRawInputDevices 	= (TYPEOF_RegisterRawInputDevices)GetProcAddress(hModule, "RegisterRawInputDevices");
	pfnGetRawInputData 			= (TYPEOF_GetRawInputData)GetProcAddress(hModule, "GetRawInputData");
	pfnGetRawInputDeviceList 	= (TYPEOF_GetRawInputDeviceList)GetProcAddress(hModule, "GetRawInputDeviceList");
	
	if((pfnRegisterRawInputDevices == NULL) || (pfnGetRawInputData == NULL) || (pfnGetRawInputDeviceList == NULL))
		{
		return FALSE;
		}
		
	UINT nDevices;
	
	if (pfnGetRawInputDeviceList(NULL, &nDevices, sizeof(RAWINPUTDEVICELIST)) != 0)
		{
		return FALSE;
		}

	RAWINPUTDEVICELIST* pRawInputDeviceList = new RAWINPUTDEVICELIST[ nDevices ];
	if (!pRawInputDeviceList)
		{
		return FALSE;
		}

	pfnGetRawInputDeviceList(pRawInputDeviceList, &nDevices,
			sizeof(RAWINPUTDEVICELIST));

	
	for (UINT i=0; i<nDevices; i++)
		{
		RAWINPUTDEVICELIST& dev = pRawInputDeviceList[i];
		if (dev.dwType == RIM_TYPEMOUSE)
			{
			if (DMultiMouse::Add(dev)!=KErrNone)
				{
				//free the device list
				delete[] pRawInputDeviceList;
				return FALSE;
				}
			}
		}

	delete[] pRawInputDeviceList;

	// Multitouch is supported when more than 2 mice are connected (including the hidden RID mouse)
	return DMultiMouse::iNumMice > 2;
	}