Stefan Wick's Weblog - Development with Silverlight, WPF and Tablet PC : Fun with Ink & Xaml

Fun with Ink & XAML Part4: WPF BitmapEffects applied to Ink

swick — Sun, 04 Nov 2007 21:47:00 GMT

Want to create some fancy looking handwritten text or drawing? Tweaking the standard DrawingAttributes on an ink stroke won't get you very far - and creating a custom ink renderer is a lot of work. Why not just apply some of the WPF BitmapEffects to your ink. All you need to do is add a few lines of markup to an <InkPresenter/> and you are done - see markup snippet below (the complete XAML file is attached to his post):

<InkPresenter.BitmapEffect>

<DropShadowBitmapEffect

Color="Black" Direction="20" Opacity="0.8" Noise="0.2" Softness="0.2"

ShadowDepth="{Binding ElementName=shadowSlider,Path=Value}"/>

<BlurBitmapEffect

KernelType='Gaussian'

Radius="{Binding ElementName=blurSlider,Path=Value}"/>

<OuterGlowBitmapEffect

GlowColor="Yellow" Noise="0.5" Opacity="0.5"

GlowSize="{Binding ElementName=glowSlider,Path=Value}"/>

<BevelBitmapEffect

BevelWidth="{Binding ElementName=bevelSlider,Path=Value}"/>

</BitmapEffectGroup>

</InkPresenter.BitmapEffect>

As you can tell from the above markup, I have bound some of the BitmapEffect properties to Slider controls, so you can change their values at runtime to see how it affects the look of your ink. To try it out on your computer, download the attached XAML file and open it in XamlPad (or use Visual Studio to create a WPF application from it).

Now what can you do with this? I think it's a great way to create images of fancy looking, personalized handwritten notes and drawings. You can export the resulting ink to a bitmap file and then use it on your website, in your application or on your blog. Here is some code-behind that takes a snapshot of the InkPresenter and writes it to a .png file:

RenderTargetBitmap target = new RenderTargetBitmap(

(int)inputCanvas.ActualWidth,

(int)inputCanvas.ActualHeight,

96d, 96d, PixelFormats.Default);

target.Render(effectsPresenter);

PngBitmapEncoder encoder = new PngBitmapEncoder();

encoder.Frames.Add(BitmapFrame.Create(target));

FileStream fs = File.Open(@"c:\stuff\InkWithEffects.png",

FileMode.OpenOrCreate);

encoder.Save(fs);

fs.Close();

General note about BitmapEffects: WPF bitmap effects are rendered in software mode. Any object that applies an effect will also be rendered in software. Performance is degraded the most when using Bitmap effects on large visuals or animating properties of a Bitmap effect. WPF bitmap effects do not support partial trust execution, so you cannot load my example code into IE. For more details on BitmapEffects visit this MSDN topic.

Previous post in this series: Fun with Ink & XAML Part3: Ink Data Binding

Fun with Ink & XAML Part3: Ink Data Binding

swick — Sat, 03 Nov 2007 16:18:00 GMT

Data binding in WPF provides a great way for applications to present and interact with data. Elements can be bound to data from a variety of data sources - for example XML files. I have put together a sample that uses data binding to retrieve a collection of handwritten ink documents from a data store (XML file), present it to the user and let the user interact with it. As always in this series, the task is accomplished by markup only - no code behind required. The sample markup (and the data file) is attached to this post.

Let's take a look at the sample markup, specifically what's inside the <Grid.Resources> tag. I have highlighted the sections that are relevant for the data binding:

<Grid.Resources>

<TextBlock HorizontalAlignment="Center" Foreground="Red"

Text="{Binding XPath=@FileName}"/>

<InkPresenter HorizontalAlignment="Center"

LayoutTransform="0.2,0,0,0.2,0,0">

<InkPresenter.Strokes>

</InkPresenter.Strokes>

</InkPresenter>

</StackPanel>

</DataTemplate>

</Grid.Resources>

The first item here is the XmlDataProvider. This class facilitates the access to XML data for data binding. The other item, our DataTemplate, defines how the data is being presented: The 'FileName' value gets assigned to a <TextBlock/> and the 'Strokes' value gets assigned to the Strokes property of an <InkPresenter/>.

