Developing for the UMPC–first steps


As a developer one of my first questions about the Origami–now known as an Ultra-Mobile PC (UMPC)–was “What do I need to do to develop for the UMPC?” In particular, how can I migrate some of my existing apps or adjust my new apps to be UMPC friendly.

Fortunately UMPCs run Windows XP (Tablet PC Edition) so for the most part any app that runs in XP will also run on UMPCs. This is good news…very good news.

At the same time, UMPCs do bring their own design issues. First, UMPC displays are typically in the 7″ range with resolutions starting around 800×480. In other words, tiny. As a result, one goal of UMPC development is to be as efficient with screen real-estate as feasible.

UMPCs also include a touch display. Yes, this means a user can use a pen to handwrite words and have them recognized–just like they can on a Tablet–however, because the digitizer is touch sensitive (like digitizers on a PDA), it means users also can use their fingers in addition to the stylus. This means large, finger-sized targets are probably a good idea. And if you want to UMPC-enhance your app, it means you may want to provide UMPC-friendly touch buttons to activate common operations. You may also find that some small targets, such as slider thumbs or toolbar grippers, may be too small to be useful with a user’s fingers.

Here are several UMPC-specific platform details you’ll want to keep in mind when developing for a UMPC:

* UMPC devices have small displays and possibly lower resolutions than you may be used to. UMPC displays currently have resolutions of 800×480 native–although they may include software drivers to render various other higher resolutions. (If the user opts for higher resolutions, bring your good eyesight, because on the small
* UMPC devices are smaller than most laptops and larger than PDAs/SmartPhones
* A user of a UMPC app, may or may not have a physical keyboard handy.
* UMPC devices are meant to be held and carried with you as you move about.
* A touch display is built in (Note: Most Tablet PCs have active digitizers whereas UMPCs have touch displays–like those in PDAs.)
* UMPCs are meant to be connected. WiFi is built-in to all current models. It would be nice if EVDO or other 3G support is added in future devices.
* UMPCs run a full version of Windows, not Windows CE or other trimmed down version of Windows. Standard XP apps should at least run on UMPC devices.

OK, so let’s say you want to develop for an UMPC. Now what? There aren’t any UMPC devices that you and I can get.

How do you develop software for a device that doesn’t exist yet? Well, of course, since UMPCs run Windows XP this means you can develop on a standard Windows notebook or desktop–so that at least you can test the functionality.

For most existing Windows XP apps, the biggest challenge is probably going to be dealing with the limited screen real-estate. That’s what I’ll focus on here.

In fact, if you have an existing app that you want to run on the new UMPCs, check what minimum screen resolution your app or any of its dialogs needs. If you want to be able to run on the lowest res displays, you’ll want your app to be able to run in 800×480 mode. That means no dialog should be wider than 800 pixels and 480 pixels high. For many of us, the height is probably the bound that you’ll have the most trouble with.

Actually, unless you’re running full screen, there may be a taskbar at the top or side of the screen–this is Windows after all. So if you leave space for the task bar being at the top or bottom (let’s say it’s 30-40 pixels high), this leaves maybe 445 pixels at the most. (And this doesn’t allow for multi-line taskbars or any third-party taskbars either.)

You can run your app and measure each of your dialogs to see if there will be a problem running on an UMPC, but there are a couple alternatives.

One is to test your app in Virtual PC and set the resolution to 800×480.

Another is to download this UMPC screen emulator from Microsoft’s dev center. (Note: As of the time I’m writing this post the emulator is still in beta. Also, it requires .the NET 2.0 framework. Plus, the current version runs OK on 1024×768 resolution or the Gateway’s widescreen, but not the high-res 1400×1050 native for the M200.)

The emulator does a little trickery to contain the desktop, so once you launch the emulator you’ll see a UMPC-looking bitmap with your Windows desktop inside it. At this point launch the program you want to test. Then maximize the app, run it windowed, and possibly try setting it full-screen if you app supports this.

Here’s what the emulator looks like when running InkGestures:


In this screenshot, you can see Word maximized with the InkGestures Getting Started dialog showing. Whew, it works. Actually, when we were developing InkGestures we tried to be careful to limit the sizes of dialogs with small displays in mind. As you can see, things worked out well.

If a window in your app doesn’t extends beyond the interior of the UMPC emulator’s bitmap, it will be shown translucent in those areas where it’s too large. You’ll then have a good idea of where you’ll need to re-layout and re-size your windows. This is where the fun begins. Hopefully, the changes will be as simple as squeezing some pixels out of a dialog.

Besides checking whether all your windows fit within the UMPC’s screen real-estate, you should also thoroughly exercise your app, especially in areas where you have calculations based on the dimensions of the window. What happens, for instance, when the app is run on a UMPC’s limited display resolution? Is everything positioned correctly? Or is the window now too small for everything to show up? It’s bugs such as this that may be a bit more difficult to predict may or may not happen without actually running the app on a small display or the screen emulator.