The following XAML demonstrates a Button, RadioButton, TextBox, and TextBlock (all from the System.Windows.Controls namespace) that display content surrounded by braces (see Figure 3-1):

<Window x:Class="Recipe_03_01.Window1"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     Title="WPF Recipes 3_01" Height="200" Width="250">
     <StackPanel>
         <Button Content="{}{A Button}" Margin="10"
                Name="button1" Width="75" />
         <RadioButton Content="{}{A RadioButton}"
                HorizontalAlignment="Center" Margin="10" />
         <TextBox Text="{}{A TextBox}" HorizontalAlignment="Center"
                Margin="10" />
         <TextBlock HorizontalAlignment="Center" Margin="10"
                Text="{}{A TextBlock}" />
     </StackPanel>
</Window>

Figure 3-1. Control content surrounded by braces

The following XAML demonstrates how to create the formatted TextBlock control shown in Figure 3-2:

<Window x:Class="Recipe_03_02.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_02" Height="100" Width="300">
    <Grid>
        <TextBlock FontFamily="Tahoma, Arial"
                   FontSize="20"
                   FontStyle="Italic"
                   FontWeight="Light"
                   HorizontalAlignment="Center"
                   TextAlignment="Right"
                   TextDecorations="Underline, Strikethrough"
                   TextWrapping="Wrap"
                   VerticalAlignment="Center">
            The quick brown fox jumped over the lazy brown dog.
        </TextBlock>
    </Grid>
</Window>

Figure 3-2. A formatted TextBlock control

The following XAML demonstrates how to size and place images on a form using the Image control. It also demonstrates how easy it is to associate a tool tip (discussed in recipe 3-16) and an opacity setting with an image (see Figure 3-3).

<Window x:Class="Recipe_03_03.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_03" Height="300" Width="400">
    <StackPanel Orientation="Horizontal">
        <Image Margin="10" ToolTip="Bottom Image" Width="100"
               Source="ApressLogo.gif" />
        <Image Margin="-30" Opacity=".7" Source="ApressLogo.gif"
               ToolTip="Middle Image" Width="150" />
        <Image Source="ApressLogo.gif" ToolTip="Top Image"
               VerticalAlignment="Top" Width="150" />
    </StackPanel>
</Window>

Figure 3-3. Displaying images using the Image control

The following XAML demonstrates how to use a TextBox control that supports multiline input with word wrap and vertical scrolling. The buttons provide simple demonstrations of how to apply some of the functionality listed in Table 3-2.

<Window x:Class="Recipe_03_04.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_04" Height="300" Width="300">
    <StackPanel>
        <TextBox AcceptsReturn="True" Height="100" IsReadOnly="True"
                 Name="textBox1" TextAlignment="Left" TextWrapping="Wrap"
                 VerticalScrollBarVisibility="Auto">
            Default starting text.
        </TextBox>
        <WrapPanel Margin="10">
            <Button Margin="5" Name="textButton" Width="75"
                    Click="TextButton_Click">Set Text</Button>
            <Button Margin="5" Name="selectAllButton" Width="75"
                    Click="SelectAllButton_Click">Select All</Button>
            <Button Margin="5" Name="clearButton" Width="75"
                    Click="ClearButton_Click">Clear</Button>
            <Button Margin="5" Name="prependButton" Width="75"
                    Click="PrependButton_Click">Prepend</Button>
            <Button Margin="5" Name="insertButton" Width="75"
                    Click="InsertButton_Click">Insert</Button>

<Button Margin="5" Name="appendButton" Width="75"
                     Click="AppendButton_Click">Append</Button>
             <Button Margin="5" Name="cutButton" Width="75"
                     Click="CutButton_Click">Cut</Button>
             <Button Margin="5" Name="pasteButton" Width="75"
                     Click="PasteButton_Click">Paste</Button>
             <Button Margin="5" Name="undoButton" Width="75"
                     Click="UndoButton_Click">Undo</Button>
         <WrapPanel>
         <Grid>
             <Grid.ColumnDefinitions>
                 <ColumnDefinition/>
                 <ColumnDefinition/>
             </Grid.ColumnDefinitions>
             <RadioButton Checked="EditableChecked" Grid.Column="0"
                          HorizontalAlignment="Center" IsChecked="True"
                          Margin="5" Name="editableRadioButton" >
                 Editable</RadioButton>
             <RadioButton Checked="EditableChecked" Grid.Column="1"
                          HorizontalAlignment="Center" Margin="5"
                          Name="readonlyRadioButton">
                 Read Only</RadioButton>
         </Grid>
         <Grid>
             <Grid.ColumnDefinitions>
                 <ColumnDefinition/>
                 <ColumnDefinition/>
                 <ColumnDefinition/>
             </Grid.ColumnDefinitions>
             <RadioButton Checked="AlignmentChecked" Grid.Column="0"
                          HorizontalAlignment="Center" IsChecked="True"
                          Margin="5" Name="leftAlignRadioButton">
                 Left</RadioButton>
             <RadioButton Checked="AlignmentChecked" Grid.Column="1"
                          HorizontalAlignment="Center" Margin="5"
                          Name="centerAlignRadioButton">
                 Center</RadioButton>
             <RadioButton Checked="AlignmentChecked" Grid.Column="2"
                          HorizontalAlignment="Center" Margin="5"
                          Name="rightAlignRadioButton">
                 Right</RadioButton>
        </Grid>
    </StackPanel<
</Window>

The following code-behind handles the events fired by the buttons and radio buttons:

using System.Windows;
using System.Windows.Controls;

namespace Recipe_03_04
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        // Handles the checking of the Text Alignment RadioButtons.
        private void AlignmentChecked(object sender, RoutedEventArgs e)
        {
            RadioButton button = e.OriginalSource as RadioButton;

            if (e.OriginalSource == leftAlignRadioButton)
            {
                textBox1.TextAlignment = TextAlignment.Left;
            }
            else if (e.OriginalSource == centerAlignRadioButton)
            {
                textBox1.TextAlignment = TextAlignment.Center;
            }
            else if (e.OriginalSource == rightAlignRadioButton)
            {
                textBox1.TextAlignment = TextAlignment.Right;
            }

            textBox1.Focus();
        }

        // Handles the click of the Append button. Adds text to the end
        // of the TextBox content.
        private void AppendButton_Click(object sender, RoutedEventArgs e)
        {
            textBox1.AppendText(" *** appended text ***");
        }

// Handles the click of the Clear button. Clears all content from
       // the TextBox.
       private void ClearButton_Click(object sender, RoutedEventArgs e)
       {
           textBox1.Clear();
       }

       // Handles the click of the Cut button. Cuts the currently
       // selected text and places it in the clipboard.
       private void CutButton_Click(object sender, RoutedEventArgs e)
       {
           if (textBox1.SelectionLength == 0)
           {
               MessageBox.Show("Select text to cut first.", Title);
           }
           else
           {
               MessageBox.Show("Cut: " + textBox1.SelectedText, Title);

               textBox1.Cut();
           }
       }

       // Handles the checking of the Editable / ReadOnly RadioButtons.
       private void EditableChecked(object sender, RoutedEventArgs e)
       {
           RadioButton button = e.OriginalSource as RadioButton;

           if (e.OriginalSource == editableRadioButton)
           {
               textBox1.IsReadOnly = false;
           }
           else if (e.OriginalSource == readonlyRadioButton)
           {
               textBox1.IsReadOnly = true;
           }

           textBox1.Focus();
       }

       // Handles the click of the Insert button. Inserts text into
       // the TextBox at the current cursor location.

