RegisterPointerInputTarget() breaks InjectTouchInput() on Windows 8.1 when the user physically touches the screen.

Question

This is a "working on Windows 8.0 but broken on 8.1" problem.
My application is a full screen magnifier. When magnification is turned on, there is no longer a 1:1 relationship between touch screen coordinates and desktop coordinates.
So I need a way to allow the user operate the computer, such as dragging or pinching something on the desktop (icon/window/whatever). So when they drag their finger(s) across the touch screen, I need to capture that, translate the touch coordinates from magnified
pixels coordinates into original desktop pixels and then inject new input to the app. I also want the ability to capture the touch input and not pass it to the app (so I can have gestures/whatever to control the magnifier viewport location). I might also want
to inject input when the user is not touching the real screen.
So I am capturing all touch input RegisterPointerInputTarget() and simulating touch input using InjectTouchInput() (after translating coordinates from the screen to the magnified desktop).
My code for simulating touch input works fine in isolation (as does the SDK sample). My code for capturing all touch input also works fine. However, if they are both used at the same time it’s not happy, although I am not getting any error codes back from the
API.
Specifically, attempts to simulate a touch and hold or a touch and drag are not working whenever the user is physically touching the real touch screen. Further diagnosis indicates that the touch input messages are not arriving in the target application. The
moment the user physcially touches the screen, any simulated input in progress gets cancelled and all subsequent calls to InjecttouchInput() are ignored - but no error code is returned.
Because I am capturing all real input using RegisterPointerInputTarget(), I would expect all real physical input to be redirected to my window (which it does) and be able to call InjectTouchInput() at any point to simulate input. The simulated input would go
to the target app and not be captured by my own process.
This all worked fine in Windows 8.0 but is broken in  windows 8.1.
I have written a basic test application that does two things.
1.       Uses RegisterPointerInputTarget() to consume all touch input.
2.       Uses InjectTouchInput() to simulate some output. In this case, it just does a click, followed by a down, a drag and an up – which handily draws a line in the paint application if you arrange your windows carefully.
If I run this, it works until you physically touch the screen with your finger. The moment you do this, InjectTouchInput stops working (no error code), but the paint app receives a mouse up and the line stops. The hwnd to capture all touch input does receive
WM_POINTER... messages and I an returning 0 from this function (have tried other return codes, nothing makes any difference).
So it looks like that if you use RegisterPointerInputTarget(), any physical input is captured, but it also breaks any simulated touch gestures that are currently in progress.
Source code is below, which you can drop in as a replacement for the main .cpp file in your injecttouch sample code from the win8 sdk (and set uiaccess=true and code sign it!). It does it in two threads, however this doesn’t seem to matter, it does the same
thing with one thread. Am I doing something wrong?  (and yes, I know that calling Sleep() is not wise - my real app doesn't do this)?
- Mike.
// allow use of Windows 8 headers
#undef WINVER
#define WINVER 0x0602
#include "stdafx.h"
#include <debugoutx.h>
#include <process.h>
* WinMain *
* Application entrypoint *
static HWND touch_hwnd = NULL;
static ATOM touch_window_atom = NULL;
LRESULT CALLBACK TouchThread_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
switch (message)
case WM_CLOSE:
DestroyWindow(hWnd);
touch_hwnd = NULL;
break;
case WM_NCPOINTERUPDATE :
case WM_NCPOINTERDOWN :
case WM_NCPOINTERUP :
case WM_POINTERENTER :
case WM_POINTERLEAVE :
case WM_POINTERACTIVATE :
case WM_POINTERCAPTURECHANGED :
case WM_TOUCHHITTESTING :
case WM_POINTERWHEEL :
case WM_POINTERHWHEEL :
// case DM_POINTERHITTEST :
case 0x250:
case WM_POINTERUPDATE :
case WM_POINTERDOWN :
case WM_POINTERUP :
// consume pointer mesages
dprintf(L"msg %x\n",message);
return 0;
break;
case WM_TIMER:
break;
default:
dprintf(L"msg %x\n",message);
return DefWindowProc(hWnd, message, wParam, lParam);
break;
return 0;
void Inject(POINTER_TOUCH_INFO &contact)
Sleep(1);
while(1)
DWORD bRet = InjectTouchInput(1, &contact);
if (bRet==0)
DWORD temp = GetLastError();
if (temp==ERROR_NOT_READY)
Sleep(1);
continue;
else
DebugBreak();
break;
static int start = 400;
static int end = 800;
bool SimulateInput(POINTER_TOUCH_INFO &contact)
static int x = start;
if (x==start)
contact.pointerInfo.ptPixelLocation.x = x;
// inject a touch down
contact.pointerInfo.pointerFlags = POINTER_FLAG_DOWN | POINTER_FLAG_INRANGE | POINTER_FLAG_INCONTACT;
Inject(contact);
else if (x==(start+1))
Sleep(10);
contact.pointerInfo.pointerFlags = POINTER_FLAG_UP ;
Inject(contact);
else if (x==(start+2))
contact.pointerInfo.pointerFlags = POINTER_FLAG_DOWN | POINTER_FLAG_INRANGE | POINTER_FLAG_INCONTACT;
Inject(contact);
else if (x==end)
contact.pointerInfo.pointerFlags = POINTER_FLAG_UP ;
Inject(contact);
PostMessage(touch_hwnd,WM_QUIT,0,0);
return false;
else if (x<end)
// drag
contact.pointerInfo.ptPixelLocation.x = x;
// contact.rcContact.left = x - 4;
// contact.rcContact.right = x + 4;
contact.pointerInfo.pointerFlags = POINTER_FLAG_UPDATE | POINTER_FLAG_INRANGE | POINTER_FLAG_INCONTACT;;
Inject(contact);
x++;
return true;
void thread2(void *)
// create window to capture global touch input.
if (!touch_window_atom)
WNDCLASS wc;
wc.style = 0; // Class style(s).
wc.lpfnWndProc = TouchThread_WndProc; // Function to retrieve messages
wc.cbClsExtra = 0; // No per-class extra data.
wc.cbWndExtra = 0; // No per-window extra data.
wc.hInstance = GetModuleHandle(0); // Application that owns the class.
wc.hIcon = NULL;
wc.hCursor = NULL;
wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = NULL; // Name of menu resource in .RC file.
wc.lpszClassName = L"MarsTouchInputCapture"; // Name used in call to CreateWindow.
// Register the window class and return success/failure code.
touch_window_atom = RegisterClass(&wc);
touch_hwnd = CreateWindowEx(WS_EX_NOACTIVATE,L"MarsTouchInputCapture",L"Magnification",0,0,0,1,1,NULL,NULL,GetModuleHandle(0),NULL);
// capture global desktop touch input
if (RegisterPointerInputTarget(touch_hwnd,PT_TOUCH)==0)
DWORD err = GetLastError();
MessageBox(NULL,L"RegisterPointerInputTarget(PT_TOUCH) failed",L"error",MB_OK);
if (RegisterPointerInputTarget(touch_hwnd,PT_PEN)==0)
DWORD err = GetLastError();
MessageBox(NULL,L"RegisterPointerInputTarget(PT_PEN) failed",L"error",MB_OK);
// message loop
MSG msg;
while (GetMessage(&msg, NULL, 0, 0))
DispatchMessage(&msg);
UnregisterPointerInputTarget(touch_hwnd,PT_TOUCH);
UnregisterPointerInputTarget(touch_hwnd,PT_PEN);
int
WINAPI WinMain(
_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPSTR lpCmdLine,
_In_ int nShowCmd)
POINTER_TOUCH_INFO contact;
BOOL bRet = TRUE;
MessageBox(NULL,L"Break on Load",L"Attach Debugger",MB_OK);
// assume a maximum of 10 contacts and turn touch feedback off
InitializeTouchInjection(10, TOUCH_FEEDBACK_NONE);
// initialize the touch info structure
memset(&contact, 0, sizeof(POINTER_TOUCH_INFO));
contact.pointerInfo.pointerType = PT_TOUCH; //we're sending touch input
contact.pointerInfo.pointerId = 7; //contact 0
contact.pointerInfo.ptPixelLocation.x = 400;
contact.pointerInfo.ptPixelLocation.y = 480;
contact.touchFlags = TOUCH_FLAG_NONE;
contact.touchMask = TOUCH_MASK_ORIENTATION | TOUCH_MASK_PRESSURE;
contact.touchMask = 0;
contact.orientation = 90;
contact.pressure = 32000;
// create thread/window for global capture
_beginthread(thread2,0,NULL);
while(SimulateInput(contact))
Sleep(1);
return 0;

Answer 1

I have almost same situation. But there are some different. I am using RegisterPointerInputTarget to redirect all touch message to my window. and use InjectTouchInput to simulate each flag, which means, WM_POINTERDOWN,WM_POINTERUPDATE,WM_POINTERUP. If user
touches monitor, I simulate DOWN, if user swipes their finger, I simulate UPDATE, if user lifts finger, I simulate UP.
Then the interesting point is, system consider user's finger as primary pointer, and my injected touch as secondary pointer. windows desktop and windows explorer skip all my injected touch. I really hate that.
However IE and chrome will accept my injected touch, they don't caret about primary pointer.
In order to fix this problem, I call AccNotifyTouchInteraction before calling InjectTouchInput.
According to the MSDN, AccNotifyTouchInteraction will notify the destination window before InjectTouchInput. But this idea still fails, which is disappointing.