/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2012-2013, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */

#include "table/TreeTable.h"

#include <new>


// #pragma mark - TreeTableField


class TreeTableField : public BField {
public:
        TreeTableField(void* object)
                :
                fObject(object)
        {
        }

        void* Object() const
        {
                return fObject;
        }

private:
        void*   fObject;
};


// #pragma mark - TreeTablePath


TreeTablePath::TreeTablePath()
{
}


TreeTablePath::TreeTablePath(const TreeTablePath& other)
{
        *this = other;
}


TreeTablePath::TreeTablePath(const TreeTablePath& other, int32 childIndex)
{
        *this = other;
        AddComponent(childIndex);
}


TreeTablePath::~TreeTablePath()
{
}


bool
TreeTablePath::AddComponent(int32 childIndex)
{
        try {
                fComponents.push_back(childIndex);
                return true;
        } catch (...) {
                return false;
        }
}


int32
TreeTablePath::RemoveLastComponent()
{
        if (fComponents.empty())
                return -1;

        int32 index = fComponents.back();
        fComponents.pop_back();
        return index;
}

void
TreeTablePath::Clear()
{
        fComponents.clear();
}


int32
TreeTablePath::CountComponents() const
{
        return fComponents.size();
}


int32
TreeTablePath::ComponentAt(int32 index) const
{
        if (index < 0 || (size_t)index >= fComponents.size())
                return -1;
        return fComponents[index];
}


TreeTablePath&
TreeTablePath::operator=(const TreeTablePath& other)
{
        try {
                fComponents = other.fComponents;
        } catch (...) {
        }
        return *this;
}


bool
TreeTablePath::operator==(const TreeTablePath& other) const
{
        return fComponents == other.fComponents;
}


bool
TreeTablePath::operator!=(const TreeTablePath& other) const
{
        return fComponents != other.fComponents;
}


// #pragma mark - TreeTableModelListener


TreeTableModelListener::~TreeTableModelListener()
{
}


void
TreeTableModelListener::TableNodesAdded(TreeTableModel* model,
        const TreeTablePath& path, int32 childIndex, int32 count)
{
}


void
TreeTableModelListener::TableNodesRemoved(TreeTableModel* model,
        const TreeTablePath& path, int32 childIndex, int32 count)
{
}


void
TreeTableModelListener::TableNodesChanged(TreeTableModel* model,
        const TreeTablePath& path, int32 childIndex, int32 count)
{
}


void
TreeTableModelListener::TableModelReset(TreeTableModel* model)
{
}


// #pragma mark - TreeTableModel


TreeTableModel::~TreeTableModel()
{
}


void*
TreeTableModel::NodeForPath(const TreeTablePath& path) const
{
        void* node = Root();

        int32 count = path.CountComponents();
        for (int32 i = 0; node != NULL && i < count; i++)
                node = ChildAt(node, path.ComponentAt(i));

        return node;
}


bool
TreeTableModel::AddListener(TreeTableModelListener* listener)
{
        return fListeners.AddItem(listener);
}


void
TreeTableModel::RemoveListener(TreeTableModelListener* listener)
{
        fListeners.RemoveItem(listener);
}


void
TreeTableModel::NotifyNodesAdded(const TreeTablePath& path, int32 childIndex,
        int32 count)
{
        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--) {
                TreeTableModelListener* listener = fListeners.ItemAt(i);
                listener->TableNodesAdded(this, path, childIndex, count);
        }
}


void
TreeTableModel::NotifyNodesRemoved(const TreeTablePath& path, int32 childIndex,
        int32 count)
{
        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--) {
                TreeTableModelListener* listener = fListeners.ItemAt(i);
                listener->TableNodesRemoved(this, path, childIndex, count);
        }
}


void
TreeTableModel::NotifyNodesChanged(const TreeTablePath& path, int32 childIndex,
        int32 count)
{
        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--) {
                TreeTableModelListener* listener = fListeners.ItemAt(i);
                listener->TableNodesChanged(this, path, childIndex, count);
        }
}


void
TreeTableModel::NotifyTableModelReset()
{
        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--) {
                TreeTableModelListener* listener = fListeners.ItemAt(i);
                listener->TableModelReset(this);
        }
}

// #pragma mark - TreeTableToolTipProvider


TreeTableToolTipProvider::~TreeTableToolTipProvider()
{
}


