Yes, there are other ways, such as removing invalid values from other boxes, but here was my solution for preventing the invalid property set by cancelling the selection/property set.

WPF sucks in this manner as there isn’t an easy way to update it. You can’t raise the property updated event since the binding ignores those when setting, to avoid recursion issue I suppose. (Yes, developers could defend by not raising the events if the property doesn’t change)

Anyway, the solution is simply to raise the property changed after the operation, by simply posting it to the work queue on the UI thread right afterward.

Code: in C#

public MyHeaderType SelectedHeader
      {
          get { return this.selectedHeader; }
          set
          {
              bool resetMe= validateValue(value);
              var origVal = selectedHeader;//store for reset

              selectedHeader = value;
              RaisePropertyChanged(() => SelectedHeader);

              if (resetMe)//Why do I need to set the value above? No idea. Doesn’t work unless I do it that way. Yes. I tried.
              {
                  Application.Current.Dispatcher.BeginInvoke( //force a reenter to put it back……
                                new Action(() =>
                                {
                                    SelectedHeader = origVal;//put me back to the correct value.
                                }),
                                DispatcherPriority.ContextIdle,
                                null
                            );                           
              }
          }
      }

Happy Coding!

Well, the issue is two fold. First, you need to set the cell contents to stretch. Then you need to get past the fact the column pads the cell by 6 pixels left and right.

Handling the padding is here:

 <Style TargetType="Border" x:Key="columnBorder">                                <Setter Property="Margin" Value="-6,-2,-6,-6"/>                                <Setter Property="Padding" Value="6,2,6,6"/>

</Style>

 

Set the HorizontalContentAlignment on the ListView or GridView.

Hope this helps.

I googled around for other entries and found this one with more detail than I wanted to write.

http://www.interact-sw.co.uk/iangblog/2007/05/30/wpf-listview-column-margins

Happy coding!

Well, simple solution to an annoying problem. Use the converter below on your binding and it becomes opposite day.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Data;
 
namespace Seekford{
    public class BooleanNotConverter : IValueConverter
    {
        //easy peezy.
 
        /// <summary>
        /// Converts a value.
        /// </summary>
        /// <param name="value">The value produced by the binding source.</param>
        /// <param name="targetType">The type of the binding target property.</param>
        /// <param name="parameter">The converter parameter to use.</param>
        /// <param name="culture">The culture to use in the converter.</param>
        /// <returns>
        /// A converted value. If the method returns null, the valid null value is used.
        /// </returns>
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            return !(bool)value;
        }
 
        /// <summary>
        /// Converts a value.
        /// </summary>
        /// <param name="value">The value that is produced by the binding target.</param>
        /// <param name="targetType">The type to convert to.</param>
        /// <param name="parameter">The converter parameter to use.</param>
        /// <param name="culture">The culture to use in the converter.</param>
        /// <returns>
        /// A converted value. If the method returns null, the valid null value is used.
        /// </returns>
        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            return !(bool)value;
        }
 
        
    }
}

Happy Coding!

WPF makes restyling controls incredibly easy. So much, I switched gears from a WinForms project to use WPF to make the interface look great without resorting to a million third party controls.

I assume you are familiar with WPF and know how to apply a style to a control. Well, apply this to a Button. Just paste the code below in your UserControl.Resources or Window.Resources section and then apply the Style={StaticResource LinkButton} to the button.

Note: I hate underlined links. You can add the underline by changing the TextFormatter on the TextBlock wrapping the content presenter.

  <Style x:Key="LinkButton" TargetType="Button">

            <Setter Property="Template">

                <Setter.Value>

                    <ControlTemplate TargetType="Button">

                        <TextBlock>

                    <ContentPresenter />

                        </TextBlock>

                    </ControlTemplate>

                </Setter.Value>

            </Setter>

            <Setter Property="Foreground" Value="Blue" />

            <Setter Property="Cursor" Value="Hand" />

            <Style.Triggers>

                <Trigger Property="IsMouseOver" Value="true">

                    <Setter Property="Foreground" Value="Red" />

                </Trigger>

            </Style.Triggers>

        </Style>

Happy Coding!

Well, since the DataContext to the content is not the main view model but the individual data item that is in the ItemSource for the ItemsControl, you have to get creative.

Enter the RelativeSource binding. This great tool allows you to search up in the visual hierarchy and grab different data contexts. Simply put, I use the FindAncestor to search for my main UserControl instance, and then go off its DataContext to grab the command. Nice and easy.

Below is the code. Should be easy to follow:

<Window x:Class="SSI.Views.SelectorView"
             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"
              mc:Ignorable="d"
             xmlns:views="clr-namespace:SSI.I8N.LanguagePackEditor.Views"
        Title="SSI">
                <ItemsControl Margin="0" ItemsSource="{Binding Folders}">
<ItemsControl.ItemTemplate>
<DataTemplate>
 <Button Content="{Binding}" Command="{Binding DataContext.FolderCommand,RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type views:SelectorView}}}" CommandParameter="{Binding}"/>
                </DataTemplate>
           </ItemsControl.ItemTemplate>
</ItemsControl></Window>

Happy coding!

So, I created an App.xaml, deleted my Programs.cs and Main and went compile.

Boom! Error, no Main method. hmmmm… I stared at another one of my WPF projects and didn’t see the magic missing setting. Finally, it dawned on. The compile options for the App.xaml.

Set the compile option to Application Definition and away you go. So simple, yet so non-obvious.

Happy Coding!

You could select multiple rows, but when you then clicked on the selection area to “drag” them, then it would unselect everything but the one you specifically clicked on.

Not the greatest of behaviors.

So the trick is rather simple, yet strange. Override the ListViewItem class, and use it to override the generated items.

