c# : winform : pdf viewer : Add page number to pdf preview SDK Library API .net asp.net html sharepoint Pro_Silverlight_5_in_CSharp_4th_edition80-part149

CHAPTER 21  DATA CONTROLS 
800 
<data:DataGrid.RowDetailsTemplate> 
<DataTemplate> 
<Border
<Border Margin="10" Padding="10" BorderBrush="SteelBlue" BorderThickness="3" 
CornerRadius="5"> 
<TextBlock Text="{Binding Description}" TextWrapping="Wrap" FontSize="10"> 
</TextBlock> 
</Border> 
</Border> 
</DataTemplate> 
</data:DataGrid.RowDetailsTemplate> 
Other options include adding controls that allow you to perform various tasks (for example, getting 
more information about a product, adding it to a shopping list, editing it, and so on). 
 Note  There’s a quick with the way the DataGrid sizes the row-details area: it doesn’t take the margin of the 
root element into account. As a result, if you set the Margin property on the root element, part of your content will 
be cut off at the bottom and right edges. To correct this problem, you can add an extra container, as in this 
example. Here, the root-level element doesn’t include a margin, but the nested Border element inside does, which 
dodges the sizing problem. 
You can configure the display behavior of the row-details area by setting the 
DataGrid.RowDetailsVisibilityMode property. By default, this property is set to VisibleWhenSelected, 
which means the row-details area is shown when the row is selected. Alternatively, you can set it to 
Visible, which means the row detail area of every row will be shown at once. Or, you can use Collapsed, 
which means the row detail area won’t be shown for any row, at least not until you change the 
RowDetailsVisibilityMode in code (for example, when the user selects a certain type of row). 
Freezing Columns 
frozen column stays in place at the left size of the DataGrid, even as you scroll to the right. Figure 21-12 
shows how a frozen Product column remains visible during scrolling. Notice how the horizontal 
scrollbar extends only under the scrollable columns, not the frozen columns. 
www.it-ebooks.info
Add page number to pdf 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 and delete pages from pdf; add page number pdf file
Add page number to pdf 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 a page to a pdf document; add page numbers to a pdf
CHAPTER 21  DATA CONTROLS 
801 
Figure 21-12. Freezing the Product column 
Column freezing is a useful feature for very wide grids, especially when you want to make sure 
certain information (such as the product name or a unique identifier) is always visible. To use it, you set 
the IsFrozen property of the column to true: 
<data:DataGridTextColumn Header="Product" Width="175" IsFrozen="True" 
Binding="{Binding ModelName}"></data:DataGridTextColumn
There’s one catch: frozen columns must always be on the left side of the grid. If you freeze one 
column, it must be the leftmost column; if you free two columns, they must be the first two on the left; 
and so on. 
www.it-ebooks.info
C# PDF insert text Library: insert text into PDF content in C#.net
pageIndex, The page index of the PDF page that will be 0
add page number pdf; add page numbers to pdf preview
C# PDF File Split Library: Split, seperate PDF into multiple files
If your page number is set as 1, then the two output PDF files will contains the first page and the later three pages Add necessary references:
adding page numbers in pdf; add page to pdf in preview
CHAPTER 21  DATA CONTROLS 
802 
Selection 
Like an ordinary list control, the DataGrid lets the user select individual items. You can react to the 
SelectionChanged event when this happens. To find out what data object is currently selected, you can 
use the SelectedItem property. If you want the user to be able to select multiple rows, set the 
SelectionMode property to Extended. (Single is the only other option and the default.) To select multiple 
rows, the user must hold down the Shift or Ctrl key. You can retrieve the collection of selected items 
from the SelectedItems property. 
 Tip  You can set the selection programmatically using the SelectedItem property. If you’re setting the selection 
