The only remaining code in frmPersonal is for the cmdOK_Click and cmdCancel_Click events, as 
Private Sub cmdOK_Click()
‘Save Current Record and unload frmPersonal
Call SaveRecord
Unload Me
End Sub
Private Sub cmdCancel_Click()
‘Unload frmPersonal without saving current record
Unload Me
End Sub
Both buttons unload frmPersonal. Only the OK button saves any changes to the current record in the
Modeless  User For ms
The modal UserForms you have dealt with so far do not allow the user to change the focus away from
the UserForm while it is being displayed. You cannot activate a worksheet, menu, or toolbar, for exam-
ple, until the UserForm has been hidden or unloaded from memory. If you have a procedure that uses
the Show method to display a modal UserForm, that procedure cannot execute the code that follows the
Showmethod until the UserForm is hidden or unloaded.
Amodeless UserForm does allow the user to activate worksheets, menus, and toolbars. It floats in the
foreground until it is hidden or unloaded. The procedure that uses the Show method to display a 
modeless UserForm will immediately continue to execute the code that follows the Show method.
frmPersonal, from the previous example that maintains a data list, can easily be displayed modeless.
All you need to do is change the code that displays it, as follows:
Private Sub CommandButton1_Click()
frmPersonal.Show vbModeless
End Sub
When the UserForm is modeless, you can carry on with other work while it is visible. You can even copy
and paste data from TextBoxes on the UserForm to worksheet cells.
Progress Indicator
One feature that has been lacking in Excel is a good progress indicator that lets you show how much
work has been done, and remains to be done, while a lengthy task is carried out in the background.
You can display a message on the status bar using Application.StatusBar, as discussed in Chapter 2,
but this message is not very obvious.
Chapter 13: UserForms
Pdf rotate page - rotate PDF page permanently in, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Users to Change the Rotation Angle of PDF File Page Using C#
rotate single page in pdf; rotate one page in pdf
Pdf rotate page - VB.NET PDF Page Rotate Library: rotate PDF page permanently in, ASP.NET, MVC, Ajax, WinForms, WPF
PDF Document Page Rotation in Visual Basic .NET Class Application
rotate pdf page by page; reverse page order pdf online
You can set up a good progress indicator very easily using a modeless UserForm. Figure 13-5 shows a
simple progress bar indicator that moves from left to right to give a graphic indication of progress.
Figure 13-5
The progress indicator is a normal UserForm with two Labelcontrols, one on top of the other, which
have been given contrasting background colors. The Caption properties of both labels are blank.
This UserForm has been given the name frmProgress. The longer label is named lblFixed, because it
extends over almost all the width of the UserForm and never changes. The shorter label, which is on top of
the fixed label, is named lblIndicate. Initially, it is given a width of 0, and its width is gradually increased
until it equals the width of the fixed label. The UserForm module contains the following procedure:
Public Sub Progress(dPerCent As Double)
‘Change width of indicator label
lblIndicate.Width = dPerCent * lblFixed.Width
‘Allow Operating system to update screen
End Sub
When you execute Progress, you pass a number between 0 and 1 as the input argument dPerCent.
Progresssets the width of lblIndicateto dPerCenttimes the width of lblFixed. The DoEvents
statement instructs the operating system to update the UserForm.
The operating system gives priority to the running macro and holds back on updating the modeless
UserForm. DoEvents tells the operating system to stop the macro and complete any pending events.
This technique often corrects problems with screen updating, or where background tasks need to be com-
pleted before a macro can continue processing. In this case you can alternatively use Refresh.
The progress indicator can be used with a procedure like the following, which counts how many cells
contain errors within a range:
Sub TakesAWhile()
Dim rng As Range
Dim lErrorCount As Long
For Each rng In Range(Cells(1, 1), Cells(4000, 250))
If IsError(rng.Value) Then lErrorCount = lErrorCount + 1
Next rng
MsgBox “Error count = “ & lErrorCount
End Sub
Chapter 13: UserForms
C# TIFF: How to Rotate TIFF Using C# Code in .NET Imaging
Convert Tiff to Jpeg Images. Convert Word, Excel, PowerPoint to Tiff. Convert PDF to Tiff. Move Tiff Page Position. Rotate a Tiff Page. Extract Tiff Pages. Tiff
rotate pdf pages; how to rotate a single page in a pdf document
VB.NET PDF Page Delete Library: remove PDF pages in, ASP.
XDoc.PDF ›› VB.NET PDF: Delete PDF Page. using RasterEdge.Imaging.Basic; using RasterEdge.XDoc.PDF; How to VB.NET: Delete a Single PDF Page from PDF File.
how to rotate a page in pdf and save it; rotate pages in pdf
To incorporate the progress indicator, you can add the following code to the procedure:
Sub TakesAWhile()
‘Routine to demonstrate progress indicator
Dim rng As Range
Dim lErrorCount As Long
Dim lCount As Long
Dim lRows As Long
Dim lColumns As Long
Dim lTotalIterations As Long
Dim lInterval As Long
‘Adjust these numbers to adjust duration of demonstration
lRows = 4000
lColumns = 250
‘Show the progress indicator UserForm
frmProgress.Show vbModeless
‘Calculate interval needed for 100 progress updates
lTotalIterations = lRows * lColumns
lInterval = lTotalIterations / 100
For Each rng In Range(Cells(1, 1), Cells(lRows, lColumns))
If IsError(rng.Value) Then lErrorCount = lErrorCount + 1
‘Each lInterval, update the indicator
If lCount Mod lInterval = 0 Then
frmProgress.Progress lCount / lTotalIterations
End If
lCount = lCount + 1
Next rng
Unload frmProgress
MsgBox “Error count = “ & lErrorCount
End Sub
The changes include showing frmProgress as a modeless UserForm at the start. lTotalIterationsis
the number of times the loop will be repeated. lInterval is the number of iterations between each
update of the indicator. Here it is calculated so as to give 100 updates. Within the ForEach...Next
loop, the variable lCount is used to count the loops. lCountModlInterval has a value of 0 when
lCountis 0 and every multiple of lIntervalloops, so frmProgressis updated 100 times, with the
Progressinput parameter varying from 0 to .99 in steps of .01.
When a class module (such as the module behind a UserForm) contains a public procedure, you can exe-
cute the procedure as a method of the object represented by the class module.
Chapter 13: UserForms
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
PDF Pages. |. Home ›› XDoc.PDF ›› VB.NET PDF: Insert PDF Page. Professional .NET PDF control for inserting PDF page in Visual Basic .NET class application.
rotate pages in pdf online; rotate pages in pdf and save
C# PDF Page Insert Library: insert pages into PDF file in
page processing functions, such as how to merge PDF document files by C# code, how to rotate PDF document page, how to delete PDF page using C# .NET, how to
rotate pdf pages; how to rotate pdf pages and save permanently
The time taken by the macro will vary according to your processor. For demonstration purposes, you
can alter the time taken by the procedure by changing the values of lRows and lColumns.
Variable User For m Nam e
All the examples of UserForms have referred to the UserForm by its programmatic name (such as
frmProgress). There can be situations where you need to run a number of different forms with the
same code, or you don’t know the programmatic name of the UserForm before the code is executed.
In these cases, you need to be able to assign the UserForm name to a variable and use the variable as an
argument. The following code allows you to do this:
FormName = “frmPersonal”
Sum mar y
This chapter introduced the topic of UserForms. You have seen how to:
Directly link controls on a form to a worksheet
Use VBAcode to access UserForm controls and copy data between the form and a worksheet
Prevent closure of a UserForm by modifying the code executed when the x button is clicked
Set up a form to maintain a data list and the difference between modal and modeless UserForms
Construct a progress indicator using a modeless UserForm
Chapter 13: UserForms
C# PDF Page Delete Library: remove PDF pages in, ASP.NET
Pages. |. Home ›› XDoc.PDF ›› C# PDF: Delete PDF Page. Demo Code: How to Delete a Single PDF Page from PDF File in C#.NET. How
rotate pages in pdf expert; pdf save rotated pages
VB.NET PDF - View PDF with WPF PDF Viewer for VB.NET
1. Anticlockwise rotation. Rotate PDF page 90 degree in anticlockwise. 2. Clockwise rotation. Rotate PDF page 90 degree in clockwise. 3. Zoom in.
how to rotate one page in a pdf file; rotate pdf page permanently
C# WPF PDF Viewer SDK to view PDF document in C#.NET
1. Anticlockwise rotation. Rotate PDF page 90 degree in anticlockwise. 2. Clockwise rotation. Rotate PDF page 90 degree in clockwise. 3. Zoom in.
rotate individual pdf pages reader; how to rotate all pages in pdf
VB.NET PDF - WPF PDF Viewer for VB.NET Program
Existing PDF Pages. Page: Replace PDF Pages. Page: Move Page Position. Page: Copy, Paste PDF Pages. Page: Rotate a PDF Page. PDF Read. Text
pdf rotate pages separately; how to rotate pdf pages and save
Ri bb on X
One of the biggest changes in Office 2007 is, of course, the Ribbon. Early in the design of the
Ribbon, Microsoft realized that there had to be a way for it to be customized by developers and
(to a certain extent) end users. That realization led to RibbonX, the Ribbon’s programmability
mechanism. This chapter provides an introduction to RibbonX and explains how you can cus-
tomize the Ribbon, both for yourself and within your applications.
Over view
In previous versions of Office, you created menus and toolbars by using VBA to manipulate the
objects that make up the CommandBarsobject model (see Chapter 15). The code to do that for a
non-trivial application often extended to hundreds and sometimes thousands of lines of VBA that
proved hard to maintain when menus were added, removed, or rearranged. For some time, best
practice has been to use a table-driven approach to building menus, in which the menus and 
toolbars were defined by filling in a table on a worksheet and a dedicated (and reusable) VBA
procedure interpreted the table to create the menus and toolbars. Even when using a table-driven
approach, you still needed quite a bit of custom VBAto ensure that specific menus were visible
only when their workbook was active, and had to be extremely careful about removing customiza-
tions when the workbook was closed.
When designing the programmability model for the Ribbon, Microsoft started with the current
best practices, identified the remaining pain points, and removed them. It took the resultant archi-
tecture on a world tour of key clients and other interested parties, listened to all their issues, and
modified the RibbonX design to resolve most of the issues that were encountered. The result is an
entirely new paradigm for the Excel developer, in which:
The customizations are defined at design-time, rather than coded individually. Instead of
using a table in a worksheet (which would only be available in Excel), they’re defined
using XML and stored as a custom part in the XML file formats (for all the Office applica-
tions that have the Ribbon).
When the workbook is opened, Excel automatically reads the XML part and applies the cus-
tomizations to the Ribbon.
If a standard workbook is used, its Ribbon customizations are only applied and visible when
that workbook is active.
If an add-in workbook is used, its Ribbon customizations are always applied and available.
Whenever a workbook is closed, its Ribbon customizations are automatically removed.
Even though the customizations are defined at design-time, most of the controls’ attributes can
be modified at run time, using VBA(such as enabled, visible, label, and so on).
Afew of the controls can be totally dynamic—so their structure as well as their attributes can
be defined at run time, using VBA.
All the built-in controls are available for our use and can be overridden, executed, and queried
for their images, caption, and so forth.
Prerequisit es
If you intend to spend more than ten minutes investigating RibbonX, there are a few key downloads
you’ll need and web sites you’ll need to know:
The official RibbonX site is at
The Office 2007 Custom UI Editor is available from
There are two invaluable files available on the MSDN web site. The first contains a list of the
names of all Excel’s built-in tabs, groups, and controls; the second is an Excel add-in that adds a
gallery of all the available built-in images that can be used for your custom controls.
If you want to get into the guts of RibbonX, the customui.xsd schema is also available on
MSDN. This is the official schema used to validate your customizations, and it details exactly
which controls have which attributes and contents.
To be informed of any errors in your RibbonX XML, check the box at Office Menu➪Excel
Options➪Advanced➪Show add-in user interface errors.
Adding the Customizations
Adding RibbonX customizations to a workbook requires just two steps:
Create the XML to define the required customization.
Insert the XML into the workbook’s file (which must be using one of the XML file formats).
Chapter 14: RibbonX
The first step is the subject of the remainder of this chapter. You can add the XML part to the workbook
by hand or programmatically, using the techniques shown in Chapter 12. The following changes need to
be made:
Add the XML file to the workbook’s zipped structure. By convention, it has the name
/customUI/customUI.xml, though any other name can be used. It’s a good idea to put the
XML part into its own folder, because you may need to store button images in there as well.
Edit the root rels file to include a reference to the new XML part, such as:
<Relationship Type=”
relationships/ui/extensibility” Target=”/customUI/customUI.xml”
Id=”rID5” />
The important thing to get right is the relationship 
attribute, because that is what
Excel looks for to see if the relationship is for a RibbonX customization. Note that
because this is XML, it is case-sensitive, so it’s critical to get the correct capitalization.
These changes are easily made by hand using the Office 2007 Custom UI Editor utility, available to
download from
XML Str ucture
One of the main criticisms of the Ribbon is that all the controls are grouped according to related func-
tionality, so the text formatting controls are in the Font group on the Home tab, and the formula auditing
tools are all in the Formula Auditing group on the Formulas tab. Yes, it’s logical when viewed from a
functional perspective, but totally illogical if you view the Ribbon from a process perspective. For exam-
ple, it’s quite common for an Excel user to be asked to look at a workbook created by someone else.
When faced with such a challenge, most people work their way through the file, tracing formula 
precedents and dependents, checking defined names, applying different formatting to the cells they
identify, adding comments, and regularly switching between the original and a working copy of the file.
Unfortunately, every one of those actions is found on a different tab of the Ribbon.
In previous versions of Excel, you could bring all these actions together by creating a custom toolbar and
adding the required buttons to it; when you finished auditing the workbook, you’d close the toolbar and
forget about it until you were next asked to look at someone else’s file.
In Office 2007, the concept of custom toolbars has been dropped. Instead, you can define some RibbonX
XMLto create a custom tab containing all the built-in groups and/or controls you need for your audit-
ing, then add that XML to an otherwise empty add-in workbook. Now when you’re asked to audit a
workbook, you can load the Auditing add-in and have all the controls you need conveniently located on
one tab; when you’re finished, you can unload the add-in to remove the custom tab. No VBA required.
Start by creating a new workbook. Click Office Menu➪Prepare➪Properties to give it a Title and
Comment (shown in the Add-ins dialog) and save it as Auditing.xlam (using the Excel Add-in .xlam
file type in the Save As dialog).
Chapter 14: RibbonX
Now start the Office 2007 Custom UI Editor, use it to open the Auditing.xlam file, enter the following
XML, and click Save to add the XML to the file. Note that everything in the XML file is case-sensitive, so
be careful to get the capitalization correct:
<customUI xmlns=””>
<tab id=”rxAuditing” label=”Auditing” >
<group id=”rxAuditMisc” label=”Miscellaneous” >
<control idMso=”Copy” />
<control idMso=”PasteMenu” />
<separator id=”rxAuditMiscSeparator1”/>
<control idMso=”NameManager” />
<control idMso=”ViewFreezePanesGallery” />
<control idMso=”WindowSwitchWindowsMenuExcel” />
<group idMso=”GroupFormulaAuditing” />
<group idMso=”GroupFont” />
<group idMso=”GroupNumber” />
Back in Excel, navigate to the Add-ins dialog (Office Menu➪Excel Options➪Add-Ins➪Manage: Excel
Add-Ins➪Go) and load the Auditing.xlam add-in. When you OK out of the dialog, you should see an
extra Auditing tab on the Ribbon containing the groups and controls defined in the XML, as depicted in
Figure 14-1.
Figure 14-1
The following paragraphs work through each line of the XML definition and relate it to the resultant
changes to the Ribbon.
The <customUI...> element is the root container for the XML, and the namespace identifies it as a
RibbonX document.
The <ribbon> element is a container for all changes related to the visible Ribbon. The <customUI>
element could also contain a <commands> element that you could use to repurpose built-in controls
(see later in this chapter).
Chapter 14: RibbonX
The <tabs> element is a container for all changes related to existing or new tabs on the Ribbon.
The<ribbon> element could also contain <officeMenu><qat>, and/or <contextualTabs>
elements to control the corresponding parts of the Ribbon. Note that you don’t have <miniToolbar> or
<statusBar>elements, and indeed, those are off limits to RibbonX.
The <tabid=”rxAuditing”label=”Auditing”> element is where customizations really begin, by
creating the custom tab. Every item you include in your customizations has to have at least an ID. There
are three types of ID attributes: ididMso, and idQ, specifying a custom item, a built-in item, or an item
shared across multiple files, respectively. In this case, you’re creating a custom tab, so you use the id
attribute and give it a unique name. It’s a good idea to use a standard prefix for all your custom items, to
easily distinguish between them and the built-in names. I tend to use rx to indicate it’s a RibbonX item,
which also helps to further distinguish it from other types of controls when you refer to it in VBA.
The <groupid=”rxAuditMisc”label=”Miscellaneous”> element creates the first of the groups and
opens the definition of its contents. Groups are displayed on the tab in the same order they’re defined in
the RibbonX file, and they display controls below each other for three rows, then across—again, in the
order they’re defined.
The <controlidMso=”Copy”/>element adds the built-in Copy button to the custom group. The generic
controlelement type can be used for all built-in controls regardless of their actual type, and the idMso
ID type provides the actual control name. As mentioned earlier, the names of all Excel’s controls are
listed in the ExcelRibbonControls.xls file available from MSDN.
The <controlidMso=”PasteMenu”/> element adds the standard Paste split button/drop-down. 
The <separatorid=”rxAuditMiscSeparator1”/> element adds a vertical separator to the group,
and starts a second column of controls. Note that even though it’s a “do nothing” visual element, it still
has to have a unique custom ID.
The next three elements add the built-in Name Manager, Freeze Panes, and Switch Windows controls to
the custom group.
The </group> line completes the definition of the first group.
The <groupidMso=”GroupFormulaAuditing”/> element adds the entire built-in Formula Auditing
group to the custom tab, again using the idMso and the correct name to identify it as built-in.
The <groupidMso=”GroupFont”/> and <groupidMso=”GroupNumber”/> elements add the built-in
Font and Number Format groups.
The </tab> line completes the definition of your custom tab, and the remaining lines close out the con-
tainers for the tabsribbon, and customUI elements.
Using this technique, you can create multiple add-ins that only contain RibbonX definitions, each one
creating custom tabs that bring together different sets of built-in controls, appropriate for different high-
level tasks. If you do so, you’ll probably want to add the Add-ins dialog to your QAT—it’s listed as
Add-Ins in the All commands section of the QAT Customization dialog.
Chapter 14: RibbonX
Documents you may be interested
Documents you may be interested