ZxItem.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * ZxItem.cpp
 *
 *  Created on: 29-Sep, 2013
 *      Author: Bob Dinitto   bob@ninzo.com
 *
 * Zuble is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <QXmlNodeModelIndex>
#include <QtQml>
#include "ZxItem.h"
#include "ZxQuery.h"
#include "ZblThreadErr.h"

namespace Zbl
{

ZxItem::ZxItem(QObject *parent) :
    QObject(parent), m_zQuery(NULL)
{
}

void ZxItem::registerType()
{
    qmlRegisterType<ZxItem>("org.zuble.qml", 1, 0, "ZxItem");
}

void ZxItem::setValue(const QXmlItem& item, ZxQuery* zQuery)
{
    m_item = item;

    m_zQuery = zQuery;

    emit stringValueChanged();
}

void ZxItem::setAtomicValue(QVariant value)
{
    m_item = QXmlItem(value);

    //m_zQuery = zQuery;

    emit stringValueChanged();
}

bool ZxItem::isAtomicValue() const
{
    return m_item.isAtomicValue();
}

bool ZxItem::isNode() const
{
    return m_item.isNode();
}

bool ZxItem::isNull() const
{
    return m_item.isNull();
}

QVariant ZxItem::toAtomicValue() const
{
    return m_item.toAtomicValue();
}

const QString ZxItem::getLocalName()
{
    QString result;

    if(!ensureIntegrity("ZxItem::getLocalName", "Item Not Initialized"))
        return result;

    QXmlNodeModelIndex mi(m_item.toNodeModelIndex());

    if(!mi.isNull())
    {
        QXmlName name = mi.model()->name(mi);

        result = name.localName(m_zQuery->getNamePool());
    }

    return result;
}

const QString ZxItem::getStringValue()
{
    QString result;

    if(!ensureIntegrity("ZxItem::elementById", "Item Not Initialized"))
        return result;

    QXmlNodeModelIndex mi(m_item.toNodeModelIndex());

    if(!mi.isNull())
        result = mi.model()->stringValue(mi);

    return result;

}


QObject* ZxItem::getRootNode()
{
    if(!ensureIntegrity("ZxItem::getRootNode", "Item Not Initialized"))
        return NULL;

    QXmlNodeModelIndex miThis(m_item.toNodeModelIndex());

    if(miThis.isNull())
        return NULL;

    QXmlNodeModelIndex miRoot = miThis.model()->root(miThis);

    ZxItem* result = new ZxItem();

    if(!miRoot.isNull())
        result->setValue(QXmlItem(miRoot), m_zQuery);
    else
        result->setValue(QXmlItem(), m_zQuery);

    return result;

}

QObject* ZxItem::elementById(const QString& id)
{
    if(!ensureIntegrity("ZxItem::elementById", "Item Not Initialized"))
        return NULL;

    QXmlNodeModelIndex miThis(m_item.toNodeModelIndex());

    if(miThis.isNull())
        return NULL;

    ZxItem* result = new ZxItem();

    QXmlNamePool np(m_zQuery->getNamePool());

    QXmlName idName(np, id);

    /*

    QXmlNodeModelIndex  miRoot = miThis.model()->root(miThis);

    if(miRoot.isNull())
    {
        qDebug("ZxItem::elementById - no root node returned");

        result->setValue(QXmlItem(), m_zQuery);

        return result;
    }
    */

    QXmlNodeModelIndex miId = miThis.model()->elementById(idName);


    if(!miId.isNull())
        result->setValue(QXmlItem(miId), m_zQuery);
    else
        result->setValue(QXmlItem(), m_zQuery);

    return result;
}

bool ZxItem::ensureIntegrity(const QString& code, const QString& message)
{
    if(m_zQuery)
        return true;

    zThreadErr.raiseError("ZxItem", code, message);

    return false;

}



} // Zbl