1. Get the Bing Maps WPF control.
2. Get a Bing Maps API key.

You MUST have a Bing Maps API key in order to use any of the SOAP services.

For this application we will be using the Geocode Service and the Route Service.  The Geocode service is used to match addresses, places, and geographic entities to latitude and longitude coordinates on the map, as well as return location information for a specified latitude and longitude coordinate.  The Route service is used to generate routes and driving directions based on locations or waypoints.

Now that you have that out of the way let’s write an application. Create a new WPF application targeting the .NET 4.0 framework. Add a reference to the Microsoft.Maps.MapControl.WPF.dll. This will most likely be located in Program Files or Program Files (x86) –> Bing Maps WPF Control –> Beta –> Libraries.

Open up your App.xaml. You need to add an ApplicationIdCredentialsProvider as a resource and enter your ApplicationId:

We need to add the Geocode and Route service to our application.  First, let’s start by adding the Geocode service.  Right click the project and select “Add Service Reference”.  Use the following address:

http://dev.virtualearth.net/webservices/v1/geocodeservice/geocodeservice.svc

Give your service a name. I called mine BingServices.  Now we need to add the Route service, but we don’t want to add a separate service reference.  Ideally we would have a single service that contained both the Geocode and Route services.  Luckily there is a trick we can use to do just that.  Select the Project and click the “Show All Files” button at the top of the Solution Explorer.  Expand the Service Reference folder and then expand the BingServices service.  Look for a file called Reference.svcmap. Open the References.svcmap and locate the MetadataSource node.  It will loko something like this:

Simply add a new MetatdataSource as follows:

As you can see we added a new MetadataSource that points to the Route service and we gave it a SourceId of 2.  Now right click the service and select “Update Service Reference”.  This will generate a single service proxy for both the Geocode and Route services.  Pretty slick huh?

The next step will be to create a ViewModel that will contain an ICommand that will execute the route calculation, properties that will represent a “To” address and a “From” address.  We will also need a property for the RouteResult and for the directions we generate.  Lets first create our Direction object:

Now we will need a make-shift delegate command (do not use in production code):

Now on to the ViewModel itself:

Let’s walk though the CalculateRoute Method.  First we geocode the “From” and “To” properties the same way we did in the geocoding post.  Once we have our From and To locations we use those results to generate a RouteRequest and send that request to the Route service.  The service will generate a result and we set our RouteResult property accordingly.  This property will be used in data binding shortly.  Next we generate an ObservableCollection<Direction> by looping through all the ItineraryItems in the result. 

Now that we have generate all of our data, we need to create a View that supports and displays this data, but before we do that we need to create some attached properties.  Why do you ask?  Well because as it stands, the Bing Maps WPF control is not data binding friendly.  So we need to enable data binding with the use of attached properties.  We will need an attached property for the Route result which will be responsible for drawing the route line on the map.  We will also need one for the MapLayer that will be used to contain the route line.  Here is the code:

The RouteResult property simply creates a MapPolyline, loops through all the points in the result and adds the locations to the route line.  It then gets the RouteLineLayer and adds it to the map.  Lastly, it sets the map’s view to best fit the route line.

Now we are ready for the View:

Oh and don’t forget the code behind:

Now let’s view the fruits of our labor at runtime.

As you can see, given a “From” and “To” address, we can draw a route line and provide turn-by-turn directions as the user hovers over the direction pins.  Pretty neat huh?  And it wasn’t too difficult to pull off.  As always you can Download the Source and start playing.

The concept is simple.  We want a Bing Maps application that can be extended at runtime.  By extended, I mean that I want the ability to add new elements/modules to the Map at runtime.  The important thing about these elements/modules is that they can come from anywhere and they should be loosely coupled from the Map as well as other elements/modules that may exist on the Map.

Luckily for us this is extremely simple to accomplish.  All we have to do is create a custom RegionAdapter, register it with our Prism application, and then apply it to our Bing Map control.  So let’s start with the RegionAdapter.