to an item that’s not currently in view, it’s a good idea to follow up with a call to the DataGrid.ScrollIntoView() 
method, which forces the DataGrid to scroll forward or backward until the item you’ve indicated is visible. 
Sorting 
The DataGrid features built-in sorting as long as you’re binding a collection that implements IList (such 
as the List<T> and ObservableCollection<T> collections). If you meet this requirement, your DataGrid 
gets basic sorting for free. 
To use the sorting, the user needs to click a column header. Clicking once sorts the column in 
ascending order based on its data type (for example, numbers are sorted from 0 up, and letters are 
sorted alphabetically). Click the column again, and the sort order is reversed. An arrow appears at the 
far-right side of the column header, indicating that the DataGrid is sorted based on the values in this 
column. The arrow points up for an ascending sort and down for a descending sort. (When you click a 
column more than once, the arrow flips with a quick animation effect.) 
Users can sort based on multiple columns by holding down Shift while they click. For example, if 
you hold down Shift and click the Category column followed by the Price column, products are sorted 
into alphabetical category groups, and the items in each category group are ordered by price. 
It’s possible to exercise some control over the DataGrid sorting process, depending on how much 
effort you’re willing to make (and how much code you’re willing to live with). Here are your options: 
• The SortMemberPath property: Every column provides the SortMemberPath 
property, which allows you to specify the property in the bound data object that’s 
used for sorting. If SortMemberPath isn’t set, the column is sorted using the 
bound data, which makes sense. However, if you have a 
DataGridTemplateColumn, you need to use SortMemberPath because there’s no 
Binding property to provide the bound data. If you don’t, your column won’t 
support sorting. 
• The PagedCollectionView class: The PagedCollectionView wraps an ordinary 
collection and gives you added abilities to sort, filter, group, and page its contents. 
(You’ll use PagedCollectionView later in this chapter for DataGrid grouping and 
sorting.) 
www.it-ebooks.info
VB.NET PDF File Split Library: Split, seperate PDF into multiple
can split target multi-page PDF document file to one-page PDF files or PDF file to smaller PDF documents by every given number of pages Add necessary references
add page to a pdf; adding a page to a pdf
C# PDF delete text Library: delete, remove text from PDF file in
Add necessary references: RasterEdge.Imaging.Basic.dll. matchString, The string wil be deleted from PDF file, -. 0
add a page to pdf file; adding page numbers to pdf in
CHAPTER 21  DATA CONTROLS 
803 
• A custom template: If you don’t like the arrows that indicate when a sort order has 
been applied (or you want to add glitzier animation), you need to use the 
DataGrid.ColumnHeaderStyle property to apply a new template. It has three key 
states: Unsorted State (when no sorting is applied), SortedAscending State (when 
the column is first sorted), and SortedDescending State (when the column header 
is clicked twice, and the sort order is reversed). Customize these to plug in your 
own visuals. 
You can also disable sorting by setting the CanUserSortColumns property to false (or turn it off for 
specific columns by setting the column’s CanUserSort property). 
DataGrid Editing 
One of the DataGrid’s greatest conveniences is its support for editing. A DataGrid cell switches into edit 
mode when the user double-clicks it. But the DataGrid lets you restrict this editing ability in several 
ways: 
• DataGrid.IsReadOnly: When this property is true, users can’t edit anything. 
• DataGridColumn.IsReadOnly: When this property is true, users can’t edit any of 
the values in that column. 
• Read-only properties: If your data object has a property with no property setter, 
the DataGrid is intelligent enough to notice this detail and disable column editing 
just as if you had set DataGridColumn.IsReadOnly to true. Similarly, if your 
property isn’t a simple text, numeric, or date type, the DataGrid makes it read-
only (although you can remedy this situation by switching to the 
DataGridTemplateColumn, as described shortly). 
What happens when a cell switches into edit mode depends on the column type. A 
DataGridTextColumn shows a text box (although it’s a seamless-looking text box that fills the entire cell 
and has no visible border). A DataGridCheckBox column shows a check box that you can check or 
uncheck. But the DataGridTemplateColumn is by far the most interesting. It allows you to replace the 
standard editing text box with a more specialized input control, like a DatePicker or ComboBox. 
Editing with Templates 
You’ve already seen how to supply a CellTemplate for the DataGridTemplateColumn. But the 
DataGridTemplateColumn supports two templates. The CellTemplate determines how the cell looks 
when it’s not being edited. The CellEditingTemplate specifies the controls that should be shown in 
editing mode, using a two-way binding expression to connect to the appropriate field. It’s up to you 
whether you use the same controls in both templates. 
For example, the following column shows a date. When the user double-clicks to edit that value, it 
turns into a drop-down DatePicker (see Figure 21-13) with the current value preselected: 
<data:DataGridTemplateColumn Header="Date Added"> 
<data:DataGridTemplateColumn.CellTemplate> 
<DataTemplate> 
<TextBlock Margin="4" Text
"{Binding DateAdded, Converter={StaticResource DateOnlyConverter}}"></TextBlock> 
</DataTemplate> 
</data:DataGridTemplateColumn.CellTemplate
www.it-ebooks.info
C# PDF replace text Library: replace text in PDF content in C#.net
Add necessary references: Delete specified string text that match the search option from specified PDF page. 0
add or remove pages from pdf; add pages to an existing pdf
C# PowerPoint - Split PowerPoint Document in C#.NET
If your page number is set as 1, then the PowerPoint files will contains the first page and the Add necessary XDoc.PowerPoint DLL libraries into your created
adding page to pdf; add page numbers pdf files
CHAPTER 21  DATA CONTROLS 
804 
<data:DataGridTemplateColumn.CellEditingTemplate> 
<DataTemplate> 
<controls:DatePicker SelectedDate="{Binding DateAddedMode=TwoWay}"> 
</controls:DatePicker> 
</DataTemplate> 
</data:DataGridTemplateColumn.CellEditingTemplate> 
</data:DataGridTemplateColumn> 
Figure 21-13. Editing dates with the DatePicker 
You can even use a template column to supply a lookup list of options for data entry. For example, 
you may want to constrain the Category choice to a list of predefined categories. The easiest way to do 
this is to create a combo box in the CellEditingTemplate. Then, bind the ComboBox.SelectedItem 
property to the Product.CategoryName using a two-way binding, and bind the ComboBox.ItemsSource 
property to a collection that contains the allowed values. In the following example, that’s a collection 
that’s exposed by the Product.CategoryChoices property: 
<data:DataGridTemplateColumn Header="Category"> 
<data:DataGridTemplateColumn.CellTemplate> 
<DataTemplate> 
<TextBlock Margin="4" Text="{Binding CategoryName}"></TextBlock> 
</DataTemplate> 
</data:DataGridTemplateColumn.CellTemplate> 
<data:DataGridTemplateColumn.CellEditingTemplate>                         
<DataTemplate> 
<ComboBox Margin="4" ItemsSource="{Binding CategoryChoices}" 
SelectedItem="{Binding CategoryNameMode=TwoWay}"> 
www.it-ebooks.info
C# Word - Split Word Document in C#.NET
your page number is set as 1, then the two output Word files will contains the first page and the later three pages respectively. C# DLLs: Split Word File. Add
add page numbers to pdf reader; add pages to pdf acrobat
VB.NET PDF url edit library: insert, remove PDF links in vb.net
objects, including website, image, document, bookmark, PDF page number, flash, etc. open in a new window, blank page or tab. NET users will be able to add a url
adding pages to a pdf document; add page numbers pdf file
CHAPTER 21  DATA CONTROLS 
805 
</ComboBox> 
</DataTemplate> 
</data:DataGridTemplateColumn.CellEditingTemplate> 
</data:DataGridTemplateColumn> 
Validation and Editing Events 
The DataGrid automatically supports the same basic validation system you learned about in the 
previous chapter, which reacts to problems in the data-binding system (such as the inability to convert 
supplied text to the appropriate data type) or exceptions thrown by the property setter. The error 
message appears as a red pop-up next to the offending column (Figure 21-14). 
Figure 21-14. A property setting exception 
The DataGridTextColumn automatically uses binding expressions that support validation. However, 
if you’re using a DataGridTemplateColumn, you must add both the ValidatesOnExceptions and 
NotifyOnValidationError properties to the binding expression in the CellEditingTemplate, as shown 
here: 
<data:DataGridTemplateColumn Header="Price"> 
<data:DataGridTemplateColumn.CellTemplate> 
<DataTemplate> 
<TextBlock Margin="4" 
 Text="{Binding UnitCostStringFormat='C'}"> 
