#include "TaskContextMenu.hpp" #include "Ui.hpp" #include #include 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 outermostTasks(const TaskBoard& board, const std::vector& ids) { const std::unordered_set chosen(ids.begin(), ids.end()); std::vector outermost; for (NodeId id : ids) { const std::vector 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& ids) { mEntries.clear(); for (NodeId id : outermostTasks(board, ids)) copySubtree(board, id, std::nullopt); } void TaskClipboard::copySubtree(const TaskBoard& board, NodeId id, std::optional 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 TaskClipboard::paste(TaskBoard& board, std::optional parent) const { std::vector created; std::vector 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 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 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 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 pasteParent) { if (!mTarget.isEmptySpace()) { const std::vector 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 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 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 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()); }