Qtfred sexp tree refactor

code/mission/missiongoals.cpp

@@ -180,8 +180,6 @@ SCP_vector<mission_event> Mission_events;
 SCP_vector<mission_goal> Mission_goals;		// structure for the goals of this mission
 static goal_text Goal_text;
 
-SCP_vector<event_annotation> Event_annotations;
-
 #define DIRECTIVE_SOUND_DELAY			500					// time directive success sound effect is delayed
 #define DIRECTIVE_SPECIAL_DELAY		7000					// mark special directives as true after 7 seconds
 

code/mission/missiongoals.h

@@ -132,22 +132,6 @@ extern int Event_index;  // used by sexp code to tell what event it came from
 extern bool Log_event;
 extern bool Snapshot_all_events;
 
-
-// only used in FRED
-struct event_annotation
-{
-	void *handle = nullptr;			// the handle of the tree node in the event editor.  This is an HTREEITEM in FRED and TBD in qtFRED.
-	int item_image = -1;			// the previous image of the tree node (replaced by a comment icon when there is a comment)
-	SCP_list<int> path;				// a way to find the node that the annotation represents:
-									// the first number is the event, the second number is the node on the first layer, etc.
-	SCP_string comment;
-	ubyte r = 255;
-	ubyte g = 255;
-	ubyte b = 255;
-};
-extern SCP_vector<event_annotation> Event_annotations;
-
-
 // prototypes
 void mission_goals_and_events_init( void );
 void	mission_show_goals_init();

code/mission/missionparse.cpp

@@ -46,6 +46,7 @@
 #include "mission/missionlog.h"
 #include "mission/missionmessage.h"
 #include "mission/missionparse.h"
+#include "missioneditor/sexp_annotation_model.h"
 #include "missionui/fictionviewer.h"
 #include "missionui/missioncmdbrief.h"
 #include "missionui/redalert.h"

code/missioneditor/missionsave.cpp

@@ -33,6 +33,7 @@
 #include "mission/missionmessage.h"
 #include "mission/missionparse.h"
 #include "missioneditor/common.h"
+#include "missioneditor/sexp_annotation_model.h"
 #include "missionui/fictionviewer.h"
 #include "missionui/missioncmdbrief.h"
 #include "nebula/neb.h"

code/missioneditor/sexp_annotation_model.cpp

@@ -0,0 +1,270 @@
+#include "missioneditor/sexp_annotation_model.h"
+#include "missioneditor/sexp_tree_model.h"
+
+SCP_vector<event_annotation> Event_annotations;
+
+// -----------------------------------------------------------------------
+// Lifecycle
+// -----------------------------------------------------------------------
+
+// Copy the global Event_annotations into our working set and resolve each
+// stored path to a live annotation key (tree_nodes[] index or root key).
+// Annotations whose paths can't be resolved (e.g. event was deleted) are
+// reset to default values so they'll be pruned on save.
+void SexpAnnotationModel::loadFromGlobal(const SCP_vector<sexp_tree_item>& tree_nodes, const SCP_vector<mission_event>& events, const SCP_vector<int>& sig)
+{
+	m_annotations = Event_annotations;
+
+	for (auto& ea : m_annotations) {
+		ea.node_index = -1;
+
+		if (ea.path.empty())
+			continue;
+
+		int key = resolveFromPath(ea.path, tree_nodes, events, sig);
+		if (key != -1) {
+			ea.node_index = key;
+		} else {
+			// Path could not be resolved (event was probably deleted).
+			// Reset to default so it will be pruned on save.
+			ea.comment.clear();
+			ea.r = ea.g = ea.b = 255;
+			ea.node_index = -1;
+		}
+	}
+}
+
+// Rebuild persistable paths from annotation keys, attempt fallback resolution
+// for any lost nodes, prune default-valued annotations, and write the result
+// back to the global Event_annotations.
+void SexpAnnotationModel::saveToGlobal(const SCP_vector<sexp_tree_item>& tree_nodes, const SCP_vector<mission_event>& events, const SCP_vector<int>& sig)
+{
+	for (auto& ea : m_annotations) {
+		int key = ea.node_index;
+		SCP_list<int> old_path = ea.path;
+		ea.path.clear();
+
+		if (key >= 0 && key < static_cast<int>(tree_nodes.size()) &&
+		    tree_nodes[key].type != SEXPT_UNUSED) {
+			ea.path = buildPath(key, tree_nodes, events);
+		} else if (isRootKey(key)) {
+			ea.path = buildPath(key, tree_nodes, events);
+		} else {
+			// Node lost — try to resolve from the old path as a fallback.
+			// (The old path may use original event indices, so we need sig.)
+			int resolved = resolveFromPath(old_path, tree_nodes, events, sig);
+			if (resolved >= 0 || isRootKey(resolved)) {
+				ea.path = buildPath(resolved, tree_nodes, events);
+			} else {
+				// Truly gone; mark default for pruning.
+				ea.comment.clear();
+				ea.r = ea.g = ea.b = 255;
+			}
+		}
+
+		// Reset transient field.
+		ea.node_index = -1;
+	}
+
+	prune();
+	Event_annotations = m_annotations;
+}
+
+// -----------------------------------------------------------------------
+// Lookup
+// -----------------------------------------------------------------------
+
+// Return the vector index of the annotation with the given key, or -1 if not found.
+int SexpAnnotationModel::findByKey(int key) const
+{
+	for (size_t i = 0; i < m_annotations.size(); ++i) {
+		if (m_annotations[i].node_index == key)
+			return static_cast<int>(i);
+	}
+	return -1;
+}
+
+// Return a const pointer to the annotation with the given key, or nullptr.
+const event_annotation* SexpAnnotationModel::getByKey(int key) const
+{
+	int idx = findByKey(key);
+	return (idx >= 0) ? &m_annotations[idx] : nullptr;
+}
+
+// Return a mutable pointer to the annotation with the given key, or nullptr.
+event_annotation* SexpAnnotationModel::getByKey(int key)
+{
+	int idx = findByKey(key);
+	return (idx >= 0) ? &m_annotations[idx] : nullptr;
+}
+
+// Get or create an annotation for the given key. If one already exists it is
+// returned; otherwise a new default-valued annotation is appended.
+event_annotation& SexpAnnotationModel::ensureByKey(int key)
+{
+	auto* existing = getByKey(key);
+	if (existing)
+		return *existing;
+
+	m_annotations.emplace_back();
+	auto& ea = m_annotations.back();
+	ea.node_index = key;
+	return ea;
+}
+
+// -----------------------------------------------------------------------
+// Predicates
+// -----------------------------------------------------------------------
+
+// True if the annotation has default values (empty comment, white color).
+bool SexpAnnotationModel::isDefault(const event_annotation& ea)
+{
+	return ea.comment.empty() && ea.r == 255 && ea.g == 255 && ea.b == 255;
+}
+
+// -----------------------------------------------------------------------
+// Mutation
+// -----------------------------------------------------------------------
+
+// Remove all annotations that have default values (no useful data).
+void SexpAnnotationModel::prune()
+{
+	m_annotations.erase(
+		std::remove_if(m_annotations.begin(), m_annotations.end(),
+		               [](const event_annotation& ea) { return isDefault(ea); }),
+		m_annotations.end());
+}
+
+// Discard all annotations from the working set.
+void SexpAnnotationModel::clear()
+{
+	m_annotations.clear();
+}
+
+// -----------------------------------------------------------------------
+// Path building (key -> path)
+// -----------------------------------------------------------------------
+
+// Build a persistable path from an annotation key to identify the node across
+// save/load cycles. The path is a list of integers: [event_index, child_pos, ...].
+// For root keys the path is just [event_index]. For regular nodes the path walks
+// from the root down, recording the child position at each level.
+SCP_list<int> SexpAnnotationModel::buildPath(int key, const SCP_vector<sexp_tree_item>& tree_nodes, const SCP_vector<mission_event>& events)
+{
+	SCP_list<int> path;
+
+	// --- Root key: path is just [event_index] ---
+	if (isRootKey(key)) {
+		int formula = formulaFromRootKey(key);
+		for (int i = 0; i < static_cast<int>(events.size()); ++i) {
+			if (events[i].formula == formula) {
+				path.push_back(i);
+				return path;
+			}
+		}
+		return path; // empty = formula not found
+	}
+
+	// --- Regular node ---
+	if (key < 0 || key >= static_cast<int>(tree_nodes.size()))
+		return path;
+
+	// Walk up to find the root (a node with no parent).
+	// Guard against cycles with a depth limit based on the tree size.
+	int root = key;
+	int depth = 0;
+	const int max_depth = static_cast<int>(tree_nodes.size());
+	while (tree_nodes[root].parent >= 0 && depth < max_depth) {
+		root = tree_nodes[root].parent;
+		++depth;
+	}
+	if (depth >= max_depth)
+		return path; // cycle detected
+
+	// Find the event index whose formula matches this root.
+	int event_idx = -1;
+	for (int i = 0; i < static_cast<int>(events.size()); ++i) {
+		if (events[i].formula == root) {
+			event_idx = i;
+			break;
+		}
+	}
+	if (event_idx < 0)
+		return path; // root not found in events
+
+	path.push_back(event_idx);
+
+	// Collect child-position indices from the target node up to the root,
+	// then reverse them so the path reads top-down.
+	std::vector<int> positions;
+	int cur = key;
+	for (;;) {
+		int parent = tree_nodes[cur].parent;
+		if (parent < 0)
+			break;
+
+		int pos = 0;
+		int sibling = tree_nodes[parent].child;
+		while (sibling >= 0 && sibling != cur) {
+			++pos;
+			sibling = tree_nodes[sibling].next;
+		}
+		positions.push_back(pos);
+		cur = parent;
+	}
+
+	for (auto rit = positions.rbegin(); rit != positions.rend(); ++rit)
+		path.push_back(*rit);
+
+	return path;
+}
+
+// -----------------------------------------------------------------------
+// Path resolution (path -> key)
+// -----------------------------------------------------------------------
+
+// Resolve a stored path back to an annotation key by mapping the original event
+// index through the sig table, then walking child positions down the tree.
+// Returns a tree_nodes[] index (>= 0), a root key (<= -2), or -1 on failure.
+int SexpAnnotationModel::resolveFromPath(const SCP_list<int>& path, const SCP_vector<sexp_tree_item>& tree_nodes, const SCP_vector<mission_event>& events, const SCP_vector<int>& sig)
+{
+	if (path.empty())
+		return -1;
+
+	int orig_event_idx = path.front();
+
+	// Map the original event index (from the saved path) to a formula
+	// using the sig table (which maps current dialog index → original index).
+	int formula = -1;
+	for (int i = 0; i < static_cast<int>(sig.size()); ++i) {
+		if (sig[i] == orig_event_idx) {
+			if (i < static_cast<int>(events.size())) {
+				formula = events[i].formula;
+			}
+			break;
+		}
+	}
+	if (formula < 0)
+		return -1;
+
+	// Path of length 1 = root label annotation.
+	if (path.size() == 1)
+		return rootKey(formula);
+
+	// Walk down the tree from the formula node.
+	int node = formula;
+	auto it = path.begin();
+	++it; // skip event index
+	for (; it != path.end() && node >= 0; ++it) {
+		int target = *it;
+		if (node < 0 || node >= static_cast<int>(tree_nodes.size()))
+			return -1;
+		int child = tree_nodes[node].child;
+		for (int c = 0; c < target && child >= 0; ++c) {
+			child = tree_nodes[child].next;
+		}
+		node = child;
+	}
+
+	return node; // >= 0 if resolution succeeded, -1 if not
+}