</TextBlock> 
</DataTemplate> 
</data:DataGridTemplateColumn.CellTemplate
<data:DataGridTemplateColumn.CellEditingTemplate> 
www.it-ebooks.info
.NET Excel Document Add-on | Manipulate Excel File in .NET
DLL, .NET programmers also need to add .NET Basic applications deployed to an unlimited number of clients license and price details on page Purchase Product
add page numbers to pdf document in preview; add remove pages from pdf
CHAPTER 21  DATA CONTROLS 
806 
<DataTemplate> 
<TextBox Margin="4" 
 Text="{Binding UnitCostMode=TwoWay, ValidatesOnExceptions=true, 
NotifyOnValidationError=true}"> 
</TextBox> 
</DataTemplate> 
</data:DataGridTemplateColumn.CellEditingTemplate> 
</data:DataGridTemplateColumn> 
You can implement validation a couple of other ways with a DataGrid. One option is to use the 
DataGrid’s editing events, which are listed in Table 21-4. The order of rows matches the order that the 
events fire in the DataGrid. 
Table 21-4. DataGrid Editing Events 
Name 
Description 
BeginningEdit  
Occurs when the cell is about to be put in edit mode. You can examine the 
column and row that are currently being edited, check the cell value, and 
cancel this operation using the DataGridBeginningEditEventArgs.Cancel 
property. 
PreparingCellForEdit  Used for template columns. At this point, you can perform any last-minute 
initialization that’s required for the editing controls. Use 
DataGridPreparingCellForEditEventArgs.EditingElement to access the element 
in the CellEditingTemplate. 
CellEditEnding  
Occurs when the cell is about to exit edit mode. 
DataGridCellEditEndingEventArgs.EditAction tells you whether the user is 
attempting to accept the edit (for example, by pressing Enter or clicking 
another cell) or cancel it (by pressing the Escape key). You can examine the 
new data and set the Cancel property to roll back an attempted change. 
CellEditEnded  
Occurs after the cell has returned to normal. You can use this point to update 
other controls or display a message that notes the change. 
RowEditEnding  
Provides a collection of all the current HTTP cookies. You can read or set the 
values in these cookies. Cookies provide one easy, low-cost way to transfer 
information from server-side ASP.NET code to client-side Silverlight code. 
However, cookies aren’t the best approach for storing small amounts of data 
on the client’s computer—isolated storage, which is discussed in Chapter 22, 
provides a similar feature with better compatibility and programming support.
RowEditEnded 
Occurs after the user has moved on from an edited row. You can use this point 
to update other controls or display a message noting the change. 
If you need a place to perform validation logic that is specific to your page (and so can’t be baked 
into the data objects), you can write custom validation logic that responds to the CellEditEnding and 
RowEditEnding events. Check column rules in the CellEditEnding event handler, and validate the 
consistency of the entire row in the RowEditEnding event. And remember, if you cancel an edit, you 
www.it-ebooks.info
CHAPTER 21  DATA CONTROLS 
807 
should provide an explanation of the problem (usually in a TextBlock elsewhere on the page, although 
you can also use the ChildWindow control or a message box). 
Finally, it’s worth noting that the DataGrid supports data annotations in a different way than the 
ordinary input controls you’ve used so far. If your property setters use the Validator.ValidateProperty() 
method to check for invalid values and throw a ValidationException (as shown earlier), the DataGrid 
responds in the typical way, by immediately recognizing the error and displaying the error message in a 
red pop-up. But if you don’t use the validator, the DataGrid still validates all the properties you’ve set 
and validates the entire object. The difference is that it doesn’t perform this validation until the user 
attempts to move to another row. Furthermore, if a validation error is detected at this point, the 
DataGrid handles it in a different way. It returns the user to the invalid row, keeping it in edit mode, and 
then shows the error message in a shaded bar that appears over the bottom of the DataGrid. Figure 21-
15 shows an example where an edit violates the custom validation routine from the ProductValidation 
class shown earlier. 
Figure 21-15. Violating a data annotation 
Here’s another way to think about it. Any exceptions you raise in the property setter are handled 
when the CellEditEnding event fires. And data annotations you apply but don’t explicitly enforce with 
code are checked by the DataGrid when the RowEditEnding event fires. 
It’s up to you whether you use this ability. If you intend to perform editing in ordinary controls as 
well as the DataGrid, you need to keep using the Validator.ValidateProperty() method to defend against 
invalid data. But if you intend to use the DataGrid exclusively for your editing needs, it may make sense 
to omit the property-setting code and let the DataGrid perform the validation. Just remember that when 
used in this way, the data annotation rules won’t kick in when you set values programmatically. (This 
also raises the possibility of a particularly odd error condition: if the DataGrid is loaded with invalid data 
and the user attempts to edit that data, the user will be trapped in edit mode until the value is changed. 
The edit can’t be cancelled, because the original value is invalid.) 
www.it-ebooks.info
CHAPTER 21  DATA CONTROLS 
808 
The PagedCollectionView 
The DataGrid has a few more features that require the support of the PagedCollectionView, which is 
found in the System.Windows.Data namespace. The PagedCollectionView wraps a collection and gives 
you a different way to look at it. Conceptually, the PagedCollectionView is a window onto your data, and 
that window can apply sorting, filtering, grouping, and paging before your data appears in a bound 
control like the DataGrid. 
To use the PagedCollectionView, you need to explicitly create it in your code. You supply the source 
collection with your data as a constructor argument. You then bind the PagedCollectionView to the 
appropriate control instead of your original collection. 
To implement this approach with the current example, you’d change this code, which reacts when 
the web service returns the collection of products: 
gridProducts.ItemsSource = e.Result; 
to this: 
PagedCollectionView view = new PagedCollectionView(e.Result); 
gridProducts.ItemsSource = view; 
To change the way your data appears in the bound control, you tweak the settings of the 
PagedCollectionView. In the following sections, you’ll see examples that use the most commonly 
modified PagedCollectionView properties. 
Sorting 
You can apply a multilevel sort order by adding SortDescription objects (from the 
System.ComponentModel namespace) to the PagedCollectionView.SortDescriptions collection. Each 
SortDescription object applies a single level of sorting, based on a single property. The SortDescription 
objects are applied in the order you add them, which means the following code orders products by 
category and then sorts each category group from lowest to highest price: 
PagedCollectionView view = new PagedCollectionView(e.Result); 
// Sort by category and price. 
view.SortDescriptions.Add( 
new SortDescription("CategoryName"ListSortDirection.Ascending)); 
view.SortDescriptions.Add( 
new SortDescription("UnitCost"ListSortDirection.Ascending)); 
gridProducts.ItemsSource = view; 
This approach integrates perfectly with the built-in DataGrid sorting you considered earlier in this 
chapter. The DataGrid displays the up or down sort arrow in the header of whatever columns the 
PagedCollectionView uses for sorting. And if the user clicks a column header, the old sort order is 
abandoned, and the rows are re-ordered appropriately. 
Filtering 
You can use the PagedCollectionView.Filter property to set a filtering callback: a routine that tests 
whether each row should be shown or hidden. To show a row, the callback returns true. To hide it, the 
callback returns false. 
www.it-ebooks.info
CHAPTER 21  DATA CONTROLS 
809 
Here’s an example that only shows products that are in the Travel category. 
PagedCollectionView view = new PagedCollectionView(e.Result); 
// Show only travel items. 
// The full list of products remains in the source collection, but the 
// non-travel items are not visible through the PagedCollectionView. 
view.Filter = delegate(object filterObject) 
Product product = (Product)filterObject; 
return (product.CategoryName == "Travel"); 
}; 
gridProducts.ItemsSource = view; 
Grouping 
The DataGrid also has support for grouping, which allows you to organize rows together into logical 
categories. The basic idea is that you pick a property to use for grouping (such as CategoryName). 
Objects that have the same value for that property (for example, products with the same CategoryName) 
are placed into a single group, which can be collapsed in the DataGrid display, as shown in Figure 21-16. 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested