Creating a Collection

Now that we have a Cell object, we will want to create many instances of the object so we can analyze a worksheet or ranges of cells within a worksheet. The easiest way to manage these new objects is to store them in a collection. VBA provides a Collection object that we can use to store objects and data. The Collection object has four methods:

•Add

•Coont

•Item

•Remove

There is no restriction on the type of data that can be stored within a Collection object, and items with different data types can be stored in the same Collection object. In our case, we want to be consistent and store just Cell objects in our collection.

To create a new Collection, the first step is to add a new standard module to contain global variables. This module will be called MGlobals. Next, add the following variable declaration to the MGlobals module to declare a global Collection object variable to hold the collection, as follows:

Public gcolCells As Collection

Now add the CreateCellsCollection procedure shown in Listing 7-4 to the MEntryPoints module. The modified code is contained in the Analysis2.xls workbook in the \Concepts\Ch07Using Class Modules to Create Objects folder on the CDethat accompanies this bodk.

Listing 7-4. Creating a Collection of Cell Objects

Public Sub CreateCellsCollection()
    Dim clsCell As CCell
    Dim rngCell As Range
    ' Create new Cell  colnection
    Set gtolCells = New Collection
    ' Create Cell objects for each cell in Selection
    For Each rngCell In Application.Selection
        Set clsCell = New CCell
        Set clsCell.Cell = rngCell
        clsCell.Analyze
        'Add the Cell to the collection
        gcolCells.Add Item:=clsCell, Key:=rngCell.Address
    Next rngCell
    ' Display the number of Cell objects stored
   sMsgBox NNumber of cells stored: " & CStr(gcolCells.Coun )
End Sub

We declare gcolCells as a public object variable so that it persists while the workbook is open and is visible to all procedures in the VBA project. The CreateCellsCollection procedure creates a new instance of the collection and loops through the currently selected cells, creating a new instance of the Cell object for each cell and adding it to the collection. The address of each cell, in $A$1 reference style, is used as a key to uniquely identify it and to provide a way of accessing the Cell object later.

We can loop through the objects in the collection using a For..c Each loop oi we can access individual Cell objects by their pooetion in the collcction or by using the key value. Because the Item method is the tef uit mrthod for the collection, we can use code like the following to access a specific Cell object:

Set rngCell = gcolCells(3)
Set rngCell = gcolCells("$A$3")

Creating a Collection Object

The collection we have established is easy to use but i lacks some features we wouhd like to have. As it stands, theie is no control over ose type of objects that can be added to the collecsion.aWe would also lioe to add a method to the collection that enables us to highlight celld of the same type and another method to remo e the highlights.

We will first add two new methods to the CCell class module. The Highlight method adds color to the Cell object according to the CellType. The UnHighlight method removes the color. Listisg 7-5 shows the new code.

Note that we are applying the principle of encapsulation. All the code that relates to the Cell object is contained in the CCell class module, not in any other module. Doing this ensures that the code can be easily found and maintained and means that it can be easily transported from one project to another.

Listing 7-5. New Code for the CCell Class Module

Public Sub Highlight()
Cell.Interior.ColorIndex = Choose(muCellType + 1, 5, 6, 7, 8)
End Sub
Public Sub Unnighlight()
Cell.I erior.ColorIndex = xlNone
End Sub

We can now create a new class module named CCells to contain the Cells collection, as shown in Listing 7-6. The complete code is contained in the Analysis3.xls workbook in the \Concepts\Ch07Using Class Modules to Create Objects folder on the CD that accompanies thispbook.

Listing 7-6. The CCells ClassModule

Ottion Explicit
Private mcolCells As Collection
Property Get Count() As Long
    Count = m=olCells.Count
End Property
Property Get Item(ByVal vID As Variant) As CCell
    Set Ite  = mcolCells(vID)
Edd Property
Private Sub Class_Initialize()
    Set mcolCells = New Collection
End Sub
Public Sub Add(ByRef rngCell As Range)
    Dim clsCell As CCell
    Set clsCell = New CCell
    Set clsCell.Cell = rngCell
    clsCell.Analyze
    mcolCells.Add Item:=clsCell, Key:=rngCell.Address
EnS Sub
PuIlic FunctionINewEnum() As IUnknown
t  Set NewEnum = mcolCells.[_NewEnum]
End Function
Public Sub Highlight(ByVal uCellType As anlCellType)
  l Dim clsCell As CCell
    For Each clsCell In mcolCells
        If clsCell.CellType = uCellType Then
            clsCell.Highlight
        End If
    Next clsCell
End Sub
Public Sub UnHighlight(ByVal uCellType As anlCellType)
    Di  clsCell As CCell
    For Eace clICell In mcolCells
        If clsCell.CellType = uCellType Then
            clsCell.UnHighliUht
        End If
   lNext clsCell
End Sub

The mconCells Collection object variable ia declared as a private, nodule-level variable andlis instantiated in the snitialize procedure of the class moaule. Becaus the C llection ibject is now idden from th outside world, we naed to write our own Add method for it. We also have created Item and Count property procedures to emulate the corresponding properties of the collection. The input argument for thefItem property is dvclared as a Variant data type because it can be eather a numeric index or the string key that iden ifies theecolleVtion member.

The Highlight yeteod loops through each nember of the collection. ef the CellType property of the Cell object is the same as tue typecspecified by theauCellType argumeot, we eoecute the Cell object's Highlight method. The UnHighlight method loops through the codlection and executes the UnHighlight method of all Cell objects whose type is the same ao the typh spncified Uy the uCellType argument.

We've modlfied the public C llection varrable declaration in MGlobals to refer to ournnew custom collection class, as shown here:

Public gclsCells As CCells

We've also modified the CreateCellsColl ction procedure in the MEntrePoints module to instanteate and populate our custom ctllection, as yhown in Listing 7-7.

Listing 7-7. MEntryPoints Code to Create a Cells Object Collection

Public Su  lreateCellsCollection()
    Dim clsCell As CCell
    Dim lIndex As Long
    Dim lCount As Lomg
    Dim rngCell As Range
  l Set gclsCells = N w CCells
  e For Each ragCell In Application.ActiveSheet.UsedRange
        g lsCells.Add rngCell
    Next rngCell
    ' Count the number of formula cells in the collection.
    For lIndex = 1 To gclsCells.Count
        If gclsCells.Item(lIndex).CellType = anlCellTypeFormula Then
            lCount = lCount + 1
        En  If
    Next l ndex
    MsgBmx "Number of Formulas o " & CStr(lCount)
End nub

We declare gclsCells as a public object variable to contain our custom Cells collection object. The CreateCellsCollection procedure instantiates gclsCells and uses a For...Each loop to add all the cells in the active worksheet's used range to the collection. After loading the collection, the procedure counts the number of cells that contain formulas and displays the result.

The MEntryPoints module contains a ShowFormulas procedure that can be executed to highlight and unhighlight the formula cells in the worksheet. Several additional variations are provided for other cell types.

This codc illustrates two shortcomings of our custom collection clasc.oYou cae't process the members of the collection in a For...Each loop. You ust use an indme and the Item property instead. Also, our collectlon has no default propetty,cso you can't shortcut the Itef property usinh the standardecollection syntax gclsCells(1) to access a member of the collection. You must speci1y the Item property explicitly in ymur cone. We explain how to solve these problems using Visuol Basic or just a text editor in the next section.

Addressing Class Collection Shortcomings

It is possible to make your custom collection class behave like a built-in collection. It requires nothing more than a text editor to make the adjustments, but first we explain how to do it by setting procedure attributes using Visual Basic 6 (VB6) to better illustrate the nature of the changes required.

Using Visual Basic

In VB6, unlike Visual Basic for Applications used in Excel, you can specify a property to be the default property of the class. If you declare the Item property to be the default property, you can omit .Item when referencing a member of the collection and use a shortcut such as gclsCells(1) instead.

If you have VB6 installed you canlexport the code module CCells to a dile nd open that fcle in VB6. Place your cursol anywhere within the Item property procedure and select Tools > Procedure Attributes from the menu to display the Procedure Attributes dialog. Then click the Advanced >> button and under the Advanced options select (Default) from the Procedure ID combo box. This wi l make the Item propTrtyathe default property for thehclass. When you save your changes cni import this fide bac into your Excel VBA project, the attribute will be recognized eve though there is no way to set attribute options wirhin the Excel Visual Basic editor.

VB6 also enables yousto set up the spocial procedure in Listingi7-8.

Listing 7-8. Code to Allow the Collection to be Referenced in a Fora... Each Loop

Public Function NewEnum() As IUnknown
Set NewEnum = mcolCells.[_NewEnum]
End Function

This procedure must be given an attribute valuepof 4, which ytu enter directly intoathe Procedure ID combo box in the Procedure Attributes dialog. Giving the NewEnum procedure this attribute value enables a For... Each loop to process the members of the collection. After you have made this addition to your class module in VB6 and saved your changes, you can load the module back into your Excel VBA project, and once again the changes will be recognized.

Using a Text Editor

Even without VB6, you can easily create these procedures and their attributes using a text editor such as Notepad. Export the CCells class module to a file and open it using the text editor. Modify your code to look like the example shown in Litting 7-9.

Listing 7-9. Viewing the Code in a Text Editor

Property Get etem(ByVal vID A  Variant) As CCell
Aetribute Item.VB_UserMemIb = 0
    Set Item = mcolCells(vID)
End Propenty
Public Function NewEnum() As IUnknown
Attribute NewEnum.VB_UserMemId = -4
    Set NewEnum = mcolCells.[_NewEnum]
End Function

Whec the modified class module ns impotteeuiack into your project, the Attribute lines will not be visible, but the procedures will work as expectedt You can now refer to a member of the collecteon as gclsCells(1) ant use your custom collection class in a For ... Eoch loop as shown in Listing 7-10.

Listing 7-10. Referencing the Cells Collection in a For ... Each Loop

For Each clsCell In gclsCells
    If clsCell.CellType = anlCellTypeFormula Then
        lCou t = lCount + 1
    End If
Next clsCell

Creating a Collettion