Brings the agent-work branch tip onto master, keeping master's architecture and putting every agent-work feature on top of it: the window/GpuDevice/ RenderTarget split, explicit per-instance profilers instead of a global, the input layer with scroll sources and ends, the Widgets core and components (shared SelectionModel/Commands lists, popup stack, titled panels, prompt dialogs, file browser, kanban, outline tree, markdown, docking), the gallery on the new UI, the Objects explorer and interpreter fixes, the Taskboard, the Sketch2D render path and its tests and bench, and the headless Wayland runner the UI tests drive. No MODULES_BUILD_* switches are introduced: platform differences are plain if (ANDROID) / if (NOT ANDROID).
176 lines
6.3 KiB
C++
176 lines
6.3 KiB
C++
#include "TaskContextMenu.hpp"
|
|
|
|
#include "Ui.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <unordered_set>
|
|
|
|
using namespace tp;
|
|
using namespace tp::taskboard;
|
|
using namespace tp::ui;
|
|
|
|
namespace {
|
|
Task copiedTask(const Task& source) {
|
|
Task copy = source;
|
|
copy.session = {};
|
|
copy.workspace.clear();
|
|
return copy;
|
|
}
|
|
|
|
std::vector<NodeId> outermostTasks(const TaskBoard& board, const std::vector<NodeId>& ids) {
|
|
const std::unordered_set<NodeId> chosen(ids.begin(), ids.end());
|
|
std::vector<NodeId> outermost;
|
|
for (NodeId id : ids) {
|
|
const std::vector<NodeId> ancestors = board.ancestorsOf(id);
|
|
const bool insideChosen =
|
|
std::any_of(ancestors.begin(), ancestors.end(), [&](NodeId ancestor) { return chosen.contains(ancestor); });
|
|
if (!insideChosen && board.task(id)) outermost.push_back(id);
|
|
}
|
|
return outermost;
|
|
}
|
|
|
|
std::string countedTasks(size_t count) { return std::to_string(count) + (count == 1 ? " task" : " tasks"); }
|
|
}
|
|
|
|
void TaskClipboard::copy(const TaskBoard& board, const std::vector<NodeId>& ids) {
|
|
mEntries.clear();
|
|
for (NodeId id : outermostTasks(board, ids))
|
|
copySubtree(board, id, std::nullopt);
|
|
}
|
|
|
|
void TaskClipboard::copySubtree(const TaskBoard& board, NodeId id, std::optional<size_t> parent) {
|
|
const size_t index = mEntries.size();
|
|
mEntries.push_back({ copiedTask(*board.task(id)), parent });
|
|
for (NodeId child : board.childrenOf(id))
|
|
copySubtree(board, child, index);
|
|
}
|
|
|
|
std::vector<NodeId> TaskClipboard::paste(TaskBoard& board, std::optional<NodeId> parent) const {
|
|
std::vector<NodeId> created;
|
|
std::vector<NodeId> roots;
|
|
for (const Entry& entry : mEntries) {
|
|
Task task = entry.task;
|
|
task.order = board.orderAfterLast();
|
|
const NodeId id = board.addTask(std::move(task), { 0, 0 });
|
|
created.push_back(id);
|
|
|
|
const std::optional<NodeId> newParent = entry.parent ? std::optional(created[*entry.parent]) : parent;
|
|
if (newParent) board.setParent(id, *newParent);
|
|
if (!entry.parent) roots.push_back(id);
|
|
}
|
|
return roots;
|
|
}
|
|
|
|
TaskContextMenu::TaskContextMenu(const TaskBoard& board, const TaskClipboard& clipboard, Actions actions) :
|
|
mBoard(board),
|
|
mClipboard(clipboard),
|
|
mActions(std::move(actions)) {
|
|
mMenu.setDebugName("task context menu");
|
|
}
|
|
|
|
void TaskContextMenu::open(Widget& owner, const TaskMenuTarget& target, Vec2F windowPoint) {
|
|
build(target);
|
|
if (owner.ui()) mMenu.openAsContextMenu(*owner.ui(), makeRect(windowPoint, { 0, 0 }));
|
|
}
|
|
|
|
void TaskContextMenu::build(const TaskMenuTarget& target) {
|
|
mMenu.closeMenu();
|
|
mMenu.clear();
|
|
mStatusMenu.clear();
|
|
mSessionMenu.clear();
|
|
mTarget = target;
|
|
std::erase_if(mTarget.tasks, [this](NodeId id) { return mBoard.task(id) == nullptr; });
|
|
|
|
if (mTarget.isEmptySpace()) addEmptySpaceItems();
|
|
else addTaskItems();
|
|
}
|
|
|
|
void TaskContextMenu::addTaskItems() {
|
|
const std::vector<NodeId> tasks = mTarget.tasks;
|
|
const bool single = tasks.size() == 1;
|
|
const NodeId first = tasks.front();
|
|
|
|
if (single) {
|
|
mMenu.addItem("Open", [this, first] { mActions.open(first); });
|
|
MenuItem& addChild = mMenu.addItem("New child task", [this, first] { mActions.create(first, std::nullopt); });
|
|
addChild.setEnabled(!mReadOnly);
|
|
mMenu.addSeparator();
|
|
}
|
|
|
|
fillStatusMenu();
|
|
mMenu.addSubmenu(single ? "Status" : "Status of " + countedTasks(tasks.size()), mStatusMenu).setEnabled(!mReadOnly);
|
|
if (single) {
|
|
fillSessionMenu(first);
|
|
mMenu.addSubmenu("Session", mSessionMenu);
|
|
}
|
|
mMenu.addSeparator();
|
|
|
|
addClipboardItems(single ? std::optional(first) : std::nullopt);
|
|
mMenu.addSeparator();
|
|
const std::string deleteText = single ? "Delete task..." : "Delete " + countedTasks(tasks.size()) + "...";
|
|
mMenu.addItem(deleteText, [this, tasks] { mActions.remove(tasks); }).setEnabled(!mReadOnly);
|
|
}
|
|
|
|
void TaskContextMenu::addEmptySpaceItems() {
|
|
const std::optional<TaskStatus> column = mTarget.column;
|
|
const std::string newText = column ? "New task in " + std::string(statusLabel(*column)) : "New task";
|
|
mMenu.addItem(newText, [this, column] { mActions.create(std::nullopt, column); }).setEnabled(!mReadOnly);
|
|
mMenu.addSeparator();
|
|
addClipboardItems(std::nullopt);
|
|
}
|
|
|
|
void TaskContextMenu::addClipboardItems(std::optional<NodeId> pasteParent) {
|
|
if (!mTarget.isEmptySpace()) {
|
|
const std::vector<NodeId> tasks = mTarget.tasks;
|
|
const std::string copyText = tasks.size() == 1 ? "Copy" : "Copy " + countedTasks(tasks.size());
|
|
mMenu.addItem(copyText, [this, tasks] { mActions.copy(tasks); }, "Ctrl+C");
|
|
}
|
|
|
|
const std::optional<TaskStatus> column = mTarget.column;
|
|
MenuItem& paste = mMenu.addItem(
|
|
pasteText(pasteParent), [this, pasteParent, column] { mActions.paste(pasteParent, column); }, "Ctrl+V"
|
|
);
|
|
paste.setEnabled(!mReadOnly && !mClipboard.isEmpty());
|
|
}
|
|
|
|
std::string TaskContextMenu::pasteText(std::optional<NodeId> parent) const {
|
|
std::string text = mClipboard.isEmpty() ? std::string("Paste") : "Paste " + countedTasks(mClipboard.taskCount());
|
|
if (parent) return text + " as children";
|
|
if (mTarget.column) return text + " into " + std::string(statusLabel(*mTarget.column));
|
|
return text;
|
|
}
|
|
|
|
void TaskContextMenu::fillStatusMenu() {
|
|
const std::vector<NodeId> tasks = mTarget.tasks;
|
|
for (const TaskStatus status : kTaskStatuses) {
|
|
const auto allHaveStatus = [this, tasks, status] {
|
|
return std::all_of(tasks.begin(), tasks.end(), [&](NodeId id) {
|
|
const Task* task = mBoard.task(id);
|
|
return task && task->status == status;
|
|
});
|
|
};
|
|
mStatusMenu.addToggle(std::string(statusLabel(status)), allHaveStatus, [this, tasks, status] {
|
|
mActions.setStatus(tasks, status);
|
|
});
|
|
}
|
|
}
|
|
|
|
void TaskContextMenu::fillSessionMenu(NodeId id) {
|
|
const Task& task = *mBoard.task(id);
|
|
const bool running = task.session.isRunning();
|
|
const bool controllable = mStore != nullptr && !mReadOnly;
|
|
|
|
mSessionMenu.addItem(
|
|
std::string(task.session.startActionLabel()), [this, id] { mStore->startSession(id); }
|
|
).setEnabled(controllable && !running);
|
|
mSessionMenu.addItem("Stop session", [this, id] { mStore->stopSession(id); }).setEnabled(controllable && running);
|
|
mSessionMenu.addSeparator();
|
|
mSessionMenu.addItem(
|
|
"Restart, keep conversation", [this, id] { mStore->restartSession(id, false); }
|
|
).setEnabled(controllable && running);
|
|
mSessionMenu.addItem(
|
|
"Restart fresh", [this, id] { mStore->restartSession(id, true); }
|
|
).setEnabled(controllable && running);
|
|
mSessionMenu.addSeparator();
|
|
mSessionMenu.addItem("Open session", [this, id] { mActions.openSession(id); }).setEnabled(task.canOpenSession());
|
|
}
|