• [07:49] - Intro to Windows 8 platform
• [34:13] - Background tasks
• [44:38] - Windows 8 UI principles

Full course outline:

• Mod 01: Overview of the Windows 8 Platform and Windows Store Apps
• Mod 02: Creating User Interfaces using XAML
• Mod 03: Presenting Data and Implementing Layout using Windows 8 Built-In Controls
• Mod 04: Handling Files in Windows Store Apps and Process Lifecycle Management
• Mod 05: Working with Resources, Styles, and Templates
• Mod 06: Designing and Implementing Navigation in a Windows Store App
• Mod 07: Implementing Windows 8 Contracts, Tiles and User Notifications
• Mod 08: Local Data and Planning for Windows Store App Deployment

• [1:01] Git Support Added to Visual Studio and TFS (Martin Woodward, Brian Keller)
• [3:14] Getting Started with Git in Visual Studio and Team Foundation Service (Matthew Mitrik (MS), Andy Lewis, and Martin Woodward)
• [3:39] Announcing Visual Studio 2012 Update 2 (VS2012.2) (Brian Harry)
• [6:35] Announcing Visual Studio 2012 Update 2 CTP 2 (Blend fro VS 2012)(Unni Ravindranathan)
• [7:51] Installing your app on your Windows RT device (Dries Marckmann)
• [8:41] Lex.db: a new database storage solution for Windows Phone 8 (Matteo Pagani )
• [9:16] WinRT Toast Notification From Desktop Application (Shai Raiten)
• [11:29] Managing Parallel Team Development–Using NuGet (Dylan Smith)
• [12:23] Microsoft Launches modern.IE Internet Explorer Testing Resource (Darryl K. Taft), modern.IE
• [13:46] Using Visual Studio database projects in real life (Gunnar Peipman)
• [15:40] Multithreading Demystified (anshu dutta)
• [16:42] Visual Studio 2012 Color Theme Choices (Zain Naboulsi), http://studiostyl.es/, Visual Studio Color Theme Editor
• [17:29] Hyper-V for Developers Part 1 (Ken Kilty)

Picks of the Week!

• Rick's Pick of the Week:[18:38] Windows Store DirectX C++ Sample Base, Maelstrom
• Brian's Pick of the Week:[20:29] Nokia Drive+ Beta for all Windows Phone 8

For cross-platform development of iOS apps, Windows Store Apps, and Windows Phone 8 apps, Parallels is unparalleled since you can work with two different operating systems and related dev tools at the same time, in the same session, from the same desktop.

Here, Kurt Schmucker, a product manager at Parallels, gives a brief summary of Parallels Desktop 8 and demonstrates how to run Windows 8 and Visual Studio 2012 on your Mac without rebooting to a Windows partition first. Kurt demonstrates the Visual Studio Windows Phone emulator running along side the Xcode iPhone emulator.

Today's project is an "end-to-end" Windows Store game that runs great on PC's (x86/x64) and the Surface RT (ARM).

And as an added bonus you get to see MVVM in action, Sharing contracts (so you can share your awesomeness with friends and family) and is even packaged in such a way as you can use the "engine" with other WinRT supported languages too!

Oh and finally there's good bit of documentation that details how everything works.

Reversi XAML/C# sample board game app

The Reversi sample is an end-to-end board game app that shows some common features of Windows Store apps in a real-world setting. It also shows the use of XAML and C# features to create a layered (MVVM) app structure that is helpful as an app becomes more complex.

For a general introduction to the sample, see Developing Reversi.

To learn how the sample uses some features without having to understand the whole sample, see Reversi feature scenarios.

To learn how the overall sample works, see Reversi app structure, which describes the layers of the app and the parts in each layer. 

The Reversi sample shows you:

• Windows Store app features, including:
  • Tile and splash screen
  • App bar
  • Toast notifications
  • Settings flyouts
  • Share contract
  • Windows Runtime component creation and usage
• The use of the Common classes generated by the Visual Studio app templates to support:
  • Data binding
  • App navigation
  • Dynamic layout for screen orientation changes and snapped view
  • App lifecycle management (suspend, terminate, and resume)
• XAML and C# features, including:
  • Data binding and code separation patterns (MVVM)
  • XAML-based animations and states, including keyboard focus and mouse hover states
  • Custom controls and user controls
  • Asynchronous programming and thread cancellation
  • LINQ and related syntax features

This sample represents a work in progress. Not every scenario has documentation coverage, and some scenarios have only simple implementations. The sample is provided as-is, with no guarantees that it meets store certification requirements. However, the goal of this project is to provide accurate guidance on designing and developing a complete Windows Store app. Additional work is currently planned to ensure that the app is fully compliant with store requirements.

Changes in the 12/6 release

This release differs from the initial release in the following ways:

• The share contract has been implemented to share an image of the current game, including text info describing its state. This info is shared in a variety of formats to increase the number of compatible share targets.
• The ReversiGame project has been refactored into a Windows Runtime component to make it reusable in Windows Store apps based on other languages (such as JavaScript), and to enable replacement with a C++ implementation in order to optimize performance.
• The ReversiGame and ReversiTests projects have been renamed to ReversiGameComponent and ReversiGameComponentTests to make their roles clearer.

Developing Reversi, a Windows Store game in C# and XAML (Windows)

The Reversi board game app is an end-to-end sample that shows some common features of Windows Store apps in a real-world setting. It also shows the use of XAML and C# features to create a layered app structure (using the Model-View-ViewModel or MVVM pattern) that is helpful as an app becomes more complex. This topic introduces the sample and provides links to additional documentation.

For a short intro to MVVM, see Using the Model-View-ViewModel pattern.

To learn how this sample uses particular features without having to understand the whole sample, see Reversi feature scenarios.

To learn how the overall sample works, see Reversi app structure, which describes the layers of the app and the parts in each layer.

Note  This documentation reflects the current state of the sample at the time of writing. See the following links for the latest code and info about any updates.

...

Reversi is one of the most common board games implemented on computers. This is because the rules and artificial intelligence (AI) are relatively easy to implement, and the rules are over a hundred years old and are thus not under copyright. It also represents a programming problem that is not too hard but also not too easy.

The Reversi sample app includes features that let a player:

• Read the rules of the game.
• Play against other humans or against an AI at several difficulty levels.
• Pause the clock when the game isn't active.
• Show and hide the clock.
• Show and hide visual indications of the legal moves and the spaces affected by the previous move.
• Undo and redo moves to explore alternate plays.
• Play the game on different board sizes.

This set of features provides enough complexity to represent a truly "real world" app, but with enough simplicity to keep the app relatively small for learning purposes.

Reversi feature scenarios (Windows)

In this article

• Tile and splash screen
• App bar
• Toast notifications
• Settings flyouts
• Sharing content
• Data binding
• Asynchronous code
• Using a Windows Runtime Component
• Related topics

The Reversi sample uses several common features of Windows Store apps using XAML and C#. This topic describes how the sample uses some of these features, and provides links to key feature topics.

This topic does not require you to understand the whole sample, but it does assume that you already know XAML and C#, and already understand the basics of each feature, or are willing to learn by reading the linked topics. For info on app development fundamentals, see Create your first Windows Store app using C# or Visual Basic.

...

Reversi app structure (Windows)

In this article

• App layers
• The model layer
• The view layer
• The view-model layer
• Infrastructure and common code
• Unit tests
• Related topics

The Reversi sample uses a layered structure known as the Model-View-ViewModel (MVVM) pattern. This structure separates UI from non-UI code, which can simplify debugging, testing, and future development. This topic describes each layer in the sample, the parts in each layer, and how all the parts work together.

The Reversi sample differs from simpler XAML samples that put most of their non-XAML code in code-behind files. Reversi adds code to code-behind files in a few cases, but moves most of its non-XAML code to other layers and uses data binding to connect those layers to the UI.

The Reversi sample also differs from more complex XAML samples that use more advanced techniques, including separate MVVM frameworks. Such frameworks are useful for increasingly complex

...

Okay, okay... I think you now see there's a number of interesting things to read about, learn and see in the game.

Let's take a look at it. Here's a snap of the Solution. BTW, kudu's to the authors for including Unit Tests. It's great to see something like that included in a "sample".

So you can the game and game component are broken into the two pieces mentioned toward the beginning of the post (aka the 12/6/2012 note).

If you're like me, you're wondering if this really works on the Surface RT?

Yep! I'm here to tell, and show, you it does. There's just a couple things to do to get it run on the Surface RT, both pretty easy.

First, you need to change the Active Platform from x86 to All CPU's.

This is how it looks when first downloaded.

So obviously this will be a problem when trying to deploy it to an ARM device... Just switch the Active Solution Platform to Any CPU.

So now that it's possible to run it on a Surface RT, how do you get it over there? For dev's there's two primary ways. The approach I use is via Remote Debugging. Getting this setup isn't hard, but does take a few steps. Tim Heuer has a great write-up about that, Remote Debugging your Windows Store app on your Surface.

The other approach is to side-load an app package.

Which creates...

You'd copy all these to the Surface RT and then execute the included powershell, *ps1, script to install the app.

Both deployment schemes have their pluses and minus, where the remote debugger is much easier when both devices are on the same network, and the appdevpackage is perfect when the devices are not...

So I said I'd show you?

I think that's enough to get you started? Code, doc's screenshots, stuff to learn and a pretty complete game to play (where I... um... "invested" too much time in when writing this post up... . Now that's the way to start the year!

A CoverFlow Control for Windows 8 and Your Surface RT

A few years ago, I needed a CoverFlow control for a Silverlight project I was working on. Since Silverlight didn’t include a CoverFlow control, I did a little searching and found an open-source XAML CoverFlow control on CodePlex. So I downloaded the code, tweaked it a bit, and quickly had a control with the basic functionality I needed for my project.

Fast forward to this week. I needed a CoverFlow control again, this time for a Windows Store app that I’m building....

...

Doing the port was relatively easy. I had to change a few .NET types to WinRT types (for example, IEasingFunction to EasingFunctionBase). I had to remove an OpacityMask from Generic.xaml since Windows 8 doesn’t support OpacityMask, and I had to convert code for mouse events into pointer events. I also added gesture support to the control using Tapped events and Manipulation events, and I added mousewheel support while I was at it. I’m still tweaking the gesture code to make it feel as natural as possible (especially on touch screens), but it’s pretty close right now – close enough for me to publish the sample so you can let me know what you think.

Start by downloading the Visual Studio solution containing the demo project (CoverFlowDemo) and the control project (CoverFlowControl). Make sure you have an Internet connection since the comic book covers come down over HTTP, and then fire up CoverFlowDemo. You’ll see a screen similar to the one above, and you can cycle through the comics by swiping horizontally, tapping or clicking any comic other than the one in the center, or rolling the mousewheel while the cursor’s over the control. I really do own all those comics, BTW, except for Fantastic Four #1, which I once owned but no longer do. I couldn’t resist leaving it in the database just so people would ask about it.

How hard was it to use the CoverFlow control once I imported it into my project? Not difficult at all. Here’s the XAML that declares a control instance and templates the data items:...

Here's a snap of the Solution;

The sample compiled and ran for me the first time, and it works just as advertised. 

In his post he shows how easily you can use it in your project. Here's a XAML snip from the sample app included in the download.

And the code used to populate it;

In short, it looks very simple and easy to add and us this in our app's today.

Also make sure you check out Jeff's Introducing MyComix Reader, Version 0.5 where he shows off this control and a good deal more (all with source too). I'll be watching this project and it's very likely to get it's own post here in the future...

The Byte Kitchen's Open Sources - Kinect Client Server System

The Kinect Client Server system consists of a desktop application and a WinRT application. The desktop is a server that sends Kinect for Windows data over a WinSocket2 socket. The WinRT application is a WinRT client that connects to the server to receive and show the Kinect data.

You can download the server binary from here, and run it. You can also download a compiled version of the client (named 3D-TV) from here directly. You will need a developer license to install it on your Windows 8 pc. Only the x86 platform is currently supported. An entry in the Windows store for the client will come in time (removes the requirement of a developer license).

You can also download the source code and build the system yourself. The client application requires the WinRT DirectX Bus to build. So you will have to download that one too and use it as described. The Project file assumes that the TheByteKitchenLibs directory (either the source code or the compiled version) is a sibling of the KinectClientServer directory.

Project Information URL: http://thebytekitchen.codeplex.com/wikipage?title=Kinect%20Client%20Server%20System&referringTitle=Home

Project Download URL: http://thebytekitchen.codeplex.com/releases

Project Source URL: http://thebytekitchen.codeplex.com/SourceControl/changeset/view/20507

Viewing Kinect Data in the New Windows 8 UI

Introduction

The Kinect SDK is not compatible with WinRT in the sense that software developed using the SDK cannot have a WinRT (Windows RunTime) UI. The reason is that the Kinect SDK is .Net software and you cannot run (full) managed code on the WinRT.

Nevertheless, I want to create software that can show Kinect data in a WinRT UI. For multiple reasons, one being that software written for the WinRT can run on a PC, a tablet, very large screens, now called a Surface, and a Windows Phone. A survey of other solutions, see below, reveals that solutions to this problem are based on networking. Networking allows us to deliver Kinect data anywhere. This then is another reason to work on separating the source of Kinect data from its presentation.

The Solution

The general solution is to make a client-server system. The server lives in the classic Windows environment, the client is a WinRT app. Communication between client and server is realized using networking technology; preferably the fastest available. The server receives the data from the Kinect and does any processing that involves the Kinect SDK. The client prepares the data for presentation on the screen. If multiple servers are involved, it integrates and time-synchronizes data from several servers. Since I’m a C++, DirectX guy, the server and client are built on just these platforms

Other Solutions

...

Evaluation

In theory, WebSockets are slower than WinSockets. There can be much discussion about what would be the fastest solution under which circumstances. I expect WinSockets to be the fastest solution, therefore I prefer WinSockets.

Also, in theory, a C++ program is faster, and smaller, than an equivalent C# program. There can be much discussion … , therefore I prefer a program written in C++.

Of course, we should do asynchronously, or in parallel, whatever can be done quicker in parallel.

Approach

So, what’s a smart way to develop a client server system to show Kinect color and depth data in a WinRT app? For one, we start from SDK samples:

- A sample from the Kinect SDK that elaborates processing depth and color data together.

- A sample the shows how to use WinSockets (in C++).

- A sample that show how to use the WinRT StreamSocket using PPL tasks (yes we will exploit parallelism extensively .

- Windows Service (optional, see below).

The use of a Windows service is an option for later use. To work with a service instead of a simple console application requires that the server is capable of handling all kinds of exceptional situations, if only by resetting itself. Consider e.g. the case that no Kinect is connected, or if the Kinect is malfunctioning? Etc.? And apart from that, I expect the Kinect SDK to be made available for WinRT applications in due time.

...

Project Information URL: http://thebytekitchen.com/2012/10/17/viewing-kinect-data-in-the-new-windows-8-ui/

Contact Information:

• Blog: http://thebytekitchen.com/

MJPEG Decoder v1.2

Release Notes

• Added support for WinRT (ARM and x86/x64)
• Added support for Windows Phone 8
• Added Error event to catch connection exceptions (thanks to Mirek Czerwinski for the idea)
  • Note that the XNA and WP7 assemblies remain at v1.1 and do not contain this addition
• Samples for WinRT in C#/XAML and HTML/JavaScript (in source code repository)
• Sample for Windows Phone 8 in C#/XAML (in source code repository)

MJPEG Decoder

Library to decode MJPEG streams. Sample code showing usage is included with the distribution. For more information, see the full Coding4Fun Article.

MJPEG Decoder

Last year the Coding4Fun/Channel 9 guys asked me to work on a few things for MIX10.  One of these items was a way to output a webcam stream to Windows Phone 7 for use with Clint's t-shirt cannon project you may have read about.  I figured the easiest way to accomplish this was by using a network/IP camera capable of sending a Motion-JPEG stream, which can be easily decoded and displayed that can display a JPEG image.  Thus, this library was born.

It has gone through quite a few changes and I have expanded it to easily display MJPEG streams on a variety of platforms.  The developer just references the assembly appropriate to their platform, adds a few lines of code, and away it goes

...

Here's a snap of the Solution;

One important to note and that Brain mentions in the article, if you want to play with the test apps, you're going to need a MJPEG video source (which kind of makes sense, doesn't it?). If you've got one, then all you need to do is plug in the URI into the test apps, which as you can see there's a bunch, and off you go...

How has Process Lifetime Management (PLM) been reimagined in Windows 8? How does app suspension work, exactly, or, what happens when an app is no longer in the foreground and not closed? How much work can you do in the background when an app is suspended? Arun covers several topics here, so please do set aside some quality time. In return, you will gain new levels of deep understanding that will help you take advantage of the Windows Store App platform and build excellent modern Windows applications.

You've met Arun before, so you should be prepared for some very deep treatment of this new world for Windows and Windows developers. This is an excellent 400 level investigation of the core changes that support the new app model.

Huge thanks to Arun for another exceptional conversation and whiteboard session.

Tune in. Learn.

From windows to tiles: WinRT sensors – Overview and C# sample

Sensors are one of the most defining features that distinguish mobile devices such as tablets or smartphones from common PCs. This being the case, we have been enormously enthusiastic to play around with these components when our brand-new Surface RT tablet arrived recently. And by the way, this device feels like a charm.

Eventually, we decided to share our experiences in this regard in terms of a blog post giving an overview on the entire sensor landscape being available on the current Surface RT tablet running WinRT – the ARM chips targeting brother of Windows 8 – as an operating system.

Overview

Basically, the currently available version of Microsoft´s Surface tablet ships with four sensor devices:

1. An ambient light sensor
2. An accelerometer
3. A gyroscope
4. A magnetometer

Given the existence of these four sensors on a hardware layer, we may exploit them in various ways on an application layer; therefore, WinRT abstracts 7 sensor interfaces in its respective API:

1. An accelerometer
2. A gyroscope
3. A compass
4. A light sensor
5. An orientation sensor
6. A simplified orientation sensor
7. An inclinometer

For detailed information regarding the interplay of hardware-level sensor devices and application-layered sensor interfaces, please see here.

...

From windows to tiles: A tutorial on live tiles & badges

This blog post seeks to demonstrate the capabilities of Windows 8 “live tiles” and “badges” as initially introduced in Microsoft´s design language Modern UI (also referred to as Metro UI). Being one of the most defining UI elements in Modern UI style, the concept of (live) tiles should be worth looking at a bit closer.

Introduction

Already introduced in Windows Phone 7, the concept of “(live) tiles” has also been adopted in Windows 8 and thus applies regardless of whether our target platform is a mobile device (such as a Windows 8 phone or a corresponding tablet like the Microsoft Surface) or a Personal Computer. The term “tile” defines a rectangular button capable of displaying images, textual content and so-called “badges”. In this context, a badge may be either a small icon or a numeric value that is displayed in the bottom-right corner of a tile. The term “live” tile implies that the contents displayed by a tile may be updated dynamically during runtime. Taking into account both badges and a tile´s capability to change its appearance dynamically, Microsoft provides a mighty new feature enabling developers to keep the user updated about an application’s status even if the application itself is terminated or suspended.

A tile displaying its application´s name (bottom-left corner), two dynamically set strings (lines at the top) and a badge notification (bottom-right corner)

Tutorial

Microsoft allows us to provide tile images for three purposes:

...

From windows to tiles: Porting a Windows Phone 7 app to Windows Runtime – A small case study

I. Setting

To begin with, the application we intended to port as a first get-in-touch with Windows RT (also referred to as Windows Runtime, WinRT) is a small, Windows Phone 7 based soccer game leveraging the mightiness of Silverlight as a subset of the Windows Presentation Foundation (WPF). Therefore, the game´s entire frontend had been designed exclusively using Silverlight XAML and related concepts. Furthermore, the applied architecture strongly follows MVVM (Model-View-ViewModel) principles targeting a strict separation of user interface and application logic. The reason for this is, that the game itself has not been created with the intention of selling it but with the intention of evaluating MVVM in the context of rich graphics and highly dynamic UI states.

Typically, computer games tend to contain various animations ranging from trivial styling of UI elements to complex transitions. Therefore, it would make sense to thoroughly stick to the MVVM pattern to enable designers to do their creative stuff without having to care about any C# code . Usually, the design guys don´t even need to launch a Visual Studio instance, they exclusively need the more design-oriented tool Expression Blend where they can exploit the code provided by their coding colleagues without having to care about the respective implementation details at all (and vice versa).

To carry this clear separation and smooth collaboration to extremes, we intensely utilized Triggers, Actions (of all kinds) and Behaviors.

Being guided by the General Porting Process as specified by Microsoft, we started creating a new, so-called “Windows Store” Project and copied our folders containing code and assets. Please note, that the aforementioned project type specifies a Windows RT (or Modern UI style) application.

Apart from that, please take into account that this article takes the (Developer) Preview as a basis and might apply only partially in future versions of the Windows RT API.

II. Model and View Model Code

...

From windows to tiles: Towards the development of Windows Store applications

Launching their new operating system Windows 8, Microsoft establishes an entire set of novel technologies and concepts. The familiar desktop will be supplemented with an additional Start screen in “Modern UI” style (formerly known as “Metro UI” style); in addition to that, Microsoft introduces a new application type called “Windows Store App” (also referred to as Windows RT application or Modern UI application). Especially this new application type is the subject of controversial discussions in the community and thus requires to be focused on in particular.

On the one hand, there had been a certain enthusiasm concerning new controls, on the other hand there had also been a number of reports about shortcomings in comparison to Windows 7 WPF (Windows Presentation Foundation). Undoubtedly, however, the variety of applicable target platforms ranging from PCs to mobile devices such as tablets (i.e. Microsoft Surface which has been released just recently) and phones (at least to a certain extent) strongly contributes to the new operating system´s attractiveness.

From a developer´s point of view, Windows RT raises a number of questions:

• Which new features will be offered and how do they work?
• How does Windows RT differ from Silverlight or WPF?
• Which concepts and technologies will still be supported?
• How smooth can one port existing WPF-/ Silverlight-based applications to Windows RT?
• How comfortably can one actually mix XAML and C# with technologies like HTML or JavaScript?

Obviously, there are numerous exciting questions that require appropriate answers. Being a UI-focused company with strong expertise in the area of WPF and Silverlight, Centigrade GmbH is currently thoroughly concerned with the development of Windows Store applications. In fact, Centigrade is an official vendor of Microsoft Germany, supporting companies new to Windows RT with respective consulting services.

For this reason, we are intensely investigating the domain of Windows RT and hence want to share our knowledge and experiences with the community. Thus, we are going to publish several blog posts in the upcoming weeks both discussing Windows 8/ Windows RT related issues and providing hands-on tutorials.

...

New posts in this series are still coming, so subscribe to the feed and follow along on his journey...

• [0:36] Windows AzureConf 2012
• [1:15] Announcing the Latest Release of Office Developer Tools (Grace Kochavi)
• [2:46] Building quality Windows 8 apps: Important pre-submission checks for your Windows Store apps (Pete Brown)
• [3:44] How to manage unit tests in Visual Studio 2012 Update 1 : Part 1–Using Traits in the Unit Test Explorer (Terje Sandstrom (via Charles Sterling))
• [5:24] Windows 8 Development + Blendability (Braulio Diez)
• [6:44] IntelliTrace: Making On Time Shipping Possible (John Robbins)
• [7:42] Scaling cloud apps with the .NET Framework 4.5 (Richard Lander)
• [8:43] //build/ Flashback: Building High-Performing JavaScript for Modern Engines
• [9:43] Inside Windows 8: The Windows Runtime (Martyn Lovell and Elliot H Omiya)
• [10:57] OpenGL for WinRT

Picks of the Week!

• Brian's Pick of the Week:[11:54] Designing by Making: your process for arranging furniture can point toward a good process for UI design (Jan Miksovsky)
• Dan's Pick of the Week:[12:58] Kinected Browser - Kinect On The Web (Harry Fairhead)

Programming Note: Due to the Thanksgiving Holiday in the US next week, there will be much turkey eating and no TWC9...

Microsoft'ism Translation: "Magic Folder" (mentioned by Brian as "Magic Foldering") is the in-house service we wrote to encode our videos for all the different formats, prep them for publishing, etc. It's one of the magic parts that powers Channel 9

What is WinRT, exactly? Why is it designed the way it is? What's the history of WinRT? What are the primary goals of this new technology? How did the Windows engineering team arrive at the design and implementation of this new Windows user mode development platform? These are the key questions addressed in this conversation with Windows Runtime engineering leaders Martyn Lovell and Elliot H Omiya (we call him EHO). Elliot and Martyn are two of the original WinRT architects. Watch as they tell us how it was conceived, how it works, and why COM is such a big part of the equation (it's not your grandmother's COM, mind you. WinRT is a very different COM than classic COM). 

Huge thanks to Martyn and EHO for this excellent conversation.

Tune in.

Abstract
Windows Store apps will give users a great experience. Apps promise the user to be alive and connected. Being connected means interfacing with services and the cloud. But what options do we have to make the connection to the outside world? In this session, we'll explore how WinRT apps can connect with services (WCF, REST...) and the cloud to offer a great experience. We'll also see how internals like roaming data can be used in your apps.

Speaker: Gill Cleeren

Download the slides.

Extra
- Belgian app builders: discover your new home: http://msdn.be/apps AKA the Apps on Windows portal.
- Working on Windows 8 app and need some expert advice? Attend an App Clinic!
- Have a look at the next events we have planned for developers in Belgium: http://msdn-events.be 

WinRT XAML Toolkit

Project Description
A set of controls, extensions and helper classes for Windows Runtime XAML applications.

Disclaimer
This project is not managed by Microsoft. Its coordinator is currently not employed or sponsored by Microsoft. It is not a port of the Silverlight Toolkit, though it might get there at some point. This does not diminish the value of the code that is part of it and that you are free to use.

How do I use it?
Download the full source code or just the snippet you find useful. Be sure to try the samples! Find me on twitter to ask any questions.

Features

• Integrated extensions from the AsyncUI library- a set of extension methods for UI classes that add support for async/await to wait for events such as:
  • Wait for a BitmapImage to load
  • Wait for a Button or one of a list of buttons to be clicked
  • Wait for a FrameworkElement to load, unload or become non-zero-sized
  • Wait for a MediaElement to change state - eg. to start or finish playback
  • Wait for a Selector (e.g. ListBox) to change selected item
  • Wait for a Storyboard to complete
  • Wait for a VisualState transition to complete
  • Wait for a WebView to complete navigation
  • Wait for a WriteableBitmap to load (uses polling due to lack of an event)

• Controls
  • AnimatingContainer - a container control that will animate its contents rotating or zooming in/out, eg. to make them feel more alive.
  • CameraCaptureControl - supports displaying camera preview, capturing photos and videos, cycling between existing video capture devices, setting preference to Front/Back panel camera, etc.
  • CascadingTextBlock - a TextBlock replacement that animates the individual letters in a cascade - fading in while falling down into position, then optionally fading out while falling down from the standard position.
  • CountdownControl - a movie-style control that animates a ring-slice shape while counting down seconds - e.g. to take a picture with a camera after a given number of seconds (supports async/await).
  • CustomAppBar - a custom implementation of the AppBar that automatically handles the three gestures to switch IsOpen (WinKey+Z, Right-Click, EdgeGesture), adds a CanOpen property, so you can prevent it from opening and opens/hides with a sliding animation when placed anywhere in the app, so you can layer content on top of it. Also features CanDismiss property to force the app bar to stay open in some situations, CanOpenInSnappedView which allows to block the app bar from showing up when the app is in the snapped view.
  • CustomGridSplitter - a custom implementation of a GridSplitter as a templated control.
  • DelayedLoadControl - given a content/DataTemplate - loads the contents after a given amount of time - e.g. to allow for staged loading of contents on screen.
  • ImageButton - a custom Button control that takes one to three images to be used to represent different states of the button (normal/hover/pressed/disabled) as well as ways for the button to render all 4 states with just one or two images.
  • ImageToggleButton - custom ToggleButton control, that like ImageButton - helps create buttons based on button state images using from 1 to 8 different state images and generating other state images with some simple image processing.
  • InputDialog - a custom/templated dialog control that takes text input.
  • ListItemButton - a simple button control with Click event and Command property to be used inside of list controls (the standard button steals pointer capture from the List/Grid~Items so they can't be selected.
  • NumericUpDown - allows to display and manipulate a number using text input, +/- buttons or Blend-like swipe-manipulations
  • PieSlice - a pie slice path/shape given StartAngle, EndAngle and Radius.
  • RingSlice - a pie slice path/shape given StartAngle, EndAngle, Radius and InnerRadius.
  • WatermarkTextBox - TextBox control with a watermark. Set WatermarkText to change the watermark prompt, change WatermarkStyle to change the style of the watermark TextBlock.
  • WebBrowser - a templated control with a WebView + address bar, title bar, backstack navigation, favicon. work in progress (visual states are a bit messed up), but might be helpful as a starting point

• Controls.Extensions
  • AnimationHelper - two attached properties - Storyboard and IsPlaying. Allows to easily control Storyboard playback from a view model (note limitation - a single storyboard per control).
  • AppBarExtensions.HideWhenSnapped - allows to make the AppBar automatically hide when the app goes to the snapped view.
  • ContentControlExtensions.FadeTransitioningContentTemplate - allows to change content template with a fade out/fade in transition.
  • ControlExtensions.Cursor - enables setting a mouse cursor to show when hovering over a control.
  • ImageExtensions.FadeInOnLoaded/.Source - allows to specify an image source such that the image fades in smoothly when the image source is loaded.
  • ListBoxExtensions./ListViewExtensions.BindableSelection - allows a two-way binding of the SelectedItems collection on the Selector/list controls.
  • RichTextBlockExtensions.PlainText - attached property that allows to easily single-way-bind plain text to a RichTextBlock (not really that useful other than for visualizing RichTextBlock styles in the sample app provided).
  • TextBlockExtensions/GetCharacterRect() - an extension method that returns a rectangle that holds a character at a given index in the TextBlock
  • TextBoxValidationExtensions - extensions that allow to specify the Format of the requested Text input as well as brushes to use to highlight a TextBox with valid or invalid Text.
  • ViewboxExtensions.GetChildScaleX()/GetChildScaleY() - return the effective scale of the Viewbox Child.
  • VisualTreeHelperExtensions - provides a set of extension methods that enumerate visual tree ascendants/descendants of a given control - making it easy to do these operations with LINQ as well as simple ways to list controls of a given type or find the first control of a given type searching up or down the visual tree
  • WebViewExtensions - extensions to get currently loaded page address, title, favicon, head tag's inner HTML.

• Converters.
  • BindingDebugConverter - helps debug bindings by allowing to trace or break whenever a binding gets updated.
  • BooleanToDataTemplateConverter - given two DataTemplates (TrueTemplate and FalseTemplate) - converts the input value to the given template. A different take on DataTemplateSelector.
  • BooleanToVisibilityConverter - the mother of all converters
  • ColorToBrushConverter - converts a Color to a Brush
  • DoubleToIntConverter
  • NullableBoolToBoolConverter
  • NullableBoolToVisibilityConverter
  • SecondsToTimeSpanStringConverter - converts the number of seconds (a double type) to a TimeSpan - useful for configuring some animations

• Debugginghelpers
  • VisualTreeDebugger - provides a trace of the visual tree structure when a control loads, its layout updates or it gets tapped as well as allowing the application to break in the debugger if one of these events occurs
  • Debug/DebugConsole/DebugConsoleOverlay/DC.Trace() - enables tracing and displaying traced information right in the application on a collapsible panel

• Imaging Extensions
  • BitmapImageLoadExtensions - extensions to simplify loading BitmapImages based on StorageFile or file name
  • ColorExtensions - Conversions between pixels and pixel buffer types of byte, int and Color
  • IBufferExtensions - Adds a GetPixels() extension method to the PixelBuffer property of a WriteableBitmap that reads in the buffer to a byte array and exposes an indexer compatible to the one of the Pixels property in Silverlight's WriteableBitmap
  • WriteableBitmap~- a set of extension methods for a WriteableBitmap
    • WriteableBitmapSaveExtensions - support for loading and saving the bitmap to/from files
    • WriteableBitmapBlitBlockExtensions - support for quick blitting of a full-width section of a bitmap to another bitmap of same width
    • WriteableBitmapCopyExtensions - support creating a copy of a WriteableBitmap
    • WriteableBitmapCropExtensions - support for creating a cropped version of a WriteableBitmap
    • WriteableBitmapDarkenExtension - performs image processing to darken the pixels of the WriteableBitmap.
    • WriteableBitmapFloodFillExtensions - support for flood-filling a region of a WriteableBitmap - either limited by an outline color or by replacing a given color - usually a color at the starting position or colors similar to it
    • WriteableBitmapFromBitmapImageExtension - allows to create a WriteableBitmap from a BitmapImage assuming the BitmapImage is installed with the application.
    • WriteableBitmapGrayscaleExtension - performs image processing to make the pixels of the WriteableBitmap (more) grayscale.
    • WriteableBitmapLightenExtension - performs image processing to lighten the pixels of the WriteableBitmap.

• IOhelpers
  • ScaledImageFile.Get() - Used to retrieve a StorageFile that uses qualifiers in the naming convention.
  • StorageFileExtensions.GetSize()/.GetSizeString() - allow to get the size of a file and its string representation (automatically converting from bytes to kB, MB, GB, TB)
  • StorageFolderExtensions
    • .ContainsFile() - returns a value that states whether a file with specific name exists in the folder
    • .CreateTempFile() - creates a temporary file
    • .CreateTempFileName() - returns an unused, unique file name for a temporary file
  • StringIOExtensions - allows to easily read or write a string from/to file in a single call
  • Serialization
    • JsonSerialization - allows to serialize a properly DataContract-annotated object to a JSON string or file or deserialize an existing one.
    • XmlSerialization - allows to serialize a properly DataContract- or XmlSerializer-annotated object to a XML string or file or deserialize an existing one.

• Net.WebFile.SaveAsync()- downloads a file from a given URL, automatically figuring out the recommended file name and saving it to a given or default folder

• Tools
  • BackgroundTimer - a timer class similar to DispatcherTimer in its interface, but somewhat more precise and running on a background thread
  • EnumExtensions.GetValues<T>() - allows to get an array of strongly typed values of enum type T
  • TryCatchRetry - allows to run a specific Task or Action, catching exceptions and retrying for a specified number of retries, with optional delays in between (mostly a debugging tool or a means of temporary workarounds)

WinRT XAML Toolkit - 1.2.0 (Click here for the latest version)

WinRT XAML Toolkit based on the Windows 8 RTM SDK.

Download the latest source from the SOURCE CODE page.

For compiled version use NuGet.

You can add it to your project in Visual Studio by going to View/Other Windows/Package Manager Console and entering:
PM> Install-Package winrtxamltoolkit

Features

• AsyncUI extensions
• Controls and control extensions
• Converters
• Debugging helpers
• Imaging
• IO helpers
• VisualTree helpers
• Samples

Here's a snap of the Solution;

The latest drop compiled and ran for me the first time with no problems. Here's some snaps of the sample app;

(Wow, I need to shave...and loose the gray hair... lol)

• [0:51] http://www.buildwindows.com/, Build 2012 is sold out. Tune in online., http://channel9.msdn.com/Events/BUILD/2012
• [1:50] What is Portable Class Library project in Visual Studio 2012– .NET 4.5 (Kishore Babu Gaddam)
• [3:04] Javascript Fundamentals: Development for Absolute Beginners (Clint Rutkas, Bob Tabor, Golnaz )
• [3:54] Building your own Windows Runtime components to deliver great Metro style apps (Ines Khelifi)
• [6:22] UPDATED HOWTO: SQLite with Windows 8 apps (Tim Heuer)
• [7:34] Maximizing Code Reuse Across Windows 8 and Windows Phone Apps (Alnur Ismail)
• [8:37] Callisto (Tim Heuer) [Found via: CALLISTO Library]
• [9:39] Large collection of Free Microsoft eBooks for you, including: SharePoint, Visual Studio, Windows Phone, Windows 8, Office 365, Office 2010, SQL Server 2012, Azure, and more. , Another large collection of Free Microsoft eBooks and Resource Kits for you, including: SharePoint 2013, Office 2013, Office 365, Duet 2.0, Azure, Cloud, Windows Phone, Lync, Dynamics CRM, and more. (Eric Ligman), Microsoft Technologies E-Book Gallery (TechNet Wiki)
• [10:32] Channel 9 Highlight: Defrag Tools (Andrew Richards, Larry Larsen)

Picks of the Week!

• Brian's Pick of the Week:[11:21] KinÊtre - Animating the World with the Human Body (Steve Clayton)
• Dan's Pick of the Week: [12:58] Build Easter Egg http://www.buildwindows.com 

• [0:54] Announcing BUILD 2012 (Tim O'Brien)
• [1:58] Creating beautiful views for local files (Marc Wautier)
• [3:50] MetroGridHelper for WinRT, a helper to get the alignment right (Mark Monster)
• [4:28] Debugging WinRT/XAML bindings (Andrej Tozon)
• [6:06] Channel 9 Highlight: Designing Metro Style Line of Business Apps (Robert Green)
• [7:10] The .NET Framework 4.5 includes new garbage collector enhancements for client and server apps (Brandon Bray)
• [9:31] aspConf http://live.aspconf.net/ & <http://channel9.msdn.com/Events/aspConf/aspConf>, aspConf 2012 Speaker Blogs and Twitter accounts: An OPML file for bulk blog feed subscription and a Twitter list for easy Following (Jon Gallant)
• [10:22] Facebook Apps and Windows Azure Web Sites (Part 1 – Getting Started) [Nathan Totten]
• [11:38] Channel 9 Highlight: What Is an Arduino Shield and Why Should My Netduino Care? (Fabien Royer)

Picks of the Week!

• Brian's Pick of the Week:[13:19] New Programming Jargon (Jeff Atwood)
• Dan's Pick of the Week:[15:37] Codealike VS2010 Extension

Abstract
The Windows 8 Runtime (WinRT) is the cornerstone for developing native C++ applications for the Windows 8 Metro platform. This session will explain what exactly the WinRT is, what it is capable of, and how to use it for your C++ Metro applications. You will also see a few language changes that have been made to C++ to make it easier to use the WinRT. The Metro UI aspect of C++ Metro applications can be implemented using XAML or DirectX. This session will go deeper in on how to use XAML and the XAML designers to develop UI for C++ Apps.

Speaker: Marc Grégoire

Build your Windows 8 app now! Make it real within 4 simple steps: http://www.microsoft.com/belux/msdn/metromap/buildyourapp.html