c# .net pdf reader : Add and delete pages in pdf SDK application API .net html windows sharepoint Pro_Silverlight_5_in_CSharp_4th_edition57-part123

CHAPTER 15  CONTROL TEMPLATES 
565 
<VisualState x:Name="AfterLoaded"></VisualState> 
<VisualState x:Name="BeforeUnloaded"> 
<Storyboard> 
<DoubleAnimation Storyboard.TargetProperty="(UIElement.Opacity)" 
Storyboard.TargetName="grid" To="0"> 
</DoubleAnimation> 
</Storyboard> 
</VisualState> 
</VisualStateGroup> 
</VisualStateManager.VisualStateGroups> 
<ContentPresenter x:Name="contentPresenter" Margin="{TemplateBinding Padding}" 
HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"> 
</ContentPresenter> 
</Grid> 
</ControlTemplate> 
To actually apply this style, you need to wrap it in a type-specific style that affects all ListBoxItem 
controls in the page: 
<UserControl.Resources> 
<Style TargetType="ListBoxItem"> 
<Setter Property="Template"> 
<Setter.Value> 
<ControlTemplate> 
... 
</ControlTemplate> 
</Setter.Value> 
</Setter> 
</Style> 
</UserControl.Resources> 
This technique is necessary because the ListBox doesn’t provide any property that lets you set the 
template of its constituent items. Instead, you must create an element-specific style that applies to all 
ListBoxItem elements. 
Figure 15-8 shows the transition that automatically fades in a new item (which is added to the 
ListBox control with the usual code). 
www.it-ebooks.info
Add and delete pages in pdf - 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 remove pages from pdf; add pages to pdf
Add and delete pages in pdf - 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 number pdf file; add a page to a pdf file
CHAPTER 15  CONTROL TEMPLATES 
566 
Figure 15-8. Fading in a new item 
There’s an obvious drawback to adding animated effects in control templates. Namely, it forces you 
to define the entire template along with the transitions, regardless of whether you actually want to 
change any of the elements in that template. For developers using Expression Blend, this is a minor 
concern—in fact, Expression Blend will insert the standard template for you automatically. But for 
coders who prefer to be up close and intimate with their XAML, it’s another code-cluttering detail. 
A simple fade-in item, as shown in the previous example, is interesting but not stunning. To get 
really adventurous effects, you need to combine the layout transitions with the FluidMoveBehavior 
described in Chapter 14. This approach allows you to animate items into (or out of) existence, while also 
animating the way the other items slide out of the way. 
FLUID LAYOUT AND EXPRESSION BLEND 
The creators of Expression Blend have taken the transition feature even further. They’ve developed an 
enhanced VisualStateManager (called ExtendedVisualStateManager) that provides more powerful transition 
capabilities. For example, the ExtendedVisualStateManager can perform animations using a pixel shader. 
The ExtendedVisualStateManager can also create transitions between states that wouldn’t ordinarily be 
supported, which is a feature commonly called fluid layout. 
As you learned earlier, ordinary transitions can animate between different Double, Point, or Color values. 
But the ExtendedVisualStateManager includes a “morphing” engine that simulates transitions for a much 
broader range of properties. For example, it can create a fade transition if you change an element’s 
www.it-ebooks.info
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
In order to run the sample code, the following steps would be necessary. Add necessary references: How to VB.NET: Delete Consecutive Pages from PDF.
adding page numbers to pdf in reader; adding pages to a pdf document
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
XDoc.PDF enables you to delete PDF page(s) with customized options, including a single page, a series of pages, and random pages to be Add necessary references
add page number to pdf in preview; add and delete pages in pdf
CHAPTER 15  CONTROL TEMPLATES 
567 
Visibility property, or it can create a movement animation if you change an element’s position in a Grid. 
The cost of this feature is tangled
automatically) and is sometimes difficult to work with, 
Although these pieces are still evolving, the ultimate goal is clear. The creators of Expression Blend want to 
ut requiring them to create 
all the animations and write all the markup. To learn more about their work and try the 
ExtendedVisualStateManager for yourself, see the post on the Expression Blend team blog at 
http://tinyurl.com/6jv6z73
Creating Templates for Custom Controls 
As you’ve seen, every Silverlight control is designed to be lookless, which means you can completely 
redefine its visuals (the look). What doesn’t change is the control’s behavior, which is hardwired into the 
control class. When you choose to use a control like Button, you choose it because you want button-like 
behavior—an element that presents content and can be clicked to trigger an action. 
In some cases, you want different behavior, which means you need to create a custom control. As 
with all controls, your custom control will be lookless. Although it will provide a default control 
template, it won’t force you to use that template. Instead, it will allow the control consumer to replace 
the default template with a fine-tuned custom template. 
In the rest of this chapter, you’ll learn how you can create a template-driven custom control. This 
custom control will let control consumers supply different visuals, just like the standard Silverlight 
controls you’ve used up to this point. 
CONTROL CUSTOMIZATION 
ms. That’s 
because Silverlight provides so many other avenues for customization, such as the following: 
• Content controls: Any control that derives from ContentControl supports nested 
content. Using content controls, you can quickly create compound controls that 
aggregate other elements. (For example, you can transform a button into an image 
button or a list box into an image list.) 
• Styles and control templates: 
You can use a style to painlessly reuse a 
combination of control properties. This means there’s no reason to derive a 
further, giving you the ability to revamp every aspect of a control’s visual 
appearance. 
• Control templates: All Silverlight controls are lookless, which means they have 
hardwired functionality, but their appearance is defined separately through the 
revamp basic controls such as buttons, check boxes, radio buttons, and even 
windows. 
www.it-ebooks.info
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
C# Page: Insert PDF pages; C# Page: Delete PDF pages; C# Read: PDF Text Extract; C# Read: PDF Image Extract; C# Write: Insert text into PDF; C# Write: Add Image
add page numbers to pdf document; add pdf pages together
C# PDF insert image Library: insert images into PDF in C#.net, ASP
C#.NET PDF SDK - Add Image to PDF Page in C#.NET. How to Insert & Add Image, Picture or Logo on PDF Page Using C#.NET. Add Image to PDF Page Using C#.NET.
add page number to pdf; add and remove pages from pdf file online
CHAPTER 15  CONTROL TEMPLATES 
568 
• Data templates: Silverlight’s list controls support data templates, which let you 
create a rich list representation of some type of data object. Using the right data 
editable controls, all in a layout container of your choosing. You’ll learn how in 
Chapter 20. 
If possible, you should pursue these avenues before you decide to create a custom control or another type 
of custom element. These solutions are simpler, easier to implement, and often easier to reuse. 
When should you create a custom element? Custom elements aren’t the best choice when you want to 
fine-tune an elemg 
functionality or design a control that has its own distinct set of properties, methods, and events. 
Planning the FlipPanel Control 
The following example develops a straightforward but useful control called FlipPanel. The basic idea 
behind the FlipPanel is that it provides two surfaces to host content, but only one is visible at a time. To 
see the other content, you “flip” between the sides. You can customize the flipping effect through the 
control template, but the default effect use a 3-D projection that looks like the panel is a sheet of paper 
being flipped around to reveal different content on its back (see Figure 15-9). Depending on your 
application, you could use the FlipPanel to combine a data-entry form with some helpful 
documentation, to provide a simple or a more complex view on the same data, or to fuse together a 
question and an answer in a trivia game. 
Figure 15-9. Flipping the FlipPanel 
You can perform the flipping programmatically (by setting a property named IsFlipped), or the user 
can flip the panel using a convenient button (unless the control consumer removes it from the 
template). 
www.it-ebooks.info
VB.NET PDF Password Library: add, remove, edit PDF file password
passwordSetting.IsAssemble = True ' Add password to PDF file. These two demos will help you to delete password for an encrypted PDF file.
add document to pdf pages; add pages to pdf reader
C# PDF Sticky Note Library: add, delete, update PDF note in C#.net
C#.NET PDF SDK - Add Sticky Note to PDF Page in C#.NET. Able to add notes to PDF using C# source code in Visual Studio .NET framework.
adding page numbers pdf file; add page to a pdf
CHAPTER 15  CONTROL TEMPLATES 
569 
Building the FlipPanel is refreshingly easy. You need to create a custom panel that adds an extra 
content region for the hidden surface, along with the animations that switch between the two sides. 
Ideally, you’ll create a carefully structured control template that allows others to restyle the custom 
FlipPanel with different visuals. 
Creating the Solution 
Although you can develop a custom Silverlight control in the same assembly that holds your application, 
it’s better to place it in a separate assembly. This approach allows you to refine, revise, and debug your 
control without affecting the application. It also gives you the option of using the same control with 
different Silverlight applications. 
To add a Silverlight class library project to an existing solution that already holds a Silverlight 
application, choose File 
Add 
New Project. Then, choose the Silverlight Class Library project, choose 
the name and location, and click OK. Now, you’re ready to begin designing your custom control. 
Starting the FlipPanel Class 
Stripped down to its bare bones, the FlipPanel is surprisingly simple. It consists of two content regions 
that the user can fill with a single element (most likely, a layout container that contains an assortment of 
elements). Technically, that means the FlipPanel isn’t a true panel, because it doesn’t use layout logic to 
organize a group of child elements. However, this isn’t likely to pose a problem, because the structure of 
the FlipPanel is clear and intuitive. The FlipPanel also includes a flip button that lets the user switch 
between the two different content regions. 
Although you can create a custom control by deriving from a control class such as ContentControl 
or Panel, the FlipPanel derives directly from the base Control class. If you don’t need the functionality of 
a specialized control class, this is the best starting point. You shouldn’t derive from the simpler 
FrameworkElement class unless you want to create an element without the standard control and 
template infrastructure: 
public class FlipPanel : Control 
{...} 
The first order of business is to create the properties for the FlipPanel. As with almost all the 
properties in a Silverlight element, you should use dependency properties. And as you learned in 
Chapter 4, defining a dependency property is a two-part process. First, you need a static definition that 
records some metadata about the property: its name, its type, the type of the containing class, and an 
optional callback that will be triggered when the property changes. 
Here’s how FlipPanel defines the FrontContent property that holds the element that’s displayed on 
the front surface: 
public static readonly DependencyProperty FrontContentProperty = 
DependencyProperty.Register("FrontContent"typeof(object), 
typeof(FlipPanel), null); 
Next, you need to add a traditional .NET property procedure that calls the base GetValue() and 
SetValue() methods to change the dependency property. Here’s the property procedure implementation 
for the FrontContent property: 
public object FrontContent 
get 
www.it-ebooks.info
VB.NET PDF insert image library: insert images into PDF in vb.net
with this sample VB.NET code to add an image to textMgr.SelectChar(page, cursor) ' Delete a selected As String = Program.RootPath + "\\" output.pdf" doc.Save
adding page numbers pdf; add page numbers to a pdf document
C# PDF Password Library: add, remove, edit PDF file password in C#
passwordSetting.IsAssemble = true; // Add password to PDF file. These C# demos will help you to delete password for an encrypted PDF file.
add page to pdf reader; add page number to pdf hyperlink
CHAPTER 15  CONTROL TEMPLATES 
570 
return base.GetValue(FrontContentProperty); 
set 
base.SetValue(FrontContentProperty, value); 
The BackContent property is virtually identical: 
public static readonly DependencyProperty BackContentProperty =  
DependencyProperty.Register("BackContent"typeof(object),  
typeof(FlipPanel), null); 
public object BackContent 
get 
return base.GetValue(BackContentProperty); 
set 
base.SetValue(BackContentProperty, value); 
You need to add just one more essential property: IsFlipped. This Boolean property keeps track of 
the current state of the FlipPanel (forward-facing or backward-facing) and lets the control consumer flip 
it programmatically: 
public static readonly DependencyProperty IsFlippedProperty = 
DependencyProperty.Register("IsFlipped"typeof(bool), typeof(FlipPanel), null); 
public bool IsFlipped 
get 
return (bool)base.GetValue(IsFlippedProperty); 
set 
base.SetValue(IsFlippedProperty, value); 
ChangeVisualState(true); 
Keen eyes will notice that the IsFlipped property setter calls a custom method called 
ChangeVisualState(). This method makes sure the display is updated to match the current flip state 
(forward-facing or backward-facing). You’ll consider the code that takes care of this task a bit later. 
The FlipPanel doesn’t need many more properties, because it inherits virtually everything it needs 
from the Control class. One exception is the CornerRadius property. Although the Control class includes 
BorderBrush and BorderThickness properties, which you can use to draw a border around the FlipPanel, 
it lacks the CornerRadius property for rounding square edges into a gentler curve, as the Border element 
www.it-ebooks.info
CHAPTER 15  CONTROL TEMPLATES 
571 
does. Implementing the same effect in the FlipPanel is easy, provided you add the CornerRadius 
property and use it to configure a Border element in the FlipPanel’s default control template: 
public static readonly DependencyProperty CornerRadiusProperty = 
DependencyProperty.Register("CornerRadius"typeof(CornerRadius), 
typeof(FlipPanel), null); 
public CornerRadius CornerRadius 
get { return (CornerRadius)GetValue(CornerRadiusProperty); } 
set { SetValue(CornerRadiusProperty, value); } 
Adding the Default Style with Generic.xaml 
Custom controls suffer from a chicken-and-egg dilemma. You can’t write the code in the control class 
without thinking about the type of control template you’ll use. But you can’t create the control template 
until you know how your control works. 
The solution is to build both the control class and the default control template at the same time. You 
can place the control class in any code file template in your Silverlight class library. The control template 
must be placed in a file named generic.xaml. If your class library contains multiple controls, all of their 
default templates must be placed in the same generic.xaml file. To add it, follow these steps: 
1. Right-click the class library project in the Solution Explorer, and choose Add  
New Folder. 
2. Name the new folder Themes. 
3. Right-click the Themes folder, and choose Add  New Item. 
4. In the Add New Item dialog box, pick the XML file template, enter the name 
generic.xaml, and click Add. 
The generic.xaml file holds a resource dictionary with styles for your custom controls. You must add 
one style for each custom control. And as you’ve probably guessed, the style must set the Template 
property of the corresponding control to apply the default control template. 
 Note  You place the generic.x
Windows theme settings into account. Silverlight keeps the Themes folder, even though it doesn’t have a similar 
mechanism. 
For example, consider the Silverlight project and class library combination shown in Figure 15-10. 
The CustomControl project is the class library with the custom control, and the 
CustomControlConsumer project is the Silverlight application that uses it. 
www.it-ebooks.info
CHAPTER 15  CONTROL TEMPLATES 
572 
Figure 15-10. A Silverlight application and class library 
In the generic.xaml file, you need to declare a resource dictionary. You then need to map the project 
namespace to an XML namespace prefix, so you can access your custom control in your markup (as you 
first saw in Chapter 2). In this example, the project namespace is FlipPanelControl, and the assembly is 
named FlipPanelControl.dll (as you would expect based on the project name): 
<ResourceDictionary 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns:local="clr-namespace:FlipPanelControl;assembly=FlipPanelControl"> 
... 
</ResourceDictionary> 
Notice that when you map the control namespace, you need to include both the project namespace 
and the project assembly name, which isn’t the case when you use custom classes inside a Silverlight 
application. That’s because the custom control will be used in other applications, and if you don’t 
specify an assembly, Silverlight will assume that the application assembly is the one you want. 
Inside the resource dictionary, you can define a style for your control. Here’s an example: 
<Style TargetType="local:FlipPanel"> 
<Setter Property="Template"> 
<Setter.Value> 
<ControlTemplate TargetType="local:FlipPanel"> 
... 
</ControlTemplate> 
</Setter.Value> 
</Setter> 
</Style> 
www.it-ebooks.info
CHAPTER 15  CONTROL TEMPLATES 
573 
There’s one last detail. To tell your control to pick up the default style from the generic.xaml file, you 
need to set the control’s DefaultStyleKey property in the constructor: 
public FlipPanel() 
DefaultStyleKey = typeof(FlipPanel); 
DefaultStyleKey indicates the type that is used to look up the style. In this case, the style is defined 
with the TargetType of FlipPanel, so the DefaultStyleKey must also use the FlipPanel type. In most cases, 
this is the pattern you’ll follow. The only exception is when you’re deriving a more specialized control 
from an existing control class. In this case, you have the option of keeping the original constructor logic 
and inheriting the standard style from the base class. For example, if you create a customized Button-
derived class with additional functionality, you can use the standard button style and save the trouble of 
creating a new style. On the other hand, if you do want a different style and a different default control 
template, you need to add the style using the TargetType of the new class and write a new constructor 
that sets the DefaultStyleKey property accordingly. 
Choosing Parts and States 
Now that you have the basic structure in place, you’re ready to identify the parts and states that you’ll 
use in the control template. 
Clearly, the FlipPanel requires two states: 
• Normal: This storyboard ensures that only the front content is visible. The back 
content is flipped, faded, or otherwise shuffled out of view. 
• Flipped: This storyboard ensures that only the back content is visible. The front 
content is animated out of the way. 
In addition, you need two parts: 
• FlipButton: This is the button that, when clicked, changes the view from the front 
to the back (or vice versa). The FlipPanel provides this service by handling this 
button’s events. 
• FlipButtonAlternate: This is an optional element that works in the same way as the 
FlipButton. Its inclusion allows the control consumer to use two different 
approaches in a custom control template. One option is to use a single flip button 
outside the flippable content region. The other option is to place a separate flip 
button on both sides of the panel, in the flippable region. 
You could also add parts for the front content and back content regions. However, the FlipPanel 
control doesn’t need to manipulate these regions directly, as long as the template includes an animation 
that hides or shows them at the appropriate time. (Another option is to define these parts so you can 
explicitly change their visibility in code. That way, the panel can still change between the front and back 
content region even if no animations are defined, by hiding one section and showing the other. For 
simplicity’s sake, the FlipPanel doesn’t go to these lengths.) 
To advertise the fact that the FlipPanel uses these parts and states, you should apply the 
TemplatePart attribute to your control class, as shown here: 
[TemplateVisualState(Name = "Normal", GroupName="ViewStates")] 
[TemplateVisualState(Name = "Flipped", GroupName = "ViewStates")] 
[TemplatePart(Name = "FlipButton", Type = typeof(ToggleButton))] 
www.it-ebooks.info
CHAPTER 15  CONTROL TEMPLATES 
574 
[TemplatePart(Name = "FlipButtonAlternate", Type = typeof(ToggleButton))] 
public class FlipPanel Control 
{ ... } 
The FlipButton and FlipButtonAlternate parts are restricted—each one can only be a ToggleButton 
or an instance of a ToggleButton-derived class. (As you may remember from Chapter 5, the 
ToggleButton is a clickable button that can be in one of two states. In the case of the FlipPanel control, 
the ToggleButton states correspond to a normal front-forward view or a flipped back-forward view.) 
 Tip  To ensure the best, most flexible template support, use the least-specialized element type that you can. For 
example, it’s better to use FrameworkElement than ContentControl, unless you need some property or behavior 
that ContentControl provides. 
NAMING CONVENTIONS FOR STATES, PARTS, AND STATE GROUPS 
The naming conventions for parts and states are fairly straightforward. When you’re naming a part or state, 
don’t include a prefix or suffix—for example, use Flipped and FlipButton rather than FlippedState and 
FlipButtonPart. The exception is state groups, which should always end with the word States, as in 
ViewStates. 
It also helps to look at similar controls in the Silverlight framework and use the same names. This is 
especially true if you need to use the states that are commonly defined in the CommonStates group 
(Normal, MouseOver, Pressed, and Disabled) or the FocusStates group (Focused and Unfocused). 
Remember, the control consumer must use the exact name. If you create a button-like control that breaks 
with convention and uses a Clicked state instead of a Pressed state and the control consumer inadvertently 
defines a Pressed state, its animation will be quietly ignored. 
Starting the Default Control Template 
Now, you can slot these pieces into the default control template. The root element is a two-row Grid that 
holds the content area (in the top row) and the flip button (in the bottom row). The content area is filled 
with two overlapping Border elements, representing the front and back content, but only one of the two 
is ever shown at a time. 
To fill in the front and back content regions, the FlipPanel uses the ContentPresenter. This 
technique is virtually the same as in the custom button example, except you need two ContentPresenter 
elements, one for each side of the FlipPanel. The FlipPanel also includes a separate Border element 
wrapping each ContentPresenter. This lets the control consumer outline the flippable content region by 
setting a few straightforward properties on the FlipPanel (BorderBrush, BorderThickness, Background, 
and CornerRadius), rather than being forced to add a border by hand. 
Here’s the basic skeleton for the default control template: 
<ControlTemplate TargetType="local:FlipPanel"> 
<Grid> 
<VisualStateManager.VisualStateGroups> 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested