ghostscriptsharp pdf to image c# : Add print button to pdf form Library application class windows winforms ajax 7053154973-Excel%202007%20VBA%20Programmers%20Reference%20-%20Wrox%20200734-part688

<tab ... >
<group ... >
All control types
<tabSet idMso=”TabSetChartTools”>
<tab ... >
<group ... >
All control types
Sharing Controls among Multiple Workbooks
When you create custom tabs, groups, and controls using the idattribute, you always get a brand new tab,
group, or control created for you—even if one already exists with the same ID or label. This is usually
beneficial, because it prevents multiple add-ins accidentally changing each other’s items. Occasionally,
though, you may want to share those items among many add-ins or workbooks. For example, you
mighthave an add-in that creates a basic tab, group, and menu structure, and many individual 
workbooks that should add items to that structure. This is achieved by using the idQattribute to pro-
vide qualifiedIDs—IDs associated with a specific namespace. The namespace is provided within the
customUIelement and just needs to be a unique string. It is typically given an alias (Q in this case) to
make the XMLeasier to read:
<customUI xmlns=””
xmlns:Q=”Excel 2007 VBA Prog Ref”>
Any elements you want to share between workbooks are then defined using the idQattribute and
including the namespace alias within the ID:
<tab idQ=”Q:rxShared” label=”Shared Tab”> 
<group id=”Group1” label=”Group Not Shared”>
Any workbooks using the same namespace string to qualify controls with the same ID will share those
controls rather than getting their own copies. In this example, any workbooks that included a name-
space of xmls:Q=”Excel2007VBAProgRef”and a qualified tab ID of idQ=”Q:rxShared”would all
use the same tab for their controls. However, because you’ve used an unqualified ID for the group, that
would not be shared between the workbooks. The ability to use qualified IDs in this way applies to all
the container-type controls, so an add-in could create a complex menu structure using qualified IDs
forall the tabs, groups, and menus, and individual workbooks could add their customizations to the
shared menus.
Chapter 14: RibbonX
Add print button to pdf form - C# PDF Field Edit Library: insert, delete, update pdf form field in, ASP.NET, MVC, Ajax, WPF
Online C# Tutorial to Insert, Delete and Update Fields in PDF Document
allow saving of pdf form; convert word document to editable pdf form
Add print button to pdf form - VB.NET PDF Field Edit library: insert, delete, update pdf form field in, ASP.NET, MVC, Ajax, WPF
How to Insert, Delete and Update Fields in PDF Document with VB.NET Demo Code
add editable fields to pdf; cannot save pdf form
Updating Controls at Run Time
Callbacks aren’t just used to get controls’ attributes when the workbook is loaded; you can also use them
to change the attribute values at any time. This is done by using a special interface (IRibbonUI) to mark
a control as invalid. The next time Excel needs to display the control, all its callbacks will be called again
to get the latest values.
You tell Excel to give you an IRibboninterface by adding the onLoadcallback to the customUIelement:
<customUI xmlns=””
xmlns:Q=”Excel 2007 VBA Prog Ref”
The signature for the onLoadcallback includes an IRibbonparameter, which is stored in a module-level
variable for later use:
Dim moRibbon As IRibbonUI
Sub rxcustomUI_onLoad(ribbon as IRibbonUI)
Set moRibbon = ribbon
End Sub
The IRibbonUIinterface has only two methods:
The InvalidateControl(“ControlID”)method marks an individual control as invalid, and
hence should be refreshed when it’s next displayed. In general, it is best to only invalidate those
controls that are necessary.
The Invalidatemethod marks your entire Ribbon customization as invalid, so every callback
for every control is called again. This might be used if you provide a choice of UI language and
use getLabelfor every control; when the user changes their language choice, every control can
be invalidated, and thereby updated to show the new text.
As an example, the following XMLcreates a splitButtonwith Up, Goto, and Down menus, using
built-in images, with callbacks defined such that you can change the button’s image and action to repeat
the last selected menu (just like the Border splitButton). Create a new workbook, save it as an add-in,
and use the Custom UI Editor to add the XML:
<customUI xmlns=””
<tab id=”rxExcelVBA” label=”VBA Prog Ref”>
<group id=”rxDemo” label=”Demo”>
<splitButton id=”rxSplit” size=”large”>
<button id=”rxButton” getImage=”rxButton_getImage”
<menu id=”rxMenu”>
<button id=”rxMenuOutlineMoveUp” label=”Up” 
<button id=”rxMenuGoTo” label=”Goto” 
Chapter 14: RibbonX
Save, Print Images in Web Image Viewer| Online Tutorials
you can be immediately enabled to save, print, download and at another page and download it with button click; like PNG, JPEG, GIF, BMP, TIFF, PDF, MS Word, etc.
create a fillable pdf form from a pdf; chrome save pdf with fields
C# WPF PDF Viewer SDK to print PDF document in C#.NET
Highlight Text. Add Text. Add Text Box. Drawing Markups. Add Stamp Annotation. PDF Print. C#.NET RasterEdge WPF PDF Viewer printing button is as following. Print
change font in pdf form field; can reader edit pdf forms
<button id=”rxMenuOutlineMoveDown” label=”Down”
Now open the add-in (ignoring any errors) and add the following VBAcode to a standard module, to
implement all the callbacks defined in the XML:
‘Variable to invalidate controls
Dim moRibbon As IRibbonUI
‘Variable to store current splitButton style,
‘which is the same as the image name
Dim msSplitStyle As String
‘Callback for customUI.onLoad
Sub rxcustomUI_onLoad(ribbon As IRibbonUI)
Set moRibbon = ribbon
End Sub
‘Callback for rxButton getImage
Sub rxButton_getImage(control As IRibbonControl, ByRef returnedVal)
‘Default the style to GoTo
If msSplitStyle = “” Then msSplitStyle = “GoTo”
‘Return the built-in image name
returnedVal = msSplitStyle
End Sub
‘Callback for rxButton onAction
Sub rxButton_onAction(control As IRibbonControl)
DoSplitAction msSplitStyle
End Sub
‘Callback for all rxMenu onActions
Sub rxMenu_onAction(control As IRibbonControl)
‘Get the style from the control ID
msSplitStyle = Mid$(control.ID, 7)
‘Tell the ribbon that the button needs to be refreshed
moRibbon.InvalidateControl “rxButton”
‘Do the appropriate action
DoSplitAction msSplitStyle
End Sub
‘Do the action
Chapter 14: RibbonX
VB.NET PDF - Print PDF with VB.NET WPF PDF Viewer
Highlight Text. Add Text. Add Text Box. Drawing Markups. PDF Print. VB.NET WPF PDF Viewer: Print PDF. VB.NET RasterEdge WPF PDF Viewer printing button is as following
add text field to pdf acrobat; create a fillable pdf form online
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PDF
various buttons are give for print or output PDF Users can freely add text annotation, freehand annotation annotations can be removed easily with delete button.
best program to create pdf forms; allow users to save pdf form
Private Sub DoSplitAction(ByVal sStyle As String)
Select Case sStyle
Case “OutlineMoveUp”: MsgBox “Up”
Case “GoTo”: MsgBox “Goto”
Case “OutlineMoveDown”: MsgBox “Down”
End Select
End Sub
Save, close, and reopen the file. You should now have a tab called VBAProg Ref with a single large split
button, whose image and action changes to match the menu selected (see Figure 14-3).
Figure 14-3
Hooking Built-In Controls
Whereas most of RibbonX concentrates on customizing the visual appearance of the Ribbon, the 
commandsand commandelements provide a mechanism for overriding any built-in menu, to modify its
enabled state or to intercept any button clicks. To achieve that, you can include the following XMLto,
say, override the Print button so you can set up some formatting:
<customUI xmlns=””>
<command idMso=”FilePrint” onAction=”rxPrint_onAction” />
The commandelement can only have an enabledattribute or getEnabledand/or onActioncallbacks.
You could, for example, disable a control by including enabled=”false”, or use a getEnabledcallback
to determine whether or not to enable the control depending on the state of the application. The onAction
callback is used to intercept the default behavior, allowing you to do some preprocessing and optionally
cancel the action:
‘Callback for Print onAction, with ability to cancel
Sub rxPrint_onAction(control as IRibbonControl, ByRef cancelDefault)
If CDbl(Time) > 0.5 Then
Msgbox “Printing can only be done in the morning!”
cancelDefault = True
End If
End Sub
Chapter 14: RibbonX
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit Excel
C# .NET, users can convert Excel to PDF document, export Viewer for C# .NET, users can add various types can be removed from Excel file by using delete button.
changing font size in pdf form; add form fields to pdf online
VB.NET Image: Web Image and Document Viewer Creation & Design
can rotate, redact & annotate images and add, delete & and processing, you may click toolbar button to print It is a powerful toolkit to print bitonal images
adding text fields to pdf; adding text fields to a pdf
Unfortunately, overriding Ribbon controls in this way only affects the user actually clicking the control
or using the Alt+Key shortcuts to trigger the control; it does not intercept the many operations that can
be achieved using the function keys and Ctrl+Key combinations (such as Ctrl+Pin this case). 
If two add-ins attempt to override the same control, the last-loaded add-in wins. For these two reasons,
the ability to override a built-in control should be used with extreme caution.
RibbonX in Dictator Applications
Most dictator-style Excel applications typically start by removing all Excel’s menus and as many other
UI elements as possible, so as to present a locked-down interface to the user. To do this for the Ribbon,
use the startFromScratchattribute of the ribbonelement to give a minimal Office Menu with New,
Open, Save As, Recent Files, and Excel Options:
<customUI xmlns=””>
<ribbon startFromScratch=”true”>
Obviously, you’d then include lots more XMLto build custom tabs, groups, and so on!
Customizing the Office Menu
The Office Menu is treated as a special case within the RibbonX definitions, in that it’s an element in its own
right (rather than, say, being a special tab). You can add controls to it through the officeMenuelement:
<customUI xmlns=””>
<button id=”rxOMBtn” label=”Office Menu” onAction=”rxOMBtn_onAction” />
You can also add buttons to the built-in items on the Office Menus, such as the Send menu, by nesting
the appropriate control IDs. Note that to do this, you have to use the correct control type, rather than the
generic controlelement:
<customUI xmlns=””>
<menu idMso=”FileSendMenu”>
<button id=”rxSend” label=”Send Menu” onAction=”rxSend_onAction” />
Chapter 14: RibbonX
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Highlight Text. Add Text. Add Text Box. Drawing Markups. PDF Print. to Jpeg, VB.NET compress PDF, VB.NET print PDF, VB.NET go to any page by using page go to button
add text fields to pdf; change font size pdf form
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
Highlight Text. Add Text. Add Text Box. Drawing Markups. PDF Print. C#.NET edit PDF sticky note, C#.NET print PDF, C#.NET go to any page by using page go to button
changing font in pdf form; android edit pdf forms
Customizing the QAT
The Office 2007 design philosophy is that the QAT belongs to the user and applications should never
add their controls directly to it. If the users consider your feature to be useful, they’ll put it on the QAT
and Excel will automatically handle the interaction.
In certain scenarios it would be highly beneficial to be able to add controls to the QAT—such as a user
creating add-ins similar to the Auditing add-in presented at the start of this chapter, but by moving
groups of controls on and off the QAT rather than adding custom tabs. Unfortunately, Microsoft chose
todisable this capability, and restricted QAT customization to Dictator Applications that also set
The QAT has two sections—one for controls shared across all open documents, and one for controls that
should only appear on the QAT when this document has the focus. You can add built-in controls using
the generic <control>type, <button>controls, and separators to either of the two areas:
<customUI xmlns=””>
<ribbon startFromScratch=”true”>
<control>,<button> or <separator> types
<control>,<button> or <separator> types
Controlling Tabs, Tab Sets, and Groups
The <tabs><tab><contextualTabs><tabSet>, and <group>elements are all used to provide the
structure to the Ribbon. You’ve been using tabs and groups all the way through this chapter; the tabSet
element provides access to the built-in sets of contextual tabs. For example, when a chart is selected,
Excel displays a Chart Tools set of three contextual tabs. You could add a custom group to the Chart
Tools Design tab with the following XML:
<customUI xmlns=””>
<tabSet idMso=”TabSetChartTools”>
<tab idMso=”TabChartToolsDesign”>
<group id=”MyChartGroup”>
<!-- All control types -->
Chapter 14: RibbonX
Microsoft has placed a few restrictions on what you can do with tabs, contextual tabs, and groups,
You can’t create your own contextual tabSet, but can only refer to built-in ones
You can add custom tabs to a tab set, and custom groups to a built-in tab
You can’t add controls to built-in groups
You can add built-in groups to different tabs (either built-in or custom)
You can make a built-in tab or group invisible
You can move a tab or group to be before or after another one
These are all achieved by setting appropriate attributes on the <tab>and <group>elements, such as:
visible=”false”to hide the tab or group
insertAfterMso=”TabData”to move or add the tab or group after a built-in tab or group
insertBeforeMso=”GroupZoom”to move or add the tab or group before a built-in tab or group
insertAfterQ=”Q:SharedTab”to move or add the tab or group after a qualified custom tab
or group
insertBeforeQ=”Q:SharedGroup”to move or add the tab or group in front of a qualified cus-
tom tab or group
Dynamic Controls
The Ribbon is designed to be a static structure of tabs, groups, and controls; while you’re working with
Excel, all the controls in the Ribbon stay in the same place and have the same structure, size, and actions.
The only parts of the Ribbon that could be considered dynamic are the contextual tabs, the Window list,
and the File MRU—and even then, it’s only the visibility of the contextual tabs that changes; their struc-
ture remains constant.
This philosophy is reflected in the design of RibbonX, with the restriction that your XMLcustomization
has to be defined up front and hard coded into your document files; you do not have a mechanism in
VBAfor providing the XMLat run time. Indeed, if you agree with the philosophy, you wouldn’t need to
provide the XMLat run time, because the getLabelgetImage, and other callbacks would be sufficient
for any localization requirements.
There are, however, times when the philosophy breaks down—the Window menu is a built-in example.
There might also be problems when migrating CommandBarcode to use the Ribbon, if that code changed the
command bar structures as workbooks were opened or closed, or worksheets were added and removed.
Fortunately, Microsoft recognized the requirement for a certain amount of dynamism in our UIs and
provided four controls whose contents can be provided at run time. They are the comboBoxdropDown,
gallery, and dynamicMenucontrols. The content is provided using a set of callbacks, called when the
controls are first displayed and when they’re explicitly marked as invalid. They also have the extremely
Chapter 14: RibbonX
useful invalidateContentOnDropattribute, which if true ensures the callbacks get called every time,
just before the control is dropped down.
dropDown,comboBox,and gallery
These controls are essentially three styles of drop-down controls, where the gallerydrops to show a 2D
grid of images and/or labels. The dropDownand comboBoxcontrols can be static, by including their
content as <item>controls in the XML. You can populate all three controls at run time by using their
getItemCountgetItemIDgetItemLabelgetItemImagegetItemScreentip, or getItemSupertip
callbacks. At a minimum, you have to use getItemCountto provide the number of items in the list. The
remaining getItemcallbacks will be called once for each item, with the item index passed in. You are
required to provide an ID for each item with getItemID,and will typically provide an image or a label
with getItemImageor getItemLabel, respectively. The dropDownand comboBoxcontrols usually look
best with images and labels, while the galleryis designed to look best as a grid of images. In all cases,
the onActioncallback of the dropDownor galleryprovides both the selected item’s ID and its index as
parameters (but not the comboBox, which only has an onChangecallback to provide the text).
The dynamicMenuis a unique control in RibbonX, because it is the only one whose content’s structure
can be changed at run time. The dropDowncomboBox, and galleryare essentially flat lists; the
dynamicMenucan contain a full control hierarchy of both custom and built-in controls—including other
dynamicMenus. This control was created to satisfy the specific requirement for dynamic content that
changes radically as workbooks are opened, closed, and changed.
Imagine a workbook containing multiple sheets of different types (for example, raw data, intermediate
calculations, summaries, and reports), and each sheet requiring a different set of menus. You might
define it statically using the following menu definition (where extra attributes and callbacks such as
Imageand onActionhave been omitted for clarity):
<menu id=”rxSheetOperations” label=”Sheet Operations”>
<menu id=”rxData1Menu” label=”Data Sheet 1”>
<button id=”rxData1Refresh” label=”Refresh Sheet 1 data”/>
<menu id=”rxData2Menu” label=”Data Sheet 2”>
<button id=”rxData2Refresh” label=”Refresh Sheet 2 data”/>
<menu id=”rxCalcMenu” label=”Calculation Sheet”>
<button id=”rxCalcRecalc” label=”Recalculate”/>
<menu id=”rxReport1Menu” label=”Report Sheet 1”>
<button id=”rxReport1Show” label=”Show Report Sheet”/>
<button id=”rxReport1Print” label=”Print Report Sheet”/>
<menu id=”rxReport2Menu” label=”Report Sheet 2”>
<button id=”rxReport1Show” label=”Show Report Sheet”/>
<button id=”rxReport1Print” label=”Print Report Sheet”/>
Chapter 14: RibbonX
The problem is that you don’t know at design-time how many sheets of each type there might be in the
final workbook, or in what order they’ll be shown. The dynamicMenu’s getContentcallback provides
the mechanism through which you can use VBAto create the preceding XMLat run time (by examining
the workbook directly). Within the XMLdefinition, you include a single entry for the dynamicMenu:
<dynamicMenu id=”rxSheetOperations” label=”Sheet Operations” 
The rxSheetOperations_getContentprocedure builds the XMLdefinition for the contained controls
and returns it, wrapped in a containing <menu>element:
Sub rxSheetOperations_getContent(ByRef control As IRibbonControl, _
ByRef returnedVal)
Dim sXML As String
Dim wks As Worksheet
‘Start with a container <menu> element
sXML = “<menu xmlns=””””>”
For Each wks In ThisWorkbook.Worksheets
‘TODO: Add the control definitions for each sheet to the sXML string
‘End by closing the container <menu> element
sXML = sXML & “</menu>”
‘Return the full XML to the dynamicMenu
returnedVal = sXML
End Sub
CommandBar Extensions for the Ribbon
With the design of RibbonX based around XMLand callbacks instead of an object model, it is the respon-
sibility of the customizing application to maintain the state information for all its controls. That raises the
question of how to query that state information—without an object, you have nothing to read the prop-
erties from! Fortunately, the CommandBarsobject has been extended with GetEnabledMsoGetImageMso,
GetLabelMsoGetPressedMsoGetScreenTipMsoGetSuperTipMso, and GetVisibleMsoproperties
to expose all the state information for the built-in controls. In each case, you pass in the name of the
built-in control. These functions are likely to be most useful to add-in writers who want to include con-
trol images on their UserForms or ensure that they’re using the correct control labels when directing
users to click a Ribbon control. Note that you don’t have a GetTextMsoto return the text of a dropDown,
comboBox, or editBox, nor can you call these functions with the ID of a custom control to query other
add-ins’ customizations.
As well as being able to retrieve the state information, you can also click any built-in control using the new
ComandBars.ExecuteMsomethod. This is extremely useful for triggering those actions that don’t have
an object model equivalent—such as putting the user in drawing mode to draw a text box on a sheet:
Application.CommandBars.ExecuteMso “TextBoxInsertExcel”
Chapter 14: RibbonX
RibbonX Limitations
The first version of any new technology can never hope to be perfect for everyone. To their great credit, the
RibbonX team at Microsoft implemented a huge number of the suggestions that were submitted during
the Office 2007 Beta testing (within the limits imposed on them by the overall Ribbon design) and have
done an amazing job of making RibbonX as feature-rich, well-rounded, and stable as it is. The remaining
major limitations are, in our view and in no particular order, as follows:
There is no way for VBAto provide the full XMLat run time. It would have been nice to see a
standard GetCustomUIevent added to the Workbookobject, or a CreateCustomUImethod
added to the CommandBarsobject.
The only way to remove a workbook’s customizations is to close the workbook. Abetter alterna-
tive might have been a RemoveCustomUImethod added to the CommandBarsobject.
The getImagecallback can be fed either an idMsoname or an IPictureobject to provide a
built-in or custom image. You should also be able to provide an internal relationship ID to use a
custom image contained in the workbook file.
There are a number of controls on Excel’s Ribbon that can’t be created using RibbonX—such as
the Page Layout Scale spinner, the galleries that display directly in the Ribbon area, and the list
boxes from the Filter popup.
You cannot create custom contextual tab sets. It would be beneficial to be able to define your
own contexts (for example, inside a P&Lreport) and display appropriate context-sensitive tabs.
The only way to activate a tab is to use SendKeys; there should be an ActivateMsomethod to
select rather than execute a control—or perhaps using ExecuteMsoon a tab name should acti-
vate it.
You can’t modify the Mini Toolbar or the status bar.
You cannot add custom ActiveX controls to the Ribbon (though you can now create Task Panes
with them).
You cannot modify the built-in groups—though that’s as much a Ribbon design issue as a
RibbonX one.
You can’t read the text of built-in dropDowncomboBox, or editBoxcontrols, identify the cur-
rently active tab, group, or control, or identify the selected item from a gallery; indeed, missing
are all the getItemequivalents to those properties that were added to the CommandBarsobject.
There is no way to execute an item from a comboBoxdropdown, or galleryExecuteMso
should take an optional ItemIDor ItemIndexparameter.
Every RibbonX container item, from the root customUIelement to a deeply nested menu,
should support having its contents set dynamically, using a getContentcallback.
Both the RibbonX XMLand any images in the file should be exposed through the Workbook
object’s CustomXMLPartscollection, so they can be easily read or updated with VBA.
There is no way for a custom group to fit in with the resize/collapse behavior of the built-in
groups. You should be able to determine how large a custom group is, and how much spare
space there is on a tab—thereby allowing you to change what you display to make the best use
of the available space.
Chapter 14: RibbonX
Documents you may be interested
Documents you may be interested