Tag Archives: WinRT

Microsoft Surface

At work we have a few Microsoft Surface devices that anyone can borrow and it was my turn to play with it over the last 4 days :)

I never owned a tablet and if you are wondering if I am itching to buy one now then read on 😉

The truth is that I mainly write apps for Windows ecosystem, mainly because I am good at C#, having said that I could be using C# to write apps for iOS and Android as well, but I find the license costs for MonoTouch and Mono for Android a bit prohibitive. Anyway, this is why I am more inclined to buy a Windows 8 tablet. Not because I would think that iPad or Android tablets are crap, purely being pragmatic here.

So I had Microsoft Surface at my disposal for the last few days and I realized I don’t really need a tablet. Whether I want one is a different question though 😉

I still found myself using my laptop more than the tablet. I suppose I am more of a creator than consumer and for someone who creates content the tablet world is still lacking. And TouchCover cannot replace a good keyboard and a great touchpad or a mouse.

I am in fact, writing this blog post on the TouchCover keyboard. I do think what Microsoft has done with it is ingenious, but still a compromise. Good for quickly typing away some notes, but a bit frustrating when writing longer texts. Still I think they have done a great job, good to see innovation like this coming from Microsoft, they have been horrendous at marketing their innovations in the past. And if you follow them a bit more closely there is lots of interesting things Microsoft Research is working on.

I think it would be nice if Surface had 3G or 4G connectivity as well and personally I see more value in a tablet running on Intel Atom Clover Trail platform.

No major complaints about the rest of the tablet. Windows 8 is a smooth OS, the build quality is awesome and the Windows store is growing fast in size too. Even though I never really understood the bragging about app numbers from all players in the market. I mean, how many of those apps are actually any good? Writing a good app is actually not that easy. It is not just about being a good developer, you have to know a thing or two about UX and marketing too.

My major complain is actually about the price of this thing and the price of tablets in general. I just don’t think a 32GB 10′ tablet should be priced above $400. And that extends to Apple products as well, while Android does have some products in this price range.

And I am unhappy about the unavailability of Windows 8 tablets in stores. I’ve read that Microsoft is unhappy with sales, but then again, even if you want a tablet (talking about tablets other than Surface here) they are incredibly hard to find. Some say this could be down to some issues Intel is having with their new Clover Trail SOC, OEMs say that the demand is low, others say that retailers just want to clear old Windows 7 stock first. Personally I think it is just a load of bullshit and Microsoft and OEMs need to get their act together.

So yeah, I won’t be buying a Surface. But I do want a tablet so I can test my creations. But I’ll resort to eBay in search of a bargain or just wait until there are some cheaper options on the market. I do hope someone comes up with a 7′ tablet in the near future. If it is priced between $300 – $400 I would buy one, that would be an ok price even though it would not see a lot of use apart from app testing and a little bit of browsing and video watching when I don’t have my laptop near me.

Using gestures in MonoGame (and XNA)

I was trying to use this bit of code yesterday, but it didn’t work:

        protected override void Update(GameTime gameTime)
        {
            while (TouchPanel.IsGestureAvailable)
            {
                var gesture = TouchPanel.ReadGesture();
                if (gesture.GestureType == GestureType.FreeDrag)
                {
                    _cue.Rotate(gesture.Delta, GraphicsDevice.Viewport.Bounds);
                }
            }

            base.Update(gameTime);
        }

Why? Because I forgot to enable gestures! This line was all that was missing:

            TouchPanel.EnabledGestures = GestureType.FreeDrag;

EnabledGestures is a flag property so you can enable multiple types of gestures by using bitwise or, like, for example:

 TouchPanel.EnabledGestures = GestureType.FreeDrag | GestureType.Tap;

In my rotate method I simply translate the delta into something more useful, which in my cases are degrees:

        public void Rotate(Vector2 delta, Rectangle viewPortBounds)
        {
            var degreesAroundYAxis = (delta.X / viewPortBounds.Width) * 360;
            var degreesAroundXAxis = (delta.Y / viewPortBounds.Height) * 90;
            Rotation += new Vector3(MathHelper.ToRadians(degreesAroundXAxis), MathHelper.ToRadians(degreesAroundYAxis), 0.0f);

            if (MathHelper.ToDegrees(Rotation.X) < 5.0f)
            {
                Rotation = new Vector3(MathHelper.ToRadians(5.0f), Rotation.Y, Rotation.Z);
            }
        }

Starting with MonoGame

I love coding little apps for my phone and (hopefully soon) tablet. The project I am working on now is porting a simple Snooker game I wrote using DirectX and C++ nearly a decade ago over to Windows 8 and Windows Phone devices.

My initial plan was to just copy my C++ code to a Direct3D project, tweak a few things and see it run. An overly optimistic goal, given my rusty C++ skills and the fact that DirectX API has evolved a lot since DirectX 8. So I started looking for alternatives that would get me to my goal quicker (I like to keep my hobby project short). If XNA had support on Windows 8 and Windows Phone 8 devices I would go with that one, but since they are not I started looking at MonoGame which is an open source implementation of XNA API. And it is awesome.

To get started you need to get MonoGame source code from GitHub by cloning the repository. The source contains VS2012 templates, copy these over to your templates folder and you are ready to start coding with MonoGame. For more details on how to do this follow instructions at bob’s blog. But you will need to (or can) do certain things differently!

First, MonoGame project has evolved a bit since and now you will have three VS2012 templates in there:

  • Game is the one you want to use if you are writing a game using MonoGame only,
  • XamlGame is a combination of MonoGame and XAML and
  • WindowsPhone is obvious

Secondly, before you can load your mesh models into your game you need to convert them into XNB file format, but at the moment there are no Content Importers in XNA. So you will need to use project templates that come with XNA Game Studio in order to convert the models to XNB format. There were some issues with installing XNA on Windows 8 in the past (see Aaron Stebner’s WebLog) but if you install Windows Phone 8 SDK it installs without a problem and you can use XNA Content project from VS2012. Then create a “Content” folder within your MonoGame project and copy XNB files in there (mark them as Content in properties and make sure they are always copied to output directory). I believe you could tweak the location by changing the line below in your Game class:

Content.RootDirectory = "Content";

This should have you ready and going. As for myself, I have this after one day:

Snook

Creating your own photo viewer app for Windows 8

Problem

In Windows 8 you can use the Photo app to view pictures in My Pictures folder. While the Photo app has lots of features and is updated with new ones quite often there is one feature I miss – the ability to navigate between pictures in the same folder as the picture I just clicked on.

Solution 

Writing a Windows Store app that solves the problem is very easy and here is how we do it.

If you are running Visual Studio on Windows 8 it comes preinstalled with templates to build Windows Store apps. For the purposes of this tutorial we are going to use the Blank App XAML template. I am going to name my app PhotoViewer.

create-project

Next we need to declare what the app needs to do it’s work and what it can do. Double-click Package.appxmanifest file in Solution Explorer, click on Capabilities tab and tick Pictures Library, this will give us access to user’s Pictures library, which is also a limitation of our app – we can only use it to view pictures that are stored in Pictures library.

We don’t need to connect to internet so you can untick Internet (client) capability.

set-capabilities

Next we are going to declare that our app can handle certain types of files. Navigate to Declarations tabs and add File Type Associations from Available Declarations dropdown. In the left pane type in Display Name and Name. Display Name is going to be used to describe the files this app can open, Windows Explorer will use this value to describe the files if you make PhotoViewer the default app to open files it supports. Next, tick Open is safe checkbox, if you wish you can tick Always unsafe if you want the user to confirm before file is opened. And lastly, add Supported file types. For the purposes of this example we are going to support jpg files, but you can add as many as you wish. Anyway, to add jpg type in image/jpeg in Content type and .jpg in File type text box, just like on the screenshot below.

set-declarations

With configuration done we can do some coding.

Open App.xaml.cs and override OnFileActivated method. The code we are going to put in OnFileActivated looks like this:

  
        protected override void OnFileActivated(FileActivatedEventArgs args)
        {
            var rootFrame = Window.Current.Content as Frame;

            if (rootFrame == null)
            {
                rootFrame = new Frame();
            }

            if (args.Files != null && args.Files.Any())
            {
                rootFrame.Navigate(typeof(MainPage), args);
                Window.Current.Content = rootFrame;
                var p = rootFrame.Content as MainPage;
            }

            Window.Current.Activate();
        }