Your new ListView

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Controls;
using System.Windows;
using System.Collections.ObjectModel;
using System.Collections;
using System.Collections.Specialized;
using System.Windows.Controls.Primitives; 

namespace Seekford{
    public class MyListView: ListView    {
        protected override DependencyObject GetContainerForItemOverride()
        {            return new MyListItem();
       }
     protected override bool IsItemItsOwnContainerOverride(object item)
      {
           return item is MyListItem;
       } 

     }
}

Your new ListViewItem

using System;
using System.Windows.Controls;
using System.Windows.Input;
using System.ComponentModel;

namespace Seekford{
      public class MyListItem : ListViewItem	{

        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
        {
            if (IsSelected)
                return;
            base.OnMouseLeftButtonDown(e);
       }

        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
        {
            if(IsSelected)
                base.OnMouseLeftButtonDown(e);
        }
 }
}

Nice and easy! Kludgy, but seems to work.

Happy Coding!

Well, it’s as simple as putting a GridViewHeader into the GridViewColumn definition and setting content to it.

<GridViewColumn  Width="Auto">
    <GridViewColumnHeader>
        <Grid HorizontalAlignment="Right" >
                <Grid.RowDefinitions>
                    <RowDefinition/>
                </Grid.RowDefinitions>
                <TextBlock Text="{Binding Title, Mode=OneWay}" Grid.Row="0" HorizontalAlignment="Right" />
             </Grid>
    </GridViewColumnHeader>
</GridViewColumn>

See. Nice and easy right? Just fill in the different UI controls you want to make it fit your needs and away you go.

Happy Coding!

It turns out this seemingly simple task is, well, actually quite simple. It is really easy to spend a number of hours looking for the “magic” tag, property, etc. to do this. You will find out though, it’s all about having style.

You simply need to set the HorizontalContentAlignment on the style for the header to align everything however you want to.

Take a look at the following code:

<GridViewColumn  Width="Auto"  >
 <GridViewColumn.HeaderContainerStyle>
    <Style  TargetType="{x:Type GridViewColumnHeader}">
            <Setter Property="HorizontalContentAlignment" Value="Right" />
    </Style>    
 </GridViewColumn.HeaderContainerStyle>
</GridViewColumn>

What we are doing is setting the HorizontalContentAlignment to right aligned. This will cause the contents of the header to all shift to the right. If you are using your own template, make sure to right align the textblocks and other controls as well. Otherwise, it probably won’t look right.

Nice and easy, right?

Happy Coding!

Since I transitioned to a new WPF project, handed off the Silverlight work, I have been trying to keep the same MVVM pattern. I wanted to get the double click off of my TreeViewItem so the child node could invoke the ViewModel to execute a Command.

Here is the behavior I wrote to handle this simple task.

Snippet

using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Controls;

namespace Seekford.Behaviors
{
    public static class MouseDoubleClickBehavior
    {
        /// <summary>
        /// Hooks up a weak event against the source Selectors MouseDoubleClick
        /// if the Selector has asked for the HandleDoubleClick to be handled
        ///�
        /// If the source Selector has expressed an interest in not having its
        /// MouseDoubleClick handled the internal reference
        /// </summary>
        private static void OnHandleDoubleClickCommandChanged(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            FrameworkElement ele = d as FrameworkElement;
            if (ele != null)
            {
                ele.MouseLeftButtonDown -= OnMouseDoubleClick;
                if (e.NewValue != null)
                {
                    ele.MouseLeftButtonDown += OnMouseDoubleClick;
                }
            }
        }

        /// <summary>
        /// TheCommandToRun : The actual ICommand to run
        /// </summary>
        public static readonly DependencyProperty DoubleClickCommandProperty =
            DependencyProperty.RegisterAttached("DoubleClickCommand",
                typeof(ICommand),
                typeof(MouseDoubleClickBehavior),
                new FrameworkPropertyMetadata((ICommand)null,
                    new PropertyChangedCallback(OnHandleDoubleClickCommandChanged)));

        /// <summary>
        /// Gets the TheCommandToRun property. �
        /// </summary>
        public static ICommand GetDoubleClickCommand(DependencyObject d)
        {
            return (ICommand)d.GetValue(DoubleClickCommandProperty);
        }

        /// <summary>
        /// Sets the TheCommandToRun property. �
        /// </summary>
        public static void SetDoubleClickCommand(DependencyObject d, ICommand value)
        {
            d.SetValue(DoubleClickCommandProperty, value);
        }

        #region Handle the event

        /// <summary>
        /// Invoke the command we tagged.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void OnMouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            //check for double clicks.
            if (e.ClickCount != 2)
                return;
            FrameworkElement ele = sender as FrameworkElement;

            DependencyObject originalSender = e.OriginalSource as DependencyObject;
            if (ele == null || originalSender == null)
                return;

            ICommand command = (ICommand)(sender as DependencyObject).GetValue(DoubleClickCommandProperty);

            if (command != null)
            {
                if (command.CanExecute(null))
                    command.Execute(null);
            }
        }
        #endregion
    }

}

Hopefully this helps you.

Oh, how to use. Almost forgot:

Snippet

xmlns:infraBehaviors="clr-namespace:Seekford.Behaviors;assembly=Seekford"

Snippet

 <Grid infraBehaviors:MouseDoubleClickBehavior.DoubleClickCommand="{Binding MyCommand}"  HorizontalAlignment="Stretch" >
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="Auto"/>       �
                </Grid.ColumnDefinitions>
                <Grid.RowDefinitions>
                    <RowDefinition></RowDefinition>
                </Grid.RowDefinitions>
                <TextBlock Text="{Binding Name}" TextWrapping="Wrap" FontWeight="Bold"  Grid.Column="0"  />
            </Grid>

Of course, make your own namespace and correct accordingly. But you already knew that.

Happy Coding!