Home · All Classes · Main Classes · Grouped Classes · Modules · Functions

dommodel.cpp Example File
^{itemviews/simpledommodel/dommodel.cpp}

    /****************************************************************************
    **
    ** Copyright (C) 2005-2005 Trolltech AS. All rights reserved.
    **
    ** This file is part of the documentation of the Qt Toolkit.
    **
    ** This file may be used under the terms of the GNU General Public
    ** License version 2.0 as published by the Free Software Foundation
    ** and appearing in the file LICENSE.GPL included in the packaging of
    ** this file.  Please review the following information to ensure GNU
    ** General Public Licensing requirements will be met:
    ** http://www.trolltech.com/products/qt/opensource.html
    **
    ** If you are unsure which license is appropriate for your use, please
    ** review the following information:
    ** http://www.trolltech.com/products/qt/licensing.html or contact the
    ** sales department at sales@trolltech.com.
    **
    ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
    ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
    **
    ****************************************************************************/

    /*
        model.cpp

        Provides a DOM model for use in various examples.
    */

    #include <QtGui>
    #include <QtXml>

    #include "domitem.h"
    #include "dommodel.h"

    DomModel::DomModel(QDomDocument document, QObject *parent)
        : QAbstractItemModel(parent), domDocument(document)
    {
        rootItem = new DomItem(domDocument, 0);
    }

    DomModel::~DomModel()
    {
        delete rootItem;
    }

    int DomModel::columnCount(const QModelIndex &/*parent*/) const
    {
        return 3;
    }

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

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

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

        QDomNode node = item->node();
        QStringList attributes;
        QDomNamedNodeMap attributeMap = node.attributes();

        switch (index.column()) {
            case 0:
                return node.nodeName();
            case 1:
                for (int i = 0; (unsigned int)(i) < attributeMap.count(); ++i) {
                    QDomNode attribute = attributeMap.item(i);
                    attributes << attribute.nodeName() + "=\""
                                  +attribute.nodeValue() + "\"";
                }
                return attributes.join(" ");
            case 2:
                return node.nodeValue().split("\n").join(" ");
            default:
                return QVariant();
        }
    }

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

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

    QVariant DomModel::headerData(int section, Qt::Orientation orientation,
                                  int role) const
    {
        if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
            switch (section) {
                case 0:
                    return tr("Name");
                case 1:
                    return tr("Attributes");
                case 2:
                    return tr("Value");
                default:
                    return QVariant();
            }
        }

        return QVariant();
    }

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

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

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

    QModelIndex DomModel::parent(const QModelIndex &child) const
    {
        if (!child.isValid())
            return QModelIndex();

        DomItem *childItem = static_cast<DomItem*>(child.internalPointer());
        DomItem *parentItem = childItem->parent();

        if (!parentItem || parentItem == rootItem)
            return QModelIndex();

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

    int DomModel::rowCount(const QModelIndex &parent) const
    {
        DomItem *parentItem;

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

        return parentItem->node().childNodes().count();
    }