private void InsertButton_Click(object sender, RoutedEventArgs e)
       {
           textBox1.Text = textBox1.Text.Insert(
               textBox1.CaretIndex, " *** inserted text *** ");
       }

       // Handles the click of the Paste button. Pastes the current
       // content of the clipboard into the TextBox at the current
       // cursor location.
       private void PasteButton_Click(object sender, RoutedEventArgs e)
       {
           textBox1.Paste();
       }

       // Handles the click of the Prepend button. Adds text to the start
       // of the TextBox content.
       private void PrependButton_Click(object sender, RoutedEventArgs e)
       {
           textBox1.Text =
               textBox1.Text.Insert(0, "*** Prepended text *** ");
       }

       // Handles the click of the Select All button. Selects all the
       // content in the TextBox.
       private void SelectAllButton_Click(object sender, RoutedEventArgs e)
       {

           textBox1.SelectAll();

           // Set the focus on the TextBox to make the selection visible.
           textBox1.Focus();
       }

       // Handles the click of the Set Text Button. Sets the content
       // of the TextBox to a default value.
       private void TextButton_Click(object sender, RoutedEventArgs e)
       {
           textBox1.Text = "Replace default text with initial text value";
       }

       // Handles the click of the Undo Button. Undoes the last undoable
       // event.
       private void UndoButton_Click(object sender, RoutedEventArgs e)
       {
           textBox1.Undo();
       }
    }
}

The following code provides a simple example of a RichTextBox used to edit a FlowDocument. The XAML defines a static FlowDocument that contains a variety of structural and formatting elements. The user interface provides a set of buttons to manipulate the RichTextBox content. The buttons rely on the application and editing command support provided by the RichTextBox control and use a style (discussed further in Chapter 6) to make the RichTextBox the target of the button's command.

<Window x:Class="Recipe_03_05.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_05" Height="350" Width="500">
    <DockPanel>
        <StackPanel DockPanel.Dock="Top" Orientation="Horizontal">
            <StackPanel.Resources>
                <Style TargetType="{x:Type Button}">
                    <Setter Property="CommandTarget"
                            Value="{Binding ElementName=rtbTextBox1}" />
                </Style>
            </StackPanel.Resources>
            <Button Content="Clear" Name="btnClear" Click="btnClear_Click" />
            <Separator Margin="5"/>
            <Button Content="Cu_t" Command="ApplicationCommands.Cut" />
            <Button Content="_Copy" Command="ApplicationCommands.Copy" />
            <Button Content="_Paste" Command="ApplicationCommands.Paste" />
            <Separator Margin="5"/>
            <Button Content="_Undo" Command="ApplicationCommands.Undo" />
            <Button Content="_Redo" Command="ApplicationCommands.Redo" />
            <Separator Margin="5"/>
            <Button Content="_Bold" Command="EditingCommands.ToggleBold" />
            <Button Content="_Italic" Command="EditingCommands.ToggleItalic" />
            <Button Content="Underline"
                    Command="EditingCommands.ToggleUnderline" />
            <Separator Margin="5"/>
            <Button Content="_Right" Command="EditingCommands.AlignRight" />
            <Button Content="C_enter" Command="EditingCommands.AlignCenter" />
            <Button Content="_Left" Command="EditingCommands.AlignLeft" />
        </StackPanel>
        <RichTextBox DockPanel.Dock="Bottom" Name="rtbTextBox1"
                    HorizontalScrollBarVisibility="Visible"
                    VerticalScrollBarVisibility="Visible">
            <FlowDocument>
                <Paragraph FontSize="12">
                    Lorem ipsum dolor sit amet, consectetuer adipiscing elit,
                    sed diam nonummy nibh euismod tincidunt ut laoreet dolore
                    magna aliquam erat volutpat.
                </Paragraph>
                <Paragraph FontSize="15">
                    Ut wisi enim ad minim veniam, quis nostrud exerci tation
                    ullamcorper suscipit lobortis nisl ut aliquip ex ea
                    commodo consequat. Duis autem vel eum iriure.
                </Paragraph>

                <Paragraph FontSize="18">A List</Paragraph>

<List>
                    <ListItem>
                        <Paragraph>
                            <Bold>Bold List Item</Bold>
                        </Paragraph>
                    </ListItem>
                    <ListItem>
                        <Paragraph>
                            <Italic>Italic List Item</Italic>
                        </Paragraph>
                    </ListItem>
                    <ListItem>
                        <Paragraph>
                            <Underline>Underlined List Item</Underline>
                        </Paragraph>
                    </ListItem>
                </List>
            </FlowDocument>
        </RichTextBox>
    </DockPanel>
</Window>

The following code-behind contains the event handler that handles the Clear button provided on the user interface defined earlier:

The following code-behind contains the event handler that handles the Clear button provided on the user interface defined earlier:

using System.Windows;

namespace Recipe_03_05

{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {

        public Window1()
        {
            InitializeComponent();
        }

        // Handles Clear Button click event.
        private void btnClear_Click(object sender, RoutedEventArgs e)
        {
            // Select all the text in the FlowDocument and cut it.
            rtbTextBox1.SelectAll();
            rtbTextBox1.Cut();
        }
     }
 }

Figure 3-4 shows what the RichTextBox looks like when the example is first run.

Figure 3-4. Using a RichTextBox to edit a FlowDocument

The following XAML displays a RichTextBox containing some default text along with the buttons necessary to create a new empty FlowDocument, open a FlowDocument, and save a FlowDocument:

<Window x:Class="Recipe_03_06.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_06" Height="300" Width="300">
    <DockPanel>
        <StackPanel DockPanel.Dock="Top" Orientation="Horizontal">
            <Button Content="_New" Name="btnNew" Click="btnNew_Click" />
            <Button Content="_Open" Name="btnOpen" Click="btnOpen_Click" />
            <Button Content="_Save" Name="btnSave" Click="btnSave_Click" />
        </StackPanel>
        <RichTextBox DockPanel.Dock="Bottom" Name="rtbTextBox1"
                     HorizontalScrollBarVisibility="Visible"
                     VerticalScrollBarVisibility="Visible">
            <FlowDocument>
                <Paragraph>
                    Lorem ipsum dolor sit amet, consectetuer adipiscing elit,
                    sed diam nonummy nibh euismod tincidunt ut laoreet dolore
                    magna aliquam erat volutpat.
                </Paragraph>
                <Paragraph>
                    Ut wisi enim ad minim veniam, quis nostrud exerci tation
                    ullamcorper suscipit lobortis nisl ut aliquip ex ea
                    commodo consequat. Duis autem vel eum iriure.
                </Paragraph>
            </FlowDocument>
        </RichTextBox>
    </DockPanel>
</Window>

The following code-behind shows the event handlers for the New, Open, and Save buttons. The btnOpen_Click event handler uses the Microsoft.Win32.OpenFileDialog to provide a standard Windows dialog box to allow the user to select the file to open. Similarly, the btnSave_Click event handler uses the Microsoft.Win32.SaveFileDialog.

