Chris Pietschmann

Managed JScript on the DLR from Microsoft is DEAD!! WHY?!??

crpietschmann — Fri, 12 Jun 2009 15:03:28 -0500

I’ve been questioning here and there as to what happened to Managed JScript on the Dynamic Language Runtime. The most recent preview release is really old, and it has since been taken out of any further preview releases of the DLR, where as IronRuby and IronPython continue on.

No More Managed JScript on the DLR?

For some time I never really got any good answers. Well, it’s really sad to hear that apparently Microsoft decided to drop it completely.

According the this link, a member on the DLR team has this to say:

“The DLR JScript was experimental for informing the design of the DLR (expression trees, interop, callsites, hosting, etc.). The JS we released with asp futures and the Silverlight dynamic sdk became very old and unserviceable as the DLR continued evolving for release in CLR 4.0. unfortunately, there are no plans at this time to develop and release a DLR hostable JScript.”

“Experimental for informing the design”??

I understand what this means, but since Managed JScript was used to help build the DLR from the beginning then “Why didn’t they keep it up to date?”

Plus if you go read the Initial Announcement of Managed JScript over on the JScript Blog you will see the following statement:

“We are working to make sure that Managed JScript is a first class language on top of DLR.”

What part of that post and the above statement specify that it’s only “experimental” and not to actually ever get released?

I’m really curious to find out who actually made the decision to drop it, and what the real reason is. Was it you ScottGu?

Why not Open Source it?

Well, the next logical question to ask is “Why not release what was done for Managed JScript as Open Source under a Public License?” At least this way it would allow the community to take it and run with it.

Are there Alternative Implementations?

None that I could find for .NET and/or the DLR. If you know of any, please let me know!

I did however find the Rhino project from Mozilla, but it’s for Java. According to Mozilla, “Rhino is an open-source implementation of JavaScript written entirely in Java. It is typically embedded into Java applications to provide scripting to end users.” I guess this could be a start at building one for .NET/DLR, but…

Update: I did find the MyJScript project on CodePlex; it’s not a complete implemenation, but it does show the basics on how to create your own scripting language on the DLR. There is also an companion article to the MyJScript project: http://www.dotnetguru.org/us/dlrus/DLR2.htm

Further Info

Here’s a few links that have some small bits of info in addition to that linked above:

http://dlr.codeplex.com/Thread/View.aspx?ThreadId=58121

http://dlr.codeplex.com/Thread/View.aspx?ThreadId=41990

http://channel9.msdn.com/posts/Charles/Jimmy-Schementi-Inside-IronRuby/?CommentID=472955

http://channel9.msdn.com/shows/Going+Deep/John-Lam-and-Martin-Maly-Deep-DLR/?CommentID=472957

http://blogs.msdn.com/jscript/archive/2007/05/04/managed-jscript-announced.aspx

Conclusion

I’ve very disappointed to hear this sad news. However, I guess I could always work on building my own Managed JScript compiler/library for the DLR; if I could only find the time in between my other open source work and other paying gigs.

Until then, I guess I can only hope that Microsoft (or would it be ScottGu) decides to reconsider.

Building JavaScript / HTML based Applications using Adobe Air for FREE

crpietschmann — Wed, 10 Jun 2009 20:44:16 -0500

As a web developer I use JavaScript, HTML and CSS a lot. I do however build desktop applications too, but can’t use those same tools/languages to build them. So, for quite some time now I’ve wanted to be able to build Desktop Applications using the same JavaScript, HTML and CSS that I use to build Web Applications. Now with the help of Adobe AIR it can finally be done with ease, and even have multi-platform support.

In this post I’m going to discuss the basics of creating a JavaScript/HTML based Desktop Application using Adobe AIR, and point you to some of the online resources that have helped me to get started.

Also, just in case you didn’t know, you can create/build JavaScript / HTML based Adobe AIR applications for FREE. The runtime and sdk are both free.

Getting Started with Adobe AIR

First you’ll need to get the following two things installed:

Adobe AIR – http://get.adobe.com/air
Adobe AIR SDK – http://www.adobe.com/products/air/tools/sdk/

Here’s a couple excellent resources I found to getting started with Adobe AIR and JavaScript:

You can follow those two guides linked to above to get you started using Adobe AIR to build JavaScript / HTML based Desktop Applications.

Setting Up the Adobe AIR SDK on Windows

I had a couple small setup issues with getting the Adobe AIR SDK setup on my Windows development box.

The Adobe AIR SDK download is just a Zip Archive containing the files necessary for the SDK; it contains no setup EXE. To get it setup, you’ll need to follow the below steps:

Extract the SDK to some folder of your choosing. For Example: C:\AdobeAIRSDK
Add the “C:\AdobeAIRSDK\bin” folder to the System Path so you can execute it easily from within the Command Line.

Also, to use the Adobe Developer Tool (adt) you’ll need Java installed, and you’ll need to make sure that the path to where Java is installed is also included within the System Path as described above.

To edit the “System Path” in Windows just follow these steps:

Open the System Properties dialog box and click the Advanced tab. You can find this in the System settings within the Control Panel.
Click the Environment Variables button.
Select the PATH entry and then click the Edit button. Add the desired path to the end of the current variable value, separating it from previous values with a semicolon. For Example “;C:\AdobeAIRSDK\bin”
Click OK to Save.

Tips to Make Building and Testing Easier

Here are some simple tips to make building and testing your applications easier.

Create .BAT files to Build and Test

One thing that you'’ll want to do to make it a little easier to Build (using adt) and Test (using adl) your HTML-based Adobe AIR applications is create some simple “build.bat” and “test.bat” DOS Batch files so you don’t have to type in the command-line parameters every time you want to build or test your application.

build.bat example:

adt –package –storetype pkcs12 –keystore certificate MyApp.air application.xml .

test.bat example:

adl application.xml

This way you can just simply double-click on the specific .BAT file within Windows Explorer to either Build or Test your application.

Also, in the above build.bat example, my Certificate file is simply named “certificate”, and it’s a self-signed certificate.

Place Application Files within a Sub-Folder

If you rename your “.air” file that was built using the above mentioned .BAT file to be a “.ZIP” file and then open it, you’ll notice that the .BAT files and your Certificate were included within the Build. This is because the above mentioned call to “adt” tells it to include all files and folders within the build. To prevent the .BAT files and Certificate from being included, you’ll need to place them within a separate folder.

The easiest way to do this is to place all you Application files within a Sub-Folder within the main folder that your .BAT files and Certificate are located. For example you could name it “App_Files”. Then make the following changes to the .BAT files to point it to the new file/folder locations appropriately:

build.bat example:

cd App_Files
adt –package –storetype pkcs12 –keystore ../certificate ../MyApp.air application.xml .

test.bat example

cd App_Files
adl application.xml

Also, one thing to note about the above modified “build.bat” file is that it will place the Built “.air” file/application within the Main folder where the .BAT files and Certificate are located.

Creating a Self-Signed Certificate

One thing that you’ll notice above is that I’m using a Certificate file names “certificate”. This is a self-signed certificate that I generated using the “adt” tool. To generate a self-signed certificate, you can execute “adt” using the following command-line parameters:

adt –certificate –cn SelfSigned 1024-RSA certificate.pfx samplePassword

Conclusion

The above is pretty much the extent of my knowledge of building Adobe AIR applications using JavaScript / HTML at the time of this writing. I decided to take a few minutes to figure out the basics, so I thought I’d share some of the tidbits I found out.

Since, I’ve wanted to build desktop applications using JavaScript, HTML and CSS for some time now I find it relieving that it can be done with Adobe AIR and for Free.

Bing Maps for Enterprise (formerly Virtual Earth) Licensing FAQ

crpietschmann — Tue, 02 Jun 2009 18:52:00 -0500

I usually get at least 1 email a month asking me some form of the below questions about Virtual Earth / Bing Maps for Enterprise Licensing. So, I’ve decided to post some information on the topic.

I’m not a Bing Maps for Enterprise (formerly Virtual Earth) Reseller, nor do I work for Microsoft or represent Microsoft in any way; so the following tips/faq are my own opinion and do not represent Microsoft in any way. For official answers, please contact Microsoft directly and refer to the “Microsoft Virtual Earth Platform API Terms of Use.”

Email all licensing questions directly to Microsoft at maplic@microsoft.com

I encourage you to read through the official “Microsoft Virtual Eearth Platform API Terms of Use”. You can also find more information on the “Microsoft Bing Maps for Enterprise – Licensing And Pricing Options” page.

I am not responsible for any actions you take based on the tips/faq provided below. The below is provided for informational purposes only and is not provided as legal advise. It is always recommended you consult an attorney.

Now that I have the disclaimer out of the way…

Q: Do I need to Pay / License Bing Maps for Enterprise to use the JavaScript Map Control and/or Web Services within my Website / Application?

A: There are really two separate answers:

1) Non-Commercial Use: No, If you are developing or hosting an online application that uses the service to display results for Non-Commercial Use, you do not need to purchase a license agreement from Microsoft.

2) Commercial or Government Use: Yes, If you are developing or hosting an online application that uses the service to display results for Commercial or Government Use, then you are required to purchase a license agreement from Microsoft. However, you are allowed to use the service for a 90 day evaluation period before you are required to purchase a license agreement.

There are some additional restrictions for using the Service for Non-Commercial use and within the 90 day evaluation period; these restrictions are outlined within the official “Microsoft Virtual Earth Platform API Terms of Use.”

Q: Can I use the Silverlight Virtual Earth Control CTP within a Website / Application?

A: Officially, the answer is No. Since the current release of the Silverlight Virtual Earth Control is a Community Technology Preview (CTP) it is not licensed for use in any Production environments. Also, there is no support provided for any bugs that you may encounter while using it.

However, you can use the Silverlight Virtual Earth Control CTP for Development and Testing purposes.

Q: Can I use Bing Maps (Virtual Earth) within a Windows Forms or WPF Desktop Application?

A: As far as Licensing, you’ll need to contact Microsoft. The “Microsoft Virtual Earth Platform API Terms of Use” doesn’t really cover this specific usage scenario.

Microsoft doesn’t have a Window Forms or WPF control that you can just drag onto a Window, but you could access the Web Service from your application or display the JavaScript Map Control within an embedded WebBrowser control.

Q: Can I use the Virtual Earth Server Control that’s part of the Windows Live Tools CTP within a Website / Application?

A: No, Since the Windows Live Tools is a Community Technology Preview (CTP) it is not licensed for use in any Production environments, and thus all the controls within the Windows Live Tools CTP are licensed the same.

Also, the Virtual Earth Server Control within the latest release of the Windows Live Tools CTP is buggy and only partially implemented.

If you are looking for an ASP.NET AJAX Bing Maps (Virtual Earth) Server Control that you CAN use in Production and is Fully Supported, then I encourage you to check out the Web.Maps.VE product by Simplovation.

Virtual Earth Shapes (VEShape) to WKT (Well-Known-Text) and Back using JavaScript

crpietschmann — Sat, 04 Apr 2009 12:38:59 -0500

One of the standard methods of representing geometric shapes is by using the WKT (Well-Known-Text) standard. This is a human readable standard method of representing geometric shapes that can be used to easily pass spatial data between applications. I know GML or GeoRSS may be a little more applicable since they are based on XML, but WKT can work just fine in some cases.

If you don’t know what WKT is here are a couple links for reference:

http://geoapi.sourceforge.net/2.0/javadoc/org/opengis/referencing/doc-files/WKT.html

http://en.wikipedia.org/wiki/Well-known_text

This is also one of the things that Virtual Earth does NOT have support built in for. So I wrote a little code that simply converts VEShape objects to a WKT string representation.

The code below allows you to represent Pushpins, Polygons and Polylines as strings like the following:

POINT(-99.71000000000001 43.74999999999998)

POLYGON((-99.71000000000001 46.74999999999998,
 -96.71000000000001 46.74999999999998,
 -96.71000000000001 43.74999999999998,
 -99.71000000000001 46.74999999999998))

LINESTRING(-99.71000000000001 40.74999999999998,
 -102.71000000000001 40.74999999999998,
 -102.71000000000001 43.74999999999998)

Here are some examples of using the conversion methods:

// Get Map Center Point
 var centerPoint = map.GetCenter();

 // Create Pushpin VEShape and Get it's WKT representation
 var wktShape = VirtualEarthWKT.ShapeToWKT(new VEShape(VEShapeType.Pushpin, centerPoint));
 // Create a VEShape from the WKT representation
 var shape = VirtualEarthWKT.ShapeFromWKT(wktShape);
 // Add VEShape to Map
 map.AddShape(shape);


 // Create Polygons' Location Array
 var polygonLocations = [
    new VELatLong(centerPoint.Latitude + 3, centerPoint.Longitude),
    new VELatLong(centerPoint.Latitude + 3, centerPoint.Longitude + 3),
    new VELatLong(centerPoint.Latitude, centerPoint.Longitude + 3)
 ];

 // Create Polygon VEShape and Get it's WKT representation
 wktShape = VirtualEarthWKT.ShapeToWKT(new VEShape(VEShapeType.Polygon, polygonLocations));
 // Create a VEShape from the WKT representation
 shape = VirtualEarthWKT.ShapeFromWKT(wktShape);
 // Add VEShape to Map
 map.AddShape(shape);


 // Create Polylines' Location Array
 var polylineLocations = [
    new VELatLong(centerPoint.Latitude - 3, centerPoint.Longitude),
    new VELatLong(centerPoint.Latitude - 3, centerPoint.Longitude - 3),
    new VELatLong(centerPoint.Latitude, centerPoint.Longitude - 3)
 ];

 // Create Polyline VEShape and Get it's WKT representation
 wktShape = VirtualEarthWKT.ShapeToWKT(new VEShape(VEShapeType.Polyline, polylineLocations));
 // Create a VEShape from the WKT representation
 shape = VirtualEarthWKT.ShapeFromWKT(wktShape);
 // Add VEShape to Map
 map.AddShape(shape);

Here’s the full code to the VirtualEarthWKT object that contains the static methods:

// Create the singleton object that contains the WKT (Well-Known-Text) transformation methods.
var VirtualEarthWKT = new (function() {
    // Declare some "private" methods that will only be used internally
    var priv = {
        trimSpaces: function(str) {
            // Trim beginning spaces
            while (priv.startsWith(str, " ")) {
                str = str.substring(1);
            }
            // Trim ending spaces
            while (priv.endsWith(str, " ")) {
                str = str.substring(0, str.length - 1);
            }
            return str;
        },
        startsWith: function(str, startstr) {
            return str.substring(0, startstr.length) == startstr;
        },
        endsWith: function(str, endstr) {
            return str.substring(str.length - endstr.length) == endstr;
        }
    };
    // Declare the "public" methods that will be exposed
    var that = {
        ///<summary>Converts a VEShape object to WKT (Well-Known-Text) string representation.</summary>
        ShapeToWKT: function(shape) {
            if (shape == null) {
                throw "VirtualEarthWKT.ShapeToWKT: 'shape' parameter can not be null.";
            }
            var wktTemplate = "";
            var wktGeomPoints = "";

            // Figure out the WKT Geometry Type
            switch (shape.GetType()) {
                case VEShapeType.Pushpin:
                    wktTemplate = "POINT({points})";
                    break;
                case VEShapeType.Polygon:
                    wktTemplate = "POLYGON(({points}))";
                    break;
                case VEShapeType.Polyline:
                    wktTemplate = "LINESTRING({points})";
                    break;
                default:
                    throw "VirtualEarthWKT.ShapeToWKT: VEShapeType (" + shape.GetType() + ") not supported.";
                    break;
            }

            // Get the List of VELatLong objects represented as WKT compatible list of points
            var shapePoints = shape.GetPoints();
            for (var i = 0; i < shapePoints.length; i++) {
                if (wktGeomPoints.length > 0) {
                    wktGeomPoints += ", ";
                }
                wktGeomPoints += shapePoints[i].Longitude + " " + shapePoints[i].Latitude;
            }

            // return WKT representation of the VEShape
            return wktTemplate.replace("{points}", wktGeomPoints);
        },
        ///<summary>
        ///Converts WKT (Well-Known-Text) string representation of a point/polygon/linestring to a VEShape object.
        ///</summary>
        ShapeFromWKT: function(strWKT) {
            if (strWKT == null) {
                throw "VirtualEarthWKT.ShapeFromWKT: 'strWKT' parameter can not be null.";
            }
            if (strWKT.length == 0) {
                throw "VirtualEarthWKT.ShapeFromWKT: 'strWKT' parameter can not be an empty string.";
            }
            var shapeType = null;
            var wktPoints = null;

            // Get the Shape Type and list of "Longitude Latitude" location points
            switch (strWKT.substring(0, 5).toLowerCase()) {
                case "point":
                    shapeType = VEShapeType.Pushpin;
                    wktPoints = strWKT.substring(6, strWKT.length - 1);
                    break;
                case "polyg":
                    shapeType = VEShapeType.Polygon;
                    wktPoints = strWKT.substring(9, strWKT.length - 2);
                    break;
                case "lines":
                    shapeType = VEShapeType.Polyline;
                    wktPoints = strWKT.substring(11, strWKT.length - 1);
                    break;
                default:
                    throw "VirtualEarthWKT.ShapeFromWKT: Unknown WKT Geometry Type";
                    break;
            }

            // split out the wkt points to be seperate
            wktPoints = wktPoints.split(",");

            // Convert the WKT Points to VELatLong locations
            var shapePoints = new Array();
            for (var i = 0; i < wktPoints.length; i++) {
                // Split the "Longitude Latitude" apart
                var loc = priv.trimSpaces(wktPoints[i]).split(" ");
                // Create VELatLong location
                shapePoints[shapePoints.length] = new VELatLong(parseFloat(loc[1]), parseFloat(loc[0]));
            }
            
            // Return a VEShape that represents this WKT Geometry
            return new VEShape(shapeType, shapePoints);
        }
    };
    // Return the object that contains the "public" and "private" methods
    return that;
})();

Awarded 2009 Microsoft MVP - Windows Live Platform

crpietschmann — Wed, 01 Apr 2009 16:17:00 -0500

Congratulations 2009 Microsoft MVP!

Dear Chris Pietschmann,

Congratulations! We are pleased to present you with the 2009 Microsoft® MVP Award! This award is given to exceptional technical community leaders who actively share their high quality, real world expertise with others.

The Microsoft MVP Award provides us the unique opportunity to celebrate and honor your significant contributions and say "Thank you for your technical leadership."

Toby Richards
General Manager
Community Support Services

I’m lucky enough to be one of the April Fools MVPs. Last year I wasn’t sure at first if the email was an April Fools joke or not, and this year I’m just as happy that it’s not. This marks the second time I’ve been awarded Microsoft MVP. Last year I was awarded in the “Virtual Earth” category, and last fall they renamed me to “Windows Live Platform”. This year I am awarded in the same “Windows Live Platform” category.

In case you’re not familiar with the Microsoft MVP Program, here’s a link for more information:

http://mvp.support.microsoft.com/gp/mvpawardintro

And Congratulations to all those that have also been awarded MVP on this April Fools day. Especially to those who’ve gotten awarded for the first time; keep it up.

Thanks!!

Chris Pietschmann

Prototype of VEToolkit + ASP.NET MVC 1.0 Component Checked In

crpietschmann — Sat, 28 Mar 2009 16:17:06 -0500

I just checked in an initial prototype of a reusable Virtual Earth component for ASP.NET MVC. The “VEToolkit.Web.MVC.Map” component is written as an Extension to the ASP.NET MVC AjaxHelper class, and allows for a simpler experience when implementing Virtual Earth mapping within ASP.NET MVC applications. This is an early prototype of what the component will be; it’s not a final release; but you are free to use it.

Download the latest Change Set of VEToolkit

The code is subject to change at any time, since this is currently in a prototype stage, but below is a basic overview of what’s there so far.

Include a Basic Map on the Page

Include the “VEToolkit.Web.MVC” namespace within the page by adding the following Include directive to the top of the Page:

<%@ Import Namespace="VEToolkit.Web.MVC" %>

Add the following two JavaScript Includes (the Virtual Earth JavaScript API and jQuery) to the Page Header:

<script type="text/javascript" src="http://dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=6.2"></script>

<script type="text/javascript" src="/Scripts/jquery-1.3.2.js"></script>

Add the following to the Page to add a basic Virtual Earth map:

<%=Ajax.Map() %>

And that’s it; you’ll have “default” sized Virtual Earth map on the page.

Specify you own name for the global VEMap Variable that’s used

By default the component autogenerates an ID to use when naming the global VEMap object within the JavaScript that’s generated.

Here’s an example of how to specify your own ID (or variable name) to be used for the global VEMap object that’s created:

<%=Ajax.Map("myMap") %>

Now to get a hold of the global reference to the VEMap object, you can just access it by name, like so:

<input type="button" value="Zoom In" onclick="myMap.ZoomIn();" />
<input type="button" value="Zoom Out" onclick="myMap.ZoomOut();" />

Set a couple Map Properties

Here’s a modified example of the above that sets the Center Location, Zoom Level and Map Style:

<%=Ajax.Map("myMap")
    .SetCenter(new Location(44, -78))
    .SetZoom(6)
    .SetMapStyle(MapStyle.Road)%>

Call a JavaScript Function Once the Map is Loaded

Also you can specify a JavaScript Function to be called once the Map has finished loading within the Page.

Here’s an example:

<%=Ajax.Map("myMap")
    .SetOnMapLoaded("MapLoaded")%>

And, here’s a simple JavaScript Function named “MapLoaded” to match that adds a Pushpin to the Map at it’s Center Point:

<script type="text/javascript">
    function MapLoaded(sender) {
        // "sender" = The Map that was Loaded
        var map = sender;

        // Add a Shape to the Center of the Map now it's finished loading
        var s = new VEShape(VEShapeType.Pushpin, sender.GetCenter());
        s.SetTitle("Center Point");
        s.SetDescription("This was the original center point when the Map loaded.");
        map.AddShape(s);
    }
</script>

Conclusion

As stated above, this is just a basic overview of what’s been implemented so far in the VEToolkit ASP.NET MVC Prototype. There are a couple more things in there than I mentioned above, but I thought I’d keep the intro very basic until development moved further along.

ASP.NET MVC: Implement Theme Folders using a Custom ViewEngine

crpietschmann — Thu, 26 Mar 2009 18:09:00 -0500

One of the things that ASP.NET MVC 1.0 is missing is the ability to easily implement Themes. The older, more mature standard ASP.NET framework includes theme support via the App_Themes folder; however limited it can be, it’s still more than ASP.NET MVC currently has. Well, at least until I wrote this little custom ViewEngine and ControllerBase class to help out and allow us to very easily implement Themes within our ASP.NET MVC applications.

A little history: A few months back I wrote up a post on “How To Setup Custom Theme Support In ASP.NET MVC Preview 4 using a Custom ViewEngine”, then a couple weeks later I posted an updated version that added Custom Themes to ASP.NET MVC Preview 5. So I’ve decided to update the code from Preview 5 and make it all work with ASP.NET MVC v1.0 Final Release.

Also, I took a tip from Michael Ryan and modified my previous theme implementation from Preview 5 to include both Views and Content folders within the Theme folder.

Download the Code

I know some of you may want to download the code and look at it before reading on, so here's the download link:

Source Code: AspNetMvc1CustomThemeImplementation.zip (262.99 kb)

Create “~/Themes” Folder and a “Default” View Theme

First, we’ll make some changes to the Views contained within the default ASP.NET MVC Template.

Here’s a brief summary of what changes are needed:

Create a sub-folder named “Themes” within the website root folder
Create a sub-folder names “Default” within the “Themes” folder
Cut and Paste the “Views” folder into the new “~/Themes/Default” folder
Cut and Past the “Content” folder into the new “~/Themes/Default” folder
Modify the Pages (.aspx) to point correctly to the Master Page (.master) for the Theme their in, now that we moved the files.
Modify the Master Pages (.master) to point to the CSS file within the “Content” folder correctly, now that we moved the files.
To create additional Themes, just copy the “Default” folder and name it what you want for the desired Theme, and repeat Steps 5 and 6 above.

To the right is a screenshot displaying the layout of the Themes folder as described above.

Apply the Custom ViewEngine

Now that we have our Themes folder created, we can go ahead and implement our Custom ViewEngine. The Custom ViewEngine in this example was created by inheriting the WebFormViewEngine and just overriding/changing the necessary functionality.

First we need to tell our application to use the new “WebFormThemeViewEngine” ViewEngine class. To do this we’ll need to clear any existing ViewEngines and add a new instance of the ‘WebFormThemeViewEngine”. This needs to be done within the Application_Start method in the Global.asax. Below is what the Application_Start method will look like after we make the necessary changes.

protected void Application_Start()
{
    RegisterRoutes(RouteTable.Routes);

    // Replace the Default WebFormViewEngine with our custom WebFormThemeViewEngine
    System.Web.Mvc.ViewEngines.Engines.Clear();
    System.Web.Mvc.ViewEngines.Engines.Add(new WebFormThemeViewEngine());
}

Also, for reference here’s the complete code for the “WebFormThemeViewEngine” class that’s used in this example. I wont be discussing the steps necessary when creating your own custom ViewEngines; that would be a little more involved than I would like to get within the scope of this article. A link to download the entire code for the project I created when writing this article is located at the top of the article.

public class WebFormThemeViewEngine : WebFormViewEngine
{
    public WebFormThemeViewEngine()
    {
        base.MasterLocationFormats = new string[] {
            "~/Themes/{2}/Views/{1}/{0}.master", 
            "~/Themes/{2}/Views/Shared/{0}.master"
        };
        base.ViewLocationFormats = new string[] { 
            "~/Themes/{2}/Views/{1}/{0}.aspx", 
            "~/Themes/{2}/Views/{1}/{0}.ascx", 
            "~/Themes/{2}/Views/Shared/{0}.aspx", 
            "~/Themes/{2}/Views/Shared/{0}.ascx" 
        };
        base.PartialViewLocationFormats = new string[] {
            "~/Themes/{2}/Views/{1}/{0}.aspx",
            "~/Themes/{2}/Views/{1}/{0}.ascx",
            "~/Themes/{2}/Views/Shared/{0}.aspx",
            "~/Themes/{2}/Views/Shared/{0}.ascx"
        };
    }

    protected override bool FileExists(ControllerContext controllerContext, string virtualPath)
    {
        try
        {
            return System.IO.File.Exists(controllerContext.HttpContext.Server.MapPath(virtualPath));
        }
        catch (HttpException exception)
        {
            if (exception.GetHttpCode() != 0x194)
            {
                throw;
            }
            return false;
        }
        catch
        {
            return false;
        }
    }

    public override ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
    {
        string[] strArray;
        string[] strArray2;

        if (controllerContext == null)
        {
            throw new ArgumentNullException("controllerContext");
        }
        if (string.IsNullOrEmpty(viewName))
        {
            throw new ArgumentException("viewName must be specified.", "viewName");
        }

        string themeName = this.GetThemeToUse(controllerContext);

        string requiredString = controllerContext.RouteData.GetRequiredString("controller");

        string viewPath = this.GetPath(controllerContext, this.ViewLocationFormats, "ViewLocationFormats",
                viewName, themeName, requiredString, "View", useCache, out strArray);

        string masterPath = this.GetPath(controllerContext, this.MasterLocationFormats, "MasterLocationFormats",
                masterName, themeName, requiredString, "Master", useCache, out strArray2);

        if (!string.IsNullOrEmpty(viewPath) && (!string.IsNullOrEmpty(masterPath) || string.IsNullOrEmpty(masterName)))
        {
            return new ViewEngineResult(this.CreateView(controllerContext, viewPath, masterPath), this);
        }
        return new ViewEngineResult(strArray.Union<string>(strArray2));
    }

    public override ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName, bool useCache)
    {
        string[] strArray;
        if (controllerContext == null)
        {
            throw new ArgumentNullException("controllerContext");
        }
        if (string.IsNullOrEmpty(partialViewName))
        {
            throw new ArgumentException("partialViewName must be specified.", "partialViewName");
        }

        string themeName = this.GetThemeToUse(controllerContext);

        string requiredString = controllerContext.RouteData.GetRequiredString("controller");
        string partialViewPath = this.GetPath(controllerContext, this.PartialViewLocationFormats,
                "PartialViewLocationFormats", partialViewName, themeName, requiredString, "Partial", useCache, out strArray);
        if (string.IsNullOrEmpty(partialViewPath))
        {
            return new ViewEngineResult(strArray);
        }
        return new ViewEngineResult(this.CreatePartialView(controllerContext, partialViewPath), this);

    }

    private string GetThemeToUse(ControllerContext controllerContext)
    {
        string themeName = controllerContext.HttpContext.Items["themeName"] as string;
        if (themeName == null) themeName = "Default";
        return themeName;
    }

    private static readonly string[] _emptyLocations;

    private string GetPath(ControllerContext controllerContext, string[] locations, string locationsPropertyName,
        string name, string themeName, string controllerName, string cacheKeyPrefix, bool useCache, out string[] searchedLocations)
    {
        searchedLocations = _emptyLocations;
        if (string.IsNullOrEmpty(name))
        {
            return string.Empty;
        }
        if ((locations == null) || (locations.Length == 0))
        {
            throw new InvalidOperationException("locations must not be null or emtpy.");
        }

        bool flag = IsSpecificPath(name);
        string key = this.CreateCacheKey(cacheKeyPrefix, name, flag ? string.Empty : controllerName, themeName);
        if (useCache)
        {
            string viewLocation = this.ViewLocationCache.GetViewLocation(controllerContext.HttpContext, key);
            if (viewLocation != null)
            {
                return viewLocation;
            }
        }
        if (!flag)
        {
            return this.GetPathFromGeneralName(controllerContext, locations, name, controllerName, themeName, key, ref searchedLocations);
        }
        return this.GetPathFromSpecificName(controllerContext, name, key, ref searchedLocations);
    }

    private static bool IsSpecificPath(string name)
    {
        char ch = name[0];
        if (ch != '~')
        {
            return (ch == '/');
        }
        return true;
    }

    private string CreateCacheKey(string prefix, string name, string controllerName, string themeName)
    {
        return string.Format(CultureInfo.InvariantCulture,
            ":ViewCacheEntry:{0}:{1}:{2}:{3}:{4}",
            new object[] { base.GetType().AssemblyQualifiedName, prefix, name, controllerName, themeName });
    }

    private string GetPathFromGeneralName(ControllerContext controllerContext, string[] locations, string name,
        string controllerName, string themeName, string cacheKey, ref string[] searchedLocations)
    {
        string virtualPath = string.Empty;
        searchedLocations = new string[locations.Length];
        for (int i = 0; i < locations.Length; i++)
        {
            string str2 = string.Format(CultureInfo.InvariantCulture, locations[i], new object[] { name, controllerName, themeName });

            if (this.FileExists(controllerContext, str2))
            {
                searchedLocations = _emptyLocations;
                virtualPath = str2;
                this.ViewLocationCache.InsertViewLocation(controllerContext.HttpContext, cacheKey, virtualPath);
                return virtualPath;
            }
            searchedLocations[i] = str2;
        }
        return virtualPath;
    }

    private string GetPathFromSpecificName(ControllerContext controllerContext, string name, string cacheKey, ref string[] searchedLocations)
    {
        string virtualPath = name;
        if (!this.FileExists(controllerContext, name))
        {
            virtualPath = string.Empty;
            searchedLocations = new string[] { name };
        }
        this.ViewLocationCache.InsertViewLocation(controllerContext.HttpContext, cacheKey, virtualPath);
        return virtualPath;
    }
}

Create a ThemeControllerBase Class to Initially Set the Theme to Use

One additional step that’s necessary when using the above WebFormThemeViewEngine is to create a custom Controller Base Class, and inherit from it with all your Controllers. This ThemeControllerBase class needs to set the Theme to use within the “HttpContext.Items[“themeName”]”. If you miss or skip this step you will get an exception and will not be able to run the website.

The ThemeControllerBase class used in this example includes code that allows you to specify the Theme to use by passing it in using the QueryString like this: “http://localhost/Default.aspx?theme=Red”

Here’s the code for the ThemeControllerBase class:

public abstract class ThemeControllerBase : Controller
{
    protected override void Execute(System.Web.Routing.RequestContext requestContext)
    {
        // Add code here to set the Theme based on your database or some other storage
        requestContext.HttpContext.Items["themeName"] = "Red";


        
        // Allow the Theme to be overriden via the querystring
        // If a Theme Name is Passed in the querystring then use it and override the previously set Theme Name
        // http://localhost/Default.aspx?theme=Red
        var previewTheme = requestContext.HttpContext.Request.QueryString["theme"];
        if (!string.IsNullOrEmpty(previewTheme))
        {
            requestContext.HttpContext.Items["themeName"] = previewTheme;
        }

        base.Execute(requestContext);
    }
}

Then you need to have all your Controller’s inherit from the ThemeControllerBase like the following:

public class HomeController : ThemeControllerBase { }

Conclusion

I’m sure some kind of Themes support is on the list for Microsoft to eventually implement into ASP.NET MVC some time down the road, but I have yet to see anything mentioned. Also, since the Official v1.0 release has already been released, I don’t really expect anything to change until presumably after .NET 4.0 ships; this is assuming the ASP.NET MVC 1.0 bits are what make it into .NET 4.0 and not a newer version of ASP.NET MVC. So, for now if you want to implement Themes into your ASP.NET MVC Website, you’ll just have to use the code I post here, or some other custom implementation.

Virtual Earth Silverlight: Using MouseClick Event To Add "Pushpins"

crpietschmann — Wed, 25 Mar 2009 22:38:00 -0500

In previous tutorials I covered the “Basics of Adding Polygons and Polylines” and “Adding Media (Images, Video, etc.)”, but what about handling user input via Map Events? Well, in this tutorial I’ll cover the basics of working with the Map.MouseClick Event (equivalent of the old “onclick” event in the Virtual Earth JavaScript Control).

Adding a MouseClick Event Handler

In order to wire things up to manipulate the Map using the MouseClick event, we must first attach an Event Handler to it. The Event Handler for the MouseClick event needs to be just like any other event handler in .NET; it must accept two parameters: 1) a “sender” object, and 2) an “EventArgs” object.

Before we create our event handler, it’s worth noting that to be more specific, the value that gets passed to the “EventArgs” parameter of the Map.MouseClick event is actually of Type MapMouseEventArgs.

The MapMouseEventArgs object has the following two properties:

Handled – Gets or Sets a value indicating whether the Map event was handled. If you want to prevent the “default” event handling behavior from executing, then all you need to do is set this to True.
ViewportPoint – Gets the viewport point where the mouse event occurred. This is a System.Windows.Point object that represents the X and Y coordinates where the mouse was clicked.

To declare the MouseClick event handler a method that matched the following signature: void(object sender, MapMouseEventArgs e)

Here’s an example Map.MouseClick event handler method:

private void myMap_MouseClick(object sender, MapMouseEventArgs e)
{
}

You can attach the above event handler from within code:

myMap.MouseClick += new EventHandler<MapMouseEventArgs>(myMap_MouseClick);

Or, from within XAML:

<m:Map Name="myMap" MouseClick="myMap_MouseClick"></m:Map>

Get the Location (Lat/Long Coordinate) the Mouse was Clicked

One thing that you may have noticed is the MapMouseEventArgs object that is passed to the MouseClick event handler doesn’t contain a “Location” or “LatLong” property of any kind. It’s seems odd at first that there’s no direct way of obtaining the Map Location (Lat/Long) of where the mouse was clicked, but with the help of a little helper method on the Map object itself we can pass in the ViewportPoint (X and Y Coordinates) value contained within the MapMouseEventArgs.ViewportPoint property and get back a Location object with Latitude/Longitude.

To obtain the Location (Lat/Long) where the mouse was clicked, simply invoke the Map.ViewportPointToLocation method by passing in the MapMouseEventArgs.ViewportPoint value.

The following line of code demonstrates how this can be done within the MouseClick Event Handler we defined above:

var location = clickedMap.ViewportPointToLocation(e.ViewportPoint);

Now that we have the Location of where the mouse was clicked, we can directly access the Latitude and Longitude values.

var lat = location.Latitude;
var lng = location.Longitude;

Add a “Pushpin” at the Clicked Location

Now that we have a MouseClick Event Handler in place, and we have access to the Location (Latitude/Longitude) where the mouse was clicked; we can go ahead and add a “Pushpin” to the Map at that Location.

If you have any questions on how to add a Shape or “Pushpin” to the Map, I recommend reading the following two tutorials:

In this example to keep things simple, we’ll add a Square (via the System.Windows.Shapes.Rectangle object) to the Map at the clicked location that is 10x10 in size.

Here’s a full code example of the MouseClick event handler we created above, including code that gets the Location clicked and adds the Rectangle Shape to the Map within a new MapLayer:

private void myMap_MouseClick(object sender, MapMouseEventArgs e)
{
    // Set a variable equal to the Map that raised the event
    Map clickedMap = (Map)sender;
    
    // Convert the X/Y Coordinate that was Clicked to a Lat/Long Location
    var location = clickedMap.ViewportPointToLocation(e.ViewportPoint);

    // Create new MapLayer
    var myLayer = new MapLayer();

    // Create a Rectangle Shape to Show as the "Pushpin"
    var rectangle = new System.Windows.Shapes.Rectangle();
    // Set it's Size to 10x10
    rectangle.Width = 10;
    rectangle.Height = 10;
    // Color the Rectangle Red
    rectangle.Fill = new SolidColorBrush(Colors.Red);

    // Center the Rectangle around the location
    PositionMethod position = PositionMethod.Center;

    // Add Rectangle to MapLayer
    myLayer.AddChild(rectangle, location, position);

    // Add the MapLayer to the Map so the "Pushpin" gets displayed
    clickedMap.AddChild(myLayer);
}

One thing that you may want to do when implementing the above example is create only 1 MapLayer and add all the new “Pushpins” to that single MapLayer. This will help improve performance on the Map if you are adding MANY pushpins. For the simple example above this just wasn’t absolutely necessary.

Auto Expand “Pushpins” using ScaleTransform

The best part of the new Virtual Earth Silverlight Map Control is the fact that we can now leverage the full power of Silverlight within our mapping applications/implementations. One of the cool things that can be done are implementing Animations to spice up the user interface.

Here’s an example that takes the above MouseClick event handler code that adds a Rectangle “Pushpin” to the Map when the user clicks the Map, and adds a ScaleTransform to “Expand” the Rectangle when the user moves the mouse over it.

This is done by setting a ScaleTransform to the Rectangle.RenderTransform during the MouseEnter event, and then removing it during the MouseLeave event. The end result are Rectangle “Pushpins” that Expand when the user Moves the mouse over them.

Here’s the full code for Map.MouseClick, Rectangle.MouseEnter and Rectangle.MouseLeave Event Handlers for this “Expand” Animation example:

// Single MapLayer that will contain all "Pushpins"
private MapLayer myLayer = null;

private void myMap_MouseClick(object sender, MapMouseEventArgs e)
{
    // Set a variable equal to the Map that raised the event
    Map clickedMap = (Map)sender;

    // Convert the X/Y Coordinate that was Clicked to a Lat/Long Location
    var location = clickedMap.ViewportPointToLocation(e.ViewportPoint);

    // Check if MapLayer has already been created
    if (myLayer == null)
    {
        // Create new MapLayer
        myLayer = new MapLayer();

        // Add the MapLayer to the Map so the "Pushpin" gets displayed
        clickedMap.AddChild(myLayer);
    }

    // Create a Rectangle Shape to Show as the "Pushpin"
    var rectangle = new System.Windows.Shapes.Rectangle();
    // Set it's Size to 10x10
    rectangle.Width = 10;
    rectangle.Height = 10;
    // Color the Rectangle Red
    rectangle.Fill = new SolidColorBrush(Colors.Red);

    // Attach MouseEnter and MouseLeave Event Handler to the Rectangle
    // This will be used to "Expand" the Rectangle when the user hovers the mouse over it
    rectangle.MouseEnter += new MouseEventHandler(rectangle_MouseEnter);
    rectangle.MouseLeave += new MouseEventHandler(rectangle_MouseLeave);

    // Center the Rectangle around the location
    PositionMethod position = PositionMethod.Center;

    // Add Rectangle to MapLayer
    myLayer.AddChild(rectangle, location, position);
}

void rectangle_MouseEnter(object sender, MouseEventArgs e)
{
    // Get the Rectangle
    var rectangle = (Rectangle)sender;

    // Create new ScaleTransform
    var scaleTransform = new ScaleTransform();

    // Set the Transform to "Expand" the Rectangle
    // equally horizontally and vertically
    scaleTransform.ScaleX = 2.0;
    scaleTransform.ScaleY = 2.0;

    // Set the Scale Center to the Center of the Rectangle
    // This is so it doesn't move when "Expanded"
    scaleTransform.CenterX = rectangle.Width / 2;
    scaleTransform.CenterY = rectangle.Height / 2;

    // Apply the ScaleTransform to the Rectangle
    rectangle.RenderTransform = scaleTransform;
}

void rectangle_MouseLeave(object sender, MouseEventArgs e)
{
    // Get the Rectangle
    var rectangle = (Rectangle)sender;

    // Remove the ScaleTransform
    rectangle.RenderTransform = null;
}

The above code example also includes a modification from the previous examples in this tutorial; it adds all the new Rectangle “Pushpins” to a Single MapLayer instead of adding a new MapLayer for each Rectangle “Pushpin”.

Conclusion

The Map.MouseClick event is really simple to take advantage of, and it’s actually just as easy to add a “Pushpin” during the “onclick” event with the Virtual Earth Silverlight Map Control as it is with the Virtual Earth JavaScript Control.

There are a few other events that the Map object exposes, and I’ll be covering some of those in additional tutorials. So, keep an eye out for future posts.

Previous Tutorial/Article: Overlay OpenStreetMap, OpenAerialMap and Yahoo Map Imagery using Custom Tile Layers

MIX'09: Virtual Earth Silverlight CTP Session Online for Viewing

crpietschmann — Sat, 21 Mar 2009 16:46:00 -0500

The "Introducing the Microsoft Virtual Earth Silverlight Map Control CTP" session from MIX'09 by Chris Pendlton is now available for your viewing pleasure online.

http://sessions.visitmix.com/MIX09/T34F

Also, here it is below:

I'm starting a Virtual Earth Developer Resource list

crpietschmann — Sat, 21 Mar 2009 16:36:00 -0500

I just started a page at the below link that I'm lising a bunch of Virtual Earth Developer Resources that I know of. The reason I'm doing this is because there just aren't any really good lists of resources out there, and there are a TON of resources that you probably don't even know about. This isn't going to be an all inclusive list (that would be impossible), but I'll try to make it the best list of resources I can. Hope it helps some of you discover great content.

http://pietschsoft.com/page/Virtual-Earth-Developer-Resources.aspx

Virtual Earth Silverlight: Overlay OpenStreetMap, OpenAerialMap and Yahoo Map Imagery using Custom Tile Layers!

crpietschmann — Fri, 20 Mar 2009 18:51:00 -0500

In the “Using Tile Layers to Overlay Custom Map Imagery” article I showed you how to overlay your own Custom Map Imagery that you generated using the MapCruncher tool on top of the Map. Now, in this article I’ll show you what you need to know in order to overlay map imagery from other competing mapping services (OpenStreetMap, OpenAerialMap and Yahoo Maps). This allows you to easily build in functionality that allows your users to easily switch (with the click of a button or selection of a dropdown) which mapping service imagery is used to visualize the data in your application.

Beware: This article is just a demo of how this is possible. If you do implement this, you need to keep in mind that you’ll need to then adhere to both the Virtual Earth Silverlight Control CTP Terms of Use and the Terms of Use for which ever mapping services data you are displaying.

Before I begin, I’d like to thank the awesome guys that are working on the DeepEarth Project.

Now to the exciting stuff!

Overview of What’s Needed

The steps to create a Tile Layer that displays Map Imagery from the mentions services is very similar to the method mentioned in the “Using Tile Layers to Overlay Custom Map Imagery” arcticle, with the exception that you need to create your own Custom Tile Source object that inherits from TileSource.

Here’s the steps needed to do this:

Create a Custom Tile Source (inheriting from TileSource) object
1. Define the “uriFormat” to be used to generate the Uri of the Map Images.
2. Override the”GetUri” method. This method uses the “uriFormat” to generate the Uri of the Map Images.
Add the Tile Source to the Map
1. Create a MapTileLayer object instance
2. Create an instance of you Custom Tile Source object
3. Add the Custom Tile Source object to the MapTileLayer
4. Set the MapTileLayer’s Opacity to the desired value
5. Add the MapTileLayer to the Children collection of the Map

The TileSource objects “GetUri” method takes the following 3 arguments:

x – The horizontal position of the tile.
y – The vertical position of the tile.
zoomLevel – The zoom level of the tile.

You then need to convert (within this method) the x, y, and zoomLevel values into the correct values to be passed using the uriFormat to load the map imagery tiles. This can take a little work in some cases (as with Yahoo Maps) and it an be straight forward in others (as with OpenStreetMap and OpenAerialMap).

Also, when you’re showing Map Imagery that will completely overlay over the top of the Virtual Earth Imagery, it’s a good practice to set the Map’s Mode to an “Empty” mode that will prevent the Virtual Earth imagery from even being downloaded for display. This will increase performance a little (whether you notice it or not), and it will prevent you from using up unnecessary transactions using the Virtual Earth Web Service (this is how the control loads the Virtual Earth imagery behind the scenes.)

Create a TileSource for OpenStreetMap

First we need to create custom TileSource object, set the UriFormat to be used to generate the Imagery Uri, and then override the “GetUri” method with code that generates the appropriate Imagery Uri’s using “String.Format”.

The resulting Custom Tile Source object is so simple, it’s probably easier to just show you the code.

namespace VirtualEarthSilverlight01
{
    public class OpenStreetMapTileSource : Microsoft.VirtualEarth.MapControl.TileSource
    {
        public OpenStreetMapTileSource()
            : base("http://tile.openstreetmap.org/{2}/{0}/{1}.png")
        {
        }

        public override Uri GetUri(int x, int y, int zoomLevel)
        {
            return new Uri(String.Format(this.UriFormat, x, y, zoomLevel));
        }
    }
}

If you aren’t familiar with the above method of using “String.Format” to replace certain placeholders within a string with specific values, you can reference the MSDN Documentation here.

Now using the described overview above, we can add the new OpenStreetMapTileSource object to a MapTileLayer on the Map and display the OpenStreetMap Imagery within the Silverlight Map Control. Here’s an example of doing this with XAML.

Also, since the OpenStreetMapTileSource object is contained within the projects namespace (“VirtualEarthSilverlight01”) we need to also add a namespace reference to the XAML file. In the example above I’m giving it the prefix of “local”. Once the namespace is included, we can then use our OpenStreetMapTileSource object within the XAML.

Create a TileSource for OpenAerialMap

The process of creating a Custom Tile Source and adding it to the Map is identical for OpenAerialMap Imagery as the above example for OpenStreetMap; with the exception of the uriFormat that is used to load the imagery. So, I’m not going to re-explain the process all over again. Instead, I’ll just show you the code.

The resulting Custom Tile Source object for showing OpenAerialMap Imagery:

namespace VirtualEarthSilverlight01
{
    public class OpenAerialMapTileSource : Microsoft.VirtualEarth.MapControl.TileSource
    {
        public OpenAerialMapTileSource()
            : base("http://tile.openaerialmap.org/tiles/1.0.0/openaerialmap-900913/{2}/{0}/{1}.jpg")
        {
        }

        public override Uri GetUri(int x, int y, int zoomLevel)
        {
            return new Uri(String.Format(this.UriFormat, x, y, zoomLevel));
        }
    }
}

Here’s some example XAML that adds the OpenAerialMapTileSource object to the Map:

             <m:Map.Mode>
                <mCore:MercatorMode></mCore:MercatorMode>
            </m:Map.Mode>
            <m:Map.Children>
                <m:MapTileLayer>
                    <m:MapTileLayer.TileSources>
                        <local:OpenAerialMapTileSource></local:OpenAerialMapTileSource>
                    </m:MapTileLayer.TileSources>
                </m:MapTileLayer>
            </m:Map.Children>
        </m:Map>
    </Grid>
</UserControl>

Create a TileSource for Yahoo Maps (Street, Aerial and Hybrid)

Again, the process for creating a Custom Tile Source for Yahoo Maps and adding it to the Map is almost identical to the above examples. Except, with Yahoo maps there’s a little math that needs to be done to convert the x, y and zoomLevel arguments that are passed in to the “TileSource.GetUri” method to be the correct values need to load the Yahoo Maps Imagery. I’m not going to cover the process of what’s needed to convert them from the Virtual Earth values to the Yahoo Maps values, but the as you’ll see below the code needed is fairly simple.

Yahoo Maps – Street Imagery

Here’s the code for the Custom Tile Source for Yahoo Maps Street Imagery:

namespace VirtualEarthSilverlight01
{
    public class YahooStreetTileSource : Microsoft.VirtualEarth.MapControl.TileSource
    {
        public YahooStreetTileSource()
            : base("http://us.maps2.yimg.com/us.png.maps.yimg.com/png?v=3.52&t=m&x={0}&y={1}&z={2}")
        {
        }

        public override Uri GetUri(int x, int y, int zoomLevel)
        {
            // The math used here was copied from the DeepEarth Project (http://deepearth.codeplex.com)
            double posY;
            double zoom = 18 - zoomLevel;
            double num4 = Math.Pow(2.0, zoomLevel) / 2.0;

            if (y < num4)
            {
                posY = (num4 - Convert.ToDouble(y)) - 1.0;
            }
            else
            {
                posY = ((Convert.ToDouble(y) + 1) - num4) * -1.0;
            }

            return new Uri(String.Format(this.UriFormat, x, posY, zoom));
        }
    }
}

And, here’s some example XAML that adds the YahooStreetTileSource object to the Map:

             <m:Map.Mode>
                <mCore:MercatorMode></mCore:MercatorMode>
            </m:Map.Mode>
            <m:Map.Children>
                <m:MapTileLayer>
                    <m:MapTileLayer.TileSources>
                        <local:YahooStreetTileSource></local:YahooStreetTileSource>
                    </m:MapTileLayer.TileSources>
                </m:MapTileLayer>
            </m:Map.Children>
        </m:Map>
    </Grid>
</UserControl>

Yahoo Maps – Aerial Imagery

Here’s the code for the Custom Tile Source for Yahoo Maps Aerial Imagery:

namespace VirtualEarthSilverlight01
{
    public class YahooAerialTileSource : Microsoft.VirtualEarth.MapControl.TileSource
    {
        public YahooAerialTileSource()
            : base("http://us.maps3.yimg.com/aerial.maps.yimg.com/tile?v=1.7&t=a&x={0}&y={1}&z={2}")
        {
        }

            return new Uri(String.Format(this.UriFormat, x, posY, zoom));
        }
    }
}

And, here’s some example XAML that adds the YahooAerialTileSource object to the Map:

             <m:Map.Mode>
                <mCore:MercatorMode></mCore:MercatorMode>
            </m:Map.Mode>
            <m:Map.Children>
                <m:MapTileLayer>
                    <m:MapTileLayer.TileSources>
                        <local:YahooAerialTileSource></local:YahooAerialTileSource>
                    </m:MapTileLayer.TileSources>
                </m:MapTileLayer>
            </m:Map.Children>
        </m:Map>
    </Grid>
</UserControl>

Yahoo Maps – Hybrid Imagery

One thing with the Yahoo Maps Hybrid Imagery is it only shows the roads in the imagery, everything else is transparent. So in order to get the same view as the Virtual Earth Hybrid Map Mode, you need to add the Yahoo Maps Aerial Imagery to the Map, then add the Yahoo Maps Hybrid Imagery so it overlays on top of the the Aerial imagery. You’ll see below that this is really simple to do.

Here’s the code for the Custom Tile Source for Yahoo Maps Hybrid Imagery:

namespace VirtualEarthSilverlight01
{
    public class YahooHybridTileSource : Microsoft.VirtualEarth.MapControl.TileSource
    {
        public YahooHybridTileSource()
            : base("http://us.maps3.yimg.com/aerial.maps.yimg.com/png?v=2.2&t=h&x={0}&y={1}&z={2}”)
        {
        }

            return new Uri(String.Format(this.UriFormat, x, posY, zoom));
        }
    }
}

And, here’s some example XAML that adds the YahooAerialTileSource and YahooHybridTileSource objects to the Map:

Conclusion

As you can see, the ability to overlay custom map imagery of any kind (like OpenStreetMap or Yahoo Maps Imagery) really offers some great flexibility in the control. Plus, it’s easy to do!

Previous Tutorial/Article: Using Tile Layers to Overlay Custom Map Imagery

Next Tutorial/Article: Using MouseClick Event To Add "Pushpins"

Virtual Earth Silverlight: Using Tile Layers to Overlay Custom Map Imagery

crpietschmann — Fri, 20 Mar 2009 18:47:00 -0500

One of the features that the Virtual Earth JavaScript Control has is the ability to add custom Tile Layers to overlay your own custom imagery over the map. The Virtual Earth Silverlight control also supports this feature.

Before I begin to explain how to add custom Tile Layers to the Map it’s important to note that you can still use the MapCruncher tool to generate Map Imagery Tiles to be used with the custom Tile Layers. The specifics of using the MapCruncher tool to generate Map Imagery Tiles isn’t within the scope of this article. You can find a tutorial on how to use MapCruncher here: http://research.microsoft.com/en-us/um/redmond/projects/mapcruncher/tutorial/version3.0docs/index.htm

Add Custom Tile Layer using Code

Once you have some custom Map Imagery Tiles generated from using MapCruncher, you can then add them using an instance of the LocationRectTileSource object and adding it to a MapTileLayer on the Map.

To do this we will following the below steps:

Create a MapTileLayer object
Create a LocationRect object that defines the bounding rectangle for our map tile overlay
Create a LocationRectTileSource
1. Point it to the Uri of our custom Map Imagery Tiles
2. Set the Minimum and Maximum Zoom Levels (ZoomRange) that the imagery is to be visible within
3. Set the Bouding Rectangle to the LocationRect object we previously created
Add the LocationRectTileSource to the MapTileLayer’s TileSources collection property
Set the MapTileLayer’s Opacity to the desired value
Add the MapTileLayer to the Children collection of the Map

Here’s some sample code that will add a custom Tile Layer using the imagery that the JavaScript Map Controls SDK uses as an example for this same thing:

// Create a Tile Layer that will display our custom Map Imagery Tiles
var customTileLayer = new MapTileLayer();

// Define the Bounding Rectangle
LocationRect boundingRect = new LocationRect(
new Location(49, -123),
new Location(47, -121)
);

// Create a LocationRectTileSource
LocationRectTileSource customTileSource = new LocationRectTileSource();

// Set the Uri for the custom Map Imagery Tiles
customTileSource.UriFormat = "http://dev.live.com/virtualearth/sdk/layers/lidar/{0}.png";

// Set the Min and Max Zoom Levels that the imagery is to be visible within
customTileSource.ZoomRange = new Range<double>(10, 18);

// The bounding rectangle area that the tile overaly is valid in.
customTileSource.BoundingRectangle = boundingRect;

// Add the Tile Source to the Tile Layer
customTileLayer.TileSources.Add(customTileSource);

// Set the Tile Layer Opacity to a desired value
customTileLayer.Opacity = 0.7;

Map1.Children.Add(customTileLayer);

Hide Virtual Earth Imagery From Being Displayed

Sometimes you may want to hide the Virtual Earth Imagery from being displayed altogether. To do this all you need to do is set the Map’s Mode property to a new instance of the MercatorMode object. Doing this allows you to show only your custom map imagery.

Using XAML:

Using Code:

Map1.Mode = new Microsoft.VirtualEarth.MapControl.Core.MercatorMode();

A little more intuitively

Alternatively, you can also create your own EmptyMapMode object that inherits from the MercatorMode object. This way your code will be a little more intuitive to read.

Here’s example of doing this:

As you notice above, since our custom EmptyMapMode object is contained within the “VirtualEarthSilverlightApplication1” namespace, we need to add that namespace to the XAML file in order to use it.

And, here’s the EmptyMapMode object shown in use above:

public class EmptyMapMode :Microsoft.VirtualEarth.MapControl.Core.MercatorMode
{
}

Conclusion

If you are familiar with the JavaScript Map Control you can see that it’s pretty much just as simple to overly your own custom map imagery tiles on the map. One thing to note is that the LocationRectTileSource inherits from the TileSource object; so presumably you could inherit from the TileSource object yourself to create write code that pulls in map imagery from any source using your own custom TileSource object.

Next Tutorial/Article: Overlay OpenStreetMap, OpenAerialMap and Yahoo Maps Imagery using Custom Tile Layers!

Previous Tutorial/Article: Adding Media (Images, Video, etc.) to the Map

Virtual Earth Silverlight: Adding Media (Images, Video, etc.) to the Map

crpietschmann — Fri, 20 Mar 2009 18:43:00 -0500

In the previous tutorial (“Basics of Adding Polygons and Polylines using XAML and Code”) I mentioned that there is no Pushpin Shape Type in the new Virtual Earth Silverlight Map Control SDK CTP. Instead, the Silverlight control has the flexibility of plotting/displaying anything (as long as it inherits from UIElement) you want at a specific Latitude/Longitude Coordinate. This opens up a ton of UI options that can be built to allow the user to interact with the data being displayed.

One thing to keep in mind when adding Images, Video and any other UIElements to the Map is that you’ll need to add them to a MapLayer, then add the MapLayer to the Map. This is required so that you can specify the Location to Plot the UIElement at. This is something that you’ll probably want to do anyway so you can easily control the layering of the elements that are plotted, or even easily show/hide groups of elements (by having a seperate MapLayer contain the elements for each specific group.)

Let’s start plotting some cool stuff on a Map.

Adding Images to the Map (aka “Pushpins”)

When adding Images to the Map, the process is very similar to adding Polygons or Polylines, except you need to add Images to a MapLayer first, then add the MapLayer to the Map.

The closest thing with the Silverlight Map Control to the “Pushpins” of the old JavaScript control is the ability to directly plot Images on the Map.

// Create MapLayer
MapLayer myLayer = new MapLayer();

// Create Image
Image image = new Image();
// Set the Image Source
image.Source = new BitmapImage(new Uri("pushpinImage.png", UriKind.Relative));

// Set Image Display Properties
image.Opacity = 0.8;
image.Stretch = Stretch.None;

// Create a Location object that defines where the "Shape" will be plotted
Location location = new Location() { Latitude = -10, Longitude = 10 };

// Center the image around the location specified
PositionMethod position = PositionMethod.Center;

// Add Image to the Layer
myLayer.AddChild(image, location, position);

// Add Layer to the Map
Map1.AddChild(myLayer);

Adding Video to the Map

Plotting Video content on the Map is a good example of what some of the possibilities are opening up with this new Virtual Earth Silverlight Map Control. To do this all you need to do is create a MediaElement with its Source set to the Uri of a Video and add it to the Map in the same way as shown above with adding Images to the Map.

// Create MapLayer
MapLayer myLayer = new MapLayer();

// Create MediaElement
MediaElement video = new MediaElement();

// Set the MediaElement Source to the Video
video.Source = new Uri("http://mschnlnine.vo.llnwd.net/d1/ch9/8/9/1/1/6/4/ScottGuthrieSL3_ch9.wmv",
UriKind.RelativeOrAbsolute);

// Set MediaElement Display Properties
video.Opacity = 0.8;
video.Width = 200;
video.Height = 150;

// Create a Location object that defines where the "Shape" will be plotted
Location location = new Location() { Latitude = -10, Longitude = 10 };

// Center the image around the location specified
PositionMethod position = PositionMethod.Center;

// Add Image to the Layer
myLayer.AddChild(video, location, position);

// Add Layer to the Map
Map1.AddChild(myLayer);

Conclusion

You can add any visual control/object that derives from UIElement to the Map using the same method described above with Images and Video. This really opens up the possibilities to plot/add any kind of Rich Content to the Map. The possibilities are almost endless.

Next Tutorial/Article: Using Tile Layers to Overlay Custom Map Imagery

Previous Tutorial/Article: Basics of Adding Polygons and Polylines using XAML and Code

Virtual Earth Silverlight: Basics of Adding Polygons and Polylines using XAML and Code

crpietschmann — Fri, 20 Mar 2009 18:40:00 -0500

Now that we’re familiar with the basics of the Virtual Earth Silverlight Map Control SDK CTP (from my Getting Started with Virtual Earth Silverlight CTP tutorial), we’re ready to move on to adding Shapes (Polygons and Polylines). After all what use is a Virtual Earth Map Control without plotting some data on it. If you’re not familiar with how to get a Map displayed within a Silverlight Application, I really encourage you to go take a look at my “Getting Started with Virtual Earth Silverlight Map Control SDK CTP” tutorial.

Did you notice that I left out Pushpins? Well, this is actually because the Map control doesn’t have a Pushpin Shape Type; the only Shapes Types are Polygon and Polyline. The reason for this is because instead of limiting you to just Pushpins (a small icon of some sort) like the JavaScript Map Control; the Silverlight Control allows you to plot/display anything (as long as it inherits from UIElement) you want at a specific Latitude/Longitude Coordinate. Since, “Pushpins” are a newly changed concept with the Silverlight Map Control; I’ll be covering that is a separate tutorial that covers “Adding Media (Images, Video, etc.) to the Map”.

Now let’s get to plotting some Polygons and Polylines!

Adding Polygons to the Map

To add a Polygon to the Map, you will need to create an instance of the MapPolygon object and add a collection of Location objects to its “Locations” property. You will also need to define the look of your Polygon by setting its “Fill”, “Stroke”, “StrokeThickness” and “Opacity” properties.

The MapPolygon properties and what they do:

Fill – A Brush object that defines how the inside of the Polygon is filled in.
Stroke – A Brush object that defines how the border that outlines the Polygon will be drawn.
StrokeThickness – A Double value that defines the thickness of the border that outlines the Polygon.
Opacity – A Double value that defines the Opacity (or Transparency) of the Polygon.

When adding Polygons to the Map you add your MapPolygon object instance to the Map.Children collection.

Add a Polygon Programmatically using Code

Here’s an example of adding a Polygon to a Map programmatically:

MapPolygon polygon = new MapPolygon();
polygon.Fill = new SolidColorBrush(Colors.Red);
polygon.Stroke = new SolidColorBrush(Colors.Yellow);
polygon.StrokeThickness = 5;
polygon.Opacity = 0.7;
polygon.Locations = new LocationCollection()
{
    new Location(20, -20),
    new Location(20, 20),
    new Location(-20, 20),
    new Location(-20, -20)
};

Map1.AddChild(polygon);
// Map1.Children.Add(polygon); // <—This also works just the same

Add a Polygon Declaratively using XAML

One other neat thing that you can do is add Polygons to a Map declaratively using XAML. Here’s an example:

Adding Polylines to the Map

To add a Polyline to the Map, you will need to create an instance of the MapPolyline object and add a collection of Location objects to its “Locations” property. You will also need to define the look of your Polyline by setting its “Stroke”, “StrokeThickness” and “Opacity” properties.

The MapPolyline properties and what they do:

Stroke – A Brush object that defines how the Line that represents the Polyline will be drawn on the Map.
StrokeThickness – A Double value that defines the thickness of the Line.
Opacity – A Double value that defines the Opacity (or Transparency) of the Polyline.

Additionally, the MapPolyline object has one more property that I didn’t mention above. This is a little bit of a special property, that you may wonder why a Polyline object has it, but it opens up some possibilities that weren’t available before using the JavaScript Map Control.

Fill - A Brush object that defines how the inside of the Polyline is filled in. This will connect the first and last Location point of the Polyline and Fill in between using the designated Brush. This doesn’t draw a Line (or Stroke) from the first Location to the last, it just fills in between the Shape.

When adding Polylines to the Map you add your MapPolyline object instance to the Map.Children collection; just the same as is done with Polygons.

Add a Polyline Programmatically using Code

Here’s an example of adding a Polyline to a Map programmatically:

MapPolyline polyline = new MapPolyline();
polyline.Stroke = new SolidColorBrush(Colors.Yellow);
polyline.StrokeThickness = 5;
polyline.Opacity = 0.7;
polyline.Locations = new LocationCollection()
{
    new Location(10, -10),
    new Location(10, 10),
    new Location(-10, -10),
    new Location(-10, 10)
};

Map1.AddChild(polyline);
// Map1.Children.Add(polyline); // <—This also works just the same

Add a Polyline Declaratively using XAML

One other neat thing that you can do is add Polylines to a Map declaratively using XAML. Here’s an example:

Adding Shape Layers

In the old JavaScript Map Control, you could add your Shapes to different Shape Layers, then you could easily hide/show the Shapes in each Layer by hiding/showing the entire Shape Layer. This is also possible using the Virtual Earth Silverlight Map Control via the MapLayer object.

To use the MapLayer object you simply create a new MapLayer, add your Shapes (Polygons or Polylines) to it, then add the MapLayer to the Map.

Here’s an example of doing this:

// Create MapLayer
MapLayer myShapeLayer = new MapLayer();

// Create Polygon
MapPolygon polygon = new MapPolygon();
polygon.Fill = new SolidColorBrush(Colors.Red);
polygon.Stroke = new SolidColorBrush(Colors.Yellow);
polygon.StrokeThickness = 5;
polygon.Opacity = 0.7;
polygon.Locations = new LocationCollection()
{
    new Location(20, -20),
    new Location(20, 20),
    new Location(-20, 20),
    new Location(-20, -20)
};

// Add Polygon to the Layer
myShapeLayer.AddChild(polygon);

// Add the Layer to the Map
Map1.AddChild(myShapeLayer);

Easily Add a “Hover Over” Effect Via Tooltips

If you want to quickly and easily add some content that gets displayed when the user hovers the mouse over the Polygon or Polyline; you can implement it very easily by taking advantage of Silverlights Tooltip feature.

Here are some code examples of doing this that add to the above Polygon examples (the exact same can be done with Polylines).

Add Tooltip Declaratively using XAML

<UserControl x:Class="VirtualEarthSilverlightApplication1.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:m="clr-namespace:Microsoft.VirtualEarth.MapControl;assembly=Microsoft.VirtualEarth.MapControl"
    Width="400" Height="300">
    <Grid x:Name="LayoutRoot" Background="White">
        <m:Map Name="Map1">
            <m:Map.Children>
                <m:MapPolygon Fill="Red" Stroke="Yellow" StrokeThickness="5" Opacity="0.7">
                    <ToolTipService.ToolTip>
                        <StackPanel>
                            <TextBlock FontWeight="Bold">A Huge Square Title</TextBlock>
                            <TextBlock>This is an arbitrary description of the "Huge Square" to be displayed within the Tooltip.</TextBlock>
                        </StackPanel>
                    </ToolTipService.ToolTip>
                    <m:MapPolygon.Locations>
                        <m:LocationCollection>
                            <m:Location>20, -20</m:Location>
                            <m:Location>20, 20</m:Location>
                            <m:Location>-20, 20</m:Location>
                            <m:Location>-20, -20</m:Location>
                        </m:LocationCollection>
                    </m:MapPolygon.Locations>
                </m:MapPolygon>
            </m:Map.Children>
        </m:Map>
    </Grid>
</UserControl>

Add Tooltip Programmatically using Code

// Declare Polygon
MapPolygon polygon = new MapPolygon();
polygon.Fill = new SolidColorBrush(Colors.Red);
polygon.Stroke = new SolidColorBrush(Colors.Yellow);
polygon.StrokeThickness = 5;
polygon.Opacity = 0.7;
polygon.Locations = new LocationCollection()
{
    new Location(20, -20),
    new Location(20, 20),
    new Location(-20, 20),
    new Location(-20, -20)
};

// Add Tooltip
var tooltipObject = new StackPanel();

var title = new TextBlock();
title.FontWeight = FontWeights.Bold;
title.Text = "A Huge Square Title";
tooltipObject.Children.Add(title);

var description = new TextBlock();
description.Text = "This is an arbitrary description of the \"Huge Square\" to be displayed within the Tooltip.";
tooltipObject.Children.Add(description);

ToolTipService.SetToolTip(polygon, tooltipObject);

// Add Polygon to Map
Map1.AddChild(polygon);
// Map1.Children.Add(polygon); // <—This also works just the same

Conclusion

As you can see, it’s fairly simple to add Polygons and Polylines to the Map. In the next tutorial I’ll cover how to add Image (also “Pushpins”) and Video to the Map.

Next Tutorial/Article: Adding Media (Images, Video, etc.) to the Map

Previous Tutorial/Article: Getting Started with Virtual Earth Silverlight Map Control SDK CTP

Getting Started with Virtual Earth Silverlight Map Control SDK CTP

crpietschmann — Fri, 20 Mar 2009 18:27:00 -0500

It seems like forever since MIX’08 when a demo was shown of a new Silverlight-based Virtual Earth Map Control. Well, now FINALLY we actually have a version of the control to “play” around with. The reason I say “play” is because it’s still a CTP (Community Technology Preview). If you read the license file you’ll see that basically the most important points of Microsoft’s position on CTP’s are: 1) You can NOT use it in a production environment, and 2) It’s a Preview, so anything can change from now until the next release (CTP, Beta, whatever). Well, anyway…

I introduce you to the Virtual Earth Silverlight Map Control SDK CTP!

Before I dig into what’s needed to begin development, and show you how simple it is to use; here’s a few highlights of what’s so Awesome about the control.

Why is the Virtual Earth Silverlight Map Control so Awesome?!?

Here’s a few reason:

Silverlight! – Silverlight itself is truly a high point with this new control. You can now Plot/Overlay Rich Media Content (Images, Video, and any Silverlight/XAML content you can think of!) over the Map!
Performance! – If you’ve used the Virtual Earth JavaScript Map Control, then you must be familiar with the fact that the Map really starts to slow down when you try to plot something around 300+ Pushpins or a hand full of Polygons with 1000+ points each. With the new Silverlight control you can literally plot THOUSANDS of Pushpins on the Map and you wont render it useless like you would with the previous JavaScript control. Your limit is really only based on the Client Computer that is running the application, and I expect that it’ll probably improve a bit with Silverlight 3’s ability to utilize the local GPU.
No More JavaScript or Browser Inconsistencies! – You no longer need to worry or hassle yourself with JavaScript and making sure it runs/works as expected in all the different web browsers (Internet Explorer, Firefox, Safari, etc.) No you can manipulate the map using pure .NET code. Don’t fret if you need to integrate with existing JavaScript code; you can always use Silverlight’s HTML Bridge to interact back and forth as needed.
Virtual Earth! – And, last but not least, we can not forget that part of the Vast Awesomeness of this control is just due to the fact that it’s Virtual Earth Mapping!!

What’s Needed to Get Started?

Firstly, Download the Virtual Earth Silverlight Map Control SDK CTP from Microsoft Connect: http://connect.microsoft.com/silverlightmapcontrolctp

Note: At the time of posting this (3/20/2009 6:26PM CST) the CTP Download is currently down. You can still go to the Microsoft Connect website and Register, then you’ll be able to download the bits when they’re back up. The download issue has been fixed.

There is also a Virtual Earth Silverlight Map Control CTP Interactive SDK (in the same style of the Virtual Earth JavaScript control) here: https://sharepoint.connect.microsoft.com/silverlightmapcontrolctp/iSDK/default.htm

Secondly, you’ll need a couple Tools installed first:

Of course you’ll also need to at least be familiar with the basics of Silverlight development. I’m referring to XAML for the most part, so if your familiar with WPF that should be enough to get you started.

For those Virtual Earth developers new to Silverlight; If you need help getting started with learning the basics of Silverlight development, here are some resources that will help:

Let’s Display a Map in Silverlight

Create a New Silverlight Application Project

Run Visual Studio 2008 and create a New Project using the Silverlight Application template.
In the “Add Silverlight Application” dialog box, select the “Add a new ASP.NET Web project to the solution to host Silverlight” option and click “OK”. You must select this option to create an ASP.NET Web Application Project or ASP.NET Website because the URL Access Restrictions in Silverlight require the page that hosts the Map control to be hosted using HTTP in order to load/access the Virtual Earth Map Tiles.

Add a Reference to Microsoft.VirtualEarth.MapControl.dll

Go to the “Solution Explorer” and Right-Click “References” in the Silverlight Project (not the ASP.NET Web Application Project), and Select “Add Reference…”
Within the “Add Reference” Dialog, Select the “Browse” tab and navigate to the folder where the SDK is installed, and select the “Microsoft.VirtualEarth.MapControl.dll”.

Note: By Default the SDK is installed in this folder “C:\Program Files (x86)\Microsoft Virtual Earth Silverlight Map Control\CTP\Libraries”

Display a Virtual Earth Map

Add a Namespace declaration to to Page.xaml for the Microsoft.VirtualEarth.MapControl namespace.
To do this add the following to the <UserControl> tag:
xmlns:m="clr-namespace:Microsoft.VirtualEarth.MapControl;assembly=Microsoft.VirtualEarth.MapControl"
Add the Map Control to Page by adding the following tag within the Grid in the Page:
<m:Map></m:Map>

The resulting Page.xaml will look like this:

Now, when you run the application (press F5) you will see a fully interactive Virtual Earth Map displayed:

Change/Set Map Properties Declaratively using XAML and Programatically using C#

You can change/set the Map Control’s properties Declaratively using XAML and Programatically using C# (or any other .NET language).

Below are examples using XAML and C#.

XAML: You can change the Map Mode declaratively using XAML by just setting the “Mode” property. For Example, setting it to “Aerial” will change the Map Mode to AerialMapMode.

C#: You can also change the Map Mode just as easily programatically using C#. Here’s the same example of setting the Map Mode to AerialMapMode within the Page constructor:

using System.Windows.Controls;
using Microsoft.VirtualEarth.MapControl;

namespace VirtualEarthSilverlightApplication1
{
    public partial class Page : UserControl
    {
        public Page()
        {
            InitializeComponent();

            Map1.Mode = new AerialMode();
        }
    }
}

First, in order to access the Map Control programatically you’ll need to set it’s “Name” property within XAML; like the following:

Conclusion

I hope your as psyched about the new Virtual Earth Silverlight control as I am. I’m really looking forward to exploring all the capabilities of the new control; most of which just weren’t possible with the old JavaScript control. One downside is we’ll have to wait until a future release for a “Go Live” license, but until then I’m sure the guys on the Virtual Earth team will be making this control the absolute best it can be; after all it’s pretty darn awesome already.

Keep an eye out, I’ll be posting more articles/tutorials to help you out in exploring this new control.

Next Tutorial/Article: Basics of Adding Polygons and Polylines using XAML and Code

Virtual Earth Silverlight Control CTP Teaser and Some Initial Thoughts

crpietschmann — Thu, 19 Mar 2009 18:12:21 -0500

Yesterday, the Virtual Earth Silverlight Control CTP (Community Technology Preview) was announced at MIX’09. I was also fortunate to get early access to the CTP, so I’ve been playing with it for a few days. I can’t show you any code yet (until it’s released publicly), but I can tell you a little about it for now. Once it’s released I’ll be posting some articles that range from Basic How-To to Implementing Some Cool Stuff; but you’ll have to wait a little bit for those.

For now, here’s a little info…

Combining the power of Silverlight and Virtual Earth Mapping makes for a pretty awesome combination. You can now build all the cool stuff you wanted to build with the JavaScript Map Control, Plus TONS More!

Here’s a couple key feature points:

Cross-Platform Support. No more hacky JavaScript to write; unless of course you want to use the Silverlight HTML Bridge to interface with existing JavaScript code (think about how you could upgrade existing mapping web applications with this).
Ability to Plot ANY Rich Content on the Map. Including Videos or any other Custom Controls.
Increased Performance! Since the control uses Silverlight it takes full advantage of the performance benefits that Silverlight has to offer. Remember how slow the JavaScript Map Control can become?
Map wraps across the International Date Line. This is an issue with the JavaScript Map Control, since it doesn’t allow you to plot Polygons or Polylines that span across the International Date Line. This is no longer an issue with the Silverlight Map Control.

Here’s a couple screenshots of the Map in action:

The first one shows a Polygon, Polyline and a Video plotted on the Map.

The second one shows a Tooltip being displayed from the mouse hovering over a Polygon.

Not a final release, and the JavaScript Map Control does offer some features that the Silverlight control does not:

For example, the Silverlight control does not have Birdseye or 3D map modes. They haven’t mentioned when/if the Silverlight control may have these, but I’m hoping they do make it into the control before RTW to keep it on par with the existing JavaScript Control.

Also keep in mind that this is just a CTP (Community Technology Preview); which means: 1) You can NOT use it in Production, and 2) The next release (CTP, Beta, Whatever) may contain (and probably will) breaking changes. So, if you’re looking for a Silverlight Map Control you can roll into Production Today, then you’ll want to check out the DeepEarth Project.

Keep an eye out for my tutorials as I release them, starting tomorrow as soon as the CTP is Released To Web (RTW).

Windows 7 Beta: Change the Logon UI Background Image

crpietschmann — Mon, 16 Mar 2009 19:03:00 -0500

Apparently, Windows 7 will "officially" support Logon UI Background Customization. The previous link describes what needs to be in place (a registry key and image file) for you to be able to have Windows 7 use any image you want as the Logon UI Background. What the previous link doesn't specify is if this works with the Windows 7 Beta (build 7000). Actually, I just test and confirmed that it does work perfectly in the Windows 7 Beta. Good news for us of whom can't (or don't want to) run a newer (possibly more buggy), "leaked" build of Windows 7.

I'll describe the 2 basic steps needed to do this with the Windows 7 Beta, but to get more detail I recommend reading the article linked above.

Step 1: Add the Following Registry Key

Go to the "HKLM\Software\Microsoft\Windows\CurrentVersion\Authentication\LogonUI\Background" Registry location using Regedit.exe and add a DWORD value named "OEMBackground" and set it's value to 1 (enabled).

Step 2: Add an Image (JPG) file to be used

Add any image file you want to the "%windir%\system32\oobe\info\backgrounds" folder, and rename it to "backgroundDefault.jpg". Also, you'll want to make sure the image file is less than 256Kb in size. If the file size is bigger it wont use it.

And, it's that simple to set the Windows 7 Beta to use your own background image for the Logon UI.

Virtual Earth: Modify the Opacity of an Existing Custom Tile Layer

crpietschmann — Fri, 13 Mar 2009 19:27:00 -0500

One of the features that the Custom Tile Layer functionality of the Virtual Earth JavaScript control is the ability to modify the Tile Layers Opacity after it's been added to the Map. It does include HideTileLayer and ShowTileLayer methods to dynamically toggle the display of Custom Tile Layers, but sometimes that's just not enough customization. However, I do have some good news, there is a small technique that you can use to modify the Tile Layer Opacity as necessary.

How to Change Custom Tile Layer Opacity

To change the Opacity of a Custom Tile Layer you basically need to Delete and then Re-Add the Custom Tile Layer. However, the technique shown below gets the existing Tile Layer by ID, changes it's Opacity value only, then deletes and re-adds it.

Here's the main javascript method that does the work for you:

function SetTileLayerOpacity(tileLayerID, newOpacity) {
    // Get TileLayer
    var layer = map.GetTileLayerByID(tileLayerID);

    // Set new Opacity Value
    layer.Opacity = newOpacity;

    // Delete Existing TileLayer from Map
    map.DeleteTileLayer(tileLayerID);

    // Re-Add the TileLayer with new Opacity
    map.AddTileLayer(layer);
}

And, here's the simple code needed to change a Custom Tile Layer's Opacity as needed:

SetTileLayerOpacity("tilerLayerID", 0.5);

Complete Code Example

Here's a full example page that implements the javascript method above. To build this example I actually copied the "Add a tile layer" example from the Virtual Earth Interactive SDK and added the SetTileLayerOpacity methed/functionality to it.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
      <title></title>
      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
      <script type="text/javascript" src="http://dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=6.2"></script>
      <script type="text/javascript">
        var map = null;
        var tileLayer;

        function GetMap()
        {
            map = new VEMap('myMap');
            map.LoadMap(new VELatLong(48.03,-122.4),12,'r' ,false);
            GetTiles();
        }

        function GetTiles()
        {
            var bounds = [new VELatLongRectangle(new VELatLong(49,-123),new VELatLong(47,-121))];

            var tileSourceSpec = new VETileSourceSpecification("lidar", "http://dev.live.com/virtualearth/sdk/layers/lidar/%4.png");
            tileSourceSpec.NumServers = 1;
            tileSourceSpec.Bounds = bounds;
            tileSourceSpec.MinZoomLevel = 10;
            tileSourceSpec.MaxZoomLevel = 18;
            tileSourceSpec.Opacity = 0.5; //opacity;
            tileSourceSpec.ZIndex = 100;

            map.AddTileLayer(tileSourceSpec, true);
        }

        function DeleteTileLayer()
        {
            map.DeleteTileLayer("lidar");
        }

        function SetTileLayerOpacity(tileLayerID, newOpacity) {
            // Get TileLayer
            var layer = map.GetTileLayerByID(tileLayerID);

            // Set new Opacity Value
            layer.Opacity = newOpacity;

            // Delete Existing TileLayer from Map
            map.DeleteTileLayer(tileLayerID);

            // Re-Add the TileLayer with new Opacity
            map.AddTileLayer(layer);
        }
      </script>
   </head>
   <body onload="GetMap();">
      <div id='myMap' style="position:relative; width:400px; height:400px;"></div>
      <a href="#" onclick="SetTileLayerOpacity('lidar', 0.5);">Set Opacity to 0.5</a><br />
      <a href="#" onclick="SetTileLayerOpacity('lidar', 1.0);">Set Opacity to 1.0</a><br />
      <hr />
      <a href="#" onclick="DeleteTileLayer();">Remove the tile layer</a>
   </body>
</html>

Cheap PC 2009 - Custom Built PC under $500 that includes Windows Vista Home Premium

crpietschmann — Fri, 13 Mar 2009 13:15:00 -0500

Two years ago I posted "Cheap PC - Build a Vista Premium Ready system for under $500 including the OS". I can't believe that was two years ago already! Anyway, the original premise of the post was to point out that you could build a "cheap" PC for under $500 that included and could run Windows Vista with "Aero" Glass Enabled. After I wrote that post I decided that I would try to remember to write a post like that every year to serve two purposes: 1) chronicle what kind of PC $500 can buy you, and 2) to help other people realize that it's possible to build a custom pc for cheap that isn't total crap. Well, it seems I skipped a year, so here's the "Cheap PC 2009" post.

One thing I decided to change from the previous post is I'm going to factor the shipping into the total price. So basically when "all said and done" the overall total price you'll pay for what I list will be No More Than $500 (US).

Total Cost: $491.48 (this includes shipping)

Now for the parts breakout:

Motherboard - $49.99 - ASUS P5N73-AM LGA775 with Integrated GeForce 7050 Graphics

Processor (CPU) - $119.99 - Intel Core 2 Duo E7400 Wolfdale 2.8Ghz 65W Dual-Core

Memory (RAM) - $39.99 - G.SKILL 4GB (2 x 2GB) F2-6400CL5D-4GBBPQ DDR2 800 (PC2 6400) Dual Channel Memory

Hard Drive - $49.99 - Western Digital Caviar SE 320GB SATA 3.0Gb/s WD3200AAJS

Optical Drive - $24.99 - LG 22X DVD±R Burner SATA Model GH22NS30

Case - $26.99 - Rosewill R222-P-BK Black Steel ATX Mid Tower Case

Power Supply - $49.99 - Rosewill RP500 500W ATX Power Supply

Operating System - $99.99 - Windows Vista Home Premium SP1 64-bit OEM

A couple things to note:

There are a couple things I want to note about the parts I spec'd out above, and I want to explain my reasoning a little bit.

One thing I did differently this time is I spec'd out the Case and Power Supply seperately. The reason for this is when you buy a cheap case, most times you'll get an even cheaper power supply included that is essentially not the most reliable. I have actually gotten bitten in the past by the super cheap power supply that came with my case burning out and having to buy a new one. On the other hand I have had super cheap power supplies that have lasted for years. It's better to be on the safe side and buy a power supply seperately to make sure you get a much better one that'll last; at least it should last.
To save on cost a little I only spec'd a 320GB hard drive. To many that may seem a little small, but it is on par with the likes of Dell and others.
The amount of Ram that I've spec'd (4GB) is actually twice that of what I've seen comparable systems from Dell come with. From my experiences 4GB of Ram is pretty much the sweet spot for Windows Vista where it performs the best and you still have plenty of Ram for the things you want to do.
Integrated Graphics Really? I chose a motherboard in this spec that has integrated GeForce 7050 Graphics. The reason for this is because it makes the build cheaper, and the GeForce 7050 does support DirectX 9. Plus, the motherboard does have a PCI-Express 2.0 x16 expansion slot, so you'll be able to upgrade to a better dedicated graphics card at some future point if you want.

Also, this "system" Will run Windows 7 perfectly. The reason I know this is because it'll run Vista perfectly, and Windows 7 will (when it comes out) require less Processor Power and Memory to run the operating system; at least the Beta currently does!

Upgrading Notes

If you are thinking of upgrading an existing system (rather than build a completely new one), remember if your system is only a few years old you may be able to save some money by only upgrading the parts that need it.

Here's an upgrade scenario:

"I bought a "pre-built" system from the store a couple few years ago. It only has a single-core processor, 1GB of Ram and is running Windows XP. My hard drive space is sufficient and the DVD drive in it works fine."

In this case, you really only need to upgrade the Motherboard, Processor (CPU) and RAM. You'll be able to reuse all your other hardware (Hard Drives, CD/DVD Drives, Case and Power Supply).

One thing you'll really need to make sure of first, though, is that the case is a standard ATX (Mid or Full) case. From my experience most are, but some aren't. If it isn't a standard ATX case, then you'll need to buy a new Power Supply and Case for your new system.

Also, if the case is a standard ATX case, then you'll also need to verify that the power supply is sufficient. Generally with the system I've spec'd above, you'll want at least a 400 Watt (W) power supply; the bigger the better. In the spec'd system above I have a 500W power supply liste, this is because you may need more power if you add more hard drives or even if you use this system as the basis for a future upgrade.

Happy System Building!

Live Framework: Connecting to the Local Live Operating Environment (LOE) for Offline Applications

crpietschmann — Sat, 07 Mar 2009 20:28:00 -0500

One of the things the Live Framework has to offer is a Local Live Operating Environment you can connect to so that you can Offline Enable your Live Framework Enabled Desktop Applications. I found the process of getting it to work a little tricky (especially since I was running Win7 Beta; I'll explain down further) so I've decided to write up a summary of my experience to help anyone else interested.

This was written using the Live Framework CTP.

Connecting to the Live Operating Environment

The "Live Operating Environment" is the main service that is hosted in the cloud by Microsoft. To connect to it and use it you are required to be connected to the Internet.

Basically to connect to the Live Operating Environment you need to prompt the user for their Windows Live ID and Password. Below is a very simple example of what is needed to create an instance of the LiveOperatingEnvironment object in C# and connect to the Live Operating Environment server.

var credentials = new System.Net.NetworkCredentials(windowsLiveID, password);

var LOE = new LiveOperatingEnvironment();

LOE.Connect(credentials);

I you haven't really looked in to how this works, you can look at the ConnectCloud method of the Login.xaml.cs file of the Project Manager sample code within the Live Framework CTP SDK.

Connecting to the Local Live Operating Environment

Now, to connect to the Local Live Operating Environment instead, you basically just call the LiveOperatingEnvironment.ConnectLocal() method instead of the Connect() method shown above. Also, another big difference is you don't need to prompt the user for their Windows Live ID and Password, since the Local Live Operating Environment handles all the authentication for you.

var LOE = new LiveOperatingEnvironment();

LOE.ConnectLocal();

This also has the benefit of only requiring the user to type in their Windows Live ID and Password once when they login with the Live Framework Client; which can actually save their password and auto log them in when they login to Windows.

Mesh Client or Live Framework Client? What's the difference?

When you go to http://mesh.com, login, and click "Add Device" so you can Sync files with Mesh Folders, it has you install the Mesh Client. This install does not contain the Local Live Operating Environment you need when programming against the Live Framework SDK.

When you go to http://developer.mesh-ctp.com, login, and click "Add Device" so you can Sync files with the "dev" version of Mesh, it has you install the Live Framework Client. This is in fact the install you want that contains the Local Live Operating Environment.

Beware the Mesh Client and Live Framework Client don't play well together

Actually, the latest update (April CTP) to the Live Framework Client does install and work correctly along-side the Mesh Client.AND, it now works on the Windows 7 Beta.

There is a known issue of running the Live Framework Client and Mesh Client on the same machine; they simply don't work as installed out of the box. You need to perform a little registry edit to fix the issue. It sounds bad, but it is actually quite painless.

~~Here's instructions on how to get the Mesh Client and Live Framework Client to run Side By Side:~~

~~Uninstall Live Framework Client.~~
~~Install Mesh Client Beta from http://mesh.com~~
~~Add the following registry item: HKCU\Software\Microsoft\Live Framework Client\AllowSxS = 1 (DWORD)~~
~~Install Live Framework Client from http://developer.mesh-ctp.com~~

~~The original posting of these instructions and a little more detail about them can be found here:~~

~~http://social.msdn.microsoft.com/Forums/en-US/liveframework/thread/2fa9d3f1-029e-44af-9568-1cea81ca78a9/~~

Current Live Framework Client does not work on the Windows 7 Beta

One thing to note before you start trying to develop against the Local Live Operating Environment is it does NOT run correctly on the Windows 7 Beta. In order to develop for it and use it you'll need to install it on Windows Vista (or presumably Windows XP).

I've jumped on the "Anti-IE6" band wagon

crpietschmann — Tue, 24 Feb 2009 22:18:00 -0500

There have been a lot of talk online for a while now about the much desired demise of Internet Explorer 6, and other out dated web browsers. I don't think I've used IE6 since the first Beta of IE7, and I haven't used Firefox 2.0 since Firefox 3.0 was released. However, I can see that there are still a few users that visit this blog of whom are still using some of these OLD versions of these web browsers. So, I am joining the effort to "Push up the web" by including the script found at http://www.pushuptheweb.com in my website to kindly remind any visitor using an out dated web browser that they may want to update.

The first Anti-IE6 campaign website I was directed to was http://iedeathmarch.org where they point out the fact that there are a ton of things younger than IE6 (which was released August 27th 2001.)

For example, these things are ALL Younger than IE6:

Google Adsense
Friendster
iPod
Original XBox
Halo
Nintendo Gamecube
Hummer H2
Windows XP
Internet Explorer 5 for Mac OS
Canon Digital SLR Cameras

We've actually seen a ton of stuff happen since IE6 was released. IE6 has been around longer than the 6+ years the U.S. has had troops in Iraq. IE6 has been around longer than the 7+ years it's been since the 9/11 attacks.

Now, why are people still using these old browsers? Why haven't they updated to the latest, safest, most secure versions? Well, regardless the reason, it's about time.

.NET Framework: Communicate through NAT Router via UPnP (Universal Plug and Play)

crpietschmann — Thu, 05 Feb 2009 19:27:00 -0500

I've been working on an application recently that needs to be able to communicate through a router/firewall using TCP. I've read/heard a bit of information about NAT Routers and UPnP; the technoligies used in almost every router sold commercially. So, I knew that you could use the Universal Plug and Play (UPnP) features of the NAT Router to automatically open up the firewall via Port Forwarding to allow other computers on the Internet to connect directly to the one your application is running on. One thing I didn't know what that Windows (since Windows XP) has the NATUPnP 1.0 Type Library (NATUPNP.DLL) COM Component that you can utilize within your applications to do this for you.

I haven't found very many articles online (via Google search) on using the NATUPnP 1.0 Type Library; there's pretty much only small code snippets available. So, I've decided to explain a little further, in this article, the What and Why of communicating through a NAT Router utilizing UPnP.

What is NAT (Network Address Translation)?

Network Address Translation is the method employed by a Network Router (and Wireless Routers) that allows you to have multiple computers connected to the internet using your home/work broadband internet connection. Your Router gets assigned an Internet IP Address by your Internet Service Provider, and then the Router assigns a Private IP Address to each computer on your network. The Router then "routes" Incoming and Outgoing network traffic from the Internet to the appropriate computer on your Private Network. This technique is also known as "IP masquerading", since it hides your entire Private Network from the Internet making it appear as if it were only a single computer connected to the Internet.

One of the biggest side effets of NAT is that it essentially turns your Router into a Firewall. This is because when any unsolicited incoming traffic gets sent you the Router, it has no idea which computer on the Private Network might be the intended recipient. So, consiquentially, it just ignores or blocks the unsolicited incoming traffic. This is also the feature that allows you to safely enable File and Printer Sharing between the computers on the Private Network without the risk of any computer/server on the Internet being able to copy your files.

Also worth noting that NAT can be implemented by other devices than a Network Router, such as: a computer running Windows with Internet Connection Sharing and Windows Firewall, or a computer running software that provides NAT.

You can read more about NAT at the following links:

http://en.wikipedia.org/wiki/Network_address_translation

http://en.wikipedia.org/wiki/NAT_traversal

What is Port Forwarding / Static NAT?

Port Forwarding, also called "Static NAT", allows computers on the Internet to connect directly to a specific computer on your Private Network. This works by configuring your NAT Router to forward any incoming traffic on a specific Port to a specific computer on your network. For example you can run a Web Server by setting the NAT Router to forward all incoming traffic on Port 80 to your Web Server on your Private Network.

You can read more aboug Port Forwarding at the following link:

http://en.wikipedia.org/wiki/Port_forwarding

What is Universal Plug and Play (UPnP)?

Universal Plug and Play (UPnP) is a simple communications mechanism that allows computers and network appliances to auto-configure Port Forwarding on a NAT Router. This greatly simplifies the setup of P2P networks such that the user doesn't need to configure the NAT Router, instead the computer can connect directly to the Router and setup the appropriate Port Forwarding to allow it to accept direct connections from external computers on the Internet.

This is essentially the technology that allows Peer-to-Peer Software (like Bit Torrent) to communicate through a NAT Router (Firewall) and connect directly to other computers across the Internet. There is also alot of Software and Devices that rely on this to function, such as Windows Live Messenger and XBox 360.

You can read more about UPnP at the following link:

http://en.wikipedia.org/wiki/Universal_Plug_and_Play

Other Resources on Network Address Translation (NAT)

Including the above links there are many articles online that discuss in further detail what NAT and UPnP is. One resource that I really recommend is Episode #42 of the Security Now Podcast with Steve Gibson. If you prefer not to listen to the podcast, there is also a full transcript available for you to read. I really encourage you to read or listen to this.

Security Now! #42 - NAT Traversal

Using the NATUPnP 1.0 Type Library to Setup Port Forwarding

The NATUPnP 1.0 Type Library (NATUPNP.DLL) COM Component, which is part of Windows (since Windows XP), makes it possible to easily manage Network Address Translation (NAT) through Universal Plug and Play (UPnP). This library provides the ability to configure port mappings on a remote Gateway Device (IGD) that uses NAT. It is worth mentioning that the remote Gateway Device could be another computer running Windows with Internet Connection Sharing and Windows Firewall, or a dedicated hardware device.

The API Reference for the NATUPnP 1.0 Type Library can be found here: http://msdn.microsoft.com/en-us/library/aa366276(VS.85).aspx

In order to use the NATUPnP Library you need to first add a reference to it to your project within Visual Studio. To do so open the Add Reference dialog, click the COM tab and select the "NATUPnP 1.0 Type Library". The resulting reference that's added will be named "NATUPNPLib" and will be the namespace that contains all the functionality contained within the library (all Interfaces and Classes).

The NATUPnP 1.0 Type Library makes it so easy to setup Port Forwarding it literally only requires a couple lines of code.

Get a listing of all existing Static Port Mappings

To get a list of all the Static Port Mappings that are already setup in your NAT enabled Internet Gateway Device (such as Router) you simply create an instance of the UPnPNATClass object and access its StaticPortMappingCollection property.

NATUPNPLib.UPnPNATClass upnpnat = new NATUPNPLib.UPnPNATClass();
NATUPNPLib.IStaticPortMappingCollection mappings = upnpnat.StaticPortMappingCollection;

Once you get the collection of existing port mapping, you can iterate through them just as you would any normal Collection of objects:

foreach(NATUPNPLib.IStaticPortMapping portMapping in mappings)
{
// do something with the port mapping, such as displaying it in a listbox
}

Add New Static Port Mapping

To add a new Static Port Mapping you simply call the Add method of the IStaticPortMappingCollection object that is returned by the UPnPNATClass.StaticPortMappingCollection property.

// Here's an example of opening up TCP Port 80 to forward to a specific Computer on the Private Network
mappings.Add(80, "TCP", 80, "192.168.1.100", true, "Local Web Server");

// Here's an example of forwarding the UDP traffic of Internet Port 80 to Port 8080 on a Computer on the Private Network
mappings.Add(80, "UDP", 8080, "192.168.1.100", true, "Local Web Server");

Remove Existing Static Port Mapping

To remove an existing Static Port Mapping you simply call the Remove method of the IStaticPortMappingCollection object that is returned by the UPnPNATClass.StaticPortMappingCollection property.

// Remove TCP forwarding for Port 80
mappings.Remove(80, "TCP");

// Remove UDP forwarding for Port 8080
mappings.Remove(8080, "UDP");

Example Port Forwarding Management Application

While working with the NATUPnP 1.0 Type Library I created a simple application that allows you to maintain the Static Port Mappings that are setup on your Private Networks NAT Router.

Download Sample: NATUPnPPortForwardManager.zip (20.68 kb)

Conclusion

Setup up Port Forwarding on your local router via UPnP makes it extremely convenient for users of your networking application. Instead of requiring them to manually setup Port Forwarding, we can automatically set it up for them. Many popular P2P applications have utilized this functionality for years, and I'm positive you've used at least one of these applications already at some point.

Using LINQ to SQL with SQL Server Compact Edition

crpietschmann — Fri, 30 Jan 2009 20:31:00 -0500

I'm currently building a desktop application that needs to store a bunch of data on the users computer, so I've decided to use SQL Server Compact 3.5 for this. There's only one problem, Visual Studio 2008 doesn't support using LINQ to SQL with SQL Server Compact. However, the .NET Framework does and there's a work around to get it working in VS'08 that I'll describe below.

In case you aren't aware of what SQL Server Compact 3.5 is, here's the short description that Microsoft gives on their website: "Microsoft SQL Server Compact is a free SQL Server embedded database ideal for building standalone and occasionally connected applications for mobile devices, desktops, and Web clients." You can download it and view more information here: http://www.microsoft.com/Sqlserver/2008/en/us/compact.aspx

Steps to create a LINQ to SQL application using SQL Server Compact

To make this easy to follow I'm going to start with Creating a Solution in Visual Studio and go through all the steps needed to get it running off of SQL Server Compact.

Also, you'll first want to make sure you have SQL Server Compact 3.5 installed. It may have been installed when Visual Studio 2008 installed; I'm not sure which editions install SQL Server Compact 3.5, when I installed Visual Studio 2008 Team Suite it did install SQL Server Compact 3.5 too. If you need to install it, you can find the installer here: http://www.microsoft.com/Sqlserver/2005/en/us/compact-downloads.aspx

Step 1: Create your new project within Visual Studio

It doesn't matter if it's a Windows Forms or WPF applciation. For this example, I'll be creating a WPF application.

Step 2: Create your SQL Server Compact database. For Example: MyDatabase.sdf

You can do this by right-clicking on your Solution within the Solution Explorer and selecting "Add - New Item..." then select the "Data" category on the left and "Local Database" on the right.

Step 3: Add some Tables to the Database

You can do this within Visual Studio 2008 using the "Server Explorer". The easiest way to open up the Database within the Server Explorer is to just double click it withinthe Solution Explorer.

Also, in this example I'm just going to create a "Person" table with ID, FirstName and LastName columns.

Step 4: Create a .dbml descriptor file for the Database

To do this you need to use the SqlMetal.exe tool. Just type the following into the Visual Studio 2008 Command Prompt:

SqlMetal.exe MyDatabase.sdf /dbml:MyDatabase.dbml

By default, the SqlMetal.exe is located at drive:\Progream Files\Microsoft SDKs\Windows\vn.nn\bin.

Step 5: Add the Existing .dbml file to your project

Once you add the .dbml file, Visual Studio 2008 will automatically generate the .NET code (C# or VB.NET) for the System.Data.Linq.DataContext class that you'll use to access your data.

Step 6: Start Coding away using LINQ to SQL!

You can now code using LINQ and your new System.Data.Linq.DataContext class against your database.

A GUI UI for SqlMetal.exe

The SQL Metal Open Source User Interface Project over on CodePlex has been built just for the purpose of making it easier to generate mapping files for SQL Server Compact databases.

You can download it here: http://www.codeplex.com/sqlmetalosui

C#: Flash Window in Taskbar via Win32 FlashWindowEx

crpietschmann — Mon, 26 Jan 2009 23:19:00 -0500

The Windows API (Win32) has the FlashWindowEx method within the User32 library; this method allows you (the developer) to Flash a Window, signifying to the user that some major event occurred within the application that requires their attention. The most common use of this is to flash the window until the user returns focus to the application. However, you can also flash the window a specified number of times, or just keep flashing it until you decide when to stop.

The use of the FlashWindowEx method however isn't built into the .NET Framework anywhere. In order to access it you need to use the Platform Invoke (PInvoke) features of .NET to "drop" down to the Windows API (Win32) and call it directly. Also, as with many other functionalities in the Windows API (that aren't directly exposed by .NET) the FlashWindowEx method can be a little tricky to use if you aren't familiar with working with the Windows API from within .NET.

Now rather than go too deep into the specifics of PInvoke or the Win32 FlashWindowEx method, below is a simple static class in C# that allows you to easily utilize this method. There is actually quite a bit of information needed to explain how to use PInvoke to utilize the Windows API (Win32), so maybe I'll cover that in a future article.

Here's some example usage of this static class:

// One this to note with this example usage code, is the "this" keyword is referring to
// the current System.Windows.Forms.Form.

// Flash window until it recieves focus
FlashWindow.Flash(this);

// Flash window 5 times
FlashWindow.Flash(this, 5);

// Start Flashing "Indefinately"
FlashWindow.Start(this);

// Stop the "Indefinate" Flashing
FlashWindow.Stop(this);

One thing to note about the FlashWindowEx method is that it requires (and will only work on) Windows 2000 or later.

Here's the code for the static class in C#:

public static class FlashWindow
{
    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool FlashWindowEx(ref FLASHWINFO pwfi);

    [StructLayout(LayoutKind.Sequential)]
    private struct FLASHWINFO
    {
        /// <summary>
        /// The size of the structure in bytes.
        /// </summary>
        public uint cbSize;
        /// <summary>
        /// A Handle to the Window to be Flashed. The window can be either opened or minimized.
        /// </summary>
        public IntPtr hwnd;
        /// <summary>
        /// The Flash Status.
        /// </summary>
        public uint dwFlags;
        /// <summary>
        /// The number of times to Flash the window.
        /// </summary>
        public uint uCount;
        /// <summary>
        /// The rate at which the Window is to be flashed, in milliseconds. If Zero, the function uses the default cursor blink rate.
        /// </summary>
        public uint dwTimeout;
    }

    /// <summary>
    /// Stop flashing. The system restores the window to its original stae.
    /// </summary>
    public const uint FLASHW_STOP = 0;

    /// <summary>
    /// Flash the window caption.
    /// </summary>
    public const uint FLASHW_CAPTION = 1;

    /// <summary>
    /// Flash the taskbar button.
    /// </summary>
    public const uint FLASHW_TRAY = 2;

    /// <summary>
    /// Flash both the window caption and taskbar button.
    /// This is equivalent to setting the FLASHW_CAPTION | FLASHW_TRAY flags.
    /// </summary>
    public const uint FLASHW_ALL = 3;

    /// <summary>
    /// Flash continuously, until the FLASHW_STOP flag is set.
    /// </summary>
    public const uint FLASHW_TIMER = 4;

    /// <summary>
    /// Flash continuously until the window comes to the foreground.
    /// </summary>
    public const uint FLASHW_TIMERNOFG = 12;

    /// <summary>
    /// Flash the spacified Window (Form) until it recieves focus.
    /// </summary>
    /// <param name="form">The Form (Window) to Flash.</param>
    /// <returns></returns>
    public static bool Flash(System.Windows.Forms.Form form)
    {
        // Make sure we're running under Windows 2000 or later
        if (Win2000OrLater)
        {
            FLASHWINFO fi = Create_FLASHWINFO(form.Handle, FLASHW_ALL | FLASHW_TIMERNOFG, uint.MaxValue, 0);
            return FlashWindowEx(ref fi);
        }
        return false;
    }

    private static FLASHWINFO Create_FLASHWINFO(IntPtr handle, uint flags, uint count, uint timeout)
    {
        FLASHWINFO fi = new FLASHWINFO();
        fi.cbSize = Convert.ToUInt32(Marshal.SizeOf(fi));
        fi.hwnd = handle;
        fi.dwFlags = flags;
        fi.uCount = count;
        fi.dwTimeout = timeout;
        return fi;
    }

    /// <summary>
    /// Flash the specified Window (form) for the specified number of times
    /// </summary>
    /// <param name="form">The Form (Window) to Flash.</param>
    /// <param name="count">The number of times to Flash.</param>
    /// <returns></returns>
    public static bool Flash(System.Windows.Forms.Form form, uint count)
    {
        if (Win2000OrLater)
        {
            FLASHWINFO fi = Create_FLASHWINFO(form.Handle, FLASHW_ALL, count, 0);
            return FlashWindowEx(ref fi);
        }
        return false;
    }

    /// <summary>
    /// Start Flashing the specified Window (form)
    /// </summary>
    /// <param name="form">The Form (Window) to Flash.</param>
    /// <returns></returns>
    public static bool Start(System.Windows.Forms.Form form)
    {
        if (Win2000OrLater)
        {
            FLASHWINFO fi = Create_FLASHWINFO(form.Handle, FLASHW_ALL, uint.MaxValue, 0);
            return FlashWindowEx(ref fi);
        }
        return false;
    }

    /// <summary>
    /// Stop Flashing the specified Window (form)
    /// </summary>
    /// <param name="form"></param>
    /// <returns></returns>
    public static bool Stop(System.Windows.Forms.Form form)
    {
        if (Win2000OrLater)
        {
            FLASHWINFO fi = Create_FLASHWINFO(form.Handle, FLASHW_STOP, uint.MaxValue, 0);
            return FlashWindowEx(ref fi);
        }
        return false;
    }

    /// <summary>
    /// A boolean value indicating whether the application is running on Windows 2000 or later.
    /// </summary>
    private static bool Win2000OrLater
    {
        get { return System.Environment.OSVersion.Version.Major >= 5; }
    }
}

VEToolkit - Virtual Earth Toolkit v6.2.012509.1053 Released!

crpietschmann — Sun, 25 Jan 2009 11:56:00 -0500

This is the first official release of the Virtual Earth Toolkit. The toolkit is by no means complete, but this is a "stable" collection of the Controls, Extenders and Methods that have been implemented thus far.

Project: http://codeplex.com/VEToolkit

Download the Release: http://www.codeplex.com/VEToolkit/Release/ProjectReleases.aspx

What is the Virtual Earth Toolkit?

The Virtual Earth Toolkit is a set of JavaScript-based Controls/Tools that Extend Virtual Earth with functionality that is commonly implemented, but hasn't been implemented within the Virtual Earth JavaScript Map Control.

The Controls/Tools in the VEToolkit library are completely self contained, and don't require the use of any other JavaScript library to use other than Virtual Earth 6.2 (current version). This allows you to use this toolkit along-side any other JavaScript library (jQuery, ASP.NET AJAX, etc.); plus you can make use of it with any server-side framework of you choice (ASP.NET, ASP.NET MVC, PHP, etc.).

Features

Below is a summary of what's included in this release:

Controls
- VEToolkit.ShapeListControl
  - A simple control that displays a list of Shapes that are currently plotted on the VEMap.
Extenders
- VEToolkit.ContextMenuExtender
  - This extends the VEMap with Context Menu (right click menu) support.
- VEToolkit.DragShapeExtender
  - This extends the VEMap to allow the user to reposition Shapes by simply clicking and dragging them around the map. It also implements functionality that allows you (the programmer) to determine at runtime which Shapes are draggable.
- VEToolkit.MiniMapExtender
  - This extends the VEMap with better MiniMap support; allowing the MiniMap to easily be positioned and aligned into any side/corner of the VEMap display.
Helper Methods
- VEToolkit.LoadAPI
  - This methods allows you to easily load the Virtual Earth JavaScript API On-Demand at runtime.
- VEToolkit.Drawing.DrawCircle
  - This method returns a collection of VELatLong objects that represent a Circle with a given radius surrounding a specific VELatLong center point.
- VEToolkit.Math.CalculateBearing
  - This method calculates the bearing (in degrees) between two VELatLong coordinates. This can be used to calculate the direction an object is pointing or traveling.
- VEToolkit.Math.CalculateInverseCoordinate
  - This method calculates the Inverse VELatLong coordinate for a given VELatLong coordinate. (Or opposite position on the globe)
- VEToolkit.Math.CalculateMidPoint
  - This method calculates the Mid Point (Center Point) in between two VELatLong coordinates.
- VEToolkit.Math.GetPolygonCentroid
  - This method calculates the approximate Centroid (Center Point) of a Polygon.
- VEToolkit.Math.IsInPolygon
  - This method calculates whether a given VELatLong coordinate exists within a given Polygon made up of an Array/collection of VELatLong coordinates.

JavaScript Intellisense

The VEToolkit also includes full Visual Studio 2008 JavaScript Intellisense Support