c# .net pdf reader : Add pages to pdf online SDK software API .net winforms html sharepoint Pro_Silverlight_5_in_CSharp_4th_edition52-part118

CHAPTER 14  STYLES AND BEHAVIORS 
514 
wraps all the properties you want to set. You’ll store this Style object as a resource, typically in the 
UserControl.Resources collection that holds resources for the entire page: 
<UserControl.Resources> 
<Style x:Key="BigButtonStyle" TargetType="Button"> 
... 
</Style> 
</UserControl.Resources> 
Like all resources, the style has a key name so you can pull it out of the collection when needed. In 
this case, the key name is BigButtonStyle. (By convention, the key names for styles usually end with 
Style.) Additionally, every Silverlight style requires a TargetType, which is the type of element on which 
you apply the style. In this case, the TargetType property indicates that this style is designed to format 
buttons. 
Every style holds a Setters collection with several Setter objects, one for each property you want to 
set. Each Setter object sets a single property in an element. The only limitation is that a setter can change 
only dependency properties—other properties can’t be modified. (In practice, this isn’t much of a 
limitation, because Silverlight elements consist almost entirely of dependency properties.) It’s also 
important to note that property setters can act on any dependency property, even one that governs 
behavior rather than appearance. For example, if you’re applying a style to a text box, you may choose to 
set the AcceptsReturn and IsReadOnly properties. 
Here’s a style that sets a combination of five properties, giving buttons large, light text with Georgia 
font: 
<UserControl.Resources> 
<Style x:Key="BigButtonStyle" TargetType="Button"> 
<Setter Property="FontFamily" Value="Georgia" /> 
<Setter Property="FontSize" Value="40" /> 
<Setter Property="Foreground" Value="SlateGray" /> 
<Setter Property="Padding" Value="20" /> 
<Setter Property="Margin" Value="10" /> 
</Style> 
</UserControl.Resources> 
In some cases, you can’t set the property value using a simple attribute string. For example, you 
can’t create a complex brush like LinearGradientBrush or ImageBrush with a string. In this situation, you 
can use the familiar XAML trick of replacing the attribute with a nested element. Here’s an example that 
sets the button background: 
<Style x:Key="BigButtonStyle" TargetType="Button"> 
<Setter Property="Background"> 
<Setter.Value> 
<LinearGradientBrush StartPoint="0,0" EndPoint="1,0"> 
<GradientStop Color="Blue"></GradientStop> 
<GradientStop Color="Yellow" Offset="1"></GradientStop> 
</LinearGradientBrush> 
</Setter.Value> 
</Setter> 
... 
</Style
More powerfully, a style can set transforms, rendering effects, and control templates that 
completely revamp the appearance of an element. 
www.it-ebooks.info
Add pages to pdf online - insert pages into PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide C# Users to Insert (Empty) PDF Page or Pages from a Supported File Format
add page numbers to pdf using preview; add page number pdf file
Add pages to pdf online - VB.NET PDF Page Insert Library: insert pages into PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Easy to Use VB.NET APIs to Add a New Blank Page to PDF Document
add page to pdf acrobat; add page pdf
CHAPTER 14  STYLES AND BEHAVIORS 
515 
Applying a Style 
Every Silverlight element can use a single style (or no style). The style plugs into an element through the 
element’s Style property (which is defined in the base FrameworkElement class). For example, to 
configure a button to use the style you created previously, you point the button to the style resource like 
this: 
<Button Style="{StaticResource BigButtonStyle}" 
Content="A Customized Button"></Button
Figure 14-1 shows a page with two buttons that use BigButtonStyle. 
Figure 14-1. Reusing button settings with a style 
The style system adds many benefits. Not only does it allow you to create groups of settings that are 
clearly related, but it also streamlines your markup by making it easier to apply these settings. Best of all, 
you can apply a style without worrying about what properties it sets. In the previous example, the font 
settings are organized into a style named BigButtonStyle. If you decide later that your big-font buttons 
also need more padding and margin space, you can add setters for the Padding and Margin properties as 
well. All the buttons that use the style automatically acquire the new style settings. 
Styles set the initial appearance of an element, but you’re free to override the characteristics they 
set. For example, if you apply the BigButtonStyle style and set the FontSize property explicitly, the 
FontSize setting in the button tag overrides the style. Ideally, you won’t rely on this behavior. Instead, if 
you need to alter a style, you should create a new style that sets the appropriate properties. This gives 
you more flexibility to adjust your user interface in the future with minimum disruption. 
www.it-ebooks.info
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
File: Split PDF; C# Page: Insert PDF pages; C# Page: Delete PDF pages; C# Read C# Read: PDF Image Extract; C# Write: Insert text into PDF; C# Write: Add Image to
add pages to pdf reader; adding page numbers in pdf
VB.NET PDF insert image library: insert images into PDF in vb.net
Access to freeware download and online VB.NET to provide users the most individualized PDF page image inserting function, allowing developers to add and insert
adding page numbers to a pdf in preview; add pages to pdf online
CHAPTER 14  STYLES AND BEHAVIORS 
516 
Dynamic Styles 
Although you’ll usually want to link up styles in your markup, you can also set them programmatically. 
All you need to do is pull the style out of the appropriate Resources collection.  
Here’s the code you use to retrieve the BigButtonStyle from the page’s Resources collection and 
apply it to a Button object named cmd: 
cmd.Style = (Style)this.Resources["AlternateBigButtonStyle"]; 
You can even retrieve a style from a separate resource dictionary file in your project (or a referenced 
assembly). First, you need to create a ResourceDictionary object and supply the correct URI: 
ResourceDictionary resourceDictionary = new ResourceDictionary(); 
resourceDictionary.Source = new Uri("/Styles/AlternateStyles.xaml"
UriKind.Relative); 
This example assumes the resource dictionary is a file named AlternateStyles.xaml in a project 
folder named Styles. For this example to work, the resource dictionary must be compiled as a content 
file (set Build Action to Content in the Properties window). 
After you’ve configured the ResourceDictionary with the right URI, you can retrieve an object from 
inside: 
Style newStyle = (Style)resourceDictionary["BigButtonStyle"]; 
cmd.Style = newStyle; 
Finally, to remove a style, set the Style property to null. 
The ability to change styles dynamically opens up the possibility of creating skinnable applications 
that can change their appearance based on user preferences. However, implementing such a system 
would be tedious, because you’d need to programmatically retrieve each style object and set each styled 
control. In WPF, the job is much easier—you simply swap in a new merged dictionary, and all the 
controls that use styles from that merged dictionary update themselves automatically. 
Style Inheritance 
In some situations, you may want to use the properties from one style as the basis for another, more 
specialized style. You can use this sort of style inheritance by setting the BasedOn attribute of a style. For 
example, consider these two styles: 
<UserControl.Resources> 
<Style x:Key="BigButtonStyle" TargetType="Button"> 
<Setter Property="FontFamily" Value="Georgia" /> 
<Setter Property="FontSize" Value="40" /> 
<Setter Property="Padding" Value="20" /> 
<Setter Property="Margin" Value="10" /> 
</Style> 
<Style x:Key="EmphasizedBigButtonStyle" TargetType="Button" 
BasedOn="{StaticResource BigButtonStyle}"> 
<Setter Property="BorderBrush" Value="Black" /> 
<Setter Property="BorderThickness" Value="5" /> 
</Style> 
</UserControl.Resources> 
www.it-ebooks.info
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
In order to run the sample code, the following steps would be necessary. Add necessary references: How to VB.NET: Delete Consecutive Pages from PDF.
add page number to pdf preview; adding a page to a pdf in preview
VB.NET PDF Password Library: add, remove, edit PDF file password
VB: Add Password to PDF with Permission Settings Applied. This VB.NET example shows how to add PDF file password with access permission setting.
adding page numbers to pdf in; add a page to a pdf file
CHAPTER 14  STYLES AND BEHAVIORS 
517 
The first style (BigButtonStyle) defines four properties. The second style 
(EmphasizedBigFontButtonStyle) acquires these aspects from BigFontButtonStyle and then 
supplements them with two more properties that apply a thick black outline around the button. This 
two-part design gives you the ability to apply just the font settings or the font and color combination. 
This design also allows you to create more styles that incorporate the font or color details you’ve defined 
(but not necessarily both). 
You can use the BasedOn property to create an entire chain of inherited styles. The only rule is that 
if you set the same property twice, the last property setter (the one in the derived class farthest down the 
inheritance chain) overrides any earlier definitions. 
 Tip  Surprisingly, an inherited style doesn’t need to have the same TargetType as its parent. That means you 
