/****************************************************************************

**

** Copyright (C) 2005-2006 Trolltech ASA. All rights reserved.

**

** This file was part of the example classes of the Qt Toolkit.

** Now it's being hacked into some other shape... :)

**

** 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.

**

****************************************************************************/

#include "memxmlModel.h"

#include <QtGui>

#include <QtXml>

#include <QDomNode>

#include <QHash>

class DomItem

{

public:

DomItem(QDomNode &node, int row, DomItem *parent = 0);

~DomItem();

DomItem *child(int i);

DomItem *parent();

QDomNode node() const;

int row();

private:

QDomNode domNode;

QHash<int,DomItem*> childItems;

DomItem *parentItem;

int rowNumber;

};

DomItem::DomItem(QDomNode &node, int row, DomItem *parent)

{

domNode = node;

// Record the item's location within its parent.

rowNumber = row;

parentItem = parent;

}

DomItem::~DomItem()

{

QHash<int,DomItem*>::iterator it;

for (it = childItems.begin(); it != childItems.end(); ++it)

delete it.value();

}

QDomNode DomItem::node() const

{

return domNode;

}

DomItem *DomItem::parent()

{

return parentItem;

}

DomItem *DomItem::child(int i)

{

if (childItems.contains(i))

return childItems[i];

if (i >= 0 && i < domNode.childNodes().count()) {

QDomNode childNode = domNode.childNodes().item(i);

DomItem *childItem = new DomItem(childNode, i, this);

childItems[i] = childItem;

return childItem;

}

return 0;

}

int DomItem::row()

{

return rowNumber;

}

MemXMLModel::MemXMLModel(QDomDocument document, QObject *parent)

: QAbstractItemModel(parent), domDocument(document)

{

rootItem = new DomItem(domDocument, 0);

}

MemXMLModel::~MemXMLModel()

{

delete rootItem;

}

int MemXMLModel::columnCount(const QModelIndex & parent) const

{

Q_UNUSED(parent);

return 3;

}

QVariant MemXMLModel::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 MemXMLModel::flags(const QModelIndex &index) const

{

if (!index.isValid())

{

return Qt::ItemIsEnabled;

}

return Qt::ItemIsEnabled | Qt::ItemIsSelectable;

}

QVariant MemXMLModel::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 MemXMLModel::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 MemXMLModel::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 MemXMLModel::rowCount(const QModelIndex &parent) const

{

DomItem *parentItem;

if (!parent.isValid())

parentItem = rootItem;

else

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

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

}

#include "memxmlModel.moc"