|
// ------------------------------------------------------------------------------
// <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
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")]
[SupportedOSPlatform("windows6.0.6000")]
[global::System.CodeDom.Compiler.GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
internal unsafe partial struct ITextPara
:IVTable<ITextPara,ITextPara.Vtbl>,IComIID {
/// <inheritdoc cref="QueryInterface(global::System.Guid*, void**)"/>
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*)"/>
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.Length != rgDispId.Length) throw new ArgumentException();
this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )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*)"/>
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, winmdroot.System.Variant.VARIANT* pVarResult, winmdroot.System.Com.EXCEPINFO* pExcepInfo, uint* puArgErr)
{
fixed (winmdroot.System.Com.DISPPARAMS* pDispParamsLocal = &pDispParams)
{
fixed (global::System.Guid* riidLocal = &riid)
{
this.Invoke(dispIdMember, riidLocal, lcid, wFlags, pDispParamsLocal, pVarResult, pExcepInfo, puArgErr);
}
}
}
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 = 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 docs.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 docs.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 = 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 docs.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*)"/>
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 = 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 docs.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*)"/>
internal unsafe void IsEqual(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 = 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 docs.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 docs.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 docs.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 = 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 docs.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 docs.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*)"/>
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 = 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 docs.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 docs.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 = 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 docs.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 docs.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*)"/>
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 = 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 docs.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 = 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 docs.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 docs.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*)"/>
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 = 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 = 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 docs.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 docs.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*)"/>
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 = 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 docs.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 docs.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*)"/>
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 = 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 = 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 docs.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*)"/>
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 = 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 = 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 docs.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*)"/>
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 = 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 docs.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 docs.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*)"/>
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 = 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 docs.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*)"/>
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 = 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 docs.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*)"/>
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 = 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 = 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 docs.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 docs.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*)"/>
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 = 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 docs.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 docs.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 = 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 docs.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*)"/>
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 = 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 docs.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 = 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 docs.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*)"/>
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 = 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 docs.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 = 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 docs.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 docs.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*)"/>
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 = 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 docs.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 = 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 docs.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 docs.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*)"/>
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 = 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 = 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 docs.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 docs.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*)"/>
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 = 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 docs.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 = 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*)"/>
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 = 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 docs.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 docs.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 = 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 docs.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 docs.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 = 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 docs.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 docs.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 docs.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 = 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 docs.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 docs.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*)"/>
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 = 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 docs.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 docs.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 = 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 docs.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 docs.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*)"/>
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 = 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 docs.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 docs.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 = 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 docs.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 docs.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*)"/>
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 = 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 = 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 docs.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 docs.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*)"/>
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 = 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 docs.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 = 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 docs.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 docs.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 docs.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 = 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 docs.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 = 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 docs.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 docs.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*)"/>
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 = 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 docs.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 docs.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 docs.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 docs.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 docs.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
{
var hr = this.QueryInterface(typeof(T).GUID, out void* 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);
}
}
}
}
|