2,000 Things You Should Know About WPF

#500 – Sharing an Event Handler Across Multiple Controls, Method 1

Sean — Thu, 23 Feb 2012 11:00:12 +0000

You can use the same event handler for more than one control by specifying the handler for each control and pointing to the same event handler code.

In the example below, we have three buttons, each of which wires up a handler for the Click event, but using the same handler (Button_Click).

In the Button_Click event handler, we can check the Source property of the RoutedEventArgs parameter to determine which button sent us the event.

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            // Get at originator of event using RoutedEventArgs.Source property

            Button b = e.Source as Button;
            MessageBox.Show(string.Format("You clicked on {0} button", b.Content));
        }

Filed under: Events Tagged: Event Handler, Events, RoutedEventArgs, WPF

#499 – Interacting with the Control That Initiated an Event

Sean — Wed, 22 Feb 2012 11:00:06 +0000

In WPF, you do not have to provide a name for every control in your user interface. Since so much is accomplished through data binding, you often don’t need to interact with a control at all from your code.

But one scenario where you might want to interact with a control is from an event handler for an event that the control initiated. Every event handler will have a sender argument that represents the control that fired the event. You can cast this argument to the appropriate type to get at the original control.

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            Button b = sender as Button;
            b.Width = b.ActualWidth + 1;
        }

Filed under: Controls Tagged: Controls, Event Handlers, WPF

No Post Today

Sean — Tue, 21 Feb 2012 12:28:42 +0000

2,000 Things / WPF is on hiatus today–back tomorrow.

Filed under: Uncategorized

#498 – A List of WPF Blogs and Forums

Sean — Mon, 20 Feb 2012 11:00:09 +0000

Though many WPF bloggers have long since moved on to greener pastures, there are still a few blogs out there that either still have good WPF content or that still blog about WPF/XAML. Here is a list of the most useful blogs and forums.

Attached WPF (Jason Rainwater)
Bea Stollnitz on WPF and Silverlight
Confessions of a Coder (Pete O’Hanlon)
C# Disciples (Marlon Grech)
Delay’s Blog (David Anson)
Dr. WPF
Jaime Rodriguez
JAPF (Jeremy Alles)
Josh Smith on WPF (Josh Smith)
Joymon’s World of WPF (Joy George)
Kent Boogaart
Lester’s WPF/SL Blog (Lester Lobo)
Matt Hamilton.NET
Random Ramblings (Leom Burke)
Rob Relyea (now blogging about Kinect for Windows)
sachabarber.net (Sacha Barber)
Interknowlogy Blogs (Tim Huckaby)
Wandering Through the Wilderness (Mark Smith)
Windows Presentation Foundation (Microsoft, WindowsClient.NET)
WPF Discussions (Codeplex)
WPF Forum (MSDN)
WPFpedia (Actipro Software)
WPF: A Beginner’s Guide (Sacha Barber)
XAML Wonderland (Walt Ritscher)
10REM.NET (Pete Brown)

Filed under: Miscellaneous Tagged: Blogs, Miscellaneous, WPF

#497 – Use a UniformGrid to Make a Group of Buttons the Same Size

Sean — Fri, 17 Feb 2012 11:00:45 +0000

You can use a StackPanel to make its child elements the same size in one of its dimensions. This is harder to do in the other dimension.

The example below uses a StackPanel to contain some buttons. They end up the same height, but are still different widths.

You can make the buttons the same height and width using a UniformGrid instead of a StackPanel.

The UniformGrid will make sure that each cell is the same height and the same width. This is desirable because you then avoid having to set the button sizes manually.

Filed under: Layout Tagged: Layout, StackPanel, UniformGrid, WPF

#496 – Using a StackPanel to Make a Group of Buttons the Same Size

Sean — Thu, 16 Feb 2012 11:00:49 +0000

You’ll often want to stack a group of buttons in a GUI, vertically or horizontally. You’d typically use a StackPanel to do this.

Let’s say that you want a series of buttons stacked vertically on the right side of a window.

We can use a DockPanel as the main container and add a StackPanel docked on the right and oriented vertically. But when we do this, the StackPanel expands to fill the available space, as does each Button.

The HorizontalAlignment of the StackPanel defaults to Stretch, as do each of the buttons. We could set the HorizontalAlignment for each Button to Right, but the buttons now all size to fit their content, which is not quite what we want.

What we really want is for the HorizontalAlignment of each Button to be Stretch, but for the HorizontalAlignment of the StackPanel itself to be Right. This gives us what we want.

Filed under: Layout Tagged: Layout, StackPanel, WPF

#495 – Binding to a Visibility Property Without Using a Value Converter

Sean — Wed, 15 Feb 2012 11:00:44 +0000

You can use a value converter to convert a string value to a value of type System.Windows.Visibility, allowing data binding to a Visibility property. You can also just set a Visibility property directly to a string, avoiding the need for a value converter.

In the example below, we bind to the Content property of a ComboBoxItem, which we access through the SelectedValue property of a ComboBox. Since Content contains a string, the binding to Visibility works without a conversion.

Filed under: Data Binding Tagged: Data Binding, Visibility, WPF

#494 – Using a Value Converter to Bind to a Visibility Property

Sean — Tue, 14 Feb 2012 11:00:40 +0000

You can bind the Visibility property of a control to a data item whose type is System.Windows.Visibility. You can also bind to an item whose type is string, provided that the string values returned represent one of the enumerated values from the Visibility type.

The example below shows how to use a value converter to convert from the SelectedValue of a ComboBox (a ComboBoxItem) to the Visibility type.

Code for IValueConverter.Convert:

        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            Visibility visibility = Visibility.Visible;

            try
            {
                if (value != null)
                {
                    ComboBoxItem item = (ComboBoxItem)value;
                    visibility = (Visibility)Enum.Parse(typeof(Visibility), (string)item.Content, false);
                }
            }
            catch { }

            return visibility;
        }

Filed under: Data Binding Tagged: Data Binding, Visibility, WPF

#493 – Setting the Visibility of a User Interface Element

Sean — Mon, 13 Feb 2012 11:00:04 +0000

You can set the visibility of any element that inherits from UIElement by settings its Visibility property to one of the three values listed below. Because every child hosted in a panel derives from UIElement, this is how you hide/show child elements in a panel.

Values for Visibility (of type System.Windows.Visibility):

Visible – element is displayed
Hidden – element is not displayed, but the space where it is located is preserved
Collapsed – element is not displayed and space for it is not preserved

Below is an example that lets a user toggle between the three possible values for the Visibility of the middle Label.

Filed under: Controls Tagged: Collapsed, Controls, Hidden, Visibility, Visible, WPF

#492 – Layout Can Change at Runtime

Sean — Fri, 10 Feb 2012 11:00:41 +0000

One benefit of flow-based layout, as opposed to coordinate-based layout, is that elements in the user interface will size to fit their content. The GUI designer does not have to explicitly set the size and location of each child element.

The layout containers in WPF don’t just position their child elements at design-time, but will re-measure and arrange their child elements when certain properties of the child elements change. For example, if the Content property of a Label control changes, the parent container will update its layout based on the new text.

In the example below, when the Label containing the movie title changes, the buttons to its right shift.

Filed under: Layout Tagged: Layout, WPF