Window code, note that we are binding the Overlay to the ImageSource property of the Counter.

<Window x:Class="IMAPChecker.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:main="clr-namespace:IMAPChecker"
>
      <Window.TaskbarItemInfo>
        <TaskbarItemInfo 
            Overlay="{Binding ElementName=Counter, Path=ImageSource}" 
            />         
    </Window.TaskbarItemInfo>
    


    <Grid Margin="10">
       …

            <main:CountControl x:Name="Counter"  
                               DisplayCount="{Binding Path=Unseen}"                               
                               HasIssue="{Binding Path=HasError}"
                               IsChecking="{Binding Path=IsChecking}"
                               />
      …
     </Grid>
</Window>

The counter control Xaml is mainly defining brushes.

<UserControl x:Class="IMAPChecker.CountControl"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:cc="clr-namespace:IMAPChecker"
             mc:Ignorable="d" Height="16" Width="16">

    <UserControl.Resources>
        <BooleanToVisibilityConverter x:Key="boolToVisibility"/>

        <RadialGradientBrush  x:Key="EmptyBrush"
                              GradientOrigin="0.5,0.1" Center="0.5,0" RadiusX="2" RadiusY="0.9" >
            <GradientStop Color="#a0ffffff" Offset="0" />
            <GradientStop Color="#40ffffff" Offset="0.6"/>
            <GradientStop Color="#40000000" Offset="0.7"/>
            <GradientStop Color="#00000000" Offset="1.25"/>
        </RadialGradientBrush>

        <RadialGradientBrush  x:Key="HighlightBrush"
                              GradientOrigin="0.5,0.1" Center="0.5,0" RadiusX="2" RadiusY="0.9" >
            <GradientStop Color="LightGreen" Offset="0" />
            <GradientStop Color="Green" Offset="0.6"/>
            <GradientStop Color="DarkGreen" Offset="0.7"/>
            <GradientStop Color="Green" Offset="1.25"/>
        </RadialGradientBrush>

        <RadialGradientBrush  x:Key="MutedBrush"
                              GradientOrigin="0.5,0.1" Center="0.5,0" RadiusX="2" RadiusY="0.9" >
            <GradientStop Color="LightYellow" Offset="0" />
            <GradientStop Color="CornflowerBlue" Offset="0.6"/>
            <GradientStop Color="Blue" Offset="0.7"/>
            <GradientStop Color="Gray" Offset="1.25"/>
        </RadialGradientBrush>

        <RadialGradientBrush  x:Key="CheckingBrush"
                              GradientOrigin="0.5,0.1" Center="0.5,0" RadiusX="2" RadiusY="0.9" >
            <GradientStop Color="LightYellow" Offset="0" />
            <GradientStop Color="Gold" Offset="0.6"/>
            <GradientStop Color="GoldenRod" Offset="0.7"/>
            <GradientStop Color="Gold" Offset="1.25"/>
        </RadialGradientBrush>

        <RadialGradientBrush  x:Key="IssueBrush"
                              GradientOrigin="0.5,0.1" Center="0.5,0" RadiusX="2" RadiusY="0.9" >
            <GradientStop Color="LightPink" Offset="0" />
            <GradientStop Color="Red" Offset="0.6"/>
            <GradientStop Color="DarkRed" Offset="0.7"/>
            <GradientStop Color="Red" Offset="1.25"/>
        </RadialGradientBrush>
    </UserControl.Resources>
    <Border BorderThickness="1" Name="ColourBorder"
        CornerRadius="5" 
        HorizontalAlignment="Stretch"
        VerticalAlignment="Stretch"
        Background="{StaticResource CheckingBrush}">

        <Viewbox HorizontalAlignment="Center">
            <TextBlock Name="TextBlock"
                    HorizontalAlignment="Stretch" VerticalAlignment="Center"
                    TextAlignment="Center" TextWrapping="NoWrap" 
                    Foreground="Gray" FontWeight="Bold"  
                    Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type cc:CountControl}}, Path=DisplayCount}"
                    />
            <!--Text="1"-->
        </Viewbox>

        <Border.BorderBrush>
            <LinearGradientBrush EndPoint="1,1" StartPoint="0,0">
                <GradientStop Color="LightGray" Offset="0" />
                <GradientStop Color="DarkSlateGray" Offset="1" />
            </LinearGradientBrush>
        </Border.BorderBrush>
    </Border>

</UserControl>

The fun begins in the code behind, first there is state logic mapping the state to brushes, which I could alternatively do via a Convertor but the logic seemed to be part of the control so made sense here

public partial class CountControl : UserControl
 {
     public CountControl()
     {
         InitializeComponent();
         InitializeBitmapGeneration();
         DisplayCount = 40;
     }

     public static readonly DependencyProperty DisplayCountProperty = DependencyProperty.Register(
         "DisplayCount",
         typeof(int),
         typeof(CountControl),
         new UIPropertyMetadata(0,
             (d, e) => ((CountControl)d)._OnDisplayChanged()));

     public static readonly DependencyProperty HasIssueProperty = DependencyProperty.Register(
      "HasIssue",
      typeof(bool),
      typeof(CountControl),
      new UIPropertyMetadata(false,
          (d, e) => ((CountControl)d)._OnDisplayChanged()));

     public static readonly DependencyProperty IsCheckingProperty = DependencyProperty.Register(
   "IsChecking",
   typeof(bool),
   typeof(CountControl),
   new UIPropertyMetadata(false,
       (d, e) => ((CountControl)d)._OnDisplayChanged()));

     public static readonly DependencyProperty HasVolumeProperty = DependencyProperty.Register(
   "HasVolume",
   typeof(bool),
   typeof(CountControl),
   new UIPropertyMetadata(false,
       (d, e) => ((CountControl)d)._OnDisplayChanged()));

     public int DisplayCount
     {
         get { return (int)GetValue(DisplayCountProperty); }
         set { SetValue(DisplayCountProperty, value); }
     }

     public bool HasIssue
     {
         get { return (bool)GetValue(HasIssueProperty); }
         set { SetValue(HasIssueProperty, value); }
     }

     public bool HasVolume
     {
         get { return (bool)GetValue(HasVolumeProperty); }
         set { SetValue(HasVolumeProperty, value); }
     }

     public bool IsChecking
     {
         get { return (bool)GetValue(IsCheckingProperty); }
         set { SetValue(IsCheckingProperty, value); }
     }

     private void _OnDisplayChanged()
     {
         ImageSource = null;
         if (IsChecking)
         {
             ColourBorder.Background = (Brush)Resources["CheckingBrush"];
             TextBlock.Foreground = Brushes.Black;
             return;
         }

         if (HasIssue)
         {
             ColourBorder.Background = (Brush)Resources["IssueBrush"];
             TextBlock.Foreground = Brushes.White;
             return;
         }

         if (HasVolume == false)
         {
             ColourBorder.Background = (Brush)Resources["MutedBrush"];
             TextBlock.Foreground = Brushes.Black;
             return;
         }

         if (DisplayCount == 0)
         {
             ColourBorder.Background = (Brush)Resources["EmptyBrush"];
             TextBlock.Foreground = Brushes.Black;
         }
         else
         {
             ColourBorder.Background = (Brush)Resources["HighlightBrush"];
             TextBlock.Foreground = Brushes.White;
         }


     }

And then we have the fun part where we convert the Control into an image.

   #region Should be in base class

        protected void InitializeBitmapGeneration()
        {
            LayoutUpdated += (sender, e) => _UpdateImageSource();
        }

        public static readonly DependencyProperty ImageSourceProperty = DependencyProperty.Register(
           "ImageSource",
           typeof(ImageSource),
           typeof(CountControl),
           new PropertyMetadata(null));

        /// <summary>
        /// Gets or sets the ImageSource property.  This dependency property 
        /// indicates ....
        /// </summary>
        public ImageSource ImageSource
        {
            get { return (ImageSource)GetValue(ImageSourceProperty); }
            set { SetValue(ImageSourceProperty, value); }
        }

        private void _UpdateImageSource()
        {
            if (ActualWidth == 0 || ActualHeight == 0)
            {
                return;
            }
            ImageSource = GenerateBitmapSource(this, 16, 16);
        }

        public static BitmapSource GenerateBitmapSource(ImageSource img)
        {
            return GenerateBitmapSource(img, img.Width, img.Height);
        }

        public static BitmapSource GenerateBitmapSource(ImageSource img, double renderWidth, double renderHeight)
        {
            var dv = new DrawingVisual();
            using (DrawingContext dc = dv.RenderOpen())
            {
                dc.DrawImage(img, new Rect(0, 0, renderWidth, renderHeight));
            }
            var bmp = new RenderTargetBitmap((int)renderWidth, (int)renderHeight, 96, 96, PixelFormats.Pbgra32);
            bmp.Render(dv);
            return bmp;
        }

        public static BitmapSource GenerateBitmapSource(Visual visual, double renderWidth, double renderHeight)
        {
            var bmp = new RenderTargetBitmap((int)renderWidth, (int)renderHeight, 96, 96, PixelFormats.Pbgra32);
            var dv = new DrawingVisual();
            using (DrawingContext dc = dv.RenderOpen())
            {
                dc.DrawRectangle(new VisualBrush(visual), null, new Rect(0, 0, renderWidth, renderHeight));
            }
            bmp.Render(dv);
            return bmp;
        }
        #endregion

    }
}

Everybody has a personal standard. We all like to think it’s pretty good. but sometimes we do a piece of work and we feel that we excel way above those standards. Last night was one of those for me.

I was leaving work until 6:30, and my boss wanted to talk about adding some functionality to allow us to a UI that start/stops individual things, so that it could also start/stop many things. But the UI is currently tree based, so how could this be achieved…

Fortunately I’d based the UI to look very much like Windows Explorer/Control Panel and finally I had a reason to implement search, the box in the top right. This way I could search for a set of processes, and then start/stop all. Even better the UI was shared with a personal project I was working on that wanted context sensitive search too, so at 8pm I rolled my sleeves up, sat down, and everything just worked perfectly.

First I implemented something that was so close to ICommandSource, that when I came across it, it seemed a perfectly natural progression. Later I realised why ICommandSource exists but not all controls use it, so I dropped the interface and kept the intent. I was struggling to correctly watermark the search box until I came across DataTrigger and only one StackOverflow search to find out why it wasn’t working properly.

Suddenly I realised I’d taken a simple restyling of a NavigationWindow into a new control, I’d investigated and learned new features, I’d worked inside an MS framework, and had decided when was best to follow other standards that closely align but not slavishly dictate the framework where it was of no value. I’d even sorted out a nasty bug that I’ve been struggling with for days, just by glimpsing at it. I was on fire. I just need to make sure I can carry on like this to see if I can get my personal standard up even higher.

I’ll follow this up with some posts describing this UI control, but for now you can see my previous post on RedGreenRefactor to see an example of this.

I have some ideas about a tool to assist and support Red Green refactor cycles as you follow a TDD loop, and my first iteration towards that is now available. This is incredibly basic right now from where I intend to take it.

Usage

This is the basic process to use RedGreenRefactor right now.

Startup

You need to select a Visual Studio solution to monitor. You can change to another at any time on the Settings page.  RedGreenRefactor will parse the projects (*.csproj) and find all those that use a test framework (only nBehave supported in this release)

Define the intent of one or many test cycles

Now go to the test cycles list and add what you think you intend to change, and if you want to group them by release. Start to work on your first cycles.

Working on an Intention

Start your TDD cycle, so in VS add a new test. Every time you recompile, RedGreenRefactor will run the tests automatically and record the results. Over time you build up a history of your changes.

Home Page

Right now the Home Page tries to give you everything you need and is starting to show a small fragment of the reporting capabilities planned.

Download

Download RedGreenRefactor.0.1.123.121.msi

What is the tool for?

Right now, RedGreenRefactor will automatically run your tests every time you re-compile or click Run Now. My original idea was to simply capture these and provide reports back on how you are doing.

I use RedGreenRefactor to help ensure I’ve followed my cycle through failing tests (including having Pending specification steps) and then into Green, and refactor. My plan is to get RedGreenRefactor to help with that and marking the difference between test development (i.e. Red stage) and functional development (i.e. Green and Refactor). However by collecting these test runs, I think many more useful reports can be made available, ranging from estimation assistance (length of time that changes were made including a set of keywords), productivity (number of tests), and personal contribution to coverage are just a few.

In addition I also think that simple things like better check in comments in your VCS of choice can be easily achieved if a tool knows what you have changed. In addition I recognise that there is a relationship between test cycles and bug fixes so integrate with tools such as JIRA may also be relevant.

Future functionality

• Support more test frameworks e.g. nUnit, mbUnit
• Detect refactorings and code transformations
• Detect change to coverage levels
• Support workflows (e.g. UI only changes may not generate a Red phase)
• Generate reports
• Integrate with version control (so we simplify the commit cycle)
• Integrate with VS
• Integrate with Bug Trackers

Another of those posts that’s actually a bookmark for myself.

The Transformation Priority Premise by Uncle Bob Martin. http://cleancoder.posterous.com/the-transformation-priority-premise

This really has got me thinking at the moment, in fact I’m wondering if it might be worth doing in association with a “TDD as if you meant it” session (designed by Keith Braithwaite but described here). In this session we can walk the willing victim (I’ll never forget Keith being my conscience ) through the minimal TDD but at decribe this in terms of transformations. I think it would be really interesting to take feedback from an audience while the coder is headphoned, or even better working remotely, so they can’t hear what we are describing.

aka Value types vs Reference types

Thanks Eric, I’m never going to get another job.

If you are employed in the C# world, then you’ve been through an interview process. I think I have a better chance of becoming a millionaire by betting everybody that has a C# job £10 that they were asked the difference between value types and reference types as an interview question, than by winning the lottery. It is one of the de-facto questions that you ask as an interviewer and expect to be asked as a candidate. The answer that people want to hear is simple,

Value types go on the stack, Reference types go on the heap.

Except that is wrong according to that man who knows. Don’t believe me, go read The Truth About Value Types.

The dilemma

So here’s the problem, do I tell people what they want to hear or what I now know is correct? Can I interrupt an interview and ask if they read Eric Lippert’s Fabulous adventures in coding, before I answer the next question?

I think from now on, I’m damned. Now I know the truth there is no way I can keep quiet, I’m not that kind of person. Then again, who likes being corrected in an interview?

Thanks Eric, I’m never going to pass another interview.

I’ve been struggling to get a custom layout working for an items control due to a large number of Double.Nan being exposed. Finally I found the answer in the MSDN docs (that’ll teach me).

http://msdn.microsoft.com/en-us/library/system.windows.frameworkelement.measureoverride.aspx

It appears there are three sizes for each WPF framework element.

Height, Width – As defined at design time

ActualHeight, ActualWidth – Where the sizes will end up once the calls to elem.Arrange(…) via ArrangeOverride of the Collection control have completed

and introducing..

DesiredSize.Height, Desized.Width – which is the value that was returned in each UIElements.MeasureOverride(…)

This means that for complex layouts you will need to calculate the entire appearance at Measure time, and then again and Arrange time.