best pdf viewer control for asp.net : Add page numbers pdf files Library application component asp.net html .net mvc Pro_Silverlight_5_in_CSharp_4th_edition40-part105

CHAPTER 11  ADVANCED ANIMATION 
392 
Figure 11-6. Catching bombs 
In this example, every dropped bomb has its own storyboard with two animations. The first 
animation drops the bomb (by animating the Canvas.Top property), and the second animation rotates 
the bomb slightly back and forth, giving it a realistic wiggle effect. If the user clicks a bomb, these 
animations are halted, and two more take place to send the bomb careening harmlessly off the side of 
the Canvas. Finally, every time an animation ends, the application checks to see whether it represents a 
bomb that fell down or one that was saved and updates the count accordingly. 
In the following sections, you’ll see how to create each part of this example. 
The Main Page 
The main page in the BombDropper example is straightforward. It contains a two-column Grid. On the 
left side is a Border element, which contains the Canvas that represents the game surface: 
<Border Grid.Column="0" BorderBrush="SteelBlue" BorderThickness="1" Margin="5"> 
<Grid> 
<Canvas x:Name="canvasBackground" SizeChanged="canvasBackground_SizeChanged" 
MinWidth="50"> 
<Canvas.Background> 
<RadialGradientBrush> 
<GradientStop Color="AliceBlue" Offset="0"></GradientStop> 
<GradientStop Color="White" Offset="0.7"></GradientStop> 
</RadialGradientBrush> 
www.it-ebooks.info
Add page numbers pdf files - 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
adding page to pdf; adding page numbers pdf
Add page numbers pdf files - 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 a page to a pdf; add page numbers pdf files
CHAPTER 11  ADVANCED ANIMATION 
393 
</Canvas.Background
</Canvas
</Grid
</Border
When the Canvas is sized for the first time or resized (when the user changes the size of the browser 
window), the following code runs and sets the clipping region: 
private void canvasBackground_SizeChanged(object sender, SizeChangedEventArgs e) 
// Set the clipping region to match the current display region of the Canvas. 
RectangleGeometry rect = new RectangleGeometry(); 
rect.Rect = new Rect(0, 0, 
canvasBackground.ActualWidth, canvasBackground.ActualHeight); 
canvasBackground.Clip = rect; 
This is required because otherwise the Canvas draws its children even if they lie outside its display 
area. In the bomb-dropping game, this would cause the bombs to fly out of the box that delineates the 
Canvas. 
 Note  Because the user control is defined without explicit sizes, it’s free to resize itself to match the browser 
