setting view states in HTML windows store apps using Blend
Intro
From developing XAML applications I got used to working with the visual state manager to set various states of my applications and controls. In Windows Store apps that are build using XAML use the visual state manager to change various properties when the view state of the app changes. The app can be ran in fullscreen, filled or snapped state.
When building Windows Store apps using HTML and JavaScript I wanted to show some UI different when the view state changes. One way to accomplish this is to change the CSS class of the elements from JavaScript. Just handle the change in view states and call some methods to set the classes.
Another way comes very close to the visual state manager from the XAML world. And can be done from within Blend.
CSS Media queries
It turns out you can set the styles for the view states using CSS media queries or media types. You might know these from building websites, where they’re often used to set different styles for different media or screen sizes.
If you look at the Style Rules pane in Blend for Visual Studio, when having an HTML Windows Store app opened, you can see four different “@media” definitions. Each one is used for a different view states. The media queries are added by default, but if they are missing or you want to add another you can do this by right click on the .css file.

Notice that only the fullscreen-landscape is white. The other three are greyed out. This is an indication that Blend is showing the landscape orientation at this moment. You can change the current orientation used in Blend on the Device pane. Just select another option for view.

To demonstrate how to use this I created a very simple example showing a grid with 6 boxes. For this I used a FlexBox. When a FlexBox is filled with elements they are stacked horizontally or vertically and wrapping could be enabled.

html:
<div class="ms-flexbox">
<div class="tile red"></div>
<div class="tile green"></div>
<div class="tile red"></div>
<div class="tile green"></div>
<div class="tile red"></div>
<div class="tile green"></div>
</div>
css:
.ms-flexbox {
display: -ms-flexbox;
-ms-flex-flow: wrap column;
width: 1000px;
}
.tile {
width: 250px;
height: 200px;
margin: 20px;
}
.tile.red {
background-color:red;
}
.tile.green {
background-color:green;
}
A similar layout like this is often used in Windows Store apps. Unfortunately it does not work when the app is snapped. In the snapped state the elements should be shown in a list, but will remain in three columns at this point. You’ll need to place parts of the .ms-flexbox class in both @media queries. You could do this by hand by editing the .css file, but I’ll show you how to do it using Blend.
The first step is to copy the .ms-flexbox class to the fullscreen-landscape and to the snapped media queries. Just right-click the .ms-flexbox entry on the Style Rules pane and click copy. That paste it on the fullscreen-landscape and the snapped media queries.

Next, select the original .ms-flexbox class and have a look at the CSS Properties pane. There’s a long list of collapsible panels containing a lot of properties. To shorten the list to only the properties that have a value, check the “View set properties only” checkbox.

The original .ms-flexbox style will be the style that is applied to all view states and contains the properties that are equal in every state. The Flexbox properties will be different. So these need to be removed. To do this click on the small advanced properties square next to Flexbox and select clear.

Select the .ms-flexbox style on the fullscreen media query on the Style Rules pane. For this part of the style clear the layout and the sizing. And do the same for the style on the snapped media query.
The style for the snapped state has to have some different properties for the Flexbox. Start by setting the View to the snapped state on the Device pane, so it visible what the change in properties is causing. First, clear the –ms-flex-wrap property, because in this state wrapping is not needed. Than, set the
–ms-flex-direction property to column. Notice the change in the designer.