can create a derived style that has the same formatting properties—but acts on a different element—than the 
parent. But you’ll get an error if your style inherits a setter for a property that doesn’t exist in its target element 
in a button style and create a TextBlock style that derives from it. However, only the button has the IsEnabled 
property, so if you set IsEnabled in a Button style, you can’t derive a TextBlock style from it.) 
STYLE INHERITANCE ADDS COMPLEXITY 
Although style inheritance seems like a great convenience at first glance, it’s usually not worth the trouble. 
That’s because style inheritance is subject to the same problems as code inheritance: dependencies that 
make your application more fragile. For example, if you use the markup shown previously, you’re forced to 
keep the same font characteristics for two styles. If you decide to change BigButtonStyle, 
EmphasizedBigButtonStyle changes as well—unless you explicitly add more setters that override the 
inherited values. 
This problem is trivial enough in
inheritance in a more realistic application. Usually, styles are categorized based on different types of 
content and the role the content plays. For example, a sales application may include styles such as 
ProductTitleStyle, ProductTextStyle, HighlightQuoteStyle, NavigationButtonStyle, and so on. If you base 
ProductTitleStyle on ProductTextStyle (perhaps because they both share the same font), you’ll run into 
trouble if you apply settings to ProductTextStyle later that you don’t want to apply to ProductTitleStyle 
(such as different margins). In this case, you’ll be forced to define your settings in ProductTextStyle and 
explicitly override them in ProductTitleStyle. At the end, you’ll be left with a more complicated model and 
very few style settings that are actually reused. 
Unless you have a specific reason to base one style on another (for example, the second style is a special 
case of the first and changes just a few characteristics out of a large number of inherited settings), think 
carefully before using style inheritance. 
www.it-ebooks.info
C# PDF insert image Library: insert images into PDF in C#.net, ASP
Insert images into PDF form field. Access to freeware download and online C#.NET class source code. How to insert and add image, picture, digital photo, scanned
add page numbers pdf; add page numbers to a pdf
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
options, including setting a single page, a series of pages, and random pages to be C#.NET Project DLLs for Deleting PDF Document Page. Add necessary references
add page numbers to a pdf document; add page break to pdf
CHAPTER 14  STYLES AND BEHAVIORS 
518 
Organizing Styles 
In the previous examples, the Style object is defined at the page level and then reused in buttons inside 
that page. Although that’s a common design, it’s certainly not your only choice. 
Strictly speaking, you don’t need to use styles and resources together. For example, you can define 
the style of a particular button by filling its Style collection directly, as shown here: 
<Button Content="A Customized Button"> 
<Button.Style> 
<Style TargetType="Button"> 
<Setter Property="FontFamily" Value="Georgia" /> 
<Setter Property="FontSize" Value="40" /> 
<Setter Property="Foreground" Value="White" /> 
</Style> 
</Button.Style> 
</Button> 
This works, but it’s obviously a lot less useful. Now there’s no way to share this style with other 
elements. 
More usefully, you may want to define styles in different resource collections. If you want to create 
more finely targeted styles, you can define them using the resources collection of their container, such as 
a StackPanel or a Grid. It’s even possible for the same style to be defined at multiple levels (in a 
StackPanel containing a button and in the page that holds the StackPanel). In this situation, Silverlight 
follows the standard resource-resolution process you learned about in Chapter 2—it searches in the 
resources collection of the current element first, then the containing element, then its container, and so 
on, until it finds a style with the matching name. 
If you want to reuse styles across an application, you should define them using the resources 
collection of your application (in the App.xaml file), which is the last place Silverlight checks. Or even 
better, put them in a separate resource dictionary that’s merged into the resource collection of every 
page that needs it, as explained in Chapter 2. 
Automatically Applying Styles by Type 
So far, you’ve seen how to create named styles and refer to them in your markup. However, there’s 
another approach. You can apply a style automatically to elements of a certain type. 
Doing this is quite easy. You simply need to set the TargetType property to indicate the appropriate 
type (as described earlier) and leave out the key name altogether. Here’s an example: 
<Style TargetType="Button"> 
Now the style is automatically applied to any buttons all the way down the element tree. For 
example, if you define a style in this way on the UserControl.Resources collection, it applies to every 
button in that page (unless there’s a style further downstream that replaces it). 
Here’s an example that sets the button styles automatically to get the same effect you saw in Figure 
14-1: 
<UserControl.Resources> 
<Style TargetType="Button"> 
<Setter Property="FontFamily" Value="Georgia" /> 
<Setter Property="FontSize" Value="40" /> 
<Setter Property="Foreground" Value="SlateGray" /> 
<Setter Property="Padding" Value="20" /> 
<Setter Property="Margin" Value="10" /> 
www.it-ebooks.info
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
File: Split PDF; C# Page: Insert PDF pages; C# Page: Delete PDF pages; C# Read C# Read: PDF Image Extract; C# Write: Insert text into PDF; C# Write: Add Image to
adding page numbers to pdf document; adding page numbers to pdf
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
File: Split PDF; C# Page: Insert PDF pages; C# Page: Delete PDF pages; C# Read C# Read: PDF Image Extract; C# Write: Insert text into PDF; C# Write: Add Image to
add pdf pages to word document; add page numbers to pdf preview
CHAPTER 14  STYLES AND BEHAVIORS 
519 
</Style> 
</UserControl.Resources> 
<StackPanel x:Name="LayoutRoot" Background="White"> 
<Button Content="A Customized Button"></Button> 
<Button Content="Another Customized Button"></Button> 
</StackPanel> 
If you want to prevent a style from being applied to an element automatically, you simply need to 
set the Style property to something else. If you don’t want to use any style at all, simply set it to a null 
value, which effectively removes the style: 
<Button Content="A Non-Customized Button" Style="{x:Null}"></Button> 
Although automatic styles are convenient, they can complicate your design. Here are a few reasons 
why: 
• In a complex page with many styles and multiple layers of styles, it becomes 
difficult to track down whether a given property is set through property value 
inheritance or a style (and if it’s a style, which one). As a result, if you want to 
change a simple detail, you may need to wade through the markup of your entire 
page. 
• The formatting in a page often starts out more general and becomes increasingly 
fine-tuned. If you apply automatic styles to the page early on, you’ll probably need 
to override the styles in many places with explicit styles. This complicates the 
overall design. It’s much more straightforward to create named styles for every 
combination of formatting characteristics you want and apply them by name. 
• For example, if you create an automatic style for the TextBlock element, you’ll 
wind up modifying other controls that use the TextBlock (such as a template-
driven ListBox control). 
To avoid problems, it’s best to apply automatic styles judiciously. If you do decide to give your 
entire user interface a single, consistent look using automatic styles, try to limit your use of explicit styles 
to special cases.  
Style Binding Expressions 
In Chapter 2, you learned about XAML to define resources in XAML and write simple binding 
expressions. Both techniques apply to styles. 
First, you can use the StaticResource markup extension in your style setters to reference a resource 
object. Here’s an example: 
<UserControl.Resources> 
<FontFamily x:Key="buttonFontFamily">Georgia</FontFamily> 
<sys:Double x:Key="buttonFontSize">18</sys:Double> 
<FontWeight x:Key="buttonFontWeight">Bold</FontWeight>         
<Style x:Key="BigButtonStyle1" TargetType="Button"> 
<Setter Property="FontFamily" Value="{StaticResource buttonFontFamily}" /> 
<Setter Property="FontSize" Value="{StaticResource buttonFontSize}" /> 
<Setter Property="FontWeight" Value="{StaticResource buttonFontWeight}" />                       
</Style> 
www.it-ebooks.info
CHAPTER 14  STYLES AND BEHAVIORS 
520 
</UserControl.Resources> 
This snippet of markup adds three resources: a FontFamily object with the name of the font you 
want to use, a double that stores the number 18, and the enumerated value FontWeight.Bold. It assumes 
you’ve mapped the System namespace System to the XML namespace prefix sys, as shown here: 
<UserControl xmlns:sys="clr-namespace:System;assembly=mscorlib" ... > 
 Note  The resource doesn’t need to be in the same page as your style setting. Silverlight will search up the 
