RSS Feed
Download our iPhone app
Browse DevX
Sign up for e-mail newsletters from DevX


Using Ink on the Web

One of the more interesting and challenging places to use Ink is in Web applications. But how can this technology, which is dependent on the physical relationship between the stylus, the digitizer, and the operating system, work over the Internet?

he Tablet PC SDK makes it easy to get Ink onto your Web page, but then what? This article walks you through the easy part and then dives into some of the trickier stuff such as when (and how) to put the UI functionality into the control or onto the page, and how to get the Ink data from the page and over to the server side for sending it to a database. Additionally, you'll learn some of the concepts behind the functionality that will be not only be beneficial for troubleshooting but will also help you sound like a real guru at your next geek gathering.

The trick to bringing Ink to Web applications is embedding Windows controls. Although the Tablet PC SDK has a COM API and a managed API for .NET, it is only the .NET API that allows you to bring Ink to the Internet.

This article teaches you the basics that you need to ink-enable your Web applications, including the important concepts about security that you need to understand to make it work. The article also walks you through deploying an ink-enabled Web application and then dives into some of the more complicated problems of what to do with the Ink that you have collected in your Web application.

It's Just a Windows Forms Control with One Big Caveat
If you have ever embedded a Windows Forms control onto a Web page, you are already nearly a pro at ink-enabling your Web application. Let's look at the basics.

Start by creating a new Windows Control Library project and add a reference to the Microsoft Tablet PC API. Then you will ink-enable the entire surface of the new User Control just the way you would in a Windows Forms application, with just one twist.

When you instantiate the InkOverlay object, one of the overrides in the constructor is to hook it up with a control, rather than a Windows handle.

   Public Sub InkOverlay(ByVal attachedControl As _
This is one of the most important things to remember to use this control in a Web application. You must attach the InkOverlay object to the control itself, not its handle. The reason for this is related to the sometimes confusing topic of Code Access Security (CAS) and what an object has permission to do on your computer. This is something that Microsoft overcame with version 1.7 of the Tablet PC SDK. .NET protects your computer from all of the terrible things that Web sites might want to do to you. It does that by giving Internet Explorer only Partial Trust on your computer.

Code running with Partial Trust has restricted permissions on your computer. For example, such applications aren't allowed to delete a file. As you will see a little further on, your ink-enabled control is automatically downloaded to the client computer, where it is able to interact with the digitizer. However, nothing that is served from Internet Explorer will ever have a trust level higher than its host (Internet Explorer).

A Windows handle is part of the Win32 API, which is, of course, unmanaged code. Unmanaged code requires Full Trust. Because of Internet Explorer's Partial Trust restriction, it is not allowed to serve up components requiring Full Trust and therefore, if your Windows Forms control contains something that requires Full Trust, its compiled assembly will also require Full Trust and Internet Explorer will be unable to serve the Ink enabled control to your computer. If the attached control's window gets re-created, it can be automatically re-connected to the new Window. (.NET controls can re-create their windows unpredictably.)

By linking the InkOverlay to the control rather than its unmanaged Window handle, you are removing the requirement for Full Trust. As long as you don't put anything else in your project that requires Full Trust, the compiled dll will run under Partial Trust and be deployed to the client computer. That is why it is so very important to remember to choose the overload of the control when you are constructing the InkOverlay object.

Remember: you created a simple control and have ink-enabled its entire surface. The code for your Windows control, therefore, should look like this

   Imports Microsoft.Ink
   Namespace InkontheWeb
     Public Class MyInkControl
     Inherits System.Windows.Forms.UserControl
       [Region: Windows Form Designer generated code]
       Dim inko As InkOverlay
       Private Sub InkControl_Load (ByVal sender As _
          Object, ByVal e As System.EventArgs) Handles _
         inko = New InkOverlay(Me)
         inko.Enabled = True
      End Sub
    End Class
   End Namespace
There will be some default code for the control hidden inside of the Windows Form Designer generated code region. The most important code in there is the code that explicitly disposes the control. Be sure not to remove that code!

   Protected Overloads Overrides Sub Dispose _
   (ByVal disposing As Boolean)
     If disposing Then
       If Not (components Is Nothing) Then
       End If
     End If
   End Sub

Close Icon
Thanks for your registration, follow us on our social networks to keep up-to-date