ZblDataModel.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZblDataModel.cpp
 * Created on: 3/22/2015
 * Author:     Bob Dinitto
 *
 * 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 "ZblDataModel.h"
#include "ZblTableHeaders.h"
#include "ZblException.h"

namespace Zbl
{

ZblDataModel::ZblDataModel() :
    m_headers(NULL),
    m_columnNames(NULL),
    m_roleNames(NULL),
    m_rootCell(new ZblTableCell())

{
}

ZblDataModel::~ZblDataModel()
{
    if(m_headers)
        delete m_headers;

    if(m_columnNames)
        delete m_columnNames;

    if(m_roleNames)
        delete m_roleNames;

    if(m_rootCell)
        delete m_rootCell;

}

void ZblDataModel::setColumnCount(int count, ZblTableCell* cell)
{
    if(cell)
        cell->data().setColumnCount(count);
    else
        rootCell().data().setColumnCount(count);
}

int ZblDataModel::columnCount(const ZblTableCell *cell) const
{
    if(cell)
        return cell->constData().columnCount();
    else
        return constRootCell().constData().columnCount();
}

int ZblDataModel::rowCount(const ZblTableCell *cell) const
{
    if(cell)
        return cell->constData().rowCount();
    else
        return constRootCell().constData().rowCount();
}

QVariant ZblDataModel::data(
        int role,
        int row,
        int col,
        const ZblTableCell* cell) const
{
    if(cell)
        return cell->constData().getValue(role, row, col);
    else
        return constRootCell().constData().getValue(role, row, col);
}

void ZblDataModel::setData(
        int role,
        int row,
        int col,
        const QVariant& value,
        ZblTableCell* cell)
{
    try
    {
    if(cell)
        cell->data().putValue(role, row, col, value);
    else
        rootCell().data().putValue(role, row, col, value);
    }
    catch(ZblException x)
    {
        QString msg = QString("ZblDataModel::setData - exception: %1").arg(x.message());
        qDebug("%s", msg.toUtf8().constData());

    }

}

QVariant ZblDataModel::getTableColumnRows(
        QList<int> roles,
        int startRow,
        int col,
        int rowCount,
        ZblTableCell *cell) const
{
    try
    {
    if(cell)
        return cell->constData().getTableColumnRows(roles, startRow, col, rowCount);
    else
        return constRootCell().constData().getTableColumnRows(roles, startRow, col, rowCount);
    }
    catch(ZblException x)
    {
        QString msg = QString("ZblDataModel::getTableColumnRows - exception: %1").arg(x.message());
        qDebug("%s", msg.toUtf8().constData());
    }
}

void ZblDataModel::putTableColumnRows(
        QVariant rows,
        int startRow,
        int col,
        ZblTableCell *cell)
{
    try
    {
    if(cell)
        cell->data().putTableColumnRows(rows, startRow, col);
    else
        rootCell().data().putTableColumnRows(rows, startRow, col);
    }
    catch(ZblException x)
    {
        QString msg = QString("ZblDataModel::setData - exception: %1").arg(x.message());
        qDebug("%s", msg.toUtf8().constData());

    }

}




void ZblDataModel::appendRow(QMap<int, QList<QVariant> > data,
        ZblTableCell* cell)

{
    try
    {
    if(cell)
        cell->data().appendRow(data);
    else
        rootCell().data().appendRow(data);
    }
    catch(ZblException x)
    {
        QString msg = QString("ZblDataModel::appendRow - exception: %1").arg(x.message());
        qDebug("%s", msg.toUtf8().constData());

    }
}

void ZblDataModel::appendRows(QList<QMap<int, QList<QVariant> > > data,
        ZblTableCell* cell)

{
    if(cell)
        cell->data().appendRows(data);
    else
        rootCell().data().appendRows(data);
}

void ZblDataModel::prependRow(QMap<int, QList<QVariant> > data,
        ZblTableCell* cell)

{
    try
    {
    if(cell)
        cell->data().prependRow(data);
    else
        rootCell().data().prependRow(data);
    }
    catch(ZblException x)
    {
        QString msg = QString("ZblDataModel::prependRow - exception: %1").arg(x.message());
        qDebug("%s", msg.toUtf8().constData());

    }
}

void ZblDataModel::prependRows(QList<QMap<int, QList<QVariant> > > data,
        ZblTableCell* cell)

{
    if(cell)
        cell->data().prependRows(data);
    else
        rootCell().data().prependRows(data);
}

void ZblDataModel::removeRows(int row, int count,
                              ZblTableCell* cell)
{
    if(cell)
        cell->data().removeRows(row, count);
    else
        rootCell().data().removeRows(row, count);
}

bool ZblDataModel::addRole(int roleNumber, ZblTableCell* cell)
{
    if(cell)
        return cell->data().addRole(roleNumber);
    else
        return rootCell().data().addRole(roleNumber);
}

bool ZblDataModel::addRole(int roleNumber,
                           const QByteArray& roleName,
                           ZblTableCell* cell)
{
    if(!m_roleNames)
        m_roleNames = new zRoleNames();
    else if(m_roleNames->contains(roleNumber))
        return false;

    m_roleNames->insert(roleNumber, roleName);

    if(cell)
        return cell->data().addRole(roleNumber);
    else
        return rootCell().data().addRole(roleNumber);
}



bool ZblDataModel::hasRole(int role, const ZblTableCell* cell) const
{
    if(cell)
        return cell->constData().hasRole(role);
    else
        return constRootCell().constData().hasRole(role);
}

QList<int> ZblDataModel::roles(const ZblTableCell* cell) const
{
    if(cell)
        return cell->constData().roles();
    else
        return constRootCell().constData().roles();
}

int ZblDataModel::roleCount(const ZblTableCell* cell) const
{
    if(cell)
        return cell->constData().roleCount();
    else
        return constRootCell().constData().roleCount();
}

void ZblDataModel::dumpModelData(const ZblTableCell* cell) const
{
    if(cell)
        return cell->constData().dumpData();
    else
        return constRootCell().constData().dumpData();
}

bool ZblDataModel::copyColumn(int fromColumn, int toColumn, ZblTableCell* cell)
{
    if(cell)
        return cell->data().copyColumn(fromColumn, toColumn);
    else
        return rootCell().data().copyColumn(fromColumn, toColumn);
}


ZblTableHeaders& ZblDataModel::headers()
{
    if(!m_headers)
        m_headers = new ZblTableHeaders();

    return *m_headers;
}

ZblTableCell& ZblDataModel::colNamesCell()
{
    if(!m_columnNames)
        m_columnNames = &rootCell();

    return *m_columnNames;
}

ZblDataModel::zRoleNames ZblDataModel::roleNames() const
{
    if(!m_roleNames)
        return zRoleNames();

    return *m_roleNames;
}

void ZblDataModel::clearData(ZblTableCell* cell)
{
    if(cell)
        return cell->data().clearData();
    else
        return rootCell().data().clearData();
}

void ZblDataModel::clearRoles()
{
    if(m_headers)
    {
        delete m_headers;
        m_headers = NULL;
    }

    if(m_columnNames)
    {
        delete m_columnNames;
        m_columnNames = NULL;
    }

    if(m_roleNames)
    {
        delete m_roleNames;
        m_roleNames = NULL;
    }

    if(m_rootCell)
    {
        delete m_rootCell;
        m_rootCell = new ZblTableCell();
    }

}



#if 0
void ZblDataModel::setRoleNames(const QHash<int, QByteArray> roleNames)
{
    if(!m_roleNames)
        m_roleNames = new zRoleNames(roleNames);
    else
       *m_roleNames = roleNames;
}
#endif

ZblTableCell& ZblDataModel::rootCell()
{
    return *m_rootCell;
}

const ZblTableCell& ZblDataModel::constRootCell() const
{
    return *m_rootCell;
}

int ZblDataModel::findNextItemRow(
        int startRow,
        const QString& text,
        int column,
        bool caseSensitive,
        bool forwardDirection,
        bool keySearch,
        const ZblTableCell* cell) const
{
    if(cell)
        return cell->constData().findNextItemRow(
                    startRow, text, column, caseSensitive, forwardDirection, keySearch);
    else
        return constRootCell().constData().findNextItemRow(
                    startRow, text, column, caseSensitive, forwardDirection, keySearch);
}


} // Zbl