void ProjectModel::addProject(Project *project)
{
//Add project and its name.
ProjectTreeItem *childProject = new ProjectTreeItem(project, project->projectName(), rootItem);
//Add each file in the project with its name
for(int i = 0; i < project->filesCount(); i++)
{
StringAndAnnotations saa = project->file(i);
ProjectTreeItem *childFile = new ProjectTreeItem(project, saa.first, childProject);
//For each file add the annotations (one per row in the model)
for(int j = 0; j < saa.second.size(); j++)
{
QVariant var;
var.setValue(saa.second.at(j));
ProjectTreeItem * childAnnotation = new ProjectTreeItem(project, var, childFile);
childFile->appendChild(childAnnotation);
}
childProject->appendChild(childFile);
}
rootItem->appendChild(childProject);
}
QVariant ProjectModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
if (role != Qt::DisplayRole && role != Qt::UserRole)
return QVariant();
ProjectTreeItem *item = static_cast<ProjectTreeItem*>(index.internalPointer());
return item->data(index.column(), role);
}
void BondDelegate::primitiveUpdated(Primitive *primitive)
{
if (primitive->type() == Primitive::MoleculeType) {
initialize();
return;
}
if (primitive->type() != Primitive::BondType)
return;
ProjectTreeItem *item = m_label->child(primitive->index());
item->setData(0, tr("bond %1").arg(primitive->index()));
}
/**
* @brief ProjectManagerTreeModel::parent Get parent of item with index.
* @param child Child where we want get parent item.
* @return Parent of given child.
*/
QModelIndex ProjectManagerTreeModel::parent(const QModelIndex &child) const
{
if(!child.isValid())
return QModelIndex();
ProjectTreeItem* cItem = static_cast<ProjectTreeItem*>(child.internalPointer());
ProjectTreeItem* pItem = cItem->getParent();
if(pItem == root)
return QModelIndex();
return createIndex(pItem->getRow(), 0, pItem);
}
int ProjectModel::rowCount(const QModelIndex &parent) const
{
ProjectTreeItem *parentItem;
if (parent.column() > 0)
return 0;
if (!parent.isValid())
parentItem = rootItem;
else
parentItem = static_cast<ProjectTreeItem*>(parent.internalPointer());
return parentItem->childCount();
}
QModelIndex ProjectModel::parent(const QModelIndex &index) const
{
if (!index.isValid())
return QModelIndex();
ProjectTreeItem *childItem = static_cast<ProjectTreeItem*>(index.internalPointer());
ProjectTreeItem *parentItem = childItem->parent();
if (parentItem == rootItem)
return QModelIndex();
return createIndex(parentItem->row(), 0, parentItem);
}
ProjectTreeItem* ProjectTreeModelDelegate::insertExpandableItem(ProjectTreeItem *parent)
{
// insert at the end
int position = parent->childCount();
d->model->insertRows(parent, position, 1);
// retrieve the item
ProjectTreeItem *item = parent->child(position);
// set it to non-terminal
item->setTerminal(false);
// store it (for hasExpandableItem & fetchMore)
d->expandableItems.append(item);
return item;
}
bool ProjectModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
if(!index.isValid())
return false;
if(role == Qt::EditRole)
{
ProjectTreeItem *item = static_cast<ProjectTreeItem*>(index.internalPointer());
item->setData(value);
return true;
}
return false;
}
void ProjectTree::loadItem(QTreeWidgetItem *item)
{
ProjectTreeItem *clickedItem = static_cast<ProjectTreeItem*>(item);
if (!clickedItem->isLoaded()) {
QDir* rootDir = new QDir(clickedItem->getFileInfo()->absoluteFilePath());
clickedItem->setLoaded(true);
for (QFileInfo fileInfo : rootDir->entryInfoList(QDir::Filter::AllEntries | QDir::Filter::NoDotAndDotDot, QDir::SortFlag::DirsFirst)) {
ProjectTreeItem* child = new ProjectTreeItem(fileInfo);
clickedItem->addChild(child);
}
resizeColumnToContents(0);
}
}
void ProjectTree::on_itemClicked(QTreeWidgetItem *item, int column)
{
ProjectTreeItem *clickedItem = static_cast<ProjectTreeItem*>(item);
if (clickedItem->getFileInfo()->isDir()) {
if (clickedItem->isExpanded())
clickedItem->setExpanded(false);
else
clickedItem->setExpanded(true);
}
else
emit fileClicked(clickedItem);
(void)column;
}
void BondDelegate::primitiveAdded(Primitive *primitive)
{
if (primitive->type() != Primitive::BondType)
return;
// add the new primitive to the end
model()->insertRows(m_label, m_label->childCount(), 1);
// get the item
ProjectTreeItem *item = m_label->child(m_label->childCount() - 1);
item->setData(0, tr("bond %1").arg(primitive->index()));
// set the primitive
PrimitiveList primitives;
primitives.append(primitive);
item->setPrimitives(primitives);
}
/**
* @brief ProjectManagerTreeModel::projectRemoved Call this method if project with given name was removed.
* @param projName Name of the old project.
*/
void ProjectManagerTreeModel::projectRemoved(QString projName)
{
int row = root->getRowCount();
for(int i = 0; i < row; ++i)
{
ProjectTreeItem* item = root->getChild(i);
if(item->getDataString() == projName)
{
insertData = projName;
insertType = ProjectTreeItem::PROJECT;
removeRows(i, 1);
return;
}
}
}
void BondDelegate::primitiveRemoved(Primitive *primitive)
{
if (primitive->type() != Primitive::BondType)
return;
// remove the row
model()->removeRows(m_label, primitive->index(), 1);
// loop over all atoms to fix their index if needed
if ((primitive->index() + 1) < (unsigned long) m_label->childCount()) {
for (int i = primitive->index(); i < m_label->childCount(); ++i) {
ProjectTreeItem *item = m_label->child(i);
item->setData(0, tr("bond %1").arg(i));
}
}
}
void SelectionDelegate::initialize()
{
// remove any existing rows
if (m_label->childCount())
model()->removeRows(m_label, 0, m_label->childCount());
QList<QString> names = m_widget->namedSelections();
// add the selectionss...
model()->insertRows(m_label, 0, names.size());
for (int i = 0; i < m_label->childCount(); ++i) {
ProjectTreeItem *item = m_label->child(i);
item->setData(0, names.at(i));
item->setData(1, QString("%1").arg(i));
// set the primitive
PrimitiveList primitives = m_widget->namedSelectionPrimitives(i);
item->setPrimitives(primitives);
}
}
/**
* @brief ProjectManagerTreeModel::index Get index of item on row and column with given parent.
* @param row Row number.
* @param column Column number.
* @param parent Parent of item we want to get.
* @return Index of our item.
*/
QModelIndex ProjectManagerTreeModel::index(int row, int column, const QModelIndex &parent) const
{
if(!hasIndex(row, column, parent))
return QModelIndex();
ProjectTreeItem* pItem;
if(!parent.isValid())
pItem = root;
else
pItem = static_cast<ProjectTreeItem*>(parent.internalPointer());
ProjectTreeItem* cItem = pItem->getChild(row);
if(cItem)
return createIndex(row,column, cItem);
else
return QModelIndex();
}
/**
* @brief ProjectManagerTreeModel::projectActiveChanged Call this method if active project was changed.
* @param newProject New active project.
* @param oldProject Old active project.
*/
void ProjectManagerTreeModel::projectActiveChanged(QString newProject, QString oldProject)
{
// new project is set
int rowNumber = root->getRowCount();
ProjectTreeItem* oldP = NULL;
ProjectTreeItem* newP = NULL;
int oldRow = 0;
int newRow = 0;
for(int i = 0; i < rowNumber; ++i)
{
ProjectTreeItem* item = root->getChild(i);
if(item->getDataString() == newProject)
{
newP = item;
newRow = i;
}
else if(item->getDataString() == oldProject)
{
oldP = item;
oldRow = i;
}
}
if(oldP != NULL)
{
QModelIndex index = createIndex(oldRow, 0, oldP);
dataChanged(index,index);
}
if(newP != NULL)
{
QModelIndex indexNew = createIndex(newRow, 0, newP);
dataChanged(indexNew,indexNew);
}
}
void ProjectModel::rollback(QModelIndex &index, int n)
{
ProjectTreeItem *item = static_cast<ProjectTreeItem*>(index.internalPointer());
QVariant var = item->data(0, Qt::UserRole);
CompleteAnnotationItem *currentAnnotation = var.value<CompleteAnnotationItem*>();
Revision<AnnotationItem*> revision = currentAnnotation->getRevision(n);
RevisionAnnotationList revisions;
for(int i = 0; i < n; i++){
revisions << currentAnnotation->getRevision(i);
}
CompleteAnnotationItem *newAnnotation =
new CompleteAnnotationItem(revision.getValue()->getId(),
revision.getValue(), revisions);
var.setValue<CompleteAnnotationItem*>(newAnnotation);
item->setData(var);
}
void BondDelegate::initialize()
{
Molecule *molecule = m_widget->molecule();
// remove any existing rows
if (m_label->childCount())
model()->removeRows(m_label, 0, m_label->childCount());
// add the bonds...
model()->insertRows(m_label, 0, molecule->numBonds());
for (int i = 0; i < m_label->childCount(); ++i) {
ProjectTreeItem *item = m_label->child(i);
item->setData(0, tr("bond %1").arg(i));
// set the primitive
PrimitiveList primitives;
primitives.append(molecule->bond(i));
item->setPrimitives(primitives);
}
}
void ProjectModel::commit(QModelIndex &index)
{
ProjectTreeItem *item = static_cast<ProjectTreeItem*>(index.internalPointer());
QVariant var = item->data(0, Qt::UserRole);
CompleteAnnotationItem *oldAnnot = var.value<CompleteAnnotationItem*>();
AnnotationItem* oldItem = oldAnnot->getItem();
AnnotationItem* newItem = new AnnotationItem(oldItem->getId(),
new ConllGraph(*oldItem->getOriginalParse()),
new ConllGraph(*oldItem->getEditableParse()));
RevisionAnnotationList revisions;
for(int i = 0; i < oldAnnot->getRevisionsCount(); i++)
revisions << oldAnnot->getRevision(i);
revisions << Revision<AnnotationItem*>(oldItem);
CompleteAnnotationItem *newAnnot = new CompleteAnnotationItem(oldAnnot->id(), newItem, revisions);
item->setData(QVariant::fromValue(newAnnot));
//Which file the item belongs ?
QString filename = item->parent()->data(0).toString();
//Get the annotation and update
int indexFile = item->project()->findFile(filename);
item->project()->changeAnnotation( indexFile , index.row(), newAnnot );
//item->project()->addModified( indexFile, index.row() );
}
/**
* @brief ProjectManagerTreeModel::shaderRemoved Call this method when shader was removed.
* @param name Name of the removed shader.
*/
void ProjectManagerTreeModel::shaderRemoved(QString name, MetaShader::SHADERTYPE type)
{
ProjectTreeItem* item;
MetaProject* proj = dynamic_cast<MetaProject*>(sender());
if(proj == NULL)
return;
//convert path to -> projectName '/' path
QString projName = proj->getName();
name.insert(0,projName + '/');
if(type == MetaShader::FRAGMENT)
//item = root->findLastCreated(name.split(QDir::separator()),ProjectTreeItem::FRAGMENT);
item = root->findLastCreated(name.split('/'),ProjectTreeItem::FRAGMENT);
else
//item = root->findLastCreated(name.split(QDir::separator()),ProjectTreeItem::VERTEX);
item = root->findLastCreated(name.split('/'),ProjectTreeItem::VERTEX);
ProjectTreeItem* candidate = item->getRemoveCandidate();
int row = candidate->getRow();
insertData = name;
insertType = ProjectTreeItem::SHADER;
QModelIndex index = createIndex(candidate->getParent()->getRow(), 0, candidate->getParent());
removeRows(row,1,index);
emit dataChanged(index,index);
}
/**
* @brief ProjectManagerTreeModel::removeRows Remove rows from this model.
* @param row Row number where we start removing items.
* @param count How many items we want to remove.
* @param parent Parent of items we want to remove.
* @return True if we removed items, false otherwise.
*/
bool ProjectManagerTreeModel::removeRows(int row, int count, const QModelIndex &parent)
{
beginRemoveRows(parent, row, row+count);
if(insertType == ProjectTreeItem::PROJECT)
{
ProjectTreeItem* item = root->getChild(row);
delete item;
}
else if(insertType == ProjectTreeItem::SHADER)
{
ProjectTreeItem* parentItem = static_cast<ProjectTreeItem*>(parent.internalPointer());
ProjectTreeItem* item = parentItem->getChild(row);
delete item;
}
endRemoveRows();
return true;
}
/**
* @brief ProjectManagerTreeModel::shaderCreated Call this method when new shader was created.
* @param name Name of the new shader.
*/
void ProjectManagerTreeModel::shaderCreated(QString name)
{
ProjectTreeItem* item;
MetaProject* p = static_cast<MetaProject*>(sender());
QStringList treePath;
treePath << p->getName();
if(p->getFragmentRelativePaths().contains(name))
treePath << FRAG;
else
treePath << VERT;
//treePath += name.split(QDir::separator());
treePath += name.split('/');
item = root->findLastCreatedFromStart(treePath);
//int row = item->getRowCount();
//QStringList offset = item->getNewPart(name.split(QDir::separator()));
QStringList offset = item->getNewPart(name.split('/'));
int row = 0;
insertData = name;
insertType = ProjectTreeItem::SHADER; // insert new shader
temp = item;
if(offset.size() == 1)
{
row = item->getNewItemPosition(offset.first(),ProjectTreeItem::SHADER);
}
else if(offset.size() == 0)
{
row = item->getNewItemPosition("",ProjectTreeItem::DIRECTORY);
}
else
{
row = item->getNewItemPosition(offset.first(),ProjectTreeItem::DIRECTORY);
}
QModelIndex index = createIndex(item->getRow(),0,item);
insertRows(row, 1, index);
emit dataChanged(index,index);
}
/**
* @brief ProjectManagerTreeModel::data Get data of this item on index with given role.
* @param index Index what item we want.
* @param role What data role we want to get.
* @return QVariant data.
*/
QVariant ProjectManagerTreeModel::data(const QModelIndex &index, int role) const
{
if(!index.isValid())
return QVariant();
ProjectTreeItem* item = static_cast<ProjectTreeItem*>(index.internalPointer());
// Display role
if(role == Qt::DisplayRole) // get name string
return QVariant(item->getDataString());
else if(role == Qt::UserRole) // get type of this item - User roles
return QVariant(item->getType());
else if(role == Qt::UserRole + 1) // get name of item (program name, so shader relative path for shader, name of project etc.
{
ProjectTreeItem::TYPE type = item->getType();
if(type == ProjectTreeItem::SHADER)
{
MetaShader* sh = static_cast<MetaShader*>(item->getData());
return QVariant(sh->getShader());
}
else if(type == ProjectTreeItem::PROJECT)
{
MetaProject* proj = static_cast<MetaProject*>(item->getData());
return QVariant(proj->getName());
}
}
else if(role == Qt::UserRole + 2 && item->getType() == ProjectTreeItem::SHADER) // get project of this shader item
{
MetaProject* proj = static_cast<MetaProject*>(item->findProject());
return QVariant(proj->getName());
}
// font role
else if(role == Qt::FontRole)
{
if(item->isActiveProject())
{
QFont font;
font.setBold(true);
return QVariant(font);
}
else
return QVariant();
}
else if(role == Qt::DecorationRole) // return icons for items
{
QIcon icon;
MetaShader* sh;
switch(item->getType())
{
case ProjectTreeItem::DIRECTORY:
icon.addFile(":/folder_blue.png");
break;
case ProjectTreeItem::SHADER:
sh = static_cast<MetaShader*>(item->getData());
if(sh->getType() == MetaShader::FRAGMENT)
{
icon.addFile(":/document_frag.png");
}
else if(sh->getType() == MetaShader::VERTEX)
{
icon.addFile(":/document_vert.png");
}
else
return QVariant();
break;
default:
return QVariant();
}
return QVariant(icon);
}
return QVariant();
}
