Wot u do with .net : Programming

Taking your app forward to Win7

paulfo — Wed, 18 Nov 2009 15:09:07 GMT

If you are looking for a concise guide to the features you should consider for your application to shine on Windows 7 look here.

A simple list of the 7 things you could do to rejuvenate your applications and ensure they work will and correctly in the modern world of Windows 7.

Widget development in Windows Mobile 6.5

paulfo — Thu, 22 Oct 2009 08:42:39 GMT

I had two sessions to present at Over The Air 09. The first was all about the new Widget runtime included in Windows Mobile 6.5.

The runtime brings a Microsoft implementation of W3C Widget support to Windows Mobile for the first time. Our implementation is coupled with the launch of our very own mobile application Marketplace – this goes live with the launch of Windows Mobile 6.5 devices on the 6th Oct – allowing Widgets and native code applications (<10mb in size) to be sold directly to Windows Mobile 6 and upward devices.

If you are new to Widgets then here is a summary: The widget ideal is to be able to build mobile applications using web development skills – HTML, Script and AJAX. They are installed on the device and look like a native application with just enough device integration to use soft keys and device state.

So what is in our Widget implementation.

Firstly, we are using the Internet Explorer 6 HTML presentation engine (HTML Control). This is coupled with most of the IE8 script engine. These are brought together in the Widget runtime application called RIAHOST.EXE.

RIAHost adds other stuff, including shell support for devices with touch, soft keys and importantly the Widget object.

The Widget object allows the Widget programmer to reach beyond the Widget into the state of the device. Being able to determine things like signal and battery strength. If the widget is in focus or hidden. As well as many other things.

Widgets are brilliant but I immediately want to do more with my Widgets.

I think, for Widgets to be successful the developer must make them Smart Widgets. Rather than just using them as installed ‘web pages’ Widgets need to know when to start and when to stop doing stuff. The widget that continually calls a web service data update even when it is no longer ‘visible’ to the end user is going to drain the device battery and drive up the users data plan bill!

With the Widget object, we can get hold of when the device is in focus and when it is hidden – allowing us to start or stop doing stuff. We can also tell if the user is roaming or on their home network – a smart widget might do less data traffic when roaming, or at least remind the user of the potential cost while roaming.

Widgets can use a local data persistence. Each field stored can be up to 4000bytes. This allows Widgets to have another trick – the perceived performance trick. Performance exists into states – perceived performance is the performance the user sees on their device. Real performance is how practical it is to make a device really do something. They are two different things, with perceived performance being more important than real performance. A smart Widget developer will ensure the perceived performance of their widget is fast. They can do this by making only asynchronous web service calls and by using only stored state on startup – thus removing any ‘web update’ delay.

What I like even more about the Widget object is that it can be extended. This means over time as more W3C standard interfaces for device service (like geolocation for example) are delivered, then this functionality can be added to WM 6.5 devices. It also means that WM 6.5 devices are open for developers to innovate and deliver some leading edge solutions!

Let me give you a quick run down of how this works.

Are you a COM programmer? Probably not – so let me just tell you something. Windows has all manner of different levels of interoperability, applicable to many different technologies and skill sets. At the fundamental core of Windows is COM. If you can’t extend or subvert Windows functions by any other means you are 99% likely to be able to do it at the COM level.

The Widget object is implemented with support for the IDispatchEX COM interface. IDispatch is the typical COM automation interface. IDispatchEX – or EXpanded – allows a COM object’s IDispatch interface – which normally reports a static list of method calls – to be extended at runtime with more method calls.

In a nut shell, Widget has a base level of functionality, which by using the IDispatchEX functionality we can add more functionality too. Quite literally, your new object’s methods appear on the Widget object. For example, Widget.MyMethod().

How do you do this? Well because Widget has the IDispatchEX, all we have to do is implement a normal IDispatch on our component. This presents method and properties that can be called from our component and that will appear on Widget.

We have to create a CAB installation file for our component – Widgets aren’t allowed to have ActiveX components in their installation package. This does present an initial installation issue, but basically your Widget needs to test for the existence of the dependant component/s and if they aren’t there redirect the user to the CAB URL so that this can be installed on first use. There after, the component/s will be available to the Widget and any other Widgets that want them.

