c# itextsharp pdfreader not opened with owner password : Add page numbers to pdf files software application dll winforms html wpf web forms Pro_Silverlight_5_in_CSharp_4th_edition35-part99

The code for starting the printout is virtually identical. The only difference is that you need a 
member field to keep track of the position in the list as the printout moves from one page to the next: 
// Keep track of the position in the list. 
private int listPrintIndex; 
private void cmdPrintList_Click(object sender, RoutedEventArgs e) 
// Reset the position, in case a previous printout has changed it. 
listPrintIndex = 0; 
PrintDocument document = new PrintDocument(); 
document.PrintPage += documentList_PrintPage; 
document.Print("List Document");  
The printing code uses a Canvas for the print visual. This is a common design choice, because the 
Canvas can hold any combination of elements. It allows you to place elements using fixed coordinates, 
and it doesn’t introduce any additional layout considerations. 
// Add some extra margin space. 
private int extraMargin = 50; 
private void documentList_PrintPage(object sender, PrintPageEventArgs e) 
// Use a Canvas for the printing surface. 
Canvas printSurface = new Canvas(); 
e.PageVisual = printSurface; 
Note that it’s not necessary to explicitly size the Canvas to the print area, because the Canvas 
doesn’t clip its content unless you set the Clip property. (In other words, content is always rendered, 
even when it’s positioned outside the bounds of its Canvas container.) 
Once the Canvas has been created, the code begins to loop through the collection of data. It creates 
a single TextBlock for each printed line: 
// Find the starting coordinate. 
double topPosition = e.PageMargins.Top + extraMargin; 
// Begin looping through the list. 
while (listPrintIndex < lst.Items.Count) 
// Create a TextBlock for each line, with a 30-pixel font. 
TextBlock txt = new TextBlock(); 
txt.FontSize = 30;                 
txt.Text = lst.Items[listPrintIndex].ToString(); 
Before the TextBlock can be placed in the Canvas, you need to be sure that it fits on the page. The 
code calculates this detail by taking into account the total available height, the current position, the 
rendered size of the TextBlock, and the page margins. If the TextBlock doesn’t fit, the code stops printing 
the page and sets PrintPageEventArgs.HasMorePages to true, which requests a new page. 
Add page numbers to 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
add document to pdf pages; add page numbers to pdf preview
Add page numbers to 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
add page pdf reader; add page number to pdf online
// If the new line doesn't fit, stop printing this page, 
// but request another page. 
double measuredHeight = txt.ActualHeight; 
if (measuredHeight > (e.PrintableArea.Height - topPosition - extraMargin)) 
e.HasMorePages = true
When HasMorePages is set to true and the method ends, PrintDocument object will fire its 
PrintPage event again, immediately. Now the code will create a new Canvas for the new page and begin 
placing elements on it. 
However, if the current TextBlock does fit, the code simply adds it to the Canvas, moves to the next 
line in the list, and shifts the coordinates down to the next row on the printed page: 
// Place the TextBlock on the Canvas. 
txt.SetValue(Canvas.TopProperty, topPosition); 
txt.SetValue(Canvas.LeftProperty, e.PageMargins.Left + extraMargin); 
// Move to the next line. 
topPosition = topPosition + measuredHeight; 
When the code reaches the last item of the list, the loop ends. Now the complete, multiple-page 
printout has finished. 
// The printing code has reached the end of the list. 
// No more pages are needed. 
e.HasMorePages = false
Figure 9-14 shows the complete printout spaced out over three pages. 
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 to pdf acrobat; add page 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.
adding page numbers to a pdf document; add page numbers pdf
Figure 9-14. Printing a list 
Although this example is fairly easy, you can see how the printing logic will grow more intricate if 
you need to print mixed content (for example, pictures and text) or multiple lines of wrapped text. 
 Note  If you set the TextBlock.TextWrapping property to Wrap and you give it a size that’s large enough to fit 
multiple lines of text, the TextBlock will automatically wrap your printed text. However, life isn’t as easy if you need 
he TextBlock runs out of space on 
any given page. The only alternative is to print your documents one word at a time so that you can determine the 
exact amount of text that fits on a page. Sadly, this technique is slow and tedious. It shows the limits of 
Silverlight’s simplified printing model. 
Bitmap and Vector Printing 
Silverlight has essentially two different printing pipelines: 
• Bitmap printing: This is the original printing system, which was introduced in 
Silverlight 4. In bitmap mode, Silverlight turns each page into a picture (using the 
WriteableBitmap class you just met). Bitmap-based printing has two significant 
advantages: it can handle any content, and it works on any printer. The 
disadvantage is that it needs to transmit a large amount of data to the printer, 
which can be slow. 
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
adding page numbers to pdf in preview; add pages to pdf reader
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 page number to pdf; add a page to a pdf in reader
• Vector printing: This alternative printing system was introduced in Silverlight 5. In 
vector mode, Silverlight sends higher-level printing instructions that tell the 
printer to render specific shapes, textures, and text. This guarantees better 
performance than in bitmap mode. However, there are two significant caveats. 
First, your printer and printer driver must support PostScript. Second, certain 
bitmap effects won’t translate to PostScript printing—most notably, layers of 
partially transparent content, perspective transforms, and 3-D scenes. 
At first glance, this seems like a very awkward situation. After all, it’s never easy to choose between a 
technology that’s better (in this case, vector printing) and one that’s better-supported (bitmap printing). 
Fortunately, Silverlight uses a fallback system that lets you take advantage of both. With this fallback 
system, you’ll get vector printing when possible but bitmap printing when the printer driver doesn’t 
support PostScript or when the type of content you’re printing makes it impossible. 
Here’s how the fallback system works. If you don’t take any additional steps, your printouts will use 
vector printing automatically, if possible. But if the printer driver lacks PostScript support or if the type 
of content you’re printing can’t be properly converted to PostScript output, Silverlight will revert to the 
older bitmap-based printing model. And if you want to force Silverlight to use bitmap-based printing, 
you can do that too. The trick is to call the PrintDocument.PrintBitmap() method rather than 
It can be difficult to tell which printing pipeline Silverlight uses when you call Print(), because 
Silverlight doesn’t make this information available to your application. But one easy way for you to tell is 
to look at the size of print job. To run this test, turn off your printer, and print the same document two 
ways, both as a forced bitmap and as an attempted vector image. To do that, you’ll need two separate 
event handlers (because you can’t show the Print dialog box twice in one event without triggering a 
security error). Here’s the sort of code you can use: 
private void cmdPrintBitmap_Click(object sender, RoutedEventArgs e) 
PrintDocument document = new PrintDocument(); 
document.PrintPage += document_PrintPage; 
// The PrintBitmap() method always uses bitmap printing. 
document.PrintBitmap("My Document - Bitmap Version"); 
private void cmdPrintVector_Click(object sender, RoutedEventArgs e) 
PrintDocument document = new PrintDocument(); 
document.PrintPage += document_PrintPage; 
// document and printer driver. 
document.Print("My Document"); 
Once you run this code, view the list of print jobs for your printer. You can do this by finding (and 
clicking) the system tray icon for your printer. Or, you can choose Devices and Printers from the Start 
menu and double-click the appropriate printer there. Either way, you’ll see a window like the one shown 
in Figure 9-15. 
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 pdf pages to word; add page to pdf reader
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 page number to pdf reader; add multi page pdf to word document
Figure 9-15. Comparing a vector and a bitmap print job 
Here, it’s clear that Silverlight is using vector printing. The bitmap version of the document (which 
is nothing more than a few lines of text on a single page) weighs in at a bloated 119 MB. By comparison, 
the PostScript version is hundreds of times smaller, requiring a paltry 309 KB. 
 Note  PostScript is a widely supported standard but far from universal. Although you’re likely to find it on big 
office printers and Mac computers, consumer-level printers on the Windows operating system commonly lack this 
feature. When you run the test described previously on them, you’ll see two identical, very large print jobs. 
As explained earlier, non-PostScript printers aren’t the only obstacle you can encounter. Silverlight 
will also switch to bitmap printing if your content includes certain effects, such as transparency. 
However, you might decide that the benefits of vector printing outweigh the value of your effect. In this 
situation, Silverlight allows you to override its normal decision-making process and force it to use vector 
printing whenever the printer driver supports it, even if some effects won’t be rendered. To do this, you 
must create an instance of the PrinterFallbackSettings class, set its ForceVector property to true, and 
then pass it as a second parameter to the Print() method. Here’s an example: 
PrintDocument document = new PrintDocument(); 
document.PrintPage += document_PrintPage; 
PrinterFallbackSettings fallback = new PrinterFallbackSettings(); 
fallback.ForceVector = true
document.Print("My Document", fallback); 
Now, unsupported details will be ignored on PostScript printers—for example, there won’t be any 
transparency where you expect it, perspective transforms won’t apply, and so on. However, nothing will 
change for non-PostScript printers, which will continue using bitmap printing with all the effects. 
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 a page to a pdf online; add page numbers to a pdf document
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
add a page to a pdf document; add page numbers to pdf document
 Note  Silverlight also boasts one more helpful improvement. Bitmap printing now uses compressed bitmaps, if 
possible (which means only on PostScript printer drivers). This makes printing faster in the scenario where your 
printer supports PostScript, but vector printing isn’t possible because your content uses an unsupported drawing 
feature. In other words, bitmap printing isn’t as slow and bloated on PostScript printers as it is on non-PostScript 
There’s one more dial to tweak. You can use the OpacityThreshold property in conjunction with the 
ForceVector property to specify how much transparency you’re willing to ignore.  
By default, the OpacityThreshold is 0, which means that Silverlight rounds up all Opacity values, 
making every element fully opaque when you use the PrinterFallbackSettings object. But if you change 
the OpacityThreshold to something higher, Silverlight becomes more discriminating. For example, 
consider this code, which sets the OpacityThreshold to 0.5: 
PrinterFallbackSettings fallback = new PrinterFallbackSettings(); 
fallback.ForceVector = true
fallback.OpacityThreshold = 0.5; 
document.Print("My Document", fallback); 
Now elements that have an Opacity of 0.5 or greater are made fully opaque. However, elements that 
have a lower Opacity value are made fully transparent, and not rendered at all. Of course, this all only 
applies if the printer driver supports vector printing. 
If you’ve created an elevated-trust application (see Chapter 18), you can send a document to the default 
printer without showing the Print dialog box. 
To do this, you need to use an overload of the Print() method that takes three arguments: the print 
document name, a PrinterFallba
print feature. Here’s what your code would look like: 
document.Print("My Document"new PrinterFallbackSettings(), true); 
Note that even though this overload of the Print() method requires the PrinterFallbackSettings object, you 
don’t actually need to use it to do anything. If you don’t set the ForceVector property, you’ll get the default 
behavior—vector printing when possible and bitmap printing when the driver or content requires it. 
Creating a Print Preview 
Although Silverlight doesn’t have a built-in print preview, you can build one of your own fairly easily. 
The basic technique is to write your root element to a WriteableBitmap (as demonstrated earlier this 
chapter). You can then show that WriteableBitmap on-screen—for example, in a ScrollViewer inside a 
pop-up ChildWindow. Figure 9-16 shows an example. 
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 pages to pdf file; add contents page to pdf
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 page to pdf in preview; add pages to pdf document
Figure 9-16. A simple print preview 
The first step to create an example like this is to refactor your printing code so that you can call it as 
part of a print operation or to create a visual to use in a preview. 
Consider the previous example, which did the bulk of its work in an event handler named 
documentList_PrintPage(). To modify this example so it can more easily support a print preview feature, 
you first separate the code that generates the visuals into a separate method: 
private bool GeneratePage(Canvas printSurface, 
Thickness pageMargins, Size pageSize) 
{ ... } 
Here, the GeneratePage() method accepts the three pieces of information it needs as arguments: the 
Canvas that acts as the root visual for the page, a Thickness object that represents the page margins, and 
a Size object that represents the page size. The code inside doesn’t need to directly interface with the 
printing system (through the PrintPageEventArgs object). Instead, it simply adds elements to the Canvas 
until the page is full. It then returns true if a new page is needed or false if the printout is complete. (To 
see the full code, refer to the downloadable examples for this chapter. You’ll find that the code in the 
GeneratePage() method is virtually identical to the original example—it’s simply been transplanted from 
the documentList_PrintPage() event handler.) 
And here’s the revised documentList_PrintPage() event handler that uses the GeneratePage() 
private void documentList_PrintPage(object sender, PrintPageEventArgs e) 
// Create the printing surface. 
Canvas printSurface = new Canvas(); 
e.PageVisual = printSurface; 
// File the page and determine if a new page is needed. 
With this rearrangement, it’s easy enough to add a print preview feature. Here’s one that creates a 
new Canvas to represent the printed page and then uses that Canvas to create a WriteableBitmap. 
Finally, the WriteableBitmap is passed to a custom ChildWindow class (named PrintPreview), like the 
ones you learned to create in Chapter 7. 
private void cmdPreviewPrintList_Click(object sender, RoutedEventArgs e) 
listPrintIndex = 0; 
Canvas printSurface = new Canvas(); 
// so we hard-code a typical page size. 
int width = 816; 
int height = 1056; 
printSurface.Width = width; 
printSurface.Height = height; 
GeneratePage(printSurface, new Thickness(0), new Size(width, height));  
// Wrap the Canvas in a WriteableBitmap. 
WriteableBitmap printPreviewBitmap = new WriteableBitmap(printSurface, null); 
// Pass the bitmap to the PrintPreview window. 
PrintPreview preview = new PrintPreview(printPreviewBitmap);             
The PrintPreview window contains an Image wrapped in a ScrollViewer: 
<ScrollViewer x:Name="scrollContainer"> 
<Image x:Name="imgPreview" VerticalAlignment="Top" 
When it first loads, it puts the WriteableBitmap into the Image element. It also stores the original 
dimensions of the bitmap to facilitate zooming with the sider. 
private Point originalSize = new Point(); 
public PrintPreview(WriteableBitmap printPreviewBitmap) 
imgPreview.Source = printPreviewBitmap; 
imgPreview.Height = printPreviewBitmap.PixelHeight; 
imgPreview.Width = printPreviewBitmap.PixelWidth; 
originalSize.X = imgPreview.Width; 
originalSize.Y = imgPreview.Height; 
When the slider is changed, the size of the Image is adjusted accordingly: 
private void sliderZoom_ValueChanged(object sender, 
RoutedPropertyChangedEventArgs<double> e) 
imgPreview.Height = originalSize.Y * sliderZoom.Value; 
imgPreview.Width = originalSize.X * sliderZoom.Value; 
As written, this code generates only the first page of the printout. However, you could develop a 
more advanced example that allows the user to step from one page to another in the preview. 
The Last Word 
In this chapter, you delved deeper into Silverlight’s 2-D drawing model. This is important, because 
understanding the plumbing behind 2-D graphics makes it far easier for you to manipulate them. 
For example, you can alter a standard 2-D graphic by modifying the brushes used to paint various 
shapes, altering the opacity, and using pixel shader effects. For still more impressive results, you can 
combine these techniques with Silverlight’s animation features. For example, it’s easy to fade a layer of 
shapes into existence using DrawingGroup.Opacity, or create a swirling dissolve effect by animating a 
custom pixel shader. You’ll see examples of techniques like these in the next chapter. 
At the same time, you also learned about lower-level approaches to generating and modifying graphics. 
You saw how you could change images on the pixel level with pixel shaders and the WriteableBitmap. 
Finally, you considered how Silverlight repurposes its bitmap rendering engine to provide a universally 
supported printing feature. 
C H A P T E R  10 
Animation Basics 
Animation allows you to create truly dynamic user interfaces. It’s often used to apply effects—for 
example, icons that grow when you move over them, logos that spin, text that scrolls into view, and so 
on. Sometimes, these effects seem like excessive glitz. But used properly, animations can enhance an 
application in a number of ways. They can make an application seem more responsive, natural, and 
intuitive. (For example, a button that slides in when you click it feels like a real, physical button—not just 
another gray rectangle.) Animations can also draw attention to important elements and guide the user 
through transitions to new content. (For example, an application could advertise new content with a 
twinkling, blinking, or pulsing icon.) 
Animations are a core part of the Silverlight model. That means you don’t need to use timers and 
event-handling code to put them into action. Instead, you can create and configure them declaratively, 
using XAML markup. Animations also integrate themselves seamlessly into ordinary Silverlight pages. 
For example, if you animate a button so it drifts around the page, the button still behaves like a button. It 
can be styled, it can receive focus, and it can be clicked to fire off the typical event-handling code. 
In this chapter, you’ll take your first look at the set of animation classes that Silverlight provides. 
You’ll see how to construct them with XAML and control their playback with code. You’ll also learn 
about the animation easing tool that lets you create more natural, lifelike animations, and you’ll learn 
about the hardware acceleration feature that can boost animation performance. 
 What’s New  Silverlight 5 adds a small but significant improvement to the way animations are rendered. If 
you’re using bitmap caching, you can offload animation work to a separate thread. This ensures that your 
animation keeps running smoothly, even if the user interface thread is tied up with other work. You’ll learn more in 
the section “Independent Animations.” 
Understanding Silverlight Animation 
Often, an animation is thought of as a series of frames. To perform the animation, these frames are 
shown one after the other, like a stop-motion video. 
Silverlight animations use a dramatically different model. Essentially, a Silverlight animation is a 
way to modify the value of a dependency property over an interval of time. For example, to make a 
button that grows and shrinks, you can modify its Width property in an animation. To make it shimmer, 
Documents you may be interested
Documents you may be interested