Wot u do with .net : UKDPETeam

PDC 09 attendees get free Win7 laptop

paulfo — Wed, 18 Nov 2009 17:41:36 GMT

Steven Sinofsky announced at PDC09 day 2 keynote, that all PDC 09 attendees would receive a MSFT designed, Acer built, Windows 7 laptop free of charge.

The laptop has a touch screen, full sensor and location functionality, is 64-bit and fully loaded up with Office 2010 beta and lots more.

Designed to enable application developers to get to grips with Windows 7 features, the keynote audience were first stunned and then jubilant at the gift.

To get going on Windows 7 application enhancement take a look here.

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.

sidebar: Project Mobile AR

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

As discussed at the recent OTA09 event, I’m working to build out an AR platform on Windows Mobile. This is a ‘skunk works’ project filling my waking hours between work and the family.

Currently, I’m exploring the DirectShow capabilities of the Windows Mobile device. DirectShow allows us to get hold of the device camera and provides a mechanism, via filters, to manipulate the video stream before rendering.

I currently envision building a transform filter that will enable a form of the Windows Video Mixing Renderer on Windows Mobile. The filter would take layer definitions, graphics or video as an input for the AR elements.

Performance is going to be a killer on these devices, so will see how rich the VMR functionality can be.

I haven’t done any serious DirectShow stuff, my only experience comes from some work nearly a decade ok, so I’m ramping up my skills.

One interesting Bing find, and a proof point for my envisioned solution, is Alex Mogurenko’s excellent DirectShow.NetCF project. Alex provides two DLLs which implement a custom SampleGrabber filter, making it possible to build a simple .NET CF application that can display video preview and capture stills from the camera.

My little WM6.5 test project is here (.Net CF 3.5 app). It works well, performance lags compared to the native HTC Camera application, but not by much. I need to explore this in more detail.

Following Alex’s lead, I’ll be implementing my own filter next and aiming in the end to provide an AR solution to .NET CF developers. Once I get this going I’ll publish the project on Codeplex.

TTFN

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.

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.

VS2010, .Net 4 and Windows 7 Multitouch WPF apps!

paulfo — Wed, 17 Jun 2009 19:14:26 GMT

Hi all,

I've been doing a little playing around with MT on Win7 using the VS2010 and .Net 4 Beta 1 to get some WPF MT demos running.

Here are the videos!

Basic how to get MT going code example:

Some internal demos that I've made to work on VS2010 and .Net4 beta 1 - using a WPF4 implementation of the Surface ScatterView control (or something that looks a lot like it)

Get building with WPF 4 in MT! I'm using the Codeplex MultitouchVista project which now has a Win7 driver. Works really well - very sweet when you don't have any MT kit!!!

XNA UK Bar Camp 21st March

paulfo — Tue, 17 Mar 2009 12:41:43 GMT

Are getting ready to come to XNA Camp? We have a great selection of speakers AND creators club memberships to give away to attendees (4mths) and speakers (12mths). Everything in fact to get you building games or building more advanced games! With the new Community Games channel on Xbox Live you could also make some money!!!

The XNA UK user group is a great gang of hobbyists, students and professional games developers. Always happy to help fellow game builders the user group provides a wealth of experience and resources to tap into. Why not join us in Birmingham at the Aston Science Park between 09:30 and 18:00. I'm giving the opening session on recent XNA and related technology announcements, then we have an open floor for 20min sessions by attendees.

Some of the speakers confirmed include:

Peter McGann - author of the recent PC Plus XNA series.
Edward Powell - explaining XNA Game Components & Services
Andrew Griffiths - telling us some of the shader tech behind the game Encroach.

There are still a few more slots available so submit your presentation idea to SlotBooker@xna-uk.net and receive a 12month Creators Club membership after your presentation. Feel free to submit a XNA question you'd like answered by someone else!

Projector and sound system is all provided by the venue - just bring your laptop to present from and to take part in the LAN party!

Arrival time: 09:30

Kick off at: 10:00

A light buffet and refreshments will be available - sponsored by Microsoft.

Hard close at: 18:00

Venue address:

iCentrum
Aston Science Park
Faraday Wharf
Birmingham B7 4BB

Car parking is available underneath this building in a pay and display.