At the prodding of Darryl Burling of Microsoft NZ I
download and installed Beta 2 of Visual Basic 2005 Express Edition. I
also downloaded and installed version 1.7 of the TabletPC SDK and installed
that.
As I
previously blogged I carefully followed a tutorial that walked me through
creating a form with an Ink Overlay. The Ink Overlay lets you ink on the form.
The net effect was that I made a gray box that I could write on. Needless
to say I was very excited.
I have now embarked upon a second, more serious TabletPC
development project and I will be blogging about my experiences here as I
progress.
The Idea
The idea for the project I’m working on
actually occurred to me quite some time ago when the blogosphere was awash with
talk of blogging in ink. Several people posted in ink using Outlook –like
James Kendrick here
- or screenshots from OneNote. While this certainly looks cool it
has a major limitation. In both cases ink is converted to an image and
posted to the web. A rather undesirable side effect of this is that that
text is not searchable.
We all drooled over the rather ingenious blog of Philippe Majerus that renders ink if your
browser supports it and text if it does not.
Once the initial excitement faded though, it occurred
to me that I only really cared about using ink to create the content because it
is easier. However the purpose of my blog is to convey information and
both my handwriting and not
being searchable would only hinder that goal. Thus I asked should
we be blogging in ink?
I also suggested
that Infopath could be used to make a simple blog client. However
after tinkering with this for a while I found that if your blog uses an API
based on XMLRPC then this is not at all easy to do.
My idea then is to create a simple blog client that
allows for content creation in ink and converts it to text as you write.
Introducing BlogPad
My project is called BlogPad. The concept is
quite simple. Clicking on an icon in the system tray brings up a form.
The user writes in the text field and the application converts the ink to text
as you write. When finished composing the entry is then posted to the
server via the MetaWeblog API.
I have started putting this together and while this
is far from what I envisage BlogPad to ultimately be here are a couple of
screen shots the ink entry in action.
Figure 1: Ink
Entry in a InkEdit control
Figure 2: The
converted text and some plans for more features.
The ink edit is a really cool control and I will blog
about its features and capabilities in more detail later. The way the ink
to text conversion works though is nice. The user inks anywhere on the
ink edit control and after a configurable delay (without more pen strokes) the
ink is converted to text. Other that that capability it seems to be much
like the traditional rich edit control. This means that you can paste
images and text into the ink edit, so rich blog posts should be possible.
What will be in
BlogPad v1.0?
Here is a list of features I am planning to include
in the first version:
- Ink to text
conversion (done)
- Correction of
converted ink (not yet implemented)
- Post to server via
MetaWeblog API (not yet implemented)
- Support for post categories,
pulled from server (not yet implemented)
- Support for post
titles (not yet implemented)
- Configuration page
to specify username, password and the url of the API (partially complete)
- Support for pasting
images and text in the post body (Partially complete)
- Support for
hyperlinks in the post body (partially complete)
- Support for
attaching an ink drawing. (not yet implemented)
The Promise
When I get all that into a package that works I
promise two things.
- I will make the
application available (though perhaps not the source) to the TabletPC
community free of charge.
- I’ll buy this t-shirt and
wear it with pride.