Cloud + Device: Combine the power of Windows Azure, IE 9, and Windows Phone 7 (Part 2)

In the last post, we talked about how IE 9 powers Windows 7 devices, how
Silverlight/XNA powers Windows Phone 7 devices, and how Windows Azure cloud
connects those devices. This post focuses on the device side. We create a
graphic rich web application using HTML 5 canvas, and browse it in IE 9.

You can see the application lively on
. It is similar to
the Direct2D demo I wrote for 1Code.
The source code for this project can also be downloaded from 1Code using this link:

Please note this application has nothing to do with Windows Azure (except for
the fact the application is distributed from Windows Azure). It just
demonstrates how, as a developer, can create a graphic rich web application that
runs in a browser within just a few hours. The next post will demonstrate how to
connect client applications to cloud services.

Choose among canvas, SVG, and Silverlight

There’re several ways to create graphic rich web applications. Below is a
summary for 3 most common APIs:

Canvas is supported in IE 9 and most other modern browsers. But it is not
supported in IE 8 and earlier. Canvas provides an immediate graphics API that is
similar to Direct2D and GDI. Choose canvas if you only need to support latest
browsers, and if you’re familiar with immediate graphics APIs.

SVG is supported in IE 9 and most other modern browsers. It is not supported
in earlier browsers, but can be worked around by installing plug-ins. SVG
provides a retained graphics API that is similar to Silverlight and WPF. Choose
SVG if you prefer retained graphics model.

Silverlight is a small browser plug-in that supports most browsers, and has
already been installed on more than half computers in this world. Silverlight is
not a standard. Choose Silverlight if you’re more confortable with .NET than
JavaScript, and if you want to adopt a better designer/developer workflow. In
most cases, you don’t need to program for graphics in Silverlight. You simply
need to design graphics using Expression Design and Expression Blend.
Silverlight also supports hardware acceleration (no matter which browser it is
using). And it uses CLR’s JIT feature to increase the performance to a further

This post covers canvas, while the next post covers SVG and Silverlight for
Windows Phone.

Familiar programming model

Some developers think canvas (and the whole HTML 5) is a new technology, and
takes a long time to learn. Some of them may even fear of the new technologies.
But keep in mind what canvas brings you is simply the fact that you can render
graphics in a browser without a plug-in. It doesn’t create any new ideas. So
actually it is very easy to learn, as long as you have worked with another
similar graphics API.

I had no knowledge of canvas prior to today, but I learned and created the
sample within 3 hours, because I can leverage my existing Driect2D knowledge.

As you will find out later, the programming model of canvas is very similar
to Direct2D (or GDI if you have to mention it). It is always much easier to
learn a new technology based on familiar concepts than learn a new concept.

Immediate graphic API

Canvas provides an immediate drawing graphics API that is similar to Direct2D
and GDI. That is, what you draw on the screen is the final bitmap result. You no
longer have access to a shape (like a rectangle) once it is drawn. The API
doesn’t provide a retain tree that stores shapes information.

Immediate graphic APIs are usually much more difficult to use than retained
APIs, especially if you want to add interactivity. They also don’t support
declarative drawing (think of SVG’s xml and Silverlight’s XAML). But they
consume fewer memory since they don’t remember the shapes’ information. So
complex games are usually created using an immediate graphics API, while simpler
scenarios are usually created using a retained graphics API.

Canvas is considered as a high level API because under the hook, the
JavaScript code is interpreted by the browser’s script engine to internal data
understood by the browser’s rendering engine. The script engine then pass those
internal data to the rendering engine, and the rendering engine invokes a native
graphic API to render the scene. For example, IE 9’s rendering engine invokes
Direct2D under the hook.

But because IE 9’s scripting engine is considerably fast, the overhead of
translating script to internal data and then to Direct2D instructions can
usually be ignored.

On the other hand, working with graphics in JavaScript is much simpler than
Direct2D. Even if you still have to think on every steps in the drawing process
(because it’s immediate API), you don’t need to worry about handling COM errors,
creating Direct2D devices and render targets, and lots of other tasks.

The canvas element

To use canvas in HTML, you define a canvas element:

    <canvas id=”mainCanvas”></canvas>

That’s all you can do to declaratively define drawing elements on a canvas.
The remaining tasks will have to be done in JavaScript code.

The following sections walks through how to create the demo app. Since this
is a Windows Azure blog, we assume you have already worked with another similar
API, and understand the basic concepts like brush and transform. If not, it is
highly recommended to read an introduction post like
. The
on MSDN also helps you to understand the concepts. Once again,
keep in mind the concepts are the same. No matter which technology you’re using,
you only need to learn the concepts for once.


Before drawing on a canvas, you must obtain its drawing context. Currently
only 2D is supported by canvas. In addition, you have to define a size for the
canvas. Canvas doesn’t support CSS. Instead, you should use the width/height
properties. The properties don’t support percentage size like 100%. So if you
want to make the canvas resizable, you must handle the window’s resize event.

            mainCanvas = $('#mainCanvas');

            drawingContext = mainCanvas[0].getContext('2d');
            // Canvas does not support CSS. So we have to manually set the width/height properties.

            mainCanvas[0].width = $(window).width();

            mainCanvas[0].height = $(window).height();

            // Make the canvas fit the browser window.

            $(window).resize(function ()


                mainCanvas[0].width = $(window).width();

                mainCanvas[0].height = $(window).height();




Render the scene

Render a simple rectangle

Now in the render function, you can draw anything you like. For example, to
draw a simple rectangle:

            // Draw a black background.

            drawingContext.fillStyle = 'black';

            drawingContext.fillRect(0, 0, canvasWidth, canvasHeight);

As you can see, when using a solid color, you don’t need to create a solid
color brush, as you do in Direct2D. You can simply use the fillStyle property of
the drawingContext.

Render circles

The next step in our demo app is to draw some small stars. Each star is a
simple white circle. There’s no method in canvas API to draw an ellipse.
Instead, an ellipse is considered as a path, and you should draw an arc path:

        function drawSmallStars()


            drawingContext.fillStyle = 'white';

            for (var i = 0; i < 300; i++)


                var x = Math.random() * canvasWidth;

                var y = Math.random() * canvasHeight;


                drawingContext.arc(x, y, 1, 0, Math.PI * 2, true);





Render complex paths

You can draw other paths using similar code, such as a Bezier curve:


            56.9435916193468, 9.34704511572823,

            53.1105762246886, 6.5137471975463,

            52.4435735457851, 16.0137402172507


Next we draw the planet. The planet is composed of a circle and two complex
continent paths. When drawing complex paths, it is often easier to draw them in
a graphic tool first. We use Expression Design to draw the paths, and exported
them to XAML. If you’re working with Silverlight or WPF, you can take the XAML
directly, without any manual code. But since we’re working on JavaScript, we
have to do some coding.

To simplify the task, let’s create a PowerShell script, to convert the XAML
content to JavaScript code. For example:

$invocation = (Get-Variable MyInvocation -Scope 0).Value
$currentDir = Split-Path $invocation.InvocationName
cd $currentDir
$xmlData = [xml](Get-Content PlanetUpPathXaml.xml)
$segments = $xmlData.PathFigure.SelectNodes(“BezierSegment”)
$segments | ForEach-Object { “drawingContext.bezierCurveTo(
” -f $_.GetAttribute(“Point1”), $_.GetAttribute(“Point2”),
$_.GetAttribute(“Point3”) } > PlanetUpPathOutput.txt

The PowerShell script reads the source XAML (xml) file, use XPath to select
all BezierSegments, and for each BezierSegment, output a corresponding
JavaScript code.

This is one disadvantage of HTML canvas compared to Silverlight. But maybe in
the future, we will see more mature tools that output JavaScript code from a
graphic designer. So we will be able to keep the designer/developer workflow.

Working with clipping paths

The continent paths need to be clipped to fit in the planet circle. To create
a clip path, simply call the clip method on the drawing context. The last path
created by the drawing context will be used as the clipping path. The clipping
path will be used by all future drawings. If you don’t like this behavior, you
can wrap the drawing tasks that rely on clipping in a save/restore pair:

// Clip the paths to fit in the circle.






Using gradient brushes

We also need to draw the star (the sun if you like). The star is composed of
a circle and a complex outline. The code is similar to the planet. We also use
PowerShell to convert XAML design to JavaScript code. There’s one difference:
The star’s outline is a radial gradient brush. The concept of radial gradient
brush in HTML canvas is similar to that in Direct2D. But the API parameters are

In Direct2D (and most other graphic APIs), you define a start point which
acts as the center of the circle. You define an end point which is a point on
the circumference. For example:

// Create a RadialGradientBrush (star outline).

HRESULT Renderer::CreateStarOutlineBrush()



ID2D1GradientStopCollection* gradientStopCollection;

D2D1_GRADIENT_STOP gradientStops[2];

gradientStops[0].color = D2D1::ColorF(0xFF7A00);

gradientStops[0].position = 0.72093f;

gradientStops[1].color = D2D1::ColorF(0xEBFF00, 0.5f);

gradientStops[1].position = 1.0f;

hr = this->m_pRenderTarget->CreateGradientStopCollection(gradientStops, 2, &gradientStopCollection);

hr = m_pRenderTarget->CreateRadialGradientBrush(

D2D1::RadialGradientBrushProperties(D2D1::Point2F(95, 95), D2D1::Point2F(0, 0), 95, 95),




return hr;


In HTML canvas, however, you define an inner circle and an outer circle. So
the code will be:

            var outlineBrush = drawingContext.createRadialGradient(95, 95, 0, 95, 95, 95);

            outlineBrush.addColorStop(0.72093, '#FF7A00');

            outlineBrush.addColorStop(1, 'rgba(235, 255, 0, 136)');

            drawingContext.fillStyle = outlineBrush;

They’re essentially the same. Just two different approaches to the same

You apply a gradient brush using the drawing context’s fillStyle property.
The brush will be used for any future drawings, unless you put the code in a
save/restore pair.

Creating animations and transforms

JavaScript doesn’t provide storyboards you find in Windows Animation Manager
and Silverlight. You have to use timers. The sample uses a timer whose interval
is 1 millisecond. That is, 1000 frames per second. You don’t need to worry if
the machine is not powerful enough to support such a high frame rate. The
browser will drop to an appropriate frame automatically. This feature also shows
the capability of different browsers. For example, on my machine (quad-core CPU,
NVidia 8800 GPU), IE 9 renders the animation very fast, while another browser
that doesn’t support hardware acceleration renders much slower.

            setInterval(function ()



            }, 1);

Like working with other immediate graphics APIs, you have to deal with
animation directly when rendering. There’s no property based animations like in
Silverlight. So when drawing the planet, we apply a translate transform to the
drawing context, whose translationX changes as time passes away:

            drawingContext.translate(10 + animateTranslateX, canvasHeight / 2 - 100);

Once again, transforms are applied to all future drawing, unless you wrap the
code in a save/restore pair.

You can also use matrix transform directly. For example, when drawing the
star, we use a matrix transform to apply a scaling and a translating at the same

            // Scale the star, and translate it to the center of the screen. We use a matrix transform here.

            drawingContext.transform(2, 0, 0, 2, canvasWidth / 2 - 190, canvasHeight / 2 - 190);


HTML 5 canvas may seem to be a new technology, but the concepts are very
similar to existing technologies like Direct2D. So as long as you’re familiar
with another immediate graphics API, you should be able to pick it up very

Canvas and other rich internet application technologies like Silverlight
allows you to deliver great user experiences in the browser. It takes much more
effort to create the application in HTML than in Silverlight. But if the user is
using a modern browser, (s)he doesn’t need to install any plug-in. And if the
user is using the latest browser such as IE 9, the hardware acceleration feature
makes HTML application’s performance almost the same as Silverlight.

You can think the sample we built in this post as one scene in a game. You
can build upon it. For example, download some data from the cloud, connect the
user to Facebook, and so on. Just imagine the possibilities. The next post (and
the final part of the series) will transfer your attention from client
applications to cloud services.


Comments (0)