Type VirtualTree

       object --+    
                |    
TreeAPIHarmonizer --+
                    |
       object --+   |
                |   |
       TreeHelper --+
                    |
                   VirtualTree

This is a mixin class that can be used to allow for virtual tree
controls. It can be mixed in with wx.TreeCtrl, wx.gizmos.TreeListCtrl, 
wx.lib.customtree.CustomTreeCtrl.

To use it derive a new class from this class and one of the tree
controls, e.g.:
class MyTree(VirtualTree, wx.TreeCtrl):
    ...

VirtualTree uses several callbacks (such as OnGetItemText) to 
retrieve information needed to construct the tree and render the 
items. To specify what item the callback needs information about,
the callback passes an item index. VirtualTree supports two types of
indices: a tuple-based index (the default) and an integer based index. 
See below for a more detailed explanation of the two index types.

Note that VirtualTree forces the wx.TR_HIDE_ROOT style.

In your subclass you *must* override OnGetItemText and either
OnGetChildrenCount if you use the tuple-based index or 
OnGetChildrenIndices if you use the integer-based index. These
methods are the minimum needed to construct the tree and render
the item labels. If you want to add images, change fonts our colours, 
etc., you need to override the appropriate OnGetXXX method as well.

About the index types: VirtualTree supports two types of indices that
are passed to the several callbacks to retrieve information about 
items in the tree.  The default index type is tuple-based, the second
type is integer-based. 

If you use tuple-based indices, your callbacks are passed a tuple of 
integers that identifies the item the VirtualTree wants information 
about. An empty tuple, i.e. (), represents the hidden root item. 
A tuple with one integer, e.g. (3,), represents a visible root item, 
in this case the fourth one. A tuple with two integers, e.g. (3,0), 
represents a child of a visible root item, in this case the first 
child of the fourth root item. The tuple-based index is best suited 
if your underlying data structure is organized as a tree and allows 
for easy navigation to the right object in your tree data structure.

If you use integer-based indices, your callbacks are passed a simple 
integer (or None) that identifies the item the VirtualTree wants 
information about. None represents the hidden root item. Zero (0) 
represents the first visible root item. If the first visible root 
item has children 1 represents the first child of the first visible 
root item. If that child has children 2 represents the first grand 
child of the first visible root item. If the first child has no 
children, 2 would represent the second child of the first visible 
root item, etc. Basically, the integer is the row number of the item 
(when the tree is completely expanded). Integer-based indices are 
more convenient when your underlying data structure is organized as 
a list that is in the same order as the tree items in the tree need 
to be.