Now in the Bootstrapper we need to register our mapping.

Now we simply give the Map a region name. (this is actually all the shell has in it)

That is all there is to it.  You can now start injecting modules onto the Map at runtime.  Lets look at my two modules I am using as an example.  Here is the structure of my application:

• ModuleA will inject a MapPolygon in the Shape of Texas.
• ModuleB is the Earthquake application we built in an earlier post.
• Infrastructure is the project where shared code goes, in this case our MapRegionAdapter
• BingMapsPrismfiedDemo is of course our shell project.

This is what the application looks like at runtime when both modules have been injected into it.

Now I can easily add more layers to this map as I see fit.  As always, Download the Source and start playing.  You may want to add MEF support as well.

Let’s start with the Geocode Service which is used to match addresses, places, and geographic entities to latitude and longitude coordinates on the map, as well as return location information for a specified latitude and longitude coordinate.  We will create a simple application that allows you to enter an address and place a pushpin at that location.  First thing is first:

1. Get the Bing Maps WPF control.
2. Get a Bing Maps API key.

You MUST have a Bing Maps API key in order to use any of the SOAP services.  Now that you have that out of the way let’s write an application. Create a new WPF application targeting the .NET 4.0 framework. Add a reference to the Microsoft.Maps.MapControl.WPF.dll. This will most likely be located in Program Files or Program Files (x86) –> Bing Maps WPF Control –> Beta –> Libraries. 

Open up your App.xaml.  You need to add an ApplicationIdCredentialsProvider as a resource and enter your ApplicationId:

Now create a very simple UI that will accept an address and a button to perform the geocoding:

The next thing we need to do is add a new Service Reference to the project and point to the following service:

http://dev.virtualearth.net/webservices/v1/geocodeservice/geocodeservice.svc

Give your service a name (I called mine BingMapsService) and just for fun, in the “Add Service Reference” dialog, click the “Advanced” button and click “Generate asynchronous operations”.

Next we need to create a ViewModel to support our View.  This is a WPF application after all.  This ViewModel will need a command for the button that will perform the geocoding, and a property that will represent the result of the service that the UI will use to map the address.  It should resemble something like this:

I want to point out that the DelegateCommand<T> is a very simple ICommand implementation and should not be used in production applications.  Here is the code:

Let’s hook our UI up to our command.  it should look something like this:

Notice that we are using the text of the TextBox as the CommandParameter.  Next, we need to implement the command:

In this command we are simply creating an instance of the service client, creating a GeocodeRequest, setting the credentials using the ApplicationId we have stored in the App.xaml, and then using the address as the Query for the request.  When the call to the service is completed we are setting the GeocodeResult property to the first element in the results.

Now the tricky part.  We want to place a Pushpin on the address that was entered and then move the map to that location.  We also need to make sure that when another address is entered, we clear any previous Pushpins that may exist on the map.  We also have to be aware that other elements my be on the map and we don’t want to accidentally alter those elements.  Oh and did I mention this was an MVVM application and this has to be done with just data binding? 

The approach that I decided to go with is to use Attached Properties.  So I created two attached properties; one for the GeocodeResult and another for a MapLayer that will be dedicated to the GeocodeResult.  This will allow us to create a MapLayer that is specific to our GeocodeResut and not alter any other elements that may be on the map.  Let’s check out the code.

Notice that when the GeocodeResult changes we get the Location and create a pushpin for that location.  We also set the tooltip to the FormattedAddress of the GeocodeResult.  So when we hover over the pushpin we will see a nice little tooltip of the address.  Next we try to get the GeocodeResultLayer from the map, if it is null this means it doesn’t exist on the map yet so we create one and assign it accordingly.  We clear the layer child elemnts and then add out pushpin.  The last thing we do is call the SetView method of the Map control passing in the location and the current ZoomLevel.

The final step is to use our AttachedProperty on the map.  Be sure to create a namespace for the MapInteractivity class and define it as follows:

One last thing.  Be sure to remember to set your DataContext of your View to the ViewModel we have created:

That’s it.  You now have an application the can map (geocode) an address using the Bing Maps WPF Control and the Geocoding SOAP Service.  Oh and we are doing this all with MVVM and data binding which is my favorite part.  Be sure to Download the Source and start playing around.

1. Get the Bing Maps WPF control.
2. Get a Bing Maps API key. (not needed for development)

Now that you have that out of the way let’s write an application.  Create a new WPF application targeting the .NET 4.0 framework.  Add a reference to the Microsoft.Maps.MapControl.WPF.dll.  This will most likely be located in Program Files or Program Files (x86) –> Bing Maps WPF Control –> Beta –> Libraries.  Next you need to declare a namespace in XAML:

Not much to look at, but it’s definitely a map. Notice that because we are not using an API key we get a nice little message that tells us where to get one.  Well this is great and all, but we want to see earth quakes!  So let’s start doing the real coding now. We know we will need an object to hold information about the earthquakes.

That should take care of that.  Next we need data about earthquakes and their locations.  Luckily for us there is a free resource available to grab this information from USGS.  So let’s write a simple service to get this information:

The last thing we need is a ViewModel that will expose our earthquakes from consumption by our view:

Don’t forget to set the DataContext of the view to our ViewModel:

Here is what you will see when you run the application:

HEY! Where the hell are my earthquakes?  This thing sucks!  Piece of sh….. Oh wait, I need to tell the map how to render the earthquakes.  So we need to create a DataTemplate:

And don’t forget to specify the ItemTemplate:

Now let’s see what we get when we run the application:

Hey look! Earthquakes.  That is so cool. But wait, I want to see information about the earth quake.  Preferably in a popup when I hover over a Pushpin.  Well Lets wire that up real quick.  First we need to add a MapLayer to the map that will act as our popup:

Now we need to add some event handler to the ItemTemplate.

We have added two event handlers; one for when we mouse over and the other for when the mouse is no longer over the pushpin.  Notice that I am storing the bound item in the Tag of the Pushpin object.  We will need that to change the location of popup.

Now when we hover over the Pushpin we get some useful information about the earthquake:

That’s it for this application.  The Bing Maps WPF Control has been a long awaited control and I am glad it finally made it to WPF.  As you can see it is pretty easy to use as well.  Now you can Download the source and start playing.

Well, now that everyone has been given their respective credit, let’s continue.  I wanted to take my last post a little further.  In that post I simply created an event handler for a button click event using inline code in the x:Code directive.  If you started to play with the sample code, you might have thought to yourself, “I wonder if I can load this XAML, event handler and all, from a file or database and have it still work.”.  Well, if you tried it, you found the answer really quick.  No!  The reason is pretty simple; code must be compiled in order to execute.  Therefore any code inside loose XAML will fail.  Also, when using loose XAML, trying to hookup an event handler would crash your application because it is not allowed.

Oh, then it must not be possible? Wrong!  Well, then how do you do it if the code must be compiled?  Simple, we compile the code just before we run it.  Say what?  That’s right, let me introduce you to the CodeDom.  The CodeDom allows you to dynamically generate and compile code at runtime.  Let’s get to it.

We need to attach event handlers to elements in loose XAML, and have them execute C# code.  Each element has different events to handle, and each event will execute different code.  This tells me that we need an object that contains two properties, one to specify the RoutedEvent to handle, and another to specify the c# code to execute.  We also need a common event handler definition to execute whenever the RoutedEvent is invoked.

That was simple enough.  Now, in order to attach event handlers to elements in loose XAML, we need away to get around the “no event handlers allowed” limitation.  To do this we can use an attached property.

This attached property allows use to attach an instance of our DynamicEvent class to our element.  When the Handler attached property is set, we simple add our OnEventExecute event handler to the RoutedEvent specified in the RoutedEvent property.  Now we have the basic framework needed to attach and event handler to any event on any element in loose XAML.  Let’s see how to attach an event handler in XAML using this newly created DynamicEvent class.

As you can see I have added a handler for a Button’s Click event.  I also provided a Script to execute when the event is invoked.  Notice that we are preserving the whitespace in the script.  Of course nothing will happen just yet.  Now we need to take the script and compile it at run time.  This is where the CodeDom comes in.

The steps necessary to compile code at run time go a little something like this:

• Create a CodeCompileUnit
• Add our namespace and import statements
• create our dynamic class
• add a method that will execute the Script
• compile the code
• execute the code

All these steps must be performed when the ROutedEvent is invoked, which means the code must be compiled inside the OnEventExecuted event handler.

The first step is really easy.  We simply need to create an instance of the CodeCompileUnit class.  The CodeCompileUnit references the CodeDom object graph and has properties for storing attributes, namespaces, and assemblies.  Next we need to create our namespace and import statements.

Once the namespace and import statement are created we need to add them to out CodeCompileUnit instance.  Then we need to create our dynamic class.  We need to make sure it is a public class:

When the dynamic class is created we add it to our namespace.  Now we create a method. We give it a name of ExecuteScript and set its access modifier to public.  We specify that it accepts two parameters.  One being the sender which is of type object, and one that is the event args that is of type RoutedEventArgs.  Lastly, we set the body of the method to the Script property.

Now we have to create our compiler parameters.  These include adding referencing to the necessary Dlls required to run your code.  We also want to specify that we want to generate the code in memory.  If you wanted to you could save the assembly to a file.

Now we compile the code into an assembly.

The last thing we need to do is run the code that was just compiled.  We will need the help of reflection to accomplish this.

That is it.  Now to test this out lets create a .txt file that contains our XAML that we define above and save it CodeSnippet.txt.  In our MainWindow.xaml.cs, lets handle the Loaded event and load our CodeSnippet.txt using the XamlReader.Load method.

Run the application is this is what it should look like.

Now click the button and our C# code defined within the Script property will be dynamically compiled and executed changed the text of the button to this:

This is a very simple example and is not intended to be a complete solution, but it does show some of the powerful capabilities you have using WPF, XAML, and the CodeDom.  Like always download the source and start playing around.  See what kind of cool stuff you can do with it.

I thought creating a custom pre-loader was common knowledge, but I guess I was wrong. So, what is a custom pre-loader really? Well, it is a small and lightweight Silverlight application that runs while your main Silverlight application is being downloaded to the client. Creating your own is really easy and only involves a few basic steps.

The first thing we need to do is add a Silverlight JavaScript  page to the Web project of your Silverlight application. So just right click your Web project and click add new item, then select Silverlight JScript Page.

You can name it whatever you want. I named my SplashScreen.xaml. When you click “Add” you will notice two files were created for you; a XAML file and a JavaScript file.

The XAML file is where you will create your pre-loader UI. So lets create a simple UI.

<Canvas        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"        x:Name="parentCanvas"        Width="850"        Height="600"        Background="OldLace"        >  <Canvas Canvas.Top="228.834" Canvas.Left="246.329" Width="357" Height="31.379">    <Rectangle Width="27.545" Height="1" x:Name="uxProgress" Canvas.Top="29.545" Canvas.Left="1.4">      <Rectangle.RenderTransform>        <TransformGroup>          <ScaleTransform x:Name="uxProgressBar" ScaleX="1" ScaleY="0"/>          <SkewTransform AngleX="0" AngleY="0"/>          <RotateTransform Angle="270"/>          <TranslateTransform X="0" Y="0"/>        </TransformGroup>      </Rectangle.RenderTransform>      <Rectangle.Fill>        <LinearGradientBrush EndPoint="1,0.5" StartPoint="0,0.5">          <GradientStop Color="#FFFFFFFF" Offset="1"/>          <GradientStop Color="#FFFFFFFF" Offset="0"/>          <GradientStop Color="#FF2975D0" Offset="0.28"/>          <GradientStop Color="#FF2975D0" Offset="0.72"/>        </LinearGradientBrush>      </Rectangle.Fill>    </Rectangle>

    <TextBlock x:Name="uxStatus" Height="25" Canvas.Left="125" Text="Loading..." TextWrapping="Wrap" Canvas.Top="4.16"/>

    <Path Width="356.85" Height="1" Fill="#FF3A3A3A" Stretch="Fill" Stroke="#FF000000" Canvas.Top="0" Data="M0,170.5 L356.84209,170.5" Opacity="0.35"/>    <Path Width="1.662" Height="29.03" Fill="#FF3A3A3A" Stretch="Fill" Stroke="#FF000000" Canvas.Top="0.48" Canvas.Left="0.2" Data="M360,168 L360,0" Opacity="0.35" />

    <Path Width="357.84" Height="1" Fill="#FF3A3A3A" Stretch="Fill" Stroke="#FF000000" Canvas.Top="29" Data="M0,170.5 L356.84209,170.5" Opacity="0.35"/>    <Path Width="358.85" Height="1" Fill="#FFA2A2A2" Stretch="Fill" Stroke="#FF000000" Canvas.Top="30" Data="M0,170.5 L356.84209,170.5" Opacity="0.25"/>    <Path Width="1.662" Height="30" Fill="#FF3A3A3A" Stretch="Fill" Stroke="#FF000000" Canvas.Left="356.01" Data="M360,168 L360,0" Opacity="0.35" Canvas.Top="-0.498"/>    <Path Width="1" Height="31" Fill="#FFA2A2A2" Stretch="Fill" Stroke="#FF000000" Canvas.Left="357.333" Data="M360,168 L360,0" Opacity="0.245" Canvas.Top="-0.498" />  </Canvas></Canvas>

I actually copied this XAML from MSDN because I was to lazy to write my own.

The JavaScript file is where you will interact with you pre-loader.  To do this there are three properties that are exposed by the Silverlight plug-in:

1. splashscreensource: The URI of a XAML page that displays while the primary package (source) is being downloaded.
2. onsourcedownloadprogresschanged: References a JavaScript event handler that will be invoked continuously while the source is being downloaded.
3. onsourcedownloadcomplete: References a JavaScript event handler that will be invoked once, when the source download is complete.

Enter Params:

You will need to add two Object Params to your page hosting the Silverlight application.

<param name="splashscreensource" value="SplashScreen.xaml"/><param name="onSourceDownloadProgressChanged" value="onSourceDownloadProgressChanged" />

The first one tells the host where to find the custom XAML file you created. The second one tells it which JavaScript function to execute when the sourceDownloadProgressChanged event fires.

So go ahead and open up your JavaScript file and delete all the code that is in there and replace it with this:

function onSourceDownloadProgressChanged(sender, eventArgs) {    sender.findName("uxStatus").Text = "Loading: " + Math.round((eventArgs.progress * 1000)) / 10 + "%";    sender.findName("uxProgressBar").ScaleY = eventArgs.progress * 356;}

The next step is very important. Make sure you add your JavaScript file into the head tag of your hosting page.

<script type="text/javascript" src="splashscreen.js"></script>

Now in order to test this thing, you need to add something very big to your main Silverlight application, set its Build Action to Content, and set Copy to Output Directory to Copy if newer.  I added a video file that was about 100MB in size. Now run your application.

And there is our custom pre-loader.

For more information on creating custom pre-loaders visit http://msdn.microsoft.com/en-us/library/cc838130(VS.95).aspx

Download the Source

