Why should you create Add-Ins? We programmers always feel that we are short of several features while working with Microsoft tools, it seems that Microsoft hasn’t yet developed the tool we needed. In fact, Microsoft has done a wonderful job of adding new features to each release of its development tools. Obviously, Microsoft can’t design features to fulfill the needs of each and every programmer around the world, so Microsoft made Visual Basic an extensible product, thereby providing the way for VB developers to create their own features in VB.
What is EOM?
EOM Stands for Extensibility Object Model. You might ask what is extensibility? Extensibility is the capability to extend, stretch, the functionality of different development tools, specifically, Microsoft Integrated Development Environment (IDE). The IDE provides you with a programming interface known as the extensibility object model, a set of powerful interfaces for customizing the environment. It allows you to hook into the IDE to create extensions known as Add-Ins. A good system is one which can be extended without jeopardizing the primary functionality of the system.
To implement extensibility features, VB offers the powerful Extensibility Object Model. Through EOM, many core objects in VB itself are available to you at no extra charge. EOM is not that easy to learn, this article will provide you only the basics of Add-in creation, you will have to delve into this vast field yourself to explore the wonders you can do using the EOM.
EOM consists of six loosely coupled packages of objects with methods that implement key services of the VB development model. These are:
- Core Objects
- Form Manipulation
- Event Response
- Add-In Management
- Project and Component Manipulation
- Code Manipulation
This package is the main package used in the creation of Add-Ins. It has the following objects:
- The root object
IDTExtensibility Interface object
- The Visual Basic instance variable
The Root Object
VBE is the root object in Visual Basic. The VBE object is the base object for every extensibility object and collection in Visual Basic. Each object and collection owns a reference to the VBE property. The collections owned by the VBE object include the following:
The VBProjects Collection
This collection enables you to access a set of VB properties. This feature can be helpful if your development environment has an established process for developing software. Some of the key properties and methods of this collection are:
Filename: returns the full pathname of the group project file
Startproject: returns or sets the project that will start when users choose Start menu from the Run menu, click the Run button, or press F5 key.
AddFromFile: This is a method that enables the users to add or open a project or group object. Its only required argument is the string representing the path of the file you want to add.
AddFromTemplate: This method enables you to add project templates into the
VBProjects collection. Its only required argument is the string representing the path of the file you want to use as a template.
The Windows Collection
Windows collection, you can access the windows such as the project and properties windows. This collection enables you to access a group of all currently open code windows and designer windows.
The IDTExtensibility Interface Object
IDTExtensibility Interface Object exposes the public methods and properties of the extensibility model. By exposes, I mean that because you don’t directly use the services, methods and properties of the underlying extensibility model, you need to invoke the methods of the model’s agent, so to speak. You can think of interfaces as public agents for the private implementation of an extensibility model object you instantiate.
The Visual Basic Instance Variable
This is also known as dynamic identification variable. It identifies a particular instance of your VB session. This instance identifier enables you to have separately identifiable running instances of VB in memory.
The instance variable is of the type
VBIDE.VBE. To use this variable, declare it in a class module or general module.
Please refer to Microsoft website for complete details of these packages. Please understand that I cannot explain each and every detail of these packages in this short article. Let's get started with the creation of the Add-In.
We will build a simple Add-In that will count the number of lines of code for a given program component.
To begin creating the Add-In, start a new project. Choose the AddIn project type. The AddIn project type includes many components necessary for creating VB Add-Ins. There is a form that you can modify to provide a user interface for your Add-In. There is also a designer module that contains the four methods that are needed for the Add-In’s interface to VB.
Remove the OK and Cancel buttons from the form and add the following controls to the form:
Count Code Lines
Here is the complete code:
Public VBInstance As VBIDE.VBE
Public Connect As Connect
Private Sub cmdCountCodeLines_Click()
Dim strVBProject As String
Dim strVBComponent As String
Dim objVBComponent As VBComponent
strVBProject = txtProject.Text
strVBComponent = txtComponent.Text
Set objVBComponent = _
txtCodeLines.Text = Str(objVBComponent.CodeModule.CountOfLines)
Private Sub cmdDone_Click()
Let’s see what's in the code, the
cmdCountCodeLines_click() is triggered when the user clicks on the Count Code Lines button. It uses the project and component names that were typed into the form’s textbox controls to assign that component to the
objVBComponent object. Note the hierarchy used to obtain a component item in the following line of code:
Set objVBComponent = _
VBInstance object is referenced and then its
VBProjects collection, that project’s
VBComponents collection is accessed by using the
strVBComponent string as a key argument for the collection’s
Item method. This long sequence of referencing ultimately assigns the specified component that is part of the specified project (
strVBProject) to the
The following line of code:
txtCodeLines.Text = Str(objVBComponent.CodeModule.CountOfLines)
is used to access the
CodeModule of the newly assigned
objVBComponent object. The
countoflines property of the
CodeModule object contains the number of lines of code in that particular component. This number is assigned to the
txtCodeLines textbox so that the user can see the results.
The second event procedure that was added is the
cmdDone_click() event. This contains only a single line of code that calls the
Hide method, hiding the Add-In’s user interface. The
Connect object is an instance of the
Connect class, which, as you might remember, is a part of the AddIn project. It is defined in the form’s General declarations section.
In Connect Designer, in the
AddInInstance_OnConnection procedure, there is a line of code that looks like this:
Set mcbMenuCommandBar = AddToAddInCommandBar(“My AddIn”)
Change the “My AddIn” to “Code Line Counter”.
Save the project and compile the Add-In by choosing File | Make CodeLineCounter.dll from the menu. When the make project dialog box appears, be sure to specify that the executable file be placed in the same directory as VB. You want VB to have access to the Add-In later.
Before you can use the Add-In, you have to make a change to the VBADDIN.INI file so that VB will know that the Add-In is available. You will find this file in the Windows directory. Add the following line in the end of the file:
Save the file; then get back into VB. Open any project that you might happen to have handy. Then choose Add-In | Add-In Manager from the menu. You should see a list of Add-Ins. Select the codelinecounter, select the Load on startup and the Loaded/Unloaded check boxes, then click OK.
Invoke the Add-In by choosing it from that menu, and its user interface shows onscreen. Enter the name of the project currently open and then the name of the component. For example, the open project’s name is project1.vbp, enter project1 in the project textbox and the form’s name is form1.frm, enter form1 in the component textbox and click “Count Code Lines” button and you will see the number of lines in the “Code Lines” textbox.
S.S. Ahmed is a senior software engineer and works for a web and software development firm. Ahmed is a Microsoft Office SharePoint Server MVP. Ahmed specializes in creating database driven dynamic web sites. He has been creating customized SharePoint solutions for the last five years. Ahmed has worked in Visual Basic, Visual C, Java, ASP, .NET, SharePoint, InfoPath, BizTalk, etc. Ahmed enjoys travelling and has been to many parts of the world. Ahmed distributes most of his work freely to many internet sites. Ahmed also participates in different newsgroups and tries to help people out with their problems. Ahmed can be reached at email@example.com