access 2007 vba bible phần 9 docx

FIGURE 15.19
A table filled with names of tables and their fields.
Selecting the “Back up back end database” command extracts the name of the back end database
from the Connect string of a linked table, and presents an InputBox with a proposed save name,
which can be edited as desired. The InputBox is shown in Figure 15.20
FIGURE 15.20
An InputBox with a proposed save name for a back-end database.
557
Customizing the Ribbon with XML in Access Databases and Add-ins
15
21_047026 ch15.qxp 4/2/07 10:06 PM Page 557
If you run this command in a database that has no linked tables, you will instead get the message
shown in Figure 15.21:
FIGURE 15.21
A message when attempting to back up the back end for a database that has no linked tables.
The procedures for the “List Table Fields”, “List Query Fields”, “Select Options”, “Back up current
database”, and “Back up back end database” buttons are similar to those in the Extras 2007.accda
add-in, except that they use the ByVal control As IRibbonControl argument that is needed to run
them from Ribbon buttons; their code is not listed here.
Summary
Although at first it may appear that the new Ribbon is not customizable, you can in fact customize
it, at least by adding new tabs and groups, with controls to run your code. This chapter covered
writing XML code to load a custom Ribbon, and VBA code for procedures to run from the custom
Ribbon buttons, both in regular Access 2007 databases and in library databases for Access 2007
add-ins. The next chapter describes how to write Shared add-ins working with the Access Ribbon
in Visual Basic 2005.
558
Adding More Functionality to Office
Part III
21_047026 ch15.qxp 4/2/07 10:06 PM Page 558
I

n Chapter 13, I described creating a VB 6 COM add-in to add extra
functionality to Access. VB 6 (though still supported by Microsoft) is not
the latest version of Visual Basic; if you want to use the latest version,
that is VB 2005, included in Visual Studio 2005, available in several editions.
There are significant differences between these versions of VB and some com-
patibility problems with Office 2007, but you can create Visual Studio 2005
add-ins that work with Access, though at present the job is much harder than
it should be, and their functionality is limited, because the Visual Studio Tools
for Office add-in does not yet include an Access add-in template.
This chapter describes creating a simple Visual Studio Shared add-in for
Access that will run in both Windows XP and Windows Vista.
Preparing to Write a Visual
Studio Add-in
Before you start writing a Visual Studio add-in, there are several preliminary
steps you need to take. The first is to check that.NET support is enabled for
Office, to support the Access interoperability component needed to work
with Access.
Adding .NET Support to Office
Since your installation of Office 2007 may not have .NET support enabled,
you need to check that this feature has been selected; it is required in order
to create Shared add-ins. To check whether.NET support is enabled, you
559
IN THIS CHAPTER
Customizing the Ribbon with a
Visual Studio 2005 Shared add-in
A comparison of Access and
Visual Studio add-ins
Customizing the Access
Ribbon with a Visual Studio
2005 Shared Add-in

22_047026 ch16.qxp 4/2/07 10:07 PM Page 559
need to run Office install. In Windows Vista, first select Programs in the Control Panel, then
Programs and Features, then select the Microsoft Office item, as shown in Figure 16.1. If you are
running Windows XP, start by selecting the Add or Remove Programs applet in the Control Panel,
then the Microsoft Office 2007 item.
FIGURE 16.1
Changing the Office 2007 installation in Windows Vista.
On the next screen, shown in Figure 16.2, select the Change option, then “Add or Remove Features”
for Vista, or the “Add or Remove Features” option for Windows XP.
In the Installation Options dialog, drop down the Microsoft Office Access list; if the .NET
Programmability Support item has a big red X, that means that it is not installed. To install it, drop
down its list and select the “Run from My Computer” item (see Figure 16.3).
560
Adding More Functionality to Office
Part III
22_047026 ch16.qxp 4/2/07 10:07 PM Page 560
FIGURE 16.2
Selecting the “Add or Remove Features” option for changing Office in Windows XP.
FIGURE 16.3
Selecting the “Run from My Computer” option for .NET programmability support.
561
Customizing the Access Ribbon with a Visual Studio 2005 Shared Add-in
16
22_047026 ch16.qxp 4/2/07 10:07 PM Page 561
If you want to create add-ins for any other Office components, select “Run from My Computer” for
their .NET Programmability Support components as well. After clicking Continue, Office installs
the new features, and when it is done, you will get a success screen, depicted in Figure 16.4; click
Close on this screen, and then close the Add/Remove Program applet.
FIGURE 16.4
The success screen after changing the Office configuration.

Although VB 2005 Express has an Upgrade Wizard, it isn’t helpful in upgrading a VB 6 COM add-
in to VB 2005 because the Express edition of VB 2005 doesn’t support creating add-ins. If you
attempt to upgrade a VB 6 COM add-in with this wizard (or the similar wizard in Visual Studio
2005), all the project components will be upgraded except the critical Access Designer, and you
will get a message “Activex Designer AccessDesigner.Dsr was not upgraded” in the Upgrade Report,
as shown in Figure 16.5.
562
Adding More Functionality to Office
Part III
22_047026 ch16.qxp 4/2/07 10:07 PM Page 562
FIGURE 16.5
The Upgrade Report for a VB 6 COM add-in, showing that the Access Designer was not upgraded.
The VB 6 COM add-in was the topic of Chapter 13.
You might think that Visual Studio Tools for Office 2005 (VSTO) would be an appropriate tool for
creating Access add-ins, when supplemented with the downloadable upgrade that supports Office
2007 — after all, Access is part of Office. But this is not so. Though you can create add-ins for all
the other major Office 2007 components, and some minor ones as well (see Figure 16.6), you can’t
create an Access add-in with VSTO, and therefore in this section I use Visual Studio 2005 for creat-
ing a Shared add-in (this is the new name for what was previously called a COM add-in).
To create a Shared add-in that adds capability to Access, start by running Visual Studio 2005 and
selecting File ➪ New Project. In the New Project dialog, select the Extensibility selection under the
Other Project Types category, then select the Shared Add-in template. Enter the add-in’s name and
solution name; you can either accept the default location for the add-in’s files or browse for a cus-
tom location, as I did in Figure 16.7.
CROSS-REF
CROSS-REF
563
Customizing the Access Ribbon with a Visual Studio 2005 Shared Add-in
16
22_047026 ch16.qxp 4/2/07 10:07 PM Page 563

FIGURE 16.6
The VSTO New Project Office screen, showing that Access add-in creation is not supported.
FIGURE 16.7
Creating a Shared add-in in Visual Studio 2005.
The add-in’s name can’t contain spaces or punctuation marks— just letters and numbers.
However, the solution name can contain spaces or punctuation marks.
After clicking OK, you will get a “Welcome to the Add-in Wizard” screen, as seen in Figure 16.8.
CAUTION
CAUTION
564
Adding More Functionality to Office
Part III
22_047026 ch16.qxp 4/2/07 10:07 PM Page 564
565
Customizing the Access Ribbon with a Visual Studio 2005 Shared Add-in
16
Running Visual Studio 2005 in Windows Vista
I
n order to run Visual Studio 2005 on Windows Vista, you need to install a Service Pack and then a hot-
fix. The first download to install is the Visual Studio 2005 Service Pack 1, which can be downloaded
from
(in various versions
depending on the edition of Visual Studio). The hotfix is called the Visual Studio 2005 Service Pack 1
Update for Windows Vista Beta; it can be downloaded at
/>loads/details
.aspx?familyid=fb6bb56a-10b7-4c05-b81c-5863284503cf&displaylang=en
.
After installing the service pack and hotfix, when you run Visual Studio 2005, you will probably get
this message:
continued

