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