void ProjectModel::finishSingleMetadataUpdate(ThreadWeaver::Job* _job) { UpdateStatsJob* job = static_cast<UpdateStatsJob*>(_job); if (job->m_status != 0) { delete job; return; } const KFileMetaInfo& info=job->m_info.first(); QModelIndex index = indexForUrl(info.url()); if (!index.isValid()) return; ProjectNode* node = nodeForIndex(index); node->setFileStats(job->m_info.first()); updateDirStats(nodeForIndex(index.parent())); QModelIndex topLeft = index.sibling(index.row(), Graph); QModelIndex bottomRight = index.sibling(index.row(), ProjectModelColumnCount - 1); emit dataChanged(topLeft, bottomRight); delete job; }
bool GSeqModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { if(action == Qt::IgnoreAction) { return true; } if(!data->hasFormat("LabExe/EventNodes.list")) { return false; } if(column >= columnCount(parent)) { return false; } GEventNode* parentNode = nodeForIndex(parent); QByteArray encodedData = data->data("LabExe/EventNodes.list"); QDataStream stream(&encodedData, QIODevice::ReadOnly); while(!stream.atEnd()) { QString text; stream >> text; qDebug() << text; // GEventNode* node = tempNodeMime; GEventNode* node = EventManagerInstance()->GetEvent(text); if(node) insertNode(parentNode, row, node); } return true; }
int CObjectInspectorTreeModel::rowCount(const QModelIndex &parent) const { if(parent.isValid() && parent.column()!=0) return 0; TreeNode * node = nodeForIndex(parent); return node?node->childCount():0; }
QModelIndex PuppyFileSystemModel::index(int row, int column, const QModelIndex &parent) const { if(hasIndex(row, column, parent)) { Node *parentNode = nodeForIndex(parent); Node *childNode = parentNode->children.at(row); return createIndex(row, column, childNode); } return QModelIndex(); }
QModelIndex GSeqModel::index(int row, int column, const QModelIndex & parent) const { if(!hasIndex(row, column, parent)) return QModelIndex(); GEventNode* parentNode = nodeForIndex(parent); GEventNode* childNode = parentNode->ChildNodes().at(row); return createIndex(row, column, childNode); }
QVariant FlatModel::data(const QModelIndex &index, int role) const { QVariant result; if (Node *node = nodeForIndex(index)) { FolderNode *folderNode = node->asFolderNode(); switch (role) { case Qt::DisplayRole: { QString name = node->displayName(); if (node->nodeType() == NodeType::Project && node->parentFolderNode() && node->parentFolderNode()->nodeType() == NodeType::Session) { const QString vcsTopic = static_cast<ProjectNode *>(node)->vcsTopic(); if (!vcsTopic.isEmpty()) name += QLatin1String(" [") + vcsTopic + QLatin1Char(']'); } result = name; break; } case Qt::EditRole: { result = node->filePath().fileName(); break; } case Qt::ToolTipRole: { result = node->tooltip(); break; } case Qt::DecorationRole: { if (folderNode) result = folderNode->icon(); else result = Core::FileIconProvider::icon(node->filePath().toString()); break; } case Qt::FontRole: { QFont font; if (node == m_startupProject) font.setBold(true); result = font; break; } case Project::FilePathRole: { result = node->filePath().toString(); break; } case Project::EnabledRole: { result = node->isEnabled(); break; } } } return result; }
void ProjectModel::pot_dataChanged(const QModelIndex& pot_topLeft, const QModelIndex& pot_bottomRight) { //tricky here - some of the pot items may be represented by po items //let's propagate that all subitems changed QModelIndex pot_parent = pot_topLeft.parent(); QModelIndex parent = indexForPotIndex(pot_parent); ProjectNode* node = nodeForIndex(parent); int count = node->rows.count(); QModelIndex topLeft = index(0, pot_topLeft.column(), parent); QModelIndex bottomRight = index(count-1, pot_bottomRight.column(), parent); emit dataChanged(topLeft, bottomRight); enqueueNodeForMetadataUpdate(nodeForIndex(topLeft.parent())); }
QModelIndex FlatModel::parent(const QModelIndex &idx) const { QModelIndex parentIndex; if (Node *node = nodeForIndex(idx)) { FolderNode *parentNode = visibleFolderNode(node->parentFolderNode()); if (parentNode) return indexForNode(parentNode); } return parentIndex; }
void ProjectModel::po_rowsInserted(const QModelIndex& po_parent, int first, int last) { QModelIndex parent = indexForPoIndex(po_parent); QModelIndex pot_parent = potIndexForOuter(parent); ProjectNode* node = nodeForIndex(parent); //insert po rows beginInsertRows(parent, first, last); for (int pos = first; pos <= last; pos ++) { ProjectNode * childNode = new ProjectNode(node, pos, pos, -1); node->rows.insert(pos, childNode); } node->poCount += last - first + 1; //update rowNumber for (int pos = last + 1; pos < node->rows.count(); pos++) node->rows[pos]->rowNumber = pos; endInsertRows(); //remove unneeded pot rows, update PO rows if (pot_parent.isValid() || !parent.isValid()) { QVector<int> pot2PoMapping; generatePOTMapping(pot2PoMapping, po_parent, pot_parent); for (int pos = node->poCount; pos < node->rows.count(); pos ++) { ProjectNode* potNode = node->rows.at(pos); int potIndex = potNode->potRowNumber; int poIndex = pot2PoMapping[potIndex]; if (poIndex != -1) { //found pot node, that now has a PO index. //remove the pot node and change the corresponding PO node beginRemoveRows(parent, pos, pos); node->rows.removeAt(pos); deleteSubtree(potNode); endRemoveRows(); node->rows[poIndex]->potRowNumber = potIndex; //This change does not need notification //dataChanged(index(poIndex, 0, parent), index(poIndex, ProjectModelColumnCount, parent)); pos--; } } } enqueueNodeForMetadataUpdate(node); }
void ProjectModel::po_dataChanged(const QModelIndex& po_topLeft, const QModelIndex& po_bottomRight) { //nothing special here //map from source and propagate QModelIndex topLeft = indexForPoIndex(po_topLeft); QModelIndex bottomRight = indexForPoIndex(po_bottomRight); emit dataChanged(topLeft, bottomRight); enqueueNodeForMetadataUpdate(nodeForIndex(topLeft.parent())); }
bool GSeqModel::insertRows( int row, int count, const QModelIndex & parent /*= QModelIndex()*/ ) { return false; beginInsertRows(parent, row, row+count); GEventNode *parentNode = nodeForIndex(parent); for(int i=0; i<count; i++) { new GEventNode(parentNode); } endInsertRows(); return true; }
QModelIndex ProjectModel::index(int row, int column, const QModelIndex& parent) const { ProjectNode* parentNode = nodeForIndex(parent); //kWarning()<<(sizeof(ProjectNode))<<nodeCounter; if (row>=parentNode->rows.size()) { kWarning()<<"SHIT HAPPENED WITH INDEXES"<<row<<parentNode->rows.size()<<itemForIndex(parent).url(); return QModelIndex(); } return createIndex(row, column, parentNode->rows.at(row)); }
bool FlatModel::canFetchMore(const QModelIndex & parent) const { if (!parent.isValid()) { return false; } else { if (FolderNode *folderNode = nodeForIndex(parent)->asFolderNode()) return !m_childNodes.contains(folderNode); else return false; } }
int FlatModel::rowCount(const QModelIndex &parent) const { int rows = 0; if (!parent.isValid()) { rows = 1; } else { FolderNode *folderNode = nodeForIndex(parent)->asFolderNode(); if (folderNode && m_childNodes.contains(folderNode)) rows = m_childNodes.value(folderNode).size(); } return rows; }
QModelIndex PuppyFileSystemModel::parent(const QModelIndex &child) const { Node *childNode = nodeForIndex(child); Node *parentNode = childNode->parent; if(parentNode == m_rootNode) { return QModelIndex(); } int row = rowForNode(parentNode); int column = 0; return createIndex(row, column, parentNode); }
QModelIndex GSeqModel::parent(const QModelIndex & child) const { GEventNode* childNode = nodeForIndex(child); GEventNode* parentNode = childNode->ParentNode(); if(parentNode == m_pSequence->RootTimeEvent()) { return QModelIndex(); } int row = rowForNode(parentNode); int col = 0; return createIndex(row, col, parentNode); }
QModelIndex ProjectModel::parent(const QModelIndex& childIndex) const { if (!childIndex.isValid()) return QModelIndex(); ProjectNode* childNode = nodeForIndex(childIndex); ProjectNode* parentNode = childNode->parent; if (!parentNode || (childNode == &m_rootNode) || (parentNode == &m_rootNode)) return QModelIndex(); return createIndex(parentNode->rowNumber, 0, parentNode); }
bool GSeqModel::setData( const QModelIndex & index, const QVariant & value, int role /*= Qt::EditRole*/ ) { if(!index.isValid() || role != Qt::EditRole) { return false; } GEventNode* childNode = nodeForIndex(index); // node->text = value.toString(); qDebug() << index.column(); qDebug() << value; QModelIndex topLeft = index; QModelIndex botRight = index; emit dataChanged(topLeft, botRight); return true; }
bool FlatModel::hasChildren(const QModelIndex &parent) const { if (!parent.isValid()) return true; FolderNode *folderNode = nodeForIndex(parent)->asFolderNode(); if (!folderNode) return false; QHash<FolderNode*, QList<Node*> >::const_iterator it = m_childNodes.constFind(folderNode); if (it == m_childNodes.constEnd()) { fetchMore(folderNode); it = m_childNodes.constFind(folderNode); } return !it.value().isEmpty(); }
bool FlatModel::setData(const QModelIndex &index, const QVariant &value, int role) { if (!index.isValid()) return false; if (role != Qt::EditRole) return false; Node *node = nodeForIndex(index); Utils::FileName orgFilePath = node->filePath(); Utils::FileName newFilePath = orgFilePath.parentDir().appendPath(value.toString()); ProjectExplorerPlugin::renameFile(node, newFilePath.toString()); emit renamed(orgFilePath, newFilePath); return true; }
QModelIndex CObjectInspectorTreeModel::index(int row, int column, const QModelIndex &parent) const { if(!frootNode || row<0 || column<0 || column>=maxColumn || (parent.isValid() && parent.column()!=0)) return QModelIndex(); TreeNode * parentNode = nodeForIndex(parent); Q_ASSERT(parentNode); if(TreeNode * item = dynamic_cast<TreeNode*>(parentNode->childAt(row))) { QModelIndex createdIndex = createIndex(row,column,item); item->setModelIndex(createdIndex); connect(item,SIGNAL(updateModel(QModelIndex,QModelIndex)),this,SIGNAL(dataChanged(QModelIndex,QModelIndex))); return createdIndex; } return QModelIndex(); }
QMimeData* GSeqModel::mimeData( const QModelIndexList & indexes ) const { QByteArray encodedData; QDataStream stream(&encodedData, QIODevice::WriteOnly); foreach(const QModelIndex & index, indexes) { if(index.isValid()) { GEventNode* node = nodeForIndex(index); if(index.column() == 0 && node) { QString text = node->UniqueSystemID(); stream << text; } tempNodeMime = node; } } QMimeData* mimeData = new QMimeData(); mimeData->setData("LabExe/EventNodes.list", encodedData); return mimeData; }
Qt::ItemFlags FlatModel::flags(const QModelIndex &index) const { if (!index.isValid()) return 0; // We claim that everything is editable // That's slightly wrong // We control the only view, and that one does the checks Qt::ItemFlags f = Qt::ItemIsSelectable|Qt::ItemIsEnabled|Qt::ItemIsDragEnabled; if (Node *node = nodeForIndex(index)) { if (node == m_rootNode) return 0; // no flags for session node... if (!node->asProjectNode()) { // either folder or file node if (node->supportedActions(node).contains(Rename)) f = f | Qt::ItemIsEditable; } } return f; }
QModelIndex CObjectInspectorTreeModel::parent(const QModelIndex &child) const { if(!child.isValid()) return QModelIndex(); if(TreeNode * childNode = nodeForIndex(child)) { if(TreeNode * parentNode = dynamic_cast<TreeNode*>(childNode->parent())) { if(parentNode == frootNode) return QModelIndex(); if(TreeNode * grandParentNode = dynamic_cast<TreeNode*>(parentNode->parent())) { int row = grandParentNode->childRow(parentNode); return createIndex(row,0,parentNode); } } } return QModelIndex(); }
bool GSeqModel::removeRows( int row, int count, const QModelIndex & parent /*= QModelIndex()*/ ) { return false; GEventNode* parentNode = nodeForIndex(parent); const QList<GEventNode*> listEv = parentNode->ChildNodes(); Q_ASSERT_X(row >= 0, "GSeqModel::removeRows", "row < 0"); Q_ASSERT_X(row + count <= listEv.count(), "GSeqModel::removeRows", "row + count > list.count()"); beginRemoveRows(parent, row, row+count); for(int i = 0; i < count; i++) { GEventNode* node = listEv.at(row); removeNode(node); } endRemoveRows(); return true; }
QModelIndex ProjectModel::indexForPotIndex(const QModelIndex& potIndex) const { if (!potIndex.isValid()) return QModelIndex(); QModelIndex outerParent = indexForPotIndex(potIndex.parent()); ProjectNode* node = nodeForIndex(outerParent); int potRow = potIndex.row(); int row = 0; while(row<node->rows.count() && node->rows.at(row)->potRowNumber!=potRow) row++; if (row != node->rows.count()) return index(row, potIndex.column(), outerParent); kWarning()<<"error mapping index from POT to outer, searched for potRow:"<<potRow; return QModelIndex(); }
QVariant GSeqModel::data(const QModelIndex &index, int role) const { if (!index.isValid()) return QVariant(); if (role != Qt::DisplayRole) return QVariant(); GEventNode* node = nodeForIndex(index); switch(index.column()) { case 0: return node->UniqueSystemID(); case 1: return node->data();//5555555 case 2: return rowForNode(node); default: return QVariant(); } }
/** * Theese methods map from project model indices to PO and POT model indices. * In each folder files form PO model comes first, and files from POT that do not exist in PO model come after. */ QModelIndex ProjectModel::indexForOuter(const QModelIndex& outerIndex, IndexType type) const { if (!outerIndex.isValid()) return QModelIndex(); QModelIndex parent = outerIndex.parent(); QModelIndex internalParent; if (parent.isValid()) { internalParent = indexForOuter(parent, type); if (!internalParent.isValid()) return QModelIndex(); } ProjectNode* node = nodeForIndex(outerIndex); short rowNumber=(type==PoIndex?node->poRowNumber:node->potRowNumber); if (rowNumber == -1) return QModelIndex(); return (type==PoIndex?m_poModel:m_potModel).index(rowNumber, outerIndex.column(), internalParent); }
bool NavigatorTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &dropIndex) { if (action == Qt::IgnoreAction) return true; if (action != Qt::LinkAction) return false; if (!data->hasFormat("application/vnd.modelnode.list")) return false; if (column > 1) return false; if (dropIndex.model() != this) return false; QModelIndex parentIndex, parentItemIndex; PropertyName parentPropertyName; int targetIndex; parentIndex = dropIndex.sibling(dropIndex.row(), 0); targetIndex = (row > -1)? row : rowCount(parentIndex); if (this->data(parentIndex, NavigatorRole).isValid()) { parentItemIndex = parentIndex; ModelNode parentNode = nodeForIndex(parentItemIndex); if (!parentNode.metaInfo().hasDefaultProperty()) return false; targetIndex -= visibleProperties(parentNode).count(); parentPropertyName = parentNode.metaInfo().defaultPropertyName(); } else { parentItemIndex = parentIndex.parent(); parentPropertyName = parentIndex.data(Qt::DisplayRole).toByteArray(); } // Disallow dropping items between properties, which are listed first. if (targetIndex < 0) return false; Q_ASSERT(parentItemIndex.isValid()); QByteArray encodedData = data->data("application/vnd.modelnode.list"); QDataStream stream(&encodedData, QIODevice::ReadOnly); QList<ModelNode> nodeList; while (!stream.atEnd()) { uint nodeHash; stream >> nodeHash; if (containsNodeHash(nodeHash)) { ModelNode node(nodeForHash(nodeHash)); nodeList.append(node); } } ModelNode parentNode(nodeForIndex(parentItemIndex)); NodeAbstractProperty parentProperty = parentNode.nodeAbstractProperty(parentPropertyName); if (parentProperty.isNodeProperty() && nodeList.count() > 1) { return false; } moveNodesInteractive(parentProperty, nodeList, targetIndex); propagateInvisible(parentNode, isNodeInvisible(parentNode)); return false; // don't let the view do drag&drop on its own }
QVariant CObjectInspectorTreeModel::data(const QModelIndex &index, int role) const { if(!frootNode || !index.isValid() || index.column()<0 || index.column()>=maxColumn) return QVariant(); TreeNode * node = nodeForIndex(index); if(node && node!=frootNode) { switch (role) { case Qt::DisplayRole: switch (index.column()) { case columnName: return node->objectName(); case columnValue: return node->stringValue(); default: break; } break; case Qt::EditRole: { if(index.column()==columnValue) { PropertyTreeNode * propertyNode = qobject_cast<PropertyTreeNode*>(node); if(propertyNode) { return propertyNode->value(); } } } break; case CObjectInspectorTreeModel::TreeNodeRole: switch (index.column()) { case columnValue: { PropertyTreeNode * propertyNode = qobject_cast<PropertyTreeNode*>(node); return propertyNode?QVariant::fromValue(propertyNode):QVariant(); } default: break; } break; case Qt::BackgroundColorRole: { PropertyTreeNode * propertyNode = qobject_cast<PropertyTreeNode*>(node); return colorByType(propertyNode->value().type()); } case Qt::ToolTipRole: { PropertyTreeNode * propertyNode = qobject_cast<PropertyTreeNode*>(node); if(propertyNode) return QString(propertyNode->value().typeName()); } break; default: break; } } return QVariant(); }