/// <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); }