treeviews

// I'm trying to convert the Simple Tree Model Example to be called in
// the following way instead of the file that's passed in and parsed.

// Here I create the root item and pass it to the model.
    QList<QVariant> root_data;
    root_data << "Column 1" << "Column 2";

    MyTreeItem *parent_item = new MyTreeItem(root_data);

    tree_model = new MyTreeModel(parent_item);

// Then I create a child and add it.
    QList<QVariant> mp_data;
    mp_data << "ABC" << "DEF";

    MyTreeItem *mp_item = new MyTreeItem(mp_data);

    parent_item->appendChild(mp_item);

// The problem is, it's crashing in MyTreeModel::rowCount().
// Here's the MyTreeModel.cpp

MyTreeModel::MyTreeModel(MyTreeItem *item, QObject *parent) :
    QAbstractItemModel(parent)

{
    root_item = item;
}

MyTreeModel::~MyTreeModel()
{
    delete root_item;
}

QModelIndex MyTreeModel::index(int row, int column,
    const QModelIndex &parent) const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();

    MyTreeItem *parent_item;

    if (!parent.isValid())
        parent_item = root_item;
    else
        parent_item = static_cast<MyTreeItem *>(parent.internalPointer());

    MyTreeItem *child_item = parent_item->child(row);

    if (child_item)
        return createIndex(row, column, child_item);
    else
        return QModelIndex();
}

QModelIndex MyTreeModel::parent(const QModelIndex &index) const
{
    if (!index.isValid())
        return QModelIndex();

    MyTreeItem *child_item = static_cast<MyTreeItem *>
        (index.internalPointer());
    MyTreeItem *parent_item = child_item->parent();

    if (parent_item == root_item)
        return QModelIndex();

    return createIndex(parent_item->row(), 0, parent_item);
}

int MyTreeModel::rowCount(const QModelIndex &parent) const
{
    MyTreeItem *parent_item;

    if (parent.column() > 0)
        return 0;

    if (!parent.isValid())
        parent_item = root_item;
    else
        // it's crashing here ...
        parent_item = static_cast<MyTreeItem *>(parent.internalPointer());

    return parent_item->childCount();
}

int MyTreeModel::columnCount(const QModelIndex &parent) const
{
    if (parent.isValid())
        return static_cast<MTreeItem *>(parent.internalPointer())->columnCount();
    else
        return root_item->columnCount();
}

Qt::ItemFlags MyTreeModel::flags(const QModelIndex &index) const
{
    if (!index.isValid())
        return 0;

    return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}

QVariant MyTreeModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid())
        return QVariant();

    if (role != Qt::DisplayRole)
        return QVariant();

    MyTreeItem *item = static_cast<MyTreeItem *>(index.internalPointer());

    return item->data(index.column());
}

QVariant MyTreeModel::headerData(int section, Qt::Orientation orientation,
    int role) const
{
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
        return root_item->data(section);
    return QVariant();
}

// MyTreeItem.cpp

MyTreeItem::MyTreeItem(const QList<QVariant> &data, MyTreeItem *parent)
{
    parent_item = parent;
    item_data = data;
}

MyTreeItem::~MyTreeItem()
{
    qDeleteAll(child_items);
}

void MyTreeItem::appendChild(MyTreeItem *item)
{
    child_items.append(item);
}

MyTreeItem* MyTreeItem::child(int row)
{
    return child_items.value(row);
}

int MyTreeItem::childCount() const
{
    return child_items.count();
}

int MyTreeItem::row() const
{
    if (parent_item)
        return parent_item->child_items.indexOf(const_cast<MyTreeItem*>(this));

    return 0;
}

int MyTreeItem::columnCount() const
{
    return item_data.count();
}

QVariant MyTreeItem::data(int column) const
{
    return item_data.value(column);
}

MyTreeItem* MyTreeItem::parent()
{
    return parent_item;
}

bool MyTreeItem::isChecked() const
{
    return checked;
}

void MyTreeItem::setChecked(bool set)
{
    checked = set;;
}