Javi
421 lines
11 KiB
C++
421 lines
11 KiB
C++
#include "treemodelcomposeelement.h"
|
|
#include "treeitem.h"
|
|
|
|
#include <QtWidgets>
|
|
|
|
|
|
TreeModelComposeElement::TreeModelComposeElement(const QStringList &headers, const QString &data, QObject *parent)
|
|
: QAbstractItemModel(parent)
|
|
{
|
|
QVector<QVariant> rootData;
|
|
foreach (QString header, headers)
|
|
rootData << header;
|
|
|
|
rootItem = new TreeItem(rootData);
|
|
//setupModelData(data.split(QString("\n")), rootItem);
|
|
|
|
// Insertar 20 filas vacias por defecto:
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
rootItem->insertChildren(rootItem->childCount(), 1, rootItem->columnCount());
|
|
for (int column = 0; column < rootItem->columnCount(); ++column)
|
|
rootItem->child(rootItem->childCount() - 1)->setData(column, QVariant());
|
|
}
|
|
}
|
|
|
|
TreeModelComposeElement::~TreeModelComposeElement()
|
|
{
|
|
delete rootItem;
|
|
}
|
|
//! [1]
|
|
|
|
//! [2]
|
|
int TreeModelComposeElement::columnCount(const QModelIndex & /* parent */) const
|
|
{
|
|
return rootItem->columnCount();
|
|
}
|
|
//! [2]
|
|
|
|
QVariant TreeModelComposeElement::data(const QModelIndex &index, int role) const
|
|
{
|
|
if (!index.isValid())
|
|
return QVariant();
|
|
|
|
TreeItem *item = getItem(index);
|
|
|
|
switch (role)
|
|
{
|
|
case Qt::DisplayRole:
|
|
case Qt::EditRole:
|
|
{
|
|
if(item->data(7).toString().isEmpty())
|
|
{
|
|
//return data(index, role).toString();
|
|
return item->data(index.column()).toString();
|
|
}
|
|
|
|
switch (index.column())
|
|
{
|
|
case 2:
|
|
case 3:
|
|
case 5:
|
|
case 6:
|
|
{
|
|
float value = 0;
|
|
|
|
if(item->data(index.column()).isValid())
|
|
{
|
|
value = item->data(index.column()).toFloat();
|
|
}
|
|
|
|
QLocale locale = QLocale("es_ES");
|
|
QString s = locale.toString(value, 'f', 2);
|
|
return s;
|
|
}
|
|
default:
|
|
return item->data(index.column()).toString();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case Qt::ForegroundRole:
|
|
if(index.column() == 0)
|
|
return QVariant::fromValue(QColor(Qt::blue));
|
|
else
|
|
return QVariant();
|
|
|
|
case Qt::TextAlignmentRole:
|
|
switch (index.column())
|
|
{
|
|
case 2:
|
|
case 3:
|
|
case 5:
|
|
case 6:
|
|
{
|
|
return int(Qt::AlignRight | Qt::AlignTop);
|
|
}
|
|
default:
|
|
return int(Qt::AlignLeft | Qt::AlignTop);
|
|
}
|
|
|
|
case Qt::FontRole:
|
|
if(item->childCount() > 0)
|
|
{
|
|
QFont font = QFont("Helvetica", 9, QFont::Bold);
|
|
return QVariant::fromValue(font);
|
|
}
|
|
else
|
|
return QVariant();
|
|
|
|
case Qt::SizeHintRole:
|
|
{
|
|
int he = 24;
|
|
switch (index.column())
|
|
{
|
|
case 0:
|
|
return QSize(30, he);
|
|
case 1:
|
|
return QSize(70, he);
|
|
case 2:
|
|
case 3:
|
|
return QSize(150, he);
|
|
case 4:
|
|
case 5:
|
|
return QSize(50, he);
|
|
case 6:
|
|
return QSize(40, he);
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
return QSize(50, he);
|
|
case 12:
|
|
return QSize(70, he);
|
|
default:
|
|
return QVariant();
|
|
}
|
|
}
|
|
|
|
case Qt::DecorationRole:
|
|
{
|
|
/*
|
|
0 Sin clasificar
|
|
1 Mano de obra
|
|
2 Maquinaria
|
|
3 Materiales
|
|
4 Componentes adicionales de residuo
|
|
5 Clasificación de residuo
|
|
*/
|
|
|
|
if(index.column() == 0)
|
|
{
|
|
if(item->data(7).toString() == "CO") // Compuesto
|
|
{
|
|
return QIcon(":/resources/icons/box.svg");
|
|
}
|
|
else if(item->data(7).toString() == "MT") // Materiales
|
|
{
|
|
return QIcon(":/resources/icons/blocks.svg");
|
|
}
|
|
else if(item->data(7).toString() == "MO") // Mano de obra
|
|
{
|
|
return QIcon(":/resources/icons/helmet.svg");
|
|
}
|
|
else if(item->data(7).toString() == "MQ") // Maquinaria
|
|
{
|
|
return QIcon(":/resources/icons/gear.svg");
|
|
}
|
|
}
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
//! [3]
|
|
Qt::ItemFlags TreeModelComposeElement::flags(const QModelIndex &index) const
|
|
{
|
|
if (!index.isValid())
|
|
return Qt::NoItemFlags;
|
|
|
|
Qt::ItemFlags flags = QAbstractItemModel::flags(index);
|
|
|
|
switch (index.column())
|
|
{
|
|
case 0:
|
|
case 2:
|
|
//case 5:
|
|
{
|
|
flags |= Qt::ItemIsEditable;
|
|
}
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
//! [3]
|
|
|
|
//! [4]
|
|
TreeItem *TreeModelComposeElement::getItem(const QModelIndex &index) const
|
|
{
|
|
if (index.isValid())
|
|
{
|
|
TreeItem *item = static_cast<TreeItem*>(index.internalPointer());
|
|
if (item)
|
|
return item;
|
|
}
|
|
return rootItem;
|
|
}
|
|
//! [4]
|
|
|
|
QVariant TreeModelComposeElement::headerData(int section, Qt::Orientation orientation,
|
|
int role) const
|
|
{
|
|
if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
|
|
return rootItem->data(section);
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
//! [5]
|
|
QModelIndex TreeModelComposeElement::index(int row, int column, const QModelIndex &parent) const
|
|
{
|
|
if (parent.isValid() && parent.column() != 0)
|
|
return QModelIndex();
|
|
//! [5]
|
|
|
|
//! [6]
|
|
TreeItem *parentItem = getItem(parent);
|
|
TreeItem *childItem = parentItem->child(row);
|
|
|
|
if (childItem)
|
|
return createIndex(row, column, childItem);
|
|
else
|
|
return QModelIndex();
|
|
}
|
|
//! [6]
|
|
|
|
bool TreeModelComposeElement::insertColumns(int position, int columns, const QModelIndex &parent)
|
|
{
|
|
bool success;
|
|
|
|
beginInsertColumns(parent, position, position + columns - 1);
|
|
success = rootItem->insertColumns(position, columns);
|
|
endInsertColumns();
|
|
|
|
return success;
|
|
}
|
|
|
|
bool TreeModelComposeElement::insertRows(int position, int rows, const QModelIndex &parent)
|
|
{
|
|
TreeItem *parentItem = getItem(parent);
|
|
bool success;
|
|
|
|
beginInsertRows(parent, position, position + rows - 1);
|
|
success = parentItem->insertChildren(position, rows, rootItem->columnCount());
|
|
endInsertRows();
|
|
|
|
return success;
|
|
}
|
|
|
|
//! [7]
|
|
QModelIndex TreeModelComposeElement::parent(const QModelIndex &index) const
|
|
{
|
|
if (!index.isValid())
|
|
return QModelIndex();
|
|
|
|
TreeItem *childItem = getItem(index);
|
|
TreeItem *parentItem = childItem->parent();
|
|
|
|
if (parentItem == rootItem)
|
|
return QModelIndex();
|
|
|
|
return createIndex(parentItem->childNumber(), 0, parentItem);
|
|
}
|
|
//! [7]
|
|
|
|
bool TreeModelComposeElement::removeColumns(int position, int columns, const QModelIndex &parent)
|
|
{
|
|
bool success;
|
|
|
|
beginRemoveColumns(parent, position, position + columns - 1);
|
|
success = rootItem->removeColumns(position, columns);
|
|
endRemoveColumns();
|
|
|
|
if (rootItem->columnCount() == 0)
|
|
removeRows(0, rowCount());
|
|
|
|
return success;
|
|
}
|
|
|
|
bool TreeModelComposeElement::removeRows(int position, int rows, const QModelIndex &parent)
|
|
{
|
|
TreeItem *parentItem = getItem(parent);
|
|
bool success = true;
|
|
|
|
beginRemoveRows(parent, position, position + rows - 1);
|
|
success = parentItem->removeChildren(position, rows);
|
|
endRemoveRows();
|
|
|
|
return success;
|
|
}
|
|
|
|
//! [8]
|
|
int TreeModelComposeElement::rowCount(const QModelIndex &parent) const
|
|
{
|
|
TreeItem *parentItem = getItem(parent);
|
|
|
|
return parentItem->childCount();
|
|
}
|
|
//! [8]
|
|
|
|
bool TreeModelComposeElement::setData(const QModelIndex &index, const QVariant &value, int role)
|
|
{
|
|
if (role != Qt::EditRole)
|
|
return false;
|
|
|
|
TreeItem *item = getItem(index);
|
|
bool result = item->setData(index.column(), value);
|
|
|
|
switch (index.column())
|
|
{
|
|
case 2:
|
|
item->setData(3, value);
|
|
calculateRow(item);
|
|
}
|
|
|
|
if (result)
|
|
{
|
|
emit dataChanged(index, index, {role});
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void TreeModelComposeElement::calculateRow(TreeItem *item)
|
|
{
|
|
float cu = item->data(2).toFloat();
|
|
float ct = item->data(3).toFloat();
|
|
float pcu = item->data(5).toFloat();
|
|
float pct = ct * pcu;
|
|
|
|
item->setData(6, pct);
|
|
}
|
|
|
|
bool TreeModelComposeElement::setHeaderData(int section, Qt::Orientation orientation,
|
|
const QVariant &value, int role)
|
|
{
|
|
if (role != Qt::EditRole || orientation != Qt::Horizontal)
|
|
return false;
|
|
|
|
bool result = rootItem->setData(section, value);
|
|
|
|
if (result)
|
|
emit headerDataChanged(orientation, section, section);
|
|
|
|
return result;
|
|
}
|
|
|
|
void TreeModelComposeElement::setupModelData(const QStringList &lines, TreeItem *parent)
|
|
{
|
|
QList<TreeItem*> parents;
|
|
QList<int> indentations;
|
|
parents << parent;
|
|
indentations << 0;
|
|
|
|
int number = 0;
|
|
|
|
while (number < lines.count())
|
|
{
|
|
int position = 0;
|
|
while (position < lines[number].length())
|
|
{
|
|
if (lines[number].at(position) != ' ')
|
|
break;
|
|
++position;
|
|
}
|
|
|
|
QString lineData = lines[number].mid(position).trimmed();
|
|
|
|
if (!lineData.isEmpty())
|
|
{
|
|
// Read the column data from the rest of the line.
|
|
QStringList columnStrings = lineData.split("\t", Qt::SkipEmptyParts);
|
|
QVector<QVariant> columnData;
|
|
for (int column = 0; column < columnStrings.count(); ++column)
|
|
columnData << columnStrings[column];
|
|
|
|
if (position > indentations.last())
|
|
{
|
|
// The last child of the current parent is now the new parent
|
|
// unless the current parent has no children.
|
|
|
|
if (parents.last()->childCount() > 0)
|
|
{
|
|
parents << parents.last()->child(parents.last()->childCount()-1);
|
|
indentations << position;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (position < indentations.last() && parents.count() > 0)
|
|
{
|
|
parents.pop_back();
|
|
indentations.pop_back();
|
|
}
|
|
}
|
|
|
|
// Append a new item to the current parent's list of children.
|
|
TreeItem *parent = parents.last();
|
|
parent->insertChildren(parent->childCount(), 1, rootItem->columnCount());
|
|
for (int column = 0; column < columnData.size(); ++column)
|
|
parent->child(parent->childCount() - 1)->setData(column, columnData[column]);
|
|
}
|
|
|
|
++number;
|
|
}
|
|
}
|