So I've been having a look around and it looks like I should be using the RealTimeStylus object instead of the InkCollector Object as it suits my needs better.
I've managed to create the RealTimeStylus object and it appears to work but i'm having trouble connecting to the events. I need to create a IStylusSyncPlugin object to handle the events but I can't figure out how to get it done.
My Current Code:
Code: Select all
#NoEnv
#SingleInstance Force
#Requires AutoHotkey v1.1.33+
if !RtsCOMDll := DllCall("LoadLibrary", "Str", "C:\Program Files\Common Files\microsoft shared\ink\rtscom.dll", "Ptr")
{
MsgBox % "rtscom.dll not found: " A_LastError
ExitApp
}
CLSID_IRealTimeStylus := "{E26B366D-F998-43ce-836F-CB6D904432B0}"
IID_IRealTimeStylus := "{A8BB5D22-3144-4a7b-93CD-F34A16BE513A}"
IID_IStylusSyncPlugin := "{A157B174-482F-4d71-A3F6-3A41DDD11BE9}"
pRealTimeStylus := ComObjCreate(CLSID_IRealTimeStylus, IID_IRealTimeStylus)
pRealTimeStylusVtbl := NumGet(pRealTimeStylus+0, "Ptr")
pput_hWnd := NumGet(pRealTimeStylusVtbl + (6 * A_PtrSize), "Ptr")
pput_Enabled := NumGet(pRealTimeStylusVtbl + (4 * A_PtrSize), "Ptr")
pAddStylusSyncPlugin := NumGet(pRealTimeStylusVtbl + (9 * A_PtrSize), "Ptr")
VARIANT_TRUE := -1
VARIANT_False := 0
S_OK := 0
; the hwnd of a window, which will host the InkCollector, is required, so we create our own
Gui New, +HwndhGui +AlwaysOnTop ; -Caption
Gui Show, w400 h200, write inside me
WinSet, Transparent , 100, ahk_id %hGui%
; associate the InkCollector with our GUI
hr := DllCall(pput_hWnd, "Ptr", pRealTimeStylus, "Ptr", hGui, "Ptr")
if (hr != S_OK)
{
MsgBox % "pRealTimeStylus::put_hWnd failed, HRESULT was " hr ". ErrorLevel was " ErrorLevel
ExitApp
}
; RTS must be disabled to Add a StylusPlugin
hr := DllCall(pput_Enabled, "Ptr", pRealTimeStylus, "Short", VARIANT_False, "Ptr")
if (hr != S_OK)
{
MsgBox % "pRealTimeStylus::put_Enabled failed, HRESULT was " hr ". ErrorLevel was " ErrorLevel
ExitApp
}
/*
HRESULT ( STDMETHODCALLTYPE *AddStylusSyncPlugin )(
__RPC__in IRealTimeStylus * This,
/* [in] */ ULONG iIndex,
/* [in] */ __RPC__in_opt IStylusSyncPlugin *piPlugin);
*/
iIndex := 0
StylusSyncPlugin := new IStylusPlugin
hr := DllCall(pAddStylusSyncPlugin, "Ptr", pRealTimeStylus, "UInt", iIndex, "Ptr", StylusSyncPlugin, "Ptr")
if (hr != S_OK)
{
MsgBox % "pRealTimeStylus::AddStylusSyncPlugin, HRESULT was " hr ". ErrorLevel was " ErrorLevel
ExitApp
}
;enable RTS anfer Plugin is added
hr := DllCall(pput_Enabled, "Ptr", pRealTimeStylus, "Short", VARIANT_true, "Ptr")
if (hr != S_OK)
{
MsgBox % "pRealTimeStylus::put_Enabled failed, HRESULT was " hr ". ErrorLevel was " ErrorLevel
ExitApp
}
return
class IStylusPlugin
{
QueryInterface(thisInst,riid,ppvObject){
traytip, , testing
}
AddRef(thisInst){
}
Release(thisInst){
}
RealTimeStylusEnabled(thisInst,piRtsSrc,cTcidCount,pTcids){
}
RealTimeStylusDisabled(thisInst,piRtsSrc,cTcidCount,pTcids){
}
StylusInRange(thisInst,piRtsSrc,tcid,sid){
}
StylusOutOfRange(thisInst,piRtsSrc,tcid,sid){
}
StylusDown(thisInst,piRtsSrc,pStylusInfo,cPropCountPerPkt,pPacket,ppInOutPkt){
}
StylusUp(thisInst,piRtsSrc,pStylusInfo,cPropCountPerPkt,pPacket,ppInOutPkt){
}
StylusButtonDown(thisInst,piRtsSrc,sid,pGuidStylusButton,pStylusPos){
}
StylusButtonUp(thisInst,piRtsSrc,sid,pGuidStylusButton,pStylusPos){
}
InAirPackets(thisInst,piRtsSrc,pStylusInfo,cPktCount,cPktBuffLength,pPackets,pcInOutPkts,ppInOutPkts){
}
Packets(thisInst,piRtsSrc,pStylusInfo,cPktCount,cPktBuffLength,pPackets,pcInOutPkts,ppInOutPkts){
}
CustomStylusDataAdded(thisInst,piRtsSrc,pGuidId,cbData,pbData){
}
SystemEvent(thisInst,piRtsSrc,tcid,sid,event,eventdata){
}
TabletAdded(thisInst,piRtsSrc,piTablet){
}
TabletRemoved(thisInst,piRtsSrc,iTabletIndex){
}
Error(thisInst,piRtsSrc,piPlugin,dataInterest,hrErrorCode,lptrKey){
}
UpdateMapping(thisInst,piRtsSrc){
}
DataInterest(thisInst,pDataInterest){
}
}
rtsHeaderFile
https://github.com/tpn/winsdk-7/blob/master/v7.1A/Include/RTSCOM.h
Example of the plugin being created - from
https://github.com/microsoft/Windows-classic-samples/blob/master/Samples/Win7Samples/Touch/MTScratchpadRTStylus/cpp/MTScratchpadRTStylus.cpp
Code: Select all
///////////////////////////////////////////////////////////////////////////////
// Real Time Stylus sync event handler
// Synchronous plugin, notitification receiver that changes pen color.
class CSyncEventHandlerRTS : public IStylusSyncPlugin
{
CSyncEventHandlerRTS();
virtual ~CSyncEventHandlerRTS();
public:
// Factory method
static IStylusSyncPlugin* Create(IRealTimeStylus* pRealTimeStylus);
// IStylusSyncPlugin methods
// Handled IStylusSyncPlugin methods, they require nontrivial implementation
STDMETHOD(StylusDown)(IRealTimeStylus* piSrcRtp, const StylusInfo* pStylusInfo, ULONG cPropCountPerPkt, LONG* pPacket, LONG** ppInOutPkt);
STDMETHOD(StylusUp)(IRealTimeStylus* piSrcRtp, const StylusInfo* pStylusInfo, ULONG cPropCountPerPkt, LONG* pPacket, LONG** ppInOutPkt);
STDMETHOD(Packets)(IRealTimeStylus* piSrcRtp, const StylusInfo* pStylusInfo, ULONG cPktCount, ULONG cPktBuffLength, LONG* pPackets, ULONG* pcInOutPkts, LONG** ppInOutPkts);
STDMETHOD(DataInterest)(RealTimeStylusDataInterest* pEventInterest);
// IStylusSyncPlugin methods with trivial inline implementation, they all return S_OK
STDMETHOD(RealTimeStylusEnabled)(IRealTimeStylus*, ULONG, const TABLET_CONTEXT_ID*) { return S_OK; }
STDMETHOD(RealTimeStylusDisabled)(IRealTimeStylus*, ULONG, const TABLET_CONTEXT_ID*) { return S_OK; }
STDMETHOD(StylusInRange)(IRealTimeStylus*, TABLET_CONTEXT_ID, STYLUS_ID) { return S_OK; }
STDMETHOD(StylusOutOfRange)(IRealTimeStylus*, TABLET_CONTEXT_ID, STYLUS_ID) { return S_OK; }
STDMETHOD(InAirPackets)(IRealTimeStylus*, const StylusInfo*, ULONG, ULONG, LONG*, ULONG*, LONG**) { return S_OK; }
STDMETHOD(StylusButtonUp)(IRealTimeStylus*, STYLUS_ID, const GUID*, POINT*) { return S_OK; }
STDMETHOD(StylusButtonDown)(IRealTimeStylus*, STYLUS_ID, const GUID*, POINT*) { return S_OK; }
STDMETHOD(SystemEvent)(IRealTimeStylus*, TABLET_CONTEXT_ID, STYLUS_ID, SYSTEM_EVENT, SYSTEM_EVENT_DATA) { return S_OK; }
STDMETHOD(TabletAdded)(IRealTimeStylus*, IInkTablet*) { return S_OK; }
STDMETHOD(TabletRemoved)(IRealTimeStylus*, LONG) { return S_OK; }
STDMETHOD(CustomStylusDataAdded)(IRealTimeStylus*, const GUID*, ULONG, const BYTE*) { return S_OK; }
STDMETHOD(Error)(IRealTimeStylus*, IStylusPlugin*, RealTimeStylusDataInterest, HRESULT, LONG_PTR*) { return S_OK; }
STDMETHOD(UpdateMapping)(IRealTimeStylus*) { return S_OK; }
// IUnknown methods
STDMETHOD_(ULONG,AddRef)();
STDMETHOD_(ULONG,Release)();
STDMETHOD(QueryInterface)(REFIID riid, LPVOID *ppvObj);
private:
LONG m_cRefCount; // COM object reference count
IUnknown* m_punkFTMarshaller; // free-threaded marshaller
int m_nContacts; // number of fingers currently in the contact with the touch digitizer
};
// CSyncEventHandlerRTS constructor.
CSyncEventHandlerRTS::CSyncEventHandlerRTS()
: m_cRefCount(1),
m_punkFTMarshaller(NULL),
m_nContacts(0)
{
}
// CSyncEventHandlerRTS destructor.
CSyncEventHandlerRTS::~CSyncEventHandlerRTS()
{
if (m_punkFTMarshaller != NULL)
{
m_punkFTMarshaller->Release();
}
}
// CSyncEventHandlerRTS factory method: creates new CSyncEventHandlerRTS and adds it to the synchronous
// plugin list of the RTS object.
// in:
// pRealTimeStylus RTS object
// returns:
// CSyncEventHandlerRTS object through IStylusSyncPlugin interface, or NULL on failure
IStylusSyncPlugin* CSyncEventHandlerRTS::Create(IRealTimeStylus* pRealTimeStylus)
{
// Check input argument
if (pRealTimeStylus == NULL)
{
ASSERT(pRealTimeStylus != NULL && L"CSyncEventHandlerRTS::Create: invalid argument RealTimeStylus");
return NULL;
}
// Instantiate CSyncEventHandlerRTS object
CSyncEventHandlerRTS* pSyncEventHandlerRTS = new CSyncEventHandlerRTS();
if (pSyncEventHandlerRTS == NULL)
{
ASSERT(pSyncEventHandlerRTS != NULL && L"CSyncEventHandlerRTS::Create: cannot create instance of CSyncEventHandlerRTS");
return NULL;
}
// Create free-threaded marshaller for this object and aggregate it.
HRESULT hr = CoCreateFreeThreadedMarshaler(pSyncEventHandlerRTS, &pSyncEventHandlerRTS->m_punkFTMarshaller);
if (FAILED(hr))
{
ASSERT(SUCCEEDED(hr) && L"CSyncEventHandlerRTS::Create: cannot create free-threaded marshaller");
pSyncEventHandlerRTS->Release();
return NULL;
}
// Add CSyncEventHandlerRTS object to the list of synchronous plugins in the RTS object.
hr = pRealTimeStylus->AddStylusSyncPlugin(
0, // insert plugin at position 0 in the sync plugin list
pSyncEventHandlerRTS); // plugin to be inserted - event handler CSyncEventHandlerRTS
if (FAILED(hr))
{
ASSERT(SUCCEEDED(hr) && L"CEventHandlerRTS::Create: failed to add CSyncEventHandlerRTS to the RealTimeStylus plugins");
pSyncEventHandlerRTS->Release();
return NULL;
}
return pSyncEventHandlerRTS;
}
// Pen-down notification.
// Sets the color for the newly started stroke and increments finger-down counter.
// in:
// piRtsSrc RTS object that has sent this event
// pStylusInfo StylusInfo struct (context ID, cursor ID, etc)
// cPropCountPerPkt number of properties per packet
// pPacket packet data (layout depends on packet description set)
// in/out:
// ppInOutPkt modified packet data (same layout as pPackets)
// returns:
// HRESULT error code
HRESULT CSyncEventHandlerRTS::StylusDown(
IRealTimeStylus* /* piRtsSrc */,
const StylusInfo* /* pStylusInfo */,
ULONG /* cPropCountPerPkt */,
LONG* /* pPacket */,
LONG** /* ppInOutPkt */)
{
// Get DrawingAttributes of DynamicRenderer
IInkDrawingAttributes* pDrawingAttributesDynamicRenderer;
HRESULT hr = g_pDynamicRenderer->get_DrawingAttributes(&pDrawingAttributesDynamicRenderer);
if (FAILED(hr))
{
ASSERT(SUCCEEDED(hr) && L"CSyncEventHandlerRTS::StylusDown: failed to get RTS's drawing attributes");
return hr;
}
// Set new stroke color to the DrawingAttributes of the DynamicRenderer
// If there are no fingers down, this is a primary contact
hr = pDrawingAttributesDynamicRenderer->put_Color(GetTouchColor(m_nContacts == 0));
if (FAILED(hr))
{
ASSERT(SUCCEEDED(hr) && L"CSyncEventHandlerRTS::StylusDown: failed to set color");
pDrawingAttributesDynamicRenderer->Release();
return hr;
}
pDrawingAttributesDynamicRenderer->Release();
++m_nContacts; // Increment finger-down counter
return S_OK;
}
// Pen-up notification.
// Decrements finger-down counter.
// in:
// piRtsSrc RTS object that has sent this event
// pStylusInfo StylusInfo struct (context ID, cursor ID, etc)
// cPropCountPerPkt number of properties per packet
// pPacket packet data (layout depends on packet description set)
// in/out:
// ppInOutPkt modified packet data (same layout as pPackets)
// returns:
// HRESULT error code
HRESULT CSyncEventHandlerRTS::StylusUp(
IRealTimeStylus* /* piRtsSrc */,
const StylusInfo* /* pStylusInfo */,
ULONG /* cPropCountPerPkt */,
LONG* /* pPacket */,
LONG** /* ppInOutPkt */)
{
--m_nContacts; // Decrement finger-down counter
return S_OK;
}
// Pen-move notification.
// In this case, does nothing, but likely to be used in a more complex application.
// RTS framework does stroke collection and rendering for us.
// in:
// piRtsRtp RTS object that has sent this event
// pStylusInfo StylusInfo struct (context ID, cursor ID, etc)
// cPktCount number of packets
// cPktBuffLength pPacket buffer size, in elements, equal to number of packets times number of properties per packet
// pPackets packet data (layout depends on packet description set)
// in/out:
// pcInOutPkts modified number of packets
// ppInOutPkts modified packet data (same layout as pPackets)
// returns:
// HRESULT error code
HRESULT CSyncEventHandlerRTS::Packets(
IRealTimeStylus* /* piSrcRtp */,
const StylusInfo* /* pStylusInfo */,
ULONG /* cPktCount */,
ULONG /* cPktBuffLength */,
LONG* /* pPackets */,
ULONG* /* pcInOutPkts */,
LONG** /* ppInOutPkts */)
{
return S_OK;
}
// Defines which handlers are called by the framework. We set the flags for pen-down, pen-up and pen-move.
// in/out:
// pDataInterest flags that enable/disable notification handlers
// returns:
// HRESULT error code
HRESULT CSyncEventHandlerRTS::DataInterest(RealTimeStylusDataInterest *pDataInterest)
{
*pDataInterest = (RealTimeStylusDataInterest)(RTSDI_StylusDown | RTSDI_Packets | RTSDI_StylusUp);
return S_OK;
}
// Increments reference count of the COM object.
// returns:
// reference count
ULONG CSyncEventHandlerRTS::AddRef()
{
return InterlockedIncrement(&m_cRefCount);
}
// Decrements reference count of the COM object, and deletes it
// if there are no more references left.
// returns:
// reference count
ULONG CSyncEventHandlerRTS::Release()
{
ULONG cNewRefCount = InterlockedDecrement(&m_cRefCount);
if (cNewRefCount == 0)
{
delete this;
}
return cNewRefCount;
}
// Returns a pointer to any interface supported by this object.
// If IID_IMarshal interface is requested, delegate the call to the aggregated
// free-threaded marshaller.
// If a valid pointer is returned, COM object reference count is increased.
// returns:
// pointer to the interface requested, or NULL if the interface is not supported by this object
HRESULT CSyncEventHandlerRTS::QueryInterface(REFIID riid, LPVOID *ppvObj)
{
if ((riid == IID_IStylusSyncPlugin) || (riid == IID_IUnknown))
{
*ppvObj = this;
AddRef();
return S_OK;
}
else if ((riid == IID_IMarshal) && (m_punkFTMarshaller != NULL))
{
return m_punkFTMarshaller->QueryInterface(riid, ppvObj);
}
*ppvObj = NULL;
return E_NOINTERFACE;
}
sample from MSDN --
https://docs.microsoft.com/en-us/windows/win32/tablet/realtimestylus-plug-in-sample
If anyone has any Ideas on how i can get this working that would be great.
Thanks Grimbot
