Qt 4.6: qobjectxmlmodel.cpp Example File (xmlpatterns/qobjectxmlmodel/qobjectxmlmodel.cpp)

|  | Home · All Classes · Overviews |

# qobjectxmlmodel.cpp Example File
xmlpatterns/qobjectxmlmodel/qobjectxmlmodel.cpp

     /****************************************************************************
     **
     ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
     ** Contact: Nokia Corporation (qt-info@nokia.com)
     **
     ** This file is part of the examples of the Qt Toolkit.
     **
     ** $QT_BEGIN_LICENSE:LGPL$
     ** No Commercial Usage
     ** This file contains pre-release code and may not be distributed.
     ** You may use this file in accordance with the terms and conditions
     ** contained in the Technology Preview License Agreement accompanying
     ** this package.
     **
     ** GNU Lesser General Public License Usage
     ** Alternatively, this file may be used under the terms of the GNU Lesser
     ** General Public License version 2.1 as published by the Free Software
     ** Foundation and appearing in the file LICENSE.LGPL included in the
     ** packaging of this file.  Please review the following information to
     ** ensure the GNU Lesser General Public License version 2.1 requirements
     ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
     **
     ** In addition, as a special exception, Nokia gives you certain
     ** additional rights.  These rights are described in the Nokia Qt LGPL
     ** Exception version 1.1, included in the file LGPL_EXCEPTION.txt in this
     ** package.
     **
     ** If you have questions regarding the use of this file, please contact
     ** Nokia at qt-info@nokia.com.
     **
     **
     **
     **
     **
     **
     **
     **
     ** $QT_END_LICENSE$
     **
     ****************************************************************************/

     #include <QVector>
     #include <QtDebug>

     #include <QCoreApplication>
     #include <QMetaProperty>
     #include <QXmlQuery>
     #include <QXmlResultItems>

     #include "qobjectxmlmodel.h"

     /*
     <metaObjects>
         <metaObject className="QObject"/>
         <metaObject className="QWidget" superClass="QObject">
         </metaObject>
         ...
     </metaObjects>
     <QObject objectName="MyWidget" property1="..." property2="..."> <!-- This is root() -->
         <QObject objectName="MyFOO" property1="..."/>
         ....
     </QObject>
     */

     QObjectXmlModel::QObjectXmlModel(QObject *const object, const QXmlNamePool &np)
         : QSimpleXmlNodeModel(np),
           m_baseURI(QUrl::fromLocalFile(QCoreApplication::applicationFilePath())),
           m_root(object),
           m_allMetaObjects(allMetaObjects())
     {
         Q_ASSERT(m_baseURI.isValid());
     }

     QXmlNodeModelIndex QObjectXmlModel::qObjectSibling(const int pos, const QXmlNodeModelIndex &n) const
     {
         Q_ASSERT(pos == 1 || pos == -1);
         Q_ASSERT(asQObject(n));

         const QObject *parent = asQObject(n)->parent();
         if (parent) {
             const QList<QObject *> &children = parent->children();
             const int siblingPos = children.indexOf(asQObject(n)) + pos;

             if (siblingPos >= 0 && siblingPos < children.count())
                 return createIndex(children.at(siblingPos));
             else
                 return QXmlNodeModelIndex();
         }
         else
             return QXmlNodeModelIndex();
     }

     QObjectXmlModel::QObjectNodeType QObjectXmlModel::toNodeType(const QXmlNodeModelIndex &n)
     {
         return QObjectNodeType(n.additionalData() & (15 << 26));
     }

     QObjectXmlModel::AllMetaObjects QObjectXmlModel::allMetaObjects() const
     {
         QXmlQuery query(namePool());
         query.bindVariable("root", root());
         query.setQuery("declare variable $root external;"
                        "$root/descendant-or-self::QObject");
         Q_ASSERT(query.isValid());

         QXmlResultItems result;
         query.evaluateTo(&result);
         QXmlItem i(result.next());

         AllMetaObjects objects;
         while (!i.isNull()) {
             const QMetaObject *moo = asQObject(i.toNodeModelIndex())->metaObject();
             while (moo) {
                 if (!objects.contains(moo))
                     objects.append(moo);
                 moo = moo->superClass();
             }
             i = result.next();
         }

         Q_ASSERT(!objects.contains(0));
         return objects;
     }

     QXmlNodeModelIndex QObjectXmlModel::metaObjectSibling(const int pos, const QXmlNodeModelIndex &n) const
     {
         Q_ASSERT(pos == 1 || pos == -1);
         Q_ASSERT(!n.isNull());

         const int indexOf = m_allMetaObjects.indexOf(static_cast<const QMetaObject *>(n.internalPointer())) + pos;

         if (indexOf >= 0 && indexOf < m_allMetaObjects.count())
             return createIndex(const_cast<QMetaObject *>(m_allMetaObjects.at(indexOf)), MetaObject);
         else
             return QXmlNodeModelIndex();
     }

     QXmlNodeModelIndex QObjectXmlModel::nextFromSimpleAxis(SimpleAxis axis, const QXmlNodeModelIndex &n) const
     {
         switch (toNodeType(n))
         {
             case IsQObject:
             {
                 switch (axis)
                 {
                     case Parent:
                         return createIndex(asQObject(n)->parent());

                     case FirstChild:
                     {
                         if (!asQObject(n) || asQObject(n)->children().isEmpty())
                             return QXmlNodeModelIndex();
                         else
                             return createIndex(asQObject(n)->children().first());
                     }

                     case NextSibling:
                         return qObjectSibling(1, n);

                     case PreviousSibling:
                     {
                         if (asQObject(n) == m_root)
                             return createIndex(qint64(0), MetaObjects);
                         else
                             return qObjectSibling(-1, n);
                     }
                 }
                 Q_ASSERT(false);
             }

             case QObjectClassName:
             case QObjectProperty:
             {
                 Q_ASSERT(axis == Parent);
                 return createIndex(asQObject(n));
             }

             case MetaObjects:
             {
                 switch (axis)
                 {
                     case Parent:
                         return QXmlNodeModelIndex();
                     case PreviousSibling:
                         return QXmlNodeModelIndex();
                     case NextSibling:
                         return root();
                     case FirstChild:
                     {
                         return createIndex(const_cast<QMetaObject*>(m_allMetaObjects.first()),MetaObject);
                     }
                 }
                 Q_ASSERT(false);
             }

             case MetaObject:
             {
                 switch (axis)
                 {
                     case FirstChild:
                         return QXmlNodeModelIndex();
                     case Parent:
                         return createIndex(qint64(0), MetaObjects);
                     case PreviousSibling:
                         return metaObjectSibling(-1, n);
                     case NextSibling:
                         return metaObjectSibling(1, n);
                 }
             }

             case MetaObjectClassName:
             case MetaObjectSuperClass:
             {
                 Q_ASSERT(axis == Parent);
                 return createIndex(asQObject(n), MetaObject);
             }
         }

         Q_ASSERT(false);
         return QXmlNodeModelIndex();
     }

     QVector<QXmlNodeModelIndex> QObjectXmlModel::attributes(const QXmlNodeModelIndex& n) const
     {
          QVector<QXmlNodeModelIndex> result;
          QObject *const object = asQObject(n);

          switch(toNodeType(n))
          {
             case IsQObject:
             {
                 const QMetaObject *const metaObject = object->metaObject();
                 const int count = metaObject->propertyCount();
                 result.append(createIndex(object, QObjectClassName));

                 for (int i = 0; i < count; ++i) {
                     const QMetaProperty qmp(metaObject->property(i));
                     const int ii = metaObject->indexOfProperty(qmp.name());
                     if (i == ii)
                         result.append(createIndex(object, QObjectProperty | i));
                 }
                 return result;
             }

             case MetaObject:
             {
                 result.append(createIndex(object, MetaObjectClassName));
                 result.append(createIndex(object, MetaObjectSuperClass));
                 return result;
             }
             default:
                 return QVector<QXmlNodeModelIndex>();
          }
     }

     QObject *QObjectXmlModel::asQObject(const QXmlNodeModelIndex &n)
     {
         return static_cast<QObject *>(n.internalPointer());
     }

     bool QObjectXmlModel::isProperty(const QXmlNodeModelIndex n)
     {
         return n.additionalData() & QObjectProperty;
     }

     QUrl QObjectXmlModel::documentUri(const QXmlNodeModelIndex& ) const
     {
         return m_baseURI;
     }

     QXmlNodeModelIndex::NodeKind QObjectXmlModel::kind(const QXmlNodeModelIndex& n) const
     {
         switch (toNodeType(n))
         {
             case IsQObject:
             case MetaObject:
             case MetaObjects:
                 return QXmlNodeModelIndex::Element;

             case QObjectProperty:
             case MetaObjectClassName:
             case MetaObjectSuperClass:
             case QObjectClassName:
                 return QXmlNodeModelIndex::Attribute;
         }

         Q_ASSERT(false);
         return QXmlNodeModelIndex::Element;
     }

     QXmlNodeModelIndex::DocumentOrder QObjectXmlModel::compareOrder(const QXmlNodeModelIndex& , const QXmlNodeModelIndex& ) const
     {
         return QXmlNodeModelIndex::Follows; // TODO
     }

     QXmlNodeModelIndex QObjectXmlModel::root() const
     {
         return createIndex(m_root);
     }

     QXmlNodeModelIndex QObjectXmlModel::root(const QXmlNodeModelIndex& n) const
     {
         QObject *p = asQObject(n);
         Q_ASSERT(p);

         do {
             QObject *const candidate = p->parent();
             if (candidate)
                 p = candidate;
             else
                 break;
         }
         while (true);

         return createIndex(p);
     }

     /*!
       We simply throw all of them into a QList and
       return an iterator over it.
      */
     QXmlNodeModelIndex::List QObjectXmlModel::ancestors(const QXmlNodeModelIndex n) const
     {
         const QObject *p = asQObject(n);
         Q_ASSERT(p);

         QXmlNodeModelIndex::List result;
         do {
             QObject *const candidate = p->parent();
             if (candidate) {
                 result.append(createIndex(candidate, 0));
                 p = candidate;
             }
             else
                 break;
         }
         while (true);

         return result;
     }

     QMetaProperty QObjectXmlModel::toMetaProperty(const QXmlNodeModelIndex &n)
     {
         const int propertyOffset = n.additionalData() & (~QObjectProperty);
         const QObject *const qo = asQObject(n);
         return qo->metaObject()->property(propertyOffset);
     }

     QXmlName QObjectXmlModel::name(const QXmlNodeModelIndex &n) const
     {
         switch (toNodeType(n))
         {
             case IsQObject:
                 return QXmlName(namePool(), QLatin1String("QObject"));
             case MetaObject:
                 return QXmlName(namePool(), QLatin1String("metaObject"));
             case QObjectClassName:
             case MetaObjectClassName:
                 return QXmlName(namePool(), QLatin1String("className"));
             case QObjectProperty:
                 return QXmlName(namePool(), toMetaProperty(n).name());
             case MetaObjects:
                 return QXmlName(namePool(), QLatin1String("metaObjects"));
             case MetaObjectSuperClass:
                 return QXmlName(namePool(), QLatin1String("superClass"));
         }

         Q_ASSERT(false);
         return QXmlName();
     }

     QVariant QObjectXmlModel::typedValue(const QXmlNodeModelIndex &n) const
     {
         switch (toNodeType(n))
         {
             case QObjectProperty:
             {
                const QVariant &candidate = toMetaProperty(n).read(asQObject(n));
                if (isTypeSupported(candidate.type()))
                    return candidate;
                else
                    return QVariant();
             }

             case MetaObjectClassName:
                 return QVariant(static_cast<QMetaObject*>(n.internalPointer())->className());

             case MetaObjectSuperClass:
             {
                 const QMetaObject *const superClass = static_cast<QMetaObject*>(n.internalPointer())->superClass();
                 if (superClass)
                     return QVariant(superClass->className());
                 else
                     return QVariant();
             }

             case QObjectClassName:
                 return QVariant(asQObject(n)->metaObject()->className());

             default:
                 return QVariant();
         }
     }

     /*!
      Returns \c true if QVariants of type \a type can be used
      in QtXmlPatterns, otherwise \c false.
      */
     bool QObjectXmlModel::isTypeSupported(QVariant::Type type)
     {
         /* See data/qatomicvalue.cpp too. */
         switch (type)
         {
             /* Fallthrough all these. */
             case QVariant::Char:
             case QVariant::String:
             case QVariant::Url:
             case QVariant::Bool:
             case QVariant::ByteArray:
             case QVariant::Int:
             case QVariant::LongLong:
             case QVariant::ULongLong:
             case QVariant::Date:
             case QVariant::DateTime:
             case QVariant::Time:
             case QVariant::Double:
                 return true;
             default:
                 return false;
         }
     }