2021年5月25日星期二

dotnet 读 WPF 源代码笔记 插入触摸设备的初始化获取设备信息

在 WPF 触摸应用中，插入触摸设备，即可在应用里面使用上插入的触摸设备。在 WPF 使用触摸设备的触摸时，需要获取到触摸设备的信息，才能实现触摸

在 WPF 触摸应用中，插入触摸设备，即可在应用里面使用上插入的触摸设备。在 WPF 使用触摸设备的触摸时，需要获取到触摸设备的信息，才能实现触摸

获取触摸设备插入

在 WPF 中，通过 Windows 消息获取触摸设备插入事件，在 src\Microsoft.DotNet.Wpf\src\PresentationCore\System\Windows\Input\Stylus\Wisp\WispLogic.cs 的 HandleMessage 将获取 Windows 消息，代码如下

  internal override void HandleMessage(WindowMessage msg, IntPtr wParam, IntPtr lParam)  {   switch (msg)   {    // 忽略代码    case WindowMessage.WM_TABLET_ADDED:     OnTabletAdded((uint)NativeMethods.IntPtrToInt32(wParam));     break;    case WindowMessage.WM_TABLET_DELETED:     OnTabletRemovedImpl((uint)NativeMethods.IntPtrToInt32(wParam), isInternalCall: true);     break;   }  }

在 WPF 框架，使用 WM_TABLET_ADDED 和 WM_TABLET_DELETED 消息获取设备的插入和删除事件

如上面代码，在设备插入时，将会调用 OnTabletAdded 方法。如 WM_TABLET_ADDED 官方文档描述，以上代码获取的参数是 Wisptis 的 Index 序号。这是因为用户可以插入多个触摸设备，通过传入序号可以拿到插入的设备

在 WPF 中，每次插入触摸设备，都会重新更新所有的触摸设备的信息，而不是只更新插入的设备。在 OnTabletAdded 方法里面，将会调用 GetDeviceCount 方法，在 GetDeviceCount 方法里面将通过 PenThread 的 WorkerGetTabletsInfo 更新所有触摸设备的信息，代码如下

  private void OnTabletAdded(uint wisptisIndex)  {   lock (__penContextsLock)   {    WispTabletDeviceCollection tabletDeviceCollection = WispTabletDevices;    // 忽略代码    // Update the last known device count.    _lastKnownDeviceCount = GetDeviceCount();    uint tabletIndex = UInt32.MaxValue;    // HandleTabletAdded returns true if we need to update contexts due to a change in tablet devices.    if (tabletDeviceCollection.HandleTabletAdded(wisptisIndex, ref tabletIndex))    {      // Update all contexts with this new tablet device.      foreach (PenContexts contexts in __penContextsMap.Values)      {       contexts.AddContext(tabletIndex);      }    }   }  }  private int GetDeviceCount()  {   PenThread penThread = null;   // Get a PenThread by mimicking a subset of the code in TabletDeviceCollection.UpdateTablets().   TabletDeviceCollection tabletDeviceCollection = TabletDevices;   if (tabletDeviceCollection != null && tabletDeviceCollection.Count > 0)   {    penThread = tabletDeviceCollection[0].As<WispTabletDevice>().PenThread;   }   if (penThread != null)   {    // Use the PenThread to get the full, unfiltered tablets info to see how many there are.    TabletDeviceInfo[] tabletdevices = penThread.WorkerGetTabletsInfo();    return tabletdevices.Length;   }   else   {    // if there's no PenThread yet, return "unknown"    return -1;   }} // WPF 代码格式化就是这样

以上代码调用 WorkerGetTabletsInfo 方法实际的获取触摸信息逻辑是放在触摸线程，上面代码需要先获取触摸线程 PenThread 然后调用触摸线程类的 WorkerGetTabletsInfo 方法，在这个方法里面执行逻辑

触摸线程

在 WPF 触摸到事件 博客里面告诉大家，在 WPF 框架，为了让触摸的性能足够强，将触摸的获取放在独立的进程里面

在获取触摸信息时，也需要调度到触摸线程执行。在 WPF 中，通过 PenThread 类的相关方法可以调度到触摸线程

在调用 WorkerGetTabletsInfo 方法时，进入 WorkerGetTabletsInfo 方法依然是主线程，里面代码如下

  internal TabletDeviceInfo[] WorkerGetTabletsInfo()  {   // Set data up for this call   WorkerOperationGetTabletsInfo getTablets = new WorkerOperationGetTabletsInfo();      lock(_workerOperationLock)   {    _workerOperation.Add(getTablets);   }   // Kick thread to do this work.   MS.Win32.Penimc.UnsafeNativeMethods.RaiseResetEvent(_pimcResetHandle.Value);   // Wait for this work to be completed.   getTablets.DoneEvent.WaitOne();   getTablets.DoneEvent.Close();     return getTablets.TabletDevicesInfo;  }

实际上以上代码是放在 PenThreadWorker.cs 文件中，在 WPF 的触摸线程设计上，触摸线程是一个循环，将会等待 PenImc 层发送触摸消息，或者等待 _pimcResetHandle 锁被释放。如上面代码，先插入 WorkerOperationGetTabletsInfo 到 _workerOperation 列表中，然后调用 RaiseResetEvent 方法释放 _pimcResetHandle 对象。触摸线程将会因为 _pimcResetHandle 被释放而跳出循环，然后获取 _workerOperation 列表里面的项，进行执行逻辑

主线程将会在 getTablets.DoneEvent.WaitOne 方法里面进入锁，等待触摸线程执行 WorkerOperationGetTabletsInfo 完成之后释放这个锁，才能让主线程继续执行

触摸线程的循环逻辑代码大概如下

  internal void ThreadProc()  {   Thread.CurrentThread.Name = "Stylus Input";   while (!__disposed)   {     // 忽略代码     WorkerOperation[] workerOps = null;     lock(_workerOperationLock)     {      if (_workerOperation.Count > 0)      {       workerOps = _workerOperation.ToArray();       _workerOperation.Clear();      }     }     if (workerOps != null)     {      for (int j=0; j<workerOps.Length; j++)      {       workerOps[j].DoWork();      }      workerOps = null;     }     // 这是第二层循环     while (true)     {       // 忽略代码     	 if (!MS.Win32.Penimc.UnsafeNativeMethods.GetPenEvent(        _handles[0], _pimcResetHandle.Value,        out evt, out stylusPointerId,        out cPackets, out cbPacket, out pPackets))       {        break;       }     }   }

默认 WPF 的触摸线程都会在第二层循环，在 GetPenEvent 方法里面等待 PenImc 发送触摸消息或等待 _pimcResetHandle 释放。在跳出第二层循环，将会去获取 _workerOperation 的项，然后执行

     WorkerOperation[] workerOps = null;     lock(_workerOperationLock)     {      if (_workerOperation.Count > 0)      {       workerOps = _workerOperation.ToArray();       _workerOperation.Clear();      }     }     if (workerOps != null)     {      for (int j=0; j<workerOps.Length; j++)      {       workerOps[j].DoWork();      }      workerOps = null;     }

获取触摸信息

在调用 WorkerOperationGetTabletsInfo 的 DoWork 方法时，将会在触摸线程获取触摸设备信息

  private class WorkerOperationGetTabletsInfo : WorkerOperation  {   internal TabletDeviceInfo[] TabletDevicesInfo   {    get { return _tabletDevicesInfo;}   }   /////////////////////////////////////////////////////////////////////////   /// <summary>   ///  Returns the list of TabletDeviceInfo structs that contain information   ///  about all of the TabletDevices on the system.   /// </summary>   protected override void OnDoWork()   {    try    {     // create new collection of tablets     MS.Win32.Penimc.IPimcManager3 pimcManager = MS.Win32.Penimc.UnsafeNativeMethods.PimcManager;     uint cTablets;     pimcManager.GetTabletCount(out cTablets);     TabletDeviceInfo[] tablets = new TabletDeviceInfo[cTablets];     for ( uint iTablet = 0; iTablet < cTablets; iTablet++ )     {      MS.Win32.Penimc.IPimcTablet3 pimcTablet;      pimcManager.GetTablet(iTablet, out pimcTablet);      tablets[iTablet] = PenThreadWorker.GetTabletInfoHelper(pimcTablet);     }     // Set result data and signal we are done.     _tabletDevicesInfo = tablets;    }    catch (Exception e) when (PenThreadWorker.IsKnownException(e))    {     Debug.WriteLine("WorkerOperationGetTabletsInfo.OnDoWork failed due to: {0}{1}", Environment.NewLine, e.ToString());    }   }   TabletDeviceInfo[] _tabletDevicesInfo = Array.Empty<TabletDeviceInfo>();  }

上面代码的 IPimcManager3 接口是一个 COM 接口，实际逻辑是在 PenImc 层进行定义，在 PenImcRcw.cs 引用，代码如下

 [ ComImport, Guid(PimcConstants.IPimcManager3IID), InterfaceType(ComInterfaceType.InterfaceIsIUnknown) ] interface IPimcManager3 {  void GetTabletCount(out UInt32 count);  void GetTablet(UInt32 tablet, out IPimcTablet3 IPimcTablet); }

在 PenImc 层的 PenImc.idl 文件里面，定义了公开的接口

[	object,	uuid(BD2C38C2-E064-41D0-A999-940F526219C2),	nonextensible,	helpstring("IPimcManager3 Interface"),	pointer_default(unique)]interface IPimcManager3 : IUnknown { [helpstring("method GetTabletCount")] HRESULT GetTabletCount([out] ULONG* pcTablets); [helpstring("method GetTablet")  ] HRESULT GetTablet([in] ULONG iTablet, [out] IPimcTablet3** ppTablet);};

在 WPF 中，在 C# 代码使用的不是最底层的方法，也就是 BD2C38C2-E064-41D0-A999-940F526219C2 组件只是 WPF 用的，而不是系统等给的接口

实际调用底层的代码是在 PenImc 层的 C++ 代码，但 PenImc 层的 C++ 代码只是一层转发调用而已，换句话说，如果使用 C# 调用底层的系统的组件也是完全可以的

如上面代码通过 GetTabletCount 方法获取当前的触摸设备，此方法是通过 COM 调用到在 PenImc.idl 文件定义的 GetTabletCount 获取的，实际定义的代码是 PimcManager.cpp 文件的 GetTabletCount 方法

STDMETHODIMP CPimcManager::GetTabletCount(__out ULONG* pcTablets){ DHR; ULONG cTablets = 0; LoadWisptis(); // Try to load wisptis via the surrogate object.  // we will return 0 in the case that there is no stylus since mouse is not considered a stylus anymore if (m_fLoadedWisptis) {  CHR(m_pMgrS->GetTabletCount(&cTablets)); }  *pcTablets = cTablets; CLEANUP: RHR;}

以上代码里面用到了一些宏，如 DHR 的含义是定义 HRESULT 变量，代码如下

#define DHR           \ HRESULT hr = S_OK;

而 CHR 表示的是判断 HRESULT 的值，如果失败了，将会调用 CLEANUP 标签的内容。在 CHR 里面用到 goto 的方法

#define CHR(hr_op)         \ {            \  hr = hr_op;         \  if (FAILED(hr))        \   goto CLEANUP;       \ }

上面代码的 RHR 表示的是返回 HRESULT 变量

#define RHR           \ return hr;

因此以上代码实际就是如下代码

STDMETHODIMP CPimcManager::GetTabletCount(__out ULONG* pcTablets){ HRESULT hr = S_OK; ULONG cTablets = 0; LoadWisptis(); // Try to load wisptis via the surrogate object.  // we will return 0 in the case that there is no stylus since mouse is not considered a stylus anymore if (m_fLoadedWisptis) {  hr = m_pMgrS->GetTabletCount(&cTablets);  if (FAILED(hr))  {   goto CLEANUP;  } }  *pcTablets = cTablets; CLEANUP: return hr;}

通过上面代码可以看到，实际调用的是 m_pMgrS 的 GetTabletCount 方法，也就是如下代码定义的方法

 MIDL_INTERFACE("764DE8AA-1867-47C1-8F6A-122445ABD89A") ITabletManager : public IUnknown { public:  virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetDefaultTablet(    /* [out] */ __RPC__deref_out_opt ITablet **ppTablet) = 0;    virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetTabletCount(    /* [out] */ __RPC__out ULONG *pcTablets) = 0;    virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetTablet(    /* [in] */ ULONG iTablet,   /* [out] */ __RPC__deref_out_opt ITablet **ppTablet) = 0;    virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetTabletContextById(    /* [in] */ TABLET_CONTEXT_ID tcid,   /* [out] */ __RPC__deref_out_opt ITabletContext **ppContext) = 0;    virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetCursorById(    /* [in] */ CURSOR_ID cid,   /* [out] */ __RPC__deref_out_opt ITabletCursor **ppCursor) = 0;   };

可以看到这是一个 COM 接口调用，实际使用的就是系统提供的 ITabletManager 组件

在底层系统组件，先调用 ITabletManager 的 GetTabletCount 方法 获取触摸设备数量，然后遍历触摸设备序号拿到 ITablet 对象

在 C# 代码里面的逻辑如下

     pimcManager.GetTabletCount(out cTablets);     TabletDeviceInfo[] tablets = new TabletDeviceInfo[cTablets];     for ( uint iTablet = 0; iTablet < cTablets; iTablet++ )     {      MS.Win32.Penimc.IPimcTablet3 pimcTablet;      pimcManager.GetTablet(iTablet, out pimcTablet);      tablets[iTablet] = PenThreadWorker.GetTabletInfoHelper(pimcTablet);     }

这里的 pimcManager.GetTablet 方法将会调用到 PimcManager.cpp 的 GetTablet 方法

STDMETHODIMP CPimcManager::GetTablet(ULONG iTablet, __deref_out IPimcTablet3** ppTablet){ DHR; switch (iTablet) {  case RELEASE_MANAGER_EXT:  {   CHR(m_managerLock.Unlock());  }  break;  default:  {   CHR(GetTabletImpl(iTablet, ppTablet));  } }CLEANUP: RHR;}STDMETHODIMP CPimcManager::GetTabletImpl(ULONG iTablet, __deref_out IPimcTablet3** ppTablet){ DHR; LoadWisptis(); // Make sure wisptis has been loaded! (Can happen when handling OnTabletAdded message)  CComPtr<ITablet>   pTabS; CComObject<CPimcTablet> * pTabC; // Can only call if we have real tablet hardware which means wisptis must be loaded! CHR(m_fLoadedWisptis ? S_OK : E_UNEXPECTED); CHR(CComObject<CPimcTablet>::CreateInstance(&pTabC)); CHR(pTabC->QueryInterface(IID_IPimcTablet3, (void**)ppTablet)); CHR(m_pMgrS->GetTablet(iTablet, &pTabS)); CHR(pTabC->Init(m_fLoadedWisptis?pTabS:NULL, this));CLEANUP: RHR;}

本质调用的是 m_pMgrS 的 GetTablet 方法，也就是系统提供的 ITabletManager 的 GetTablet 方法 获取 ITablet 接口。只是在 C++ 代码里面，将 ITablet 接口再做一层封装，返回给 C# 的是 IPimcTablet3 接口

接下来就是通过 PenThreadWorker 的 GetTabletInfoHelper 方法获取触摸信息

  private static TabletDeviceInfo GetTabletInfoHelper(IPimcTablet3 pimcTablet)  {   TabletDeviceInfo tabletInfo = new TabletDeviceInfo();   tabletInfo.PimcTablet = new SecurityCriticalDataClass<IPimcTablet3>(pimcTablet);   pimcTablet.GetKey(out tabletInfo.Id);   pimcTablet.GetName(out tabletInfo.Name);   pimcTablet.GetPlugAndPlayId(out tabletInfo.PlugAndPlayId);   int iTabletWidth, iTabletHeight, iDisplayWidth, iDisplayHeight;   pimcTablet.GetTabletAndDisplaySize(out iTabletWidth, out iTabletHeight, out iDisplayWidth, out iDisplayHeight);   tabletInfo.SizeInfo = new TabletDeviceSizeInfo(new Size(iTabletWidth, iTabletHeight),               new Size(iDisplayWidth, iDisplayHeight));   int caps;   pimcTablet.GetHardwareCaps(out caps);   tabletInfo.HardwareCapabilities = (TabletHardwareCapabilities)caps;   int deviceType;   pimcTablet.GetDeviceType(out deviceType);   tabletInfo.DeviceType = (TabletDeviceType)(deviceType -1);   //    // REENTRANCY NOTE: Let a PenThread do this work to avoid reentrancy!   //     The IPimcTablet3 object is created in the pen thread. If we access it from the UI thread,   //     COM will set up message pumping which will cause reentrancy here.   InitializeSupportedStylusPointProperties(pimcTablet, tabletInfo);   tabletInfo.StylusDevicesInfo = GetStylusDevicesInfo(pimcTablet);      // Obtain the WispTabletKey for future use in locking the WISP tablet.   tabletInfo.WispTabletKey = MS.Win32.Penimc.UnsafeNativeMethods.QueryWispTabletKey(pimcTablet);      // If the manager has not already been created and locked, we will lock it here. This is the first opportunity   // we will have to lock the manager as it will have been created on the thread to instantiate the first tablet.   MS.Win32.Penimc.UnsafeNativeMethods.SetWispManagerKey(pimcTablet);   MS.Win32.Penimc.UnsafeNativeMethods.LockWispManager();   return tabletInfo;  }

实际调用的就是 ITablet 接口 的方法

以上代码的 pimcTablet.GetKey 方法是在 C++ 层封装的，而不是系统提供的

STDMETHODIMP CPimcTablet::GetKey(__out INT * pKey){ DHR; CHR(pKey ? S_OK : E_INVALIDARG); *pKey = (INT)PtrToInt(m_pTabS.p);CLEANUP: RHR;} CComPtr<ITablet>  m_pTabS;

在 WPF 框架，获取的方法本质就是通过 Tablet PC 系统组件获取

更多触摸请看 WPF 触摸相关









原文转载：http://www.shaoqun.com/a/760830.html

跨境电商：https://www.ikjzd.com/

易麦：https://www.ikjzd.com/w/2048

识货：https://www.ikjzd.com/w/1745


在WPF触摸应用中，插入触摸设备，即可在应用里面使用上插入的触摸设备。在WPF使用触摸设备的触摸时，需要获取到触摸设备的信息，才能实现触摸在WPF触摸应用中，插入触摸设备，即可在应用里面使用上插入的触摸设备。在WPF使用触摸设备的触摸时，需要获取到触摸设备的信息，才能实现触摸获取触摸设备插入在WPF中，通过Windows消息获取触摸设备插入事件，在src\Microsoft.DotNet.Wpf\
瀚霖：https://www.ikjzd.com/w/2345
shirley：https://www.ikjzd.com/w/1684
汇通天下物流：https://www.ikjzd.com/w/2055
这有一份7月亚马逊爆单产品清单，请查收！：https://www.ikjzd.com/articles/144316
被罚530万！亚马逊退货政策"巨变"，卖家买单？：https://www.ikjzd.com/articles/143031
卖家必看，亚马逊选品你不得不知的秘诀：https://www.ikjzd.com/articles/134142
发帖者 时间：