## #755 – Implementing Rotational Inertia during Touch Manipulation

In the same way that you can support inertia as a result of touch manipulation during translation and expansion, you can also set up rotational inertia.  When the user rotates an element using touch, the element has some initial rotational velocity (in deg/ms) when they lift their fingers off the screen.  You can then specify a desired value for a rotational deceleration (deg/ms^2).

As with translation and expansion, you specify the desired rotational deceleration in a handler for the ManipulationInertiaStarting event.  In the example below, we display the initial rotational velocity to the console and then specify a deceleration of 100 degrees/sec^2.  (Reduce velocity by 100 deg/sec each second).

```        private void Image_ManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
// Rotational inertia - 100 deg/sec^2 deceleration
Console.WriteLine(string.Format("Initial rotational velocity = {0} deg/sec",
e.RotationBehavior.InitialVelocity * 1000.0));
e.RotationBehavior.DesiredDeceleration = 100.0 / (1000.0 * 1000.0);
}
```

## #734 – Recognizing Different Fingers in Touch Event Handlers

When you’re handling low-level touch events in WPF and the user will be using more than one finger at a time on the screen, you’ll want to keep track of which finger is generating a particular touch event.  You can do this using the TouchEventArgs.TouchDevice.Id property.  Every touch event handler will report a different Id for each finger that is touching the screen.  Also, when you touch and drag a finger on the screen, the Id property will remain the same for all events associated with that finger.

Here’s an example.

```        private const double CircleWidth = 10;
private Dictionary<int, Point> LastPositionDict;

private void Canvas_TouchDown(object sender, TouchEventArgs e)
{
try
{
TouchPoint tp = e.GetTouchPoint(null);

}
catch (Exception xx)
{
MessageBox.Show(xx.ToString());
}
}

private void Canvas_TouchMove(object sender, TouchEventArgs e)
{
TouchPoint tp = e.GetTouchPoint(null);

LastPositionDict[e.TouchDevice.Id] = tp.Position;
}

private void Canvas_TouchUp(object sender, TouchEventArgs e)
{
TouchPoint tp = e.GetTouchPoint(null);

LastPositionDict.Remove(e.TouchDevice.Id);
}
```

Now I can draw with two fingers at the same time:

## #732 – Basic Events for Raw Touch Input

WPF includes a set of events for handling raw touch input.  These events are defined for all UIElement, ContentElement, and UIElement3D objects.

The most basic events are:

• TouchDown – User touches the screen
• TouchMove – User moves finger across the screen
• TouchUp – User lifts finger off the screen

Below is a simple example that allows drawing using touch.  We’ve defined event handlers and attached them to a main Canvas element.  A red circle is drawn at the TouchDown point and a blue circle at the TouchUp point.  A continuous line is drawn as the user moves their finger across the screen.

```        private const double CircleWidth = 10;
private Point LastPosition;

private void Canvas_TouchDown(object sender, TouchEventArgs e)
{
try
{
TouchPoint tp = e.GetTouchPoint(null);

LastPosition = tp.Position;
}
catch (Exception xx)
{
MessageBox.Show(xx.ToString());
}
}

private void Canvas_TouchMove(object sender, TouchEventArgs e)
{
TouchPoint tp = e.GetTouchPoint(null);

LastPosition = tp.Position;
}

private void Canvas_TouchUp(object sender, TouchEventArgs e)
{
TouchPoint tp = e.GetTouchPoint(null);

}

private void AddEllipseAt(Canvas canv, Point pt, Brush brush)
{
Ellipse el = new Ellipse();
el.Stroke = brush;
el.Fill = brush;
el.Width = CircleWidth;
el.Height = CircleWidth;

Canvas.SetLeft(el, pt.X - (CircleWidth / 2));
Canvas.SetTop(el, pt.Y - (CircleWidth / 2));

}

private void AddLineFromTo(Canvas canv, Point from, Point to, Brush brush)
{
Line l = new Line();
l.Stroke = brush;
l.X1 = from.X;
l.Y1 = from.Y;
l.X2 = to.X;
l.Y2 = to.Y;
l.StrokeThickness = 2;

}
```

So when I touch and drag on a touch-enabled device, I get something that looks like this:

## #717 – Drag-and-Drop with Touch on Windows 7

You can implement drag-and-drop on a touch-based system in a similar way to how you implement drag-and-drop using the mouse.

You start by defining a handler for the TouchDown event of the control that serves as a drag source.  You then define a handler for the Drop event of the control that is the drop target.

```    <StackPanel>
<Label Content="Benjamin Disraeli"
TouchDown="Label_TouchDown"/>
<Label Content="Drag to here"
AllowDrop="True" Drop="Label_Drop"/>
</StackPanel>
```

In the code-behind, you call the DoDragDrop method to initiate drag-and-drop.

```        // Drag source
private void Label_TouchDown(object sender, TouchEventArgs e)
{
Label l = e.Source as Label;
DragDrop.DoDragDrop(l, l.Content + " was Dragged!", DragDropEffects.Copy);
}

// Drag target
private void Label_Drop(object sender, DragEventArgs e)
{
string draggedText = (string)e.Data.GetData(DataFormats.StringFormat);
Label l = e.Source as Label;
l.Content = draggedText;
}
```

You can now touch and hold your finger down to drag.

## #617 – Input Events

Elements in WPF fire various type of input events, as a user interacts with the element.  There are four basic types of input events.

• Keyboard events – Fire when user presses keys on the keyboard
• Mouse events – Fire when a user does something with the mouse–e.g. moves the mouse or presses a mouse button
• Touch events – Fire when a user uses their finger to touch an element (requires touch-sensitive screen)
• Stylus events – Fire when the user uses a stylus device to touch an element on the screen  (requires a stylus device and touch-sensitive screen)