/// <summary> /// Invokes GetAlternateList in the native dll /// </summary> /// <returns></returns> private GestureRecognitionResult[] InvokeGetAlternateList() { GestureRecognitionResult[] recResults = new GestureRecognitionResult[] { }; int hr = 0; MS.Win32.Recognizer.RECO_RANGE recoRange; recoRange.iwcBegin = 0; recoRange.cCount = 1; uint countOfAlternates = IRAS_DefaultCount; IntPtr[] pRecoAlternates = new IntPtr[IRAS_DefaultCount]; try { hr = MS.Win32.Recognizer.UnsafeNativeMethods.GetAlternateList(_hContext, ref recoRange, ref countOfAlternates, pRecoAlternates, MS.Win32.Recognizer.ALT_BREAKS.ALT_BREAKS_SAME); if (HRESULT.Succeeded(hr) && countOfAlternates != 0) { List <GestureRecognitionResult> resultList = new List <GestureRecognitionResult>(); for (int i = 0; i < countOfAlternates; i++) { uint size = 1; // length of string == 1 since gesture id is a single WCHAR StringBuilder recoString = new StringBuilder(1); RecognitionConfidence confidenceLevel; if (HRESULT.Failed(MS.Win32.Recognizer.UnsafeNativeMethods.GetString(pRecoAlternates[i], out recoRange, ref size, recoString)) || HRESULT.Failed(MS.Win32.Recognizer.UnsafeNativeMethods.GetConfidenceLevel(pRecoAlternates[i], out recoRange, out confidenceLevel))) { // Fail to retrieve the reco result, skip this one continue; } ApplicationGesture gesture = (ApplicationGesture)recoString[0]; Debug.Assert(ApplicationGestureHelper.IsDefined(gesture)); if (ApplicationGestureHelper.IsDefined(gesture)) { resultList.Add(new GestureRecognitionResult(confidenceLevel, gesture)); } } recResults = resultList.ToArray(); } } finally { // Destroy the alternates for (int i = 0; i < countOfAlternates; i++) { if (pRecoAlternates[i] != IntPtr.Zero) { #pragma warning suppress 6031, 56031 // Return value ignored on purpose. MS.Win32.Recognizer.UnsafeNativeMethods.DestroyAlternate(pRecoAlternates[i]); pRecoAlternates[i] = IntPtr.Zero; } } } return(recResults); }
protected override void OnGesture(InkCanvasGestureEventArgs e) { GestureRecognitionResult Result = e.GetGestureRecognitionResults()[0]; if (Result.ApplicationGesture != ApplicationGesture.NoGesture && Result.RecognitionConfidence <= Confidence) { if (this.Gesture != null) { Gesture(Result.ApplicationGesture); } } }
/// <summary> /// This is the InkCanvas gesture event handler. Here certain gestures are received /// and acted upon accordingly. /// </summary> void InkCanvas_Gesture(object sender, InkCanvasGestureEventArgs e) { GestureRecognitionResult topResult = e.GetGestureRecognitionResults()[0]; if (topResult.RecognitionConfidence == RecognitionConfidence.Strong) { ApplicationGesture gesture = topResult.ApplicationGesture; switch (gesture) { case ApplicationGesture.ScratchOut: StrokeCollection strokesToRemove = myInkCanvas.Strokes.HitTest(e.Strokes.GetBounds(), 10); if (strokesToRemove.Count > 0) { myInkCanvas.Strokes.Remove(strokesToRemove); } break; case ApplicationGesture.Right: myScrollViewer.ScrollToHorizontalOffset(myScrollViewer.HorizontalOffset + 30); break; case ApplicationGesture.Left: myScrollViewer.ScrollToHorizontalOffset(myScrollViewer.HorizontalOffset - 30); break; case ApplicationGesture.Up: myScrollViewer.ScrollToVerticalOffset(myScrollViewer.VerticalOffset - 30); break; case ApplicationGesture.Down: myScrollViewer.ScrollToVerticalOffset(myScrollViewer.VerticalOffset + 30); break; } } }
/// <summary> /// Invokes GetLatticePtr in the native dll /// </summary> /// <returns></returns> private GestureRecognitionResult[] InvokeGetLatticePtr() { GestureRecognitionResult[] recResults = new GestureRecognitionResult[] { }; // int hr = 0; IntPtr ptr = IntPtr.Zero; // NOTICE-2005/07/11-WAYNEZEN, // There is no need to free the returned the structure. // The memory will be released when ResetContext, which is invoked in the callee - Recognize, is called. if (HRESULT.Succeeded( MS.Win32.Recognizer.UnsafeNativeMethods.GetLatticePtr( _hContext, ref ptr))) { unsafe { MS.Win32.Recognizer.RECO_LATTICE *pRecoLattice = (MS.Win32.Recognizer.RECO_LATTICE *)ptr; uint bestResultColumnCount = pRecoLattice->ulBestResultColumnCount; Debug.Assert(!(bestResultColumnCount != 0 && pRecoLattice->pLatticeColumns == IntPtr.Zero), "Invalid results!"); if (bestResultColumnCount > 0 && pRecoLattice->pLatticeColumns != IntPtr.Zero) { List <GestureRecognitionResult> resultList = new List <GestureRecognitionResult>(); MS.Win32.Recognizer.RECO_LATTICE_COLUMN *pLatticeColumns = (MS.Win32.Recognizer.RECO_LATTICE_COLUMN *)(pRecoLattice->pLatticeColumns); ulong *pulBestResultColumns = (ulong *)(pRecoLattice->pulBestResultColumns); for (uint i = 0; i < bestResultColumnCount; i++) { ulong column = pulBestResultColumns[i]; MS.Win32.Recognizer.RECO_LATTICE_COLUMN recoColumn = pLatticeColumns[column]; Debug.Assert(0 < recoColumn.cLatticeElements, "Invalid results!"); for (int j = 0; j < recoColumn.cLatticeElements; j++) { MS.Win32.Recognizer.RECO_LATTICE_ELEMENT recoElement = ((MS.Win32.Recognizer.RECO_LATTICE_ELEMENT *)(recoColumn.pLatticeElements))[j]; Debug.Assert((RECO_TYPE)(recoElement.type) == RECO_TYPE.RECO_TYPE_WCHAR, "The Application gesture has to be WCHAR type"); if ((RECO_TYPE)(recoElement.type) == RECO_TYPE.RECO_TYPE_WCHAR) { // Retrieve the confidence lever RecognitionConfidence confidenceLevel = RecognitionConfidence.Poor; MS.Win32.Recognizer.RECO_LATTICE_PROPERTIES recoProperties = recoElement.epProp; uint propertyCount = recoProperties.cProperties; MS.Win32.Recognizer.RECO_LATTICE_PROPERTY **apProps = (MS.Win32.Recognizer.RECO_LATTICE_PROPERTY * *)recoProperties.apProps; for (int k = 0; k < propertyCount; k++) { MS.Win32.Recognizer.RECO_LATTICE_PROPERTY *pProps = apProps[k]; if (pProps->guidProperty == GUID_CONFIDENCELEVEL) { Debug.Assert(pProps->cbPropertyValue == sizeof(uint) / sizeof(byte)); RecognitionConfidence level = (RecognitionConfidence)(((uint *)pProps->pPropertyValue))[0]; if (level >= RecognitionConfidence.Strong && level <= RecognitionConfidence.Poor) { confidenceLevel = level; } break; } } ApplicationGesture gesture = (ApplicationGesture)((char)(recoElement.pData)); Debug.Assert(ApplicationGestureHelper.IsDefined(gesture)); if (ApplicationGestureHelper.IsDefined(gesture)) { // Get the gesture result resultList.Add(new GestureRecognitionResult(confidenceLevel, gesture)); } } } } recResults = (GestureRecognitionResult[])(resultList.ToArray()); } } } return(recResults); }
/// <summary> /// Recognize the strokes. /// </summary> /// <param name="strokes"></param> /// <returns></returns> internal GestureRecognitionResult[] Recognize(StrokeCollection strokes) { if (_disposed) { throw new ObjectDisposedException("NativeRecognizer"); } // // note that we validate this argument from GestureRecognizer // but since this is marked TAS, we want to do it here as well // if (strokes == null) { throw new ArgumentNullException("strokes"); // Null is not allowed as the argument value } if (strokes.Count > 2) { throw new ArgumentException(SR.Get(SRID.StrokeCollectionCountTooBig), "strokes"); } // Create an empty result. GestureRecognitionResult[] recResults = new GestureRecognitionResult[] {}; if (strokes.Count == 0) { return(recResults); } int hr = 0; try { // Reset the context hr = MS.Win32.Recognizer.UnsafeNativeMethods.ResetContext(_hContext); if (HRESULT.Failed(hr)) { //finally block will clean up and throw return(recResults); } // Add strokes hr = AddStrokes(_hContext, strokes); if (HRESULT.Failed(hr)) { //AddStrokes's finally block will clean up this finally block will throw return(recResults); } // recognize the ink bool bIncremental; hr = MS.Win32.Recognizer.UnsafeNativeMethods.Process(_hContext, out bIncremental); if (HRESULT.Succeeded(hr)) { if (s_GetAlternateListExists) { recResults = InvokeGetAlternateList(); } else { recResults = InvokeGetLatticePtr(); } } } finally { // Check if we should report any error. if (HRESULT.Failed(hr)) { //don't throw a com exception here, we don't need to pass out any details throw new InvalidOperationException(SR.Get(SRID.UnspecifiedGestureException)); } } return(recResults); }
void TouchCanvas_Gesture(object sender, InkCanvasGestureEventArgs e) { GestureRecognitionResult recognitionResult = e.GetGestureRecognitionResults().FirstOrDefault(); if (recognitionResult != null && recognitionResult.RecognitionConfidence == RecognitionConfidence.Strong && recognitionResult.ApplicationGesture == ApplicationGesture.ScratchOut) Strokes.Clear(); }
public GestureEventArgs(GestureRecognitionResult result, GestureType type) { this.Result = result; this.GestureType = type; }