In here we are setting up the contents of the app by creating a new Frame object which acts as a container for our pages. Our app’s starting page is MainPage so we navigate to it and passing file activation arguments to it. When MainPage is navigated to we need to set our data source. In order to do so we will tweak MainPage.cs like so:

    public sealed partial class MainPage : LayoutAwarePage
    {
        private FolderViewModel _viewModel;

        public MainPage()
        {
            this.InitializeComponent();
            _viewModel = new FolderViewModel();
            DataContext = _viewModel;
        }

        /// <summary>
        /// Populates the page with content passed during navigation.  Any saved state is also
        /// provided when recreating a page from a prior session.
        /// </summary>
        /// <param name="navigationParameter">The parameter value passed to
        /// <see cref="Frame.Navigate(Type, Object)"/> when this page was initially requested.
        /// </param>
        /// <param name="pageState">A dictionary of state preserved by this page during an earlier
        /// session.  This will be null the first time a page is visited.</param>
        protected override async void LoadState(Object navigationParameter, Dictionary<String, Object> pageState)
        {
            // Allow saved page state to override the initial item to display
            if (pageState != null && pageState.ContainsKey("DataContext"))
            {
                _viewModel = (FolderViewModel)pageState["DataContext"];
            }
            else if (navigationParameter is FileActivatedEventArgs)
            {
                await _viewModel.Initialize((FileActivatedEventArgs)navigationParameter);
            }

            // To make debugging easier this code is only included in release mode
            if (!_viewModel.ContainsPictures)
            {
                await ShowWarningAndClose();
            }
        }

        private async Task ShowWarningAndClose()
        {
            var messageDialog = new MessageDialog("To use PhotoViewer select a picture in Pictures Library first.", "No Picture Selected");

            messageDialog.Commands.Add(new UICommand(
                "Close",
                new UICommandInvokedHandler(this.CommandInvokedHandler)));

            await messageDialog.ShowAsync();
        }

        private void CommandInvokedHandler(IUICommand command)
        {
            App.Current.Exit();
        }

        /// <summary>
        /// Preserves state associated with this page in case the application is suspended or the
        /// page is discarded from the navigation cache.  Values must conform to the serialization
        /// requirements of <see cref="SuspensionManager.SessionState"/>.
        /// </summary>
        /// <param name="pageState">An empty dictionary to be populated with serializable state.</param>
        protected override void SaveState(Dictionary<String, Object> pageState)
        {
            pageState["DataContext"] = _viewModel;
        }
    }

First, note that I have changed MainPage class to inherit from LayoutAwarePage. LayoutAwarePage is a class that is included in other Windows Store app templates, such as Grid App XAML template. It handles a number of page navigation aspects hence I copied it over to my PhotoViewer app. When you copy this class over also copy BindableBase and SuspensionManager classes, we will need them. Next notice that I am setting DataContext to our view model in MainPage constructor, but this is not where the view model is initialized.

View model initialization occurs in LoadState method. There are two ways of initializing the view model; we could be coming back to MainPage in which case the view model is initialized from page state (which gets saved in SaveState method) or we could be navigating to the page for the first time in which case we initialize view model based on the arguments that were passed in.

This class also contains some code to notify the user when there is nothing to display but that is fairly straight forward. Let’s have a look at the FolderViewModel class instead:

    internal class FolderViewModel : BindableBase
    {
        private ObservableCollection<PictureModel> _pictures = new ObservableCollection<PictureModel>();
        public ObservableCollection<PictureModel> Pictures 
        {
            get { return _pictures; }
        }

        private async Task SetPictures(IEnumerable<StorageFile> pictures)
        {
            _pictures.Clear();
            foreach (var picture in pictures.Select(f => new PictureModel(f)))
            {
                await picture.Initialize();
                _pictures.Add(picture);
            }
        }

        public bool ContainsPictures { 
            get { return Pictures != null && Pictures.Any(); }
        }

        public async Task Initialize(FileActivatedEventArgs args)
        {
            var file = args.Files[0];

            var folderPath = file.Path.Replace(file.Name, string.Empty);
            var folder = await StorageFolder.GetFolderFromPathAsync(folderPath);

            await SetPictures(await folder.GetFilesAsync());
        }
    }

