c# free pdf viewer component : Add page numbers to pdf document in preview software SDK cloud windows winforms wpf class Pro_Silverlight_5_in_CSharp_4th_edition31-part95

CHAPTER 8  SHAPES AND TRANSFORMS 
300 
<Rectangle Width="80" Height="10" Stroke="Blue" Fill="Yellow" 
Canvas.Left="100" Canvas.Top="100" RenderTransformOrigin="0.5,0.5"> 
<Rectangle.RenderTransform> 
<RotateTransform Angle="25" /> 
</Rectangle.RenderTransform> 
</Rectangle> 
This works because the point (0.5, 0.5) designates the center of the shape, regardless of its size. In 
practice, RenderTransformOrigin is generally more useful than the CenterX and CenterY properties, 
although you can use either one (or both) depending on your needs. 
 Tip  You can use values greater than 1 or less than 0 when setting the RenderTransformOrigin property to 
designate a point that appears outside the bounding box of your shape. For example, you can use this technique 
with a RotateTransform to rotate a shape in a large arc around a very distant point, such as (5, 5). 
Transforms and Layout Containers 
The RenderTransform and RenderTransformOrigin properties aren’t limited to shapes. The Shape class 
inherits them from the UIElement class, which means they’re supported by all Silverlight elements, 
including buttons, text boxes, the TextBlock; entire layout containers full of content; and so on. 
Amazingly, you can rotate, skew, and scale any piece of Silverlight user interface (although in most cases 
you shouldn’t). 
It’s important to note that when you apply transforms to the elements in a layout container, the 
transforming is performed after the layout. For the simple Canvas, which uses coordinate-based layout, 
this distinction has no effect. But for other layout containers, which position elements relatively based 
on the placement and size of other elements, the effect is important. For instance, consider Figure 8-22, 
which shows a StackPanel that contains a rotated button. Here, the StackPanel lays out the two buttons 
as though the first button is positioned normally, and the rotation happens just before the button is 
rendered. As a result, the rotated button overlaps the one underneath. 
www.it-ebooks.info
Add page numbers to pdf document in 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
add page to pdf acrobat; add and delete pages in pdf
Add page numbers to pdf document in 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
adding page numbers to pdf in preview; adding page numbers to a pdf in preview
CHAPTER 8  SHAPES AND TRANSFORMS 
301 
Figure 8-22. Rotating buttons 
WPF also has the ability to use layout transforms, which are applied before the layout pass. This 
means the layout container uses the transformed dimensions of an element when positioning other 
elements. However, Silverlight doesn’t provide this ability. 
 Tip  You can also use transforms to change a wide range of Silverlight ingredients, such as brushes, 