resource tree, ending with the application resources, as described in Chapter 2. 
Of course, you might prefer to wrap these font settings into a single object. Silverlight doesn’t have 
any all-in-one Font class, but you can certainly create your own, like the FontInfo class shown here: 
public class FontInfo 
public FontFamily FontFamily { getset; }         
public double FontSize getset; } 
public FontWeight FontWeight { getset; } 
And if you make that namespace available to your markup: 
<UserControl xmlns:local="clr-namespace:Styles" ... > 
you can use it in your resources collection and bind to it in your styles: 
<UserControl.Resources> 
<local:FontInfo x:Key="buttonFont" FontFamily="Georgia" FontSize="18" 
FontWeight="Bold"></local:FontInfo> 
<Style x:Key="BigButtonStyle2" TargetType="Button"> 
<Setter Property="Padding" Value="20" /> 
<Setter Property="Margin" Value="10" /> 
<Setter Property="FontFamily"  
Value="{Binding Source={StaticResource buttonFont}, Path=FontFamily}" /> 
<Setter Property="FontSize" 
Value="{Binding Source={StaticResource buttonFont}, Path=FontSize}" /> 
<Setter Property="FontWeight" 
Value="{Binding Source={StaticResource buttonFont}, Path=FontWeight}" /> 
</Style> 
</UserControl.Resources> 
Here, each binding expression grabs the resource named buttonFont and extracts a single property, 
just as you learned to do in Chapter 2. 
Both of these techniques inject dependencies that can make your code more fragile and difficult to 
work with. For example, it’s all too easy to accidentally apply these styles in a page where the linked 
resource isn’t available. In general, these features are meant to support higher-level frameworks, like the 
MVVM toolkits introduced in the commanding section of Chapter 4. You can use them on your own, but 
be careful not to make your markup more complicated than necessary. 
www.it-ebooks.info
CHAPTER 14  STYLES AND BEHAVIORS 
521 
Behaviors 
Styles give you a practical way to reuse groups of property settings. They’re a great first step that can help 
you build consistent, well-organized interfaces—but they’re also broadly limited. 
The problem is that property settings are only a small part of the user-interface infrastructure in a 
typical application. Even the most basic program usually needs reams of user-interface code that has 
nothing to do with the application’s functionality. In many programs, the code that’s used for UI tasks 
(such as driving animations, powering slick effects, maintaining user-interface state, and supporting 
user-interface features like dragging, zooming, and docking) far outweighs the business code in both size 
and complexity. Much of this code is generic, meaning you end up writing the same thing in every 
Silverlight project you create. Almost all of it is tedious. 
Based on this reality, it’s clear that a method for reusing user-interface code would be even more 
useful than a system for reusing property values through styles. So far, Silverlight hasn’t met the 
challenge. But a new system of behaviors is beginning to fill the gap. The idea is simple: you (or another 
developer) create a behavior that encapsulates a common bit of user-interface functionality. This 
functionality can be basic (such as starting a storyboard or navigating to a hyperlink). Or, it can be 
complex (such as handling scrolling and the mouse wheel for a Deep Zoom image or modeling a 
collision with a real-time physics engine). Once built, this functionality can be added to another control 
in any application by hooking up the right behavior and setting its properties. In Expression Blend, using 
a behavior takes little more than a drag-and-drop operation. 
 Note  Custom controls are another technique for reusing user-interface functionality in an application (or among 
multiple applications). However, a custom control must be developed as a tightly linked package of visuals and 
code. Although custom controls are extremely powerful, they don’t address situations where you need to equip 
many different controls with similar functionality (for example, adding a mouse-over rendering effect to a group of 
different elements). For that reason, styles, behaviors, and custom controls are all complementary, and some of 
the most flexible applications use them in combination. You’ll learn about behaviors in the rest of this chapter and 
custom controls in the next chapter. 
Getting Support for Behaviors 
There’s one catch. The new infrastructure for reusing common blocks of user-interface code isn’t part of 
the Silverlight SDK. Instead, it’s bundled with Expression Blend. This is because behaviors began as a 
design-time feature for Expression Blend (and Expression Blend is currently the only tool that lets you 
add behaviors by dragging them onto the controls that need them). That doesn’t mean behaviors are 
useful only in Expression Blend. You can create and use them in a Visual Studio application with only 
slightly more effort. (You simply need to write the markup by hand rather than using the Toolbox.) 
To get the assemblies that support behaviors, you have three options: 
• Use the beta version of Expression Blend for Silverlight 5. (To get it, search for 
“Silverlight 5” at www.microsoft.com/download.) 
www.it-ebooks.info
CHAPTER 14  STYLES AND BEHAVIORS 
522 
•  Install the Expression Blend SDK for Silverlight 4 (which is available at 
http://tinyurl.com/25sh2jt). Even though the version numbers don’t match, this 
works equally well with Silverlight 5. Microsoft may also release an Expression 
Blend SDK for Silverlight 5 at some point in the future. 
• Use Expression Blend 4. Even though you can’t author a Silverlight 5 application 
in Expression Blend 4, you can still grab the assemblies you need from an 
Expression Blend 4 installation. 
No matter which option you use, you’ll get two important assemblies: 
• System.Windows.Interactivity.dll: This assembly defines the base classes that 
support behaviors. It’s the cornerstone of the behavior feature. 
• Microsoft.Expression.Interactions.dll: This assembly adds some useful extensions, 
with optional action and trigger classes that are based on the core behavior 
classes. 
Look for these assemblies in a folder like c:\Program Files\Microsoft 
SDKs\Expression\Blend\Silverlight\v5.0\Libraries. If you’re using a version of Expression Blend that 
supports Silverlight 4 rather than Silverlight 5, change the v5.0 folder part of the path to v4.0, and look for 
the assemblies there. 
In the following sections, you’ll see how to develop a simple action and wire it up in an application, 
using nothing more than the System.Windows.Interactivity.dll assembly. Once you’ve completed this 
exercise and you understand the behavior model, you’ll examine the 
Microsoft.Expression.Interactions.dll assembly and consider other ready-made behaviors. 
Triggers and Actions 
The behaviors feature consists of three smaller ingredients—trigger, action, and behavior classes—
which, somewhat confusingly, are all called behaviors. 
Triggers and actions work hand in hand. The trigger fires when something happens and invokes an 
action. Together, triggers and actions make up the simplest form of behavior. 
Creating an Action 
To get a grip on triggers and actions, it helps to design a simple action of your own. For example, 
imagine you want to play a sound when the user performs an operation (such as clicking a button). It’s 
fairly easy to carry this out without behaviors—you add a MediaElement to the page, supply the URI of 
an audio file, and call the MediaElement.Play() method at the appropriate time. However, these details 
add unnecessary clutter. If you want to play a range of different sounds in response to different events, 
you need to manage a surprisingly large amount of code. 
You can avoid the hassle with an action that takes care of the playback for you. And assuming no 
one has created just the action you need, you can create it yourself. First, create a Silverlight class library 
assembly. (In this example, it’s called CustomBehaviorsLibrary.) Then, add a reference to the 
System.Windows.Interactivity.dll assembly. Finally, create an action class that derives from 
TriggerAction, as shown here: 
Public Class PlaySoundAction 
Inherits TriggerAction(Of FrameworkElement) 
{ ... } 
www.it-ebooks.info
CHAPTER 14  STYLES AND BEHAVIORS 
523 
All actions derive from the confusingly named TriggerAction class. That’s because these are actions 
that are activated by a trigger. (In theory, the model could support actions that are wired up in different 
ways, although it currently doesn’t and there’s no reason it should.) 
 Note  Ideally, you won’t need to create an action yourself—instead, you’ll use a ready-made action that 
someone else has created. Although the System.Windows.Interactivity.dll assembly doesn’t include any action 
classes, you’ll hunt some down later in this chapter. 
As you can see in the previous example, the TriggerAction class uses generics. When you derive from 
TriggerAction, you supply the type of element that can use your action as a type parameter. Unless your 
action requires specialized functionality in the triggering element, it’s common to use UIElement or 
FrameworkElement. In this example, PlaySoundAction supports any FrameworkElement. (It uses 
FrameworkElement rather than the somewhat more generic UIElement class, because it needs to use 
the VisualTreeHelper to search the visual tree, as you’ll see shortly. But because all elements inherit from 
FrameworkElement, which in turn inherits from UIElement, there’s really no difference.) 
Like any other class, your action needs properties. Ideally, you’ll use dependency properties to give 
yourself the best support for other Silverlight features. In this example, PlaySoundAction requires just 
one property—the URI source that points to the audio file: 
public static readonly DependencyProperty SourceProperty = 
DependencyProperty.Register("Source"typeof(Uri), 
typeof(PlaySoundAction), new PropertyMetadata(null)); 
public Uri Source 
get { return (Uri)GetValue(PlaySoundAction.SourceProperty); } 
set { SetValue(PlaySoundAction.SourceProperty, value); } 
When a trigger fires, it activates your action by calling the Invoke() method. You override this 
method to supply all the code for your action. In this example, that means you need to supply the code 
that plays the audio. 
As you know from Chapter 12, the media support in Silverlight has one clear restriction. To play 
anything through a MediaElement, you must place it in your hierarchy of elements. Even if your 
MediaElement is intended to play ordinary audio and has no visual presence, it needs to be in your 
page’s visual tree. 
You can handle this limitation several possible ways in the PlaySoundAction class. For example, you 
can include a property that takes the name of a MediaElement on the page. PlaySoundAction can then 
look up that MediaElement and use it. Another approach is to create the MediaElement you need and 
then remove it as soon as the playback is finished. This approach has several advantages: it saves you 
from needing to define the MediaElement yourself, and it allows you to play an unlimited number of 
sounds simultaneously. Here’s the code that does the job, using a FindContainer() method that gets a 
container where the MediaElement can be inserted: 
protected override void Invoke(object args) 
// Find a place to insert the MediaElement. 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested