예제 #1
0
 /// <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);
 }
예제 #2
0
 /// <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);
         }
     }
 }
예제 #3
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);
        }
예제 #5
0
 private MappingService(IntPtr pService)
 {
     _service      = pService;
     _win32Service = InteropTools.Unpack <Win32Service>(_service);
 }
예제 #6
0
        /// <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);
                    }
                }
            }
        }
예제 #7
0
        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);
                    }
                }
            }
        }
예제 #8
0
 private MappingService(IntPtr pService)
 {
     _service = pService;
     InteropTools.Unpack(out _win32Service, _service);
 }