When initializing the view model we take in file activation arguments (FileAcivatedEventArgs) which contain the path of the photo that was selected in Windows Explorer. Note that most IO APIs in WinRT are asynchronous by nature, hence the usage of async/await keywords. Based on the path being passed we determine the contaning folder and initialize our pictures collection with all photos from the same folder. The collection contains objects of PictureModel type which is a simple class containing information we need on the UI:

    internal class PictureModel : BindableBase
    {
        private StorageFile _file;

        public PictureModel(StorageFile file)
        {
            _file = file;
        }

        public string UniqueId { 
            get { return _file.Path; } 
        }

        private BitmapImage _image;
        public BitmapImage Image
        {
            get { return _image; }
        }

        public async Task Initialize()
        {
            var fileStream = await _file.OpenAsync(Windows.Storage.FileAccessMode.Read);
            BitmapImage bmp = new BitmapImage();
            bmp.SetSource(fileStream);
            _image = bmp;
            OnPropertyChanged("Image");
        }
    }

The bit that is important is in Initialize method – you have to initialize BitmapImage from a file stream, if you don’t you will end up with a page but no image.

Now that we have all the code we only need to create some XAML to display the information. And here is how it will look like:

        <FlipView
            AutomationProperties.AutomationId="ItemsFlipView"
            AutomationProperties.Name="Item Details"
            ItemsSource="{Binding Pictures}">

            <FlipView.ItemContainerStyle>
                <Style TargetType="FlipViewItem">
                    <Setter Property="Margin" Value="0,0,0,0"/>
                </Style>
            </FlipView.ItemContainerStyle>

            <FlipView.ItemTemplate>
                <DataTemplate>

                    <!--
                        UserControl chosen as the templated item because it supports visual state management
                        Loaded/unloaded events explicitly subscribe to view state updates from the page
                    -->
                    <UserControl Loaded="StartLayoutUpdates" Unloaded="StopLayoutUpdates">
                        <Grid>
                            <Image Height="Auto"
                                   Width="Auto"
                                   Source="{Binding Image}">
                            </Image>
                        </Grid>

                        <VisualStateManager.VisualStateGroups>

                            <!-- Visual states reflect the application's view state inside the FlipView -->
                            <VisualStateGroup x:Name="ApplicationViewStates">
                                <VisualState x:Name="FullScreenLandscape"/>
                                <VisualState x:Name="Filled"/>

                                <!-- Respect the narrower 100-pixel margin convention for portrait -->
                                <VisualState x:Name="FullScreenPortrait">
                                    <Storyboard>
                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="image" Storyboard.TargetProperty="Margin">
                                            <DiscreteObjectKeyFrame KeyTime="0" Value="97,20,87,67"/>
                                        </ObjectAnimationUsingKeyFrames>
                                    </Storyboard>
                                </VisualState>

                                <!-- When snapped, the content is reformatted and scrolls vertically -->
                                <VisualState x:Name="Snapped">
                                    <Storyboard>
                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="image" Storyboard.TargetProperty="Margin">
                                            <DiscreteObjectKeyFrame KeyTime="0" Value="17,20,17,67"/>
                                        </ObjectAnimationUsingKeyFrames>
                                    </Storyboard>
                                </VisualState>
                            </VisualStateGroup>
                        </VisualStateManager.VisualStateGroups>

                    </UserControl>
                </DataTemplate>
            </FlipView.ItemTemplate>
        </FlipView>

FlipView is a perfect control for what we are trying to achieve as it allows us to flip through items in our folder. A few things to notice here:

  • ItemsSource is bound to Pictures property of our FolderViewModel,
  • FlipView’s DataTemplate contains an Image control whose Source is bound to Image property of PictureModel class.

Conclusion

This is it. Running the app from Visual studio will only display a warning that no pictures could be found, but if you go to Windows Explorer and right click on a photo in Pictures library you should see an option to open it with PhotoViewer. Overall it is a very basic app, but it is a good start. Complete source code of this tutorial is on GitHub.