—

One of the really unsettling events before the launch of the TouchSmart PC was that Engadget somehow got a hold of some pictures that had been prepared for the launch in early 2007 at the Consumer Electronics Show. It was billed in the first sentence as “AMD’s sweet new rig”, which was a little bit of a slap in the face, since most of the real work fell outside of AMDs realm. I remember the team meeting when our program manager came in and told us about the “leak”. He had heard it from Microsoft just a few moments before joining the meeting. The mood in the room instantly turned. People started feeling both mad at the leaked information (and the leaker) and depressed about the potential impact this would have on our launch at CES. Microsoft especially was disappointed, since the TouchSmart PC represented a big investment on their part, carrying some of the Vista messaging. The TouchSmart PC was to be billed as one of a few “dream” PCs at CES. Having gone through an experience like that, I now always think about how the people involved must feel when I see “leaked” information about upcoming products. It’s not fun to have it happen to you.

On a happier note, the TouchSmart PC seemed to make quite a splash at CES. At the last minute I was asked to attend the show to help with technical support on the show floor. This was my first time attending CES and going to Las Vegas, and I quite enjoyed the experience. I ran into quite a few of the people that had worked with us on the project, and it was fun to see the crowds milling about the TouchSmart PCs at the HP and Microsoft booths. Having backstage access was a unique thing, but it involved a lot of walking around, helping the people doing demos by making sure the software was installed properly.

Since then, the HP TouchSmart PC has received numerous awards (including spot number seven on PC World’s list of most innovative products of 2007) and for a short while even had a fan website, the HP TouchSmart Owner’s Club.

—

This is the tentative end of the series. If you’re curious about other aspects, let me know, and if I can talk about it, I’ll see if I can accommodate your curiosity.

Share This

—

The guiding principles for HP SmartCenter and the other touch-optimized applications were to provide quick, “transactional” experiences, to have the applications be as intuitive as possible to use, and have them look polished and clean. HP SmartCenter was to be the “home page” for touch-based interactions with the PC. It had to easily give the user access to key Media Center experiences (TV, music, games) as well as two other touch-optimized programs HP was developing (HP SmartCalendar and HP Photosmart Touch). Finally the user had to have the ability to add access to a certain number of programs of their choice.

To enable some of the quick, “transactional” experiences using a touch screen, HP SmartCenter had to have large “target” areas that are easy to hit using a finger. This requirement helped making decisions about the layout of the “tiles” that the user touches to “launch” something.

We wanted to highlight a few of the key features of the TouchSmart suite of software. We decided that three tiles would be larger than the remaining ones, and that those three would be able to show more details from the underlying program than the smaller tiles. The calendar tile, for example, will pull three upcoming events out of the calendar program and display key information about those events right within the calendar tile. The Photosmart Touch tile will look for pictures in the My Pictures folder and display five of those in a rotation. The weather tile will display high and low temperatures expected for the day as well as the current temperature as reported by the weather service. The analog and digital clock tiles will display two additional clocks (probably configured for different time zones) in text form, in addition to the main clock, which is shown in a larger, graphical look.

The three user configurable tiles would be able to either start a program on the system or a web page, using Internet Explorer. We settled on only having three configurable items, since there was an overall limit in the graphical design at nine small tiles plus three large tiles, and we wanted to encourage people to stick with tiles that didn’t take you out of a touch-optimized / touch oriented environment.

Beyond picking a software development technology (WPF), our other challenges were the many changes in both Windows Vista and WPF as both matured. WPF introduced “breaking changes” several times in our short cycle, and we discovered numerous problems with the integration of WPF and Windows Media Center. We worked closely with Microsoft to get these addressed. But a few problems remained, one of which is that every time you start one of the programs we developed, the computer screen will go black for a few seconds. It gives you the unsettling feeling that something went wrong, but it’s actually a consequence of the interactions between certain software components that are controlling the graphics card (DirectX, WPF and Media Center). As much as we didn’t like it, we were out of time to address these problems by the time our shipping date came.

—

That’s a wrap for part 3. Next time you’ll hear about the reactions from the team when information about the TouchSmart PC was leaked to Engadget way before the actual launch event, and I’ll also talk a little about the launch at CES 2007.

Update (2008-04-30): Part four is now posted.

Share This

—

I hacked together a very simple first version of HP SmartCenter (then codenamed LaunchPad, which still is the name of the executable, incidentally) in HTML and my colleague Maguy added some rough graphical elements to give our design firm an idea of what we were looking for.

My quick HTML mockup

Improved graphics

From about February 2006 until April 2006 we then iterated with our design firm on the GUI and user experience design. Towards the end of May 2006 we took final delivery of the work from them. I was to turn their beautiful work into a living application with page navigation, drag-and-drop functionality, configuration options, and settings persistence. They had provided a solid foundation to build on, including well thought out namespaces, classes, animations and navigation design.

But there was still a lot of work to be done during the next three to four months. In addition to the application itself I was also responsible for delivering an installer, a supporting “touch optimization” program, and integration with our factory PC build process, including dealing with the “sealing” process that prepares the master hard drive for replication.

We participated in Microsoft’s early adopter program for Windows Presentation Foundation and Windows Vista, which gave us access to builds of the WPF bits, with a seemingly never-ending stream of Community Technology Preview versions. Windows Vista was in a similar state of flux, and I had my hands full, wiping out and reinstalling test machines and updating my developer machine to keep up with the changes.

At the same time I climbed the learning curve for WPF (which Simon Middlemiss once described as more of a cliff), trying to figure out how to get the mostly fixed-content XAML pages that the design company had delivered turned into malleable components and re-configurable layouts.

The initial design from the outside company included two components that pull information from the web: weather and stocks. We had to drop the stocks piece for business reasons early on, and had big challenges working out the business issues for the weather feed integration. We wanted our own high-quality images to illustrate the weather conditions and had to get approval from the owner of the feed data. I thought several times that the weather feature was dead, but stubbornness overcame pessimism, and we pulled all the right people from several companies together to get our images approved within 24 hours before the final code submittal deadline. I remember pulling a work-at-home weekend to fine-tune the weather feature where I had to stop working because I was hit with the flu. I was out for three days. After something like that happens you don’t give up a feature without a fight.

One benefit of being part of the early adopter program for WPF and Vista was that Microsoft arranged for training and troubleshooting sessions. I made two trips to Redmond under this program, once to get more in-depth training on WPF and Vista, and once to get help with troubleshooting performance issues we had run into. That’s when I learned that there is such a thing as a “managed memory leak“, which can be introduced in WPF without the programmer necessarily realizing it. Towards the end of the program three of my colleagues and I got to spend a couple of days with Microsoft again, this time at their Platform Adoption lab (Building 20), going over some last minute design and performance questions with their WPF developers one-on-one. This especially helped with getting HP Photosmart Touch into better shape for final release. We got a lot of tips and strategies for dealing with images, collections and containers in these sessions.

—

That’s it for part 2. Next time I’ll dig a little more into the guiding principles that were used for the implementation of HP SmartCenter, as well as some of the challenges and problems I encountered on the way.

Update (2008-04-30): Parts three and four are now posted.

Share This

My involvement with the HP TouchSmart PC began in about December of 2005. The decision was made to invest in software that would be best suited for the touchscreen that the unit would have. One of the results is HP SmartCenter as seen here (screenshot from my developer machine, not necessarily representative of the final product):

We had tight deadlines. Our final bits would be due in about six months, around June / July 2006. Our product marketing folks decided they wanted the touch application to provide quick access to TV and music as primary features. Windows Media Center was our software of choice for delivering TV and music experiences, and so we made HP SmartCenter run within Windows Media Center. This helped to avoid waiting for Media Center to start up when the user wants to watch TV or listen to music. In other areas the choice created lots of challenges. The initial one was picking a software development technology.

I had just attended PDC05 and was pretty excited about Windows Presentation Foundation (WPF) and the speed I could sense it would give developers and designers for rapidly creating exciting software. I had learned that Media Center in Windows Vista would support WPF, and my recommendation to use it for our apps to make the deadlines while delivering a polished user interface was accepted.

An interface developed in HTML would not have had the same quality (read: look-and-feel). Using the Media Center Markup Language (MCML / SplashFX) was not an option, since that was not going to be revealed in any useful detail until about March 2006, way too late for us to learn how to use it and produce a product.

At PDC05, it had been mentioned that a well-know design company had worked on some XAML styles for the show. We approached them to help out with the application design and asked them to deliver their stuff as working XAML / WPF code. They were pretty excited about the idea and signed on.

—

That’s it for now. Check back soon for the next installment of this mini-series, where I’ll show you a few screenshots of very early prototypes.

Update (2008-04-30): Parts two, three and four are now posted.

Share This

Anyway, if you’re having trouble with .NET 3.5 on Vista x64, try uninstalling the KB110806 update. I’m going to assume you know where to do that if you’re reading this.

Share This

A Triggers’ EnterActions or ExitActions don’t seem to get fired when a UserControl is constructed. If you want, say, an animation in your control to start on a property change, you can put a BeginStoryboard element into a Trigger’s EnterActions and a reverse BeginStoryboard into the ExitActions.

But for the control to start out right at initialization you also need to have the right Setter element on the Trigger to set initial states (in addition to setting the opposite initial states on the elements to be animated/initialized.)

Here’s a tiny example:

 1 <UserControl> <!– Namespaces omitted for brevity –>
 2   <Grid>
 3     <ToggleButton x:Name=”Toggle”>
 4       <ToggleButton.Template>
 5         <ControlTemplate TargetType=”{x:Type ToggleButton}“>
 6           <Grid>
 7             <!– Initial opacity is 1 for the initially unchecked ToggleButton state. A trigger changes it to 0 for an initial checked state. –>
 8             <Grid x:Name=”HideMe” Opacity=”1″>
 9               <TextBlock Text=”Hidden”/>
10             </Grid>
11             <!– Other parts of the control go here –>
12           </Grid>
13           <ControlTemplate.Triggers>
14             <Trigger Property=”ToggleButton.IsChecked” Value=”True”>
15               <!– This setter hides the desired element when the ToggleButton’s initial state is checked –>
16               <Setter TargetName=”HideMe” Property=”Opacity” Value=”0″/>
17               <Trigger.EnterActions>
18                 <BeginStoryboard>
19                   <Storyboard>
20                     <DoubleAnimation BeginTime=”00:00:00″ Duration=”00:00:00.05″ Storyboard.TargetName=”HideMe” Storyboard.TargetProperty=”(UIElement.Opacity)” To=”0″ />
21                   </Storyboard>
22                 </BeginStoryboard>
23               </Trigger.EnterActions>
24               <!– ExitActions go here to make the Grid with the TextBlock visible again –>
25             </Trigger>
26           </ControlTemplate.Triggers>
27         </ControlTemplate>
28       </ToggleButton.Template>
29     </ToggleButton>
30   </Grid>
31 </UserControl>

The ToggleButton contains a TextBlock in line 9 that I want hidden when the ToggleButton’s IsChecked state is True. The animation in line 18 takes care of doing that when the user interacts with the control, but when the control is initialized, I need the Setter in line 16 to hide the TextBlock initially if the ToggleButton is checked by default (through data binding, for example.)

Share This

It’s a bit of an experiment, and I’m looking for some real-world “beta” testers. My plan is to try my hand at charging for the program. But to see if word will spread, I’m planning to give out 50 or so licenses without charge while I work out any kinks that might be in the program.

If you’re interested in trying it out, download the program, install and run it, and then click the “Request License” button.

Read more about it on the CardSharkV page.

Update (2007-11-25): CardSharkV depends on the .NET Framework 3.0. It’s thus meant to be installed on Vista systems only. If you have XP and the .NET Framework 3.0, it should still work. Also, since I posted the whole thing Saturday night after a whole day of re-shaping my first, never published version, I didn’t test the install too well. I’ve since had a little time to test and found some issues, especially with the license mechanism. I’ve posted version 1.0.2.0 to correct those issues and to improve the installer as well.

Share This

Deprecated features

The following features have been deprecated:

• Hosting for Microsoft .NET Framework 3.0 Extensible Application Markup Language (XAML) browser applications (XBAPs).
• The Triple-tap/Soft-keyboard ActiveX control for hosted HTML applications.
• Support for using alternative shells to run and host HTML applications.

The reason I’m surprised is that Microsoft announced the support for WPF based extensibility apps at PDC05 with some fanfare.

I guess interest among developers just hasn’t been there for WPF-based Media Center apps, and Microsoft needs to make judgment calls on where to invest in their extensibility platform. The rest of the deprecated features seem to have been made for the same reason: limited interest among developers for these features. In addition I think there might be issues of an architectural nature that just make the three things that got dropped too expensive to maintain or improve.

I’m sad about this development, mostly because I still don’t see a great set of development and design tools around for MCML. WPF seems to me to have a whole lot more momentum than MCML (WPF has the Expression suite of tools and has been billed as the “GDI for the next 20 years”), but who knows what may be coming for Windows 7, or even an earlier interim update for Media Center?

Share This

I had set my system up according to Tim Sneath’s post on the perfect WPF developer system, including VS 2005 SP1 and the beta version of the Vista extensions for VS 2005. I was running VS “as administrator”.

As it turns out there are some technical details around starting XBAP debugging sessions from an elevated VS process that cause this behavior if you already have another instance of IE running when starting the debugging session.

Thanks to Tim Sneath and Chango Valtchev at Microsoft for helping in tracking this down!

Moral of the story: If you want to debug an XBAP from VS 2005 under Vista, run VS non-elevated, or make sure you have no other instances of IE running when you start the debugging session.

Share This

So with all those problems, we decided to take a different approach for our WPF XBAP applications. We put all our strings into a standalone XAML file, producing a ResourceDictionary. This way our application can pick up strings using Text=”{StaticResource strXYZ}” for XAML markup and/or use Application.Current.FindResource(”strXYZ”) for codebehind. We name the file “Strings_en-US.xaml”. We can localize this file nicely, and name the resulting set appropriately: “Strings_de-DE.xaml”, “Strings_fr-FR.xaml” and so on. These files can then be included as resources in the application. They can also be added as “loose” XAML files, so we can add languages or make corrections after compilation.

The string resource file looks something like this:

<?xml version="1.0" encoding="utf-8" ?>
<ResourceDictionary
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:sys="clr-namespace:System;assembly=mscorlib"
>
  <sys:String x:Key="strButtonOK">OK</sys>
  <sys:String x:Key="strButtonCancel">Cancel</sys>
</ResourceDictionary>

At application load time, we look at the CurrentCulture and attempt to load the ResourceDictionary object like this:

ResourceDictionary rd = null;
System.Globalization.CultureInfo ci =
     System.Globalization.CultureInfo.CurrentCulture;
string langCountry = ci.Name;
string languageFile =
     string.Format("/Resources/Strings/Strings_{0}.xaml", langCountry);
try
{
  rd = (ResourceDictionary)Application.LoadComponent(
                              new Uri(languageFile, UriKind.RelativeOrAbsolute)
                                  );
}

You can imagine this with some catch {} fallbacks for when a specific language-country combination doesn’t exist. We’ll fall back to a file that’s only language specific, and if that doesn’t work out, we’ll fall back to en-US.

We’re not using CurrentUICulture, since that seems to be tied to the UI language of Vista, and we want our apps to follow what the user sets in Control Panel. CurrentCulture seems to work for that.

To load the strings into the global resource dictionary, we just do

Application.Current.Resources.MergedDictionaries.Add(rd);

To load loose XAML files that are not part of the application’s resources, we do something like this:

ResourceDictionary rd1 = null;
string languageFileLoose = string.Format(
         "pack://siteoforigin:,,,/Resources/Strings/Strings_{0}.xaml",
         langCountry
      );
Uri uri = new Uri(languageFileLoose, UriKind.Absolute);
System.Windows.Resources.StreamResourceInfo info;
System.Windows.Markup.XamlReader reader;
try {
  info = Application.GetRemoteStream(uri);
  reader = new System.Windows.Markup.XamlReader();
  rd1 = (ResourceDictionary)reader.LoadAsync(info.Stream);
}

Again, we extend this with catch {} blocks to fall back to a file that’s only language specific. We do the loose XAML loading after we’ve loaded embedded resources, so we can rely on a basic set of languages and strings, but can add languages, fix string translation errors or make improvements in the loose XAML after compiling things.

It may work for you as well, but ymmv.

Update: Changed the first Uri to UriKind.RelativeOrAbsolute

Share This

At this late a stage in a product’s delivery cycle it is common to make very few changes to the code in order not to create more bugs than one fixes. Ideally each change should be peer-reviewed and thouroughly tested before getting checked in (like with Windows Vista and the contortions people have to go through in the “shiproom” to get a bugfix approved). Too bad for me that I’m the only “peer” on the project (i.e. I’m the only developer). There’s nobody I can go to for a review.

And in the last few weeks I’ve broken the “as few changes as possible” rule a number of times. Why? Because I’m confident in the features that WPF provides. And because I do tend to run extensive tests before I check stuff in.

So what kinds of changes have I put in at the “last minute”? I’ve shuffled buttons around on the page, I’ve added code for drawing the user’s eyes to input fields containing invalid data, I’ve added data-bound and data-driven UI elements.

WPF has given me the confidence to be able to do this at the last minute. The fact that moving buttons around is a simple XAML markup change, for example, is just great for last minute UI adjustments.

But I’m not exactly proud of doing it. Oh well. So far everything seems to have worked out.

Share This

If you have an XBAP WPF application that tries to access files at the location identified by CSIDL_COMMON_APPDATA (Environment.SpecialFolders.CommonApplicationData in .Net 2.0/3.0) they need to be marked with Read/Write permissions for ”Everyone”. Otherwise File Virtualization kicks in and Vista creates copies of the files in the VirtualStore.

This shouldn’t be a problem per se, but if you have data integrity issues with your application reading/writing files it’s nice to eliminate the virtualization for troubleshooting.

Also, if your application needs to share the same data among users you don’t want virtualization, since that is a per-user thing, and you’d end up with one set of data files for each user.

If you’re installing some default data files for the application using Windows Installer (which will run elevated), you need to make sure you change the permissions on the data files so “Everyone” gets read/write permissions. This can be done using the LockPermissions table of Windows Installer.

Share This

My last two projects before starting on WPF were built around hosting IE in “something”.

The first “something” was an exe hosting IE and adding a bunch of window.external functionality. I took the lead in moving a somewhat old, pretty static UI infrastructure for presenting internet-updatable content to the XML/CSS/XSLT age. That involved a lot of using dynamic expressions to enable reflowing of the UI for different monitor sizes (the app was a fullscreen app). Towards the end of that project I started hearing about an XML-based application development thing coming from Microsoft, and I remember thinking “How cool! No more need for the mess of HTML / CSS / XSLT and JScript/dynamic expressions to glue it together.”

 The second “something” was an application for Windows Media Center, which at the time only offered hosted IE as its application development model (with a bunch of window.external functionality thrown in to get at the Media Center stuff, similar to how our exe had worked). Three of us wrote a pretty interesting little application that shipped for about a year and then was discontinued when circumstances changed on us drastically. Around the time this happened, the XML-based app development thing from Microsoft, better known then as “Avalon”, took more shape.

I was lucky enough to get to experience the energy that Microsoft projected at PDC05. It felt like an explosion of enthusiasm around the newly re-christened “Windows Presentation Foundation”. My eyes were popping at Greg Schechter’s talk. Manuel Clement’s talk was chock-full infectious excitement. I wanted to work with this new stuff.

Luckily the project(s) we were given to work on next required a level of “polish” that I doubted we could achieve using HTML, WinForms or any other technology we were proficient in. I advocated strongly for using WPF, and for some reason management went along. One of the requirements for one of the projects was that it had to run under Vista and more specifically under Media Center to get a great user experience. The level of “polish” that was required pretty much ruled out using HTML. We could have done all ActiveX controls, I suppose, or an HTML/Flash hybrid, but none of us had the required expertise to implement that, and the time frame was extremely tight to begin with.

To me the only way to solve the problem was using the incredible leverage of WPF to “get things done”, even with the steep, steep initial learning curve. I worked on some throw-away applications just to show my manager that this new platform had incredible potential and that I would be able to pick it up quickly enough to work with it seriously. He liked what he saw. The rest is material for another post. Let me just say now that the devil is in the details, and we had lots of challenges on the project overall. Once it’s out there I can talk more about it, but not yet.

Share This

XAMLPad (from the Windows SDK [Full ISO|Express Web Download])
Snoop (from Pete Blois)
Perforator (from the Windows SDK) (Don’t forget to turn on the required debugging setting in the registry - mentioned in the article)
CLR Profiler
.Net Reflector (from Lutz Roeder)

If you’re a designer / developer you also want:

Microsoft Expression: Interactive Designer
MOBIFORM Aurora XAML Designer
Electric Rain Zam3D

And of course the staples:

.Net Framework 3.0 September 2006 CTP (I usually pick the complete installer to avoid download problems - it’s hidden a few paragraphs down under a link that says “for x86″)
Visual Studio 2005 / Visual Studio 2005 Express
“Cider” / “Orcas Preview for WPF”

Did I miss anything?

Share This

With Vista, not only do you get the .Net Framework 2.0 (much improved over the previous versions) in the box, but also the amazingly powerful Windows Presentation Foundation (which is what I’ve worked with), Windows Communication Foundation and Windows Workflow Foundation (two pieces I know nothing about yet).

This will lower the barrier to entry for applications developed using these powerful tools to zero. As long as you’re writing your application for Vista you can be sure the basic requirements are there.

There will be issues with certain features of WPF (rendering in software vs. hardware, especially for 3D), but the framework helps you detect these issues and makes it possible to adapt your application to lower its “flashyness” (RenderCapability.Tier, remember this needs to be shifted down by 16 bits if you want to use 0, 1 and 2 as the human readable values).

To me Windows Presentation Foundation is the most important technology to come out of Microsoft for a long time. I’ve never written too much actual Win32 or even MFC/ATL UI code for client applications, but I’ve done a lot of HTML / CSS stuff and pure business object stuff (COM/ATL). More about that in my next post. I don’t want this to get too long.

Share This

System.Windows.Media.RenderCapability.Tierreported a wrong tier (zero) after I upgraded my Windows XP dev box’s .Net Framework 3.0 installation to the RC1 release. My card used to be a tier two and I had just upgraded the drivers, too. I contacted Microsoft about it and they said this is a known issue with the RC1 release and that it will be fixed in the upcoming RTM release. The problem is only with this particular API and only happens on Windows XP. All the actual rendering is still done correctly based on the capabilities of the hardware. So the only problem is if your WPF application is built to behave differently based on the value of this API call.There is a workaround that has to do with changing the value type of a certain registry entry (the video memory size) from Binary to DWORD. I’ll point to more details once I get a URL from Microsoft to point to.

Share This

I had several UIElements that each had the Rendering event hooked up, and the code in the event handler would do next to nothing most of the time, since the animation only was kicked off on a mouse up event. I modified the code, so that the event hookup doesn’t happen until the mouse up event comes in, and also so that an unhook happens when the animation is finished. This promptly took down the CPU load to the typical intermittent 1-2%.

Share This

If you’re writing a Windows Presentation Foundation app that has just a little bit of complexity to it, you may do things like hook up UI Elements to event handlers. This could be for navigation, reacting to data changes, timers etc.

An important thing to remember is to unhoook those event handlers when your UI Element is unloaded. Otherwise the event handler hangs on to the visual tree and the garbage collector will not let go of it. This results in memory consumption “problems”, which is a nice word for a “managed memory leak”.

So if you do something like this:

public MyElement()
{
  InitializeComponent();
  Loaded += new EventHandler(OnLoaded);
}

public void OnLoaded(object sender, EventArgs e)
{
  myTimer.Tick += new EventHandler(OnTick);
}

Don’t forget to also hook the Unloaded event and do this in it:

public void Unloaded(object sender, EventArgs e)
{
  myTimer.Tick -= new EventHandler(OnTick);
}

Share This