Explore the underlying implementation of WPF’s ITabletManager.GetTabletCount in Win11 system-1024programmer

Explore the underlying implementation of WPF’s ITabletManager.GetTabletCount in Win11 system

This article will introduce to you the underlying implementation of the GetTabletCount method of ITabletManager provided for WPF touch module in Windows 11 system.

This article will introduce to you the underlying implementation of the GetTabletCount method of ITabletManager provided specifically for the WPF touch module in Windows 11 system

This article belongs to a series of blogs related to WPF touch, focusing on the bottom layer of the system. For more touch blogs, please see WPF touch related

As we all know, in Windows 7 system, there are dedicated pen and touch services to provide support for touch messages. WPF is a framework that has been around since the Vista era, so it naturally needs to support the XP system. In the XP system, there is no perfect WM_Touch message, and at the same time, performance needs to be taken into consideration. The best solution is RealTimeStylus. There is a set of COM interfaces specifically used for WPF touch modules under Windows. This set of interfaces provides almost the same implementation functions as RealTimeStylus. For details, please see https://learn.microsoft.com/en-us/windows/win32/tablet /com-apis-used-by-windows-presentation-foundation

For more introduction to this COM touch layer, please see the touch COM interface used in WPF

If you are interested in the docking of this COM touch layer in WPF, please refer to how the WPF touch bottom PenImc works

But starting from Win10, there are no dedicated pen and touch services in the system, but touch messages are integrated into the system

This article will talk to you about the touch bottom layer of WPF under Windows 11, that is, where the ITabletManager interface is defined, and how the GetTabletCount method is implemented

Since this can be changed on each system, this article focuses on writing code for debugging and understanding the implementation on Windows 11 22H2 22621 with the help of VisualStudio and IDA

In order to know where the specific implementation DLL of ITabletManager is, you can define the COM interface and learn the corresponding DLL file by getting the virtual function table address of the COM interface

First write the code that defines the ITabletManager interface, the code is as follows

using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using HRESULT = System.Int32;

 [ComImport, Guid("764DE8AA-1867-47C1-8F6A-122445ABD89A"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
 public interface ITabletManager
 {
     int GetDefaultTablet(out ITablet ppTablet);
     int GetTabletCount(out ulong pcTablets);
     int GetTablet(ulong iTablet, out ITablet ppTablet);
 }

The above ITablet interface is not the focus of this article. We only need to define the empty interface and do not need to define the methods in it

[ComImport, Guid("1CB2EFC3-ABC7-4172-8FCB-3BC9CB93E29F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
 public interface ITablet //: IUnknown
 {
 }

Then in the code, first create the CLSID_TabletManagerS object and then convert it to the ITabletManager interface

Call CoCreateInstance with a class ID of CLSID_TabletManagerS, and then call QueryInterface to get a pointer to the ITabletManager Interface. The CLSID_TabletManagerS GUID is defined as follows: #define CLSID_TabletManagerS uuid(A5B020FD-E04B-4e67-B65A-E7DEED25B2CF)

The C# code corresponding to the above document is as follows

 var typeFromClsid = Type.GetTypeFromCLSID(new Guid("A5B020FD-E04B-4e67-B65A-E7DEED25B2CF"));
             object comObject = Activator.CreateInstance(typeFromClsid);

             var manager = comObject as ITabletManager;
             manager!.GetTabletCount(out var tabletCount);

Enable native debugging, run the code, and set a breakpoint at the last sentence of the above code. After entering the breakpoint, you can expand the native view of comObject and find the of the COM object. __vfptr address. Then according to the address, find the DLL file falling within the address range from the debugging module of VisualStudio. As shown below

Only when I wrote this did I see that the wisp.dll file has been written in VisualStudio. I don’t need to calculate the address myself, which is convenient

I learned that the current ITabletManager is defined in the C:\Windows\System32\wisp.dll file. You can throw this file into IDA and decompile it, as shown below

You can see that the GetPointerDevices method is used in line 53. I feel that this is the core implementation. This GetPointerDevices is a method to obtain the number of touch devices under the WM_Pointer touch series under Win10

That is to say, the core implementation of GetTabletCount of ITabletManager is in the POINTER mechanism again. This is beyond the scope of this article, but you can know that the underlying GetTabletCount of ITabletManager is also based on the POINTER mechanism.�Enough for me to play with. Because this reflects that Win11 is not retaining the old code, but just API redirection and adding compatible code. In other words, if a bug exists in the Pointer layer, then WPF’s COM touch layer will also exist. But the converse is not true. If there is a bug in the COM touch layer of WPF, it may be caused by Win11’s API calls or compatibility code, and it may not necessarily be a problem with Pointer

For a description of GetPointerDevices, see https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getpointerdevices

Simple GetPointerDevices usage can be called using PInvoke, as shown in the following example

First install the Microsoft.Windows.CsWin32 library, such as dotnet. Use the CsWin32 library to simplify the Win32 function calling logic. The method provided by the blog

Next write code to obtain touch information from GetPointerDevices

 StringBuilder stringBuilder = ...

                 // Get the number of Pointer devices
                 uint deviceCount = 0;
                 PInvoke.GetPointerDevices(ref deviceCount,
                     (Windows.Win32.UI.Controls.POINTER_DEVICE_INFO*)IntPtr.Zero);
                 Windows.Win32.UI.Controls.POINTER_DEVICE_INFO[] pointerDeviceInfo =
                     new Windows.Win32.UI.Controls.POINTER_DEVICE_INFO[deviceCount];
                 fixed (Windows.Win32.UI.Controls.POINTER_DEVICE_INFO* pDeviceInfo = &pointerDeviceInfo[0])
                 {
                     // You need to get it twice here, the first time to get the quantity, the second time to get the information
                     PInvoke.GetPointerDevices(ref deviceCount, pDeviceInfo);
                     stringBuilder.AppendLine($"PointerDeviceCount:{deviceCount} device list:");
                     foreach (var info in pointerDeviceInfo)
                     {
                         stringBuilder.AppendLine($" - {info.productString}");
                     }
                 }

GetPointerDevices needs to be called twice, the first to get the quantity and the second to get the information. When the first parameter passed in to GetPointerDevices is 0, it will not fill in the second parameter array information

The above is the underlying implementation of the GetTabletCount method of ITabletManager provided specifically for the WPF touch module in Windows 11 system

The Blog Garden blog only makes backups and will no longer be updated when the blog is published. If you want to see the latest blog, please go to https://blog.lindexi.com/

This work Licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. You are welcome to reprint, use and republish, but be sure to retain the article signature [Lin Dexi] (https://www.cnblogs.com/lindexi) (including link: https://www.cnblogs.com/lindexi) and may not be used for commercial purposes For this purpose, modified works based on this article must be released under the same license. If you have any questions, please contact me [mailto:lindexi_gd@163.com].