// #pragma mark - TreeTableListener


TreeTableListener::~TreeTableListener()
{
}


void
TreeTableListener::TreeTableSelectionChanged(TreeTable* table)
{
}


void
TreeTableListener::TreeTableNodeInvoked(TreeTable* table,
        const TreeTablePath& path)
{
}


void
TreeTableListener::TreeTableNodeExpandedChanged(TreeTable* table,
        const TreeTablePath& path, bool expanded)
{
}


void
TreeTableListener::TreeTableCellMouseDown(TreeTable* table,
        const TreeTablePath& path, int32 columnIndex, BPoint screenWhere,
        uint32 buttons)
{
}


void
TreeTableListener::TreeTableCellMouseUp(TreeTable* table,
        const TreeTablePath& path, int32 columnIndex, BPoint screenWhere,
        uint32 buttons)
{
}


// #pragma mark - Column


class TreeTable::Column : public AbstractColumn {
public:
                                                                Column(TreeTableModel* model,
                                                                        TableColumn* tableColumn);
        virtual                                         ~Column();

        virtual void                            SetModel(AbstractTableModelBase* model);

protected:
        virtual void                            DrawTitle(BRect rect, BView* targetView);
        virtual void                            DrawField(BField* field, BRect rect,
                                                                        BView* targetView);
        virtual int                                     CompareFields(BField* field1, BField* field2);

        virtual void                            GetColumnName(BString* into) const;
        virtual float                           GetPreferredWidth(BField* field,
                                                                        BView* parent) const;

private:
                        TreeTableModel*         fModel;
};


TreeTable::Column::Column(TreeTableModel* model, TableColumn* tableColumn)
        :
        AbstractColumn(tableColumn),
        fModel(model)
{
}


TreeTable::Column::~Column()
{
}


void
TreeTable::Column::SetModel(AbstractTableModelBase* model)
{
        fModel = dynamic_cast<TreeTableModel*>(model);
}


void
TreeTable::Column::DrawTitle(BRect rect, BView* targetView)
{
        fTableColumn->DrawTitle(rect, targetView);
}


void
TreeTable::Column::DrawField(BField* _field, BRect rect, BView* targetView)
{
        TreeTableField* field = dynamic_cast<TreeTableField*>(_field);
        if (field == NULL)
                return;

        int32 modelIndex = fTableColumn->ModelIndex();
        BVariant value;
        if (!fModel->GetValueAt(field->Object(), modelIndex, value))
                return;
        fTableColumn->DrawValue(value, rect, targetView);
}


int
TreeTable::Column::CompareFields(BField* _field1, BField* _field2)
{
        TreeTableField* field1 = dynamic_cast<TreeTableField*>(_field1);
        TreeTableField* field2 = dynamic_cast<TreeTableField*>(_field2);

        if (field1 == field2)
                return 0;

        if (field1 == NULL)
                return -1;
        if (field2 == NULL)
                return 1;

        int32 modelIndex = fTableColumn->ModelIndex();
        BVariant value1;
        bool valid1 = fModel->GetValueAt(field1->Object(), modelIndex, value1);
        BVariant value2;
        bool valid2 = fModel->GetValueAt(field2->Object(), modelIndex, value2);

        if (!valid1)
                return valid2 ? -1 : 0;
        if (!valid2)
                return 1;

        return fTableColumn->CompareValues(value1, value2);
}


void
TreeTable::Column::GetColumnName(BString* into) const
{
        fTableColumn->GetColumnName(into);
}


float
TreeTable::Column::GetPreferredWidth(BField* _field, BView* parent) const
{
        TreeTableField* field = dynamic_cast<TreeTableField*>(_field);
        if (field == NULL)
                return Width();

        int32 modelIndex = fTableColumn->ModelIndex();
        BVariant value;
        if (!fModel->GetValueAt(field->Object(), modelIndex, value))
                return Width();
        return fTableColumn->GetPreferredWidth(value, parent);
}


// #pragma mark - TreeTableRow


class TreeTableRow : public BRow {
public:
        TreeTableRow(TreeTableNode* node)
                :
                fNode(node)
        {
        }

        TreeTableNode* Node()
        {
                return fNode;
        }

private:
        TreeTableNode*  fNode;
};


// #pragma mark - TreeTableNode


