Let’s start by writing the grid’s XAML:

<Border BorderBrush="Silver"
        BorderThickness="1"
        HorizontalAlignment="Stretch"
        Margin="0"
        Name="border1"
        VerticalAlignment="Top"
        Height="25">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="{Binding Percentage, Converter={StaticResource DoubleToGridLengthStarConverter}}"/>
            <ColumnDefinition Width="{Binding Percentage, Converter={StaticResource DoubleToInvertedGridLengthStarConverter}}"/>
        </Grid.ColumnDefinitions>

        <Rectangle HorizontalAlignment="Stretch"
                   Grid.Column="0"
                   Margin="0"
                   Fill="{StaticResource PhoneAccentBrush}"
                   StrokeThickness="1"
                   VerticalAlignment="Stretch"/>
    </Grid>
</Border>

The code above creates a Grid (with a border), and adds 2 columns to the grid. The colomns’ width is bound to the DataContext’s Percentage property, and converted using the value-converters we’ll create shorty. We then add a rectangle shape (which will be placed in the first column)

Now, on to the value-converters. For simplicity, and since it might be useful later on, I’ve created 2 converters – the first will handle the widths of the “filled” part of the ProgressBar. The second is used for the remaining “empty” area. The converters are simple – they take a percentage value (in the 0.0 – 1.0 range), and convert them to a GridLength, which will control the width of our columns:

public class DoubleToGridLengthStarConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value == null)
            return null;
        var doubleValue = (double) value;
        return new GridLength(doubleValue, GridUnitType.Star);
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

public class DoubleToInvertedGridLengthStarConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value == null)
            return null;
        var doubleValue = (double)value;
        return new GridLength(1 - doubleValue, GridUnitType.Star);
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

We can then add the 2 converters to our resources:

<Converters:DoubleToGridLengthStarConverter x:Key="DoubleToGridLengthStarConverter" />
<Converters:DoubleToInvertedGridLengthStarConverter x:Key="DoubleToInvertedGridLengthStarConverter" />

Here’s a sample usage, from my upcoming application:

Add this to Andreas Kahler’s solution of using an Expression<Func<T>> parameter to avoid “magic strings” that can be found here: Implementing INotifyPropertyChanged without hard-coded strings

Together, these two solutions result in an easy to use, simple to understand, and change-safe implementation of INotifyPropertyChanged.

A quick bing search brought me to the MSDN page named Naming Files, Paths, and Namespaces that gives a lot of background on filenames, paths, and limitations, which includes the following section:

The “\\?\” prefix can also be used with paths constructed according to the universal naming convention (UNC). To specify such a path using UNC, use the “\\?\UNC\” prefix. For example, “\\?\UNC\server\share”, where “server” is the name of the computer and “share” is the name of the shared folder. These prefixes are not used as part of the path itself. They indicate that the path should be passed to the system with minimal modification, which means that you cannot use forward slashes to represent path separators, or a period to represent the current directory, or double dots to represent the parent directory. Because you cannot use the “\\?\” prefix with a relative path, relative paths are always limited to a total of MAX_PATH characters.

Usually, handling long paths is done by adding a prefix – “\\?\” – to the path. Meaning, the path D:\LongFolderName will become “\\?\D:\LongFolderName”

Handling UNC paths is a little different – you need to add a different prefix – “\\?\UNC\” which means that “\\server\share\” becomes “\\?\UNC\server\share\”

However, after playing a bit with the new site, I’ve started getting errors in the in some of the javascript files. it turned out that the theme I was using called jQuery’s “include” method in several places. When loading the default Index action, things went fine. However, when navigation to other actions, due to the URL including the Controller’s and Action’s name, the “include” method couldn’t find the files due to their relative path.

Obviously, you can’t use MVC’s “Url” helper class from within the JS files to resolve a “~/” URL. The workaround I’ve found is to create a JS prototype in my Layout.chtml file, and use it’s method to resolve the URLs in JS. Here is the code:

<script type="text/javascript">
    Url = function () { };
    Url.prototype = {
        // Resolve ~/ using the MVC view engine
        _relativeRoot: '@Url.Content("~/")',
        // Create an extension method called "resolve"
        resolve: function (relative) {
            var resolved = relative;
            if (relative.charAt(0) == '~' && relative.charAt(1) == '/')
                resolved = this._relativeRoot + relative.substring(2);
            return resolved;
        }
    };

    $Url = new Url();
</script>

In all your JS, you can now use the “resolve” method like this:

$.include($Url.resolve('~/js/jquery.watermarkinput.js'));

WP7: Extra Wide, Horizontally Wrapping PanoramaItem with dynamic ListBox « dotnet Catch.

Here’s a screenshot:

public class ListViewEx : ListView
{
    private const int WM_NOTIFY = 78;
    private const int TTN_FIRST = -520;
    private const int TTN_NEEDTEXT = (TTN_FIRST - 10);

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
    public struct NMHDR
    {
        public IntPtr hwndFrom;
        public Int32 idFrom;
        public Int32 code;
    }

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
    public struct NMTTDISPINFO
    {
        public NMHDR hdr;
        [MarshalAs(UnmanagedType.LPTStr)]
        public string lpszText;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)]
        public string szText;
        public IntPtr hinst;
        public int uFlags;
        public IntPtr lParam;
    }

    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    public static extern IntPtr SendMessage(IntPtr hWnd, IntPtr uMsg, IntPtr wParam, IntPtr lParam);

    protected override void OnNotifyMessage(Message m)
    {
        // Handle only WM_NOTIFY messages
        if (m.Msg != (int)WM_NOTIFY)
        {
            base.OnNotifyMessage(m);
            return;
        }
        // Get the details of the WM_NOTIFY message, in the form of an NMHDR object
        var nmHdr = (NMHDR) Marshal.PtrToStructure(m.LParam, typeof (NMHDR));
        // We will handle only the TTN_NEEDTEXT message
        if (nmHdr.code != TTN_NEEDTEXT)
            return;

        // Calculate the tool-tip
        var tip = CalculateToolTip();
        if (tip == null)
            return;

        // Get the details of the notification message in the form of an NMTTDISPINFO object
        var nmttDispInfo = (NMTTDISPINFO)Marshal.PtrToStructure(m.LParam, typeof(NMTTDISPINFO));

        // Set max-width, to force multi-line tooltips (here, I've hard-coded the max-width to 320px.
        // You can calculated it based on the length of the tool-tip, screen resolution, etc.)
        SendMessage(nmttDispInfo.hdr.hwndFrom, (IntPtr)1048, IntPtr.Zero, (IntPtr)320);

        // Update tool-tip text
        nmttDispInfo.lpszText = tip;
        // Update the handle of the object that will host the tool-tip
        nmttDispInfo.hdr.hwndFrom = m.HWnd;
        
        // Update message information with new data
        Marshal.StructureToPtr(nmttDispInfo, m.LParam, false);
    }

    private string CalculateToolTip()
    {
        // Convert MousePosition to position inside the ListView
        var pt = PointToClient(MousePosition);

        // Perform HitTest, to allow us to find the correct ListView item/subitem
        var hitTestInfo = HitTest(pt);
        var item = hitTestInfo.Item;
        var subitem = hitTestInfo.SubItem;

        // If we didn't hit any item, no need for a tool-tip
        if (item == null)
            return null;

        return string.Format("Tool-tip for item: {0}\r\nSubitem: {1}", item.Index, item.SubItems.IndexOf(subitem));
    }
}

As you can see, the code is not overly complex, but not something that you could have guessed without Googling Binging it first.

We’ll start by adding the following code to the constructor of the App class:

// Global handler for uncaught exceptions.
UnhandledException += OnUnhandledException;

and in the OnUnhandledException method, we’ll ask the user permission to send the error report, and then use the EmailComposeTask task:

var result = MessageBox.Show(
    "Would you like to email the details of this error to the Developer?\n\n"+
    "(No personal information, other than your email address, will be sent to the Developer)",
    "An error has occurred!",
    MessageBoxButton.OKCancel);

if (result == MessageBoxResult.OK)
{
    var task = new EmailComposeTask
            {
                To = "your@hotmail.com",
                Subject = "Error Report: Your App Title",
                Body = "An unhandled exception occurred in App:\n\n" +
                       "Version: 1.0.0.1\n\n" +
                       e.ExceptionObject
            };
    task.Show();
}

This will allow you to receive an email with a few details of the error.

The application allows you to easily manage your book collection. You can read all about the application in the WP7 Books page in this blog, or in the WP7 Marketplace.

The article shows how to easily create services, and have their dependencies automatically resolved by the Windsor container, with minimal changes.