644 lines
17 KiB
C++
644 lines
17 KiB
C++
/*
|
|
Georges Editor Qt
|
|
Copyright (C) 2010 Adrian Jaekel <aj at elane2k dot com>
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "georgesform_model.h"
|
|
|
|
// NeL includes
|
|
#include <nel/misc/types_nl.h>
|
|
#include <nel/misc/rgba.h>
|
|
#include <nel/misc/path.h>
|
|
#include <nel/georges/u_form_elm.h>
|
|
#include <nel/georges/u_type.h>
|
|
#include <nel/georges/u_form_dfn.h>
|
|
|
|
// Qt includes
|
|
#include <QColor>
|
|
#include <QBrush>
|
|
#include <QApplication>
|
|
#include <QStyle>
|
|
#include <QDebug>
|
|
|
|
// project includes
|
|
#include "formitem.h"
|
|
#include "modules.h"
|
|
|
|
using namespace NLGEORGES;
|
|
|
|
namespace NLQT
|
|
{
|
|
|
|
CGeorgesFormModel::CGeorgesFormModel(UFormElm *rootElm, QMap< QString, QStringList> deps,
|
|
QString comment, QStringList parents, QObject *parent) : QAbstractItemModel(parent)
|
|
{
|
|
QList<QVariant> rootData;
|
|
rootData << "Value" << "Data" << "Extra";// << "Type";
|
|
_rootElm = rootElm;
|
|
_rootItem = new CFormItem(_rootElm, rootData);
|
|
_dependencies = deps;
|
|
_comments = comment;
|
|
_parents = parents;
|
|
_parentRows = new QList<const QModelIndex*>;
|
|
|
|
setupModelData();
|
|
}
|
|
|
|
CGeorgesFormModel::~CGeorgesFormModel()
|
|
{
|
|
delete _rootItem;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
QVariant CGeorgesFormModel::data(const QModelIndex &p_index, int p_role) const
|
|
{
|
|
if (!p_index.isValid())
|
|
return QVariant();
|
|
|
|
switch (p_role)
|
|
{
|
|
case Qt::DisplayRole:
|
|
{
|
|
return getItem(p_index)->data(p_index.column());
|
|
}
|
|
case Qt::BackgroundRole:
|
|
{
|
|
QBrush defaultBrush = QBrush(QColor(255,0,0,30));
|
|
QBrush parentBrush = QBrush(QColor(0,255,0,30));
|
|
|
|
// if elm not existing it must be some kind of default or type value
|
|
if(!getItem(p_index)->getFormElm())
|
|
{
|
|
return defaultBrush;
|
|
}
|
|
|
|
// else it might be some parent elm
|
|
switch (getItem(p_index)->nodeFrom())
|
|
{
|
|
case NLGEORGES::UFormElm::NodeParentForm:
|
|
{
|
|
return parentBrush;
|
|
}
|
|
case NLGEORGES::UFormElm::NodeForm:
|
|
{
|
|
switch (getItem(p_index)->valueFrom())
|
|
{
|
|
case NLGEORGES::UFormElm::ValueParentForm:
|
|
{
|
|
return parentBrush;
|
|
}
|
|
default:
|
|
{
|
|
// parent status test kindof ugly, testing only 2 steps deep
|
|
// only needed for colorization as treeview default hides childs
|
|
// when parent is hidden
|
|
CFormItem *parent = getItem(p_index)->parent();
|
|
if (parent)
|
|
{
|
|
if (parent->nodeFrom() == NLGEORGES::UFormElm::NodeParentForm)
|
|
{
|
|
return parentBrush;
|
|
}
|
|
|
|
CFormItem *parentParent = parent->parent();
|
|
if (parentParent)
|
|
{
|
|
if (parentParent->nodeFrom() == NLGEORGES::UFormElm::NodeParentForm)
|
|
{
|
|
return parentBrush;
|
|
}
|
|
} // endif parentParent
|
|
} // endif parent
|
|
} // end default
|
|
} // end switch valueFrom
|
|
} // end case nodeForm
|
|
default:
|
|
break;
|
|
} // end switch nodeFrom
|
|
return QVariant();
|
|
}
|
|
case Qt::DecorationRole:
|
|
{
|
|
if (p_index.column() == 2)
|
|
{
|
|
//p_index.
|
|
QModelIndex in = index(p_index.row(),p_index.column()-1,p_index.parent());
|
|
CFormItem *item = getItem(in);
|
|
|
|
QString value = item->data(1).toString();
|
|
//QString path = NLMISC::CPath::lookup(value.toUtf8().constData(),false).c_str();
|
|
|
|
if (value.contains(".shape"))
|
|
{
|
|
if (Modules::objViewInt())
|
|
{
|
|
QIcon *icon = Modules::objViewInt()->saveOneImage(value.toUtf8().constData());
|
|
if (icon)
|
|
{
|
|
if(icon->isNull())
|
|
return QIcon(":/images/pqrticles.png");
|
|
else
|
|
return QIcon(*icon);
|
|
}
|
|
else
|
|
{
|
|
return QIcon();
|
|
}
|
|
}
|
|
}
|
|
else if(value.contains(".tga") || value.contains(".png"))
|
|
{
|
|
QString path = NLMISC::CPath::lookup(value.toUtf8().constData(),false).c_str();
|
|
if(path.isEmpty())
|
|
{
|
|
path = ":/images/pqrticles.png";
|
|
}
|
|
return QIcon(path);
|
|
}
|
|
}
|
|
return QVariant();
|
|
break;
|
|
}
|
|
case Qt::ToolTipRole:
|
|
{
|
|
if (p_index.column() == 2)
|
|
{
|
|
QModelIndex in = index(p_index.row(),p_index.column()-1,p_index.parent());
|
|
CFormItem *item = getItem(in);
|
|
QString value = item->data(1).toString();
|
|
|
|
if (value.contains(".shape"))
|
|
{
|
|
if (Modules::objViewInt())
|
|
{
|
|
QIcon *icon = Modules::objViewInt()->saveOneImage(value.toUtf8().constData());
|
|
if (icon)
|
|
{
|
|
if(icon->isNull())
|
|
return QIcon(":/images/pqrticles.png");
|
|
else
|
|
return QIcon(*icon);
|
|
}
|
|
else
|
|
{
|
|
return QIcon();
|
|
}
|
|
}
|
|
}
|
|
else if(value.contains(".tga") || value.contains(".png"))
|
|
{
|
|
QString path = NLMISC::CPath::lookup(value.toUtf8().constData(),false).c_str();
|
|
if(path.isEmpty())
|
|
{
|
|
path = ":/images/pqrticles.png";
|
|
}
|
|
|
|
QString imageTooltip = QString("<img src='%1'>").arg(path);
|
|
|
|
return imageTooltip;
|
|
}
|
|
}
|
|
return QVariant();
|
|
break;
|
|
}
|
|
default:
|
|
return QVariant();
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
CFormItem *CGeorgesFormModel::getItem(const QModelIndex &index) const
|
|
{
|
|
if (index.isValid())
|
|
{
|
|
CFormItem *item = static_cast<CFormItem*>(index.internalPointer());
|
|
if (item)
|
|
return item;
|
|
}
|
|
return _rootItem;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
bool CGeorgesFormModel::setData(const QModelIndex &index, const QVariant &value,
|
|
int role)
|
|
{
|
|
|
|
if (role != Qt::EditRole)
|
|
return false;
|
|
|
|
CFormItem *item = getItem(index);
|
|
bool result = item->setData(index.column(), value);
|
|
|
|
// TODO: ugly hack for updating icon too
|
|
if (result)
|
|
Q_EMIT dataChanged(index, this->index(index.row(),index.column()+1,index.parent()));
|
|
|
|
setupModelData();
|
|
return result;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
Qt::ItemFlags CGeorgesFormModel::flags(const QModelIndex& index) const {
|
|
|
|
if (!index.isValid())
|
|
return 0;
|
|
|
|
Qt::ItemFlags returnValue = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
|
|
|
|
if(index.column() == 1)
|
|
returnValue |= Qt::ItemIsEditable;
|
|
// TODO?
|
|
// col 2 should go here too but i dont want to do another delegate
|
|
// so for now i just connected the dblClick in the dialog
|
|
|
|
return returnValue;
|
|
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
QVariant CGeorgesFormModel::headerData(int section,
|
|
Qt::Orientation orientation, int role) const
|
|
{
|
|
if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
|
|
return _rootItem->data(section);
|
|
|
|
return QVariant();
|
|
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
QModelIndex CGeorgesFormModel::index(int row, int column, const QModelIndex &parent)
|
|
const
|
|
{
|
|
if (!hasIndex(row, column, parent))
|
|
return QModelIndex();
|
|
|
|
CFormItem *parentItem;
|
|
|
|
if (!parent.isValid())
|
|
parentItem = _rootItem;
|
|
else
|
|
parentItem = static_cast<CFormItem*>(parent.internalPointer());
|
|
|
|
CFormItem *childItem = parentItem->child(row);
|
|
if (childItem)
|
|
return createIndex(row, column, childItem);
|
|
else
|
|
return QModelIndex();
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
QModelIndex CGeorgesFormModel::parent(const QModelIndex &index) const
|
|
{
|
|
if (!index.isValid())
|
|
return QModelIndex();
|
|
|
|
CFormItem *childItem = static_cast<CFormItem*>(index.internalPointer());
|
|
CFormItem *parentItem = childItem->parent();
|
|
|
|
if (parentItem == _rootItem)
|
|
return QModelIndex();
|
|
|
|
return createIndex(parentItem->row(), 0, parentItem);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
int CGeorgesFormModel::rowCount(const QModelIndex &parent) const {
|
|
|
|
CFormItem *parentItem;
|
|
if (parent.column() > 0)
|
|
return 0;
|
|
|
|
if (!parent.isValid())
|
|
parentItem = _rootItem;
|
|
else
|
|
parentItem = static_cast<CFormItem*>(parent.internalPointer());
|
|
|
|
return parentItem->childCount();
|
|
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
int CGeorgesFormModel::columnCount(const QModelIndex &parent) const {
|
|
|
|
if (parent.isValid())
|
|
return static_cast<CFormItem*>(parent.internalPointer())->columnCount();
|
|
else
|
|
return _rootItem->columnCount();
|
|
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CGeorgesFormModel::loadFormData(UFormElm *root, CFormItem *parent) {
|
|
|
|
if (!root)
|
|
return;
|
|
|
|
uint num = 0;
|
|
|
|
|
|
if (root->isStruct())
|
|
{
|
|
//((CFormElm*)root)->getForm()->getComment();
|
|
uint structSize = 0;
|
|
root->getStructSize(structSize);
|
|
while (num < structSize)
|
|
{
|
|
UFormElm::TWhereIsNode *whereN = new UFormElm::TWhereIsNode;
|
|
UFormElm::TWhereIsValue *whereV = new UFormElm::TWhereIsValue;
|
|
// Append a new item to the current parent's list of children.
|
|
std::string elmName;
|
|
if(root->getStructNodeName(num, elmName))
|
|
{
|
|
QList<QVariant> columnData;
|
|
//QVariant value;
|
|
std::string value;
|
|
//NLMISC::CRGBA value_color;
|
|
//uint value_uint;
|
|
//sint value_sint;
|
|
//double value_double;
|
|
QString elmtType;
|
|
UFormElm *elmt = 0;
|
|
if(root->getNodeByName(&elmt, elmName.c_str(), whereN, true))
|
|
{
|
|
if (elmt)
|
|
{
|
|
if (elmt->isArray())
|
|
elmtType = "Array";
|
|
if (elmt->isStruct())
|
|
elmtType = "Struct";
|
|
if (elmt->isAtom()) {
|
|
elmtType = "Atom";
|
|
uint numDefinitions = 0;
|
|
const UType *type = elmt->getType();
|
|
if (type)
|
|
{
|
|
numDefinitions = type->getNumDefinition();
|
|
root->getValueByName(value, elmName.c_str(),UFormElm::Eval,whereV);
|
|
switch (type->getType())
|
|
{
|
|
case UType::UnsignedInt:
|
|
value = QString("%1").arg(QString(value.c_str()).toDouble()).toUtf8().constData();
|
|
elmtType.append("_uint");break;
|
|
case UType::SignedInt:
|
|
value = QString("%1").arg(QString(value.c_str()).toDouble()).toUtf8().constData();
|
|
elmtType.append("_sint");break;
|
|
case UType::Double:
|
|
value = QString("%1").arg(QString(value.c_str()).toDouble(),0,'f',1).toUtf8().constData();
|
|
elmtType.append("_double");break;
|
|
case UType::String:
|
|
elmtType.append("_string");break;
|
|
case UType::Color:
|
|
elmtType.append("_color");break;
|
|
default:
|
|
elmtType.append("_unknownType");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
elmtType.append("_noType");
|
|
}
|
|
|
|
if (numDefinitions)
|
|
{
|
|
std::string l, v;
|
|
QString tmpLabel, tmpValue;
|
|
for (uint i = 0; i < numDefinitions; i++)
|
|
{
|
|
type->getDefinition(i,l,v);
|
|
tmpLabel = l.c_str();
|
|
tmpValue = v.c_str();
|
|
if (type->getType() == UType::SignedInt)
|
|
{
|
|
if (QString("%1").arg(value.c_str()).toDouble() == tmpValue.toDouble()) {
|
|
value = l;
|
|
break;
|
|
}
|
|
}
|
|
if (type->getType() == UType::String)
|
|
{
|
|
if (QString(value.c_str()) == tmpValue)
|
|
{
|
|
value = l;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (elmt->isVirtualStruct())
|
|
{
|
|
root->getValueByName(value, elmName.c_str(),UFormElm::Eval,whereV);
|
|
elmtType = "VirtualStruct";
|
|
}
|
|
switch (*whereN)
|
|
{
|
|
case UFormElm::NodeForm:
|
|
elmtType.append("_fromForm"); break;
|
|
case UFormElm::NodeParentForm:
|
|
elmtType.append("_fromParentForm"); break;
|
|
case UFormElm::NodeDfn:
|
|
elmtType.append("_isDFN"); break;
|
|
case UFormElm::NodeType:
|
|
elmtType.append("_isType"); break;
|
|
default:
|
|
elmtType.append("_noNode");
|
|
}
|
|
switch (*whereV)
|
|
{
|
|
case UFormElm::ValueForm:
|
|
elmtType.append("_formValue"); break;
|
|
case UFormElm::ValueParentForm:
|
|
elmtType.append("_parentValue"); break;
|
|
case UFormElm::ValueDefaultDfn:
|
|
elmtType.append("_dfnValue"); break;
|
|
case UFormElm::ValueDefaultType:
|
|
elmtType.append("_typeValue"); break;
|
|
default:
|
|
elmtType.append("_noValue");
|
|
}
|
|
columnData << QString(elmName.c_str()) << QString(value.c_str()) << "" << elmtType;
|
|
parent->appendChild(new CFormItem(elmt, columnData, parent, *whereV, *whereN));
|
|
//if (parents.last()->childCount() > 0) {
|
|
// parents << parents.last()->child(parents.last()->childCount()-1);
|
|
//}
|
|
loadFormData(elmt, parent->child(parent->childCount()-1));
|
|
}
|
|
else
|
|
{
|
|
// add Defaults
|
|
// TODO: spams warnings for non ATOM values but i dont get type of non existing nodes
|
|
bool success = root->getValueByName(value, elmName.c_str(),UFormElm::Eval,whereV);
|
|
switch (*whereN)
|
|
{
|
|
case UFormElm::NodeForm:
|
|
elmtType.append("_fromForm"); break;
|
|
case UFormElm::NodeParentForm:
|
|
elmtType.append("_fromParentForm"); break;
|
|
case UFormElm::NodeDfn:
|
|
elmtType.append("_isDFN"); break;
|
|
case UFormElm::NodeType:
|
|
elmtType.append("_isType"); break;
|
|
default:
|
|
elmtType.append("_noNode");
|
|
}
|
|
switch (*whereV)
|
|
{
|
|
case UFormElm::ValueForm:
|
|
elmtType.append("_formValue"); break;
|
|
case UFormElm::ValueParentForm:
|
|
elmtType.append("_parentValue"); break;
|
|
case UFormElm::ValueDefaultDfn:
|
|
elmtType.append("_dfnValue"); break;
|
|
case UFormElm::ValueDefaultType:
|
|
elmtType.append("_typeValue"); break;
|
|
default:
|
|
elmtType.append("_noValue");
|
|
}
|
|
|
|
columnData << QString(elmName.c_str()) << QString(value.c_str()) << "" << elmtType;
|
|
parent->appendChild(new CFormItem(elmt, columnData, parent, *whereV, *whereN));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nlinfo("getNodeByName returned false");
|
|
}
|
|
}
|
|
num++;
|
|
}
|
|
}
|
|
if (root->isArray())
|
|
{
|
|
uint arraySize = 0;
|
|
root->getArraySize(arraySize);
|
|
while (num < arraySize)
|
|
{
|
|
std::string elmName;
|
|
if(root->getArrayNodeName(elmName, num))
|
|
{
|
|
QList<QVariant> columnData;
|
|
std::string value;
|
|
QString elmtType;
|
|
|
|
UFormElm *elmt = 0;
|
|
if(root->getArrayNode(&elmt,0) && elmt)
|
|
{
|
|
if (elmt->isArray())
|
|
elmtType = "Array";
|
|
if (elmt->isStruct()) {
|
|
elmtType = "Struct";
|
|
}
|
|
if (elmt->isAtom())
|
|
{
|
|
elmt->getValue(value);
|
|
elmtType = "Atom";
|
|
}
|
|
if (elmt->isVirtualStruct())
|
|
elmtType = "VirtualStruct";
|
|
|
|
elmtType.append("_arrayValue");
|
|
columnData << QString(elmName.c_str()) << QString(value.c_str()) << "" << elmtType;
|
|
parent->appendChild(new CFormItem(elmt, columnData, parent));
|
|
loadFormData(elmt, parent->child(parent->childCount()-1));
|
|
}
|
|
}
|
|
num++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CGeorgesFormModel::loadFormHeader()
|
|
{
|
|
|
|
CFormItem *fi_pars = new CFormItem(_rootElm, QList<QVariant>() << "parents", _rootItem);
|
|
_rootItem->appendChild(fi_pars);
|
|
|
|
Q_FOREACH(QString str, _parents)
|
|
{
|
|
fi_pars->appendChild(new CFormItem(_rootElm, QList<QVariant>() << str, fi_pars));
|
|
}
|
|
|
|
/*QStringList dfns = _dependencies["dfn"];
|
|
QStringList typs = _dependencies["typ"];
|
|
|
|
_dependencies.remove("dfn");
|
|
_dependencies.remove("typ");
|
|
|
|
CFormItem *fi_dep = new CFormItem(_rootElm, QList<QVariant>() << "dependencies", _rootItem);
|
|
_rootItem->appendChild(fi_dep);
|
|
|
|
if (!dfns.isEmpty()) {
|
|
CFormItem *fi_dfn = new CFormItem(_rootElm, QList<QVariant>() << "dfn", fi_dep);
|
|
fi_dep->appendChild(fi_dfn);
|
|
foreach(QString str, dfns) {
|
|
fi_dfn->appendChild(new CFormItem(_rootElm, QList<QVariant>() << str, fi_dfn));
|
|
}
|
|
}
|
|
if (!typs.isEmpty()) {
|
|
CFormItem *fi_typ = new CFormItem(_rootElm, QList<QVariant>() << "typ", fi_dep);
|
|
fi_dep->appendChild(fi_typ);
|
|
foreach(QString str, typs) {
|
|
fi_typ->appendChild(new CFormItem(_rootElm, QList<QVariant>() << str, fi_typ));
|
|
}
|
|
}
|
|
if (!_dependencies.isEmpty()) {
|
|
CFormItem *fi_other = new CFormItem(_rootElm, QList<QVariant>() << "other", fi_dep);
|
|
fi_dep->appendChild(fi_other);
|
|
foreach(QStringList list, _dependencies) {
|
|
foreach(QString str, list) {
|
|
fi_other->appendChild(new CFormItem(_rootElm, QList<QVariant>() << str, fi_other));
|
|
}
|
|
}
|
|
}*/
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CGeorgesFormModel::setupModelData()
|
|
{
|
|
loadFormHeader();
|
|
loadFormData(_rootElm, _rootItem);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CGeorgesFormModel::setShowParents( bool show ) {
|
|
_showParents = show;
|
|
Q_EMIT layoutAboutToBeChanged();
|
|
Q_EMIT layoutChanged();
|
|
}
|
|
void CGeorgesFormModel::setShowDefaults( bool show )
|
|
{
|
|
_showDefaults = show;
|
|
Q_EMIT layoutAboutToBeChanged();
|
|
Q_EMIT layoutChanged();
|
|
}
|
|
} /* namespace NLQT */
|
|
|
|
/* end of file */
|