This tutorial shows how you can have a Microsoft Office (Word, Excel,…)
call your Delphi application. For the demonstration, I will use Word.
From Word, a macro will call my Delphi application which will prompt the
user for some data which will be inserted in the Word document.
In the real world, it is likely that your Delphi application will be a
large application managing enterprise data. Calling it from Word or
Excel will use existing function to fetch data and return it back to
Word or Excel.
In this tutorial, we will:
- Create a simple automatable Delphi application
- Create a Word VBA macro invoking the automatable Delphi application to get data and insert it in the document.
To build this tutorial I used Delphi XE3 and Word 2010. You can apply
the same features using other Delphi or Word versions. Details may vary
slightly with different versions but globally it remains the same.
Automatable Delphi application
Let’s create an automatable Delphi application!
Launch Delphi and create a new “VCL Forms Application” (File / New / VCL Forms Application – Delphi).
Save the application: Do Menu / File / Save project, name the main form
unit “DelphiAppMain.pas” and the project file “DelphiApp.dproj”. Compile
and run just to check everything is OK.
To make the application automatable, we need to add an “Automation
object”. Do Menu / File / Other. Select Delphi projects / ActiveX on the
left and select “Automation Object” on the right.
Click OK. On the next form, fill the fields as shown in this screen capture:
Click OK. On the next form, fill the fields as shown in this screen capture:
CoClass name “DataInterface” will be used in the VBA code we will see in a moment.
Description is anything you like to describe your application.
Threading model and Instancing will instruct the Windows COM engine
about how to handle request. Using “single” and “Single instance” will
make your application run automatically for each request. This may not
be the best choice in all cases, but for now, it is the simplest and
working choice suitable for this simple application.
Click OK to save your changes. This will create three files:
- DelphiApp.ridl (A type library source file)
- DelphiApp_TLB.pas (The type library imported into Delphi code)
- Unit1.pas (A class to implement the interfaces declared in the type library)
In the project manager (Ctrl+Alt+F11 if it is not displayed), you see the files in our project:
In the main window, where you normally see your code, you should now see
the “type library editor”. If yoy don’t see it, do Menu / View / Type
Library.
Right click on IDataInterface branch on the treeview. Click on “New” and select “Method”:
Change the name to “ReadData”:
“ReadData” is the name of the function we will call from VBA macro. Now
we need to create and describe the arguments and return value. Since we
intent to ask the user some data, we will pass two arguments and have a
return value:
- A string to prompt the user
- A reference to a string to return the data
- Return value will be an integer
In the type library editor, there is a tab with parameters. There is button to add or delete parameters.
Data type deserve a little bit of explanations. Since OLE / COM /
ActiveX is independent of the language, the data types are not only
limited to a subset of what Delphi can handle, but their names is
somewhat different than what Delphi uses. To make a long discussion
short, here we need string and integer. Strings are named “BSTR” and
integers are named “int”. We have in and/or out parameters. For “out”
parameters, we must use a pointer. A pointer is specified by appending a
start to the type name. So “int*” correspond to Delphi ^integer (A
pointer to an integer).
The return value, as seen from VBA code, is an “out” parameter marked as
“retval”. Do not confuse this return value with “return type” which
should always be HRESULT is merely describe a low level API return value
and type we don’t really care here.
With that knowledge, fill in the type library as the screen dump below shows:
Once the screen is as shown, click on the “Refresh implementation” tool button.
Click on the “Save All” button in Delphi main tool bar. This will prompt
you for the implementation unit name currently named “unit1”. Name it
“DelphiAppComInterface.pas”. You are also prompted for the type library
file. Name it “DelphiApp_TLB.pas”.
Click on the DelphiAppComInterface tab to have a look at the source code
which has been generated for you. You should see a single class named
TDataInterface with a single method named ReadAdata, taking two
WideString parameters Prompt and Value. The first is “const” , the
second is “var”. This correspond to the “[in]” and “[in, out]” modifiers
we used in the type library editor. The return value is of type SYSINT
which is an alias of “integer”.
Here is the code:
Now we have to fill the gap and write the implementation code:
To use “InputQuery”, add “Dialogs” into the uses clause. ReadData, in my
mind, is made to return a kind of error code. In a real application,
you would query the data from some data source which might trigger
several error conditions. ReadData should map those conditions to error
codes and return it. Here in this tutorial, we just return 0 if OK and 1
as a single error code saying “not OK”.
We can compile and run the application which will just… do nothing!
Technically, the automatable application is an out of process COM object
as Microsoft names it. Delphi runtime has everything required to build
such a beast and this is exactly what we have done so far. Well, we just
instructed Delphi to generate all the code except a single line…
As we wrote it, the application only responds when invoked from the
outside via a COM interface. As it is now, that COM interface already
exists but is almost unusable unless it is registered in Windows
registry so that other applications can locate it, learn which
interfaces are defined and call one of the interfaces methods.
Registering the application
COM object must be registered Windows registry. We don’t need to know
all the complexity involved in that registration since Delphi runtime
provides a method for doing exactly that.
When you build an application containing an automation object, Delphi
runtime silently add command line argument processing to register and
unregister your application in the OLE registry keys.
You need administrator privilege to be able to register your
application. So first open a command line prompt with administrator
privilege by right clicking on the command prompt shortcut and select
“Run as administrator”. If asked, confirm. Then at the command prompt
type de fill path name for your application between double quotes and
add “/REGSERVER”. On my system, this gives:
“D:\Delphi\BlogArticle\Office\Word To Delphi\Win32\Debug\DelphiApp.exe” /REGSERVER
Nothing happens on screen and you get back the command prompt almost
immediately. Now DelphiApp is registered and can be used from any other
application capable of accessing a COM object. And this is the case for
Microsoft Office applications using VBA.
Writing a VBA macro to call DelphiApp
We need to write VBA code in Word. For that purpose, we have to make the
“Developer” ribbon page available: right click on the ribbon where
there is nothing and click “Customize the ribbon”. On the right list,
search for “Developer” and check the checkbox, then click OK. You should
now see the developer ribbon page displayed. (This may be different in
older Word versions. Consult Word online help).
On the “Developer” tab is visible, click on “Visual Basic” button (Alt+F11). This will bring the Visual Basic IDE.
In Visual Basic for Application (VBA) you must add a reference to your
automation object: click on the tools menu, then references and in the
dialog box, search for your automation object and check the checkbox on
the right of his name. In our case, the object is “DelphiApp”.
“DelphiApp” comes in that list because we registered our Delphi
application. If you don’t see it, you probably forgot to register it.
See the first part of this article to see which step you missed.
Next, you must write VBA code to call your Delphi application. Let’s
enter this code in a new module associated with “Normal”. “Normal” is
the template which is always used. This makes your macro available in
all documents. In VBA project explorer (Ctrl+R), right click on
“Normal”, and select “Insert” and then “Module”. You then see “Module1”
added in the “Project Explorer” and a code window where you’ll enter
your VBA instructions.
In the code window, you can add the following VBA code:
Once the macro is created, you may assign it to a keyboard shortcut or
to a ribbon button. Let’s see how you can do that with Word 2010:
Right click on the ribbon where there is nothing and select “Customize
ribbon” in the popup menu. You see 3 columns. Above the middle column,
in the drop down list, select “Macros”. You should now see your macro
“ReadDataFromDelphi”.
On the right side, you see all existing tabs. Click on the tab which you
would like to be just on the left of the new tab. Below the list, click
on the button “New tab”. This will create both a new tab and a new
group. Click on the new tab. Click on the button “Rename”. Select a new
name such as “DelphiApp”. Click on the new group. Click on the rename,
enter a new name such as “Delphi” and select an icon.
Click on your macro in the middle column. Click on the button “Add”
between the two right most columns. This will add your macro to the new
group. Select a name such as “ReadData” and an icon.
Finally, click OK! You now should see the new tab “DelphiApp” with a
single group “Delphi” having a single icon “ReadData”. Activate the tab
and click the icon. Your Delphi program will start and display the
InputQuery dialog box we programmed in Delphi.
My VBA code displays the value returned by DelphiApp using MsgBox. To
insert the value into the document, replace the call to MsgBox by:
Selection.Text = Value
That’ it!
No comments:
Post a Comment