inspectorJ -- JavaTM Profiler

sf project site browse source checkout source

src/inspectorj/model/classtreemodel.cpp

Go to the documentation of this file.

/***************************************************************************
 *   inspectorJ - java profiler                                            *
 *   Copyright (C) 2007 by  James May
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <QtGui>

#include "inspectorj/model/treeitem.h"
#include "inspectorj/model/classtreemodel.h"

using inspectorj::model::TreeItem;
        
namespace inspectorj {
namespace model {     
        
ClassTreeModel::ClassTreeModel(QObject *parent)
    : QAbstractItemModel(parent), javaClass(0), rootItem(0)
{
}

ClassTreeModel::~ClassTreeModel()
{
    if(rootItem) {
        delete rootItem;
        rootItem = 0;        
    }
}

int ClassTreeModel::columnCount(const QModelIndex &parent) const
{
    if (parent.isValid())
        return static_cast<TreeItem*>(parent.internalPointer())->columnCount();
    else
        return rootItem->columnCount();
}

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

    TreeItem *item = static_cast<TreeItem*>(index.internalPointer());
    if (role == Qt::DisplayRole) {        
        return item->data(index.column());
    }
    
    if (role == Qt::ForegroundRole) {
        if (item->parent() != 0) {
            if (item->parent()->parent() == 0)
                return Qt::darkBlue;
        }
        if (item->childCount() > 0)
            return Qt::darkRed;
    }
    return QVariant();
}

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

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

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

    return QVariant();
}

QModelIndex ClassTreeModel::index(int row, int column, const QModelIndex &parent)
            const
{
    TreeItem *parentItem;

    if (!parent.isValid())
        parentItem = rootItem;
    else
        parentItem = static_cast<TreeItem*>(parent.internalPointer());

    TreeItem *childItem = parentItem->child(row);
    if (childItem)
        return createIndex(row, column, childItem);
    else
        return QModelIndex();
}

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

    TreeItem *childItem = static_cast<TreeItem*>(index.internalPointer());
    TreeItem *parentItem = childItem->parent();
    if (parentItem == rootItem)
        return QModelIndex();

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

int ClassTreeModel::rowCount(const QModelIndex &parent) const
{
    TreeItem *parentItem;

    if (!parent.isValid())
        parentItem = rootItem;
    else
        parentItem = static_cast<TreeItem*>(parent.internalPointer());

    return parentItem->childCount();
}

void ClassTreeModel::setupModelData(TreeItem *root)
{
    QList<QVariant> classlist;
    classlist << this->javaClass->getClassSignature();
    TreeItem *classItem = new TreeItem(classlist,root);
    root->appendChild(classItem);
    
    QList<QVariant> fields;
    fields << QString("fields");
    
    // Add Fields
    TreeItem *fieldsItem = new TreeItem(fields, classItem);
    QList<JavaField*>& fieldList = this->javaClass->getFields();
    QList<JavaField*>::iterator iter;
    for (iter = fieldList.begin(); iter != fieldList.end(); ++iter) {
        QList<QVariant> fieldData;
        fieldData << (*iter)->getFieldName()
                << (*iter)->getFieldSignature()
                << (*iter)->getFieldId().value;
        TreeItem *fieldItem = new TreeItem(fieldData, fieldsItem);
        fieldsItem->appendChild(fieldItem);
    }
    if (fieldList.size() > 0) {
        classItem->appendChild(fieldsItem);            
    }
    
    QList<QVariant> methods;
    methods << QString("methods");
    
    // Add Methods
    TreeItem *methodsItem = new TreeItem(methods, classItem);
    QList<JavaMethod*>& methodList = this->javaClass->getMethods();
    QList<JavaMethod*>::iterator m_iter;
    for (m_iter = methodList.begin(); m_iter != methodList.end(); ++m_iter) {
        QList<QVariant> methodData;
        methodData << (*m_iter)->getMethodSignature() 
                << (*m_iter)->getJNIMethodSignature() 
                << (*m_iter)->getMethodId().value;
        TreeItem *methodItem = new TreeItem(methodData, methodsItem);
        methodsItem->appendChild(methodItem);
    }    
    if (methodList.size() > 0) {
        classItem->appendChild(methodsItem);           
    } 
}

void ClassTreeModel::setJavaClass(JavaClass* javaClass)
{
    this->javaClass = javaClass;
}

void ClassTreeModel::initModel()
{
    if (! javaClass) {
        return;
    }
    
    QList<QVariant> rootData;
    rootData << this->javaClass->getJNIClassSignature() << QString("");
    if (rootItem) {
        delete rootItem;
        rootItem = 0;
    }
    rootItem = new TreeItem(rootData);
    setupModelData(rootItem);
    reset();
}


} // end namespace inspectorj
} // end namespace model

---