using Microsoft.Win32;
using System;
using System.IO;
using System.Windows;
using System.Windows.Documents;
using System.Windows.Markup;

namespace Recipe_03_06
{
     /// <summary>
     /// Interaction logic for Window1.xaml
     /// </summary>
     public partial class Window1 : Window
     {
         private String currentFileName = String.Empty;

         public Window1()
         {
             InitializeComponent();
         }

         // Handles the Open Button Click event
         private void btnOpen_Click(object sender, RoutedEventArgs e)
         {
             // Use a standard OpenFileDialog to allow the user to
             // select the file to open.
             OpenFileDialog dialog = new OpenFileDialog();
             dialog.FileName = currentFileName;
             dialog.Filter = "XAML Files (*.xaml)|*.xaml";

             // Display the OpenFileDialog and read if the user
             // provides a file name.
             if (dialog.ShowDialog() == true)
             {
                 // Remember the new file name.
                 currentFileName = dialog.FileName;

                 {
                     using (FileStream stream = File.Open(currentFileName,
                         FileMode.Open))
                     {
                         // TODO: Need logic to handle incorrect file format errors.
                         FlowDocument doc = XamlReader.Load(stream) as FlowDocument;

                         if (doc == null)
                         {
                             MessageBox.Show("Could not load document.", Title);
                         }
                         else
                         {
                            rtbTextBox1.Document = doc;
                         }
                     }
                 }

}
}

      // Handles the New Button Click event
      private void btnNew_Click(object sender, RoutedEventArgs e)
      {
          // Create a totally new FlowDocument for the RichTextBox.
          rtbTextBox1.Document = new FlowDocument();

          currentFileName = String.Empty;
      }

      // Handles the Save Button Click event
      private void btnSave_Click(object sender, RoutedEventArgs e)
      {
         // Use a standard SaveFileDialog to allow the user to
         // select the file to save.
         SaveFileDialog dialog = new SaveFileDialog();
         dialog.FileName = currentFileName;
         dialog.Filter = "XAML Files (*.xaml)|*.xaml";

         // Display the SaveFileDialog and save if the user
         // provides a file name.
         if (dialog.ShowDialog() == true)
         {
            // Remember the new file name.
            currentFileName = dialog.FileName;

            using (FileStream stream = File.Open(currentFileName,
               FileMode.Create))
            {
               XamlWriter.Save(rtbTextBox1.Document, stream);
            }
         }
      }
   }
}

The following example demonstrates how to use a PasswordBox to allow the user to enter a password, which it then displays when the user clicks the OK button (which is not very secure but demonstrates how to use the Password property). The example uses an exclamation mark as the password character.

<Window x:Class="Recipe_03_07.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_07" Height="100" Width="300">
    <StackPanel Orientation="Horizontal">
        <TextBlock Margin="5" VerticalAlignment="Center">
            Enter Password:
       </TextBlock>
       <PasswordBox Name="passwordBox" PasswordChar="!"
                    VerticalAlignment="Center" Width="150" />
       <Button Content="OK" IsDefault="True" Margin="5" Name="button1"
               VerticalAlignment="Center" Click="button1_Click" />
    </StackPanel>
</Window>

The following code-behind handles the button click event:

using System.Windows;

namespace Recipe_03_07
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        // Handles the Button Click event
        private void button1_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Password entered: " + passwordBox.Password,
                Title);
        }
    }
}

Figure 3-5 shows how the PasswordBox masks the user input with a selectable substitute character.

Figure 3-5. Using the PasswordBox to mask user input

The following XAML declares a TextBox with spell checking enabled:

<Window x:Class="Recipe_03_08.Window1"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     Title="WPF Recipes 3_08" Height="100" Width="300">
     <StackPanel>
         <TextBlock FontSize="14" FontWeight="Bold"
                       Text="A spell-checking TextBox:"/>
         <TextBox AcceptsReturn="True" AcceptsTab="True" FontSize="14"
                     Margin="5" SpellCheck.IsEnabled="True" TextWrapping="Wrap">
                The qick red focks jumped over the lasy brown dog.
         </TextBox>
     </StackPanel>
</Window>

Figure 3-6 shows the spell-check-enabled TextBox from the previous example. It also shows the context menu displayed to allow the user to select suggested alternatives to the word identified as being misspelled.

Figure 3-6. Spell-check-enabled TextBox

The following example presents three Button controls. When the user clicks a Button, the example displays a System.Windows.MessageBox containing the name of the Button selected. This example casts the Object in the RoutedEventArgs.OriginalSource property to a Button to access the Name of the Button. Recipe 3-4 contains an example that directly compares a known Button control with the Object in the OriginalSource property.

<Window x:Class="Recipe_03_09.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_09" Height="200" Width="200">
    <StackPanel>
        <Button Click="SharedButtonClickHandler" Height="23" Margin="10"
                Name="button1" Width="75">Button One</Button>
        <Button Click="SharedButtonClickHandler" Height="23" Margin="10"
                Name="button2" Width="75">Button Two</Button>
        <Button Click="SharedButtonClickHandler" Height="23" Margin="10"
                Name="button3" Width="75">Button Three</Button>
    </StackPanel>
</Window>

Here is the code-behind containing the shared Click event handler:

using System.Windows;
using System.Windows.Controls;

namespace Recipe_03_09
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

private void SharedButtonClickHandler(object sender,
             RoutedEventArgs e)
         {
             Button source = e.OriginalSource as Button;

             if (source != null)
             {
                 MessageBox.Show("You pressed " + source.Name, Title);
             }
         }
     }
}

The following example uses two RepeatButton controls to move a slider. The first RepeatButton must be clicked and held to move the slider to the left. The second RepeatButton moves the slider to the right while the mouse hovers over the xbutton.

<Window x:Class="Recipe_03_10.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_10" Height="100" Width="200">
    <StackPanel>
        <Slider Name="slider" Maximum="100" Minimum="0" Value="50" />
        <StackPanel Orientation="Horizontal">
            <RepeatButton Click="SliderLeft_Click" Content="Click Me"
                          Height="23" Margin="10" Width="70"
                          ToolTip="Click to move slider left" />
            <RepeatButton Click="SliderRight_Click" ClickMode="Hover"
                          Content="Touch Me" Height="23" Margin="10"
                          ToolTip="Hover to move slider right" Width="70" />
        </StackPanel>
    </StackPanel>
</Window>

The following code-behind shows how to handle the Click events raised by the RepeatButton controls:

using System.Windows;

namespace Recipe_03_10
{
     /// <summary>
     /// Interaction logic for Window1.xaml
     /// </summary>
     public partial class Window1 : Window
     {
         public Window1()
         {
             InitializeComponent();
         }

         // Handles the SliderLeft Click event.
         private void SliderLeft_Click(object sender, RoutedEventArgs e)
         {
             // Reduce the value of the slider by one for each click.
             slider.Value -= 1;
         }

         // Handles the SliderRight Click event.
         private void SliderRight_Click(object sender, RoutedEventArgs e)
         {
             // Increase the value of the slider by one for each click.
             slider.Value += 1;
         }
     }
}

The following example contains a System.Windows.Controls.TextBox and three Button controls. The button3 Button is configured as the default. As the default, btnThree is selected when the application first loads and is "clicked" when you press Enter while editing the TextBox.

<Window x:Class="Recipe_03_11.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_11" Height="100" Width="300">
    <DockPanel>
        <TextBox DockPanel.Dock="Top" Margin="5">
            Button three is the default button.
        </TextBox>
        <StackPanel HorizontalAlignment="Center" DockPanel.Dock="Bottom"
                    Orientation="Horizontal">
            <Button Click="SharedButtonClickHandler" Content="Button One"
                    Margin="5" Name="btnOne" Width="75" />
            <Button Click="SharedButtonClickHandler" Content="Button Two"
                    Margin="5" Name="btnTwo" Width="75" />

<Button Click="SharedButtonClickHandler" Content="Button Three"
                        IsDefault="True" Margin="5" Name="btnThree" />
        </StackPanel>
    </DockPanel>
</Window>

Here is the code-behind containing the shared Click event handler:

using System.Windows;
using System.Windows.Controls;

namespace Recipe_03_11
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        // Handles the click event for all buttons.
        private void SharedButtonClickHandler(object sender,
            RoutedEventArgs e)
        {
            Button source = e.OriginalSource as Button;

            if (source != null)
            {
                MessageBox.Show("You pressed " + source.Name, Title);
            }
        }
    }
}

Figure 3-7 shows how a default button is identified when the user is focused on a text entry control.

Figure 3-7. Setting a default Button

The following XAML displays a window containing three Label and TextBox control pairs. Each Label defines a numeric quick access key (1, 2, or 3) that, when pressed in conjunction with the Alt key, takes you to the TextBox associated with the Label. In Windows Vista, the default configuration displays only the underscore when you press the Alt key.

<Window x:Class="Recipe_03_12.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_12" Height="200" Width="250">
    <StackPanel>
        <StackPanel Margin="10" Orientation="Horizontal">
            <Label Target="{Binding ElementName=textBox1}">Label _1</Label>
            <TextBox Name="textBox1" Width="150"></TextBox>
        </StackPanel>

<StackPanel Margin="10" Orientation="Horizonal">
            <Label Target="{Binding ElementName=textBox2}">Label_2</Label>
            <TextBox Name="textBox2" Width="150"></TextBox>
        </StackPanel>
        <StackPanel Margin="10" Orientation="Horizontal">
            <Label Targe="{Binding ElementName=textBox3}">Label_3</Label>
            <TextBox Name="textBox3" Width="150"></TextBox>
        </StackPanel>
    <StackPanel>
</Window>

The following XAML demonstrates how to use underscores to define access keys for the three Button controls:

<Window x:Class="Recipe_03_13.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_13" Height="100" Width="300">
    <StackPanel HorizontalAlignment="Center" Orientation="Horizontal">
        <Button Click="SharedButtonClickHandler" Height="23" Margin="5"
                 Name="button1" Width="75">Button _One</Button>
        <Button Click="SharedButtonClickHandler" Height="23" Margin="5"
                 Name="button2" Width="75">Button _Two</Button>
        <Button Click="SharedButtonClickHandler" Height="23" Margin="5"
                 Name="button3" Width="75">Button T_hree</Button>
    </StackPanel>
</Window>

The following code-behind provides the Click event handler for the preceding XAML:

using System;
using System.Windows;
using System.Windows.Controls;

namespace Recipe_03_13
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        private void SharedButtonClickHandler(object sender, RoutedEventArgs e)
        {
            Button source = e.OriginalSource as Button;

            if (source != null)
            {
                string message = String.Format("{0} was pressed.", source.Content);
                MessageBox.Show(message, Title);
            }
        }
    }
}

The following XAML displays two Slider controls. The top Slider allows the user to move the thumb freely between the Minimum and Maximum values but specifies a LargerChange value of 10 for when the user clicks the track. The bottom Slider uses a TickFrequency value of 25 and forces the thumb to align to a tick using the IsSnapToTickEnabled property. This results in a slider that always moves in increments of 25.

<Window x:Class="Recipe_03_14.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_14" Height="200" Width="300">
    <StackPanel>
        <TextBlock Margin="5" Text="0" FontSize="20"
                   HorizontalAlignment="Center" Name="txtSliderValue" />
        <Slider LargeChange="10" Margin="5" Maximum="1000" Minimum="0"
                Name="slider1" TickPlacement="TopLeft"
                Ticks="100, 200, 400, 800" Value="0"
                ValueChanged="slider_ValueChanged" />
        <Button Name="btnGetSliderValue1" Width="100"
                Click="GetSliderValue_Click">Get Slider 1 Value</Button>
        <Slider IsSnapToTickEnabled="True" Margin="5" Maximum="1000"
                Minimum="0" Name="slider2" TickFrequency="25"
                TickPlacement="BottomRight" Value="1000"
                ValueChanged="slider_ValueChanged" />
        <Button Name="btnGetSliderValue2" Width="100"
                Click="GetSliderValue_Click">Get Slider 2 Value</Button>
    </StackPanel>
</Window>

The following code-behind demonstrates how to obtain the current Value of a Slider in response to a button click and also shows how to handle the ValueChanged event to respond dynamically to the movement of the Slider thumb:

using System.Windows;
using System.Windows.Controls;

namespace Recipe_03_14
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        // Handles all GetSliderValue Button Clicks
        private void GetSliderValue_Click(object sender, RoutedEventArgs e)
        {
            Button button = e.OriginalSource as Button;
            string message = "Unknown slider.";

            if (button == btnGetSliderValue1)
            {
                message = "Slider1 value = " + slider1.Value;
            }
            else if (button == btnGetSliderValue2)
            {
            message = "Slider2 value = " + slider2.Value;
        }

        MessageBox.Show(message, Title);
     }

     // Handles all Slider ValueChangedEvents.
     private void slider_ValueChanged(object sender,
         RoutedPropertyChangedEventArgs<double> e)
     {
         Slider slider = e.OriginalSource as Slider;

         if (slider != null)
         {
             txtSliderValue.Text = slider.Value.ToString();
         }
      }
   }
}

Figure 3-8 shows the sample code where the number at the top of the window shows the Value property of the top slider.

Figure 3-8. Getting user input from a Slider

The following XAML demonstrates how to define a ContextMenu for a TextBox that lets the user clear, select, cut, copy, and paste content from the TextBox. A submenu allows the user to change the format of the TextBox content. The example uses a shared Click event handler to handle format changes, individual Click event handlers for the Clear and Select All menu items, and standard Command bindings for the Cut, Copy, and Paste commands, which the TextBox knows how to handle.

<Window x:Class="Recipe_03_15.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_15" Height="100" Width="300">
    <Grid>
        <TextBox FontSize="16" Height="23" Name="txtTextBox" >
            <TextBox.ContextMenu>
                <ContextMenu HasDropShadow="True" Opacity=".8">
                    <MenuItem Command="Cut" Header="Cu_t" />
                    <MenuItem Command="Copy" Header="_Copy" />
                    <MenuItem Command="Paste" Header="_Paste" />
                    <Separator/>
                    <MenuItem Click="SelectAll_Click" Header="_Select All" />
                    <MenuItem Click="Clear_Click" Header="_Clear" />
                    <Separator/>
                    <MenuItem Header="Format">
                        <MenuItem Click="TextStyle_Click" Header="_Normal"
                              Name="miNormal"></MenuItem>
                        <MenuItem Click="TextStyle_Click" FontWeight="Bold"
                              Header="_Bold" Name="miBold"></MenuItem>
                        <MenuItem Click="TextStyle_Click" FontStyle="Italic"
                              Header="_Italic" Name="miItalic"></MenuItem>
                    </MenuItem>
                </ContextMenu>
            </TextBox.ContextMenu>
            A TextBox control with ContextMenu.</TextBox>
    </Grid>
</Window>

The following code-behind contains the shared Click event handler to handle format changes and individual Click event handlers for the Clear and Select All context menu items:

using System.Windows;

namespace Recipe_03_15
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        // Handles Clear Button Click.
        private void Clear_Click(object sender, RoutedEventArgs e)
        {
            txtTextBox.Clear();
        }

        // Handles the Select All Button Click.
        private void SelectAll_Click(object sender, RoutedEventArgs e)
        {
            txtTextBox.SelectAll();
        }

        // Handles all the Button Click events that format the TextBox.
        private void TextStyle_Click(object sender, RoutedEventArgs e)
        {
            if (sender == miNormal)
            {
                txtTextBox.FontWeight = FontWeights.Normal;
                txtTextBox.FontStyle = FontStyles.Normal;
            }
            else if (sender == miBold)
            {
                txtTextBox.FontWeight = FontWeights.Bold;
            }
            else if (sender == miItalic)
            {
                txtTextBox.FontStyle = FontStyles.Italic;
            }
        }
    }
}

Figure 3-9 shows the two levels of ContextMenu open over the TextBox as defined in this recipe's sample code.

Figure 3-9. A ContextMenu on a TextBox

The following XAML demonstrates both how to use the ToolTip attribute to specify the tool tip of a Button and how to use a ToolTip object defined using property element syntax to create a tool tip that contains larger and more structured content comprising a label and a list of values:

<Window x:Class="Recipe_03_16.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_16" Height="150" Width="300">
    <StackPanel Name="stackPanel1">
        <Button Height="23" Margin="10" Name="button1"
                ToolTip="A simple textual ToolTip" Width="175">
            Button with Simple ToolTip
        </Button>
        <Button Content="Button with a Richer ToolTip" Height="23"
                Margin="10" Name="button2" Width="175">
            <Button.ToolTip>
                <StackPanel Name="stackPanel2" Width="200">
                    <Label Name="label1" HorizontalAlignment="Left">
                        List of Things:
                    </Label>
                    <ListBox Name="listBox1" Margin="10" >
                        <ListBoxItem>Thing 1</ListBoxItem>
                        <ListBoxItem>Thing 2</ListBoxItem>
                        <ListBoxItem>Thing 3</ListBoxItem>
                    </ListBox>
                 </StackPanel>
             </Button.ToolTip>
         </Button>
    </StackPanel>
</Window>

Figure 3-10 shows the previous example with the ToolTip visible for the lower Button.

Figure 3-10. Displaying a ToolTip on a Button

The following XAML demonstrates how to use the ToolTipService.ShowOnDisabled attached property to enable the display of a ToolTip for a disabled Button control. The code contains two Button controls: the first shows the default behavior of a ToolTip on a disabled control, and the second shows the effect of setting the ToolTipService.ShowOnDisabled property to True.

<Window x:Class="Recipe_03_17.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_17" Height="150" Width="300">
    <StackPanel>
        <Button Content="Disabled Button without ToolTipService"
            Height="23" IsEnabled="False" Margin="10" Name="button1"
            Width="200">
            <Button.ToolTip>
                ToolTip on a disabled control
            </Button.ToolTip>
        </Button>
        <Button Content="Disabled Button with ToolTipService"
            Height="23" IsEnabled="False" Margin="10" Name="button2"
                ToolTipService.ShowOnDisabled="True" Width="200">
        <Button.ToolTip>
            ToolTip on a disabled control
        </Button.ToolTip>
     </Button>
   </StackPanel>
</Window>

The following XAML declares three buttons, each with ToolTip controls using different properties of the ToolTipService class to control position and display duration:

<Window x:Class="Recipe_03_18.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_18" Height="200" Width="300">
    <StackPanel>
        <Button Height="40" Margin="5" ToolTipService.Placement="Mouse"
                ToolTipService.ShowDuration="1000">
            <Button.ToolTip>
                <ToolTip>
                    ToolTip displayed for 1 second...
                </ToolTip>
            </Button.ToolTip>
            Button with ToolTip under Mouse
        </Button>
        <Button Height="40" Margin="5" ToolTipService.Placement="Center">
            <Button.ToolTip>
                <ToolTip>
                    ToolTip displayed for 5 seconds...
                </ToolTip>
            </Button.ToolTip>
            Button with Centered ToolTip
        </Button>
        <Button Height="40" Margin="5" ToolTipService.HorizontalOffset="5cm"
                ToolTipService.Placement="Relative"
                ToolTipService.ShowDuration="10000"
                ToolTipService.VerticalOffset="50px">
            <Button.ToolTip>
                <ToolTip >
                    ToolTip displayed for 10 seconds...
                </ToolTip>

</Button.ToolTip>
       Button with offset ToolTip
     </Button>
   </StackPanel>
</Window>

The following example demonstrated how to create two groups of RadioButton controls. Using the GroupName property, the example creates two groups within a single System.Windows.Controls.StackPanel (on the left) and also creates a group (Group1) that spans the left and right StackPanel containers.

<Window x:Class="Recipe_03_19.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_19" SizeToContent="Height" Width="300">

<Grid Name="grid">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition/>
            <ColumnDefinition/>
        </Grid.ColumnDefinitions>
        <Border Grid.Column="0" BorderBrush="Gray" BorderThickness="1" />
        <Border Grid.Column="1" BorderBrush="Gray" BorderThickness="1" />
        <StackPanel Grid.Column="0" HorizontalAlignment="Center" Margin="5"
                    Name="spLeftContainer">
            <TextBlock FontSize="16" Text="Radio Group 1" />
            <RadioButton Content="Radio Button 1A" GroupName="Group1"
                        IsChecked="True" Margin="5" Name="rbnOneA" />
            <RadioButton Content="Radio Button 1B" GroupName="Group1"
                        Margin="5" Name="rbnOneB" />
            <RadioButton Content="Radio Button 1C" GroupName="Group1"
                        Margin="5" Name="rbnOneC" />
            <Separator/>
            <TextBlock FontSize="16" Text="Radio Group 2" />
            <RadioButton Checked="RadioButton_Checked" GroupName="Group2"
                         Content="Radio Button 2A" IsChecked="True"
                         Margin="5" Name="rbnTwoA" />
            <RadioButton Checked="RadioButton_Checked" GroupName="Group2"
                         Content="Radio Button 2B" Margin="5" Name="rbnTwoB"/>
            <RadioButton Checked="RadioButton_Checked" GroupName="Group2"
                         Content="Radio Button 2C" Margin="5" Name="rbnTwoC"/>
     </StackPanel>
     <StackPanel Grid.Column="1" HorizontalAlignment="Center" Margin="5"
                 Name="spRightContainer">
            <TextBlock FontSize="16" Text="Radio Group 1" />
            <RadioButton Content="Radio Button 1D" GroupName="Group1"
                         Margin="5" Name="rbnOneD" />
            <RadioButton Content="Radio Button 1E" GroupName="Group1"
                         Margin="5" Name="rbnOneE" />
        </StackPanel>
        <Button Content="Show Group1 Selection" Grid.ColumnSpan="2"
                Grid.Row="1" HorizontalAlignment="Center"
                Margin="10" MaxHeight="25" Click="Button_Click" />
    </Grid>
</Window>

The following code-behind demonstrates how to handle the RadioButton.Checked event and also how to loop through the children of a container to determine which RadioButton from a particular group is checked:

using System;
using System.Linq;
using System.Windows;
using System.Windows.Controls;

namespace Recipe_03_19
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
         public Window1()
         {
             InitializeComponent();
         }

         // Handles the Submit Button Click event.
         private void Button_Click(object sender, RoutedEventArgs e)
         {
             RadioButton radioButton = null;

             // Try the first (left) container to see if one of
             // the radio buttons in Group1 is checked.
             radioButton = GetCheckedRadioButton(
                 spLeftContainer.Children, "Group1");

             // If no RadioButton in the first container is checked, try
             // the second (right) container.
             if (radioButton == null)
             {
                 radioButton = GetCheckedRadioButton(
                     spRightContainer.Children, "Group1");
             }

             // We must have at least one RadioButton checked to display.
             MessageBox.Show(radioButton.Content + " checked.", Title);
         }

         // A method that loops through a UIElementCollection and identifies
         // a checked RadioButton with a specified group name.
         private RadioButton GetCheckedRadioButton(
             UIElementCollection children, String groupName)
         {

return children.OfType<RadioButton>().
         FirstOrDefault( rb => rb.IsChecked == true
             && rb.GroupName == groupName);
     }

     // Handles the RadioButton Checked event for all buttons in Group2.
     private void RadioButton_Checked(object sender, RoutedEventArgs e)
     {
         // Don't handle events until the Window is fully initialized.
         if (!this.IsInitialized) return;

         RadioButton radioButton = e.OriginalSource as RadioButton;

         if (radioButton != null)
         {
             MessageBox.Show(radioButton.Content + " checked.", Title);
         }
      }
   }
}

Figure 3-11 shows the two groups of RadioButton controls created in the previous example.

Figure 3-11. Creating sets of RadioButton controls

The following example demonstrates two approaches to determining the state of a set of CheckBox controls. The XAML defines a simple window containing four CheckBox controls (two enabled with tristate support). Each time the user changes the state of a CheckBox, the example shows a message box describing the change. The user can also click a button, which will populate a list with the names of the CheckBox controls that are currently checked.

<Window x:Class="Recipe_03_20.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_20" Height="250" Width="300">
    <StackPanel Name="panel">
        <CheckBox Checked="CheckBox_Checked" Content="First CheckBox"
                  IsChecked="True" Margin="2" Name="checkbox1"
                  Unchecked="CheckBox_Unchecked"/>
        <CheckBox Checked="CheckBox_Checked" Content="Second CheckBox"
                  IsChecked="False" Margin="2" Name="checkbox2"
                  Unchecked="CheckBox_Unchecked"/>
        <CheckBox Checked="CheckBox_Checked"
                  Content="Third CheckBox (Tri-State Enabled)"
                  Indeterminate="CheckBox_Indeterminate" IsChecked="True"
                  IsThreeState="True" Margin="2" Name="checkbox3"
                  Unchecked="CheckBox_Unchecked"/>
        <CheckBox Checked="CheckBox_Checked"
                  Content="Fourth CheckBox (Tri-State Enabled)"
                  Indeterminate="CheckBox_Indeterminate" IsChecked="False"
                  IsThreeState="True" Margin="2" Name="checkbox4"
                  Unchecked="CheckBox_Unchecked"/>

<Button Content="Get Selected" Margin="5" MaxWidth="100"
                Click="Button_Click" />
        <TextBlock FontWeight="Bold" Text="Selected CheckBoxes:" />
        <ListBox Margin="5" MinHeight="2cm" Name="listbox" />
    </StackPanel>
</Window>

The following code-behind provides the logic for processing the Button.Cick event to populate the list with the names of the checked CheckBox controls and the event handlers for displaying message boxes as the state of a CheckBox changes:

using System.Linq;
using System.Windows;
using System.Windows.Controls;

namespace Recipe_03_20
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        // Handles Button Click event to populate the ListBox with
        // the names of the currently checked CheckBox controls.
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            // Clear the content of the ListBox.
            listbox.Items.Clear();

            // Process each CheckBox control in the main StackPanel.
            foreach (CheckBox checkbox in panel.Children.OfType<CheckBox>()
                .Where( cb => cb.IsChecked == true))
            {
                listbox.Items.Add(checkbox.Name);
            }
        }

        // Handles all the CheckBox Checked events to display a message
        // when a CheckBox changes to a checked state.
        private void CheckBox_Checked(object sender, RoutedEventArgs e)
        {
            // Don't handle these events during initialization.
            if (!IsInitialized) return;

CheckBox checkbox = e.OriginalSource as CheckBox;

       if (checkbox != null)
       {
           MessageBox.Show(checkbox.Name + " is checked.", Title);
       }
     }

     // Handles all the CheckBox Indeterminate events to display a message
     // when a CheckBox changes to an indeterminate state.
     private void CheckBox_Indeterminate(object sender, RoutedEventArgs e)
     {
         // Don't handle these events during initialization.
         if (!IsInitialized) return;

         CheckBox checkbox = e.OriginalSource as CheckBox;

         if (checkbox != null)
         {
             MessageBox.Show(checkbox.Name + " is indeterminate.", Title);
         }
     }

     // Handles all the CheckBox Unchecked events to display a message
     // when a CheckBox changes to an unchecked state.
     private void CheckBox_Unchecked(object sender, RoutedEventArgs e)
     {
         // Don't handle these events during initialization.
         if (!IsInitialized) return;

         CheckBox checkbox = e.OriginalSource as CheckBox;

         if (checkbox != null)
         {
             MessageBox.Show(checkbox.Name + " is unchecked.", Title);
         }
      }
   }
}

Figure 3-12 shows the previous example after the user has toggled the fourth CheckBox into an indeterminate state and has clicked the Get Selected Button.

Figure 3-12. Creating sets of CheckBox controls

The following example demonstrates how to use a TreeView control to display hierarchical information. As the user selects an item, the example shows a MessageBox for each TreeViewItem.Selected event raised. The user can also click the Button to see a message box identifying the header of the currently selected TreeViewItem. The example uses a Style with an EventSetter element to assign a common Selected event handler to all instances of TreeViewItem.

<Window x:Class="Recipe_03_21.Window1"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="WPF Recipes 3_21" Height="200" Width="300">
   <DockPanel LastChildFill="True">
     <DockPanel.Resources>
       <Style TargetType="{x:Type TreeViewItem}">
         <EventSetter Event="Selected"
                         Handler="TreeViewItem_Selected" />
       </Style>
     </DockPanel.Resources>
     <Button Click="Button_Click" DockPanel.Dock="Bottom"
                Content="Show Selected" MaxHeight="23" MaxWidth="100" />
     <TreeView FontSize="16" Name="tvTree">
       <TreeViewItem Header="Birds" IsExpanded="True">
         <TreeViewItem Header="Flighted">
           <TreeViewItem Header="Falcon" />
           <TreeViewItem Header="Starling" />
         </TreeViewItem>
         <TreeViewItem Header="Flightless" IsExpanded="True">
           <TreeViewItem Header="Emu" />
           <TreeViewItem Header="Kiwi" />
         </TreeViewItem>
       </TreeViewItem>
       <TreeViewItem Header="Reptiles">
         <TreeViewItem Header="Lizards">
           <TreeViewItem Header="Blue Tonge" />
           <TreeViewItem Header="Frilled" />
           <TreeViewItem Header="Iguana" />
         </TreeViewItem>

<TreeViewItem Header="Snakes">
           <TreeViewItem Header="Anaconda" />
           <TreeViewItem Header="Cobra" />
           <TreeViewItem Header="Rattlesnake" />
         </TreeViewItem>
       </TreeViewItem>
     </TreeView>
   </DockPanel>
</Window>

The following code contains the event-handling logic for the TreeView example:

using System;
using System.Windows;
using System.Windows.Controls;

namespace Recipe_03_21
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        // Handles the Selected event for all TreeViewItems.
        private void TreeViewItem_Selected(object sender,
            RoutedEventArgs e)
        {
            String message = String.Empty;

            // As the Selected event is fired by successive
            // parent TreeViewItem controls of the actually
            // selected TreeViewItem, the sender will change,
            // but the e.OriginalSource will continue to
            // refer to the TreeViewItem that was actually
            // clicked.
            TreeViewItem item = sender as TreeViewItem;

            if (item == e.OriginalSource)
            {
                // Event raised by clicked item.
                message =
                    String.Format("Item selected: {0} ({1} child items)",
                    item.Header, item.Items.Count);
            }

else
         {
           // Event raised by a parent of clicked item.
           message =
               String.Format("Parent of selected: {0} ({1} child items)",
               item.Header, item.Items.Count);
       }

       MessageBox.Show(message, Title);
     }

     // Handles the Button Click event.
     private void Button_Click(object sender, RoutedEventArgs e)
     {
         TreeViewItem item = tvTree.SelectedItem as TreeViewItem;

         if (item != null)
         {
             MessageBox.Show("Item selected: " + item.Header, Title);
         }
         else
         {
             MessageBox.Show("No item selected", Title);
         }
      }
   }
}

Figure 3-13 shows the example in its initial state with the Birds and Flightless items expanded by default.

Figure 3-13. Hierarchical data shown in a TreeView control

The following XAML defines in single-select ListBox containing a variety of other controls, including a nested ListBox. Some items are contained directly within the ListBox, while others are wrapped in ListBoxItem elements.

<Window x:Class="Recipe_03_22.Window1"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="WPF Recipes 3_22" Height="300" Width="300">
   <StackPanel>
     <ListBox SelectionChanged="OuterListBox_SelectionChanged"
                 Name="outerListBox">
            <ListBoxItem Content="List Box Item 1" FontFamily="Tahoma"
                            FontSize="14" HorizontalContentAlignment="Left" />
            <ListBoxItem Content="List Box Item 2" FontFamily="Algerian"
                            FontSize="16" HorizontalContentAlignment="Center" />
            <ListBoxItem Content="List Box Item 3" FontSize="20"
                            FontFamily="FreeStyle Script"
                            HorizontalContentAlignment="Right" />
            <Button Content="Button directly in a list" Margin="5" />
            <ListBoxItem HorizontalContentAlignment="Center" Margin="5">
                   <Button Content="Button wrapped in ListBoxItem" />
            </ListBoxItem>
            <ListBox Height="50" Margin="5">
                   <ListBoxItem Content="Inner List Item 1"
                                   Selected="InnerListBoxItem_Selected" />
                   <ListBoxItem Content="Inner List Item 2"
                                   Selected="InnerListBoxItem_Selected" />
                   <ListBoxItem Content="Inner List Item 3"
                                   Selected="InnerListBoxItem_Selected" />
                   <ListBoxItem Content="Inner List Item 4"
                                   Selected="InnerListBoxItem_Selected" />
            </ListBox>
            <StackPanel Margin="5" Orientation="Horizontal">
                   <Label Content="Enter some text:" />
                   <TextBox MinWidth="150" />
            </StackPanel>
       </ListBox>
       <TextBlock Text="No item currently selected." Margin="10"
                     HorizontalAlignment="Center" Name="txtSelectedItem" />
     </StackPanel>
</Window>

The following code-behind contains the logic used to handle the event raised by the outer ListBox and the items contained in the inner ListBox. When the user selects an item in the outer ListBox, the code handles the ListBox.SelectionChanged event and displays the ToString output of the selected item at the bottom of the form. When the user selects an item in the inner ListBox, the code handles the ListBoxItem.Selected event and displays the Content property of the selected item in a MessageBox.

using System.Windows;
using System.Windows.Controls;

namespace Recipe_03_22
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        // Handles ListBoxItem Selected events for the ListBoxItems in the
        // inner ListBox.
        private void InnerListBoxItem_Selected(object sender,
            RoutedEventArgs e)
        {
            ListBoxItem item = e.OriginalSource as ListBoxItem;

            if (item != null)
            {
                MessageBox.Show(item.Content + " was selected.", Title);
            }
        }

        // Handles ListBox SelectionChanged events for the outer ListBox.
        private void OuterListBox_SelectionChanged(object sender,
            SelectionChangedEventArgs e)
        {
            object item = outerListBox.SelectedItem;

            if (item == null)
            {
                txtSelectedItem.Text = "No item currently selected.";
            }
            else
            {
               txtSelectedItem.Text = item.ToString();
            }
        }
    }
}

Figure 3-14 shows the ListBox from the example. The first button is the currently selected item.

Figure 3-14. A ListBox containing a rich set of controls as list elements

The following XAML defines a simple ListBox control in Extended selection mode containing some statically defined items. The example contains System.Windows.Controls.TextBox and System.Windows.Controls.Button controls that allow the user to add and remove items from the list.

<Window x:Class="Recipe_03_23.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_23" Height="300" Width="300">
    <StackPanel>
        <ListBox FontSize="16" Height="150" Margin="5" Name="listBox1"
                 SelectionMode="Extended">
            <ListBoxItem>List Item 1</ListBoxItem>
            <ListBoxItem>List Item 2</ListBoxItem>
            <ListBoxItem>List Item 3</ListBoxItem>
        </ListBox>
        <StackPanel HorizontalAlignment="Center" Orientation="Horizontal">
            <Label Content="_New item text:" VerticalAlignment="Center"
                   Target="{Binding ElementName=textBox}" />
            <TextBox Margin="5" Name="textBox" MinWidth="120" />
        </StackPanel>
        <StackPanel HorizontalAlignment="Center" Orientation="Horizontal">
            <utton Click="btnAddListItem_Click" Content="Add Item"
                    IsDefault="True" Margin="5" Name="btnAddListItem" />
            <Button Click="btnDeleteListItem_Click" Content="Delete Items"
                    Margin="5" Name="btnDeleteListItem" />
            <Button Click="btnSelectAll_Click" Content="Select All"
                    Margin="5" Name="btnSelectAll" />
        </StackPanel>
    </StackPanel>
</Window>

The following code-behind handles the Button click events that add and remove items from the list. When the user clicks the Add Item Button, the event handler gets the content of the TextBox, wraps it in a ListBoxItem, formats it, and adds it to the ListBox. When the user clicks the Delete Items Button, the event handler loops through the set of currently selected items and removes them from the ListBox.

using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace Recipe_03_23
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>

public partial class Window1 : Window
   {
     public Window1()
     {
         InitializeComponent();
     }

     // Handles the Add Item Button Click event.
     private void btnAddListItem_Click(object sender,
         RoutedEventArgs e)
     {
         // Ensure there is text to add.
         if (textBox.Text.Length == 0)
         {
             MessageBox.Show("Enter text to add to the list.", Title);
         }
         else
         {
             // Wrap the text in a ListBoxItem and configure.
             ListBoxItem item = new ListBoxItem();
             item.Content = textBox.Text;
             item.IsSelected = true;
             item.HorizontalAlignment = HorizontalAlignment.Center;
             item.FontWeight = FontWeights.Bold;
             item.FontFamily = new FontFamily("Tahoma");

             // Add the ListBoxItem to the ListBox
             listBox1.Items.Add(item);

             // Clear the content of the textBox and give it focus.
             textBox.Clear();
             textBox.Focus();
          }
       }

       // Handles the Delete Item Button Click event.
       private void btnDeleteListItem_Click(object sender,
           RoutedEventArgs e)
       {
           // Ensure there is at least one item selected.
           if (listBox1.SelectedItems.Count == 0)
           {
               MessageBox.Show("Select list items to delete.", Title);
           }

else
       {
           // Iterate through the selected items and remove each one.
           // Cannot use foreach because we are changing the underlying
           // data.
           while (listBox1.SelectedItems.Count > 0)
           {
               listBox1.Items.Remove(listBox1.SelectedItems[0]);
           }
        }
     }

     // Handles the Select All Button Click event.
     private void btnSelectAll_Click(object sender, RoutedEventArgs e)
     {
         listBox1.SelectAll();
     }
   }
}

The following XAML defines a ComboBox containing five ComboBoxItem items and sets the third item to be selected using the IsSelected property. The Get Selected button causes the example to determine which ComboBoxItem is currently selected. As the user changes their selection, the example handles both ComboBoxItem.Selected and ComboBox.SelectionChanged events, displaying messages about which item is now selected.

<Window x:Class="Recipe_03_24.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_24" Height="100" Width="300">
    <StackPanel>
        <ComboBox Name="comboBox" IsEditable="True" Margin="5"
                  SelectionChanged="ComboBox_SelectionChanged">
            <ComboBoxItem Content="ComboBox Item 1"
                          Selected="ComboBoxItem_Selected" />
            <ComboBoxItem Content="ComboBox Item 2"
                          Selected="ComboBoxItem_Selected" />
            <ComboBoxItem Content="ComboBox Item 3"
                          Selected="ComboBoxItem_Selected" IsSelected="True"/>
            <ComboBoxItem Content="ComboBox Item 4"
                          Selected="ComboBoxItem_Selected" />
            <ComboBoxItem Content="ComboBox Item 5"
                          Selected="ComboBoxItem_Selected" />
        </ComboBox>
        <Button Content="Get Selected" Margin="5" Width="100"
                Click="Button_Click" />
    </StackPanel>
</Window>

The following code-behind contains the event handlers used by the preceding XAML:

using System;
using System.Windows;
using System.Windows.Controls;

namespace Recipe_03_24
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        // Gets the currently selected ComboBoxItem when the user
        // clicks the Button. If the SelectedItem of the ComboBox
        // is null, the code checks to see if the user has entered
        // text into the ComboBox instead.
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            ComboBoxItem item = comboBox.SelectedItem as ComboBoxItem;

            if (item != null)
            {
                MessageBox.Show("Current item: " + item.Content, Title);
            }
            else if (!String.IsNullOrEmpty(comboBox.Text))
            {
                MessageBox.Show("Text entered: " + comboBox.Text, Title);
            }
         }

         // Handles ComboBox SelectionChanged events.
         private void ComboBox_SelectionChanged(object sender,
             SelectionChangedEventArgs e)
     {
             // Do not handle events until Window is fully initialized.
             if (!IsInitialized) return;

             ComboBoxItem item = comboBox.SelectedItem as ComboBoxItem;

if (item != null)
       {
          MessageBox.Show("Selected item: " + item.Content, Title);
       }
     }

     // Handles ComboBoxItem Selected events.
     private void ComboBoxItem_Selected(object sender,
         RoutedEventArgs e)
     {
         // Do not handle events until Window is fully initialized.
         if (!IsInitialized) return;

         ComboBoxItem item = e.OriginalSource as ComboBoxItem;

         if (item != null)
         {
             MessageBox.Show(item.Content + " was selected.", Title);
         }
      }
   }
}

The following XAML demonstrates a variety of rotated controls. The bottom left shows the difference in behavior of a LayoutTransform compared to a RenderTransform (shown in the bottom-right corner). See Figure 3-15.

<Window x:Class="Recipe_03_25.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WPF Recipes 3_25" Height="350" Width="400">
    <Grid ShowGridLines="True">
        <Grid.RowDefinitions>
            <RowDefinition MinHeight="140" />
            <RowDefinition MinHeight="170" />
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition />
            <ColumnDefinition />
        </Grid.ColumnDefinitions>
        <TextBox Grid.Row="0" Grid.Column="0" Height="23"
                 HorizontalAlignment="Center" Text="An upside down TextBox."
                 Width="140">
            <TextBox.LayoutTransform>
                <RotateTransform Angle="180"/>
            </TextBox.LayoutTransform>
        </TextBox>
        <Button Content="A rotated Button" Grid.Row="0" Grid.Column="1"
                Height="23" Width="100">
            <Button.LayoutTransform>
                <RotateTransform Angle="-120"/>
            </Button.LayoutTransform>
        </Button>
        <StackPanel Grid.Row="1" Grid.Column="0" >
            <TextBlock HorizontalAlignment="Center" Margin="5">
                Layout Tranform
            </TextBlock>
            <Button Margin="5" Width="100">Top Button</Button>

<Button Content="Middle Button" Margin="5" Width="100">
                    <Button.LayoutTransform>
                        <RotateTransform Angle="30" />
                    </Button.LayoutTransform>
                </Button>
                <Button Margin="5" Width="100">Bottom Button</Button>
            </StackPanel>
            <StackPanel Grid.Row="1" Grid.Column="1" >
            <TextBlock HorizontalAlignment="Center" Margin="5">
                Render Tranform
            </TextBlock>
            <Button Margin="5" Width="100">Top Button</Button>
            <Button Content="Middle Button" Margin="5"
                    RenderTransformOrigin="0.5, 0.5" Width="100">
                <Button.RenderTransform>
                    <RotateTransform Angle="30" />
                </Button.RenderTransform>
            </Button>
            <Button Margin="5" Width="100">Bottom Button</Button>
        </StackPanel>
    </Grid>
</Window>

Figure 3-15 shows a variety of rotated controls.

Figure 3-15. A set of rotated controls