/// <summary> /// Retrieves a list of available ELS platform-supported services, along with associated /// information, according to application-specified criteria. /// </summary> /// <param name="options">Optional. A <see cref="MappingEnumOptions">MappingEnumOptions</see> object containing criteria to use during /// enumeration of services. The application specifies null for this parameter to retrieve all /// installed services.</param> /// <returns>An array of <see cref="MappingService">MappingService</see> objects matching the criteria supplied in the options /// parameter.</returns> public static MappingService[] GetServices(MappingEnumOptions options) { // Throw PlatformNotSupportedException if not running on Win7 or greater ThrowIfNotWin7(); IntPtr pService = IntPtr.Zero; UInt32 dwServiceCount = 0; UInt32 hResult = 0; IntPtr guidPtr = IntPtr.Zero; try { if (options != null) { Win32EnumOptions enumOptions = options._win32EnumOption; Nullable <Guid> pGuid = options._guid; if (pGuid != null) { Guid guid = (Guid)pGuid; guidPtr = Marshal.AllocHGlobal(InteropTools.SizeOfGuid); Marshal.StructureToPtr(guid, guidPtr, false); enumOptions._pGuid = guidPtr; } hResult = Win32Methods.MappingGetServices(ref enumOptions, ref pService, ref dwServiceCount); } else { hResult = Win32Methods.MappingGetServices(IntPtr.Zero, ref pService, ref dwServiceCount); } if (hResult != 0) { throw new LinguisticException(hResult); } if ((pService == IntPtr.Zero) != (dwServiceCount == 0)) { throw new InvalidOperationException(); } IntPtr[] services = new IntPtr[dwServiceCount]; ServiceCache.Instance.RegisterServices(ref pService, services); MappingService[] result = new MappingService[dwServiceCount]; for (int i = 0; i < dwServiceCount; ++i) { result[i] = new MappingService(services[i]); } return(result); } finally { if (pService != IntPtr.Zero) { // Ignore the result if an exception is being thrown. Win32Methods.MappingFreeServices(pService); } if (guidPtr != IntPtr.Zero) { Marshal.FreeHGlobal(guidPtr); } } }
/// <summary> /// Causes an ELS service to perform an action after text recognition has occurred. For example, /// a phone dialer service first must recognize phone numbers and then can perform the "action" /// of dialing a number. /// </summary> /// <param name="bag">A <see cref="MappingPropertyBag">MappingPropertyBag</see> object containing the results of a previous call to /// MappingService.MappingRecognizeText. This parameter cannot be set to null.</param> /// <param name="rangeIndex">A starting index inside the text recognition results for a recognized /// text range. This value should be between 0 and the range count.</param> /// <param name="actionId">The identifier of the action to perform. /// This parameter cannot be set to null.</param> public void DoAction(MappingPropertyBag bag, int rangeIndex, string actionId) { if (rangeIndex < 0) { throw new LinguisticException(LinguisticException.E_INVALIDARG); } UInt32 hResult = Win32Methods.MappingDoAction(ref bag._win32PropertyBag, (uint)rangeIndex, actionId); if (hResult != 0) { throw new LinguisticException(hResult); } }
private bool DisposeInternal() { if (_win32PropertyBag._context == IntPtr.Zero) { return(true); } UInt32 hResult = Win32Methods.MappingFreePropertyBag(ref _win32PropertyBag); if (hResult != 0) { throw new LinguisticException(hResult); } return(true); }
private void FreeAllServices() { // Don't use synchronization here. // This will only be called during finalization // and at that point synchronization doesn't matter. // Also, the lock object might have already been finalized. if (_servicePointers != null) { foreach (IntPtr servicePtr in _servicePointers) { // Ignore the result, we need to continue anyway. Win32Methods.MappingFreeServices(servicePtr); } _servicePointers = null; _guidToService = null; } }
/// <summary> /// Calls an ELS service to recognize text. For example, the Microsoft Language Detection service /// will attempt to recognize the language in which the input text is written. /// </summary> /// <param name="text">The text to recognize. The text must be UTF-16, but some services have additional /// requirements for the input format. This parameter cannot be set to null.</param> /// <param name="length">Length, in characters, of the text specified in text.</param> /// <param name="index">Index inside the specified text to be used by the service. This value should be /// between 0 and length-1. If the application wants to process the entire text, it should set this /// parameter to 0.</param> /// <param name="options">Optional. A <see cref="MappingOptions">MappingOptions</see> object containing options that affect the result and /// behavior of text recognition. The application does not have to specify values for all object members. /// This parameter can be set to null to use the default mapping options.</param> /// <returns>A <see cref="MappingPropertyBag">MappingPropertyBag</see> object in which the service has stored its results. The structure is filled /// with information produced by the service during text recognition.</returns> public MappingPropertyBag RecognizeText(string text, int length, int index, MappingOptions options) { if (text == null) { throw new ArgumentNullException("text"); } if (length > text.Length || length < 0) { throw new ArgumentOutOfRangeException("length"); } if (index < 0) { throw new ArgumentOutOfRangeException("index"); } UInt32 hResult = LinguisticException.E_FAIL; MappingPropertyBag bag = new MappingPropertyBag(options, text); try { hResult = Win32Methods.MappingRecognizeText( _service, bag._text.AddrOfPinnedObject(), (uint)length, (uint)index, bag._options, ref bag._win32PropertyBag); if (hResult != 0) { throw new LinguisticException(hResult); } return(bag); } finally { if (hResult != 0) // S_OK { bag.Dispose(); } } }
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); } } } }