1. Activate the worksheet in which you want an add-in to be loaded.
2. Press the shortcut button  Alt+F11 to display the VBA Editor or click on Developer ribbon and then click the Visual Basic button on the left hand side.
3. Double-click on the “This Workbook” object in the Project Explorer. Excel opens a code window for This Workbook.
4. Put the following code into macro windows you have loaded:

Private Sub Workbook_BeforeClose(Cancel As Boolean)
    AddIns("Add-In Name").Installed = False
End Sub

Private Sub Workbook_Open()
    AddIns("Add-In Name").Installed = True
End Sub

1. In the code, change the name of the add-ins (”Add-In Name”) to the real name of the add-in you want to use with the worksheet.
2. Close the VBA Editor.
3. Save your worksheet.

If you are not sure of the correct name for a particular add-in (see step 5), you can use the macro recorder function to record the process of activating an add-in. That will show you the exact name you should use in the above macros.

Related Post

• Related Post

Do [Until condition]
statements]
[Exit Do]
[statements]
Loop

The following example is the same one presented for the Do-While loop but recoded to use a Do-Until loop:

Sub DoUntilDemo()
Do Until IsEmpty(ActiveCell.Value)
ActiveCell.Value = ActiveCell.Value * 2
ActiveCell.Offset(1, 0).Select
Loop
End Sub

Just like with the Do-While loop, you may encounter a different form of the Do-Until loop — a Do-Loop Until loop. The following example, which has the same effect as the preceding procedure, demonstrates an alternate syntax for this type of loop:

Sub DoLoopUntilDemo()
Do
ActiveCell.Value = ActiveCell.Value * 2
ActiveCell.Offset(1, 0).Select
Loop Until IsEmpty(ActiveCell.Value)
End Sub

There is a subtle difference in how the Do-Until loop and the Do-Loop Until loop operate. In the former, the test is performed at the beginning of the loop, before anything in the body of the loop is executed. This means that it is possible that the code in the loop body will not be executed if the test condition is met. In the latter version, the condition is tested at the end of the loop. Therefore, at a minimum, the Do-Loop Until loop always results in the body of the loop being executed once.

Related Post

• Do-While loop
• Nested For-Next
• Looping Code

Do [While condition]
[statements]
[Exit Do]
[statements]
Loop

The following example uses a Do-While loop. This routine uses the active cell as a starting point and then travels down the column, multiplying each cell’s value by 2. The loop continues until the routine encounters an empty cell.

Sub DoWhileDemo()
Do While ActiveCell.Value <> Empty
ActiveCell.Value = ActiveCell.Value * 2
ActiveCell.Offset(1, 0).Select
Loop
End Sub

Some people prefer to code a Do-While loop as a Do-Loop While loop. This example performs exactly as the previous procedure but uses a different loop syntax:

Sub DoLoopWhileDemo()
Do
ActiveCell.Value = ActiveCell.Value * 2
ActiveCell.Offset(1, 0).Select
Loop While ActiveCell.Value <> Empty
End Sub

Remember this key difference between the Do-While and Do-Loop While loops: The Do-While loop always performs its conditional test first. If the test is not true, the instructions inside the loop are never executed. The Do-Loop While loop, on the other hand, always performs its conditional test after the instructions inside the loop are executed. Thus, the loop instructions are always executed at least once, regardless of the test. This difference can have a profound effect on how your program functions.

Related Post

• Do-Until loop
• Nested For-Next
• Looping Code

So far, all this chapter’s examples use relatively simple loops. However, you can have any number of statements in the loop and nest For-Next loops inside other For-Next loops. The following example uses a nested For-Next loop to insert random numbers into a 12-row-x-5-column range of cells, as shown in Figure 10-2. Notice that the routine executes the inner loop (the loop with the Row counter) once for each iteration of the outer loop (the loop with the Col counter). In other words, the routine executes the Cells(Row, Col) = Rnd statement 60 times.

Sub FillRange2()
Dim Col As Long
Dim Row As Long
For Col = 1 To 5
For Row = 1 To 12
Cells(Row, Col) = Rnd
Next Row
Next Col
End Sub

The next example uses nested For-Next loops to initialize a three-dimensional array with zeros. This routine executes the statement in the middle of all the loops (the assignment statement) 1,000 times, each time with a different combination of values for i, j, and k:

Sub NestedLoops()
Dim MyArray(10, 10, 10)
Dim i As Integer
Dim j As Integer
Dim k As Integer
For i = 1 To 10
For j = 1 To 10
For k = 1 To 10
MyArray(i, j, k) = 0
Next k
Next j
Next i
End Sub

Related Post

• Looping Code
• Do-Until loop
• Do-While loop

Sub ExitForDemo()
Dim MaxVal As Double
Dim Row As Long
MaxVal = Application.WorksheetFunction. _
Max(Range(“A:A”))
For Row = 1 To Rows.Count
If Range(“A1”).Offset(Row – 1, 0).Value = MaxVal
Then
Range(“A1”).Offset(Row – 1, 0).Activate
MsgBox “Max value is in Row “ & Row
Exit For
End If
Next Row
End Sub

