|  | 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();
        }