To see how these two resources are being used in the actual UI markup, let's inspect the ListBox element. The ListBox is being used to display a thumbnail view of all ink documents in the data store and to let the user choose which document they want to view or edit.

<ListBox Name="lbStrokes" Background="AntiqueWhite"

ItemsSource="{Binding Source={StaticResource InkData},

XPath=InkFile}"

ItemTemplate="{StaticResource InkDataTemplate}"/>

Now to view and interact with the selected item from our ListBox, we are adding a larger InkCanvas element that is data-bound to the ListBox. So when the user selects a new ink note from the list, that document gets loaded into the InkCanvas automatically. Here is the relevant markup to set up that binding:

<InkCanvas DataContext="{Binding ElementName=lbStrokes,Path=SelectedItem}"

Strokes="{Binding XPath=@Strokes}"

Background="Snow">

Below is a screenshot of the sample that is attached to this post. To run it, unpack the .zip file and load the .xaml file into XamlPad - or just double-click it to open it in IE. Note that the data file (InkData.xml) must reside in the same location as the XAML file.

Next post in this series: Fun with Ink & XAML Part4: WPF BitmapEffects applied to Ink

Previous post in this series: Fun with Ink & Xaml - Part2: Zoom and Scroll

Fun with Ink & Xaml - Part2: Zoom and Scroll

swick — Fri, 02 Nov 2007 02:01:00 GMT

Here is some more fun with ink and Xaml: Scrolling and zooming ink content - in WPF it is as easy as 1,2,3:

1) place an InkCanvas inside a ScrollViewer

2) assign a ScaleTransform to InkCanvas' LayoutTransform

3) data-bind to ScaleX/ScaleY properties in order to zoom in and out

All of this can be done in XAML - no code-behind required. Compare the below simple piece of markup with the code amount and complexity of the Winforms Ink Zoom & Scroll sample from the TabletPC SDK.

<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">

<DockPanel>

    <Slider Name="zoomSlider" DockPanel.Dock="Top"

            Minimum="0.1" Maximum="5" Value="1"/>

    <ScrollViewer HorizontalScrollBarVisibility="Auto">

      <InkCanvas Background="Yellow">

        <InkCanvas.LayoutTransform>

          <ScaleTransform ScaleX="{Binding ElementName=zoomSlider,

                                           Path=Value}"

                          ScaleY="{Binding ElementName=zoomSlider,

                                           Path=Value}"/>

        </InkCanvas.LayoutTransform>

      </InkCanvas>

    </ScrollViewer>

</DockPanel>

</Page>

The XAML file for this sample is attached to this post. You can load it directly into IE or play with it in XamlPad (see screenshot below). Use the slider on top of the Ink control to adjust the zoom level.

Next post in this series: Fun with Ink & XAML Part3: Ink Data Binding

Previous post in this series: Fun with Ink & Xaml - Part1: Ink Reflections

Fun with Ink & Xaml - Part1: Ink Reflections

swick — Thu, 01 Nov 2007 00:44:00 GMT

With the InkCanvas element in WPF you can create stunning inking experiences for TabletPC users (mouse users can play along, too!). Several very cool scenarios can be enabled just by writing markup - without any additional code behind.

Here is a first example: an ink input field (takes input from either stylus or mouse) that has a dynamic reflection effect. While the user is inking, the reflection gets updated dynamically, in real-time. Implemented entirely in markup.

The key feature (besides InkCanvas) here is the VisualBrush. The bottom part of the scene is a Rectangle that gets painted with a VisualBrush that is bound to the ink input control. As a result it gets updated dynamically as the user draws onto the control. Below is the relevant piece of markup. The full XAML file is attached to this post. You can load it into XamlPad to play with it, or just open in IE and ink away.

<Rectangle.Fill>
    <VisualBrush
      Visual="{Binding ElementName=inkBorder}">
      <VisualBrush.RelativeTransform>
        <TransformGroup>
          <ScaleTransform ScaleX="1" ScaleY="-1" />
          <TranslateTransform Y="1" />
        </TransformGroup>
      </VisualBrush.RelativeTransform>
    </VisualBrush>
</Rectangle.Fill>

More information about creating reflections using VisualBrush can be found in this MSDN How-To Topic. Additional How-To topics on Ink in WPF are also available on MSDN.

Next post in this series: Fun with Ink & Xaml - Part2: Zoom and Scroll