best pdf viewer control for asp.net : Add page number to pdf document control Library system azure asp.net html console Pro_Silverlight_5_in_CSharp_4th_edition41-part106

CHAPTER 11  ADVANCED ANIMATION 
402 
• Use animation easing: If you want bombs to accelerate as they fall, bounce off the 
screen, or wiggle more naturally, you can add easing functions to the animations 
used here. And, as you’d expect, easing functions can be constructed in code just 
as easily as in XAML. 
• Fine-tune the parameters: You can provide more dials to tweak behavior (for 
example, variables that set how the bomb times, trajectories, and frequencies are 
altered as the game processes). You can also inject more randomness (for 
example, allowing saved bombs to bounce off the Canvas in slightly different 
ways). 
You can find countless examples of Silverlight game programming on the Web. Microsoft’s 
Silverlight community site includes game samples with full source code at 
www.silverlight.net/showcase. You can also check out Andy Beaulieu’s website, which provides 
Silverlight games and an impressive physics simulator, at www.andybeaulieu.com. 
Encapsulating Animations 
When you create animations dynamically in code, a fair bit of boilerplate code is required to create the 
animations, set the storyboard properties, and handle the Completed event to clean up. For this reason, 
Silverlight developers often wrap animations in higher-level classes that take care of the low-level 
details. 
For example, you can create an animation class named FadeElementEffect and fade an element out 
of view using code like this: 
FadeElementEffect fade = new FadeElementEffect(); 
fade.Animate(canvas); 
Creating classes like this is fairly straightforward, although the exact design depends on the needs of 
your application. In the rest of this section, you’ll consider one possible way to create animation helper 
classes that provide transitional animations when the user navigates between pages. 
Page Transitions 
In Chapter 7, you saw different ways to support page navigation in a Silverlight application. One 
technique is to use some sort of layout container as your application’s root element. You can then add 
user controls to this container and remove them when needed. Navigating from one page to another 
consists of removing the user control for the current page and adding the user control for the next page. 
One advantage of this technique is that it allows you to use an animated effect to switch between the 
two pages. For example, you can create an animation that fades in or slides in the new page. To make 
this work, you add both pages to the root visual at once, one over the other. (The easiest way to do this is 
to place both user controls in the same cell of a Grid, but a Canvas works equally well.) Then, you 
animate the properties of the topmost page. For example, you can change the Opacity property to fade 
the page in, alter the properties of a TranslateTransform to move it, and so on. You can even apply 
multiple effects at once—for example, to create a “blow up” effect that expands a page from the corner 
to fill the entire display area. 
In the rest of this chapter, you’ll learn how to use a simple wipe effect that unveils the new page on 
top of the current one. Figure 11-7 shows the wipe in action. 
www.it-ebooks.info
Add page number to pdf document - 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 number to pdf preview; add page numbers to pdf in preview
Add page number to pdf document - 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
adding page numbers to pdf in; add page number to pdf reader
CHAPTER 11  ADVANCED ANIMATION 
403 
Figure 11-7. Transitioning between pages with a wipe 
This example assumes the root element in your application is a Grid. In other words, your 
Application class requires code like this: 
// This Grid will host your pages. 
private Grid rootVisual = new Grid(); 
private void Application_Startup(object sender, StartupEventArgs e) 
// Load the first page. 
this.RootVisual = rootVisual; 
rootVisual.Children.Add(new Page()); 
This technique is discussed in Chapter 7. 
The Base Class 
The most straightforward way to animate a transition between pages is to code it directly in the App 
class, using a custom Navigate() method. However, it’s far more flexible (and just a bit more effort) to 
place the animation code in a separate class. And if you standardize your animations with an abstract 
class or an interface, you’ll gain far more flexibility to swap in the new effects. 
In this example, all transitions inherit from an abstract class named PageTransitionBase. This class 
stores the storyboard, the previous page, and the new page as fields: 
public abstract class PageTransitionBase 
protected Storyboard storyboard = new Storyboard(); 
protected UserControl oldPage; 
www.it-ebooks.info
C# PDF insert text Library: insert text into PDF content in C#.net
Description: Add a char value at specified page position with pageIndex, The page index of the PDF page that will be 0
adding page numbers to pdf files; add a page to a pdf in reader
C# PDF File Split Library: Split, seperate PDF into multiple files
If your page number is set as 1, then the two output PDF files will contains the first page and the later three pages Add necessary references:
add page numbers to a pdf file; add a blank page to a pdf
CHAPTER 11  ADVANCED ANIMATION 
404 
protected UserControl newPage; 
public PageTransitionBase() 
storyboard.Completed += TransitionCompleted; 
... 
The application calls the PageTransitionBase.Navigate() method to move from one page to another. 
The Navigate() method adds both pages to the Grid, calls a PrepareStoryboard() method to set up the 
animation, and then starts the storyboard: 
...     
public void Navigate(UserControl newPage) 
// Set the pages. 
this.newPage = newPage; 
Grid grid = (Grid)Application.Current.RootVisual; 
oldPage = (UserControl)grid.Children[0]; 
grid.Children.Insert(0, newPage); 
// Prepared the animation. 
PrepareStoryboard(); 
// Perform the animation. 
storyboard.Begin(); 
... 
The PrepareStoryboard() method is abstract. It must be overridden in derived classes, which creates 
the specific animation objects they want. 
...     
protected abstract void PrepareStoryboard(); 
... 
The TransitionCompleted() event handler responds when the animation is complete. It removes the 
old page: 
...     
private void TransitionCompleted(object sender, EventArgs e) 
// Remove the old page, which is not needed any longer. 
Grid grid = (Grid)Application.Current.RootVisual; 
grid.Children.Remove(oldPage); 
You can also use this method to perform cleanup. However, in this example, the animation acts on 
the old page, which is discarded after the navigation. No extra cleanup is needed. 
www.it-ebooks.info
VB.NET PDF File Split Library: Split, seperate PDF into multiple
can split target multi-page PDF document file to one-page PDF files or PDF file to smaller PDF documents by every given number of pages Add necessary references
add document to pdf pages; add page numbers pdf file
C# PDF Text Search Library: search text inside PDF file in C#.net
Add necessary references: Description: Search specified string from all the PDF pages. eg: The first page is 0. 0
add page number pdf; add contents page to pdf
CHAPTER 11  ADVANCED ANIMATION 
405 
The Wipe Transition 
To use a page transition, you need at least one derived class that creates animations. In this section, 
you’ll consider one example: a WipeTransition class that wipes away the old page, revealing the new one 
underneath. 
The trick to creating a wipe effect is animating a brush that uses an opacity mask. (As you learned in 
Chapter 8, an opacity mask determines what portions of an image or element should be visible and 
which ones should be transparent.) To use an animation as a page transition, you need to use a 
LinearGradientBrush for the opacity mask. As the animation progresses, you move the offsets in the 
opacity mask, gradually making more of the topmost element transparent and revealing more of the 
content underneath. In a page transition, the topmost element is the old page, and underneath is the 
new page. Wipes commonly work from left to right or top to bottom, but more creative effects are 
possible if you use different opacity masks. 
To perform its work, the WipeTransition class overrides the PrepareStoryboard() method. Its first 
task is to create the opacity mask and add it to the old page (which is topmost in the grid). This opacity 
mask uses a gradient that defines two gradient stops: Black (the image is completely visible) and 
Transparent (the image is completely transparent). Initially, both stops are positioned at the left edge of 
the image. Because the visible stop is declared last, it takes precedence, and the image is completely 
opaque. 
public class WipeTransition PageTransitionBase 
protected override void PrepareStoryboard() 
// Create the opacity mask. 
LinearGradientBrush mask = new LinearGradientBrush(); 
mask.StartPoint = new Point(0,0); 
mask.EndPoint = new Point(1,0); 
GradientStop transparentStop = new GradientStop(); 
transparentStop.Color = Colors.Transparent; 
transparentStop.Offset = 0; 
mask.GradientStops.Add(transparentStop); 
GradientStop visibleStop = new GradientStop(); 
visibleStop.Color = Colors.Black; 
visibleStop.Offset = 0; 
mask.GradientStops.Add(visibleStop); 
oldPage.OpacityMask = mask; 
... 
Next, you need to perform your animation on the offsets of the LinearGradientBrush. In this 
example, both offsets are moved from the left side to the right side, allowing the image underneath to 
appear. To make this example a bit fancier, the offsets don’t occupy the same position while they move. 
Instead, the visible offset leads the way, followed by the transparent offset after a short delay of 0.2 
seconds. This creates a blended fringe at the edge of the wipe while the animation is underway. 
...         
// Create the animations for the opacity mask. 
DoubleAnimation visibleStopAnimation = new DoubleAnimation(); 
Storyboard.SetTarget(visibleStopAnimation, visibleStop); 
Storyboard.SetTargetProperty(visibleStopAnimation, 
www.it-ebooks.info
C# PDF delete text Library: delete, remove text from PDF file in
Add necessary references: RasterEdge.Imaging.Basic.dll. matchString, The string wil be deleted from PDF file, -. 0
add page number to pdf file; add pages to pdf without acrobat
C# PDF Text Highlight Library: add, delete, update PDF text
200F); annot.EndPoint = new PointF(300F, 400F); // add annotation to The string wil be highlighted from PDF file, 0
add page to existing pdf file; add pages to pdf file
CHAPTER 11  ADVANCED ANIMATION 
406 
new PropertyPath("Offset")); 
visibleStopAnimation.Duration = TimeSpan.FromSeconds(1.2); 
visibleStopAnimation.From = 0; 
visibleStopAnimation.To = 1.2; 
DoubleAnimation transparentStopAnimation = new DoubleAnimation(); 
Storyboard.SetTarget(transparentStopAnimation, transparentStop); 
Storyboard.SetTargetProperty(transparentStopAnimation, 
new PropertyPath("Offset")); 
transparentStopAnimation.BeginTime = TimeSpan.FromSeconds(0.2); 
transparentStopAnimation.From = 0; 
transparentStopAnimation.To = 1; 
transparentStopAnimation.Duration = TimeSpan.FromSeconds(1); 
... 
There’s one odd detail here. The visible stop moves to 1.2 rather than 1, which denotes the right 
edge of the image. This ensures that both offsets move at the same speed, because the total distance that 
each one must cover is proportional to the duration of its animation. 
The final step is to add the animations to the storyboard, which is defined in the PageTransitionBase 
class. You don’t need to start the storyboard, because the PageTransitionBase class performs this step as 
soon as the PrepareStoryboard() method returns. 
...         
// Add the animations to the storyboard. 
storyboard.Children.Add(transparentStopAnimation); 
storyboard.Children.Add(visibleStopAnimation); 
Now, you can use code like this to navigate between pages: 
WipeTransition transition = new WipeTransition(); 
transition.Navigate(new Page2()); 
As with the BombDropper, there are plenty of imaginative ways to extend this example: 
• Add transition properties: You could enhance the WipeTransition class with more 
possibilities, allowing a configurable wipe direction, a configurable wipe time, and 
so on. 
• Create more transitions: Creating a new animated page transition is as simple as 
deriving a class from PageTransitionBase and overriding PrepareStoryboard(). 
• Refactor the PageTransitionBase code: The current example is designed to be as 
simple as possible. However, a more elaborate design would pull out the code that 
adds and removes pages and place it in the custom application class. This opens 
up new possibilities. It allows you to use different layouts. (For example, you can 
use a transition animation in one panel rather than for the entire window.) It also 
lets the application class add application services. (For example, you can keep 
pages alive in a cache after you navigate away from them, as described in Chapter 
7. This lets you retain the current state of all your elements.) 
For fancier effects, check out the collection of custom pixel shaders and transitions in the free WPF 
Shader Effects Library at http://codeplex.com/wpffx. 
www.it-ebooks.info
C# Word - Split Word Document in C#.NET
If your page number is set as 1, then the two output Word files will contains the first page and the later three pages respectively. Add references:
adding page numbers to pdf; add multi page pdf to word document
C# PowerPoint - Split PowerPoint Document in C#.NET
If your page number is set as 1, then the PowerPoint files will contains the first page and the Add necessary XDoc.PowerPoint DLL libraries into your created
add page numbers to pdf online; adding page numbers to pdf documents
CHAPTER 11  ADVANCED ANIMATION 
407 
Frame-Based Animation 
Along with the property-based animation system, Silverlight provides a way to create frame-based 
animation using nothing but code. All you need to do is respond to the static 
CompositionTarget.Rendering event, which is fired to get the content for each frame. This is a far lower-
level approach, which you shouldn’t tackle unless you’re sure the standard property-based animation 
model won’t work for your scenario (for example, if you’re building a simple side-scrolling game, 
creating physics-based animations, or modeling particle effects such as fire, snow, and bubbles). 
The basic technique for building a frame-based animation is easy. You attach an event handler to 
the static CompositionTarget.Rendering event. After you do, Silverlight begins calling this event handler 
continuously. (As long as your rendering code executes quickly enough, Silverlight will call it 60 times 
each second.) In the rendering event handler, it’s up to you to create or adjust the elements in the 
window accordingly. In other words, you need to manage all the work yourself. When the animation has 
ended, detach the event handler. 
Figure 11-8 shows a straightforward example. Here, a random number of circles fall from the top of 
a Canvas to the bottom. They fall at different speeds (based on a random starting velocity), but they 
accelerate downward at the same rate. The animation ends when all the circles reach the bottom. 
Figure 11-8. A frame-based animation of falling circles 
In this example, each falling circle is represented by an Ellipse element. A custom class named 
EllipseInfo keeps a reference to the ellipse and tracks the details that are important for the physics 
model. In this case, there’s only one piece of information: the velocity at which the ellipse is moving 
www.it-ebooks.info
CHAPTER 11  ADVANCED ANIMATION 
408 
along the y-axis. (You could easily extend this class to include a velocity along the x-axis, additional 
acceleration information, and so on.) 
public class EllipseInfo 
public Ellipse Ellipse 
getset
public double VelocityY 
getset
public EllipseInfo(Ellipse ellipse, double velocityY) 
VelocityY = velocityY; 
Ellipse = ellipse; 
The application keeps track of the EllipseInfo object for each ellipse using a collection. Several more 
window-level fields record various details used when calculating the fall of the ellipse. You can easily 
make these details configurable. 
private List<EllipseInfo> ellipses = new List<EllipseInfo>(); 
private double accelerationY = 0.1; 
private int minStartingSpeed = 1; 
private int maxStartingSpeed = 50; 
private double speedRatio = 0.1; 
private int minEllipses = 20; 
private int maxEllipses = 100; 
private int ellipseRadius = 10; 
private SolidColorBrush ellipseBrush = new SolidColorBrush(Colors.Green); 
When a button is clicked, the collection is cleared, and the event handler is attached to the 
CompositionTarget.Rendering event: 
private bool rendering = false
private void cmdStart_Clicked(object sender, RoutedEventArgs e) 
if (!rendering) 
ellipses.Clear(); 
canvas.Children.Clear(); 
CompositionTarget.Rendering += RenderFrame; 
rendering = true
www.it-ebooks.info
CHAPTER 11  ADVANCED ANIMATION 
409 
If the ellipses don’t exist, the rendering code creates them automatically. It creates a random 
number of ellipses (currently, between 20 and 100) and gives each of them the same size and color. The 
ellipses are placed at the top of the Canvas, but they’re offset randomly along the x-axis, and each one is 
given a random starting speed: 
private void RenderFrame(object sender, EventArgs e) 
if (ellipses.Count == 0) 
// Animation just started. Create the ellipses. 
int halfCanvasWidth = (int)canvas.ActualWidth / 2; 
Random rand = new Random(); 
int ellipseCount = rand.Next(minEllipses, maxEllipses+1); 
for (int i = 0; i < ellipseCount; i++) 
// Create the ellipse. 
Ellipse ellipse = new Ellipse(); 
ellipse.Fill = ellipseBrush; 
ellipse.Width = ellipseRadius; 
ellipse.Height = ellipseRadius; 
// Place the ellipse. 
Canvas.SetLeft(ellipse, halfCanvasWidth + 
rand.Next(-halfCanvasWidth, halfCanvasWidth)); 
Canvas.SetTop(ellipse, 0); 
canvas.Children.Add(ellipse); 
// Track the ellipse. 
EllipseInfo info = new EllipseInfo(ellipse, 
ellipses.Add(info); 
... 
If the ellipses already exist, the code tackles the more interesting job of animating them. Each ellipse 
is moved slightly using the Canvas.SetTop() method. The amount of movement depends on the assigned 
velocity.     
... 
else 
for (int i = ellipses.Count-1; i >= 0; i--) 
EllipseInfo info = ellipses[i]; 
double top = Canvas.GetTop(info.Ellipse); 
Canvas.SetTop(info.Ellipse, top + 1 * info.VelocityY); 
... 
To improve performance, the ellipses are removed from the tracking collection as soon as they’ve 
reached the bottom of the Canvas. That way, you don’t need to process them again. To allow this to work 
www.it-ebooks.info
CHAPTER 11  ADVANCED ANIMATION 
410 
without causing you to lose your place while stepping through the collection, you need to iterate 
backward, from the end of the collection to the beginning. 
If the ellipse hasn’t yet reached the bottom of the Canvas, the code increases the velocity. 
(Alternatively, you could set the velocity based on how close the ellipse is to the bottom of the Canvas for 
a magnet-like effect.)             
... 
if (top >= (canvas.ActualHeight - ellipseRadius*2)) 
// This circle has reached the bottom. 
// Stop animating it. 
ellipses.Remove(info); 
else 
// Increase the velocity. 
info.VelocityY += accelerationY; 
... 
Finally, if all the ellipses have been removed from the collection, the event handler is removed, 
allowing the animation to end:             
... 
if (ellipses.Count == 0) 
// End the animation. 
// There's no reason to keep calling this method 
// if it has no work to do. 
CompositionTarget.Rendering -= RenderFrame; 
rendering = false
Obviously, you can extend this animation to make the circles bounce, scatter, and so on. The 
technique is the same—you need to use more complex formulas to arrive at the velocity. 
There’s one caveat to consider when building frame-based animations: they aren’t time-dependent. 
In other words, your animation may run faster on fast computers, because the frame rate will increase, 
and your CompositionTarget.Rendering event will be called more frequently. To compensate for this 
effect, you need to write code that takes the current time into account. 
The Last Word 
In this chapter, you learned the techniques needed to make practical animations and integrate them 
into your applications. The only missing ingredient is the eye candy—in other words, making sure the 
animated effects are as polished as your code. 
As you’ve seen over the past two chapters, the animation model in Silverlight is surprisingly full-
featured. However, getting the result you want isn’t always easy. If you want to animate separate 
portions of your interface as part of a single animated scene, you’re forced to take care of a few tedious 
details, such as tracking animated objects and performing cleanup. Furthermore, none of the stock 
www.it-ebooks.info
CHAPTER 11  ADVANCED ANIMATION 
411 
animation classes accepts arguments in their parameters. As a result, the code required to 
programmatically build a new animation is often simple but long. 
The future of Silverlight animation is in higher-level features that build on the basic plumbing 
you’ve learned about in this chapter. You’ve already seen one example of this technique with the page 
transitions in this chapter. Here, someone else designs the animation, and you plug it into your 
application with a couple of lines of code. In Chapter 15, you’ll learn about another approach that works 
with Silverlight controls: using transitions
 Note  Transitions are animations that are declared, in markup, as part of a control’s template. They’re triggered 
automatically at the right time—for example, when the user hovers over a button or when new items are added to 
a container. Transitions are built on the animation model you’ve explored in this chapter and the previous one, but 
lso have the potential to be far 
more convenient, especially for business developers looking for a quick way to plug in some basic effects. 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested