Provides a window that can be displayed over a parent window and blocks interaction with the parent window.
Namespace:
System.Windows.Controls
Assembly:
System.Windows.Controls (in System.Windows.Controls.dll)
Visual Basic (Declaration)
<TemplateVisualStateAttribute(Name := "Open", GroupName := "WindowStates")> _
<TemplatePartAttribute(Name := "CloseButton", Type := GetType(ButtonBase))> _
<TemplatePartAttribute(Name := "ContentPresenter", Type := GetType(FrameworkElement))> _
<TemplatePartAttribute(Name := "Root", Type := GetType(FrameworkElement))> _
<TemplatePartAttribute(Name := "Chrome", Type := GetType(FrameworkElement))> _
<TemplatePartAttribute(Name := "Overlay", Type := GetType(Panel))> _
<TemplatePartAttribute(Name := "ContentRoot", Type := GetType(FrameworkElement))> _
<TemplateVisualStateAttribute(Name := "Closed", GroupName := "WindowStates")> _
Public Class ChildWindow _
Inherits ContentControl
Dim instance As ChildWindow
[TemplateVisualStateAttribute(Name = "Open", GroupName = "WindowStates")]
[TemplatePartAttribute(Name = "CloseButton", Type = typeof(ButtonBase))]
[TemplatePartAttribute(Name = "ContentPresenter", Type = typeof(FrameworkElement))]
[TemplatePartAttribute(Name = "Root", Type = typeof(FrameworkElement))]
[TemplatePartAttribute(Name = "Chrome", Type = typeof(FrameworkElement))]
[TemplatePartAttribute(Name = "Overlay", Type = typeof(Panel))]
[TemplatePartAttribute(Name = "ContentRoot", Type = typeof(FrameworkElement))]
[TemplateVisualStateAttribute(Name = "Closed", GroupName = "WindowStates")]
public class ChildWindow : ContentControl
XAML Object Element Usage
<controls:ChildWindow ...>
singleObject
</controls:ChildWindow>
XAML Values
- controls:
A prefix that is defined to map the XML namespace for the System.Windows.Controls assembly and the System.Windows.Controls CLR namespace.
- singleObject
A single object element that declares the content. Typically this is a class that can support additional content as child elements, such as a Panel class.
You can use a ChildWindow to direct a user’s attention to a particular activity in your application, such as entering data or viewing information. To display simple information to a user, you might consider using a Popup or MessageBox. Consider using a ChildWindow when you want greater customization, you want to block the parent window, or when you want to retrieve a DialogResult and other data from the popup window. A ChildWindow always displays in a modal popup that blocks user interaction with the underlying user interface.
The following illustration shows the parts of a ChildWindow.
ChildWindow Parts
.png)
A ChildWindow has three distinct areas inside its Root part:
Overlay – the part of the child window that covers the parent window.
Chrome – the part of the child window which hosts the Title and CloseButton parts.
ContentRoot – the part of the child window which hosts application-specific content in its ContentPresenter part.
Note: |
|---|
The ChildWindow control includes the Overlay part, which covers the whole parent window. Therefore, when ChildWindow reports its size, it considers the size of the Overlay in addition to the size of the Chrome and ContentRoot parts. |
You typically define a child window by creating a new class that derives from ChildWindow. Alternatively, you can instantiate a ChildWindow directly. A child window can be the child of another child window.
To display a child window, call the Show method. The Show method does not block the calling thread. This lets activity on the parent window, such as an animation, continue. However, user interaction with the parent window is not possible as long as the child window is open.
By default, a user can close a child window by clicking the close button in the title bar, or by pressing the CTRL+SHIFT+F4 key combination.
To close a child window programmatically, you can either set the DialogResult value or call the Close method. Setting the DialogResult value will automatically call the Close method to close the child window.
You can cancel the close action by handling the Closing event and setting the CancelEventArgs..::.Cancel property to true in the event handler. If the close action is canceled, the DialogResult value will be reset to nullNothingnullptra null reference (Nothing in Visual Basic).
To get the DialogResult value from a child window, handle the Closed event in the code-behind page of the calling window. In the Closed event handler, cast the sender parameter to a ChildWindow or a derived class to access the DialogResult property.
Note: |
|---|
The ChildWindow control is available as part of the libraries in the Silverlight Software Development Kit (SDK). For more information, see the Silverlight Tools. |
To add a ChildWindow Control to a Visual Studio Project
To add a ChildWindow to a project in Visual Studio, complete the following steps:
In Solution Explorer, select your Silverlight project.
On the Project menu, click Add New Item. The Add New Item dialog box opens.
In the Category pane, select Silverlight.
In the Templates pane, select Silverlight Child Window
Enter a name for the child window and click Add.
Customizing the ChildWindow Control
You can set the Title to be any object. This lets you create complex titles with text, graphics, and animations. If the object does not have a visual representation, the string representation of the object returned by the ToString method will be shown in the title bar. You can modify the appearance of the child window overlay area by setting the OverlayBrush and OverlayOpacity properties.
The default close button can be hidden by setting the HasCloseButton property to false. This can be useful if you want to prevent a user from dismissing the information displayed in the child window. For example, you might display a video message and then close the child window automatically when the video is finished. If the default close button is hidden, you should call the Close method in your code to close the child window or provide an alternative way for the user to close the child window.
You can customize a child window every time it is opened by overriding the OnOpened method. In the OnOpened method, apply conditional logic to set the properties of the child window.
To apply the same property settings to multiple ChildWindow controls, use the Style property. To change the visual structure and visual behavior of a ChildWindow, copy and modify its default style and template. For more information, see Control Customization. To apply a template to the whole ChildWindow control, including the overlay, chrome, and content areas, set the Template property. To apply a template to only chrome and content areas, set the ContentTemplate property.
If a dependency property for a ChildWindow is set by its default style, the property might change from its default value when the ChildWindow appears in the application. For more information, see Dependency Property Value Precedence. You can get the default style and template for ChildWindow from ChildWindow Styles and Templates.
The following code example demonstrates how to use a child window to get login credentials from a user. The LoginWindow class is derived from ChildWindow. In the main page of the application, the LoginWindow is instantiated and displayed when the login button is clicked. If the user submits their login credentials with incomplete information, a second ChildWindow is displayed with instructions for the user. When the user submits their login credentials, the LoginWindow is closed and the main page displays a greeting to the user.
Run this sample
The following XAML and code show the child window.
<controls:ChildWindow x:Class="ChildWindowLogin.LoginWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:controls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls"
Width="300" Height="200"
Title="Login Window"
Closing="ChildWindow_Closing">
<Grid x:Name="LayoutRoot" Margin="2">
<Grid.RowDefinitions>
<RowDefinition />
<RowDefinition Height="Auto" />
</Grid.RowDefinitions>
<StackPanel>
<TextBlock Text="Name" />
<TextBox x:Name="nameBox"/>
<TextBlock Text="Password" />
<PasswordBox x:Name="passwordBox"/>
</StackPanel>
<Button x:Name="CancelButton" Content="Cancel" Click="CancelButton_Click"
Width="75" Height="23" HorizontalAlignment="Right" Margin="0,12,0,0"
Grid.Row="1" />
<Button x:Name="OKButton" Content="OK" Click="OKButton_Click"
Width="75" Height="23" HorizontalAlignment="Right" Margin="0,12,79,0"
Grid.Row="1" />
</Grid>
</controls:ChildWindow>
Partial Public Class LoginWindow
Inherits ChildWindow
Public Sub New()
InitializeComponent()
End Sub
Private Sub OKButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs) Handles OKButton.Click
Me.DialogResult = True
End Sub
Private Sub CancelButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs) Handles CancelButton.Click
Me.DialogResult = False
End Sub
Private Sub ChildWindow_Closing(ByVal sender As System.Object, ByVal e As System.ComponentModel.CancelEventArgs)
If Me.DialogResult = True AndAlso _
(Me.nameBox.Text = String.Empty OrElse Me.passwordBox.Password = String.Empty) Then
e.Cancel = True
Dim cw As New ChildWindow
cw.Content = "Please enter name and password or click Cancel."
cw.Show()
End If
End Sub
End Class
using System.Windows;
using System.Windows.Controls;
namespace ChildWindowLogin
{
public partial class LoginWindow : ChildWindow
{
public LoginWindow()
{
InitializeComponent();
}
private void OKButton_Click(object sender, RoutedEventArgs e)
{
this.DialogResult = true;
}
private void CancelButton_Click(object sender, RoutedEventArgs e)
{
this.DialogResult = false;
}
private void ChildWindow_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
if (this.DialogResult == true &&
(this.nameBox.Text == string.Empty || this.passwordBox.Password == string.Empty))
{
e.Cancel = true;
ChildWindow cw = new ChildWindow();
cw.Content = "Please enter name and password or click Cancel.";
cw.Show();
}
}
}
}
The following XAML and code show the parent window that calls the child window.
<UserControl x:Class="ChildWindowLogin.MainPage"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Width="300" Height="200">
<Grid x:Name="LayoutRoot" Background="White">
<StackPanel Margin="5">
<Button Height="23" Width="100" HorizontalAlignment="Left"
Content="Log in" Click="Button_Click" />
<TextBlock Name="helloTxt" />
</StackPanel>
</Grid>
</UserControl>
Partial Public Class MainPage
Inherits UserControl
Public Sub New()
InitializeComponent()
End Sub
Private Sub Button_Click(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs)
Dim loginWnd As New LoginWindow()
AddHandler loginWnd.Closed, AddressOf loginWnd_Closed
loginWnd.Show()
End Sub
Private Sub loginWnd_Closed(ByVal sender As System.Object, ByVal e As EventArgs)
Dim lw As LoginWindow = CType(sender, LoginWindow)
If lw.DialogResult = True AndAlso lw.nameBox.Text <> String.Empty Then
Me.helloTxt.Text = "Hello " + lw.nameBox.Text
ElseIf (lw.DialogResult = False) Then
Me.helloTxt.Text = "Login canceled."
End If
End Sub
End Class
using System;
using System.Windows;
using System.Windows.Controls;
namespace ChildWindowLogin
{
public partial class MainPage : UserControl
{
public MainPage()
{
InitializeComponent();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
LoginWindow loginWnd = new LoginWindow();
loginWnd.Closed += new EventHandler(loginWnd_Closed);
loginWnd.Show();
}
void loginWnd_Closed(object sender, EventArgs e)
{
LoginWindow lw = (LoginWindow)sender;
if (lw.DialogResult == true && lw.nameBox.Text != string.Empty)
{
this.helloTxt.Text = "Hello " + lw.nameBox.Text;
}
else if (lw.DialogResult == false)
{
this.helloTxt.Text = "Login canceled.";
}
}
}
}
The following code example demonstrates how to use a child window as a splash screen. The SplashWindow class is derived from ChildWindow. In the main page of the application, the SplashWindow is instantiated and displayed when the page is loaded or when the button is clicked. The SplashWindow displays one of two videos that is randomly selected in the OnOpened method. It closes automatically when the video is finished. The splash window uses a custom OverlayBrush and does not have a close button.
Run this sample
The following XAML and code show the child window.
<controls:ChildWindow x:Class="ChildWindowSplash.SplashWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:controls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls"
Width="200" Height="150"
HasCloseButton="False"
OverlayBrush="{StaticResource overlayGradient}"
OverlayOpacity="0.85">
<Grid x:Name="LayoutRoot" Margin="2">
<MediaElement x:Name="splashMedia" MediaEnded="splashMedia_MediaEnded"
Height="100" Margin="10" />
</Grid>
</controls:ChildWindow>
Partial Public Class SplashWindow
Inherits ChildWindow
Public Sub New()
InitializeComponent()
End Sub
Private Sub splashMedia_MediaEnded(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs)
Me.Close()
End Sub
Protected Overrides Sub OnOpened()
MyBase.OnOpened()
Dim generator As New Random
Dim randomValue As Integer
randomValue = generator.Next(0, 2)
If randomValue = 1 Then
Me.splashMedia.Source = New Uri("/Silverlight1.wmv", UriKind.RelativeOrAbsolute)
Else
Me.splashMedia.Source = New Uri("/Silverlight2.wmv", UriKind.RelativeOrAbsolute)
End If
End Sub
End Class
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Shapes;
namespace ChildWindowSplash
{
public partial class SplashWindow : ChildWindow
{
public SplashWindow()
{
InitializeComponent();
}
private void splashMedia_MediaEnded(object sender, RoutedEventArgs e)
{
this.Close();
}
protected override void OnOpened()
{
base.OnOpened();
Random random = new Random();
if ((int)random.Next(0, 2) == 1)
{
this.splashMedia.Source = new Uri("/Silverlight1.wmv", UriKind.RelativeOrAbsolute); ;
}
else
this.splashMedia.Source = new Uri("/Silverlight2.wmv", UriKind.RelativeOrAbsolute);
}
}
}
The following XAML and code show the parent window that calls the child window.
<UserControl x:Class="ChildWindowSplash.MainPage"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Width="400" Height="300">
<Grid x:Name="LayoutRoot" Background="White">
<Button Content="Show Splash Window" Click="Button_Click"
Height="100" Width="200" Margin="10" />
</Grid>
</UserControl>
Partial Public Class MainPage
Inherits UserControl
Public Sub New()
InitializeComponent()
AddHandler Me.Loaded, AddressOf MainPage_Loaded
End Sub
Private Sub Button_Click(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs)
Dim splashWnd As New SplashWindow
splashWnd.Show()
End Sub
Private Sub MainPage_Loaded(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs)
Dim splashWnd As New SplashWindow
splashWnd.Show()
End Sub
End Class
using System.Windows;
using System.Windows.Controls;
namespace ChildWindowSplash
{
public partial class MainPage : UserControl
{
public MainPage()
{
InitializeComponent();
Loaded += new RoutedEventHandler(MainPage_Loaded);
}
void MainPage_Loaded(object sender, RoutedEventArgs e)
{
SplashWindow splashWnd = new SplashWindow();
splashWnd.Show();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
SplashWindow splashWnd = new SplashWindow();
splashWnd.Show();
}
}
}
System..::.Object
System.Windows..::.DependencyObject
System.Windows..::.UIElement
System.Windows..::.FrameworkElement
System.Windows.Controls..::.Control
System.Windows.Controls..::.ContentControl
System.Windows.Controls..::.ChildWindow
Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.
For a list of the operating systems and browsers that are supported by Silverlight, see Supported Operating Systems and Browsers.
Reference