// ------------------------------------------------------------------------------ // <auto-generated> // This code was generated by a tool. // // Changes to this file may cause incorrect behavior and will be lost if // the code is regenerated. // </auto-generated> // ------------------------------------------------------------------------------ #pragma warning disable CS1591,CS1573,CS0465,CS0649,CS8019,CS1570,CS1584,CS1658,CS0436,CS8981,SYSLIB1092,CS3021,CS3019 using global::System; using global::System.Diagnostics; using global::System.Diagnostics.CodeAnalysis; using global::System.Runtime.CompilerServices; using global::System.Runtime.InteropServices; using global::System.Runtime.Versioning; using winmdroot = global::Windows.Win32; namespace Windows.Win32 { namespace UI.Controls.RichEdit { [Guid("8CC497C4-A1DF-11CE-8098-00AA0047BE5D")] [CLSCompliant(false)] [SupportedOSPlatform("windows6.0.6000")] [global::System.CodeDom.Compiler.GeneratedCode("Microsoft.Windows.CsWin32", "0.3.287+85e3fa26dd.RR")] internal unsafe partial struct ITextPara :winmdroot.IVTable<ITextPara,ITextPara.Vtbl>,IComIID { /// <inheritdoc cref="QueryInterface(global::System.Guid*, void**)"/> [OverloadResolutionPriority(1)] internal unsafe winmdroot.Foundation.HRESULT QueryInterface(in global::System.Guid riid, out void* ppvObject) { fixed (void** ppvObjectLocal = &ppvObject) { fixed (global::System.Guid* riidLocal = &riid) { winmdroot.Foundation.HRESULT __result = this.QueryInterface(riidLocal, ppvObjectLocal); return __result; } } } public unsafe winmdroot.Foundation.HRESULT QueryInterface(global::System.Guid* riid, void** ppvObject) { return ((delegate *unmanaged [Stdcall]<ITextPara*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT>)lpVtbl[0])((ITextPara*)Unsafe.AsPointer(ref this), riid, ppvObject); } public uint AddRef() { return ((delegate *unmanaged [Stdcall]<ITextPara*,uint>)lpVtbl[1])((ITextPara*)Unsafe.AsPointer(ref this)); } public uint Release() { return ((delegate *unmanaged [Stdcall]<ITextPara*,uint>)lpVtbl[2])((ITextPara*)Unsafe.AsPointer(ref this)); } /// <inheritdoc cref="GetTypeInfoCount(uint*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetTypeInfoCount(out uint pctinfo) { fixed (uint* pctinfoLocal = &pctinfo) { this.GetTypeInfoCount(pctinfoLocal); } } public unsafe void GetTypeInfoCount(uint* pctinfo) { ((delegate *unmanaged [Stdcall]<ITextPara*,uint* ,winmdroot.Foundation.HRESULT>)lpVtbl[3])((ITextPara*)Unsafe.AsPointer(ref this), pctinfo).ThrowOnFailure(); } public unsafe void GetTypeInfo(uint iTInfo, uint lcid, winmdroot.System.Com.ITypeInfo** ppTInfo) { ((delegate *unmanaged [Stdcall]<ITextPara*,uint ,uint ,winmdroot.System.Com.ITypeInfo** ,winmdroot.Foundation.HRESULT>)lpVtbl[4])((ITextPara*)Unsafe.AsPointer(ref this), iTInfo, lcid, ppTInfo).ThrowOnFailure(); } /// <inheritdoc cref="GetIDsOfNames(global::System.Guid*, winmdroot.Foundation.PWSTR*, uint, uint, int*)"/> internal unsafe void GetIDsOfNames(in global::System.Guid riid, ReadOnlySpan<winmdroot.Foundation.PWSTR> rgszNames, uint lcid, Span<int> rgDispId) { fixed (int* rgDispIdLocal = rgDispId) { fixed (winmdroot.Foundation.PWSTR* rgszNamesLocal = rgszNames) { fixed (global::System.Guid* riidLocal = &riid) { if (!rgszNames.IsEmpty && !rgDispId.IsEmpty && rgszNames.Length != rgDispId.Length) throw new ArgumentException(); this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )(rgDispId.IsEmpty ? rgszNames.Length : rgDispId.Length), lcid, rgDispIdLocal); } } } } public unsafe void GetIDsOfNames(global::System.Guid* riid, winmdroot.Foundation.PWSTR* rgszNames, uint cNames, uint lcid, int* rgDispId) { ((delegate *unmanaged [Stdcall]<ITextPara*,global::System.Guid* ,winmdroot.Foundation.PWSTR* ,uint ,uint ,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[5])((ITextPara*)Unsafe.AsPointer(ref this), riid, rgszNames, cNames, lcid, rgDispId).ThrowOnFailure(); } /// <inheritdoc cref="Invoke(int, global::System.Guid*, uint, winmdroot.System.Com.DISPATCH_FLAGS, winmdroot.System.Com.DISPPARAMS*, winmdroot.System.Variant.VARIANT*, winmdroot.System.Com.EXCEPINFO*, uint*)"/> [OverloadResolutionPriority(1)] internal unsafe void Invoke(int dispIdMember, in global::System.Guid riid, uint lcid, winmdroot.System.Com.DISPATCH_FLAGS wFlags, in winmdroot.System.Com.DISPPARAMS pDispParams, out winmdroot.System.Variant.VARIANT pVarResult, out winmdroot.System.Com.EXCEPINFO pExcepInfo, out uint puArgErr) { fixed (uint* puArgErrLocal = &puArgErr) { fixed (winmdroot.System.Com.EXCEPINFO* pExcepInfoLocal = &pExcepInfo) { fixed (winmdroot.System.Variant.VARIANT* pVarResultLocal = &pVarResult) { fixed (winmdroot.System.Com.DISPPARAMS* pDispParamsLocal = &pDispParams) { fixed (global::System.Guid* riidLocal = &riid) { this.Invoke(dispIdMember, riidLocal, lcid, wFlags, pDispParamsLocal, pVarResultLocal, pExcepInfoLocal, puArgErrLocal); } } } } } } /// <inheritdoc cref="Invoke(int, global::System.Guid*, uint, winmdroot.System.Com.DISPATCH_FLAGS, winmdroot.System.Com.DISPPARAMS*, winmdroot.System.Variant.VARIANT*, winmdroot.System.Com.EXCEPINFO*, uint*)"/> internal unsafe void Invoke(int dispIdMember, in global::System.Guid riid, uint lcid, winmdroot.System.Com.DISPATCH_FLAGS wFlags, in winmdroot.System.Com.DISPPARAMS pDispParams) { fixed (winmdroot.System.Com.DISPPARAMS* pDispParamsLocal = &pDispParams) { fixed (global::System.Guid* riidLocal = &riid) { this.Invoke(dispIdMember, riidLocal, lcid, wFlags, pDispParamsLocal, default(winmdroot.System.Variant.VARIANT* ), default(winmdroot.System.Com.EXCEPINFO* ), default(uint* )); } } } public unsafe void Invoke(int dispIdMember, global::System.Guid* riid, uint lcid, winmdroot.System.Com.DISPATCH_FLAGS wFlags, winmdroot.System.Com.DISPPARAMS* pDispParams, [Optional] winmdroot.System.Variant.VARIANT* pVarResult, [Optional] winmdroot.System.Com.EXCEPINFO* pExcepInfo, [Optional] uint* puArgErr) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,global::System.Guid* ,uint ,winmdroot.System.Com.DISPATCH_FLAGS ,winmdroot.System.Com.DISPPARAMS* ,winmdroot.System.Variant.VARIANT* ,winmdroot.System.Com.EXCEPINFO* ,uint* ,winmdroot.Foundation.HRESULT>)lpVtbl[6])((ITextPara*)Unsafe.AsPointer(ref this), dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetDuplicate(ITextPara* pThis, winmdroot.UI.Controls.RichEdit.ITextPara** ppPara) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetDuplicate(ppPara); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Creates a duplicate of the specified paragraph format object. The duplicate property is the default property of an ITextPara object.</summary> /// <param name="ppPara"> /// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/api/tom/nn-tom-itextpara">ITextPara</a>**</b> The duplicate <a href="https://docs.microsoft.com/windows/desktop/api/tom/nn-tom-itextpara">ITextPara</a> object.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getduplicate#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetDuplicate</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getduplicate">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetDuplicate(winmdroot.UI.Controls.RichEdit.ITextPara** ppPara) { ((delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.UI.Controls.RichEdit.ITextPara** ,winmdroot.Foundation.HRESULT>)lpVtbl[7])((ITextPara*)Unsafe.AsPointer(ref this), ppPara).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetDuplicate(ITextPara* pThis, [Optional] winmdroot.UI.Controls.RichEdit.ITextPara* pPara) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetDuplicate(pPara); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the formatting for an existing paragraph by copying a given format.</summary> /// <param name="pPara"> /// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/api/tom/nn-tom-itextpara">ITextPara</a>*</b> The <a href="https://docs.microsoft.com/windows/desktop/api/tom/nn-tom-itextpara">ITextPara</a> range that contains the new paragraph formatting.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setduplicate#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetDuplicate</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>The tomUndefined values have no effect, that is, they will not change the target values.</remarks> public unsafe void SetDuplicate([Optional] winmdroot.UI.Controls.RichEdit.ITextPara* pPara) { ((delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.UI.Controls.RichEdit.ITextPara* ,winmdroot.Foundation.HRESULT>)lpVtbl[8])((ITextPara*)Unsafe.AsPointer(ref this), pPara).ThrowOnFailure(); } /// <inheritdoc cref="CanChange(int*)"/> [OverloadResolutionPriority(1)] internal unsafe void CanChange(out int pValue) { fixed (int* pValueLocal = &pValue) { this.CanChange(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT CanChange(ITextPara* pThis, int* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.CanChange(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Determines whether the paragraph formatting can be changed.</summary> /// <param name="pValue"> /// <para>Type: <b>long*</b> A variable that is <b>tomTrue</b> if the paragraph formatting can be changed or <b>tomFalse</b> if it cannot be changed. This parameter can be null.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-canchange#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If paragraph formatting can change, <b>ITextPara::CanChange</b> succeeds and returns <b>S_OK</b>. If paragraph formatting cannot change, the method fails and returns S_FALSE. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>.</para> /// </returns> /// <remarks>The *<i>pbCanChange</i> parameter returns <b>tomTrue</b> only if the paragraph formatting can be changed (that is, if no part of an associated range is protected and an associated document is not read-only). If this <a href="https://docs.microsoft.com/windows/desktop/api/tom/nn-tom-itextpara">ITextPara</a> object is a duplicate, no protection rules apply.</remarks> public unsafe void CanChange(int* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[9])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } /// <inheritdoc cref="IsEqual(winmdroot.UI.Controls.RichEdit.ITextPara*, int*)"/> [OverloadResolutionPriority(1)] internal unsafe void IsEqual([Optional] winmdroot.UI.Controls.RichEdit.ITextPara* pPara, out int pValue) { fixed (int* pValueLocal = &pValue) { this.IsEqual(pPara, pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT IsEqual(ITextPara* pThis, [Optional] winmdroot.UI.Controls.RichEdit.ITextPara* pPara, int* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.IsEqual(pPara, pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Determines if the current range has the same properties as a specified range.</summary> /// <param name="pPara"> /// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/api/tom/nn-tom-itextpara">ITextPara</a>*</b> The <a href="https://docs.microsoft.com/windows/desktop/api/tom/nn-tom-itextpara">ITextPara</a> range that is compared to the current range.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-isequal#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <param name="pValue"> /// <para>Type: <b>long*</b> The comparison result. The value can be null.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-isequal#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If the objects are equal, <b>ITextPara::IsEqual</b> succeeds and returns <b>S_OK</b>. If the objects are not equal, the method fails and returns S_FALSE. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-isequal">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public unsafe void IsEqual([Optional] winmdroot.UI.Controls.RichEdit.ITextPara* pPara, int* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.UI.Controls.RichEdit.ITextPara* ,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[10])((ITextPara*)Unsafe.AsPointer(ref this), pPara, pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT Reset(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.Reset(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Resets the paragraph formatting to a choice of default values.</summary> /// <param name="Value"> /// <para>Type: <b>long</b> Type of reset. It can be one of the following possible values. </para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-reset#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::Reset</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-reset">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public void Reset(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[11])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetStyle(int*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetStyle(out int pValue) { fixed (int* pValueLocal = &pValue) { this.GetStyle(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetStyle(ITextPara* pThis, int* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetStyle(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the style handle to the paragraphs in the specified range.</summary> /// <param name="pValue"> /// <para>Type: <b>long*</b> The paragraph style handle. For more information, see the Remarks.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getstyle#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetStyle</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para>The Text Object Model (TOM) version 1.0 has no way to specify the meanings of user-defined style handles. They depend on other facilities of the text system implementing TOM. Negative style handles are reserved for built-in character and paragraph styles. Currently defined values are listed in the following table. For a description of the following styles, see the Microsoft Word documentation. </para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getstyle#">Read more on learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetStyle(int* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[12])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetStyle(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetStyle(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the paragraph style for the paragraphs in a range.</summary> /// <param name="Value"> /// <para>Type: <b>long</b> New paragraph style handle. For a list of styles, see the Remarks section of <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getstyle">ITextPara::GetStyle</a>.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setstyle#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetStyle</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setstyle">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public void SetStyle(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[13])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetAlignment(int*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetAlignment(out int pValue) { fixed (int* pValueLocal = &pValue) { this.GetAlignment(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetAlignment(ITextPara* pThis, int* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetAlignment(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the current paragraph alignment value.</summary> /// <param name="pValue">Type: <b>long*</b></param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetAlignment</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getalignment">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetAlignment(int* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[14])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetAlignment(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetAlignment(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the paragraph alignment.</summary> /// <param name="Value"> /// <para>Type: <b>long</b> New paragraph alignment. For a list of possible values, see the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getalignment">ITextPara::GetAlignment</a> method.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setalignment#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetAlignment</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setalignment">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public void SetAlignment(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[15])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetHyphenation(winmdroot.UI.Controls.RichEdit.tomConstants*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetHyphenation(out winmdroot.UI.Controls.RichEdit.tomConstants pValue) { fixed (winmdroot.UI.Controls.RichEdit.tomConstants* pValueLocal = &pValue) { this.GetHyphenation(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetHyphenation(ITextPara* pThis, winmdroot.UI.Controls.RichEdit.tomConstants* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetHyphenation(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Determines whether automatic hyphenation is enabled for the range.</summary> /// <param name="pValue">Type: <b>long*</b></param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetHyphenation</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>This property corresponds to the PFE_DONOTHYPHEN effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-paraformat2">PARAFORMAT2</a> structure.</remarks> public unsafe void GetHyphenation(winmdroot.UI.Controls.RichEdit.tomConstants* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.UI.Controls.RichEdit.tomConstants* ,winmdroot.Foundation.HRESULT>)lpVtbl[16])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetHyphenation(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetHyphenation(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Controls hyphenation for the paragraphs in the range.</summary> /// <param name="Value"> /// <para>Type: <b>long</b> Indicates how hyphenation is controlled. It can be one of the following possible values. </para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-sethyphenation#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetHyphenation</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-sethyphenation">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public void SetHyphenation(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[17])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetFirstLineIndent(float*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetFirstLineIndent(out float pValue) { fixed (float* pValueLocal = &pValue) { this.GetFirstLineIndent(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetFirstLineIndent(ITextPara* pThis, float* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetFirstLineIndent(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the amount used to indent the first line of a paragraph relative to the left indent. The left indent is the indent for all lines of the paragraph except the first line.</summary> /// <param name="pValue"> /// <para>Type: <b>float*</b> The first-line indentation amount in floating-point points.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getfirstlineindent#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetFirstLineIndent</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para>To set the first line indentation amount, call the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-setindents">ITextPara::SetIndents</a> method. To get and set the indent for all other lines of the paragraph (that is, the left indent), use <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getleftindent">ITextPara::GetLeftIndent</a> and <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-setindents">ITextPara::SetIndents</a>.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getfirstlineindent#">Read more on learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetFirstLineIndent(float* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[18])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } /// <inheritdoc cref="GetKeepTogether(winmdroot.UI.Controls.RichEdit.tomConstants*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetKeepTogether(out winmdroot.UI.Controls.RichEdit.tomConstants pValue) { fixed (winmdroot.UI.Controls.RichEdit.tomConstants* pValueLocal = &pValue) { this.GetKeepTogether(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetKeepTogether(ITextPara* pThis, winmdroot.UI.Controls.RichEdit.tomConstants* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetKeepTogether(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Determines whether page breaks are allowed within paragraphs.</summary> /// <param name="pValue">Type: <b>long*</b></param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetKeepTogether</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>This property corresponds to the PFE_KEEP effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-paraformat2">PARAFORMAT2</a> structure.</remarks> public unsafe void GetKeepTogether(winmdroot.UI.Controls.RichEdit.tomConstants* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.UI.Controls.RichEdit.tomConstants* ,winmdroot.Foundation.HRESULT>)lpVtbl[19])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetKeepTogether(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetKeepTogether(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Controls whether page breaks are allowed within a paragraph in a range.</summary> /// <param name="Value"> /// <para>Type: <b>long</b> Indicates whether page breaks are allowed within a paragraph in a range. It can be one of the following possible values. </para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setkeeptogether#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetKeepTogether</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>This property corresponds to the PFE_KEEP effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-paraformat2">PARAFORMAT2</a> structure.</remarks> public void SetKeepTogether(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[20])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetKeepWithNext(winmdroot.UI.Controls.RichEdit.tomConstants*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetKeepWithNext(out winmdroot.UI.Controls.RichEdit.tomConstants pValue) { fixed (winmdroot.UI.Controls.RichEdit.tomConstants* pValueLocal = &pValue) { this.GetKeepWithNext(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetKeepWithNext(ITextPara* pThis, winmdroot.UI.Controls.RichEdit.tomConstants* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetKeepWithNext(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Determines whether page breaks are allowed between paragraphs in the range.</summary> /// <param name="pValue">Type: <b>long*</b></param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetKeepWithNext</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>This property corresponds to the PFE_KEEPNEXT effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-paraformat2">PARAFORMAT2</a> structure.</remarks> public unsafe void GetKeepWithNext(winmdroot.UI.Controls.RichEdit.tomConstants* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.UI.Controls.RichEdit.tomConstants* ,winmdroot.Foundation.HRESULT>)lpVtbl[21])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetKeepWithNext(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetKeepWithNext(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Controls whether page breaks are allowed between the paragraphs in a range.</summary> /// <param name="Value"> /// <para>Type: <b>long</b> Indicates if page breaks can be used between the paragraphs of a range. It can be one of the following possible values. </para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setkeepwithnext#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetKeepWithNext</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>This property corresponds to the PFE_KEEPNEXT effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-paraformat2">PARAFORMAT2</a> structure.</remarks> public void SetKeepWithNext(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[22])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetLeftIndent(float*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetLeftIndent(out float pValue) { fixed (float* pValueLocal = &pValue) { this.GetLeftIndent(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetLeftIndent(ITextPara* pThis, float* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetLeftIndent(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the distance used to indent all lines except the first line of a paragraph. The distance is relative to the left margin.</summary> /// <param name="pValue"> /// <para>Type: <b>float*</b> The left indentation, in floating-point points.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getleftindent#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetLeftIndent</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para>To set the left indentation amount, call the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-setindents">ITextPara::SetIndents</a> method. To get the first-line indent, call <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getfirstlineindent">ITextPara::GetFirstLineIndent</a>.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getleftindent#">Read more on learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetLeftIndent(float* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[23])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } /// <inheritdoc cref="GetLineSpacing(float*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetLineSpacing(out float pValue) { fixed (float* pValueLocal = &pValue) { this.GetLineSpacing(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetLineSpacing(ITextPara* pThis, float* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetLineSpacing(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the line-spacing value for the text range.</summary> /// <param name="pValue"> /// <para>Type: <b>float*</b> The line-spacing value. The following table shows how this value is interpreted for the different line-spacing rules.</para> /// <para></para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getlinespacing#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetLineSpacing</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>To retrieve the line-spacing rule, call the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getlinespacingrule">ITextPara::GetLineSpacingRule</a> method.</remarks> public unsafe void GetLineSpacing(float* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[24])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } /// <inheritdoc cref="GetLineSpacingRule(int*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetLineSpacingRule(out int pValue) { fixed (int* pValueLocal = &pValue) { this.GetLineSpacingRule(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetLineSpacingRule(ITextPara* pThis, int* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetLineSpacingRule(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the line-spacing rule for the text range.</summary> /// <param name="pValue">Type: <b>long*</b></param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetLineSpacingRule</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getlinespacingrule">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetLineSpacingRule(int* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[25])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } /// <inheritdoc cref="GetListAlignment(int*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetListAlignment(out int pValue) { fixed (int* pValueLocal = &pValue) { this.GetListAlignment(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetListAlignment(ITextPara* pThis, int* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetListAlignment(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the kind of alignment to use for bulleted and numbered lists.</summary> /// <param name="pValue">Type: <b>long*</b></param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetListAlignment</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>For a description of the different types of lists, see the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getlisttype">ITextPara::GetListType</a> method.</remarks> public unsafe void GetListAlignment(int* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[26])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetListAlignment(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetListAlignment(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the alignment of bulleted or numbered text used for paragraphs.</summary> /// <param name="Value"> /// <para>Type: <b>long</b> New list alignment value. For possible values, see <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getlistalignment">ITextPara::GetListAlignment</a>.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setlistalignment#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetListAlignment</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setlistalignment">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public void SetListAlignment(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[27])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetListLevelIndex(int*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetListLevelIndex(out int pValue) { fixed (int* pValueLocal = &pValue) { this.GetListLevelIndex(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetListLevelIndex(ITextPara* pThis, int* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetListLevelIndex(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the list level index used with paragraphs.</summary> /// <param name="pValue"> /// <para>Type: <b>long*</b> A variable that is the list level index. The value of <i>pValue</i> can be one of the following.</para> /// <para></para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getlistlevelindex#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetListLevelIndex</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getlistlevelindex">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetListLevelIndex(int* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[28])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetListLevelIndex(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetListLevelIndex(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the list level index used for paragraphs.</summary> /// <param name="Value"> /// <para>Type: <b>long</b> New list level index value. For possible values, see <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getlistlevelindex">ITextPara::GetListLevelIndex</a>.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setlistlevelindex#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetListLevelIndex</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>Setting the list level index does not automatically change a list's indentation and other paragraph properties.</remarks> public void SetListLevelIndex(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[29])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetListStart(int*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetListStart(out int pValue) { fixed (int* pValueLocal = &pValue) { this.GetListStart(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetListStart(ITextPara* pThis, int* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetListStart(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the starting value or code of a list numbering sequence.</summary> /// <param name="pValue"> /// <para>Type: <b>long*</b> The starting value or code of a list numbering sequence. For the possible values, see the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getlisttype">ITextPara::GetListType</a> method.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getliststart#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetListStart</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>For a discussion on which sequence to use, see the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getlisttype">ITextPara::GetListType</a> method.</remarks> public unsafe void GetListStart(int* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[30])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetListStart(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetListStart(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the starting number or Unicode value for a numbered list.</summary> /// <param name="Value"> /// <para>Type: <b>long</b> New starting number or Unicode value for a numbered list.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setliststart#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetListStart</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>Other characteristics of a list are specified by <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-setlisttype">ITextPara::SetListType</a>.</remarks> public void SetListStart(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[31])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetListTab(float*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetListTab(out float pValue) { fixed (float* pValueLocal = &pValue) { this.GetListTab(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetListTab(ITextPara* pThis, float* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetListTab(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the list tab setting, which is the distance between the first-line indent and the text on the first line. The numbered or bulleted text is left-justified, centered, or right-justified at the first-line indent value.</summary> /// <param name="pValue"> /// <para>Type: <b>float*</b> The list tab setting. The list tab value is in floating-point points.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getlisttab#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetListTab</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>To determine whether the numbered or bulleted text is left-justified, centered, or right-justified, call <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getlistalignment">ITextPara::GetListAlignment</a>.</remarks> public unsafe void GetListTab(float* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[32])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetListTab(ITextPara* pThis, float Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetListTab(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the list tab setting, which is the distance between the first indent and the start of the text on the first line.</summary> /// <param name="Value"> /// <para>Type: <b>float</b> New list tab value, in floating-point points.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setlisttab#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetListTab</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setlisttab">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public void SetListTab(float Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[33])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetListType(int*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetListType(out int pValue) { fixed (int* pValueLocal = &pValue) { this.GetListType(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetListType(ITextPara* pThis, int* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetListType(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the kind of numbering to use with paragraphs.</summary> /// <param name="pValue">Type: <b>long*</b></param> /// <returns> /// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If <b>ITextPara::GetListType</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para>Values above 32 correspond to Unicode values for bullets. The mobile Microsoft Office version of the rich edit control uses <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomIgnoreNumberStyle</a> to suppress setting the style. The following Microsoft Visual Basic for Applications (VBA) example numbers the paragraphs in a range, starting with the number 2 and following the numbers with a period.</para> /// <para></para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getlisttype#">Read more on learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetListType(int* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[34])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetListType(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetListType(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the type of list to be used for paragraphs.</summary> /// <param name="Value"> /// <para>Type: <b>long</b> New list type. For possible list types, see the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getlisttype">ITextPara::GetListType</a> method.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setlisttype#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetListType</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setlisttype">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public void SetListType(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[35])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetNoLineNumber(int*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetNoLineNumber(out int pValue) { fixed (int* pValueLocal = &pValue) { this.GetNoLineNumber(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetNoLineNumber(ITextPara* pThis, int* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetNoLineNumber(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Determines whether paragraph numbering is enabled.</summary> /// <param name="pValue">Type: <b>long*</b></param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetNoLineNumber</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>Paragraph numbering is when the paragraphs of a range are numbered. The number appears on the first line of a paragraph.</remarks> public unsafe void GetNoLineNumber(int* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[36])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetNoLineNumber(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetNoLineNumber(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Determines whether to suppress line numbering of paragraphs in a range.</summary> /// <param name="Value"> /// <para>Type: <b>long</b> Indicates if line numbering is suppressed. It can be one of the following possible values. </para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setnolinenumber#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetNoLineNumber</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para>This property concerns the numbering of paragraphs in a range. If <i>Value</i> is <b>tomFalse</b>, the number of the paragraph appears on the first line of the paragraph.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setnolinenumber#">Read more on learn.microsoft.com</see>.</para> /// </remarks> public void SetNoLineNumber(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[37])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetPageBreakBefore(int*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetPageBreakBefore(out int pValue) { fixed (int* pValueLocal = &pValue) { this.GetPageBreakBefore(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetPageBreakBefore(ITextPara* pThis, int* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetPageBreakBefore(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Determines whether each paragraph in the range must begin on a new page.</summary> /// <param name="pValue">Type: <b>long*</b></param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetPageBreakBefore</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getpagebreakbefore">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetPageBreakBefore(int* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[38])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetPageBreakBefore(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetPageBreakBefore(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Controls whether there is a page break before each paragraph in a range.</summary> /// <param name="Value">Type: <b>long</b></param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetPageBreakBefore</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>This method is included for compatibility with Microsoft Word; it does not affect how the rich edit control displays text.</remarks> public void SetPageBreakBefore(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[39])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetRightIndent(float*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetRightIndent(out float pValue) { fixed (float* pValueLocal = &pValue) { this.GetRightIndent(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetRightIndent(ITextPara* pThis, float* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetRightIndent(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the size of the right margin indent of a paragraph.</summary> /// <param name="pValue"> /// <para>Type: <b>float*</b> The right indentation, in floating-point points.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getrightindent#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetRightIndent</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getrightindent">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetRightIndent(float* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[40])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetRightIndent(ITextPara* pThis, float Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetRightIndent(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the right margin of paragraph.</summary> /// <param name="Value"> /// <para>Type: <b>float</b> Right indent, in floating-point points.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setrightindent#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetRightIndent</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setrightindent">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public void SetRightIndent(float Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[41])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetIndents(ITextPara* pThis, float First, float Left, float Right) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetIndents(First, Left, Right); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the first-line indent, the left indent, and the right indent for a paragraph.</summary> /// <param name="First"> /// <para>Type: <b>float</b> Indent of the first line in a paragraph, relative to the left indent. The value is in floating-point points and can be positive or negative.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setindents#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <param name="Left"> /// <para>Type: <b>float</b> Left indent of all lines except the first line in a paragraph, relative to left margin. The value is in floating-point points and can be positive or negative.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setindents#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <param name="Right"> /// <para>Type: <b>float</b> Right indent of all lines in paragraph, relative to the right margin. The value is in floating-point points and can be positive or negative. This value is optional.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setindents#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetIndents</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>Line indents are not allowed to position text in the margins. If the first-line indent is set to a negative value (for an outdented paragraph) while the left indent is zero, the first-line indent is reset to zero. To avoid this problem while retaining property sets, set the first-line indent value equal to zero either explicitly or by calling the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-reset">ITextPara::Reset</a> method. Then, call <b>ITextPara::SetIndents</b> to set a nonnegative, left-indent value and set the desired first-line indent.</remarks> public void SetIndents(float First, float Left, float Right) { ((delegate *unmanaged [Stdcall]<ITextPara*,float ,float ,float ,winmdroot.Foundation.HRESULT>)lpVtbl[42])((ITextPara*)Unsafe.AsPointer(ref this), First, Left, Right).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetLineSpacing(ITextPara* pThis, int Rule, float Spacing) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetLineSpacing(Rule, Spacing); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the paragraph line-spacing rule and the line spacing for a paragraph.</summary> /// <param name="Rule"> /// <para>Type: <b>long</b> Value of new line-spacing rule. For a list of possible rule values and further discussion, see the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-getlinespacingrule">ITextPara::GetLineSpacingRule</a> method.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setlinespacing#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <param name="Spacing"> /// <para>Type: <b>float</b> Value of new line spacing. If the line-spacing rule treats the <i>Spacing</i> value as a linear dimension, then <i>Spacing</i> is given in floating-point points.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setlinespacing#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetLineSpacing</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>The line-spacing rule and line spacing work together, and as a result, they must be set together, much as the first and left indents need to be set together.</remarks> public void SetLineSpacing(int Rule, float Spacing) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,float ,winmdroot.Foundation.HRESULT>)lpVtbl[43])((ITextPara*)Unsafe.AsPointer(ref this), Rule, Spacing).ThrowOnFailure(); } /// <inheritdoc cref="GetSpaceAfter(float*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetSpaceAfter(out float pValue) { fixed (float* pValueLocal = &pValue) { this.GetSpaceAfter(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetSpaceAfter(ITextPara* pThis, float* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetSpaceAfter(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the amount of vertical space below a paragraph.</summary> /// <param name="pValue"> /// <para>Type: <b>float*</b> The space-after value, in floating-point points.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getspaceafter#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetSpaceAfter</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getspaceafter">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetSpaceAfter(float* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[44])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetSpaceAfter(ITextPara* pThis, float Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetSpaceAfter(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the amount of space that follows a paragraph.</summary> /// <param name="Value"> /// <para>Type: <b>float</b> New space-after value, in floating-point points.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setspaceafter#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetSpaceAfter</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setspaceafter">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public void SetSpaceAfter(float Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[45])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetSpaceBefore(float*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetSpaceBefore(out float pValue) { fixed (float* pValueLocal = &pValue) { this.GetSpaceBefore(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetSpaceBefore(ITextPara* pThis, float* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetSpaceBefore(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the amount of vertical space above a paragraph.</summary> /// <param name="pValue"> /// <para>Type: <b>float*</b> The space-before value, in floating-point points.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getspacebefore#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetSpaceBefore</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-getspacebefore">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetSpaceBefore(float* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[46])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetSpaceBefore(ITextPara* pThis, float Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetSpaceBefore(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Sets the amount of space preceding a paragraph.</summary> /// <param name="Value"> /// <para>Type: <b>float</b> New space-before value, in floating-point points.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setspacebefore#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetSpaceBefore</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setspacebefore">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public void SetSpaceBefore(float Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[47])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetWidowControl(int*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetWidowControl(out int pValue) { fixed (int* pValueLocal = &pValue) { this.GetWidowControl(pValueLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetWidowControl(ITextPara* pThis, int* pValue) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetWidowControl(pValue); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the widow and orphan control state for the paragraphs in a range.</summary> /// <param name="pValue">Type: <b>long*</b></param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetWidowControl</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>A widow is created when the last line of a paragraph is printed by itself at the top of a page. An orphan is when the first line of a paragraph is printed by itself at the bottom of a page.</remarks> public unsafe void GetWidowControl(int* pValue) { ((delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[48])((ITextPara*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT SetWidowControl(ITextPara* pThis, int Value) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.SetWidowControl(Value); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Controls the suppression of widows and orphans.</summary> /// <param name="Value"> /// <para>Type: <b>long</b> A tomBool value that controls the suppression of widows and orphans. It can be one of the following possible values. </para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setwidowcontrol#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::SetWidowControl</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para>This method is included for compatibility with Microsoft Word; it does not affect how the rich edit control displays text. A widow is created when the last line of a paragraph is printed by itself at the top of a page. An orphan is when the first line of a paragraph is printed by itself at the bottom of a page.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-setwidowcontrol#">Read more on learn.microsoft.com</see>.</para> /// </remarks> public void SetWidowControl(int Value) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[49])((ITextPara*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure(); } /// <inheritdoc cref="GetTabCount(int*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetTabCount(out int pCount) { fixed (int* pCountLocal = &pCount) { this.GetTabCount(pCountLocal); } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetTabCount(ITextPara* pThis, int* pCount) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetTabCount(pCount); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves the tab count.</summary> /// <param name="pCount"> /// <para>Type: <b>long*</b> The tab count.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-gettabcount#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetTabCount</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>The tab count of a new instance can be nonzero, depending on the underlying text engine. For example, Microsoft Word stories begin with no explicit tabs defined, while rich edit instances start with a single explicit tab. To be sure there are no explicit tabs (that is, to set the tab count to zero), call <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-clearalltabs">ITextPara::ClearAllTabs</a>.</remarks> public unsafe void GetTabCount(int* pCount) { ((delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[50])((ITextPara*)Unsafe.AsPointer(ref this), pCount).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT AddTab(ITextPara* pThis, float tbPos, int tbAlign, int tbLeader) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.AddTab(tbPos, tbAlign, tbLeader); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Adds a tab at the displacement tbPos, with type tbAlign, and leader style, tbLeader.</summary> /// <param name="tbPos"> /// <para>Type: <b>float</b> New tab displacement, in floating-point points.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-addtab#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <param name="tbAlign"> /// <para>Type: <b>long</b> Alignment options for the tab position. It can be one of the following. </para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-addtab#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <param name="tbLeader"> /// <para>Type: <b>long</b> Leader character style. A leader character is the character that is used to fill the space taken by a tab character. It can be one of the following. </para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-addtab#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::AddTab</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks>It is assumed that there is never a tab at position zero. If multiple paragraphs are described, the common subset of tabs will be returned with 0x8000 in the upper word of the tab type.</remarks> public void AddTab(float tbPos, int tbAlign, int tbLeader) { ((delegate *unmanaged [Stdcall]<ITextPara*,float ,int ,int ,winmdroot.Foundation.HRESULT>)lpVtbl[51])((ITextPara*)Unsafe.AsPointer(ref this), tbPos, tbAlign, tbLeader).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT ClearAllTabs(ITextPara* pThis) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.ClearAllTabs(); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Clears all tabs, reverting to equally spaced tabs with the default tab spacing.</summary> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::ClearAllTabs</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-clearalltabs">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public void ClearAllTabs() { ((delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.Foundation.HRESULT>)lpVtbl[52])((ITextPara*)Unsafe.AsPointer(ref this)).ThrowOnFailure(); } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT DeleteTab(ITextPara* pThis, float tbPos) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.DeleteTab(tbPos); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Deletes a tab at a specified displacement.</summary> /// <param name="tbPos"> /// <para>Type: <b>float</b> Displacement, in floating-point points, at which a tab should be deleted.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-deletetab#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::DeleteTab</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-deletetab">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public void DeleteTab(float tbPos) { ((delegate *unmanaged [Stdcall]<ITextPara*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[53])((ITextPara*)Unsafe.AsPointer(ref this), tbPos).ThrowOnFailure(); } /// <inheritdoc cref="GetTab(int, float*, int*, int*)"/> [OverloadResolutionPriority(1)] internal unsafe void GetTab(int iTab, out float ptbPos, out int ptbAlign, out int ptbLeader) { fixed (int* ptbLeaderLocal = &ptbLeader) { fixed (int* ptbAlignLocal = &ptbAlign) { fixed (float* ptbPosLocal = &ptbPos) { this.GetTab(iTab, ptbPosLocal, ptbAlignLocal, ptbLeaderLocal); } } } } [UnmanagedCallersOnly(CallConvs = new []{ typeof(CallConvStdcall)} )] private static winmdroot.Foundation.HRESULT GetTab(ITextPara* pThis, int iTab, float* ptbPos, int* ptbAlign, int* ptbLeader) { try { winmdroot.Foundation.HRESULT __hr = winmdroot.ComHelpers.UnwrapCCW(pThis, out Interface __object); if (__hr.Failed) { return __hr; } return __object.GetTab(iTab, ptbPos, ptbAlign, ptbLeader); } catch (Exception ex) { return (winmdroot.Foundation.HRESULT)ex.HResult; } } /// <summary>Retrieves tab parameters (displacement, alignment, and leader style) for a specified tab.</summary> /// <param name="iTab"> /// <para>Type: <b>long</b> Index of tab for which to retrieve info. It can be either a numerical index or a special value (see the following table). Since tab indexes are zero-based, <i>iTab</i> = zero gets the first tab defined, <i>iTab</i> = 1 gets the second tab defined, and so forth. The following table summarizes all of the possible values of <i>iTab</i>.</para> /// <para></para> /// <para>This doc was truncated.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-gettab#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <param name="ptbPos"> /// <para>Type: <b>float*</b> The tab displacement, in floating-point points. The value of * <i>ptbPos</i> is zero if the tab does not exist and the value of * <i>ptbPos</i> is tomUndefined if there are multiple values in the associated range.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-gettab#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <param name="ptbAlign"> /// <para>Type: <b>long*</b> The tab alignment. For more information, see <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-addtab">ITextPara::AddTab</a>.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-gettab#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <param name="ptbLeader"> /// <para>Type: <b>long*</b> The tab leader-character style. For more information, see <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextpara-addtab">ITextPara::AddTab</a>.</para> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-gettab#parameters">Read more on learn.microsoft.com</see>.</para> /// </param> /// <returns> /// <para>Type: <b>HRESULT</b> If <b>ITextPara::GetTab</b> succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para> /// <para>This doc was truncated.</para> /// </returns> /// <remarks> /// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextpara-gettab">Learn more about this API from learn.microsoft.com</see>.</para> /// </remarks> public unsafe void GetTab(int iTab, float* ptbPos, int* ptbAlign, int* ptbLeader) { ((delegate *unmanaged [Stdcall]<ITextPara*,int ,float* ,int* ,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[54])((ITextPara*)Unsafe.AsPointer(ref this), iTab, ptbPos, ptbAlign, ptbLeader).ThrowOnFailure(); } internal unsafe global::Windows.Win32.Foundation.HRESULT QueryInterface<T>(out T* ppv) where T : unmanaged { Guid guid = typeof(T).GUID; void* pv; var hr = this.QueryInterface(&guid, &pv); if (hr.Succeeded) { ppv = (T*)pv; } else { ppv = null; } return hr; } internal struct Vtbl { internal delegate *unmanaged [Stdcall]<ITextPara*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT> QueryInterface_1; internal delegate *unmanaged [Stdcall]<ITextPara*,uint> AddRef_2; internal delegate *unmanaged [Stdcall]<ITextPara*,uint> Release_3; internal delegate *unmanaged [Stdcall]<ITextPara*,uint* ,winmdroot.Foundation.HRESULT> GetTypeInfoCount_4; internal delegate *unmanaged [Stdcall]<ITextPara*,uint ,uint ,winmdroot.System.Com.ITypeInfo** ,winmdroot.Foundation.HRESULT> GetTypeInfo_5; internal delegate *unmanaged [Stdcall]<ITextPara*,global::System.Guid* ,winmdroot.Foundation.PWSTR* ,uint ,uint ,int* ,winmdroot.Foundation.HRESULT> GetIDsOfNames_6; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,global::System.Guid* ,uint ,winmdroot.System.Com.DISPATCH_FLAGS ,winmdroot.System.Com.DISPPARAMS* ,winmdroot.System.Variant.VARIANT* ,winmdroot.System.Com.EXCEPINFO* ,uint* ,winmdroot.Foundation.HRESULT> Invoke_7; internal delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.UI.Controls.RichEdit.ITextPara** ,winmdroot.Foundation.HRESULT> GetDuplicate_8; internal delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.UI.Controls.RichEdit.ITextPara* ,winmdroot.Foundation.HRESULT> SetDuplicate_9; internal delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT> CanChange_10; internal delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.UI.Controls.RichEdit.ITextPara* ,int* ,winmdroot.Foundation.HRESULT> IsEqual_11; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> Reset_12; internal delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT> GetStyle_13; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> SetStyle_14; internal delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT> GetAlignment_15; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> SetAlignment_16; internal delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.UI.Controls.RichEdit.tomConstants* ,winmdroot.Foundation.HRESULT> GetHyphenation_17; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> SetHyphenation_18; internal delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT> GetFirstLineIndent_19; internal delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.UI.Controls.RichEdit.tomConstants* ,winmdroot.Foundation.HRESULT> GetKeepTogether_20; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> SetKeepTogether_21; internal delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.UI.Controls.RichEdit.tomConstants* ,winmdroot.Foundation.HRESULT> GetKeepWithNext_22; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> SetKeepWithNext_23; internal delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT> GetLeftIndent_24; internal delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT> GetLineSpacing_25; internal delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT> GetLineSpacingRule_26; internal delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT> GetListAlignment_27; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> SetListAlignment_28; internal delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT> GetListLevelIndex_29; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> SetListLevelIndex_30; internal delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT> GetListStart_31; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> SetListStart_32; internal delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT> GetListTab_33; internal delegate *unmanaged [Stdcall]<ITextPara*,float ,winmdroot.Foundation.HRESULT> SetListTab_34; internal delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT> GetListType_35; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> SetListType_36; internal delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT> GetNoLineNumber_37; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> SetNoLineNumber_38; internal delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT> GetPageBreakBefore_39; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> SetPageBreakBefore_40; internal delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT> GetRightIndent_41; internal delegate *unmanaged [Stdcall]<ITextPara*,float ,winmdroot.Foundation.HRESULT> SetRightIndent_42; internal delegate *unmanaged [Stdcall]<ITextPara*,float ,float ,float ,winmdroot.Foundation.HRESULT> SetIndents_43; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,float ,winmdroot.Foundation.HRESULT> SetLineSpacing_44; internal delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT> GetSpaceAfter_45; internal delegate *unmanaged [Stdcall]<ITextPara*,float ,winmdroot.Foundation.HRESULT> SetSpaceAfter_46; internal delegate *unmanaged [Stdcall]<ITextPara*,float* ,winmdroot.Foundation.HRESULT> GetSpaceBefore_47; internal delegate *unmanaged [Stdcall]<ITextPara*,float ,winmdroot.Foundation.HRESULT> SetSpaceBefore_48; internal delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT> GetWidowControl_49; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,winmdroot.Foundation.HRESULT> SetWidowControl_50; internal delegate *unmanaged [Stdcall]<ITextPara*,int* ,winmdroot.Foundation.HRESULT> GetTabCount_51; internal delegate *unmanaged [Stdcall]<ITextPara*,float ,int ,int ,winmdroot.Foundation.HRESULT> AddTab_52; internal delegate *unmanaged [Stdcall]<ITextPara*,winmdroot.Foundation.HRESULT> ClearAllTabs_53; internal delegate *unmanaged [Stdcall]<ITextPara*,float ,winmdroot.Foundation.HRESULT> DeleteTab_54; internal delegate *unmanaged [Stdcall]<ITextPara*,int ,float* ,int* ,int* ,winmdroot.Foundation.HRESULT> GetTab_55; } public static void PopulateVTable(Vtbl* vtable) { vtable->GetDuplicate_8 = &GetDuplicate; vtable->SetDuplicate_9 = &SetDuplicate; vtable->CanChange_10 = &CanChange; vtable->IsEqual_11 = &IsEqual; vtable->Reset_12 = &Reset; vtable->GetStyle_13 = &GetStyle; vtable->SetStyle_14 = &SetStyle; vtable->GetAlignment_15 = &GetAlignment; vtable->SetAlignment_16 = &SetAlignment; vtable->GetHyphenation_17 = &GetHyphenation; vtable->SetHyphenation_18 = &SetHyphenation; vtable->GetFirstLineIndent_19 = &GetFirstLineIndent; vtable->GetKeepTogether_20 = &GetKeepTogether; vtable->SetKeepTogether_21 = &SetKeepTogether; vtable->GetKeepWithNext_22 = &GetKeepWithNext; vtable->SetKeepWithNext_23 = &SetKeepWithNext; vtable->GetLeftIndent_24 = &GetLeftIndent; vtable->GetLineSpacing_25 = &GetLineSpacing; vtable->GetLineSpacingRule_26 = &GetLineSpacingRule; vtable->GetListAlignment_27 = &GetListAlignment; vtable->SetListAlignment_28 = &SetListAlignment; vtable->GetListLevelIndex_29 = &GetListLevelIndex; vtable->SetListLevelIndex_30 = &SetListLevelIndex; vtable->GetListStart_31 = &GetListStart; vtable->SetListStart_32 = &SetListStart; vtable->GetListTab_33 = &GetListTab; vtable->SetListTab_34 = &SetListTab; vtable->GetListType_35 = &GetListType; vtable->SetListType_36 = &SetListType; vtable->GetNoLineNumber_37 = &GetNoLineNumber; vtable->SetNoLineNumber_38 = &SetNoLineNumber; vtable->GetPageBreakBefore_39 = &GetPageBreakBefore; vtable->SetPageBreakBefore_40 = &SetPageBreakBefore; vtable->GetRightIndent_41 = &GetRightIndent; vtable->SetRightIndent_42 = &SetRightIndent; vtable->SetIndents_43 = &SetIndents; vtable->SetLineSpacing_44 = &SetLineSpacing; vtable->GetSpaceAfter_45 = &GetSpaceAfter; vtable->SetSpaceAfter_46 = &SetSpaceAfter; vtable->GetSpaceBefore_47 = &GetSpaceBefore; vtable->SetSpaceBefore_48 = &SetSpaceBefore; vtable->GetWidowControl_49 = &GetWidowControl; vtable->SetWidowControl_50 = &SetWidowControl; vtable->GetTabCount_51 = &GetTabCount; vtable->AddTab_52 = &AddTab; vtable->ClearAllTabs_53 = &ClearAllTabs; vtable->DeleteTab_54 = &DeleteTab; vtable->GetTab_55 = &GetTab; } private void** lpVtbl; /// <summary>The IID guid for this interface.</summary> /// <value>{8cc497c4-a1df-11ce-8098-00aa0047be5d}</value> internal static readonly Guid IID_Guid = new Guid(0x8CC497C4, 0xA1DF, 0x11CE, 0x80, 0x98, 0x00, 0xAA, 0x00, 0x47, 0xBE, 0x5D); static ref readonly Guid IComIID.Guid { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { ReadOnlySpan<byte> data = new byte[] { 0xC4,0x97,0xC4,0x8C,0xDF,0xA1,0xCE,0x11,0x80,0x98,0x00,0xAA,0x00,0x47,0xBE,0x5D }; return ref Unsafe.As<byte,Guid>(ref MemoryMarshal.GetReference(data)); } } [Guid("8CC497C4-A1DF-11CE-8098-00AA0047BE5D"),InterfaceType(ComInterfaceType.InterfaceIsDual),ComImport()] [SupportedOSPlatform("windows6.0.6000")] internal interface Interface { [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetDuplicate(winmdroot.UI.Controls.RichEdit.ITextPara** ppPara); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT SetDuplicate([Optional] winmdroot.UI.Controls.RichEdit.ITextPara* pPara); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT CanChange(int* pValue); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT IsEqual([Optional] winmdroot.UI.Controls.RichEdit.ITextPara* pPara, int* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT Reset(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetStyle(int* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetStyle(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetAlignment(int* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetAlignment(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetHyphenation(winmdroot.UI.Controls.RichEdit.tomConstants* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetHyphenation(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetFirstLineIndent(float* pValue); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetKeepTogether(winmdroot.UI.Controls.RichEdit.tomConstants* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetKeepTogether(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetKeepWithNext(winmdroot.UI.Controls.RichEdit.tomConstants* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetKeepWithNext(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetLeftIndent(float* pValue); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetLineSpacing(float* pValue); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetLineSpacingRule(int* pValue); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetListAlignment(int* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetListAlignment(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetListLevelIndex(int* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetListLevelIndex(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetListStart(int* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetListStart(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetListTab(float* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetListTab(float Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetListType(int* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetListType(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetNoLineNumber(int* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetNoLineNumber(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetPageBreakBefore(int* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetPageBreakBefore(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetRightIndent(float* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetRightIndent(float Value); [PreserveSig()] winmdroot.Foundation.HRESULT SetIndents(float First, float Left, float Right); [PreserveSig()] winmdroot.Foundation.HRESULT SetLineSpacing(int Rule, float Spacing); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetSpaceAfter(float* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetSpaceAfter(float Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetSpaceBefore(float* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetSpaceBefore(float Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetWidowControl(int* pValue); [PreserveSig()] winmdroot.Foundation.HRESULT SetWidowControl(int Value); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetTabCount(int* pCount); [PreserveSig()] winmdroot.Foundation.HRESULT AddTab(float tbPos, int tbAlign, int tbLeader); [PreserveSig()] winmdroot.Foundation.HRESULT ClearAllTabs(); [PreserveSig()] winmdroot.Foundation.HRESULT DeleteTab(float tbPos); [PreserveSig()] unsafe winmdroot.Foundation.HRESULT GetTab(int iTab, float* ptbPos, int* ptbAlign, int* ptbLeader); } } } }