Because of this, you occasionally have a rather urgent need to roll back everyone to the last working version, and this turns out to be rather easy.

In the publish’s output folder you will see a file called “<application name>.application”. This is the ClickOnce Application Deployment Manifest and contains a load of details about the application and in particular the version to install and where to find it.

You will also see an “Application Files” folder which will contain a folder for each version of your application deployed so far. To revert all of your users to a previous version, simply copy the “<application name>.application” file from the relevant version subdirectory over the one in the root, then either point your users at your ClickOnce location or if you had the application set to check for and apply updates automatically just tell them to restart. The application will detect that there is a “newer” version (even if that version is in fact older) and allow the user to install it.

The original TextBox control would automatically set the caret (cursor) position to the end of the text and use ScrollToCaret() to ensure the last line was always visible after dynamically adding content. This doesn’t quite work the same when called on a RichTextBox as it appears to scroll until just the very top of the caret is visible, resulting in at best a few pixels of the last line’s text visible.

Quite a bit of googling of the problem reveals lots of discussion but not much in the way of a suggested solution.

Fortunately, user32.dll provides calls we can use to set the scroll position and we can access these unmanaged functions through P/Invoke as follows:

[StructLayout(LayoutKind.Sequential)]
public class POINT
{
    public int x;
    public int y;

    public POINT()
    {
    }

    public POINT(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

const int SB_VERT = 1;
const int EM_SETSCROLLPOS = 0x0400 + 222;

[DllImport("user32", CharSet = CharSet.Auto)]
static extern bool GetScrollRange(IntPtr hWnd, int nBar, out int lpMinPos, out int lpMaxPos);

[DllImport("user32", CharSet = CharSet.Auto)]
static extern IntPtr SendMessage(IntPtr hWnd, int msg, int wParam, POINT lParam)

Then, when you want to set the scroll position (“control” is your RichTextBox instance):

int min, max;
GetScrollRange(control.Handle, SB_VERT, out min, out max);
SendMessage(control.Handle, EM_SETSCROLLPOS, 0, new POINT(0, max - control.Height));

This is the first of four exams I’m aiming to complete in order to become a Microsoft Certified Professional Developer.

static void Main(string[] args)
{
...
}

with a useful string array of arguments like you do in a regular C# console app, so how do you access them?

In a default WPF application, the entry point to the program is the Application object. This object has an event Startup which is fired, unsurprisingly on startup of your app and contains StartupEventArgs. You can query this object to get to your arguments as follows:

public partial class App : Application
 {
   ///
   /// A static string array containing our start-up command line arguments
   ///
   public static string[] Args;

   protected override void OnStartup(StartupEventArgs e)
   {
       Args = e.Args;
       base.OnStartup(e);
   }
}

Store them in a static member and then you can access them elsewhere in your application as Apps.Args.

So far, so good. But what happens if you actually need some arguments to run, and so want to check and fail gracefully if they don’t exist? I found that if I checked in my OnStartup handler, I still couldn’t halt the start-up of my application on error.

Instead, I added a Loaded event handler to my MainWindow. This is fired once the Application and MainWindow have been loaded so I know I my static Args member will have been set by the time it is fired. I can do all the validation I want on my argument array and decide whether to continue execution or stop and provide an error to the user.

public MainWindow()
{
     InitializeComponent();

     // Make sure the command line arguments have been processed
     this.Loaded += new RoutedEventHandler(MainWindow_Loaded);
}

void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
    if (App.Args.Length == 1)
    {
        // everything is good, do stuff
    }
    else
    {
        // ERROR!!!
        MessageBox.Show("Not enough arguments!");
        App.Current.Shutdown();
     }
}

A google search of the problem shows that I’m not alone. There seems to be as many solutions as there are people posting so in case it’s of any use, here’s what has worked for me every time.

1. Select all of the tracks you wish to group, right-click, and from the context menu select “Get Info”.
2. On the “Info” tab, enter a single space in the “Album Artist” field.
3. On the “Options” tab, set “Part of a compilation” to “Yes”.
4. Click “OK” to make those changes.
5. The album should now be grouped properly, and you’ll see something like this:
6. The only problem is now iTunes thinks that the album’s artist is ” ” and so isn’t listing it as “Various Artists”, so with the tracks selected, right-click and from the context menu select “Get Info” again.
7. This time on the “Info” tab, remove the single space from the “Album Artist” field.
8. Click “OK” to make that change and the album should now be grouped properly and listed as Various Artists.

We have:

• Full Google Maps interaction, plotting all our note hits on a map.
• International support, now you can plot your notes anywhere the Google Maps API can geocode.
• The complete old database! All of your original DoshTracker notes and user accounts have been preserved. These will be imported during the beta.

Check out the new logo and design on www.doshtracker.co.uk and please sign up for our mailing list so we can keep in touch.

Invites to the closed beta test will be going out soon to the mailing list and former users of the old site.

The answer is in one of the attributes of Binding called “UpdateSourceTrigger” which has the following options:

• LostFocus – Update bound property when the control loses focus (TextBox default).
• PropertyChanged – Update bound property in real-time.
• Explicit - Update bound property when UpdateSource() is called

It is this last setting which allows us to delay updating our bound property until we tell it to.

Let’s say we have a UserControl containing a TextBox, ‘MyTextBox’ which is bound to some Dependency Property and two buttons, ‘OK’ and ‘Cancel’. Depending on how you hook your buttons up (with RoutedCommands or click handlers (eugh!)) the ‘OK’ button’s code looks like this:

BindingExpression be = MyTextBox.GetBindingExpression(TextBox.TextProperty);
if (be!=null) be.UpdateSource();

The ‘Cancel’ button’s code does the reverse:

BindingExpression be = MyTextBox.GetBindingExpression(TextBox.TextProperty);
if (be!=null) be.UpdateTarget();

Et voila! Your dependency property will now only update when you want it to.

Following on from my previous post, where I explained how to create a ControlTemplate to style a TextBox in WPF, I’ve got an object, TextEntryBox, which dervies from a TextBox (it provides some custom event handlers when text is entered, but to all intents and purposes, it’s a regular TextBox).

I wanted to style my TextEntryBox, this time including a button within my ControlTemplate (this will eventually toggle an on-screen keyboard pop-up, but that’s another blog post!). I came up with this:

All’s well and good, until I want to try and handle the Click event for that button within my TextEntryBox class. Even Matthew MacDonald’s “Pro WPF in C# 2008″ which has proved a lifesaver for all things WPF since I’ve been working with this technology only had the following words of wisdom;

“You can’t attach event handlers in the control template. Instead, you’ll need to give your elements recognizable names and attach event handlers to them programmatically in the control constructor”

But whatever I tried I couldn’t access the event in my constructor, until I remembered the seperation between the visual and logical trees in WPF.

The template is applied at runtime, and so elements contained within it it are part of the visual tree. My class, and therefore my class’ constructor is executed within the logical tree, so I needed to attach my event handler after the template had been applied. You can do this by overriding OnApplyTemplate in your class, obtain the template that’s being applied, and then you have access to the named button’s events, like this:

public override void OnApplyTemplate()
{
    DependencyObject d = GetTemplateChild("PART_KeyboardPopupButton");
    if (d != null)
    {
        (d as Button).Click += new RoutedEventHandler(KeyboardPopupButton_Click);
    }

    base.OnApplyTemplate();
}

Note the null check, as someone could have applied a completely different template to the object.

Q: If you want to create a ControlTemplate to provide a custom style for a TextBox, how do you specify where the text goes when it’s used in WPF?

A: The answer was hidden in the depths of the MSDN Documentation. You have to include a <ScrollViewer> within your ControlTemplate with an x:Name value of “PART_ContentHost”.

Here’s a noddy example: