/// <summary>
/// Returns a StylusPointCollection object for processing the data in the packet.
/// This method creates a new StylusPointCollection and copies the data.
/// </summary>
internal override StylusPointCollection GetStylusPoints(IInputElement relativeTo, StylusPointDescription subsetToReformatTo)
{
if (null == subsetToReformatTo)
{
throw new ArgumentNullException("subsetToReformatTo");
}
// Fake up an empty one if we have to.
if (_currentStylusPoints == null)
{
return(new StylusPointCollection(subsetToReformatTo));
}
return(_currentStylusPoints.Reformat(subsetToReformatTo, StylusDevice.GetElementTransform(relativeTo)));
}
void DescriptionSnippets()
{
//<Snippet17>
StylusPointDescription description1 =
new StylusPointDescription(new StylusPointPropertyInfo[]
{
new StylusPointPropertyInfo(StylusPointProperties.X),
new StylusPointPropertyInfo(StylusPointProperties.Y),
new StylusPointPropertyInfo(StylusPointProperties.NormalPressure),
new StylusPointPropertyInfo(StylusPointProperties.XTiltOrientation),
new StylusPointPropertyInfo(StylusPointProperties.YTiltOrientation),
new StylusPointPropertyInfo(StylusPointProperties.BarrelButton)
});
// Create a StylusPointCollection that uses description1 as its
// StylusPointDescription.
StylusPointCollection points = new StylusPointCollection(description1);
StylusPointDescription description2 =
new StylusPointDescription(new StylusPointPropertyInfo[]
{
new StylusPointPropertyInfo(StylusPointProperties.X),
new StylusPointPropertyInfo(StylusPointProperties.Y),
new StylusPointPropertyInfo(StylusPointProperties.NormalPressure),
new StylusPointPropertyInfo(StylusPointProperties.ButtonPressure),
new StylusPointPropertyInfo(StylusPointProperties.BarrelButton)
});
// Find the common StylusPointDescription between description1
// and description2. Get a StylusPointCollection that uses the
// common StylusPointDescription.
StylusPointDescription common =
StylusPointDescription.GetCommonDescription(description1, description2);
StylusPointCollection points2 = points.Reformat(common);
//</Snippet17>
//Add two styluspoints with different descriptions. Throws an exception.
//StylusPoint stylusPoint1 = new StylusPoint(100, 100, .5f, description1, new int[]{0, 0, 1});
//StylusPoint stylusPoint2 = new StylusPoint(200, 200, .35f, description2, new int[] {0, 1 });
//StylusPointCollection points3 = new StylusPointCollection(
// new StylusPoint[] { stylusPoint1, stylusPoint2 });
//StylusPointCollection points4 = new StylusPointCollection(description1);
//StylusPoint stylusPoint1 = new StylusPoint(100, 100, .5f);
//points4.Add(stylusPoint1);
//MessageBox.Show(points2.Count.ToString());
}
private void InitializeCapture(InputDevice inputDevice, IStylusEditing stylusEditingBehavior, bool userInitiated, bool resetDynamicRenderer)
{
this._capturedStylus = (inputDevice as StylusDevice);
this._capturedMouse = (inputDevice as MouseDevice);
if (this._capturedStylus != null)
{
StylusPointCollection stylusPoints = this._capturedStylus.GetStylusPoints(this._inkCanvas);
this._commonDescription = StylusPointDescription.GetCommonDescription(this._inkCanvas.DefaultStylusPointDescription, stylusPoints.Description);
StylusPointCollection stylusPoints2 = stylusPoints.Reformat(this._commonDescription);
if (resetDynamicRenderer)
{
InkCollectionBehavior inkCollectionBehavior = stylusEditingBehavior as InkCollectionBehavior;
if (inkCollectionBehavior != null)
{
inkCollectionBehavior.ResetDynamicRenderer();
}
}
stylusEditingBehavior.AddStylusPoints(stylusPoints2, userInitiated);
this._inkCanvas.CaptureStylus();
if (this._inkCanvas.IsStylusCaptured && this.ActiveEditingMode != InkCanvasEditingMode.None)
{
this._inkCanvas.AddHandler(Stylus.StylusMoveEvent, new StylusEventHandler(this.OnInkCanvasDeviceMove <StylusEventArgs>));
this._inkCanvas.AddHandler(UIElement.LostStylusCaptureEvent, new StylusEventHandler(this.OnInkCanvasLostDeviceCapture <StylusEventArgs>));
return;
}
this._capturedStylus = null;
return;
}
else
{
this._commonDescription = null;
Point[] points = new Point[]
{
this._capturedMouse.GetPosition(this._inkCanvas)
};
StylusPointCollection stylusPoints2 = new StylusPointCollection(points);
stylusEditingBehavior.AddStylusPoints(stylusPoints2, userInitiated);
this._inkCanvas.CaptureMouse();
if (this._inkCanvas.IsMouseCaptured && this.ActiveEditingMode != InkCanvasEditingMode.None)
{
this._inkCanvas.AddHandler(Mouse.MouseMoveEvent, new MouseEventHandler(this.OnInkCanvasDeviceMove <MouseEventArgs>));
this._inkCanvas.AddHandler(UIElement.LostMouseCaptureEvent, new MouseEventHandler(this.OnInkCanvasLostDeviceCapture <MouseEventArgs>));
return;
}
this._capturedMouse = null;
return;
}
}
private void UpdateStateForSystemGesture(SystemGesture gesture, RawStylusSystemGestureInputReport report)
{
switch (gesture)
{
case SystemGesture.Tap:
case SystemGesture.Drag:
// request the next mouse move to become LeftButtonDown
_fLeftButtonDownTrigger = true;
_fGestureWasFired = true;
break;
case SystemGesture.RightTap:
case SystemGesture.RightDrag:
// request the next mouse move to become RightButtonDown
_fLeftButtonDownTrigger = false;
_fGestureWasFired = true;
break;
case SystemGesture.HoldEnter:
// press & hold animation started..
_seenHoldEnterGesture = true;
break;
case SystemGesture.Flick:
// We don't do any mouse promotion for a flick!
_fGestureWasFired = true;
// Update the stylus location info just for flick gestures. This is because
// we want to fire the flick event not from the last stylus location
// (end of flick gesture) but from the beginning of the flick gesture
// (stylus down point) since this is the element that we query whether they
// allow flicks and since scrolling is targetted we need to scroll the
// element you really flicked on.
// Only route the flick if we have data we can send.
if (report != null && report.InputSource != null && _eventStylusPoints != null && _eventStylusPoints.Count > 0)
{
StylusPoint stylusPoint = _eventStylusPoints[_eventStylusPoints.Count - 1];
stylusPoint.X = report.GestureX;
stylusPoint.Y = report.GestureY;
// Update the current point with this data.
_eventStylusPoints = new StylusPointCollection(stylusPoint.Description,
stylusPoint.GetPacketData(),
GetTabletToElementTransform(null),
Matrix.Identity);
PresentationSource inputSource = DetermineValidSource(report.InputSource, _eventStylusPoints, report.PenContext.Contexts);
if (inputSource != null)
{
// See if we need to remap the stylus data X and Y values to different presentation source.
if (inputSource != report.InputSource)
{
Point newWindowLocation = PointUtil.ClientToScreen(new Point(0, 0), inputSource);
newWindowLocation = _stylusLogic.MeasureUnitsFromDeviceUnits(newWindowLocation);
Point oldWindowLocation = _stylusLogic.MeasureUnitsFromDeviceUnits(report.PenContext.Contexts.DestroyedLocation);
// Create translate matrix transform to shift coords to map points to new window location.
MatrixTransform additionalTransform = new MatrixTransform(new Matrix(1, 0, 0, 1,
oldWindowLocation.X - newWindowLocation.X,
oldWindowLocation.Y - newWindowLocation.Y));
_eventStylusPoints = _eventStylusPoints.Reformat(report.StylusPointDescription, additionalTransform);
}
_rawPosition = _eventStylusPoints[_eventStylusPoints.Count - 1];
_inputSource = new SecurityCriticalDataClass<PresentationSource>(inputSource);
Point pt = _stylusLogic.DeviceUnitsFromMeasureUnits((Point)_rawPosition);
_lastScreenLocation = PointUtil.ClientToScreen(pt, inputSource);
}
}
break;
}
}
internal void UpdateState(RawStylusInputReport report)
{
Debug.Assert(report.TabletDeviceId == _tabletDevice.Id);
Debug.Assert((report.Actions & RawStylusActions.None) == 0);
_eventStylusPoints =
new StylusPointCollection( report.StylusPointDescription,
report.GetRawPacketData(),
GetTabletToElementTransform(null),
Matrix.Identity);
PresentationSource inputSource = DetermineValidSource(report.InputSource, _eventStylusPoints, report.PenContext.Contexts);
// See if we need to remap the stylus data X and Y values to different presentation source.
if (inputSource != null && inputSource != report.InputSource)
{
Point newWindowLocation = PointUtil.ClientToScreen(new Point(0, 0), inputSource);
newWindowLocation = _stylusLogic.MeasureUnitsFromDeviceUnits(newWindowLocation);
Point oldWindowLocation = _stylusLogic.MeasureUnitsFromDeviceUnits(report.PenContext.Contexts.DestroyedLocation);
// Create translate matrix transform to shift coords to map points to new window location.
MatrixTransform additionalTransform = new MatrixTransform(new Matrix(1, 0, 0, 1,
oldWindowLocation.X - newWindowLocation.X,
oldWindowLocation.Y - newWindowLocation.Y));
_eventStylusPoints = _eventStylusPoints.Reformat(report.StylusPointDescription, additionalTransform);
}
_rawPosition = _eventStylusPoints[_eventStylusPoints.Count - 1];
_inputSource = new SecurityCriticalDataClass<PresentationSource>(inputSource);
if (inputSource != null)
{
// Update our screen position from this move.
Point pt = _stylusLogic.DeviceUnitsFromMeasureUnits((Point)_rawPosition);
_lastScreenLocation = PointUtil.ClientToScreen(pt, inputSource);
}
// If we are not blocked from updating the location we want to use for the
// promoted mouse location then update it. We set this flag in the post process phase
// of Stylus events (after they have fired).
if (!_fBlockMouseMoveChanges)
{
_lastMouseScreenLocation = _lastScreenLocation;
}
if ((report.Actions & RawStylusActions.Down) != 0 ||
(report.Actions & RawStylusActions.Move) != 0)
{
_fInAir = false;
// Keep the stylus down location for turning system gestures into mouse event
if ((report.Actions & RawStylusActions.Down) != 0)
{
_needToSendMouseDown = true;
// reset the gesture flag. This is used to determine if we will need to fabricate a systemgesture tap on the
// corresponding up event.
_fGestureWasFired = false;
_fDetectedDrag = false;
_seenHoldEnterGesture = false;
// Make sure our drag and move deltas are up to date.
TabletDevice.UpdateSizeDeltas(report.StylusPointDescription, _stylusLogic);
}
// See if we need to do our own Drag detection (on Stylus Move event)
else if (inputSource != null && _fBlockMouseMoveChanges && _seenDoubleTapGesture && !_fGestureWasFired && !_fDetectedDrag)
{
Size delta = TabletDevice.CancelSize;
// We use the first point of the packet data for Drag detection to try and
// filter out cases where the stylus skips when going down.
Point dragPosition =(Point)_eventStylusPoints[0];
dragPosition = _stylusLogic.DeviceUnitsFromMeasureUnits(dragPosition);
dragPosition = PointUtil.ClientToScreen(dragPosition, inputSource);
// See if we need to detect a Drag gesture. If so do the calculation.
if ((Math.Abs(_lastMouseScreenLocation.X - dragPosition.X) > delta.Width) ||
(Math.Abs(_lastMouseScreenLocation.Y - dragPosition.Y) > delta.Height))
{
_fDetectedDrag = true;
}
}
}
UpdateEventStylusPoints(report, false);
if ((report.Actions & RawStylusActions.Up) != 0 ||
(report.Actions & RawStylusActions.InAirMove) != 0)
{
_fInAir = true;
if ((report.Actions & RawStylusActions.Up) != 0)
{
_sawMouseButton1Down = false; // reset this on Stylus Up.
}
}
}
/// <summary>
/// Retrieve the packet description, packets data and XFORM which is the information the native recognizer needs.
/// The method is called from AddStrokes.
/// </summary>
private void GetPacketData
(
Stroke stroke,
out MS.Win32.Recognizer.PACKET_DESCRIPTION packetDescription,
out int countOfBytes,
out IntPtr packets,
out NativeMethods.XFORM xForm
)
{
int i;
countOfBytes = 0;
packets = IntPtr.Zero;
packetDescription = new MS.Win32.Recognizer.PACKET_DESCRIPTION();
Matrix matrix = Matrix.Identity;
xForm = new NativeMethods.XFORM((float)(matrix.M11), (float)(matrix.M12), (float)(matrix.M21),
(float)(matrix.M22), (float)(matrix.OffsetX), (float)(matrix.OffsetY));
StylusPointCollection stylusPoints = stroke.StylusPoints;
if (stylusPoints.Count == 0)
{
return; //we'll fail when the calling routine sees that packets is IntPtr.Zer
}
if (stylusPoints.Description.PropertyCount > StylusPointDescription.RequiredCountOfProperties)
{
//
// reformat to X, Y, P
//
StylusPointDescription reformatDescription
= new StylusPointDescription(
new StylusPointPropertyInfo[] {
new StylusPointPropertyInfo(StylusPointProperties.X),
new StylusPointPropertyInfo(StylusPointProperties.Y),
stylusPoints.Description.GetPropertyInfo(StylusPointProperties.NormalPressure)
});
stylusPoints = stylusPoints.Reformat(reformatDescription);
}
//
// now make sure we only take a finite amount of data for the stroke
//
if (stylusPoints.Count > MaxStylusPoints)
{
stylusPoints = stylusPoints.Clone(MaxStylusPoints);
}
Guid[] propertyGuids = new Guid[] { StylusPointPropertyIds.X, //required index for SPD
StylusPointPropertyIds.Y, //required index for SPD
StylusPointPropertyIds.NormalPressure }; //required index for SPD
Debug.Assert(stylusPoints != null);
Debug.Assert(propertyGuids.Length == StylusPointDescription.RequiredCountOfProperties);
// Get the packet description
packetDescription.cbPacketSize = (uint)(propertyGuids.Length * Marshal.SizeOf(typeof(Int32)));
packetDescription.cPacketProperties = (uint)propertyGuids.Length;
//
// use X, Y defaults for metrics, sometimes mouse metrics can be bogus
// always use NormalPressure metrics, though.
//
StylusPointPropertyInfo[] infosToUse = new StylusPointPropertyInfo[StylusPointDescription.RequiredCountOfProperties];
infosToUse[StylusPointDescription.RequiredXIndex] = StylusPointPropertyInfoDefaults.X;
infosToUse[StylusPointDescription.RequiredYIndex] = StylusPointPropertyInfoDefaults.Y;
infosToUse[StylusPointDescription.RequiredPressureIndex] =
stylusPoints.Description.GetPropertyInfo(StylusPointProperties.NormalPressure);
MS.Win32.Recognizer.PACKET_PROPERTY[] packetProperties =
new MS.Win32.Recognizer.PACKET_PROPERTY[packetDescription.cPacketProperties];
StylusPointPropertyInfo propertyInfo;
for (i = 0; i < packetDescription.cPacketProperties; i++)
{
packetProperties[i].guid = propertyGuids[i];
propertyInfo = infosToUse[i];
MS.Win32.Recognizer.PROPERTY_METRICS propertyMetrics = new MS.Win32.Recognizer.PROPERTY_METRICS( );
propertyMetrics.nLogicalMin = propertyInfo.Minimum;
propertyMetrics.nLogicalMax = propertyInfo.Maximum;
propertyMetrics.Units = (int)(propertyInfo.Unit);
propertyMetrics.fResolution = propertyInfo.Resolution;
packetProperties[i].PropertyMetrics = propertyMetrics;
}
unsafe
{
int allocationSize = (int)(Marshal.SizeOf(typeof(MS.Win32.Recognizer.PACKET_PROPERTY)) * packetDescription.cPacketProperties);
packetDescription.pPacketProperties = Marshal.AllocCoTaskMem(allocationSize);
MS.Win32.Recognizer.PACKET_PROPERTY *pPacketProperty =
(MS.Win32.Recognizer.PACKET_PROPERTY *)(packetDescription.pPacketProperties.ToPointer());
MS.Win32.Recognizer.PACKET_PROPERTY *pElement = pPacketProperty;
for (i = 0; i < packetDescription.cPacketProperties; i++)
{
Marshal.StructureToPtr(packetProperties[i], new IntPtr(pElement), false);
pElement++;
}
}
// Get packet data
int[] rawPackets = stylusPoints.ToHiMetricArray();
int packetCount = rawPackets.Length;
if (packetCount != 0)
{
countOfBytes = packetCount * Marshal.SizeOf(typeof(Int32));
packets = Marshal.AllocCoTaskMem(countOfBytes);
Marshal.Copy(rawPackets, 0, packets, packetCount);
}
}