There is one more ‘special bit’. To tell Widget that our component is designed to extend it we have to set a registry key. This can be easily done by including the key definition in the CAB installation file for the component.

[HKEY_LOCAL_MACHINE\Software\Microsoft\Shell\Widgets\ObjectModels\<ObjectName>] "CLSID"="{GUID}“

Where GUID is the GUID of your component control implementation.

A small aside here. My device was running a near final but not final build of Windows Mobile 6.5. When I looked in the device registry to set this key I discovered my ObjectModels was actually BuiltinObjectModels. All the documentation I have seen says it is ObjectModels, but adding the above key to BuiltinObjectModels worked for me :-) Once it worked I didn’t go back to try doing it with a ObjectModels key – sorry pressures of work.

With that done, and the component installed, our Widget can take advantage of our new functionality using script like this:

Var myObj = widget.createObject(“ObjectName”);

myObj.MyMethod();

What might that new functionality be? Well it could be new W3C bits as they are defined. But what about that intellectual property of yours that you’d prefer not to implement in script for the world to easily see. Or many you just need some additional native code features to help exploit device capability.

Using this feature means you can achieve all sorts of exciting stuff with your Widgets – or in fact, your exciting stuff can become the basis for other peoples widgets too.

I’m currently exploring an Augmented Reality framework that could be implemented for Widgets to exploit. This needs some camera integration not available to the Widget script engine. A widget extension object might just be the way to go.

I’m posting my extended widget source code on the downloads section of this site. Please also see the session slides PDF for more detail and do take a look a the WindowsMobile team’s blog – Jorge is doing an awesome job filling in the detail on Widget development.

There are also some helpful projects on Codeplex which provide Widget packaging, emulation and project templates for VS2008 and Expression Web.

Making your app shine on Windows 7: Tabbed Thumb Nails

paulfo — Thu, 22 Oct 2009 08:38:05 GMT

This post is one in a series of posts covering the Windows API Code Pack. The code pack provides a managed code framework for using the new native Windows 7 features.

In this post we’ll examine how to implement thumbnail previews for a tabbed application UI. We’ll add to each thumbnail preview some buttons to control our application directly from the preview thumbnail. You need to be using .Net 3.5 SP1.

I used a simple C# Winforms project to test this all out. You’ll need to add five references:

WindowsBase

PresentationCore

PresentationFramework

Microsoft.WindowsAPICodePack

Microsoft.WindowsAPICodePack.Shell

The code pack framework provides Integration to the Windows 7 thumbnail preview via the TaskbarManager class. The class contains four methods and five properties. The methods mainly deal with the overlay of icons onto the taskbar icon and the progress bar overlay that I’m sure you are already familiar with in Windows 7.

The properties are the interesting bits for using thumbnail previews. The first property is a a boolean flag – IsPlatformSupported - to indicate if the current platform your app is running on can support thumbnails. Then you have Instance and ApplicationId. Instance represents the Windows Taskbar, and ApplicationId is the unique identifier for your application.

Then you have the two most useful properties; the TabbedThumbnail and ThumbnailToolbars. These get the manager class for each type allowing you to add and update the thumbnail previews associated with your application and the toolbars that may also exist for each of the previews for your application. Yes each preview could have a different toolbar for each tabbed thumbnail.

To add support to your application for thumbnail previews all you have to do is populate and maintain these two collections as necessary for your application. Because the code pack framework is provided as a static library doing this is very simple.

I have a tabcontrol in my Winforms app that allows me to add new tabs containing new instances of the WebBrowser control. In my add new tab button click event I run the following code:

Code Snippet
       TabPage newTab = new TabPage("Tab " + tabControl1.TabPages.Count + 1); 
tabControl1.TabPages.Add(newTab); 
WebBrowser wb = new WebBrowser(); 
wb.DocumentTitleChanged += new EventHandler(wb_DocumentTitleChanged); 
wb.DocumentCompleted += new WebBrowserDocumentCompletedEventHandler(wb_DocumentCompleted); 
wb.Navigated += new WebBrowserNavigatedEventHandler(wb_Navigated); 
wb.Dock = DockStyle.Fill; 
wb.Navigate(textBox1.Text); 
newTab.Controls.Add(wb); 
  
// Add thumbnail toolbar buttons 
TaskbarManager.Instance.ThumbnailToolbars.AddButtons(newTab.Handle, thumbButtonBack, thumbButtonForward, thumbButtonRefresh); 
  
// Add a new preview 
TabbedThumbnail preview = new TabbedThumbnail(this.Handle, newTab.Handle); 
  
// Event handlers for this preview 
preview.TabbedThumbnailActivated += new EventHandler<TabbedThumbnailEventArgs>(preview_TabbedThumbnailActivated); 
preview.TabbedThumbnailClosed += new EventHandler<TabbedThumbnailEventArgs>(preview_TabbedThumbnailClosed); 
preview.TabbedThumbnailMaximized += new EventHandler<TabbedThumbnailEventArgs>(preview_TabbedThumbnailMaximized); 
preview.TabbedThumbnailMinimized += new EventHandler<TabbedThumbnailEventArgs>(preview_TabbedThumbnailMinimized); 
  
TaskbarManager.Instance.TabbedThumbnail.AddThumbnailPreview(preview); 
  
// Select the tab in the application UI as well as taskbar tabbed thumbnail list 
tabControl1.SelectedTab = newTab; 
TaskbarManager.Instance.TabbedThumbnail.SetActiveTab(tabControl1.SelectedTab); 
     

As you can see. I add a new tabpage, create a new instance of a WebBrowser control. Tie some events to it – these have meaningful code in them ensuring the correct thumbnail behaviour occurs on the Taskbar – and add the browser control to the tabpage.

Then I add the ThumbnailToolbars buttons. These have already been defined at class level.

Code Snippet
         
      private ThumbnailToolbarButton thumbButtonBack; 
      private ThumbnailToolbarButton thumbButtonForward; 
      private ThumbnailToolbarButton thumbButtonRefresh; 
     

Then a new instance of a TabbedThumbnail is created naming the Windows handle and the new tabpage handle. Following this the event handlers for the thumbnail toolbar buttons are attached.

Our TabbedThumbnail definition is then added to the Taskbar instance’s collection of TabbedThumbnails. And finally, we ensure the new tabpage is the current tabpage in focus on the tabcontrol and on the taskbar.

The rest of the code in the application ensures that when tabpages are changed in the tabcontrol the preview thumbnails are synchronised. And likewise, when preview thumbnails are selected or hovered over the correct tabpage is brought to focus.

The end result lookis like this:

There are all sorts of additional goodies in the TabbedThumbnail class properties that allow you to clip the bitmap and effective zoom into it as well as provide tooltips etc.

Adding thumbnail previews to your applications seems a small effort for achieving one of the most visible enhancements in the Windows 7 UI. The code pack API makes it easy to do.

My complete application can be downloaded from here. It is a simplified version of the code pack Thumbnail sample.

XNA 3.1 install onto Windows 7

paulfo — Thu, 22 Oct 2009 08:37:04 GMT

I nuked my machines to move up to a clean build of Windows 7 RTM. In rebuilding them I hit a snag with the XNA3.1 install. The install would start and then rollback just after the redistributables copy started.

To overcome this issue I set the runtime compatibility of the XNA 3.1 install file to be Windows Vista Service Pack 2 – you do this from the file property dialog. Re-running the XNA 3.1 install it all worked fine.

On starting VS2008 Pro I see that I have both XNA 3.0 and XNA 3.1 project templates available.

A quick test building the platform game and everything looks good.

Now I just need a Zune HD!

Making your app shine on Windows 7: Jumplist

paulfo — Thu, 22 Oct 2009 08:35:49 GMT

This post is one in a series of posts covering the Windows API Code Pack. The code pack provides a managed code framework for using the new native Windows 7 features.

After thumbnail previews the next item you’ll be looking to implement for your application is a Jumplist. A Jumplist may provide shortcuts to recent documents, frequently use documents and application functionality.

Setting up a jumplist for your application is as simple as simple can be using the code pack managed API – but there are some gotchas worth noting.

First, you have to have a valid active window on the taskbar before you can create your jumplist. This isn’t obvious – except when you get the code pack’s error message on first run of your modified application. Remember, in working with the new Taskbar features, you are actually providing the Taskbar with details you want it to attribute to your application. If it doesn’t know about your application, it can’t take your details.