A couple of things to note; this feature requires your application to run as an Out Of Browser (OOB) with elevated permissions. Also, there is no IntelliSense for your COM objects. So make sure you have the documentation to the API you are trying to use. So lets get started.

Creating an OOB Application

First thing you need to do is crack open VS 2010 Beta 2 and create a new Silverlight project. Make sure you are targeting the .NET Framework 4 it is a Silverlight 4 application.

For this test project we don’t need to host this in a website.

The next thing you need to do is right-click on the project and choose “Properties”.  Check the “Enable Running Application out of browser”

Now click the Out of Browser Settings button and set “Require Elevated Trust when running outside the browser.”

Next add a button to the application to install our OOB application.

<Button x:Name="btnInstall" Content="Install Me" Click="btnInstall_Click" />

if (Application.Current.InstallState == InstallState.NotInstalled)

               Application.Current.Install();

Now run the application and install it by clicking the install button you just created.  When you start the installation, you will be prompted to install the app, and whether or not you want to create some shortcuts. Just say yes, we trust ourselves, sort of.

The next thing we want to do is enable debugging our OOB application.  So right click your project and chose properties –> Debug –> Installed out of browser application –> YourApplication

The final step is to add a reference to Microsoft.CSharp.dll so we can use the dynamic keyword.  Look for it in C:\Program Files\Microsoft SDKs\Silverlight\v4.0\Libraries\Client\.  Now on to fun stuff.

Send an Email with Outlook

First create a form that will take your user input for the “To” and “Message” data, and a button to send the message.

<StackPanel>

    <StackPanel Margin="5">

        <TextBlock Text="To:" />

        <TextBox x:Name="txtTo" />

    </StackPanel>

    <StackPanel Margin="5">

        <TextBlock Text="Message" />

        <TextBox x:Name="txtMessage" Height="200" />

    </StackPanel>

    <Button x:Name="btnSend" Content="Send Message" Click="btnSend_Click" />

</StackPanel>

Then handle the button click event as follows.

private void btnSend_Click(object sender, RoutedEventArgs e)

{

    using (dynamic outlook = ComAutomationFactory.CreateObject("Outlook.Application"))

    {

        dynamic mail = outlook.CreateItem(0);

        mail.To = txtTo.Text;

        mail.Subject = "Hello, from Silverlight";

        mail.HTMLBody = txtMessage.Text;

        mail.Display();

    }

}

And you done.  Of course this will only display the message, but just call mail.Send() to actually send it; one thing to mention is to make sure you have Outlook open when you hit send or bad things will happen.

Send Data to Excel, edit it, and update Silverlight

Now this little trick is cool. We will have a data source, send it to excel for display and editing, then send the updated data back to our Silverlight application and update the UI.  Now this is a poor mans implementation for demo reasons.

First lets create our UI and populate it with data.  This is what mine looks like.

Lets code up the Launch Excel button.

bool firstTime = true;

private void LaunchExcel(object sender, RoutedEventArgs e)

{

   // create an instance of excel

   dynamic excel = ComAutomationFactory.CreateObject("Excel.Application");

   excel.Visible = true;  // make it visible to the user.

   // add a workbook to the instance 

   dynamic workbook = excel.workbooks;

   workbook.Add();

   dynamic sheet = excel.ActiveSheet; // get the active sheet

   dynamic cell = null;

   int i = 1;

   // iterate through our data source and populate the excel spreadsheet

   foreach (Entity item in CustomerList.ItemsSource)

   {

       cell = sheet.Cells[i, 1]; // row, column

       cell.Value = item.CustomerName;

       cell.ColumnWidth = 25;

       cell = sheet.Cells[i, 2];

       cell.Value = item.UnitSales;

       i++;

   }

   // add a chart

   dynamic sheetShapes = sheet.Shapes;

   sheetShapes.AddChart(-4100, 200, 2, 400, 300);

   // wire up an event handler to the Excel SheetChanged event

   if (firstTime)

   {

       excel.SheetChange += new SheetChangedDelegate(SheetChangedEventHandler);

       string sheetName = sheet.Name;

       firstTime = false;

   }

   ExcelButton.IsEnabled = true;

}

As you can see we are hooking into the Sheet changed event so we can respond to when the data is update in excel. So here is the code for that.

delegate void SheetChangedDelegate(dynamic excelSheet, dynamic rangeArgs);

// event handler for the sheet changed event

// looks at the data and creates a new items source to rebind to the datagrid

private void SheetChangedEventHandler(dynamic excelSheet, dynamic rangeArgs)

{

    dynamic sheet = excelSheet;

    string sheetName = sheet.Name;

    dynamic range = rangeArgs;

    dynamic rowValue = range.Row;

    Entity[] entities = CustomerList.ItemsSource as Entity[];

    Entity[] newEntities = new Entity[10];

    dynamic col2range = sheet.Range("B1:B10");

    for (int i = 0; i < 10; i++)

    {

        Entity newEntity = new Entity();

        newEntity.CustomerName = entities[i].CustomerName;

        newEntity.PhoneNumber = entities[i].PhoneNumber;

        dynamic item = col2range.Item(i + 1);

        newEntity.UnitSales = Convert.ToInt32(item.Value);

        newEntities[i] = newEntity;

    }

    CustomerList.ItemsSource = newEntities;

    CustomerList.SelectedIndex = Convert.ToInt32(rowValue) - 1;

    UpdateNotification.Text = "Data updated from Excel spreadsheet";

}

Now, I will click the Launch Excel button, and edit my data.

Now if I look back in my Silverlight application, I will now see that all of my data in the grid has been updated.

Lets Open a Program

Using the WScript.Shell API we can execute any command and open any program.  In this example lets open Notepad and write some text to it.  So first I am going to create a simple UI to allow a user to enter some text, then click a button to send it to Notepad.

<StackPanel>

   <TextBlock Text="Enter text to send to NotePad." />

   <TextBox x:Name="txtTextToSend" />

   <Button x:Name="txtOpenProgram" Content="Open NotePad" Click="txtOpenProgram_Click"  />

</StackPanel>

private void txtOpenProgram_Click(object sender, RoutedEventArgs e)

{

    using (dynamic shell = ComAutomationFactory.CreateObject("WScript.Shell"))

    {

        shell.Run(@"C:\windows\notepad.exe"); //you can open anything

        shell.SendKeys(txtTextToSend.Text);

    }

}

Now lets enter some text and click that button.

Now that's pretty cool. I am sure your mind is thinking of all the cool stuff you can do with this.

Well, this stuff is cool and all, but where is the really cool stuff? Wait no more!

Text to Speech

That’s right, I said it.  I am going to use the SAPI.SpVoice API to tap into the power of text to speech. So lets build a UI that will allow a user to enter some text. Heck lets let them control the rate and pitch of the speech.

<StackPanel>

    <TextBlock Text="Enter text to say: " />

    <TextBox x:Name="txtTextToSay" Margin="0,0,0,20" />

    <TextBlock Text="Pitch" />

    <Slider x:Name="sldrPitch" Minimum="-10" Maximum="10" Value="0" />

    <TextBlock Text="Rate" />

    <Slider x:Name="sldrRate" Minimum="-10" Maximum="10" Value="0" />

    <Button x:Name="btnSpeak" Content="Speak" Click="btnSpeak_Click" Margin="20" />

</StackPanel>

This should look something like this.

Lets hook up our button’s click event and make some noise.

private void btnSpeak_Click(object sender, RoutedEventArgs e)

{

   using (dynamic ISpeechVoice = ComAutomationFactory.CreateObject("SAPI.SpVoice"))

   {

       ISpeechVoice.Volume = 100;

       ISpeechVoice.Speak(string.Format("<rate speed=\"{0}\"><pitch middle=\"{1}\">{2}", Math.Round(sldrRate.Value), Math.Round(sldrPitch.Value), txtTextToSay.Text));

   }

}

If you wanted to you could create a volume control for it as well.

What? This still isn’t cool enough for you? Well I think I can satisfy your need for coolness. Enter:

Acquire an Image from your Scanner/Camera

That’s right I said it.  You can access your scanner, scan an image, and then save it to your hard drive.  Here we are using the WIA (Windows Image Acquisition). “WIA is a full-featured image manipulation component that provides end-to-end image processing capabilities.  The WIA Automation Layer makes it easy to acquire images on digital cameras, scanners, or Web cameras, and to rotate, scale, and annotate your image files.” So, enough with the talking, lets get coding.

First all I need to do it create a button that will initiate the process.

<Button x:Name="btnAquireImage" Content="Aquire Image from Scanner/Camera" Click="btnAquireImage_Click" />

Now we need to handle the button’s click event and do all the complicated code.

private void btnAquireImage_Click(object sender, RoutedEventArgs e)

{

   using (dynamic CommonDialog = ComAutomationFactory.CreateObject("WIA.CommonDialog"))

   {

       dynamic imageFile = CommonDialog.ShowAcquireImage();

       if (imageFile != null)

       {

           string filePath = string.Format("D:\\{0}.jpg", Guid.NewGuid());

           imageFile.SaveFile(filePath);

           MessageBox.Show(string.Format("Saved {0}", filePath));

       }

   }

}

So what does this actually do?  Well lets push the button and find out:

Well the first thing it does is asks me which device I want to get my images from.  Lets pick my scanner.

Well, holly crap, that’s my scanner. And I can preview and crop my image before I even get the image. Yes, that is my baby picture, it was the only thing I could find OKAY!  All my current pictures are digital.  Anyways, so once I like my settings I click scan, the scanner will do its thing and my image will be saved.

And there it is right where I told it to save.  How fun is that? I did you a favor and already coded all this up and packed it up in a nice little zip file.  So download the code, play with it, and write some kick ass applications!

I almost forgot to mention, when you open the source code, go into Properties –> Debug –> and select “Dynamically create the page”, then run the application, install it, and go back and change the option back to “Installed out of browser application ”.

Recap:

The Silverlight and WPF platforms are very similar, but they do not have binary compatibility; this means that an assembly compiled for one platform cannot execute on the other platform (Although, the story is a little different in Silverlight 4). You may want to target some or all of your application on WPF and Silverlight for a number of reasons.

Due to the fact that Silverlight and WPF are so closely related, the bulk of your application code can be shared between the two platforms. This encourages heavy use of pattern based development to isolate the logic from the presentation and maximize the separation between UI code and non-UI code.

Elements you can share:

• Presenters
• Controllers
• Models
• Services
• Unit tests
• Simple views, if the XAML used is supported by both Silverlight and WPF.

Elements that are harder to share:

• Complex views (XAML)
• Controls
• Styling
• Animation

Like always, if anyone has any questions feel free ask.

Recap:

The Silverlight and WPF platforms are very similar, but they do not have binary compatibility; this means that an assembly compiled for one platform cannot execute on the other platform (Although, the story is a little different in Silverlight 4). You may want to target some or all of your application on WPF and Silverlight for a number of reasons.

Due to the fact that Silverlight and WPF are so closely related, the bulk of your application code can be shared between the two platforms. This encourages heavy use of pattern based development to isolate the logic from the presentation and maximize the separation between UI code and non-UI code.

Elements you can share:

• Presenters
• Controllers
• Models
• Services
• Unit tests
• Simple views, if the XAML used is supported by both Silverlight and WPF.

Elements that are harder to share:

• Complex views (XAML)
• Controls
• Styling
• Animation

Like always, if anyone has any questions feel free ask.

Here is what it looks like.

Here is the source: Download the Loading Animation Source

I hope it is useful to someone besides me.