documentchoosermodel.cpp

Go to the documentation of this file.

#include <QStringList>
#include <QDebug>
#include <QIcon>
#include "documentchoosermodel.h"
#include "../Data/datadefinitions.h"
#include "abstractmodel.h"
#include "../Models/costtypemodel.h"

DocumentChooserModel::DocumentChooserModel(QObject *parent) : QAbstractItemModel(parent)
{
    p_rootItem = new DocumentItem(new AbstractModel(-1, -1, "Dokumente"));

    addDocumentType(WindowType::CostType);
    addDocumentType(WindowType::CostCentre);
    addDocumentType(WindowType::CostUnit);
    addDocumentType(WindowType::PriceComparison);
}

DocumentChooserModel::~DocumentChooserModel()
{
    delete p_rootItem;
}

int DocumentChooserModel::columnCount(const QModelIndex &parent) const
{
    if(parent.isValid())
    {
        return static_cast<DocumentItem*>(parent.internalPointer())->columnCount();
    }
    else
    {
        return p_rootItem->columnCount();
    }
}

QVariant DocumentChooserModel::data(const QModelIndex &index, int role) const
{
    if(!index.isValid())
    {
        return QVariant();
    }

    if(role == 32)
    {
        DocumentItem *item = documentItem(index.parent().data(Qt::DisplayRole).toString(), index.data(Qt::DisplayRole).toString());

        QVariant var;
        var.setValue(*item); // copy item into the variant (call by VALUE!!)

        return var;
    }

    if(role == Qt::DecorationRole)
    {
        DocumentItem *item = static_cast<DocumentItem*>(index.internalPointer());
        switch(item->type())
        {
            case WindowType::CostType:
            {
                return QIcon(":/childwindows/CostType");
            }
            case WindowType::CostCentre:
            {
                return QIcon(":/childwindows/CostCentre");
            }
            case WindowType::CostUnit:
            {
                return QIcon(":/childwindows/CostUnit");
            }
            case WindowType::PriceComparison:
            {
                return QIcon(":/childwindows/PriceComparison");
            }
        }
    }

    if(role == Qt::DisplayRole)
    {
        DocumentItem *item = static_cast<DocumentItem*>(index.internalPointer());
        return item->data(index.column());
    }
    return QVariant();
}

DocumentItem* DocumentChooserModel::documentItem(int fileid, int documentType) const
{
    DocumentItem* root = p_rootItem;
    for(int i = 0; i != root->childCount(); i++)
    {
        DocumentItem *category = root->child(i);

        if(category->model()->type() == documentType)
        {
            for(int j = 0; j != category->childCount(); j++)
            {
                DocumentItem *item = category->child(j);
                if(item->model()->fileId() == fileid)
                {
                    return item;
                }
            }
        }
    }
    return new DocumentItem(new AbstractModel(-1, -1, ""));
}

DocumentItem* DocumentChooserModel::documentItem(QString documentType, QString filename) const
{
    DocumentItem* root = p_rootItem;
    for(int i = 0; i != root->childCount(); i++)
    {
        DocumentItem *category = root->child(i);
        WindowType *type = new WindowType();
        if(type->type(category->model()->type()) == documentType)
        {
            for(int j = 0; j != category->childCount(); j++)
            {
                DocumentItem *item = category->child(j);
                if(item->model()->fileName() == filename)
                {
                    return item;
                }
            }
        }
    }
    return new DocumentItem(new AbstractModel(-1, -1, ""));
}

AbstractModel* DocumentChooserModel::abstractModel(int fileid, int documentType) const
{
    DocumentItem* root = p_rootItem;
    for(int i = 0; i != root->childCount(); i++)
    {
        DocumentItem *category = root->child(i);
        WindowType *type = new WindowType();
        if(category->model()->type() == documentType)
        {
            for(int j = 0; j != category->childCount(); j++)
            {
                DocumentItem *item = category->child(j);
                if(item->model()->fileId() == fileid)
                {
                    return item->model();
                }
            }
        }
    }
    return new AbstractModel(-1, -1, "");
}

Qt::ItemFlags DocumentChooserModel::flags(const QModelIndex &index) const
{
    if(!index.isValid())
    {
        return 0;
    }

    return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}

QVariant DocumentChooserModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if(orientation == Qt::Horizontal && role == Qt::DisplayRole)
    {
        return p_rootItem->model()->fileName();
    }

    return QVariant();
}

QModelIndex DocumentChooserModel::index(int row, int column, const QModelIndex &parent) const
{
    if(!hasIndex(row, column, parent))
    {
        return QModelIndex();
    }

    DocumentItem *parentItem;

    if(!parent.isValid())
    {
        parentItem = p_rootItem;
    }
    else
    {
        parentItem = static_cast<DocumentItem*>(parent.internalPointer());
    }

    DocumentItem *childItem = parentItem->child(row);
    if(childItem)
    {
        return createIndex(row, column, childItem);
    }
    else
    {
        return QModelIndex();
    }
}

QModelIndex DocumentChooserModel::parent(const QModelIndex &index) const
{
    if(!index.isValid())
    {
        return QModelIndex();
    }

    DocumentItem *childItem = static_cast<DocumentItem*>(index.internalPointer());
    DocumentItem *parentItem = childItem->parent();

    if(parentItem == p_rootItem)
    {
        return QModelIndex();
    }

    return createIndex(parentItem->row(), 0, parentItem);
}

int DocumentChooserModel::rowCount(const QModelIndex &parent) const
{
    DocumentItem *parentItem;
    if(parent.column() > 0)
        return 0;

    if(!parent.isValid())
    {
        parentItem = p_rootItem;
    }
    else
    {
        parentItem = static_cast<DocumentItem*>(parent.internalPointer());
    }
    return parentItem->childCount();
}

void DocumentChooserModel::addDocumentType(int documentType)
{
    WindowType *window = new WindowType();

    p_rootItem->appendChild(new DocumentItem(new AbstractModel(-1, documentType, window->type(documentType)), p_rootItem));

    reset();                     //NEEDED!!!! -- otherwise the view won't update!
}

void DocumentChooserModel::addDocument(AbstractModel *model)
{
    for(int i=0; i < p_rootItem->childCount();i++)
    {
        DocumentItem *type = p_rootItem->child(i);
        if(type->model()->type() == model->type())
        {
            p_rootItem->childItems.value(i)->appendChild(new DocumentItem(model, p_rootItem->childItems.value(i)));
            reset();            //NEEDED!!!! -- otherwise the view doesn't display anything of the new position!
        }
    }
}

bool DocumentChooserModel::documentExists(int fileid, int documentType)
{
    bool exists = false;
    for(int i = 0; i != p_rootItem->childCount(); i++)
    {
        DocumentItem *cate = p_rootItem->child(i);
        if(cate->type() == documentType)
        {
            for(int j = 0; j != cate->childCount(); j++)
            {
                DocumentItem *pos = cate->child(j);
                if(pos->fileid() == fileid)
                {
                    exists = true;
                }
            }
        }
    }
    return exists;
}

void DocumentChooserModel::deleteDocument(int fileid, int documentType)
{
    for(int i = 0; i != p_rootItem->childCount(); i++)
    {
        DocumentItem *cat = p_rootItem->child(i);
        if(cat->type() == documentType)
        {
            for(int j = 0; j != cat->childCount(); j++)
            {
                DocumentItem *item = cat->child(j);
                if(item->fileid() == fileid)
                {
                    cat->removeChild(item);

                    reset();
                    emit documentRemoved(fileid);

                    return;
                }
            }
        }
    }
}

void DocumentChooserModel::clear()
{
    for(int i = 0; i < p_rootItem->childCount(); i++)
    {
        DocumentItem *cat = p_rootItem->child(i);
        cat->removeChilds();

        reset();
    }
}

bool DocumentChooserModel::fileExists(const QString &name) const
{
    for(int i = 0; i < p_rootItem->childCount(); i++)
    {
        DocumentItem *cat = p_rootItem->child(i);
        for(int j = 0; j < cat->childCount(); j++)
        {
            DocumentItem *doc = cat->child(j);
            if(QString::compare(doc->fileName(), name, Qt::CaseInsensitive) == 0)
            {
                return true;
            }
        }
    }
    return false;
}

CostTypeModel* DocumentChooserModel::costTypeModelById(int fileId)
{
    return (CostTypeModel*)abstractModel(fileId, WindowType::CostType);
}

DocumentItem::DocumentItem(AbstractModel *model, DocumentItem *parent)
{
    p_model = model;

    parentItem = parent;
}

DocumentItem::~DocumentItem()
{
    qDeleteAll(childItems);
}

void DocumentItem::appendChild(DocumentItem *item)
{
    childItems.append(item);
}

void DocumentItem::removeChild(DocumentItem *item)
{
    childItems.removeAll(item);
}

void DocumentItem::removeChilds()
{
    childItems.clear();
}

DocumentItem *DocumentItem::child(int row)
{
    return childItems.value(row);
}

int DocumentItem::childCount() const
{
    return childItems.count();
}

int DocumentItem::columnCount() const
{
    return 1;
}

QVariant DocumentItem::data(int column) const
{
    return p_model->fileName();
}

AbstractModel* DocumentItem::model() const
{
    return p_model;
}

int DocumentItem::fileid() const
{
    return p_model->fileId();
}

QString DocumentItem::fileName() const
{
    return p_model->fileName();
}

int DocumentItem::type() const
{
    return p_model->type();
}

DocumentItem *DocumentItem::parent()
{
    return parentItem;
}

int DocumentItem::row() const
{
    if(parentItem)
    {
        return parentItem->childItems.indexOf(const_cast<DocumentItem*>(this));
    }

    return 0;
}

---