tangchao0503/HPPA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add，计划采集14：

Browse Source 
修改节点名
This commit is contained in:
tangchao0503
2026-06-16 15:52:32 +08:00
parent fc3853c3ca
commit 59abab3f5d
3 changed files with 43 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
HPPA/TaskTreeModel.cpp
View File

@ -3,44 +3,44 @@
#include <QFont> #include <QFont>
#include <QIcon> #include <QIcon>
// ==================== TreeNode 实现 ==================== // ==================== TaskTreeNode 实现 ====================
TreeNode::TreeNode(TreeNode* parent) TaskTreeNode::TaskTreeNode(TaskTreeNode* parent)
: m_parent(parent) : m_parent(parent)
{ {
} }
TreeNode::~TreeNode() TaskTreeNode::~TaskTreeNode()
{ {
qDeleteAll(m_children); qDeleteAll(m_children);
} }
void TreeNode::appendChild(TreeNode* child) void TaskTreeNode::appendChild(TaskTreeNode* child)
{ {
m_children.append(child); m_children.append(child);
} }
TreeNode* TreeNode::child(int row) TaskTreeNode* TaskTreeNode::child(int row)
{ {
if (row < 0 || row >= m_children.size()) if (row < 0 || row >= m_children.size())
return nullptr; return nullptr;
return m_children.at(row); return m_children.at(row);
} }
int TreeNode::childCount() const int TaskTreeNode::childCount() const
{ {
return m_children.size(); return m_children.size();
} }
int TreeNode::row() const int TaskTreeNode::row() const
{ {
if (m_parent) { if (m_parent) {
return m_parent->m_children.indexOf(const_cast<TreeNode*>(this)); return m_parent->m_children.indexOf(const_cast<TaskTreeNode*>(this));
} }
return 0; return 0;
} }
TreeNode* TreeNode::parentNode() TaskTreeNode* TaskTreeNode::parentNode()
{ {
return m_parent; return m_parent;
} }
@ -49,7 +49,7 @@ TreeNode* TreeNode::parentNode()
TaskTreeModel::TaskTreeModel(QObject* parent) TaskTreeModel::TaskTreeModel(QObject* parent)
: QAbstractItemModel(parent) : QAbstractItemModel(parent)
, m_rootNode(new TreeNode()) , m_rootNode(new TaskTreeNode())
, m_countdownTimer(new QTimer(this)) , m_countdownTimer(new QTimer(this))
{ {
m_rootNode->nodeType = TreeNodeType::Root; m_rootNode->nodeType = TreeNodeType::Root;
@ -68,13 +68,13 @@ QModelIndex TaskTreeModel::index(int row, int column, const QModelIndex& parent)
if (!hasIndex(row, column, parent)) if (!hasIndex(row, column, parent))
return QModelIndex(); return QModelIndex();
TreeNode* parentNode; TaskTreeNode* parentNode;
if (!parent.isValid()) if (!parent.isValid())
parentNode = m_rootNode; parentNode = m_rootNode;
else else
parentNode = static_cast<TreeNode*>(parent.internalPointer()); parentNode = static_cast<TaskTreeNode*>(parent.internalPointer());
TreeNode* childNode = parentNode->child(row); TaskTreeNode* childNode = parentNode->child(row);
if (childNode) if (childNode)
return createIndex(row, column, childNode); return createIndex(row, column, childNode);
@ -86,8 +86,8 @@ QModelIndex TaskTreeModel::parent(const QModelIndex& index) const
if (!index.isValid()) if (!index.isValid())
return QModelIndex(); return QModelIndex();
TreeNode* childNode = static_cast<TreeNode*>(index.internalPointer()); TaskTreeNode* childNode = static_cast<TaskTreeNode*>(index.internalPointer());
TreeNode* parentNode = childNode->parentNode(); TaskTreeNode* parentNode = childNode->parentNode();
if (parentNode == m_rootNode) if (parentNode == m_rootNode)
return QModelIndex(); return QModelIndex();
@ -97,11 +97,11 @@ QModelIndex TaskTreeModel::parent(const QModelIndex& index) const
int TaskTreeModel::rowCount(const QModelIndex& parent) const int TaskTreeModel::rowCount(const QModelIndex& parent) const
{ {
TreeNode* parentNode; TaskTreeNode* parentNode;
if (!parent.isValid()) if (!parent.isValid())
parentNode = m_rootNode; parentNode = m_rootNode;
else else
parentNode = static_cast<TreeNode*>(parent.internalPointer()); parentNode = static_cast<TaskTreeNode*>(parent.internalPointer());
return parentNode->childCount(); return parentNode->childCount();
} }
@ -117,7 +117,7 @@ QVariant TaskTreeModel::data(const QModelIndex& index, int role) const
if (!index.isValid()) if (!index.isValid())
return QVariant(); return QVariant();
TreeNode* node = static_cast<TreeNode*>(index.internalPointer()); TaskTreeNode* node = static_cast<TaskTreeNode*>(index.internalPointer());
if (role == Qt::DisplayRole) { if (role == Qt::DisplayRole) {
if (node->nodeType == TreeNodeType::Task && node->taskData) { if (node->nodeType == TreeNodeType::Task && node->taskData) {
@ -328,7 +328,7 @@ void TaskTreeModel::setupModelData()
TimedTask& task = m_tasks[i]; TimedTask& task = m_tasks[i];
// 创建任务节点 // 创建任务节点
TreeNode* taskNode = new TreeNode(m_rootNode); TaskTreeNode* taskNode = new TaskTreeNode(m_rootNode);
taskNode->nodeType = TreeNodeType::Task; taskNode->nodeType = TreeNodeType::Task;
taskNode->taskId = task.id; taskNode->taskId = task.id;
taskNode->taskData = &task; taskNode->taskData = &task;
@ -338,7 +338,7 @@ void TaskTreeModel::setupModelData()
for (int j = 0; j < task.subTasks.size(); ++j) { for (int j = 0; j < task.subTasks.size(); ++j) {
SubTask& subTask = task.subTasks[j]; SubTask& subTask = task.subTasks[j];
TreeNode* subTaskNode = new TreeNode(taskNode); TaskTreeNode* subTaskNode = new TaskTreeNode(taskNode);
subTaskNode->nodeType = TreeNodeType::SubTask; subTaskNode->nodeType = TreeNodeType::SubTask;
subTaskNode->taskId = task.id; subTaskNode->taskId = task.id;
subTaskNode->subTaskIndex = j; subTaskNode->subTaskIndex = j;
@ -365,13 +365,13 @@ void TaskTreeModel::updateTask(const TimedTask& task)
m_tasks[dataIndex] = task; m_tasks[dataIndex] = task;
// 重新设置指针（因为数据被复制了） // 重新设置指针（因为数据被复制了）
TreeNode* taskNode = findTaskNode(task.id); TaskTreeNode* taskNode = findTaskNode(task.id);
if (taskNode) { if (taskNode) {
taskNode->taskData = &m_tasks[dataIndex]; taskNode->taskData = &m_tasks[dataIndex];
// 更新子任务指针 // 更新子任务指针
for (int i = 0; i < taskNode->childCount() && i < m_tasks[dataIndex].subTasks.size(); ++i) { for (int i = 0; i < taskNode->childCount() && i < m_tasks[dataIndex].subTasks.size(); ++i) {
TreeNode* subNode = taskNode->child(i); TaskTreeNode* subNode = taskNode->child(i);
if (subNode) { if (subNode) {
subNode->subTaskData = &m_tasks[dataIndex].subTasks[i]; subNode->subTaskData = &m_tasks[dataIndex].subTasks[i];
} }
@ -406,7 +406,7 @@ void TaskTreeModel::updateSubTask(int taskId, int subTaskIndex, const SubTask& s
m_tasks[dataIndex].subTasks[subTaskIndex] = subTask; m_tasks[dataIndex].subTasks[subTaskIndex] = subTask;
// 重新设置指针 // 重新设置指针
TreeNode* subNode = findSubTaskNode(taskId, subTaskIndex); TaskTreeNode* subNode = findSubTaskNode(taskId, subTaskIndex);
if (subNode) { if (subNode) {
subNode->subTaskData = &m_tasks[dataIndex].subTasks[subTaskIndex]; subNode->subTaskData = &m_tasks[dataIndex].subTasks[subTaskIndex];
} }
@ -510,7 +510,7 @@ SubTask* TaskTreeModel::getSubTask(int taskId, int subTaskIndex)
QModelIndex TaskTreeModel::getTaskIndex(int taskId) const QModelIndex TaskTreeModel::getTaskIndex(int taskId) const
{ {
for (int i = 0; i < m_rootNode->childCount(); ++i) { for (int i = 0; i < m_rootNode->childCount(); ++i) {
TreeNode* node = m_rootNode->child(i); TaskTreeNode* node = m_rootNode->child(i);
if (node && node->taskId == taskId) { if (node && node->taskId == taskId) {
return createIndex(i, 0, node); return createIndex(i, 0, node);
} }
@ -520,9 +520,9 @@ QModelIndex TaskTreeModel::getTaskIndex(int taskId) const
QModelIndex TaskTreeModel::getSubTaskIndex(int taskId, int subTaskIndex) const QModelIndex TaskTreeModel::getSubTaskIndex(int taskId, int subTaskIndex) const
{ {
TreeNode* taskNode = findTaskNode(taskId); TaskTreeNode* taskNode = findTaskNode(taskId);
if (taskNode && subTaskIndex < taskNode->childCount()) { if (taskNode && subTaskIndex < taskNode->childCount()) {
TreeNode* subNode = taskNode->child(subTaskIndex); TaskTreeNode* subNode = taskNode->child(subTaskIndex);
if (subNode) { if (subNode) {
return createIndex(subTaskIndex, 0, subNode); return createIndex(subTaskIndex, 0, subNode);
} }
@ -530,10 +530,10 @@ QModelIndex TaskTreeModel::getSubTaskIndex(int taskId, int subTaskIndex) const
return QModelIndex(); return QModelIndex();
} }
TreeNode* TaskTreeModel::findTaskNode(int taskId) const TaskTreeNode* TaskTreeModel::findTaskNode(int taskId) const
{ {
for (int i = 0; i < m_rootNode->childCount(); ++i) { for (int i = 0; i < m_rootNode->childCount(); ++i) {
TreeNode* node = m_rootNode->child(i); TaskTreeNode* node = m_rootNode->child(i);
if (node && node->taskId == taskId) { if (node && node->taskId == taskId) {
return node; return node;
} }
@ -541,9 +541,9 @@ TreeNode* TaskTreeModel::findTaskNode(int taskId) const
return nullptr; return nullptr;
} }
TreeNode* TaskTreeModel::findSubTaskNode(int taskId, int subTaskIndex) const TaskTreeNode* TaskTreeModel::findSubTaskNode(int taskId, int subTaskIndex) const
{ {
TreeNode* taskNode = findTaskNode(taskId); TaskTreeNode* taskNode = findTaskNode(taskId);
if (taskNode && subTaskIndex < taskNode->childCount()) { if (taskNode && subTaskIndex < taskNode->childCount()) {
return taskNode->child(subTaskIndex); return taskNode->child(subTaskIndex);
} }

22
HPPA/TaskTreeModel.h
View File

@ -14,17 +14,17 @@ enum class TreeNodeType {
}; };
// 树节点数据 // 树节点数据
class TreeNode class TaskTreeNode
{ {
public: public:
explicit TreeNode(TreeNode* parent = nullptr); explicit TaskTreeNode(TaskTreeNode* parent = nullptr);
~TreeNode(); ~TaskTreeNode();
void appendChild(TreeNode* child); void appendChild(TaskTreeNode* child);
TreeNode* child(int row); TaskTreeNode* child(int row);
int childCount() const; int childCount() const;
int row() const; int row() const;
TreeNode* parentNode(); TaskTreeNode* parentNode();
TreeNodeType nodeType = TreeNodeType::Root; TreeNodeType nodeType = TreeNodeType::Root;
int taskId = -1; // 任务ID int taskId = -1; // 任务ID
@ -35,8 +35,8 @@ public:
SubTask* subTaskData = nullptr; SubTask* subTaskData = nullptr;
private: private:
QVector<TreeNode*> m_children; QVector<TaskTreeNode*> m_children;
TreeNode* m_parent; TaskTreeNode* m_parent;
}; };
// 树形模型 // 树形模型
@ -101,8 +101,8 @@ private slots:
private: private:
void setupModelData(); void setupModelData();
void clearTree(); void clearTree();
TreeNode* findTaskNode(int taskId) const; TaskTreeNode* findTaskNode(int taskId) const;
TreeNode* findSubTaskNode(int taskId, int subTaskIndex) const; TaskTreeNode* findSubTaskNode(int taskId, int subTaskIndex) const;
int findTaskDataIndex(int taskId) const; int findTaskDataIndex(int taskId) const;
QString statusToString(TaskStatus status) const; QString statusToString(TaskStatus status) const;
@ -111,7 +111,7 @@ private:
QColor statusColor(TaskStatus status) const; QColor statusColor(TaskStatus status) const;
QString formatCountdown(qint64 seconds) const; QString formatCountdown(qint64 seconds) const;
TreeNode* m_rootNode; TaskTreeNode* m_rootNode;
QVector<TimedTask> m_tasks; QVector<TimedTask> m_tasks;
QTimer* m_countdownTimer; QTimer* m_countdownTimer;
}; };

4
HPPA/TimedDataCollection.cpp
View File

@ -219,7 +219,7 @@ void TimedDataCollection::onTreeItemClicked(const QModelIndex& index)
{ {
if (!index.isValid()) return; if (!index.isValid()) return;
TreeNode* node = static_cast<TreeNode*>(index.internalPointer()); TaskTreeNode* node = static_cast<TaskTreeNode*>(index.internalPointer());
if (!node) return; if (!node) return;
QString info; QString info;
@ -242,7 +242,7 @@ void TimedDataCollection::onTreeItemDoubleClicked(const QModelIndex& index)
{ {
if (!index.isValid()) return; if (!index.isValid()) return;
TreeNode* node = static_cast<TreeNode*>(index.internalPointer()); TaskTreeNode* node = static_cast<TaskTreeNode*>(index.internalPointer());
if (!node) return; if (!node) return;
if (node->nodeType == TreeNodeType::Task && node->taskData) { if (node->nodeType == TreeNodeType::Task && node->taskData) {