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

 	}