window. The game logic uses the current window dimensions without attempting to compensate for them in any 
way. Thus, if you have a very wide window, bombs are spread across a wide area, making the game more 
difficult. Similarly, if you have a very tall window, bombs fall faster so they can complete their trajectory in the 
same interval of time. You could get around this issue by using a fixed-size region, which you could then center in 
the middle of your user control. However, a resizable window makes the example more adaptable and more 
interesting. 
On the right side of the main window is a panel that shows the game statistics, the current bomb-
dropped and bomb-saved count, and a button for starting the game: 
<Border Grid.Column="1" BorderBrush="SteelBlue" BorderThickness="1" Margin="5"> 
<Border.Background
<RadialGradientBrush GradientOrigin="1,0.7" Center="1,0.7" 
RadiusX="1" RadiusY="1"> 
<GradientStop Color="Orange"  Offset="0"></GradientStop
<GradientStop Color="White" Offset="1"></GradientStop
</RadialGradientBrush
</Border.Background
<StackPanel Margin="15" VerticalAlignment="Center" HorizontalAlignment="Center"> 
<bomb:Title></bomb:Title
<TextBlock x:Name="lblRate" Margin="0,30,0,0" TextWrapping="Wrap" 
FontFamily="Georgia" FontSize="14"></TextBlock
<TextBlock x:Name="lblSpeed" Margin="0,30" TextWrapping="Wrap" 
FontFamily="Georgia" FontSize="14"></TextBlock
www.it-ebooks.info
C# Create PDF Library SDK to convert PDF from other file formats
them the ability to count the page numbers of generated metadata adding control, you can add some additional Create PDF Document from Existing Files Using C#.
add page numbers to pdf document in preview; adding pages to a pdf document
C# Word - Word Create or Build in C#.NET
also offer them the ability to count the page numbers of generated using this Word document adding control, you can add some additional Create Word From PDF.
add page numbers to pdf preview; add multi page pdf to word document
CHAPTER 11  ADVANCED ANIMATION 
394 
<TextBlock x:Name="lblStatus" TextWrapping="Wrap" 
FontFamily="Georgia" FontSize="20">No bombs have dropped.</TextBlock> 
<Button x:Name="cmdStart" Padding="5" Margin="0,30" Width="80" 
Content="Start Game" Click="cmdStart_Click"></Button> 
</StackPanel> 
</Border> 
You’ll notice that the right-side column contains one unusual ingredient: an element named Title. 
This is a custom user control that shows the BombDropper title in fiery orange letters. Technically, it’s a 
piece of vector art. It was created in Microsoft Word using the WordArt feature, saved as an XPS file, and 
then exported to XAML using the technique described in Chapter 8. Although you could insert the 
markup for the BombDropper title directly into the main page, defining it as a separate user control 
allows you to separate the title markup from the rest of the user interface. 
To use the Title user control, you need to map your project namespace to an XML namespace, 
thereby making it available in your page (as described in Chapter 2). Assuming the project is named 
BombDropper, here’s what you need to add: 
<UserControl x:Class="BombDropper.Page" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns:bomb="clr-namespace:BombDropper;assembly=BombDropper"> 
Now you can use the XML prefix “bomb” to insert any custom controls from your project, including 
user controls: 
<bomb:Title></bomb:Title> 
The Bomb User Control 
The next step is to create the graphical image of the bomb. Although you can use a static image (as long 
as it has a transparent background), it’s always better to deal with more flexible Silverlight shapes. By 
using shapes, you gain the ability to resize the bomb without introducing distortion, and you can 
animate or alter individual parts of the drawing. The bomb shown in this example is drawn straight from 
Microsoft Word’s online clip-art collection. The bomb was converted to XAML by inserting it into a Word 
document and then saving that document as an XPS file, a process described in Chapter 8. The full 
XAML, which uses a combination of Path elements, isn’t shown here. But you can see it by downloading 
the BombDropper game along with the samples for this chapter. 
The XAML for the Bomb class was then simplified slightly (by removing the unnecessary extra 
Canvas elements around it and the transforms for scaling it). The XAML was then inserted into a new 
user control named Bomb. This way, the main page can show a bomb by creating the Bomb user control 
and adding it to a layout container (like a Canvas). 
Placing the graphic in a separate user control makes it easy to instantiate multiple copies of that 
graphic in your user interface. It also lets you encapsulate related functionality by adding to the user 
control’s code. In the bomb-dropping example, only one detail is added to the code—a Boolean 
property that tracks whether the bomb is currently falling: 
public partial class Bomb: UserControl 
public Bomb() 
InitializeComponent(); 
www.it-ebooks.info
C# PowerPoint - PowerPoint Creating in C#.NET
New PowerPoint File and Load PowerPoint from Other Files. them the ability to count the page numbers of generated creating toolkit, if you need to add some text
add pdf pages together; add a page to pdf file
C# Word - Word Creating in C#.NET
to Create New Word File and Load Word from Other Files. them the ability to count the page numbers of generated creating toolkit, if you need to add some text
add document to pdf pages; add a page to a pdf in reader
CHAPTER 11  ADVANCED ANIMATION 
395 
public bool IsFalling 
get
set
The markup for the bomb includes a RotateTransform, which the animation code can use to give 
the bomb a wiggling effect as it falls. Although you could create and add this RotateTransform 
programmatically, it makes more sense to define it in the XAML file for the bomb: 
<UserControl x:Class="BombDrop.Bomb" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
> 
<UserControl.RenderTransform> 
<TransformGroup> 
<RotateTransform Angle="20" CenterX="50" CenterY="50"></RotateTransform> 
<ScaleTransform ScaleX="0.5" ScaleY="0.5"></ScaleTransform> 
</TransformGroup> 
</UserControl.RenderTransform> 
<Canvas> 
</Canvas> 
</UserControl> 
With this code in place, you could insert a bomb into your window using a <bomb:Bomb> element, 
much as the main window inserts the Title user control (as described in the previous section). However, 
in this case it makes far more sense to create the bombs programmatically. 
Dropping the Bombs 
To drop the bombs, the application uses DispatcherTimer, a timer that plays nicely with Silverlight user 
interface because it triggers events on the user-interface thread (saving you the effort of marshalling or 
locking, two multithreaded programming techniques that are described in Chapter 16). You choose a 
time interval, and then the DispatcherTimer fires a periodic Tick event at that interval. 
private DispatcherTimer bombTimer = new DispatcherTimer(); 
public Page() 
InitializeComponent(); 
bombTimer.Tick += bombTimer_Tick; 
In the BombDro
button to start the game, the timer is started: 
// Keep track of how many bombs are dropped and stopped. 
private int droppedCount = 0; 
private int savedCount = 0; 
www.it-ebooks.info
C# Excel - Excel Creating in C#.NET
to Create New Excel File and Load Excel from Other Files. them the ability to count the page numbers of generated creating toolkit, if you need to add some text
add page to pdf; add page numbers to a pdf document
VB.NET TIFF: VB.NET Sample Codes to Sort TIFF File with .NET
to sort a multi-page TIFF file with page numbers using VB define the orders for the TIFF file page sorting by pageCount - 1 To 0 Step -1 newOrders.Add(i) Next
add pages to pdf in preview; adding page to pdf in preview
CHAPTER 11  ADVANCED ANIMATION 
396 
private double initialSecondsBetweenBombs = 1.3; 
private double initialSecondsToFall = 3.5; 
private double secondsBetweenBombs; 
private double secondsToFall; 
private void cmdStart_Click(object sender, RoutedEventArgs e) 
cmdStart.IsEnabled = false
// Reset the game. 
droppedCount = 0; 
savedCount = 0; 
secondsBetweenBombs = initialSecondsBetweenBombs; 
secondsToFall = initialSecondsToFall; 
// Start the bomb-dropping timer. 
bombTimer.Interval = TimeSpan.FromSeconds(secondsBetweenBombs); 
bombTimer.Start(); 
Every time the timer fires, the code creates a new Bomb object and sets its position on the Canvas. 
The bomb is placed just above the top edge of the Canvas, so it can fall seamlessly into view. It’s given a 
random horizontal position that falls somewhere between the left and right sides: 
private void bombTimer_Tick(object sender, EventArgs e) 
// Create the bomb. 
Bomb bomb = new Bomb(); 
bomb.IsFalling = true
// Position the bomb. 
Random random = new Random(); 
bomb.SetValue(Canvas.LeftProperty, 
(double)(random.Next(0, (int)(canvasBackground.ActualWidth - 50)))); 
bomb.SetValue(Canvas.TopProperty, -100.0); 
// Add the bomb to the Canvas. 
canvasBackground.Children.Add(bomb); 
... 
The code then dynamically creates a storyboard to animate the bomb. Two animations are used: 
one that drops the bomb by changing the attached Canvas.Top property and one that wiggles the bomb 
by changing the angle of its rotate transform. Because Storyboard.TargetElement and 
Storyboard.TargetProperty are attached properties, you must set them using the 
Storyboard.SetTargetElement() and Storyboard.SetTargetProperty() methods: 
... 
 
// Attach mouse click event (for defusing the bomb). 
bomb.MouseLeftButtonDown += bomb_MouseLeftButtonDown; 
// Create the animation for the falling bomb. 
www.it-ebooks.info
C#: Use XImage.OCR to Recognize MICR E-13B, OCR-A, OCR-B Fonts
may need to scan and get check characters like numbers and codes. page.RecSettings. LanguagesEnabled.Add(Language.Other); page.RecSettings.OtherLanguage
add page number to pdf document; add pages to pdf
VB.NET Excel: VB Methods to Set and Customize Excel Rendering
treat every single Excel spreadsheet as a page in our An image consists of large numbers of dots, and the Our Excel converting add-on for VB.NET still supports
adding page numbers to a pdf file; adding page numbers in pdf file
CHAPTER 11  ADVANCED ANIMATION 
397 
Storyboard storyboard = new Storyboard(); 
DoubleAnimation fallAnimation = new DoubleAnimation(); 
fallAnimation.To = canvasBackground.ActualHeight; 
fallAnimation.Duration = TimeSpan.FromSeconds(secondsToFall); 
Storyboard.SetTarget(fallAnimation, bomb); 
Storyboard.SetTargetProperty(fallAnimation, new PropertyPath("(Canvas.Top)")); 
storyboard.Children.Add(fallAnimation); 
// Create the animation for the bomb "wiggle." 
DoubleAnimation wiggleAnimation = new DoubleAnimation(); 
wiggleAnimation.To = 30; 
wiggleAnimation.Duration = TimeSpan.FromSeconds(0.2); 
wiggleAnimation.RepeatBehavior = RepeatBehavior.Forever; 
wiggleAnimation.AutoReverse = true
Storyboard.SetTarget(wiggleAnimation, 
((TransformGroup)bomb.RenderTransform).Children[0]); 
Storyboard.SetTargetProperty(wiggleAnimation, new PropertyPath("Angle")); 
storyboard.Children.Add(wiggleAnimation); 
... 
Both of these animations could use animation easing for more realistic behavior, but this example 
keeps the code simple by using basic linear animations. 
The newly created bomb and storyboard are stored in two dictionary collections so they can be 
retrieved easily in other event handlers. The collections are stored as fields in the main page class and 
are defined like this: 
private Dictionary<BombStoryboard> storyboards = 
new Dictionary<BombStoryboard>(); 
private Dictionary<StoryboardBomb> bombs = new Dictionary<StoryboardBomb>(); 
Here’s the code that adds the bomb and storyboard to these two collections: 
...     
bombs.Add(storyboard, bomb); 
storyboards.Add(bomb, storyboard); 
... 
Next, you attach an event handler that reacts when the storyboard finishes the fallAnimation, which 
occurs when the bomb hits the ground. Finally, the storyboard is started, and the animations are put in 
motion: 
...     
storyboard.Duration = fallAnimation.Duration; 
storyboard.Completed += storyboard_Completed; 
storyboard.Begin(); 
... 
The bomb-dropping code needs one last detail. As the game progresses, it becomes more difficult. 
The timer begins to fire more frequently, the bombs begin to appear more closely together, and the fall 
time is reduced. To implement these changes, the timer code makes adjustments whenever a set interval 
www.it-ebooks.info
C# Excel: Create and Draw Linear and 2D Barcodes on Excel Page
barcode image to the first page page.AddImage(barcodeImage C#.NET Excel Barcode Creating Add-on imaging controls, PDF document, image to pdf files and components
add page number to pdf in preview; adding page numbers to pdf in
VB.NET Image: Guide to Convert Images to Stream with DocImage SDK
Follow this guiding page to learn how to easily convert a single image or numbers of it an image processing component which can enable developers to add a wide
add blank page to pdf; add page numbers to pdf reader
CHAPTER 11  ADVANCED ANIMATION 
398 
of time has passed. By default, BombDropper makes an adjustment every 15 seconds. Here are the fields 
that control the adjustments: 
// Perform an adjustment every 15 seconds. 
private double secondsBetweenAdjustments = 15; 
private DateTime lastAdjustmentTime = DateTime.MinValue; 
// After every adjustment, shave 0.1 seconds off both. 
private double secondsBetweenBombsReduction = 0.1; 
private double secondsToFallReduction = 0.1; 
And here’s the code at the end of the DispatcherTimer.Tick event handler, which checks whether an 
adjustment is needed and makes the appropriate changes: 
... 
// Perform an "adjustment" when needed. 
if ((DateTime.Now.Subtract(lastAdjustmentTime).TotalSeconds > 
secondsBetweenAdjustments)) 
lastAdjustmentTime = DateTime.Now; 
secondsBetweenBombs -= secondsBetweenBombsReduction; 
secondsToFall -= secondsToFallReduction; 
// (Technically, you should check for 0 or negative values. 
// However, in practice these won't occur because the game will 
// always end first.) 
// Set the timer to drop the next bomb at the appropriate time. 
bombTimer.Interval = TimeSpan.FromSeconds(secondsBetweenBombs); 
// Update the status message. 
lblRate.Text = String.Format("A bomb is released every {0} seconds."
secondsBetweenBombs); 
lblSpeed.Text = String.Format("Each bomb takes {0} seconds to fall."
secondsToFall); 
With this code in place, there’s enough functionality to drop bombs at an ever-increasing rate. 
However, the game still lacks the code that responds to dropped and saved bombs. 
Intercepting a Bomb 
The user saves a bomb by clicking it before it reaches the bottom of the Canvas and explodes. Because 
each bomb is a separate instance of the Bomb user control, intercepting mouse clicks is easy—all you 
need to do is handle the MouseLeftButtonDown event, which fires when any part of the bomb is clicked 
(but doesn’t fire if you click somewhere in the background, such as around the edges of the bomb circle). 
When a bomb is clicked, the first step is to get appropriate bomb object and set its IsFalling property 
to indicate that it’s no longer falling. (The IsFalling property is used by the event handler that deals with 
completed animations.) 
private void bomb_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) 
www.it-ebooks.info
CHAPTER 11  ADVANCED ANIMATION 
399 
// Get the bomb. 
Bomb bomb = (Bomb)sender; 
bomb.IsFalling = false
// Record the bomb's current (animated) position. 
double currentTop = Canvas.GetTop(bomb); 
... 
The next step is to find the storyboard that controls the animation for this bomb so it can be 
stopped. To find the storyboard, you need to look it up in the collection that this game uses for tracking. 
Currently, Silverlight doesn’t include any standardized way to find the animations that are acting on a 
given element. 
... 
// Stop the bomb from falling. 
Storyboard storyboard = storyboards[bomb]; 
storyboard.Stop(); 
... 
After a button is clicked, another set of animations moves the bomb off the screen, throwing it up 
and left or right (depending on which side is closest). Although you could create an entirely new 
storyboard to implement this effect, the BombDropper game clears the current storyboard that’s being 
used for the bomb and adds new animations to it. When this process is completed, the new storyboard is 
started: 
... 
// Reuse the existing storyboard, but with new animations. 
// Send the bomb on a new trajectory by animating Canvas.Top 
// and Canvas.Left. 
storyboard.Children.Clear(); 
DoubleAnimation riseAnimation = new DoubleAnimation(); 
riseAnimation.From = currentTop; 
riseAnimation.To = 0; 
riseAnimation.Duration = TimeSpan.FromSeconds(2); 
Storyboard.SetTarget(riseAnimation, bomb); 
Storyboard.SetTargetProperty(riseAnimation, new PropertyPath("(Canvas.Top)")); 
storyboard.Children.Add(riseAnimation); 
DoubleAnimation slideAnimation = new DoubleAnimation(); 
double currentLeft = Canvas.GetLeft(bomb); 
// Throw the bomb off the closest side. 
if (currentLeft < canvasBackground.ActualWidth / 2) 
slideAnimation.To = -100; 
else 
slideAnimation.To = canvasBackground.ActualWidth + 100; 
www.it-ebooks.info
CHAPTER 11  ADVANCED ANIMATION 
400 
slideAnimation.Duration = TimeSpan.FromSeconds(1); 
Storyboard.SetTarget(slideAnimation, bomb); 
Storyboard.SetTargetProperty(slideAnimation, new PropertyPath("(Canvas.Left)")); 
storyboard.Children.Add(slideAnimation); 
// Start the new animation. 
storyboard.Duration = slideAnimation.Duration; 
storyboard.Begin(); 
Now the game has enough code to drop bombs and bounce them off the screen when the user saves 
them. However, to keep track of what bombs are saved and which ones are dropped, you need to react to 
the Storyboard.Completed event that fires at the end of an animation. 
Counting Bombs and Cleaning Up 
As you’ve seen, the BombDropper uses storyboards in two ways: to animate a falling bomb and to 
animate a defused bomb. You could handle the completion of these storyboards with different event 
handlers, but to keep things simple the BombDropper uses just one. It tells the difference between an 
exploded bomb and a rescued bomb by examining the Bomb.IsFalling property. 
// End the game when 5 bombs have fallen. 
private int maxDropped = 5; 
private void storyboard_Completed(object sender, EventArgs e) 
Storyboard completedStoryboard = (Storyboard)sender; 
Bomb completedBomb = bombs[completedStoryboard]; 
if (completedBomb.IsFalling) 
droppedCount++; 
else 
savedCount++; 
... 
Either way, the code then updates the display test to indicate how many bombs have been dropped 
and saved. It then performs some cleanup, removing the bomb from the Canvas, and removing both the 
bomb and the storyboard from the collections that are used for tracking. 
... 
// Update the display. 
lblStatus.Text = String.Format("You have dropped {0} bombs and saved {1}."
droppedCount, savedCount); 
// Clean up. 
completedStoryboard.Stop(); 
canvasBackground.Children.Remove(completedBomb); 
www.it-ebooks.info
CHAPTER 11  ADVANCED ANIMATION 
401 
// Update the tracking collections. 
storyboards.Remove(completedBomb); 
bombs.Remove(completedStoryboard); 
... 
At this point, the code checks to see whether the maximum number of dropped bombs has been 
reached. If it has, the game ends, the timer is stopped, and all the bombs and storyboards are removed: 
... 
// Check if it's game over. 
if (droppedCount >= maxDropped) 
bombTimer.Stop(); 
lblStatus.Text += "\r\n\r\nGame over."
// Find all the storyboards that are underway. 
foreach (KeyValuePair<BombStoryboard> item in storyboards) 
Storyboard storyboard = item.Value; 
Bomb bomb = item.Key; 
storyboard.Stop(); 
canvasBackground.Children.Remove(bomb); 
// Empty the tracking collections. 
storyboards.Clear(); 
bombs.Clear(); 
// Allow the user to start a new game. 
cmdStart.IsEnabled = true
This completes the code for BombDropper game. However, you can make plenty of refinements. 
Some examples include the following: 
• Animate a bomb explosion effect: This effect can make the flames around the 
bomb twinkle or send small pieces of shrapnel flying across the Canvas. 
• Animate the background: This change is easy, and it adds pizzazz. For example, 
you can create a linear gradient that shifts up, creating an impression of 
movement, or one that transitions between two colors. 
• Add depth: It’s easier than you think. The basic technique is to give the bombs 
different sizes. Bombs that are bigger should have a higher ZIndex, ensuring that 
they overlap smaller bombs, and should be given a shorter animation time, 
ensuring that they fall faster. You can also make the bombs partially transparent, 
so as one falls the others behind it are visible. 
• Add sound effects: In Chapter 12, you’ll learn to use sound and other media in 
Silverlight. You can use well-timed sound effects to punctuate bomb explosions or 
rescued bombs. 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested