/// <summary>
/// An array of <see cref="MappingDataRange">MappingDataRange</see> objects containing all recognized text range results. This member is populated
/// by MappingService.RecognizeText or asynchronously with
/// MappingService.BeginRecognizeText.
/// </summary>
public MappingDataRange[] GetResultRanges()
{
MappingDataRange[] result = new MappingDataRange[_win32PropertyBag._rangesCount];
for (int i = 0; i < result.Length; ++i)
{
MappingDataRange range = new MappingDataRange();
InteropTools.Unpack(out range._win32DataRange,
(IntPtr)((UInt64)_win32PropertyBag._ranges + ((UInt64)i * InteropTools.SizeOfWin32DataRange)));
result[i] = range;
}
return(result);
}
/// <summary>
/// Frees all unmanaged resources allocated for the property bag.
/// </summary>
public void Dispose()
{
if (Interlocked.CompareExchange(ref _isFinalized, 0, 0) == 0)
{
bool result = DisposeInternal();
if (result)
{
_serviceCache.UnregisterResource();
InteropTools.Free <Win32Options>(ref _options);
_text.Free();
Interlocked.CompareExchange(ref _isFinalized, 1, 0);
}
}
}
internal MappingPropertyBag(MappingOptions options, string text)
{
_serviceCache = ServiceCache.Instance;
if (!_serviceCache.RegisterResource())
{
throw new LinguisticException();
}
_win32PropertyBag._size = InteropTools.SizeOfWin32PropertyBag;
if (options != null)
{
_options = InteropTools.Pack(ref options._win32Options);
}
_text = GCHandle.Alloc(text, GCHandleType.Pinned);
}
/// <summary>
/// An array of <see cref="MappingDataRange">MappingDataRange</see> objects containing all recognized text range results. This member
/// is populated by MappingService.RecognizeText or asynchronously with MappingService.BeginRecognizeText.
/// </summary>
public MappingDataRange[] GetResultRanges()
{
var result = new MappingDataRange[_win32PropertyBag._rangesCount];
for (var i = 0; i < result.Length; ++i)
{
var range = new MappingDataRange
{
_win32DataRange = InteropTools.Unpack <Win32DataRange>(
(IntPtr)((ulong)_win32PropertyBag._ranges + ((ulong)i * InteropTools.SizeOfWin32DataRange)))
};
result[i] = range;
}
return(result);
}
private MappingService(IntPtr pService)
{
_service = pService;
_win32Service = InteropTools.Unpack <Win32Service>(_service);
}
/// <summary>
/// Constructs a new <see cref="MappingService">MappingService</see> object by instanciating an ELS service
/// by its guid. For Windows 7, the only supported GUIDs are provided as
/// readonly members of the <see cref="MappingAvailableServices">MappingAvailableServices</see> class.
///
/// If the service
/// with the specified guid doesn't exist, a <see cref="LinguisticException">LinguisticException</see> is thrown.
/// </summary>
/// <param name="serviceIdentifier">The guid of the service to instantiate.</param>
public MappingService(Guid serviceIdentifier)
{
ThrowIfNotWin7();
IntPtr servicePointer;
UInt32 serviceCount = 0;
UInt32 hresult = 0;
// First, check to see if we already have the service in the cache:
servicePointer = ServiceCache.Instance.GetCachedService(ref serviceIdentifier);
if (servicePointer != IntPtr.Zero)
{
_service = servicePointer;
_win32Service = InteropTools.Unpack <Win32Service>(_service);
}
else // pService is IntPtr.Zero in this case.
{
// If we don't, we must find it via MappingGetServices:
IntPtr guidPtr = IntPtr.Zero;
try
{
guidPtr = Marshal.AllocHGlobal(InteropTools.SizeOfGuid);
Win32EnumOptions enumOptions = new Win32EnumOptions();
enumOptions._size = InteropTools.SizeOfWin32EnumOptions;
Marshal.StructureToPtr(serviceIdentifier, guidPtr, false);
enumOptions._pGuid = guidPtr;
hresult = Win32NativeMethods.MappingGetServices(ref enumOptions, ref servicePointer, ref serviceCount);
if (hresult != 0)
{
throw new LinguisticException(hresult);
}
if (servicePointer == IntPtr.Zero)
{
throw new InvalidOperationException();
}
if (serviceCount != 1)
{
hresult = Win32NativeMethods.MappingFreeServices(servicePointer);
if (hresult == 0)
{
throw new InvalidOperationException();
}
else
{
throw new LinguisticException(hresult);
}
}
IntPtr[] services = new IntPtr[1];
ServiceCache.Instance.RegisterServices(ref servicePointer, services);
_service = services[0];
_win32Service = InteropTools.Unpack <Win32Service>(_service);
}
finally
{
if (servicePointer != IntPtr.Zero)
{
// Ignore the result if an exception is being thrown.
Win32NativeMethods.MappingFreeServicesVoid(servicePointer);
}
if (guidPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(guidPtr);
}
}
}
}
public MappingService(Guid serviceGuid)
{
// Throw PlatformNotSupportedException if not running on Win7 or greater
ThrowIfNotWin7();
IntPtr pService;
UInt32 dwServiceCount = 0;
UInt32 hResult = 0;
// First, check to see if we already have the service in the cache:
pService = ServiceCache.Instance.GetCachedService(ref serviceGuid);
if (pService != IntPtr.Zero)
{
_service = pService;
InteropTools.Unpack(out _win32Service, _service);
}
else // pService is IntPtr.Zero in this case.
{
// If we don't, we must find it via MappingGetServices:
IntPtr guidPtr = IntPtr.Zero;
try
{
guidPtr = Marshal.AllocHGlobal(InteropTools.SizeOfGuid);
Win32EnumOptions enumOptions = new Win32EnumOptions();
enumOptions._size = InteropTools.SizeOfWin32EnumOptions;
Marshal.StructureToPtr(serviceGuid, guidPtr, false);
enumOptions._pGuid = guidPtr;
hResult = Win32Methods.MappingGetServices(ref enumOptions, ref pService, ref dwServiceCount);
if (hResult != 0)
{
throw new LinguisticException(hResult);
}
if (pService == IntPtr.Zero)
{
throw new InvalidOperationException();
}
if (dwServiceCount != 1)
{
hResult = Win32Methods.MappingFreeServices(pService);
if (hResult == 0)
{
throw new InvalidOperationException();
}
else
{
throw new LinguisticException(hResult);
}
}
IntPtr[] services = new IntPtr[1];
ServiceCache.Instance.RegisterServices(ref pService, services);
_service = services[0];
InteropTools.Unpack(out _win32Service, _service);
}
finally
{
if (pService != IntPtr.Zero)
{
// Ignore the result if an exception is being thrown.
Win32Methods.MappingFreeServices(pService);
}
if (guidPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(guidPtr);
}
}
}
}
private MappingService(IntPtr pService)
{
_service = pService;
InteropTools.Unpack(out _win32Service, _service);
}