ON Blog » Windows Phone 7

Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 3

onishimura — Thu, 29 Jul 2010 09:27:44 +0000

This is part 3 in a 3 part tutorial for creating a notes application using Silverlight and Windows Phone 7. The previous articles can be read here
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 1
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 2

Download the code here

Currently our application can display a list of notes, and create and save a new note. The last piece of the puzzle is to allow the user to delete an existing note. To accomplish this all we really need to do is add an application bar button to the details page, remove it from the working items list, and save it to isolated storage.

Add the appbar.save.rest.png image in C:\Program Files\Microsoft SDKs\Windows Phone\v7.0\Icons to the Images folder in the project, and set it’s ‘Build Action’ to Content’, and it’s ‘Copy to Output Directory’ proerpty to ‘Copy if newer’.

Change DetailsPage.xaml to include an application bar, with the following code:
```
	
		
		
	
```
The two ApplicationBarIconButton added here will allow the user to return to the main list of notes, or delete the current note being viewed.

Modify the DetailsPage class (DetaislPage.xaml.cs) to do the following

Create a private instance variable to represent the current index of current note
Change the ‘OnNavigatedTo’ method to set this index when the page gets focus
Add event handlers for the delete and back buttons

The DetailsPage class uses an index scoped to the OnNavigatedTo method, and sets the pages DataContext using it. All we really need to do is change it to an instance member and set it in OnNavigated To like so:

private int index;

protected override void OnNavigatedTo(NavigationEventArgs e)
{
	base.OnNavigatedTo(e);

	string selectedIndex = "";
	if (NavigationContext.QueryString.TryGetValue("selectedItem", out selectedIndex))
	{
		index = int.Parse(selectedIndex);
		DataContext = App.ViewModel.Items[index];
	}
}

The event handlers are fairly straightforward. For the delete button, it should remove the note from the working list, save the current list to isolated storage, and finally navigate to the MainPage. The back button should simply navigate the user back to the MainPage.

