display pdf winform c# : Rotate all pages in pdf preview Library SDK component .net asp.net html mvc 7053154973-Excel%202007%20VBA%20Programmers%20Reference%20-%20Wrox%20200743-part670

Save the project and make the Add-In DLL by clicking File ➪Make Excel2007ProgRef.dll, and then open
Excel 2007 (note that you will not be able to subsequently rebuild the DLL if it is being accessed by Excel
at the time). As Excel opens, you’ll see a Connected message pop up as the Add-In is connected, and a
Disconnected message when Excel is closed. You will also get these messages if you load or unload the
Add-In using the COM Add-Ins dialog.
Responding to Excel’s Events
The Designer code module is a type of class module that allows you to declare a variable WithEvents,
to hook into their events. In the previous code, you hooked into the Excel Application events, enabling
the COM Add-In to respond to the users opening or closing workbooks, changing data in cells, and so
on, in the same way you can in a normal Excel Add-In. See Chapters 8 and 16 for more information
about these events.
Adding CommandBar Controls
Prior to Excel 2007, you used the CommandBars objects to create all menus and toolbars. In Excel 2007,
the Ribbon replaced the top-level menus and toolbars, but you still use the CommandBars objects for the
popup menus. This example COM Add-In adds two menu items to the cell’s right-click popup menu to
show Wizard forms to assist in the entry of Automation Add-In formulas. Using the Ribbon with COM
Add-Ins is explained later in the chapter. 
Once you have a reference to the Excel Application object, you can add buttons to command bars in
the same way as described in Chapter 15. The only difference is how the code responds to a button being
When adding a CommandBarButton from within Excel, set its OnActionproperty to be the name of the
VBA procedure to run when the button is clicked.
When adding a CommandBarButton from outside Excel (from within a COM Add-In), hook the button’s
Clickevent using a variable declared WithEventsinside the Add-In.
To use CommandBarButtons, you need a reference to the Office object library, so click Project➪References
and check the Microsoft Office 12.0 Object Library.
Delete any code that may already exist in the Designer’s code module (such as the example code added
in the previous section), and replace it with the following. This defines the class-level variables you’ll be
using to store the reference to the Excel Application object, and to hook the CommandBarButton’s
Dim WithEvents moXL As Excel.Application
Dim WithEvents moBtn As Office.CommandBarButton
Const msAddInTag As String = “Excel2007ProgRefTag”
When you hook a command bar button’s events using the WithEvents keyword, the variable (moBtn) is
associated with the Tagproperty of the button it’s set to reference. All buttons that share the same Tag
will cause the Click event to fire. In this way, you can handle the click events for all your buttons
Chapter 18: Automation Add-Ins and COM Add-Ins
Rotate all pages in pdf preview - rotate PDF page permanently in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Users to Change the Rotation Angle of PDF File Page Using C#
rotate pdf pages by degrees; save pdf rotated pages
Rotate all pages in pdf preview - VB.NET PDF Page Rotate Library: rotate PDF page permanently in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
PDF Document Page Rotation in Visual Basic .NET Class Application
how to permanently rotate pdf pages; how to rotate pdf pages and save permanently
using a single WithEventsvariable, by ensuring they all have the same Tag. You can distinguish
between buttons by giving them each a unique Parameter property as you create them in the
OnConnectionmethod, which should be copied into the Designer’s code module:
‘ The IDTExtensibility2_OnConnection method is handled by the Designer,
‘ and exposed to us through the Add-InInstance_OnConnection method
Private Sub AddInInstance_OnConnection( _
ByVal Application As Object, _
ByVal ConnectMode As AddInDesignerObjects.ext_ConnectMode, _
ByVal AddInInst As Object, custom() As Variant)
Dim oToolsBar As CommandBar, oBtn As CommandBarButton
Set moXL = Application
‘ Get a reference to the cell right-click menus
Set oToolsBar = moXL.CommandBars(“Cell”)
‘ If our controls don’t exist on the menu bar, add them
‘ Handle errors in-line (such as the button not existing)
On Error Resume Next
‘ Check for, and add, the ‘Sequence Wizard’ button
Set oBtn = oToolsBar.Controls(“Sequence Wizard”)
If oBtn Is Nothing Then
Set oBtn = oToolsBar.Controls.Add( _
msoControlButton, ,”SequenceWiz”, , True)
With oBtn
.Caption = “Sequence Wizard”
.Style = msoButtonCaption
.Tag = msAddInTag
End With
End If
‘ Check for, and add, the ‘RandUnique Wizard’ button
Set oBtn = Nothing
Set oBtn = oToolsBar.Controls(“RandUnique Wizard”)
If oBtn Is Nothing Then
Set oBtn = oToolsBar.Controls.Add( _
msoControlButton, , “RandUniqueWiz”, , True)
With oBtn
.Caption = “RandUnique Wizard”
.Style = msoButtonCaption
.Tag = msAddInTag
End With
End If
‘ Set the WithEvents object to hook these buttons. All buttons 
‘ that share the same Tag property will fire the moBtn_Click event
Set moBtn = oBtn
End Sub
Chapter 18: Automation Add-Ins and COM Add-Ins
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Also a preview component enables compressing and decompressing in preview in ASP.NET All object data. VB.NET Demo Code to Optimize An Exist PDF File in Visual
rotate all pages in pdf preview; pdf rotate page and save
How to C#: Preview Document Content Using XDoc.Word
if (bmp == null) throw new Exception("fail to load the document preview"); //. Copyright © <2000-2016> by <RasterEdge.com>. All Rights Reserved.
rotate pages in pdf expert; permanently rotate pdf pages
Although you set the Temporary parameter to True when adding the controls, it is good practice to
delete them when the Add-In is unloaded, using the OnDisconnectionevent:
‘ The IDTExtensibility2_OnDisconnection method is handled by the Designer,
‘ and exposed to us through the AddInInstance_OnDisconnection method
Private Sub AddInInstance_OnDisconnection( _
ByVal RemoveMode As AddInDesignerObjects.ext_DisconnectMode, _
custom() As Variant)
Dim oCtl As CommandBarControl
‘ Find and remove the buttons
For Each oCtl In moXL.CommandBars.FindControls(Tag:=msAddInTag)
Set moBtn = Nothing
Set moXL = Nothing
End Sub
In the Click event, you check the Parameter property of the button that was clicked and show the
appropriate form. For this example, just add two blank forms to the project, giving them the names
frmSequenceWizand frmRandUniqueWiz:
‘ The moBtn_Click event is fired when any of our commandbar buttons are 
‘ clicked. This is because the event handler is associated with the Tag
‘ property of the button, not the button itself. Hence, all buttons that
‘ have the same Tag will fire this event.
Private Sub moBtn_Click(ByVal Ctrl As Office.CommandBarButton, _
CancelDefault As Boolean)
‘ Check that a cell range is selected
If TypeOf moXL.Selection Is Range Then
‘ Run the appropriate form, depending on the control’s Parameter
Select Case Ctrl.Parameter
Case “SequenceWiz”
frmSequenceWiz.Show vbModal
Case “RandUniqueWiz”
frmRandUniqueWiz.Show vbModal
End Select
‘ Display an error message if a range is not selected
MsgBox “A range must be selected to run the Wizard.”, vbOKOnly, _
“Excel 2007 Prog Ref Wizards”
End If
End Sub
Chapter 18: Automation Add-Ins and COM Add-Ins
How to C#: Preview Document Content Using XDoc.PowerPoint
if (bmp == null) throw new Exception("fail to load the document preview"); //. Copyright © <2000-2016> by <RasterEdge.com>. All Rights Reserved.
pdf expert rotate page; reverse page order pdf
C# WinForms Viewer: Load, View, Convert, Annotate and Edit PDF
Erase PDF pages. Miscellaneous. Plenty of VB.NET class demo codes and tutorials are given on How to Use XDoc.PDF SDK in VB.NET program. All Rights Reserved.
rotate single page in pdf; rotate all pages in pdf and save
Save the project and use File ➪Make Excel2007ProgRef.dll to create the DLL, which also adds the reg-
istry entries for Excel to see it. Start Excel 2007, right-click a cell, and click the Sequence Wizard menu to
show the Wizard form.
Using a COM Add-In from VBA
It is possible (though unfortunately quite rare) for the creator of a COM Add-In to provide program-
matic access to the Add-In from VBA. This would be done either to:
Expose the Add-In’s functionality for use through code
Provide a mechanism for controlling or customizing the Add-In
It is achieved by setting the Add-In instance’s Object property to reference the COM Add-In class 
(or a separate class within the Add-In), and then exposing the required functionality using Public prop-
erties and methods, just like any other class. This example provides yet another way of getting to the
Sequenceand RandUniquefunctions.
Add the following lines to the bottom of the AddInInstance_OnConnection routine, to provide a ref-
erence to the Add-In class using the Add-In’s Objectproperty:
‘ Set the Add-In instance’s Object property to be this class, providing
‘ access to the Com Add-In’s object model from within VBA. Note that we
‘ don’t use Set here!
AddInInst.Object = Me
And add the following code to the bottom of the Designer’s class module, to create and return new
instances of our Simple and Complex classes:
‘ Property to return a reference to our Simple class, providing access
‘ from VBA:
‘vaSeq = Application.ComAddIns(“Excel2007ProgRef.ComAddIn”).Object _
‘        .SimpleFuncs.Sequence(...)
Public Property Get SimpleFuncs() As Simple
Set SimpleFuncs = New Simple
End Property
‘ Property to return a reference to our Complex class, providing access
‘ from VBA:
‘vaRU = Application.ComAddIns(“Excel2007ProgRef.ComAddIn”).Object _
‘       .ComplexFuncs.RandUnique(...)
Public Property Get ComplexFuncs() As Complex
Set ComplexFuncs = New Complex
End Property
From within Excel, you can then use the following code to access the Sequence function, going through
the COM Add-In and its Object property:
Private Sub CommandButton1_Click()
Dim vaSequence As Variant
‘ Get the sequence using the COM Add-In
Chapter 18: Automation Add-Ins and COM Add-Ins
C# WPF Viewer: Load, View, Convert, Annotate and Edit PDF
Erase PDF pages. Miscellaneous. Plenty of VB.NET class demo codes and tutorials are given on How to Use XDoc.PDF SDK in VB.NET program. All Rights Reserved.
pdf rotate pages and save; pdf reverse page order
C# PDF Page Insert Library: insert pages into PDF file in C#.net
as how to merge PDF document files by C# code, how to rotate PDF document page This C# demo explains how to insert empty pages to a specific All Rights Reserved
rotate pdf pages individually; rotate individual pages in pdf reader
vaSequence = Application.ComAddIns(“Excel2007ProgRef.ComAddIn”) _
.Object.SimpleFuncs.Sequence(5, 10, 2)
‘ Write the sequence to the sheet
ActiveCell.Resize(1, 5) = vaSequence
End Sub
The key point about using this method is that you are accessing the same instance of the class that Excel
is using for the Add-In, allowing you to manipulate, query, or control that Add-In from VBA. For more
complex COM Add-Ins, the same method can be used to provide access to a full object model for con-
trolling the Add-In.
Adding Ribbon Controls
Chapter 14 explained how VBA applications can modify the Ribbon by creating custom tabs, groups, 
or controls. This was done by creating a text file containing the XML for the custom UI definition and
adding it to the XML workbook file. When Excel loads the workbook, it sees the custom part and pro-
cesses it, creating custom controls. As designed, this allows you to create document-level RibbonX cus-
tomizations, but that chapter demonstrated how to achieve application-level customizations by simply
using a standard Excel XMLAdd-In (.xlam). The “official” approach to application-level UI customiza-
tions is to use a COM Add-In.
Obviously, COM Add-Ins don’t have an XML workbook that Excel can check for any custom UI XML.
Instead, each time Excel 2007 loads a COM Add-In, it checks to see if the Add-In implements another
specific interface, IRibbonExtensibility. If that interface is found, Excel calls its GetCustomUI func-
tion and the Add-In returns the custom UI XML as text. After that point, the behavior of a COM Add-In
is exactly the same as the VBA code shown in Chapter 14, except that all the callbacks must exist in the
same class that implements the IRibbonExtensibilityinterface. To demonstrate this concept, this
section creates a simple COM Add-In that uses RibbonX to add a menu to Excel’s View tab. Start by cre-
ating a new VB6 Add-In project and performing the following steps to configure it correctly:
Remove the default form.
Delete all the code from the Designer Connect class.
Edit the Designer to give it a meaningful name and description, targeting Excel 12.0 and loading
at startup.
Change the project name from MyAddIn to XLVBARibbonX.
Click Project➪References and uncheck the reference to the Visual Basic 6.0 Extensibility library.
Check that the project references the Microsoft Excel 12.0 Object Library and the Microsoft
Office 12.0 Object Library (which contains the definition of the IRibbonExtensibilityinter-
face), adding them if they’re missing.
Copy the following code into the Connect class (which can also be found in the XLVBARibbonX
folder in the code download for this chapter):
‘Implement an interface to tell Excel we’re doing things with RibbonX
Implements IRibbonExtensibility
‘Store a reference to the ribbon, so we can invalidate controls when needed
Chapter 18: Automation Add-Ins and COM Add-Ins
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit Raster
NET RasterEdge HTML5 Viewer offers user the functionality to rotate images 90 images to Tiff (.tif, .tiff) online, create PDF document from All Rights Reserved
rotate all pages in pdf; rotate one page in pdf reader
C# TIFF: TIFF Editor SDK to Read & Manipulate TIFF File Using C#.
Here we list all features supported by RasterEdge C#.NET to process Tiff file and its pages, like merge append, split, extract, create, insert, rotate, sort, etc
pdf rotate pages separately; rotate pdf pages
Dim moRibbon As IRibbonUI
‘Called by Excel at startup. Provide the custom UI.
Private Function IRibbonExtensibility_GetCustomUI(ByVal RibbonID As String) _
As String
Dim sXML As String
‘Build the XML for the custom UI
‘Here, we’re Adding a simple button to the middle of Excel’s View tab
‘Typically, this would be read from a resource file
sXML = “”
sXML = sXML & “<customUI “ & _
“xmlns=””http://schemas.microsoft.com/office/2006/01/customui”” “ & _ 
sXML = sXML & “  <ribbon>”
sXML = sXML & “    <tabs>”
sXML = sXML & “      <tab idMso=””TabView””>”
sXML = sXML & “        <group id=””XLVBAView”” “
sXML = sXML & “         insertAfterMso=””GroupViewShowHide”” “ 
sXML = sXML & “         label=””VBA Prog Ref””>”
sXML = sXML & “          <button id=””CTPTest”” label=””A Test”” “
sXML = sXML & “           imageMso=””DateAndTimeInsert”” size=””large”” “
sXML = sXML & “           onAction=””CTPTest_Click””/>”
sXML = sXML & “        </group>”
sXML = sXML & “      </tab>”
sXML = sXML & “    </tabs>”
sXML = sXML & “  </ribbon>”
sXML = sXML & “</customUI>”
IRibbonExtensibility_GetCustomUI = sXML
End Function
‘Called by Excel to provide the Ribbon object, 
‘which is used to invalidate controls, forcing a refresh.
Public Sub CustomUI_OnLoad(ribbon As IRibbonUI)
Set moRibbon = ribbon
End Sub
‘Show a message when the button is clicked
Public Sub CTPTest_Click(control As IRibbonControl)
MsgBox “Clicked me!”
End Sub
Compile the DLL, start Excel 2007, click the View tab, and click the Date Picker button in the middle of
the tab. You should get the Clicked me! message box.
Note that the GetCustomUI function is only called once in the life of the COM Add-In, at startup. That
means you have only the one opportunity to provide your custom UI XML. Although you can change
the visibility of controls, in practice that means you are extremely limited in the degree to which you can
change your UI in response to changes within Excel (such as opening or closing workbooks). This is a
serious deficiency of the COM Add-In RibbonX extensibility model. Instead of being asked to provide
CustomUI XML at startup, Excel should provide a reference to a class factory the Add-In could use to
create or modify UI customizations at any time during its life. As you’ll see later in this chapter, that
design is used for custom task panes and it works extremely well.
Chapter 18: Automation Add-Ins and COM Add-Ins
VB.NET PDF File Split Library: Split, seperate PDF into multiple
limit the pages of each file to 8 pages options.MaxPages = 8 outputFileName + "_" + i.ToString() + ".pdf") Next ' Split input PDF file to All Rights Reserved.
rotate individual pdf pages reader; save pdf after rotating pages
VB.NET PDF remove image library: remove, delete images from PDF in
pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET Remove multiple or all image objects from PDF Remove PDF image in preview without adobe PDF reader
how to rotate a pdf page in reader; rotate one page in pdf
Creating Custom Task Panes
When task panes were introduced in Office XP, developers were soon eager to use them for their own con-
tent. In Office 2007, Microsoft has answered that request by adding the ability for COM Add-Ins to create
custom task panes (CTPs), using custom ActiveX controls to define their content. Just like RibbonX, 
the COM Add-In tells Excel that it contains a custom task pane by implementing another interface,
ICustomTaskPaneConsumer. ACOM Add-In, therefore, needs to do the following to create a CTP:
Implement the ICustomTaskPaneConsumer interface, which contains a single method,
The CTPFactoryAvailable procedure is passed a reference to Excel’s CTP factory class, which
the Add-In stores in a module-level variable.
Design a custom ActiveX control to provide the content of the CTP.
Create, show, and hide the CTP in response to a user trigger.
From a VBAdeveloper’s perspective, the restriction that you can only use ActiveX controls to provide
the CTP content is a rather nasty one, because you can’t create ActiveX controls using VBA. There are,
however, two ways to get around that. The first is to realize that there are a number of readily available
ActiveX controls that you can drop into a CTP, such as the Web Browser control. All you need is a simple
COM Add-In that exposes the capability to create new CTPs to VBA, then use VBA code to create a CTP
containing a Web Browser control and automate the Web Browser control to show an HTML page. To
create the COM Add-In, follow the steps listed in the “Adding Ribbon Controls” section, give the project
the name OACTPVBA, and copy in the following code to implement the ICustomTaskPaneConsumer
interface and expose CTP creation to VBA:
‘Tell Excel that we’re working with custom task panes
Implements ICustomTaskPaneConsumer
‘Store a reference to Excel’s CTP factory class
Dim moCTPFactory As ICTPFactory
‘Expose the functions in this class to VBA
Private Sub AddInInstance_OnConnection(ByVal Application As Object, _
ByVal ConnectMode As AddInDesignerObjects.ext_ConnectMode, _
ByVal AddInInst As Object, custom() As Variant)
AddInInst.object = Me
End Sub
‘Called by Excel when the Add-In is loaded, 
‘providing a factory object that we use to
‘create custom task panes.
Private Sub ICustomTaskPaneConsumer_CTPFactoryAvailable( _
ByVal CTPFactoryInst As Office.ICTPFactory)
‘Store a reference to the factory object, for use when required
Set moCTPFactory = CTPFactoryInst
End Sub
‘Expose CTP-creation to VBA, e.g. to create a web browser task pane:
‘Dim moCTP As CustomTaskPane
‘Set moCTP = Application.ComAddIns(“OACTPVBA.Connect”).Object
Chapter 18: Automation Add-Ins and COM Add-Ins
‘            .CreateTaskPane(“Internet Explorer”,”Shell.Explorer.2”)
Public Function CreateTaskPane(ByVal sTitle As String, _
ByVal sProgID As String) As Office.CustomTaskPane
On Error Resume Next
Set CreateTaskPane = moCTPFactory.CreateCTP(sProgID, sTitle)
End Function
Compile the DLL, start Excel, and use the following VBA code in a standard module to show Google in a
custom task pane:
‘Keep a reference to the CTP, so we can show/hide it
Dim moCTP As CustomTaskPane
Sub ShowGoogleCTP()
‘Create the CTP containing a Web Browser control
Set moCTP = Application.COMAddIns(“OACTPVBA.Connect”).Object _
.CreateTaskPane(“Internet Explorer”, “Shell.Explorer.2”)
‘Show the CTP
moCTP.Visible = True
‘Navigate to Google
moCTP.ContentControl.navigate “http://www.google.com”
End Sub
It’s enlightening to compare the way in which CTPs have been implemented to the RibbonX mechanism.
For CTPs, when the COM Add-In starts up, Excel passes a factory class into the CTPFactoryAvailable
method, which is stored in a module-level variable. You can then use the factory class to create new
instances of custom task panes at any time you like. In turn, that allows you to very easily expose the
new CTP functionality to VBA. In contrast, the RibbonX design requires you to specify all customization
as soon as the COM Add-In starts, so you can only create one customization snippet and can neither
expose the RibbonX features to VBAnor create dynamic interfaces that respond to the changing Excel
Showing VBA UserForms as Task Panes
While CTPs are a very useful addition to Excel VBA, you’re either limited by the set of generally avail-
able ActiveX controls or you need to learn how to create your own ActiveX controls. Although this is
beyond the scope of this book, it is actually quite easy to do, using either VB6 or .NET.
There is, however, a third possibility, which is for someone to create a custom ActiveX control that can in
turn host a normal VBA UserForm—and we’ve done exactly that! The OACTPUserformHost is a single
ocx file containing both a COM Add-In and an ActiveX control, and it’s available as one of the download
files for this chapter from www.wrox.com.
Load the COM Add-In by using the Add... button on the COM Add-Ins dialog (Office Menu➪Excel
Options➪Add-Ins➪Manage: COM Add-Ins➪Go), choosing Files of Type: All Files, and navigating to
the OACTPUserformHost.ocx file.
Chapter 18: Automation Add-Ins and COM Add-Ins
You can show a standard VBA UserForm as a task pane by including the following code within the
UserForm’s code module. You’ll first need to add a Project reference to the OACTPUserformHost library,
listed as Custom Task Pane Userform Host in the Project References dialog. If not in the list, it can be
added by clicking the Browse button, choosing Files of Type: ActiveX Controls, and navigating to the
‘A WithEvents object variable to refer to the Custom Task Pane Userform Host
‘object. Requires a reference to OACTPUserformHost.OCX, listed as 
‘“Custom Task Pane Userform Host” in the Project References dialog
Dim WithEvents moCTP As CTPUserformHost
‘ Public method to show a VBA userform in a custom
‘ task pane. Typical usage is:
‘ UserformName.ShowAsTaskPane
Public Sub ShowAsTaskPane()
If moCTP Is Nothing Then
‘Create a task pane with the required title
Set moCTP = Application.COMAddIns(“OACTPUserformHost.Connect”).Object _
.CreateUserformTaskPaneHost(Me, “Hello World”)
With moCTP
‘Set the task pane’s properties
‘(default = msoCTPDockPositionRestrictNone)
.DockPositionRestrict = msoCTPDockPositionRestrictNone   
‘(default = msoCTPDockPositionRight)
.DockPosition = msoCTPDockPositionRight          
‘Tell the task pane whether to handle the userform’s resizing
‘(default = False)
.HandleResizing = True                                   
End With
End If
‘Make the task pane visible
moCTP.Visible = True
End Sub
‘Close the CTP when the form is unloaded
Private Sub UserForm_Terminate()
On Error Resume Next
moCTP.Visible = False
Set moCTP = Nothing
End Sub
Acall to Userform.ShowAsTaskPaneuses the OACTPUserformHost COM Add-In to create a custom
task pane hosting the UserForm, which is then initialized and displayed. As well as acting as a host for
the UserForm, the COM Add-In also handles the form’s resizing, using the technique for resizable forms
shown in Chapter 27.
Chapter 18: Automation Add-Ins and COM Add-Ins
Putting it all Together
By adding extra interfaces that a COM Add-In can choose to implement, Microsoft has created an easily
extensible architecture that works across all the Office applications and across multiple development
platforms—commonly VB6 and .NET. Afeature-rich COM Add-In can implement all three interfaces
(IDTExtensibility2IRibbonExtensibility, and ICustomTaskPaneConsumer) to deliver its func-
tionality. The sample XLVBADatePicker COM Add-In does this to create a custom task pane that con-
tains the standard Month View control, with a RibbonX toggle button to control its visibility. To make it
all work seamlessly, it handles the following events:
When the toggle button is clicked, the task pane is shown or hidden.
When the user closes the task pane, the toggle button is restored.
When a date is selected in the task pane, the value is put into the active cell.
When a cell containing a date is selected, the task pane shows that date in the calendar.
You can find the complete code for the COM Add-In at www.wrox.com, in the XLVBADatePicker folder
in the sample downloads for this chapter.
Linking to Multiple Office Applications
The start of this chapter mentioned that one of the fundamental advantages of COM Add-Ins over xla
or xlamAdd-Ins is that the same DLL can target multiple Office applications. All you need to do to
achieve this is to add a new Add-In Designer class for each application you want to target, in exactly
the same way you added the Designer to target Excel previously in the chapter. Of course, you still
have to handle the idiosyncrasies of each application separately.
In the following simple example, you make the Sequence function available through the COM Add-Ins
collection in Access and use it to populate a list box on a form.
Start by opening the Excel2007ProgRef project and adding a new Add-In class to the project. In the
Properties window, change its name to AccessAddIn, set its Public property to True (ignoring any
warnings), and complete the Designer’s form as follows:
Add-In Display Name
Excel 2007 Prog Ref Sequence
Addin Description
Example to expose the Sequence function through Access’ COM
Microsoft Access
Application Version
Microsoft Access 12.0
Initial Load Behavior
Click View➪Code and copy the following into the Designer’s code module:
‘ Simple COM Add-In to provide the Sequence function to MS Access,
‘ through Access’ COMAdd-Ins collection
Private Sub Add-InInstance_OnConnection(ByVal Application As Object, _
Chapter 18: Automation Add-Ins and COM Add-Ins
Documents you may be interested
Documents you may be interested