best pdf viewer control for asp.net : Add page numbers to pdf using preview Library software component .net windows winforms mvc Pro_Silverlight_5_in_CSharp_4th_edition38-part102

CHAPTER 10  ANIMATION BASICS 
372 
 Tip  For the best animation performance, use transparency sparingly, avoid animating text size (because font 
smoothing and hinting slow down performance), and don’t use the windowless setting discussed in Chapter 9 
(which lets HTML elements show through the Silverlight content region). 
Hardware Acceleration 
The holy grail of graphics programming is to offload most of the work to the graphics processing unit 
(GPU) on the computer’s video card. After all, video cards are specially designed to be able to handle 
certain types of graphical tasks (for example, bitmap scaling) quickly and efficiently. But when running a 
typical web application, your video card is hardly working at all. Surely, it makes sense to enlist their 
help and free up the much more valuable CPU. 
 Note  Technically, offloading work to the GPU is called hardware acceleration, because this technique speeds 
up complex video tasks such as 3-D rendering in cutting-edge computer games. In a Silverlight application, 
hardware acceleration can reduce the load on the CPU and it may improve the frame rate of your animations 
(allowing them to run more smoothly). 
Unfortunately, implementing hardware acceleration is not as easy as it seems. The first problem is 
that hardware acceleration requires an extra layer of video card support on the platform that’s running 
the application. For a Silverlight application running on a Windows computer, that means you’ll need a 
DirectX 9–compatible video card and drivers. On Mac OS X, you’ll need an OpenGL2-compatible video 
card with drivers. Furthermore, hardware acceleration works on a Mac hardware only when your 
application is running in full-screen mode (as described in Chapter 3). The Windows implementation of 
Silverlight doesn’t have the same limitation. 
The second problem is that video cards are designed to accelerate certain specific graphic 
operations (for example, shading in the tiny triangles that make up 3D scenes). Many of these 
optimizations aren’t suited to Silverlight applications. In fact, Silverlight applications use just one type of 
optimization: the ability of a video card to cache some visual element as a bitmap. Other types of 
hardware acceleration might be possible, but they aren’t currently implemented in Silverlight. 
Enabling Hardware Acceleration 
parameter and setting it true, as shown here:<div id="silverlightControlHost"> 
<object data="data:application/x-silverlight-2," 
type="application/x-silverlight-2" width="100%" height="100%"> 
<param name="enableGPUAcceleration" value="true" /> 
<param name="enableCacheVisualization" value="true" /> 
<param name="enableFrameRateCounter" value="true" /> 
... 
www.it-ebooks.info
Add page numbers to pdf using preview - 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 a page to a pdf; add page numbers to pdf document in preview
Add page numbers to pdf using preview - 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 and delete pages from pdf; adding a page to a pdf in preview
CHAPTER 10  ANIMATION BASICS 
373 
</object
<iframe style="visibility:hidden;height:0;width:0;border:0px"></iframe
</div
You’ll notice this example also adds two optional parameters that work in conjunction with 
hardware acceleration. The enableCacheVisualization parameter uses tinting to highlight areas of your 
application that aren’t taking advantage of bitmap caching on the video card. The 
enableFrameRateCounter parameter displays a frame rate counter that updates itself continuously as 
your animations run. Both of these parameters give you helpful diagnostic tools that allow you to 
evaluate performance during testing. You’ll remove them in the final version of your application. 
Setting the enableGPUAcceleration property has no immediate effect. It gives you the ability to 
switch on bitmap caching for individual elements. But until you take this step, you won’t notice any 
change in your application’s performance. 
Bitmap Caching 
Bitmap caching tells Silverlight to take a bitmap image of your content as it currently is and copy that to 
the memory on your video card. From this point on, the video card can take charge of manipulating the 
bitmap and refreshing the display. This process is far faster than getting the Silverlight runtime to do all 
the work and communicate continuously with the video card. 
However, there’s a catch. The video card is limited in what it can do with the bitmap. It supports the 
following operations: 
Scaling, rotating, moving, or skewing a bitmap with a RenderTransform 
Applying a 3-D effect to a bitmap with a perspective transform (using the 
Projection property) 
Changing the opacity of the bitmap (using the Opacity property) 
Clipping the bitmap with a rectangular clipping region (using the Clip property) 
Thus, if you have animations that perform scaling, rotation, or fading on an element, you’ll get a 
benefit from hardware acceleration. However, if you have animations that do anything else to change 
the way an element looks—for example, changing its color, applying a pixel shader, and so on, you 
should definitely not use bitmap caching. In this sort of situation, Silverlight will be forced to keep 
passing an updated copy of the bitmap back to the video card, updating its cache several times a second. 
This process will actually decrease performance. 
To switch on bitmap caching, you set the CacheMode property of the corresponding element to 
BitmapCache. Every element provides this property, which means you have a fine-grained ability to 
choose exactly which elements use this feature. 
 Note  If you cache an element that contains other elements, like a layout container, all the elements will be 
cached in a single bitmap. Thus, you need to be extremely careful about adding caching to something like a 
Canvas—only do it if all the children are limited to the allowed transformations in the previous list. 
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 PDF document in C#.NET using this PDF document creating toolkit, if you need to add some text
add a blank page to a pdf; add page numbers to pdf preview
C# PowerPoint - PowerPoint Creating in C#.NET
them the ability to count the page numbers of generated a PowerPoint document in C#.NET using this PowerPoint creating toolkit, if you need to add some text
adding pages to a pdf document in preview; add a page to a pdf file
CHAPTER 10  ANIMATION BASICS 
374 
To get a better understanding, it helps to play with a simple example. Figure 10-7 shows a project 
that’s included with the downloadable samples for this chapter. Here, two animations are at work. The 
first rotates an Image element that contains the picture of a phone booth. The second one changes the 
size of a button using a ScaleTransform, endlessly expanding and shrinking it. Both animations are clear 
candidates for bitmap caching. 
Figure 10-7. A test page with two animated elements 
Here’s the markup that switches on bitmap caching for both: 
<Canvas> 
<Image x:Name="img" Source="phone_booth.jpg" Stretch="None" 
CacheMode="BitmapCache"> 
<Image.RenderTransform> 
<RotateTransform x:Name="rotateTransform"></RotateTransform> 
</Image.RenderTransform> 
</Image> 
<Button x:Name="cmd" Content="I GROW and SHRINK." Canvas.Top="70" Canvas.Left="10" 
CacheMode="BitmapCache"> 
<Button.RenderTransform> 
<ScaleTransform x:Name="scaleTransform"></ScaleTransform> 
</Button.RenderTransform> 
www.it-ebooks.info
C# Word - Word Creating in C#.NET
offer them the ability to count the page numbers of generated creating a Word document in C#.NET using this Word creating toolkit, if you need to add some text
add page numbers to a pdf in preview; add page break to pdf
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 or remove pages from pdf; adding a page to a pdf document
CHAPTER 10  ANIMATION BASICS 
375 
</Button> 
</Canvas> 
And here’s the markup that declares the animations: 
<Storyboard x:Name="storyboard"> 
<DoubleAnimation Storyboard.TargetName="rotateTransform" 
Storyboard.TargetProperty="Angle" To="360" Duration="0:0:2" 
RepeatBehavior="Forever"></DoubleAnimation> 
<DoubleAnimation Storyboard.TargetName="scaleTransform" 
Storyboard.TargetProperty="ScaleX" AutoReverse="True" 
To="20" Duration="0:0:1.8" RepeatBehavior="Forever"></DoubleAnimation> 
<DoubleAnimation Storyboard.TargetName="scaleTransform" 
Storyboard.TargetProperty="ScaleY" AutoReverse="True" 
To="20" Duration="0:0:1.8" RepeatBehavior="Forever"></DoubleAnimation> 
</Storyboard> 
Bitmap caching has one potential problem. Ordinarily, when you enable bitmap caching, Silverlight 
takes a snapshot of the element at its current size and copies that bitmap to the video card. If you then 
use a ScaleTransform to make the bitmap bigger, you’ll be enlarging the cached bitmap, not the actual 
element. In the current example, that means the button will grow fuzzy and pixelated as it grows. 
To solve this problem, you could switch on bitmap caching altogether (in which case the effect 
disappears, because Silverlight treats buttons and other elements as fully resizable vector images). 
However, another option is to explicitly indicate the size of bitmap that Silverlight should cache on the 
video card, using the BitmapCache.RenderAtScale property. Ordinarily, this property is set to 1, and the 
element is taken at its current size. But the markup here takes a snapshot of the button at five times its 
current size: 
<Button x:Name="cmd" Content="I GROW and SHRINK." Canvas.Top="70" Canvas.Left="10"> 
<Button.CacheMode> 
<BitmapCache RenderAtScale="5"></BitmapCache> 
</Button.CacheMode> 
<Button.RenderTransform> 
<ScaleTransform x:Name="scaleTransform"></ScaleTransform> 
</Button.RenderTransform> 
</Button> 
This resolves the pixelation problem. The cached bitmap is still smaller than the maximum 
animated size of the button (which reaches ten times its original size), but the video card is able to 
double the size of the bitmap from five to ten times the size without any obvious scaling artifacts. There 
are only two potential disadvantages to increasing the RenderAtScale property. First, you’re forcing 
Silverlight to transfer more data to the video card (which slows the initial rendering step). Second, you’re 
asking the video card to use more of its onboard video memory. Different video cards have different 
amounts of memory, and when the available memory is used up, the video card won’t be able to cache 
any more bitmaps, and Silverlight will fall back on software rendering. 
Evaluating Hardware Acceleration 
The easiest way to evaluate the success of your bitmap caching is to run your application both with and 
without hardware acceleration. In most cases, the difference won’t be obvious until you check the CPU 
usage of your computer or the frame rate of your animation. To check the CPU usage, load Task 
Manager and watch the Performance tab. In an informal test with the previous example, CPU usage on a 
www.it-ebooks.info
C# Excel - Excel Creating in C#.NET
also offer them the ability to count the page numbers of generated a Excel document in C#.NET using this Excel creating toolkit, if you need to add some text
add pages to pdf in preview; add page to pdf reader
CHAPTER 10  ANIMATION BASICS 
376 
single-processor computer dropped from about 50% to about 20% when caching was switched on. The 
downloadable samples for this chapter include an example that allows you to switch caching on and off 
using a check box. The change is performed programmatically using code like this: 
img.CacheMode = new BitmapCache(); 
Another useful tool is Silverlight’s built-in diagnostic support. Earlier, you learned about the 
enableCacheVisualization and enableFrameRateCounter parameters, which you can add to your test 
page to capture some extra diagnostic information. Figure 10-8 shows an example where both 
parameters are switched on and caching is turned off. 
Figure 10-8. Using cache visualization and the frame rate counter 
Here, the Image and Button elements are tinted red to indicate that they aren’t being cached 
(thanks to enableCacheVisualization). The set of numbers in the top-left corner provides frame rate 
information (thanks to enableFrameRateCounter), as follows: 
• The first number shows the animation frame rate. When you are not using bitmap 
caching, this number tends to fluctuate more dramatically and drop during the 
most complex parts of the animation. 
• The second number shows how many kilobytes of video card memory are used. 
This increases when caching is turned on. 
www.it-ebooks.info
CHAPTER 10  ANIMATION BASICS 
377 
• The third number shows the total number of hardware-accelerated surfaces. 
Remember, switching bitmap caching on for one element will usually affect 
several surfaces—even in the case of the button, there is a TextBlock with content 
inside. 
• The fourth number shows the number of implicit hardware-accelerated surfaces. 
In some situations, switching caching on for one element may necessitate turning 
it on for another (for example, if the second element overlaps the first one). In this 
case, Silverlight will automatically perform caching for the additional element, 
which is known as an implicit surface. 
The bottom line is that you can quickly size up an example like this and determine that bitmap 
caching makes sense. In this scenario, it both reduces the CPU load and improves the frame rate. 
Independent Animations 
When the architects of Silverlight built Silverlight 5, they redesigned a portion of the low-level graphics 
system. Mostly, their work was part of the effort to introduce 3D rendering, which you’ll learn about in 
Chapter 13. However, the change also allows for another benefit, called independent animations
Ordinarily, animations run on Silverlight’s user interface thread. Independent animations are 
different—they run on a separate thread, which is called the composition thread. In many situations, this 
distinction isn’t important. But if you have an application that’s performing CPU-intensive work on the 
user-interface thread, it can affect your animations, causing them to become jerky or stop altogether. 
Often, this is a sign of a poorly designed application. For example, it might suggest that you should 
move your time-consuming work to a background thread (using the BackgroundWorker class described 
in Chapter 16) so that your user interface thread can do its job. After all, it’s never good to lock up the 
user interface thread, because it also needs to process user actions, like mouse clicks or key presses. 
However, in some situations, glitchy animations are almost unavoidable. For example, imagine you’ve 
created an “in-progress” animation that runs while you compute or download data (possibly using the 
BackgroundWorker). Once you have the data, you add it into a DataGrid in the window. However, your 
data is so large that this operation briefly locks up the user interface thread, causing your animation to 
pause. Using an independent animation solves this problem and removes this pause. 
Running an animation on the composition thread is simple in theory, although there are numerous 
subtle details that can thwart it. Most notably, you need to meet all the requirements of hardware 
acceleration: 
1. Enable hardware acceleration with the enableGpuAcceleration parameter. 
2. Set the BitmapCache property on the element you’re animating. 
3. Make sure you aren’t using any unsupported drawing features (like pixel 
shaders). 
If you meet these requirements, the animations on your element will automatically be promoted to 
independent animations. 
To test that your animation is actually running on the composition thread, find a way to tie up your 
user interface thread. In the previous example, the button is given an event handler so that every time 
it’s clicked, the user interface thread is put to sleep for five seconds: 
private void cmd_Click(object sender, RoutedEventArgs e) 
Thread.Sleep(TimeSpan.FromSeconds(5)); 
www.it-ebooks.info
CHAPTER 10  ANIMATION BASICS 
378 
If you aren’t using independent animations, this action will freeze the animations that are currently 
taking place, for five seconds. If you are using independent animations, the animations will carry on 
unaffected. 
The Last Word 
In this chapter, you explored Silverlight’s animation support in detail. You learned about the basic 
animation classes and the concept of linear interpolation. You also saw how to control the playback of 
one or more animations with a storyboard and how to create more natural effects with animation 
easing. 
Now that you’ve mastered the basics, you can spend more time with the art of animation—deciding 
what properties to animate and how to modify them to get your desired effect. In the next chapter, you’ll 
learn how to create a variety of effects by applying animations to transforms, brushes, and pixel shaders. 
You’ll also learn to create key frame animations that contain multiple segments and frame-based 
animations that break free from the standard property-based animation model. Finally, you’ll see how 
you can create and manage storyboards with code rather than XAML. 
www.it-ebooks.info
C H A P T E R  11 
379 
Advanced Animation 
You now know the fundamentals of Silverlight’s property animation system—how animations are 
defined, how they’re connected to elements, how you can control playback with a storyboard, and how 
you can incorporate animation easing to create more realistic effects. Now is a good time to take a closer 
look at the practical animation techniques you can use in an application. 
In this chapter, you’ll begin by considering what you should animate to get the results you want. 
You’ll see examples that animate transforms, brushes, and pixel shaders. Next, you’ll learn how key 
frame–based animations allow you to shape the acceleration and deceleration of your animations, in a 
way that’s similar to animation easing but far more flexible. Then, you’ll examine two code-powered 
animation examples—first, a bomb-dropping game and, second, an animated page transition. Both 
examples show how you can integrate animations into the overall flow of an application, by creating and 
managing them with code. Lastly, you’ll learn how frame-based animation lets you break free of the 
animation model altogether to create complex effects such as realistic collisions. 
Animation Types Revisited 
The first challenge in creating any animation is choosing the right property to animate. Making the leap 
between the result you want (for example, an element moving across the page) and the property you 
need to use (in this case, Canvas.Left and Canvas.Top) isn’t always intuitive. Here are a few guidelines: 
• If you want to use an animation to make an element appear or disappear, don’t 
use the Visibility property (which allows you to switch only between completely 
visible or completely invisible). Instead, use the Opacity property to fade it in or 
out. 
• If you want to animate the position of an element, consider using a Canvas. It 
provides the most direct properties (Canvas.Left and Canvas.Top) and requires 
the least overhead. 
• The most common properties to animate are transforms, which you first explored 
in Chapter 8. You can use them to move or flip an element (TranslateTransform), 
rotate it (RotateTransform), resize or stretch it (ScaleTransform), and more. Used 
carefully, transforms can sometimes allow you to avoid hard-coding sizes and 
positions in your animation. TranslateTransform also lets you move elements in 
layout containers such as the Grid in much the same way you can position them in 
the Canvas. 
www.it-ebooks.info
CHAPTER 11  ADVANCED ANIMATION 
380 
• One good way to change the surface of an element through an animation is to 
modify the properties of the brush. You can use a ColorAnimation to change the 
color or another animation object to transform a property of a more complex 
brush, like the offset in a gradient. 
The following examples demonstrate how to animate transforms and brushes and how to use a few 
more animation types. You’ll also learn how to create multi-segmented animations with key frames. 
Animating Transforms 
Transforms offer one of the most powerful ways to customize an element. When you use transforms, you 
don’t simply change the bounds of an element. Instead, the element’s entire visual appearance is 
moved, flipped, skewed, stretched, enlarged, shrunk, or rotated. For example, if you animate the size of a 
button using a ScaleTransform, the entire button is resized, including its border and its inner content. 
The effect is much more impressive than if you animate its Width and Height or the FontSize property 
that affects its text. 
To use a transform in animation, the first step is to define the transform. (An animation can change 
an existing transform but not create a new one.) For example, imagine you want to allow a button to 
rotate. This requires the RotateTransform: 
<Button Content="A Button"> 
<Button.RenderTransform> 
<RotateTransform x:Name="rotateTransform"></RotateTransform> 
</Button.RenderTransform> 
</Button> 
 Tip  You can use transforms in combination. It’s easy—use a TransformGroup object to set the 
RenderTransform property. You can nest as many transforms as you need inside the transform group. You’ll see an 
example in the bomb game that’s shown later in this chapter. 
Here’s an animation that makes a button rotate when the mouse moves over it. It acts on the 
Button.RotateTransform object and uses the target property Angle. The fact that the RenderTransform 
property can hold a variety of different transform objects, each with different properties, doesn’t cause a 
problem. As long as you’re using a transform that has an Angle property, this animation will work. 
<Storyboard x:Name="rotateStoryboard"> 
<DoubleAnimation Storyboard.TargetName="rotateTransform" 
Storyboard.TargetProperty="Angle" 
To="360" Duration="0:0:0.8" RepeatBehavior="Forever"></DoubleAnimation> 
</Storyboard> 
If you place this animation in the page’s Resources collection, you can trigger it when the user 
moves the mouse over the button: 
private void cmd_MouseEnter(object sender, MouseEventArgs e) 
rotateStoryboard.Begin(); 
www.it-ebooks.info
CHAPTER 11  ADVANCED ANIMATION 
381 
The button rotates one revolution every 0.8 seconds and continues rotating perpetually. While the 
button rotates, it’s completely usable—for example, you can click it and handle the Click event. 
To make sure the button rotates around its center point (not the upper-left corner), you need to set 
the RenderTransformOrigin property as shown here: 
<Button Content="One" Margin="5" RenderTransformOrigin="0.5,0.5" 
MouseEnter="cmd_MouseEnter"> 
<Button.RenderTransform> 
<RotateTransform x:Name="rotateTransform"></RotateTransform> 
</Button.RenderTransform> 
</Button> 
Remember, the RenderTransformOrigin property uses relative units from 0 to 1, so 0.5 represents a 
midpoint. 
To stop the rotation, you can react to the MouseLeave event. You could stop the storyboard that 
performs the rotation, but doing so would cause the button to jump back to its original orientation in 
one step. A better approach is to start a second animation that replaces the first. This animation leaves 
out the From property, which allows it to seamlessly rotate the button from its current angle to its 
original orientation in a snappy 0.2 seconds: 
<Storyboard x:Name="unrotateStoryboard"> 
<DoubleAnimation Storyboard.TargetName="rotateTransform" 
Storyboard.TargetProperty="Angle" To="0" Duration="0:0:0.2"></DoubleAnimation> 
</Storyboard> 
Here’s the event handler: 
private void cmd_MouseLeave(object sender, MouseEventArgs e) 
unrotateStoryboard.Begin(); 
With a little more work, you can make these two animations and the two event handlers work for a 
whole stack of rotatable buttons, as shown in Figure 11-1. The trick is to handle the events of all the 
buttons with the same code, and dynamically assign the target of the storyboard to the current button 
using the Storyboard.SetTarget() method: 
private void cmd_MouseEnter(object sender, MouseEventArgs e) 
rotateStoryboard.Stop(); 
Storyboard.SetTarget(rotateStoryboard, ((Button)sender).RenderTransform); 
rotateStoryboard.Begin(); 
private void cmd_MouseLeave(object sender, MouseEventArgs e) 
unrotateStoryboard.Stop(); 
Storyboard.SetTarget(unrotateStoryboard, ((Button)sender).RenderTransform); 
unrotateStoryboard.Begin(); 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested