diff --git a/.gitignore b/.gitignore index e5e3927..6630515 100644 --- a/.gitignore +++ b/.gitignore @@ -56,3 +56,4 @@ /mingw-w64-v4.0.0.tar.bz2 /mingw-w64-v4.0.1.tar.bz2 /mingw-w64-v4.0.2.tar.bz2 +/mingw-w64-v4.0.4.tar.bz2 diff --git a/commit-4ce7a79 b/commit-4ce7a79 new file mode 100644 index 0000000..e78370b --- /dev/null +++ b/commit-4ce7a79 @@ -0,0 +1,56 @@ +From 4ce7a79ee9b1099f9762ee7a4d9f7ad1bbc01bc9 Mon Sep 17 00:00:00 2001 +From: Jacek Caban +Date: Fri, 22 May 2015 16:25:01 +0200 +Subject: Install *.c files as headers as well. + + +diff --git a/mingw-w64-headers/Makefile.am b/mingw-w64-headers/Makefile.am +index a8f0990..2e66933 100644 +--- a/mingw-w64-headers/Makefile.am ++++ b/mingw-w64-headers/Makefile.am +@@ -36,6 +36,7 @@ dist-hook: + find $(distdir) -name ".svn" -type d -delete + + EXTRA_HEADERS = \ ++ include/*.c \ + include/*.dlg \ + include/*.h \ + include/*.h16 \ +diff --git a/mingw-w64-headers/Makefile.in b/mingw-w64-headers/Makefile.in +index 901ff18..f0b4066 100644 +--- a/mingw-w64-headers/Makefile.in ++++ b/mingw-w64-headers/Makefile.in +@@ -262,6 +262,7 @@ CLEANFILES = $(nodist_sdkshead_HEADERS) + DISTCHECK_CONFIGURE_FLAGS = --enable-crt --enable-sdk=all --enable-idl + EXTRA_DIST = $(srcdir)/ChangeLog.* include crt direct-x ddk + EXTRA_HEADERS = \ ++ include/*.c \ + include/*.dlg \ + include/*.h \ + include/*.h16 \ +diff --git a/mingw-w64-headers/configure b/mingw-w64-headers/configure +index 8de18ee..abc4d42 100755 +--- a/mingw-w64-headers/configure ++++ b/mingw-w64-headers/configure +@@ -2547,7 +2547,7 @@ fi + + BASEHEAD_LIST="crt/_bsd_types.h crt/_cygwin.h crt/_mingw.h crt/_mingw_mac.h crt/_mingw_print_push.h crt/_mingw_print_pop.h crt/_mingw_secapi.h crt/_mingw_unicode.h crt/_timeval.h crt/crtdefs.h crt/excpt.h crt/intrin.h crt/vadefs.h crt/tchar.h "$srcdir/include/*.h + SECHEAD_LIST="$srcdir/crt/sec_api/stralign_s.h" +-for i in dlg h16 hxx rh ver; do ++for i in c dlg h16 hxx rh ver; do + BASEHEAD_LIST="$BASEHEAD_LIST "$srcdir/include/*.$i + done + #FIXME: Add in base directx +diff --git a/mingw-w64-headers/configure.ac b/mingw-w64-headers/configure.ac +index 312cf0a..7e3863d 100644 +--- a/mingw-w64-headers/configure.ac ++++ b/mingw-w64-headers/configure.ac +@@ -41,7 +41,7 @@ + + BASEHEAD_LIST="crt/_bsd_types.h crt/_cygwin.h crt/_mingw.h crt/_mingw_mac.h crt/_mingw_print_push.h crt/_mingw_print_pop.h crt/_mingw_secapi.h crt/_mingw_unicode.h crt/_timeval.h crt/crtdefs.h crt/excpt.h crt/intrin.h crt/vadefs.h crt/tchar.h "$srcdir/include/*.h + SECHEAD_LIST="$srcdir/crt/sec_api/stralign_s.h" +-for i in dlg h16 hxx rh ver; do ++for i in c dlg h16 hxx rh ver; do + BASEHEAD_LIST="$BASEHEAD_LIST "$srcdir/include/*.$i + done + #FIXME: Add in base directx diff --git a/commit-6c56d0b b/commit-6c56d0b deleted file mode 100644 index 1017d69..0000000 --- a/commit-6c56d0b +++ /dev/null @@ -1,23 +0,0 @@ -commit 6c56d0b0eb5be9fbeb552ba070a2304b842a5102 -Author: Руслан Ижбулатов -Date: Wed Mar 18 14:06:33 2015 +0000 - - Add more includes to shlobj.h - - wtypesbase.h and wincrypt.h pull some other headers, - together they all provide EXTERN_C, DECLSPEC_IMPORT and WINAPI macros, - which are needed by shlobj.h directly or indirectly. - -diff --git a/mingw-w64-headers/include/shlobj.h b/mingw-w64-headers/include/shlobj.h -index 3d2e21c..be087c4 100644 ---- a/mingw-w64-headers/include/shlobj.h -+++ b/mingw-w64-headers/include/shlobj.h -@@ -6,6 +6,8 @@ - #ifndef _SHLOBJ_H_ - #define _SHLOBJ_H_ - -+#include -+#include - #include - - #if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_DESKTOP) || defined(WINSTORECOMPAT) diff --git a/commit-7eee339 b/commit-7eee339 new file mode 100644 index 0000000..888d927 --- /dev/null +++ b/commit-7eee339 @@ -0,0 +1,789 @@ +From 7eee3397ffe04d53ccde517e4cf9669f824969c8 Mon Sep 17 00:00:00 2001 +From: Jacek Caban +Date: Wed, 29 Apr 2015 21:27:26 +0200 +Subject: msinkaut.idl: Added new file. + + +diff --git a/mingw-w64-headers/Makefile.am b/mingw-w64-headers/Makefile.am +index 4fa8d83..3271692 100644 +--- a/mingw-w64-headers/Makefile.am ++++ b/mingw-w64-headers/Makefile.am +@@ -108,6 +108,7 @@ IDL_SRCS = \ + include/mmdeviceapi.idl \ + include/mscoree.idl \ + include/msctf.idl \ ++ include/msinkaut.idl \ + include/mshtml.idl \ + include/mshtmhst.idl \ + include/msopc.idl \ +diff --git a/mingw-w64-headers/Makefile.in b/mingw-w64-headers/Makefile.in +index 5a57f43..6c2c031 100644 +--- a/mingw-w64-headers/Makefile.in ++++ b/mingw-w64-headers/Makefile.in +@@ -332,6 +332,7 @@ EXTRA_HEADERS = \ + @HAVE_WIDL_TRUE@ include/mmdeviceapi.idl \ + @HAVE_WIDL_TRUE@ include/mscoree.idl \ + @HAVE_WIDL_TRUE@ include/msctf.idl \ ++@HAVE_WIDL_TRUE@ include/msinkaut.idl \ + @HAVE_WIDL_TRUE@ include/mshtml.idl \ + @HAVE_WIDL_TRUE@ include/mshtmhst.idl \ + @HAVE_WIDL_TRUE@ include/msopc.idl \ +diff --git a/mingw-w64-headers/include/msinkaut.idl b/mingw-w64-headers/include/msinkaut.idl +new file mode 100644 +index 0000000..6d3c547 +--- /dev/null ++++ b/mingw-w64-headers/include/msinkaut.idl +@@ -0,0 +1,711 @@ ++/** ++ * This file is part of the mingw-w64 runtime package. ++ * No warranty is given; refer to the file DISCLAIMER within this package. ++ */ ++ ++import "oaidl.idl"; ++import "ocidl.idl"; ++import "tpcshrd.idl"; ++ ++// cpp_quote("#import ") ++ ++typedef enum InkRasterOperation { ++ IRO_Black = 1, ++ IRO_NotMergePen = 2, ++ IRO_MaskNotPen = 3, ++ IRO_NotCopyPen = 4, ++ IRO_MaskPenNot = 5, ++ IRO_Not = 6, ++ IRO_XOrPen = 7, ++ IRO_NotMaskPen = 8, ++ IRO_MaskPen = 9, ++ IRO_NotXOrPen = 10, ++ IRO_NoOperation = 11, ++ IRO_MergeNotPen = 12, ++ IRO_CopyPen = 13, ++ IRO_MergePenNot = 14, ++ IRO_MergePen = 15, ++ IRO_White = 16 ++} InkRasterOperation; ++ ++typedef enum InkPenTip { ++ IPT_Ball = 0, ++ IPT_Rectangle = 1 ++} InkPenTip; ++ ++typedef enum TabletHardwareCapabilities { ++ THWC_Integrated = 0x1, ++ THWC_CursorMustTouch = 0x2, ++ THWC_HardProximity = 0x4, ++ THWC_CursorsHavePhysicalIds = 0x8 ++} TabletHardwareCapabilities; ++ ++typedef enum TabletPropertyMetricUnit { ++ TPMU_Default, ++ TPMU_Inches, ++ TPMU_Centimeters, ++ TPMU_Degrees, ++ TPMU_Radians, ++ TPMU_Seconds, ++ TPMU_Pounds, ++ TPMU_Grams ++} TabletPropertyMetricUnit; ++ ++typedef enum InkCursorButtonState { ++ ICBS_Unavailable, ++ ICBS_Up, ++ ICBS_Down ++} InkCursorButtonState; ++ ++typedef enum InkRecognitionConfidence { ++ IRC_Strong = 0, ++ IRC_Intermediate = 1, ++ IRC_Poor = 2 ++} InkRecognitionConfidence; ++ ++typedef enum InkBoundingBoxMode { ++ IBBM_Default = 0, ++ IBBM_NoCurveFit = 1, ++ IBBM_CurveFit = 2, ++ IBBM_PointsOnly = 3, ++ IBBM_Union = 4 ++} InkBoundingBoxMode; ++ ++typedef enum InkExtractFlags { ++ IEF_CopyFromOriginal = 0, ++ IEF_RemoveFromOriginal = 1, ++ IEF_Default = IEF_RemoveFromOriginal ++} InkExtractFlags; ++ ++typedef enum InkPersistenceFormat { ++ IPF_InkSerializedFormat = 0, ++ IPF_Base64InkSerializedFormat = 1, ++ IPF_GIF = 2, ++ IPF_Base64GIF = 3 ++} InkPersistenceFormat; ++ ++typedef enum InkPersistenceCompressionMode { ++ IPCM_Default = 0, ++ IPCM_MaximumCompression = 1, ++ IPCM_NoCompression = 2 ++} InkPersistenceCompressionMode; ++ ++typedef enum InkClipboardFormats { ++ ICF_None = 0x0000, ++ ICF_InkSerializedFormat = 0x0001, ++ ICF_SketchInk = 0x0002, ++ ICF_TextInk = 0x0006, ++ ICF_EnhancedMetafile = 0x0008, ++ ICF_Metafile = 0x0020, ++ ICF_Bitmap = 0x0040, ++ ICF_PasteMask = 0x0007, ++ ICF_CopyMask = 0x007f, ++ ICF_Default = ICF_CopyMask ++} InkClipboardFormats; ++ ++typedef enum InkClipboardModes { ++ ICB_Copy = 0x00, ++ ICB_Cut = 0x01, ++ ICB_ExtractOnly = 0x30, ++ ICB_DelayedCopy = 0x20, ++ ICB_Default = ICB_Copy ++} InkClipboardModes; ++ ++typedef enum InkCollectionMode { ++ ICM_InkOnly, ++ ICM_GestureOnly, ++ ICM_InkAndGesture ++} InkCollectionMode; ++ ++typedef enum InkMousePointer { ++ IMP_Default = 0, ++ IMP_Arrow = 1, ++ IMP_Crosshair = 2, ++ IMP_Ibeam = 3, ++ IMP_SizeNESW = 4, ++ IMP_SizeNS = 5, ++ IMP_SizeNWSE = 6, ++ IMP_SizeWE = 7, ++ IMP_UpArrow = 8, ++ IMP_Hourglass = 9, ++ IMP_NoDrop = 10, ++ IMP_ArrowHourglass = 11, ++ IMP_ArrowQuestion = 12, ++ IMP_SizeAll = 13, ++ IMP_Hand = 14, ++ IMP_Custom = 99 ++} InkMousePointer; ++ ++typedef enum InkApplicationGesture { ++ IAG_AllGestures = 0x0000, ++ IAG_NoGesture = 0xf000, ++ IAG_Scratchout = 0xf001, ++ IAG_Triangle = 0xf002, ++ IAG_Square = 0xf003, ++ IAG_Star = 0xf004, ++ IAG_Check = 0xf005, ++ IAG_Curlicue = 0xf010, ++ IAG_DoubleCurlicue = 0xf011, ++ IAG_Circle = 0xf020, ++ IAG_DoubleCircle = 0xf021, ++ IAG_SemiCircleLeft = 0xf028, ++ IAG_SemiCircleRight = 0xf029, ++ IAG_ChevronUp = 0xf030, ++ IAG_ChevronDown = 0xf031, ++ IAG_ChevronLeft = 0xf032, ++ IAG_ChevronRight = 0xf033, ++ IAG_ArrowUp = 0xf038, ++ IAG_ArrowDown = 0xf039, ++ IAG_ArrowLeft = 0xf03a, ++ IAG_ArrowRight = 0xf03b, ++ IAG_Up = 0xf058, ++ IAG_Down = 0xf059, ++ IAG_Left = 0xf05a, ++ IAG_Right = 0xf05b, ++ IAG_UpDown = 0xf060, ++ IAG_DownUp = 0xf061, ++ IAG_LeftRight = 0xf062, ++ IAG_RightLeft = 0xf063, ++ IAG_UpLeftLong = 0xf064, ++ IAG_UpRightLong = 0xf065, ++ IAG_DownLeftLong = 0xf066, ++ IAG_DownRightLong = 0xf067, ++ IAG_UpLeft = 0xf068, ++ IAG_UpRight = 0xf069, ++ IAG_DownLeft = 0xf06a, ++ IAG_DownRight = 0xf06b, ++ IAG_LeftUp = 0xf06c, ++ IAG_LeftDown = 0xf06d, ++ IAG_RightUp = 0xf06e, ++ IAG_RightDown = 0xf06f, ++ IAG_Exclamation = 0xf0a4, ++ IAG_Tap = 0xf0f0, ++ IAG_DoubleTap = 0xf0f1 ++} InkApplicationGesture; ++ ++typedef enum InkCollectorEventInterest { ++ ICEI_DefaultEvents = -1, ++ ICEI_CursorDown = (ICEI_DefaultEvents+1), ++ ICEI_Stroke = (ICEI_CursorDown+1), ++ ICEI_NewPackets = (ICEI_Stroke+1), ++ ICEI_NewInAirPackets = (ICEI_NewPackets+1), ++ ICEI_CursorButtonDown = (ICEI_NewInAirPackets+1), ++ ICEI_CursorButtonUp = (ICEI_CursorButtonDown+1), ++ ICEI_CursorInRange = (ICEI_CursorButtonUp+1), ++ ICEI_CursorOutOfRange = (ICEI_CursorInRange+1), ++ ICEI_SystemGesture = (ICEI_CursorOutOfRange+1), ++ ICEI_TabletAdded = (ICEI_SystemGesture+1), ++ ICEI_TabletRemoved = (ICEI_TabletAdded+1), ++ ICEI_MouseDown = (ICEI_TabletRemoved+1), ++ ICEI_MouseMove = (ICEI_MouseDown+1), ++ ICEI_MouseUp = (ICEI_MouseMove+1), ++ ICEI_MouseWheel = (ICEI_MouseUp+1), ++ ICEI_DblClick = (ICEI_MouseWheel+1), ++ ICEI_AllEvents = (ICEI_DblClick+1) ++} InkCollectorEventInterest; ++ ++typedef enum DISPID_InkCollectorEvent { ++ DISPID_ICEStroke = 1, ++ DISPID_ICECursorDown = (DISPID_ICEStroke+1), ++ DISPID_ICENewPackets = (DISPID_ICECursorDown+1), ++ DISPID_ICENewInAirPackets = (DISPID_ICENewPackets+1), ++ DISPID_ICECursorButtonDown = (DISPID_ICENewInAirPackets+1), ++ DISPID_ICECursorButtonUp = (DISPID_ICECursorButtonDown+1), ++ DISPID_ICECursorInRange = (DISPID_ICECursorButtonUp+1), ++ DISPID_ICECursorOutOfRange = (DISPID_ICECursorInRange+1), ++ DISPID_ICESystemGesture = (DISPID_ICECursorOutOfRange+1), ++ DISPID_ICEGesture = (DISPID_ICESystemGesture+1), ++ DISPID_ICETabletAdded = (DISPID_ICEGesture+1), ++ DISPID_ICETabletRemoved = (DISPID_ICETabletAdded+1), ++ DISPID_IOEPainting = (DISPID_ICETabletRemoved+1), ++ DISPID_IOEPainted = (DISPID_IOEPainting+1), ++ DISPID_IOESelectionChanging = (DISPID_IOEPainted+1), ++ DISPID_IOESelectionChanged = (DISPID_IOESelectionChanging+1), ++ DISPID_IOESelectionMoving = (DISPID_IOESelectionChanged+1), ++ DISPID_IOESelectionMoved = (DISPID_IOESelectionMoving+1), ++ DISPID_IOESelectionResizing = (DISPID_IOESelectionMoved+1), ++ DISPID_IOESelectionResized = (DISPID_IOESelectionResizing+1), ++ DISPID_IOEStrokesDeleting = (DISPID_IOESelectionResized+1), ++ DISPID_IOEStrokesDeleted = (DISPID_IOEStrokesDeleting+1), ++ DISPID_IPEChangeUICues = (DISPID_IOEStrokesDeleted+1), ++ DISPID_IPEClick = (DISPID_IPEChangeUICues+1), ++ DISPID_IPEDblClick = (DISPID_IPEClick+1), ++ DISPID_IPEInvalidated = (DISPID_IPEDblClick+1), ++ DISPID_IPEMouseDown = (DISPID_IPEInvalidated+1), ++ DISPID_IPEMouseEnter = (DISPID_IPEMouseDown+1), ++ DISPID_IPEMouseHover = (DISPID_IPEMouseEnter+1), ++ DISPID_IPEMouseLeave = (DISPID_IPEMouseHover+1), ++ DISPID_IPEMouseMove = (DISPID_IPEMouseLeave+1), ++ DISPID_IPEMouseUp = (DISPID_IPEMouseMove+1), ++ DISPID_IPEMouseWheel = (DISPID_IPEMouseUp+1), ++ DISPID_IPESizeModeChanged = (DISPID_IPEMouseWheel+1), ++ DISPID_IPEStyleChanged = (DISPID_IPESizeModeChanged+1), ++ DISPID_IPESystemColorsChanged = (DISPID_IPEStyleChanged+1), ++ DISPID_IPEKeyDown = (DISPID_IPESystemColorsChanged+1), ++ DISPID_IPEKeyPress = (DISPID_IPEKeyDown+1), ++ DISPID_IPEKeyUp = (DISPID_IPEKeyPress+1), ++ DISPID_IPEResize = (DISPID_IPEKeyUp+1), ++ DISPID_IPESizeChanged = (DISPID_IPEResize+1) ++} DISPID_InkCollectorEvent; ++ ++ ++interface IInkDisp; ++interface IInkStrokes; ++interface IInkRecognitionAlternate; ++ ++[ ++ object, ++ uuid(db489209-b7c3-411d-90f6-1548cfff271e), ++ dual ++] ++interface IInkExtendedProperty : IDispatch ++{ ++ [propget] HRESULT Guid([out, retval] BSTR *Guid); ++ [propget] HRESULT Data([out, retval] VARIANT *Data); ++ [propput] HRESULT Data([in] VARIANT Data); ++} ++ ++[ ++ object, ++ uuid(89f2a8be-95a9-4530-8b8f-88e971e3e25f), ++ dual ++] ++interface IInkExtendedProperties : IDispatch ++{ ++ [propget] HRESULT Count([out, retval] long *Count); ++ [propget] HRESULT _NewEnum([out, retval] IUnknown **_NewEnum); ++ HRESULT Item([in] VARIANT Identifier, [out, retval] IInkExtendedProperty **Item); ++ HRESULT Add([in] BSTR Guid, [in] VARIANT Data, [out, retval] IInkExtendedProperty **InkExtendedProperty); ++ HRESULT Remove([in] VARIANT Identifier); ++ HRESULT Clear(); ++ HRESULT DoesPropertyExist([in] BSTR Guid, [out, retval] VARIANT_BOOL *DoesPropertyExist); ++} ++ ++[ ++ object, ++ uuid(bf519b75-0a15-4623-adc9-c00d436a8092), ++ dual ++] ++interface IInkDrawingAttributes : IDispatch ++{ ++ [propget] HRESULT Color([out] long *CurrentColor); ++ [propput] HRESULT Color([in] long NewColor); ++ [propget] HRESULT Width([out, retval] float *CurrentWidth); ++ [propput] HRESULT Width([in] float NewWidth); ++ [propget] HRESULT Height([out, retval] float *CurrentHeight); ++ [propput] HRESULT Height([in] float NewHeight); ++ [propget] HRESULT FitToCurve([out, retval] VARIANT_BOOL *Flag); ++ [propput] HRESULT FitToCurve([in] VARIANT_BOOL Flag); ++ [propget] HRESULT IgnorePressure([out, retval] VARIANT_BOOL *Flag); ++ [propput] HRESULT IgnorePressure([in] VARIANT_BOOL Flag); ++ [propget] HRESULT AntiAliased([out, retval] VARIANT_BOOL *Flag); ++ [propput] HRESULT AntiAliased([in] VARIANT_BOOL Flag); ++ [propget] HRESULT Transparency([out, retval] long *CurrentTransparency); ++ [propput] HRESULT Transparency([in] long NewTransparency); ++ [propget] HRESULT RasterOperation([out, retval] InkRasterOperation *CurrentRasterOperation); ++ [propput] HRESULT RasterOperation([in] InkRasterOperation NewRasterOperation); ++ [propget] HRESULT PenTip([out, retval] InkPenTip *CurrentPenTip); ++ [propput] HRESULT PenTip([in] InkPenTip NewPenTip); ++ [propget] HRESULT ExtendedProperties([out, retval] IInkExtendedProperties **Properties); ++ HRESULT Clone([out, retval] IInkDrawingAttributes **DrawingAttributes); ++} ++ ++[ ++ object, ++ uuid(9794ff82-6071-4717-8a8b-6ac7c64a686e), ++ dual ++] ++interface IInkRectangle : IDispatch ++{ ++ [propget] HRESULT Top([out, retval] long *Units); ++ [propput] HRESULT Top([in] long Units); ++ [propget] HRESULT Left([out, retval] long *Units); ++ [propput] HRESULT Left([in] long Units); ++ [propget] HRESULT Bottom([out, retval] long *Units); ++ [propput] HRESULT Bottom([in] long Units); ++ [propget] HRESULT Right([out, retval] long *Units); ++ [propput] HRESULT Right([in] long Units); ++ [propget] HRESULT Data([out, retval] RECT *Rect); ++ [propput] HRESULT Data([in] RECT Rect); ++ HRESULT GetRectangle([out] long *Top, [out] long *Left, [out] long *Bottom, [out] long *Right); ++ HRESULT SetRectangle([in] long Top, [in] long Left, [in] long Bottom, [in] long Right); ++} ++ ++[ ++ object, ++ uuid(2de25eaa-6ef8-42d5-aee9-185bc81b912d), ++ dual ++] ++interface IInkTablet : IDispatch ++{ ++ [propget] HRESULT Name([out, retval] BSTR *Name); ++ [propget] HRESULT PlugAndPlayId([out, retval] BSTR *Id); ++ [propget] HRESULT MaximumInputRectangle([out, retval] IInkRectangle **Rectangle); ++ [propget] HRESULT HardwareCapabilities([out, retval] TabletHardwareCapabilities *Capabilities); ++ HRESULT IsPacketPropertySupported([in] BSTR packetPropertyName, [out, retval] VARIANT_BOOL *Supported); ++ HRESULT GetPropertyMetrics([in] BSTR propertyName, [out] long *Minimum, [out] long *Maximum, ++ [out] TabletPropertyMetricUnit *Units, [out] float *Resolution); ++} ++ ++[ ++ object, ++ uuid(85ef9417-1d59-49b2-a13c-702c85430894), ++ dual ++] ++interface IInkCursorButton : IDispatch ++{ ++ [propget] HRESULT Name([out, retval] BSTR *Name); ++ [propget] HRESULT Id([out, retval] BSTR *Id); ++ [propget] HRESULT State([out, retval] InkCursorButtonState *CurrentState); ++} ++ ++[ ++ object, ++ uuid(3671cC40-b624-4671-9fa0-db119d952d54), ++ dual ++] ++interface IInkCursorButtons : IDispatch ++{ ++ [propget] HRESULT Count([out, retval] long *Count); ++ [propget] HRESULT _NewEnum([out, retval] IUnknown **_NewEnum); ++ HRESULT Item([in] VARIANT Identifier, [out, retval] IInkCursorButton **Button); ++} ++ ++[ ++ object, ++ uuid(ad30c630-40c5-4350-8405-9c71012fc558), ++ dual ++] ++interface IInkCursor : IDispatch ++{ ++ [propget] HRESULT Name([out, retval] BSTR *Name); ++ [propget] HRESULT Id([out, retval] long *Id); ++ [propget] HRESULT Inverted([out, retval] VARIANT_BOOL *Status); ++ [propget] HRESULT DrawingAttributes([out, retval] IInkDrawingAttributes **Attributes); ++ [propputref] HRESULT DrawingAttributes([in] IInkDrawingAttributes *Attributes); ++ [propget] HRESULT Tablet([out, retval] IInkTablet **Tablet); ++ [propget] HRESULT Buttons([out, retval] IInkCursorButtons **Buttons); ++} ++ ++[ ++ object, ++ uuid(615f1d43-8703-4565-88e2-8201d2ecd7b7), ++ dual ++] ++interface IInkTransform : IDispatch ++{ ++ HRESULT Reset(); ++ HRESULT Translate([in] float HorizontalComponent, [in] float VerticalComponent); ++ HRESULT Rotate([in] float Degrees, [in, defaultvalue(0)] float x, [in, defaultvalue(0)] float y); ++ HRESULT Reflect([in] VARIANT_BOOL Horizontally, [in] VARIANT_BOOL Vertically); ++ HRESULT Shear([in] float HorizontalComponent, [in] float VerticalComponent); ++ HRESULT ScaleTransform([in] float HorizontalMultiplier, [in] float VerticalMultiplier); ++ HRESULT GetTransform([out] float *eM11, [out] float *eM12, [out] float *eM21, [out] float *eM22, ++ [out] float *eDx, [out] float *eDy); ++ HRESULT SetTransform([in] float eM11, [in] float eM12, [in] float eM21, [in] float eM22, [in] float eDx, [in] float eDy); ++ [propget, hidden] HRESULT eM11([out, retval] float *Value); ++ [propput, hidden] HRESULT eM11([in] float Value); ++ [propget, hidden] HRESULT eM12([out, retval] float *Value); ++ [propput, hidden] HRESULT eM12([in] float Value); ++ [propget, hidden] HRESULT eM21([out, retval] float *Value); ++ [propput, hidden] HRESULT eM21([in] float Value); ++ [propget, hidden] HRESULT eM22([out, retval] float *Value); ++ [propput, hidden] HRESULT eM22([in] float Value); ++ [propget, hidden] HRESULT eDx([out, retval] float *Value); ++ [propput, hidden] HRESULT eDx([in] float Value); ++ [propget, hidden] HRESULT eDy([out, retval] float *Value); ++ [propput, hidden] HRESULT eDy([in] float Value); ++ [propget, hidden] HRESULT Data([out, retval] XFORM *XForm); ++ [propput, hidden] HRESULT Data([in] XFORM XForm); ++} ++ ++[ ++ object, ++ uuid(286a167f-9f19-4c61-9d53-4f07be622b84), ++ dual ++] ++interface IInkRecognitionAlternates : IDispatch ++{ ++ [propget] HRESULT Count([out, retval] long *Count); ++ [propget, restricted] HRESULT _NewEnum([out, retval] IUnknown **_NewEnum); ++ [propget] HRESULT Strokes([out, retval] IInkStrokes **Strokes); ++ HRESULT Item([in] long Index, [out, retval] IInkRecognitionAlternate **InkRecoAlternate); ++} ++ ++[ ++ object, ++ uuid(b7e660ad-77e4-429b-adda-873780d1fc4a), ++ dual ++] ++interface IInkRecognitionAlternate : IDispatch ++{ ++ [propget] HRESULT String([out, retval] BSTR *RecoString); ++ [propget] HRESULT Confidence([out, retval] InkRecognitionConfidence *Confidence) ; ++ [propget] HRESULT Baseline([out, retval] VARIANT *Baseline); ++ [propget] HRESULT Midline([out, retval] VARIANT *Midline); ++ [propget] HRESULT Ascender([out, retval] VARIANT *Ascender); ++ [propget] HRESULT Descender([out, retval] VARIANT *Descender); ++ [propget] HRESULT LineNumber([out, retval] long *LineNumber); ++ [propget] HRESULT Strokes([out, retval] IInkStrokes **Strokes); ++ [propget] HRESULT LineAlternates([out, retval] IInkRecognitionAlternates **LineAlternates); ++ [propget] HRESULT ConfidenceAlternates([out, retval] IInkRecognitionAlternates **ConfidenceAlternates); ++ HRESULT GetStrokesFromStrokeRanges([in] IInkStrokes *Strokes, [out, retval] IInkStrokes **GetStrokesFromStrokeRanges); ++ HRESULT GetStrokesFromTextRange([in, out] long *selectionStart, [in, out] long *selectionLength, ++ [out, retval] IInkStrokes **GetStrokesFromTextRange); ++ HRESULT GetTextRangeFromStrokes([in] IInkStrokes *Strokes, [in, out] long *selectionStart, [in, out] long *selectionLength); ++ HRESULT AlternatesWithConstantPropertyValues([in] BSTR PropertyType, ++ [out, retval] IInkRecognitionAlternates **AlternatesWithConstantPropertyValues); ++ HRESULT GetPropertyValue([in] BSTR PropertyType, [out, retval] VARIANT *PropertyValue); ++} ++ ++[ ++ object, ++ uuid(3bc129a8-86cd-45ad-bde8-e0d32d61c16d), ++ dual ++] ++interface IInkRecognitionResult : IDispatch ++{ ++ [propget] HRESULT TopString([out, retval] BSTR *TopString); ++ [propget] HRESULT TopAlternate([out, retval] IInkRecognitionAlternate **TopAlternate); ++ [propget] HRESULT TopConfidence([out, retval] InkRecognitionConfidence *TopConfidence); ++ [propget] HRESULT Strokes([out, retval] IInkStrokes **Strokes); ++ HRESULT AlternatesFromSelection([in] long selectionStart, [in] long selectionLength, [in] long maximumAlternates, ++ [out, retval] IInkRecognitionAlternates **AlternatesFromSelection); ++ HRESULT ModifyTopAlternate([in] IInkRecognitionAlternate *Alternate); ++ HRESULT SetResultOnStrokes(); ++} ++ ++[ ++ object, ++ uuid(43242fea-91d1-4a72-963e-fbb91829cfa2), ++ dual ++] ++interface IInkStrokeDisp : IDispatch ++{ ++ [propget] HRESULT ID([out, retval] long *ID); ++ [propget] HRESULT BezierPoints([out, retval] VARIANT *Points); ++ [propget] HRESULT DrawingAttributes([out, retval] IInkDrawingAttributes **DrawAttrs); ++ [propputref] HRESULT DrawingAttributes([in] IInkDrawingAttributes *DrawAttrs); ++ [propget] HRESULT Ink([out, retval] IInkDisp **Ink); ++ [propget] HRESULT ExtendedProperties([out, retval] IInkExtendedProperties **Properties); ++ [propget] HRESULT PolylineCusps([out, retval] VARIANT *Cusps); ++ [propget] HRESULT BezierCusps([out, retval] VARIANT *Cusps); ++ [propget] HRESULT SelfIntersections([out, retval] VARIANT *Intersections); ++ [propget] HRESULT PacketCount([out, retval] long *plCount); ++ [propget] HRESULT PacketSize([out, retval] long *plSize); ++ [propget] HRESULT PacketDescription([out, retval] VARIANT *PacketDescription); ++ [propget] HRESULT Deleted([out, retval] VARIANT_BOOL *Deleted); ++ HRESULT GetBoundingBox([in] InkBoundingBoxMode BoundingBoxMode, [out, retval] IInkRectangle **Rectangle); ++ HRESULT FindIntersections([in] IInkStrokes *Strokes, [out, retval] VARIANT *Intersections); ++ HRESULT GetRectangleIntersections([in] IInkRectangle *Rectangle, [out, retval] VARIANT *Intersections); ++ HRESULT Clip([in] IInkRectangle *Rectangle); ++ HRESULT HitTestCircle([in] long X, [in] long Y, [in] float Radius, [out, retval] VARIANT_BOOL *Intersects); ++ HRESULT NearestPoint([in] long X, [in] long Y, [in, out] float *Distance, [out, retval] float *Point); ++ HRESULT Split([in] float SplitAt, [out, retval] IInkStrokeDisp **NewStroke); ++ HRESULT GetPacketDescriptionPropertyMetrics([in] BSTR PropertyName, [out] long *Minimum, [out] long *Maximum, ++ [out] TabletPropertyMetricUnit *Units, [out] float *Resolution); ++ HRESULT GetPoints([in] long Index, [in] long Count, [out, retval] VARIANT *Points); ++ HRESULT SetPoints([in] VARIANT Points, [in] long Index, [in] long Count, [out, retval] long *NumberOfPointsSet); ++ HRESULT GetPacketData([in] long Index, [in] long Count, [out, retval] VARIANT *PacketData); ++ HRESULT GetPacketValuesByProperty([in] BSTR PropertyName, [in] long Index, [in] long Count, ++ [out, retval] VARIANT *PacketValues) ; ++ HRESULT SetPacketValuesByProperty([in] BSTR bstrPropertyName, [in] VARIANT PacketValues, [in] long Index, ++ [in] long Count, [out, retval] long *NumberOfPacketsSet); ++ HRESULT GetFlattenedBezierPoints([in] long FittingError, [out, retval] VARIANT *FlattenedBezierPoints); ++ HRESULT Transform([in] IInkTransform *Transform, [in, defaultvalue(0)] VARIANT_BOOL ApplyOnPenWidth); ++ HRESULT ScaleToRectangle([in] IInkRectangle *Rectangle); ++ HRESULT Move([in] float HorizontalComponent, [in] float VerticalComponent); ++ HRESULT Rotate([in] float Degrees, [in, defaultvalue(0)] float x, [in, defaultvalue(0)] float y); ++ HRESULT Shear([in] float HorizontalMultiplier, [in] float VerticalMultiplier); ++ HRESULT ScaleTransform([in] float HorizontalMultiplier, [in] float VerticalMultiplier); ++} ++ ++[ ++ object, ++ uuid(7e23a88f-c30e-420f-9bdb-28902543f0c1), ++ dual ++] ++interface IInkCustomStrokes : IDispatch ++{ ++ [propget] HRESULT Count([out, retval] long *Count); ++ [propget, restricted] HRESULT _NewEnum([out, retval] IUnknown **_NewEnum); ++ HRESULT Item([in] VARIANT Identifier, [out, retval] IInkStrokes **Strokes); ++ HRESULT Add([in] BSTR Name, [in] IInkStrokes *Strokes); ++ HRESULT Remove([in] VARIANT Identifier); ++ HRESULT Clear(); ++} ++ ++[ ++ object, ++ uuid(9d398fa0-c4e2-4fcd-9973-975caaf47ea6), ++ dual ++] ++interface IInkDisp : IDispatch ++{ ++ [propget] HRESULT Strokes([out, retval] IInkStrokes **Strokes); ++ [propget] HRESULT ExtendedProperties([out, retval] IInkExtendedProperties **Properties); ++ [propget] HRESULT Dirty([out, retval] VARIANT_BOOL *Dirty); ++ [propput] HRESULT Dirty([in] VARIANT_BOOL Dirty); ++ [propget] HRESULT CustomStrokes([out, retval] IInkCustomStrokes **ppunkInkCustomStrokes); ++ HRESULT GetBoundingBox([in] InkBoundingBoxMode BoundingBoxMode, [out, retval] IInkRectangle **Rectangle); ++ HRESULT DeleteStrokes([in, unique, defaultvalue(0)] IInkStrokes *Strokes); ++ HRESULT DeleteStroke([in] IInkStrokeDisp *Stroke); ++ HRESULT ExtractStrokes([in] IInkStrokes *Strokes, InkExtractFlags ExtractFlags, [out, retval] IInkDisp **ExtractedInk); ++ HRESULT ExtractWithRectangle([in] IInkRectangle *Rectangle, [in] InkExtractFlags extractFlags, ++ [out, retval] IInkDisp **ExtractedInk); ++ HRESULT Clip([in] IInkRectangle *Rectangle); ++ HRESULT Clone([out, retval] IInkDisp **NewInk); ++ HRESULT HitTestCircle([in] long X, [in] long Y, [in] float radius, [out, retval] IInkStrokes **Strokes); ++ HRESULT HitTestWithRectangle([in] IInkRectangle *SelectionRectangle, [in] float IntersectPercent, ++ [out, retval] IInkStrokes **Strokes); ++ HRESULT HitTestWithLasso([in] VARIANT Points, [in] float IntersectPercent, [in, out, unique] VARIANT *LassoPoints, ++ [out, retval] IInkStrokes **Strokes); ++ HRESULT NearestPoint([in] long X, [in] long Y, [in, out] float *PointOnStroke, [in, out] float *DistanceFromPacket, ++ [out, retval] IInkStrokeDisp **Stroke); ++ HRESULT CreateStrokes([in] VARIANT StrokeIds, [out, retval] IInkStrokes **Strokes); ++ HRESULT AddStrokesAtRectangle([in] IInkStrokes *SourceStrokes, [in] IInkRectangle *TargetRectangle); ++ HRESULT Save([in] InkPersistenceFormat PersistenceFormat, [in] InkPersistenceCompressionMode CompressionMode, ++ [out, retval] VARIANT *Data); ++ HRESULT Load([in] VARIANT Data); ++ HRESULT CreateStroke([in] VARIANT PacketData, [in] VARIANT PacketDescription, [out, retval] IInkStrokeDisp **Stroke); ++ HRESULT ClipboardCopyWithRectangle([in] IInkRectangle *Rectangle, [in] InkClipboardFormats ClipboardFormats, ++ [in] InkClipboardModes ClipboardModes, [out, retval] IDataObject **DataObject); ++ HRESULT ClipboardCopy([in] IInkStrokes *strokes, [in] InkClipboardFormats ClipboardFormats, ++ [in] InkClipboardModes ClipboardModes, [out, retval] IDataObject **DataObject); ++ HRESULT CanPaste([in] IDataObject *DataObject, [out, retval] VARIANT_BOOL *CanPaste); ++ HRESULT ClipboardPaste([in] long x, [in] long y, [in, unique] IDataObject *DataObject, [out, retval] IInkStrokes **Strokes); ++} ++ ++[ ++ object, ++ uuid(f1f4c9d8-590a-4963-b3ae-1935671bb6f3), ++ dual ++] ++interface IInkStrokes : IDispatch ++{ ++ [propget] HRESULT Count([out, retval] long *Count); ++ [propget] HRESULT _NewEnum([out, retval] IUnknown **_NewEnum); ++ [propget] HRESULT Ink([out, retval] IInkDisp **Ink); ++ [propget] HRESULT RecognitionResult([out, retval] IInkRecognitionResult **RecognitionResult); ++ HRESULT ToString([out, retval] BSTR *ToString); ++ HRESULT Item([in] long Index, [out, retval] IInkStrokeDisp **Stroke); ++ HRESULT Add([in] IInkStrokeDisp *InkStroke); ++ HRESULT AddStrokes([in] IInkStrokes *InkStrokes); ++ HRESULT Remove([in] IInkStrokeDisp *InkStroke); ++ HRESULT RemoveStrokes([in] IInkStrokes *InkStrokes); ++ HRESULT ModifyDrawingAttributes([in] IInkDrawingAttributes *DrawAttrs); ++ HRESULT GetBoundingBox([in] InkBoundingBoxMode BoundingBoxMode, [out, retval] IInkRectangle **BoundingBox); ++ HRESULT Transform([in] IInkTransform *Transform, [in, defaultvalue(0)] VARIANT_BOOL ApplyOnPenWidth); ++ HRESULT ScaleToRectangle([in] IInkRectangle *Rectangle); ++ HRESULT Move([in] float HorizontalComponent, [in] float VerticalComponent); ++ HRESULT Rotate([in] float Degrees, [in, defaultvalue(0)] float x, [in, defaultvalue(0)] float y); ++ HRESULT Shear([in] float HorizontalMultiplier, [in] float VerticalMultiplier); ++ HRESULT ScaleTransform([in] float HorizontalMultiplier, [in] float VerticalMultiplier); ++ HRESULT Clip([in] IInkRectangle *Rectangle); ++ HRESULT RemoveRecognitionResult(); ++} ++ ++[ ++ object, ++ uuid(e6257a9c-b511-4f4c-a8b0-a7dbc9506b83), ++ dual ++] ++interface IInkRenderer : IDispatch ++{ ++ HRESULT GetViewTransform([in] IInkTransform *ViewTransform) ; ++ HRESULT SetViewTransform([in] IInkTransform *ViewTransform); ++ HRESULT GetObjectTransform([in] IInkTransform *ObjectTransform); ++ HRESULT SetObjectTransform([in] IInkTransform *ObjectTransform); ++ HRESULT Draw([in] LONG_PTR hDC, [in] IInkStrokes *Strokes); ++ HRESULT DrawStroke([in] LONG_PTR hDC, [in] IInkStrokeDisp *Stroke, ++ [in, defaultvalue(0)] IInkDrawingAttributes *DrawingAttributes); ++ HRESULT PixelToInkSpace([in] LONG_PTR hDC, [in, out] long *x, [in, out] long *y); ++ HRESULT InkSpaceToPixel([in] LONG_PTR hdcDisplay, [in, out] long *x, [in, out] long *y); ++ HRESULT PixelToInkSpaceFromPoints([in] LONG_PTR hDC, [in, out] VARIANT *Points); ++ HRESULT InkSpaceToPixelFromPoints([in] LONG_PTR hDC, [in, out] VARIANT *Points); ++ HRESULT Measure([in] IInkStrokes *Strokes, [out, retval] IInkRectangle **Rectangle); ++ HRESULT MeasureStroke([in] IInkStrokeDisp *Stroke, [in] IInkDrawingAttributes *DrawingAttributes, ++ [out, retval] IInkRectangle **Rectangle); ++ HRESULT Move([in] float HorizontalComponent, [in] float VerticalComponent); ++ HRESULT Rotate([in] float Degrees, [in, defaultvalue(0)] float x, [in, defaultvalue(0)] float y); ++ HRESULT ScaleTransform([in] float HorizontalMultiplier, [in] float VerticalMultiplier, ++ [in, defaultvalue(-1)] VARIANT_BOOL ApplyOnPenWidth); ++} ++ ++[ ++ object, ++ uuid(a248c1ac-c698-4e06-9e5c-d57f77c7e647), ++ dual ++] ++interface IInkCursors : IDispatch ++{ ++ [propget] HRESULT Count([out, retval] long *Count); ++ [propget, restricted] HRESULT _NewEnum([out, retval] IUnknown **_NewEnum); ++ HRESULT Item([in] long Index, [out, retval] IInkCursor **Cursor); ++} ++ ++[ ++ object, ++ uuid(f0f060b5-8b1f-4a7c-89ec-880692588a4f), ++ dual ++] ++interface IInkCollector : IDispatch ++{ ++ [propget] HRESULT hWnd([out, retval] LONG_PTR *CurrentWindow); ++ [propput] HRESULT hWnd([in] LONG_PTR NewWindow); ++ [propget] HRESULT Enabled([out, retval] VARIANT_BOOL *Collecting); ++ [propput] HRESULT Enabled([in] VARIANT_BOOL Collecting); ++ [propget] HRESULT DefaultDrawingAttributes([out, retval] IInkDrawingAttributes **CurrentAttributes); ++ [propputref] HRESULT DefaultDrawingAttributes([in] IInkDrawingAttributes *NewAttributes); ++ [propget] HRESULT Renderer([out, retval] IInkRenderer **CurrentInkRenderer); ++ [propputref] HRESULT Renderer([in] IInkRenderer *NewInkRenderer); ++ [propget] HRESULT Ink([out, retval] IInkDisp **Ink); ++ [propputref] HRESULT Ink([in] IInkDisp *NewInk); ++ [propget] HRESULT AutoRedraw([out, retval] VARIANT_BOOL *AutoRedraw); ++ [propput] HRESULT AutoRedraw([in] VARIANT_BOOL AutoRedraw); ++ [propget] HRESULT CollectingInk([out, retval] VARIANT_BOOL *Collecting); ++ [propget] HRESULT CollectionMode([out, retval] InkCollectionMode *Mode); ++ [propput] HRESULT CollectionMode([in] InkCollectionMode Mode); ++ [propget] HRESULT DynamicRendering([out, retval] VARIANT_BOOL *Enabled); ++ [propput] HRESULT DynamicRendering([in] VARIANT_BOOL Enabled); ++ [propget] HRESULT DesiredPacketDescription([out, retval] VARIANT *PacketGuids); ++ [propput] HRESULT DesiredPacketDescription([in] VARIANT PacketGuids); ++ [propget] HRESULT MouseIcon([out, retval] IPictureDisp **MouseIcon); ++ [propput] HRESULT MouseIcon([in, unique] IPictureDisp *MouseIcon); ++ [propputref] HRESULT MouseIcon([in, unique] IPictureDisp *MouseIcon); ++ [propget] HRESULT MousePointer([out, retval] InkMousePointer *MousePointer); ++ [propput] HRESULT MousePointer([in] InkMousePointer MousePointer); ++ [propget] HRESULT Cursors([out, retval] IInkCursors **Cursors); ++ [propget] HRESULT MarginX([out, retval] long *MarginX); ++ [propput] HRESULT MarginX([in] long MarginX); ++ [propget] HRESULT MarginY([out, retval] long *MarginY); ++ [propput] HRESULT MarginY([in] long MarginY); ++ [propget] HRESULT Tablet([out, retval] IInkTablet **SingleTablet); ++ [propget] HRESULT SupportHighContrastInk([out, retval] VARIANT_BOOL *Support); ++ [propput] HRESULT SupportHighContrastInk([in] VARIANT_BOOL Support); ++ HRESULT SetGestureStatus([in] InkApplicationGesture Gesture, [in] VARIANT_BOOL Listen); ++ HRESULT GetGestureStatus([in] InkApplicationGesture Gesture, [out, retval] VARIANT_BOOL *Listening); ++ HRESULT GetWindowInputRectangle([in, out] IInkRectangle **WindowInputRectangle); ++ HRESULT SetWindowInputRectangle([in] IInkRectangle *WindowInputRectangle); ++ HRESULT SetAllTabletsMode([in, defaultvalue(-1)] VARIANT_BOOL UseMouseForInput); ++ HRESULT SetSingleTabletIntegratedMode([in] IInkTablet *Tablet); ++ HRESULT GetEventInterest([in] InkCollectorEventInterest EventId, [out, retval] VARIANT_BOOL *Listen); ++ HRESULT SetEventInterest([in] InkCollectorEventInterest EventId, [in] VARIANT_BOOL Listen); ++} ++ ++[ ++ uuid(11a583f2-712d-4fea-abcf-ab4af38ea06b) ++] ++dispinterface _IInkCollectorEvents ++{ ++ properties: ++ methods: ++ /* FIXME */ ++} ++ ++[ ++ uuid(43fb1553-ad74-4ee8-88e4-3e6daac915db) ++] ++coclass InkCollector ++{ ++} +diff --git a/mingw-w64-headers/include/tpcshrd.h b/mingw-w64-headers/include/tpcshrd.h +index a8dd1fc..b114270 100644 +--- a/mingw-w64-headers/include/tpcshrd.h ++++ b/mingw-w64-headers/include/tpcshrd.h +@@ -44,6 +44,17 @@ extern "C" { + typedef DWORD CURSOR_ID; + typedef USHORT SYSTEM_EVENT; + typedef DWORD TABLET_CONTEXT_ID; ++#ifndef _XFORM_ ++#define _XFORM_ ++typedef struct tagXFORM { ++ float eM11; ++ float eM12; ++ float eM21; ++ float eM22; ++ float eDx; ++ float eDy; ++} XFORM; ++#endif + /* Begin additional prototypes for all interfaces */ + + +diff --git a/mingw-w64-headers/include/tpcshrd.idl b/mingw-w64-headers/include/tpcshrd.idl +index cc74801..d11f3e8 100644 +--- a/mingw-w64-headers/include/tpcshrd.idl ++++ b/mingw-w64-headers/include/tpcshrd.idl +@@ -28,3 +28,15 @@ cpp_quote("#define IP_MARGIN 0x4") + typedef DWORD CURSOR_ID; + typedef USHORT SYSTEM_EVENT; + typedef DWORD TABLET_CONTEXT_ID; ++ ++cpp_quote("#ifndef _XFORM_") ++cpp_quote("#define _XFORM_") ++typedef struct tagXFORM { ++ float eM11; ++ float eM12; ++ float eM21; ++ float eM22; ++ float eDx; ++ float eDy; ++} XFORM; ++cpp_quote("#endif") diff --git a/commit-85b4034 b/commit-85b4034 new file mode 100644 index 0000000..b06cf04 --- /dev/null +++ b/commit-85b4034 @@ -0,0 +1,35 @@ +From 85b403445b2308fa6277aa26446da790866fe052 Mon Sep 17 00:00:00 2001 +From: Jacek Caban +Date: Fri, 17 Apr 2015 16:42:32 +0200 +Subject: textstor.idl: Updated to current Wine version. + + +diff --git a/mingw-w64-headers/include/textstor.h b/mingw-w64-headers/include/textstor.h +index 7581c39..0e051d7 100644 +--- a/mingw-w64-headers/include/textstor.h ++++ b/mingw-w64-headers/include/textstor.h +@@ -91,6 +91,10 @@ extern "C" { + + #define TS_ST_CORRECTION (0x1) + ++#define GXFPF_ROUND_NEAREST (0x1) ++ ++#define GXFPF_NEAREST (0x2) ++ + typedef enum __WIDL_textstor_generated_name_00000002 { + TS_AE_NONE = 0, + TS_AE_START = 1, +diff --git a/mingw-w64-headers/include/textstor.idl b/mingw-w64-headers/include/textstor.idl +index 5492071..7640e8c 100644 +--- a/mingw-w64-headers/include/textstor.idl ++++ b/mingw-w64-headers/include/textstor.idl +@@ -74,6 +74,9 @@ const DWORD TS_IAS_QUERYONLY = 0x2; + + const DWORD TS_ST_CORRECTION = 0x1; + ++const DWORD GXFPF_ROUND_NEAREST = 0x1; ++const DWORD GXFPF_NEAREST = 0x2; ++ + typedef [uuid(05fcf85b-5e9c-4c3e-ab71-29471d4f38e7)] enum { TS_AE_NONE, TS_AE_START, TS_AE_END } TsActiveSelEnd; + typedef [uuid(033b0df0-f193-4170-b47b-141afc247878)] enum { TS_RT_PLAIN, TS_RT_HIDDEN, TS_RT_OPAQUE } TsRunType; + typedef [uuid(ef3457d9-8446-49a7-a9e6-b50d9d5f3fd9)] GUID TS_ATTRID; diff --git a/commit-a883b47 b/commit-a883b47 new file mode 100644 index 0000000..8719d37 --- /dev/null +++ b/commit-a883b47 @@ -0,0 +1,91 @@ +From a883b47a45ff74ced41dfbd9f748d5c2c61f3c01 Mon Sep 17 00:00:00 2001 +From: Jacek Caban +Date: Thu, 19 Mar 2015 14:47:34 +0100 +Subject: Added new versionhelpers.h header. + + +diff --git a/mingw-w64-headers/include/versionhelpers.h b/mingw-w64-headers/include/versionhelpers.h +new file mode 100644 +index 0000000..25ea414 +--- /dev/null ++++ b/mingw-w64-headers/include/versionhelpers.h +@@ -0,0 +1,79 @@ ++/** ++ * This file is part of the mingw-w64 runtime package. ++ * No warranty is given; refer to the file DISCLAIMER within this package. ++ */ ++ ++#ifndef _INC_VERSIONHELPERS ++#define _INC_VERSIONHELPERS ++ ++#include ++ ++#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && !defined(__WIDL__) ++ ++#ifdef __cplusplus ++#define VERSIONHELPERAPI inline bool ++#else ++#define VERSIONHELPERAPI FORCEINLINE BOOL ++#endif ++ ++VERSIONHELPERAPI IsWindowsVersionOrGreater(WORD major, WORD minor, WORD servpack) ++{ ++ OSVERSIONINFOEXW vi = {sizeof(vi),major,minor,0,0,{0},servpack}; ++ return VerifyVersionInfoW(&vi, VER_MAJORVERSION|VER_MINORVERSION|VER_SERVICEPACKMAJOR, ++ VerSetConditionMask(VerSetConditionMask(VerSetConditionMask(0, ++ VER_MAJORVERSION,VER_GREATER_EQUAL), ++ VER_MINORVERSION,VER_GREATER_EQUAL), ++ VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL)); ++} ++ ++VERSIONHELPERAPI IsWindowsXPOrGreater(void) { ++ return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WINXP), LOBYTE(_WIN32_WINNT_WINXP), 0); ++} ++ ++VERSIONHELPERAPI IsWindowsXPSP1OrGreater(void) { ++ return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WINXP), LOBYTE(_WIN32_WINNT_WINXP), 1); ++} ++ ++VERSIONHELPERAPI IsWindowsXPSP2OrGreater(void) { ++ return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WINXP), LOBYTE(_WIN32_WINNT_WINXP), 2); ++} ++ ++VERSIONHELPERAPI IsWindowsXPSP3OrGreater(void) { ++ return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WINXP), LOBYTE(_WIN32_WINNT_WINXP), 3); ++} ++ ++VERSIONHELPERAPI IsWindowsVistaOrGreater(void) { ++ return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_VISTA), LOBYTE(_WIN32_WINNT_VISTA), 0); ++} ++ ++VERSIONHELPERAPI IsWindowsVistaSP1OrGreater(void) { ++ return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_VISTA), LOBYTE(_WIN32_WINNT_VISTA), 1); ++} ++ ++VERSIONHELPERAPI IsWindowsVistaSP2OrGreater(void) { ++ return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_VISTA), LOBYTE(_WIN32_WINNT_VISTA), 2); ++} ++ ++VERSIONHELPERAPI IsWindows7OrGreater(void) { ++ return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WIN7), LOBYTE(_WIN32_WINNT_WIN7), 0); ++} ++ ++VERSIONHELPERAPI IsWindows7SP1OrGreater(void) { ++ return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WIN7), LOBYTE(_WIN32_WINNT_WIN7), 1); ++} ++ ++VERSIONHELPERAPI IsWindows8OrGreater(void) { ++ return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WIN8), LOBYTE(_WIN32_WINNT_WIN8), 0); ++} ++ ++VERSIONHELPERAPI IsWindows8Point1OrGreater(void) { ++ return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WINBLUE), LOBYTE(_WIN32_WINNT_WINBLUE), 0); ++} ++ ++VERSIONHELPERAPI IsWindowsServer(void) { ++ OSVERSIONINFOEXW vi = {sizeof(vi),0,0,0,0,{0},0,0,0,VER_NT_WORKSTATION}; ++ return !VerifyVersionInfoW(&vi, VER_PRODUCT_TYPE, VerSetConditionMask(0, VER_PRODUCT_TYPE, VER_EQUAL)); ++} ++ ++#endif ++#endif diff --git a/commit-e4a8812 b/commit-e4a8812 new file mode 100644 index 0000000..efb3bb2 --- /dev/null +++ b/commit-e4a8812 @@ -0,0 +1,57 @@ +From e4a8812d72529fbaf168e50725b0ae6bf9951d23 Mon Sep 17 00:00:00 2001 +From: Jacek Caban +Date: Thu, 12 Feb 2015 17:27:47 +0100 +Subject: d2d1_1helper.h: Added a few missing declarations. + + +diff --git a/mingw-w64-headers/include/d2d1_1helper.h b/mingw-w64-headers/include/d2d1_1helper.h +index 9523203..54c6539 100644 +--- a/mingw-w64-headers/include/d2d1_1helper.h ++++ b/mingw-w64-headers/include/d2d1_1helper.h +@@ -10,11 +10,15 @@ + #ifndef D2D_USE_C_DEFINITIONS + + namespace D2D1 { ++ template<> struct TypeTraits { ++ typedef D2D1_POINT_2L Point; ++ typedef D2D1_RECT_L Rect; ++ }; + +- D2D1FORCEINLINE D2D1_VECTOR_2F Vector2F(FLOAT x = 0.0f, FLOAT y = 0.0f) { +- D2D1_VECTOR_2F r = {x, y}; +- return r; +- } ++ template<> struct TypeTraits { ++ typedef D2D1_POINT_2L Point; ++ typedef D2D1_RECT_L Rect; ++ }; + + D2D1FORCEINLINE D2D1_LAYER_PARAMETERS1 LayerParameters1(CONST D2D1_RECT_F &contentBounds = D2D1::InfiniteRect(), + ID2D1Geometry *geometricMask = NULL, D2D1_ANTIALIAS_MODE maskAntialiasMode = D2D1_ANTIALIAS_MODE_PER_PRIMITIVE, +@@ -63,6 +67,11 @@ namespace D2D1 { + } + }; + ++ D2D1FORCEINLINE D2D1_VECTOR_2F Vector2F(FLOAT x = 0.0f, FLOAT y = 0.0f) { ++ D2D1_VECTOR_2F r = {x, y}; ++ return r; ++ } ++ + D2D1FORCEINLINE D2D1_VECTOR_3F Vector3F(FLOAT x = 0.0f, FLOAT y = 0.0f, FLOAT z = 0.0f) { + D2D1_VECTOR_3F r = {x, y, z}; + return r; +@@ -72,6 +81,14 @@ namespace D2D1 { + D2D1_VECTOR_4F r = {x, y, z, w}; + return r; + } ++ ++ D2D1FORCEINLINE D2D1_POINT_2L Point2L(INT32 x = 0, INT32 y = 0) { ++ return Point2(x, y); ++ } ++ ++ D2D1FORCEINLINE D2D1_RECT_L RectL(INT32 left = 0.0f, INT32 top = 0.0f, INT32 right = 0.0f, INT32 bottom = 0.0f) { ++ return Rect(left, top, right, bottom); ++ } + } + + #endif /* D2D_USE_C_DEFINITIONS */ diff --git a/commit-e960f8f b/commit-e960f8f new file mode 100644 index 0000000..c929437 --- /dev/null +++ b/commit-e960f8f @@ -0,0 +1,34 @@ +From e960f8fffb399036079cef960a44e86a9abebc71 Mon Sep 17 00:00:00 2001 +From: Jacek Caban +Date: Thu, 19 Mar 2015 14:47:13 +0100 +Subject: winsdkver.h: Added *_WINBLUE defines. + + +diff --git a/mingw-w64-headers/include/sdkddkver.h b/mingw-w64-headers/include/sdkddkver.h +index 0433811..1b965ae 100644 +--- a/mingw-w64-headers/include/sdkddkver.h ++++ b/mingw-w64-headers/include/sdkddkver.h +@@ -21,6 +21,7 @@ + #define _WIN32_WINNT_LONGHORN 0x0600 + #define _WIN32_WINNT_WIN7 0x0601 + #define _WIN32_WINNT_WIN8 0x0602 ++#define _WIN32_WINNT_WINBLUE 0x0603 + + /* _WIN32_IE */ + #define _WIN32_IE_IE20 0x0200 +@@ -64,6 +65,7 @@ + #define _WIN32_IE_LONGHORN _WIN32_IE_IE70 + #define _WIN32_IE_WIN7 _WIN32_IE_IE80 + #define _WIN32_IE_WIN8 _WIN32_IE_IE100 ++#define _WIN32_IE_WINBLUE _WIN32_IE_IE100 + + /* NTDDI_VERSION */ + #ifndef NTDDI_WIN2K +@@ -124,6 +126,7 @@ + + #define NTDDI_WIN7 0x06010000 + #define NTDDI_WIN8 0x06020000 ++#define NTDDI_WINBLUE 0x06030000 + + /* Version Fields in NTDDI_VERSION */ + #define OSVERSION_MASK 0xFFFF0000U diff --git a/commit-ef5e914 b/commit-ef5e914 new file mode 100644 index 0000000..ea39b2a --- /dev/null +++ b/commit-ef5e914 @@ -0,0 +1,68 @@ +From ef5e914c022ca5a470046f47fccf984b766885bd Mon Sep 17 00:00:00 2001 +From: Jacek Caban +Date: Wed, 29 Apr 2015 22:01:51 +0200 +Subject: msinkaut_i.c: Added new file. + + +diff --git a/mingw-w64-headers/include/msinkaut_i.c b/mingw-w64-headers/include/msinkaut_i.c +new file mode 100644 +index 0000000..1edf4f7 +--- /dev/null ++++ b/mingw-w64-headers/include/msinkaut_i.c +@@ -0,0 +1,56 @@ ++/*** Autogenerated by WIDL 1.6 from include/msinkaut.idl - Do not edit ***/ ++ ++#include ++#include ++ ++#ifdef _MIDL_USE_GUIDDEF_ ++ ++#ifndef INITGUID ++#define INITGUID ++#include ++#undef INITGUID ++#else ++#include ++#endif ++ ++#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ ++ DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) ++ ++#else ++ ++#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ ++ const type name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}} ++ ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++MIDL_DEFINE_GUID(IID, IID_IInkExtendedProperty, 0xdb489209, 0xb7c3, 0x411d, 0x90,0xf6, 0x15,0x48,0xcf,0xff,0x27,0x1e); ++MIDL_DEFINE_GUID(IID, IID_IInkExtendedProperties, 0x89f2a8be, 0x95a9, 0x4530, 0x8b,0x8f, 0x88,0xe9,0x71,0xe3,0xe2,0x5f); ++MIDL_DEFINE_GUID(IID, IID_IInkDrawingAttributes, 0xbf519b75, 0x0a15, 0x4623, 0xad,0xc9, 0xc0,0x0d,0x43,0x6a,0x80,0x92); ++MIDL_DEFINE_GUID(IID, IID_IInkRectangle, 0x9794ff82, 0x6071, 0x4717, 0x8a,0x8b, 0x6a,0xc7,0xc6,0x4a,0x68,0x6e); ++MIDL_DEFINE_GUID(IID, IID_IInkTablet, 0x2de25eaa, 0x6ef8, 0x42d5, 0xae,0xe9, 0x18,0x5b,0xc8,0x1b,0x91,0x2d); ++MIDL_DEFINE_GUID(IID, IID_IInkCursorButton, 0x85ef9417, 0x1d59, 0x49b2, 0xa1,0x3c, 0x70,0x2c,0x85,0x43,0x08,0x94); ++MIDL_DEFINE_GUID(IID, IID_IInkCursorButtons, 0x3671cc40, 0xb624, 0x4671, 0x9f,0xa0, 0xdb,0x11,0x9d,0x95,0x2d,0x54); ++MIDL_DEFINE_GUID(IID, IID_IInkCursor, 0xad30c630, 0x40c5, 0x4350, 0x84,0x05, 0x9c,0x71,0x01,0x2f,0xc5,0x58); ++MIDL_DEFINE_GUID(IID, IID_IInkTransform, 0x615f1d43, 0x8703, 0x4565, 0x88,0xe2, 0x82,0x01,0xd2,0xec,0xd7,0xb7); ++MIDL_DEFINE_GUID(IID, IID_IInkRecognitionAlternates, 0x286a167f, 0x9f19, 0x4c61, 0x9d,0x53, 0x4f,0x07,0xbe,0x62,0x2b,0x84); ++MIDL_DEFINE_GUID(IID, IID_IInkRecognitionAlternate, 0xb7e660ad, 0x77e4, 0x429b, 0xad,0xda, 0x87,0x37,0x80,0xd1,0xfc,0x4a); ++MIDL_DEFINE_GUID(IID, IID_IInkRecognitionResult, 0x3bc129a8, 0x86cd, 0x45ad, 0xbd,0xe8, 0xe0,0xd3,0x2d,0x61,0xc1,0x6d); ++MIDL_DEFINE_GUID(IID, IID_IInkStrokeDisp, 0x43242fea, 0x91d1, 0x4a72, 0x96,0x3e, 0xfb,0xb9,0x18,0x29,0xcf,0xa2); ++MIDL_DEFINE_GUID(IID, IID_IInkCustomStrokes, 0x7e23a88f, 0xc30e, 0x420f, 0x9b,0xdb, 0x28,0x90,0x25,0x43,0xf0,0xc1); ++MIDL_DEFINE_GUID(IID, IID_IInkDisp, 0x9d398fa0, 0xc4e2, 0x4fcd, 0x99,0x73, 0x97,0x5c,0xaa,0xf4,0x7e,0xa6); ++MIDL_DEFINE_GUID(IID, IID_IInkStrokes, 0xf1f4c9d8, 0x590a, 0x4963, 0xb3,0xae, 0x19,0x35,0x67,0x1b,0xb6,0xf3); ++MIDL_DEFINE_GUID(IID, IID_IInkRenderer, 0xe6257a9c, 0xb511, 0x4f4c, 0xa8,0xb0, 0xa7,0xdb,0xc9,0x50,0x6b,0x83); ++MIDL_DEFINE_GUID(IID, IID_IInkCursors, 0xa248c1ac, 0xc698, 0x4e06, 0x9e,0x5c, 0xd5,0x7f,0x77,0xc7,0xe6,0x47); ++MIDL_DEFINE_GUID(IID, IID_IInkCollector, 0xf0f060b5, 0x8b1f, 0x4a7c, 0x89,0xec, 0x88,0x06,0x92,0x58,0x8a,0x4f); ++MIDL_DEFINE_GUID(IID, DIID__IInkCollectorEvents, 0x11a583f2, 0x712d, 0x4fea, 0xab,0xcf, 0xab,0x4a,0xf3,0x8e,0xa0,0x6b); ++MIDL_DEFINE_GUID(CLSID, CLSID_InkCollector, 0x43fb1553, 0xad74, 0x4ee8, 0x88,0xe4, 0x3e,0x6d,0xaa,0xc9,0x15,0xdb); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#undef MIDL_DEFINE_GUID diff --git a/commit-fc960d3 b/commit-fc960d3 new file mode 100644 index 0000000..9e29e05 --- /dev/null +++ b/commit-fc960d3 @@ -0,0 +1,7862 @@ +From fc960d33b03f8e241f501c5d7f79700c2d1c9a95 Mon Sep 17 00:00:00 2001 +From: Jacek Caban +Date: Wed, 29 Apr 2015 22:09:54 +0200 +Subject: msinkaut.h: Generated header file. + + +diff --git a/mingw-w64-headers/include/msinkaut.h b/mingw-w64-headers/include/msinkaut.h +new file mode 100644 +index 0000000..fadab56 +--- /dev/null ++++ b/mingw-w64-headers/include/msinkaut.h +@@ -0,0 +1,7850 @@ ++/*** Autogenerated by WIDL 1.6 from include/msinkaut.idl - Do not edit ***/ ++ ++#ifndef __REQUIRED_RPCNDR_H_VERSION__ ++#define __REQUIRED_RPCNDR_H_VERSION__ 475 ++#endif ++ ++#include ++#include ++ ++#ifndef COM_NO_WINDOWS_H ++#include ++#include ++#endif ++ ++#ifndef __msinkaut_h__ ++#define __msinkaut_h__ ++ ++/* Forward declarations */ ++ ++#ifndef __IInkExtendedProperty_FWD_DEFINED__ ++#define __IInkExtendedProperty_FWD_DEFINED__ ++typedef interface IInkExtendedProperty IInkExtendedProperty; ++#endif ++ ++#ifndef __IInkExtendedProperties_FWD_DEFINED__ ++#define __IInkExtendedProperties_FWD_DEFINED__ ++typedef interface IInkExtendedProperties IInkExtendedProperties; ++#endif ++ ++#ifndef __IInkDrawingAttributes_FWD_DEFINED__ ++#define __IInkDrawingAttributes_FWD_DEFINED__ ++typedef interface IInkDrawingAttributes IInkDrawingAttributes; ++#endif ++ ++#ifndef __IInkRectangle_FWD_DEFINED__ ++#define __IInkRectangle_FWD_DEFINED__ ++typedef interface IInkRectangle IInkRectangle; ++#endif ++ ++#ifndef __IInkTablet_FWD_DEFINED__ ++#define __IInkTablet_FWD_DEFINED__ ++typedef interface IInkTablet IInkTablet; ++#endif ++ ++#ifndef __IInkCursorButton_FWD_DEFINED__ ++#define __IInkCursorButton_FWD_DEFINED__ ++typedef interface IInkCursorButton IInkCursorButton; ++#endif ++ ++#ifndef __IInkCursorButtons_FWD_DEFINED__ ++#define __IInkCursorButtons_FWD_DEFINED__ ++typedef interface IInkCursorButtons IInkCursorButtons; ++#endif ++ ++#ifndef __IInkCursor_FWD_DEFINED__ ++#define __IInkCursor_FWD_DEFINED__ ++typedef interface IInkCursor IInkCursor; ++#endif ++ ++#ifndef __IInkTransform_FWD_DEFINED__ ++#define __IInkTransform_FWD_DEFINED__ ++typedef interface IInkTransform IInkTransform; ++#endif ++ ++#ifndef __IInkRecognitionAlternates_FWD_DEFINED__ ++#define __IInkRecognitionAlternates_FWD_DEFINED__ ++typedef interface IInkRecognitionAlternates IInkRecognitionAlternates; ++#endif ++ ++#ifndef __IInkRecognitionAlternate_FWD_DEFINED__ ++#define __IInkRecognitionAlternate_FWD_DEFINED__ ++typedef interface IInkRecognitionAlternate IInkRecognitionAlternate; ++#endif ++ ++#ifndef __IInkRecognitionResult_FWD_DEFINED__ ++#define __IInkRecognitionResult_FWD_DEFINED__ ++typedef interface IInkRecognitionResult IInkRecognitionResult; ++#endif ++ ++#ifndef __IInkStrokeDisp_FWD_DEFINED__ ++#define __IInkStrokeDisp_FWD_DEFINED__ ++typedef interface IInkStrokeDisp IInkStrokeDisp; ++#endif ++ ++#ifndef __IInkCustomStrokes_FWD_DEFINED__ ++#define __IInkCustomStrokes_FWD_DEFINED__ ++typedef interface IInkCustomStrokes IInkCustomStrokes; ++#endif ++ ++#ifndef __IInkDisp_FWD_DEFINED__ ++#define __IInkDisp_FWD_DEFINED__ ++typedef interface IInkDisp IInkDisp; ++#endif ++ ++#ifndef __IInkStrokes_FWD_DEFINED__ ++#define __IInkStrokes_FWD_DEFINED__ ++typedef interface IInkStrokes IInkStrokes; ++#endif ++ ++#ifndef __IInkRenderer_FWD_DEFINED__ ++#define __IInkRenderer_FWD_DEFINED__ ++typedef interface IInkRenderer IInkRenderer; ++#endif ++ ++#ifndef __IInkCursors_FWD_DEFINED__ ++#define __IInkCursors_FWD_DEFINED__ ++typedef interface IInkCursors IInkCursors; ++#endif ++ ++#ifndef __IInkCollector_FWD_DEFINED__ ++#define __IInkCollector_FWD_DEFINED__ ++typedef interface IInkCollector IInkCollector; ++#endif ++ ++#ifndef ___IInkCollectorEvents_FWD_DEFINED__ ++#define ___IInkCollectorEvents_FWD_DEFINED__ ++typedef interface _IInkCollectorEvents _IInkCollectorEvents; ++#endif ++ ++#ifndef __InkCollector_FWD_DEFINED__ ++#define __InkCollector_FWD_DEFINED__ ++#ifdef __cplusplus ++typedef class InkCollector InkCollector; ++#else ++typedef struct InkCollector InkCollector; ++#endif /* defined __cplusplus */ ++#endif /* defined __InkCollector_FWD_DEFINED__ */ ++ ++/* Headers for imported files */ ++ ++#include ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef enum InkRasterOperation { ++ IRO_Black = 1, ++ IRO_NotMergePen = 2, ++ IRO_MaskNotPen = 3, ++ IRO_NotCopyPen = 4, ++ IRO_MaskPenNot = 5, ++ IRO_Not = 6, ++ IRO_XOrPen = 7, ++ IRO_NotMaskPen = 8, ++ IRO_MaskPen = 9, ++ IRO_NotXOrPen = 10, ++ IRO_NoOperation = 11, ++ IRO_MergeNotPen = 12, ++ IRO_CopyPen = 13, ++ IRO_MergePenNot = 14, ++ IRO_MergePen = 15, ++ IRO_White = 16 ++} InkRasterOperation; ++typedef enum InkPenTip { ++ IPT_Ball = 0, ++ IPT_Rectangle = 1 ++} InkPenTip; ++typedef enum TabletHardwareCapabilities { ++ THWC_Integrated = 0x1, ++ THWC_CursorMustTouch = 0x2, ++ THWC_HardProximity = 0x4, ++ THWC_CursorsHavePhysicalIds = 0x8 ++} TabletHardwareCapabilities; ++typedef enum TabletPropertyMetricUnit { ++ TPMU_Default = 0, ++ TPMU_Inches = 1, ++ TPMU_Centimeters = 2, ++ TPMU_Degrees = 3, ++ TPMU_Radians = 4, ++ TPMU_Seconds = 5, ++ TPMU_Pounds = 6, ++ TPMU_Grams = 7 ++} TabletPropertyMetricUnit; ++typedef enum InkCursorButtonState { ++ ICBS_Unavailable = 0, ++ ICBS_Up = 1, ++ ICBS_Down = 2 ++} InkCursorButtonState; ++typedef enum InkRecognitionConfidence { ++ IRC_Strong = 0, ++ IRC_Intermediate = 1, ++ IRC_Poor = 2 ++} InkRecognitionConfidence; ++typedef enum InkBoundingBoxMode { ++ IBBM_Default = 0, ++ IBBM_NoCurveFit = 1, ++ IBBM_CurveFit = 2, ++ IBBM_PointsOnly = 3, ++ IBBM_Union = 4 ++} InkBoundingBoxMode; ++typedef enum InkExtractFlags { ++ IEF_CopyFromOriginal = 0, ++ IEF_RemoveFromOriginal = 1, ++ IEF_Default = IEF_RemoveFromOriginal ++} InkExtractFlags; ++typedef enum InkPersistenceFormat { ++ IPF_InkSerializedFormat = 0, ++ IPF_Base64InkSerializedFormat = 1, ++ IPF_GIF = 2, ++ IPF_Base64GIF = 3 ++} InkPersistenceFormat; ++typedef enum InkPersistenceCompressionMode { ++ IPCM_Default = 0, ++ IPCM_MaximumCompression = 1, ++ IPCM_NoCompression = 2 ++} InkPersistenceCompressionMode; ++typedef enum InkClipboardFormats { ++ ICF_None = 0x0, ++ ICF_InkSerializedFormat = 0x1, ++ ICF_SketchInk = 0x2, ++ ICF_TextInk = 0x6, ++ ICF_EnhancedMetafile = 0x8, ++ ICF_Metafile = 0x20, ++ ICF_Bitmap = 0x40, ++ ICF_PasteMask = 0x7, ++ ICF_CopyMask = 0x7f, ++ ICF_Default = ICF_CopyMask ++} InkClipboardFormats; ++typedef enum InkClipboardModes { ++ ICB_Copy = 0x0, ++ ICB_Cut = 0x1, ++ ICB_ExtractOnly = 0x30, ++ ICB_DelayedCopy = 0x20, ++ ICB_Default = ICB_Copy ++} InkClipboardModes; ++typedef enum InkCollectionMode { ++ ICM_InkOnly = 0, ++ ICM_GestureOnly = 1, ++ ICM_InkAndGesture = 2 ++} InkCollectionMode; ++typedef enum InkMousePointer { ++ IMP_Default = 0, ++ IMP_Arrow = 1, ++ IMP_Crosshair = 2, ++ IMP_Ibeam = 3, ++ IMP_SizeNESW = 4, ++ IMP_SizeNS = 5, ++ IMP_SizeNWSE = 6, ++ IMP_SizeWE = 7, ++ IMP_UpArrow = 8, ++ IMP_Hourglass = 9, ++ IMP_NoDrop = 10, ++ IMP_ArrowHourglass = 11, ++ IMP_ArrowQuestion = 12, ++ IMP_SizeAll = 13, ++ IMP_Hand = 14, ++ IMP_Custom = 99 ++} InkMousePointer; ++typedef enum InkApplicationGesture { ++ IAG_AllGestures = 0x0, ++ IAG_NoGesture = 0xf000, ++ IAG_Scratchout = 0xf001, ++ IAG_Triangle = 0xf002, ++ IAG_Square = 0xf003, ++ IAG_Star = 0xf004, ++ IAG_Check = 0xf005, ++ IAG_Curlicue = 0xf010, ++ IAG_DoubleCurlicue = 0xf011, ++ IAG_Circle = 0xf020, ++ IAG_DoubleCircle = 0xf021, ++ IAG_SemiCircleLeft = 0xf028, ++ IAG_SemiCircleRight = 0xf029, ++ IAG_ChevronUp = 0xf030, ++ IAG_ChevronDown = 0xf031, ++ IAG_ChevronLeft = 0xf032, ++ IAG_ChevronRight = 0xf033, ++ IAG_ArrowUp = 0xf038, ++ IAG_ArrowDown = 0xf039, ++ IAG_ArrowLeft = 0xf03a, ++ IAG_ArrowRight = 0xf03b, ++ IAG_Up = 0xf058, ++ IAG_Down = 0xf059, ++ IAG_Left = 0xf05a, ++ IAG_Right = 0xf05b, ++ IAG_UpDown = 0xf060, ++ IAG_DownUp = 0xf061, ++ IAG_LeftRight = 0xf062, ++ IAG_RightLeft = 0xf063, ++ IAG_UpLeftLong = 0xf064, ++ IAG_UpRightLong = 0xf065, ++ IAG_DownLeftLong = 0xf066, ++ IAG_DownRightLong = 0xf067, ++ IAG_UpLeft = 0xf068, ++ IAG_UpRight = 0xf069, ++ IAG_DownLeft = 0xf06a, ++ IAG_DownRight = 0xf06b, ++ IAG_LeftUp = 0xf06c, ++ IAG_LeftDown = 0xf06d, ++ IAG_RightUp = 0xf06e, ++ IAG_RightDown = 0xf06f, ++ IAG_Exclamation = 0xf0a4, ++ IAG_Tap = 0xf0f0, ++ IAG_DoubleTap = 0xf0f1 ++} InkApplicationGesture; ++typedef enum InkCollectorEventInterest { ++ ICEI_DefaultEvents = -1, ++ ICEI_CursorDown = ICEI_DefaultEvents + 1, ++ ICEI_Stroke = ICEI_CursorDown + 1, ++ ICEI_NewPackets = ICEI_Stroke + 1, ++ ICEI_NewInAirPackets = ICEI_NewPackets + 1, ++ ICEI_CursorButtonDown = ICEI_NewInAirPackets + 1, ++ ICEI_CursorButtonUp = ICEI_CursorButtonDown + 1, ++ ICEI_CursorInRange = ICEI_CursorButtonUp + 1, ++ ICEI_CursorOutOfRange = ICEI_CursorInRange + 1, ++ ICEI_SystemGesture = ICEI_CursorOutOfRange + 1, ++ ICEI_TabletAdded = ICEI_SystemGesture + 1, ++ ICEI_TabletRemoved = ICEI_TabletAdded + 1, ++ ICEI_MouseDown = ICEI_TabletRemoved + 1, ++ ICEI_MouseMove = ICEI_MouseDown + 1, ++ ICEI_MouseUp = ICEI_MouseMove + 1, ++ ICEI_MouseWheel = ICEI_MouseUp + 1, ++ ICEI_DblClick = ICEI_MouseWheel + 1, ++ ICEI_AllEvents = ICEI_DblClick + 1 ++} InkCollectorEventInterest; ++typedef enum DISPID_InkCollectorEvent { ++ DISPID_ICEStroke = 1, ++ DISPID_ICECursorDown = DISPID_ICEStroke + 1, ++ DISPID_ICENewPackets = DISPID_ICECursorDown + 1, ++ DISPID_ICENewInAirPackets = DISPID_ICENewPackets + 1, ++ DISPID_ICECursorButtonDown = DISPID_ICENewInAirPackets + 1, ++ DISPID_ICECursorButtonUp = DISPID_ICECursorButtonDown + 1, ++ DISPID_ICECursorInRange = DISPID_ICECursorButtonUp + 1, ++ DISPID_ICECursorOutOfRange = DISPID_ICECursorInRange + 1, ++ DISPID_ICESystemGesture = DISPID_ICECursorOutOfRange + 1, ++ DISPID_ICEGesture = DISPID_ICESystemGesture + 1, ++ DISPID_ICETabletAdded = DISPID_ICEGesture + 1, ++ DISPID_ICETabletRemoved = DISPID_ICETabletAdded + 1, ++ DISPID_IOEPainting = DISPID_ICETabletRemoved + 1, ++ DISPID_IOEPainted = DISPID_IOEPainting + 1, ++ DISPID_IOESelectionChanging = DISPID_IOEPainted + 1, ++ DISPID_IOESelectionChanged = DISPID_IOESelectionChanging + 1, ++ DISPID_IOESelectionMoving = DISPID_IOESelectionChanged + 1, ++ DISPID_IOESelectionMoved = DISPID_IOESelectionMoving + 1, ++ DISPID_IOESelectionResizing = DISPID_IOESelectionMoved + 1, ++ DISPID_IOESelectionResized = DISPID_IOESelectionResizing + 1, ++ DISPID_IOEStrokesDeleting = DISPID_IOESelectionResized + 1, ++ DISPID_IOEStrokesDeleted = DISPID_IOEStrokesDeleting + 1, ++ DISPID_IPEChangeUICues = DISPID_IOEStrokesDeleted + 1, ++ DISPID_IPEClick = DISPID_IPEChangeUICues + 1, ++ DISPID_IPEDblClick = DISPID_IPEClick + 1, ++ DISPID_IPEInvalidated = DISPID_IPEDblClick + 1, ++ DISPID_IPEMouseDown = DISPID_IPEInvalidated + 1, ++ DISPID_IPEMouseEnter = DISPID_IPEMouseDown + 1, ++ DISPID_IPEMouseHover = DISPID_IPEMouseEnter + 1, ++ DISPID_IPEMouseLeave = DISPID_IPEMouseHover + 1, ++ DISPID_IPEMouseMove = DISPID_IPEMouseLeave + 1, ++ DISPID_IPEMouseUp = DISPID_IPEMouseMove + 1, ++ DISPID_IPEMouseWheel = DISPID_IPEMouseUp + 1, ++ DISPID_IPESizeModeChanged = DISPID_IPEMouseWheel + 1, ++ DISPID_IPEStyleChanged = DISPID_IPESizeModeChanged + 1, ++ DISPID_IPESystemColorsChanged = DISPID_IPEStyleChanged + 1, ++ DISPID_IPEKeyDown = DISPID_IPESystemColorsChanged + 1, ++ DISPID_IPEKeyPress = DISPID_IPEKeyDown + 1, ++ DISPID_IPEKeyUp = DISPID_IPEKeyPress + 1, ++ DISPID_IPEResize = DISPID_IPEKeyUp + 1, ++ DISPID_IPESizeChanged = DISPID_IPEResize + 1 ++} DISPID_InkCollectorEvent; ++#ifndef __IInkDisp_FWD_DEFINED__ ++#define __IInkDisp_FWD_DEFINED__ ++typedef interface IInkDisp IInkDisp; ++#endif ++ ++#ifndef __IInkStrokes_FWD_DEFINED__ ++#define __IInkStrokes_FWD_DEFINED__ ++typedef interface IInkStrokes IInkStrokes; ++#endif ++ ++#ifndef __IInkRecognitionAlternate_FWD_DEFINED__ ++#define __IInkRecognitionAlternate_FWD_DEFINED__ ++typedef interface IInkRecognitionAlternate IInkRecognitionAlternate; ++#endif ++ ++/***************************************************************************** ++ * IInkExtendedProperty interface ++ */ ++#ifndef __IInkExtendedProperty_INTERFACE_DEFINED__ ++#define __IInkExtendedProperty_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkExtendedProperty, 0xdb489209, 0xb7c3, 0x411d, 0x90,0xf6, 0x15,0x48,0xcf,0xff,0x27,0x1e); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("db489209-b7c3-411d-90f6-1548cfff271e") ++IInkExtendedProperty : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Guid( ++ BSTR *Guid) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Data( ++ VARIANT *Data) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Data( ++ VARIANT Data) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkExtendedProperty, 0xdb489209, 0xb7c3, 0x411d, 0x90,0xf6, 0x15,0x48,0xcf,0xff,0x27,0x1e) ++#endif ++#else ++typedef struct IInkExtendedPropertyVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkExtendedProperty* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkExtendedProperty* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkExtendedProperty* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkExtendedProperty* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkExtendedProperty* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkExtendedProperty* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkExtendedProperty* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkExtendedProperty methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Guid)( ++ IInkExtendedProperty* This, ++ BSTR *Guid); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Data)( ++ IInkExtendedProperty* This, ++ VARIANT *Data); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Data)( ++ IInkExtendedProperty* This, ++ VARIANT Data); ++ ++ END_INTERFACE ++} IInkExtendedPropertyVtbl; ++interface IInkExtendedProperty { ++ CONST_VTBL IInkExtendedPropertyVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkExtendedProperty_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkExtendedProperty_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkExtendedProperty_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkExtendedProperty_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkExtendedProperty_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkExtendedProperty_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkExtendedProperty_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkExtendedProperty methods ***/ ++#define IInkExtendedProperty_get_Guid(This,Guid) (This)->lpVtbl->get_Guid(This,Guid) ++#define IInkExtendedProperty_get_Data(This,Data) (This)->lpVtbl->get_Data(This,Data) ++#define IInkExtendedProperty_put_Data(This,Data) (This)->lpVtbl->put_Data(This,Data) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkExtendedProperty_QueryInterface(IInkExtendedProperty* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkExtendedProperty_AddRef(IInkExtendedProperty* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkExtendedProperty_Release(IInkExtendedProperty* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkExtendedProperty_GetTypeInfoCount(IInkExtendedProperty* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkExtendedProperty_GetTypeInfo(IInkExtendedProperty* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkExtendedProperty_GetIDsOfNames(IInkExtendedProperty* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkExtendedProperty_Invoke(IInkExtendedProperty* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkExtendedProperty methods ***/ ++static FORCEINLINE HRESULT IInkExtendedProperty_get_Guid(IInkExtendedProperty* This,BSTR *Guid) { ++ return This->lpVtbl->get_Guid(This,Guid); ++} ++static FORCEINLINE HRESULT IInkExtendedProperty_get_Data(IInkExtendedProperty* This,VARIANT *Data) { ++ return This->lpVtbl->get_Data(This,Data); ++} ++static FORCEINLINE HRESULT IInkExtendedProperty_put_Data(IInkExtendedProperty* This,VARIANT Data) { ++ return This->lpVtbl->put_Data(This,Data); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkExtendedProperty_get_Guid_Proxy( ++ IInkExtendedProperty* This, ++ BSTR *Guid); ++void __RPC_STUB IInkExtendedProperty_get_Guid_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkExtendedProperty_get_Data_Proxy( ++ IInkExtendedProperty* This, ++ VARIANT *Data); ++void __RPC_STUB IInkExtendedProperty_get_Data_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkExtendedProperty_put_Data_Proxy( ++ IInkExtendedProperty* This, ++ VARIANT Data); ++void __RPC_STUB IInkExtendedProperty_put_Data_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkExtendedProperty_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkExtendedProperties interface ++ */ ++#ifndef __IInkExtendedProperties_INTERFACE_DEFINED__ ++#define __IInkExtendedProperties_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkExtendedProperties, 0x89f2a8be, 0x95a9, 0x4530, 0x8b,0x8f, 0x88,0xe9,0x71,0xe3,0xe2,0x5f); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("89f2a8be-95a9-4530-8b8f-88e971e3e25f") ++IInkExtendedProperties : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Count( ++ LONG *Count) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get__NewEnum( ++ IUnknown **_NewEnum) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Item( ++ VARIANT Identifier, ++ IInkExtendedProperty **Item) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Add( ++ BSTR Guid, ++ VARIANT Data, ++ IInkExtendedProperty **InkExtendedProperty) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Remove( ++ VARIANT Identifier) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Clear( ++ ) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE DoesPropertyExist( ++ BSTR Guid, ++ VARIANT_BOOL *DoesPropertyExist) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkExtendedProperties, 0x89f2a8be, 0x95a9, 0x4530, 0x8b,0x8f, 0x88,0xe9,0x71,0xe3,0xe2,0x5f) ++#endif ++#else ++typedef struct IInkExtendedPropertiesVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkExtendedProperties* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkExtendedProperties* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkExtendedProperties* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkExtendedProperties* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkExtendedProperties* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkExtendedProperties* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkExtendedProperties* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkExtendedProperties methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Count)( ++ IInkExtendedProperties* This, ++ LONG *Count); ++ ++ HRESULT (STDMETHODCALLTYPE *get__NewEnum)( ++ IInkExtendedProperties* This, ++ IUnknown **_NewEnum); ++ ++ HRESULT (STDMETHODCALLTYPE *Item)( ++ IInkExtendedProperties* This, ++ VARIANT Identifier, ++ IInkExtendedProperty **Item); ++ ++ HRESULT (STDMETHODCALLTYPE *Add)( ++ IInkExtendedProperties* This, ++ BSTR Guid, ++ VARIANT Data, ++ IInkExtendedProperty **InkExtendedProperty); ++ ++ HRESULT (STDMETHODCALLTYPE *Remove)( ++ IInkExtendedProperties* This, ++ VARIANT Identifier); ++ ++ HRESULT (STDMETHODCALLTYPE *Clear)( ++ IInkExtendedProperties* This); ++ ++ HRESULT (STDMETHODCALLTYPE *DoesPropertyExist)( ++ IInkExtendedProperties* This, ++ BSTR Guid, ++ VARIANT_BOOL *DoesPropertyExist); ++ ++ END_INTERFACE ++} IInkExtendedPropertiesVtbl; ++interface IInkExtendedProperties { ++ CONST_VTBL IInkExtendedPropertiesVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkExtendedProperties_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkExtendedProperties_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkExtendedProperties_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkExtendedProperties_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkExtendedProperties_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkExtendedProperties_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkExtendedProperties_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkExtendedProperties methods ***/ ++#define IInkExtendedProperties_get_Count(This,Count) (This)->lpVtbl->get_Count(This,Count) ++#define IInkExtendedProperties_get__NewEnum(This,_NewEnum) (This)->lpVtbl->get__NewEnum(This,_NewEnum) ++#define IInkExtendedProperties_Item(This,Identifier,Item) (This)->lpVtbl->Item(This,Identifier,Item) ++#define IInkExtendedProperties_Add(This,Guid,Data,InkExtendedProperty) (This)->lpVtbl->Add(This,Guid,Data,InkExtendedProperty) ++#define IInkExtendedProperties_Remove(This,Identifier) (This)->lpVtbl->Remove(This,Identifier) ++#define IInkExtendedProperties_Clear(This) (This)->lpVtbl->Clear(This) ++#define IInkExtendedProperties_DoesPropertyExist(This,Guid,DoesPropertyExist) (This)->lpVtbl->DoesPropertyExist(This,Guid,DoesPropertyExist) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkExtendedProperties_QueryInterface(IInkExtendedProperties* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkExtendedProperties_AddRef(IInkExtendedProperties* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkExtendedProperties_Release(IInkExtendedProperties* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkExtendedProperties_GetTypeInfoCount(IInkExtendedProperties* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkExtendedProperties_GetTypeInfo(IInkExtendedProperties* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkExtendedProperties_GetIDsOfNames(IInkExtendedProperties* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkExtendedProperties_Invoke(IInkExtendedProperties* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkExtendedProperties methods ***/ ++static FORCEINLINE HRESULT IInkExtendedProperties_get_Count(IInkExtendedProperties* This,LONG *Count) { ++ return This->lpVtbl->get_Count(This,Count); ++} ++static FORCEINLINE HRESULT IInkExtendedProperties_get__NewEnum(IInkExtendedProperties* This,IUnknown **_NewEnum) { ++ return This->lpVtbl->get__NewEnum(This,_NewEnum); ++} ++static FORCEINLINE HRESULT IInkExtendedProperties_Item(IInkExtendedProperties* This,VARIANT Identifier,IInkExtendedProperty **Item) { ++ return This->lpVtbl->Item(This,Identifier,Item); ++} ++static FORCEINLINE HRESULT IInkExtendedProperties_Add(IInkExtendedProperties* This,BSTR Guid,VARIANT Data,IInkExtendedProperty **InkExtendedProperty) { ++ return This->lpVtbl->Add(This,Guid,Data,InkExtendedProperty); ++} ++static FORCEINLINE HRESULT IInkExtendedProperties_Remove(IInkExtendedProperties* This,VARIANT Identifier) { ++ return This->lpVtbl->Remove(This,Identifier); ++} ++static FORCEINLINE HRESULT IInkExtendedProperties_Clear(IInkExtendedProperties* This) { ++ return This->lpVtbl->Clear(This); ++} ++static FORCEINLINE HRESULT IInkExtendedProperties_DoesPropertyExist(IInkExtendedProperties* This,BSTR Guid,VARIANT_BOOL *DoesPropertyExist) { ++ return This->lpVtbl->DoesPropertyExist(This,Guid,DoesPropertyExist); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkExtendedProperties_get_Count_Proxy( ++ IInkExtendedProperties* This, ++ LONG *Count); ++void __RPC_STUB IInkExtendedProperties_get_Count_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkExtendedProperties_get__NewEnum_Proxy( ++ IInkExtendedProperties* This, ++ IUnknown **_NewEnum); ++void __RPC_STUB IInkExtendedProperties_get__NewEnum_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkExtendedProperties_Item_Proxy( ++ IInkExtendedProperties* This, ++ VARIANT Identifier, ++ IInkExtendedProperty **Item); ++void __RPC_STUB IInkExtendedProperties_Item_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkExtendedProperties_Add_Proxy( ++ IInkExtendedProperties* This, ++ BSTR Guid, ++ VARIANT Data, ++ IInkExtendedProperty **InkExtendedProperty); ++void __RPC_STUB IInkExtendedProperties_Add_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkExtendedProperties_Remove_Proxy( ++ IInkExtendedProperties* This, ++ VARIANT Identifier); ++void __RPC_STUB IInkExtendedProperties_Remove_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkExtendedProperties_Clear_Proxy( ++ IInkExtendedProperties* This); ++void __RPC_STUB IInkExtendedProperties_Clear_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkExtendedProperties_DoesPropertyExist_Proxy( ++ IInkExtendedProperties* This, ++ BSTR Guid, ++ VARIANT_BOOL *DoesPropertyExist); ++void __RPC_STUB IInkExtendedProperties_DoesPropertyExist_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkExtendedProperties_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkDrawingAttributes interface ++ */ ++#ifndef __IInkDrawingAttributes_INTERFACE_DEFINED__ ++#define __IInkDrawingAttributes_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkDrawingAttributes, 0xbf519b75, 0x0a15, 0x4623, 0xad,0xc9, 0xc0,0x0d,0x43,0x6a,0x80,0x92); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("bf519b75-0a15-4623-adc9-c00d436a8092") ++IInkDrawingAttributes : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Color( ++ LONG *CurrentColor) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Color( ++ LONG NewColor) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Width( ++ float *CurrentWidth) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Width( ++ float NewWidth) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Height( ++ float *CurrentHeight) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Height( ++ float NewHeight) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_FitToCurve( ++ VARIANT_BOOL *Flag) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_FitToCurve( ++ VARIANT_BOOL Flag) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_IgnorePressure( ++ VARIANT_BOOL *Flag) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_IgnorePressure( ++ VARIANT_BOOL Flag) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_AntiAliased( ++ VARIANT_BOOL *Flag) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_AntiAliased( ++ VARIANT_BOOL Flag) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Transparency( ++ LONG *CurrentTransparency) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Transparency( ++ LONG NewTransparency) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_RasterOperation( ++ InkRasterOperation *CurrentRasterOperation) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_RasterOperation( ++ InkRasterOperation NewRasterOperation) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_PenTip( ++ InkPenTip *CurrentPenTip) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_PenTip( ++ InkPenTip NewPenTip) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_ExtendedProperties( ++ IInkExtendedProperties **Properties) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Clone( ++ IInkDrawingAttributes **DrawingAttributes) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkDrawingAttributes, 0xbf519b75, 0x0a15, 0x4623, 0xad,0xc9, 0xc0,0x0d,0x43,0x6a,0x80,0x92) ++#endif ++#else ++typedef struct IInkDrawingAttributesVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkDrawingAttributes* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkDrawingAttributes* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkDrawingAttributes* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkDrawingAttributes* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkDrawingAttributes* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkDrawingAttributes* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkDrawingAttributes* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkDrawingAttributes methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Color)( ++ IInkDrawingAttributes* This, ++ LONG *CurrentColor); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Color)( ++ IInkDrawingAttributes* This, ++ LONG NewColor); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Width)( ++ IInkDrawingAttributes* This, ++ float *CurrentWidth); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Width)( ++ IInkDrawingAttributes* This, ++ float NewWidth); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Height)( ++ IInkDrawingAttributes* This, ++ float *CurrentHeight); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Height)( ++ IInkDrawingAttributes* This, ++ float NewHeight); ++ ++ HRESULT (STDMETHODCALLTYPE *get_FitToCurve)( ++ IInkDrawingAttributes* This, ++ VARIANT_BOOL *Flag); ++ ++ HRESULT (STDMETHODCALLTYPE *put_FitToCurve)( ++ IInkDrawingAttributes* This, ++ VARIANT_BOOL Flag); ++ ++ HRESULT (STDMETHODCALLTYPE *get_IgnorePressure)( ++ IInkDrawingAttributes* This, ++ VARIANT_BOOL *Flag); ++ ++ HRESULT (STDMETHODCALLTYPE *put_IgnorePressure)( ++ IInkDrawingAttributes* This, ++ VARIANT_BOOL Flag); ++ ++ HRESULT (STDMETHODCALLTYPE *get_AntiAliased)( ++ IInkDrawingAttributes* This, ++ VARIANT_BOOL *Flag); ++ ++ HRESULT (STDMETHODCALLTYPE *put_AntiAliased)( ++ IInkDrawingAttributes* This, ++ VARIANT_BOOL Flag); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Transparency)( ++ IInkDrawingAttributes* This, ++ LONG *CurrentTransparency); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Transparency)( ++ IInkDrawingAttributes* This, ++ LONG NewTransparency); ++ ++ HRESULT (STDMETHODCALLTYPE *get_RasterOperation)( ++ IInkDrawingAttributes* This, ++ InkRasterOperation *CurrentRasterOperation); ++ ++ HRESULT (STDMETHODCALLTYPE *put_RasterOperation)( ++ IInkDrawingAttributes* This, ++ InkRasterOperation NewRasterOperation); ++ ++ HRESULT (STDMETHODCALLTYPE *get_PenTip)( ++ IInkDrawingAttributes* This, ++ InkPenTip *CurrentPenTip); ++ ++ HRESULT (STDMETHODCALLTYPE *put_PenTip)( ++ IInkDrawingAttributes* This, ++ InkPenTip NewPenTip); ++ ++ HRESULT (STDMETHODCALLTYPE *get_ExtendedProperties)( ++ IInkDrawingAttributes* This, ++ IInkExtendedProperties **Properties); ++ ++ HRESULT (STDMETHODCALLTYPE *Clone)( ++ IInkDrawingAttributes* This, ++ IInkDrawingAttributes **DrawingAttributes); ++ ++ END_INTERFACE ++} IInkDrawingAttributesVtbl; ++interface IInkDrawingAttributes { ++ CONST_VTBL IInkDrawingAttributesVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkDrawingAttributes_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkDrawingAttributes_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkDrawingAttributes_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkDrawingAttributes_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkDrawingAttributes_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkDrawingAttributes_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkDrawingAttributes_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkDrawingAttributes methods ***/ ++#define IInkDrawingAttributes_get_Color(This,CurrentColor) (This)->lpVtbl->get_Color(This,CurrentColor) ++#define IInkDrawingAttributes_put_Color(This,NewColor) (This)->lpVtbl->put_Color(This,NewColor) ++#define IInkDrawingAttributes_get_Width(This,CurrentWidth) (This)->lpVtbl->get_Width(This,CurrentWidth) ++#define IInkDrawingAttributes_put_Width(This,NewWidth) (This)->lpVtbl->put_Width(This,NewWidth) ++#define IInkDrawingAttributes_get_Height(This,CurrentHeight) (This)->lpVtbl->get_Height(This,CurrentHeight) ++#define IInkDrawingAttributes_put_Height(This,NewHeight) (This)->lpVtbl->put_Height(This,NewHeight) ++#define IInkDrawingAttributes_get_FitToCurve(This,Flag) (This)->lpVtbl->get_FitToCurve(This,Flag) ++#define IInkDrawingAttributes_put_FitToCurve(This,Flag) (This)->lpVtbl->put_FitToCurve(This,Flag) ++#define IInkDrawingAttributes_get_IgnorePressure(This,Flag) (This)->lpVtbl->get_IgnorePressure(This,Flag) ++#define IInkDrawingAttributes_put_IgnorePressure(This,Flag) (This)->lpVtbl->put_IgnorePressure(This,Flag) ++#define IInkDrawingAttributes_get_AntiAliased(This,Flag) (This)->lpVtbl->get_AntiAliased(This,Flag) ++#define IInkDrawingAttributes_put_AntiAliased(This,Flag) (This)->lpVtbl->put_AntiAliased(This,Flag) ++#define IInkDrawingAttributes_get_Transparency(This,CurrentTransparency) (This)->lpVtbl->get_Transparency(This,CurrentTransparency) ++#define IInkDrawingAttributes_put_Transparency(This,NewTransparency) (This)->lpVtbl->put_Transparency(This,NewTransparency) ++#define IInkDrawingAttributes_get_RasterOperation(This,CurrentRasterOperation) (This)->lpVtbl->get_RasterOperation(This,CurrentRasterOperation) ++#define IInkDrawingAttributes_put_RasterOperation(This,NewRasterOperation) (This)->lpVtbl->put_RasterOperation(This,NewRasterOperation) ++#define IInkDrawingAttributes_get_PenTip(This,CurrentPenTip) (This)->lpVtbl->get_PenTip(This,CurrentPenTip) ++#define IInkDrawingAttributes_put_PenTip(This,NewPenTip) (This)->lpVtbl->put_PenTip(This,NewPenTip) ++#define IInkDrawingAttributes_get_ExtendedProperties(This,Properties) (This)->lpVtbl->get_ExtendedProperties(This,Properties) ++#define IInkDrawingAttributes_Clone(This,DrawingAttributes) (This)->lpVtbl->Clone(This,DrawingAttributes) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkDrawingAttributes_QueryInterface(IInkDrawingAttributes* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkDrawingAttributes_AddRef(IInkDrawingAttributes* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkDrawingAttributes_Release(IInkDrawingAttributes* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkDrawingAttributes_GetTypeInfoCount(IInkDrawingAttributes* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_GetTypeInfo(IInkDrawingAttributes* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_GetIDsOfNames(IInkDrawingAttributes* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_Invoke(IInkDrawingAttributes* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkDrawingAttributes methods ***/ ++static FORCEINLINE HRESULT IInkDrawingAttributes_get_Color(IInkDrawingAttributes* This,LONG *CurrentColor) { ++ return This->lpVtbl->get_Color(This,CurrentColor); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_put_Color(IInkDrawingAttributes* This,LONG NewColor) { ++ return This->lpVtbl->put_Color(This,NewColor); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_get_Width(IInkDrawingAttributes* This,float *CurrentWidth) { ++ return This->lpVtbl->get_Width(This,CurrentWidth); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_put_Width(IInkDrawingAttributes* This,float NewWidth) { ++ return This->lpVtbl->put_Width(This,NewWidth); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_get_Height(IInkDrawingAttributes* This,float *CurrentHeight) { ++ return This->lpVtbl->get_Height(This,CurrentHeight); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_put_Height(IInkDrawingAttributes* This,float NewHeight) { ++ return This->lpVtbl->put_Height(This,NewHeight); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_get_FitToCurve(IInkDrawingAttributes* This,VARIANT_BOOL *Flag) { ++ return This->lpVtbl->get_FitToCurve(This,Flag); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_put_FitToCurve(IInkDrawingAttributes* This,VARIANT_BOOL Flag) { ++ return This->lpVtbl->put_FitToCurve(This,Flag); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_get_IgnorePressure(IInkDrawingAttributes* This,VARIANT_BOOL *Flag) { ++ return This->lpVtbl->get_IgnorePressure(This,Flag); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_put_IgnorePressure(IInkDrawingAttributes* This,VARIANT_BOOL Flag) { ++ return This->lpVtbl->put_IgnorePressure(This,Flag); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_get_AntiAliased(IInkDrawingAttributes* This,VARIANT_BOOL *Flag) { ++ return This->lpVtbl->get_AntiAliased(This,Flag); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_put_AntiAliased(IInkDrawingAttributes* This,VARIANT_BOOL Flag) { ++ return This->lpVtbl->put_AntiAliased(This,Flag); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_get_Transparency(IInkDrawingAttributes* This,LONG *CurrentTransparency) { ++ return This->lpVtbl->get_Transparency(This,CurrentTransparency); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_put_Transparency(IInkDrawingAttributes* This,LONG NewTransparency) { ++ return This->lpVtbl->put_Transparency(This,NewTransparency); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_get_RasterOperation(IInkDrawingAttributes* This,InkRasterOperation *CurrentRasterOperation) { ++ return This->lpVtbl->get_RasterOperation(This,CurrentRasterOperation); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_put_RasterOperation(IInkDrawingAttributes* This,InkRasterOperation NewRasterOperation) { ++ return This->lpVtbl->put_RasterOperation(This,NewRasterOperation); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_get_PenTip(IInkDrawingAttributes* This,InkPenTip *CurrentPenTip) { ++ return This->lpVtbl->get_PenTip(This,CurrentPenTip); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_put_PenTip(IInkDrawingAttributes* This,InkPenTip NewPenTip) { ++ return This->lpVtbl->put_PenTip(This,NewPenTip); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_get_ExtendedProperties(IInkDrawingAttributes* This,IInkExtendedProperties **Properties) { ++ return This->lpVtbl->get_ExtendedProperties(This,Properties); ++} ++static FORCEINLINE HRESULT IInkDrawingAttributes_Clone(IInkDrawingAttributes* This,IInkDrawingAttributes **DrawingAttributes) { ++ return This->lpVtbl->Clone(This,DrawingAttributes); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_get_Color_Proxy( ++ IInkDrawingAttributes* This, ++ LONG *CurrentColor); ++void __RPC_STUB IInkDrawingAttributes_get_Color_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_put_Color_Proxy( ++ IInkDrawingAttributes* This, ++ LONG NewColor); ++void __RPC_STUB IInkDrawingAttributes_put_Color_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_get_Width_Proxy( ++ IInkDrawingAttributes* This, ++ float *CurrentWidth); ++void __RPC_STUB IInkDrawingAttributes_get_Width_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_put_Width_Proxy( ++ IInkDrawingAttributes* This, ++ float NewWidth); ++void __RPC_STUB IInkDrawingAttributes_put_Width_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_get_Height_Proxy( ++ IInkDrawingAttributes* This, ++ float *CurrentHeight); ++void __RPC_STUB IInkDrawingAttributes_get_Height_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_put_Height_Proxy( ++ IInkDrawingAttributes* This, ++ float NewHeight); ++void __RPC_STUB IInkDrawingAttributes_put_Height_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_get_FitToCurve_Proxy( ++ IInkDrawingAttributes* This, ++ VARIANT_BOOL *Flag); ++void __RPC_STUB IInkDrawingAttributes_get_FitToCurve_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_put_FitToCurve_Proxy( ++ IInkDrawingAttributes* This, ++ VARIANT_BOOL Flag); ++void __RPC_STUB IInkDrawingAttributes_put_FitToCurve_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_get_IgnorePressure_Proxy( ++ IInkDrawingAttributes* This, ++ VARIANT_BOOL *Flag); ++void __RPC_STUB IInkDrawingAttributes_get_IgnorePressure_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_put_IgnorePressure_Proxy( ++ IInkDrawingAttributes* This, ++ VARIANT_BOOL Flag); ++void __RPC_STUB IInkDrawingAttributes_put_IgnorePressure_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_get_AntiAliased_Proxy( ++ IInkDrawingAttributes* This, ++ VARIANT_BOOL *Flag); ++void __RPC_STUB IInkDrawingAttributes_get_AntiAliased_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_put_AntiAliased_Proxy( ++ IInkDrawingAttributes* This, ++ VARIANT_BOOL Flag); ++void __RPC_STUB IInkDrawingAttributes_put_AntiAliased_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_get_Transparency_Proxy( ++ IInkDrawingAttributes* This, ++ LONG *CurrentTransparency); ++void __RPC_STUB IInkDrawingAttributes_get_Transparency_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_put_Transparency_Proxy( ++ IInkDrawingAttributes* This, ++ LONG NewTransparency); ++void __RPC_STUB IInkDrawingAttributes_put_Transparency_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_get_RasterOperation_Proxy( ++ IInkDrawingAttributes* This, ++ InkRasterOperation *CurrentRasterOperation); ++void __RPC_STUB IInkDrawingAttributes_get_RasterOperation_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_put_RasterOperation_Proxy( ++ IInkDrawingAttributes* This, ++ InkRasterOperation NewRasterOperation); ++void __RPC_STUB IInkDrawingAttributes_put_RasterOperation_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_get_PenTip_Proxy( ++ IInkDrawingAttributes* This, ++ InkPenTip *CurrentPenTip); ++void __RPC_STUB IInkDrawingAttributes_get_PenTip_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_put_PenTip_Proxy( ++ IInkDrawingAttributes* This, ++ InkPenTip NewPenTip); ++void __RPC_STUB IInkDrawingAttributes_put_PenTip_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_get_ExtendedProperties_Proxy( ++ IInkDrawingAttributes* This, ++ IInkExtendedProperties **Properties); ++void __RPC_STUB IInkDrawingAttributes_get_ExtendedProperties_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDrawingAttributes_Clone_Proxy( ++ IInkDrawingAttributes* This, ++ IInkDrawingAttributes **DrawingAttributes); ++void __RPC_STUB IInkDrawingAttributes_Clone_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkDrawingAttributes_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkRectangle interface ++ */ ++#ifndef __IInkRectangle_INTERFACE_DEFINED__ ++#define __IInkRectangle_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkRectangle, 0x9794ff82, 0x6071, 0x4717, 0x8a,0x8b, 0x6a,0xc7,0xc6,0x4a,0x68,0x6e); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("9794ff82-6071-4717-8a8b-6ac7c64a686e") ++IInkRectangle : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Top( ++ LONG *Units) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Top( ++ LONG Units) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Left( ++ LONG *Units) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Left( ++ LONG Units) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Bottom( ++ LONG *Units) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Bottom( ++ LONG Units) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Right( ++ LONG *Units) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Right( ++ LONG Units) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Data( ++ RECT *Rect) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Data( ++ RECT Rect) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetRectangle( ++ LONG *Top, ++ LONG *Left, ++ LONG *Bottom, ++ LONG *Right) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE SetRectangle( ++ LONG Top, ++ LONG Left, ++ LONG Bottom, ++ LONG Right) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkRectangle, 0x9794ff82, 0x6071, 0x4717, 0x8a,0x8b, 0x6a,0xc7,0xc6,0x4a,0x68,0x6e) ++#endif ++#else ++typedef struct IInkRectangleVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkRectangle* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkRectangle* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkRectangle* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkRectangle* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkRectangle* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkRectangle* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkRectangle* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkRectangle methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Top)( ++ IInkRectangle* This, ++ LONG *Units); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Top)( ++ IInkRectangle* This, ++ LONG Units); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Left)( ++ IInkRectangle* This, ++ LONG *Units); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Left)( ++ IInkRectangle* This, ++ LONG Units); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Bottom)( ++ IInkRectangle* This, ++ LONG *Units); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Bottom)( ++ IInkRectangle* This, ++ LONG Units); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Right)( ++ IInkRectangle* This, ++ LONG *Units); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Right)( ++ IInkRectangle* This, ++ LONG Units); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Data)( ++ IInkRectangle* This, ++ RECT *Rect); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Data)( ++ IInkRectangle* This, ++ RECT Rect); ++ ++ HRESULT (STDMETHODCALLTYPE *GetRectangle)( ++ IInkRectangle* This, ++ LONG *Top, ++ LONG *Left, ++ LONG *Bottom, ++ LONG *Right); ++ ++ HRESULT (STDMETHODCALLTYPE *SetRectangle)( ++ IInkRectangle* This, ++ LONG Top, ++ LONG Left, ++ LONG Bottom, ++ LONG Right); ++ ++ END_INTERFACE ++} IInkRectangleVtbl; ++interface IInkRectangle { ++ CONST_VTBL IInkRectangleVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkRectangle_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkRectangle_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkRectangle_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkRectangle_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkRectangle_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkRectangle_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkRectangle_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkRectangle methods ***/ ++#define IInkRectangle_get_Top(This,Units) (This)->lpVtbl->get_Top(This,Units) ++#define IInkRectangle_put_Top(This,Units) (This)->lpVtbl->put_Top(This,Units) ++#define IInkRectangle_get_Left(This,Units) (This)->lpVtbl->get_Left(This,Units) ++#define IInkRectangle_put_Left(This,Units) (This)->lpVtbl->put_Left(This,Units) ++#define IInkRectangle_get_Bottom(This,Units) (This)->lpVtbl->get_Bottom(This,Units) ++#define IInkRectangle_put_Bottom(This,Units) (This)->lpVtbl->put_Bottom(This,Units) ++#define IInkRectangle_get_Right(This,Units) (This)->lpVtbl->get_Right(This,Units) ++#define IInkRectangle_put_Right(This,Units) (This)->lpVtbl->put_Right(This,Units) ++#define IInkRectangle_get_Data(This,Rect) (This)->lpVtbl->get_Data(This,Rect) ++#define IInkRectangle_put_Data(This,Rect) (This)->lpVtbl->put_Data(This,Rect) ++#define IInkRectangle_GetRectangle(This,Top,Left,Bottom,Right) (This)->lpVtbl->GetRectangle(This,Top,Left,Bottom,Right) ++#define IInkRectangle_SetRectangle(This,Top,Left,Bottom,Right) (This)->lpVtbl->SetRectangle(This,Top,Left,Bottom,Right) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkRectangle_QueryInterface(IInkRectangle* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkRectangle_AddRef(IInkRectangle* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkRectangle_Release(IInkRectangle* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkRectangle_GetTypeInfoCount(IInkRectangle* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkRectangle_GetTypeInfo(IInkRectangle* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkRectangle_GetIDsOfNames(IInkRectangle* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkRectangle_Invoke(IInkRectangle* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkRectangle methods ***/ ++static FORCEINLINE HRESULT IInkRectangle_get_Top(IInkRectangle* This,LONG *Units) { ++ return This->lpVtbl->get_Top(This,Units); ++} ++static FORCEINLINE HRESULT IInkRectangle_put_Top(IInkRectangle* This,LONG Units) { ++ return This->lpVtbl->put_Top(This,Units); ++} ++static FORCEINLINE HRESULT IInkRectangle_get_Left(IInkRectangle* This,LONG *Units) { ++ return This->lpVtbl->get_Left(This,Units); ++} ++static FORCEINLINE HRESULT IInkRectangle_put_Left(IInkRectangle* This,LONG Units) { ++ return This->lpVtbl->put_Left(This,Units); ++} ++static FORCEINLINE HRESULT IInkRectangle_get_Bottom(IInkRectangle* This,LONG *Units) { ++ return This->lpVtbl->get_Bottom(This,Units); ++} ++static FORCEINLINE HRESULT IInkRectangle_put_Bottom(IInkRectangle* This,LONG Units) { ++ return This->lpVtbl->put_Bottom(This,Units); ++} ++static FORCEINLINE HRESULT IInkRectangle_get_Right(IInkRectangle* This,LONG *Units) { ++ return This->lpVtbl->get_Right(This,Units); ++} ++static FORCEINLINE HRESULT IInkRectangle_put_Right(IInkRectangle* This,LONG Units) { ++ return This->lpVtbl->put_Right(This,Units); ++} ++static FORCEINLINE HRESULT IInkRectangle_get_Data(IInkRectangle* This,RECT *Rect) { ++ return This->lpVtbl->get_Data(This,Rect); ++} ++static FORCEINLINE HRESULT IInkRectangle_put_Data(IInkRectangle* This,RECT Rect) { ++ return This->lpVtbl->put_Data(This,Rect); ++} ++static FORCEINLINE HRESULT IInkRectangle_GetRectangle(IInkRectangle* This,LONG *Top,LONG *Left,LONG *Bottom,LONG *Right) { ++ return This->lpVtbl->GetRectangle(This,Top,Left,Bottom,Right); ++} ++static FORCEINLINE HRESULT IInkRectangle_SetRectangle(IInkRectangle* This,LONG Top,LONG Left,LONG Bottom,LONG Right) { ++ return This->lpVtbl->SetRectangle(This,Top,Left,Bottom,Right); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkRectangle_get_Top_Proxy( ++ IInkRectangle* This, ++ LONG *Units); ++void __RPC_STUB IInkRectangle_get_Top_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRectangle_put_Top_Proxy( ++ IInkRectangle* This, ++ LONG Units); ++void __RPC_STUB IInkRectangle_put_Top_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRectangle_get_Left_Proxy( ++ IInkRectangle* This, ++ LONG *Units); ++void __RPC_STUB IInkRectangle_get_Left_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRectangle_put_Left_Proxy( ++ IInkRectangle* This, ++ LONG Units); ++void __RPC_STUB IInkRectangle_put_Left_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRectangle_get_Bottom_Proxy( ++ IInkRectangle* This, ++ LONG *Units); ++void __RPC_STUB IInkRectangle_get_Bottom_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRectangle_put_Bottom_Proxy( ++ IInkRectangle* This, ++ LONG Units); ++void __RPC_STUB IInkRectangle_put_Bottom_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRectangle_get_Right_Proxy( ++ IInkRectangle* This, ++ LONG *Units); ++void __RPC_STUB IInkRectangle_get_Right_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRectangle_put_Right_Proxy( ++ IInkRectangle* This, ++ LONG Units); ++void __RPC_STUB IInkRectangle_put_Right_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRectangle_get_Data_Proxy( ++ IInkRectangle* This, ++ RECT *Rect); ++void __RPC_STUB IInkRectangle_get_Data_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRectangle_put_Data_Proxy( ++ IInkRectangle* This, ++ RECT Rect); ++void __RPC_STUB IInkRectangle_put_Data_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRectangle_GetRectangle_Proxy( ++ IInkRectangle* This, ++ LONG *Top, ++ LONG *Left, ++ LONG *Bottom, ++ LONG *Right); ++void __RPC_STUB IInkRectangle_GetRectangle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRectangle_SetRectangle_Proxy( ++ IInkRectangle* This, ++ LONG Top, ++ LONG Left, ++ LONG Bottom, ++ LONG Right); ++void __RPC_STUB IInkRectangle_SetRectangle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkRectangle_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkTablet interface ++ */ ++#ifndef __IInkTablet_INTERFACE_DEFINED__ ++#define __IInkTablet_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkTablet, 0x2de25eaa, 0x6ef8, 0x42d5, 0xae,0xe9, 0x18,0x5b,0xc8,0x1b,0x91,0x2d); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("2de25eaa-6ef8-42d5-aee9-185bc81b912d") ++IInkTablet : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Name( ++ BSTR *Name) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_PlugAndPlayId( ++ BSTR *Id) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_MaximumInputRectangle( ++ IInkRectangle **Rectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_HardwareCapabilities( ++ TabletHardwareCapabilities *Capabilities) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE IsPacketPropertySupported( ++ BSTR packetPropertyName, ++ VARIANT_BOOL *Supported) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetPropertyMetrics( ++ BSTR propertyName, ++ LONG *Minimum, ++ LONG *Maximum, ++ TabletPropertyMetricUnit *Units, ++ float *Resolution) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkTablet, 0x2de25eaa, 0x6ef8, 0x42d5, 0xae,0xe9, 0x18,0x5b,0xc8,0x1b,0x91,0x2d) ++#endif ++#else ++typedef struct IInkTabletVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkTablet* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkTablet* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkTablet* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkTablet* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkTablet* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkTablet* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkTablet* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkTablet methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Name)( ++ IInkTablet* This, ++ BSTR *Name); ++ ++ HRESULT (STDMETHODCALLTYPE *get_PlugAndPlayId)( ++ IInkTablet* This, ++ BSTR *Id); ++ ++ HRESULT (STDMETHODCALLTYPE *get_MaximumInputRectangle)( ++ IInkTablet* This, ++ IInkRectangle **Rectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *get_HardwareCapabilities)( ++ IInkTablet* This, ++ TabletHardwareCapabilities *Capabilities); ++ ++ HRESULT (STDMETHODCALLTYPE *IsPacketPropertySupported)( ++ IInkTablet* This, ++ BSTR packetPropertyName, ++ VARIANT_BOOL *Supported); ++ ++ HRESULT (STDMETHODCALLTYPE *GetPropertyMetrics)( ++ IInkTablet* This, ++ BSTR propertyName, ++ LONG *Minimum, ++ LONG *Maximum, ++ TabletPropertyMetricUnit *Units, ++ float *Resolution); ++ ++ END_INTERFACE ++} IInkTabletVtbl; ++interface IInkTablet { ++ CONST_VTBL IInkTabletVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkTablet_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkTablet_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkTablet_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkTablet_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkTablet_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkTablet_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkTablet_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkTablet methods ***/ ++#define IInkTablet_get_Name(This,Name) (This)->lpVtbl->get_Name(This,Name) ++#define IInkTablet_get_PlugAndPlayId(This,Id) (This)->lpVtbl->get_PlugAndPlayId(This,Id) ++#define IInkTablet_get_MaximumInputRectangle(This,Rectangle) (This)->lpVtbl->get_MaximumInputRectangle(This,Rectangle) ++#define IInkTablet_get_HardwareCapabilities(This,Capabilities) (This)->lpVtbl->get_HardwareCapabilities(This,Capabilities) ++#define IInkTablet_IsPacketPropertySupported(This,packetPropertyName,Supported) (This)->lpVtbl->IsPacketPropertySupported(This,packetPropertyName,Supported) ++#define IInkTablet_GetPropertyMetrics(This,propertyName,Minimum,Maximum,Units,Resolution) (This)->lpVtbl->GetPropertyMetrics(This,propertyName,Minimum,Maximum,Units,Resolution) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkTablet_QueryInterface(IInkTablet* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkTablet_AddRef(IInkTablet* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkTablet_Release(IInkTablet* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkTablet_GetTypeInfoCount(IInkTablet* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkTablet_GetTypeInfo(IInkTablet* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkTablet_GetIDsOfNames(IInkTablet* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkTablet_Invoke(IInkTablet* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkTablet methods ***/ ++static FORCEINLINE HRESULT IInkTablet_get_Name(IInkTablet* This,BSTR *Name) { ++ return This->lpVtbl->get_Name(This,Name); ++} ++static FORCEINLINE HRESULT IInkTablet_get_PlugAndPlayId(IInkTablet* This,BSTR *Id) { ++ return This->lpVtbl->get_PlugAndPlayId(This,Id); ++} ++static FORCEINLINE HRESULT IInkTablet_get_MaximumInputRectangle(IInkTablet* This,IInkRectangle **Rectangle) { ++ return This->lpVtbl->get_MaximumInputRectangle(This,Rectangle); ++} ++static FORCEINLINE HRESULT IInkTablet_get_HardwareCapabilities(IInkTablet* This,TabletHardwareCapabilities *Capabilities) { ++ return This->lpVtbl->get_HardwareCapabilities(This,Capabilities); ++} ++static FORCEINLINE HRESULT IInkTablet_IsPacketPropertySupported(IInkTablet* This,BSTR packetPropertyName,VARIANT_BOOL *Supported) { ++ return This->lpVtbl->IsPacketPropertySupported(This,packetPropertyName,Supported); ++} ++static FORCEINLINE HRESULT IInkTablet_GetPropertyMetrics(IInkTablet* This,BSTR propertyName,LONG *Minimum,LONG *Maximum,TabletPropertyMetricUnit *Units,float *Resolution) { ++ return This->lpVtbl->GetPropertyMetrics(This,propertyName,Minimum,Maximum,Units,Resolution); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkTablet_get_Name_Proxy( ++ IInkTablet* This, ++ BSTR *Name); ++void __RPC_STUB IInkTablet_get_Name_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTablet_get_PlugAndPlayId_Proxy( ++ IInkTablet* This, ++ BSTR *Id); ++void __RPC_STUB IInkTablet_get_PlugAndPlayId_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTablet_get_MaximumInputRectangle_Proxy( ++ IInkTablet* This, ++ IInkRectangle **Rectangle); ++void __RPC_STUB IInkTablet_get_MaximumInputRectangle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTablet_get_HardwareCapabilities_Proxy( ++ IInkTablet* This, ++ TabletHardwareCapabilities *Capabilities); ++void __RPC_STUB IInkTablet_get_HardwareCapabilities_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTablet_IsPacketPropertySupported_Proxy( ++ IInkTablet* This, ++ BSTR packetPropertyName, ++ VARIANT_BOOL *Supported); ++void __RPC_STUB IInkTablet_IsPacketPropertySupported_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTablet_GetPropertyMetrics_Proxy( ++ IInkTablet* This, ++ BSTR propertyName, ++ LONG *Minimum, ++ LONG *Maximum, ++ TabletPropertyMetricUnit *Units, ++ float *Resolution); ++void __RPC_STUB IInkTablet_GetPropertyMetrics_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkTablet_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkCursorButton interface ++ */ ++#ifndef __IInkCursorButton_INTERFACE_DEFINED__ ++#define __IInkCursorButton_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkCursorButton, 0x85ef9417, 0x1d59, 0x49b2, 0xa1,0x3c, 0x70,0x2c,0x85,0x43,0x08,0x94); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("85ef9417-1d59-49b2-a13c-702c85430894") ++IInkCursorButton : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Name( ++ BSTR *Name) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Id( ++ BSTR *Id) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_State( ++ InkCursorButtonState *CurrentState) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkCursorButton, 0x85ef9417, 0x1d59, 0x49b2, 0xa1,0x3c, 0x70,0x2c,0x85,0x43,0x08,0x94) ++#endif ++#else ++typedef struct IInkCursorButtonVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkCursorButton* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkCursorButton* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkCursorButton* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkCursorButton* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkCursorButton* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkCursorButton* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkCursorButton* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkCursorButton methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Name)( ++ IInkCursorButton* This, ++ BSTR *Name); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Id)( ++ IInkCursorButton* This, ++ BSTR *Id); ++ ++ HRESULT (STDMETHODCALLTYPE *get_State)( ++ IInkCursorButton* This, ++ InkCursorButtonState *CurrentState); ++ ++ END_INTERFACE ++} IInkCursorButtonVtbl; ++interface IInkCursorButton { ++ CONST_VTBL IInkCursorButtonVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkCursorButton_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkCursorButton_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkCursorButton_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkCursorButton_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkCursorButton_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkCursorButton_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkCursorButton_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkCursorButton methods ***/ ++#define IInkCursorButton_get_Name(This,Name) (This)->lpVtbl->get_Name(This,Name) ++#define IInkCursorButton_get_Id(This,Id) (This)->lpVtbl->get_Id(This,Id) ++#define IInkCursorButton_get_State(This,CurrentState) (This)->lpVtbl->get_State(This,CurrentState) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkCursorButton_QueryInterface(IInkCursorButton* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkCursorButton_AddRef(IInkCursorButton* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkCursorButton_Release(IInkCursorButton* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkCursorButton_GetTypeInfoCount(IInkCursorButton* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkCursorButton_GetTypeInfo(IInkCursorButton* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkCursorButton_GetIDsOfNames(IInkCursorButton* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkCursorButton_Invoke(IInkCursorButton* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkCursorButton methods ***/ ++static FORCEINLINE HRESULT IInkCursorButton_get_Name(IInkCursorButton* This,BSTR *Name) { ++ return This->lpVtbl->get_Name(This,Name); ++} ++static FORCEINLINE HRESULT IInkCursorButton_get_Id(IInkCursorButton* This,BSTR *Id) { ++ return This->lpVtbl->get_Id(This,Id); ++} ++static FORCEINLINE HRESULT IInkCursorButton_get_State(IInkCursorButton* This,InkCursorButtonState *CurrentState) { ++ return This->lpVtbl->get_State(This,CurrentState); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkCursorButton_get_Name_Proxy( ++ IInkCursorButton* This, ++ BSTR *Name); ++void __RPC_STUB IInkCursorButton_get_Name_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCursorButton_get_Id_Proxy( ++ IInkCursorButton* This, ++ BSTR *Id); ++void __RPC_STUB IInkCursorButton_get_Id_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCursorButton_get_State_Proxy( ++ IInkCursorButton* This, ++ InkCursorButtonState *CurrentState); ++void __RPC_STUB IInkCursorButton_get_State_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkCursorButton_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkCursorButtons interface ++ */ ++#ifndef __IInkCursorButtons_INTERFACE_DEFINED__ ++#define __IInkCursorButtons_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkCursorButtons, 0x3671cc40, 0xb624, 0x4671, 0x9f,0xa0, 0xdb,0x11,0x9d,0x95,0x2d,0x54); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("3671cc40-b624-4671-9fa0-db119d952d54") ++IInkCursorButtons : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Count( ++ LONG *Count) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get__NewEnum( ++ IUnknown **_NewEnum) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Item( ++ VARIANT Identifier, ++ IInkCursorButton **Button) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkCursorButtons, 0x3671cc40, 0xb624, 0x4671, 0x9f,0xa0, 0xdb,0x11,0x9d,0x95,0x2d,0x54) ++#endif ++#else ++typedef struct IInkCursorButtonsVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkCursorButtons* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkCursorButtons* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkCursorButtons* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkCursorButtons* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkCursorButtons* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkCursorButtons* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkCursorButtons* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkCursorButtons methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Count)( ++ IInkCursorButtons* This, ++ LONG *Count); ++ ++ HRESULT (STDMETHODCALLTYPE *get__NewEnum)( ++ IInkCursorButtons* This, ++ IUnknown **_NewEnum); ++ ++ HRESULT (STDMETHODCALLTYPE *Item)( ++ IInkCursorButtons* This, ++ VARIANT Identifier, ++ IInkCursorButton **Button); ++ ++ END_INTERFACE ++} IInkCursorButtonsVtbl; ++interface IInkCursorButtons { ++ CONST_VTBL IInkCursorButtonsVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkCursorButtons_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkCursorButtons_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkCursorButtons_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkCursorButtons_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkCursorButtons_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkCursorButtons_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkCursorButtons_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkCursorButtons methods ***/ ++#define IInkCursorButtons_get_Count(This,Count) (This)->lpVtbl->get_Count(This,Count) ++#define IInkCursorButtons_get__NewEnum(This,_NewEnum) (This)->lpVtbl->get__NewEnum(This,_NewEnum) ++#define IInkCursorButtons_Item(This,Identifier,Button) (This)->lpVtbl->Item(This,Identifier,Button) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkCursorButtons_QueryInterface(IInkCursorButtons* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkCursorButtons_AddRef(IInkCursorButtons* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkCursorButtons_Release(IInkCursorButtons* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkCursorButtons_GetTypeInfoCount(IInkCursorButtons* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkCursorButtons_GetTypeInfo(IInkCursorButtons* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkCursorButtons_GetIDsOfNames(IInkCursorButtons* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkCursorButtons_Invoke(IInkCursorButtons* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkCursorButtons methods ***/ ++static FORCEINLINE HRESULT IInkCursorButtons_get_Count(IInkCursorButtons* This,LONG *Count) { ++ return This->lpVtbl->get_Count(This,Count); ++} ++static FORCEINLINE HRESULT IInkCursorButtons_get__NewEnum(IInkCursorButtons* This,IUnknown **_NewEnum) { ++ return This->lpVtbl->get__NewEnum(This,_NewEnum); ++} ++static FORCEINLINE HRESULT IInkCursorButtons_Item(IInkCursorButtons* This,VARIANT Identifier,IInkCursorButton **Button) { ++ return This->lpVtbl->Item(This,Identifier,Button); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkCursorButtons_get_Count_Proxy( ++ IInkCursorButtons* This, ++ LONG *Count); ++void __RPC_STUB IInkCursorButtons_get_Count_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCursorButtons_get__NewEnum_Proxy( ++ IInkCursorButtons* This, ++ IUnknown **_NewEnum); ++void __RPC_STUB IInkCursorButtons_get__NewEnum_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCursorButtons_Item_Proxy( ++ IInkCursorButtons* This, ++ VARIANT Identifier, ++ IInkCursorButton **Button); ++void __RPC_STUB IInkCursorButtons_Item_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkCursorButtons_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkCursor interface ++ */ ++#ifndef __IInkCursor_INTERFACE_DEFINED__ ++#define __IInkCursor_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkCursor, 0xad30c630, 0x40c5, 0x4350, 0x84,0x05, 0x9c,0x71,0x01,0x2f,0xc5,0x58); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("ad30c630-40c5-4350-8405-9c71012fc558") ++IInkCursor : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Name( ++ BSTR *Name) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Id( ++ LONG *Id) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Inverted( ++ VARIANT_BOOL *Status) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_DrawingAttributes( ++ IInkDrawingAttributes **Attributes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE putref_DrawingAttributes( ++ IInkDrawingAttributes *Attributes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Tablet( ++ IInkTablet **Tablet) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Buttons( ++ IInkCursorButtons **Buttons) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkCursor, 0xad30c630, 0x40c5, 0x4350, 0x84,0x05, 0x9c,0x71,0x01,0x2f,0xc5,0x58) ++#endif ++#else ++typedef struct IInkCursorVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkCursor* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkCursor* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkCursor* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkCursor* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkCursor* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkCursor* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkCursor* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkCursor methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Name)( ++ IInkCursor* This, ++ BSTR *Name); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Id)( ++ IInkCursor* This, ++ LONG *Id); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Inverted)( ++ IInkCursor* This, ++ VARIANT_BOOL *Status); ++ ++ HRESULT (STDMETHODCALLTYPE *get_DrawingAttributes)( ++ IInkCursor* This, ++ IInkDrawingAttributes **Attributes); ++ ++ HRESULT (STDMETHODCALLTYPE *putref_DrawingAttributes)( ++ IInkCursor* This, ++ IInkDrawingAttributes *Attributes); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Tablet)( ++ IInkCursor* This, ++ IInkTablet **Tablet); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Buttons)( ++ IInkCursor* This, ++ IInkCursorButtons **Buttons); ++ ++ END_INTERFACE ++} IInkCursorVtbl; ++interface IInkCursor { ++ CONST_VTBL IInkCursorVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkCursor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkCursor_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkCursor_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkCursor_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkCursor_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkCursor_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkCursor_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkCursor methods ***/ ++#define IInkCursor_get_Name(This,Name) (This)->lpVtbl->get_Name(This,Name) ++#define IInkCursor_get_Id(This,Id) (This)->lpVtbl->get_Id(This,Id) ++#define IInkCursor_get_Inverted(This,Status) (This)->lpVtbl->get_Inverted(This,Status) ++#define IInkCursor_get_DrawingAttributes(This,Attributes) (This)->lpVtbl->get_DrawingAttributes(This,Attributes) ++#define IInkCursor_putref_DrawingAttributes(This,Attributes) (This)->lpVtbl->putref_DrawingAttributes(This,Attributes) ++#define IInkCursor_get_Tablet(This,Tablet) (This)->lpVtbl->get_Tablet(This,Tablet) ++#define IInkCursor_get_Buttons(This,Buttons) (This)->lpVtbl->get_Buttons(This,Buttons) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkCursor_QueryInterface(IInkCursor* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkCursor_AddRef(IInkCursor* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkCursor_Release(IInkCursor* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkCursor_GetTypeInfoCount(IInkCursor* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkCursor_GetTypeInfo(IInkCursor* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkCursor_GetIDsOfNames(IInkCursor* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkCursor_Invoke(IInkCursor* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkCursor methods ***/ ++static FORCEINLINE HRESULT IInkCursor_get_Name(IInkCursor* This,BSTR *Name) { ++ return This->lpVtbl->get_Name(This,Name); ++} ++static FORCEINLINE HRESULT IInkCursor_get_Id(IInkCursor* This,LONG *Id) { ++ return This->lpVtbl->get_Id(This,Id); ++} ++static FORCEINLINE HRESULT IInkCursor_get_Inverted(IInkCursor* This,VARIANT_BOOL *Status) { ++ return This->lpVtbl->get_Inverted(This,Status); ++} ++static FORCEINLINE HRESULT IInkCursor_get_DrawingAttributes(IInkCursor* This,IInkDrawingAttributes **Attributes) { ++ return This->lpVtbl->get_DrawingAttributes(This,Attributes); ++} ++static FORCEINLINE HRESULT IInkCursor_putref_DrawingAttributes(IInkCursor* This,IInkDrawingAttributes *Attributes) { ++ return This->lpVtbl->putref_DrawingAttributes(This,Attributes); ++} ++static FORCEINLINE HRESULT IInkCursor_get_Tablet(IInkCursor* This,IInkTablet **Tablet) { ++ return This->lpVtbl->get_Tablet(This,Tablet); ++} ++static FORCEINLINE HRESULT IInkCursor_get_Buttons(IInkCursor* This,IInkCursorButtons **Buttons) { ++ return This->lpVtbl->get_Buttons(This,Buttons); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkCursor_get_Name_Proxy( ++ IInkCursor* This, ++ BSTR *Name); ++void __RPC_STUB IInkCursor_get_Name_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCursor_get_Id_Proxy( ++ IInkCursor* This, ++ LONG *Id); ++void __RPC_STUB IInkCursor_get_Id_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCursor_get_Inverted_Proxy( ++ IInkCursor* This, ++ VARIANT_BOOL *Status); ++void __RPC_STUB IInkCursor_get_Inverted_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCursor_get_DrawingAttributes_Proxy( ++ IInkCursor* This, ++ IInkDrawingAttributes **Attributes); ++void __RPC_STUB IInkCursor_get_DrawingAttributes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCursor_putref_DrawingAttributes_Proxy( ++ IInkCursor* This, ++ IInkDrawingAttributes *Attributes); ++void __RPC_STUB IInkCursor_putref_DrawingAttributes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCursor_get_Tablet_Proxy( ++ IInkCursor* This, ++ IInkTablet **Tablet); ++void __RPC_STUB IInkCursor_get_Tablet_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCursor_get_Buttons_Proxy( ++ IInkCursor* This, ++ IInkCursorButtons **Buttons); ++void __RPC_STUB IInkCursor_get_Buttons_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkCursor_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkTransform interface ++ */ ++#ifndef __IInkTransform_INTERFACE_DEFINED__ ++#define __IInkTransform_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkTransform, 0x615f1d43, 0x8703, 0x4565, 0x88,0xe2, 0x82,0x01,0xd2,0xec,0xd7,0xb7); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("615f1d43-8703-4565-88e2-8201d2ecd7b7") ++IInkTransform : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE Reset( ++ ) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Translate( ++ float HorizontalComponent, ++ float VerticalComponent) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Rotate( ++ float Degrees, ++ float x = 0, ++ float y = 0) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Reflect( ++ VARIANT_BOOL Horizontally, ++ VARIANT_BOOL Vertically) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Shear( ++ float HorizontalComponent, ++ float VerticalComponent) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ScaleTransform( ++ float HorizontalMultiplier, ++ float VerticalMultiplier) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetTransform( ++ float *eM11, ++ float *eM12, ++ float *eM21, ++ float *eM22, ++ float *eDx, ++ float *eDy) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE SetTransform( ++ float eM11, ++ float eM12, ++ float eM21, ++ float eM22, ++ float eDx, ++ float eDy) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_eM11( ++ float *Value) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_eM11( ++ float Value) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_eM12( ++ float *Value) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_eM12( ++ float Value) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_eM21( ++ float *Value) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_eM21( ++ float Value) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_eM22( ++ float *Value) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_eM22( ++ float Value) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_eDx( ++ float *Value) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_eDx( ++ float Value) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_eDy( ++ float *Value) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_eDy( ++ float Value) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Data( ++ XFORM *XForm) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Data( ++ XFORM XForm) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkTransform, 0x615f1d43, 0x8703, 0x4565, 0x88,0xe2, 0x82,0x01,0xd2,0xec,0xd7,0xb7) ++#endif ++#else ++typedef struct IInkTransformVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkTransform* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkTransform* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkTransform* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkTransform* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkTransform* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkTransform* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkTransform* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkTransform methods ***/ ++ HRESULT (STDMETHODCALLTYPE *Reset)( ++ IInkTransform* This); ++ ++ HRESULT (STDMETHODCALLTYPE *Translate)( ++ IInkTransform* This, ++ float HorizontalComponent, ++ float VerticalComponent); ++ ++ HRESULT (STDMETHODCALLTYPE *Rotate)( ++ IInkTransform* This, ++ float Degrees, ++ float x, ++ float y); ++ ++ HRESULT (STDMETHODCALLTYPE *Reflect)( ++ IInkTransform* This, ++ VARIANT_BOOL Horizontally, ++ VARIANT_BOOL Vertically); ++ ++ HRESULT (STDMETHODCALLTYPE *Shear)( ++ IInkTransform* This, ++ float HorizontalComponent, ++ float VerticalComponent); ++ ++ HRESULT (STDMETHODCALLTYPE *ScaleTransform)( ++ IInkTransform* This, ++ float HorizontalMultiplier, ++ float VerticalMultiplier); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTransform)( ++ IInkTransform* This, ++ float *eM11, ++ float *eM12, ++ float *eM21, ++ float *eM22, ++ float *eDx, ++ float *eDy); ++ ++ HRESULT (STDMETHODCALLTYPE *SetTransform)( ++ IInkTransform* This, ++ float eM11, ++ float eM12, ++ float eM21, ++ float eM22, ++ float eDx, ++ float eDy); ++ ++ HRESULT (STDMETHODCALLTYPE *get_eM11)( ++ IInkTransform* This, ++ float *Value); ++ ++ HRESULT (STDMETHODCALLTYPE *put_eM11)( ++ IInkTransform* This, ++ float Value); ++ ++ HRESULT (STDMETHODCALLTYPE *get_eM12)( ++ IInkTransform* This, ++ float *Value); ++ ++ HRESULT (STDMETHODCALLTYPE *put_eM12)( ++ IInkTransform* This, ++ float Value); ++ ++ HRESULT (STDMETHODCALLTYPE *get_eM21)( ++ IInkTransform* This, ++ float *Value); ++ ++ HRESULT (STDMETHODCALLTYPE *put_eM21)( ++ IInkTransform* This, ++ float Value); ++ ++ HRESULT (STDMETHODCALLTYPE *get_eM22)( ++ IInkTransform* This, ++ float *Value); ++ ++ HRESULT (STDMETHODCALLTYPE *put_eM22)( ++ IInkTransform* This, ++ float Value); ++ ++ HRESULT (STDMETHODCALLTYPE *get_eDx)( ++ IInkTransform* This, ++ float *Value); ++ ++ HRESULT (STDMETHODCALLTYPE *put_eDx)( ++ IInkTransform* This, ++ float Value); ++ ++ HRESULT (STDMETHODCALLTYPE *get_eDy)( ++ IInkTransform* This, ++ float *Value); ++ ++ HRESULT (STDMETHODCALLTYPE *put_eDy)( ++ IInkTransform* This, ++ float Value); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Data)( ++ IInkTransform* This, ++ XFORM *XForm); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Data)( ++ IInkTransform* This, ++ XFORM XForm); ++ ++ END_INTERFACE ++} IInkTransformVtbl; ++interface IInkTransform { ++ CONST_VTBL IInkTransformVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkTransform_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkTransform_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkTransform_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkTransform_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkTransform_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkTransform_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkTransform_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkTransform methods ***/ ++#define IInkTransform_Reset(This) (This)->lpVtbl->Reset(This) ++#define IInkTransform_Translate(This,HorizontalComponent,VerticalComponent) (This)->lpVtbl->Translate(This,HorizontalComponent,VerticalComponent) ++#define IInkTransform_Rotate(This,Degrees,x,y) (This)->lpVtbl->Rotate(This,Degrees,x,y) ++#define IInkTransform_Reflect(This,Horizontally,Vertically) (This)->lpVtbl->Reflect(This,Horizontally,Vertically) ++#define IInkTransform_Shear(This,HorizontalComponent,VerticalComponent) (This)->lpVtbl->Shear(This,HorizontalComponent,VerticalComponent) ++#define IInkTransform_ScaleTransform(This,HorizontalMultiplier,VerticalMultiplier) (This)->lpVtbl->ScaleTransform(This,HorizontalMultiplier,VerticalMultiplier) ++#define IInkTransform_GetTransform(This,eM11,eM12,eM21,eM22,eDx,eDy) (This)->lpVtbl->GetTransform(This,eM11,eM12,eM21,eM22,eDx,eDy) ++#define IInkTransform_SetTransform(This,eM11,eM12,eM21,eM22,eDx,eDy) (This)->lpVtbl->SetTransform(This,eM11,eM12,eM21,eM22,eDx,eDy) ++#define IInkTransform_get_eM11(This,Value) (This)->lpVtbl->get_eM11(This,Value) ++#define IInkTransform_put_eM11(This,Value) (This)->lpVtbl->put_eM11(This,Value) ++#define IInkTransform_get_eM12(This,Value) (This)->lpVtbl->get_eM12(This,Value) ++#define IInkTransform_put_eM12(This,Value) (This)->lpVtbl->put_eM12(This,Value) ++#define IInkTransform_get_eM21(This,Value) (This)->lpVtbl->get_eM21(This,Value) ++#define IInkTransform_put_eM21(This,Value) (This)->lpVtbl->put_eM21(This,Value) ++#define IInkTransform_get_eM22(This,Value) (This)->lpVtbl->get_eM22(This,Value) ++#define IInkTransform_put_eM22(This,Value) (This)->lpVtbl->put_eM22(This,Value) ++#define IInkTransform_get_eDx(This,Value) (This)->lpVtbl->get_eDx(This,Value) ++#define IInkTransform_put_eDx(This,Value) (This)->lpVtbl->put_eDx(This,Value) ++#define IInkTransform_get_eDy(This,Value) (This)->lpVtbl->get_eDy(This,Value) ++#define IInkTransform_put_eDy(This,Value) (This)->lpVtbl->put_eDy(This,Value) ++#define IInkTransform_get_Data(This,XForm) (This)->lpVtbl->get_Data(This,XForm) ++#define IInkTransform_put_Data(This,XForm) (This)->lpVtbl->put_Data(This,XForm) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkTransform_QueryInterface(IInkTransform* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkTransform_AddRef(IInkTransform* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkTransform_Release(IInkTransform* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkTransform_GetTypeInfoCount(IInkTransform* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkTransform_GetTypeInfo(IInkTransform* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkTransform_GetIDsOfNames(IInkTransform* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkTransform_Invoke(IInkTransform* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkTransform methods ***/ ++static FORCEINLINE HRESULT IInkTransform_Reset(IInkTransform* This) { ++ return This->lpVtbl->Reset(This); ++} ++static FORCEINLINE HRESULT IInkTransform_Translate(IInkTransform* This,float HorizontalComponent,float VerticalComponent) { ++ return This->lpVtbl->Translate(This,HorizontalComponent,VerticalComponent); ++} ++static FORCEINLINE HRESULT IInkTransform_Rotate(IInkTransform* This,float Degrees,float x,float y) { ++ return This->lpVtbl->Rotate(This,Degrees,x,y); ++} ++static FORCEINLINE HRESULT IInkTransform_Reflect(IInkTransform* This,VARIANT_BOOL Horizontally,VARIANT_BOOL Vertically) { ++ return This->lpVtbl->Reflect(This,Horizontally,Vertically); ++} ++static FORCEINLINE HRESULT IInkTransform_Shear(IInkTransform* This,float HorizontalComponent,float VerticalComponent) { ++ return This->lpVtbl->Shear(This,HorizontalComponent,VerticalComponent); ++} ++static FORCEINLINE HRESULT IInkTransform_ScaleTransform(IInkTransform* This,float HorizontalMultiplier,float VerticalMultiplier) { ++ return This->lpVtbl->ScaleTransform(This,HorizontalMultiplier,VerticalMultiplier); ++} ++static FORCEINLINE HRESULT IInkTransform_GetTransform(IInkTransform* This,float *eM11,float *eM12,float *eM21,float *eM22,float *eDx,float *eDy) { ++ return This->lpVtbl->GetTransform(This,eM11,eM12,eM21,eM22,eDx,eDy); ++} ++static FORCEINLINE HRESULT IInkTransform_SetTransform(IInkTransform* This,float eM11,float eM12,float eM21,float eM22,float eDx,float eDy) { ++ return This->lpVtbl->SetTransform(This,eM11,eM12,eM21,eM22,eDx,eDy); ++} ++static FORCEINLINE HRESULT IInkTransform_get_eM11(IInkTransform* This,float *Value) { ++ return This->lpVtbl->get_eM11(This,Value); ++} ++static FORCEINLINE HRESULT IInkTransform_put_eM11(IInkTransform* This,float Value) { ++ return This->lpVtbl->put_eM11(This,Value); ++} ++static FORCEINLINE HRESULT IInkTransform_get_eM12(IInkTransform* This,float *Value) { ++ return This->lpVtbl->get_eM12(This,Value); ++} ++static FORCEINLINE HRESULT IInkTransform_put_eM12(IInkTransform* This,float Value) { ++ return This->lpVtbl->put_eM12(This,Value); ++} ++static FORCEINLINE HRESULT IInkTransform_get_eM21(IInkTransform* This,float *Value) { ++ return This->lpVtbl->get_eM21(This,Value); ++} ++static FORCEINLINE HRESULT IInkTransform_put_eM21(IInkTransform* This,float Value) { ++ return This->lpVtbl->put_eM21(This,Value); ++} ++static FORCEINLINE HRESULT IInkTransform_get_eM22(IInkTransform* This,float *Value) { ++ return This->lpVtbl->get_eM22(This,Value); ++} ++static FORCEINLINE HRESULT IInkTransform_put_eM22(IInkTransform* This,float Value) { ++ return This->lpVtbl->put_eM22(This,Value); ++} ++static FORCEINLINE HRESULT IInkTransform_get_eDx(IInkTransform* This,float *Value) { ++ return This->lpVtbl->get_eDx(This,Value); ++} ++static FORCEINLINE HRESULT IInkTransform_put_eDx(IInkTransform* This,float Value) { ++ return This->lpVtbl->put_eDx(This,Value); ++} ++static FORCEINLINE HRESULT IInkTransform_get_eDy(IInkTransform* This,float *Value) { ++ return This->lpVtbl->get_eDy(This,Value); ++} ++static FORCEINLINE HRESULT IInkTransform_put_eDy(IInkTransform* This,float Value) { ++ return This->lpVtbl->put_eDy(This,Value); ++} ++static FORCEINLINE HRESULT IInkTransform_get_Data(IInkTransform* This,XFORM *XForm) { ++ return This->lpVtbl->get_Data(This,XForm); ++} ++static FORCEINLINE HRESULT IInkTransform_put_Data(IInkTransform* This,XFORM XForm) { ++ return This->lpVtbl->put_Data(This,XForm); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkTransform_Reset_Proxy( ++ IInkTransform* This); ++void __RPC_STUB IInkTransform_Reset_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_Translate_Proxy( ++ IInkTransform* This, ++ float HorizontalComponent, ++ float VerticalComponent); ++void __RPC_STUB IInkTransform_Translate_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_Rotate_Proxy( ++ IInkTransform* This, ++ float Degrees, ++ float x, ++ float y); ++void __RPC_STUB IInkTransform_Rotate_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_Reflect_Proxy( ++ IInkTransform* This, ++ VARIANT_BOOL Horizontally, ++ VARIANT_BOOL Vertically); ++void __RPC_STUB IInkTransform_Reflect_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_Shear_Proxy( ++ IInkTransform* This, ++ float HorizontalComponent, ++ float VerticalComponent); ++void __RPC_STUB IInkTransform_Shear_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_ScaleTransform_Proxy( ++ IInkTransform* This, ++ float HorizontalMultiplier, ++ float VerticalMultiplier); ++void __RPC_STUB IInkTransform_ScaleTransform_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_GetTransform_Proxy( ++ IInkTransform* This, ++ float *eM11, ++ float *eM12, ++ float *eM21, ++ float *eM22, ++ float *eDx, ++ float *eDy); ++void __RPC_STUB IInkTransform_GetTransform_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_SetTransform_Proxy( ++ IInkTransform* This, ++ float eM11, ++ float eM12, ++ float eM21, ++ float eM22, ++ float eDx, ++ float eDy); ++void __RPC_STUB IInkTransform_SetTransform_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_get_eM11_Proxy( ++ IInkTransform* This, ++ float *Value); ++void __RPC_STUB IInkTransform_get_eM11_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_put_eM11_Proxy( ++ IInkTransform* This, ++ float Value); ++void __RPC_STUB IInkTransform_put_eM11_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_get_eM12_Proxy( ++ IInkTransform* This, ++ float *Value); ++void __RPC_STUB IInkTransform_get_eM12_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_put_eM12_Proxy( ++ IInkTransform* This, ++ float Value); ++void __RPC_STUB IInkTransform_put_eM12_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_get_eM21_Proxy( ++ IInkTransform* This, ++ float *Value); ++void __RPC_STUB IInkTransform_get_eM21_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_put_eM21_Proxy( ++ IInkTransform* This, ++ float Value); ++void __RPC_STUB IInkTransform_put_eM21_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_get_eM22_Proxy( ++ IInkTransform* This, ++ float *Value); ++void __RPC_STUB IInkTransform_get_eM22_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_put_eM22_Proxy( ++ IInkTransform* This, ++ float Value); ++void __RPC_STUB IInkTransform_put_eM22_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_get_eDx_Proxy( ++ IInkTransform* This, ++ float *Value); ++void __RPC_STUB IInkTransform_get_eDx_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_put_eDx_Proxy( ++ IInkTransform* This, ++ float Value); ++void __RPC_STUB IInkTransform_put_eDx_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_get_eDy_Proxy( ++ IInkTransform* This, ++ float *Value); ++void __RPC_STUB IInkTransform_get_eDy_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_put_eDy_Proxy( ++ IInkTransform* This, ++ float Value); ++void __RPC_STUB IInkTransform_put_eDy_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_get_Data_Proxy( ++ IInkTransform* This, ++ XFORM *XForm); ++void __RPC_STUB IInkTransform_get_Data_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkTransform_put_Data_Proxy( ++ IInkTransform* This, ++ XFORM XForm); ++void __RPC_STUB IInkTransform_put_Data_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkTransform_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkRecognitionAlternates interface ++ */ ++#ifndef __IInkRecognitionAlternates_INTERFACE_DEFINED__ ++#define __IInkRecognitionAlternates_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkRecognitionAlternates, 0x286a167f, 0x9f19, 0x4c61, 0x9d,0x53, 0x4f,0x07,0xbe,0x62,0x2b,0x84); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("286a167f-9f19-4c61-9d53-4f07be622b84") ++IInkRecognitionAlternates : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Count( ++ LONG *Count) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get__NewEnum( ++ IUnknown **_NewEnum) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Strokes( ++ IInkStrokes **Strokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Item( ++ LONG Index, ++ IInkRecognitionAlternate **InkRecoAlternate) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkRecognitionAlternates, 0x286a167f, 0x9f19, 0x4c61, 0x9d,0x53, 0x4f,0x07,0xbe,0x62,0x2b,0x84) ++#endif ++#else ++typedef struct IInkRecognitionAlternatesVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkRecognitionAlternates* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkRecognitionAlternates* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkRecognitionAlternates* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkRecognitionAlternates* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkRecognitionAlternates* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkRecognitionAlternates* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkRecognitionAlternates* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkRecognitionAlternates methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Count)( ++ IInkRecognitionAlternates* This, ++ LONG *Count); ++ ++ HRESULT (STDMETHODCALLTYPE *get__NewEnum)( ++ IInkRecognitionAlternates* This, ++ IUnknown **_NewEnum); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Strokes)( ++ IInkRecognitionAlternates* This, ++ IInkStrokes **Strokes); ++ ++ HRESULT (STDMETHODCALLTYPE *Item)( ++ IInkRecognitionAlternates* This, ++ LONG Index, ++ IInkRecognitionAlternate **InkRecoAlternate); ++ ++ END_INTERFACE ++} IInkRecognitionAlternatesVtbl; ++interface IInkRecognitionAlternates { ++ CONST_VTBL IInkRecognitionAlternatesVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkRecognitionAlternates_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkRecognitionAlternates_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkRecognitionAlternates_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkRecognitionAlternates_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkRecognitionAlternates_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkRecognitionAlternates_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkRecognitionAlternates_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkRecognitionAlternates methods ***/ ++#define IInkRecognitionAlternates_get_Count(This,Count) (This)->lpVtbl->get_Count(This,Count) ++#define IInkRecognitionAlternates_get__NewEnum(This,_NewEnum) (This)->lpVtbl->get__NewEnum(This,_NewEnum) ++#define IInkRecognitionAlternates_get_Strokes(This,Strokes) (This)->lpVtbl->get_Strokes(This,Strokes) ++#define IInkRecognitionAlternates_Item(This,Index,InkRecoAlternate) (This)->lpVtbl->Item(This,Index,InkRecoAlternate) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkRecognitionAlternates_QueryInterface(IInkRecognitionAlternates* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkRecognitionAlternates_AddRef(IInkRecognitionAlternates* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkRecognitionAlternates_Release(IInkRecognitionAlternates* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkRecognitionAlternates_GetTypeInfoCount(IInkRecognitionAlternates* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternates_GetTypeInfo(IInkRecognitionAlternates* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternates_GetIDsOfNames(IInkRecognitionAlternates* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternates_Invoke(IInkRecognitionAlternates* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkRecognitionAlternates methods ***/ ++static FORCEINLINE HRESULT IInkRecognitionAlternates_get_Count(IInkRecognitionAlternates* This,LONG *Count) { ++ return This->lpVtbl->get_Count(This,Count); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternates_get__NewEnum(IInkRecognitionAlternates* This,IUnknown **_NewEnum) { ++ return This->lpVtbl->get__NewEnum(This,_NewEnum); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternates_get_Strokes(IInkRecognitionAlternates* This,IInkStrokes **Strokes) { ++ return This->lpVtbl->get_Strokes(This,Strokes); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternates_Item(IInkRecognitionAlternates* This,LONG Index,IInkRecognitionAlternate **InkRecoAlternate) { ++ return This->lpVtbl->Item(This,Index,InkRecoAlternate); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternates_get_Count_Proxy( ++ IInkRecognitionAlternates* This, ++ LONG *Count); ++void __RPC_STUB IInkRecognitionAlternates_get_Count_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternates_get__NewEnum_Proxy( ++ IInkRecognitionAlternates* This, ++ IUnknown **_NewEnum); ++void __RPC_STUB IInkRecognitionAlternates_get__NewEnum_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternates_get_Strokes_Proxy( ++ IInkRecognitionAlternates* This, ++ IInkStrokes **Strokes); ++void __RPC_STUB IInkRecognitionAlternates_get_Strokes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternates_Item_Proxy( ++ IInkRecognitionAlternates* This, ++ LONG Index, ++ IInkRecognitionAlternate **InkRecoAlternate); ++void __RPC_STUB IInkRecognitionAlternates_Item_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkRecognitionAlternates_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkRecognitionAlternate interface ++ */ ++#ifndef __IInkRecognitionAlternate_INTERFACE_DEFINED__ ++#define __IInkRecognitionAlternate_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkRecognitionAlternate, 0xb7e660ad, 0x77e4, 0x429b, 0xad,0xda, 0x87,0x37,0x80,0xd1,0xfc,0x4a); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("b7e660ad-77e4-429b-adda-873780d1fc4a") ++IInkRecognitionAlternate : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_String( ++ BSTR *RecoString) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Confidence( ++ InkRecognitionConfidence *Confidence) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Baseline( ++ VARIANT *Baseline) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Midline( ++ VARIANT *Midline) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Ascender( ++ VARIANT *Ascender) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Descender( ++ VARIANT *Descender) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_LineNumber( ++ LONG *LineNumber) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Strokes( ++ IInkStrokes **Strokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_LineAlternates( ++ IInkRecognitionAlternates **LineAlternates) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_ConfidenceAlternates( ++ IInkRecognitionAlternates **ConfidenceAlternates) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetStrokesFromStrokeRanges( ++ IInkStrokes *Strokes, ++ IInkStrokes **GetStrokesFromStrokeRanges) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetStrokesFromTextRange( ++ LONG *selectionStart, ++ LONG *selectionLength, ++ IInkStrokes **GetStrokesFromTextRange) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetTextRangeFromStrokes( ++ IInkStrokes *Strokes, ++ LONG *selectionStart, ++ LONG *selectionLength) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE AlternatesWithConstantPropertyValues( ++ BSTR PropertyType, ++ IInkRecognitionAlternates **AlternatesWithConstantPropertyValues) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetPropertyValue( ++ BSTR PropertyType, ++ VARIANT *PropertyValue) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkRecognitionAlternate, 0xb7e660ad, 0x77e4, 0x429b, 0xad,0xda, 0x87,0x37,0x80,0xd1,0xfc,0x4a) ++#endif ++#else ++typedef struct IInkRecognitionAlternateVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkRecognitionAlternate* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkRecognitionAlternate* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkRecognitionAlternate* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkRecognitionAlternate* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkRecognitionAlternate* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkRecognitionAlternate* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkRecognitionAlternate* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkRecognitionAlternate methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_String)( ++ IInkRecognitionAlternate* This, ++ BSTR *RecoString); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Confidence)( ++ IInkRecognitionAlternate* This, ++ InkRecognitionConfidence *Confidence); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Baseline)( ++ IInkRecognitionAlternate* This, ++ VARIANT *Baseline); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Midline)( ++ IInkRecognitionAlternate* This, ++ VARIANT *Midline); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Ascender)( ++ IInkRecognitionAlternate* This, ++ VARIANT *Ascender); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Descender)( ++ IInkRecognitionAlternate* This, ++ VARIANT *Descender); ++ ++ HRESULT (STDMETHODCALLTYPE *get_LineNumber)( ++ IInkRecognitionAlternate* This, ++ LONG *LineNumber); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Strokes)( ++ IInkRecognitionAlternate* This, ++ IInkStrokes **Strokes); ++ ++ HRESULT (STDMETHODCALLTYPE *get_LineAlternates)( ++ IInkRecognitionAlternate* This, ++ IInkRecognitionAlternates **LineAlternates); ++ ++ HRESULT (STDMETHODCALLTYPE *get_ConfidenceAlternates)( ++ IInkRecognitionAlternate* This, ++ IInkRecognitionAlternates **ConfidenceAlternates); ++ ++ HRESULT (STDMETHODCALLTYPE *GetStrokesFromStrokeRanges)( ++ IInkRecognitionAlternate* This, ++ IInkStrokes *Strokes, ++ IInkStrokes **GetStrokesFromStrokeRanges); ++ ++ HRESULT (STDMETHODCALLTYPE *GetStrokesFromTextRange)( ++ IInkRecognitionAlternate* This, ++ LONG *selectionStart, ++ LONG *selectionLength, ++ IInkStrokes **GetStrokesFromTextRange); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTextRangeFromStrokes)( ++ IInkRecognitionAlternate* This, ++ IInkStrokes *Strokes, ++ LONG *selectionStart, ++ LONG *selectionLength); ++ ++ HRESULT (STDMETHODCALLTYPE *AlternatesWithConstantPropertyValues)( ++ IInkRecognitionAlternate* This, ++ BSTR PropertyType, ++ IInkRecognitionAlternates **AlternatesWithConstantPropertyValues); ++ ++ HRESULT (STDMETHODCALLTYPE *GetPropertyValue)( ++ IInkRecognitionAlternate* This, ++ BSTR PropertyType, ++ VARIANT *PropertyValue); ++ ++ END_INTERFACE ++} IInkRecognitionAlternateVtbl; ++interface IInkRecognitionAlternate { ++ CONST_VTBL IInkRecognitionAlternateVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkRecognitionAlternate_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkRecognitionAlternate_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkRecognitionAlternate_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkRecognitionAlternate_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkRecognitionAlternate_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkRecognitionAlternate_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkRecognitionAlternate_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkRecognitionAlternate methods ***/ ++#define IInkRecognitionAlternate_get_String(This,RecoString) (This)->lpVtbl->get_String(This,RecoString) ++#define IInkRecognitionAlternate_get_Confidence(This,Confidence) (This)->lpVtbl->get_Confidence(This,Confidence) ++#define IInkRecognitionAlternate_get_Baseline(This,Baseline) (This)->lpVtbl->get_Baseline(This,Baseline) ++#define IInkRecognitionAlternate_get_Midline(This,Midline) (This)->lpVtbl->get_Midline(This,Midline) ++#define IInkRecognitionAlternate_get_Ascender(This,Ascender) (This)->lpVtbl->get_Ascender(This,Ascender) ++#define IInkRecognitionAlternate_get_Descender(This,Descender) (This)->lpVtbl->get_Descender(This,Descender) ++#define IInkRecognitionAlternate_get_LineNumber(This,LineNumber) (This)->lpVtbl->get_LineNumber(This,LineNumber) ++#define IInkRecognitionAlternate_get_Strokes(This,Strokes) (This)->lpVtbl->get_Strokes(This,Strokes) ++#define IInkRecognitionAlternate_get_LineAlternates(This,LineAlternates) (This)->lpVtbl->get_LineAlternates(This,LineAlternates) ++#define IInkRecognitionAlternate_get_ConfidenceAlternates(This,ConfidenceAlternates) (This)->lpVtbl->get_ConfidenceAlternates(This,ConfidenceAlternates) ++#define IInkRecognitionAlternate_GetStrokesFromStrokeRanges(This,Strokes,GetStrokesFromStrokeRanges) (This)->lpVtbl->GetStrokesFromStrokeRanges(This,Strokes,GetStrokesFromStrokeRanges) ++#define IInkRecognitionAlternate_GetStrokesFromTextRange(This,selectionStart,selectionLength,GetStrokesFromTextRange) (This)->lpVtbl->GetStrokesFromTextRange(This,selectionStart,selectionLength,GetStrokesFromTextRange) ++#define IInkRecognitionAlternate_GetTextRangeFromStrokes(This,Strokes,selectionStart,selectionLength) (This)->lpVtbl->GetTextRangeFromStrokes(This,Strokes,selectionStart,selectionLength) ++#define IInkRecognitionAlternate_AlternatesWithConstantPropertyValues(This,PropertyType,AlternatesWithConstantPropertyValues) (This)->lpVtbl->AlternatesWithConstantPropertyValues(This,PropertyType,AlternatesWithConstantPropertyValues) ++#define IInkRecognitionAlternate_GetPropertyValue(This,PropertyType,PropertyValue) (This)->lpVtbl->GetPropertyValue(This,PropertyType,PropertyValue) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkRecognitionAlternate_QueryInterface(IInkRecognitionAlternate* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkRecognitionAlternate_AddRef(IInkRecognitionAlternate* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkRecognitionAlternate_Release(IInkRecognitionAlternate* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkRecognitionAlternate_GetTypeInfoCount(IInkRecognitionAlternate* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_GetTypeInfo(IInkRecognitionAlternate* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_GetIDsOfNames(IInkRecognitionAlternate* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_Invoke(IInkRecognitionAlternate* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkRecognitionAlternate methods ***/ ++static FORCEINLINE HRESULT IInkRecognitionAlternate_get_String(IInkRecognitionAlternate* This,BSTR *RecoString) { ++ return This->lpVtbl->get_String(This,RecoString); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_get_Confidence(IInkRecognitionAlternate* This,InkRecognitionConfidence *Confidence) { ++ return This->lpVtbl->get_Confidence(This,Confidence); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_get_Baseline(IInkRecognitionAlternate* This,VARIANT *Baseline) { ++ return This->lpVtbl->get_Baseline(This,Baseline); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_get_Midline(IInkRecognitionAlternate* This,VARIANT *Midline) { ++ return This->lpVtbl->get_Midline(This,Midline); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_get_Ascender(IInkRecognitionAlternate* This,VARIANT *Ascender) { ++ return This->lpVtbl->get_Ascender(This,Ascender); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_get_Descender(IInkRecognitionAlternate* This,VARIANT *Descender) { ++ return This->lpVtbl->get_Descender(This,Descender); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_get_LineNumber(IInkRecognitionAlternate* This,LONG *LineNumber) { ++ return This->lpVtbl->get_LineNumber(This,LineNumber); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_get_Strokes(IInkRecognitionAlternate* This,IInkStrokes **Strokes) { ++ return This->lpVtbl->get_Strokes(This,Strokes); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_get_LineAlternates(IInkRecognitionAlternate* This,IInkRecognitionAlternates **LineAlternates) { ++ return This->lpVtbl->get_LineAlternates(This,LineAlternates); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_get_ConfidenceAlternates(IInkRecognitionAlternate* This,IInkRecognitionAlternates **ConfidenceAlternates) { ++ return This->lpVtbl->get_ConfidenceAlternates(This,ConfidenceAlternates); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_GetStrokesFromStrokeRanges(IInkRecognitionAlternate* This,IInkStrokes *Strokes,IInkStrokes **GetStrokesFromStrokeRanges) { ++ return This->lpVtbl->GetStrokesFromStrokeRanges(This,Strokes,GetStrokesFromStrokeRanges); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_GetStrokesFromTextRange(IInkRecognitionAlternate* This,LONG *selectionStart,LONG *selectionLength,IInkStrokes **GetStrokesFromTextRange) { ++ return This->lpVtbl->GetStrokesFromTextRange(This,selectionStart,selectionLength,GetStrokesFromTextRange); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_GetTextRangeFromStrokes(IInkRecognitionAlternate* This,IInkStrokes *Strokes,LONG *selectionStart,LONG *selectionLength) { ++ return This->lpVtbl->GetTextRangeFromStrokes(This,Strokes,selectionStart,selectionLength); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_AlternatesWithConstantPropertyValues(IInkRecognitionAlternate* This,BSTR PropertyType,IInkRecognitionAlternates **AlternatesWithConstantPropertyValues) { ++ return This->lpVtbl->AlternatesWithConstantPropertyValues(This,PropertyType,AlternatesWithConstantPropertyValues); ++} ++static FORCEINLINE HRESULT IInkRecognitionAlternate_GetPropertyValue(IInkRecognitionAlternate* This,BSTR PropertyType,VARIANT *PropertyValue) { ++ return This->lpVtbl->GetPropertyValue(This,PropertyType,PropertyValue); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_get_String_Proxy( ++ IInkRecognitionAlternate* This, ++ BSTR *RecoString); ++void __RPC_STUB IInkRecognitionAlternate_get_String_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_get_Confidence_Proxy( ++ IInkRecognitionAlternate* This, ++ InkRecognitionConfidence *Confidence); ++void __RPC_STUB IInkRecognitionAlternate_get_Confidence_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_get_Baseline_Proxy( ++ IInkRecognitionAlternate* This, ++ VARIANT *Baseline); ++void __RPC_STUB IInkRecognitionAlternate_get_Baseline_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_get_Midline_Proxy( ++ IInkRecognitionAlternate* This, ++ VARIANT *Midline); ++void __RPC_STUB IInkRecognitionAlternate_get_Midline_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_get_Ascender_Proxy( ++ IInkRecognitionAlternate* This, ++ VARIANT *Ascender); ++void __RPC_STUB IInkRecognitionAlternate_get_Ascender_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_get_Descender_Proxy( ++ IInkRecognitionAlternate* This, ++ VARIANT *Descender); ++void __RPC_STUB IInkRecognitionAlternate_get_Descender_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_get_LineNumber_Proxy( ++ IInkRecognitionAlternate* This, ++ LONG *LineNumber); ++void __RPC_STUB IInkRecognitionAlternate_get_LineNumber_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_get_Strokes_Proxy( ++ IInkRecognitionAlternate* This, ++ IInkStrokes **Strokes); ++void __RPC_STUB IInkRecognitionAlternate_get_Strokes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_get_LineAlternates_Proxy( ++ IInkRecognitionAlternate* This, ++ IInkRecognitionAlternates **LineAlternates); ++void __RPC_STUB IInkRecognitionAlternate_get_LineAlternates_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_get_ConfidenceAlternates_Proxy( ++ IInkRecognitionAlternate* This, ++ IInkRecognitionAlternates **ConfidenceAlternates); ++void __RPC_STUB IInkRecognitionAlternate_get_ConfidenceAlternates_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_GetStrokesFromStrokeRanges_Proxy( ++ IInkRecognitionAlternate* This, ++ IInkStrokes *Strokes, ++ IInkStrokes **GetStrokesFromStrokeRanges); ++void __RPC_STUB IInkRecognitionAlternate_GetStrokesFromStrokeRanges_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_GetStrokesFromTextRange_Proxy( ++ IInkRecognitionAlternate* This, ++ LONG *selectionStart, ++ LONG *selectionLength, ++ IInkStrokes **GetStrokesFromTextRange); ++void __RPC_STUB IInkRecognitionAlternate_GetStrokesFromTextRange_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_GetTextRangeFromStrokes_Proxy( ++ IInkRecognitionAlternate* This, ++ IInkStrokes *Strokes, ++ LONG *selectionStart, ++ LONG *selectionLength); ++void __RPC_STUB IInkRecognitionAlternate_GetTextRangeFromStrokes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_AlternatesWithConstantPropertyValues_Proxy( ++ IInkRecognitionAlternate* This, ++ BSTR PropertyType, ++ IInkRecognitionAlternates **AlternatesWithConstantPropertyValues); ++void __RPC_STUB IInkRecognitionAlternate_AlternatesWithConstantPropertyValues_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionAlternate_GetPropertyValue_Proxy( ++ IInkRecognitionAlternate* This, ++ BSTR PropertyType, ++ VARIANT *PropertyValue); ++void __RPC_STUB IInkRecognitionAlternate_GetPropertyValue_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkRecognitionAlternate_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkRecognitionResult interface ++ */ ++#ifndef __IInkRecognitionResult_INTERFACE_DEFINED__ ++#define __IInkRecognitionResult_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkRecognitionResult, 0x3bc129a8, 0x86cd, 0x45ad, 0xbd,0xe8, 0xe0,0xd3,0x2d,0x61,0xc1,0x6d); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("3bc129a8-86cd-45ad-bde8-e0d32d61c16d") ++IInkRecognitionResult : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_TopString( ++ BSTR *TopString) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_TopAlternate( ++ IInkRecognitionAlternate **TopAlternate) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_TopConfidence( ++ InkRecognitionConfidence *TopConfidence) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Strokes( ++ IInkStrokes **Strokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE AlternatesFromSelection( ++ LONG selectionStart, ++ LONG selectionLength, ++ LONG maximumAlternates, ++ IInkRecognitionAlternates **AlternatesFromSelection) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ModifyTopAlternate( ++ IInkRecognitionAlternate *Alternate) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE SetResultOnStrokes( ++ ) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkRecognitionResult, 0x3bc129a8, 0x86cd, 0x45ad, 0xbd,0xe8, 0xe0,0xd3,0x2d,0x61,0xc1,0x6d) ++#endif ++#else ++typedef struct IInkRecognitionResultVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkRecognitionResult* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkRecognitionResult* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkRecognitionResult* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkRecognitionResult* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkRecognitionResult* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkRecognitionResult* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkRecognitionResult* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkRecognitionResult methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_TopString)( ++ IInkRecognitionResult* This, ++ BSTR *TopString); ++ ++ HRESULT (STDMETHODCALLTYPE *get_TopAlternate)( ++ IInkRecognitionResult* This, ++ IInkRecognitionAlternate **TopAlternate); ++ ++ HRESULT (STDMETHODCALLTYPE *get_TopConfidence)( ++ IInkRecognitionResult* This, ++ InkRecognitionConfidence *TopConfidence); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Strokes)( ++ IInkRecognitionResult* This, ++ IInkStrokes **Strokes); ++ ++ HRESULT (STDMETHODCALLTYPE *AlternatesFromSelection)( ++ IInkRecognitionResult* This, ++ LONG selectionStart, ++ LONG selectionLength, ++ LONG maximumAlternates, ++ IInkRecognitionAlternates **AlternatesFromSelection); ++ ++ HRESULT (STDMETHODCALLTYPE *ModifyTopAlternate)( ++ IInkRecognitionResult* This, ++ IInkRecognitionAlternate *Alternate); ++ ++ HRESULT (STDMETHODCALLTYPE *SetResultOnStrokes)( ++ IInkRecognitionResult* This); ++ ++ END_INTERFACE ++} IInkRecognitionResultVtbl; ++interface IInkRecognitionResult { ++ CONST_VTBL IInkRecognitionResultVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkRecognitionResult_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkRecognitionResult_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkRecognitionResult_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkRecognitionResult_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkRecognitionResult_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkRecognitionResult_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkRecognitionResult_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkRecognitionResult methods ***/ ++#define IInkRecognitionResult_get_TopString(This,TopString) (This)->lpVtbl->get_TopString(This,TopString) ++#define IInkRecognitionResult_get_TopAlternate(This,TopAlternate) (This)->lpVtbl->get_TopAlternate(This,TopAlternate) ++#define IInkRecognitionResult_get_TopConfidence(This,TopConfidence) (This)->lpVtbl->get_TopConfidence(This,TopConfidence) ++#define IInkRecognitionResult_get_Strokes(This,Strokes) (This)->lpVtbl->get_Strokes(This,Strokes) ++#define IInkRecognitionResult_AlternatesFromSelection(This,selectionStart,selectionLength,maximumAlternates,AlternatesFromSelection) (This)->lpVtbl->AlternatesFromSelection(This,selectionStart,selectionLength,maximumAlternates,AlternatesFromSelection) ++#define IInkRecognitionResult_ModifyTopAlternate(This,Alternate) (This)->lpVtbl->ModifyTopAlternate(This,Alternate) ++#define IInkRecognitionResult_SetResultOnStrokes(This) (This)->lpVtbl->SetResultOnStrokes(This) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkRecognitionResult_QueryInterface(IInkRecognitionResult* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkRecognitionResult_AddRef(IInkRecognitionResult* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkRecognitionResult_Release(IInkRecognitionResult* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkRecognitionResult_GetTypeInfoCount(IInkRecognitionResult* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkRecognitionResult_GetTypeInfo(IInkRecognitionResult* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkRecognitionResult_GetIDsOfNames(IInkRecognitionResult* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkRecognitionResult_Invoke(IInkRecognitionResult* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkRecognitionResult methods ***/ ++static FORCEINLINE HRESULT IInkRecognitionResult_get_TopString(IInkRecognitionResult* This,BSTR *TopString) { ++ return This->lpVtbl->get_TopString(This,TopString); ++} ++static FORCEINLINE HRESULT IInkRecognitionResult_get_TopAlternate(IInkRecognitionResult* This,IInkRecognitionAlternate **TopAlternate) { ++ return This->lpVtbl->get_TopAlternate(This,TopAlternate); ++} ++static FORCEINLINE HRESULT IInkRecognitionResult_get_TopConfidence(IInkRecognitionResult* This,InkRecognitionConfidence *TopConfidence) { ++ return This->lpVtbl->get_TopConfidence(This,TopConfidence); ++} ++static FORCEINLINE HRESULT IInkRecognitionResult_get_Strokes(IInkRecognitionResult* This,IInkStrokes **Strokes) { ++ return This->lpVtbl->get_Strokes(This,Strokes); ++} ++static FORCEINLINE HRESULT IInkRecognitionResult_AlternatesFromSelection(IInkRecognitionResult* This,LONG selectionStart,LONG selectionLength,LONG maximumAlternates,IInkRecognitionAlternates **AlternatesFromSelection) { ++ return This->lpVtbl->AlternatesFromSelection(This,selectionStart,selectionLength,maximumAlternates,AlternatesFromSelection); ++} ++static FORCEINLINE HRESULT IInkRecognitionResult_ModifyTopAlternate(IInkRecognitionResult* This,IInkRecognitionAlternate *Alternate) { ++ return This->lpVtbl->ModifyTopAlternate(This,Alternate); ++} ++static FORCEINLINE HRESULT IInkRecognitionResult_SetResultOnStrokes(IInkRecognitionResult* This) { ++ return This->lpVtbl->SetResultOnStrokes(This); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkRecognitionResult_get_TopString_Proxy( ++ IInkRecognitionResult* This, ++ BSTR *TopString); ++void __RPC_STUB IInkRecognitionResult_get_TopString_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionResult_get_TopAlternate_Proxy( ++ IInkRecognitionResult* This, ++ IInkRecognitionAlternate **TopAlternate); ++void __RPC_STUB IInkRecognitionResult_get_TopAlternate_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionResult_get_TopConfidence_Proxy( ++ IInkRecognitionResult* This, ++ InkRecognitionConfidence *TopConfidence); ++void __RPC_STUB IInkRecognitionResult_get_TopConfidence_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionResult_get_Strokes_Proxy( ++ IInkRecognitionResult* This, ++ IInkStrokes **Strokes); ++void __RPC_STUB IInkRecognitionResult_get_Strokes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionResult_AlternatesFromSelection_Proxy( ++ IInkRecognitionResult* This, ++ LONG selectionStart, ++ LONG selectionLength, ++ LONG maximumAlternates, ++ IInkRecognitionAlternates **AlternatesFromSelection); ++void __RPC_STUB IInkRecognitionResult_AlternatesFromSelection_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionResult_ModifyTopAlternate_Proxy( ++ IInkRecognitionResult* This, ++ IInkRecognitionAlternate *Alternate); ++void __RPC_STUB IInkRecognitionResult_ModifyTopAlternate_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRecognitionResult_SetResultOnStrokes_Proxy( ++ IInkRecognitionResult* This); ++void __RPC_STUB IInkRecognitionResult_SetResultOnStrokes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkRecognitionResult_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkStrokeDisp interface ++ */ ++#ifndef __IInkStrokeDisp_INTERFACE_DEFINED__ ++#define __IInkStrokeDisp_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkStrokeDisp, 0x43242fea, 0x91d1, 0x4a72, 0x96,0x3e, 0xfb,0xb9,0x18,0x29,0xcf,0xa2); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("43242fea-91d1-4a72-963e-fbb91829cfa2") ++IInkStrokeDisp : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_ID( ++ LONG *ID) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_BezierPoints( ++ VARIANT *Points) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_DrawingAttributes( ++ IInkDrawingAttributes **DrawAttrs) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE putref_DrawingAttributes( ++ IInkDrawingAttributes *DrawAttrs) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Ink( ++ IInkDisp **Ink) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_ExtendedProperties( ++ IInkExtendedProperties **Properties) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_PolylineCusps( ++ VARIANT *Cusps) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_BezierCusps( ++ VARIANT *Cusps) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_SelfIntersections( ++ VARIANT *Intersections) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_PacketCount( ++ LONG *plCount) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_PacketSize( ++ LONG *plSize) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_PacketDescription( ++ VARIANT *PacketDescription) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Deleted( ++ VARIANT_BOOL *Deleted) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetBoundingBox( ++ InkBoundingBoxMode BoundingBoxMode, ++ IInkRectangle **Rectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE FindIntersections( ++ IInkStrokes *Strokes, ++ VARIANT *Intersections) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetRectangleIntersections( ++ IInkRectangle *Rectangle, ++ VARIANT *Intersections) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Clip( ++ IInkRectangle *Rectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE HitTestCircle( ++ LONG X, ++ LONG Y, ++ float Radius, ++ VARIANT_BOOL *Intersects) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE NearestPoint( ++ LONG X, ++ LONG Y, ++ float *Distance, ++ float *Point) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Split( ++ float SplitAt, ++ IInkStrokeDisp **NewStroke) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetPacketDescriptionPropertyMetrics( ++ BSTR PropertyName, ++ LONG *Minimum, ++ LONG *Maximum, ++ TabletPropertyMetricUnit *Units, ++ float *Resolution) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetPoints( ++ LONG Index, ++ LONG Count, ++ VARIANT *Points) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE SetPoints( ++ VARIANT Points, ++ LONG Index, ++ LONG Count, ++ LONG *NumberOfPointsSet) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetPacketData( ++ LONG Index, ++ LONG Count, ++ VARIANT *PacketData) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetPacketValuesByProperty( ++ BSTR PropertyName, ++ LONG Index, ++ LONG Count, ++ VARIANT *PacketValues) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE SetPacketValuesByProperty( ++ BSTR bstrPropertyName, ++ VARIANT PacketValues, ++ LONG Index, ++ LONG Count, ++ LONG *NumberOfPacketsSet) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetFlattenedBezierPoints( ++ LONG FittingError, ++ VARIANT *FlattenedBezierPoints) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Transform( ++ IInkTransform *Transform, ++ VARIANT_BOOL ApplyOnPenWidth = 0) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ScaleToRectangle( ++ IInkRectangle *Rectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Move( ++ float HorizontalComponent, ++ float VerticalComponent) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Rotate( ++ float Degrees, ++ float x = 0, ++ float y = 0) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Shear( ++ float HorizontalMultiplier, ++ float VerticalMultiplier) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ScaleTransform( ++ float HorizontalMultiplier, ++ float VerticalMultiplier) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkStrokeDisp, 0x43242fea, 0x91d1, 0x4a72, 0x96,0x3e, 0xfb,0xb9,0x18,0x29,0xcf,0xa2) ++#endif ++#else ++typedef struct IInkStrokeDispVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkStrokeDisp* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkStrokeDisp* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkStrokeDisp* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkStrokeDisp* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkStrokeDisp* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkStrokeDisp* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkStrokeDisp* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkStrokeDisp methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_ID)( ++ IInkStrokeDisp* This, ++ LONG *ID); ++ ++ HRESULT (STDMETHODCALLTYPE *get_BezierPoints)( ++ IInkStrokeDisp* This, ++ VARIANT *Points); ++ ++ HRESULT (STDMETHODCALLTYPE *get_DrawingAttributes)( ++ IInkStrokeDisp* This, ++ IInkDrawingAttributes **DrawAttrs); ++ ++ HRESULT (STDMETHODCALLTYPE *putref_DrawingAttributes)( ++ IInkStrokeDisp* This, ++ IInkDrawingAttributes *DrawAttrs); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Ink)( ++ IInkStrokeDisp* This, ++ IInkDisp **Ink); ++ ++ HRESULT (STDMETHODCALLTYPE *get_ExtendedProperties)( ++ IInkStrokeDisp* This, ++ IInkExtendedProperties **Properties); ++ ++ HRESULT (STDMETHODCALLTYPE *get_PolylineCusps)( ++ IInkStrokeDisp* This, ++ VARIANT *Cusps); ++ ++ HRESULT (STDMETHODCALLTYPE *get_BezierCusps)( ++ IInkStrokeDisp* This, ++ VARIANT *Cusps); ++ ++ HRESULT (STDMETHODCALLTYPE *get_SelfIntersections)( ++ IInkStrokeDisp* This, ++ VARIANT *Intersections); ++ ++ HRESULT (STDMETHODCALLTYPE *get_PacketCount)( ++ IInkStrokeDisp* This, ++ LONG *plCount); ++ ++ HRESULT (STDMETHODCALLTYPE *get_PacketSize)( ++ IInkStrokeDisp* This, ++ LONG *plSize); ++ ++ HRESULT (STDMETHODCALLTYPE *get_PacketDescription)( ++ IInkStrokeDisp* This, ++ VARIANT *PacketDescription); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Deleted)( ++ IInkStrokeDisp* This, ++ VARIANT_BOOL *Deleted); ++ ++ HRESULT (STDMETHODCALLTYPE *GetBoundingBox)( ++ IInkStrokeDisp* This, ++ InkBoundingBoxMode BoundingBoxMode, ++ IInkRectangle **Rectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *FindIntersections)( ++ IInkStrokeDisp* This, ++ IInkStrokes *Strokes, ++ VARIANT *Intersections); ++ ++ HRESULT (STDMETHODCALLTYPE *GetRectangleIntersections)( ++ IInkStrokeDisp* This, ++ IInkRectangle *Rectangle, ++ VARIANT *Intersections); ++ ++ HRESULT (STDMETHODCALLTYPE *Clip)( ++ IInkStrokeDisp* This, ++ IInkRectangle *Rectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *HitTestCircle)( ++ IInkStrokeDisp* This, ++ LONG X, ++ LONG Y, ++ float Radius, ++ VARIANT_BOOL *Intersects); ++ ++ HRESULT (STDMETHODCALLTYPE *NearestPoint)( ++ IInkStrokeDisp* This, ++ LONG X, ++ LONG Y, ++ float *Distance, ++ float *Point); ++ ++ HRESULT (STDMETHODCALLTYPE *Split)( ++ IInkStrokeDisp* This, ++ float SplitAt, ++ IInkStrokeDisp **NewStroke); ++ ++ HRESULT (STDMETHODCALLTYPE *GetPacketDescriptionPropertyMetrics)( ++ IInkStrokeDisp* This, ++ BSTR PropertyName, ++ LONG *Minimum, ++ LONG *Maximum, ++ TabletPropertyMetricUnit *Units, ++ float *Resolution); ++ ++ HRESULT (STDMETHODCALLTYPE *GetPoints)( ++ IInkStrokeDisp* This, ++ LONG Index, ++ LONG Count, ++ VARIANT *Points); ++ ++ HRESULT (STDMETHODCALLTYPE *SetPoints)( ++ IInkStrokeDisp* This, ++ VARIANT Points, ++ LONG Index, ++ LONG Count, ++ LONG *NumberOfPointsSet); ++ ++ HRESULT (STDMETHODCALLTYPE *GetPacketData)( ++ IInkStrokeDisp* This, ++ LONG Index, ++ LONG Count, ++ VARIANT *PacketData); ++ ++ HRESULT (STDMETHODCALLTYPE *GetPacketValuesByProperty)( ++ IInkStrokeDisp* This, ++ BSTR PropertyName, ++ LONG Index, ++ LONG Count, ++ VARIANT *PacketValues); ++ ++ HRESULT (STDMETHODCALLTYPE *SetPacketValuesByProperty)( ++ IInkStrokeDisp* This, ++ BSTR bstrPropertyName, ++ VARIANT PacketValues, ++ LONG Index, ++ LONG Count, ++ LONG *NumberOfPacketsSet); ++ ++ HRESULT (STDMETHODCALLTYPE *GetFlattenedBezierPoints)( ++ IInkStrokeDisp* This, ++ LONG FittingError, ++ VARIANT *FlattenedBezierPoints); ++ ++ HRESULT (STDMETHODCALLTYPE *Transform)( ++ IInkStrokeDisp* This, ++ IInkTransform *Transform, ++ VARIANT_BOOL ApplyOnPenWidth); ++ ++ HRESULT (STDMETHODCALLTYPE *ScaleToRectangle)( ++ IInkStrokeDisp* This, ++ IInkRectangle *Rectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *Move)( ++ IInkStrokeDisp* This, ++ float HorizontalComponent, ++ float VerticalComponent); ++ ++ HRESULT (STDMETHODCALLTYPE *Rotate)( ++ IInkStrokeDisp* This, ++ float Degrees, ++ float x, ++ float y); ++ ++ HRESULT (STDMETHODCALLTYPE *Shear)( ++ IInkStrokeDisp* This, ++ float HorizontalMultiplier, ++ float VerticalMultiplier); ++ ++ HRESULT (STDMETHODCALLTYPE *ScaleTransform)( ++ IInkStrokeDisp* This, ++ float HorizontalMultiplier, ++ float VerticalMultiplier); ++ ++ END_INTERFACE ++} IInkStrokeDispVtbl; ++interface IInkStrokeDisp { ++ CONST_VTBL IInkStrokeDispVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkStrokeDisp_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkStrokeDisp_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkStrokeDisp_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkStrokeDisp_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkStrokeDisp_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkStrokeDisp_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkStrokeDisp_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkStrokeDisp methods ***/ ++#define IInkStrokeDisp_get_ID(This,ID) (This)->lpVtbl->get_ID(This,ID) ++#define IInkStrokeDisp_get_BezierPoints(This,Points) (This)->lpVtbl->get_BezierPoints(This,Points) ++#define IInkStrokeDisp_get_DrawingAttributes(This,DrawAttrs) (This)->lpVtbl->get_DrawingAttributes(This,DrawAttrs) ++#define IInkStrokeDisp_putref_DrawingAttributes(This,DrawAttrs) (This)->lpVtbl->putref_DrawingAttributes(This,DrawAttrs) ++#define IInkStrokeDisp_get_Ink(This,Ink) (This)->lpVtbl->get_Ink(This,Ink) ++#define IInkStrokeDisp_get_ExtendedProperties(This,Properties) (This)->lpVtbl->get_ExtendedProperties(This,Properties) ++#define IInkStrokeDisp_get_PolylineCusps(This,Cusps) (This)->lpVtbl->get_PolylineCusps(This,Cusps) ++#define IInkStrokeDisp_get_BezierCusps(This,Cusps) (This)->lpVtbl->get_BezierCusps(This,Cusps) ++#define IInkStrokeDisp_get_SelfIntersections(This,Intersections) (This)->lpVtbl->get_SelfIntersections(This,Intersections) ++#define IInkStrokeDisp_get_PacketCount(This,plCount) (This)->lpVtbl->get_PacketCount(This,plCount) ++#define IInkStrokeDisp_get_PacketSize(This,plSize) (This)->lpVtbl->get_PacketSize(This,plSize) ++#define IInkStrokeDisp_get_PacketDescription(This,PacketDescription) (This)->lpVtbl->get_PacketDescription(This,PacketDescription) ++#define IInkStrokeDisp_get_Deleted(This,Deleted) (This)->lpVtbl->get_Deleted(This,Deleted) ++#define IInkStrokeDisp_GetBoundingBox(This,BoundingBoxMode,Rectangle) (This)->lpVtbl->GetBoundingBox(This,BoundingBoxMode,Rectangle) ++#define IInkStrokeDisp_FindIntersections(This,Strokes,Intersections) (This)->lpVtbl->FindIntersections(This,Strokes,Intersections) ++#define IInkStrokeDisp_GetRectangleIntersections(This,Rectangle,Intersections) (This)->lpVtbl->GetRectangleIntersections(This,Rectangle,Intersections) ++#define IInkStrokeDisp_Clip(This,Rectangle) (This)->lpVtbl->Clip(This,Rectangle) ++#define IInkStrokeDisp_HitTestCircle(This,X,Y,Radius,Intersects) (This)->lpVtbl->HitTestCircle(This,X,Y,Radius,Intersects) ++#define IInkStrokeDisp_NearestPoint(This,X,Y,Distance,Point) (This)->lpVtbl->NearestPoint(This,X,Y,Distance,Point) ++#define IInkStrokeDisp_Split(This,SplitAt,NewStroke) (This)->lpVtbl->Split(This,SplitAt,NewStroke) ++#define IInkStrokeDisp_GetPacketDescriptionPropertyMetrics(This,PropertyName,Minimum,Maximum,Units,Resolution) (This)->lpVtbl->GetPacketDescriptionPropertyMetrics(This,PropertyName,Minimum,Maximum,Units,Resolution) ++#define IInkStrokeDisp_GetPoints(This,Index,Count,Points) (This)->lpVtbl->GetPoints(This,Index,Count,Points) ++#define IInkStrokeDisp_SetPoints(This,Points,Index,Count,NumberOfPointsSet) (This)->lpVtbl->SetPoints(This,Points,Index,Count,NumberOfPointsSet) ++#define IInkStrokeDisp_GetPacketData(This,Index,Count,PacketData) (This)->lpVtbl->GetPacketData(This,Index,Count,PacketData) ++#define IInkStrokeDisp_GetPacketValuesByProperty(This,PropertyName,Index,Count,PacketValues) (This)->lpVtbl->GetPacketValuesByProperty(This,PropertyName,Index,Count,PacketValues) ++#define IInkStrokeDisp_SetPacketValuesByProperty(This,bstrPropertyName,PacketValues,Index,Count,NumberOfPacketsSet) (This)->lpVtbl->SetPacketValuesByProperty(This,bstrPropertyName,PacketValues,Index,Count,NumberOfPacketsSet) ++#define IInkStrokeDisp_GetFlattenedBezierPoints(This,FittingError,FlattenedBezierPoints) (This)->lpVtbl->GetFlattenedBezierPoints(This,FittingError,FlattenedBezierPoints) ++#define IInkStrokeDisp_Transform(This,Transform,ApplyOnPenWidth) (This)->lpVtbl->Transform(This,Transform,ApplyOnPenWidth) ++#define IInkStrokeDisp_ScaleToRectangle(This,Rectangle) (This)->lpVtbl->ScaleToRectangle(This,Rectangle) ++#define IInkStrokeDisp_Move(This,HorizontalComponent,VerticalComponent) (This)->lpVtbl->Move(This,HorizontalComponent,VerticalComponent) ++#define IInkStrokeDisp_Rotate(This,Degrees,x,y) (This)->lpVtbl->Rotate(This,Degrees,x,y) ++#define IInkStrokeDisp_Shear(This,HorizontalMultiplier,VerticalMultiplier) (This)->lpVtbl->Shear(This,HorizontalMultiplier,VerticalMultiplier) ++#define IInkStrokeDisp_ScaleTransform(This,HorizontalMultiplier,VerticalMultiplier) (This)->lpVtbl->ScaleTransform(This,HorizontalMultiplier,VerticalMultiplier) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkStrokeDisp_QueryInterface(IInkStrokeDisp* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkStrokeDisp_AddRef(IInkStrokeDisp* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkStrokeDisp_Release(IInkStrokeDisp* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkStrokeDisp_GetTypeInfoCount(IInkStrokeDisp* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_GetTypeInfo(IInkStrokeDisp* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_GetIDsOfNames(IInkStrokeDisp* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_Invoke(IInkStrokeDisp* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkStrokeDisp methods ***/ ++static FORCEINLINE HRESULT IInkStrokeDisp_get_ID(IInkStrokeDisp* This,LONG *ID) { ++ return This->lpVtbl->get_ID(This,ID); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_get_BezierPoints(IInkStrokeDisp* This,VARIANT *Points) { ++ return This->lpVtbl->get_BezierPoints(This,Points); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_get_DrawingAttributes(IInkStrokeDisp* This,IInkDrawingAttributes **DrawAttrs) { ++ return This->lpVtbl->get_DrawingAttributes(This,DrawAttrs); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_putref_DrawingAttributes(IInkStrokeDisp* This,IInkDrawingAttributes *DrawAttrs) { ++ return This->lpVtbl->putref_DrawingAttributes(This,DrawAttrs); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_get_Ink(IInkStrokeDisp* This,IInkDisp **Ink) { ++ return This->lpVtbl->get_Ink(This,Ink); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_get_ExtendedProperties(IInkStrokeDisp* This,IInkExtendedProperties **Properties) { ++ return This->lpVtbl->get_ExtendedProperties(This,Properties); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_get_PolylineCusps(IInkStrokeDisp* This,VARIANT *Cusps) { ++ return This->lpVtbl->get_PolylineCusps(This,Cusps); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_get_BezierCusps(IInkStrokeDisp* This,VARIANT *Cusps) { ++ return This->lpVtbl->get_BezierCusps(This,Cusps); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_get_SelfIntersections(IInkStrokeDisp* This,VARIANT *Intersections) { ++ return This->lpVtbl->get_SelfIntersections(This,Intersections); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_get_PacketCount(IInkStrokeDisp* This,LONG *plCount) { ++ return This->lpVtbl->get_PacketCount(This,plCount); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_get_PacketSize(IInkStrokeDisp* This,LONG *plSize) { ++ return This->lpVtbl->get_PacketSize(This,plSize); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_get_PacketDescription(IInkStrokeDisp* This,VARIANT *PacketDescription) { ++ return This->lpVtbl->get_PacketDescription(This,PacketDescription); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_get_Deleted(IInkStrokeDisp* This,VARIANT_BOOL *Deleted) { ++ return This->lpVtbl->get_Deleted(This,Deleted); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_GetBoundingBox(IInkStrokeDisp* This,InkBoundingBoxMode BoundingBoxMode,IInkRectangle **Rectangle) { ++ return This->lpVtbl->GetBoundingBox(This,BoundingBoxMode,Rectangle); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_FindIntersections(IInkStrokeDisp* This,IInkStrokes *Strokes,VARIANT *Intersections) { ++ return This->lpVtbl->FindIntersections(This,Strokes,Intersections); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_GetRectangleIntersections(IInkStrokeDisp* This,IInkRectangle *Rectangle,VARIANT *Intersections) { ++ return This->lpVtbl->GetRectangleIntersections(This,Rectangle,Intersections); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_Clip(IInkStrokeDisp* This,IInkRectangle *Rectangle) { ++ return This->lpVtbl->Clip(This,Rectangle); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_HitTestCircle(IInkStrokeDisp* This,LONG X,LONG Y,float Radius,VARIANT_BOOL *Intersects) { ++ return This->lpVtbl->HitTestCircle(This,X,Y,Radius,Intersects); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_NearestPoint(IInkStrokeDisp* This,LONG X,LONG Y,float *Distance,float *Point) { ++ return This->lpVtbl->NearestPoint(This,X,Y,Distance,Point); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_Split(IInkStrokeDisp* This,float SplitAt,IInkStrokeDisp **NewStroke) { ++ return This->lpVtbl->Split(This,SplitAt,NewStroke); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_GetPacketDescriptionPropertyMetrics(IInkStrokeDisp* This,BSTR PropertyName,LONG *Minimum,LONG *Maximum,TabletPropertyMetricUnit *Units,float *Resolution) { ++ return This->lpVtbl->GetPacketDescriptionPropertyMetrics(This,PropertyName,Minimum,Maximum,Units,Resolution); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_GetPoints(IInkStrokeDisp* This,LONG Index,LONG Count,VARIANT *Points) { ++ return This->lpVtbl->GetPoints(This,Index,Count,Points); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_SetPoints(IInkStrokeDisp* This,VARIANT Points,LONG Index,LONG Count,LONG *NumberOfPointsSet) { ++ return This->lpVtbl->SetPoints(This,Points,Index,Count,NumberOfPointsSet); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_GetPacketData(IInkStrokeDisp* This,LONG Index,LONG Count,VARIANT *PacketData) { ++ return This->lpVtbl->GetPacketData(This,Index,Count,PacketData); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_GetPacketValuesByProperty(IInkStrokeDisp* This,BSTR PropertyName,LONG Index,LONG Count,VARIANT *PacketValues) { ++ return This->lpVtbl->GetPacketValuesByProperty(This,PropertyName,Index,Count,PacketValues); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_SetPacketValuesByProperty(IInkStrokeDisp* This,BSTR bstrPropertyName,VARIANT PacketValues,LONG Index,LONG Count,LONG *NumberOfPacketsSet) { ++ return This->lpVtbl->SetPacketValuesByProperty(This,bstrPropertyName,PacketValues,Index,Count,NumberOfPacketsSet); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_GetFlattenedBezierPoints(IInkStrokeDisp* This,LONG FittingError,VARIANT *FlattenedBezierPoints) { ++ return This->lpVtbl->GetFlattenedBezierPoints(This,FittingError,FlattenedBezierPoints); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_Transform(IInkStrokeDisp* This,IInkTransform *Transform,VARIANT_BOOL ApplyOnPenWidth) { ++ return This->lpVtbl->Transform(This,Transform,ApplyOnPenWidth); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_ScaleToRectangle(IInkStrokeDisp* This,IInkRectangle *Rectangle) { ++ return This->lpVtbl->ScaleToRectangle(This,Rectangle); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_Move(IInkStrokeDisp* This,float HorizontalComponent,float VerticalComponent) { ++ return This->lpVtbl->Move(This,HorizontalComponent,VerticalComponent); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_Rotate(IInkStrokeDisp* This,float Degrees,float x,float y) { ++ return This->lpVtbl->Rotate(This,Degrees,x,y); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_Shear(IInkStrokeDisp* This,float HorizontalMultiplier,float VerticalMultiplier) { ++ return This->lpVtbl->Shear(This,HorizontalMultiplier,VerticalMultiplier); ++} ++static FORCEINLINE HRESULT IInkStrokeDisp_ScaleTransform(IInkStrokeDisp* This,float HorizontalMultiplier,float VerticalMultiplier) { ++ return This->lpVtbl->ScaleTransform(This,HorizontalMultiplier,VerticalMultiplier); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_get_ID_Proxy( ++ IInkStrokeDisp* This, ++ LONG *ID); ++void __RPC_STUB IInkStrokeDisp_get_ID_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_get_BezierPoints_Proxy( ++ IInkStrokeDisp* This, ++ VARIANT *Points); ++void __RPC_STUB IInkStrokeDisp_get_BezierPoints_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_get_DrawingAttributes_Proxy( ++ IInkStrokeDisp* This, ++ IInkDrawingAttributes **DrawAttrs); ++void __RPC_STUB IInkStrokeDisp_get_DrawingAttributes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_putref_DrawingAttributes_Proxy( ++ IInkStrokeDisp* This, ++ IInkDrawingAttributes *DrawAttrs); ++void __RPC_STUB IInkStrokeDisp_putref_DrawingAttributes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_get_Ink_Proxy( ++ IInkStrokeDisp* This, ++ IInkDisp **Ink); ++void __RPC_STUB IInkStrokeDisp_get_Ink_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_get_ExtendedProperties_Proxy( ++ IInkStrokeDisp* This, ++ IInkExtendedProperties **Properties); ++void __RPC_STUB IInkStrokeDisp_get_ExtendedProperties_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_get_PolylineCusps_Proxy( ++ IInkStrokeDisp* This, ++ VARIANT *Cusps); ++void __RPC_STUB IInkStrokeDisp_get_PolylineCusps_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_get_BezierCusps_Proxy( ++ IInkStrokeDisp* This, ++ VARIANT *Cusps); ++void __RPC_STUB IInkStrokeDisp_get_BezierCusps_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_get_SelfIntersections_Proxy( ++ IInkStrokeDisp* This, ++ VARIANT *Intersections); ++void __RPC_STUB IInkStrokeDisp_get_SelfIntersections_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_get_PacketCount_Proxy( ++ IInkStrokeDisp* This, ++ LONG *plCount); ++void __RPC_STUB IInkStrokeDisp_get_PacketCount_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_get_PacketSize_Proxy( ++ IInkStrokeDisp* This, ++ LONG *plSize); ++void __RPC_STUB IInkStrokeDisp_get_PacketSize_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_get_PacketDescription_Proxy( ++ IInkStrokeDisp* This, ++ VARIANT *PacketDescription); ++void __RPC_STUB IInkStrokeDisp_get_PacketDescription_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_get_Deleted_Proxy( ++ IInkStrokeDisp* This, ++ VARIANT_BOOL *Deleted); ++void __RPC_STUB IInkStrokeDisp_get_Deleted_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_GetBoundingBox_Proxy( ++ IInkStrokeDisp* This, ++ InkBoundingBoxMode BoundingBoxMode, ++ IInkRectangle **Rectangle); ++void __RPC_STUB IInkStrokeDisp_GetBoundingBox_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_FindIntersections_Proxy( ++ IInkStrokeDisp* This, ++ IInkStrokes *Strokes, ++ VARIANT *Intersections); ++void __RPC_STUB IInkStrokeDisp_FindIntersections_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_GetRectangleIntersections_Proxy( ++ IInkStrokeDisp* This, ++ IInkRectangle *Rectangle, ++ VARIANT *Intersections); ++void __RPC_STUB IInkStrokeDisp_GetRectangleIntersections_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_Clip_Proxy( ++ IInkStrokeDisp* This, ++ IInkRectangle *Rectangle); ++void __RPC_STUB IInkStrokeDisp_Clip_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_HitTestCircle_Proxy( ++ IInkStrokeDisp* This, ++ LONG X, ++ LONG Y, ++ float Radius, ++ VARIANT_BOOL *Intersects); ++void __RPC_STUB IInkStrokeDisp_HitTestCircle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_NearestPoint_Proxy( ++ IInkStrokeDisp* This, ++ LONG X, ++ LONG Y, ++ float *Distance, ++ float *Point); ++void __RPC_STUB IInkStrokeDisp_NearestPoint_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_Split_Proxy( ++ IInkStrokeDisp* This, ++ float SplitAt, ++ IInkStrokeDisp **NewStroke); ++void __RPC_STUB IInkStrokeDisp_Split_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_GetPacketDescriptionPropertyMetrics_Proxy( ++ IInkStrokeDisp* This, ++ BSTR PropertyName, ++ LONG *Minimum, ++ LONG *Maximum, ++ TabletPropertyMetricUnit *Units, ++ float *Resolution); ++void __RPC_STUB IInkStrokeDisp_GetPacketDescriptionPropertyMetrics_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_GetPoints_Proxy( ++ IInkStrokeDisp* This, ++ LONG Index, ++ LONG Count, ++ VARIANT *Points); ++void __RPC_STUB IInkStrokeDisp_GetPoints_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_SetPoints_Proxy( ++ IInkStrokeDisp* This, ++ VARIANT Points, ++ LONG Index, ++ LONG Count, ++ LONG *NumberOfPointsSet); ++void __RPC_STUB IInkStrokeDisp_SetPoints_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_GetPacketData_Proxy( ++ IInkStrokeDisp* This, ++ LONG Index, ++ LONG Count, ++ VARIANT *PacketData); ++void __RPC_STUB IInkStrokeDisp_GetPacketData_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_GetPacketValuesByProperty_Proxy( ++ IInkStrokeDisp* This, ++ BSTR PropertyName, ++ LONG Index, ++ LONG Count, ++ VARIANT *PacketValues); ++void __RPC_STUB IInkStrokeDisp_GetPacketValuesByProperty_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_SetPacketValuesByProperty_Proxy( ++ IInkStrokeDisp* This, ++ BSTR bstrPropertyName, ++ VARIANT PacketValues, ++ LONG Index, ++ LONG Count, ++ LONG *NumberOfPacketsSet); ++void __RPC_STUB IInkStrokeDisp_SetPacketValuesByProperty_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_GetFlattenedBezierPoints_Proxy( ++ IInkStrokeDisp* This, ++ LONG FittingError, ++ VARIANT *FlattenedBezierPoints); ++void __RPC_STUB IInkStrokeDisp_GetFlattenedBezierPoints_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_Transform_Proxy( ++ IInkStrokeDisp* This, ++ IInkTransform *Transform, ++ VARIANT_BOOL ApplyOnPenWidth); ++void __RPC_STUB IInkStrokeDisp_Transform_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_ScaleToRectangle_Proxy( ++ IInkStrokeDisp* This, ++ IInkRectangle *Rectangle); ++void __RPC_STUB IInkStrokeDisp_ScaleToRectangle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_Move_Proxy( ++ IInkStrokeDisp* This, ++ float HorizontalComponent, ++ float VerticalComponent); ++void __RPC_STUB IInkStrokeDisp_Move_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_Rotate_Proxy( ++ IInkStrokeDisp* This, ++ float Degrees, ++ float x, ++ float y); ++void __RPC_STUB IInkStrokeDisp_Rotate_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_Shear_Proxy( ++ IInkStrokeDisp* This, ++ float HorizontalMultiplier, ++ float VerticalMultiplier); ++void __RPC_STUB IInkStrokeDisp_Shear_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokeDisp_ScaleTransform_Proxy( ++ IInkStrokeDisp* This, ++ float HorizontalMultiplier, ++ float VerticalMultiplier); ++void __RPC_STUB IInkStrokeDisp_ScaleTransform_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkStrokeDisp_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkCustomStrokes interface ++ */ ++#ifndef __IInkCustomStrokes_INTERFACE_DEFINED__ ++#define __IInkCustomStrokes_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkCustomStrokes, 0x7e23a88f, 0xc30e, 0x420f, 0x9b,0xdb, 0x28,0x90,0x25,0x43,0xf0,0xc1); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("7e23a88f-c30e-420f-9bdb-28902543f0c1") ++IInkCustomStrokes : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Count( ++ LONG *Count) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get__NewEnum( ++ IUnknown **_NewEnum) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Item( ++ VARIANT Identifier, ++ IInkStrokes **Strokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Add( ++ BSTR Name, ++ IInkStrokes *Strokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Remove( ++ VARIANT Identifier) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Clear( ++ ) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkCustomStrokes, 0x7e23a88f, 0xc30e, 0x420f, 0x9b,0xdb, 0x28,0x90,0x25,0x43,0xf0,0xc1) ++#endif ++#else ++typedef struct IInkCustomStrokesVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkCustomStrokes* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkCustomStrokes* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkCustomStrokes* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkCustomStrokes* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkCustomStrokes* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkCustomStrokes* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkCustomStrokes* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkCustomStrokes methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Count)( ++ IInkCustomStrokes* This, ++ LONG *Count); ++ ++ HRESULT (STDMETHODCALLTYPE *get__NewEnum)( ++ IInkCustomStrokes* This, ++ IUnknown **_NewEnum); ++ ++ HRESULT (STDMETHODCALLTYPE *Item)( ++ IInkCustomStrokes* This, ++ VARIANT Identifier, ++ IInkStrokes **Strokes); ++ ++ HRESULT (STDMETHODCALLTYPE *Add)( ++ IInkCustomStrokes* This, ++ BSTR Name, ++ IInkStrokes *Strokes); ++ ++ HRESULT (STDMETHODCALLTYPE *Remove)( ++ IInkCustomStrokes* This, ++ VARIANT Identifier); ++ ++ HRESULT (STDMETHODCALLTYPE *Clear)( ++ IInkCustomStrokes* This); ++ ++ END_INTERFACE ++} IInkCustomStrokesVtbl; ++interface IInkCustomStrokes { ++ CONST_VTBL IInkCustomStrokesVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkCustomStrokes_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkCustomStrokes_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkCustomStrokes_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkCustomStrokes_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkCustomStrokes_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkCustomStrokes_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkCustomStrokes_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkCustomStrokes methods ***/ ++#define IInkCustomStrokes_get_Count(This,Count) (This)->lpVtbl->get_Count(This,Count) ++#define IInkCustomStrokes_get__NewEnum(This,_NewEnum) (This)->lpVtbl->get__NewEnum(This,_NewEnum) ++#define IInkCustomStrokes_Item(This,Identifier,Strokes) (This)->lpVtbl->Item(This,Identifier,Strokes) ++#define IInkCustomStrokes_Add(This,Name,Strokes) (This)->lpVtbl->Add(This,Name,Strokes) ++#define IInkCustomStrokes_Remove(This,Identifier) (This)->lpVtbl->Remove(This,Identifier) ++#define IInkCustomStrokes_Clear(This) (This)->lpVtbl->Clear(This) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkCustomStrokes_QueryInterface(IInkCustomStrokes* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkCustomStrokes_AddRef(IInkCustomStrokes* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkCustomStrokes_Release(IInkCustomStrokes* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkCustomStrokes_GetTypeInfoCount(IInkCustomStrokes* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkCustomStrokes_GetTypeInfo(IInkCustomStrokes* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkCustomStrokes_GetIDsOfNames(IInkCustomStrokes* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkCustomStrokes_Invoke(IInkCustomStrokes* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkCustomStrokes methods ***/ ++static FORCEINLINE HRESULT IInkCustomStrokes_get_Count(IInkCustomStrokes* This,LONG *Count) { ++ return This->lpVtbl->get_Count(This,Count); ++} ++static FORCEINLINE HRESULT IInkCustomStrokes_get__NewEnum(IInkCustomStrokes* This,IUnknown **_NewEnum) { ++ return This->lpVtbl->get__NewEnum(This,_NewEnum); ++} ++static FORCEINLINE HRESULT IInkCustomStrokes_Item(IInkCustomStrokes* This,VARIANT Identifier,IInkStrokes **Strokes) { ++ return This->lpVtbl->Item(This,Identifier,Strokes); ++} ++static FORCEINLINE HRESULT IInkCustomStrokes_Add(IInkCustomStrokes* This,BSTR Name,IInkStrokes *Strokes) { ++ return This->lpVtbl->Add(This,Name,Strokes); ++} ++static FORCEINLINE HRESULT IInkCustomStrokes_Remove(IInkCustomStrokes* This,VARIANT Identifier) { ++ return This->lpVtbl->Remove(This,Identifier); ++} ++static FORCEINLINE HRESULT IInkCustomStrokes_Clear(IInkCustomStrokes* This) { ++ return This->lpVtbl->Clear(This); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkCustomStrokes_get_Count_Proxy( ++ IInkCustomStrokes* This, ++ LONG *Count); ++void __RPC_STUB IInkCustomStrokes_get_Count_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCustomStrokes_get__NewEnum_Proxy( ++ IInkCustomStrokes* This, ++ IUnknown **_NewEnum); ++void __RPC_STUB IInkCustomStrokes_get__NewEnum_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCustomStrokes_Item_Proxy( ++ IInkCustomStrokes* This, ++ VARIANT Identifier, ++ IInkStrokes **Strokes); ++void __RPC_STUB IInkCustomStrokes_Item_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCustomStrokes_Add_Proxy( ++ IInkCustomStrokes* This, ++ BSTR Name, ++ IInkStrokes *Strokes); ++void __RPC_STUB IInkCustomStrokes_Add_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCustomStrokes_Remove_Proxy( ++ IInkCustomStrokes* This, ++ VARIANT Identifier); ++void __RPC_STUB IInkCustomStrokes_Remove_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCustomStrokes_Clear_Proxy( ++ IInkCustomStrokes* This); ++void __RPC_STUB IInkCustomStrokes_Clear_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkCustomStrokes_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkDisp interface ++ */ ++#ifndef __IInkDisp_INTERFACE_DEFINED__ ++#define __IInkDisp_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkDisp, 0x9d398fa0, 0xc4e2, 0x4fcd, 0x99,0x73, 0x97,0x5c,0xaa,0xf4,0x7e,0xa6); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("9d398fa0-c4e2-4fcd-9973-975caaf47ea6") ++IInkDisp : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Strokes( ++ IInkStrokes **Strokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_ExtendedProperties( ++ IInkExtendedProperties **Properties) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Dirty( ++ VARIANT_BOOL *Dirty) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Dirty( ++ VARIANT_BOOL Dirty) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_CustomStrokes( ++ IInkCustomStrokes **ppunkInkCustomStrokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetBoundingBox( ++ InkBoundingBoxMode BoundingBoxMode, ++ IInkRectangle **Rectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE DeleteStrokes( ++ IInkStrokes *Strokes = 0) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE DeleteStroke( ++ IInkStrokeDisp *Stroke) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ExtractStrokes( ++ IInkStrokes *Strokes, ++ InkExtractFlags ExtractFlags, ++ IInkDisp **ExtractedInk) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ExtractWithRectangle( ++ IInkRectangle *Rectangle, ++ InkExtractFlags extractFlags, ++ IInkDisp **ExtractedInk) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Clip( ++ IInkRectangle *Rectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Clone( ++ IInkDisp **NewInk) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE HitTestCircle( ++ LONG X, ++ LONG Y, ++ float radius, ++ IInkStrokes **Strokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE HitTestWithRectangle( ++ IInkRectangle *SelectionRectangle, ++ float IntersectPercent, ++ IInkStrokes **Strokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE HitTestWithLasso( ++ VARIANT Points, ++ float IntersectPercent, ++ VARIANT *LassoPoints, ++ IInkStrokes **Strokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE NearestPoint( ++ LONG X, ++ LONG Y, ++ float *PointOnStroke, ++ float *DistanceFromPacket, ++ IInkStrokeDisp **Stroke) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE CreateStrokes( ++ VARIANT StrokeIds, ++ IInkStrokes **Strokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE AddStrokesAtRectangle( ++ IInkStrokes *SourceStrokes, ++ IInkRectangle *TargetRectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Save( ++ InkPersistenceFormat PersistenceFormat, ++ InkPersistenceCompressionMode CompressionMode, ++ VARIANT *Data) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Load( ++ VARIANT Data) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE CreateStroke( ++ VARIANT PacketData, ++ VARIANT PacketDescription, ++ IInkStrokeDisp **Stroke) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ClipboardCopyWithRectangle( ++ IInkRectangle *Rectangle, ++ InkClipboardFormats ClipboardFormats, ++ InkClipboardModes ClipboardModes, ++ IDataObject **DataObject) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ClipboardCopy( ++ IInkStrokes *strokes, ++ InkClipboardFormats ClipboardFormats, ++ InkClipboardModes ClipboardModes, ++ IDataObject **DataObject) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE CanPaste( ++ IDataObject *DataObject, ++ VARIANT_BOOL *CanPaste) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ClipboardPaste( ++ LONG x, ++ LONG y, ++ IDataObject *DataObject, ++ IInkStrokes **Strokes) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkDisp, 0x9d398fa0, 0xc4e2, 0x4fcd, 0x99,0x73, 0x97,0x5c,0xaa,0xf4,0x7e,0xa6) ++#endif ++#else ++typedef struct IInkDispVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkDisp* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkDisp* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkDisp* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkDisp* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkDisp* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkDisp* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkDisp* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkDisp methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Strokes)( ++ IInkDisp* This, ++ IInkStrokes **Strokes); ++ ++ HRESULT (STDMETHODCALLTYPE *get_ExtendedProperties)( ++ IInkDisp* This, ++ IInkExtendedProperties **Properties); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Dirty)( ++ IInkDisp* This, ++ VARIANT_BOOL *Dirty); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Dirty)( ++ IInkDisp* This, ++ VARIANT_BOOL Dirty); ++ ++ HRESULT (STDMETHODCALLTYPE *get_CustomStrokes)( ++ IInkDisp* This, ++ IInkCustomStrokes **ppunkInkCustomStrokes); ++ ++ HRESULT (STDMETHODCALLTYPE *GetBoundingBox)( ++ IInkDisp* This, ++ InkBoundingBoxMode BoundingBoxMode, ++ IInkRectangle **Rectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *DeleteStrokes)( ++ IInkDisp* This, ++ IInkStrokes *Strokes); ++ ++ HRESULT (STDMETHODCALLTYPE *DeleteStroke)( ++ IInkDisp* This, ++ IInkStrokeDisp *Stroke); ++ ++ HRESULT (STDMETHODCALLTYPE *ExtractStrokes)( ++ IInkDisp* This, ++ IInkStrokes *Strokes, ++ InkExtractFlags ExtractFlags, ++ IInkDisp **ExtractedInk); ++ ++ HRESULT (STDMETHODCALLTYPE *ExtractWithRectangle)( ++ IInkDisp* This, ++ IInkRectangle *Rectangle, ++ InkExtractFlags extractFlags, ++ IInkDisp **ExtractedInk); ++ ++ HRESULT (STDMETHODCALLTYPE *Clip)( ++ IInkDisp* This, ++ IInkRectangle *Rectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *Clone)( ++ IInkDisp* This, ++ IInkDisp **NewInk); ++ ++ HRESULT (STDMETHODCALLTYPE *HitTestCircle)( ++ IInkDisp* This, ++ LONG X, ++ LONG Y, ++ float radius, ++ IInkStrokes **Strokes); ++ ++ HRESULT (STDMETHODCALLTYPE *HitTestWithRectangle)( ++ IInkDisp* This, ++ IInkRectangle *SelectionRectangle, ++ float IntersectPercent, ++ IInkStrokes **Strokes); ++ ++ HRESULT (STDMETHODCALLTYPE *HitTestWithLasso)( ++ IInkDisp* This, ++ VARIANT Points, ++ float IntersectPercent, ++ VARIANT *LassoPoints, ++ IInkStrokes **Strokes); ++ ++ HRESULT (STDMETHODCALLTYPE *NearestPoint)( ++ IInkDisp* This, ++ LONG X, ++ LONG Y, ++ float *PointOnStroke, ++ float *DistanceFromPacket, ++ IInkStrokeDisp **Stroke); ++ ++ HRESULT (STDMETHODCALLTYPE *CreateStrokes)( ++ IInkDisp* This, ++ VARIANT StrokeIds, ++ IInkStrokes **Strokes); ++ ++ HRESULT (STDMETHODCALLTYPE *AddStrokesAtRectangle)( ++ IInkDisp* This, ++ IInkStrokes *SourceStrokes, ++ IInkRectangle *TargetRectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *Save)( ++ IInkDisp* This, ++ InkPersistenceFormat PersistenceFormat, ++ InkPersistenceCompressionMode CompressionMode, ++ VARIANT *Data); ++ ++ HRESULT (STDMETHODCALLTYPE *Load)( ++ IInkDisp* This, ++ VARIANT Data); ++ ++ HRESULT (STDMETHODCALLTYPE *CreateStroke)( ++ IInkDisp* This, ++ VARIANT PacketData, ++ VARIANT PacketDescription, ++ IInkStrokeDisp **Stroke); ++ ++ HRESULT (STDMETHODCALLTYPE *ClipboardCopyWithRectangle)( ++ IInkDisp* This, ++ IInkRectangle *Rectangle, ++ InkClipboardFormats ClipboardFormats, ++ InkClipboardModes ClipboardModes, ++ IDataObject **DataObject); ++ ++ HRESULT (STDMETHODCALLTYPE *ClipboardCopy)( ++ IInkDisp* This, ++ IInkStrokes *strokes, ++ InkClipboardFormats ClipboardFormats, ++ InkClipboardModes ClipboardModes, ++ IDataObject **DataObject); ++ ++ HRESULT (STDMETHODCALLTYPE *CanPaste)( ++ IInkDisp* This, ++ IDataObject *DataObject, ++ VARIANT_BOOL *CanPaste); ++ ++ HRESULT (STDMETHODCALLTYPE *ClipboardPaste)( ++ IInkDisp* This, ++ LONG x, ++ LONG y, ++ IDataObject *DataObject, ++ IInkStrokes **Strokes); ++ ++ END_INTERFACE ++} IInkDispVtbl; ++interface IInkDisp { ++ CONST_VTBL IInkDispVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkDisp_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkDisp_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkDisp_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkDisp_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkDisp_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkDisp_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkDisp_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkDisp methods ***/ ++#define IInkDisp_get_Strokes(This,Strokes) (This)->lpVtbl->get_Strokes(This,Strokes) ++#define IInkDisp_get_ExtendedProperties(This,Properties) (This)->lpVtbl->get_ExtendedProperties(This,Properties) ++#define IInkDisp_get_Dirty(This,Dirty) (This)->lpVtbl->get_Dirty(This,Dirty) ++#define IInkDisp_put_Dirty(This,Dirty) (This)->lpVtbl->put_Dirty(This,Dirty) ++#define IInkDisp_get_CustomStrokes(This,ppunkInkCustomStrokes) (This)->lpVtbl->get_CustomStrokes(This,ppunkInkCustomStrokes) ++#define IInkDisp_GetBoundingBox(This,BoundingBoxMode,Rectangle) (This)->lpVtbl->GetBoundingBox(This,BoundingBoxMode,Rectangle) ++#define IInkDisp_DeleteStrokes(This,Strokes) (This)->lpVtbl->DeleteStrokes(This,Strokes) ++#define IInkDisp_DeleteStroke(This,Stroke) (This)->lpVtbl->DeleteStroke(This,Stroke) ++#define IInkDisp_ExtractStrokes(This,Strokes,ExtractFlags,ExtractedInk) (This)->lpVtbl->ExtractStrokes(This,Strokes,ExtractFlags,ExtractedInk) ++#define IInkDisp_ExtractWithRectangle(This,Rectangle,extractFlags,ExtractedInk) (This)->lpVtbl->ExtractWithRectangle(This,Rectangle,extractFlags,ExtractedInk) ++#define IInkDisp_Clip(This,Rectangle) (This)->lpVtbl->Clip(This,Rectangle) ++#define IInkDisp_Clone(This,NewInk) (This)->lpVtbl->Clone(This,NewInk) ++#define IInkDisp_HitTestCircle(This,X,Y,radius,Strokes) (This)->lpVtbl->HitTestCircle(This,X,Y,radius,Strokes) ++#define IInkDisp_HitTestWithRectangle(This,SelectionRectangle,IntersectPercent,Strokes) (This)->lpVtbl->HitTestWithRectangle(This,SelectionRectangle,IntersectPercent,Strokes) ++#define IInkDisp_HitTestWithLasso(This,Points,IntersectPercent,LassoPoints,Strokes) (This)->lpVtbl->HitTestWithLasso(This,Points,IntersectPercent,LassoPoints,Strokes) ++#define IInkDisp_NearestPoint(This,X,Y,PointOnStroke,DistanceFromPacket,Stroke) (This)->lpVtbl->NearestPoint(This,X,Y,PointOnStroke,DistanceFromPacket,Stroke) ++#define IInkDisp_CreateStrokes(This,StrokeIds,Strokes) (This)->lpVtbl->CreateStrokes(This,StrokeIds,Strokes) ++#define IInkDisp_AddStrokesAtRectangle(This,SourceStrokes,TargetRectangle) (This)->lpVtbl->AddStrokesAtRectangle(This,SourceStrokes,TargetRectangle) ++#define IInkDisp_Save(This,PersistenceFormat,CompressionMode,Data) (This)->lpVtbl->Save(This,PersistenceFormat,CompressionMode,Data) ++#define IInkDisp_Load(This,Data) (This)->lpVtbl->Load(This,Data) ++#define IInkDisp_CreateStroke(This,PacketData,PacketDescription,Stroke) (This)->lpVtbl->CreateStroke(This,PacketData,PacketDescription,Stroke) ++#define IInkDisp_ClipboardCopyWithRectangle(This,Rectangle,ClipboardFormats,ClipboardModes,DataObject) (This)->lpVtbl->ClipboardCopyWithRectangle(This,Rectangle,ClipboardFormats,ClipboardModes,DataObject) ++#define IInkDisp_ClipboardCopy(This,strokes,ClipboardFormats,ClipboardModes,DataObject) (This)->lpVtbl->ClipboardCopy(This,strokes,ClipboardFormats,ClipboardModes,DataObject) ++#define IInkDisp_CanPaste(This,DataObject,CanPaste) (This)->lpVtbl->CanPaste(This,DataObject,CanPaste) ++#define IInkDisp_ClipboardPaste(This,x,y,DataObject,Strokes) (This)->lpVtbl->ClipboardPaste(This,x,y,DataObject,Strokes) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkDisp_QueryInterface(IInkDisp* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkDisp_AddRef(IInkDisp* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkDisp_Release(IInkDisp* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkDisp_GetTypeInfoCount(IInkDisp* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkDisp_GetTypeInfo(IInkDisp* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkDisp_GetIDsOfNames(IInkDisp* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkDisp_Invoke(IInkDisp* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkDisp methods ***/ ++static FORCEINLINE HRESULT IInkDisp_get_Strokes(IInkDisp* This,IInkStrokes **Strokes) { ++ return This->lpVtbl->get_Strokes(This,Strokes); ++} ++static FORCEINLINE HRESULT IInkDisp_get_ExtendedProperties(IInkDisp* This,IInkExtendedProperties **Properties) { ++ return This->lpVtbl->get_ExtendedProperties(This,Properties); ++} ++static FORCEINLINE HRESULT IInkDisp_get_Dirty(IInkDisp* This,VARIANT_BOOL *Dirty) { ++ return This->lpVtbl->get_Dirty(This,Dirty); ++} ++static FORCEINLINE HRESULT IInkDisp_put_Dirty(IInkDisp* This,VARIANT_BOOL Dirty) { ++ return This->lpVtbl->put_Dirty(This,Dirty); ++} ++static FORCEINLINE HRESULT IInkDisp_get_CustomStrokes(IInkDisp* This,IInkCustomStrokes **ppunkInkCustomStrokes) { ++ return This->lpVtbl->get_CustomStrokes(This,ppunkInkCustomStrokes); ++} ++static FORCEINLINE HRESULT IInkDisp_GetBoundingBox(IInkDisp* This,InkBoundingBoxMode BoundingBoxMode,IInkRectangle **Rectangle) { ++ return This->lpVtbl->GetBoundingBox(This,BoundingBoxMode,Rectangle); ++} ++static FORCEINLINE HRESULT IInkDisp_DeleteStrokes(IInkDisp* This,IInkStrokes *Strokes) { ++ return This->lpVtbl->DeleteStrokes(This,Strokes); ++} ++static FORCEINLINE HRESULT IInkDisp_DeleteStroke(IInkDisp* This,IInkStrokeDisp *Stroke) { ++ return This->lpVtbl->DeleteStroke(This,Stroke); ++} ++static FORCEINLINE HRESULT IInkDisp_ExtractStrokes(IInkDisp* This,IInkStrokes *Strokes,InkExtractFlags ExtractFlags,IInkDisp **ExtractedInk) { ++ return This->lpVtbl->ExtractStrokes(This,Strokes,ExtractFlags,ExtractedInk); ++} ++static FORCEINLINE HRESULT IInkDisp_ExtractWithRectangle(IInkDisp* This,IInkRectangle *Rectangle,InkExtractFlags extractFlags,IInkDisp **ExtractedInk) { ++ return This->lpVtbl->ExtractWithRectangle(This,Rectangle,extractFlags,ExtractedInk); ++} ++static FORCEINLINE HRESULT IInkDisp_Clip(IInkDisp* This,IInkRectangle *Rectangle) { ++ return This->lpVtbl->Clip(This,Rectangle); ++} ++static FORCEINLINE HRESULT IInkDisp_Clone(IInkDisp* This,IInkDisp **NewInk) { ++ return This->lpVtbl->Clone(This,NewInk); ++} ++static FORCEINLINE HRESULT IInkDisp_HitTestCircle(IInkDisp* This,LONG X,LONG Y,float radius,IInkStrokes **Strokes) { ++ return This->lpVtbl->HitTestCircle(This,X,Y,radius,Strokes); ++} ++static FORCEINLINE HRESULT IInkDisp_HitTestWithRectangle(IInkDisp* This,IInkRectangle *SelectionRectangle,float IntersectPercent,IInkStrokes **Strokes) { ++ return This->lpVtbl->HitTestWithRectangle(This,SelectionRectangle,IntersectPercent,Strokes); ++} ++static FORCEINLINE HRESULT IInkDisp_HitTestWithLasso(IInkDisp* This,VARIANT Points,float IntersectPercent,VARIANT *LassoPoints,IInkStrokes **Strokes) { ++ return This->lpVtbl->HitTestWithLasso(This,Points,IntersectPercent,LassoPoints,Strokes); ++} ++static FORCEINLINE HRESULT IInkDisp_NearestPoint(IInkDisp* This,LONG X,LONG Y,float *PointOnStroke,float *DistanceFromPacket,IInkStrokeDisp **Stroke) { ++ return This->lpVtbl->NearestPoint(This,X,Y,PointOnStroke,DistanceFromPacket,Stroke); ++} ++static FORCEINLINE HRESULT IInkDisp_CreateStrokes(IInkDisp* This,VARIANT StrokeIds,IInkStrokes **Strokes) { ++ return This->lpVtbl->CreateStrokes(This,StrokeIds,Strokes); ++} ++static FORCEINLINE HRESULT IInkDisp_AddStrokesAtRectangle(IInkDisp* This,IInkStrokes *SourceStrokes,IInkRectangle *TargetRectangle) { ++ return This->lpVtbl->AddStrokesAtRectangle(This,SourceStrokes,TargetRectangle); ++} ++static FORCEINLINE HRESULT IInkDisp_Save(IInkDisp* This,InkPersistenceFormat PersistenceFormat,InkPersistenceCompressionMode CompressionMode,VARIANT *Data) { ++ return This->lpVtbl->Save(This,PersistenceFormat,CompressionMode,Data); ++} ++static FORCEINLINE HRESULT IInkDisp_Load(IInkDisp* This,VARIANT Data) { ++ return This->lpVtbl->Load(This,Data); ++} ++static FORCEINLINE HRESULT IInkDisp_CreateStroke(IInkDisp* This,VARIANT PacketData,VARIANT PacketDescription,IInkStrokeDisp **Stroke) { ++ return This->lpVtbl->CreateStroke(This,PacketData,PacketDescription,Stroke); ++} ++static FORCEINLINE HRESULT IInkDisp_ClipboardCopyWithRectangle(IInkDisp* This,IInkRectangle *Rectangle,InkClipboardFormats ClipboardFormats,InkClipboardModes ClipboardModes,IDataObject **DataObject) { ++ return This->lpVtbl->ClipboardCopyWithRectangle(This,Rectangle,ClipboardFormats,ClipboardModes,DataObject); ++} ++static FORCEINLINE HRESULT IInkDisp_ClipboardCopy(IInkDisp* This,IInkStrokes *strokes,InkClipboardFormats ClipboardFormats,InkClipboardModes ClipboardModes,IDataObject **DataObject) { ++ return This->lpVtbl->ClipboardCopy(This,strokes,ClipboardFormats,ClipboardModes,DataObject); ++} ++static FORCEINLINE HRESULT IInkDisp_CanPaste(IInkDisp* This,IDataObject *DataObject,VARIANT_BOOL *CanPaste) { ++ return This->lpVtbl->CanPaste(This,DataObject,CanPaste); ++} ++static FORCEINLINE HRESULT IInkDisp_ClipboardPaste(IInkDisp* This,LONG x,LONG y,IDataObject *DataObject,IInkStrokes **Strokes) { ++ return This->lpVtbl->ClipboardPaste(This,x,y,DataObject,Strokes); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkDisp_get_Strokes_Proxy( ++ IInkDisp* This, ++ IInkStrokes **Strokes); ++void __RPC_STUB IInkDisp_get_Strokes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_get_ExtendedProperties_Proxy( ++ IInkDisp* This, ++ IInkExtendedProperties **Properties); ++void __RPC_STUB IInkDisp_get_ExtendedProperties_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_get_Dirty_Proxy( ++ IInkDisp* This, ++ VARIANT_BOOL *Dirty); ++void __RPC_STUB IInkDisp_get_Dirty_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_put_Dirty_Proxy( ++ IInkDisp* This, ++ VARIANT_BOOL Dirty); ++void __RPC_STUB IInkDisp_put_Dirty_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_get_CustomStrokes_Proxy( ++ IInkDisp* This, ++ IInkCustomStrokes **ppunkInkCustomStrokes); ++void __RPC_STUB IInkDisp_get_CustomStrokes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_GetBoundingBox_Proxy( ++ IInkDisp* This, ++ InkBoundingBoxMode BoundingBoxMode, ++ IInkRectangle **Rectangle); ++void __RPC_STUB IInkDisp_GetBoundingBox_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_DeleteStrokes_Proxy( ++ IInkDisp* This, ++ IInkStrokes *Strokes); ++void __RPC_STUB IInkDisp_DeleteStrokes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_DeleteStroke_Proxy( ++ IInkDisp* This, ++ IInkStrokeDisp *Stroke); ++void __RPC_STUB IInkDisp_DeleteStroke_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_ExtractStrokes_Proxy( ++ IInkDisp* This, ++ IInkStrokes *Strokes, ++ InkExtractFlags ExtractFlags, ++ IInkDisp **ExtractedInk); ++void __RPC_STUB IInkDisp_ExtractStrokes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_ExtractWithRectangle_Proxy( ++ IInkDisp* This, ++ IInkRectangle *Rectangle, ++ InkExtractFlags extractFlags, ++ IInkDisp **ExtractedInk); ++void __RPC_STUB IInkDisp_ExtractWithRectangle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_Clip_Proxy( ++ IInkDisp* This, ++ IInkRectangle *Rectangle); ++void __RPC_STUB IInkDisp_Clip_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_Clone_Proxy( ++ IInkDisp* This, ++ IInkDisp **NewInk); ++void __RPC_STUB IInkDisp_Clone_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_HitTestCircle_Proxy( ++ IInkDisp* This, ++ LONG X, ++ LONG Y, ++ float radius, ++ IInkStrokes **Strokes); ++void __RPC_STUB IInkDisp_HitTestCircle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_HitTestWithRectangle_Proxy( ++ IInkDisp* This, ++ IInkRectangle *SelectionRectangle, ++ float IntersectPercent, ++ IInkStrokes **Strokes); ++void __RPC_STUB IInkDisp_HitTestWithRectangle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_HitTestWithLasso_Proxy( ++ IInkDisp* This, ++ VARIANT Points, ++ float IntersectPercent, ++ VARIANT *LassoPoints, ++ IInkStrokes **Strokes); ++void __RPC_STUB IInkDisp_HitTestWithLasso_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_NearestPoint_Proxy( ++ IInkDisp* This, ++ LONG X, ++ LONG Y, ++ float *PointOnStroke, ++ float *DistanceFromPacket, ++ IInkStrokeDisp **Stroke); ++void __RPC_STUB IInkDisp_NearestPoint_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_CreateStrokes_Proxy( ++ IInkDisp* This, ++ VARIANT StrokeIds, ++ IInkStrokes **Strokes); ++void __RPC_STUB IInkDisp_CreateStrokes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_AddStrokesAtRectangle_Proxy( ++ IInkDisp* This, ++ IInkStrokes *SourceStrokes, ++ IInkRectangle *TargetRectangle); ++void __RPC_STUB IInkDisp_AddStrokesAtRectangle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_Save_Proxy( ++ IInkDisp* This, ++ InkPersistenceFormat PersistenceFormat, ++ InkPersistenceCompressionMode CompressionMode, ++ VARIANT *Data); ++void __RPC_STUB IInkDisp_Save_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_Load_Proxy( ++ IInkDisp* This, ++ VARIANT Data); ++void __RPC_STUB IInkDisp_Load_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_CreateStroke_Proxy( ++ IInkDisp* This, ++ VARIANT PacketData, ++ VARIANT PacketDescription, ++ IInkStrokeDisp **Stroke); ++void __RPC_STUB IInkDisp_CreateStroke_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_ClipboardCopyWithRectangle_Proxy( ++ IInkDisp* This, ++ IInkRectangle *Rectangle, ++ InkClipboardFormats ClipboardFormats, ++ InkClipboardModes ClipboardModes, ++ IDataObject **DataObject); ++void __RPC_STUB IInkDisp_ClipboardCopyWithRectangle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_ClipboardCopy_Proxy( ++ IInkDisp* This, ++ IInkStrokes *strokes, ++ InkClipboardFormats ClipboardFormats, ++ InkClipboardModes ClipboardModes, ++ IDataObject **DataObject); ++void __RPC_STUB IInkDisp_ClipboardCopy_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_CanPaste_Proxy( ++ IInkDisp* This, ++ IDataObject *DataObject, ++ VARIANT_BOOL *CanPaste); ++void __RPC_STUB IInkDisp_CanPaste_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkDisp_ClipboardPaste_Proxy( ++ IInkDisp* This, ++ LONG x, ++ LONG y, ++ IDataObject *DataObject, ++ IInkStrokes **Strokes); ++void __RPC_STUB IInkDisp_ClipboardPaste_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkDisp_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkStrokes interface ++ */ ++#ifndef __IInkStrokes_INTERFACE_DEFINED__ ++#define __IInkStrokes_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkStrokes, 0xf1f4c9d8, 0x590a, 0x4963, 0xb3,0xae, 0x19,0x35,0x67,0x1b,0xb6,0xf3); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("f1f4c9d8-590a-4963-b3ae-1935671bb6f3") ++IInkStrokes : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Count( ++ LONG *Count) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get__NewEnum( ++ IUnknown **_NewEnum) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Ink( ++ IInkDisp **Ink) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_RecognitionResult( ++ IInkRecognitionResult **RecognitionResult) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ToString( ++ BSTR *ToString) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Item( ++ LONG Index, ++ IInkStrokeDisp **Stroke) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Add( ++ IInkStrokeDisp *InkStroke) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE AddStrokes( ++ IInkStrokes *InkStrokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Remove( ++ IInkStrokeDisp *InkStroke) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE RemoveStrokes( ++ IInkStrokes *InkStrokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ModifyDrawingAttributes( ++ IInkDrawingAttributes *DrawAttrs) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetBoundingBox( ++ InkBoundingBoxMode BoundingBoxMode, ++ IInkRectangle **BoundingBox) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Transform( ++ IInkTransform *Transform, ++ VARIANT_BOOL ApplyOnPenWidth = 0) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ScaleToRectangle( ++ IInkRectangle *Rectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Move( ++ float HorizontalComponent, ++ float VerticalComponent) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Rotate( ++ float Degrees, ++ float x = 0, ++ float y = 0) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Shear( ++ float HorizontalMultiplier, ++ float VerticalMultiplier) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ScaleTransform( ++ float HorizontalMultiplier, ++ float VerticalMultiplier) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Clip( ++ IInkRectangle *Rectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE RemoveRecognitionResult( ++ ) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkStrokes, 0xf1f4c9d8, 0x590a, 0x4963, 0xb3,0xae, 0x19,0x35,0x67,0x1b,0xb6,0xf3) ++#endif ++#else ++typedef struct IInkStrokesVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkStrokes* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkStrokes* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkStrokes* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkStrokes* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkStrokes* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkStrokes* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkStrokes* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkStrokes methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Count)( ++ IInkStrokes* This, ++ LONG *Count); ++ ++ HRESULT (STDMETHODCALLTYPE *get__NewEnum)( ++ IInkStrokes* This, ++ IUnknown **_NewEnum); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Ink)( ++ IInkStrokes* This, ++ IInkDisp **Ink); ++ ++ HRESULT (STDMETHODCALLTYPE *get_RecognitionResult)( ++ IInkStrokes* This, ++ IInkRecognitionResult **RecognitionResult); ++ ++ HRESULT (STDMETHODCALLTYPE *ToString)( ++ IInkStrokes* This, ++ BSTR *ToString); ++ ++ HRESULT (STDMETHODCALLTYPE *Item)( ++ IInkStrokes* This, ++ LONG Index, ++ IInkStrokeDisp **Stroke); ++ ++ HRESULT (STDMETHODCALLTYPE *Add)( ++ IInkStrokes* This, ++ IInkStrokeDisp *InkStroke); ++ ++ HRESULT (STDMETHODCALLTYPE *AddStrokes)( ++ IInkStrokes* This, ++ IInkStrokes *InkStrokes); ++ ++ HRESULT (STDMETHODCALLTYPE *Remove)( ++ IInkStrokes* This, ++ IInkStrokeDisp *InkStroke); ++ ++ HRESULT (STDMETHODCALLTYPE *RemoveStrokes)( ++ IInkStrokes* This, ++ IInkStrokes *InkStrokes); ++ ++ HRESULT (STDMETHODCALLTYPE *ModifyDrawingAttributes)( ++ IInkStrokes* This, ++ IInkDrawingAttributes *DrawAttrs); ++ ++ HRESULT (STDMETHODCALLTYPE *GetBoundingBox)( ++ IInkStrokes* This, ++ InkBoundingBoxMode BoundingBoxMode, ++ IInkRectangle **BoundingBox); ++ ++ HRESULT (STDMETHODCALLTYPE *Transform)( ++ IInkStrokes* This, ++ IInkTransform *Transform, ++ VARIANT_BOOL ApplyOnPenWidth); ++ ++ HRESULT (STDMETHODCALLTYPE *ScaleToRectangle)( ++ IInkStrokes* This, ++ IInkRectangle *Rectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *Move)( ++ IInkStrokes* This, ++ float HorizontalComponent, ++ float VerticalComponent); ++ ++ HRESULT (STDMETHODCALLTYPE *Rotate)( ++ IInkStrokes* This, ++ float Degrees, ++ float x, ++ float y); ++ ++ HRESULT (STDMETHODCALLTYPE *Shear)( ++ IInkStrokes* This, ++ float HorizontalMultiplier, ++ float VerticalMultiplier); ++ ++ HRESULT (STDMETHODCALLTYPE *ScaleTransform)( ++ IInkStrokes* This, ++ float HorizontalMultiplier, ++ float VerticalMultiplier); ++ ++ HRESULT (STDMETHODCALLTYPE *Clip)( ++ IInkStrokes* This, ++ IInkRectangle *Rectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *RemoveRecognitionResult)( ++ IInkStrokes* This); ++ ++ END_INTERFACE ++} IInkStrokesVtbl; ++interface IInkStrokes { ++ CONST_VTBL IInkStrokesVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkStrokes_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkStrokes_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkStrokes_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkStrokes_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkStrokes_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkStrokes_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkStrokes_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkStrokes methods ***/ ++#define IInkStrokes_get_Count(This,Count) (This)->lpVtbl->get_Count(This,Count) ++#define IInkStrokes_get__NewEnum(This,_NewEnum) (This)->lpVtbl->get__NewEnum(This,_NewEnum) ++#define IInkStrokes_get_Ink(This,Ink) (This)->lpVtbl->get_Ink(This,Ink) ++#define IInkStrokes_get_RecognitionResult(This,RecognitionResult) (This)->lpVtbl->get_RecognitionResult(This,RecognitionResult) ++#define IInkStrokes_ToString(This,ToString) (This)->lpVtbl->ToString(This,ToString) ++#define IInkStrokes_Item(This,Index,Stroke) (This)->lpVtbl->Item(This,Index,Stroke) ++#define IInkStrokes_Add(This,InkStroke) (This)->lpVtbl->Add(This,InkStroke) ++#define IInkStrokes_AddStrokes(This,InkStrokes) (This)->lpVtbl->AddStrokes(This,InkStrokes) ++#define IInkStrokes_Remove(This,InkStroke) (This)->lpVtbl->Remove(This,InkStroke) ++#define IInkStrokes_RemoveStrokes(This,InkStrokes) (This)->lpVtbl->RemoveStrokes(This,InkStrokes) ++#define IInkStrokes_ModifyDrawingAttributes(This,DrawAttrs) (This)->lpVtbl->ModifyDrawingAttributes(This,DrawAttrs) ++#define IInkStrokes_GetBoundingBox(This,BoundingBoxMode,BoundingBox) (This)->lpVtbl->GetBoundingBox(This,BoundingBoxMode,BoundingBox) ++#define IInkStrokes_Transform(This,Transform,ApplyOnPenWidth) (This)->lpVtbl->Transform(This,Transform,ApplyOnPenWidth) ++#define IInkStrokes_ScaleToRectangle(This,Rectangle) (This)->lpVtbl->ScaleToRectangle(This,Rectangle) ++#define IInkStrokes_Move(This,HorizontalComponent,VerticalComponent) (This)->lpVtbl->Move(This,HorizontalComponent,VerticalComponent) ++#define IInkStrokes_Rotate(This,Degrees,x,y) (This)->lpVtbl->Rotate(This,Degrees,x,y) ++#define IInkStrokes_Shear(This,HorizontalMultiplier,VerticalMultiplier) (This)->lpVtbl->Shear(This,HorizontalMultiplier,VerticalMultiplier) ++#define IInkStrokes_ScaleTransform(This,HorizontalMultiplier,VerticalMultiplier) (This)->lpVtbl->ScaleTransform(This,HorizontalMultiplier,VerticalMultiplier) ++#define IInkStrokes_Clip(This,Rectangle) (This)->lpVtbl->Clip(This,Rectangle) ++#define IInkStrokes_RemoveRecognitionResult(This) (This)->lpVtbl->RemoveRecognitionResult(This) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkStrokes_QueryInterface(IInkStrokes* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkStrokes_AddRef(IInkStrokes* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkStrokes_Release(IInkStrokes* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkStrokes_GetTypeInfoCount(IInkStrokes* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkStrokes_GetTypeInfo(IInkStrokes* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkStrokes_GetIDsOfNames(IInkStrokes* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkStrokes_Invoke(IInkStrokes* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkStrokes methods ***/ ++static FORCEINLINE HRESULT IInkStrokes_get_Count(IInkStrokes* This,LONG *Count) { ++ return This->lpVtbl->get_Count(This,Count); ++} ++static FORCEINLINE HRESULT IInkStrokes_get__NewEnum(IInkStrokes* This,IUnknown **_NewEnum) { ++ return This->lpVtbl->get__NewEnum(This,_NewEnum); ++} ++static FORCEINLINE HRESULT IInkStrokes_get_Ink(IInkStrokes* This,IInkDisp **Ink) { ++ return This->lpVtbl->get_Ink(This,Ink); ++} ++static FORCEINLINE HRESULT IInkStrokes_get_RecognitionResult(IInkStrokes* This,IInkRecognitionResult **RecognitionResult) { ++ return This->lpVtbl->get_RecognitionResult(This,RecognitionResult); ++} ++static FORCEINLINE HRESULT IInkStrokes_ToString(IInkStrokes* This,BSTR *ToString) { ++ return This->lpVtbl->ToString(This,ToString); ++} ++static FORCEINLINE HRESULT IInkStrokes_Item(IInkStrokes* This,LONG Index,IInkStrokeDisp **Stroke) { ++ return This->lpVtbl->Item(This,Index,Stroke); ++} ++static FORCEINLINE HRESULT IInkStrokes_Add(IInkStrokes* This,IInkStrokeDisp *InkStroke) { ++ return This->lpVtbl->Add(This,InkStroke); ++} ++static FORCEINLINE HRESULT IInkStrokes_AddStrokes(IInkStrokes* This,IInkStrokes *InkStrokes) { ++ return This->lpVtbl->AddStrokes(This,InkStrokes); ++} ++static FORCEINLINE HRESULT IInkStrokes_Remove(IInkStrokes* This,IInkStrokeDisp *InkStroke) { ++ return This->lpVtbl->Remove(This,InkStroke); ++} ++static FORCEINLINE HRESULT IInkStrokes_RemoveStrokes(IInkStrokes* This,IInkStrokes *InkStrokes) { ++ return This->lpVtbl->RemoveStrokes(This,InkStrokes); ++} ++static FORCEINLINE HRESULT IInkStrokes_ModifyDrawingAttributes(IInkStrokes* This,IInkDrawingAttributes *DrawAttrs) { ++ return This->lpVtbl->ModifyDrawingAttributes(This,DrawAttrs); ++} ++static FORCEINLINE HRESULT IInkStrokes_GetBoundingBox(IInkStrokes* This,InkBoundingBoxMode BoundingBoxMode,IInkRectangle **BoundingBox) { ++ return This->lpVtbl->GetBoundingBox(This,BoundingBoxMode,BoundingBox); ++} ++static FORCEINLINE HRESULT IInkStrokes_Transform(IInkStrokes* This,IInkTransform *Transform,VARIANT_BOOL ApplyOnPenWidth) { ++ return This->lpVtbl->Transform(This,Transform,ApplyOnPenWidth); ++} ++static FORCEINLINE HRESULT IInkStrokes_ScaleToRectangle(IInkStrokes* This,IInkRectangle *Rectangle) { ++ return This->lpVtbl->ScaleToRectangle(This,Rectangle); ++} ++static FORCEINLINE HRESULT IInkStrokes_Move(IInkStrokes* This,float HorizontalComponent,float VerticalComponent) { ++ return This->lpVtbl->Move(This,HorizontalComponent,VerticalComponent); ++} ++static FORCEINLINE HRESULT IInkStrokes_Rotate(IInkStrokes* This,float Degrees,float x,float y) { ++ return This->lpVtbl->Rotate(This,Degrees,x,y); ++} ++static FORCEINLINE HRESULT IInkStrokes_Shear(IInkStrokes* This,float HorizontalMultiplier,float VerticalMultiplier) { ++ return This->lpVtbl->Shear(This,HorizontalMultiplier,VerticalMultiplier); ++} ++static FORCEINLINE HRESULT IInkStrokes_ScaleTransform(IInkStrokes* This,float HorizontalMultiplier,float VerticalMultiplier) { ++ return This->lpVtbl->ScaleTransform(This,HorizontalMultiplier,VerticalMultiplier); ++} ++static FORCEINLINE HRESULT IInkStrokes_Clip(IInkStrokes* This,IInkRectangle *Rectangle) { ++ return This->lpVtbl->Clip(This,Rectangle); ++} ++static FORCEINLINE HRESULT IInkStrokes_RemoveRecognitionResult(IInkStrokes* This) { ++ return This->lpVtbl->RemoveRecognitionResult(This); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkStrokes_get_Count_Proxy( ++ IInkStrokes* This, ++ LONG *Count); ++void __RPC_STUB IInkStrokes_get_Count_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_get__NewEnum_Proxy( ++ IInkStrokes* This, ++ IUnknown **_NewEnum); ++void __RPC_STUB IInkStrokes_get__NewEnum_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_get_Ink_Proxy( ++ IInkStrokes* This, ++ IInkDisp **Ink); ++void __RPC_STUB IInkStrokes_get_Ink_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_get_RecognitionResult_Proxy( ++ IInkStrokes* This, ++ IInkRecognitionResult **RecognitionResult); ++void __RPC_STUB IInkStrokes_get_RecognitionResult_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_ToString_Proxy( ++ IInkStrokes* This, ++ BSTR *ToString); ++void __RPC_STUB IInkStrokes_ToString_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_Item_Proxy( ++ IInkStrokes* This, ++ LONG Index, ++ IInkStrokeDisp **Stroke); ++void __RPC_STUB IInkStrokes_Item_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_Add_Proxy( ++ IInkStrokes* This, ++ IInkStrokeDisp *InkStroke); ++void __RPC_STUB IInkStrokes_Add_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_AddStrokes_Proxy( ++ IInkStrokes* This, ++ IInkStrokes *InkStrokes); ++void __RPC_STUB IInkStrokes_AddStrokes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_Remove_Proxy( ++ IInkStrokes* This, ++ IInkStrokeDisp *InkStroke); ++void __RPC_STUB IInkStrokes_Remove_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_RemoveStrokes_Proxy( ++ IInkStrokes* This, ++ IInkStrokes *InkStrokes); ++void __RPC_STUB IInkStrokes_RemoveStrokes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_ModifyDrawingAttributes_Proxy( ++ IInkStrokes* This, ++ IInkDrawingAttributes *DrawAttrs); ++void __RPC_STUB IInkStrokes_ModifyDrawingAttributes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_GetBoundingBox_Proxy( ++ IInkStrokes* This, ++ InkBoundingBoxMode BoundingBoxMode, ++ IInkRectangle **BoundingBox); ++void __RPC_STUB IInkStrokes_GetBoundingBox_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_Transform_Proxy( ++ IInkStrokes* This, ++ IInkTransform *Transform, ++ VARIANT_BOOL ApplyOnPenWidth); ++void __RPC_STUB IInkStrokes_Transform_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_ScaleToRectangle_Proxy( ++ IInkStrokes* This, ++ IInkRectangle *Rectangle); ++void __RPC_STUB IInkStrokes_ScaleToRectangle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_Move_Proxy( ++ IInkStrokes* This, ++ float HorizontalComponent, ++ float VerticalComponent); ++void __RPC_STUB IInkStrokes_Move_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_Rotate_Proxy( ++ IInkStrokes* This, ++ float Degrees, ++ float x, ++ float y); ++void __RPC_STUB IInkStrokes_Rotate_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_Shear_Proxy( ++ IInkStrokes* This, ++ float HorizontalMultiplier, ++ float VerticalMultiplier); ++void __RPC_STUB IInkStrokes_Shear_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_ScaleTransform_Proxy( ++ IInkStrokes* This, ++ float HorizontalMultiplier, ++ float VerticalMultiplier); ++void __RPC_STUB IInkStrokes_ScaleTransform_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_Clip_Proxy( ++ IInkStrokes* This, ++ IInkRectangle *Rectangle); ++void __RPC_STUB IInkStrokes_Clip_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkStrokes_RemoveRecognitionResult_Proxy( ++ IInkStrokes* This); ++void __RPC_STUB IInkStrokes_RemoveRecognitionResult_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkStrokes_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkRenderer interface ++ */ ++#ifndef __IInkRenderer_INTERFACE_DEFINED__ ++#define __IInkRenderer_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkRenderer, 0xe6257a9c, 0xb511, 0x4f4c, 0xa8,0xb0, 0xa7,0xdb,0xc9,0x50,0x6b,0x83); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("e6257a9c-b511-4f4c-a8b0-a7dbc9506b83") ++IInkRenderer : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE GetViewTransform( ++ IInkTransform *ViewTransform) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE SetViewTransform( ++ IInkTransform *ViewTransform) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetObjectTransform( ++ IInkTransform *ObjectTransform) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE SetObjectTransform( ++ IInkTransform *ObjectTransform) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Draw( ++ LONG_PTR hDC, ++ IInkStrokes *Strokes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE DrawStroke( ++ LONG_PTR hDC, ++ IInkStrokeDisp *Stroke, ++ IInkDrawingAttributes *DrawingAttributes = 0) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE PixelToInkSpace( ++ LONG_PTR hDC, ++ LONG *x, ++ LONG *y) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE InkSpaceToPixel( ++ LONG_PTR hdcDisplay, ++ LONG *x, ++ LONG *y) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE PixelToInkSpaceFromPoints( ++ LONG_PTR hDC, ++ VARIANT *Points) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE InkSpaceToPixelFromPoints( ++ LONG_PTR hDC, ++ VARIANT *Points) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Measure( ++ IInkStrokes *Strokes, ++ IInkRectangle **Rectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE MeasureStroke( ++ IInkStrokeDisp *Stroke, ++ IInkDrawingAttributes *DrawingAttributes, ++ IInkRectangle **Rectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Move( ++ float HorizontalComponent, ++ float VerticalComponent) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Rotate( ++ float Degrees, ++ float x = 0, ++ float y = 0) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE ScaleTransform( ++ float HorizontalMultiplier, ++ float VerticalMultiplier, ++ VARIANT_BOOL ApplyOnPenWidth = -1) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkRenderer, 0xe6257a9c, 0xb511, 0x4f4c, 0xa8,0xb0, 0xa7,0xdb,0xc9,0x50,0x6b,0x83) ++#endif ++#else ++typedef struct IInkRendererVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkRenderer* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkRenderer* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkRenderer* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkRenderer* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkRenderer* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkRenderer* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkRenderer* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkRenderer methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetViewTransform)( ++ IInkRenderer* This, ++ IInkTransform *ViewTransform); ++ ++ HRESULT (STDMETHODCALLTYPE *SetViewTransform)( ++ IInkRenderer* This, ++ IInkTransform *ViewTransform); ++ ++ HRESULT (STDMETHODCALLTYPE *GetObjectTransform)( ++ IInkRenderer* This, ++ IInkTransform *ObjectTransform); ++ ++ HRESULT (STDMETHODCALLTYPE *SetObjectTransform)( ++ IInkRenderer* This, ++ IInkTransform *ObjectTransform); ++ ++ HRESULT (STDMETHODCALLTYPE *Draw)( ++ IInkRenderer* This, ++ LONG_PTR hDC, ++ IInkStrokes *Strokes); ++ ++ HRESULT (STDMETHODCALLTYPE *DrawStroke)( ++ IInkRenderer* This, ++ LONG_PTR hDC, ++ IInkStrokeDisp *Stroke, ++ IInkDrawingAttributes *DrawingAttributes); ++ ++ HRESULT (STDMETHODCALLTYPE *PixelToInkSpace)( ++ IInkRenderer* This, ++ LONG_PTR hDC, ++ LONG *x, ++ LONG *y); ++ ++ HRESULT (STDMETHODCALLTYPE *InkSpaceToPixel)( ++ IInkRenderer* This, ++ LONG_PTR hdcDisplay, ++ LONG *x, ++ LONG *y); ++ ++ HRESULT (STDMETHODCALLTYPE *PixelToInkSpaceFromPoints)( ++ IInkRenderer* This, ++ LONG_PTR hDC, ++ VARIANT *Points); ++ ++ HRESULT (STDMETHODCALLTYPE *InkSpaceToPixelFromPoints)( ++ IInkRenderer* This, ++ LONG_PTR hDC, ++ VARIANT *Points); ++ ++ HRESULT (STDMETHODCALLTYPE *Measure)( ++ IInkRenderer* This, ++ IInkStrokes *Strokes, ++ IInkRectangle **Rectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *MeasureStroke)( ++ IInkRenderer* This, ++ IInkStrokeDisp *Stroke, ++ IInkDrawingAttributes *DrawingAttributes, ++ IInkRectangle **Rectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *Move)( ++ IInkRenderer* This, ++ float HorizontalComponent, ++ float VerticalComponent); ++ ++ HRESULT (STDMETHODCALLTYPE *Rotate)( ++ IInkRenderer* This, ++ float Degrees, ++ float x, ++ float y); ++ ++ HRESULT (STDMETHODCALLTYPE *ScaleTransform)( ++ IInkRenderer* This, ++ float HorizontalMultiplier, ++ float VerticalMultiplier, ++ VARIANT_BOOL ApplyOnPenWidth); ++ ++ END_INTERFACE ++} IInkRendererVtbl; ++interface IInkRenderer { ++ CONST_VTBL IInkRendererVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkRenderer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkRenderer_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkRenderer_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkRenderer_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkRenderer_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkRenderer_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkRenderer_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkRenderer methods ***/ ++#define IInkRenderer_GetViewTransform(This,ViewTransform) (This)->lpVtbl->GetViewTransform(This,ViewTransform) ++#define IInkRenderer_SetViewTransform(This,ViewTransform) (This)->lpVtbl->SetViewTransform(This,ViewTransform) ++#define IInkRenderer_GetObjectTransform(This,ObjectTransform) (This)->lpVtbl->GetObjectTransform(This,ObjectTransform) ++#define IInkRenderer_SetObjectTransform(This,ObjectTransform) (This)->lpVtbl->SetObjectTransform(This,ObjectTransform) ++#define IInkRenderer_Draw(This,hDC,Strokes) (This)->lpVtbl->Draw(This,hDC,Strokes) ++#define IInkRenderer_DrawStroke(This,hDC,Stroke,DrawingAttributes) (This)->lpVtbl->DrawStroke(This,hDC,Stroke,DrawingAttributes) ++#define IInkRenderer_PixelToInkSpace(This,hDC,x,y) (This)->lpVtbl->PixelToInkSpace(This,hDC,x,y) ++#define IInkRenderer_InkSpaceToPixel(This,hdcDisplay,x,y) (This)->lpVtbl->InkSpaceToPixel(This,hdcDisplay,x,y) ++#define IInkRenderer_PixelToInkSpaceFromPoints(This,hDC,Points) (This)->lpVtbl->PixelToInkSpaceFromPoints(This,hDC,Points) ++#define IInkRenderer_InkSpaceToPixelFromPoints(This,hDC,Points) (This)->lpVtbl->InkSpaceToPixelFromPoints(This,hDC,Points) ++#define IInkRenderer_Measure(This,Strokes,Rectangle) (This)->lpVtbl->Measure(This,Strokes,Rectangle) ++#define IInkRenderer_MeasureStroke(This,Stroke,DrawingAttributes,Rectangle) (This)->lpVtbl->MeasureStroke(This,Stroke,DrawingAttributes,Rectangle) ++#define IInkRenderer_Move(This,HorizontalComponent,VerticalComponent) (This)->lpVtbl->Move(This,HorizontalComponent,VerticalComponent) ++#define IInkRenderer_Rotate(This,Degrees,x,y) (This)->lpVtbl->Rotate(This,Degrees,x,y) ++#define IInkRenderer_ScaleTransform(This,HorizontalMultiplier,VerticalMultiplier,ApplyOnPenWidth) (This)->lpVtbl->ScaleTransform(This,HorizontalMultiplier,VerticalMultiplier,ApplyOnPenWidth) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkRenderer_QueryInterface(IInkRenderer* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkRenderer_AddRef(IInkRenderer* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkRenderer_Release(IInkRenderer* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkRenderer_GetTypeInfoCount(IInkRenderer* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkRenderer_GetTypeInfo(IInkRenderer* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkRenderer_GetIDsOfNames(IInkRenderer* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkRenderer_Invoke(IInkRenderer* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkRenderer methods ***/ ++static FORCEINLINE HRESULT IInkRenderer_GetViewTransform(IInkRenderer* This,IInkTransform *ViewTransform) { ++ return This->lpVtbl->GetViewTransform(This,ViewTransform); ++} ++static FORCEINLINE HRESULT IInkRenderer_SetViewTransform(IInkRenderer* This,IInkTransform *ViewTransform) { ++ return This->lpVtbl->SetViewTransform(This,ViewTransform); ++} ++static FORCEINLINE HRESULT IInkRenderer_GetObjectTransform(IInkRenderer* This,IInkTransform *ObjectTransform) { ++ return This->lpVtbl->GetObjectTransform(This,ObjectTransform); ++} ++static FORCEINLINE HRESULT IInkRenderer_SetObjectTransform(IInkRenderer* This,IInkTransform *ObjectTransform) { ++ return This->lpVtbl->SetObjectTransform(This,ObjectTransform); ++} ++static FORCEINLINE HRESULT IInkRenderer_Draw(IInkRenderer* This,LONG_PTR hDC,IInkStrokes *Strokes) { ++ return This->lpVtbl->Draw(This,hDC,Strokes); ++} ++static FORCEINLINE HRESULT IInkRenderer_DrawStroke(IInkRenderer* This,LONG_PTR hDC,IInkStrokeDisp *Stroke,IInkDrawingAttributes *DrawingAttributes) { ++ return This->lpVtbl->DrawStroke(This,hDC,Stroke,DrawingAttributes); ++} ++static FORCEINLINE HRESULT IInkRenderer_PixelToInkSpace(IInkRenderer* This,LONG_PTR hDC,LONG *x,LONG *y) { ++ return This->lpVtbl->PixelToInkSpace(This,hDC,x,y); ++} ++static FORCEINLINE HRESULT IInkRenderer_InkSpaceToPixel(IInkRenderer* This,LONG_PTR hdcDisplay,LONG *x,LONG *y) { ++ return This->lpVtbl->InkSpaceToPixel(This,hdcDisplay,x,y); ++} ++static FORCEINLINE HRESULT IInkRenderer_PixelToInkSpaceFromPoints(IInkRenderer* This,LONG_PTR hDC,VARIANT *Points) { ++ return This->lpVtbl->PixelToInkSpaceFromPoints(This,hDC,Points); ++} ++static FORCEINLINE HRESULT IInkRenderer_InkSpaceToPixelFromPoints(IInkRenderer* This,LONG_PTR hDC,VARIANT *Points) { ++ return This->lpVtbl->InkSpaceToPixelFromPoints(This,hDC,Points); ++} ++static FORCEINLINE HRESULT IInkRenderer_Measure(IInkRenderer* This,IInkStrokes *Strokes,IInkRectangle **Rectangle) { ++ return This->lpVtbl->Measure(This,Strokes,Rectangle); ++} ++static FORCEINLINE HRESULT IInkRenderer_MeasureStroke(IInkRenderer* This,IInkStrokeDisp *Stroke,IInkDrawingAttributes *DrawingAttributes,IInkRectangle **Rectangle) { ++ return This->lpVtbl->MeasureStroke(This,Stroke,DrawingAttributes,Rectangle); ++} ++static FORCEINLINE HRESULT IInkRenderer_Move(IInkRenderer* This,float HorizontalComponent,float VerticalComponent) { ++ return This->lpVtbl->Move(This,HorizontalComponent,VerticalComponent); ++} ++static FORCEINLINE HRESULT IInkRenderer_Rotate(IInkRenderer* This,float Degrees,float x,float y) { ++ return This->lpVtbl->Rotate(This,Degrees,x,y); ++} ++static FORCEINLINE HRESULT IInkRenderer_ScaleTransform(IInkRenderer* This,float HorizontalMultiplier,float VerticalMultiplier,VARIANT_BOOL ApplyOnPenWidth) { ++ return This->lpVtbl->ScaleTransform(This,HorizontalMultiplier,VerticalMultiplier,ApplyOnPenWidth); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkRenderer_GetViewTransform_Proxy( ++ IInkRenderer* This, ++ IInkTransform *ViewTransform); ++void __RPC_STUB IInkRenderer_GetViewTransform_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_SetViewTransform_Proxy( ++ IInkRenderer* This, ++ IInkTransform *ViewTransform); ++void __RPC_STUB IInkRenderer_SetViewTransform_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_GetObjectTransform_Proxy( ++ IInkRenderer* This, ++ IInkTransform *ObjectTransform); ++void __RPC_STUB IInkRenderer_GetObjectTransform_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_SetObjectTransform_Proxy( ++ IInkRenderer* This, ++ IInkTransform *ObjectTransform); ++void __RPC_STUB IInkRenderer_SetObjectTransform_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_Draw_Proxy( ++ IInkRenderer* This, ++ LONG_PTR hDC, ++ IInkStrokes *Strokes); ++void __RPC_STUB IInkRenderer_Draw_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_DrawStroke_Proxy( ++ IInkRenderer* This, ++ LONG_PTR hDC, ++ IInkStrokeDisp *Stroke, ++ IInkDrawingAttributes *DrawingAttributes); ++void __RPC_STUB IInkRenderer_DrawStroke_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_PixelToInkSpace_Proxy( ++ IInkRenderer* This, ++ LONG_PTR hDC, ++ LONG *x, ++ LONG *y); ++void __RPC_STUB IInkRenderer_PixelToInkSpace_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_InkSpaceToPixel_Proxy( ++ IInkRenderer* This, ++ LONG_PTR hdcDisplay, ++ LONG *x, ++ LONG *y); ++void __RPC_STUB IInkRenderer_InkSpaceToPixel_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_PixelToInkSpaceFromPoints_Proxy( ++ IInkRenderer* This, ++ LONG_PTR hDC, ++ VARIANT *Points); ++void __RPC_STUB IInkRenderer_PixelToInkSpaceFromPoints_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_InkSpaceToPixelFromPoints_Proxy( ++ IInkRenderer* This, ++ LONG_PTR hDC, ++ VARIANT *Points); ++void __RPC_STUB IInkRenderer_InkSpaceToPixelFromPoints_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_Measure_Proxy( ++ IInkRenderer* This, ++ IInkStrokes *Strokes, ++ IInkRectangle **Rectangle); ++void __RPC_STUB IInkRenderer_Measure_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_MeasureStroke_Proxy( ++ IInkRenderer* This, ++ IInkStrokeDisp *Stroke, ++ IInkDrawingAttributes *DrawingAttributes, ++ IInkRectangle **Rectangle); ++void __RPC_STUB IInkRenderer_MeasureStroke_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_Move_Proxy( ++ IInkRenderer* This, ++ float HorizontalComponent, ++ float VerticalComponent); ++void __RPC_STUB IInkRenderer_Move_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_Rotate_Proxy( ++ IInkRenderer* This, ++ float Degrees, ++ float x, ++ float y); ++void __RPC_STUB IInkRenderer_Rotate_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkRenderer_ScaleTransform_Proxy( ++ IInkRenderer* This, ++ float HorizontalMultiplier, ++ float VerticalMultiplier, ++ VARIANT_BOOL ApplyOnPenWidth); ++void __RPC_STUB IInkRenderer_ScaleTransform_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkRenderer_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkCursors interface ++ */ ++#ifndef __IInkCursors_INTERFACE_DEFINED__ ++#define __IInkCursors_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkCursors, 0xa248c1ac, 0xc698, 0x4e06, 0x9e,0x5c, 0xd5,0x7f,0x77,0xc7,0xe6,0x47); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("a248c1ac-c698-4e06-9e5c-d57f77c7e647") ++IInkCursors : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_Count( ++ LONG *Count) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get__NewEnum( ++ IUnknown **_NewEnum) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE Item( ++ LONG Index, ++ IInkCursor **Cursor) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkCursors, 0xa248c1ac, 0xc698, 0x4e06, 0x9e,0x5c, 0xd5,0x7f,0x77,0xc7,0xe6,0x47) ++#endif ++#else ++typedef struct IInkCursorsVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkCursors* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkCursors* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkCursors* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkCursors* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkCursors* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkCursors* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkCursors* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkCursors methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_Count)( ++ IInkCursors* This, ++ LONG *Count); ++ ++ HRESULT (STDMETHODCALLTYPE *get__NewEnum)( ++ IInkCursors* This, ++ IUnknown **_NewEnum); ++ ++ HRESULT (STDMETHODCALLTYPE *Item)( ++ IInkCursors* This, ++ LONG Index, ++ IInkCursor **Cursor); ++ ++ END_INTERFACE ++} IInkCursorsVtbl; ++interface IInkCursors { ++ CONST_VTBL IInkCursorsVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkCursors_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkCursors_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkCursors_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkCursors_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkCursors_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkCursors_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkCursors_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkCursors methods ***/ ++#define IInkCursors_get_Count(This,Count) (This)->lpVtbl->get_Count(This,Count) ++#define IInkCursors_get__NewEnum(This,_NewEnum) (This)->lpVtbl->get__NewEnum(This,_NewEnum) ++#define IInkCursors_Item(This,Index,Cursor) (This)->lpVtbl->Item(This,Index,Cursor) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkCursors_QueryInterface(IInkCursors* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkCursors_AddRef(IInkCursors* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkCursors_Release(IInkCursors* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkCursors_GetTypeInfoCount(IInkCursors* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkCursors_GetTypeInfo(IInkCursors* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkCursors_GetIDsOfNames(IInkCursors* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkCursors_Invoke(IInkCursors* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkCursors methods ***/ ++static FORCEINLINE HRESULT IInkCursors_get_Count(IInkCursors* This,LONG *Count) { ++ return This->lpVtbl->get_Count(This,Count); ++} ++static FORCEINLINE HRESULT IInkCursors_get__NewEnum(IInkCursors* This,IUnknown **_NewEnum) { ++ return This->lpVtbl->get__NewEnum(This,_NewEnum); ++} ++static FORCEINLINE HRESULT IInkCursors_Item(IInkCursors* This,LONG Index,IInkCursor **Cursor) { ++ return This->lpVtbl->Item(This,Index,Cursor); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkCursors_get_Count_Proxy( ++ IInkCursors* This, ++ LONG *Count); ++void __RPC_STUB IInkCursors_get_Count_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCursors_get__NewEnum_Proxy( ++ IInkCursors* This, ++ IUnknown **_NewEnum); ++void __RPC_STUB IInkCursors_get__NewEnum_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCursors_Item_Proxy( ++ IInkCursors* This, ++ LONG Index, ++ IInkCursor **Cursor); ++void __RPC_STUB IInkCursors_Item_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkCursors_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IInkCollector interface ++ */ ++#ifndef __IInkCollector_INTERFACE_DEFINED__ ++#define __IInkCollector_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IInkCollector, 0xf0f060b5, 0x8b1f, 0x4a7c, 0x89,0xec, 0x88,0x06,0x92,0x58,0x8a,0x4f); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("f0f060b5-8b1f-4a7c-89ec-880692588a4f") ++IInkCollector : public IDispatch ++{ ++ virtual HRESULT STDMETHODCALLTYPE get_hWnd( ++ LONG_PTR *CurrentWindow) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_hWnd( ++ LONG_PTR NewWindow) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Enabled( ++ VARIANT_BOOL *Collecting) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_Enabled( ++ VARIANT_BOOL Collecting) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_DefaultDrawingAttributes( ++ IInkDrawingAttributes **CurrentAttributes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE putref_DefaultDrawingAttributes( ++ IInkDrawingAttributes *NewAttributes) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Renderer( ++ IInkRenderer **CurrentInkRenderer) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE putref_Renderer( ++ IInkRenderer *NewInkRenderer) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Ink( ++ IInkDisp **Ink) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE putref_Ink( ++ IInkDisp *NewInk) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_AutoRedraw( ++ VARIANT_BOOL *AutoRedraw) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_AutoRedraw( ++ VARIANT_BOOL AutoRedraw) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_CollectingInk( ++ VARIANT_BOOL *Collecting) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_CollectionMode( ++ InkCollectionMode *Mode) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_CollectionMode( ++ InkCollectionMode Mode) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_DynamicRendering( ++ VARIANT_BOOL *Enabled) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_DynamicRendering( ++ VARIANT_BOOL Enabled) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_DesiredPacketDescription( ++ VARIANT *PacketGuids) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_DesiredPacketDescription( ++ VARIANT PacketGuids) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_MouseIcon( ++ IPictureDisp **MouseIcon) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_MouseIcon( ++ IPictureDisp *MouseIcon) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE putref_MouseIcon( ++ IPictureDisp *MouseIcon) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_MousePointer( ++ InkMousePointer *MousePointer) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_MousePointer( ++ InkMousePointer MousePointer) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Cursors( ++ IInkCursors **Cursors) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_MarginX( ++ LONG *MarginX) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_MarginX( ++ LONG MarginX) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_MarginY( ++ LONG *MarginY) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_MarginY( ++ LONG MarginY) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_Tablet( ++ IInkTablet **SingleTablet) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE get_SupportHighContrastInk( ++ VARIANT_BOOL *Support) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE put_SupportHighContrastInk( ++ VARIANT_BOOL Support) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE SetGestureStatus( ++ InkApplicationGesture Gesture, ++ VARIANT_BOOL Listen) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetGestureStatus( ++ InkApplicationGesture Gesture, ++ VARIANT_BOOL *Listening) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetWindowInputRectangle( ++ IInkRectangle **WindowInputRectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE SetWindowInputRectangle( ++ IInkRectangle *WindowInputRectangle) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE SetAllTabletsMode( ++ VARIANT_BOOL UseMouseForInput = -1) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE SetSingleTabletIntegratedMode( ++ IInkTablet *Tablet) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE GetEventInterest( ++ InkCollectorEventInterest EventId, ++ VARIANT_BOOL *Listen) = 0; ++ ++ virtual HRESULT STDMETHODCALLTYPE SetEventInterest( ++ InkCollectorEventInterest EventId, ++ VARIANT_BOOL Listen) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IInkCollector, 0xf0f060b5, 0x8b1f, 0x4a7c, 0x89,0xec, 0x88,0x06,0x92,0x58,0x8a,0x4f) ++#endif ++#else ++typedef struct IInkCollectorVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IInkCollector* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IInkCollector* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IInkCollector* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ IInkCollector* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ IInkCollector* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ IInkCollector* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ IInkCollector* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ /*** IInkCollector methods ***/ ++ HRESULT (STDMETHODCALLTYPE *get_hWnd)( ++ IInkCollector* This, ++ LONG_PTR *CurrentWindow); ++ ++ HRESULT (STDMETHODCALLTYPE *put_hWnd)( ++ IInkCollector* This, ++ LONG_PTR NewWindow); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Enabled)( ++ IInkCollector* This, ++ VARIANT_BOOL *Collecting); ++ ++ HRESULT (STDMETHODCALLTYPE *put_Enabled)( ++ IInkCollector* This, ++ VARIANT_BOOL Collecting); ++ ++ HRESULT (STDMETHODCALLTYPE *get_DefaultDrawingAttributes)( ++ IInkCollector* This, ++ IInkDrawingAttributes **CurrentAttributes); ++ ++ HRESULT (STDMETHODCALLTYPE *putref_DefaultDrawingAttributes)( ++ IInkCollector* This, ++ IInkDrawingAttributes *NewAttributes); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Renderer)( ++ IInkCollector* This, ++ IInkRenderer **CurrentInkRenderer); ++ ++ HRESULT (STDMETHODCALLTYPE *putref_Renderer)( ++ IInkCollector* This, ++ IInkRenderer *NewInkRenderer); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Ink)( ++ IInkCollector* This, ++ IInkDisp **Ink); ++ ++ HRESULT (STDMETHODCALLTYPE *putref_Ink)( ++ IInkCollector* This, ++ IInkDisp *NewInk); ++ ++ HRESULT (STDMETHODCALLTYPE *get_AutoRedraw)( ++ IInkCollector* This, ++ VARIANT_BOOL *AutoRedraw); ++ ++ HRESULT (STDMETHODCALLTYPE *put_AutoRedraw)( ++ IInkCollector* This, ++ VARIANT_BOOL AutoRedraw); ++ ++ HRESULT (STDMETHODCALLTYPE *get_CollectingInk)( ++ IInkCollector* This, ++ VARIANT_BOOL *Collecting); ++ ++ HRESULT (STDMETHODCALLTYPE *get_CollectionMode)( ++ IInkCollector* This, ++ InkCollectionMode *Mode); ++ ++ HRESULT (STDMETHODCALLTYPE *put_CollectionMode)( ++ IInkCollector* This, ++ InkCollectionMode Mode); ++ ++ HRESULT (STDMETHODCALLTYPE *get_DynamicRendering)( ++ IInkCollector* This, ++ VARIANT_BOOL *Enabled); ++ ++ HRESULT (STDMETHODCALLTYPE *put_DynamicRendering)( ++ IInkCollector* This, ++ VARIANT_BOOL Enabled); ++ ++ HRESULT (STDMETHODCALLTYPE *get_DesiredPacketDescription)( ++ IInkCollector* This, ++ VARIANT *PacketGuids); ++ ++ HRESULT (STDMETHODCALLTYPE *put_DesiredPacketDescription)( ++ IInkCollector* This, ++ VARIANT PacketGuids); ++ ++ HRESULT (STDMETHODCALLTYPE *get_MouseIcon)( ++ IInkCollector* This, ++ IPictureDisp **MouseIcon); ++ ++ HRESULT (STDMETHODCALLTYPE *put_MouseIcon)( ++ IInkCollector* This, ++ IPictureDisp *MouseIcon); ++ ++ HRESULT (STDMETHODCALLTYPE *putref_MouseIcon)( ++ IInkCollector* This, ++ IPictureDisp *MouseIcon); ++ ++ HRESULT (STDMETHODCALLTYPE *get_MousePointer)( ++ IInkCollector* This, ++ InkMousePointer *MousePointer); ++ ++ HRESULT (STDMETHODCALLTYPE *put_MousePointer)( ++ IInkCollector* This, ++ InkMousePointer MousePointer); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Cursors)( ++ IInkCollector* This, ++ IInkCursors **Cursors); ++ ++ HRESULT (STDMETHODCALLTYPE *get_MarginX)( ++ IInkCollector* This, ++ LONG *MarginX); ++ ++ HRESULT (STDMETHODCALLTYPE *put_MarginX)( ++ IInkCollector* This, ++ LONG MarginX); ++ ++ HRESULT (STDMETHODCALLTYPE *get_MarginY)( ++ IInkCollector* This, ++ LONG *MarginY); ++ ++ HRESULT (STDMETHODCALLTYPE *put_MarginY)( ++ IInkCollector* This, ++ LONG MarginY); ++ ++ HRESULT (STDMETHODCALLTYPE *get_Tablet)( ++ IInkCollector* This, ++ IInkTablet **SingleTablet); ++ ++ HRESULT (STDMETHODCALLTYPE *get_SupportHighContrastInk)( ++ IInkCollector* This, ++ VARIANT_BOOL *Support); ++ ++ HRESULT (STDMETHODCALLTYPE *put_SupportHighContrastInk)( ++ IInkCollector* This, ++ VARIANT_BOOL Support); ++ ++ HRESULT (STDMETHODCALLTYPE *SetGestureStatus)( ++ IInkCollector* This, ++ InkApplicationGesture Gesture, ++ VARIANT_BOOL Listen); ++ ++ HRESULT (STDMETHODCALLTYPE *GetGestureStatus)( ++ IInkCollector* This, ++ InkApplicationGesture Gesture, ++ VARIANT_BOOL *Listening); ++ ++ HRESULT (STDMETHODCALLTYPE *GetWindowInputRectangle)( ++ IInkCollector* This, ++ IInkRectangle **WindowInputRectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *SetWindowInputRectangle)( ++ IInkCollector* This, ++ IInkRectangle *WindowInputRectangle); ++ ++ HRESULT (STDMETHODCALLTYPE *SetAllTabletsMode)( ++ IInkCollector* This, ++ VARIANT_BOOL UseMouseForInput); ++ ++ HRESULT (STDMETHODCALLTYPE *SetSingleTabletIntegratedMode)( ++ IInkCollector* This, ++ IInkTablet *Tablet); ++ ++ HRESULT (STDMETHODCALLTYPE *GetEventInterest)( ++ IInkCollector* This, ++ InkCollectorEventInterest EventId, ++ VARIANT_BOOL *Listen); ++ ++ HRESULT (STDMETHODCALLTYPE *SetEventInterest)( ++ IInkCollector* This, ++ InkCollectorEventInterest EventId, ++ VARIANT_BOOL Listen); ++ ++ END_INTERFACE ++} IInkCollectorVtbl; ++interface IInkCollector { ++ CONST_VTBL IInkCollectorVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IInkCollector_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IInkCollector_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IInkCollector_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define IInkCollector_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define IInkCollector_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define IInkCollector_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define IInkCollector_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++/*** IInkCollector methods ***/ ++#define IInkCollector_get_hWnd(This,CurrentWindow) (This)->lpVtbl->get_hWnd(This,CurrentWindow) ++#define IInkCollector_put_hWnd(This,NewWindow) (This)->lpVtbl->put_hWnd(This,NewWindow) ++#define IInkCollector_get_Enabled(This,Collecting) (This)->lpVtbl->get_Enabled(This,Collecting) ++#define IInkCollector_put_Enabled(This,Collecting) (This)->lpVtbl->put_Enabled(This,Collecting) ++#define IInkCollector_get_DefaultDrawingAttributes(This,CurrentAttributes) (This)->lpVtbl->get_DefaultDrawingAttributes(This,CurrentAttributes) ++#define IInkCollector_putref_DefaultDrawingAttributes(This,NewAttributes) (This)->lpVtbl->putref_DefaultDrawingAttributes(This,NewAttributes) ++#define IInkCollector_get_Renderer(This,CurrentInkRenderer) (This)->lpVtbl->get_Renderer(This,CurrentInkRenderer) ++#define IInkCollector_putref_Renderer(This,NewInkRenderer) (This)->lpVtbl->putref_Renderer(This,NewInkRenderer) ++#define IInkCollector_get_Ink(This,Ink) (This)->lpVtbl->get_Ink(This,Ink) ++#define IInkCollector_putref_Ink(This,NewInk) (This)->lpVtbl->putref_Ink(This,NewInk) ++#define IInkCollector_get_AutoRedraw(This,AutoRedraw) (This)->lpVtbl->get_AutoRedraw(This,AutoRedraw) ++#define IInkCollector_put_AutoRedraw(This,AutoRedraw) (This)->lpVtbl->put_AutoRedraw(This,AutoRedraw) ++#define IInkCollector_get_CollectingInk(This,Collecting) (This)->lpVtbl->get_CollectingInk(This,Collecting) ++#define IInkCollector_get_CollectionMode(This,Mode) (This)->lpVtbl->get_CollectionMode(This,Mode) ++#define IInkCollector_put_CollectionMode(This,Mode) (This)->lpVtbl->put_CollectionMode(This,Mode) ++#define IInkCollector_get_DynamicRendering(This,Enabled) (This)->lpVtbl->get_DynamicRendering(This,Enabled) ++#define IInkCollector_put_DynamicRendering(This,Enabled) (This)->lpVtbl->put_DynamicRendering(This,Enabled) ++#define IInkCollector_get_DesiredPacketDescription(This,PacketGuids) (This)->lpVtbl->get_DesiredPacketDescription(This,PacketGuids) ++#define IInkCollector_put_DesiredPacketDescription(This,PacketGuids) (This)->lpVtbl->put_DesiredPacketDescription(This,PacketGuids) ++#define IInkCollector_get_MouseIcon(This,MouseIcon) (This)->lpVtbl->get_MouseIcon(This,MouseIcon) ++#define IInkCollector_put_MouseIcon(This,MouseIcon) (This)->lpVtbl->put_MouseIcon(This,MouseIcon) ++#define IInkCollector_putref_MouseIcon(This,MouseIcon) (This)->lpVtbl->putref_MouseIcon(This,MouseIcon) ++#define IInkCollector_get_MousePointer(This,MousePointer) (This)->lpVtbl->get_MousePointer(This,MousePointer) ++#define IInkCollector_put_MousePointer(This,MousePointer) (This)->lpVtbl->put_MousePointer(This,MousePointer) ++#define IInkCollector_get_Cursors(This,Cursors) (This)->lpVtbl->get_Cursors(This,Cursors) ++#define IInkCollector_get_MarginX(This,MarginX) (This)->lpVtbl->get_MarginX(This,MarginX) ++#define IInkCollector_put_MarginX(This,MarginX) (This)->lpVtbl->put_MarginX(This,MarginX) ++#define IInkCollector_get_MarginY(This,MarginY) (This)->lpVtbl->get_MarginY(This,MarginY) ++#define IInkCollector_put_MarginY(This,MarginY) (This)->lpVtbl->put_MarginY(This,MarginY) ++#define IInkCollector_get_Tablet(This,SingleTablet) (This)->lpVtbl->get_Tablet(This,SingleTablet) ++#define IInkCollector_get_SupportHighContrastInk(This,Support) (This)->lpVtbl->get_SupportHighContrastInk(This,Support) ++#define IInkCollector_put_SupportHighContrastInk(This,Support) (This)->lpVtbl->put_SupportHighContrastInk(This,Support) ++#define IInkCollector_SetGestureStatus(This,Gesture,Listen) (This)->lpVtbl->SetGestureStatus(This,Gesture,Listen) ++#define IInkCollector_GetGestureStatus(This,Gesture,Listening) (This)->lpVtbl->GetGestureStatus(This,Gesture,Listening) ++#define IInkCollector_GetWindowInputRectangle(This,WindowInputRectangle) (This)->lpVtbl->GetWindowInputRectangle(This,WindowInputRectangle) ++#define IInkCollector_SetWindowInputRectangle(This,WindowInputRectangle) (This)->lpVtbl->SetWindowInputRectangle(This,WindowInputRectangle) ++#define IInkCollector_SetAllTabletsMode(This,UseMouseForInput) (This)->lpVtbl->SetAllTabletsMode(This,UseMouseForInput) ++#define IInkCollector_SetSingleTabletIntegratedMode(This,Tablet) (This)->lpVtbl->SetSingleTabletIntegratedMode(This,Tablet) ++#define IInkCollector_GetEventInterest(This,EventId,Listen) (This)->lpVtbl->GetEventInterest(This,EventId,Listen) ++#define IInkCollector_SetEventInterest(This,EventId,Listen) (This)->lpVtbl->SetEventInterest(This,EventId,Listen) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT IInkCollector_QueryInterface(IInkCollector* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG IInkCollector_AddRef(IInkCollector* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG IInkCollector_Release(IInkCollector* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT IInkCollector_GetTypeInfoCount(IInkCollector* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT IInkCollector_GetTypeInfo(IInkCollector* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT IInkCollector_GetIDsOfNames(IInkCollector* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT IInkCollector_Invoke(IInkCollector* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++/*** IInkCollector methods ***/ ++static FORCEINLINE HRESULT IInkCollector_get_hWnd(IInkCollector* This,LONG_PTR *CurrentWindow) { ++ return This->lpVtbl->get_hWnd(This,CurrentWindow); ++} ++static FORCEINLINE HRESULT IInkCollector_put_hWnd(IInkCollector* This,LONG_PTR NewWindow) { ++ return This->lpVtbl->put_hWnd(This,NewWindow); ++} ++static FORCEINLINE HRESULT IInkCollector_get_Enabled(IInkCollector* This,VARIANT_BOOL *Collecting) { ++ return This->lpVtbl->get_Enabled(This,Collecting); ++} ++static FORCEINLINE HRESULT IInkCollector_put_Enabled(IInkCollector* This,VARIANT_BOOL Collecting) { ++ return This->lpVtbl->put_Enabled(This,Collecting); ++} ++static FORCEINLINE HRESULT IInkCollector_get_DefaultDrawingAttributes(IInkCollector* This,IInkDrawingAttributes **CurrentAttributes) { ++ return This->lpVtbl->get_DefaultDrawingAttributes(This,CurrentAttributes); ++} ++static FORCEINLINE HRESULT IInkCollector_putref_DefaultDrawingAttributes(IInkCollector* This,IInkDrawingAttributes *NewAttributes) { ++ return This->lpVtbl->putref_DefaultDrawingAttributes(This,NewAttributes); ++} ++static FORCEINLINE HRESULT IInkCollector_get_Renderer(IInkCollector* This,IInkRenderer **CurrentInkRenderer) { ++ return This->lpVtbl->get_Renderer(This,CurrentInkRenderer); ++} ++static FORCEINLINE HRESULT IInkCollector_putref_Renderer(IInkCollector* This,IInkRenderer *NewInkRenderer) { ++ return This->lpVtbl->putref_Renderer(This,NewInkRenderer); ++} ++static FORCEINLINE HRESULT IInkCollector_get_Ink(IInkCollector* This,IInkDisp **Ink) { ++ return This->lpVtbl->get_Ink(This,Ink); ++} ++static FORCEINLINE HRESULT IInkCollector_putref_Ink(IInkCollector* This,IInkDisp *NewInk) { ++ return This->lpVtbl->putref_Ink(This,NewInk); ++} ++static FORCEINLINE HRESULT IInkCollector_get_AutoRedraw(IInkCollector* This,VARIANT_BOOL *AutoRedraw) { ++ return This->lpVtbl->get_AutoRedraw(This,AutoRedraw); ++} ++static FORCEINLINE HRESULT IInkCollector_put_AutoRedraw(IInkCollector* This,VARIANT_BOOL AutoRedraw) { ++ return This->lpVtbl->put_AutoRedraw(This,AutoRedraw); ++} ++static FORCEINLINE HRESULT IInkCollector_get_CollectingInk(IInkCollector* This,VARIANT_BOOL *Collecting) { ++ return This->lpVtbl->get_CollectingInk(This,Collecting); ++} ++static FORCEINLINE HRESULT IInkCollector_get_CollectionMode(IInkCollector* This,InkCollectionMode *Mode) { ++ return This->lpVtbl->get_CollectionMode(This,Mode); ++} ++static FORCEINLINE HRESULT IInkCollector_put_CollectionMode(IInkCollector* This,InkCollectionMode Mode) { ++ return This->lpVtbl->put_CollectionMode(This,Mode); ++} ++static FORCEINLINE HRESULT IInkCollector_get_DynamicRendering(IInkCollector* This,VARIANT_BOOL *Enabled) { ++ return This->lpVtbl->get_DynamicRendering(This,Enabled); ++} ++static FORCEINLINE HRESULT IInkCollector_put_DynamicRendering(IInkCollector* This,VARIANT_BOOL Enabled) { ++ return This->lpVtbl->put_DynamicRendering(This,Enabled); ++} ++static FORCEINLINE HRESULT IInkCollector_get_DesiredPacketDescription(IInkCollector* This,VARIANT *PacketGuids) { ++ return This->lpVtbl->get_DesiredPacketDescription(This,PacketGuids); ++} ++static FORCEINLINE HRESULT IInkCollector_put_DesiredPacketDescription(IInkCollector* This,VARIANT PacketGuids) { ++ return This->lpVtbl->put_DesiredPacketDescription(This,PacketGuids); ++} ++static FORCEINLINE HRESULT IInkCollector_get_MouseIcon(IInkCollector* This,IPictureDisp **MouseIcon) { ++ return This->lpVtbl->get_MouseIcon(This,MouseIcon); ++} ++static FORCEINLINE HRESULT IInkCollector_put_MouseIcon(IInkCollector* This,IPictureDisp *MouseIcon) { ++ return This->lpVtbl->put_MouseIcon(This,MouseIcon); ++} ++static FORCEINLINE HRESULT IInkCollector_putref_MouseIcon(IInkCollector* This,IPictureDisp *MouseIcon) { ++ return This->lpVtbl->putref_MouseIcon(This,MouseIcon); ++} ++static FORCEINLINE HRESULT IInkCollector_get_MousePointer(IInkCollector* This,InkMousePointer *MousePointer) { ++ return This->lpVtbl->get_MousePointer(This,MousePointer); ++} ++static FORCEINLINE HRESULT IInkCollector_put_MousePointer(IInkCollector* This,InkMousePointer MousePointer) { ++ return This->lpVtbl->put_MousePointer(This,MousePointer); ++} ++static FORCEINLINE HRESULT IInkCollector_get_Cursors(IInkCollector* This,IInkCursors **Cursors) { ++ return This->lpVtbl->get_Cursors(This,Cursors); ++} ++static FORCEINLINE HRESULT IInkCollector_get_MarginX(IInkCollector* This,LONG *MarginX) { ++ return This->lpVtbl->get_MarginX(This,MarginX); ++} ++static FORCEINLINE HRESULT IInkCollector_put_MarginX(IInkCollector* This,LONG MarginX) { ++ return This->lpVtbl->put_MarginX(This,MarginX); ++} ++static FORCEINLINE HRESULT IInkCollector_get_MarginY(IInkCollector* This,LONG *MarginY) { ++ return This->lpVtbl->get_MarginY(This,MarginY); ++} ++static FORCEINLINE HRESULT IInkCollector_put_MarginY(IInkCollector* This,LONG MarginY) { ++ return This->lpVtbl->put_MarginY(This,MarginY); ++} ++static FORCEINLINE HRESULT IInkCollector_get_Tablet(IInkCollector* This,IInkTablet **SingleTablet) { ++ return This->lpVtbl->get_Tablet(This,SingleTablet); ++} ++static FORCEINLINE HRESULT IInkCollector_get_SupportHighContrastInk(IInkCollector* This,VARIANT_BOOL *Support) { ++ return This->lpVtbl->get_SupportHighContrastInk(This,Support); ++} ++static FORCEINLINE HRESULT IInkCollector_put_SupportHighContrastInk(IInkCollector* This,VARIANT_BOOL Support) { ++ return This->lpVtbl->put_SupportHighContrastInk(This,Support); ++} ++static FORCEINLINE HRESULT IInkCollector_SetGestureStatus(IInkCollector* This,InkApplicationGesture Gesture,VARIANT_BOOL Listen) { ++ return This->lpVtbl->SetGestureStatus(This,Gesture,Listen); ++} ++static FORCEINLINE HRESULT IInkCollector_GetGestureStatus(IInkCollector* This,InkApplicationGesture Gesture,VARIANT_BOOL *Listening) { ++ return This->lpVtbl->GetGestureStatus(This,Gesture,Listening); ++} ++static FORCEINLINE HRESULT IInkCollector_GetWindowInputRectangle(IInkCollector* This,IInkRectangle **WindowInputRectangle) { ++ return This->lpVtbl->GetWindowInputRectangle(This,WindowInputRectangle); ++} ++static FORCEINLINE HRESULT IInkCollector_SetWindowInputRectangle(IInkCollector* This,IInkRectangle *WindowInputRectangle) { ++ return This->lpVtbl->SetWindowInputRectangle(This,WindowInputRectangle); ++} ++static FORCEINLINE HRESULT IInkCollector_SetAllTabletsMode(IInkCollector* This,VARIANT_BOOL UseMouseForInput) { ++ return This->lpVtbl->SetAllTabletsMode(This,UseMouseForInput); ++} ++static FORCEINLINE HRESULT IInkCollector_SetSingleTabletIntegratedMode(IInkCollector* This,IInkTablet *Tablet) { ++ return This->lpVtbl->SetSingleTabletIntegratedMode(This,Tablet); ++} ++static FORCEINLINE HRESULT IInkCollector_GetEventInterest(IInkCollector* This,InkCollectorEventInterest EventId,VARIANT_BOOL *Listen) { ++ return This->lpVtbl->GetEventInterest(This,EventId,Listen); ++} ++static FORCEINLINE HRESULT IInkCollector_SetEventInterest(IInkCollector* This,InkCollectorEventInterest EventId,VARIANT_BOOL Listen) { ++ return This->lpVtbl->SetEventInterest(This,EventId,Listen); ++} ++#endif ++#endif ++ ++#endif ++ ++HRESULT STDMETHODCALLTYPE IInkCollector_get_hWnd_Proxy( ++ IInkCollector* This, ++ LONG_PTR *CurrentWindow); ++void __RPC_STUB IInkCollector_get_hWnd_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_put_hWnd_Proxy( ++ IInkCollector* This, ++ LONG_PTR NewWindow); ++void __RPC_STUB IInkCollector_put_hWnd_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_Enabled_Proxy( ++ IInkCollector* This, ++ VARIANT_BOOL *Collecting); ++void __RPC_STUB IInkCollector_get_Enabled_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_put_Enabled_Proxy( ++ IInkCollector* This, ++ VARIANT_BOOL Collecting); ++void __RPC_STUB IInkCollector_put_Enabled_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_DefaultDrawingAttributes_Proxy( ++ IInkCollector* This, ++ IInkDrawingAttributes **CurrentAttributes); ++void __RPC_STUB IInkCollector_get_DefaultDrawingAttributes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_putref_DefaultDrawingAttributes_Proxy( ++ IInkCollector* This, ++ IInkDrawingAttributes *NewAttributes); ++void __RPC_STUB IInkCollector_putref_DefaultDrawingAttributes_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_Renderer_Proxy( ++ IInkCollector* This, ++ IInkRenderer **CurrentInkRenderer); ++void __RPC_STUB IInkCollector_get_Renderer_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_putref_Renderer_Proxy( ++ IInkCollector* This, ++ IInkRenderer *NewInkRenderer); ++void __RPC_STUB IInkCollector_putref_Renderer_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_Ink_Proxy( ++ IInkCollector* This, ++ IInkDisp **Ink); ++void __RPC_STUB IInkCollector_get_Ink_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_putref_Ink_Proxy( ++ IInkCollector* This, ++ IInkDisp *NewInk); ++void __RPC_STUB IInkCollector_putref_Ink_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_AutoRedraw_Proxy( ++ IInkCollector* This, ++ VARIANT_BOOL *AutoRedraw); ++void __RPC_STUB IInkCollector_get_AutoRedraw_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_put_AutoRedraw_Proxy( ++ IInkCollector* This, ++ VARIANT_BOOL AutoRedraw); ++void __RPC_STUB IInkCollector_put_AutoRedraw_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_CollectingInk_Proxy( ++ IInkCollector* This, ++ VARIANT_BOOL *Collecting); ++void __RPC_STUB IInkCollector_get_CollectingInk_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_CollectionMode_Proxy( ++ IInkCollector* This, ++ InkCollectionMode *Mode); ++void __RPC_STUB IInkCollector_get_CollectionMode_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_put_CollectionMode_Proxy( ++ IInkCollector* This, ++ InkCollectionMode Mode); ++void __RPC_STUB IInkCollector_put_CollectionMode_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_DynamicRendering_Proxy( ++ IInkCollector* This, ++ VARIANT_BOOL *Enabled); ++void __RPC_STUB IInkCollector_get_DynamicRendering_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_put_DynamicRendering_Proxy( ++ IInkCollector* This, ++ VARIANT_BOOL Enabled); ++void __RPC_STUB IInkCollector_put_DynamicRendering_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_DesiredPacketDescription_Proxy( ++ IInkCollector* This, ++ VARIANT *PacketGuids); ++void __RPC_STUB IInkCollector_get_DesiredPacketDescription_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_put_DesiredPacketDescription_Proxy( ++ IInkCollector* This, ++ VARIANT PacketGuids); ++void __RPC_STUB IInkCollector_put_DesiredPacketDescription_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_MouseIcon_Proxy( ++ IInkCollector* This, ++ IPictureDisp **MouseIcon); ++void __RPC_STUB IInkCollector_get_MouseIcon_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_put_MouseIcon_Proxy( ++ IInkCollector* This, ++ IPictureDisp *MouseIcon); ++void __RPC_STUB IInkCollector_put_MouseIcon_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_putref_MouseIcon_Proxy( ++ IInkCollector* This, ++ IPictureDisp *MouseIcon); ++void __RPC_STUB IInkCollector_putref_MouseIcon_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_MousePointer_Proxy( ++ IInkCollector* This, ++ InkMousePointer *MousePointer); ++void __RPC_STUB IInkCollector_get_MousePointer_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_put_MousePointer_Proxy( ++ IInkCollector* This, ++ InkMousePointer MousePointer); ++void __RPC_STUB IInkCollector_put_MousePointer_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_Cursors_Proxy( ++ IInkCollector* This, ++ IInkCursors **Cursors); ++void __RPC_STUB IInkCollector_get_Cursors_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_MarginX_Proxy( ++ IInkCollector* This, ++ LONG *MarginX); ++void __RPC_STUB IInkCollector_get_MarginX_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_put_MarginX_Proxy( ++ IInkCollector* This, ++ LONG MarginX); ++void __RPC_STUB IInkCollector_put_MarginX_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_MarginY_Proxy( ++ IInkCollector* This, ++ LONG *MarginY); ++void __RPC_STUB IInkCollector_get_MarginY_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_put_MarginY_Proxy( ++ IInkCollector* This, ++ LONG MarginY); ++void __RPC_STUB IInkCollector_put_MarginY_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_Tablet_Proxy( ++ IInkCollector* This, ++ IInkTablet **SingleTablet); ++void __RPC_STUB IInkCollector_get_Tablet_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_get_SupportHighContrastInk_Proxy( ++ IInkCollector* This, ++ VARIANT_BOOL *Support); ++void __RPC_STUB IInkCollector_get_SupportHighContrastInk_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_put_SupportHighContrastInk_Proxy( ++ IInkCollector* This, ++ VARIANT_BOOL Support); ++void __RPC_STUB IInkCollector_put_SupportHighContrastInk_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_SetGestureStatus_Proxy( ++ IInkCollector* This, ++ InkApplicationGesture Gesture, ++ VARIANT_BOOL Listen); ++void __RPC_STUB IInkCollector_SetGestureStatus_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_GetGestureStatus_Proxy( ++ IInkCollector* This, ++ InkApplicationGesture Gesture, ++ VARIANT_BOOL *Listening); ++void __RPC_STUB IInkCollector_GetGestureStatus_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_GetWindowInputRectangle_Proxy( ++ IInkCollector* This, ++ IInkRectangle **WindowInputRectangle); ++void __RPC_STUB IInkCollector_GetWindowInputRectangle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_SetWindowInputRectangle_Proxy( ++ IInkCollector* This, ++ IInkRectangle *WindowInputRectangle); ++void __RPC_STUB IInkCollector_SetWindowInputRectangle_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_SetAllTabletsMode_Proxy( ++ IInkCollector* This, ++ VARIANT_BOOL UseMouseForInput); ++void __RPC_STUB IInkCollector_SetAllTabletsMode_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_SetSingleTabletIntegratedMode_Proxy( ++ IInkCollector* This, ++ IInkTablet *Tablet); ++void __RPC_STUB IInkCollector_SetSingleTabletIntegratedMode_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_GetEventInterest_Proxy( ++ IInkCollector* This, ++ InkCollectorEventInterest EventId, ++ VARIANT_BOOL *Listen); ++void __RPC_STUB IInkCollector_GetEventInterest_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++HRESULT STDMETHODCALLTYPE IInkCollector_SetEventInterest_Proxy( ++ IInkCollector* This, ++ InkCollectorEventInterest EventId, ++ VARIANT_BOOL Listen); ++void __RPC_STUB IInkCollector_SetEventInterest_Stub( ++ IRpcStubBuffer* This, ++ IRpcChannelBuffer* pRpcChannelBuffer, ++ PRPC_MESSAGE pRpcMessage, ++ DWORD* pdwStubPhase); ++ ++#endif /* __IInkCollector_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * _IInkCollectorEvents dispinterface ++ */ ++#ifndef ___IInkCollectorEvents_DISPINTERFACE_DEFINED__ ++#define ___IInkCollectorEvents_DISPINTERFACE_DEFINED__ ++ ++DEFINE_GUID(DIID__IInkCollectorEvents, 0x11a583f2, 0x712d, 0x4fea, 0xab,0xcf, 0xab,0x4a,0xf3,0x8e,0xa0,0x6b); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("11a583f2-712d-4fea-abcf-ab4af38ea06b") ++_IInkCollectorEvents : public IDispatch ++{ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(_IInkCollectorEvents, 0x11a583f2, 0x712d, 0x4fea, 0xab,0xcf, 0xab,0x4a,0xf3,0x8e,0xa0,0x6b) ++#endif ++#else ++typedef struct _IInkCollectorEventsVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ _IInkCollectorEvents* This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ _IInkCollectorEvents* This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ _IInkCollectorEvents* This); ++ ++ /*** IDispatch methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( ++ _IInkCollectorEvents* This, ++ UINT *pctinfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( ++ _IInkCollectorEvents* This, ++ UINT iTInfo, ++ LCID lcid, ++ ITypeInfo **ppTInfo); ++ ++ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( ++ _IInkCollectorEvents* This, ++ REFIID riid, ++ LPOLESTR *rgszNames, ++ UINT cNames, ++ LCID lcid, ++ DISPID *rgDispId); ++ ++ HRESULT (STDMETHODCALLTYPE *Invoke)( ++ _IInkCollectorEvents* This, ++ DISPID dispIdMember, ++ REFIID riid, ++ LCID lcid, ++ WORD wFlags, ++ DISPPARAMS *pDispParams, ++ VARIANT *pVarResult, ++ EXCEPINFO *pExcepInfo, ++ UINT *puArgErr); ++ ++ END_INTERFACE ++} _IInkCollectorEventsVtbl; ++interface _IInkCollectorEvents { ++ CONST_VTBL _IInkCollectorEventsVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define _IInkCollectorEvents_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define _IInkCollectorEvents_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define _IInkCollectorEvents_Release(This) (This)->lpVtbl->Release(This) ++/*** IDispatch methods ***/ ++#define _IInkCollectorEvents_GetTypeInfoCount(This,pctinfo) (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) ++#define _IInkCollectorEvents_GetTypeInfo(This,iTInfo,lcid,ppTInfo) (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) ++#define _IInkCollectorEvents_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ++#define _IInkCollectorEvents_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ++#else ++/*** IUnknown methods ***/ ++static FORCEINLINE HRESULT _IInkCollectorEvents_QueryInterface(_IInkCollectorEvents* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static FORCEINLINE ULONG _IInkCollectorEvents_AddRef(_IInkCollectorEvents* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static FORCEINLINE ULONG _IInkCollectorEvents_Release(_IInkCollectorEvents* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDispatch methods ***/ ++static FORCEINLINE HRESULT _IInkCollectorEvents_GetTypeInfoCount(_IInkCollectorEvents* This,UINT *pctinfo) { ++ return This->lpVtbl->GetTypeInfoCount(This,pctinfo); ++} ++static FORCEINLINE HRESULT _IInkCollectorEvents_GetTypeInfo(_IInkCollectorEvents* This,UINT iTInfo,LCID lcid,ITypeInfo **ppTInfo) { ++ return This->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo); ++} ++static FORCEINLINE HRESULT _IInkCollectorEvents_GetIDsOfNames(_IInkCollectorEvents* This,REFIID riid,LPOLESTR *rgszNames,UINT cNames,LCID lcid,DISPID *rgDispId) { ++ return This->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId); ++} ++static FORCEINLINE HRESULT _IInkCollectorEvents_Invoke(_IInkCollectorEvents* This,DISPID dispIdMember,REFIID riid,LCID lcid,WORD wFlags,DISPPARAMS *pDispParams,VARIANT *pVarResult,EXCEPINFO *pExcepInfo,UINT *puArgErr) { ++ return This->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr); ++} ++#endif ++#endif ++ ++#endif ++ ++#endif /* ___IInkCollectorEvents_DISPINTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * InkCollector coclass ++ */ ++ ++DEFINE_GUID(CLSID_InkCollector, 0x43fb1553, 0xad74, 0x4ee8, 0x88,0xe4, 0x3e,0x6d,0xaa,0xc9,0x15,0xdb); ++ ++#ifdef __cplusplus ++class DECLSPEC_UUID("43fb1553-ad74-4ee8-88e4-3e6daac915db") InkCollector; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(InkCollector, 0x43fb1553, 0xad74, 0x4ee8, 0x88,0xe4, 0x3e,0x6d,0xaa,0xc9,0x15,0xdb) ++#endif ++#endif ++ ++/* Begin additional prototypes for all interfaces */ ++ ++ULONG __RPC_USER BSTR_UserSize (ULONG *, ULONG, BSTR *); ++unsigned char * __RPC_USER BSTR_UserMarshal (ULONG *, unsigned char *, BSTR *); ++unsigned char * __RPC_USER BSTR_UserUnmarshal(ULONG *, unsigned char *, BSTR *); ++void __RPC_USER BSTR_UserFree (ULONG *, BSTR *); ++ULONG __RPC_USER VARIANT_UserSize (ULONG *, ULONG, VARIANT *); ++unsigned char * __RPC_USER VARIANT_UserMarshal (ULONG *, unsigned char *, VARIANT *); ++unsigned char * __RPC_USER VARIANT_UserUnmarshal(ULONG *, unsigned char *, VARIANT *); ++void __RPC_USER VARIANT_UserFree (ULONG *, VARIANT *); ++ ++/* End additional prototypes */ ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* __msinkaut_h__ */ diff --git a/mingw-headers.spec b/mingw-headers.spec index 1239f48..e27701f 100644 --- a/mingw-headers.spec +++ b/mingw-headers.spec @@ -21,8 +21,8 @@ %endif Name: mingw-headers -Version: 4.0.2 -Release: 2%{?dist} +Version: 4.0.4 +Release: 1%{?dist} Summary: Win32/Win64 header files License: Public Domain and LGPLv2+ and ZPLv2.1 @@ -46,8 +46,15 @@ Source0: http://downloads.sourceforge.net/mingw-w64/mingw-w64-v%{version} # happening as the .idl files shouldn't be used by default Patch0: mingw-headers-no-widl.patch -# Backport fix for https://bugzilla.redhat.com/show_bug.cgi?id=1213843 -Patch1: commit-6c56d0b +# Backported commits required to build wine-gecko 2.40-beta1 +Patch1: commit-4ce7a79 +Patch2: commit-7eee339 +Patch3: commit-85b4034 +Patch4: commit-a883b47 +Patch5: commit-e4a8812 +Patch6: commit-e960f8f +Patch7: commit-ef5e914 +Patch8: commit-fc960d3 BuildArch: noarch @@ -95,7 +102,16 @@ unzip %{S:0} %endif %patch0 -p0 -b .idl + +# wine-gecko backports %patch1 -p1 +%patch2 -p1 +%patch3 -p1 +%patch4 -p1 +%patch5 -p1 +%patch6 -p1 +%patch7 -p1 +%patch8 -p1 %build @@ -130,6 +146,10 @@ rm -f $RPM_BUILD_ROOT%{mingw64_includedir}/pthread_unistd.h %changelog +* Wed Aug 5 2015 Erik van Pienbroek - 4.0.4-1 +- Update to 4.0.4 +- Backport various commits which are required by wine-gecko 2.40-beta1 + * Wed Jun 17 2015 Fedora Release Engineering - 4.0.2-2 - Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild diff --git a/sources b/sources index 2496717..c58882c 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -bb6404499342e02447b7c49f47b06b5e mingw-w64-v4.0.2.tar.bz2 +d54e353670e17b54f1ac86df3bb33e31 mingw-w64-v4.0.4.tar.bz2