private void appbar_button1_Click(object sender, EventArgs e)
{
	if (index < App.ViewModel.Items.Count)
	{
		App.ViewModel.Items.RemoveAt(index);
		StorageHelper.Save>(App.NotesFileName, App.ViewModel.Items);
	}
	NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

private void appbar_button2_Click(object sender, EventArgs e)
{
	NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

After all of these changes your class should look like this

using System;
using System.Collections.ObjectModel;
using System.Windows.Navigation;
using Microsoft.Phone.Controls;

namespace MyNotes
{
    public partial class DetailsPage : PhoneApplicationPage
    {
        // Constructor
        public DetailsPage()
        {
            InitializeComponent();
        }

        private int index;

        // When page is navigated to, set data context to selected item in list
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            string selectedIndex = "";
            if (NavigationContext.QueryString.TryGetValue("selectedItem", out selectedIndex))
            {
                index = int.Parse(selectedIndex);
                DataContext = App.ViewModel.Items[index];
            }
        }

        private void appbar_button1_Click(object sender, EventArgs e)
        {
            if (index < App.ViewModel.Items.Count)
            {
                App.ViewModel.Items.RemoveAt(index);
                StorageHelper.Save>(App.NotesFileName, App.ViewModel.Items);
            }
            NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
        }

        private void appbar_button2_Click(object sender, EventArgs e)
        {
            NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
        }
    }
}

And thats it. We can now add a new note, view a list of current notes and delete an existing note. This note app for Windows Phone 7 is fairly simple in functionality, so naturally there’s many more features you can add. For example, we could allow the editing of notes, or the addition of different types of notes, such as sketches. I’ve added the completed project below.

Download the code here

Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 2

onishimura — Tue, 27 Jul 2010 09:19:50 +0000

This is part 2 in a 3 part tutorial for creating a notes application using Silverlight and Windows Phone 7. The other articles can be read here
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 1
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 3

In part one of the tutorial we created the project, added a new Note class to serve as our model, and added a StorageHelper class to help us manage IsolatedStorage. The next step is to add support for adding a note to the app. We’ll keep it simple and just use a button on the main page’s application bar to add a note. When a user clicks the add note button on the main page, a new Windows Phone 7 page will load, which will enable the user to enter a note title and note text. They’ll also be able to save the note, or cancel the save, which will return them to the main page.

Add default icons to the project in order to support adding a note, saving a note and canceling the action. When you install the Windows Phone 7 SDK it also installs a number of default icons in C:\Program Files\Microsoft SDKs\Windows Phone\v7.0\Icons. For our purposes we’re going to use the icons in the dark folder, specifically add the following to the Images folder:
- appbar.add.rest.png
- appbar.save.rest.png
- appbar.cancel.rest.png
After adding these icons, modify their properties so that their Resource type is Content and Copy to output directory is ‘Copy if newer’. This allows us to configure the IconUri property on the ApplicationBarIconButton to a path like the following: IconUri=”/Images/appbar.add.rest.png”.
Modify MainPage.xaml and MainPage.xaml.cs to do the following:
- Display the notes properly
- Add a new application bar button
- An event handler for the button’s click
- Refresh the list of displayed notes whenever the page is navigated to. This will allow the user to see the new notes that they’ve added.
In MainPage.xaml change the StackPanel in MainListBox to the following:
```
   
   
```
This allows the notes to be displayed on the main page, displaying the note’s title and createdate. Now add the following application bar before the closing phone:PhoneApplicationPage tag
```
   
        
   
```
This will add our appbar button and use the add icon we added earlier as it’s image. Next we change MainPage.xaml.cs to handle the app bar button’s click event. First add an event handler:
```
        private void appbar_button1_Click(object sender, EventArgs e)
        {
            // Navigate to the new page
            NavigationService.Navigate(new Uri("/AddPage.xaml", UriKind.Relative));

            // Reset selected index to -1 (no selection)
            MainListBox.SelectedIndex = -1;
        }
	
```
This simply uses the base navigation framework in the windows phone 7 version of silverlight to navigate the user to the AddPage page, which we’ll add in a bit. Now modify the OnNavigatedTo method to refresh the data list whenever the page gets focus
```
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            if (DataContext == null)
                DataContext = App.ViewModel;

            App.ViewModel.Refresh();
            MainListBox.ItemsSource = App.ViewModel.Items;
        }
	
```
Modify MainViewModel.cs to add a Refresh method that will set the ViewModel’s current Items property to the latest data in isolated storage. All we really need to do is call the Load method in our StorageHelper class
```
public void Refresh()
{
    Items = StorageHelper.Load>(App.NotesFileName);
}
```
Also, remove the code in the MainViewModel.cs constructor that initializes the ObservableCollection of ItemViewModels. The Refresh method will be called by the MainPage’s OnNavigateTo method (which is also called when the page is first displayed)

Finally, add a new Silverlight xaml page, AddPage.xaml and configure it with Silverlight controls (textblocks and textboxes) for title and note. Additionally, add the application bar items to the AddPage.xaml file for saving and canceling, and modify AddPage.xaml.cs to handle the click events

The xaml for AddPage.xaml should look like the following. Note that we’re using the save and cancel icons we added earlier, for the application bar

The code behind for this page really only needs two events added to it, to save the note and navigate back to the main page, and to navigate back to the main page when the user clicks ‘cancel’

private void button1_Click(object sender, EventArgs e)
{
	Note newNote = new Note { Title = textTitle.Text, NoteText = textNote.Text, CreateDate = DateTime.Now };
	newNote.Save();

	NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

private void button2_Click(object sender, EventArgs e)
{
	NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

And thats it! We should now be able to add a note to our notes.dat file, and view the new note in a list of notes on our main page. As you can see adding controls and event handlers in silverlight and windows phone 7 is quick and easy. Next up, deleting a note…..

Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 1

onishimura — Sun, 25 Jul 2010 08:24:28 +0000

This is part 1 in a 3 part tutorial for creating a notes application using Silverlight and Windows Phone 7. The other articles can be read here
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 2
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 3

Admittedly a bouncing ball on Windows Phone 7 isn’t all that useful, so I decided to create a sample application that could do a little more than draw a ball or say ‘hello world’. Ideally I wanted to work with some of the core concepts on the phone, such as lists, navigation and the application bar. Additionally I wanted a Windows Phone 7 app that persisted it’s data, which meant working with Isolated Storage. Obviously this calls for a note-taking app…after all who doesn’t love taking notes? Notes are only second to bouncing balls in my book.

To keep the scope of the app small and focused, I wanted the note app to do only the following

View a list of notes
Add a note
Delete a note

Pretty simple, right? The actual implementation turned out to be fairly quick as well. The full step by step is a little long for a single blog post so I’m breaking it up into three posts. The first post covers creating the project, adding a support class to help manage the isolated storage, and defining the model. The second post will cover adding a note, and the third post will cover deleting a note.

To start with, create a Windows Phone List Application, named MyNotes. This will create a basic silverlight template for managing list-based apps. The structure of the project follows the MVVM pattern, so the views are populated by ViewModel classes, defined in the ViewModel folder.

Here’s a quick run down of the files in the base list project:
- MainPage.xaml : The initial screen of the site, which displays data in a ListBox named MainListBox by default. Selecting an item fires the MainListBox_SelectionChanged which navigates the user to the details page
- DetailsPage.xaml : Individual item details for each item in the list. Clicking on an item on the main page brings you here
- MainViewModelSampleData.xaml : Just as the name states, sample data that’s displayed during design time. Basically allows the design surface to render with the xaml designer.
- MainViewModel.cs : ViewModel for the MainPage, by default the project populates itself with dummy “runtime” data when the project is run. The application has a property, ViewModel, which is an instance of this class and used in both the main page and details page to show the items.
- ItemViewModel.cs : ViewModel for each individual item in the list. This default class has really only three properties, LineOne, LineTwo, LineThree, but also demonstrates an implementation for INotifyPropertyChanged

Create a helper class to save notes data. Local data storage using silverlight in Windows Phone 7 is currently limited to using isolated storage. There’s no limit on the amount of data that can be stored though, other than the physical limit of the device of course. I’ve used something similar to the following in the past (This uses System.Runtime.Serialization so you’ll have to add that as a reference):

using System.IO.IsolatedStorage;
using System.Runtime.Serialization;

namespace MyNotes
{
    public class StorageHelper
    {
        public static T Load(string name) where T : class, new()
        {
            T loadedObject = null;
            using (IsolatedStorageFile storageFile = IsolatedStorageFile.GetUserStoreForApplication())
            using (IsolatedStorageFileStream storageFileStream = new IsolatedStorageFileStream(name, System.IO.FileMode.OpenOrCreate, storageFile))
            {
                if (storageFileStream.Length > 0)
                {
                    DataContractSerializer serializer = new DataContractSerializer(typeof(T));
                    loadedObject = serializer.ReadObject(storageFileStream) as T;
                }
                if (loadedObject == null)
                {
                    loadedObject = new T();
                }
            }

            return loadedObject;
        }

        public static void Save(string name, T objectToSave)
        {
            using (IsolatedStorageFile storageFile = IsolatedStorageFile.GetUserStoreForApplication())
            using (IsolatedStorageFileStream storageFileStream = new IsolatedStorageFileStream(name, System.IO.FileMode.Create, storageFile))
            {
                DataContractSerializer serializer = new DataContractSerializer(typeof(T));
                serializer.WriteObject(storageFileStream, objectToSave);
            }
        }

        public static void Delete(string name)
        {
            using (IsolatedStorageFile storageFile = IsolatedStorageFile.GetUserStoreForApplication())
            {
                storageFile.Remove();
            }
        }
    }
}

Instead of using the ItemViewModel class, we’re going to add our own Model, Note. This requires us to make changes in MainPage.xaml, MainViewModel.cs, DetailsPage.xaml and MainViewModelSampleData.xaml as well, to reflect the new properties. So, create a new folder title Models, and add the Note class below, to it. Also, change all references from ItemViewModel to Note, as this will be the Model we’ll be using going forward (I just did a find and replace on the entire project).

using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.Serialization;

namespace MyNotes
{
    [DataContract]
    public class Note : INotifyPropertyChanged
    {
        private string title;
        [DataMember]
        public string Title
        {
            get
            {
                return title;
            }
            set
            {
                if (value != title)
                {
                    title = value;
                    NotifyPropertyChanged("Title");
                }
            }
        }

        private string noteText;
        [DataMember]
        public string NoteText
        {
            get
            {
                return noteText;
            }
            set
            {
                if (value != noteText)
                {
                    noteText = value;
                    NotifyPropertyChanged("NoteText");
                }
            }
        }

        private DateTime createDate;
        [DataMember]
        public DateTime CreateDate
        {
            get
            {
                return createDate;
            }
            set
            {
                if (value != createDate)
                {
                    createDate = value;
                    NotifyPropertyChanged("CreateDate");
                }
            }
        }

        public void Save()
        {
            ObservableCollection currentNotes = StorageHelper.Load>(App.NotesFileName);
            currentNotes.Add(this);
            StorageHelper.Save>(App.NotesFileName, currentNotes);
        }

        public event PropertyChangedEventHandler PropertyChanged;
        private void NotifyPropertyChanged(String propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (null != handler)
            {
                handler(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }
}

For xaml files, such as MainViewModelSampleData.xaml you’ll need to change the properties that are bound, for example

Modify your App.xaml.cs file to add the following property. This is just the name of the notes file that will be stored in isolated storage.
```
	public static string NotesFileName
	{
		get { return "notes.dat"; }
	}
```

So now we have a fairly simple starting point. We have a main page, a details page, a class to help us manage isolated storage, and our base model class, Note. Next up, adding a note…

Part 2 is now up and can be read here
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 2

Windows Phone 7 – List of Tutorials and Resources

onishimura — Thu, 22 Jul 2010 08:11:41 +0000

Following up on yesterday’s post on Windows Phone 7 development, here’s a few of the tutorials and guides I’ve been looking at the past few days. There’s a lot of info to digest so I’ll be adding to this post as I come across more resoucres.

Tutorials and Samples

Scott Guthrie’s Tutorial
http://weblogs.asp.net/scottgu/archive/2010/03/18/building-a-windows-phone-7-twitter-application-using-silverlight.aspx
Introduction to Silverlight on Windows Phone 7 – Creating a list application
http://10rem.net/blog/2010/03/15/building-your-first-silverlight-for-windows-phone-application
Introduction to XNA
http://mobile.tutsplus.com/tutorials/windows/introduction-to-xna-on-windows-phone-7/
Channel 9 Developer Training Kit
http://channel9.msdn.com/learn/courses/WP7TrainingKit/
Code Samples for Windows Phone
http://msdn.microsoft.com/en-us/library/ff431744(VS.92).aspx
Charles Petzold’s Free ebook
http://blogs.msdn.com/b/microsoft_press/archive/2010/03/15/free-ebook-programming-windows-phone-7-series-draft-preview.aspx

Blogs/Community

Windows Phone Developer Blog
http://windowsteamblog.com/Windows_Phone/b/wpdev/
Smarty Pants Coding
http://www.smartypantscoding.com/
Nick Gravelyn’s Blog – Focused on the XNA Framework and game development
http://blogs.msdn.com/b/nicgrave/
Jesse Liberty – Check out the mini-tutorials
http://jesseliberty.com/Tags/phone/
Paul Thurrott
http://windowsphonesecrets.com/
Windows Phone 7 Forums
http://social.msdn.microsoft.com/Forums/en-US/windowsphone7series/threads

Documentation and Resources

Official Developer Portal
http://developer.windowsphone.com/
Class Library Reference
http://msdn.microsoft.com/en-us/library/ff626516(v=VS.92).aspx
Programming Guide for Windows Phone
http://msdn.microsoft.com/en-us/library/ff402551(v=VS.92).aspx
Developer Tools Resouces – Getting started and Developer Fundamentals
http://msdn.microsoft.com/en-us/library/ff402523(v=VS.92).aspx
Design Resources
http://msdn.microsoft.com/en-us/library/ff637515(VS.92).aspx
Windows Phone 7 Jump Start Training Resources
http://borntolearn.mslearn.net/wp7/m/classresources/default.aspx

Windows Phone 7 and Silverlight – Getting started with a Bouncing Ball

onishimura — Tue, 20 Jul 2010 23:55:36 +0000

The beta of the developer tools for Windows Phone 7 was released last week. I was curious to see how different/easy it was to develop for this platform so I decided to convert my old SL 3 bouncing ball app, done AGES ago, to Silverlight 4 and Windows Phone 7. The process was pretty painless and even allowed me to add a few features:

1. Install the tools from http://www.microsoft.com/downloads/details.aspx?FamilyID=c8496c2a-54d9-4b11-9491-a1bfaf32f2e3&displaylang=en if you haven’t already

2. Create a new Windows Phone Application (from templaes: Visual C# – Silverlight for Windows Phone – Windows Phone Application)

3. Modify the ContentGrid, change it to a canvas and add an ellipse:

4. Uncomment the sample app bar code and change it to the following, to add a click event and some descriptive text:

5. In the code behind add the following private instance variables, which are used to determine the initial speed of the ball and the current state of the ball:

private int xVelocity = 5;
private int yVelocity = 5;
private bool isBouncing = false;

6. Add a helper method to start a new bounce, randoming the directions and speed:

private void startNewBounce()
{
	//Make speed, direction random
	Random r = new Random();
	xVelocity = r.Next(3, 10);
	yVelocity = r.Next(3, 10);
	int coin = r.Next(100);
	if (coin > 50)
	{
		xVelocity *= -1;
	}
	coin = r.Next(100);
	if (coin > 50)
	{
		yVelocity *= -1;
	}

	ellipseStoryboard.Begin();
	isBouncing = true;
}

7. Add the storyboard_Completed event. This will move the ellipse and also check for collisions against the layoutroots dimensions. If a collision is found it will reverse the direction. Note that the Y axis is a little funnky here, I had to tweak the upper and lower bounds a bit, partially because of the space the title grid takes up.

protected void ellipseStoryboard_Completed(object sender, EventArgs e)
{
	double ellipseX = (double)ellipseObject.GetValue(Canvas.LeftProperty);
	double ellipseY = (double)ellipseObject.GetValue(Canvas.TopProperty);

	//NOTE: canvas.width - ellipse.width for max, since the left and top properties
	//are based on upper left corner of the object
	//+/- 250 if title is present
	if (ellipseX >= (LayoutRoot.ActualWidth - ellipseObject.ActualWidth) || ellipseX <= 0)
	{
		xVelocity *= -1;
	}
	if (ellipseY >= ((LayoutRoot.ActualHeight - 300) + ellipseObject.ActualHeight) || ellipseY <= -150)
	{
		yVelocity *= -1;
	}

	ellipseX += xVelocity;
	ellipseY += yVelocity;

	ellipseObject.SetValue(Canvas.LeftProperty, ellipseX);
	ellipseObject.SetValue(Canvas.TopProperty, ellipseY);

	ellipseStoryboard.Begin();
}

8. Add an event handler for the app bar button click. All we need to do is start a new bounce (if the ball is already moving this will change the speed/direction of the ball too):

private void appbar_button1_Click(object sender, EventArgs e)
{
	startNewBounce();
}

9. One last piece of functionality, add a start/stop toggle if the user touches the screen. On the emulator this boils down to basically clicking the mouse on the screen. The events used to detect touch inputs are OnManipulationStarted, OnManipulationDelta and OnManipulationComepleted.

protected override void OnManipulationStarted(ManipulationStartedEventArgs e)
{
	base.OnManipulationStarted(e);
	if (isBouncing)
	{
		ellipseStoryboard.Stop();
		isBouncing = false;
	}
	else
	{
		ellipseStoryboard.Begin();
		isBouncing = true;
	}

}

10. Hit f5 and let the emulator load up, it could take a bit but even on my old machine it wasn't too bad. A lot faster than the Android emulator in Eclipse was at least.

The fact that the development language and environment is pretty much the same is compelling. There are some differences though. Debugging in the emulator worked failry well too, clicking on the home button would stop the debugging process but leave the emulator running. Performance on the emulator wasn't fantastic but I guess that's to be expected. Just means I need to get a new computer. As I mentioned I did have to make some adjustments in the collision detection code to account for the title, but there's still a small bar at the top of the emulator that makes it look like the ball isn't hitting the exact top. It might look better on an actual device though, tough to say without having a device to test on.

Download the code here