class TreeTableNode {
public:
                                                                TreeTableNode(TreeTableNode* parent);
                                                                ~TreeTableNode();

                        status_t                        Init(void* modelObject, int32 columnCount);
                        void                            DetachRow();

                        TreeTableNode*          Parent() const  { return fParent; }
                        TreeTableRow*           Row() const             { return fRow; }
                        void*                           ModelObject() const;

                        bool                            AddChild(TreeTableNode* child, int32 index);
                        TreeTableNode*          RemoveChild(int32 index);

                        int32                           CountChildren() const;
                        TreeTableNode*          ChildAt(int32 index);
                        int32                           IndexOf(TreeTableNode* child);

private:
                        typedef BObjectList<TreeTableNode, true> NodeList;

private:
                        TreeTableNode*          fParent;
                        TreeTableRow*           fRow;
                        NodeList*                       fChildren;
};


TreeTableNode::TreeTableNode(TreeTableNode* parent)
        :
        fParent(parent),
        fRow(NULL),
        fChildren(NULL)
{
}


TreeTableNode::~TreeTableNode()
{
        delete fChildren;
        delete fRow;
}


status_t
TreeTableNode::Init(void* modelObject, int32 columnCount)
{
        // create row
        fRow = new(std::nothrow) TreeTableRow(this);
        if (fRow == NULL)
                return B_NO_MEMORY;

        // add dummy fields to row
        for (int32 columnIndex = 0; columnIndex < columnCount; columnIndex++) {
                // It would be nice to create only a single field and set it for all
                // columns, but the row takes ultimate ownership, so it have to be
                // individual objects.
                TreeTableField* field = new(std::nothrow) TreeTableField(modelObject);
                if (field == NULL)
                        return B_NO_MEMORY;

                fRow->SetField(field, columnIndex);
        }

        return B_OK;
}


void
TreeTableNode::DetachRow()
{

        fRow = NULL;

        if (fChildren != NULL) {
                for (int32 i = 0; TreeTableNode* child = fChildren->ItemAt(i); i++)
                        child->DetachRow();
        }
}


void*
TreeTableNode::ModelObject() const
{
        TreeTableField* field = dynamic_cast<TreeTableField*>(fRow->GetField(0));
        return field->Object();
}


bool
TreeTableNode::AddChild(TreeTableNode* child, int32 index)
{
        if (fChildren == NULL) {
                fChildren = new(std::nothrow) NodeList(10);
                if (fChildren == NULL)
                        return false;
        }

        return fChildren->AddItem(child, index);
}


TreeTableNode*
TreeTableNode::RemoveChild(int32 index)
{
        return fChildren != NULL ? fChildren->RemoveItemAt(index) : NULL;
}


int32
TreeTableNode::CountChildren() const
{
        return fChildren != NULL ? fChildren->CountItems() : 0;
}


TreeTableNode*
TreeTableNode::ChildAt(int32 index)
{
        return fChildren != NULL ? fChildren->ItemAt(index) : NULL;
}


int32
TreeTableNode::IndexOf(TreeTableNode* child)
{
        return fChildren != NULL ? fChildren->IndexOf(child) : -1;
}


// #pragma mark - TreeTableSelectionModel


TreeTableSelectionModel::TreeTableSelectionModel(TreeTable* table)
        :
        fTreeTable(table),
        fNodes(NULL),
        fNodeCount(-1)
{
}


TreeTableSelectionModel::~TreeTableSelectionModel()
{
        delete[] fNodes;
}


int32
TreeTableSelectionModel::CountNodes()
{
        _Update();

        return fNodeCount;
}


void*
TreeTableSelectionModel::NodeAt(int32 index)
{
        if (TreeTableNode* node = _NodeAt(index))
                return node->ModelObject();
        return NULL;
}


bool
TreeTableSelectionModel::GetPathAt(int32 index, TreeTablePath& _path)
{
        if (TreeTableNode* node = _NodeAt(index)) {
                fTreeTable->_GetPathForNode(node, _path);
                return true;
        }

        return false;
}


void
TreeTableSelectionModel::_SelectionChanged()
{
        if (fNodeCount >= 0) {
                fNodeCount = -1;
                delete[] fNodes;
                fNodes = NULL;
        }
}


void
TreeTableSelectionModel::_Update()
{
        if (fNodeCount >= 0)
                return;

        // count the nodes
        fNodeCount = 0;
        BRow* row = NULL;
        while ((row = fTreeTable->CurrentSelection(row)) != NULL)
                fNodeCount++;

        if (fNodeCount == 0)
                return;

        // allocate node array
        fNodes = new(std::nothrow) TreeTableNode*[fNodeCount];
        if (fNodes == NULL) {
                fNodeCount = 0;
                return;
        }

        // get the nodes
        row = NULL;
        int32 index = 0;
        while ((row = fTreeTable->CurrentSelection(row)) != NULL)
                fNodes[index++] = dynamic_cast<TreeTableRow*>(row)->Node();
}


TreeTableNode*
TreeTableSelectionModel::_NodeAt(int32 index)
{
        _Update();

        return index >= 0 && index < fNodeCount ? fNodes[index] : NULL;
}


// #pragma mark - Table


TreeTable::TreeTable(const char* name, uint32 flags, border_style borderStyle,
        bool showHorizontalScrollbar)
        :
        AbstractTable(name, flags, borderStyle, showHorizontalScrollbar),
        fModel(NULL),
        fToolTipProvider(NULL),
        fRootNode(NULL),
        fSelectionModel(this),
        fIgnoreSelectionChange(0)
{
}


TreeTable::TreeTable(TreeTableModel* model, const char* name, uint32 flags,
        border_style borderStyle, bool showHorizontalScrollbar)
        :
        AbstractTable(name, flags, borderStyle, showHorizontalScrollbar),
        fModel(NULL),
        fToolTipProvider(NULL),
        fRootNode(NULL),
        fSelectionModel(this),
        fIgnoreSelectionChange(0)
{
        SetTreeTableModel(model);
}


TreeTable::~TreeTable()
{
        SetTreeTableModel(NULL);
}


bool
TreeTable::SetTreeTableModel(TreeTableModel* model)
{
        if (model == fModel)
                return true;

        if (fModel != NULL) {
                fModel->RemoveListener(this);

                if (fRootNode != NULL) {
                        fRootNode->DetachRow();
                        delete fRootNode;
                        fRootNode = NULL;
                }

                Clear();

                for (int32 i = 0; AbstractColumn* column = fColumns.ItemAt(i); i++)
                        column->SetModel(NULL);
        }

        fModel = model;

        if (fModel == NULL)
                return true;

        fRootNode = new(std::nothrow) TreeTableNode(NULL);
        if (fRootNode == NULL)
                return false;

        if (fRootNode->Init(fModel->Root(), fModel->CountColumns()) != B_OK) {
                delete fRootNode;
                fRootNode = NULL;
                return false;
        }

        fModel->AddListener(this);

        for (int32 i = 0; AbstractColumn* column = fColumns.ItemAt(i); i++)
                column->SetModel(fModel);

        // recursively create the rows
        if (!_AddChildRows(fRootNode, 0, fModel->CountChildren(fModel->Root()),
                        fModel->CountColumns())) {
                SetTreeTableModel(NULL);
                return false;
        }

        return true;
}


void
TreeTable::SetToolTipProvider(TreeTableToolTipProvider* toolTipProvider)
{
        fToolTipProvider = toolTipProvider;
}


TreeTableSelectionModel*
TreeTable::SelectionModel()
{
        return &fSelectionModel;
}


void
TreeTable::SelectNode(const TreeTablePath& path, bool extendSelection)
{
        TreeTableNode* node = _NodeForPath(path);
        if (node == NULL)
                return;

        if (!extendSelection) {
                fIgnoreSelectionChange++;
                DeselectAll();
                fIgnoreSelectionChange--;
        }

        AddToSelection(node->Row());
}


void
TreeTable::DeselectNode(const TreeTablePath& path)
{
        if (TreeTableNode* node = _NodeForPath(path))
                Deselect(node->Row());
}


void
TreeTable::DeselectAllNodes()
{
        DeselectAll();
}


bool
TreeTable::IsNodeExpanded(const TreeTablePath& path) const
{
        if (TreeTableNode* node = _NodeForPath(path))
                return node->Row()->IsExpanded();
        return false;
}


void
TreeTable::SetNodeExpanded(const TreeTablePath& path, bool expanded,
        bool expandAncestors)
{
        if (TreeTableNode* node = _NodeForPath(path))
                _SetNodeExpanded(node, expanded, expandAncestors);
}


void
TreeTable::ScrollToNode(const TreeTablePath& path)
{
        if (TreeTableNode* node = _NodeForPath(path))
                BColumnListView::ScrollTo(node->Row());
}


bool
TreeTable::AddTreeTableListener(TreeTableListener* listener)
{
        return fListeners.AddItem(listener);
}


void
TreeTable::RemoveTreeTableListener(TreeTableListener* listener)
{
        fListeners.RemoveItem(listener);
}


status_t
TreeTable::GetCellRectAt(const TreeTablePath& path, int32 colIndex,
        BRect& _output) const
{
        TreeTableNode* node = _NodeForPath(path);
        if (node == NULL)
                return B_ENTRY_NOT_FOUND;

        AbstractColumn* column = fColumns.ItemAt(colIndex);
        if (column == NULL)
                return B_ENTRY_NOT_FOUND;

        _output = GetFieldRect(node->Row(), column);

        return B_OK;
}


bool
TreeTable::GetToolTipAt(BPoint point, BToolTip** _tip)
{
        if (fToolTipProvider == NULL)
                return AbstractTable::GetToolTipAt(point, _tip);

        // get the table row
        BRow* row = RowAt(point);
        if (row == NULL)
                return AbstractTable::GetToolTipAt(point, _tip);

        TreeTableRow* treeRow = dynamic_cast<TreeTableRow*>(row);
        // get the table column
        BColumn* column = ColumnAt(point);

        int32 columnIndex = column != NULL ? column->LogicalFieldNum() : -1;

        TreeTablePath path;
        _GetPathForNode(treeRow->Node(), path);

        return fToolTipProvider->GetToolTipForTablePath(path, columnIndex,
                _tip);
}


void
TreeTable::SelectionChanged()
{
        if (fIgnoreSelectionChange > 0)
                return;

        fSelectionModel._SelectionChanged();

        if (!fListeners.IsEmpty()) {
                int32 listenerCount = fListeners.CountItems();
                for (int32 i = listenerCount - 1; i >= 0; i--)
                        fListeners.ItemAt(i)->TreeTableSelectionChanged(this);
        }
}


AbstractTable::AbstractColumn*
TreeTable::CreateColumn(TableColumn* column)
{
        return new Column(fModel, column);
}


void
TreeTable::ColumnMouseDown(AbstractColumn* column, BRow* _row, BField* field,
        BPoint screenWhere, uint32 buttons)
{
        if (!fListeners.IsEmpty()) {
                // get the table node and the column index
                TreeTableRow* row = dynamic_cast<TreeTableRow*>(_row);
                int32 columnIndex = column->LogicalFieldNum();
                if (row == NULL || columnIndex < 0)
                        return;

                // get the node path
                TreeTablePath path;
                _GetPathForNode(row->Node(), path);

                // notify listeners
                int32 listenerCount = fListeners.CountItems();
                for (int32 i = listenerCount - 1; i >= 0; i--) {
                        fListeners.ItemAt(i)->TreeTableCellMouseDown(this, path,
                                columnIndex, screenWhere, buttons);
                }
        }
}


void
TreeTable::ColumnMouseUp(AbstractColumn* column, BRow* _row, BField* field,
        BPoint screenWhere, uint32 buttons)
{
        if (!fListeners.IsEmpty()) {
                // get the table node and the column index
                TreeTableRow* row = dynamic_cast<TreeTableRow*>(_row);
                int32 columnIndex = column->LogicalFieldNum();
                if (row == NULL || columnIndex < 0)
                        return;

                // get the node path
                TreeTablePath path;
                _GetPathForNode(row->Node(), path);

                // notify listeners
                int32 listenerCount = fListeners.CountItems();
                for (int32 i = listenerCount - 1; i >= 0; i--) {
                        fListeners.ItemAt(i)->TreeTableCellMouseUp(this, path, columnIndex,
                                screenWhere, buttons);
                }
        }
}


void
TreeTable::TableNodesAdded(TreeTableModel* model, const TreeTablePath& path,
        int32 childIndex, int32 count)
{
        TreeTableNode* node = _NodeForPath(path);
        if (node == NULL)
                return;

        _AddChildRows(node, childIndex, count, fModel->CountColumns());
}


