As a Silverlight control developer, you may encounter a need to create a custom content control. This type of control allows the consumers to place anything they want in certain areas of your control. In Silverlight, you may have noticed that the Button control has a content property. You can essentially put anything you want in a button. I’m going to show you how you can create a control to do this.
We are going to create a control that has a header and body. The final result will look like the image below:
Step 1 – Setup the Solution
The first step in creating our control is to ensure that our Visual Studio environment is setup correctly. We’ll have our basic Silverlight Application project and Web Project to test it in. However, we are going to add a Silverlight Class Library project and add a reference to it in our Silverlight Application project.
The next step is what gets a lot of developers. Add a “themes” folder in our controls project (Silverlight Class Library project). Inside the “themes” folder, add a new text file and name it “generic.xaml”. Make sure that the folder/file names are lower case!
Silverlight 2 does not support themes like WPF does. However, inserting the “themes/generic.xaml” file inside our controls project does yield us the ability to define our CustomContentControl style/template.
Step 2 – Create the Custom Content Control
Now that our solution is ready, let’s add our CustomContentControl to our controls project. We’ll be inheriting from the ContentControl object. Therefore by default, we’ll already have a Content property. However we want to create an additional Header property so that other developers can put whatever they want in the header. Here’s our CustomContentControl code:
1: Public Class CustomContentControl
2: Inherits ContentControl
3:
4: Public Shared ReadOnly HeaderProperty As DependencyProperty = DependencyProperty.Register("Header", GetType(UIElement), GetType(CustomContentControl), Nothing)
5:
6: Public Property Header() As UIElement
7: Get
8: Return DirectCast(Me.GetValue(CustomContentControl.HeaderProperty), UIElement)
9: End Get
10: Set(ByVal value As UIElement)
11: Me.SetValue(CustomContentControl.HeaderProperty, value)
12: End Set
13: End Property
14:
15: Public Sub New()
16: MyBase.New()
17: Me.DefaultStyleKey = GetType(CustomContentControl)
18: End Sub
19:
20: End Class
Here we have our control which inherits from ContentControl and has a Header property defined. There’s one last thing to mention about our control. Check out line 17. We set the DefaultStyleKey to a resource object which we are going to define in our generic.xaml file. So let’s do that.
Step 3 – Create Control’s DefaultStyleKey (generic.xaml)
In step 2 we saw that after our CustomContentControl was instantiated we immediately wired up its DefaultStyleKey. In the generic.xaml file we’ll define our style/template for our CustomContentControl. The style will automatically be found and used for our control. Here’s the style for our control:
1: <ResourceDictionary
2: xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3: xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4: xmlns:local="clr-namespace:ContentControlExample.Controls">
5:
6: <!-- CustomContentControl -->
7: <Style TargetType="local:CustomContentControl">
8: <Setter Property="Background" Value="Transparent" />
9: <Setter Property="Foreground" Value="Black" />
10: <Setter Property="BorderBrush" Value="Transparent" />
11: <Setter Property="BorderThickness" Value="0" />
12: <Setter Property="HorizontalAlignment" Value="Stretch" />
13: <Setter Property="VerticalAlignment" Value="Stretch" />
14: <Setter Property="HorizontalContentAlignment" Value="Left" />
15: <Setter Property="VerticalContentAlignment" Value="Top" />
16: <Setter Property="Template">
17: <Setter.Value>
18: <ControlTemplate TargetType="local:CustomContentControl">
19: <Border Background="White" BorderBrush="#87AFDA" BorderThickness="1">
20: <Grid>
21: <Grid.RowDefinitions>
22: <RowDefinition Height="Auto" />
23: <RowDefinition Height="*" />
24: </Grid.RowDefinitions>
25:
26: <Border Grid.Column="0" Grid.Row="0" Background="#D4E6FC" BorderThickness="0,0,0,1" BorderBrush="#87AFDA">
27: <ContentControl Content="{TemplateBinding Header}" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Stretch" Foreground="#224499" FontWeight="Bold" FontFamily="Arial" FontSize="12" Margin="3,3,3,3" />
28: </Border>
29: <ContentControl Grid.Column="0" Grid.Row="1" Content="{TemplateBinding Content}" ContentTemplate="{TemplateBinding ContentTemplate}" Cursor="{TemplateBinding Cursor}" HorizontalAlignment="{TemplateBinding HorizontalAlignment}" HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}" FontFamily="Arial" FontSize="{TemplateBinding FontSize}" FontStretch="{TemplateBinding FontStretch}" Foreground="{TemplateBinding Foreground}" Margin="{TemplateBinding Padding}" VerticalAlignment="{TemplateBinding VerticalAlignment}" VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}" />
30: </Grid>
31: </Border>
32: </ControlTemplate>
33: </Setter.Value>
34: </Setter>
35: </Style>
36: </ResourceDictionary>
At a quick glance take note that we have a ContentControl for both the Header and Content properties of our CustomContentControl. When the template is bound, the Header and Content values will be placed inside our ContentControls defined here.
Step 4 – Use the CustomContentControl
Now that we have the solution setup, our control coded, and our default style/template defined in the generic.xaml file, we can use our control. Here’s the page XAML that uses the control.
1: <UserControl x:Class="ContentControlExample.Page"
2: xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3: xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4: xmlns:ex="clr-namespace:ContentControlExample.Controls;assembly=ContentControlExample.Controls"
5: Width="300" Height="200">
6: <Grid x:Name="LayoutRoot" Background="White">
7: <ex:CustomContentControl x:Name="myCustomContentControl">
8: <ex:CustomContentControl.Header>
9: <TextBlock Text="This is the Header" />
10: </ex:CustomContentControl.Header>
11: <ex:CustomContentControl.Content>
12: <StackPanel Orientation="Vertical" Margin="5">
13: <TextBlock Text="This is the body or content." Margin="0,0,0,5" />
14: <Button Content="Click Me!" Width="100" Height="30" />
15: </StackPanel>
16: </ex:CustomContentControl.Content>
17: </ex:CustomContentControl>
18: </Grid>
19: </UserControl>
If you wish to add events to your custom content control, I've written another post which can be found here.
ContentControlExample_Soln.zip (619.31 kb)