Connect a list container to a tree/list control

.
 
Most user interface oriented applications need a container of some kind (for example, list) and a visual representation of this container in a tree or list control. When a programmer modifies an item in a container, it must also update this specific item in a tree/list control. Vice versa, if a user of the program modifies the contents of the item, programmer must also update the item contents in a container.

As an example, I will discuss tree control since it is more complex. Each level in a tree control can be (and usually is) represented with a different data structure or class.

Using a structure for a node item

Each structure representing a node item should be declared in such a way that its first data member is an enum type. Enum is declared separatelly and identifies different type of structures which are used in a tree control.

enum treeItems {
    tiVehicleGroup,    // Planes, trucks, cars, ships etc.
    tiVehicle,         // Toyota, Renault, Mercedes, Chrysler, etc.
    tiPart             // Windshield, Wheels, Tyres, Engine, etc.
};

struct TVehicleGroup {
    int Id;            // Initialized to tiVehicleGroup
    CString Name;
    .....
    void *Handle;
};

struct TVehicle {
    int Id;            // Initialized to tiVehicle
    CString Name;
    ......
    TVehicleGroup *Owner;
    void *Handle;
};

These structures are organized into one or more containers. When populating a tree control, Name is used for item visual representation while a pointer to a data structure is associated with a tree item: Handle is initialized with a HTREEITEM handle returned from InsertItem function. It is declared as a pointer to void instead of HTREEITEM in order to allow a structure to be inserted in a tree or list control.

void TFoo::Foo(CTreeCtrl& tc, TVehicleGroup *ptr)
{
    HTREEITEM handle = tc.InsertItem(ptr->Name);
    ptr->Handle = (void*)handle;
    tc.SetItemData(handle,(DWORD)ptr);
}

void TFoo::Foo(CTreeCtrl& tc, TVehicle *ptr)
{
    HTREEITEM handle = tc.InsertItem(ptr->Name, (HTREEITEM)ptr->Owner->Handle);
    ptr->Handle = (void*)handle;
    tc.SetItemData(handle,(DWORD)ptr);
}
 
Getting a pointer to a data structure given a handle to a tree item is straightforward:

HTREEITEM handle = tc.GetSelectedItem();
TVehicle *ptr = (TVehicle*)tc.GetItemData(handle);
switch (ptr->Id) {
    case tiVehicleGroup:
        {
            TVehicleGroup *vg = (TVehicleGroup*)ptr;
            // Do something
        }
        break;
    case tiVehicle:
        {
            TVehicle *vg = (TVehicleGroup*)ptr;
            // Do something
        }
        break;
    case tiPart:
        ....
        break;
};

I can safely test an Id member of an unknown structure only if it is assunmed that all structures associated with tree items have an Id as a first data member. After detecting the exact type, I can safelly access all its data members.
 
Using classes for node items

With classes it is not possible to rely on an in-memory representation of the class as I did with structures. Different approach is needed. First, declare a base class for all classes whose instances will be associated with tree items. This class contains all common data (name of tree item, handle to tree item etc.).

class TBaseForTreeItem : public CObject {
    public:
        CString Name;
        void *Handle;
        TBaseForTreeItem *Parent;
        // ....
};

Then, concrete classes are declare using previous class as a base class.

class TVehicleGroup : public TBaseForTreeItem {
    ....
};

class TVehicle : public TBaseForTreeItem {
    ....
};

Inserting an item into the tree control is the same as previously described. The difference is in getting the pointer to the object in a container. For this, we can use several different techniques:

• If all classes use a DECLARE_SERIAL or DECLARE_DYNAMIC macro, then rtti is enabled and we can use IsKindOf to get to the right object.

HTREEITEM handle = tc.GetSelectedItem();
TBaseForTreeItem *obj = (TBaseForTreeItem*)tc.GetItemData(handle);
if (obj->IsKindOf(RUNTIME_CLASS(TVehicleGroup)) {
    TVehicleGroup *vg = (TVehicleGroup*)obj;
    // Do something
} else if (obj->IsKindOf(RUNTIME_CLASS(TVehicle)) {
    TVehicle *v = (TVehicle*)obj;
    // Do something
}
 

• If rtti is enabled but we don't use DECLARE_SERIAL or DECLARE_DYNAMIC macros, we can use a C++ defined dynamic_cast macro to get to the right object.

HTREEITEM handle = tc.GetSelectedItem();
TBaseForTreeItem *obj = (TBaseForTreeItem*)tc.GetItemData(handle);
TVehicleGroup *vg = dynamic_cast<TVehicleGroup*>(obj);
if (vg != NULL) {
    // Do something
} else {
    TVehicle *v = dynamic_cast<TVehicle*>(obj);
    if (v != NULL) {
        // Do something
    }
}
 

• If rtti is not enabled, we can rely on C++ inheritance and do the following:

• Define an enum treeItem { tiBase, tiVehicleGroup, tiVehicle, ... }.
• Add a virtual int GetId(void) member function to a TBaseForTreeItem and all derived classes.
• Implement this function in each class and return a different enum constant (based on a class type).
With this modifications, it is possible to get the correct pointer to an object associated with a tree item using the following:

HTREEITEM handle = tc.GetSelectedItem();
TBaseForTreeItem *obj = (TBaseForTreeItem*)tc.GetItemData(handle);
switch (obj->GetId()) {
    case tiVehicleGroup:
        {
            TVehicleGroup *vg = (TVehicleGroup*)obj;
            // Do something
        }
        break;
    case tiVehicle:
        {
            TVehicle *v = (TVehicle*)obj;
            // Do something
        }
        break;
}

Conclusion

This technique can be used with all controls that allow a programmer to associate a DWORD with a control item (list boxes, combo boxes, listview etc.).