I [heart] code!

Learning WPF With BabySmash - Redux: See Drewbie in Action!

Kirstin Juhl — Mon, 03 Nov 2008 17:27:49 GMT

Here is a video of Drew using his SmartNav and special switch to play on the computer!

*Note: SFW, But there is sound with this video.

Learning WPF With BabySmash: Redux. BabySmash KeyBoard Click Events in WPF

Kirstin Juhl — Mon, 27 Oct 2008 17:09:42 GMT

Now that I had my Amazing Qwerty KeyBoard, I had to hook it up. BabySmash uses the OnKeyUp event in the MainScreen as its hook to the business logic:

public partial class MainWindow : Window
{
private readonly Controller controller;
public Controller Controller { get { return controller; } }

public MainWindow(Controller c)
{
    this.controller = c;
    this.DataContext = controller;
    InitializeComponent();
}

....

protected override void OnKeyUp(KeyEventArgs e)
{
    base.OnKeyUp(e);
    e.Handled = true;
    controller.ProcessKey(this, e);
}

...

}

Since I wanted to mimic the existing behavior as closely as possible, I had to create a corresponding event for my on-screen key board, and then have the MainWindow handle it in the same manner.

My keys are <Button/>s, so I used the "Click" event on all of my keys:

...

I then implemented the "HandleKeyBoardClick" class in the code behind:

    protected void HandleKeyBoardClick(object sender, RoutedEventArgs e)
    {
        Button b = (Button) sender;
        NewKeyBoardClick(b.Name);
    }

I abstracted the actual logic of the event raising in case I ever wanted to raise the event in a different way. My NewKeyBoardClick method takes the desired key as a plain-text string (ie: "Q"). I chose not to convert back and forth from ascii codes because I really didn't see any value in doing so.

public void NewKeyBoardClick(string keyName)
{
//Raise a key click event for the specified key
}

Now I needed a KeyClick event. After much googling and pain (It was during this activity that my KeyBoard user control briefly became a custom control before it was reincarnated back in it's present form.) I not only needed a custom event, I needed a custom event argument (which key was clicked).

Here is what I came up with:

First, I created my custom argument:

public class KeyBoardClickArgs : EventArgs
{
public string KeyName { get; set; }
}

Then I created the delegate for my event:

public delegate void KeyboardClickHandler(Object sender, KeyBoardClickArgs args);

Then I created my event:

public event KeyboardClickHandler KeyBoardClick;

Now, I needed to raise the event with the proper argument in my NewKeyBoardClick class. First I instantiated my KeyClickArgs and set the keyName property. Then I check for any subscribers to my event, and if I find any, I raise my event:

public void NewKeyBoardClick(string keyName)
{
    KeyBoardClickArgs e = new KeyBoardClickArgs();
    e.KeyName = keyName;
    if (KeyBoardClick != null)
    {
        KeyBoardClick(this, e);
    }
}

Now my control is ready to go! (I know, I haven't implemented the size property yet - that came later.)

I added the KeyBoard control the the MainPage window:

xmlns:local="clr-namespace:BabySmash"

I set it to "Hidden" because I only want to display it if we are in "drewbie mode".

Now I just needed to hook up the new event:

First I added it to the MainWindow constructor:

KeyBoardC.KeyBoardClick += new Keyboard3.KeyboardClickHandler(KeyBoardC_KeyBoardClick);

Then I used the event in the same way that MainScreen uses its OnKeyUp event:

void KeyBoardC_KeyBoardClick(object sender, KeyBoardClickArgs e)
{
controller.ProcessKey(this, e.KeyName);
}

Success!! The MainWindow is responding to keyboard clicks from either the real keyboard or my on-screen keyboard control in exactly the same way! Now I can go ahead with modifying BabySmash and implementing new "DrewbieSmash" features without thinking about the input mechanism.

I'll work on getting the source code available. Until then, email me.

Learning WPF With BabySmash: Redux. My Amazing BabySmash Qwerty Keyboard

Kirstin Juhl — Mon, 27 Oct 2008 16:10:06 GMT

The first thing I did after downloading BabySmash was to begin building an on-screen keyboard. I installed Microsoft Expressions, but quickly became frustrated. That was a surprise to me because I am a Photoshop pro!! (On portraits anyway). Despite the admonishing of many, I switched over to Visual Studio and began coding my keyboard by hand. Now I was on much more familiar territory! I do plan to return someday to Expressions when I have a more open mind. But for now, I want to build DrewbieSmash!

The following are my requirements for my keyboard:

1. Appears in the bottom right corner of the BabySmash main window when BabySmash is in "drewbie mode".

2. Is resizable.

3. Sends a key-click event to the main window when a key is clicked on. I wanted to reuse as much code as possible, and hook the on-screen keyboard right into where the real keyboard is hooked in.

I tried many things... first I made my keyboard a <Window />. Mainly because the sample xaml files I was working with were all <window /> s, and I was just trying to do some cut-and-paste development to get my feet wet with WPF. Getting my window to render inside the main window as I wanted it to appear was problematic - probably because I didn't know what I was doing. And probably because putting a window inside another window is probably a dumb idea.

Then there was this challenge... BabySmash is architected so that all logic is executed by a controller class. The controller class requires a FrameworkElement argument and uses this for where it performs the animation. The original BabySmash main window was both the input and the action window, so it just used "this". Since my events were coming from the KeyBoard window, I had to get a reference to the Main window before I could execute the animations in the MainWindow via the controller class. Furthermore, it was apparent to me that BabySmash was really architected around having a single main window, and by continuing down this path I would likely run into additional challenges when trying to work with a second window.

So I took a step back and realized that in a .NET application, I would make the keyboard a <usercontrol />, and give it a "KeyClicked" event.

Since the keyboard object doesn't know anything about the size and real-estate concerns of the containing object, the keyboard was coded to size itself relative to the parent window. There were no pixel values coded into the Keyboard xaml. So originally I thought that the Keyboard size could be entirely controlled by the parent window. However, I soon realized that I have to change the font size as the key board is resized. So I added a "size" property to the KeyBoard control. I didn't want to use explicit pixel values because we still don't know what is going on with the parent. So I made the KeyBoard accept 4 sizes: Large, Medium, Small, Standard. (Standard being the smallest and the size of the on-screen keyboard that ships with the Windows OS. If someone has a better name for that one, please let me know!!!!)

Now, even though I don't know what the actual size of the KeyBoard will be, I can make a guess as to the size the font should be. And this works very well.

Here is a screen shot of my Amazing BabySmash keyboard. You can see by the name of the control that this is my third attempt at creating a keyboard. The next blog post will be about how I coded the KeyClicked event and how I modified the BabySmash application to use it.

Learning WPF With BabySmash: Redux

Kirstin Juhl — Sat, 25 Oct 2008 05:53:07 GMT

A long, long time ago in a galaxy far far away, a developer at Microsoft named Scott Hanselman decided to learn WPF. And so he set out upon the Great BabySmash Experiment.

Meanwhile, in another galaxy, a developer at Magenic named Kirstin decided to learn WPF. By this time, the Great BabySmash Experiment had achieved fame far and wide, and so Kirstin downloaded the source code and created DrewbieSmash.

Who is Drewbie?

Drew is my five-year-old nephew and is very special in many ways. When he was about one year old we learned that he has SMA. Spinal Muscular Atrophy is a form of Muscular Dystrophy. SMA is the reason he can’t walk or sit unsupported. However, please don’t worry about him. He has a scooter that he can drive like a pro. Besides, he's really smart. Best of all, he's one of the happiest five year olds you’ll ever meet! As you can see in his picture, he gives his life a double thumbs-up!

Few things will be more important for Drew than access to computers. Using a mouse is too difficult for him. When we were struggling with a way for Drew to access the computer I found a wonderful piece of equipment called the SmartNav. Drew puts a small ring on his finger to mouse and uses a switch to click. Drew will use an on-screen keyboard with his SmartNav for keyboard input.

DrewbieSmash

Ideally Drew will be able to use the on-screen keyboard that ships with the OS, so as to minimize the adaptations that need to be made to any PC he wants to use. (The SmartNav and the switch use a USB port and the SmartNav software must be installed.) However, the on-screen keyboards are quite small and require precise control of the mouse, something that Drew is working to master with his SmartNav.

When I saw BabySmash, I had an idea for a modification that could transform it into a platform for Drew (or any other toddler) to master the keyboard as well as learn letters and words. Instead of displaying whatever letter the user happens to "smash", why not have a word displayed that the child would then key in? If the correct letter was pressed, the letter would come dancing out and settle into place into its proper spot below the word. For Drew, I would create an on-screen keyboard as part of DrewbieSmash that could start out large with big keys and gradually be made smaller and smaller as his skill at clicking on the correct letter improves. Eventually he will be able to use the regular on-screen keyboard.

Learning WPF

And so here begins my adventure in learning WPF. Never having had any exposure whatsoever to WPF, yet eager to get going, I eschewed all preliminary research on the topic and decided to go the old-fashioned route: reverse engineering BabySmash and coding by Google. I will blog about my progress and what I learn along the way. If anyone has any helpful comments, PLEASE add your two cents. Scott has graciously offered to make whatever I come up with available as part of the BabySmash repository. Thanks for riding along with me!

Everything old is new again

Kirstin Juhl — Fri, 22 Aug 2008 00:35:32 GMT

Last I attended a TFS User Group meeting in Minneapolis. Bill Maurer explained how Microsoft used Team Foundation Server to build the next release of Visual Studio.

It was really interesting to hear how the development team used TFS to track their own work. The most interesting thing to me was to hear about how TFS is being used to manage Java projects (Not at Microsoft of course!) Previously it had not occurred to me to consider TFS as anything other than a .NET development tool. But, of, course, data is data, and it makes perfect sense now that TFS would be used to track any type of project.

Bill mentioned that quite frequently, the software development team doesn't want management to have this detailed kind of visibility into the process. "If they knew how bad things really were, we would get fired!" Ten years ago I started putting Manufacturing Execution Systems into factories in my previous life as a Chemical Engineer. The operators nearly staged a mutiny over the fact that their actions would be tracked down to every operation they performed on every item. One plant was a union plant and the union was looking into whether or not the contract even allowed this type of data to be tracked! Management was also unsure... they were spending millions to dollars to implement systems that had no direct affect on the product.

Now, of course, you cannot imagine a manufacturing plant that does not have traceability down through the process for each unit produced. The operators work in an environment of reasonable expectations and an optimized process. No one thinks twice about logging into a system and then scanning each unit as it comes down the line.

Similarly, I think that one day no one will believe that we actually tried to build software without tracking this kind of data. The value of the data will be many times the cost of purchasing and implementing the system that supports it. Bill's comment to the teams that are concerned about giving management an actual picture of what is going on is that management will finally understand what can actually be accomplished, and remove bottlenecks if performance is unsatisfactory. "The working environment for the software team will actually improve", Bill says.

I do believe in the promised of optimized performance through Defining metrics, measuring what matters, analyzing the data, and improving and controlling the process. I have lived it in my years as a manufacturing engineer. TFS promises to be a huge asset to the teams that choose to use it for this purpose. I am anxious for Microsoft to give us a hint as to what Rosario will do. Perhaps at the upcoming PDC. I guess we will just have to wait.

TechEd US Sessions online

Kirstin Juhl — Thu, 21 Aug 2008 21:07:29 GMT

Blogging so that I can find these again when I have time to watch them...:)

Ø Introduction to Microsoft Dynamics CRM, Susan Sauls

Ø Intro to SQL Server Data Services, Soumitra Sengupta

Ø The Spy Who Hacked Me! , Alex Smolen, Rudolph Araujo

Ø How Microsoft SQL Server Helps You to Lower Your Cost of Storage, Torsten Grabs

Ø Microsoft System Centre Virtual Machine Manager 2008: Overview, Edwin Yeun

Ø A Hackers Diary: How I Can Hack Your Vulnerable Services and How You Can Stop Me, Marcus Murray

Ø Advances Microsoft SQL Server PowerShell Tips and Tricks, Dan Jones

Ø Technical Introduction to Microsoft System Center Data Protection Manager 2007, Jason Buffington

Ø Introduction to Microsoft Forefront Code Name "Stirling", Brad Wright

Ø Hyper-V Architecture, Scenarios and Networking, Jeff Woolsey, Mike Sterling

Ø Windows, PowerShell, and Windows Management Instrumentation: Unveiling Microsoft's Best Kept Secret, Ben Pearce

Ø Windows Logins Revealed, Mark Minasi

Ø Virtualization and Security: What Does it Mean For Me? Steve Riley

Ø Windows Security Boundaries Mark Russinovich

Ø How to Build Your next Generation IT Infrastructure Using Windows Server 2008, Corey Hynes

Ø Deploying Windows Server 2008 Hyper V and System Centre Virtual Machine Manager 2008 Best Practices Edwin Yeun, Alan Stewart

Ø Deploying Microsoft Dynamics CRM, Ryan Casey

Ø Microsoft System Centre Service Manager Paul Ross, Travis Wright

Ø Windows Server 2008 Hyper-V: Scripting & Programmatic Management for Fun & Profit (VBS & PowerShell), John Kelbley, Alexander Lash

Charity Fragathon

Kirstin Juhl — Sat, 02 Aug 2008 17:50:44 GMT

A colleague of mine is organizing a community event to benefit Children's Hospitals and Clinics of Minnesota.

The Charity Fragathon will be held September 24, 2008 at the Microsoft office in Bloomington.

This is an amazing hospital, not only due to the world-class health care, but for the family experience they provide.

So come on out, have some fun, and benefit this great cause!

I'll be there, and I don't even game!

I'm on DimeCasts.NET!!!

Kirstin Juhl — Fri, 01 Aug 2008 00:49:10 GMT

There is a great new site dedicated to educating developers on all sorts of topics. It is run by developers, and the contributors are developers.

My first episode had been released: Creating a Project in Team Foundation Server!

I am really excited to be a part of this great project... look for more episodes from me coming soon!

Planning for "Duh!"

Kirstin Juhl — Thu, 03 Jul 2008 15:30:28 GMT

We've all done it. More often than we'd like to admit. Yesterday I spent half a day working on an issue where the end result turned out to be SO SIMPLE as to make me ashamed to call myself a developer. There was the feeling as I slogged through the problem that "This shouldn't be this difficult". When the problem resolved with 4 simple lines of code, my giddiness with solving the problem was tempered by my feeling like a complete idiot for having spent half a day producing those four lines. Hearing that I was the third person to tackle this issue, that two others had tried and failed made me feel only marginally better.

Software development is extremely rewarding and mind-numbingly frustrating at the same time. You can go for days, even weeks, where progress is steady and the project marches along right on schedule, maybe even a bit ahead. And then you hit it. The problem you can't solve - the functionality you can't quite implement, the bug that you just can't fix. And there you sit, working on one stupid little thing for hours, perhaps a day or more. You go home feeling as if you have made no progress, as if you have produced nothing for all your laboring at the keyboard. Then you finally solve the problem, and all you have to say is "Duh!" And the task that was supposed to take 4 hours has morphed into a two-day effort. And now you're behind schedule.

When estimating projects, I know to add 30% to whatever number I come up with. This is my "fudge factor". A fudge factor that allows for the inevitable "Duh" moments not accounted for up front, even if I make an effort to be conservative as to the anticipated productivity in my estimate. Breathing room for the things that pop up during a project.

Thirty percent sounds like a lot. And it is. I always feel as if I am padding the estimate. It is tempting to to be the hero who can deliver the project in an impressively timely manner. But the stress and loss of credibility of delivering late more than cancels that out. And time and time again, I am grateful for that thirty percent. I am glad that I planned for "Duh!"

What was my latest "Duh!" you ask?

I was working on a web application that was using the asp menu control. One section of the app was to function as a wizard, with "Continue" and "Back" buttons serving as the navigation, and the menu simply indicating which step of the wizard the user is at for non-authenticated users. The desired behavior for a non-authenticated user was that the menu be completely disabled, with the menu items indicating which step the user is at by which one is selected. An authenticated user would be have the ability to use the menu to land on which ever step (page) they desire. Hmm, that's easy. Just make the menu disabled for non-authenticated users. Oops, now the page won't load because it can't reference the selected item in a group that is disabled. Move this to the end of the Page Load. Now the page loads fine, but the menu item of the current step does not appear as selected. Assumption: Setting the Enabled or Selectable properties of the menu or the menu items would cause the menu to be rendered with no item appearing as selected when the page finished loading. DID NOT TEST ASSUMPTION. Onto another path. Playing with style sheets. Playing with the controls' methods. Playing with javascript because we don't even want to post back if the user clicks on the menu. Getting another set of eyes to look at the problem, and demonstrating to him that setting the Selectable property of the menu items to false at the end of Page Load renders the menu with nothing selected. Umm... it's working as I need it to. The menu is disabled and non-clickable, but the current selection is highlighted on the menu. Click through the wizard, and the highlighted menu item changes. My assumption held true only for the menu control and it's enabled property, not the selectable property of the menu items.

protected void Page_Load(object sender, EventArgs e)
{

//snip...

if (!User.Identity.IsAuthenticated)
    {
        LeftMenu.Items[0].Selectable = false;
        LeftMenu.Items[1].Selectable = false;
        LeftMenu.Items[2].Selectable = false;
    }

}

Duh!

Four hours. Four lines of code.

Update: I should point out that the 30% addition applies only to the development phase, not the estimate in its entirety.

Customize your TFS Template

Kirstin Juhl — Tue, 24 Jun 2008 04:14:01 GMT

One of the questions that came out of my TFS talk at the Magenic Technology Summit was:

How do you go about customizing one of the existing templates provided for TFS, such as MSF Agile? We may want to add new types for Work Items, for example, or add new states that work items can be in.

The easiest way to do this is through the Visual Studio Team System 2008 Team Foundation Server Power Tools.

If you do not have the Power Tools installed, you can still do this by editing the XML that makes up the templates.

First, get the existing template that you want to customize by clicking Team > Team Foundation Server Settings > Process Template Manager. Select the template you want to customize by selecting it and click "Download".

The process template will be downloaded to the specified directory. The process template is nothing more than a set of XML files organized into folders by function. The top-level folder is the name of the template.

In this case, I have downloaded the MSF for Agile Software Development - v4.2:

I HIGHLY suggest changing the name of the template as your first modification, so that if you mess up the template (easy to do), you can start over by downloading the unchanged vanilla template. A this point I also change the name of the top-level directory for the Process Template.

In ProcessTemplate.xml, make the following changes:

<?xml version="1.0" encoding="utf-8" ?>
<ProcessTemplate>
<metadata>
<name>MSF for Agile Software Development - v4.2 - MODIFIED</name>

Now you are ready to create a new type of work item.

First, open workitems.xml and add your new work item type:

- <task id="WITs" name="WorkItemType definitions" plugin="Microsoft.ProjectCreationWizard.WorkItemTracking"         completionMessage="Work item types created">
-     <taskXml>
-         <WORKITEMTYPES>
            <WORKITEMTYPE fileName="WorkItem Tracking\TypeDefinitions\Bug.xml" />
            <WORKITEMTYPE fileName="WorkItem Tracking\TypeDefinitions\Task.xml" />
            <WORKITEMTYPE fileName="WorkItem Tracking\TypeDefinitions\Qos.xml" />
            <WORKITEMTYPE fileName="WorkItem Tracking\TypeDefinitions\Scenario.xml" />
            <WORKITEMTYPE fileName="WorkItem Tracking\TypeDefinitions\Risk.xml" />

<WORKITEMTYPE fileName="WorkItem Tracking\TypeDefinitions\NewWorkItemType .xml" />

</WORKITEMTYPES>
</taskXml>
</task>

Next you need to create the template for your work item type: in the TypeDefinitions folder, open the XML for the work item most like the new one that you are creating.

The FIRST step is to save this XML document with the new name. The name is the what you typed into the ProcessTemplate.xml, in this case, "NewWorkItemType.xml"

After you have saved the new template, you can make the modifications that you need.

In the <FIELDS> section, you can delete, modify, or add the fields that you want to appear on your new work item type.

In the <WORKFLOW> section, you can add, modify, or delete states for your new work item.

For example: to add a new state called "Estimate", you would add the following xml to the <WORKFLOW><STATES> section:

<STATE value="Estimate" /> </STATE>

Here, you can also set field values and transition behavior - topics that will be covered in a future post.

When you are finished with your modifications, you can Upload the process template the same way that you downloaded it, by browsing to the new folder and clicking "Upload".

Here you can see my Process Template Dialog after a successful Process Template upload:

This template is now available for me to create a project from:

When I select the new template for my new project, I can see the new work item type:

Using the Power Tools gives us a graphical interface to the process templates: A few screen shots are shown, but we will not go into using the Power Tools here. Using the Power Tools is a much easier and safer way to modify your process templates, and I highly recommend that you download them and give them a whirl!

Update: Your TFS User or Group must have been granted the "Manage process template" permission in order to customize the templates.