FIGURE 16.8
The first screen of the Shared Add-in Wizard.
22_047026 ch16.qxp 4/2/07 10:07 PM Page 565
566
Adding More Functionality to Office
Part III
continued
If you click on the link, you will get a Web page with more links to pages with information about
running Visual Studio 2005 on Vista:
For running Visual Studio 2005 on Vista, the link you need is the third one, “Running with elevated
administrator permissions.” There is a lot of information on this page, but basically you only need
one thing: when running Visual Studio in Vista, right-click its icon and select “Run as administrator”
from its context menu:
22_047026 ch16.qxp 4/2/07 10:07 PM Page 566
567
Customizing the Access Ribbon with a Visual Studio 2005 Shared Add-in
16
Now you can create new projects or open existing projects, and work with them as in Windows XP,
and your Visual Studio add-in Ribbons (and other customizations) will work in Access 2007
databases.
22_047026 ch16.qxp 4/2/07 10:07 PM Page 567
On the screen depicted in Figure 16.9, select Visual Basic as the programming language to use (it
may be the only choice, depending on the language support you selected when installing Visual
Studio).
FIGURE 16.9
Selecting a programming language for the add-in.
On the next screen, shown in Figure 16.10, select Microsoft Access as the application host.
FIGURE 16.10
Selecting an application host for the add-in.
568

Adding More Functionality to Office
Part III
22_047026 ch16.qxp 4/2/07 10:07 PM Page 568
On screen 3 of the wizard (see Figure 16.11), enter the add-in’s name and description (not the
same as the project name and solution name entered on the first screen).
FIGURE 16.11
Giving the add-in a name and description.
Next, as depicted in Figure 16.12, select add-in options — during development, it’s best to check
only the first checkbox, so only you (the developer) can work with the add-in.
FIGURE 16.12
Selecting add-in options.
569
Customizing the Access Ribbon with a Visual Studio 2005 Shared Add-in
16
22_047026 ch16.qxp 4/2/07 10:07 PM Page 569
The final page of the Shared Add-in Wizard (see Figure 16.13) gives a summary of the selected
options.
FIGURE 16.13
The Summary page of the Shared Add-in Wizard.
On clicking Finish, the new add-in project is created, with all the necessary components, and the
Connect class (the Connect.vb module) is displayed, as shown in Figure 16.14 (note the similarity
to the Access Designer in the VB 6 COM add-in). To work with the references more easily, select
Project ➪ Show All Files, and expand the References folder in the Solution Explorer at the right of
the screen.
If you don’t see the References folder in the Solution Explorer, select Show All Files from
the Project menu to make the folder visible.
TIP
TIP
570
Adding More Functionality to Office

Part III
22_047026 ch16.qxp 4/2/07 10:07 PM Page 570
FIGURE 16.14
The new Shared add-in project.
Next, add a reference to the Access Interoperability item. To add references, right-click the References
folder and select Add Reference, then select the .NET tab, select “Microsoft.Office.Interop.Access” (as
in Figure 16.15), and click OK.
Figure 16.16 shows the solution’s references in the Solution Explorer.
571
Customizing the Access Ribbon with a Visual Studio 2005 Shared Add-in
16
22_047026 ch16.qxp 4/2/07 10:07 PM Page 571
FIGURE 16.15
Adding a reference to the Interop.Access item.
FIGURE 16.16
The Access Interoperability reference, and standard references.
572
Adding More Functionality to Office
Part III
22_047026 ch16.qxp 4/2/07 10:07 PM Page 572
The next step is to add some Imports statements under the two default statements in the
Declarations section of the class module, using IntelliSense (see Figure 16.17):
Imports Extensibility
Imports System.Runtime.InteropServices
Imports Microsoft.Office.Core
Imports Access = Microsoft.Office.Interop.Access
FIGURE 16.17
Using IntelliSense to add an Imports statement to the Connect class module.
Next, replace the class-level variables (applicationObject and addInInstance), both
declared as

Object, with typed references, replacing Dim with Private (I also gave the
applicationObject variable a more application-specific name, appAccess):
Private appAccess As Microsoft.Office.Interop.Access.Application
Private addInInstance As Microsoft.Office.Core.COMAddIn
After adding statements and modifying the variables, there are some more modifications to be
made to the code in the Connect class module. These changes are described in the next section.
Modifying the Connect Class Module Code
If you were (for example) creating an Excel 2007 add-in using VSTO 2005 with the 2007 upgrade,
you could add Ribbon support to your add-in by simply adding a Ribbon Support item to your
project. Visual Studio 2005 lacks a Ribbon Support item, and VSTO doesn’t support creating
Access add-ins, so this step requires extensive manual modification of the Connect class module,
to support working with Access and the Ribbon.
573
Customizing the Access Ribbon with a Visual Studio 2005 Shared Add-in
16
22_047026 ch16.qxp 4/2/07 10:07 PM Page 573
In the OnConnection method, modify the rows that set the application (Access) and add-in vari-
ables as follows:
appAccess = DirectCast(application, _
Microsoft.Office.Interop.Access.Application)
addInInstance = DirectCast(addInInst, _
Microsoft.Office.Core.COMAddIn)
Next, modify the two lines that set the Access and add-in variables as follows:
appAccess = DirectCast(application, Access.Application)
addInInstance = DirectCast(application, Core.COMAddIn)
Add another Implements statement to the Connect class as follows:
Implements Extensibility.IDTExtensibility2
Implements IRibbonExtensibility
If all this manual modification of the Shared add-in code is getting tedious, hopefully
the next version (v. 3) of VSTO will include an Access template that will eliminate most

of the hand-coding for support of Access Shared add-ins and the Ribbon.
After adding the Implements IRibbonExtensibility line, a new function stub should
appear in the Connect class module,
GetCustomUI.
If you don’t see the function stub, try doing a Save All. If it still doesn’t appear, just type
in the whole function.
Add a line of code to this function, as listed next:
Public Function GetCustomUI(ByVal RibbonID As String) As String _
Implements Microsoft.Office.Core.IRibbonExtensibility.GetCustomUI
Return My.Resources.Ribbon
End Function
Finally, open the Assembly.vb class from the Solution Explorer and add information about the add-
in (you don’t have to fill in all the information), as shown in Figure 16.18.
This completes the general changes to the Connect class module; now you need to add code for
your add-in’s specific functionality.
NOTE
NOTE
NOTE
NOTE
574
Adding More Functionality to Office
Part III
22_047026 ch16.qxp 4/2/07 10:07 PM Page 574
FIGURE 16.18
Adding Assembly information to the add-in.
Adding Functionality to the Shared Add-in
For the Visual Studio add-in I used components of the Access object model to create a table, form,
or report programmatically, adding fields to the table and controls to the form or report. To imple-
ment this functionality, I needed to write the custom Ribbon’s XML code, three button functions,
and some supporting code.

To create the Ribbon XML and embed it within the project, first create an XML File item by select-
ing Project ➪ Add New Item, and then the XML File item in the Add New Item dialog (give the file
the name Ribbon.xml), as shown in Figure 16.19.
575
Customizing the Access Ribbon with a Visual Studio 2005 Shared Add-in
16
22_047026 ch16.qxp 4/2/07 10:07 PM Page 575
FIGURE 16.19
Creating an XML File item for Ribbon support.
The XML code for the Ribbon in this add-in is listed here (see Chapter 15 for more detailed infor-
mation on creating Ribbon XML code):
<?xml version=”1.0” encoding=”utf-8” ?>
<customUI
xmlns=” /><ribbon startFromScratch=”false”>
<tabs>
<tab id=”dbDemoTab”
label=”Visual Studio Add-in”
visible=”true”>
<group id=”dbAccessObjectsGroup”
label=”Create Access Objects”>
<button id=”btnCreateTable”
label=”Create New Table”
enabled=”true”
imageMso=”Table”
size=”normal”
onAction=”CreateTableInDesignView”/>
<button id=”btnCreateForm”
label=”Create New Form”
enabled=”true”
imageMso=”CreateFormInDesignView”

size=”normal”
onAction=”CreateNewForm”/>
<button id=”btnCreateReport”
label=”Create New Report”
enabled=”true”
576
Adding More Functionality to Office
Part III
22_047026 ch16.qxp 4/2/07 10:07 PM Page 576
imageMso=”CreateReportInDesignView”
size=”normal”
onAction=”CreateNewReport”/>
</group>
</tab>
</tabs>
</ribbon>
</customUI>
Next, the XML file needs to be treated as a resource within the project, so you don’t have to deal with
a separate text file. To do this, select Ribbon.xml in the Solution Explorer, and select Embedded
Resource as the value for the Build Action property in its properties sheet (see Figure 16.20).
FIGURE 16.20
Selecting Embedded Resource as the Build Action property of the Ribbon.xml file.
Next, select “CreateObjects Properties” from the bottom of the Project menu (if you are working
with a different project, its name appears instead of CreateObjects). Click the Resources tab; if you
have not already created a resources file, all you will see is the link shown in Figure 16.21.
FIGURE 16.21
A link to add a resource to a project.
Click the link to create a resources file; a datasheet appears, with columns for Name, Value, and
Comment. Drag the Ribbon.xml file from the Solution Explorer to the Resources pane; now, as in
Figure 16.22, you will see an icon for the Ribbon.xml file.

577
Customizing the Access Ribbon with a Visual Studio 2005 Shared Add-in
16
22_047026 ch16.qxp 4/2/07 10:07 PM Page 577
FIGURE 16.22
The Ribbon.xml file added to the project’s resources file.
Each of the buttons in the Ribbon XML code needs its own procedure; the three button proce-
dures, plus a standard add-in error handler (same as in the VB 6 COM add-in) are listed next:
Public Sub CreateNewTable(ByVal control As _
Microsoft.Office.Core.IRibbonControl)
On Error GoTo ErrorHandler
Dim strSQL As String
Dim strTable As String
Dim obj As AccessObject
strTable = “tblTest”
strSQL = “CREATE TABLE “ & strTable & “ (FileDate DATE, “ _
& “FileNumber LONG, FileName TEXT (100), “ _
& “Current YESNO);”
Debug.Print(“SQL Statement: “ & strSQL)
Create table if it doesn’t already exist.
For Each obj In appAccess.CurrentData.AllTables
If obj.Name = strTable Then
‘Table already exists
GoTo ErrorHandlerExit
End If
Next
578
Adding More Functionality to Office
Part III
22_047026 ch16.qxp 4/2/07 10:07 PM Page 578

Create the table.
appAccess.DoCmd.RunSQL(strSQL)
ErrorHandlerExit:
Exit Sub
ErrorHandler:
AddInErr(Err)
Resume ErrorHandlerExit
End Sub
Public Sub CreateNewForm(ByVal control As _
Microsoft.Office.Core.IRibbonControl)
On Error GoTo ErrorHandler
Dim frm As Microsoft.Office.Interop.Access.Form
Dim txt As Microsoft.Office.Interop.Access.TextBox
Dim lbl As Microsoft.Office.Interop.Access.Label
Dim cbo As Microsoft.Office.Interop.Access.ComboBox
Dim lst As Microsoft.Office.Interop.Access.ListBox
Dim chk As Microsoft.Office.Interop.Access.CheckBox
Create a new form.
frm = appAccess.CreateForm()
frm.RecordSource = “tblTest”
txt = appAccess.CreateControl(FormName:=frm.Name, _
ControlType:=Microsoft.Office.Interop.Access.AcControlType.acTextBox, _
Section:=Microsoft.Office.Interop.Access.AcSection.acDetail, _
Left:=0, Top:=0, Width:=2500, Height:=400)
lbl = appAccess.CreateControl(FormName:=frm.Name, _
ControlType:=Microsoft.Office.Interop.Access.AcControlType.acLabel, _
Section:=Microsoft.Office.Interop.Access.AcSection.acDetail, _
Left:=0, Top:=1000, Width:=2500, Height:=400)
cbo = appAccess.CreateControl(FormName:=frm.Name, _
ControlType:=Microsoft.Office.Interop.Access.AcControlType.acComboBox, _

Section:=Microsoft.Office.Interop.Access.AcSection.acDetail, _
Left:=0, Top:=2000, Width:=2500, Height:=400)
lst = appAccess.CreateControl(FormName:=frm.Name, _
ControlType:=Microsoft.Office.Interop.Access.AcControlType.acListBox, _
Section:=Microsoft.Office.Interop.Access.AcSection.acDetail, _
Left:=0, Top:=3000, Width:=2500, Height:=400)
579
Customizing the Access Ribbon with a Visual Studio 2005 Shared Add-in
16
22_047026 ch16.qxp 4/2/07 10:07 PM Page 579
chk = appAccess.CreateControl(FormName:=frm.Name, _
ControlType:=Microsoft.Office.Interop.Access.AcControlType.acCheckBox, _
Section:=Microsoft.Office.Interop.Access.AcSection.acDetail, _
Left:=0, Top:=4000, Width:=2500, Height:=400)
ErrorHandlerExit:
Exit Sub
ErrorHandler:
AddInErr(Err)
Resume ErrorHandlerExit
End Sub
Public Sub CreateNewReport(ByVal control As _
Microsoft.Office.Core.IRibbonControl)
On Error GoTo ErrorHandler
Dim rpt As Microsoft.Office.Interop.Access.Report
Dim txt As Microsoft.Office.Interop.Access.TextBox
Dim lbl As Microsoft.Office.Interop.Access.Label
Dim cbo As Microsoft.Office.Interop.Access.ComboBox
Dim lst As Microsoft.Office.Interop.Access.ListBox
Dim chk As Microsoft.Office.Interop.Access.CheckBox
Create a new report.

rpt = appAccess.CreateReport()
rpt.RecordSource = “tblTest”
txt = appAccess.CreateReportControl(ReportName:=rpt.Name, _
ControlType:=Microsoft.Office.Interop.Access.AcControlType.acTextBox, _
Section:=Microsoft.Office.Interop.Access.AcSection.acDetail, _
Left:=0, Top:=0, Width:=2500, Height:=400)
lbl = appAccess.CreateReportControl(ReportName:=rpt.Name, _
ControlType:=Microsoft.Office.Interop.Access.AcControlType.acLabel, _
Section:=Microsoft.Office.Interop.Access.AcSection.acDetail, _
Left:=0, Top:=1000, Width:=2500, Height:=400)
cbo = appAccess.CreateReportControl(ReportName:=rpt.Name, _
ControlType:=Microsoft.Office.Interop.Access.AcControlType.acComboBox, _
Section:=Microsoft.Office.Interop.Access.AcSection.acDetail, _
Left:=0, Top:=2000, Width:=2500, Height:=400)
lst = appAccess.CreateReportControl(ReportName:=rpt.Name, _
ControlType:=Microsoft.Office.Interop.Access.AcControlType.acListBox, _
Section:=Microsoft.Office.Interop.Access.AcSection.acDetail, _
Left:=0, Top:=3000, Width:=2500, Height:=400)
580
Adding More Functionality to Office
Part III
22_047026 ch16.qxp 4/2/07 10:07 PM Page 580
chk = appAccess.CreateReportControl(ReportName:=rpt.Name, _
ControlType:=Microsoft.Office.Interop.Access.AcControlType.acCheckBox, _
Section:=Microsoft.Office.Interop.Access.AcSection.acDetail, _
Left:=0, Top:=4000, Width:=2500, Height:=400)
ErrorHandlerExit:
Exit Sub
ErrorHandler:
AddInErr(Err)

Resume ErrorHandlerExit
End Sub
Public Sub AddInErr(ByVal errX As ErrObject)
Displays a message box with error information.
Dim strMsg As String
strMsg = _
“An error occurred in the Extras add-in” _
& Microsoft.VisualBasic.Constants.vbCrLf _
& “Error #:” & errX.Number _
& Microsoft.VisualBasic.Constants.vbCrLf _
& “Description: “ & errX.Description
MsgBox(strMsg, MsgBoxStyle.Critical, “Error!”)
End Sub
The syntax for named constants is much more verbose in Visual Studio 2005 than in
Access VBA or VB 6: Instead of (for example)
acControlType, you need the full enum
reference,
Microsoft.Office.Interop.Access.acControlType.
If you turn on the Error List pane (View ➪ Error List), you will see a number of warnings
about implicit conversion of a variable from Access control to a specific Access control type (see
Figure 16.23).
In general, you can clear up conversion warnings by using a conversion function in the code, but
Visual Studio 2005 doesn’t have any conversion functions for Access controls, so you just have to
live with the warnings (the code will run fine).
NOTE
NOTE
581
Customizing the Access Ribbon with a Visual Studio 2005 Shared Add-in
16
22_047026 ch16.qxp 4/2/07 10:07 PM Page 581