The Technical Certification Requirements for Windows Phone 7 applications state the following:

5.5.2 – Content and Themes

Application content, such as text and visual elements, must be visible and legible regardless of the phone theme. For example, if the phone theme changes from black background to white background, the text and visual elements of your application must be visible or legible.

This means that everything in you application, including images, should be well visible in the dark and light theming of the phone. Handling dark/light support is very easy.

Dark and Light

Often companies have a special version of their logos for different situations (Bing for example). For this demo I’ve created two logos, a black and a white one. The white logo should be used when the theme is set to dark, the other when a light theme has been selected.

I’ve dropped these images into Expression Blend and grouped them together in a Grid control (Ctrl+G ). This grid is placed in the title panel, which resulted in the following XAML:

<StackPanel x:Name="TitlePanel" Grid.Row="0">
    <Grid>
        <Image Source="Logo-Black.png" />
        <Image Source="Logo-White.png" />
    </Grid>
</StackPanel> 

To get the white logo to be only visible when the dark theme is set, select the image of the white logo. With the image selected click on the “Advanced options”-peg:

Now, go to “System Resource” and select the “PhoneDarkThemeVisibility” resource.

At this point a green rectangle is placed around the visibility property of the images letting you know a resource is set on that property.

To get the same results for the dark logo, repeat the process on that images. But select the “PhoneLightThemeVisibility” instead.

Testing

To test the results right in Expression Blend, got to the “Device” tab. On this tab you can set different device settings, including the Accent Color and the Light or Dark themes.

Switching from dark to light and back should result in the images below.

Wrap-up

Setting the visibility like this can be done on every element in your XAML. And whenever you need to use the visibility for other purposes, there’s a similar resource for the Opacity.

If you’re using Photoshop or Illustrator and would like to use them too, you can download them here:

In this I application I wanted to try a few things. First, I wanted to see how to create a trial version of an application with possibilities to buy the app. Next I added a couple of behaviors to make it very easy to share a link to the application in various ways. The main goal of all these is ease of use for the developer and reusable. For example, a lot of times you’ll need a link to the marketplace, navigate to a URL or let the enduser write a review.

Another thing I would like to build is a localized app. The first version of this app is in Dutch only. I’m working on the German version. There will be an English version too, although this will contain the Dutch quotes.

Trial version

For the trial version of the application I wanted to show a MassageBox after a few taps on the button. The MessageBox should have a link to the marketplace to directly buy the app.

“You are using the trial version of the New Kids Button application. The full version contains more quotes!

[Buy now] [Continue trial]”

Another thing that I’ve added is a behavior that sets the visibility of the element it is applied to based on whether the application is running in trial mode or not.

Other behaviors

The first behavior continues a bit on the trial version. The behavior is used to navigate to the details of the application in the marketplace. All you need to do is place this on a button and it’s ready to go.

Because getting people to review your application is crucial to a successful app you’ll need to fire up the review task somehow. One behavior in this application does just that. Attach it to a button and it opens the review screen when it is pressed.

Sending an email from the application needs to done quite often too. A behavior that fires up the email task  is used in the app. You can set the body, subject and addressee of the email.

Another behavior takes a URL as a parameter. When it is placed on a button it can be used to open a browser windows and show that URL.

The last one is my personal favorite. Sharing a link to your app on a social network is a great way to promote your application. This behavior uses the ShareThis API to share a link on a lot of different networks. 

You can download this behavior here: TimmyTools.Wp7.Behaviors.zip

A few other links

Link to the app in the marketplace : http://timmykokke.com/NewKidsApp

Twitter: @NewKidsApp

Email: NewKidsApp@hotmail.com

Getting started

We’ll start off by creating a new project and choosing the Fixed Layout Application project template.

As you can see, the template has added a paragraph (p) to the tree which contains some text. You can use that to place the title of your application. The ListView is going to be in the same div as that paragraph.

You can add the ListView by hand, typing the HTML, but I personally prefer dragging and dropping controls onto the designer. Select the parent div of the paragraph. 

Type ListView in the search box of the Assets panel and drag the result from the list to the design surface.

If you switch to Split view in the designer you can see the HTML …

which should contain the following element.

<div data-win-control="WinJS.UI.ListView"></div>

To be able to write code against the ListView it has to have an Id. You can enter this on the Attributes panel. In this case I named the ListView “posts”.

Getting Data

The ListView in this demo application is going to display the Atom feed from this blog. The Windows Library makes this very easy.

Have a look at default.js in your solution. This file contains some code to get you started. When the window is activated the onmainwindowsactivated function is called. This is where the retrieval of the atom feed has to be initiated. First create a new AtomPubClient and a Uri to the feed. Than, pass the url to the retreiveFeedAsync function and have it process the posts or handle the error. At the end of the function you have to call processAll to have all declarative bindings applied on the controls. This is needed to get the templating to work which we’ll create in a second.

I haven’t implemented error handling in the demo, only an empty function. The processPosts function will be implemented after the templated.

WinJS.Application.onmainwindowactivated = function (e) {
    if (e.detail.kind ===
     Windows.ApplicationModel.Activation.ActivationKind.launch) {

        var syn = new Windows.Web.AtomPub.AtomPubClientClient();
        var url =
           new Windows.Foundation.Uri("http://timmykokke.com/atom");
        syn.retrieveFeedAsync(url)
           .then(processPosts, downloadError);

        WinJS.UI.processAll();
    }
}

function downloadError() {
    // handle error
}

Creating a template

The template is created in HTML. It’s basically a div with the data-win-control set like the ListView. The children of that div are used as a template for the ListView.  The template has to be defined before the ListView. To get the bindings to work you’ll have to add the binding.js script to the head section of the HTML file.

The actual binding is done by adding the data-win-control attribute to the divs inside the template. In this case the innerText property of the div is bound to the title property of the data bound object. Note that the children of the template are not shown in the Live DOM panel.

I’ll demonstrate how to set the classes later.

<script src="/winjs/js/binding.js"></script>
...
<div id="itemTemplate" data-win-control="WinJS.Binding.Template" >
    <div class="post">
        <div class="title" data-win-bind="innerText: title"></div>
        <div class="summary" data-win-bind="innerText: summary"></div>
        <div class="date" data-win-bind="innerText: date"></div>
    </div>
</div>
<div id="posts" data-win-control="WinJS.UI.ListView" ></div>

To make the template known to the ListView, select it and go to the Attributes panel. Enter the name of the template in the textbox next to the itemRenderer property. In this case the templated is named itemTemplate.

Process feed

The feed returned by the earlier code has to be processed to match the template. It’s nothing more than creating an array (myDataSource), run over the items, adding anonymous objects to the array and setting the data source of the posts to it. If you would like to do some custom formatting on the items, like changing the date to something more readable for example, you can do that here.

function processPosts(feed) {
    var myDataSource = [];

    for (var i = 0, len = feed.items.length; i < len; i++) {
        var item = feed.items[i];
        myDataSource.push({
            title:   item.title.text,
            summary: item.summary.text,
            date:    item.publishedDate
         });
     }

     posts.winControl.dataSource = myDataSource;
}

One of the great things of working with Blend is that you do not have to run your application to see the result and work with it. Try hitting CTRL+R or click on the refresh button in the top right corner of the designer.

If all code is correct you should see the ListView filled with titles and summaries. The Live DOM panel should be filled with elements now. The elements that are generated by code are added to the list to. These elements are marked with a small lightning  bold icon.

Now we have to make sure the ListView is showing a ListLayout. With the posts element selected in the Live DOM panel head over to the Attributes panel. Look for the layout property and hit the button next to it.

Select ListLayout from the list and hit Ok. Refresh the design if needed.

CSS for template

Now we have the ListView filled with data we can set the templates.

Try selecting a title of one of the posts. You might have to click a couple of times, and notice that with every click you drill a little deeper in the element tree.

With the element selected head over to the CSS Properties panel. Click on the little triangle and select Create style rule from selected element class… and title.

This will create a CSS style rule in default.css for the title class. It is automatically selected. Try changing some of its properties, for example the text color and font-size and see what happens. The height and margins of the programmatically added items is not recalculated on every change, so you may want to hit the refresh button every now and then to update it.

You can repeat the process for the summary and date template items too.

To see what items in the designer are affected by a CSS style rule, select one on the Styles panel. For example the .title rule. Notice how all titles got a green border in the designer and the elements in the Live DOM panel got a dark green background.

Wrap up

I hope that this tutorial has given you a start on how to use the ListView and how to use templating in Expression Blend. Other controls work in pretty much the same way. Feel free to drop my a line if you have any questions regarding this tutorial or anything else you run into.

For future tutorials on Expression Blend please subscribe to the rss feed or follow me on Twitter (@Sorskoot).

Last week my KnockOnWood Windows Phone 7 app was released in the marketplace. The basic idea of the application is that it gives you something to knock on if no real wood is available. In other words, it should play a sound effect when the screen is touched.

From Wikipedia:
Knocking on wood, and the spoken expression “knock on wood,” are used to express a desire to avoid “tempting fate” after making some boast or speaking of one’s own death.

In this application I wanted to try out to work with sounds for another application I’m working on. I had only a few requirements for this application:

1. Multitouch. The sound should be triggered even if the screen is touched already.
2. Fast. You  should not have to wait for a sound to finish playing when you tap the screen. Just play it immediately.

Multitouch

Because of requirement 1, Multitouch, I decided to go for the static Touch class instead of using normal mouse events. To handle touches to the screen you’ll have to subscribe to the FrameReported event. I’ve added the following line to the constructor.

Touch.FrameReported += this.TouchFrameReported;

I figured a sound should only be played if a touch point is added to the screen. So I’ve created a private field _current to keep track of the number of touch points. If the first, or primary, touch point is taken off the screen (TouchAction.Up) this number should be reset to 0. If the number of touchpoints at a certain moment exceeds the stored number the sound is played.

private void TouchFrameReported(object sender, TouchFrameEventArgs e)
{
    int newcurrent = e.GetTouchPoints(this.LayoutRoot).Count();
    if (e.GetPrimaryTouchPoint(this.LayoutRoot)
	 	.Action == TouchAction.Up)
    {
        newcurrent = 0;
    }
    if (newcurrent > this._current)
    {
	// play sound
    }
    this._current = newcurrent;
}

Sound

At first I thought about using a single media element to play the knocking sound. But, with the first few tests it became clear a media element isn’t fast enough. Starting, stopping, rewinding and playing again didn’t work as easy as I hoped. I had to turn over to XNA for playing sounds.

Playing a SoundEffect when the screen is touched was still not fast enough…  So, I tried SoundEffectInstance, which holds an instance of SoundEffect ready to be played. This worked a lot better, but stopping, rewinding and starting an instance was not completely right. Tapping on the screen wasn’t quite right.

Because I wanted to play the sounds as fast as possible I’ve came up with the following solution. I’ve created an array of SoundEffectInstance and cycled through that on every tap. Because the knocking sound is pretty short, I’ve set the buffer size to 10 instances. This didn’t cause anything notable what tapping the screen.

Throughout the code I use a constant and two fields:

private const int BufferSize = 10;
private readonly SoundEffectInstance[] _soundEffectInstances;
private int _currentInstance;

In the constructor the _soundEffectInstances array is constructed and filled with instances of a SoundEffect.

this._soundEffectInstances = new SoundEffectInstance[BufferSize];

var effect = this.LoadSound("woodknock.wav");

for (int i = 0; i < BufferSize; i++)
{
    this._soundEffectInstances[i] = effect.CreateInstance();
    this._soundEffectInstances[i].IsLooped = false;
}

The LoadSound method takes a path and filename of a content file in the solution, reads it and returns a SoundEffect.

private SoundEffect LoadSound(string path)
{
    using (Stream stream = TitleContainer.OpenStream(path))
    {
        return stream != null ? SoundEffect.FromStream(stream) : null;
    }
}

When the screen is tapped, the TouchFrameReported event handler is called. In this method I did all the playing from the array of sound instances and keeping track of which instance to play.

private void TouchFrameReported(object sender, TouchFrameEventArgs e)
{
    int newcurrent = e.GetTouchPoints(this.LayoutRoot).Count();
    if (e.GetPrimaryTouchPoint(this.LayoutRoot)
             .Action == TouchAction.Up)
    {
        newcurrent = 0;
    }
    if (newcurrent > this._current &&
            this._soundEffectInstances != null &&
            this._currentInstance < BufferSize &&
            this._soundEffectInstances[this._currentInstance] != null)
    {
        this._soundEffectInstances[this._currentInstance].Play();
        this._currentInstance++;
        if (this._currentInstance >= BufferSize)
        {
            this._currentInstance = 0;
        }
    }
    this._current = newcurrent;
}

And that’s about it.

Wrap-up

Playing one sound at a time without having to deal with speed and responsiveness is not that hard. Playing multiple instances is a bit harder. But, as you’ve just seen, can be done with only a few lines of code.

If you have a Windows  Phone, please give the application a try and show your support by rating it. The KnockOnWood application can be found in the marketplace.

For future tutorials on Windows Phone, Silverlight and Expression Blend please subscribe to the rss feed or follow me on Twitter (@Sorskoot).

Defining a style

For sake of simplicity I’ve created a new solution in Blend using the Blank Application project template. This template comes with three CSS files. Two files are for the default Metro style. One defines a light UI, ui-light.css and one that defines a dark UI, ui-dark.css. Only one of these files is linked in the default.html file, the dark version. I won’t recommend changing these files, but adding you own styles to a new CSS file or adding them to the third CSS file in the project, default.css.

Style sheets linked to the currently opened and active file can be found on the Styles panel.

On this panel you can quickly create new style sheets, link existing CSS files or add a style block to you html file.  You can also add new style rules to a style sheet. Because there can be a large amount of style rules available a search box is available to help you find your rules very fast.

We’ll start by adding a rule to the default.css file by clicking on the “ + “ symbol next at the end of the line.

The style sheet unfolds and a new rule is added to the list. Type #YellowHeader and hit enter. The “ # “ indicates this rule will be applied to an html element with YellowHeader as its ID.

Setting Properties

With the newly added style rule selected have a look at the CSS Properties panel. At the top of panel you’ll find the name of the rule, in this case #YellowHeader. Below that is a search box to find properties. A checkbox for filtering the list is next. Check this to hide all empty properties and show only the ones that are set to certain value. The last part of the CSS Properties panel show a list of all available CSS properties. You can group these per category or show them as a long list ordered by name.

As the name of the style rule implies, we’re going to make a header that is yellow. Navigate to the Text category and click on big box next to color. The Color Editor pops out where you can select a color. Pick yellow. Note that the little square at the end of the line becomes white indicating a value has been set, different from the default.

Apply Rule

Now we’ve got a style rule defined we’ll need to add it an html element. We’re going to apply this to an H1 tag in the html file. Set the designer to split view to be able to edit the raw html by clicking on the little split button on the upper right corner of the design panel. Add the following between the start and end of the Body tag:

<H1>A Yellow Header</H1>

The element immediately shows up in the designer and the Live DOM panel too.

Select the element in the Live Dom panel or in the designer. And look at the Attributes panel now. This panel contains all attributes for the selected html element. All elements can have an id which uniquely identifies the element. To match this with CSS rule we’ve created earlier name it YellowHeader. Notice that in the list of attributes the id changes too, the little square becomes white and the id also shows up in the Live DOM panel.

Because we’ve created the rule before setting the id, the H1 element immediately turns to yellow.

One last great feature that was added is to quickly find out which elements are affected by a certain style rule. Select the #YellowHeader rule on the Styles panel and watch the border around the selected element in the designer turn green. Notice the element in the Live DOM getting a dark green background also.

Inline Styles

There’s more… In this case we’re going to work the other way around. We’ll start with some html elements and add styles for that.

Start by adding the following lines to the body of the html file, right below the H1 tag we added earlier.

<ul>
    <li>Item 1</li>
    <li>Item 2</li>
    <li>Item 3</li>
</ul>

This creates a list with 3 items.

Select the first LI element. On the CSS Properties panel, have a look at the Applied Rules box. Because the styles are cascading and this stack of applied rules can grow bug, it’s sometimes hard to find out what’s the winning rule. This box helps you with that. When winning is selected the properties show what properties are set. Try selecting the bottom one in this case and note all three items are surrounded with a green border again. This is because the selected rule is applied on all LI tags.

Select inline in the Applied Rules box to create an inline style. When this is selected, the changes you make to the properties are placed inside the html tags.

Lets change a couple of properties:

• Set background-color to dark blue
• Set font-size to 15pt
• Set font-weight to bold
• Set line-height to 25pt

The item should look something like this now:

CSS Class

Very often CSS uses classes (not .NET classes with code, but CSS classes) to define the looks and formatting for multiple elements at once. Lets convert the previously created inline style to a class and apply it to the other list items.

With the second LI element selected go to the Attributes panel and write redItem in the textbox behind class.

Next, switch to the CSS Properties panel. Click on the little tiny triangle in the upper right corner of the Applied Rules and select Create style rule from selected element class… –> redItem.

Change the text-color to red, the line-height to 25pt and the background-color to dark red.

Select the third LI element now and go to the Attributes panel again. Enter redItem in the box behind class and watch the third item turn red too. Try selecting the .redItem rule on the Styles panel too and notice both elements get a green border.

Wrap up

I hope you get the basic idea of how to work with CSS styles in Expression Blend 5. If you haven’t used CSS before, have a look over at www.w3schools.com. You’ll find lots of information there about CSS and CSS3, along with much more information about other web development/design topic.

For future tutorials on Expression Blend (and I’m sure many will follow) please subscribe to the rss feed or follow me on Twitter (@Sorskoot).

This preview of Expression Blend 5 doesn’t let you create Silverlight, WPF or Windows Phone 7 apps. Instead it does what a lot of people where hoping for: Editing/Designing Html5, Css and JavaScript.

Project Templates

The first thing to notice are the new project templates. There’s only one category in the preview: Windows Metro Style. The category contains 5 templates. All templates help you getting started creating Html applications for Windows 8 in Metro style. The Language and Version dropdown lists only contain one element in the preview version. I assume these will grow over time, when Silverlight, WPF and WP7 return.

The Blank Application template creates a solutions with only the minimal elements needed. The designer shows a tablet-shape around the surface, like you might be used to when working on Windows Phone 7 applications. The solution contains a couple of Css and .Js files needed for the Metro Style. A manifest file is also added which defines what is needed to run the app on Windows 8.

The second project template, Fixed Layout Application, adds some basic layout to the blank application.

The Grid Application template is where things get a lot more interesting if you’re just starting writing these kinds of apps. This template contains a couple of .Html files glued together (I might dive into this in a later tutorial) with html attributes. It’s a basic starting point  a grid application and contains some navigating from master to detail views.

The Navigation Applications template creates a solutions which looks a lot like the last, but blank. The basic Html elements are in place. This would be a great template to start you applications.

The last template, Split Application, create a more complex solution again. It demonstrates how to create a master/detail application showing the master and the details side by side.

Item Templates

Besides new project templates, there are new Item Templates too. Adding new files to the solution is something you would to in an Html/JavaScript application too, right? Besides a basic JavaScript File, Style Sheet or Html page, there some templates that will help you develop your Windows 8 applications faster.

The Landing Page adds a Html page, a Css file and a JavaScript file to the solution. The page contains a header with a button and a title and a section containing a list. Again, the data is defined in the JavaScript file. The JavaScript code wires thing up to create an interactive page.

The Split Page template shows a lot of resemblance with the Split Application project template. The item template adds a Html file to the solution defining the layout of the page. A Css file is added for the styling and a JavaScript file is added which contains the code to make things interactive. The JavaScript code is responsible for creating the sample data too.

The Collection Page item template defines a large item and a list of smaller items. Again a Html, Css and JavaScript file are added to the solution. It should be pretty easy to extend the JavaScript code and make the small items navigate to different pages in the solution.

The Category Page template adds a page with a horizontal list of images with some details below them. The JavaScript file that is added is pretty much the same as the ones in the previous templates and again, it should not be hard to modify and extend this code to add navigation to the page.

The Html Fragment adds an almost empty page. It contains the most basic styles and elements for a Metro style application. The JavaScript file that is added contains only a few lines of code handling the fragmentLoad event.

The Details Page contains a large text over multiple columns. The JavaScript file that goes along with this template initializes the page and fills it with sample data.

That’s it for the templates.

Wrap-up

Although this first preview of Expression Blend 5 only does Html, I think it’s moving in the right direction. Looking at the .Dll files in the root directory of Blend reassures me that the future will bring everything we’re used to back to one of my favorite tools.

Great job Expression Blend team! Keep up the good work.

For future tutorials on Expression Blend (and I’m sure many will follow) please subscribe to the rss feed or follow me on Twitter (@Sorskoot).

Zwaailicht helps you choose one of the many feeds of http://www.alarmeringen.nl.  Which was kindly enough to made their feeds available on a Creative Commons-license. The application gives you 4 options to base your feed on.

1. City
2. Region
3. GPS
4. Nationwide

The application contains a list with almost all Dutch cites you can scroll through. To find the city you are looking for a bit faster you can use the searchbox on top to filter the list.

The region selection is a much smaller list of the regions the Dutch emergency services work in.

Zwaailicht can also find a city based on your current GPS location. It uses the Bing Geolocation service to do this. Zwaailicht sends your current GPS location to this services which returns your current address. Zwaailicht uses the city from this address to get a new feed.

The application uses Teleriks Rad Controls for Windows Phone for navigation, showing lists and filtering them. This took away lots of work in the design of the application and added a lot of smoothness and animations.

For the design itself I choose to stick to the Metro theme as much as possible. I added a couple of backgrounds to make the application stick out a little more. I used the default animations as much as possible.

The application failed certification the first time. Besides correctly configuring the manifest file in the project to contain its capabilities, like GPS in this case, it also needed to include a privacy policy. I’ve added a this to the about screen. In this I explain the data captured from the GPS is not used for anything else that getting the current city. Added the privacy policy was enough to get it certified the second time.

The application can be downloaded here. Don’t forget to leave a review if you like it. If you don’t, please send me an email or tweet and I might add your suggestion to the next version.

The idea for this session came when I saw a coworker tinker with XAML in visual studio to create an animation when he had Expression Blend available through his MSDN subscription. It turned out that a lot of Silverlight, WPF and Windows Phone 7 developers didn’t know they could use Expression Blend. “Expression Blend is for designers”, they thought.

The first part of the session I explained Sample Data. I demonstrated how to create it and how to use it to create bindings. I demonstrated how to use the Visual State manager and set them by using behaviors. In the last demo I showed a couple of my favorite features of Expression Blend (including the gradient picker).

The recording of my session is available online and for download at Channel9. Although the slides are in English, the session itself is spoken in Dutch.

The slides contain all content shown in the demos. You can download them here.

Last but not least I would like to thank everyone for coming to my session. I hope I was able to send you home with little more knowledge that you had when you came in and inspired you to start using Expression Blend in your job.

My first Windows Phone 7 application is available in the marketplace, Duck’n’Cow. Feel free to download and play with it (and rate it of course ).

I build the application to try some of the features of the Windows Phone. In this application I focused mainly on the accelerometers.

The application shows a Duck and a Cow, hidden in a circle. When you shake the phone the duck pops up and you hear it quack. When you turn the phone upside down, you’ll see the cow pop up.

Idea

I wanted to create a funny looking application that could be used to express your feelings about something when attending a presentation. A positive, cheering and green, action when you like something and a negative, red, action when disliking what is being told. But with a wink. Just a simple thumbs up or down wasn’t fun enough. So I decided to go for a moo and a quack, which automatically led to duck and a cow.

Gestures

The application uses to gestures, shaking and turning upside down. The turning upside down reminds of the nostalgic cow-in-a-box toys. But the gesture also resembles turning your thumb down to express dislikeness. The shaking motion is inspired by cheering and applauding.

I started off by reading the accelerometer data myself. By calculating the change of the accelerometers in X,Y and Z directions I was able to detect a shaking motion. By reading the Y accelerometer I was able to tell if the phone was turned upside down. Very soon I ran into issues whit this method, because the raw data returned by the accelerometers was too course (?!). I needed some kind of filtering to smooth things out a little. When looking around to find the best approach I came across the ShakeGesture library, which is build on the AccelerometerHelper library. Both these libraries helped my abstracting out the raw accelerometer data and use filtered events to get the data right.

Graphics and Xaml

As soon as I knew I was going to use the concept of a duck and a cow I started sketching. Below is the original sketch.

I’ve digitized the sketch in Adobe Illustrator to be able to scale it to any size so I could use the same image for all the places where tiles were needed, like the live-tile or the tile in the marketplace.

The first version of the application only contained this image. I’ve added it as .png in expression blend. A couple of people I’ve showed the app to told me they’d rather see some animation. So I took the image apart and separated into a circle, the duck and the cow. And added the animations in Expression Blend.

I’ve created a UserControl to make the switching between states a little more convenient. The control contains 4 states, duck, cow, both and none.

Wrap-up

That’s it about the app for now. If you’ve got a windows phone yourself, feel free to try the app. You can download it through here.

To stay up-to-date about the application you can follow the app on twitter: @DuckAndCow . For comments, bug or feature requests, send me an email at DuckAndCow[at]hotmail[dot]nl.

To be informed about anything else that’s going on my blog, follow me on twitter (@sorskoot) or subscribe to the RSS feed.