And that’s it. Well… Almost actually. We haven’t done anything with the filled and fullscreen-portrait states. You could copy the state from the landscape state, but this would mean you’ll have to keep them in sync in case of changes.
At this point I changed the CSS by hand and added the filled and portrait definition to the landscape view state, which results to:
@media screen and (-ms-view-state: fullscreen-landscape),
screen and (-ms-view-state: fullscreen-portrait),
screen and (-ms-view-state: filled)
{
.ms-flexbox {
-ms-flex-flow: wrap;
}
}
Wrap up
Handling view states is an important part of you Windows Store app. In a real world application the styles and HTML will be a lot more complex than I showed here, but I hope you’ll get the idea. Otherwise, just drop me a line and I’ll see if I can expand the tutorial.
Getting started with Metro, JS and blend
Intro
In this first tutorial in a series about building a Windows 8 application with JavaScript, HMTL and CSS using Expression Blend 5, we’re going to make a start on a very simple game. In this game the player has to guess a random number between 1 and 10. The player wins if the guess is correct, and looses if it’s wrong. In future parts of the series this game will be extended to include various features of WinJS and Windows 8.
File-New
I’ve started with a new “Blank App” from the HTML list. I added a few HTML elements to start from. You can add HTML elements by typing them in the source panel. Or you can drag’n’drop them from Assets pane to Live DOM pane or design area.
I’ve added the following to the body-tag. Don’t worry about the looks of it, we’ll fix that later.
<h1>Guess a number</h1>
<p>
<span>Enter a number between 1 and 10:</span>
</p>
<p>
<input />
<button>Guess</button>
</p>
<p>
<span>result:</span>
<span></span>
</p>
The easiest way to access the HTML elements is by assigning IDs. I assigned the following IDs:
- input ==> numberInput
- button ==> numberGuess
- the empty span ==> numberResult
That’s it for the HTML for this moment. Let’s have a look at some code.
Code
Although Expression Blend is an awesome tool, I still prefer to edit my code in Visual Studio. Right click the default.js file and select Edit in Visual Studio to do just that.
For now we’re going to ignore most of the code that’s inside default.js. It’s almost all about state management. We’ll talk about that in a later tutorial. I’ve added the following code right below WinJS.strictProcessing(); :
var randomNubmer = Math.round(Math.random() * 10) + 1;
function buttonClickHandler() {
var value = document.getElementById("numberInput").value;
var numberResult = document.getElementById("numberResult");
if(value == randomNumber) {
numberResult.textContent = "Correct";
}else {
numberResult.textContent = "Incorrect";
}
}
Line 1 of this piece of code generates a random number and makes sure it’s between 1 and 10.
From line 3 and further the click event handler is defined. The first thing this function does is reading the value from the input with the numberInput id. Than, the element for the result is stored. The last thing this function does is comparing the provided value with the random number. If they are equal the text on the result is set to Correct, otherwise it’s set to Incorrect.
The event handler has to be attached to the button. This can be done in the following way:
var numberGuess = document.getElementById("numberGuess");
numberGuess.addEventListener("click", buttonClickHandler, false);
These lines need to be placed after the call to args.setPromise(WinJS.UI.processAll());.
It takes the element with the numberGuess id, and adds an event listener to that. The event handler is told that it should handle the click event and that it should handle the click event with the buttonClickHandler function. The last parameter tells the event listener that it should use bubbling. This means that the event will bubble up the hierarchy of DOM elements and is handled by each element before calling a possible event handler on its parent. Bubbling is what you would want most of the time. The other option, True, means the event listener needs to use capturing. This means the event is handled by the parent first and than the child.
With this piece of code in place it is time to run the application to see if it works. You can hit F5 in Visual Studio or Expression Blend to run the application. Or you can use the interactive mode in Expression Blend.
The great thing with this is that you can bring your application is a specific state and continue editing from there.
CSS
If everything’s right you should be able to play the little game now. Time to make it look a little better by adding some CSS styling.
There are a couple of ways to set the CSS properties for the application. You can set them directly on the objects. To give the elements we added in the beginning a bit more space around the border we’re going to change the padding on the body tag. First, select the body element in the Live DOM pane. Now, go to the CSS Properties pane and look in the Layout section.
To set the padding for all borders at once make sure the link option, right next to the inputs, is set. Enter 50px in the first input box and note that all boxes are filled with the same value. The CSS properties are stored in the HTML in the style attribute, in this case on the body tag.
To demonstrate a second way of setting styles we’re going to make the title look glowing, bold and blue. We’re going to add a CSS style rule to store the properties. To do that select the title in the designer, right click on it and select Add New Class…
The class has to have a name. Enter title in the input box. Because we want the properties to be stored in a CSS style rule make sure the Create style rule checkbox is checked. Hit OK.
The title style rule is automatically selected. Go to the CSS properties pane and look at the top section.
As you can see the .title rule is selected and that it is stored in the default.css file. The rules below the .title are default rules which are stored in the ui-dark.css file. Because there are different ways in which CSS properties can be set and because they can be overwritten by others all origins of properties are listed here. Each row is loaded on top of the one below. To two options above the line are special. If you select Winning Properties the CSS Properties pane shows a flattened view of all set properties. Very useful to see what values are set. You can even see where a value came from by clicking on the little advanced properties peg next to a set property. In the CSS Cascade section is shown what caused the value to be the way it is.
The computed values option shows a read-only view of all values. Even the ones that are not set.
Right. To make the title look blue select the .title element in the Applied Style Rules list. Go to the Text section. Set the color to light blue, the font-weight to 400 and enter 0 0 5px #4488FF in the text-shadow box. This gives the text a glow look by adding a shadow without X or Y offset.
A nice thing to notices is the way Expression Blend tells you were a specific style rule is used. Now that we have the .title rule set, go to the Style Rule pane and select it. At this point the Live DOM pane should have the H1 element highlighted with a dark green background. In the designer the title has a green border. If there would be multiple elements with the selected style rule, all of them would be highlighted in the same way.
For the last way of setting the styling I would like to show you we have the add a little code first. In the click event handler, in the check if the number is correct I’ve added two lines. These lines set the CSS class to correct or incorrect based on the result.
if(value == randomNumber) {
numberResult.textContent = "Correct";
numberResult.setAttribute("class", "correct");
}else {
numberResult.textContent = "Incorrect";
numberResult.setAttribute("class", "incorrect");
}
Switch back to Blend and enter interactive mode. Type a number in the textbox and hit Guess. You’ll probably hit an incorrect number, but for the tutorial it doesn’t matter very much. The .incorrect rule should make the text turn red and the .correct rule should make the text turn green. After having the result shown leave the interactive mode and select the numberResult element. Go to the HTML Attributes pane.
A couple of thing are happening here. The first thing to notice are the blue borders around the class box and the textContent property. This blue border means these values are set at runtime. The little lightning bolt next to the class name also indicates this class has been added at runtime.
To convert the dynamically added class to a normal style rule, click on the advanced properties peg, go to Create Style Rule from Element Class and select incorrect.
Go to the Style Rules pane, which should contain the .incorrect rule now. Select it and go to the CSS Properties pane. Set the color to red. You can repeat the process until you guess the number, or you can add the .correct rule by clicking the + on the Style Rules pane. Select the rule and set the text color to green.
Wrap-up
This first tutorial in the series turned out to be a little longer than I suspected, but I hope you get the basic idea of setting the styles of your apps. If you have any questions just let me know. You can download the code for this tutorial here.
Discovering Expression Blend 5 – ListView
Often you need to display a list of items in a application. The Windows Library for JavaScript contains a ListView control for you to use in your applications. The control can be bound to a data source and templated from HTML.
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).
Discovering Expression Blend 5 – Styles
In my previous article I explained the different templates of the Expression Blend 5 preview. Today I would like to walk you through some of the basic of using CSS, or Cascading Style Sheets, in Expression Blend 5. You’ll need CSS to define the look and formatting of your Windows 8 Metro Style application. Expression Blend 5 helps you create your styles in pretty much the same way you are used to when working on Silverlight or WPF applications in Expression Blend 4 and earlier. But not entirely.
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).