void
TreeTable::TableNodesRemoved(TreeTableModel* model, const TreeTablePath& path,
        int32 childIndex, int32 count)
{
        TreeTableNode* node = _NodeForPath(path);
        if (node == NULL)
                return;

        _RemoveChildRows(node, childIndex, count);
}


void
TreeTable::TableNodesChanged(TreeTableModel* model, const TreeTablePath& path,
        int32 childIndex, int32 count)
{
        TreeTableNode* node = _NodeForPath(path);
        if (node == NULL)
                return;

        int32 endIndex = childIndex + count;
        for (int32 i = childIndex; i < endIndex; i++) {
                if (TreeTableNode* child = node->ChildAt(i))
                        UpdateRow(child->Row());
        }
}


void
TreeTable::TableModelReset(TreeTableModel* model)
{
        _RemoveChildRows(fRootNode, 0, fRootNode->CountChildren());
        _AddChildRows(fRootNode, 0, fModel->CountChildren(
                fModel->Root()), fModel->CountColumns());
}


void
TreeTable::ExpandOrCollapse(BRow* _row, bool expand)
{
        TreeTableRow* row = dynamic_cast<TreeTableRow*>(_row);
        if (row == NULL || row->IsExpanded() == expand)
                return;

        AbstractTable::ExpandOrCollapse(row, expand);

        if (row->IsExpanded() != expand)
                return;

        TreeTablePath path;
        _GetPathForNode(row->Node(), path);

        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--)
                fListeners.ItemAt(i)->TreeTableNodeExpandedChanged(this, path, expand);
}


void
TreeTable::ItemInvoked()
{
        if (fListeners.IsEmpty())
                return;

        TreeTableRow* row = dynamic_cast<TreeTableRow*>(CurrentSelection());
        if (row == NULL)
                return;

        TreeTablePath path;
        _GetPathForNode(row->Node(), path);

        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--)
                fListeners.ItemAt(i)->TreeTableNodeInvoked(this, path);
}


bool
TreeTable::_AddChildRows(TreeTableNode* parentNode, int32 childIndex,
        int32 count, int32 columnCount)
{
        int32 childEndIndex = childIndex + count;
        for (int32 i = childIndex; i < childEndIndex; i++) {
                void* child = fModel->ChildAt(parentNode->ModelObject(), i);

                // create node
                TreeTableNode* node = new(std::nothrow) TreeTableNode(parentNode);
                if (node == NULL || node->Init(child, columnCount) != B_OK
                        || !parentNode->AddChild(node, i)) {
                        delete node;
                        return false;
                }

                // add row
                AddRow(node->Row(), i,
                        parentNode != fRootNode ? parentNode->Row() : NULL);

                // recursively create children
                if (!_AddChildRows(node, 0, fModel->CountChildren(child), columnCount))
                        return false;
        }

        return true;
}


void
TreeTable::_RemoveChildRows(TreeTableNode* parentNode, int32 childIndex,
        int32 count)
{
        // check if the removal request would in effect remove all
        // existing nodes.
        if (parentNode == fRootNode && childIndex == 0
                && count == parentNode->CountChildren()) {
                Clear();
                return;
        }

        for (int32 i = childIndex + count - 1; i >= childIndex; i--) {
                if (TreeTableNode* child = parentNode->RemoveChild(i)) {
                        int32 childCount = child->CountChildren();
                        if (childCount > 0)
                                _RemoveChildRows(child, 0, childCount);

                        RemoveRow(child->Row());
                        delete child;
                }
        }
}


void
TreeTable::_SetNodeExpanded(TreeTableNode* node, bool expanded,
        bool expandAncestors)
{
        if (expanded && expandAncestors && node != fRootNode)
                _SetNodeExpanded(node->Parent(), true, true);

        ExpandOrCollapse(node->Row(), expanded);
}


TreeTableNode*
TreeTable::_NodeForPath(const TreeTablePath& path) const
{
        TreeTableNode* node = fRootNode;

        int32 count = path.CountComponents();
        for (int32 i = 0; node != NULL && i < count; i++)
                node = node->ChildAt(path.ComponentAt(i));

        return node;
}


void
TreeTable::_GetPathForNode(TreeTableNode* node, TreeTablePath& _path) const
{
        if (node == fRootNode) {
                _path.Clear();
                return;
        }

        _GetPathForNode(node->Parent(), _path);
        _path.AddComponent(node->Parent()->IndexOf(node));
}