geometries, and clipping regions. 
A Reflection Effect 
Transforms are important for applying many types of effects. One example is a reflection effect, such as 
the one demonstrated in Figure 8-23. 
www.it-ebooks.info
C# Create PDF Library SDK to convert PDF from other file formats
offer them the ability to count the page numbers of generated document in C#.NET using this PDF document creating toolkit, if you need to add some text
add a page to pdf file; add pages to pdf file
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 online; adding page numbers in pdf
CHAPTER 8  SHAPES AND TRANSFORMS 
302 
Figure 8-23. A reflection effect 
To create a reflection effect in Silverlight, you first explicitly duplicate the content that will use the 
effect. For example, to create the reflection shown in Figure 8-23, you need to begin with two identical 
Image elements—one of which shows the original image and the other of which shows the reflected 
copy: 
<Grid x:Name="LayoutRoot" Background="White"> 
<Grid.RowDefinitions> 
<RowDefinition></RowDefinition> 
<RowDefinition></RowDefinition> 
</Grid.RowDefinitions> 
<Image Grid.Row="0" Source="harpsichord.jpg"></Image> 
<Image Grid.Row="1" Source="harpsichord.jpg"></Image> 
</Grid> 
www.it-ebooks.info
C# PowerPoint - PowerPoint Creating in C#.NET
offer them the ability to count the page numbers of generated in C#.NET using this PowerPoint document creating toolkit, if you need to add some text
adding a page to a pdf in reader; add pdf pages to word
C# Word - Word Creating in C#.NET
offer them the ability to count the page numbers of generated document in C#.NET using this Word document creating toolkit, if you need to add some text
add document to pdf pages; add pages to an existing pdf
CHAPTER 8  SHAPES AND TRANSFORMS 
303 
Because this technique forces you to duplicate your content, it generally isn’t practical to add a 
reflection effect to controls. But it’s possible to create a reflection of a live video playback with the help 
of the VideoBrush class, which is described in Chapter 12. 
The second step is to modify the copy of your content to make it look more like a reflection. To 
accomplish this, you use a combination of two ingredients—a transform, which flips the image into 
place, and an opacity mask, which fades it gently out of sight. 
<Image Grid.Row="1" Source="harpsichord.jpg" RenderTransformOrigin="0,0.4"> 
<Image.RenderTransform> 
<ScaleTransform ScaleY="-0.8"></ScaleTransform> 
</Image.RenderTransform> 
<Image.OpacityMask> 
<LinearGradientBrush StartPoint="0,0" EndPoint="0,1"> 
<GradientStop Offset="0" Color="Transparent"></GradientStop> 
<GradientStop Offset="1" Color="#44000000"></GradientStop> 
</LinearGradientBrush> 
</Image.OpacityMask> 
</Image> 
Here, a ScaleTransform flips the image over by using a negative value for ScaleY. To flip an image 
horizontally, you use –1. Using a fractional value (in this case, –0.8) simultaneously flips the image over 
and compresses it, so it’s shorter than the original image. To make sure the flipped copy appears in the 
right place, you must position it exactly (using a layout container like the Canvas) or use the 
RenderTransformOrigin property, as in this example. Here, the image is flipped around the point (0, 0.4). 
In other words, it keeps the same left alignment (x = 0) but is moved down (y = 0.4). Essentially, it’s 
flipped around an imaginary horizontal line that’s a bit higher than the midpoint of the image. 
This example uses a LinearGradientBrush that fades between a completely transparent color and a 
partially transparent color to make the reflected content more faded. Because the image is upside down, 
you must define the gradient stops in reverse order. 
Perspective Transforms 
Silverlight doesn’t include a true toolkit for 3-D drawing. However, it does have a feature called 
perspective transforms that lets you simulate a 3-D surface. Much like a normal transform, a perspective 
transform takes an existing element and manipulates its visual appearance. But with a perspective 
transform, the element is made to look as though it’s on a 3-D surface. 
Perspective transforms can come in handy, but they’re a long way from real 3-D. First, and most 
obvious, they give you only a single shape to work with—essentially, a flat, rectangular plane, like a sheet 
of paper, on which you can place your elements and then tilt them away from the viewer. By 
comparison, a true 3-D framework allows you to fuse tiny triangles together to build more complex 
surfaces, ranging from cubes and polyhedrons to spheres and entire topographic maps. True 3-D 
frameworks also use complex math to calculate proper lighting and shading, determine what shapes are 
obscuring other shapes, and so on. (For an example, consider Silverlight’s Windows-only big brother, 
WPF, which has rich 3-D support.) 
www.it-ebooks.info
C# Excel - Excel Creating in C#.NET
also offer them the ability to count the page numbers of generated in C#.NET using this Excel document creating toolkit, if you need to add some text
add page number to pdf preview; adding page numbers in pdf file
CHAPTER 8  SHAPES AND TRANSFORMS 
304 
 Note  The bottom line is this—if you’re looking for a few tricks to create some 3-D eye candy without the hard 
work, you’ll like Silverlight’s perspective-transform feature. (Perspective transforms are particularly useful when 
combined with animation, as you’ll see in Chapter 10.) But if you’re hoping for a comprehensive framework to 
model a 3-D world, you’ll be sorely disappointed. 
Much as Silverlight includes an abstract Transform class from which all transforms derive, it uses an 
abstract System.Windows.Media.Projection class from which all projections derive. Currently, Silverlight 
includes just two projections: the practical PlaneProjection that you’ll use in this chapter and the far 
more complex Matrix3DProjection, which suits those who are comfortable using heavy-duty math to 
construct and manipulate 3D matrices. Matrix3DProjection is beyond the scope of this book. However, if 
you’d like to experiment with it and explore the underlying math, Charles Petzold provides a good two-
part introduction with sample code at 
http://tinyurl.com/m29v3q
and 
http://tinyurl.com/laalp6
The PlaneProjection Class 
PlaneProjection gives you two complementary abilities. First, you can rotate the 3-D plane around the x-
axis (side-to-side), the y-axis (up-and-down), or the z-axis (which looks like a normal rotational 
transform). Figure 8-24 illustrates the difference, with 45-degree rotations around the three different 
axes. 
Figure 8-24. Rotations with the PlaneProjection class 
In Figure 8-24, the picture is rotated around its center point. But you can explicitly choose to rotate 
the element around a different point by setting the right property. Here’s how: 
• For an x-axis rotation, use RotationX to control the amount of rotation (as an 
angle from 0 to 360 degrees). Use CenterOfRotationX to set the x coordinate of the 
center point in relative terms, where 0 is the far left, 1 is the far right, and 0.5 is the 
middle point (and default). 
www.it-ebooks.info
CHAPTER 8  SHAPES AND TRANSFORMS 
305 
• For a y-axis rotation, use RotationY to set the angle of rotation. Use 
CenterOfRotationY to set the y coordinate of the center point, where 0 is the top, 1 
is the bottom, and 0.5 is the middle (and default). 
• For a y-axis rotation, use RotationZ to set the angle of rotation. Use 
CenterOfRotationZ to set the z coordinate of the center point, where 0 is the 
middle (and default), positive numbers are in front of the element, and negative 
numbers are behind it. 
In many cases, the rotation properties will be the only parts of the PlaneProjection that you’ll want 
to use. However, you can also shift the element in any direction. There are two ways to move it: 
• Use the GlobalOffsetX, GlobalOffsetY, and GlobalOffsetZ properties to move the 
element using screen coordinates, before the projection is applied.  
• Use the LocalOffsetX, LocalOffsetY, and LocalOffsetZ properties to move the 
element using its transformed properties, after the projection is applied. 
For example, consider the case where you haven’t rotated the element. In this case, the global and 
the local properties will have the same effect. Increasing GlobalOffsetX or LocalOffsetX shifts the 
element to the right. Now, consider the case where the element has been rotated around the y-axis using 
the RotationY property (shown in Figure 8-25). In this situation, increasing GlobalOffsetX shifts the 
rendered content to the right, exactly the same way it does when the element hasn’t been rotated. But 
increasing LocalOffsetX moves the content along the x-axis, which now points in a virtual 3-D direction. 
As a result, the content appears to move to the right and backward. 
www.it-ebooks.info
CHAPTER 8  SHAPES AND TRANSFORMS 
306 
Figure 8-25. Translation with the PlaneProjection 
These two details—rotation and translation—encompass everything the PlaneProjection does. 
Applying a Projection 
Projections works on virtually any Silverlight element, because every class that derives from UIElement 
includes the required Projection property. To add a perspective effect to an element, you create a 
PlaneProjection and use it to set the Projection property, either in code or in XAML markup. 
For example, here’s the PlaneProjection that rotates the first figure in Figure 8-24: 
<Border BorderBrush="SlateGray" CornerRadius="2" BorderThickness="4"> 
<Border.Projection> 
<PlaneProjection RotationY="45"></PlaneProjection> 
</Border.Projection> 
<Image Source="grandpiano.jpg"></Image> 
</Border> 
As with ordinary transforms, perspective transforms are performed after layout. Figure 8-24 
illustrates this fact by using a shaded border that occupies the original position of the transformed 
www.it-ebooks.info
CHAPTER 8  SHAPES AND TRANSFORMS 
307 
element. Even though the element now sticks out in new places, the bounds of the shaded background 
are used for layout calculations. As with all elements, if more than one element overlaps, the one 
declared last in the markup is placed on top. (Some layout controls offer more sophisticated layering, as 
the Canvas does with the ZIndex property discussed in Chapter 3.) 
To get a feeling for how the different PlaneProjection properties interact, it helps to play with a 
simple test application, like the one shown in Figure 8-26. Here, the user can rotate an element around 
its x-axis, y-axis, or z-axis (or any combination). In addition, the element can be displaced locally or 
globally along the x-axis using the LocalOffsetX and GlobalOffsetX properties described earlier. 
Figure 8-26. Rotating ordinary elements in 3-D 
Although you can use a projection on any element, it’s often useful to apply it to some sort of 
container, such as a layout panel or the Border element, as in this example. That way, you can place 
more elements inside. This example is particularly interesting because among the projected elements 
are interactive controls such as a button and text box. These controls continue to work in their standard 
ways, responding to mouse clicks, allowing focus and typing, and so on, even as you rotate the 
containing Border element. 
<Border BorderBrush="SlateGray" CornerRadius="2" BorderThickness="4" Padding="10"> 
<Border.Projection> 
<PlaneProjection x:Name="projection"></PlaneProjection> 
www.it-ebooks.info
CHAPTER 8  SHAPES AND TRANSFORMS 
308 
</Border.Projection> 
<StackPanel> 
<TextBlock>Type Here:</TextBlock> 
<TextBox></TextBox>                                 
<Button Margin="0,5" Content="OK"></Button> 
<Image Source="happyface.jpg" Stretch="None"></Image> 
</StackPanel>  
</Border> 
Although you can adjust the PlaneProjection object using code, this example uses the data-binding 
feature you learned about in Chapter 2. However, because the PlaneProjection isn’t an element, it can’t 
use binding expressions. Instead, you need to place the binding in the linked Slider controls and use a 
two-way binding to ensure that the new angles are passed backed to the projection as the user drags the 
tab. Here’s an example with the x-axis slider: 
<TextBlock Margin="5">RotationX</TextBlock> 
<Slider Grid.Column="1" Minimum="-180" Maximum="180"  
Value="{Binding RotationXMode=TwoWay, ElementName=projection}"></Slider> 
If you rotate an element far enough around the x-axis or y-axis (more than 90 degrees), you begin to 
see its back. Silverlight treats all elements as though they have transparent backing, which means your 
element’s content is reversed when you look at it from the rear. This is notably different from the 3-D 
support in WPF, which gives all shapes a blank (invisible) backing unless you explicitly place content 
there. If you flip interactive elements this way, they keep working, and they continue capturing all the 
standard mouse events. 
Exporting Clip Art 
In most cases, you won’t create Silverlight art by hand. Instead, you (or a graphic designer) will use a 
design tool to create vector art, and then export it to XAML. The exported XAML document you end up 
with is essentially a Canvas that contains a combination of shape elements. You can place that Canvas 
inside an existing Canvas to show your artwork. 
Although many drawing programs don’t have built-in support for XAML export, you still have many 
options for getting the graphics you need. The following sections outline the options you can use to get 
vector art out of virtually any application. 
Expression Design 
Expression Design, Microsoft’s illustration and graphic design program, has built-in XAML export. It can 
import a variety of vector-art file formats, including Adobe Illustrator (.ai) files, and it can export to 
XAML. 
When exporting to XAML, follow these steps: 
1. Choose File 
Export from the menu. 
2. In the Export dialog box, in the Save As Type list, choose XAML. Then, enter a 
file name, and click Save. The Export XAML window appears (see Figure 8-27), 
which shows you the image you’re exporting and a preview of the XAML 
content it will create (click the XAML tab). 
www.it-ebooks.info
CHAPTER 8  SHAPES AND TRANSFORMS 
309 
Figure 8-27. Creating a Silverlight-compatible XAML file 
3. In the Document Format group of settings, click Silverlight to be sure you’re 
creating a Silverlight-compatible XAML file. This ensures that XAML features 
that are supported in WPF but not in Silverlight aren’t used. 
 Note  Usually, the standard XAML export option (Canvas) works with Silverlight applications with minimal 
changes, such as manually removing a few unsupported attributes. However, the Resource Dictionary export 
option creates XAML files that don’t work with Silverlight. That’s because this option stores the graphic in a 
collection of DrawingBrush resources instead of a Canvas. This makes it easier to efficiently reuse the drawing in 
WPF, but it’s useless in Silverlight, because Silverlight doesn’t include the Drawing or DrawingBrush class. 
4. Click Export to save the file. 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested