Soundside Software » VBA

The Feasibility of Converting Office VBA Applications to VB6

David Horowitz — Thu, 15 Dec 2011 15:40:09 +0000

The first thing one should address in an article about converting Office VBA applications to VB6 is “WHY?”

Why would someone bother in the year 2011 to convert one decade-old technology to another decade-old technology?

The answer is this: many businesses are still using these technologies. Especially large firms find it takes many years to switch to the latest and greatest.

Some of my clients still use Office 2003 or even Office 2000.

And I’m not talking only about small companies who perhaps don’t know any better or who are on tight budgets. I’m talking about large multinationals, the largest companies in the world.

The next question is: why convert from Office VBA to VB6?

The answers:

To create a free-standing application executable, one which doesn’t use a Word document or template directly to house the code. Granted, there are other ways to do this, but using VB6 may be one of the simplest.
To take advantage of the speed advantage by using a compiled language like VB6 versus a semi-compiled/interpreted language like Office VBA.
To have your code run in a more stable environment – VB6 versus Office VBA.

While we won’t go into a detailed technical how-to here, we will address the feasibility.

The answer is: yes, it is feasible to convert Office VBA applications to VB6 applications.

The language syntaxes are virtually identical.

Here are a few pointers:

You must physically move the code. There are easy ways to do this.
You must set proper References to the Office libraries that are usually set by default within the Office VBA environment.
You must account for the differences between the Application object in Office VBA and the App object in VB6. They have little in common.
Generally, you may find it best to use full object qualification in your code. For example, I routinely use Word.Document as an object type in my Word VBA code rather than simply Document. This does tend to make things a bit easier when converting to VB6. If you do this, you can be sure you’re referring to the correct object type. The same object type may exist in different libraries. I also use Word.Application rather than simply Application.
With a bit of diligence and a cool head, you can successfully convert your Office VBA applications to VB6 applications.

Please feel free to contact us here at Soundside more information. And happy coding!

Getting the Range of the top of the next page in Word VBA

David Horowitz — Thu, 04 Nov 2010 23:57:06 +0000

I needed a function that would conveniently return me a Range that contained the top of the next page in a Word document.

The following does the trick:

Function TopOfNextPage(rng As Word.Range) As Word.Range
    Set TopOfNextPage = rng.Duplicate.GoTo(What:=wdGoToPage, Which:=wdGoToNext)
End Function

Notice it does not disturb the original Range. It accomplishes this by use of the Range.Duplicate function, which I find very handy sometimes when I don’t want to disturb my original Range.

Notice the returned Range is collapsed to the top of the page.

IsLastPage Function in Word VBA

David Horowitz — Thu, 04 Nov 2010 23:52:52 +0000

Here’s a handy little function that tells you if the end of a Range in Word VBA lies on the last page of the document:

Function IsLastPage(rng As Word.Range) As Boolean
     IsLastPage = CBool(rng.Information(wdActiveEndPageNumber) = rng.Information(wdNumberOfPagesInDocument))
End Function

The Range.Information function is very useful. Check it out!

We hope it comes in handy.

InsertFieldAfter Function in Word VBA

David Horowitz — Thu, 04 Nov 2010 23:48:22 +0000

I wanted a function in Word VBA that would add a Field to a Range’s Fields collection and automatically extend the Range to include the added field.

This mimics the behavior of the Range.InsertAfter function and similar functions.

It allows you to keep adding text, fields, and other items to a Word document sequentially.

The function I created is called InsertFieldAfter. Its parameters mimic the parameters to the Fields.Add function.

The Range you pass in is extended to include the newly added Field. The new Range is also returned as the function return value for convenience.

The text of the function and related support functions is below, followed by an example of how to use the function.

' Expand the Range to include the added field and return it. Public Function InsertFieldAfter( _
             ByRef Range As Word.Range, _
             ByVal FieldType As WdFieldType, _
             ByVal Text As String, _
             Optional ByVal PreserveFormatting As Boolean = False _
         ) As Word.Range
     On Error GoTo handler
     Dim StartPos As Long, EndPos As Long
     StartPos = Range.Start
     Range.Collapse Direction:=wdCollapseEnd
     EndPos = Range.Fields.Add( _
             Range:=Range, _
             Type:=FieldType, _
             Text:=Text, _
             PreserveFormatting:=PreserveFormatting) _
         .Result.End + 1
     Range.SetRange StartPos, EndPos
     Set InsertFieldAfter = Range
     Exit Function
handler:
     ' handle any run-time error here
End Function

Here’s a code snippet showing an example of its use:

With myRange
     .InsertAfter "Here is a field: "
     InsertFieldAfter Range:=myRange, FieldType:=wdFieldEmpty, Text:="REF Field1"
     .InsertAfter vbCrLf & "Here is another field: "
     InsertFieldAfter Range:=myRange, FieldType:=wdFieldEmpty, Text:="REF Field2"
     .InsertAfter vbCrLf
End With

Happy coding!

Dynamic UserForms in VBA

David Horowitz — Sun, 21 Feb 2010 06:11:07 +0000

Dynamic UserForms in VBA

by David Horowitz

Did you know that you can add and remove controls from a UserForm (also known as custom dialog boxes) at run-time? This means that you can change your UserForms based on certain conditions that exist during the operation of your VBA project—you’re not limited to the design of the UserForm that you created in the VBE designer!

To illustrate the technique, we’ll create a Word VBA Template which will prompt the user for the number of cars they own. (It allows for up to 20—hopefully that will be enough for most of us!) It will then display the correct number of textboxes to allow the user to enter the make of each car. When the user is done, the list of cars will be added to the document.

The key thing here we want to illustrate is the part where the dialog box will actually change to display the correct number of textboxes (with accompanying labels).

The primary method that accomplishes this task is Form.Controls.Add. (You can look it up in VBA Help.) Its syntax is like this:

Set ctl = Me.Controls.Add(ControlClass, Name, Visible)

For our purposes, ControlClass can have one of the following values:

"Forms.CheckBox.1"
"Forms.ComboBox.1"
"Forms.CommandButton.1"
"Forms.Frame.1"
"Forms.Image.1"
"Forms.Label.1"
"Forms.ListBox.1"
"Forms.MultiPage.1"
"Forms.OptionButton.1"
"Forms.ScrollBar.1"
"Forms.SpinButton.1"
"Forms.TabStrip.1"
"Forms.TextBox.1"
"Forms.ToggleButton.1"

These are text strings, so you must enclose them in quotes.

You can optionally specify the name of the new control using the Name parameter, for example, “TextBox7”, “txtFirstName”, “lblPrompt”, or “chkChicago”, whatever’s appropriate for your use.

Finally, you can choose to make the new control invisible by specifying False for the Visible parameter. The default is for Visible to be True.

So, for example, let’s say you would like to add a new label to your form. The form is named frmMyForm, and the new label should have the name “lblPrompt”. The method call would look like:

Dim myLabel as Label
Set myLabel = frmMyForm.Controls.Add _
    ("Forms.Label.1", "lblPrompt")

Don’t get confused about myLabel and lblPrompt. myLabel is an Object variable in VBA which is now set to refer to the control on the form by the name of “lblPrompt”.

Once you add a control to a form, you will certainly need to set some properties on the control, at least things like Top, Left, Width and Height. You can do this right after creation if you want, using, in our example, myLabel:

With myLabel
    .Left = 10
    .Top = 10
    .Width = 30
    .Caption = "Enter your name:"
End With

We’ve let the Height property default to whatever VBA sets for it initially.

Now later on in your code, if you want to refer to the newly added control, but you no longer have the myLabel reference, you can either use:

frmMyForm.Controls("lblPrompt”)

frmMyForm!lblPrompt

You cannot use the other syntax to refer to a control:

frmMyform.lblPrompt

when the control has been created dynamically using Controls.Add.

The example which accompanies this article, Dynamic UserForms Demo.dot, is a Word template which illustrates the techniques we’ve just describes in greater detail and in actual usage. You can download a copy of this template demo by clicking: HERE.

When you open this template, the Document_New method will call ShowCarsDialog, which will call the frmCars.Show method. frmCars has a label (lblNumCars) and textbox (txtNumCars), which prompt you to enter the number of cars you have. When you click on the Show Cars button (cmdShowCars), you will see a number of labels and textboxes equal to the number of cars you entered, allowing you to enter a make for each car. Then, when you click the Done button (cmdDone), all the car makes you entered will be inserted into the document and the dialog form (frmCars) will be unloaded.

If you want to change the number of cars again before you press Done, you can do that and when you click on Show Cars, the number of car labels and textboxes will change again to accommodate. So you can Add and Remove cars from the list before you click Done.

When you look at the code, you will see that each car make has a label and a textbox called lblCarN and txtCarN, where N is the number of the car. Each label is added to the form using this line of code:

Set theLabel = Me.Controls.Add _
    ("Forms.Label.1", "lblCar" & CurrentNumberOfCars)

Each textbox is added to the form using this line of code:

Set theTextBox = Me.Controls.Add _
    ("Forms.TextBox.1", "txtCar" & CurrentNumberOfCars)

After creating each control, we set a number of properties on it. We set each label’s caption using this line of code:

theLabel.Caption = "Car #" & CurrentNumberOfCars & ":"

You can see we even set the Accelerator property on each label to the number of the car using this line of code:

theLabel.Accelerator = CurrentNumberOfCars

If you tell the dialog box to remove some cars, the following lines of code are used:

Me.Controls.Remove "lblCar" & CurrentNumberOfCars
Me.Controls.Remove "txtCar" & CurrentNumberOfCars

In this article, we’ve learned how to use Form.Controls.Add to add controls to a form’s Controls collection at run-time. We then set properties on the control to make it look and function the way we want. We also learned how to dynamically remove a control from a form’s Controls collection using Form.Controls.Remove.

Now you can experiment with adding and removing controls to your forms whenever you need them. You will find many uses for this technique once you’ve learned how to do it.

This article originally appeared in Vol 3, Issue 2 of TechTrax.

Need further help getting your VBA code working right? Contact us or check out TechTrax’s free VBA support groups. See these links for details: http://groups.yahoo.com/group/Word_VBA/ and/or http://groups.yahoo.com/group/ExcelVBA/.