The routine calculates the maximum value in the column by using Excel’s MAX function and assigns the result to the MaxVal variable. The For-Next loop then checks each cell in the column. If the cell being checked is equal to MaxVal, the routine doesn’t need to continue looping (its job is finished), so the Exit For statement terminates the loop. Before terminating the loop, the procedure activates the cell with the maximum value and informs the user of its location. Notice that I use Rows.Count in the For statement. The count property of the Rows objects returns the number of rows in the worksheet. Therefore, you can use this procedure with Excel 2007 as well as with earlier versions (which have fewer rows).

Related Post

• For-Next with a Step
• Nested For-Next
• For-Next loops

Sub FillRange()
Dim Count As Long
For Count = 1 To 100 Step 2
ActiveCell.Offset(Count – 1, 0) = Rnd
Next Count
End Sub

This time, Count starts out as 1 and then takes on a value of 3, 5, 7, and so on. The final Count value is 99. The Step value determines how the counter is incremented.
This chapter introduces looping via the BadLoop example, which uses a GoTo statement. Here’s the same example, which is available on this book’s Web site, converted into a good loop by using the For-Next structure:

Sub FillRange()
Dim StartVal As Long
Dim NumToFill As Long
Dim CellCount As Long
StartVal = InputBox(“Enter the starting value: “)
NumToFill = InputBox(“How many cells? “)
For CellCount = 1 To NumToFill
ActiveCell.Offset(CellCount – 1, 0) = _
StartVal + CellCount – 1
Next CellCount
End Sub

Related Post

• For-Next with an Exit For statement
• Looping through the ChartObjects collection
• Looping through a range efficiently

For counter = start To end [Step stepval]
[statements]
[Exit For]
[statements]
Next [counter]

The looping is controlled by a counter variable, which starts at one value and stops at another value. The statements between the For statement and the Next statement are the statements that get repeated in the loop. To see how
this works, keep reading.

A For-Next example
The following example shows a For-Next loop that doesn’t use the optional Step value or the optional Exit For statement. This routine loops 100 times and uses the VBA Rnd function to enter a random number into 100 cells:

Sub FillRange()
Dim Count As Long
For Count = 1 To 100
ActiveCell.Offset(Count – 1, 0) = Rnd
Next Count
End Sub

In this example, Count (the loop counter variable) starts with a value of 1 and increases by 1 each time through the loop. Because I didn’t specify a Step value, VBA uses the default value (1). The Offset method uses the value of Count as an argument. The first time through the loop, the procedure enters a number into the active cell offset by zero rows. The second time through (Count = 2), the procedure enters a number into the active cell offset by one row (Count –1), and so on. Because the loop counter is a normal variable, you can change its value within the block of code between the For and the Next statements. This, however, is a very bad practice. Changing the counter within the loop can have
unpredictable results. Take special precautions to ensure that your code does not directly change the value of the loop counter.

Related Post

• For-Next with an Exit For statement
• For-Next with a Step
• Do-Until loop

Sub BadLoop()
Dim StartVal As Long
Dim NumToFill As Long
Dim CellCount As Long
StartVal = InputBox(“Enter the starting value: “)
NumToFill = InputBox(“How many cells? “)
ActiveCell = StartVal
CellCount = 1
DoAnother:
ActiveCell.Offset(CellCount, 0) = StartVal + CellCount
CellCount = CellCount + 1
If CellCount < NumToFill Then GoTo DoAnother _
Else Exit Sub
End Sub

This routine works as intended, so why is it an example of bad looping? As I mention earlier in this chapter, avoid using a GoTo statement unless it’s absolutely necessary. Using GoTo statements to perform looping

• Is contrary to the concept of structured programming. (See the sidebar earlier in this chapter, “What is structured programming? Does it matter?”)
• Makes the code more difficult to read.
• Is more prone to errors than using structured looping procedures.

VBA has enough structured looping commands that you almost never have to rely on GoTo statements for your decision making. Again, the exception is for error handling. Now you can move on to a discussion of good looping structures.

Related Post

• Nested For-Next
• Do-Until loop
• Do-While loop

Related Post

• Do-Until loop
• Using a UserForm as a progress indicator

Sub FillRange()
Dim r as Long, c As Integer
Dim Number as Long
Number = 0
For r = 1 To 50
For c = 1 To 50
Number = Number + 1
Cells(r, c).Value = Number
Next c
Next r
End Sub

You see each value being entered into the cells. Now insert the following statement at the beginning of the procedure and execute it again:

Application.ScreenUpdating = False

The range is filled up much faster, and you don’t see the end result until the macro is finished running. When debugging code, sometimes program execution ends somewhere in the middle, without having turned Screen updating back on (and yes, this happens to me too). This sometimes causes Excel’s application window to become totally unresponsive. The way out of this frozen state is simple: Go back to the VBE and type the following statement in the Immediate window. Press the enter key to let the VBE execute this command.

Application.ScreenUpdating = True

Related Post

• For-Next with a Step
• Applying chart formatting
• Modifying chart properties