c# .net pdf reader : Add pages to pdf acrobat SDK control service wpf web page windows dnn Pro_Silverlight_5_in_CSharp_4th_edition56-part122

CHAPTER 15  CONTROL TEMPLATES 
555 
Figure 15-5. Focus in a custom button template 
You should take care to avoid animating the same properties in different state groups. For example, 
if you animate the background color in the MouseOver state (which is in the CommonStates group), you 
shouldn’t animate the background color in the Focused state (which is in the FocusStates group). If you 
do, the result will depend on the order that the control applies its states. For example, if the button 
applies the state from the FocusStates group first and then the state from the CommonStates group, 
your focused state animation will be active for just a split second before being replaced by the 
competing MouseOver state. 
Transitions 
The button shown in the previous example uses zero-length state animations. As a result, the color 
change happens instantly when the mouse moves over the button. 
You can lengthen the duration to create a more gradual color-blending effect. Here’s an example 
that fades in the new color over a snappy 0.2 seconds: 
<VisualStateManager.VisualStateGroups> 
<VisualStateGroup x:Name="CommonStates"> 
<VisualState x:Name="MouseOver"> 
<Storyboard> 
<ColorAnimation Duration="0:0:0.2" ... /> 
</Storyboard> 
</VisualState> 
... 
</VisualStateGroup> 
</VisualStateManager.VisualStateGroups> 
Although this works, the concept isn’t quite right. Technically, each visual state is meant to 
represent the appearance of the control while it’s in that state (not including the transition used to get 
into that state). Ideally, a visual state animation should be either a zero-length animation like the ones 
www.it-ebooks.info
Add pages to pdf acrobat - 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 pages to pdf acrobat; add a page to a pdf file
Add pages to pdf acrobat - 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 preview; adding page numbers pdf
CHAPTER 15  CONTROL TEMPLATES 
556 
shown earlier or a steady-state animation—an animation that repeats itself one or more times. For 
example, a button that glimmers when you move the mouse over it uses a steady-state animation. 
If you want an animated effect to signal when the control switches from one state to another, you 
should use a transition instead. A transition is an animation that starts from the current state and ends at 
the new state. One of the advantages of the transition model is that you don’t need to create the 
storyboard for this animation. Instead, Silverlight creates the animation you need automatically. 
 Note  Controls are smart enough to skip transition animations when the controls begin in a certain state. For 
example, consider the CheckBox control, which has an Unchecked state and a Checked state. You may decide to 
use an animation to fade in the check mark gracefully when the check box is selected. If you add the fade-in effect 
to the Checked state animation, it will apply when you show a checked check box for the first time. (For example, 
if you have a page with three checked check boxes, all three check marks will fade in when the page first 
appears.) However, if you add the fade-in effect through a transition, it will be used only when the user clicks the 
check box to change its state. It won’t apply when the control is shown for the first time, which makes more 
sense. 
The Default Transition 
Transitions apply to state groups. When you define a transition, you must add it to the 
VisualStateGroup.Transitions collection. The simplest type of transition is a default transition, which 
applies to all the state changes for that group. To create the default transition, you need to add a 
VisualTransition element and set the GeneratedDuration property to set the length of the transition 
effect. Here’s an example: 
<VisualStateManager.VisualStateGroups
<VisualStateGroup x:Name="CommonStates"> 
<VisualStateGroup.Transitions
<VisualTransition GeneratedDuration="0:0:0.2" /> 
</VisualStateGroup.Transitions
<VisualState x:Name="MouseOver"> 
<Storyboard
<ColorAnimation Duration="0:0:0" 
Storyboard.TargetName="ButtonBackgroundBrush" 
Storyboard.TargetProperty="Color" To="Orange" /> 
</Storyboard
</VisualState
<VisualState x:Name="Normal"> 
</VisualState
</VisualStateGroup
</VisualStateManager.VisualStateGroups
www.it-ebooks.info
.NET PDF Document Viewing, Annotation, Conversion & Processing
Redact text content, images, whole pages from PDF file. Add, insert PDF native annotations to PDF file. Edit, update, delete PDF annotations from PDF file. Print
add pages to an existing pdf; add and delete pages from pdf
C# PDF Converter Library SDK to convert PDF to other file formats
manipulate & convert standard PDF documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat.
add page to pdf acrobat; adding page numbers in pdf
CHAPTER 15  CONTROL TEMPLATES 
557 
Now, whenever the button changes from one of the common states to another, the default 0.2-
second transition kicks in. That means that when the user moves the mouse over the button and the 
button enters the MouseOver state, the new color fades in over 0.2 seconds, even though the MouseOver 
state animation has a zero length. Similarly, when the user moves the mouse off the button, the button 
blends back to its original color over 0.2 seconds. 
Essentially, a transition is an animation that takes you from one state to another. 
VisualStateManager can create a transition animation as long as your state animations use one of the 
following types: 
• ColorAnimation or ColorAnimationUsingKeyFrames 
• PointAnimation or PointAnimationUsingKeyFrames 
• DoubleAnimation or DoubleAnimationUsingKeyFrames 
The button example works because the Normal and MouseOver states use a ColorAnimation, which 
is one of the supported types. If you use something else—say, an ObjectAnimationUsingKeyFrames—the 
transition won’t have any effect. Instead, the old value will stay in place, the transition will run out its 
duration, and then the new value will snap in. 
 Noteanimations that use supported 
types are animated by the transition. Any unsupported types snap in at the end of the transition. 
From and to Transitions 
A default transition is convenient, but it’s a one-size-fits-all solution that’s not always suitable. For 
example, you may want a button to transition to the MouseOver state over 0.2 seconds but return 
instantly to the Normal state when the mouse moves away. To set this up, you need to define multiple 
transitions, and you need to set the From and To properties to specify when the transition will come into 
effect. 
For example, if you have these transitions 
<VisualStateGroup.Transitions> 
<VisualTransition To="MouseOver" GeneratedDuration="0:0:0.5" /> 
<VisualTransition From="MouseOver" GeneratedDuration="0:0:0.1" /> 
</VisualStateGroup.Transitions> 
the button will switch into the MouseOver state in 0.5 seconds, and it will leave the MouseOver state in 
0.1 seconds. There is no default transition, so any other state changes will happen instantly. 
This example shows transitions that apply when entering specific states and transitions that apply 
when leaving specific states. You can also use the To and From properties in conjunction to create even 
more specific transitions that apply only when moving between two specific states. When applying 
transitions, Silverlight looks through the collection of transitions to find the most specific one that 
applies, and it uses only that one. For example, when the mouse moves over a button, the 
VisualStateManager searches for states in this order, stopping when it finds a match: 
1. A transition with From="Normal" and To="MouseOver" 
2. A transition with To="MouseOver" 
www.it-ebooks.info
C# powerpoint - PowerPoint Conversion & Rendering in C#.NET
documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. PowerPoint to PDF Conversion.
add a page to a pdf in acrobat; add page to pdf without acrobat
C# Word - Word Conversion in C#.NET
Word documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Word to PDF Conversion.
adding a page to a pdf file; adding a page to a pdf document
CHAPTER 15  CONTROL TEMPLATES 
558 
3. A transition with From="Normal" 
4. The default transition 
If there’s no default transition, it switches between the two states immediately. 
Transitioning to a Steady State 
So far, you’ve seen how transitions work with zero-length state animations. However, it’s equally 
possible to create a control template that uses transitions to move between steady-state animations. 
(Remember, a steady-state animation is a looping animation that repeats itself more than one time.) 
To understand what happens in this situation, you need to realize that a transition to a steady-state 
animation moves from the current property value to the starting property value of the steady-state 
animation. For example, imagine you want to create a button that pulses steadily when the mouse is 
over it. As with all steady-state animations, you need to set the RepeatBehavior property to a number of 
repetitions you want or use Forever to loop indefinitely (as in this example). Depending on the data type, 
you may also need to set the AutoReverse property to true. For example, with a ColorAnimation, you 
need to use automatic reversal to return to the original color before repeating the animation. With a key-
frame animation, this extra step isn’t necessary because you can animate from the last key frame at the 
end of the animation to the first key frame of a new iteration. 
Here’s the steady-state animation for the pulsing button: 
<VisualState x:Name="MouseOver"> 
<Storyboard> 
<ColorAnimation Duration="0:0:0.4" Storyboard.TargetName="ButtonBackgroundBrush" 
Storyboard.TargetProperty="Color" From="DarkOrange" To="Orange" 
RepeatBehavior="Forever" AutoReverse="True" /> 
</Storyboard> 
</VisualState> 
It’s not necessary to use a transition with this button—after all, you may want the pulsing effect to 
kick in immediately. But if you do want to provide a transition, it will occur before the pulsing begins. 
Consider a standard transition like this one: 
<VisualStateGroup.Transitions> 
<VisualTransition From="Normal" To="MouseOver" GeneratedDuration="0:0:1" /> 
</VisualStateGroup.Transitions> 
This takes the button from its current color (Red) to the starting color of the steady-state animation 
(DarkOrange) using a one-second animation. After that, the pulsing begins. 
Custom Transition 
All the previous examples have used automatically generated transition animations. They change a 
property smoothly from its current value to the value set by the new state. However, you may want to 
define customized transitions that work differently. You may even choose to mix standard transitions 
with custom transitions that apply only to specific state changes. 
www.it-ebooks.info
C# Windows Viewer - Image and Document Conversion & Rendering in
standard image and document in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Convert to PDF.
add page to pdf online; adding page numbers to pdf documents
VB.NET PDF: How to Create Watermark on PDF Document within
need no external application plugin, like Adobe Acrobat. VB.NET demo code to add text watermark to create graphics watermark on multiple PDF pages within the
add page number pdf file; adding page to pdf
CHAPTER 15  CONTROL TEMPLATES 
559 
 Tip  You may create a custom transition for several reasons. Here are some examples: to control the pace of the 
animation with a more sophisticated animation, to use an animation easing, to run several animations in 
succession (as in the FlipPanel example at the end of this chapter), or to play a sound at the same time as an 
animation. 
To define a custom transition, you place a storyboard with one or more animations inside the 
VisualTransition element. Here’s an example that creates an elastic compression effect when the user 
moves the mouse off a button: 
<VisualStateGroup.Transitions> 
<VisualTransition To="Normal" From="MouseOver" GeneratedDuration="0:0:0.7"> 
<Storyboard> 
<DoubleAnimationUsingKeyFrames Storyboard.TargetName="ScaleTransform" 
Storyboard.TargetProperty="ScaleX"> 
<LinearDoubleKeyFrame KeyTime="0:0:0.5" Value="0" /> 
<LinearDoubleKeyFrame KeyTime="0:0:0.7" Value="1" /> 
</DoubleAnimationUsingKeyFrames> 
</Storyboard> 
</VisualTransition> 
</VisualStateGroup.Transitions> 
 Note  When you use a custom transition, you must still set the VisualTransition.GeneratedDuration property to 
match the duration of your animation. Without this detail, the VisualStateManager can’t use your transition, and it 
will apply the new state immediately. (The actual time value you use still has no effect on your custom transition, 
because it applies only to automatically generated animations. See the end of this section to learn how you can 
mix and match a custom transition with automatically generated animations.) 
This transition uses a key-frame animation. The first key frame compresses the button horizontally 
until it disappears from view, and the second key frame causes it to spring back into sight over a shorter 
interval of time. The transition animation works by adjusting the scale of this ScaleTransform object, 
which is defined in the control template: 
<Grid RenderTransformOrigin="0.5,0.5"> 
<Grid.RenderTransform> 
<ScaleTransform x:Name="ScaleTransform" ScaleX="1" /> 
</Grid.RenderTransform> 
... 
</Grid> 
When the transition is complete, the transition animation is stopped, and the animated properties 
return to their original values (or the values that are set by the current state animation). In this example, 
www.it-ebooks.info
VB.NET PowerPoint: VB Code to Draw and Create Annotation on PPT
limitations (other documents are compatible, including PDF, TIFF, MS project, what would you do to add and draw no more plug-ins needed like Acrobat or Adobe
add remove pages from pdf; adding a page to a pdf
C# Excel - Excel Conversion & Rendering in C#.NET
Excel documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Excel to PDF Conversion.
adding page numbers to pdf document; add page numbers pdf
CHAPTER 15  CONTROL TEMPLATES 
560 
the animation returns the ScaleTransform to its initial ScaleX value of 1, so you don’t notice any change 
when the transition animation ends. 
It’s logical to assume that a custom transition animation like this one replaces the automatically 
generated transition that the VisualStateManager would otherwise use. However, this isn’t necessarily 
the case. Instead, it all depends on whether your custom transition animates the same properties as the 
VisualStateManager. 
If your transition animates the same properties as the new state animation, your transition replaces 
the automatically generated transition. In the current example, the transition bridges the gap between 
the MouseOver state and the Normal state. The new state, Normal, uses a zero-length animation to 
change the button’s background color. Thus, if you don’t supply a custom animation for your transition, 
the VisualStateManager creates an animation that smoothly shifts the background color from the old 
state to the new state. 
So what happens if you throw a custom transition into the mix? If you create a custom transition 
animation that targets the background color, the VisualStateManager will use your animation instead of 
its default transition animation. But that’s not what happens in this example. Here, the custom 
transition doesn’t modify the color—instead, it animates a transform. For that reason, the 
VisualStateManager still generates an automatic animation to change the background color. It uses its 
automatically generated animation in addition to your custom transition animation, and it runs them 
both at the same time, giving the generated transition the duration that’s set by the 
VisualTransition.GeneratedDuration property. In this example, that means the new color fades in over 
0.7 seconds, and at the same time the custom transition animation applies the compression effect. 
Understanding Parts with the Slider Control 
In the parts and states model, the states dominate. Many controls, like Button, use templates that define 
multiple state groups but no parts. But in other controls, like Slider, parts allow you to wire up elements 
in the control template to key pieces of control functionality. 
To understand how parts work, you need to consider a control that uses them. Often, parts are 
found in controls that contain small working parts. For example, the DatePicker control uses parts to 
identify the drop-down button that opens the calendar display and the text box that shows the currently 
selected date. The ScrollBar control uses parts to delineate the draggable thumb, the track, and the scroll 
buttons. The Slider control uses much the same set of parts, although its scroll buttons are placed over 
the track, and they’re invisible. This allows the user to move the slider thumb by clicking either side of 
the track. 
A control indicates that it uses a specific part with the TemplatePart attribute. Here are the 
TemplatePart attributes that decorate the Slider control: 
[TemplatePart(Name="HorizontalTemplate", Type=typeof(FrameworkElement))] 
[TemplatePart(Name="HorizontalTrackLargeChangeIncreaseRepeatButton"
Type=typeof(RepeatButton))] 
[TemplatePart(Name="HorizontalTrackLargeChangeDecreaseRepeatButton"
Type=typeof(RepeatButton))] 
[TemplatePart(Name="HorizontalThumb", Type=typeof(Thumb))] 
[TemplatePart(Name="VerticalTemplate", Type=typeof(FrameworkElement))] 
[TemplatePart(Name="VerticalTrackLargeChangeIncreaseRepeatButton"
Type=typeof(RepeatButton))] 
[TemplatePart(Name="VerticalTrackLargeChangeDecreaseRepeatButton"
Type=typeof(RepeatButton))] 
[TemplatePart(Name="VerticalThumb", Type=typeof(Thumb))] 
[TemplateVisualState(Name="Disabled", GroupName="CommonStates")] 
[TemplateVisualState(Name="Unfocused", GroupName="FocusStates")] 
www.it-ebooks.info
BMP to PDF Converter | Convert Bitmap to PDF, Convert PDF to BMP
Also designed to be used add-on for .NET Image SDK Support conversion of Bitmap - PDF files in both single & batch mode; Convert all pages or certain
add page to a pdf; add page number pdf
DICOM to PDF Converter | Convert DICOM to PDF, Convert PDF to
users do not need to load Adobe Acrobat or any Start DICOM - PDF image conversion through drag &drop method; Convert all pages or certain pages chosen by users;
add page number to pdf in preview; add page number to pdf preview
CHAPTER 15  CONTROL TEMPLATES 
561 
[TemplateVisualState(Name="MouseOver", GroupName="CommonStates")] 
[TemplateVisualState(Name="Focused", GroupName="FocusStates")] 
[TemplateVisualState(Name="Normal", GroupName="CommonStates")] 
public class Slider: RangeBase 
{ ... } 
The Slider is complicated by the fact that it can be used in two different orientations, which require 
two separate templates that are coded side by side. Here’s the basic structure: 
<ControlTemplate TargetType="Slider"> 
<Grid> 
<!-- This Grid is used for the horizontal orientation. --> 
<Grid x:Name="HorizontalTemplate"> 
... 
</Grid> 
<!-- This Grid is used for the vertical orientation. --> 
<Grid x:Name="VerticalTemplate"> 
... 
</Grid> 
</Grid> 
</ControlTemplate> 
If Slider.Orientation is Horizontal, the Slider shows the HorizontalTemplate element and hides the 
VerticalTemplate element (if it exists). Usually, both of these elements are layout containers. In this 
example, each one is a Grid that contains the rest of the markup for that orientation. 
When you understand that two distinct layouts are embedded in one control template, you’ll realize 
that there are two sets of template parts to match. In this example, you’ll consider a Slider that’s always 
used in horizontal orientation and so provides only the corresponding horizontal parts: 
HorizontalTemplate, HorizontalTrackLargeChangeIncreaseRepeatButton, 
HorizontalTrackLargeChangeDecreaseRepeatButton, and HorizontalThumb. 
Figure 15-6 shows how these parts work together. Essentially, the thumb sits in the middle, on the 
track. On the left and right are two invisible buttons that allow you to quickly scroll the thumb to a new 
value by clicking one side of the track and holding down the mouse button. 
Figure 15-6. The named parts in the HorizontalTemplate part for the Slider 
www.it-ebooks.info
CHAPTER 15  CONTROL TEMPLATES 
562 
The TemplatePart attribute indicates the name the element must have, which is critical because the 
control code searches for that element by name. It also indicates the element type, which may be 
something very specific (such as Thumb, in the case of the HorizontalThumb part) or something much 
more general (for example, FrameworkElement, in the case of the HorizontalTemplate part, which 
allows you to use any element). 
The fact that an element is used as a part in a control template tells you nothing about how that 
element is used. However, there are a few common patterns: 
• The control handles events from a part: For example, the Slider code searches for 
the thumb when it’s initialized and attaches event handlers that react when the 
thumb is clicked and dragged. 
• The control changes the visibility of a part: For example, depending on the 
orientation, the Slider shows or hides the HorizontalTemplate and 
VerticalTemplate parts. 
• If a part isn’t present, the control doesn’t raise an exception: Depending on the 
importance of the part, the control may continue to work (if at all possible), or an 
important part of its functionality may be missing. For example, when dealing 
with the Slider, you can safely omit 
HorizontalTrackLargeChangeIncreaseRepeatButton and 
HorizontalTrackLargeChangeDecreaseRepeatButton. Even without these parts, 
you can still set the Slider value by dragging the thumb. But if you omit the 
HorizontalThumb element, you’ll end up with a much less useful Slider. 
Figure 15-7 shows a customized Slider control. Here, a custom control template changes the 
appearance of the track (using a gently rounded Rectangle element) and the thumb (using a 
semitransparent circle). 
Figure 15-7. A customized Slider control 
www.it-ebooks.info
CHAPTER 15  CONTROL TEMPLATES 
563 
To create this effect, your custom template must supply a HorizontalTemplate part. In that 
HorizontalTemplate part, you must also include the HorizontalThumb part. The TemplatePart attribute 
makes it clear that you can’t replace the Thumb control with another element. However, you can 
customize the control template of the Thumb to modify its visual appearance, as in this example. 
Here’s the complete custom control template: 
<ControlTemplate TargetType="Slider"> 
<Grid> 
<Grid x:Name="HorizontalTemplate"> 
<Grid.ColumnDefinitions> 
<ColumnDefinition Width="Auto" /> 
<ColumnDefinition Width="Auto" /> 
<ColumnDefinition Width="*" /> 
</Grid.ColumnDefinitions> 
<!-- The track --> 
<Rectangle Stroke="SteelBlue" StrokeThickness="1" Fill="AliceBlue" 
Grid.Column="0" Grid.ColumnSpan="3" Height="7" RadiusX="3" RadiusY="3" /> 
<!-- The left RepeatButton --> 
<RepeatButton x:Name="HorizontalTrackLargeChangeDecreaseRepeatButton" 
Grid.Column="0" Background="Transparent" Opacity="0"  IsTabStop="False" /> 
<!-- The Thumb --> 
<Thumb x:Name="HorizontalThumb" Height="28" Width="28" Grid.Column="1"> 
<Thumb.Template> 
<ControlTemplate TargetType="Thumb"> 
<Ellipse x:Name="Thumb" Opacity="0.3"  Fill="AliceBlue" 
Stroke="SteelBlue" StrokeThickness="3" Stretch="Fill"></Ellipse> 
</ControlTemplate> 
</Thumb.Template> 
</Thumb> 
<!-- The right RepeatButton --> 
<RepeatButton x:Name="HorizontalTrackLargeChangeIncreaseRepeatButton" 
Grid.Column="2" Background="Transparent" Opacity="0"  IsTabStop="False" /> 
</Grid> 
<!-- Add VerticalTemplate here if desired. --> 
</Grid> 
</ControlTemplate> 
CREATING SLICK CONTROL SKINS 
The examples you’ve seen in this chapter demonstrate everything you need to know about the parts and 
states model. But they lack one thing: eye candy. For example, although you now understand the concepts 
you need to create customized Button and Slider controls, you haven’t seen how to design the graphics 
that make a truly attractive control. And although the simple animated effects you’ve seen here—color 
changing, pulsing, and scaling—are respectable, they certainly aren’t eye-catching. To get more dramatic 
www.it-ebooks.info
CHAPTER 15  CONTROL TEMPLATES 
564 
results, you need to get creative with the graphics and animation skills you’ve picked up in earlier 
chapters. 
To get an idea of what’s possible, you should check out the Silverlight control examples that are available 
on the Web, including the many different glass and glow buttons that developers have created. You can 
also apply new templates using the expansive set of themes that are included with the Silverlight Toolkit 
(
http://silverlight.codeplex.com
). If you want to restyle your controls, you’ll find that these themes 
give you a wide range of slick, professional choices. Best of all, themes work automatically thanks to a 
crafty tool called the ImplicitStyleManager. All you need to do is set the theme on some sort of container 
element (like a panel). The ImplicitStyleManager will automatically apply the correct styles to all the 
elements inside, complete with the matching control templates. 
Layout Transitions 
Silverlight’s control model attempts to support two very different types of people: those who want to 
build every widget themselves and customize it down to the finest details and those who want an easy 
way to customize and extend the controls the platform gives them. Initially, Silverlight was more geared 
to the first sort of developer. (In fact, the first version of Silverlight had a drawing model but no 
prewritten controls.) But increasingly, Silverlight has set to work trying to satisfy the second type of 
developer. 
One example is the parts and states model. Originally fashioned as a way to make it easier to change 
the control appearance, the parts and states model is gradually shifting into a convenient way to bolt on 
new animated effects. For example, some controls now include states that, ordinarily, they don’t use at 
all. However, these states provide useful extensibility points that allow developers to add new 
animations. These features can make the control feel like a very individual, handcrafted bit of user 
interface, even though it’s still the stock Silverlight control under the covers. 
So far, this is a new technique that many controls don’t exploit. One that does is the ListBoxItem 
control, which represents each item in a ListBox. It includes a state group named LayoutStates, which 
defines three states: BeforeLoaded (when an item is about to be added), AfterLoaded (once an item has 
been added), and BeforeUnloaded (when an item is about to be removed). 
For example, consider the following template, which fades in added items and fades out removed 
ones: 
<ControlTemplate> 
<Grid x:Name="grid" Background="{TemplateBinding Background}"> 
<VisualStateManager.VisualStateGroups> 
<VisualStateGroup x:Name="LayoutStates"> 
<VisualStateGroup.Transitions> 
<VisualTransition GeneratedDuration="0:0:0.5" /> 
</VisualStateGroup.Transitions> 
<VisualState x:Name="BeforeLoaded"> 
<Storyboard> 
<DoubleAnimation Storyboard.TargetProperty="(UIElement.Opacity)" 
Storyboard.TargetName="grid" From="0"> 
</DoubleAnimation> 
</Storyboard> 
</VisualState> 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested