GP-4186: Refactor trace events.

2026-05-31 02:51:12 +08:00 · 2024-02-06 09:43:56 -05:00
parent 00afebac48
commit 69d58d4e86
93 changed files with 1555 additions and 1111 deletions
@@ -26,12 +26,12 @@ import ghidra.async.AsyncTimer;
 import ghidra.debug.api.tracemgr.DebuggerCoordinates;
 import ghidra.program.model.address.Address;
 import ghidra.trace.model.Trace;
-import ghidra.trace.model.Trace.*;
 import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.memory.TraceMemoryRegion;
 import ghidra.trace.model.modules.TraceModule;
 import ghidra.trace.model.modules.TraceSection;
 import ghidra.trace.model.program.TraceProgramView;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.Swing;

 public class DebuggerLocationLabel extends JLabel {
@@ -44,19 +44,19 @@ public class DebuggerLocationLabel extends JLabel {
 			updateLabelDebouncer
 					.addListener(__ -> Swing.runIfSwingOrRunLater(() -> doUpdateLabel()));

-			listenFor(TraceMemoryRegionChangeType.ADDED, this::regionChanged);
-			listenFor(TraceMemoryRegionChangeType.CHANGED, this::regionChanged);
-			listenFor(TraceMemoryRegionChangeType.LIFESPAN_CHANGED, this::regionChanged);
-			listenFor(TraceMemoryRegionChangeType.DELETED, this::regionChanged);
+			listenFor(TraceEvents.REGION_ADDED, this::regionChanged);
+			listenFor(TraceEvents.REGION_CHANGED, this::regionChanged);
+			listenFor(TraceEvents.REGION_LIFESPAN_CHANGED, this::regionChanged);
+			listenFor(TraceEvents.REGION_DELETED, this::regionChanged);

-			listenFor(TraceModuleChangeType.ADDED, this::moduleChanged);
-			listenFor(TraceModuleChangeType.CHANGED, this::moduleChanged);
-			listenFor(TraceModuleChangeType.LIFESPAN_CHANGED, this::moduleChanged);
-			listenFor(TraceModuleChangeType.DELETED, this::moduleChanged);
+			listenFor(TraceEvents.MODULE_ADDED, this::moduleChanged);
+			listenFor(TraceEvents.MODULE_CHANGED, this::moduleChanged);
+			listenFor(TraceEvents.MODULE_LIFESPAN_CHANGED, this::moduleChanged);
+			listenFor(TraceEvents.MODULE_DELETED, this::moduleChanged);

-			listenFor(TraceSectionChangeType.ADDED, this::sectionChanged);
-			listenFor(TraceSectionChangeType.CHANGED, this::sectionChanged);
-			listenFor(TraceSectionChangeType.DELETED, this::sectionChanged);
+			listenFor(TraceEvents.SECTION_ADDED, this::sectionChanged);
+			listenFor(TraceEvents.SECTION_CHANGED, this::sectionChanged);
+			listenFor(TraceEvents.SECTION_DELETED, this::sectionChanged);
 		}

 		private void doUpdateLabel() {
@@ -31,7 +31,7 @@ import ghidra.framework.options.SaveState;
 import ghidra.framework.plugintool.AutoConfigState.ConfigFieldCodec;
 import ghidra.framework.plugintool.PluginTool;
 import ghidra.trace.model.Trace;
-import ghidra.trace.util.TraceChangeType;
+import ghidra.trace.util.TraceEvent;
 import ghidra.util.classfinder.ClassSearcher;
 import ghidra.util.classfinder.ExtensionPoint;
 import ghidra.util.exception.CancelledException;
@@ -91,7 +91,7 @@ public interface AutoMapSpec extends ExtensionPoint {
 		return DebuggerResources.ICON_CONFIG;
 	}

-	Collection<TraceChangeType<?, ?>> getChangeTypes();
+	Collection<TraceEvent<?, ?>> getChangeTypes();

 	default String getTaskTitle() {
 		return getMenuName();
@@ -24,9 +24,8 @@ import ghidra.debug.api.modules.ModuleMapProposal;
 import ghidra.debug.api.modules.ModuleMapProposal.ModuleMapEntry;
 import ghidra.program.model.listing.Program;
 import ghidra.trace.model.Trace;
-import ghidra.trace.model.Trace.TraceMemoryRegionChangeType;
-import ghidra.trace.model.Trace.TraceModuleChangeType;
-import ghidra.trace.util.TraceChangeType;
+import ghidra.trace.util.TraceEvent;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;

@@ -44,9 +43,10 @@ public class ByModuleAutoMapSpec implements AutoMapSpec {
 	}

 	@Override
-	public Collection<TraceChangeType<?, ?>> getChangeTypes() {
-		return List.of(TraceModuleChangeType.ADDED, TraceModuleChangeType.CHANGED,
-			TraceMemoryRegionChangeType.ADDED, TraceMemoryRegionChangeType.CHANGED);
+	public Collection<TraceEvent<?, ?>> getChangeTypes() {
+		return List.of(
+			TraceEvents.MODULE_ADDED, TraceEvents.MODULE_CHANGED,
+			TraceEvents.REGION_ADDED, TraceEvents.REGION_CHANGED);
 	}

 	@Override
@@ -24,8 +24,8 @@ import ghidra.debug.api.modules.RegionMapProposal;
 import ghidra.debug.api.modules.RegionMapProposal.RegionMapEntry;
 import ghidra.program.model.listing.Program;
 import ghidra.trace.model.Trace;
-import ghidra.trace.model.Trace.TraceMemoryRegionChangeType;
-import ghidra.trace.util.TraceChangeType;
+import ghidra.trace.util.TraceEvent;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;

@@ -43,8 +43,8 @@ public class ByRegionAutoMapSpec implements AutoMapSpec {
 	}

 	@Override
-	public Collection<TraceChangeType<?, ?>> getChangeTypes() {
-		return List.of(TraceMemoryRegionChangeType.ADDED);
+	public Collection<TraceEvent<?, ?>> getChangeTypes() {
+		return List.of(TraceEvents.REGION_ADDED);
 	}

 	@Override
@@ -24,8 +24,8 @@ import ghidra.debug.api.modules.SectionMapProposal;
 import ghidra.debug.api.modules.SectionMapProposal.SectionMapEntry;
 import ghidra.program.model.listing.Program;
 import ghidra.trace.model.Trace;
-import ghidra.trace.model.Trace.TraceSectionChangeType;
-import ghidra.trace.util.TraceChangeType;
+import ghidra.trace.util.TraceEvent;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;

@@ -43,8 +43,8 @@ public class BySectionAutoMapSpec implements AutoMapSpec {
 	}

 	@Override
-	public Collection<TraceChangeType<?, ?>> getChangeTypes() {
-		return List.of(TraceSectionChangeType.ADDED);
+	public Collection<TraceEvent<?, ?>> getChangeTypes() {
+		return List.of(TraceEvents.SECTION_ADDED);
 	}

 	@Override
@@ -32,18 +32,16 @@ import ghidra.app.util.viewer.listingpanel.AddressSetDisplayListener;
 import ghidra.debug.api.target.Target;
 import ghidra.debug.api.tracemgr.DebuggerCoordinates;
 import ghidra.framework.cmd.BackgroundCommand;
-import ghidra.framework.model.DomainObject;
-import ghidra.framework.model.DomainObjectChangeRecord;
+import ghidra.framework.model.*;
 import ghidra.framework.options.SaveState;
 import ghidra.framework.plugintool.*;
 import ghidra.framework.plugintool.annotation.AutoConfigStateField;
 import ghidra.program.model.address.*;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceMemoryStateChangeType;
-import ghidra.trace.model.Trace.TraceSnapshotChangeType;
 import ghidra.trace.model.memory.TraceMemoryState;
 import ghidra.trace.model.program.TraceProgramView;
 import ghidra.trace.model.time.TraceSnapshot;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.Msg;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;
@@ -101,9 +99,9 @@ public abstract class DebuggerReadsMemoryTrait {

 	protected class ForReadsTraceListener extends TraceDomainObjectListener {
 		public ForReadsTraceListener() {
-			listenForUntyped(DomainObject.DO_OBJECT_RESTORED, this::objectRestored);
-			listenFor(TraceSnapshotChangeType.ADDED, this::snapshotAdded);
-			listenFor(TraceMemoryStateChangeType.CHANGED, this::memStateChanged);
+			listenForUntyped(DomainObjectEvent.RESTORED, this::objectRestored);
+			listenFor(TraceEvents.SNAPSHOT_ADDED, this::snapshotAdded);
+			listenFor(TraceEvents.BYTES_STATE_CHANGED, this::memStateChanged);
 		}

 		private void objectRestored(DomainObjectChangeRecord rec) {
@@ -43,11 +43,10 @@ import ghidra.framework.plugintool.*;
 import ghidra.framework.plugintool.annotation.AutoConfigStateField;
 import ghidra.program.util.ProgramLocation;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
-import ghidra.trace.model.Trace.TraceStackChangeType;
 import ghidra.trace.model.stack.TraceStack;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.util.TraceAddressSpace;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.Msg;

 public class DebuggerTrackLocationTrait {
@@ -57,8 +56,8 @@ public class DebuggerTrackLocationTrait {
 	protected class ForTrackingListener extends TraceDomainObjectListener {

 		public ForTrackingListener() {
-			listenFor(TraceMemoryBytesChangeType.CHANGED, this::registersChanged);
-			listenFor(TraceStackChangeType.CHANGED, this::stackChanged);
+			listenFor(TraceEvents.BYTES_CHANGED, this::registersChanged);
+			listenFor(TraceEvents.STACK_CHANGED, this::stackChanged);
 		}

 		private void registersChanged(TraceAddressSpace space, TraceAddressSnapRange range,
@@ -22,7 +22,7 @@ import ghidra.app.services.DebuggerStaticMappingService;
 import ghidra.app.services.ProgramManager;
 import ghidra.framework.plugintool.PluginTool;
 import ghidra.trace.model.Trace;
-import ghidra.trace.util.TraceChangeType;
+import ghidra.trace.util.TraceEvent;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;

@@ -40,7 +40,7 @@ public class NoneAutoMapSpec implements AutoMapSpec {
 	}

 	@Override
-	public Collection<TraceChangeType<?, ?>> getChangeTypes() {
+	public Collection<TraceEvent<?, ?>> getChangeTypes() {
 		return List.of();
 	}

@@ -24,7 +24,7 @@ import ghidra.program.model.listing.Program;
 import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.modules.TraceConflictedMappingException;
-import ghidra.trace.util.TraceChangeType;
+import ghidra.trace.util.TraceEvent;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;

@@ -42,7 +42,7 @@ public class OneToOneAutoMapSpec implements AutoMapSpec {
 	}

 	@Override
-	public Collection<TraceChangeType<?, ?>> getChangeTypes() {
+	public Collection<TraceEvent<?, ?>> getChangeTypes() {
 		return List.of();
 	}

@@ -52,9 +52,9 @@ import ghidra.program.model.address.AddressRange;
 import ghidra.program.util.MarkerLocation;
 import ghidra.program.util.ProgramLocation;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceBreakpointChangeType;
 import ghidra.trace.model.breakpoint.TraceBreakpoint;
 import ghidra.trace.model.breakpoint.TraceBreakpointKind;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.*;
 import ghidra.util.database.ObjectKey;
 import ghidra.util.table.GhidraTable;
@@ -602,10 +602,10 @@ public class DebuggerBreakpointsProvider extends ComponentProviderAdapter
 		public ForBreakpointLocationsTraceListener(Trace trace) {
 			this.trace = trace;
 			listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());
-			listenFor(TraceBreakpointChangeType.ADDED, this::locationAdded);
-			listenFor(TraceBreakpointChangeType.CHANGED, this::locationChanged);
-			listenFor(TraceBreakpointChangeType.LIFESPAN_CHANGED, this::locationLifespanChanged);
-			listenFor(TraceBreakpointChangeType.DELETED, this::locationDeleted);
+			listenFor(TraceEvents.BREAKPOINT_ADDED, this::locationAdded);
+			listenFor(TraceEvents.BREAKPOINT_CHANGED, this::locationChanged);
+			listenFor(TraceEvents.BREAKPOINT_LIFESPAN_CHANGED, this::locationLifespanChanged);
+			listenFor(TraceEvents.BREAKPOINT_DELETED, this::locationDeleted);

 			trace.addListener(this);
 		}
@@ -49,10 +49,10 @@ import ghidra.framework.plugintool.util.PluginStatus;
 import ghidra.program.model.address.Address;
 import ghidra.program.model.listing.Program;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceObjectChangeType;
 import ghidra.trace.model.target.TraceObjectValue;
 import ghidra.trace.model.time.schedule.Scheduler;
 import ghidra.trace.model.time.schedule.TraceSchedule;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.Msg;
 import ghidra.util.Swing;
 import ghidra.util.exception.CancelledException;
@@ -78,9 +78,9 @@ public class DebuggerControlPlugin extends AbstractDebuggerPlugin

 	private final TraceDomainObjectListener listenerForObjects = new TraceDomainObjectListener() {
 		{
-			listenFor(TraceObjectChangeType.VALUE_CREATED, this::valueChanged);
-			listenFor(TraceObjectChangeType.VALUE_DELETED, this::valueChanged);
-			listenFor(TraceObjectChangeType.VALUE_LIFESPAN_CHANGED, this::valueLifespanChanged);
+			listenFor(TraceEvents.VALUE_CREATED, this::valueChanged);
+			listenFor(TraceEvents.VALUE_DELETED, this::valueChanged);
+			listenFor(TraceEvents.VALUE_LIFESPAN_CHANGED, this::valueLifespanChanged);
 		}

 		private void valueChanged(TraceObjectValue value) {
@@ -42,9 +42,9 @@ import ghidra.program.model.address.Address;
 import ghidra.program.model.address.AddressSet;
 import ghidra.program.util.ProgramSelection;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceMemoryRegionChangeType;
 import ghidra.trace.model.memory.TraceMemoryManager;
 import ghidra.trace.model.memory.TraceMemoryRegion;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.database.ObjectKey;
 import ghidra.util.table.GhidraTable;
 import ghidra.util.table.GhidraTableFilterPanel;
@@ -143,10 +143,10 @@ public class DebuggerLegacyRegionsPanel extends JPanel {
 		public RegionsListener() {
 			listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());

-			listenFor(TraceMemoryRegionChangeType.ADDED, this::regionAdded);
-			listenFor(TraceMemoryRegionChangeType.CHANGED, this::regionChanged);
-			listenFor(TraceMemoryRegionChangeType.LIFESPAN_CHANGED, this::regionChanged);
-			listenFor(TraceMemoryRegionChangeType.DELETED, this::regionDeleted);
+			listenFor(TraceEvents.REGION_ADDED, this::regionAdded);
+			listenFor(TraceEvents.REGION_CHANGED, this::regionChanged);
+			listenFor(TraceEvents.REGION_LIFESPAN_CHANGED, this::regionChanged);
+			listenFor(TraceEvents.REGION_DELETED, this::regionDeleted);
 		}

 		private void objectRestored() {
@@ -55,10 +55,10 @@ import ghidra.program.model.mem.MemoryBlock;
 import ghidra.program.util.ProgramLocation;
 import ghidra.program.util.ProgramSelection;
 import ghidra.trace.model.Trace;
-import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
 import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.program.TraceProgramView;
 import ghidra.trace.util.TraceAddressSpace;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.Swing;

 public class DebuggerMemoryBytesProvider extends ProgramByteViewerComponentProvider {
@@ -88,7 +88,7 @@ public class DebuggerMemoryBytesProvider extends ProgramByteViewerComponentProvi

 	protected class ListenerForChanges extends TraceDomainObjectListener {
 		public ListenerForChanges() {
-			listenFor(TraceMemoryBytesChangeType.CHANGED, this::bytesChanged);
+			listenFor(TraceEvents.BYTES_CHANGED, this::bytesChanged);
 		}

 		private void bytesChanged(TraceAddressSpace space) {
@@ -22,7 +22,6 @@ import ghidra.async.AsyncTimer;
 import ghidra.debug.api.tracemgr.DebuggerCoordinates;
 import ghidra.program.model.address.*;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.*;
 import ghidra.trace.model.breakpoint.TraceBreakpoint;
 import ghidra.trace.model.breakpoint.TraceBreakpointManager;
 import ghidra.trace.model.memory.TraceMemoryManager;
@@ -30,6 +29,7 @@ import ghidra.trace.model.memory.TraceMemoryRegion;
 import ghidra.trace.model.modules.*;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.model.thread.TraceThreadManager;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.Swing;

 public class DebuggerMemviewTraceListener extends TraceDomainObjectListener {
@@ -55,31 +55,31 @@ public class DebuggerMemviewTraceListener extends TraceDomainObjectListener {

 		updateLabelDebouncer.addListener(__ -> Swing.runIfSwingOrRunLater(() -> doUpdate()));

-		listenFor(TraceThreadChangeType.ADDED, this::threadChanged);
-		listenFor(TraceThreadChangeType.CHANGED, this::threadChanged);
-		listenFor(TraceThreadChangeType.LIFESPAN_CHANGED, this::threadChanged);
-		listenFor(TraceThreadChangeType.DELETED, this::threadChanged);
+		listenFor(TraceEvents.THREAD_ADDED, this::threadChanged);
+		listenFor(TraceEvents.THREAD_CHANGED, this::threadChanged);
+		listenFor(TraceEvents.THREAD_LIFESPAN_CHANGED, this::threadChanged);
+		listenFor(TraceEvents.THREAD_DELETED, this::threadChanged);

-		listenFor(TraceMemoryRegionChangeType.ADDED, this::regionChanged);
-		listenFor(TraceMemoryRegionChangeType.CHANGED, this::regionChanged);
-		listenFor(TraceMemoryRegionChangeType.LIFESPAN_CHANGED, this::regionChanged);
-		listenFor(TraceMemoryRegionChangeType.DELETED, this::regionChanged);
+		listenFor(TraceEvents.REGION_ADDED, this::regionChanged);
+		listenFor(TraceEvents.REGION_CHANGED, this::regionChanged);
+		listenFor(TraceEvents.REGION_LIFESPAN_CHANGED, this::regionChanged);
+		listenFor(TraceEvents.REGION_DELETED, this::regionChanged);

-		listenFor(TraceModuleChangeType.ADDED, this::moduleChanged);
-		listenFor(TraceModuleChangeType.CHANGED, this::moduleChanged);
-		listenFor(TraceModuleChangeType.LIFESPAN_CHANGED, this::moduleChanged);
-		listenFor(TraceModuleChangeType.DELETED, this::moduleChanged);
+		listenFor(TraceEvents.MODULE_ADDED, this::moduleChanged);
+		listenFor(TraceEvents.MODULE_CHANGED, this::moduleChanged);
+		listenFor(TraceEvents.MODULE_LIFESPAN_CHANGED, this::moduleChanged);
+		listenFor(TraceEvents.MODULE_DELETED, this::moduleChanged);

-		listenFor(TraceSectionChangeType.ADDED, this::sectionChanged);
-		listenFor(TraceSectionChangeType.CHANGED, this::sectionChanged);
-		listenFor(TraceSectionChangeType.DELETED, this::sectionChanged);
+		listenFor(TraceEvents.SECTION_ADDED, this::sectionChanged);
+		listenFor(TraceEvents.SECTION_CHANGED, this::sectionChanged);
+		listenFor(TraceEvents.SECTION_DELETED, this::sectionChanged);

-		listenFor(TraceBreakpointChangeType.ADDED, this::breakpointChanged);
-		listenFor(TraceBreakpointChangeType.CHANGED, this::breakpointChanged);
-		listenFor(TraceBreakpointChangeType.LIFESPAN_CHANGED, this::breakpointChanged);
-		listenFor(TraceBreakpointChangeType.DELETED, this::breakpointChanged);
+		listenFor(TraceEvents.BREAKPOINT_ADDED, this::breakpointChanged);
+		listenFor(TraceEvents.BREAKPOINT_CHANGED, this::breakpointChanged);
+		listenFor(TraceEvents.BREAKPOINT_LIFESPAN_CHANGED, this::breakpointChanged);
+		listenFor(TraceEvents.BREAKPOINT_DELETED, this::breakpointChanged);

-		listenFor(TraceMemoryBytesChangeType.CHANGED, this::bytesChanged);
+		listenFor(TraceEvents.BYTES_CHANGED, this::bytesChanged);
 	}

 	public MemviewProvider getProvider() {
@@ -22,14 +22,13 @@ import java.util.stream.Stream;

 import docking.widgets.table.RangeCursorTableHeaderRenderer.SeekListener;
 import docking.widgets.table.threaded.ThreadedTableModel;
-import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.model.DomainObjectChangeRecord;
+import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.plugintool.Plugin;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceObjectChangeType;
-import ghidra.trace.model.Trace.TraceSnapshotChangeType;
 import ghidra.trace.model.target.TraceObject;
 import ghidra.trace.model.target.TraceObjectValue;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.datastruct.Accumulator;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;
@@ -40,12 +39,12 @@ public abstract class AbstractQueryTableModel<T> extends ThreadedTableModel<T, T
 	protected class ListenerForChanges extends TraceDomainObjectListener {
 		public ListenerForChanges() {
 			listenForUntyped(DomainObjectEvent.RESTORED, this::objectRestored);
-			listenFor(TraceObjectChangeType.VALUE_CREATED, this::valueCreated);
-			listenFor(TraceObjectChangeType.VALUE_DELETED, this::valueDeleted);
-			listenFor(TraceObjectChangeType.VALUE_LIFESPAN_CHANGED, this::valueLifespanChanged);
+			listenFor(TraceEvents.VALUE_CREATED, this::valueCreated);
+			listenFor(TraceEvents.VALUE_DELETED, this::valueDeleted);
+			listenFor(TraceEvents.VALUE_LIFESPAN_CHANGED, this::valueLifespanChanged);

-			listenFor(TraceSnapshotChangeType.ADDED, this::maxSnapChanged);
-			listenFor(TraceSnapshotChangeType.DELETED, this::maxSnapChanged);
+			listenFor(TraceEvents.SNAPSHOT_ADDED, this::maxSnapChanged);
+			listenFor(TraceEvents.SNAPSHOT_DELETED, this::maxSnapChanged);
 		}

 		protected void objectRestored(DomainObjectChangeRecord record) {
@@ -27,8 +27,8 @@ import ghidra.dbg.target.*;
 import ghidra.dbg.util.PathUtils.TargetObjectKeyComparator;
 import ghidra.framework.model.*;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceObjectChangeType;
 import ghidra.trace.model.target.*;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.HTMLUtilities;
 import ghidra.util.LockHold;
 import ghidra.util.datastruct.WeakValueHashMap;
@@ -40,10 +40,10 @@ public class ObjectTreeModel implements DisplaysModified {
 			implements DomainObjectClosedListener {
 		public ListenerForChanges() {
 			listenForUntyped(DomainObjectEvent.RESTORED, this::domainObjectRestored);
-			listenFor(TraceObjectChangeType.CREATED, this::objectCreated);
-			listenFor(TraceObjectChangeType.VALUE_CREATED, this::valueCreated);
-			listenFor(TraceObjectChangeType.VALUE_DELETED, this::valueDeleted);
-			listenFor(TraceObjectChangeType.VALUE_LIFESPAN_CHANGED, this::valueLifespanChanged);
+			listenFor(TraceEvents.OBJECT_CREATED, this::objectCreated);
+			listenFor(TraceEvents.VALUE_CREATED, this::valueCreated);
+			listenFor(TraceEvents.VALUE_DELETED, this::valueDeleted);
+			listenFor(TraceEvents.VALUE_LIFESPAN_CHANGED, this::valueLifespanChanged);
 		}

 		@Override
@@ -36,8 +36,8 @@ import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.plugintool.PluginTool;
 import ghidra.program.model.address.*;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceModuleChangeType;
 import ghidra.trace.model.modules.*;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.database.ObjectKey;
 import ghidra.util.table.GhidraTable;
 import ghidra.util.table.GhidraTableFilterPanel;
@@ -159,10 +159,10 @@ public class DebuggerLegacyModulesPanel extends JPanel {
 		public ModulesListener() {
 			listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());

-			listenFor(TraceModuleChangeType.ADDED, this::moduleAdded);
-			listenFor(TraceModuleChangeType.CHANGED, this::moduleChanged);
-			listenFor(TraceModuleChangeType.LIFESPAN_CHANGED, this::moduleChanged);
-			listenFor(TraceModuleChangeType.DELETED, this::moduleDeleted);
+			listenFor(TraceEvents.MODULE_ADDED, this::moduleAdded);
+			listenFor(TraceEvents.MODULE_CHANGED, this::moduleChanged);
+			listenFor(TraceEvents.MODULE_LIFESPAN_CHANGED, this::moduleChanged);
+			listenFor(TraceEvents.MODULE_DELETED, this::moduleDeleted);
 		}

 		private void objectRestored() {
@@ -37,10 +37,9 @@ import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.plugintool.PluginTool;
 import ghidra.program.model.address.*;
 import ghidra.trace.model.Trace;
-import ghidra.trace.model.Trace.TraceModuleChangeType;
-import ghidra.trace.model.Trace.TraceSectionChangeType;
 import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.modules.*;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.database.ObjectKey;
 import ghidra.util.table.GhidraTable;
 import ghidra.util.table.GhidraTableFilterPanel;
@@ -146,13 +145,13 @@ public class DebuggerLegacySectionsPanel extends JPanel {
 			 * NOTE: No need for Module.ADDED here. A TraceModule is created empty, so when each
 			 * section is added, we'll get the call.
 			 */
-			listenFor(TraceModuleChangeType.CHANGED, this::moduleChanged);
-			listenFor(TraceModuleChangeType.LIFESPAN_CHANGED, this::moduleChanged);
-			listenFor(TraceModuleChangeType.DELETED, this::moduleDeleted);
+			listenFor(TraceEvents.MODULE_CHANGED, this::moduleChanged);
+			listenFor(TraceEvents.MODULE_LIFESPAN_CHANGED, this::moduleChanged);
+			listenFor(TraceEvents.MODULE_DELETED, this::moduleDeleted);

-			listenFor(TraceSectionChangeType.ADDED, this::sectionAdded);
-			listenFor(TraceSectionChangeType.CHANGED, this::sectionChanged);
-			listenFor(TraceSectionChangeType.DELETED, this::sectionDeleted);
+			listenFor(TraceEvents.SECTION_ADDED, this::sectionAdded);
+			listenFor(TraceEvents.SECTION_CHANGED, this::sectionChanged);
+			listenFor(TraceEvents.SECTION_DELETED, this::sectionDeleted);
 		}

 		private void objectRestored() {
@@ -64,9 +64,9 @@ import ghidra.program.model.mem.MemoryBlock;
 import ghidra.program.util.ProgramLocation;
 import ghidra.program.util.ProgramSelection;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
 import ghidra.trace.model.modules.*;
-import ghidra.trace.util.TraceChangeType;
+import ghidra.trace.util.TraceEvent;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.HelpLocation;
 import ghidra.util.Msg;

@@ -271,12 +271,12 @@ public class DebuggerModulesProvider extends ComponentProviderAdapter {

 	protected class ForMappingTraceListener extends TraceDomainObjectListener {
 		public ForMappingTraceListener(AutoMapSpec spec) {
-			for (TraceChangeType<?, ?> type : spec.getChangeTypes()) {
+			for (TraceEvent<?, ?> type : spec.getChangeTypes()) {
 				listenFor(type, this::changed);
 			}

-			// TODO: Delete this if/when TraceRecorderTarget is removed
-			listenFor(TraceMemoryBytesChangeType.CHANGED, this::memoryChanged);
+			// Delete this if/when TraceRecorderTarget is removed
+			listenFor(TraceEvents.BYTES_CHANGED, this::memoryChanged);
 		}

 		private void changed() {
@@ -48,9 +48,9 @@ import ghidra.program.model.listing.Program;
 import ghidra.program.util.ProgramLocation;
 import ghidra.program.util.ProgramSelection;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceStaticMappingChangeType;
 import ghidra.trace.model.modules.TraceStaticMapping;
 import ghidra.trace.model.modules.TraceStaticMappingManager;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.MathUtilities;
 import ghidra.util.Msg;
 import ghidra.util.database.ObjectKey;
@@ -107,8 +107,8 @@ public class DebuggerStaticMappingProvider extends ComponentProviderAdapter
 	protected class ListenerForStaticMappingDisplay extends TraceDomainObjectListener {
 		public ListenerForStaticMappingDisplay() {
 			listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());
-			listenFor(TraceStaticMappingChangeType.ADDED, this::staticMappingAdded);
-			listenFor(TraceStaticMappingChangeType.DELETED, this::staticMappingDeleted);
+			listenFor(TraceEvents.MAPPING_ADDED, this::staticMappingAdded);
+			listenFor(TraceEvents.MAPPING_DELETED, this::staticMappingDeleted);
 		}

 		private void objectRestored() {
@@ -52,8 +52,8 @@ import ghidra.dbg.error.DebuggerModelAccessException;
 import ghidra.debug.api.target.Target;
 import ghidra.debug.api.tracemgr.DebuggerCoordinates;
 import ghidra.docking.settings.*;
-import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.model.DomainObjectChangeRecord;
+import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.options.AutoOptions;
 import ghidra.framework.options.SaveState;
 import ghidra.framework.plugintool.*;
@@ -64,15 +64,13 @@ import ghidra.program.model.lang.*;
 import ghidra.program.model.listing.Data;
 import ghidra.program.model.util.CodeUnitInsertionException;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.*;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.listing.*;
 import ghidra.trace.model.memory.*;
 import ghidra.trace.model.program.TraceProgramView;
 import ghidra.trace.model.target.TraceObject;
 import ghidra.trace.model.thread.TraceThread;
-import ghidra.trace.util.TraceAddressSpace;
-import ghidra.trace.util.TraceRegisterUtils;
+import ghidra.trace.util.*;
 import ghidra.util.HelpLocation;
 import ghidra.util.Msg;
 import ghidra.util.classfinder.ClassSearcher;
@@ -274,14 +272,14 @@ public class DebuggerRegistersProvider extends ComponentProviderAdapter
 	class TraceChangeListener extends TraceDomainObjectListener {
 		public TraceChangeListener() {
 			listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored(e));
-			listenFor(TraceMemoryBytesChangeType.CHANGED, this::registerValueChanged);
-			listenFor(TraceMemoryStateChangeType.CHANGED, this::registerStateChanged);
-			listenFor(TraceCodeChangeType.ADDED, this::registerTypeAdded);
-			listenFor(TraceCodeChangeType.DATA_TYPE_REPLACED, this::registerTypeReplaced);
-			listenFor(TraceCodeChangeType.LIFESPAN_CHANGED, this::registerTypeLifespanChanged);
-			listenFor(TraceCodeChangeType.REMOVED, this::registerTypeRemoved);
-			listenFor(TraceThreadChangeType.DELETED, this::threadDeleted);
-			listenFor(TraceThreadChangeType.LIFESPAN_CHANGED, this::threadDestroyed);
+			listenFor(TraceEvents.BYTES_CHANGED, this::registerValueChanged);
+			listenFor(TraceEvents.BYTES_STATE_CHANGED, this::registerStateChanged);
+			listenFor(TraceEvents.CODE_ADDED, this::registerTypeAdded);
+			listenFor(TraceEvents.CODE_DATA_TYPE_REPLACED, this::registerTypeReplaced);
+			listenFor(TraceEvents.CODE_LIFESPAN_CHANGED, this::registerTypeLifespanChanged);
+			listenFor(TraceEvents.CODE_REMOVED, this::registerTypeRemoved);
+			listenFor(TraceEvents.THREAD_DELETED, this::threadDeleted);
+			listenFor(TraceEvents.THREAD_LIFESPAN_CHANGED, this::threadDestroyed);
 		}

 		private boolean isVisibleObjectsMode(AddressSpace space) {
@@ -170,7 +170,7 @@ public class RegisterRow {
 	/**
 	 * Check if the register's value can be set via its data type's representation
 	 * 
-	 * @return
+	 * @return true if the representation cell is editable
 	 */
 	public boolean isRepresentationEditable() {
 		return provider.canWriteRegisterRepresentation(register);
@@ -39,15 +39,12 @@ import ghidra.program.model.lang.Register;
 import ghidra.program.model.lang.RegisterValue;
 import ghidra.program.model.listing.Program;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
-import ghidra.trace.model.Trace.TraceStackChangeType;
 import ghidra.trace.model.memory.TraceMemorySpace;
 import ghidra.trace.model.program.TraceProgramView;
 import ghidra.trace.model.stack.TraceStack;
 import ghidra.trace.model.stack.TraceStackFrame;
 import ghidra.trace.model.thread.TraceThread;
-import ghidra.trace.util.TraceAddressSpace;
-import ghidra.trace.util.TraceRegisterUtils;
+import ghidra.trace.util.*;
 import ghidra.util.Swing;
 import ghidra.util.table.GhidraTable;
 import ghidra.util.table.GhidraTableFilterPanel;
@@ -124,11 +121,11 @@ public class DebuggerLegacyStackPanel extends JPanel {

 	class ForStackListener extends TraceDomainObjectListener {
 		public ForStackListener() {
-			listenFor(TraceStackChangeType.ADDED, this::stackAdded);
-			listenFor(TraceStackChangeType.CHANGED, this::stackChanged);
-			listenFor(TraceStackChangeType.DELETED, this::stackDeleted);
+			listenFor(TraceEvents.STACK_ADDED, this::stackAdded);
+			listenFor(TraceEvents.STACK_CHANGED, this::stackChanged);
+			listenFor(TraceEvents.STACK_DELETED, this::stackDeleted);

-			listenFor(TraceMemoryBytesChangeType.CHANGED, this::bytesChanged);
+			listenFor(TraceEvents.BYTES_CHANGED, this::bytesChanged);
 		}

 		private void stackAdded(TraceStack stack) {
@@ -40,7 +40,6 @@ import ghidra.program.model.mem.ByteMemBufferImpl;
 import ghidra.program.model.mem.Memory;
 import ghidra.program.model.pcode.*;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.listing.*;
 import ghidra.trace.model.memory.*;
@@ -48,6 +47,7 @@ import ghidra.trace.model.stack.TraceStack;
 import ghidra.trace.model.stack.TraceStackFrame;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.util.TraceAddressSpace;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.MathUtilities;
 import ghidra.util.Msg;
 import ghidra.util.exception.InvalidInputException;
@@ -650,7 +650,7 @@ public enum VariableValueUtils {
 		 */
 		private class ListenerForChanges extends TraceDomainObjectListener {
 			public ListenerForChanges() {
-				listenFor(TraceMemoryBytesChangeType.CHANGED, this::bytesChanged);
+				listenFor(TraceEvents.BYTES_CHANGED, this::bytesChanged);
 			}

 			private void bytesChanged(TraceAddressSpace space, TraceAddressSnapRange range) {
@@ -826,8 +826,8 @@ public enum VariableValueUtils {
 		 * data unit using {@link #getRegisterUnit(Register)}. Fall back to this method only if that
 		 * one fails.
 		 * 
-		 * @param register
-		 * @return
+		 * @param register the register
+		 * @return the "raw" value of the register
 		 */
 		public WatchValue getRawRegisterValue(Register register) {
 			WatchValuePcodeExecutorState state =
@@ -33,16 +33,15 @@ import ghidra.app.plugin.core.debug.gui.DebuggerSnapActionContext;
 import ghidra.app.services.DebuggerTraceManagerService;
 import ghidra.debug.api.tracemgr.DebuggerCoordinates;
 import ghidra.docking.settings.Settings;
-import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.model.DomainObjectChangeRecord;
+import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.plugintool.AutoService;
 import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceSnapshotChangeType;
-import ghidra.trace.model.Trace.TraceThreadChangeType;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.model.thread.TraceThreadManager;
 import ghidra.trace.model.time.TraceSnapshot;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.database.ObjectKey;
 import ghidra.util.table.GhidraTable;
 import ghidra.util.table.GhidraTableFilterPanel;
@@ -128,13 +127,13 @@ public class DebuggerLegacyThreadsPanel extends JPanel {
 		public ForThreadsListener() {
 			listenForUntyped(DomainObjectEvent.RESTORED, this::objectRestored);

-			listenFor(TraceThreadChangeType.ADDED, this::threadAdded);
-			listenFor(TraceThreadChangeType.CHANGED, this::threadChanged);
-			listenFor(TraceThreadChangeType.LIFESPAN_CHANGED, this::threadChanged);
-			listenFor(TraceThreadChangeType.DELETED, this::threadDeleted);
+			listenFor(TraceEvents.THREAD_ADDED, this::threadAdded);
+			listenFor(TraceEvents.THREAD_CHANGED, this::threadChanged);
+			listenFor(TraceEvents.THREAD_LIFESPAN_CHANGED, this::threadChanged);
+			listenFor(TraceEvents.THREAD_DELETED, this::threadDeleted);

-			listenFor(TraceSnapshotChangeType.ADDED, this::snapAdded);
-			listenFor(TraceSnapshotChangeType.DELETED, this::snapDeleted);
+			listenFor(TraceEvents.SNAPSHOT_ADDED, this::snapAdded);
+			listenFor(TraceEvents.SNAPSHOT_DELETED, this::snapDeleted);
 		}

 		private void objectRestored(DomainObjectChangeRecord rec) {
@@ -33,15 +33,15 @@ import ghidra.app.plugin.core.debug.gui.DebuggerResources.ToToggleSelectionListe
 import ghidra.app.services.*;
 import ghidra.app.services.DebuggerTraceManagerService.BooleanChangeAdapter;
 import ghidra.debug.api.tracemgr.DebuggerCoordinates;
-import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.model.DomainObjectChangeRecord;
+import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.plugintool.AutoService;
 import ghidra.framework.plugintool.ComponentProviderAdapter;
 import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
 import ghidra.trace.model.Trace;
-import ghidra.trace.model.Trace.TraceSnapshotChangeType;
 import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.time.TraceSnapshot;
+import ghidra.trace.util.TraceEvents;

 public class DebuggerThreadsProvider extends ComponentProviderAdapter {

@@ -67,8 +67,8 @@ public class DebuggerThreadsProvider extends ComponentProviderAdapter {
 		public ForSnapsListener() {
 			listenForUntyped(DomainObjectEvent.RESTORED, this::objectRestored);

-			listenFor(TraceSnapshotChangeType.ADDED, this::snapAdded);
-			listenFor(TraceSnapshotChangeType.DELETED, this::snapDeleted);
+			listenFor(TraceEvents.SNAPSHOT_ADDED, this::snapAdded);
+			listenFor(TraceEvents.SNAPSHOT_DELETED, this::snapDeleted);
 		}

 		private void setTrace(Trace trace) {
@@ -31,10 +31,10 @@ import ghidra.docking.settings.Settings;
 import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.plugintool.PluginTool;
 import ghidra.trace.model.Trace;
-import ghidra.trace.model.Trace.TraceSnapshotChangeType;
 import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.time.TraceSnapshot;
 import ghidra.trace.model.time.TraceTimeManager;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.table.GhidraTableFilterPanel;
 import ghidra.util.table.column.AbstractGColumnRenderer;

@@ -96,9 +96,9 @@ public class DebuggerSnapshotTablePanel extends JPanel {
 		public SnapshotListener() {
 			listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());

-			listenFor(TraceSnapshotChangeType.ADDED, this::snapAdded);
-			listenFor(TraceSnapshotChangeType.CHANGED, this::snapChanged);
-			listenFor(TraceSnapshotChangeType.DELETED, this::snapDeleted);
+			listenFor(TraceEvents.SNAPSHOT_ADDED, this::snapAdded);
+			listenFor(TraceEvents.SNAPSHOT_CHANGED, this::snapChanged);
+			listenFor(TraceEvents.SNAPSHOT_DELETED, this::snapDeleted);
 		}

 		private void objectRestored() {
@@ -56,8 +56,8 @@ import ghidra.base.widgets.table.DataTypeTableCellEditor;
 import ghidra.debug.api.tracemgr.DebuggerCoordinates;
 import ghidra.debug.api.watch.WatchRow;
 import ghidra.docking.settings.*;
-import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.model.DomainObjectChangeRecord;
+import ghidra.framework.model.DomainObjectEvent;
 import ghidra.framework.options.SaveState;
 import ghidra.framework.plugintool.*;
 import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
@@ -75,12 +75,11 @@ import ghidra.program.model.util.CodeUnitInsertionException;
 import ghidra.program.util.ProgramLocation;
 import ghidra.program.util.ProgramSelection;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
-import ghidra.trace.model.Trace.TraceMemoryStateChangeType;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.program.TraceProgramView;
 import ghidra.trace.model.time.schedule.TraceSchedule;
 import ghidra.trace.util.TraceAddressSpace;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.HelpLocation;
 import ghidra.util.Msg;
 import ghidra.util.exception.CancelledException;
@@ -247,8 +246,8 @@ public class DebuggerWatchesProvider extends ComponentProviderAdapter
 	class ForDepsListener extends TraceDomainObjectListener {
 		public ForDepsListener() {
 			listenForUntyped(DomainObjectEvent.RESTORED, this::objectRestored);
-			listenFor(TraceMemoryBytesChangeType.CHANGED, this::bytesChanged);
-			listenFor(TraceMemoryStateChangeType.CHANGED, this::stateChanged);
+			listenFor(TraceEvents.BYTES_CHANGED, this::bytesChanged);
+			listenFor(TraceEvents.BYTES_STATE_CHANGED, this::stateChanged);
 		}

 		private void objectRestored(DomainObjectChangeRecord rec) {
@@ -49,26 +49,26 @@ import ghidra.program.model.address.AddressRange;
 import ghidra.program.model.listing.*;
 import ghidra.program.util.*;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceBreakpointChangeType;
 import ghidra.trace.model.breakpoint.TraceBreakpoint;
 import ghidra.trace.model.breakpoint.TraceBreakpointKind;
 import ghidra.trace.model.program.TraceProgramView;
 import ghidra.trace.util.TraceAddressSpace;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.Msg;
 import ghidra.util.datastruct.ListenerSet;

@PluginInfo(
-		shortDescription = "Debugger logical breakpoints service plugin",
-		description = "Aggregates breakpoints from open programs and live traces",
-		category = PluginCategoryNames.DEBUGGER,
-		packageName = DebuggerPluginPackage.NAME,
-		status = PluginStatus.RELEASED,
-		eventsConsumed = { ProgramOpenedPluginEvent.class, ProgramClosedPluginEvent.class,
-			TraceOpenedPluginEvent.class, TraceActivatedPluginEvent.class,
-			TraceInactiveCoordinatesPluginEvent.class, TraceClosedPluginEvent.class, },
-		servicesRequired = { DebuggerTraceManagerService.class,
-			DebuggerStaticMappingService.class, },
-		servicesProvided = { DebuggerLogicalBreakpointService.class, })
+	shortDescription = "Debugger logical breakpoints service plugin",
+	description = "Aggregates breakpoints from open programs and live traces",
+	category = PluginCategoryNames.DEBUGGER,
+	packageName = DebuggerPluginPackage.NAME,
+	status = PluginStatus.RELEASED,
+	eventsConsumed = { ProgramOpenedPluginEvent.class, ProgramClosedPluginEvent.class,
+		TraceOpenedPluginEvent.class, TraceActivatedPluginEvent.class,
+		TraceInactiveCoordinatesPluginEvent.class, TraceClosedPluginEvent.class, },
+	servicesRequired = { DebuggerTraceManagerService.class,
+		DebuggerStaticMappingService.class, },
+	servicesProvided = { DebuggerLogicalBreakpointService.class, })
 public class DebuggerLogicalBreakpointServicePlugin extends Plugin
 		implements DebuggerLogicalBreakpointService {

@@ -198,10 +198,10 @@ public class DebuggerLogicalBreakpointServicePlugin extends Plugin
 			this.info = info;

 			listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());
-			listenFor(TraceBreakpointChangeType.ADDED, this::breakpointAdded);
-			listenFor(TraceBreakpointChangeType.CHANGED, this::breakpointChanged);
-			listenFor(TraceBreakpointChangeType.LIFESPAN_CHANGED, this::breakpointLifespanChanged);
-			listenFor(TraceBreakpointChangeType.DELETED, this::breakpointDeleted);
+			listenFor(TraceEvents.BREAKPOINT_ADDED, this::breakpointAdded);
+			listenFor(TraceEvents.BREAKPOINT_CHANGED, this::breakpointChanged);
+			listenFor(TraceEvents.BREAKPOINT_LIFESPAN_CHANGED, this::breakpointLifespanChanged);
+			listenFor(TraceEvents.BREAKPOINT_DELETED, this::breakpointDeleted);
 		}

 		@Override
@@ -51,25 +51,25 @@ import ghidra.program.model.listing.Program;
 import ghidra.program.model.mem.MemoryBlock;
 import ghidra.program.util.ProgramLocation;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceStaticMappingChangeType;
 import ghidra.trace.model.memory.TraceMemoryRegion;
 import ghidra.trace.model.modules.*;
 import ghidra.trace.model.program.TraceProgramView;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.Msg;
 import ghidra.util.datastruct.ListenerSet;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;

@PluginInfo(
-		shortDescription = "Debugger static mapping manager",
-		description = "Track and manage static mappings (program-trace relocations)",
-		category = PluginCategoryNames.DEBUGGER,
-		packageName = DebuggerPluginPackage.NAME,
-		status = PluginStatus.RELEASED,
-		eventsConsumed = { ProgramOpenedPluginEvent.class, ProgramClosedPluginEvent.class,
-			TraceOpenedPluginEvent.class, TraceClosedPluginEvent.class, },
-		servicesRequired = { ProgramManager.class, DebuggerTraceManagerService.class, },
-		servicesProvided = { DebuggerStaticMappingService.class, })
+	shortDescription = "Debugger static mapping manager",
+	description = "Track and manage static mappings (program-trace relocations)",
+	category = PluginCategoryNames.DEBUGGER,
+	packageName = DebuggerPluginPackage.NAME,
+	status = PluginStatus.RELEASED,
+	eventsConsumed = { ProgramOpenedPluginEvent.class, ProgramClosedPluginEvent.class,
+		TraceOpenedPluginEvent.class, TraceClosedPluginEvent.class, },
+	servicesRequired = { ProgramManager.class, DebuggerTraceManagerService.class, },
+	servicesProvided = { DebuggerStaticMappingService.class, })
 public class DebuggerStaticMappingServicePlugin extends Plugin
 		implements DebuggerStaticMappingService, DomainFolderChangeAdapter {

@@ -222,8 +222,8 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
 			this.trace = trace;

 			listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());
-			listenFor(TraceStaticMappingChangeType.ADDED, this::staticMappingAdded);
-			listenFor(TraceStaticMappingChangeType.DELETED, this::staticMappingDeleted);
+			listenFor(TraceEvents.MAPPING_ADDED, this::staticMappingAdded);
+			listenFor(TraceEvents.MAPPING_DELETED, this::staticMappingDeleted);

 			trace.addListener(this);

@@ -52,8 +52,6 @@ import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
 import ghidra.framework.plugintool.util.PluginStatus;
 import ghidra.lifecycle.Internal;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceObjectChangeType;
-import ghidra.trace.model.Trace.TraceThreadChangeType;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.program.TraceProgramView;
 import ghidra.trace.model.program.TraceVariableSnapProgramView;
@@ -62,6 +60,7 @@ import ghidra.trace.model.target.TraceObjectKeyPath;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.model.time.TraceSnapshot;
 import ghidra.trace.model.time.schedule.TraceSchedule;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.*;
 import ghidra.util.database.DomainObjectLockHold;
 import ghidra.util.exception.*;
@@ -107,9 +106,9 @@ public class DebuggerTraceManagerServicePlugin extends Plugin

 		public ListenerForTraceChanges(Trace trace) {
 			this.trace = trace;
-			listenFor(TraceThreadChangeType.ADDED, this::threadAdded);
-			listenFor(TraceThreadChangeType.DELETED, this::threadDeleted);
-			listenFor(TraceObjectChangeType.CREATED, this::objectCreated);
+			listenFor(TraceEvents.THREAD_ADDED, this::threadAdded);
+			listenFor(TraceEvents.THREAD_DELETED, this::threadDeleted);
+			listenFor(TraceEvents.OBJECT_CREATED, this::objectCreated);
 		}

 		private void threadAdded(TraceThread thread) {
@@ -77,10 +77,10 @@ import ghidra.test.AbstractGhidraHeadedIntegrationTest;
 import ghidra.test.TestEnv;
 import ghidra.trace.database.ToyDBTraceBuilder;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
 import ghidra.trace.model.memory.TraceMemorySpace;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.util.TraceAddressSpace;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.InvalidNameException;
 import ghidra.util.datastruct.TestDataStructureErrorHandlerInstaller;
 import ghidra.util.exception.CancelledException;
@@ -809,7 +809,7 @@ public abstract class AbstractGhidraHeadedDebuggerTest

 		TraceDomainObjectListener listener = new TraceDomainObjectListener() {
 			{
-				listenFor(TraceMemoryBytesChangeType.CHANGED, this::bytesChanged);
+				listenFor(TraceEvents.BYTES_CHANGED, this::bytesChanged);
 			}

 			void bytesChanged(TraceAddressSpace space, TraceAddressSnapRange range, byte[] oldValue,
@@ -17,6 +17,7 @@ package ghidra.app.plugin.core.debug.gui.pcode;

 import static org.junit.Assert.*;

+import java.awt.Color;
 import java.lang.invoke.MethodHandles;
 import java.util.List;

@@ -25,12 +26,14 @@ import org.junit.Test;

 import db.Transaction;
 import generic.Unique;
+import generic.theme.*;
 import ghidra.app.plugin.assembler.Assembler;
 import ghidra.app.plugin.assembler.Assemblers;
 import ghidra.app.plugin.core.debug.gui.AbstractGhidraHeadedDebuggerTest;
 import ghidra.app.plugin.core.debug.gui.listing.DebuggerListingPlugin;
 import ghidra.app.plugin.core.debug.gui.pcode.DebuggerPcodeStepperProvider.PcodeRowHtmlFormatter;
-import ghidra.app.plugin.core.debug.service.emulation.*;
+import ghidra.app.plugin.core.debug.service.emulation.BytesDebuggerPcodeEmulator;
+import ghidra.app.plugin.core.debug.service.emulation.BytesDebuggerPcodeEmulatorFactory;
 import ghidra.app.plugin.core.debug.service.tracemgr.DebuggerTraceManagerServicePlugin;
 import ghidra.app.plugin.processors.sleigh.SleighLanguage;
 import ghidra.app.services.DebuggerEmulationService;
@@ -63,6 +66,9 @@ public class DebuggerPcodeStepperProviderTest extends AbstractGhidraHeadedDebugg

 	@Before
 	public void setUpPcodeStepperProviderTest() throws Exception {
+		ThemeManager themeManager = ApplicationThemeManager.getInstance();
+		themeManager.setColor("color.fg.listing.pcode.label", new Color(0, 0, 255));
+
 		traceManager = addPlugin(tool, DebuggerTraceManagerServicePlugin.class);
 		pcodePlugin = addPlugin(tool, DebuggerPcodeStepperPlugin.class);
 		listingPlugin = addPlugin(tool, DebuggerListingPlugin.class); // For colors
@@ -59,10 +59,9 @@ import ghidra.trace.model.memory.TraceMemoryRegion;
 import ghidra.trace.model.program.TraceProgramView;
 import ghidra.trace.model.property.TraceAddressPropertyManager;
 import ghidra.trace.model.time.TraceSnapshot;
+import ghidra.trace.util.*;
 import ghidra.trace.util.CopyOnWrite.WeakHashCowSet;
 import ghidra.trace.util.CopyOnWrite.WeakValueHashCowMap;
-import ghidra.trace.util.TraceChangeManager;
-import ghidra.trace.util.TraceChangeRecord;
 import ghidra.util.*;
 import ghidra.util.database.*;
 import ghidra.util.datastruct.ListenerSet;
@@ -658,7 +657,8 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
 			traceChangeSet.sourceArchiveChanged(sourceArchiveID.getValue());
 		}
 		setChanged(
-			new TraceChangeRecord<>(TraceSourceArchiveChangeType.CHANGED, null, sourceArchiveID));
+			new TraceChangeRecord<>(TraceEvents.SOURCE_TYPE_ARCHIVE_CHANGED, null,
+				sourceArchiveID));
 	}

 	public void sourceArchiveAdded(UniversalID sourceArchiveID) {
@@ -666,7 +666,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
 			traceChangeSet.sourceArchiveAdded(sourceArchiveID.getValue());
 		}
 		setChanged(
-			new TraceChangeRecord<>(TraceSourceArchiveChangeType.ADDED, null, sourceArchiveID));
+			new TraceChangeRecord<>(TraceEvents.SOURCE_TYPE_ARCHIVE_ADDED, null, sourceArchiveID));
 	}

 	public void dataTypeChanged(long changedID, DataType changedType) {
@@ -674,7 +674,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
 			traceChangeSet.dataTypeChanged(changedID);
 		}
 		setChanged(
-			new TraceChangeRecord<>(TraceDataTypeChangeType.CHANGED, null, changedID, changedType));
+			new TraceChangeRecord<>(TraceEvents.DATA_TYPE_CHANGED, null, changedID, changedType));
 	}

 	public void dataTypeAdded(long addedID, DataType addedType) {
@@ -682,14 +682,14 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
 			traceChangeSet.dataTypeAdded(addedID);
 		}
 		setChanged(
-			new TraceChangeRecord<>(TraceDataTypeChangeType.ADDED, null, addedID, addedType));
+			new TraceChangeRecord<>(TraceEvents.DATA_TYPE_ADDED, null, addedID, addedType));
 	}

 	public void dataTypeReplaced(long replacedID, DataTypePath replacedPath, DataTypePath newPath) {
 		if (recordChanges) {
 			traceChangeSet.dataTypeChanged(replacedID);
 		}
-		setChanged(new TraceChangeRecord<>(TraceDataTypeChangeType.REPLACED, null, replacedID,
+		setChanged(new TraceChangeRecord<>(TraceEvents.DATA_TYPE_REPLACED, null, replacedID,
 			replacedPath, newPath));
 	}

@@ -697,7 +697,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
 		if (recordChanges) {
 			traceChangeSet.dataTypeChanged(movedID);
 		}
-		setChanged(new TraceChangeRecord<>(TraceDataTypeChangeType.MOVED, null, movedID, oldPath,
+		setChanged(new TraceChangeRecord<>(TraceEvents.DATA_TYPE_MOVED, null, movedID, oldPath,
 			newPath));
 	}

@@ -705,7 +705,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
 		if (recordChanges) {
 			traceChangeSet.dataTypeChanged(renamedID);
 		}
-		setChanged(new TraceChangeRecord<>(TraceDataTypeChangeType.RENAMED, null, renamedID,
+		setChanged(new TraceChangeRecord<>(TraceEvents.DATA_TYPE_RENAMED, null, renamedID,
 			oldName, newName));
 	}

@@ -713,7 +713,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
 		if (recordChanges) {
 			traceChangeSet.dataTypeChanged(deletedID);
 		}
-		setChanged(new TraceChangeRecord<>(TraceDataTypeChangeType.DELETED, null, deletedID,
+		setChanged(new TraceChangeRecord<>(TraceEvents.DATA_TYPE_DELETED, null, deletedID,
 			deletedPath, null));
 	}

@@ -722,14 +722,14 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
 			traceChangeSet.categoryAdded(addedID);
 		}
 		setChanged(
-			new TraceChangeRecord<>(TraceCategoryChangeType.ADDED, null, addedID, addedCategory));
+			new TraceChangeRecord<>(TraceEvents.TYPE_CATEGORY_ADDED, null, addedID, addedCategory));
 	}

 	public void categoryMoved(long movedID, CategoryPath oldPath, CategoryPath newPath) {
 		if (recordChanges) {
 			traceChangeSet.categoryChanged(movedID);
 		}
-		setChanged(new TraceChangeRecord<>(TraceCategoryChangeType.MOVED, null, movedID, oldPath,
+		setChanged(new TraceChangeRecord<>(TraceEvents.TYPE_CATEGORY_MOVED, null, movedID, oldPath,
 			newPath));
 	}

@@ -737,7 +737,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
 		if (recordChanges) {
 			traceChangeSet.categoryChanged(renamedID);
 		}
-		setChanged(new TraceChangeRecord<>(TraceCategoryChangeType.RENAMED, null, renamedID,
+		setChanged(new TraceChangeRecord<>(TraceEvents.TYPE_CATEGORY_RENAMED, null, renamedID,
 			oldName, newName));
 	}

@@ -745,7 +745,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
 		if (recordChanges) {
 			traceChangeSet.categoryChanged(deletedID);
 		}
-		setChanged(new TraceChangeRecord<>(TraceCategoryChangeType.DELETED, null, deletedID,
+		setChanged(new TraceChangeRecord<>(TraceEvents.TYPE_CATEGORY_DELETED, null, deletedID,
 			deletedPath, null));
 	}

@@ -29,8 +29,8 @@ import ghidra.program.model.address.Address;
 import ghidra.program.model.address.AddressSpace;
 import ghidra.trace.database.DBTrace;
 import ghidra.trace.database.DBTraceManager;
-import ghidra.trace.model.Trace.TraceOverlaySpaceChangeType;
 import ghidra.trace.util.TraceChangeRecord;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.LockHold;
 import ghidra.util.database.*;
 import ghidra.util.database.DBCachedObjectStoreFactory.AbstractDBFieldCodec;
@@ -267,7 +267,7 @@ public class DBTraceOverlaySpaceAdapter implements DBTraceManager {
 		ent.set(space.getName(), base.getName());
 		trace.updateViewsAddSpaceBlock(space);
 		trace.setChanged(
-			new TraceChangeRecord<>(TraceOverlaySpaceChangeType.ADDED, null, trace, null, space));
+			new TraceChangeRecord<>(TraceEvents.OVERLAY_ADDED, null, trace, null, space));
 		return space;
 	}

@@ -313,8 +313,8 @@ public class DBTraceOverlaySpaceAdapter implements DBTraceManager {
 			assert space != null;
 			factory.removeOverlaySpace(name);
 			trace.updateViewsDeleteSpaceBlock(space);
-			trace.setChanged(new TraceChangeRecord<>(TraceOverlaySpaceChangeType.DELETED, null,
-				trace, space, null));
+			trace.setChanged(
+				new TraceChangeRecord<>(TraceEvents.OVERLAY_DELETED, null, trace, space, null));
 			invalidateCache(true);
 		}
 	}
@@ -24,11 +24,11 @@ import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
 import ghidra.trace.model.Lifespan;
-import ghidra.trace.model.Trace.TraceBookmarkChangeType;
 import ghidra.trace.model.bookmark.TraceBookmark;
 import ghidra.trace.model.bookmark.TraceBookmarkType;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.util.TraceChangeRecord;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.LockHold;
 import ghidra.util.database.DBCachedObjectStore;
 import ghidra.util.database.DBObjectColumn;
@@ -140,14 +140,14 @@ public class DBTraceBookmark extends AbstractDBTraceAddressSnapRangePropertyMapD
 			update(CATEGORY_COLUMN, COMMENT_COLUMN);
 		}
 		space.trace.setChanged(
-			new TraceChangeRecord<>(TraceBookmarkChangeType.CHANGED, space, this));
+			new TraceChangeRecord<>(TraceEvents.BOOKMARK_CHANGED, space, this));
 	}

 	@Override
 	public void delete() {
 		space.bookmarkMapSpace.deleteData(this);
 		space.trace.setChanged(
-			new TraceChangeRecord<>(TraceBookmarkChangeType.DELETED, space, this));
+			new TraceChangeRecord<>(TraceEvents.BOOKMARK_DELETED, space, this));
 	}

 	@Override
@@ -31,12 +31,12 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAdd
 import ghidra.trace.database.space.*;
 import ghidra.trace.database.thread.DBTraceThreadManager;
 import ghidra.trace.model.Lifespan;
-import ghidra.trace.model.Trace.TraceBookmarkChangeType;
 import ghidra.trace.model.bookmark.TraceBookmarkManager;
 import ghidra.trace.model.bookmark.TraceBookmarkType;
 import ghidra.trace.model.stack.TraceStackFrame;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.util.TraceChangeRecord;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.LockHold;
 import ghidra.util.Msg;
 import ghidra.util.database.DBOpenMode;
@@ -231,7 +231,7 @@ public class DBTraceBookmarkManager extends AbstractDBTraceSpaceBasedManager<DBT
 			type = new DBTraceBookmarkType(this, typeName);
 			typesByName.put(typeName, type);
 		}
-		trace.setChanged(new TraceChangeRecord<>(TraceBookmarkChangeType.TYPE_ADDED, null, type));
+		trace.setChanged(new TraceChangeRecord<>(TraceEvents.BOOKMARK_TYPE_ADDED, null, type));
 		return type;
 	}

@@ -250,7 +250,7 @@ public class DBTraceBookmarkManager extends AbstractDBTraceSpaceBasedManager<DBT
 			type = new DBTraceBookmarkType(this, typeName, icon, color, priority);
 			typesByName.put(typeName, type);
 		}
-		trace.setChanged(new TraceChangeRecord<>(TraceBookmarkChangeType.TYPE_ADDED, null, type));
+		trace.setChanged(new TraceChangeRecord<>(TraceEvents.BOOKMARK_TYPE_ADDED, null, type));
 		return type;
 	}

@@ -25,11 +25,11 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapSpace;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
 import ghidra.trace.database.space.DBTraceSpaceBased;
 import ghidra.trace.model.Lifespan;
-import ghidra.trace.model.Trace.TraceBookmarkChangeType;
 import ghidra.trace.model.bookmark.TraceBookmarkSpace;
 import ghidra.trace.model.bookmark.TraceBookmarkType;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.util.TraceChangeRecord;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.LockHold;
 import ghidra.util.database.DBCachedObjectIndex;
 import ghidra.util.exception.VersionException;
@@ -110,8 +110,7 @@ public class DBTraceBookmarkSpace implements TraceBookmarkSpace, DBTraceSpaceBas
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
 			DBTraceBookmark bookmark = bookmarkMapSpace.put(address, lifespan, null);
 			bookmark.set(type.getTypeString(), category, comment);
-			trace.setChanged(
-				new TraceChangeRecord<>(TraceBookmarkChangeType.ADDED, this, bookmark));
+			trace.setChanged(new TraceChangeRecord<>(TraceEvents.BOOKMARK_ADDED, this, bookmark));
 			return bookmark;
 		}
 	}
@@ -27,11 +27,11 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
 import ghidra.trace.database.thread.DBTraceThreadManager;
 import ghidra.trace.model.Lifespan;
-import ghidra.trace.model.Trace.TraceBreakpointChangeType;
 import ghidra.trace.model.breakpoint.TraceBreakpoint;
 import ghidra.trace.model.breakpoint.TraceBreakpointKind;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.util.TraceChangeRecord;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.LockHold;
 import ghidra.util.Msg;
 import ghidra.util.database.DBCachedObjectStore;
@@ -193,8 +193,8 @@ public class DBTraceBreakpoint
 			this.name = name;
 			update(NAME_COLUMN);
 		}
-		space.trace.setChanged(new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED,
-			space, this));
+		space.trace
+				.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));

 	}

@@ -261,7 +261,7 @@ public class DBTraceBreakpoint
 			oldLifespan = lifespan;
 			doSetLifespan(newLifespan);
 		}
-		space.trace.setChanged(new TraceChangeRecord<>(TraceBreakpointChangeType.LIFESPAN_CHANGED,
+		space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_LIFESPAN_CHANGED,
 			space, this, oldLifespan, newLifespan));
 	}

@@ -325,16 +325,15 @@ public class DBTraceBreakpoint
 		}
 		if (that == this) {
 			space.trace.setChanged(
-				new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED, space, this));
+				new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
 		}
 		else {
 			// Yes, issue ADDED, before LIFESPAN_CHANGED, as noted in docs
+			space.trace
+					.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_ADDED, space, that));
 			space.trace.setChanged(
-				new TraceChangeRecord<>(TraceBreakpointChangeType.ADDED, space, that));
-			space.trace.setChanged(
-				new TraceChangeRecord<>(TraceBreakpointChangeType.LIFESPAN_CHANGED,
-					space, this, Objects.requireNonNull(oldLifespan),
-					Objects.requireNonNull(newLifespan)));
+				new TraceChangeRecord<>(TraceEvents.BREAKPOINT_LIFESPAN_CHANGED, space, this,
+					Objects.requireNonNull(oldLifespan), Objects.requireNonNull(newLifespan)));
 		}
 		return that;
 	}
@@ -403,8 +402,8 @@ public class DBTraceBreakpoint
 		try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
 			doSetEnabled(enabled);
 		}
-		space.trace.setChanged(new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED,
-			space, this));
+		space.trace
+				.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
 	}

 	@Override
@@ -420,8 +419,8 @@ public class DBTraceBreakpoint
 		try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
 			doSetEmuEnabled(enabled);
 		}
-		space.trace.setChanged(new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED,
-			space, this));
+		space.trace
+				.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
 	}

 	@Override
@@ -437,8 +436,8 @@ public class DBTraceBreakpoint
 		try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
 			doSetKinds(kinds);
 		}
-		space.trace.setChanged(
-			new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED, space, this));
+		space.trace
+				.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
 	}

 	@Override
@@ -454,8 +453,8 @@ public class DBTraceBreakpoint
 			this.comment = comment;
 			update(COMMENT_COLUMN);
 		}
-		space.trace.setChanged(new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED,
-			space, this));
+		space.trace
+				.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
 	}

 	@Override
@@ -476,8 +475,8 @@ public class DBTraceBreakpoint
 			}
 			update(SLEIGH_COLUMN);
 		}
-		space.trace.setChanged(new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED,
-			space, this));
+		space.trace
+				.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
 	}

 	@Override
@@ -31,11 +31,11 @@ import ghidra.trace.database.thread.DBTraceThread;
 import ghidra.trace.database.thread.DBTraceThreadManager;
 import ghidra.trace.model.ImmutableTraceAddressSnapRange;
 import ghidra.trace.model.Lifespan;
-import ghidra.trace.model.Trace.TraceBreakpointChangeType;
 import ghidra.trace.model.breakpoint.TraceBreakpoint;
 import ghidra.trace.model.breakpoint.TraceBreakpointKind;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.util.TraceChangeRecord;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.LockHold;
 import ghidra.util.database.DBCachedObjectIndex;
 import ghidra.util.database.DBCachedObjectStoreFactory;
@@ -102,7 +102,7 @@ public class DBTraceBreakpointSpace implements DBTraceSpaceBased {
 				breakpointMapSpace.put(new ImmutableTraceAddressSnapRange(range, lifespan), null);
 			breakpoint.set(path, path, threads, kinds, enabled, true, comment);
 			trace.setChanged(
-				new TraceChangeRecord<>(TraceBreakpointChangeType.ADDED, this, breakpoint));
+				new TraceChangeRecord<>(TraceEvents.BREAKPOINT_ADDED, this, breakpoint));
 			return breakpoint;
 		}
 	}
@@ -128,8 +128,7 @@ public class DBTraceBreakpointSpace implements DBTraceSpaceBased {

 	public void deleteBreakpoint(DBTraceBreakpoint breakpoint) {
 		breakpointMapSpace.deleteData(breakpoint);
-		trace.setChanged(
-			new TraceChangeRecord<>(TraceBreakpointChangeType.DELETED, this, breakpoint));
+		trace.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_DELETED, this, breakpoint));
 	}

 	@Override
@@ -27,7 +27,6 @@ import ghidra.program.model.address.AddressRange;
 import ghidra.trace.database.target.*;
 import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
-import ghidra.trace.model.Trace.TraceBreakpointChangeType;
 import ghidra.trace.model.breakpoint.*;
 import ghidra.trace.model.target.TraceObject;
 import ghidra.trace.model.target.annot.TraceObjectInterfaceUtils;
@@ -59,18 +58,18 @@ public class DBTraceObjectBreakpointLocation
 		}

 		@Override
-		protected TraceChangeType<TraceBreakpoint, Void> getAddedType() {
-			return TraceBreakpointChangeType.ADDED;
+		protected TraceEvent<TraceBreakpoint, Void> getAddedType() {
+			return TraceEvents.BREAKPOINT_ADDED;
 		}

 		@Override
-		protected TraceChangeType<TraceBreakpoint, Lifespan> getLifespanChangedType() {
-			return TraceBreakpointChangeType.LIFESPAN_CHANGED;
+		protected TraceEvent<TraceBreakpoint, Lifespan> getLifespanChangedType() {
+			return TraceEvents.BREAKPOINT_LIFESPAN_CHANGED;
 		}

 		@Override
-		protected TraceChangeType<TraceBreakpoint, Void> getChangedType() {
-			return TraceBreakpointChangeType.CHANGED;
+		protected TraceEvent<TraceBreakpoint, Void> getChangedType() {
+			return TraceEvents.BREAKPOINT_CHANGED;
 		}

 		@Override
@@ -79,8 +78,8 @@ public class DBTraceObjectBreakpointLocation
 		}

 		@Override
-		protected TraceChangeType<TraceBreakpoint, Void> getDeletedType() {
-			return TraceBreakpointChangeType.DELETED;
+		protected TraceEvent<TraceBreakpoint, Void> getDeletedType() {
+			return TraceEvents.BREAKPOINT_DELETED;
 		}
 	}

@@ -26,8 +26,6 @@ import ghidra.trace.database.target.DBTraceObject;
 import ghidra.trace.database.target.DBTraceObjectInterface;
 import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
-import ghidra.trace.model.Trace.TraceBreakpointChangeType;
-import ghidra.trace.model.Trace.TraceObjectChangeType;
 import ghidra.trace.model.breakpoint.*;
 import ghidra.trace.model.breakpoint.TraceBreakpointKind.TraceBreakpointKindSet;
 import ghidra.trace.model.target.TraceObject;
@@ -35,8 +33,7 @@ import ghidra.trace.model.target.TraceObjectValue;
 import ghidra.trace.model.target.annot.TraceObjectInterfaceUtils;
 import ghidra.trace.model.thread.TraceObjectThread;
 import ghidra.trace.model.thread.TraceThread;
-import ghidra.trace.util.TraceAddressSpace;
-import ghidra.trace.util.TraceChangeRecord;
+import ghidra.trace.util.*;
 import ghidra.util.LockHold;
 import ghidra.util.Msg;
 import ghidra.util.exception.DuplicateNameException;
@@ -243,9 +240,8 @@ public class DBTraceObjectBreakpointSpec

 	@Override
 	public TraceChangeRecord<?, ?> translateEvent(TraceChangeRecord<?, ?> rec) {
-		if (rec.getEventType() == TraceObjectChangeType.VALUE_CREATED.getEventType()) {
-			TraceChangeRecord<TraceObjectValue, Void> cast =
-				TraceObjectChangeType.VALUE_CREATED.cast(rec);
+		if (rec.getEventType() == TraceEvents.VALUE_CREATED) {
+			TraceChangeRecord<TraceObjectValue, Void> cast = TraceEvents.VALUE_CREATED.cast(rec);
 			TraceObjectValue affected = cast.getAffectedObject();
 			String key = affected.getEntryKey();
 			boolean applies = keys.contains(key);
@@ -259,8 +255,8 @@ public class DBTraceObjectBreakpointSpec
 			for (TraceObjectBreakpointLocation loc : getLocations()) {
 				DBTraceObjectBreakpointLocation dbLoc = (DBTraceObjectBreakpointLocation) loc;
 				TraceAddressSpace space = dbLoc.getTraceAddressSpace();
-				TraceChangeRecord<?, ?> evt = new TraceChangeRecord<>(
-					TraceBreakpointChangeType.CHANGED, space, loc, null, null);
+				TraceChangeRecord<?, ?> evt =
+					new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, loc, null, null);
 				object.getTrace().setChanged(evt);
 			}
 			return null;
@@ -34,12 +34,10 @@ import ghidra.trace.database.DBTraceUtils.CompilerSpecIDDBFieldCodec;
 import ghidra.trace.database.DBTraceUtils.LanguageIDDBFieldCodec;
 import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
-import ghidra.trace.model.Trace.TracePlatformChangeType;
 import ghidra.trace.model.guest.TraceGuestPlatform;
 import ghidra.trace.model.guest.TraceGuestPlatformMappedRange;
-import ghidra.trace.util.OverlappingObjectIterator;
+import ghidra.trace.util.*;
 import ghidra.trace.util.OverlappingObjectIterator.Ranger;
-import ghidra.trace.util.TraceChangeRecord;
 import ghidra.util.LockHold;
 import ghidra.util.database.*;
 import ghidra.util.database.annot.*;
@@ -217,8 +215,8 @@ public class DBTraceGuestPlatform extends DBAnnotatedObject
 			hostAddressSet.delete(hostRange);
 			guestAddressSet.delete(guestRange);
 		}
-		manager.trace.setChanged(new TraceChangeRecord<>(TracePlatformChangeType.MAPPING_DELETED,
-			null, this, range, null));
+		manager.trace.setChanged(
+			new TraceChangeRecord<>(TraceEvents.PLATFORM_MAPPING_DELETED, null, this, range, null));
 	}

 	@Override
@@ -265,8 +263,8 @@ public class DBTraceGuestPlatform extends DBAnnotatedObject
 			hostAddressSet.add(mappedRange.getHostRange());
 			guestAddressSet.add(mappedRange.getGuestRange());
 		}
-		manager.trace.setChanged(new TraceChangeRecord<>(TracePlatformChangeType.MAPPING_ADDED,
-			null, this, null, mappedRange));
+		manager.trace.setChanged(new TraceChangeRecord<>(TraceEvents.PLATFORM_MAPPING_ADDED, null,
+			this, null, mappedRange));
 		return mappedRange;
 	}

@@ -32,13 +32,13 @@ import ghidra.program.model.address.AddressSpace;
 import ghidra.program.model.lang.Register;
 import ghidra.program.model.lang.RegisterValue;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.*;
 import ghidra.trace.model.guest.*;
 import ghidra.trace.model.memory.TraceMemoryManager;
 import ghidra.trace.model.memory.TraceMemorySpace;
 import ghidra.trace.model.symbol.*;
 import ghidra.trace.model.target.*;
 import ghidra.trace.util.TraceChangeRecord;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.Msg;

 public enum DBTraceObjectRegisterSupport {
@@ -47,10 +47,10 @@ public enum DBTraceObjectRegisterSupport {

 	private static final TraceDomainObjectListener HANDLER = new TraceDomainObjectListener() {
 		{
-			listenFor(TraceObjectChangeType.VALUE_CREATED, INSTANCE::objectValueCreated);
-			listenFor(TraceSymbolChangeType.ADDED, INSTANCE::symbolAdded);
-			listenFor(TraceOverlaySpaceChangeType.ADDED, INSTANCE::spaceAdded);
-			listenFor(TracePlatformChangeType.MAPPING_ADDED, INSTANCE::guestMappingAdded);
+			listenFor(TraceEvents.VALUE_CREATED, INSTANCE::objectValueCreated);
+			listenFor(TraceEvents.SYMBOL_ADDED, INSTANCE::symbolAdded);
+			listenFor(TraceEvents.OVERLAY_ADDED, INSTANCE::spaceAdded);
+			listenFor(TraceEvents.PLATFORM_MAPPING_ADDED, INSTANCE::guestMappingAdded);
 		}
 	};

@@ -28,9 +28,9 @@ import ghidra.trace.database.DBTrace;
 import ghidra.trace.database.DBTraceManager;
 import ghidra.trace.database.guest.DBTraceGuestPlatform.DBTraceGuestLanguage;
 import ghidra.trace.model.Trace;
-import ghidra.trace.model.Trace.TracePlatformChangeType;
 import ghidra.trace.model.guest.*;
 import ghidra.trace.util.TraceChangeRecord;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.LockHold;
 import ghidra.util.database.*;
 import ghidra.util.exception.CancelledException;
@@ -282,7 +282,7 @@ public class DBTracePlatformManager implements DBTraceManager, TracePlatformMana
 			platformsByCompiler.remove(platform.getCompilerSpec());
 			platformStore.delete(platform);
 		}
-		trace.setChanged(new TraceChangeRecord<>(TracePlatformChangeType.DELETED, null, platform));
+		trace.setChanged(new TraceChangeRecord<>(TraceEvents.PLATFORM_DELETED, null, platform));
 	}

 	@Override
@@ -307,7 +307,7 @@ public class DBTracePlatformManager implements DBTraceManager, TracePlatformMana
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
 			platform = doAddGuestPlatform(compilerSpec);
 		}
-		trace.setChanged(new TraceChangeRecord<>(TracePlatformChangeType.ADDED, null, platform));
+		trace.setChanged(new TraceChangeRecord<>(TraceEvents.PLATFORM_ADDED, null, platform));
 		return platform;
 	}

@@ -335,7 +335,7 @@ public class DBTracePlatformManager implements DBTraceManager, TracePlatformMana
 			}
 			platform = doAddGuestPlatform(compilerSpec);
 		}
-		trace.setChanged(new TraceChangeRecord<>(TracePlatformChangeType.ADDED, null, platform));
+		trace.setChanged(new TraceChangeRecord<>(TraceEvents.PLATFORM_ADDED, null, platform));
 		return platform;
 	}

@@ -29,9 +29,9 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapSpace;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
 import ghidra.trace.database.memory.DBTraceMemorySpace;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceCodeChangeType;
 import ghidra.trace.model.listing.TraceBaseDefinedUnitsView;
 import ghidra.trace.util.TraceChangeRecord;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.LockHold;
 import ghidra.util.database.spatial.rect.Rectangle2DDirection;
 import ghidra.util.exception.CancelledException;
@@ -339,8 +339,8 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
 		cacheForContaining.notifyEntryRemoved(unit.getLifespan(), unit.getRange(), unit);
 		cacheForSequence.notifyEntryRemoved(unit.getLifespan(), unit.getRange(), unit);
 		space.undefinedData.invalidateCache();
-		space.trace.setChanged(new TraceChangeRecord<>(TraceCodeChangeType.REMOVED,
-			space, unit.getBounds(), unit, null));
+		space.trace.setChanged(
+			new TraceChangeRecord<>(TraceEvents.CODE_REMOVED, space, unit.getBounds(), unit, null));
 	}

 	/**
@@ -353,8 +353,8 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
 		cacheForContaining.notifyEntryShapeChanged(unit.getLifespan(), unit.getRange(), unit);
 		cacheForSequence.notifyEntryShapeChanged(unit.getLifespan(), unit.getRange(), unit);
 		space.undefinedData.invalidateCache();
-		space.trace.setChanged(new TraceChangeRecord<>(TraceCodeChangeType.LIFESPAN_CHANGED,
-			space, unit, oldSpan, unit.getLifespan()));
+		space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.CODE_LIFESPAN_CHANGED, space,
+			unit, oldSpan, unit.getLifespan()));
 	}

 	/**
@@ -36,8 +36,8 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAdd
 import ghidra.trace.database.space.DBTraceSpaceKey;
 import ghidra.trace.database.thread.DBTraceThreadManager;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceCommentChangeType;
 import ghidra.trace.util.TraceChangeRecord;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.LockHold;
 import ghidra.util.database.*;
 import ghidra.util.database.annot.*;
@@ -155,7 +155,7 @@ public class DBTraceCommentAdapter
 			}
 		}
 		trace.setChanged(new TraceChangeRecord<TraceAddressSnapRange, String>(
-			TraceCommentChangeType.byType(commentType),
+			TraceEvents.byCommentType(commentType),
 			DBTraceSpaceKey.create(address.getAddressSpace(), null, 0),
 			new ImmutableTraceAddressSnapRange(address, lifespan),
 			oldValue, comment));
@@ -25,7 +25,6 @@ import ghidra.program.model.symbol.RefType;
 import ghidra.program.model.symbol.SourceType;
 import ghidra.trace.database.data.DBTraceDataSettingsOperations;
 import ghidra.trace.database.symbol.DBTraceReference;
-import ghidra.trace.model.Trace.TraceCodeChangeType;
 import ghidra.trace.model.listing.TraceData;
 import ghidra.trace.model.symbol.TraceReference;
 import ghidra.trace.util.*;
@@ -96,9 +95,8 @@ public interface DBTraceDataAdapter extends DBTraceCodeUnitAdapter, DataAdapterM
 		try (LockHold hold = getTrace().lockWrite()) {
 			getSettingsSpace(true).setLong(getLifespan(), getAddress(), name, value);
 		}
-		getTrace().setChanged(new TraceChangeRecord<>(
-			TraceCodeChangeType.DATA_TYPE_SETTINGS_CHANGED, getTraceSpace(), this.getBounds(), null,
-			null));
+		getTrace().setChanged(new TraceChangeRecord<>(TraceEvents.CODE_DATA_SETTINGS_CHANGED,
+			getTraceSpace(), this.getBounds(), null, null));
 	}

 	@Override
@@ -121,9 +119,8 @@ public interface DBTraceDataAdapter extends DBTraceCodeUnitAdapter, DataAdapterM
 		try (LockHold hold = getTrace().lockWrite()) {
 			getSettingsSpace(true).setString(getLifespan(), getAddress(), name, value);
 		}
-		getTrace().setChanged(new TraceChangeRecord<>(
-			TraceCodeChangeType.DATA_TYPE_SETTINGS_CHANGED, getTraceSpace(), this.getBounds(), null,
-			null));
+		getTrace().setChanged(new TraceChangeRecord<>(TraceEvents.CODE_DATA_SETTINGS_CHANGED,
+			getTraceSpace(), this.getBounds(), null, null));
 	}

 	@Override
@@ -147,9 +144,8 @@ public interface DBTraceDataAdapter extends DBTraceCodeUnitAdapter, DataAdapterM
 		try (LockHold hold = getTrace().lockWrite()) {
 			getSettingsSpace(true).setValue(getLifespan(), getAddress(), name, value);
 		}
-		getTrace().setChanged(new TraceChangeRecord<>(
-			TraceCodeChangeType.DATA_TYPE_SETTINGS_CHANGED, getTraceSpace(), this.getBounds(), null,
-			null));
+		getTrace().setChanged(new TraceChangeRecord<>(TraceEvents.CODE_DATA_SETTINGS_CHANGED,
+			getTraceSpace(), this.getBounds(), null, null));
 	}

 	@Override
@@ -176,9 +172,8 @@ public interface DBTraceDataAdapter extends DBTraceCodeUnitAdapter, DataAdapterM
 			}
 			space.clear(getLifespan(), getAddress(), name);
 		}
-		getTrace().setChanged(new TraceChangeRecord<>(
-			TraceCodeChangeType.DATA_TYPE_SETTINGS_CHANGED, getTraceSpace(), this.getBounds(), null,
-			null));
+		getTrace().setChanged(new TraceChangeRecord<>(TraceEvents.CODE_DATA_SETTINGS_CHANGED,
+			getTraceSpace(), this.getBounds(), null, null));
 	}

 	@Override
@@ -190,9 +185,8 @@ public interface DBTraceDataAdapter extends DBTraceCodeUnitAdapter, DataAdapterM
 			}
 			space.clear(getLifespan(), getAddress(), null);
 		}
-		getTrace().setChanged(new TraceChangeRecord<>(
-			TraceCodeChangeType.DATA_TYPE_SETTINGS_CHANGED, getTraceSpace(), this.getBounds(), null,
-			null));
+		getTrace().setChanged(new TraceChangeRecord<>(TraceEvents.CODE_DATA_SETTINGS_CHANGED,
+			getTraceSpace(), this.getBounds(), null, null));
 	}

 	@Override
@@ -21,10 +21,9 @@ import ghidra.program.model.mem.MemBuffer;
 import ghidra.program.model.util.CodeUnitInsertionException;
 import ghidra.trace.database.memory.DBTraceMemorySpace;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceCodeChangeType;
-import ghidra.trace.model.Trace.TraceCompositeDataChangeType;
 import ghidra.trace.model.listing.TraceCodeSpace;
 import ghidra.trace.util.TraceChangeRecord;
+import ghidra.trace.util.TraceEvents;
 import ghidra.util.LockHold;

 /**
@@ -157,12 +156,12 @@ public class DBTraceDefinedDataView extends AbstractBaseDBTraceDefinedUnitsView<
 			if (dataType instanceof Composite || dataType instanceof Array ||
 				dataType instanceof Dynamic) {
 				// TODO: Track composites?
-				space.trace.setChanged(new TraceChangeRecord<>(TraceCompositeDataChangeType.ADDED,
+				space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.COMPOSITE_DATA_ADDED,
 					space, tasr, created));
 			}

-			space.trace.setChanged(new TraceChangeRecord<>(TraceCodeChangeType.ADDED,
-				space, tasr, created));
+			space.trace.setChanged(
+				new TraceChangeRecord<>(TraceEvents.CODE_ADDED, space, tasr, created));
 			return created;
 		}
 		catch (AddressOverflowException e) {
@@ -176,7 +175,7 @@ public class DBTraceDefinedDataView extends AbstractBaseDBTraceDefinedUnitsView<
 		DataType dataType = unit.getBaseDataType();
 		if (dataType instanceof Composite || dataType instanceof Array ||
 			dataType instanceof Dynamic) {
-			space.trace.setChanged(new TraceChangeRecord<>(TraceCompositeDataChangeType.REMOVED,
+			space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.COMPOSITE_DATA_REMOVED,
 				space, unit.getBounds(), unit, null));
 		}
 	}
@@ -188,7 +187,7 @@ public class DBTraceDefinedDataView extends AbstractBaseDBTraceDefinedUnitsView<
 		if (dataType instanceof Composite || dataType instanceof Array ||
 			dataType instanceof Dynamic) {
 			space.trace.setChanged(
-				new TraceChangeRecord<>(TraceCompositeDataChangeType.LIFESPAN_CHANGED,
+				new TraceChangeRecord<>(TraceEvents.COMPOSITE_DATA_LIFESPAN_CHANGED,
 					space, unit, oldSpan, unit.getLifespan()));
 		}
 	}
@@ -39,7 +39,6 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
 import ghidra.trace.database.symbol.DBTraceReference;
 import ghidra.trace.database.symbol.DBTraceReferenceSpace;
 import ghidra.trace.model.*;
-import ghidra.trace.model.Trace.TraceInstructionChangeType;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.listing.TraceInstruction;
 import ghidra.trace.model.symbol.TraceReference;
@@ -571,7 +570,7 @@ public class DBTraceInstruction extends AbstractDBTraceCodeUnit<DBTraceInstructi
 			}
 		}
 		space.trace.setChanged(
-			new TraceChangeRecord<>(TraceInstructionChangeType.FLOW_OVERRIDE_CHANGED, space, this,
+			new TraceChangeRecord<>(TraceEvents.INSTRUCTION_FLOW_OVERRIDE_CHANGED, space, this,
 				oldFlowOverride, flowOverride));
 	}

@@ -604,7 +603,7 @@ public class DBTraceInstruction extends AbstractDBTraceCodeUnit<DBTraceInstructi
 			updateLengthOverride(length);
 		}
 		space.trace.setChanged(
-			new TraceChangeRecord<>(TraceInstructionChangeType.LENGTH_OVERRIDE_CHANGED, space, this,
+			new TraceChangeRecord<>(TraceEvents.INSTRUCTION_LENGTH_OVERRIDE_CHANGED, space, this,
 				oldLengthOverride, length));
 	}

@@ -731,7 +730,7 @@ public class DBTraceInstruction extends AbstractDBTraceCodeUnit<DBTraceInstructi
 		}
 		update(FLAGS_COLUMN);
 		space.trace.setChanged(
-			new TraceChangeRecord<>(TraceInstructionChangeType.FALL_THROUGH_OVERRIDE_CHANGED, space,
+			new TraceChangeRecord<>(TraceEvents.INSTRUCTION_FALL_THROUGH_OVERRIDE_CHANGED, space,
 				this, !overridden, overridden));
 	}

--- a/Show More
+++ b/Show More