Second, the code pack API does a good job of proactive error detection. For example, it’ll test to make sure the file you want to list on your jumplist exists. If it doesn’t you get blown out before you get near the Taskbar. The same with file associations. The code pack tests for the file association relationship to your application. If it doesn’t you can’t list the file. For more details on this one, look at the code pack TaskBarDemo sample. You might wonder why this extreme protection. The answer lines in the third gotcha.

Third, the known category types (Recent, Frequent) are populated by the Taskbar for your application ‘automagically’. So you only have to choose to show one of these categories in your jumplist to get the information displayed. This is because Windows maintains a recent items history infrastructure when you use the current common file dialogs( or explicitly call the relevant API). If you don’t use them (why?), you can hand code this mechanism by using the shell API SHAddToRecentDocs or the code pack’s jumplist.AddToRecent method.

Fourth, the code pack’s jumplist does a lot of good stuff. This includes maintaining your jumplist against the removed items list created by the user. You may want to have all the items in the jumplist but the user can selectively remove file references from your list. It’s considered bad form to keep putting the item back when the user has removed it, jumplist ensures you don’t make this mistake. If you don’t use jumplist you have to check the removedDestinations property and modify the list yourself.

Now lets look at the code. Below is the specific parts of a C# Winforms application showing the creation of a jumplist:

Code Snippet
 public partial class Form1 : Form
{
    private JumpList jumpList;
 
    private JumpListCustomCategory category1 = new JumpListCustomCategory("Custom Stuff");
    private JumpListCustomCategory category2 = new JumpListCustomCategory("Custom Stuff2");
 
    public Form1()
    {
        InitializeComponent();
        
    }
 
    private void Form1_Shown(object sender, EventArgs e)
    {
        // create a new taskbar jump list for the main window
        jumpList = JumpList.CreateJumpList();
 
        // Add custom categories
        jumpList.AddCustomCategories(category1, category2);
 
        AddTasks();
        jumpList.Refresh();
    }
 
    private void AddTasks()
    {
        // Path to Windows system folder
        string systemFolder = Environment.GetFolderPath(Environment.SpecialFolder.System);
 
        // Add our user tasks
        jumpList.AddUserTasks(new JumpListLink(Path.Combine(systemFolder, "notepad.exe"), "Open Notepad")
        {
            IconReference = new IconReference(Path.Combine(systemFolder, "notepad.exe"), 0)
        });
 
        jumpList.AddUserTasks(new JumpListLink(Path.Combine(systemFolder, "mspaint.exe"), "Open Paint")
        {
            IconReference = new IconReference(Path.Combine(systemFolder, "mspaint.exe"), 0)
        });
 
        jumpList.AddUserTasks(new JumpListSeparator());
 
        jumpList.AddUserTasks(new JumpListLink(Path.Combine(systemFolder, "calc.exe"), "Open Calculator")
        {
            IconReference = new IconReference(Path.Combine(systemFolder, "calc.exe"), 0)
        });
 
 
    }
}
 

All the work is kicked off in the form’s Shown event. With the creation of a jumplist. Two custom categories are added to it. Then some tasks are added that open other applications. The jumplist is ‘published’ by calling jumplist.refresh();

Remember the Jumplist is created by the Taskbar for your application. Unlike the Thumbnail preview toolbars there doesn’t appear to be a mechanism of capturing jumplist events into your application. The only event raised by jumplist is when items have been removed from the jumplist since the last jumplist refresh occurred. This means achieving something similar to Internet Explorer 8’s Open new tab jumplist task, requires an ‘external’ communication to occur with your application.

Preparing for The Assembly

paulfo — Tue, 22 Jul 2008 15:01:19 GMT

I have been lucky enough to get a speaking slot at The Assembly in Finland at the end of the month. 7000 computer hobbyists in one place for four days. Naturally I am talking about robotics! My plan during the session is to show how to build simulated worlds and robots to play in them. This will allow delegates to explore the world of robotics without cost - remember Microsoft Robotics Developer Studio is free for non-commercial use and requires only free runtime downloads from MS including Visual C# Express 2005/8.

However, I'm only speaking for a couple of hours and the event is four days long - although I can only attend for the first two days. So while manning the Microsoft booth I need a few more things to play with.

So, I have been plotting the rebuild of the Wotudo blimp! Today I got the final part - a new 5.8Ghz wireless camera. The camera from Flyonthewall is superb quality! I mashed up a battery connector for it (using a PP3 9V battery) and was able to walk around my garden getting excellent colour images and audio from the camera. My garden is pretty big at 1.1acres, I only got signal interference when line of sight was broken by bushes and trees at about 40metres out, but once line of sight was restored it continued to work very well.

The plan is to use two new blimp balloons and the original blimp gondola with the camera to fly within The Assembly venue. Rather than having the two blimp balloons stacked - as we did at Mashed - I'm hoping we can make more of a 'X-wing' horizontal arrangement with them side by side and the gondola and camera in the middle.

The camera receiver isn't USB so I intend to use my camcorder as the bridging device. This can take a video feed in from the receiver and convert it as required to a USB output which my laptop can use as a web cam. I can then process the feed as I wish - probably using the Volts-IQ visual SDK again to detect faces and other objects. Being 5.8Ghz of course I don't cause interference with Wifi :-)

I also have an iRobot Create to take, and will put the camera onto this also, providing me with a remote camera I can process the feed from, for vision guidance etc. I don't have time to mount a PC on the Create as I intended too, so having it under remote Bluetooth control from a PC and with a wireless vision system is pretty cool to demo and play with. I may take my Lynxmotion 6 Axis arm with me as I can also control this via a wireless mechanism if I plumb the servos into my Devantech servo controller board rather than the servo controller supplied with the arm. Both the controller board and the arm run from batteries, so no real effort required to put this all together. I do need a new micro servo for the gripper as the gears break very easily - something to get ordered I think!!

I think The Assembly is looking pretty cool. I am very excited to be going and to be taking my toys with me!! Although the Sauna in the speaker lounge could be one step to far - even my Stockholm past hasn't prepared me for this ;-). If you are also attending do drop by the MS booth and my seminar to say hi!

Microsoft Robotics Developer Studio 2008 CTP July

paulfo — Sat, 19 Jul 2008 23:52:50 GMT

The next CTP of MRDS is out! It has lots of exciting new features and tutorials (take a look at the DSS Log Analyzer - cam view and GPS mapping data example!).

A quick list of highlights:

1. New samples and tutorials: This CTP has many new samples and tutorials including:

1. DSS Node Discovery using UPnP: A new UPnP sample illustrates how to use UPnP for discovering DSS nodes across a UPnP network.

2. Transport Extensibility: PipeTransport and PipeTransportHost are two new tutorials on how to write your own transport and load it in your custom host. In addition you will also find the UdpTransport and UdpTransport as additional transport samples.

3. LINQ: Service Tutorial 12 shows how to subscribe to the Directory Service using a LINQ Filter and how to receive filtered notifications.

4. Silverlight: The XBox Controller Viewer sample shows support for use of interactive Silverlight-based UI

5. Embedded Simulation Environment: The sample EmbeddedSim sample shows how to embed the Visual Simulation Environment in a custom Windows Forms user interface.

6. Simulated Pursuit Camera: The PursuitCamera sample shows how to implement a camera entity that follows behind a target and avoids obstacles.

7. Simulated 4x4-drive: The SimulatedFourByFourDrive sample shows how to implement an entity that behaves like a 4x4 off-road car.

2. Global Assembly Cache: Core CCR and DSS assemblies are put into the Global Assembly Cache. means that they are a shared resource for all installations on a single machine.

3. Simulation on 64-bit machines: Simulation now runs on 64-bit systems using the Microsoft Windows-32-on-Windows-64 (WOW64) subsystem. To use simulation on 64-bit machines, make sure you use dsshost32.exe which forces the WOW64 mode.

4. Visual Studio Project Wizards: The Visual Studio Project Wizards have been rewritten to make it much simpler to create new service projects directly from Visual Studio 2005 and 2008. Project wizards are provided for VB.Net and C# targeting .NET Framework.

5. Much Faster DSS Proxy Generation: The DssProxy tool has been completely rewritten to simplify the generation of service proxy assemblies and to make it much faster to compile services. In addition, the tool chain for writing services for .NET Compact Framework has been simplified to no longer need a companion service project targeting the desktop version of .NET Framework. This makes development for .NET Compact Framework much easier.

6. DSS Log Analyzer: The DSS Log Analyzer is a preview of a powerful new debugging and monitoring tool that can visualize and analyze message exchanges between services sent within a DSS node or across nodes. In addition to showing the actual messages that have been sent it also provides message correlations, time lines, and illustrates how multiple message interactions are causally linked over time.

7. Embedded Visual Simulation Environment: In addition to having a stand-alone UI, the Visual Simulation Environment can now be embedded in other applications. This enables other applications to show the Visual Simulation Environment as part of their application.

See here for more: Welcome to Microsoft Robotics Developer Studio 2008 CTP July

Download link here: MS Download

Get kids programming with Wowwee bots!

paulfo — Fri, 13 Jun 2008 11:54:00 GMT

Getting children into science and technology is one of the big challenges facing UK education today. Getting kids into programming is even harder. Or it used to be.

Yesterday I met up with Jane Braybrook and Peter Kibble of Q4 Technologies. Jane (a Teacher) and Peter (a .net developer) have built an Integrated Development Environment(IDE) for children, called Go-Robo, which allows them to use their Windows PC to program the Wowwee range of robots!

The IDE comes in three flavours targeting the different key stages (KS) defined in the UK education curriculum. At KS1 & KS2 there is the Go-Robo Controller. At KS2 & KS3 the Go-Robo Programmer and at KS4, 5 and higher the Go-Robo Studio. There are three flavours so that the right level of features and user interface is presented for the age range of the children. Controller is a simple environment with mouse operations enabling the programming and execution of the code on the robot. The other versions move towards a complete scripting language (called GridScript) with all your normal language constructs. The IDE provides break points and stepped instruction execution too, along with a resources environment for teacher and student support! The new UK curriculum revisions provide many, and I mean many, topic areas where programming can be used appropriately as a practical exercise for the topic. Go-Robo provides the tools and the Wowwee robots ensure the children are focused and motivated.

My eldest son of 7 years, who's previous programming experience was limited to the original Lego MindStorms RCX, was programming his Robosapian V1 with only two minutes instruction on the environment from me! Ok we haven't got into loops, if..then..else or sub-routines just yet but combinations of movements, speech and input messageboxes were no problems.

There are several key things about the Go-Robo software (and accompanying IR beamer): The versions are focused on specific age ranges, accessibility has been a high priority in the UI, Go-Robo teaches children sequential programming - not picture drawing - real programming. Wowwee robots deliver instant gratification to your young programmers and are cheap, robust and importantly ready built. I particularly like the way Go-Robo uses speech synthesis to feedback what is happening in the IDE (such as at build and deployment time). During deployment with a Robosapion V2 it is as if the Windows PC and the bot are having a conversation! It can also speak the GridScript language elements so even children who can't read can use the tool. There is also a storyboard style timeline onto which your program or direct Gridscript elements can be placed along with accompanying music (for all those synchronised dance routines).

We've only had Go-Robo in the Foster household for a few hours but already I can call my 7yo a programmer, and my 4yo is real keen to have a go too (school has got in the way, he'll have to wait until he gets home).

Peter and Jane have had an excellent response from the education community in the UK. Not only have they won a Bett Education Show award, they have support from a local education authority (or whatever they are called these days) to deploy Go-Robo and Robosapian V2 to 50 schools in the Grimsby area of the UK.

So, if you are like me, you're a dev who so wants to inspire his children into the wonders of science and technology, or a teacher who really wants to execute in STEM topics, I heartily recommend Go-Robo with your choice of Wowwee robot. Robosapian V2/RS Media provide the most functionality at the moment, but Robosapian V1, Roboraptor, and Roboquad all are very useable and fun. RoboPet has limited functionality.

At present Wowwee UK importer - Character - have most of these robots reduced enormously!! Like you can pick up the originally priced £300 RS Media for £99!!! The other bots are even cheaper.

The new generation of Wowwee robots promise even more and Peter is geared up to support them in future Go-Robo releases.

I shall be taking Go-Robo to schools in Staffordshire at the end of this month to get further hands on experience and feedback from children. They'll use both Lego Mindstorms and Go-Robo - the feedback and observations are going to be really interesting. I'll let you know how I get on. There are several activities I've done in the last year which have been about inspiring young people to use tech - Go-Robo provides an even more programming focused activity.

I really think this is something us techie pros should step up and do more of - supporting schools with our skills, inspiring young people to be creative with technology. If you agree please drop me a note - I want to make a contribution to UK Education. Are you with me?